Skip to content

Commit bf0d3c6

Browse files
Stylie777Stylie777
committed
formatting fixes
1 parent 305a0d8 commit bf0d3c6

File tree

6 files changed

+89
-71
lines changed

6 files changed

+89
-71
lines changed

‎flang/include/flang/Parser/parse-tree.h‎

Lines changed: 3 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -5025,7 +5025,9 @@ struct OpenMPLoopConstruct {
50255025
TUPLE_CLASS_BOILERPLATE(OpenMPLoopConstruct);
50265026
OpenMPLoopConstruct(OmpBeginLoopDirective &&a)
50275027
: t({std::move(a), std::nullopt, std::nullopt}) {}
5028-
std::tuple<OmpBeginLoopDirective, std::optional<std::variant<DoConstruct, common::Indirection<OpenMPLoopConstruct>>>,
5028+
std::tuple<OmpBeginLoopDirective,
5029+
std::optional<
5030+
std::variant<DoConstruct, common::Indirection<OpenMPLoopConstruct>>>,
50295031
std::optional<OmpEndLoopDirective>>
50305032
t;
50315033
};

‎flang/lib/Lower/OpenMP/OpenMP.cpp‎

Lines changed: 4 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -4232,8 +4232,10 @@ static void genOMP(lower::AbstractConverter &converter, lower::SymMap &symTable,
42324232
converter.genLocation(beginLoopDirective.source);
42334233

42344234
auto &optLoopCons = std::get<1>(loopConstruct.t);
4235-
if(optLoopCons.has_value())
4236-
if(auto *ompNestedLoopCons{std::get_if<common::Indirection<parser::OpenMPLoopConstruct>>(&*optLoopCons)}) {
4235+
if (optLoopCons.has_value())
4236+
if (auto *ompNestedLoopCons{
4237+
std::get_if<common::Indirection<parser::OpenMPLoopConstruct>>(
4238+
&*optLoopCons)}) {
42374239
genOMP(converter, symTable, semaCtx, eval, ompNestedLoopCons->value());
42384240
}
42394241

‎flang/lib/Parser/unparse.cpp‎

Lines changed: 2 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -2926,7 +2926,8 @@ class UnparseVisitor {
29262926
Walk(std::get<OmpBeginLoopDirective>(x.t));
29272927
Put("\n");
29282928
EndOpenMP();
2929-
Walk(std::get<std::optional<std::variant<DoConstruct, common::Indirection<parser::OpenMPLoopConstruct>>>>(x.t));
2929+
Walk(std::get<std::optional<std::variant<DoConstruct,
2930+
common::Indirection<parser::OpenMPLoopConstruct>>>>(x.t));
29302931
Walk(std::get<std::optional<OmpEndLoopDirective>>(x.t));
29312932
}
29322933
void Unparse(const BasedPointer &x) {

‎flang/lib/Semantics/canonicalize-omp.cpp‎

Lines changed: 31 additions & 23 deletions
Original file line numberDiff line numberDiff line change
@@ -109,8 +109,8 @@ class CanonicalizationOfOmp {
109109

110110
void missingDoConstruct(parser::OmpLoopDirective &dir) {
111111
messages_.Say(dir.source,
112-
"A DO loop must follow the %s directive"_err_en_US,
113-
parser::ToUpperCaseLetters(dir.source.ToString()));
112+
"A DO loop must follow the %s directive"_err_en_US,
113+
parser::ToUpperCaseLetters(dir.source.ToString()));
114114
}
115115

116116
void RewriteOpenMPLoopConstruct(parser::OpenMPLoopConstruct &x,
@@ -142,7 +142,8 @@ class CanonicalizationOfOmp {
142142
if (auto *doCons{GetConstructIf<parser::DoConstruct>(*nextIt)}) {
143143
if (doCons->GetLoopControl()) {
144144
// move DoConstruct
145-
std::get<std::optional<std::variant<parser::DoConstruct, common::Indirection<parser::OpenMPLoopConstruct>>>>(x.t) =
145+
std::get<std::optional<std::variant<parser::DoConstruct,
146+
common::Indirection<parser::OpenMPLoopConstruct>>>>(x.t) =
146147
std::move(*doCons);
147148
nextIt = block.erase(nextIt);
148149
// try to match OmpEndLoopDirective
@@ -159,39 +160,46 @@ class CanonicalizationOfOmp {
159160
}
160161
} else if (auto *ompLoopCons{
161162
GetOmpIf<parser::OpenMPLoopConstruct>(*nextIt)}) {
162-
// We should allow UNROLL and TILE constructs to be inserted between an OpenMP Loop Construct and the DO loop itself
163+
// We should allow UNROLL and TILE constructs to be inserted between an
164+
// OpenMP Loop Construct and the DO loop itself
163165
auto &beginDirective =
164166
std::get<parser::OmpBeginLoopDirective>(ompLoopCons->t);
165167
auto &beginLoopDirective =
166-
std::get<parser::OmpLoopDirective>(beginDirective.t);
168+
std::get<parser::OmpLoopDirective>(beginDirective.t);
167169
if ((beginLoopDirective.v == llvm::omp::Directive::OMPD_unroll ||
168-
beginLoopDirective.v == llvm::omp::Directive::OMPD_tile)) {
169-
// iterate through the remaining block items to find the end directive for the unroll/tile directive.
170+
beginLoopDirective.v == llvm::omp::Directive::OMPD_tile)) {
171+
// iterate through the remaining block items to find the end directive
172+
// for the unroll/tile directive.
170173
parser::Block::iterator endIt;
171174
endIt = nextIt;
172-
while(endIt != block.end()) {
175+
while (endIt != block.end()) {
173176
if (auto *endDir{
174-
GetConstructIf<parser::OmpEndLoopDirective>(*endIt)}) {
175-
auto &endLoopDirective = std::get<parser::OmpLoopDirective>(endDir->t);
176-
if(endLoopDirective.v == dir.v) {
177-
std::get<std::optional<parser::OmpEndLoopDirective>>(x.t) =
178-
std::move(*endDir);
179-
endIt = block.erase(endIt);
180-
continue;
181-
}
177+
GetConstructIf<parser::OmpEndLoopDirective>(*endIt)}) {
178+
auto &endLoopDirective =
179+
std::get<parser::OmpLoopDirective>(endDir->t);
180+
if (endLoopDirective.v == dir.v) {
181+
std::get<std::optional<parser::OmpEndLoopDirective>>(x.t) =
182+
std::move(*endDir);
183+
endIt = block.erase(endIt);
184+
continue;
182185
}
183-
++endIt;
184186
}
187+
++endIt;
188+
}
185189
RewriteOpenMPLoopConstruct(*ompLoopCons, block, nextIt);
186-
auto &ompLoop = std::get<std::optional<std::variant<parser::DoConstruct, common::Indirection<parser::OpenMPLoopConstruct>>>>(x.t);
187-
ompLoop = std::optional<std::variant<parser::DoConstruct, common::Indirection<parser::OpenMPLoopConstruct>>>{
188-
std::variant<parser::DoConstruct, common::Indirection<parser::OpenMPLoopConstruct>>{
189-
common::Indirection{std::move(*ompLoopCons)}}};
190+
auto &ompLoop =
191+
std::get<std::optional<std::variant<parser::DoConstruct,
192+
common::Indirection<parser::OpenMPLoopConstruct>>>>(x.t);
193+
ompLoop = std::optional<std::variant<parser::DoConstruct,
194+
common::Indirection<parser::OpenMPLoopConstruct>>>{
195+
std::variant<parser::DoConstruct,
196+
common::Indirection<parser::OpenMPLoopConstruct>>{
197+
common::Indirection{std::move(*ompLoopCons)}}};
190198
nextIt = block.erase(nextIt);
191199
} else {
192200
messages_.Say(dir.source,
193-
"Only OpenMP Loop Transformation Constructs can be nested within OpenMPLoopConstruct's"_err_en_US,
194-
parser::ToUpperCaseLetters(dir.source.ToString()));
201+
"Only OpenMP Loop Transformation Constructs can be nested within OpenMPLoopConstruct's"_err_en_US,
202+
parser::ToUpperCaseLetters(dir.source.ToString()));
195203
}
196204
} else {
197205
missingDoConstruct(dir);

‎flang/lib/Semantics/check-omp-structure.cpp‎

Lines changed: 36 additions & 36 deletions
Original file line numberDiff line numberDiff line change
@@ -763,7 +763,7 @@ void OmpStructureChecker::Enter(const parser::OpenMPLoopConstruct &x) {
763763
SetLoopInfo(x);
764764

765765
auto &optLoopCons = std::get<1>(x.t);
766-
if(optLoopCons.has_value()) {
766+
if (optLoopCons.has_value()) {
767767
if (const auto &doConstruct{
768768
std::get_if<parser::DoConstruct>(&*optLoopCons)}) {
769769
const auto &doBlock{std::get<parser::Block>(doConstruct->t)};
@@ -866,26 +866,26 @@ void OmpStructureChecker::CheckLoopItrVariableIsInt(
866866
auto &optLoopCons = std::get<1>(x.t);
867867
if (optLoopCons.has_value()) {
868868
if (const auto &loopConstruct{
869-
std::get_if<parser::DoConstruct>(&*optLoopCons)}) {
869+
std::get_if<parser::DoConstruct>(&*optLoopCons)}) {
870870

871-
for (const parser::DoConstruct *loop{&*loopConstruct}; loop;) {
872-
if (loop->IsDoNormal()) {
873-
const parser::Name &itrVal{GetLoopIndex(loop)};
874-
if (itrVal.symbol) {
875-
const auto *type{itrVal.symbol->GetType()};
876-
if (!type->IsNumeric(TypeCategory::Integer)) {
877-
context_.Say(itrVal.source,
878-
"The DO loop iteration"
879-
" variable must be of the type integer."_err_en_US,
880-
itrVal.ToString());
871+
for (const parser::DoConstruct *loop{&*loopConstruct}; loop;) {
872+
if (loop->IsDoNormal()) {
873+
const parser::Name &itrVal{GetLoopIndex(loop)};
874+
if (itrVal.symbol) {
875+
const auto *type{itrVal.symbol->GetType()};
876+
if (!type->IsNumeric(TypeCategory::Integer)) {
877+
context_.Say(itrVal.source,
878+
"The DO loop iteration"
879+
" variable must be of the type integer."_err_en_US,
880+
itrVal.ToString());
881+
}
881882
}
882883
}
883-
}
884-
// Get the next DoConstruct if block is not empty.
885-
const auto &block{std::get<parser::Block>(loop->t)};
886-
const auto it{block.begin()};
887-
loop = it != block.end() ? parser::Unwrap<parser::DoConstruct>(*it)
888-
: nullptr;
884+
// Get the next DoConstruct if block is not empty.
885+
const auto &block{std::get<parser::Block>(loop->t)};
886+
const auto it{block.begin()};
887+
loop = it != block.end() ? parser::Unwrap<parser::DoConstruct>(*it)
888+
: nullptr;
889889
}
890890
}
891891
}
@@ -1088,25 +1088,25 @@ void OmpStructureChecker::CheckDistLinear(
10881088
// clauses.
10891089
auto &optLoopCons = std::get<1>(x.t);
10901090
if (optLoopCons.has_value()) {
1091-
if (const auto &loopConstruct{
1092-
std::get_if<parser::DoConstruct>(&*optLoopCons)}) {
1093-
for (const parser::DoConstruct *loop{&*loopConstruct}; loop;) {
1094-
if (loop->IsDoNormal()) {
1095-
const parser::Name &itrVal{GetLoopIndex(loop)};
1096-
if (itrVal.symbol) {
1097-
// Remove the symbol from the collected set
1098-
indexVars.erase(&itrVal.symbol->GetUltimate());
1099-
}
1100-
collapseVal--;
1101-
if (collapseVal == 0) {
1102-
break;
1091+
if (const auto &loopConstruct{
1092+
std::get_if<parser::DoConstruct>(&*optLoopCons)}) {
1093+
for (const parser::DoConstruct *loop{&*loopConstruct}; loop;) {
1094+
if (loop->IsDoNormal()) {
1095+
const parser::Name &itrVal{GetLoopIndex(loop)};
1096+
if (itrVal.symbol) {
1097+
// Remove the symbol from the collected set
1098+
indexVars.erase(&itrVal.symbol->GetUltimate());
1099+
}
1100+
collapseVal--;
1101+
if (collapseVal == 0) {
1102+
break;
1103+
}
11031104
}
1104-
}
1105-
// Get the next DoConstruct if block is not empty.
1106-
const auto &block{std::get<parser::Block>(loop->t)};
1107-
const auto it{block.begin()};
1108-
loop = it != block.end() ? parser::Unwrap<parser::DoConstruct>(*it)
1109-
: nullptr;
1105+
// Get the next DoConstruct if block is not empty.
1106+
const auto &block{std::get<parser::Block>(loop->t)};
1107+
const auto it{block.begin()};
1108+
loop = it != block.end() ? parser::Unwrap<parser::DoConstruct>(*it)
1109+
: nullptr;
11101110
}
11111111
}
11121112
}

‎flang/lib/Semantics/resolve-directives.cpp‎

Lines changed: 13 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -1968,10 +1968,11 @@ void OmpAttributeVisitor::PrivatizeAssociatedLoopIndexAndCheckLoopLevel(
19681968
auto &optLoopCons = std::get<1>(x.t);
19691969
if (optLoopCons.has_value()) {
19701970
if (const auto &outer{std::get_if<parser::DoConstruct>(&*optLoopCons)}) {
1971-
for (const parser::DoConstruct *loop{&*outer}; loop && level > 0; --level) {
1971+
for (const parser::DoConstruct *loop{&*outer}; loop && level > 0;
1972+
--level) {
19721973
if (loop->IsDoConcurrent()) {
1973-
// DO CONCURRENT is explicitly allowed for the LOOP construct so long as
1974-
// there isn't a COLLAPSE clause
1974+
// DO CONCURRENT is explicitly allowed for the LOOP construct so long
1975+
// as there isn't a COLLAPSE clause
19751976
if (isLoopConstruct) {
19761977
if (hasCollapseClause) {
19771978
// hasCollapseClause implies clause != nullptr
@@ -2000,16 +2001,20 @@ void OmpAttributeVisitor::PrivatizeAssociatedLoopIndexAndCheckLoopLevel(
20002001
}
20012002
}
20022003
CheckAssocLoopLevel(level, GetAssociatedClause());
2003-
} else if (const auto &loop{std::get_if<common::Indirection<parser::OpenMPLoopConstruct>>(&*optLoopCons)}) {
2004+
} else if (const auto &loop{std::get_if<
2005+
common::Indirection<parser::OpenMPLoopConstruct>>(
2006+
&*optLoopCons)}) {
20042007
auto &beginDirective =
2005-
std::get<parser::OmpBeginLoopDirective>(loop->value().t);
2008+
std::get<parser::OmpBeginLoopDirective>(loop->value().t);
20062009
auto &beginLoopDirective =
20072010
std::get<parser::OmpLoopDirective>(beginDirective.t);
20082011
if ((beginLoopDirective.v != llvm::omp::Directive::OMPD_unroll &&
2009-
beginLoopDirective.v != llvm::omp::Directive::OMPD_tile)) {
2012+
beginLoopDirective.v != llvm::omp::Directive::OMPD_tile)) {
20102013
context_.Say(GetContext().directiveSource,
2011-
"Only UNROLL or TILE constructs are allowed between an OpenMP Loop Construct and a DO construct"_err_en_US,
2012-
parser::ToUpperCaseLetters(llvm::omp::getOpenMPDirectiveName(GetContext().directive, version).str()));
2014+
"Only UNROLL or TILE constructs are allowed between an OpenMP Loop Construct and a DO construct"_err_en_US,
2015+
parser::ToUpperCaseLetters(llvm::omp::getOpenMPDirectiveName(
2016+
GetContext().directive, version)
2017+
.str()));
20132018
} else {
20142019
PrivatizeAssociatedLoopIndexAndCheckLoopLevel(loop->value());
20152020
}

0 commit comments

Comments
 (0)