1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
|
//===-- 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 "llvm/ADT/DenseMap.h"
#include "llvm/ADT/SmallVector.h"
#include "llvm/ADT/StringRef.h"
#include <string>
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;
llvm::SmallVector<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 llvm::StringRef 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);
void Post(const OpenMPDeclarativeConstruct &);
void Post(const OpenMPConstruct &);
void PostConstructsCommon();
void Post(const OmpProcBindClause::AffinityPolicy &c);
void Post(const OmpDefaultClause::DataSharingAttribute &c);
void Post(const OmpDefaultmapClause::ImplicitBehavior &c);
void Post(const OmpVariableCategory::Value &c);
void Post(const OmpDeviceTypeClause::DeviceTypeDescription &c);
void Post(const OmpChunkModifier::Value &c);
void Post(const OmpLinearModifier::Value &c);
void Post(const OmpOrderingModifier::Value &c);
void Post(const OmpTaskDependenceType::Value &c);
void Post(const OmpMapType::Value &c);
void Post(const OmpScheduleClause::Kind &c);
void Post(const OmpDirectiveNameModifier &c);
void Post(const OmpCancelType::Type &c);
void Post(const OmpClause &c);
void PostClauseCommon(const ClauseInfo &ci);
std::string clauseDetails;
llvm::SmallVector<LogRecord> constructClauses;
llvm::SmallVector<OmpWrapperType *> ompWrapperStack;
llvm::DenseMap<OmpWrapperType *, llvm::SmallVector<ClauseInfo>> clauseStrings;
Parsing *parsing{nullptr};
};
} // namespace parser
} // namespace Fortran
#endif /* FORTRAN_FLANG_OMP_REPORT_VISITOR_H */
|
