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 ↗

(On Diff #372954)

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 ↗

(On Diff #372954)

[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 ↗

(On Diff #372954)

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

83–89 ↗

(On Diff #372954)

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

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

100 ↗

(On Diff #372954)

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 ↗

(On Diff #372954)

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

11 ↗

(On Diff #372954)

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 ↗

(On Diff #372954)

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

19 ↗

(On Diff #372954)

[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 ↗

(On Diff #372954)

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

26

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

22

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

12

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).

16

-fopen?

58–74

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/examples/CMakeLists.txt

 if(NOT FLANG_BUILD_EXAMPLES)
   set(EXCLUDE_FROM_ALL ON)
 endif()
 
 # This test is not run by default as it requires input.
 add_executable(external-hello-world
   external-hello.cpp
 )
 
 target_link_libraries(external-hello-world
   FortranRuntime
 )
 
 add_subdirectory(PrintFlangFunctionNames)
+add_subdirectory(flang-omp-report-plugin)

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

+add_llvm_library(
+  flangOmpReport
+  MODULE
+  flang-omp-report.cpp
+  flang-omp-report-visitor.cpp
+)

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

+//===-- examples/flang-omp-report-plugin/flang-omp-report-visitor.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_FLANG_OMP_REPORT_VISITOR_H
+#define FORTRAN_FLANG_OMP_REPORT_VISITOR_H
+
+#include "flang/Parser/parse-tree-visitor.h"
+#include "flang/Parser/parse-tree.h"
+#include "flang/Parser/parsing.h"
+
+#include <deque>
+#include <map>
+#include <string>
+#include <vector>
+
+namespace Fortran {
+namespace parser {
+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)} {}
+};
+bool operator<(const ClauseInfo &a, const ClauseInfo &b);
+bool operator==(const ClauseInfo &a, const ClauseInfo &b);
+bool operator!=(const ClauseInfo &a, const ClauseInfo &b);
+
+struct LogRecord {
+  std::string file;
+  int line;
+  std::string construct;
+  std::vector<ClauseInfo> clauses;
+};
+bool operator==(const LogRecord &a, const LogRecord &b);
+bool operator!=(const LogRecord &a, const LogRecord &b);
+
+using OmpWrapperType =
+    std::variant<const OpenMPConstruct *, const OpenMPDeclarativeConstruct *>;
+
+struct OpenMPCounterVisitor {
+  std::string normalize_construct_name(std::string s);
+  ClauseInfo normalize_clause_name(const std::string &s);
+  SourcePosition getLocation(const OmpWrapperType &w);
+  SourcePosition getLocation(const OpenMPDeclarativeConstruct &c);
+  SourcePosition getLocation(const OpenMPConstruct &c);
+
+  std::string getName(const OmpWrapperType &w);
+  std::string getName(const OpenMPDeclarativeConstruct &c);
+  std::string getName(const OpenMPConstruct &c);
+
+  template <typename A> bool Pre(const A &) { return true; }
+  template <typename A> void Post(const A &) {}
+  bool Pre(const OpenMPDeclarativeConstruct &c);
+  bool Pre(const OpenMPConstruct &c);
+  bool Pre(const OmpEndLoopDirective &c);
+  bool Pre(const DoConstruct &);
+
+  void Post(const OpenMPDeclarativeConstruct &);
+  void Post(const OpenMPConstruct &);
+  void PostConstructsCommon();
+  void Post(const OmpEndLoopDirective &c);
+
+  void Post(const OmpProcBindClause::Type &c);
+  void Post(const OmpDefaultClause::Type &c);
+  void Post(const OmpDefaultmapClause::ImplicitBehavior &c);
+  void Post(const OmpDefaultmapClause::VariableCategory &c);
+  void Post(const OmpScheduleModifierType::ModType &c);
+  void Post(const OmpLinearModifier::Type &c);
+  void Post(const OmpDependenceType::Type &c);
+  void Post(const OmpMapType::Type &c);
+  void Post(const OmpScheduleClause::ScheduleType &c);
+  void Post(const OmpIfClause::DirectiveNameModifier &c);
+  void Post(const OmpCancelType::Type &c);
+  void Post(const OmpClause &c);
+  void PostClauseCommon(const ClauseInfo &ci);
+  void Post(const DoConstruct &);
+
+  std::string clauseDetails{""};
+  std::map<std::pair<std::string, std::string>, int> constructClauseCount;
+
+  // 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.
+  std::deque<LogRecord> constructClauses;
+
+  LogRecord *curLoopLogRecord{nullptr};
+  std::vector<LogRecord *> loopLogRecordStack;
+  std::vector<OmpWrapperType *> ompWrapperStack;
+  std::map<OmpWrapperType *, std::vector<ClauseInfo>> clauseStrings;
+  Parsing *parsing{nullptr};
+};
+} // namespace parser
+} // namespace Fortran
+
+#endif /* FORTRAN_FLANG_OMP_REPORT_VISITOR_H */

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

+//===-- examples/flang-omp-report-plugin/flang-omp-report-visitor.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-omp-report-visitor.h"
+
+namespace Fortran {
+namespace parser {
+bool operator<(const ClauseInfo &a, const ClauseInfo &b) {
+  return a.clause < b.clause;
+}
+bool operator==(const ClauseInfo &a, const ClauseInfo &b) {
+  return a.clause == b.clause && a.clauseDetails == b.clauseDetails;
+}
+bool operator!=(const ClauseInfo &a, const ClauseInfo &b) { return !(a == b); }
+
+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;
+}
+bool operator!=(const LogRecord &a, const LogRecord &b) { return !(a == b); }
+
+std::string OpenMPCounterVisitor::normalize_construct_name(std::string s) {
+  std::transform(s.begin(), s.end(), s.begin(),
+      [](unsigned char c) { return std::tolower(c); });
+  return s;
+}
+ClauseInfo OpenMPCounterVisitor::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 OpenMPCounterVisitor::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 OpenMPCounterVisitor::getLocation(
+    const OpenMPDeclarativeConstruct &c) {
+  return std::visit(
+      [&](const auto &o) -> SourcePosition {
+        return parsing->allCooked().GetSourcePositionRange(o.source)->first;
+      },
+      c.u);
+}
+SourcePosition OpenMPCounterVisitor::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 OpenMPCounterVisitor::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 OpenMPCounterVisitor::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 OpenMPCounterVisitor::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);
+}
+
+bool OpenMPCounterVisitor::Pre(const OpenMPDeclarativeConstruct &c) {
+  OmpWrapperType *ow{new OmpWrapperType(&c)};
+  ompWrapperStack.push_back(ow);
+  return true;
+}
+bool OpenMPCounterVisitor::Pre(const OpenMPConstruct &c) {
+  OmpWrapperType *ow{new OmpWrapperType(&c)};
+  ompWrapperStack.push_back(ow);
+  return true;
+}
+bool OpenMPCounterVisitor::Pre(const OmpEndLoopDirective &c) { return true; }
+bool OpenMPCounterVisitor::Pre(const DoConstruct &) {
+  loopLogRecordStack.push_back(curLoopLogRecord);
+  return true;
+}
+
+void OpenMPCounterVisitor::Post(const OpenMPDeclarativeConstruct &) {
+  PostConstructsCommon();
+}
+void OpenMPCounterVisitor::Post(const OpenMPConstruct &) {
+  PostConstructsCommon();
+}
+void OpenMPCounterVisitor::PostConstructsCommon() {
+  OmpWrapperType *curConstruct = ompWrapperStack.back();
+  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 OpenMPCounterVisitor::Post(const OmpEndLoopDirective &c) {}
+
+void OpenMPCounterVisitor::Post(const OmpProcBindClause::Type &c) {
+  clauseDetails += "type=" + OmpProcBindClause::EnumToString(c) + ";";
+}
+void OpenMPCounterVisitor::Post(const OmpDefaultClause::Type &c) {
+  clauseDetails += "type=" + OmpDefaultClause::EnumToString(c) + ";";
+}
+void OpenMPCounterVisitor::Post(
+    const OmpDefaultmapClause::ImplicitBehavior &c) {
+  clauseDetails +=
+      "implicit_behavior=" + OmpDefaultmapClause::EnumToString(c) + ";";
+}
+void OpenMPCounterVisitor::Post(
+    const OmpDefaultmapClause::VariableCategory &c) {
+  clauseDetails +=
+      "variable_category=" + OmpDefaultmapClause::EnumToString(c) + ";";
+}
+void OpenMPCounterVisitor::Post(const OmpScheduleModifierType::ModType &c) {
+  clauseDetails += "modifier=" + OmpScheduleModifierType::EnumToString(c) + ";";
+}
+void OpenMPCounterVisitor::Post(const OmpLinearModifier::Type &c) {
+  clauseDetails += "modifier=" + OmpLinearModifier::EnumToString(c) + ";";
+}
+void OpenMPCounterVisitor::Post(const OmpDependenceType::Type &c) {
+  clauseDetails += "type=" + OmpDependenceType::EnumToString(c) + ";";
+}
+void OpenMPCounterVisitor::Post(const OmpMapType::Type &c) {
+  clauseDetails += "type=" + OmpMapType::EnumToString(c) + ";";
+}
+void OpenMPCounterVisitor::Post(const OmpScheduleClause::ScheduleType &c) {
+  clauseDetails += "type=" + OmpScheduleClause::EnumToString(c) + ";";
+}
+void OpenMPCounterVisitor::Post(const OmpIfClause::DirectiveNameModifier &c) {
+  clauseDetails += "name_modifier=" + OmpIfClause::EnumToString(c) + ";";
+}
+void OpenMPCounterVisitor::Post(const OmpCancelType::Type &c) {
+  clauseDetails += "type=" + OmpCancelType::EnumToString(c) + ";";
+}
+void OpenMPCounterVisitor::Post(const OmpClause &c) {
+  PostClauseCommon(normalize_clause_name(c.source.ToString()));
+  clauseDetails.clear();
+}
+void OpenMPCounterVisitor::PostClauseCommon(const ClauseInfo &ci) {
+  // 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") {
+    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 OpenMPCounterVisitor::Post(const DoConstruct &) {
+  curLoopLogRecord = loopLogRecordStack.back();
+  loopLogRecordStack.pop_back();
+}
+} // namespace parser
+} // namespace Fortran

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

+//===-- examples/flang-omp-report-plugin/flang-omp-report.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
+//
+//===----------------------------------------------------------------------===//
+// This plugin parses a Fortran source file and generates a YAML
+// report with all the OpenMP constructs and clauses and which
+// line they're located on.
+//
+// The plugin may be invoked as:
+// ./bin/flang-new -fc1 -load lib/flangOmpReport.so -plugin
+// flang-omp-report -fopenmp -o - <source_file.f90>
+//
+//===----------------------------------------------------------------------===//
+
+#include "flang-omp-report-visitor.h"
+
+#include "flang/Frontend/CompilerInstance.h"
+#include "flang/Frontend/FrontendActions.h"
+#include "flang/Frontend/FrontendPluginRegistry.h"
+#include "flang/Parser/dump-parse-tree.h"
+#include "llvm/Support/YAMLParser.h"
+#include "llvm/Support/YAMLTraits.h"
+
+using namespace Fortran::frontend;
+using namespace Fortran::parser;
+
+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<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
+
+class FlangOmpReport : public PluginParseTreeAction {
+  void ExecuteAction() override {
+    // Prepare the parse tree and the visitor
+    CompilerInstance &ci = this->instance();
+    Parsing &parsing = ci.parsing();
+    const Program &parseTree = *parsing.parseTree();
+    OpenMPCounterVisitor visitor;
+    visitor.parsing = &parsing;
+
+    // Walk the parse tree
+    Walk(parseTree, visitor);
+
+    // Dump the output
+    std::unique_ptr<llvm::raw_pwrite_stream> OS{ci.CreateDefaultOutputFile(
+        /*Binary=*/true, /*InFile=*/GetCurrentFileOrBufferName(),
+        /*Extension=*/".yaml")};
+    llvm::yaml::Output yout(*OS);
+    yout << visitor.constructClauses;
+  }
+};
+
+static FrontendPluginRegistry::Add<FlangOmpReport> X("flang-omp-report",
+    "Generate a YAML summary of OpenMP constructs and clauses");

flang/test/Examples/omp-atomic.f90

+! Check the flang-omp-report plugin for omp-atomic.f90
+
+! REQUIRES: plugins
+
+! RUN: %flang_fc1 -load %llvmshlibdir/flangOmpReport.so -plugin flang-omp-report -fopenmp %s -o - | FileCheck %s
+
+! Check OpenMP 2.13.6 atomic Construct
+
+  a = 1.0
+  !$omp parallel num_threads(4) shared(a)
+  !$omp atomic seq_cst, read
+  b = a
+
+  !$omp atomic seq_cst write
+  a = b
+  !$omp end atomic
+
+  !$omp atomic capture seq_cst
+  b = a
+  a = a + 1
+  !$omp end atomic
+
+  !$omp atomic
+  a = a + 1
+  !$omp end parallel
+end
+
+! CHECK:---
+! CHECK-NEXT:- file:            '{{[^"]*}}omp-atomic.f90'
+! CHECK-NEXT:  line:            11
+! CHECK-NEXT:  construct:       atomic-read
+! CHECK-NEXT:  clauses:
+! CHECK-NEXT:    - clause:      seq_cst
+! CHECK-NEXT:      details:     ''
+! CHECK-NEXT:- file:            '{{[^"]*}}omp-atomic.f90'
+! CHECK-NEXT:  line:            14
+! CHECK-NEXT:  construct:       atomic-write
+! CHECK-NEXT:  clauses:
+! CHECK-NEXT:    - clause:      seq_cst
+! CHECK-NEXT:      details:     ''
+! CHECK-NEXT:- file:            '{{[^"]*}}omp-atomic.f90'
+! CHECK-NEXT:  line:            18
+! CHECK-NEXT:  construct:       atomic-capture
+! CHECK-NEXT:  clauses:
+! CHECK-NEXT:    - clause:      seq_cst
+! CHECK-NEXT:      details:     ''
+! CHECK-NEXT:- file:            '{{[^"]*}}omp-atomic.f90'
+! CHECK-NEXT:  line:            23
+! CHECK-NEXT:  construct:       atomic-atomic
+! CHECK-NEXT:  clauses:         []
+! CHECK-NEXT:- file:            '{{[^"]*}}omp-atomic.f90'
+! CHECK-NEXT:  line:            10
+! CHECK-NEXT:  construct:       parallel
+! CHECK-NEXT:  clauses:
+! CHECK-NEXT:    - clause:      num_threads
+! CHECK-NEXT:      details:     '4'
+! CHECK-NEXT:    - clause:      shared
+! CHECK-NEXT:      details:     a
+! CHECK-NEXT:...

flang/test/Examples/omp-declarative-directive.f90

+! Check the flang-omp-report plugin for omp-declarative-directive.f90
+
+! REQUIRES: plugins
+
+! RUN: %flang_fc1 -load %llvmshlibdir/flangOmpReport.so -plugin flang-omp-report -fopenmp %s -o - | FileCheck %s
+
+! Check OpenMP declarative directives
+
+! 2.8.2 declare-simd
+
+subroutine declare_simd_1(a, b)
+  real(8), intent(inout) :: a, b
+  !$omp declare simd(declare_simd_1) aligned(a)
+  a = 3.14 + b
+end subroutine declare_simd_1
+
+! 2.10.6 declare-target
+! 2.15.2 threadprivate
+
+module m2
+contains
+  subroutine foo
+    !$omp declare target
+    integer, parameter :: N=10000, M=1024
+    integer :: i
+    real :: Q(N, N), R(N,M), S(M,M)
+  end subroutine foo
+end module m2
+
+end
+
+! CHECK:---
+! CHECK-NEXT:- file:            '{{[^"]*}}omp-declarative-directive.f90'
+! CHECK-NEXT:  line:            13
+! CHECK-NEXT:  construct:       declare simd
+! CHECK-NEXT:  clauses:
+! CHECK-NEXT:    - clause:      aligned
+! CHECK-NEXT:      details:     a
+! CHECK-NEXT:- file:            '{{[^"]*}}omp-declarative-directive.f90'
+! CHECK-NEXT:  line:            23
+! CHECK-NEXT:  construct:       declare target
+! CHECK-NEXT:  clauses:         []
+! CHECK-NEXT:...

flang/test/Examples/omp-device-constructs.f90

+! Check flang-omp-report --femit-yaml for omp-device-constructs.f90
+
+! REQUIRES: plugins
+
+!RUN: %flang_fc1 -load %llvmshlibdir/flangOmpReport.so -plugin flang-omp-report -fopenmp %s -o - | FileCheck %s
+
+! Check OpenMP clause validity for the following directives:
+!     2.10 Device constructs
+program main
+
+  real(8) :: arrayA(256), arrayB(256)
+  integer :: N
+
+  arrayA = 1.414
+  arrayB = 3.14
+  N = 256
+
+  !$omp target map(arrayA)
+  do i = 1, N
+     a = 3.14
+  enddo
+  !$omp end target
+
+  !$omp target device(0)
+  do i = 1, N
+     a = 3.14
+  enddo
+  !$omp end target
+
+  !$omp target defaultmap(tofrom:scalar)
+  do i = 1, N
+     a = 3.14
+  enddo
+  !$omp end target
+
+  !$omp teams num_teams(3) thread_limit(10) default(shared) private(i) shared(a)
+  do i = 1, N
+     a = 3.14
+  enddo
+  !$omp end teams
+
+  !$omp target map(tofrom:a)
+  do i = 1, N
+     a = 3.14
+  enddo
+  !$omp end target
+
+  !$omp target data device(0) map(to:a)
+  do i = 1, N
+    a = 3.14
+  enddo
+  !$omp end target data
+
+end program main
+
+! CHECK: ---
+! CHECK-NEXT: - file:            '{{[^"]*}}omp-device-constructs.f90'
+! CHECK-NEXT:   line:            18
+! CHECK-NEXT:   construct:       target
+! CHECK-NEXT:   clauses:
+! CHECK-NEXT:     - clause:          map
+! CHECK-NEXT:       details:         arraya
+! CHECK-NEXT: - file:            '{{[^"]*}}omp-device-constructs.f90'
+! CHECK-NEXT:   line:            24
+! CHECK-NEXT:   construct:       target
+! CHECK-NEXT:   clauses:
+! CHECK-NEXT:     - clause:          device
+! CHECK-NEXT:       details:         '0'
+! CHECK-NEXT: - file:            '{{[^"]*}}omp-device-constructs.f90'
+! CHECK-NEXT:   line:            30
+! CHECK-NEXT:   construct:       target
+! CHECK-NEXT:   clauses:
+! CHECK-NEXT:     - clause:          defaultmap
+! CHECK-NEXT:       details:         'tofrom:scalar'
+! CHECK-NEXT: - file:            '{{[^"]*}}omp-device-constructs.f90'
+! CHECK-NEXT:   line:            36
+! CHECK-NEXT:   construct:       teams
+! CHECK-NEXT:   clauses:
+! CHECK-NEXT:     - clause:          default
+! CHECK-NEXT:       details:         shared
+! CHECK-NEXT:     - clause:          num_teams
+! CHECK-NEXT:       details:         '3'
+! CHECK-NEXT:     - clause:          private
+! CHECK-NEXT:       details:         i
+! CHECK-NEXT:     - clause:          shared
+! CHECK-NEXT:       details:         a
+! CHECK-NEXT:     - clause:          thread_limit
+! CHECK-NEXT:       details:         '10'
+! CHECK-NEXT: - file:            '{{[^"]*}}omp-device-constructs.f90'
+! CHECK-NEXT:   line:            42
+! CHECK-NEXT:   construct:       target
+! CHECK-NEXT:   clauses:
+! CHECK-NEXT:     - clause:          map
+! CHECK-NEXT:       details:         'tofrom:a'
+! CHECK-NEXT: - file:            '{{[^"]*}}omp-device-constructs.f90'
+! CHECK-NEXT:   line:            48
+! CHECK-NEXT:   construct:       target data
+! CHECK-NEXT:   clauses:
+! CHECK-NEXT:     - clause:          device
+! CHECK-NEXT:       details:         '0'
+! CHECK-NEXT:     - clause:          map
+! CHECK-NEXT:       details:         'to:a'
+! CHECK-NEXT: ...