Flang OpenMP Report Plugin

[ijan1]

Summary

This plugin parses Fortran files and creates a
YAML report with all the OpenMP constructs and
clauses seen in the file.

The following tests have been modified to be
compatible for testing the plugin, hence why
they are not reused from another directory:

• omp-atomic.f90
• omp-declarative-directive.f90
• omp-device-constructs.f90

The plugin outputs a single file in the same
directory as the source file in the following format:
<source-file-name>.yaml

Building the plugin:
ninja flangOmpReport

Running the plugin:
./bin/flang-new -fc1 -load lib/flangOmpReport.so -plugin flang-omp-report -fopenmp <source_file.f90>

Co-authored-by: Kiran Chandramohan <[e-mail]>
Co-authored-by: Stuart Ellis <[e-mail]>

[awarzynski]

Thank you for working on this! I would like to suggest organising this a bit more strictly. Currently, it's hard to identify code that's specifically for visiting the nodes (e.g. OpenMPCounterVisitor) and what is for collecting/dumping the data (e.g. Dumper). I suggest the following files:

• flang-omp-report.cpp that implements FompReportYamlAction/FlangOmpReport together with OpenMPCounterVisitor
• flang-omp-report.h that declares FompReportYamlAction/FlangOmpReport together with OpenMPCounterVisitor
• flang-omp-report-support.cpp that defines classes and functions for processing the data (e.g. Dumper)
• flang-omp-report-support.h that declares classes and functions for processing the data (e.g. Dumper)

flang-omp-report.{cpp|h} will require flang-omp-report-support.{cpp|h} to work, but the latter should be independent of flang-omp-report.{cpp|h} . Do you think that that could work?

flang/tools/CMakeLists.txt

9

This is not a tool and hence should not be located in flang/tools. IMO, flang/examples is a better place. Note that PrintFlangFunctionNames is already there (the other plugin example inside LLVM Flang).

flang/tools/flang-omp-report-plugin/CMakeLists.txt

4

[nit] IMO, -plugin at the end of the *.cpp filename can be skipped (i.e. rename the actual file)

flang/tools/flang-omp-report-plugin/count-openmp.cpp

82

This is a very generic name. Could it be a bit more specific?

83–89

Please use CreateDefaultOutputFile instead. Btw, it takes care of the diagnostics for you.

flang/tools/flang-omp-report-plugin/count-openmp.h

100

This is a very large class and it would be helpful to have it declared in one file and defined in another. Otherwise it's hard to see what the actual interface is.

flang/tools/flang-omp-report-plugin/flang-omp-report-plugin.cpp

1

Missing LLVM header: https://llvm.org/docs/CodingStandards.html#file-headers

11

I suggest simply FlangOmpReport. IMO that will more accurately reflect what this is, i.e.

• we know that it's an Action based on what this class inherits from
• the fact that it generates YAML is an implementation detail that does not have to be included in the name as there is no e.g. FompReportTxtAction

13–14

[nit] Both OpenMPStatisticsParseTree and SummarizeResults are rather straightforward and I would be temped to inline them here.

19

[nit] It's not a tool, it's a plugin.

[ijan1]

Thanks for the feedback! I am still working on some of the things you've pointed out, however I have managed to add tests.
Unfortunately, since the plugin outputs a file with the same name every time, this causes some of the tests to fail because they're ran in parallel.
I will have a patch which adds the source file's name to the one generated by the plugin so that there\' a unique file each time.

[awarzynski]

In D109890#3011824, @ijan1 wrote:

I will have a patch which adds the source file's name to the one generated by the plugin so that there\' a unique file each time.

You should get that for free by switching to CreateDefaultOutputFile for file generation.

[kiranchandramohan]

Thanks @ijan1 for this plugin.

A few comments mostly relating to code not required due to either,

1. We only emit the log report and not the others (construct/clause summary, total constructs seen)
2. Only yaml is emitted (not text report)
3. We run plugin after semantics so no need for hacks to work after parsing.

flang/examples/flang-omp-report-plugin/flang-omp-report-support.cpp

367 ↗

(On Diff #373837)

Since we don't have a text report, I think this operator overload can be removed.

434 ↗

(On Diff #373837)

Remove the Mapping Traits for SummaryRecord, ClauseSummary and ConstructSummary above. I think it is not required.

flang/examples/flang-omp-report-plugin/flang-omp-report-support.h

2 ↗

(On Diff #373837)

Address the clang-tidy warning.

33 ↗

(On Diff #373837)

I think this can be removed since we don't dump anything other than logs.

43 ↗

(On Diff #373837)

I think this can be removed since we don't dump anything other than logs.

53 ↗

(On Diff #373837)

I think this can be removed since we don't dump anything other than logs.

138 ↗

(On Diff #373837)

This is probably not required, if we are not emitting the number of constructs and clauses?

140–142 ↗

(On Diff #373837)

Are these three maps (ompConstructCounter, ompClauseCounter, constructClauseCount) required if the information collected by these is not emitted?

150–151 ↗

(On Diff #373837)

These two (curLoopLogRecord, loopLogRecordStack) were required to maintain which loop we are currently processing. This was required since the standalone tool was operating before semantic checks (which corrects some loop information). Since the plugin tool runs after semantics, it might not be required now. Please check.

154 ↗

(On Diff #373837)

I think this can also be removed.

[ijan1]

Thanks for the feedback. Updated accordingly.

[ijan1]

flang/examples/flang-omp-report-plugin/flang-omp-report-support.h

140–142 ↗

(On Diff #373837)

constructClauseCount is required. I've removed the others.

150–151 ↗

(On Diff #373837)

Removing curLoopLogRecord leaves the "clauses" part in the yaml file empty. loopLogRecordStack was not needed and removed.

flang/tools/flang-omp-report-plugin/count-openmp.cpp

82

Removed.

[awarzynski]

Thanks for the updates @ijan1 ! This already looks great, but I have a few more suggestions to make it a bit leaner and concise. And to clarify a few things. For example - shouldn't this plugin use LLVM's ADT instead of STL? @kiranchandramohan
, what are your thoughts?

A few more suggestions:

1. I don't see much point of having flang/test/Examples/Inputs/ (i.e. the directory). For example, flang/test/Examples/omp-atomic.f90 and flang/test/Examples/Inputs/omp-atomic.f90 can be merged. Same for other tests like this.
2. Files from flang/test/Examples/Inputs/ seem to be copied from flang/test/Semantics. If we are not going to re-use them, then it would be good explain that in the commit message (e.g. Files x, y, z were copied from flang/test/Semantics. We decided not to share them because abc.
3. IMHO, there's no need for flang-omp-report.h. Everything from there can be moved to flang-omp-report.cpp. Fewer files will make this easier to read/follow.
4. I really like how you made flang-omp-report-support.{cpp|h} implement just one thing - the visitor that's used inside FlangOmpReport. That makes so much sense! I would suggest renaming the files accordingly (e.g. flang-omp-report-visitor.{cpp|h})

Thanks for all the effort :)

flang/examples/flang-omp-report-plugin/flang-omp-report-support.cpp

253 ↗

(On Diff #374183)

This function is not needed. Please move this code inside FlangOmpReport::ExecuteAction. That's the only place where it's used.

flang/examples/flang-omp-report-plugin/flang-omp-report-support.h

30 ↗

(On Diff #374183)

Hm, everything is public here. Do we need friend? Some in other places.

98–103 ↗

(On Diff #374183)

Please reformat the comment so that it's above the declaration that it documents.

111 ↗

(On Diff #374183)

Can be deleted once the contents of this function is inlined inside ExecuteAction.

2 ↗

(On Diff #373837)

There are still some clang-tidy warnings left. Please fix.

flang/examples/flang-omp-report-plugin/flang-omp-report.cpp

25 ↗

(On Diff #374183)

Note that this will only work on Linux. We should avoid solutions that work only on a particular platform. Instead, you could use e.g. filename or other utilities from llvm::sys::path.

Also, you are overriding the default behavior of the compiler here, which can be counter intuitive. For example, what should happen here:

flang -fc1 -load flangOmpReport.so -plugin flang-omp-report -fopenmp omp-device-constructs.f90 -o <some_dir/another_dir>/output_file_name.yaml

? Where should output_file_name.yaml be saved? Either way, it would be helpful to have this behavior documented somewhere. For example at the top of this file.

flang/examples/flang-omp-report-plugin/flang-omp-report.h

1 ↗

(On Diff #374183)

Please fix clang-tidy checks.

[awarzynski]

Apologies, I forgot to mention this one before.

In FlangOmpReport::ExecuteAction, you do some filename manipulation in order to prevent the plugin from generating output files next to the input. You can avoid that and leverage the "existing" mechanism, e.g.:

• flang-new -o <output-filename> <input-filename> will use <output-filename> as the location and name of the output file

In particular,flang-new -o - <intput-filename> will print to stdout. If you use this, then all you have to do is write your RUN lines in tests like this:

! RUNL %flang_fc1 -load %llvmshlibdir/flangOmpReport.so -plugin flang-omp-report -fopenmp %S/Inputs/omp-declarative-directive.f90 -o - | FileCheck %s

So, less code in tests and in ExecuteAction :)

[ijan1]

Thanks a lot for the feedback! I've changed accordingly to use -o now. Hopefully I got the header guards right this time.

[ijan1]

flang/examples/flang-omp-report-plugin/flang-omp-report-support.h

30 ↗

(On Diff #374183)

To my understanding, friend is used because class methods take an implicit this parameter. So, when you're overloading operator methods, there's 3 parameters being passed, which is illegal. I've moved the definitions out of the class.

[awarzynski]

From your summary:

The plugin outputs a single file in the following format: summary-<source-file>.yaml

This is no longer accurate. Similarly here:

Running the plugin:
./bin/flang-new -fc1 -load lib/flangOmpReport.so -plugin fomp-report-yaml -fopenmp <source_file.f90>

The plugin name is flang-omp-report.

In order to fix the clang-tidy check, try updating the header guard to: FORTRAN_FLANG_OMP_REPORT_VISITOR_H

flang/examples/flang-omp-report-plugin/flang-omp-report-visitor.h

21 ↗

(On Diff #374488)

We should avoid using using namespace <namespace> in header files. Otherwise, all files that include this file will have their local namespaces polluted with Fortran::parser. That might be undesired.

flang/examples/flang-omp-report-plugin/flang-omp-report.cpp

11 ↗

(On Diff #374488)

This will depend on how the plugin is invoked. For example,

./bin/flang-new -fc1 -load lib/flangOmpReport.so -plugin fomp-report-yaml -o - <source_file.f90>

prints to stdout. I suggest deleting this sentence and using ^^^ for your example (so that people see the output immediately when they run the plugin for the first time).

15 ↗

(On Diff #374488)

-fopen?

57–73 ↗

(On Diff #374488)

Small suggestion as how to split this into "functional" blocks.

[kiranchandramohan]

LGTM.
Please wait for @awarzynski's approval.

[ijan1]

Thanks a lot for the feedback, it's easy to miss such silly mistakes.

[awarzynski]

Great work, thank you @ijan1 for addressing my comments! LGTM

Many thanks to @stuartellis for preparing the first draft of this patch "downstream" and to @kiranchandramohan for designing and implementing the tool in the first place.

(Btw, we didn't really decided whether to switch to LLVM ADT. We can do it in a separate patch._

[awarzynski]

Some buildbots are unhappy with the tests added in this patch. Uploaded fix here: https://reviews.llvm.org/D110682

flang/tools/CMakeLists.txt

 #===-- 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(flang-omp-report-plugin)
 add_subdirectory(f18)
 add_subdirectory(flang-driver)
 add_subdirectory(tco)
 add_subdirectory(f18-parse-demo)
 add_subdirectory(fir-opt)
 add_subdirectory(flang-omp-report)

flang/tools/flang-omp-report-plugin/CMakeLists.txt

+add_llvm_library(
+  flangOmpReport
+  MODULE
+  flang-omp-report-plugin.cpp
+  count-openmp.cpp
+)

flang/tools/flang-omp-report-plugin/count-openmp.h

+//===-- tools/flang-omp-report-plugin/count-openmp.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
+//
+//===----------------------------------------------------------------------===//
+
+#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/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/source.h"
+#include "flang/Parser/unparse.h"
+#include "flang/Semantics/expression.h"
+#include "flang/Semantics/semantics.h"
+
+#include <algorithm>
+#include <deque>
+#include <functional>
+#include <map>
+#include <stdlib.h>
+#include <string>
+#include <type_traits>
+#include <vector>
+
+using namespace Fortran::parser;
+struct SummaryRecord {
+  int numConstructs;
+  int numClauses;
+  friend bool operator==(const SummaryRecord &a, const SummaryRecord &b) {
+    return a.numConstructs == b.numConstructs && a.numClauses == b.numClauses;
+  }
+  friend bool operator!=(const SummaryRecord &a, const SummaryRecord &b) {
+    return !(a == b);
+  }
+};
+struct ClauseSummary {
+  std::string clause;
+  int numClauses;
+  friend bool operator==(const ClauseSummary &a, const ClauseSummary &b) {
+    return a.clause == b.clause && a.numClauses == b.numClauses;
+  }
+  friend bool operator!=(const ClauseSummary &a, const ClauseSummary &b) {
+    return !(a == b);
+  }
+};
+struct ConstructSummary {
+  std::string construct;
+  int numConstructs;
+  std::vector<ClauseSummary> clauses;
+  friend bool operator==(const ConstructSummary &a, const ConstructSummary &b) {
+    return a.construct == b.construct && a.numConstructs == b.numConstructs &&
+        a.clauses == b.clauses;
+  }
+  friend bool operator!=(const ConstructSummary &a, const ConstructSummary &b) {
+    return !(a == b);
+  }
+};
+struct ClauseInfo {
+  std::string clause;
+  std::string clauseDetails;
+  ClauseInfo() {}
+  ClauseInfo(const std::string &c, const std::string &cd)
+      : clause{c}, clauseDetails{cd} {}
+  ClauseInfo(const std::pair<std::string, std::string> &p)
+      : clause{std::get<0>(p)}, clauseDetails{std::get<1>(p)} {}
+  friend bool operator<(const ClauseInfo &a, const ClauseInfo &b) {
+    return a.clause < b.clause;
+  }
+  friend bool operator==(const ClauseInfo &a, const ClauseInfo &b) {
+    return a.clause == b.clause && a.clauseDetails == b.clauseDetails;
+  }
+  friend bool operator!=(const ClauseInfo &a, const ClauseInfo &b) {
+    return !(a == b);
+  }
+};
+struct LogRecord {
+  std::string file;
+  int line;
+  std::string construct;
+  std::vector<ClauseInfo> clauses;
+  friend bool operator==(const LogRecord &a, const LogRecord &b) {
+    return a.file == b.file && a.line == b.line && a.construct == b.construct &&
+        a.clauses == b.clauses;
+  }
+  friend bool operator!=(const LogRecord &a, const LogRecord &b) {
+    return !(a == b);
+  }
+};
+
+using OmpWrapperType =
+    std::variant<const OpenMPConstruct *, const OpenMPDeclarativeConstruct *>;
+
+struct OpenMPCounterVisitor {
+  std::string normalize_construct_name(std::string s) {
+    std::transform(s.begin(), s.end(), s.begin(),
+        [](unsigned char c) { return std::tolower(c); });
+    return s;
+  }
+  ClauseInfo normalize_clause_name(const std::string &s) {
+    std::size_t start = s.find('(');
+    std::size_t end = s.find(')');
+    std::string clauseName;
+    if (start != std::string::npos && end != std::string::npos) {
+      clauseName = s.substr(0, start);
+      clauseDetails = s.substr(start + 1, end - start - 1);
+    } else {
+      clauseName = s;
+    }
+    std::transform(clauseName.begin(), clauseName.end(), clauseName.begin(),
+        [](unsigned char c) { return std::tolower(c); });
+    std::transform(clauseDetails.begin(), clauseDetails.end(),
+        clauseDetails.begin(), [](unsigned char c) { return std::tolower(c); });
+    return ClauseInfo{clauseName, clauseDetails};
+  }
+  SourcePosition getLocation(const OmpWrapperType &w) {
+    if (auto *val = std::get_if<const OpenMPConstruct *>(&w)) {
+      const OpenMPConstruct *o{*val};
+      return getLocation(*o);
+    }
+    return getLocation(*std::get<const OpenMPDeclarativeConstruct *>(w));
+  }
+  SourcePosition getLocation(const OpenMPDeclarativeConstruct &c) {
+    return std::visit(
+        [&](const auto &o) -> SourcePosition {
+          return parsing->allCooked().GetSourcePositionRange(o.source)->first;
+        },
+        c.u);
+  }
+  SourcePosition getLocation(const OpenMPConstruct &c) {
+    return std::visit(
+        Fortran::common::visitors{
+            [&](const OpenMPStandaloneConstruct &c) -> SourcePosition {
+              return parsing->allCooked()
+                  .GetSourcePositionRange(c.source)
+                  ->first;
+            },
+            // OpenMPSectionsConstruct, OpenMPLoopConstruct,
+            // OpenMPBlockConstruct, OpenMPCriticalConstruct Get the source from
+            // the directive field.
+            [&](const auto &c) -> SourcePosition {
+              const CharBlock &source{std::get<0>(c.t).source};
+              return (parsing->allCooked().GetSourcePositionRange(source))
+                  ->first;
+            },
+            [&](const OpenMPAtomicConstruct &c) -> SourcePosition {
+              return std::visit(
+                  [&](const auto &o) -> SourcePosition {
+                    const CharBlock &source{std::get<Verbatim>(o.t).source};
+                    return parsing->allCooked()
+                        .GetSourcePositionRange(source)
+                        ->first;
+                  },
+                  c.u);
+            },
+        },
+        c.u);
+  }
+
+  std::string getName(const OmpWrapperType &w) {
+    if (auto *val = std::get_if<const OpenMPConstruct *>(&w)) {
+      const OpenMPConstruct *o{*val};
+      return getName(*o);
+    }
+    return getName(*std::get<const OpenMPDeclarativeConstruct *>(w));
+  }
+  std::string getName(const OpenMPDeclarativeConstruct &c) {
+    return std::visit(
+        [&](const auto &o) -> std::string {
+          const CharBlock &source{std::get<Verbatim>(o.t).source};
+          return normalize_construct_name(source.ToString());
+        },
+        c.u);
+  }
+  std::string getName(const OpenMPConstruct &c) {
+    return std::visit(
+        Fortran::common::visitors{
+            [&](const OpenMPStandaloneConstruct &c) -> std::string {
+              return std::visit(
+                  [&](const auto &c) {
+                    // Get source from the directive or verbatim fields
+                    const CharBlock &source{std::get<0>(c.t).source};
+                    return normalize_construct_name(source.ToString());
+                  },
+                  c.u);
+            },
+            [&](const OpenMPExecutableAllocate &c) -> std::string {
+              const CharBlock &source{std::get<0>(c.t).source};
+              return normalize_construct_name(source.ToString());
+            },
+            [&](const OpenMPDeclarativeAllocate &c) -> std::string {
+              const CharBlock &source{std::get<0>(c.t).source};
+              return normalize_construct_name(source.ToString());
+            },
+            [&](const OpenMPAtomicConstruct &c) -> std::string {
+              return std::visit(
+                  [&](const auto &c) {
+                    // Get source from the verbatim fields
+                    const CharBlock &source{std::get<Verbatim>(c.t).source};
+                    return "atomic-" +
+                        normalize_construct_name(source.ToString());
+                  },
+                  c.u);
+            },
+            // OpenMPSectionsConstruct, OpenMPLoopConstruct,
+            // OpenMPBlockConstruct, OpenMPCriticalConstruct Get the source from
+            // the directive field of the begin directive or from the verbatim
+            // field of the begin directive in Critical
+            [&](const auto &c) -> std::string {
+              const CharBlock &source{std::get<0>(std::get<0>(c.t).t).source};
+              return normalize_construct_name(source.ToString());
+            },
+        },
+        c.u);
+  }
+
+  template <typename A> bool Pre(const A &) { return true; }
+  template <typename A> void Post(const A &) {}
+  bool Pre(const OpenMPDeclarativeConstruct &c) {
+    OmpWrapperType *ow{new OmpWrapperType(&c)};
+    ompWrapperStack.push_back(ow);
+    return true;
+  }
+  bool Pre(const OpenMPConstruct &c) {
+    OmpWrapperType *ow{new OmpWrapperType(&c)};
+    ompWrapperStack.push_back(ow);
+    return true;
+  }
+  bool Pre(const OmpEndLoopDirective &c) {
+    isEndLoopDirective = true;
+    return true;
+  }
+  bool Pre(const DoConstruct &) {
+    loopLogRecordStack.push_back(curLoopLogRecord);
+    return true;
+  }
+
+  void Post(const OpenMPDeclarativeConstruct &) { PostConstructsCommon(); }
+  void Post(const OpenMPConstruct &) { PostConstructsCommon(); }
+  void PostConstructsCommon() {
+    ++constructCounter;
+    OmpWrapperType *curConstruct = ompWrapperStack.back();
+    ompConstructCounter[normalize_construct_name(getName(*curConstruct))]++;
+    std::sort(
+        clauseStrings[curConstruct].begin(), clauseStrings[curConstruct].end());
+
+    SourcePosition s{getLocation(*curConstruct)};
+    LogRecord r{s.file.path(), s.line, getName(*curConstruct),
+        clauseStrings[curConstruct]};
+    constructClauses.push_back(r);
+
+    // Keep track of loop log records if it can potentially have the
+    // nowait clause added on later.
+    if (const auto *oc = std::get_if<const OpenMPConstruct *>(curConstruct)) {
+      if (const auto *olc = std::get_if<OpenMPLoopConstruct>(&(*oc)->u)) {
+        const auto &beginLoopDir{
+            std::get<Fortran::parser::OmpBeginLoopDirective>(olc->t)};
+        const auto &beginDir{
+            std::get<Fortran::parser::OmpLoopDirective>(beginLoopDir.t)};
+        if (beginDir.v == llvm::omp::Directive::OMPD_do ||
+            beginDir.v == llvm::omp::Directive::OMPD_do_simd) {
+          curLoopLogRecord = &constructClauses.back();
+        }
+      }
+    }
+
+    auto it = clauseStrings.find(curConstruct);
+    clauseStrings.erase(it);
+    ompWrapperStack.pop_back();
+    delete curConstruct;
+  }
+  void Post(const OmpEndLoopDirective &c) { isEndLoopDirective = false; }
+
+  void Post(const OmpProcBindClause::Type &c) {
+    clauseDetails += "type=" + OmpProcBindClause::EnumToString(c) + ";";
+  }
+  void Post(const OmpDefaultClause::Type &c) {
+    clauseDetails += "type=" + OmpDefaultClause::EnumToString(c) + ";";
+  }
+  void Post(const OmpDefaultmapClause::ImplicitBehavior &c) {
+    clauseDetails +=
+        "implicit_behavior=" + OmpDefaultmapClause::EnumToString(c) + ";";
+  }
+  void Post(const OmpDefaultmapClause::VariableCategory &c) {
+    clauseDetails +=
+        "variable_category=" + OmpDefaultmapClause::EnumToString(c) + ";";
+  }
+  void Post(const OmpScheduleModifierType::ModType &c) {
+    clauseDetails +=
+        "modifier=" + OmpScheduleModifierType::EnumToString(c) + ";";
+  }
+  void Post(const OmpLinearModifier::Type &c) {
+    clauseDetails += "modifier=" + OmpLinearModifier::EnumToString(c) + ";";
+  }
+  void Post(const OmpDependenceType::Type &c) {
+    clauseDetails += "type=" + OmpDependenceType::EnumToString(c) + ";";
+  }
+  void Post(const OmpMapType::Type &c) {
+    clauseDetails += "type=" + OmpMapType::EnumToString(c) + ";";
+  }
+  void Post(const OmpScheduleClause::ScheduleType &c) {
+    clauseDetails += "type=" + OmpScheduleClause::EnumToString(c) + ";";
+  }
+  void Post(const OmpIfClause::DirectiveNameModifier &c) {
+    clauseDetails += "name_modifier=" + OmpIfClause::EnumToString(c) + ";";
+  }
+  void Post(const OmpCancelType::Type &c) {
+    clauseDetails += "type=" + OmpCancelType::EnumToString(c) + ";";
+  }
+  void Post(const OmpClause &c) {
+    PostClauseCommon(normalize_clause_name(c.source.ToString()));
+    clauseDetails.clear();
+  }
+  void PostClauseCommon(const ClauseInfo &ci) {
+    ++clauseCounter;
+    ompClauseCounter[ci.clause]++;
+    // The end loop construct (!$omp end do) can contain a nowait clause.
+    // The flang parser does not parse the end loop construct as part of
+    // the OpenMP construct for the loop construct. So the end loop is left
+    // hanging as a separate executable construct. If a nowait clause is seen in
+    // an end loop construct we have to find the associated loop construct and
+    // add nowait to its list of clauses. Note: This is not a bug in flang, the
+    // parse tree is corrected during semantic analysis.
+    if (ci.clause == "nowait" && isEndLoopDirective) {
+      assert(curLoopLogRecord &&
+          "loop Construct should be visited before a nowait clause");
+      constructClauseCount[std::make_pair(
+          curLoopLogRecord->construct, ci.clause)]++;
+      curLoopLogRecord->clauses.push_back(ci);
+    } else {
+      assert(!ompWrapperStack.empty() &&
+          "Construct should be visited before clause");
+      constructClauseCount[std::make_pair(
+          getName(*ompWrapperStack.back()), ci.clause)]++;
+      clauseStrings[ompWrapperStack.back()].push_back(ci);
+    }
+  }
+  void Post(const DoConstruct &) {
+    curLoopLogRecord = loopLogRecordStack.back();
+    loopLogRecordStack.pop_back();
+  }
+
+  int clauseCounter{0}, constructCounter{0};
+  std::string clauseDetails{""};
+  std::map<std::string, int> ompConstructCounter;
+  std::map<std::string, int> ompClauseCounter;
+  std::map<std::pair<std::string, std::string>, int> constructClauseCount;
+  std::deque<LogRecord>
+      constructClauses; // curLoopLogRecord and loopLogRecordStack store
+                        // pointers to this datastructure's entries. Hence a
+                        // vector cannot be used since pointers are invalidated
+                        // on resize. Next best option seems to be deque. Also a
+                        // list cannot be used since YAML gen requires a
+                        // datastructure which can be accessed through indices.
+  LogRecord *curLoopLogRecord{nullptr};
+  std::vector<LogRecord *> loopLogRecordStack;
+  std::vector<OmpWrapperType *> ompWrapperStack;
+  std::map<OmpWrapperType *, std::vector<ClauseInfo>> clauseStrings;
+  bool isEndLoopDirective{false};
+  Parsing *parsing{nullptr};
+};
+
+void OpenMPStatisticsParseTree(Parsing &parse);
+void SummarizeResults();

flang/tools/flang-omp-report-plugin/count-openmp.cpp

+//===-- tools/flang-omp-report-plugin/count-openmp.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 "count-openmp.h"
+
+#include "llvm/ADT/StringExtras.h"
+#include "llvm/Support/FileSystem.h"
+#include "llvm/Support/YAMLParser.h"
+#include "llvm/Support/YAMLTraits.h"
+#include "llvm/Support/raw_ostream.h"
+
+#include <fstream>
+#include <sstream>
+
+OpenMPCounterVisitor visitor;
+void OpenMPStatisticsParseTree(Fortran::parser::Parsing &parsing) {
+  visitor.parsing = &parsing;
+  const Program &parseTree{*parsing.parseTree()};
+  Fortran::parser::Walk(parseTree, visitor);
+}
+
+static void getSortedConstructSummary(
+    std::vector<ConstructSummary> &csv, OpenMPCounterVisitor &visitor) {
+  typedef std::function<bool(
+      const ConstructSummary &, const ConstructSummary &)>
+      CmpFuncP;
+  CmpFuncP cmpCS = [](const ConstructSummary &a, const ConstructSummary &b) {
+    // Sort by:
+    return (
+        // 1. Number of times constructs appear
+        (a.numConstructs > b.numConstructs) ||
+        // 2. If 1. gives equality, compare the number of clauses
+        ((a.numConstructs == b.numConstructs) &&
+            (a.clauses.size() > b.clauses.size())) ||
+        // 3. If 1. and 2. give equality, compare names (lexicographically)
+        (((a.numConstructs == b.numConstructs) &&
+            (a.clauses.size() == b.clauses.size()) &&
+            (a.construct >= b.construct))));
+  };
+
+  for (auto &p : visitor.ompConstructCounter) {
+    ConstructSummary cs;
+    cs.construct = p.first;
+    cs.numConstructs = p.second;
+    for (auto elem : visitor.constructClauseCount) {
+      if (p.first == elem.first.first) {
+        ClauseSummary c{elem.first.second, elem.second};
+        cs.clauses.emplace_back(c);
+      }
+    }
+    csv.push_back(cs);
+  }
+  std::stable_sort(csv.begin(), csv.end(), cmpCS);
+}
+
+static void getSortedClauseSummary(
+    std::vector<ClauseSummary> &csv, OpenMPCounterVisitor &visitor) {
+  typedef std::function<bool(const ClauseSummary &, const ClauseSummary &)>
+      CmpFuncCS;
+  CmpFuncCS cmpCS = [](const ClauseSummary &a, const ClauseSummary &b) {
+    // Sort by:
+    return (
+        // 1. Number of times this clause is present
+        (a.numClauses > b.numClauses) ||
+        // 2. If 1. gives equality, compare names (lexicographically)
+        ((a.numClauses == b.numClauses) && (a.clause > b.clause)));
+  };
+  for (auto &p : visitor.ompClauseCounter) {
+    ClauseSummary cs;
+    cs.clause = p.first;
+    cs.numClauses = p.second;
+    csv.push_back(cs);
+  }
+  std::stable_sort(csv.begin(), csv.end(), cmpCS);
+}
+
+class Dumper {
+  void openStream(llvm::StringRef fileName) {
+    std::error_code EC;
+    OS = new llvm::raw_fd_ostream(
+        fileName, EC, llvm::sys::fs::OpenFlags::OF_Text);
+    if (EC) {
+      llvm::errs() << "Opening file = " << fileName << "\n";
+    }
+  }
+
+  void closeStream() { delete OS; }
+
+  std::string getFileName(const std::string &fileSuffix) {
+    std::string retStr{"tmp"};
+    std::string fileExt{".yaml"};
+    return retStr + fileSuffix + fileExt;
+  }
+
+  template <typename T> void dump(llvm::StringRef fileName, T &r) {
+    openStream(fileName);
+    llvm::yaml::Output yout(*OS);
+    yout << r;
+    closeStream();
+  }
+
+  llvm::raw_ostream *OS;
+
+public:
+  void dump(SummaryRecord &sr, std::vector<ConstructSummary> &cosv,
+      std::vector<ClauseSummary> &clsv, std::deque<LogRecord> &lrv) {
+    dump(getFileName("-log"), lrv);
+  }
+};
+
+std::istream &operator>>(std::istream &is, std::deque<LogRecord> &vlr) {
+  std::string ignore_line;
+  std::getline(is, ignore_line);
+
+  LogRecord lr;
+  while (std::getline(is, lr.file, ',')) {
+    lr.clauses.clear();
+    std::string tmp;
+    std::getline(is, tmp, ',');
+    lr.line = std::stoi(tmp);
+    std::string tmp2;
+    std::getline(is, tmp2);
+    size_t commaLoc{tmp2.find(',')};
+    if (commaLoc != std::string::npos) {
+      lr.construct = tmp2.substr(0, commaLoc);
+      std::string clauses_str{
+          tmp2.substr(commaLoc + 1, tmp2.length() - commaLoc)};
+      std::istringstream iss{clauses_str};
+      std::string clause;
+      while (std::getline(iss, clause, ',')) {
+        std::string clauseDetails;
+        std::getline(iss, clauseDetails, ',');
+        if (clauseDetails.empty())
+          lr.clauses.push_back(std::make_pair(clause, clauseDetails));
+        else
+          lr.clauses.push_back(std::make_pair(
+              clause, clauseDetails.substr(1, clauseDetails.length() - 2)));
+      }
+    } else {
+      lr.construct = tmp2;
+    }
+    vlr.push_back(lr);
+  }
+  return is;
+}
+
+LLVM_YAML_IS_SEQUENCE_VECTOR(ConstructSummary)
+LLVM_YAML_IS_SEQUENCE_VECTOR(ClauseSummary)
+LLVM_YAML_IS_SEQUENCE_VECTOR(LogRecord)
+LLVM_YAML_IS_SEQUENCE_VECTOR(ClauseInfo)
+namespace llvm {
+namespace yaml {
+using llvm::yaml::IO;
+using llvm::yaml::MappingTraits;
+template <typename T>
+struct SequenceTraits<std::deque<T>,
+    std::enable_if_t<CheckIsBool<SequenceElementTraits<T>::flow>::value>>
+    : SequenceTraitsImpl<std::deque<T>, SequenceElementTraits<T>::flow> {};
+template <> struct MappingTraits<SummaryRecord> {
+  static void mapping(IO &io, SummaryRecord &info) {
+    io.mapRequired("numConstructs", info.numConstructs);
+    io.mapRequired("numClauses", info.numClauses);
+  }
+};
+template <> struct MappingTraits<ClauseSummary> {
+  static void mapping(IO &io, ClauseSummary &info) {
+    io.mapRequired("clause", info.clause);
+    io.mapRequired("numClauses", info.numClauses);
+  }
+};
+template <> struct MappingTraits<ConstructSummary> {
+  static void mapping(IO &io, ConstructSummary &info) {
+    io.mapRequired("construct", info.construct);
+    io.mapRequired("numConstructs", info.numConstructs);
+    io.mapRequired("clauses", info.clauses);
+  }
+};
+template <> struct MappingTraits<ClauseInfo> {
+  static void mapping(IO &io, ClauseInfo &info) {
+    io.mapRequired("clause", info.clause);
+    io.mapRequired("details", info.clauseDetails);
+  }
+};
+template <> struct MappingTraits<LogRecord> {
+  static void mapping(IO &io, LogRecord &info) {
+    io.mapRequired("file", info.file);
+    io.mapRequired("line", info.line);
+    io.mapRequired("construct", info.construct);
+    io.mapRequired("clauses", info.clauses);
+  }
+};
+} // namespace yaml
+} // namespace llvm
+
+void SummarizeResults() {
+  SummaryRecord sr{visitor.constructCounter, visitor.clauseCounter};
+  std::vector<ConstructSummary> cosv;
+  getSortedConstructSummary(cosv, visitor);
+  std::vector<ClauseSummary> clsv;
+  getSortedClauseSummary(clsv, visitor);
+  {
+    std::unique_ptr<Dumper> d = std::make_unique<Dumper>();
+    d->dump(sr, cosv, clsv, visitor.constructClauses);
+  }
+}

flang/tools/flang-omp-report-plugin/flang-omp-report-plugin.cpp

+#include "count-openmp.h"
+
+#include "flang/Frontend/CompilerInstance.h"
+#include "flang/Frontend/FrontendActions.h"
+#include "flang/Frontend/FrontendPluginRegistry.h"
+#include "flang/Parser/dump-parse-tree.h"
+#include "flang/Parser/parsing.h"
+
+using namespace Fortran::frontend;
+
+class FompReportYamlAction : public PluginParseTreeAction {
+  void ExecuteAction() override {
+    OpenMPStatisticsParseTree(instance().parsing());
+    SummarizeResults();
+  }
+};
+
+static FrontendPluginRegistry::Add<FompReportYamlAction> X(
+    "fomp-report-yaml", "Flang omp report tool - output YAML format");