[fir] Add data flow optimization pass

[clementval]

Summary

Add pass to perform store/load forwarding and potentially removing dead
stores.

This patch is part of the upstreaming effort from fir-dev branch.

[mehdi_amini]

flang/lib/Optimizer/Transforms/MemRefDataFlowOpt.cpp

30

49

Not sure why it is a reference, and auto does not help readability so why not spell out the type? (here and everywhere, in all the upstreaming patches please).

53

85

It is a bit misleading that the variable name is loadOps but contains instances of ReadOp (while there is also a LoadOp class...)

107

flang/test/Fir/memref-data-flow.fir

390

This looks like purely generated checks, can you minimize these?

[jdoerfert]

Drive by: Just glancing at this I am very doubtful this is correct or well tested:

• All non-load/store users are ignored, which is already a bad thing (I just so the FIXME which is easily lost and not mentioned in the rather sparse commit message).
• The reasoning about "nearest stores" ignores all non dominating stores, which should also not be correct.
• The reasoning about "unneeded stores" ignores non-dominated loads, which should also not be correct.
• Given that the test have no comments I'm not sure if they are positive or negative tests. I would hope both are present and the situations described above are in there.

[clementval]

Address @mehdi's comments

[clementval]

In D111288#3050087, @jdoerfert wrote:

Drive by: Just glancing at this I am very doubtful this is correct or well tested:

• All non-load/store users are ignored, which is already a bad thing (I just so the FIXME which is easily lost and not mentioned in the rather sparse commit message).
• The reasoning about "nearest stores" ignores all non dominating stores, which should also not be correct.
• The reasoning about "unneeded stores" ignores non-dominated loads, which should also not be correct.
• Given that the test have no comments I'm not sure if they are positive or negative tests. I would hope both are present and the situations described above are in there.

As for probably 80% of the fir-dev upstreaming patch, I'm not the primary author of this code so maybe @schweitz can comment on that.

[clementval]

Rebase

[schweitz]

In D111288#3050436, @clementval wrote:

In D111288#3050087, @jdoerfert wrote:

Drive by: Just glancing at this I am very doubtful this is correct or well tested:

• All non-load/store users are ignored, which is already a bad thing (I just so the FIXME which is easily lost and not mentioned in the rather sparse commit message).
• The reasoning about "nearest stores" ignores all non dominating stores, which should also not be correct.
• The reasoning about "unneeded stores" ignores non-dominated loads, which should also not be correct.
• Given that the test have no comments I'm not sure if they are positive or negative tests. I would hope both are present and the situations described above are in there.

As for probably 80% of the fir-dev upstreaming patch, I'm not the primary author of this code so maybe @schweitz can comment on that.

I'm not the primary author of this code either.

The background here is that this is some prototype experimental work done to gauge the feasibility of using the affine dialect from Fortran. There are problems here as well as some bit rot. (The experiment yielded some promising results and discovered some interesting issues, as you might expect.)

@clementval is upstreaming it effectively in an "as-is" state, sharing it with a broader audience, and as a possible starting point for future work. Pros: It puts the prototype out there for anyone interested. Cons: It's just an early prototype. That's just one alternative.

Another alternative is to not bother upstreaming it, since it may be "too much of a prototype" (It's not always super clear how to distinguish "overly prototype-y" from "prototype-y but possibly useful in a new project.), and let someone figure out what to do in the future. Pros: It's not there and no one will mistakenly assume its robust, productized code by mistake. Cons: It's not there, so the reference point, lessons learned, etc. are likely to just be lost over time.

[schweitz]

We've made a decision a long time ago to use auto routinely and let the compiler type inference.

Here is an actual type from the front end that might help in understanding why fully elaborated types do not improve readability.

Understanding the code concerns can be addressed in more economical and truly effective ways.

std::__detail::__variant::__gen_vtable_impl<std::__detail::__variant::_Multi_array<void (*)(Fortran::common::visitors<auto Fortran::lower::pft::ReferenceVariantBase<true, Fortran::parser::AllocateStmt, Fortran::parser::AssignmentStmt, Fortran::parser::BackspaceStmt, Fortran::parser::CallStmt, Fortran::parser::CloseStmt, Fortran::parser::ContinueStmt, Fortran::parser::CycleStmt, Fortran::parser::DeallocateStmt, Fortran::parser::EndfileStmt, Fortran::parser::EventPostStmt, Fortran::parser::EventWaitStmt, Fortran::parser::ExitStmt, Fortran::parser::FailImageStmt, Fortran::parser::FlushStmt, Fortran::parser::FormTeamStmt, Fortran::parser::GotoStmt, Fortran::parser::IfStmt, Fortran::parser::InquireStmt, Fortran::parser::LockStmt, Fortran::parser::NullifyStmt, Fortran::parser::OpenStmt, Fortran::parser::PointerAssignmentStmt, Fortran::parser::PrintStmt, Fortran::parser::ReadStmt, Fortran::parser::ReturnStmt, Fortran::parser::RewindStmt, Fortran::parser::StopStmt, Fortran::parser::SyncAllStmt, Fortran::parser::SyncImagesStmt, Fortran::parser::SyncMemoryStmt, Fortran::parser::SyncTeamStmt, Fortran::parser::UnlockStmt, Fortran::parser::WaitStmt, Fortran::parser::WhereStmt, Fortran::parser::WriteStmt, Fortran::parser::ComputedGotoStmt, Fortran::parser::ForallStmt, Fortran::parser::ArithmeticIfStmt, Fortran::parser::AssignStmt, Fortran::parser::AssignedGotoStmt, Fortran::parser::PauseStmt, Fortran::parser::EntryStmt, Fortran::parser::FormatStmt, Fortran::parser::AssociateStmt, Fortran::parser::EndAssociateStmt, Fortran::parser::BlockStmt, Fortran::parser::EndBlockStmt, Fortran::parser::SelectCaseStmt, Fortran::parser::CaseStmt, Fortran::parser::EndSelectStmt, Fortran::parser::ChangeTeamStmt, Fortran::parser::EndChangeTeamStmt, Fortran::parser::CriticalStmt, Fortran::parser::EndCriticalStmt, Fortran::parser::NonLabelDoStmt, Fortran::parser::EndDoStmt, Fortran::parser::IfThenStmt, Fortran::parser::ElseIfStmt, Fortran::parser::ElseStmt, Fortran::parser::EndIfStmt, Fortran::parser::SelectRankStmt, Fortran::parser::SelectRankCaseStmt, Fortran::parser::SelectTypeStmt, Fortran::parser::TypeGuardStmt, Fortran::parser::WhereConstructStmt, Fortran::parser::MaskedElsewhereStmt, Fortran::parser::ElsewhereStmt, Fortran::parser::EndWhereStmt, Fortran::parser::ForallConstructStmt, Fortran::parser::EndForallStmt, Fortran::parser::EndProgramStmt, Fortran::parser::EndFunctionStmt, Fortran::parser::EndSubroutineStmt, Fortran::parser::EndMpSubprogramStmt, Fortran::parser::AssociateConstruct, Fortran::parser::BlockConstruct, Fortran::parser::CaseConstruct, Fortran::parser::ChangeTeamConstruct, Fortran::parser::CriticalConstruct, Fortran::parser::DoConstruct, Fortran::parser::IfConstruct, Fortran::parser::SelectRankConstruct, Fortran::parser::SelectTypeConstruct, Fortran::parser::WhereConstruct, Fortran::parser::ForallConstruct, Fortran::parser::CompilerDirective, Fortran::parser::OpenACCConstruct, Fortran::parser::OpenMPConstruct, Fortran::parser::OmpEndLoopDirective>::visit<(anonymous namespace)::FirConverter::genFIR(Fortran::lower::pft::Evaluation&, bool)::'lambda'(auto const&)>(auto&&) const::'lambda'(auto)>&&, std::variant<Fortran::common::Reference<Fortran::parser::AllocateStmt const>, Fortran::common::Reference<Fortran::parser::AssignmentStmt const>, Fortran::common::Reference<Fortran::parser::BackspaceStmt const>, Fortran::common::Reference<Fortran::parser::CallStmt const>, Fortran::common::Reference<Fortran::parser::CloseStmt const>, Fortran::common::Reference<Fortran::parser::ContinueStmt const>, Fortran::common::Reference<Fortran::parser::CycleStmt const>, Fortran::common::Reference<Fortran::parser::DeallocateStmt const>, Fortran::common::Reference<Fortran::parser::EndfileStmt const>, Fortran::common::Reference<Fortran::parser::EventPostStmt const>, Fortran::common::Reference<Fortran::parser::EventWaitStmt const>, Fortran::common::Reference<Fortran::parser::ExitStmt const>, Fortran::common::Reference<Fortran::parser::FailImageStmt const>, Fortran::common::Reference<Fortran::parser::FlushStmt const>, Fortran::common::Reference<Fortran::parser::FormTeamStmt const>, Fortran::common::Reference<Fortran::parser::GotoStmt const>, Fortran::common::Reference<Fortran::parser::IfStmt const>, Fortran::common::Reference<Fortran::parser::InquireStmt const>, Fortran::common::Reference<Fortran::parser::LockStmt const>, Fortran::common::Reference<Fortran::parser::NullifyStmt const>, Fortran::common::Reference<Fortran::parser::OpenStmt const>, Fortran::common::Reference<Fortran::parser::PointerAssignmentStmt const>, Fortran::common::Reference<Fortran::parser::PrintStmt const>, Fortran::common::Reference<Fortran::parser::ReadStmt const>, Fortran::common::Reference<Fortran::parser::ReturnStmt const>, Fortran::common::Reference<Fortran::parser::RewindStmt const>, Fortran::common::Reference<Fortran::parser::StopStmt const>, Fortran::common::Reference<Fortran::parser::SyncAllStmt const>, Fortran::common::Reference<Fortran::parser::SyncImagesStmt const>, Fortran::common::Reference<Fortran::parser::SyncMemoryStmt const>, Fortran::common::Reference<Fortran::parser::SyncTeamStmt const>, Fortran::common::Reference<Fortran::parser::UnlockStmt const>, Fortran::common::Reference<Fortran::parser::WaitStmt const>, Fortran::common::Reference<Fortran::parser::WhereStmt const>, Fortran::common::Reference<Fortran::parser::WriteStmt const>, Fortran::common::Reference<Fortran::parser::ComputedGotoStmt const>, Fortran::common::Reference<Fortran::parser::ForallStmt const>, Fortran::common::Reference<Fortran::parser::ArithmeticIfStmt const>, Fortran::common::Reference<Fortran::parser::AssignStmt const>, Fortran::common::Reference<Fortran::parser::AssignedGotoStmt const>, Fortran::common::Reference<Fortran::parser::PauseStmt const>, Fortran::common::Reference<Fortran::parser::EntryStmt const>, Fortran::common::Reference<Fortran::parser::FormatStmt const>, Fortran::common::Reference<Fortran::parser::AssociateStmt const>, Fortran::common::Reference<Fortran::parser::EndAssociateStmt const>, Fortran::common::Reference<Fortran::parser::BlockStmt const>, Fortran::common::Reference<Fortran::parser::EndBlockStmt const>, Fortran::common::Reference<Fortran::parser::SelectCaseStmt const>, Fortran::common::Reference<Fortran::parser::CaseStmt const>, Fortran::common::Reference<Fortran::parser::EndSelectStmt const>, Fortran::common::Reference<Fortran::parser::ChangeTeamStmt const>, Fortran::common::Reference<Fortran::parser::EndChangeTeamStmt const>, Fortran::common::Reference<Fortran::parser::CriticalStmt const>, Fortran::common::Reference<Fortran::parser::EndCriticalStmt const>, Fortran::common::Reference<Fortran::parser::NonLabelDoStmt const>, Fortran::common::Reference<Fortran::parser::EndDoStmt const>, Fortran::common::Reference<Fortran::parser::IfThenStmt const>, Fortran::common::Reference<Fortran::parser::ElseIfStmt const>, Fortran::common::Reference<Fortran::parser::ElseStmt const>, Fortran::common::Reference<Fortran::parser::EndIfStmt const>, Fortran::common::Reference<Fortran::parser::SelectRankStmt const>, Fortran::common::Reference<Fortran::parser::SelectRankCaseStmt const>, Fortran::common::Reference<Fortran::parser::SelectTypeStmt const>, Fortran::common::Reference<Fortran::parser::TypeGuardStmt const>, Fortran::common::Reference<Fortran::parser::WhereConstructStmt const>, Fortran::common::Reference<Fortran::parser::MaskedElsewhereStmt const>, Fortran::common::Reference<Fortran::parser::ElsewhereStmt const>, Fortran::common::Reference<Fortran::parser::EndWhereStmt const>, Fortran::common::Reference<Fortran::parser::ForallConstructStmt const>, Fortran::common::Reference<Fortran::parser::EndForallStmt const>, Fortran::common::Reference<Fortran::parser::EndProgramStmt const>, Fortran::common::Reference<Fortran::parser::EndFunctionStmt const>, Fortran::common::Reference<Fortran::parser::EndSubroutineStmt const>, Fortran::common::Reference<Fortran::parser::EndMpSubprogramStmt const>, Fortran::common::Reference<Fortran::parser::AssociateConstruct const>, Fortran::common::Reference<Fortran::parser::BlockConstruct const>, Fortran::common::Reference<Fortran::parser::CaseConstruct const>, Fortran::common::Reference<Fortran::parser::ChangeTeamConstruct const>, Fortran::common::Reference<Fortran::parser::CriticalConstruct const>, Fortran::common::Reference<Fortran::parser::DoConstruct const>, Fortran::common::Reference<Fortran::parser::IfConstruct const>, Fortran::common::Reference<Fortran::parser::SelectRankConstruct const>, Fortran::common::Reference<Fortran::parser::SelectTypeConstruct const>, Fortran::common::Reference<Fortran::parser::WhereConstruct const>, Fortran::common::Reference<Fortran::parser::ForallConstruct const>, Fortran::common::Reference<Fortran::parser::CompilerDirective const>, Fortran::common::Reference<Fortran::parser::OpenACCConstruct const>, Fortran::common::Reference<Fortran::parser::OpenMPConstruct const>, Fortran::common::Reference<Fortran::parser::OmpEndLoopDirective const> > const&)>, std::tuple<std::variant<Fortran::common::Reference<Fortran::parser::AllocateStmt const>, Fortran::common::Reference<Fortran::parser::AssignmentStmt const>, Fortran::common::Reference<Fortran::parser::BackspaceStmt const>, Fortran::common::Reference<Fortran::parser::CallStmt const>, Fortran::common::Reference<Fortran::parser::CloseStmt const>, Fortran::common::Reference<Fortran::parser::ContinueStmt const>, Fortran::common::Reference<Fortran::parser::CycleStmt const>, Fortran::common::Reference<Fortran::parser::DeallocateStmt const>, Fortran::common::Reference<Fortran::parser::EndfileStmt const>, Fortran::common::Reference<Fortran::parser::EventPostStmt const>, Fortran::common::Reference<Fortran::parser::EventWaitStmt const>, Fortran::common::Reference<Fortran::parser::ExitStmt const>, Fortran::common::Reference<Fortran::parser::FailImageStmt const>, Fortran::common::Reference<Fortran::parser::FlushStmt const>, Fortran::common::Reference<Fortran::parser::FormTeamStmt const>, Fortran::common::Reference<Fortran::parser::GotoStmt const>, Fortran::common::Reference<Fortran::parser::IfStmt const>, Fortran::common::Reference<Fortran::parser::InquireStmt const>, Fortran::common::Reference<Fortran::parser::LockStmt const>, Fortran::common::Reference<Fortran::parser::NullifyStmt const>, Fortran::common::Reference<Fortran::parser::OpenStmt const>, Fortran::common::Reference<Fortran::parser::PointerAssignmentStmt const>, Fortran::common::Reference<Fortran::parser::PrintStmt const>, Fortran::common::Reference<Fortran::parser::ReadStmt const>, Fortran::common::Reference<Fortran::parser::ReturnStmt const>, Fortran::common::Reference<Fortran::parser::RewindStmt const>, Fortran::common::Reference<Fortran::parser::StopStmt const>, Fortran::common::Reference<Fortran::parser::SyncAllStmt const>, Fortran::common::Reference<Fortran::parser::SyncImagesStmt const>, Fortran::common::Reference<Fortran::parser::SyncMemoryStmt const>, Fortran::common::Reference<Fortran::parser::SyncTeamStmt const>, Fortran::common::Reference<Fortran::parser::UnlockStmt const>, Fortran::common::Reference<Fortran::parser::WaitStmt const>, Fortran::common::Reference<Fortran::parser::WhereStmt const>, Fortran::common::Reference<Fortran::parser::WriteStmt const>, Fortran::common::Reference<Fortran::parser::ComputedGotoStmt const>, Fortran::common::Reference<Fortran::parser::ForallStmt const>, Fortran::common::Reference<Fortran::parser::ArithmeticIfStmt const>, Fortran::common::Reference<Fortran::parser::AssignStmt const>, Fortran::common::Reference<Fortran::parser::AssignedGotoStmt const>, Fortran::common::Reference<Fortran::parser::PauseStmt const>, Fortran::common::Reference<Fortran::parser::EntryStmt const>, Fortran::common::Reference<Fortran::parser::FormatStmt const>, Fortran::common::Reference<Fortran::parser::AssociateStmt const>, Fortran::common::Reference<Fortran::parser::EndAssociateStmt const>, Fortran::common::Reference<Fortran::parser::BlockStmt const>, Fortran::common::Reference<Fortran::parser::EndBlockStmt const>, Fortran::common::Reference<Fortran::parser::SelectCaseStmt const>, Fortran::common::Reference<Fortran::parser::CaseStmt const>, Fortran::common::Reference<Fortran::parser::EndSelectStmt const>, Fortran::common::Reference<Fortran::parser::ChangeTeamStmt const>, Fortran::common::Reference<Fortran::parser::EndChangeTeamStmt const>, Fortran::common::Reference<Fortran::parser::CriticalStmt const>, Fortran::common::Reference<Fortran::parser::EndCriticalStmt const>, Fortran::common::Reference<Fortran::parser::NonLabelDoStmt const>, Fortran::common::Reference<Fortran::parser::EndDoStmt const>, Fortran::common::Reference<Fortran::parser::IfThenStmt const>, Fortran::common::Reference<Fortran::parser::ElseIfStmt const>, Fortran::common::Reference<Fortran::parser::ElseStmt const>, Fortran::common::Reference<Fortran::parser::EndIfStmt const>, Fortran::common::Reference<Fortran::parser::SelectRankStmt const>, Fortran::common::Reference<Fortran::parser::SelectRankCaseStmt const>, Fortran::common::Reference<Fortran::parser::SelectTypeStmt const>, Fortran::common::Reference<Fortran::parser::TypeGuardStmt const>, Fortran::common::Reference<Fortran::parser::WhereConstructStmt const>, Fortran::common::Reference<Fortran::parser::MaskedElsewhereStmt const>, Fortran::common::Reference<Fortran::parser::ElsewhereStmt const>, Fortran::common::Reference<Fortran::parser::EndWhereStmt const>, Fortran::common::Reference<Fortran::parser::ForallConstructStmt const>, Fortran::common::Reference<Fortran::parser::EndForallStmt const>, Fortran::common::Reference<Fortran::parser::EndProgramStmt const>, Fortran::common::Reference<Fortran::parser::EndFunctionStmt const>, Fortran::common::Reference<Fortran::parser::EndSubroutineStmt const>, Fortran::common::Reference<Fortran::parser::EndMpSubprogramStmt const>, Fortran::common::Reference<Fortran::parser::AssociateConstruct const>, Fortran::common::Reference<Fortran::parser::BlockConstruct const>, Fortran::common::Reference<Fortran::parser::CaseConstruct const>, Fortran::common::Reference<Fortran::parser::ChangeTeamConstruct const>, Fortran::common::Reference<Fortran::parser::CriticalConstruct const>, Fortran::common::Reference<Fortran::parser::DoConstruct const>, Fortran::common::Reference<Fortran::parser::IfConstruct const>, Fortran::common::Reference<Fortran::parser::SelectRankConstruct const>, Fortran::common::Reference<Fortran::parser::SelectTypeConstruct const>, Fortran::common::Reference<Fortran::parser::WhereConstruct const>, Fortran::common::Reference<Fortran::parser::ForallConstruct const>, Fortran::common::Reference<Fortran::parser::CompilerDirective const>, Fortran::common::Reference<Fortran::parser::OpenACCConstruct const>, Fortran::common::Reference<Fortran::parser::OpenMPConstruct const>, Fortran::common::Reference<Fortran::parser::OmpEndLoopDirective const> > const&>, std::integer_sequence<unsigned long, 84ul> >::__visit_invoke(Fortran::common::visitors<auto Fortran::lower::pft::ReferenceVariantBase<true, Fortran::parser::AllocateStmt, Fortran::parser::AssignmentStmt, Fortran::parser::BackspaceStmt, Fortran::parser::CallStmt, Fortran::parser::CloseStmt, Fortran::parser::ContinueStmt, Fortran::parser::CycleStmt, Fortran::parser::DeallocateStmt, Fortran::parser::EndfileStmt, Fortran::parser::EventPostStmt, Fortran::parser::EventWaitStmt, Fortran::parser::ExitStmt, Fortran::parser::FailImageStmt, Fortran::parser::FlushStmt, Fortran::parser::FormTeamStmt, Fortran::parser::GotoStmt, Fortran::parser::IfStmt, Fortran::parser::InquireStmt, Fortran::parser::LockStmt, Fortran::parser::NullifyStmt, Fortran::parser::OpenStmt, Fortran::parser::PointerAssignmentStmt, Fortran::parser::PrintStmt, Fortran::parser::ReadStmt, Fortran::parser::ReturnStmt, Fortran::parser::RewindStmt, Fortran::parser::StopStmt, Fortran::parser::SyncAllStmt, Fortran::parser::SyncImagesStmt, Fortran::parser::SyncMemoryStmt, Fortran::parser::SyncTeamStmt, Fortran::parser::UnlockStmt, Fortran::parser::WaitStmt, Fortran::parser::WhereStmt, Fortran::parser::WriteStmt, Fortran::parser::ComputedGotoStmt, Fortran::parser::ForallStmt, Fortran::parser::ArithmeticIfStmt, Fortran::parser::AssignStmt, Fortran::parser::AssignedGotoStmt, Fortran::parser::PauseStmt, Fortran::parser::EntryStmt, Fortran::parser::FormatStmt, Fortran::parser::AssociateStmt, Fortran::parser::EndAssociateStmt, Fortran::parser::BlockStmt, Fortran::parser::EndBlockStmt, Fortran::parser::SelectCaseStmt, Fortran::parser::CaseStmt, Fortran::parser::EndSelectStmt, Fortran::parser::ChangeTeamStmt, Fortran::parser::EndChangeTeamStmt, Fortran::parser::CriticalStmt, Fortran::parser::EndCriticalStmt, Fortran::parser::NonLabelDoStmt, Fortran::parser::EndDoStmt, Fortran::parser::IfThenStmt, Fortran::parser::ElseIfStmt, Fortran::parser::ElseStmt, Fortran::parser::EndIfStmt, Fortran::parser::SelectRankStmt, Fortran::parser::SelectRankCaseStmt, Fortran::parser::SelectTypeStmt, Fortran::parser::TypeGuardStmt, Fortran::parser::WhereConstructStmt, Fortran::parser::MaskedElsewhereStmt, Fortran::parser::ElsewhereStmt, Fortran::parser::EndWhereStmt, Fortran::parser::ForallConstructStmt, Fortran::parser::EndForallStmt, Fortran::parser::EndProgramStmt, Fortran::parser::EndFunctionStmt, Fortran::parser::EndSubroutineStmt, Fortran::parser::EndMpSubprogramStmt, Fortran::parser::AssociateConstruct, Fortran::parser::BlockConstruct, Fortran::parser::CaseConstruct, Fortran::parser::ChangeTeamConstruct, Fortran::parser::CriticalConstruct, Fortran::parser::DoConstruct, Fortran::parser::IfConstruct, Fortran::parser::SelectRankConstruct, Fortran::parser::SelectTypeConstruct, Fortran::parser::WhereConstruct, Fortran::parser::ForallConstruct, Fortran::parser::CompilerDirective, Fortran::parser::OpenACCConstruct, Fortran::parser::OpenMPConstruct, Fortran::parser::OmpEndLoopDirective>::visit<(anonymous namespace)::FirConverter::genFIR(Fortran::lower::pft::Evaluation&, bool)::'lambda'(auto const&)>(auto&&) const::'lambda'(auto)>&&, std::variant<Fortran::common::Reference<Fortran::parser::AllocateStmt const>, Fortran::common::Reference<Fortran::parser::AssignmentStmt const>, Fortran::common::Reference<Fortran::parser::BackspaceStmt const>, Fortran::common::Reference<Fortran::parser::CallStmt const>, Fortran::common::Reference<Fortran::parser::CloseStmt const>, Fortran::common::Reference<Fortran::parser::ContinueStmt const>, Fortran::common::Reference<Fortran::parser::CycleStmt const>, Fortran::common::Reference<Fortran::parser::DeallocateStmt const>, Fortran::common::Reference<Fortran::parser::EndfileStmt const>, Fortran::common::Reference<Fortran::parser::EventPostStmt const>, Fortran::common::Reference<Fortran::parser::EventWaitStmt const>, Fortran::common::Reference<Fortran::parser::ExitStmt const>, Fortran::common::Reference<Fortran::parser::FailImageStmt const>, Fortran::common::Reference<Fortran::parser::FlushStmt const>, Fortran::common::Reference<Fortran::parser::FormTeamStmt const>, Fortran::common::Reference<Fortran::parser::GotoStmt const>, Fortran::common::Reference<Fortran::parser::IfStmt const>, Fortran::common::Reference<Fortran::parser::InquireStmt const>, Fortran::common::Reference<Fortran::parser::LockStmt const>, Fortran::common::Reference<Fortran::parser::NullifyStmt const>, Fortran::common::Reference<Fortran::parser::OpenStmt const>, Fortran::common::Reference<Fortran::parser::PointerAssignmentStmt const>, Fortran::common::Reference<Fortran::parser::PrintStmt const>, Fortran::common::Reference<Fortran::parser::ReadStmt const>, Fortran::common::Reference<Fortran::parser::ReturnStmt const>, Fortran::common::Reference<Fortran::parser::RewindStmt const>, Fortran::common::Reference<Fortran::parser::StopStmt const>, Fortran::common::Reference<Fortran::parser::SyncAllStmt const>, Fortran::common::Reference<Fortran::parser::SyncImagesStmt const>, Fortran::common::Reference<Fortran::parser::SyncMemoryStmt const>, Fortran::common::Reference<Fortran::parser::SyncTeamStmt const>, Fortran::common::Reference<Fortran::parser::UnlockStmt const>, Fortran::common::Reference<Fortran::parser::WaitStmt const>, Fortran::common::Reference<Fortran::parser::WhereStmt const>, Fortran::common::Reference<Fortran::parser::WriteStmt const>, Fortran::common::Reference<Fortran::parser::ComputedGotoStmt const>, Fortran::common::Reference<Fortran::parser::ForallStmt const>, Fortran::common::Reference<Fortran::parser::ArithmeticIfStmt const>, Fortran::common::Reference<Fortran::parser::AssignStmt const>, Fortran::common::Reference<Fortran::parser::AssignedGotoStmt const>, Fortran::common::Reference<Fortran::parser::PauseStmt const>, Fortran::common::Reference<Fortran::parser::EntryStmt const>, Fortran::common::Reference<Fortran::parser::FormatStmt const>, Fortran::common::Reference<Fortran::parser::AssociateStmt const>, Fortran::common::Reference<Fortran::parser::EndAssociateStmt const>, Fortran::common::Reference<Fortran::parser::BlockStmt const>, Fortran::common::Reference<Fortran::parser::EndBlockStmt const>, Fortran::common::Reference<Fortran::parser::SelectCaseStmt const>, Fortran::common::Reference<Fortran::parser::CaseStmt const>, Fortran::common::Reference<Fortran::parser::EndSelectStmt const>, Fortran::common::Reference<Fortran::parser::ChangeTeamStmt const>, Fortran::common::Reference<Fortran::parser::EndChangeTeamStmt const>, Fortran::common::Reference<Fortran::parser::CriticalStmt const>, Fortran::common::Reference<Fortran::parser::EndCriticalStmt const>, Fortran::common::Reference<Fortran::parser::NonLabelDoStmt const>, Fortran::common::Reference<Fortran::parser::EndDoStmt const>, Fortran::common::Reference<Fortran::parser::IfThenStmt const>, Fortran::common::Reference<Fortran::parser::ElseIfStmt const>, Fortran::common::Reference<Fortran::parser::ElseStmt const>, Fortran::common::Reference<Fortran::parser::EndIfStmt const>, Fortran::common::Reference<Fortran::parser::SelectRankStmt const>, Fortran::common::Reference<Fortran::parser::SelectRankCaseStmt const>, Fortran::common::Reference<Fortran::parser::SelectTypeStmt const>, Fortran::common::Reference<Fortran::parser::TypeGuardStmt const>, Fortran::common::Reference<Fortran::parser::WhereConstructStmt const>, Fortran::common::Reference<Fortran::parser::MaskedElsewhereStmt const>, Fortran::common::Reference<Fortran::parser::ElsewhereStmt const>, Fortran::common::Reference<Fortran::parser::EndWhereStmt const>, Fortran::common::Reference<Fortran::parser::ForallConstructStmt const>, Fortran::common::Reference<Fortran::parser::EndForallStmt const>, Fortran::common::Reference<Fortran::parser::EndProgramStmt const>, Fortran::common::Reference<Fortran::parser::EndFunctionStmt const>, Fortran::common::Reference<Fortran::parser::EndSubroutineStmt const>, Fortran::common::Reference<Fortran::parser::EndMpSubprogramStmt const>, Fortran::common::Reference<Fortran::parser::AssociateConstruct const>, Fortran::common::Reference<Fortran::parser::BlockConstruct const>, Fortran::common::Reference<Fortran::parser::CaseConstruct const>, Fortran::common::Reference<Fortran::parser::ChangeTeamConstruct const>, Fortran::common::Reference<Fortran::parser::CriticalConstruct const>, Fortran::common::Reference<Fortran::parser::DoConstruct const>, Fortran::common::Reference<Fortran::parser::IfConstruct const>, Fortran::common::Reference<Fortran::parser::SelectRankConstruct const>, Fortran::common::Reference<Fortran::parser::SelectTypeConstruct const>, Fortran::common::Reference<Fortran::parser::WhereConstruct const>, Fortran::common::Reference<Fortran::parser::ForallConstruct const>, Fortran::common::Reference<Fortran::parser::CompilerDirective const>, Fortran::common::Reference<Fortran::parser::OpenACCConstruct const>, Fortran::common::Reference<Fortran::parser::OpenMPConstruct const>, Fortran::common::Reference<Fortran::parser::OmpEndLoopDirective const> > const&)

[mehdi_amini]

In D111288#3052799, @schweitz wrote:

We've made a decision a long time ago to use auto routinely and let the compiler type inference.

Here is an actual type from the front end that might help in understanding why fully elaborated types do not improve readability.

Right, our coding guidelines are indeed recommending to use auto to improve readability, and the example of type you show here is exactly why we have this guideline: auto can greatly improve readability.

But there are plenty of cases where the improvement isn't clear to me, look at for example the case at hand here:

for (auto &loadOp : loadOps) {

vs:

for (ReadOp loadOp : loadOps) {

Is the auto improving readability here? If not why should we use it then?

In this particular case it is even worse: to me the auto is actively misleading:

1. the variable is named "loadOp" but isn't a LoadOp and is ReadOp instead.
2. The code takes a reference to the op, which makes me think it isn't an op since these are value-based class.

This is same for using auto op where we could read Operation *op, etc.

[jdoerfert]

In D111288#3052150, @schweitz wrote:

Another alternative is to not bother upstreaming it, since it may be "too much of a prototype" (It's not always super clear how to distinguish "overly prototype-y" from "prototype-y but possibly useful in a new project.), and let someone figure out what to do in the future. Pros: It's not there and no one will mistakenly assume its robust, productized code by mistake. Cons: It's not there, so the reference point, lessons learned, etc. are likely to just be lost over time.

I'm fine with it being there in a state like this but not without actual comments, in the code and commit message, telling people that this is not sound. Dropping some code that is known buggy without any form of documentation is not helpful for anyone.

[clementval]

In D111288#3053413, @jdoerfert wrote:

In D111288#3052150, @schweitz wrote:

Another alternative is to not bother upstreaming it, since it may be "too much of a prototype" (It's not always super clear how to distinguish "overly prototype-y" from "prototype-y but possibly useful in a new project.), and let someone figure out what to do in the future. Pros: It's not there and no one will mistakenly assume its robust, productized code by mistake. Cons: It's not there, so the reference point, lessons learned, etc. are likely to just be lost over time.

I'm fine with it being there in a state like this but not without actual comments, in the code and commit message, telling people that this is not sound. Dropping some code that is known buggy without any form of documentation is not helpful for anyone.

As Eric mentioned we are not the authors of this code and we have two options here:

1. We upstream the code in its current shape (we can add a comment mentioning that) so the broader community can start from it.
2. We do not upstream these transformations and any new effort will have to start from scratch on that.

[mehdi_amini]

I think @jdoerfert request to document more careful the state of the code and the caveat seem reasonable to me.
If you don't understand what is there enough to document it, then yeah maybe you shouldn't upstream it.

[jdoerfert]

In D111288#3053917, @mehdi_amini wrote:

I think @jdoerfert request to document more careful the state of the code and the caveat seem reasonable to me.
If you don't understand what is there enough to document it, then yeah maybe you shouldn't upstream it.

Here and for the other one. Put a warning in the commit message and file comment. In both cases list the things I said as potential problems. State it is a prototype and not necessarily production quality.
Then it's fine to be upstreamed.

[clementval]

In D111288#3053959, @jdoerfert wrote:

Here and for the other one. Put a warning in the commit message and file comment. In both cases list the things I said as potential problems. State it is a prototype and not necessarily production quality.
Then it's fine to be upstreamed.

Sure we can add these comments.

[clementval]

In D111288#3053917, @mehdi_amini wrote:

I think @jdoerfert request to document more careful the state of the code and the caveat seem reasonable to me.
If you don't understand what is there enough to document it, then yeah maybe you shouldn't upstream it.

It's not that we do not understand the code but more how much resource we can put to upstream it.

[clementval]

Rebase

[clementval]

Rebase

[mehdi_amini]

flang/test/Fir/memref-data-flow.fir

103

These tests looks like entirely auto-generated, what should we expect here?

Also the source of the test seems like taken directly from a real-world example, without any attempt to document or minimize: this can be a maintenance problem moving forward.

[clementval]

flang/test/Fir/memref-data-flow.fir

103

I heard that when you guys discussed the upstreaming of fir-dev it was advise to use to MLIR script to generate the check because the current checks were too small.

[mehdi_amini]

flang/test/Fir/memref-data-flow.fir

103

I'm not aware of this, we have documented guidelines though: https://mlir.llvm.org/getting_started/TestingGuide/#filecheck-best-practices

[clementval]

flang/test/Fir/memref-data-flow.fir

103

Thanks for the guidelines link. I'll have to check what we will do in Flang because I now have contradictory information from two sides.

[awarzynski]

flang/test/Fir/memref-data-flow.fir

103

I heard that when you guys discussed the upstreaming of fir-dev it was advise to use to MLIR script to generate the check because the current checks were too small.

I think that quite a few separate discussions have happened in the last year or so. I was just a by-stander most of the time, so can't really comment. Also, I'm not aware of anything public that we could refer to here (e.g. an RFC or something similar). Perhaps this particular aspect has not been discussed? :)

@mehdi_amini,

These tests looks like entirely auto-generated, what should we expect here?

IIUC, you *are* in favor of auto-generated tests (e.g. with generate-test-checks.py), but would prefer them to be a bit refactored, right? Otherwise it's not really obvious "what" is being tested. Basically,

Tests should be minimal, and only check what is absolutely necessary.

@clementval The check lines could be reduced to only contain the key operations being tested and making sure the these are generated correctly.

this can be a maintenance problem moving forward

I agree. Any change in MLIR that causes these tests to fail could be non-trivial to triage. But I also think that it will be quite tricky to re-generate these tests from scratch. Perhaps we could make sure that:

• every test is documented (e.g. by making a descriptive function name that highlights "what" is being tested)
• check lines not strictly related to the functionality being tested are reduced/removed

This way we would make any potential triaging much easier for ourselves without having to re-write these cases.

This is just my 2p. WDYT?

[mehdi_amini]

. Perhaps we could make sure that:

• • every test is documented (e.g. by making a descriptive function name that highlights "what" is being tested)
• check lines not strictly related to the functionality being tested are reduced/removed

Right, that seems to go in the direction of the guidelines I posted I think :)

Thanks!

[clementval]

flang/test/Fir/memref-data-flow.fir

103

I fully understand your points @awarzynski and it makes sense to me. Once again I just want to point out that we need to find a trade off in the current upstreaming process.
I'll not be able to refactor/rework deeply every single patch I post. Keep in mind that every change done here must be sync back in fir-dev until we can discard it (tests are the easy one to sync). fir-dev is still evolving everyday and if we want to get rid of it one day we need to find the right pace to the upstreaming can catch up with the daily evolution.
This is not a comment specifically for this patch but rather a general one for the current process we are in. AFAIK, I'm the only person spending time upstreaming fir-dev at the moment.
In most cases I'm not the author of the code and even refactoring tests can take quite some times. Time that I'm happy to spend when we find flaw or blockers.
We agreed in the past that we will try our best to make small patches because a single push like it was done for MLIR or the Flang frontends was pushed back.
We might need a new discussion on the usptreaming process if we want it to be successful in a timely manner.

[kiranchandramohan]

flang/test/Fir/memref-data-flow.fir

103

Many thanks, @clementval for your efforts in restarting and making quite some progress with upstreaming. I am in favour of upstreaming fast so that we do not have to work across two repositories (llvm-project and fir-dev). For the OpenMP work, we face some difficulties working across the two repos.

I think we can consider,

1. Increasing the number of people working on upstreaming. It might be possible (subject to approval) for one of us at Arm to join the upstreaming effort (either in helping to write or fix tests or regular upstreaming work). Will this be acceptable?
2. Adding non-critical but essential changes as bugs/issues and come back to this once we have llvm-project and fir-dev on par.
3. Stopping fir-dev work once we reach full Fortran 95 support and everyone joins upstreaming for a couple of months.

[clementval]

flang/test/Fir/memref-data-flow.fir

103

A simplification of the first test could look like the following. Would that be ok?

// CHECK-LABEL:   func @_QPf1dc(
// CHECK-SAME:                  %[[VAL_0:.*]]: !fir.ref<!fir.array<60xi32>>, 
// CHECK:         ^bb2:
// CHECK:           %[[VAL_12:.*]] = fir.convert %{{.*}} : (index) -> i32
// CHECK-NOT:       fir.store %{{.*}} to %{{.*}} : !fir.ref<i32>
// CHECK-NOT:       %{{.*}} = fir.load %{{.*}} : !fir.ref<i32>
// CHECK:           %[[VAL_13:.*]] = fir.convert %[[VAL_12]] : (i32) -> i64

// CHECK:    %[[VAL_15:.*]] = fir.coordinate_of %{{.*}}, %{{.*}} : (!fir.ref<!fir.array<60xi32>>, i64) -> !fir.ref<i32>
// CHECK:    %[[VAL_16:.*]] = fir.load %[[VAL_15]] : !fir.ref<i32>

// CHECK:    %[[VAL_18:.*]] = fir.coordinate_of %{{.*}}, %{{.*}} : (!fir.ref<!fir.array<60xi32>>, i64) -> !fir.ref<i32>
// CHECK:    fir.store %{{.*}} to %[[VAL_18]] : !fir.ref<i32>

// CHECK:  ^bb3:
// CHECK:     %[[VAL_21:.*]] = fir.convert %{{.*}} : (index) -> i32
// CHECK-NOT: fir.store %{{.*}} to %{{.*}} : !fir.ref<i32>
// CHECK:     br ^bb4

// CHECK:  ^bb5:
// CHECK:    %[[VAL_25:.*]] = fir.convert %{{.*}} : (index) -> i32
// CHECK-NOT: fir.store %{{.*}} to %{{.*}} : !fir.ref<i32>
// CHECK-NOT: %{{.*}} = fir.load %{{.*}} : !fir.ref<i32>
// CHECK:    %[[VAL_26:.*]] = fir.convert %[[VAL_25]] : (i32) -> i64
// CHECK:    %[[VAL_28:.*]] = fir.coordinate_of %{{.*}}, %{{.*}} : (!fir.ref<!fir.array<60xi32>>, i64) -> !fir.ref<i32>
// CHECK:    %[[VAL_29:.*]] = fir.load %[[VAL_28]] : !fir.ref<i32>
// CHECK:    %[[VAL_30:.*]] = fir.coordinate_of %{{.*}}, %{{.*}} : (!fir.ref<!fir.array<60xi32>>, i64) -> !fir.ref<i32>
// CHECK:    %[[VAL_31:.*]] = fir.load %[[VAL_30]] : !fir.ref<i32>
// CHECK:    %[[VAL_33:.*]] = fir.coordinate_of %{{.*}}, %{{.*}} : (!fir.ref<!fir.array<60xi32>>, i64) -> !fir.ref<i32>
// CHECK:    fir.store %{{.*}} to %[[VAL_33]] : !fir.ref<i32>

[clementval]

flang/test/Fir/memref-data-flow.fir

103

I think we can consider,

1. Increasing the number of people working on upstreaming. It might be possible (subject to approval) for one of us at Arm to join the upstreaming effort (either in helping to write or fix tests or regular upstreaming work). Will this be acceptable?

Of course more people working on this will help. We just need to coordinate if this is going to happen.

2. Adding non-critical but essential changes as bugs/issues and come back to this once we have llvm-project and fir-dev on par.

I think we should go this route. I would suggests that critical changes should be marked as "Request Changes" and any other comment would be done as best effort. Would this be acceptable? Also it doesn't mean that this comments will never be addressed but rather delayed until we can discard fir-dev.

3. Stopping fir-dev work once we reach full Fortran 95 support and everyone joins upstreaming for a couple of months.

I think we should at least reduce what we accept on fir-dev once F95 is reached. I guess we can talk about this during the next call.

[awarzynski]

flang/test/Fir/memref-data-flow.fir

107–162

Perhaps something like this would be sufficient? It highlights that:

• the store-load chains have been removed (as expected)
• basic blocks have been preserved (as expected)
• stores and loads that are not in a load-store chain are preserved

I also removed all regex regex variables. These didn't seem required.

This is not too different to what @clementval proposed, but leverages CHECK-LABEL and CHECK-DAG to make it a bit more robust.

[mehdi_amini]

flang/test/Fir/memref-data-flow.fir

103

I think we can defer some action items, but I would prefer that a bug is filed and mentioned in a comment like this strawman: // TODO: llvm.org/pr12345 this needs to be ....

We can either keep track of these with a "tag"/"keyword" on the bug, or with a separate "component" on buganizer.

[clementval]

flang/test/Fir/memref-data-flow.fir

103

Ok we will coordinate on this.

@mehdi_amini Is the smaller test proposed by me or @awarzynski look ok to you? If so, I can update this patch so we can move forward,

[mehdi_amini]

flang/test/Fir/memref-data-flow.fir

103

I am not sure: I haven't spent time on the existing test, but I'd start with the function name which isn't descriptive: can we name the function against what it is testing?
In some cases we may need comments about what is the test exercising as well.

I see tests very much as part of the documentation for the code: in many case when I'm unsure about some part of a pass, I'll try to disable it in the code and run the tests to see which case is breaking for example. But having over-constrained test or test where the input IR isn't minimized makes it impossible.

[clementval]

Reduce number of fir-to-fir tests and reduce the checks

[clementval]

flang/test/Fir/memref-data-flow.fir

103

@awarzynski @kiranchandramohan @mehdi_amini Test have been reduced and checks are just checking what is important.

[kiranchandramohan]

I guess some of the arithmetic operations at various places can be removed to shorten the test. Like for e.g:

%65 = arith.subi %64, %c1 : index
%66 = arith.muli %5, %65 : index
%67 = arith.addi %66, %62 : index

I am OK with creating a ticket to reduce the test later and proceeding. Please wait for Mehdi.

[kiranchandramohan]

flang/test/Fir/memref-data-flow.fir

404

CHECL-NOT -> CHECK-NOT and couple of places below.

[awarzynski]

Thanks for trimming the tests @clementval - now it is much clearer what is being tested! I think the the following pattern:

// CHECK-NOT:     %{{.*}} = fir.load %{{.*}} : !fir.ref<i32>
// CHECK:         %{{.*}} = fir.load %{{.*}} : !fir.ref<i32>

can be reduced to:

// CHECK:         %{{.*}} = fir.load %{{.*}} : !fir.ref<i32>

Not a blocker for me. I've also left a few inline comments, but mostly nits! LGTM (modulo the typos), but please wait for Mehdi to take a look before merging.

Thanks for working on this!

flang/test/Fir/memref-data-flow.fir

58

[nit] This comment applies to all cases in this file - I'd move it to the very top (near the RUN line). You may also want to note that fir.stores and fir.loads that are not in a chain are preserved. Perhaps that's obvious?

76–77

Just a [nit]

143–144

To make sure that there's no fir.store before fir.load

253

258–261

Just a [nit]

270–273

401

To make sure that there's no fir.store before fir.load.

427–430

[nit]

[clementval]

Fix typos and nits

[clementval]

In D111288#3069662, @kiranchandramohan wrote:

I guess some of the arithmetic operations at various places can be removed to shorten the test. Like for e.g:

%65 = arith.subi %64, %c1 : index
%66 = arith.muli %5, %65 : index
%67 = arith.addi %66, %62 : index

Thanks for the review. I'm not sure we should trim the inputs. At least not before we have lowering tests so we make sure dialects are good together.

flang/test/Fir/memref-data-flow.fir

404

Thanks for catching this.

[clementval]

In D111288#3069727, @awarzynski wrote:

Thanks for trimming the tests @clementval - now it is much clearer what is being tested! I think the the following pattern:

// CHECK-NOT:     %{{.*}} = fir.load %{{.*}} : !fir.ref<i32>
// CHECK:         %{{.*}} = fir.load %{{.*}} : !fir.ref<i32>

can be reduced to:

// CHECK:         %{{.*}} = fir.load %{{.*}} : !fir.ref<i32>

Not a blocker for me. I've also left a few inline comments, but mostly nits! LGTM (modulo the typos), but please wait for Mehdi to take a look before merging.

Thanks for working on this!

Thanks for the review. I made a last pass on this patch and hopefully the last one.

[clementval]

Move comment

[clementval]

Fix check typo

[clementval]

Can we go ahead we this?

[mehdi_amini]

Seems like I didn't click "send" when I reviewed this earlier this week, sorry!

flang/lib/Optimizer/Transforms/MemRefDataFlowOpt.cpp

30

This is marked as done, but it isn't (it isn't the only one I think)

flang/test/Fir/memref-data-flow.fir

62

Are we not expecting a fir.store? If so the check-not is more robust with simply // CHECK-NOT: fir.store

If you need to match the type as well I don't think you need to match the " to ", so // CHECK-NOT: fir.store{{.*}}!fir.ref<i32>

Same logic everywhere...

63

The two CHECK-NOT above apply to bb1, but in the source it is:

^bb1(%2: index, %3: index):  // 2 preds: ^bb0, ^bb2
  %4 = arith.cmpi sgt, %3, %c0 : index
  cond_br %4, ^bb2, ^bb3

Why are we specifically checking for no load/store in here?

66–67

I really don't understand this sequence: we have a CHECK-NOT followed by the identical CHECK.

74

This check-not is also followed by some identical checks, again the whole logic behind these checks is beyond me right now.

[mehdi_amini]

flang/test/Fir/memref-data-flow.fir

277

I still believe we should have documentation for the test itself: what is this IR exposing as a pattern and what it this testing that the other above don't?

This is quite a long function right now...

[awarzynski]

flang/test/Fir/memref-data-flow.fir

63

Currently, fir-memref-dataflow-opt makes sure that:

// All store-load chains are removed

These particular CHECK-NOTs verify that there are no new store-loads in bb1. There shouldn't be. It's just a sanity check in case something goes horribly wrong. Do you think that it's confusing?

66–67

IIUC, the first CHECK-NOT can safely be removed without affecting the test. From https://llvm.org/docs/CommandGuide/FileCheck.html#the-check-not-directive :

The “CHECK-NOT:” directive is used to verify that a string doesn’t occur between two matches (or before the first match, or after the last match).

I also find it confusing, but I believe that it's valid and that it does check that there's no store-load chain here.

277

what it this testing that the other above don't

IIUC, it is similar to the other tests. I don't think there's anything particular here beyond: there are some store-load chains, which are being removed. Wouldn't that be sufficient?

[clementval]

flang/lib/Optimizer/Transforms/MemRefDataFlowOpt.cpp

30

I have discussed this with others and they would like to keep it like that. The guidlines are kind of blurry on this... If this is a blocker we will ave to discuss this further.

[mehdi_amini]

flang/lib/Optimizer/Transforms/MemRefDataFlowOpt.cpp

30

Let's discuss then.
(and please don't ignore comments or mark them as done when they aren't!)

flang/test/Fir/memref-data-flow.fir

66–67

If I had to document your check right now it would be (as I understand them):

// Check that there is at least one fir.load followed by at least one fir.store, 
// both on i32. The load/store don't have to be related to each other.

And I could write the exact same test with:

// CHECK-LABEL: ^bb2:
// CHECK:     fir.load{{.*}} !fir.ref<i32>
// CHECK:     fir.store{{.*} }!fir.ref<i32>

Do you see an input to FileCheck that would be handled differently by the code you have right now and the above?

Also please provide the kind of plain text english documentation I wrote above on what you're checking in each section.

[clementval]

flang/lib/Optimizer/Transforms/MemRefDataFlowOpt.cpp

30

Sorry for that. We have discussed in this patch or in maybe another one and in the last call that during the upstreaming work any "blocker" comment should be put as "Change Requested" so that we can identified where to put our effort.
In this particular case auto can surely be removed but not everywhere like you mentioned in your comment. I think that's more the everywhere that others were against.

auto does not help readability so why not spell out the type? (here and everywhere, in all the upstreaming patches please).

[clementval]

flang/lib/Optimizer/Transforms/MemRefDataFlowOpt.cpp

30

On this particular comment, I remember what happened. I did the change and marked it as done then after discussion I revrted the change but I forgot to mention that. Sorry for that, I didn't mean to discard your comment.

[clementval]

flang/test/Fir/memref-data-flow.fir

66–67

In the initial code we have two sequences of load/store. We want to make sure only one stays. Maybe using

// Verify that all store-load pairs have been eliminated. Other stores and loads are preserved.
CHECK-COUNT-1: fir.store
CHECK-COUNT-1: fir.load

[mehdi_amini]

flang/test/Fir/memref-data-flow.fir

66–67

That would make more sense to me.

[clementval]

Update the tests to make them easier to understand.

flang/test/Fir/memref-data-flow.fir

74

We check that the fir.store/fir.load pair has been removed here (between the fir.convert ops). The next checks make sure the loads have been preserved later. I added a comment to make it clearer.

[clementval]

flang/lib/Optimizer/Transforms/MemRefDataFlowOpt.cpp

30

@mehdi_amini We had discussion with the team and they mentioned couple of points why they would like to keep auto:

• It avoids to introduce type's bugs like

auto ch = getc(file);
changed to
char ch = getc(file);
it's a small type change. The char type looks like documentation but it is actually introducing a bug that might be really hard to detect.

• Also refactoring is easier if we have type inference.

Not sure if this is addressing your comment here. If not please let us know and we can discuss further how we can best approach this since it will be a recurrent pattern in the Flang code.

[mehdi_amini]

flang/lib/Optimizer/Transforms/MemRefDataFlowOpt.cpp

30

These are very valid arguments, but they challenge the documented status quo in LLVM. As such I don't think this is something that can just be settled here in a revision.

I invite you to send an RFC (and a patch) to llvm-dev@ to update the coding standards if this is something that "the team" really believe is important to change: https://llvm.org/docs/CodingStandards.html#use-auto-type-deduction-to-make-code-more-readable

flang/test/Fir/memref-data-flow.fir

277

Wouldn't that be sufficient?

Not really: this isn't really a good way to write and design tests IMO.

Ideally I'd like the tests to look like this for example: https://github.com/llvm/llvm-project/blob/main/mlir/test/Transforms/loop-coalescing.mlir
Note how every individual case is shared in a different function, and how documented they are in what they are actually testing.

[mehdi_amini]

flang/test/Fir/memref-data-flow.fir

277

(You can browse all the tests in this directory, or in MLIR in general, they should mostly look like this or have a similar overall form. I don't think you'll find any comparable to what is here)

[mehdi_amini]

flang/lib/Optimizer/Transforms/MemRefDataFlowOpt.cpp

85

I'm also interested in what "the team" would argue here: this code is very misleading in the naming and this is mostly because of the use of auto.

[clementval]

flang/lib/Optimizer/Transforms/MemRefDataFlowOpt.cpp

85

In this case ReadOp is a template parameter so not sure it would help here. This is what I gathered from the team so if we need to discuss this in more details we can arrange something.

[mehdi_amini]

flang/lib/Optimizer/Transforms/MemRefDataFlowOpt.cpp

85

OK I totally missed that this was a template parameter in my initial comment here!

By the way there seems to be a single instantiation of the template right now? It this intended to have more?

[clementval]

flang/lib/Optimizer/Transforms/MemRefDataFlowOpt.cpp

85

I can find only a single instantiation of the template in fir-dev right now.

[clementval]

flang/lib/Optimizer/Transforms/MemRefDataFlowOpt.cpp

30

We have talked together and we do not think the main LLVM guideline should be change for that. We will update couple of autos in the upstreaming patch where it makes sense.
We will also put up for review a update on the Flang guidelines like you have for MLIR (https://mlir.llvm.org/getting_started/DeveloperGuide/#style-guide) where we can precise the auto usage. Would that work for you?

I'm gonna update this patch and the other that is under review.

[mehdi_amini]

flang/lib/Optimizer/Transforms/MemRefDataFlowOpt.cpp

30

Note that the only place where MLIR deviates from LLVM really is the camelBack aspect (the other items are just things that LLVM does not define or aren't applicable in LLVM), and that wasn't intentional to deviate from LLVM: at the time there was a push in LLVM to adopt camelBack and we used it in anticipation. Had we known that LLVM would end-up not changing, we likely would have followed LLVM convention as-is.

Looking forward to the proposal for flang, I hope it won't go agains the LLVM style guide!

[clementval]

Update auto in some non evident places

[clementval]

Updated some of the non-evident auto usage.

[schweitz]

flang/lib/Optimizer/Transforms/MemRefDataFlowOpt.cpp

30

Mehdi:

Would you help clarify direction here? Are you suggesting that you would be ok with revising the LLVM style just for the flang directories in question (just like MLIR did with respect to camelBack)? Or do you prefer that this be addressed for the entire llvm-project tree?

[mehdi_amini]

flang/lib/Optimizer/Transforms/MemRefDataFlowOpt.cpp

30

Unless there is a really good reason to, I don't think the flang directory is supposed to diverge from LLVM.
I understand the status quo (which was discussed on llvm-dev@ before deciding on integrating flang I believe) to be that we'll apply the existing LLVM coding standard (I remember that C++17 was an exception for example) and usual practices.

So I see two possible ways if you want to have flang code not follow the LLVM practices:

• renegotiate the status quo (I would go back to llvm-dev@ for this, since this is where this was agree'd upon before).
• update the LLVM-wide coding standards.

In general I rather keep consistency in the project, unless the specificities of a particular project are making a difference (for example libcxx is very constrained by the standard, the compiler-rt have "embedded" constraints, MLIR python bindings need exception handling, etc.)

[awarzynski]

flang/lib/Optimizer/Transforms/MemRefDataFlowOpt.cpp

30

I believe that this is the most recent discussion on the usage of auto on llvm-dev: https://lists.llvm.org/pipermail/llvm-dev/2018-November/127953.html. Based on that, an update to the LLVM-wide coding standards is likely to be a hard sell.

Perhaps the focus should be on "why" would Flang benefit from a bit more liberal approach here?

[clementval]

flang/lib/Optimizer/Transforms/MemRefDataFlowOpt.cpp

30

Once again, I don't think we do not follow the LLVM guidelines with auto. We have eased our stance here by updating auto where requested and we will do so future patches as well.
I don't think Eric is proposing a divergence from the guidelines at all but rather a clarification for Flang for a guideline that is subject to interpretation.

[schweitz]

flang/lib/Optimizer/Transforms/MemRefDataFlowOpt.cpp

30

This concerns a very limited, narrow scope: local variable declarations with initialization expressions. The phrase "already obvious" in the coding conventions is ambiguous, an invitation to disagreement.

The use of auto allows the compiler to perform type inferencing on variables, resulting in the following benefits:

• Extremely long and complicated type names are not used, which is less error-prone and greatly improves understandability.
• The clutter from repetitive namespace tags is removed.
• Explicitly declared types can and do introduce hard-to-find bugs from unexpected or incorrect truncations, extensions, and other conversions.
• Using auto instead of declared types simplifies refactoring when interfaces are rapidly evolving.
• auto can be required when writing some templatized code.

[mehdi_amini]

flang/lib/Optimizer/Transforms/MemRefDataFlowOpt.cpp

30

Right, what you write here seems reasonable. But you have to see how it plays in practice, and the 2 answers in the thread above are a good reference.

Also, if we come back at that case at hand here:

for (auto *user : v.getUsers())

vs

for (mlir::Operation *user : v.getUsers())

I don't think this is an "Extremely long and complicated type name" case, the namespace is annoying, what I'm doing in every project downstream (like TensorFlow) is to have a namespace inside the mlir namespace (mlir::tensorflow::). If your code is implemented inside this namespace, you remove all of the prefixes.

Explicitly declared types can and do introduce hard-to-find bugs from unexpected or incorrect truncations, extensions, and other conversions.

It's be great to have a very clear guideline on the kind of API that is subject to these problems, any reference by the way?

Using auto instead of declared types simplifies refactoring when interfaces are rapidly evolving.

Yes, but this is also a double-edged sword (code may compile when you wouldn't expect it possibly). Also, this isn't a rapidly evolving API here.

For this particular getUsers() API, it isn't defined in this file, so I wouldn't say that the context is obvious here to just know the type: having to lookup an API on another class isn't the current context to me.
And in this particular example it is worse because there is a very close API: v.getUses() (it differs by one letter!).
From experience, this users/uses is also a frequent source of confusion for users.

[clementval]

flang/lib/Optimizer/Transforms/MemRefDataFlowOpt.cpp

30

for (auto *user : v.getUsers())

Is a good example where we changed to

for (mlir::Operation *user : v.getUsers())

as requested.

[clementval]

This patch was on hold because of th auto discussion. I think we have solved this and we are aligned with the guidelines now. I'll wait until tomorrow and land it.

[mehdi_amini]

The test is still not really in a satisfying shape, could you rework this?

[clementval]

In D111288#3140668, @mehdi_amini wrote:

The test is still not really in a satisfying shape, could you rework this?

We trimmed the checks to a minimum and added explanatory comments. What else do you want to be changed?

[mehdi_amini]

flang/test/Fir/memref-data-flow.fir

83

What kind of pattern this function is exercising that isn't exercised by other tests?

I don't know what forward_store0 is covering compared to forward_store1...

(same question for forward_store2, forward_store3...)

156

This sequence of checks is fairly obscure to me.

(same below)

[clementval]

@mehdi_amini Ok we will work on that.

[clementval]

Remove tests checking similar behavior. Add comment in checks.

flang/include/flang/Optimizer/Transforms/Passes.h

 // Passes defined in Passes.td
 //===----------------------------------------------------------------------===//
 
 std::unique_ptr<mlir::Pass> createAbstractResultOptPass();
 std::unique_ptr<mlir::Pass> createAffineDemotionPass();
 std::unique_ptr<mlir::Pass> createFirToCfgPass();
 std::unique_ptr<mlir::Pass> createCharacterConversionPass();
 std::unique_ptr<mlir::Pass> createExternalNameConversionPass();
+std::unique_ptr<mlir::Pass> createMemDataFlowOptPass();
 std::unique_ptr<mlir::Pass> createPromoteToAffinePass();
 
 /// Support for inlining on FIR.
 bool canLegallyInline(mlir::Operation *op, mlir::Region *reg,
                       mlir::BlockAndValueMapping &map);
 
 // declarative passes
 #define GEN_PASS_REGISTRATION
 #include "flang/Optimizer/Transforms/Passes.h.inc"
 
 } // namespace fir
 
 #endif // OPTIMIZER_TRANSFORMS_PASSES_H

flang/include/flang/Optimizer/Transforms/Passes.td

 def ExternalNameConversion : Pass<"external-name-interop", "mlir::ModuleOp"> {
   let summary = "Convert name for external interoperability";
   let description = [{
     Demangle FIR internal name and mangle them for external interoperability.
   }];
   let constructor = "::fir::createExternalNameConversionPass()";
 }
 
+def MemRefDataFlowOpt : FunctionPass<"fir-memref-dataflow-opt"> {
+  let summary =
+    "Perform store/load forwarding and potentially removing dead stores.";
+  let description = [{
+    This pass performs store to load forwarding to eliminate memory accesses and
+    potentially the entire allocation if all the accesses are forwarded.
+  }];
+  let constructor = "::fir::createMemDataFlowOptPass()";
+  let dependentDialects = [
+    "fir::FIROpsDialect", "mlir::StandardOpsDialect"
+  ];
+}
+
 #endif // FLANG_OPTIMIZER_TRANSFORMS_PASSES

flang/lib/Optimizer/Transforms/CMakeLists.txt

 add_flang_library(FIRTransforms
   AbstractResult.cpp
   AffinePromotion.cpp
   AffineDemotion.cpp
   CharacterConversion.cpp
   Inliner.cpp
   ExternalNameConversion.cpp
+  MemRefDataFlowOpt.cpp
   RewriteLoop.cpp
 
   DEPENDS
   FIRDialect
   FIRSupport
   FIROptTransformsPassIncGen
   RewritePatternsIncGen
 
   LINK_LIBS
   FIRDialect
   MLIRAffineToStandard
   MLIRLLVMIR
   MLIROpenACC
   MLIROpenMP
   FIRSupport
 )

flang/lib/Optimizer/Transforms/MemRefDataFlowOpt.cpp

+//===- MemRefDataFlowOpt.cpp - Memory DataFlow Optimization pass ----------===//
+//
+// 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 "PassDetail.h"
+#include "flang/Optimizer/Dialect/FIRDialect.h"
+#include "flang/Optimizer/Dialect/FIROps.h"
+#include "flang/Optimizer/Dialect/FIRType.h"
+#include "flang/Optimizer/Transforms/Passes.h"
+#include "mlir/Dialect/StandardOps/IR/Ops.h"
+#include "mlir/IR/Dominance.h"
+#include "mlir/IR/Operation.h"
+#include "mlir/Transforms/Passes.h"
+#include "llvm/ADT/Optional.h"
+#include "llvm/ADT/STLExtras.h"
+#include "llvm/ADT/SmallVector.h"
+
+#define DEBUG_TYPE "fir-memref-dataflow-opt"
+
+namespace {
+
+template <typename OpT>
+static std::vector<OpT> getSpecificUsers(mlir::Value v) {
+  std::vector<OpT> ops;
+  for (auto *user : v.getUsers())
+    if (auto op = dyn_cast<OpT>(user))
+      ops.push_back(op);
+  return ops;
+}
+
+/// This is based on MLIR's MemRefDataFlowOpt which is specialized on AffineRead
+/// and AffineWrite interface
+template <typename ReadOp, typename WriteOp>
+class LoadStoreForwarding {
+public:
+  LoadStoreForwarding(mlir::DominanceInfo *di) : domInfo(di) {}
+
+  // FIXME: This algorithm has a bug. It ignores escaping references between a
+  // store and a load.
+  llvm::Optional<WriteOp> findStoreToForward(ReadOp loadOp,
+                                             std::vector<WriteOp> &&storeOps) {
+    llvm::SmallVector<WriteOp> candidateSet;
+
+    for (auto storeOp : storeOps)
+      if (domInfo->dominates(storeOp, loadOp))
+        candidateSet.push_back(storeOp);
+
+    if (candidateSet.empty())
+      return {};
+
+    llvm::Optional<WriteOp> nearestStore;
+    for (auto candidate : candidateSet) {
+      auto nearerThan = [&](WriteOp otherStore) {
+        if (candidate == otherStore)
+          return false;
+        auto rv = domInfo->properlyDominates(candidate, otherStore);
+        if (rv) {
+          LLVM_DEBUG(llvm::dbgs()
+                     << "candidate " << candidate << " is not the nearest to "
+                     << loadOp << " because " << otherStore << " is closer\n");
+        }
+        return rv;
+      };
+      if (!llvm::any_of(candidateSet, nearerThan)) {
+        nearestStore = mlir::cast<WriteOp>(candidate);
+        break;
+      }
+    }
+    if (!nearestStore) {
+      LLVM_DEBUG(
+          llvm::dbgs()
+          << "load " << loadOp << " has " << candidateSet.size()
+          << " store candidates, but this algorithm can't find a best.\n");
+    }
+    return nearestStore;
+  }
+
+  llvm::Optional<ReadOp> findReadForWrite(WriteOp storeOp,
+                                          std::vector<ReadOp> &&loadOps) {
+    for (auto &loadOp : loadOps) {
+      if (domInfo->dominates(storeOp, loadOp))
+        return loadOp;
+    }
+    return {};
+  }
+
+private:
+  mlir::DominanceInfo *domInfo;
+};
+
+class MemDataFlowOpt : public fir::MemRefDataFlowOptBase<MemDataFlowOpt> {
+public:
+  void runOnFunction() override {
+    mlir::FuncOp f = getFunction();
+
+    auto *domInfo = &getAnalysis<mlir::DominanceInfo>();
+    LoadStoreForwarding<fir::LoadOp, fir::StoreOp> lsf(domInfo);
+    f.walk([&](fir::LoadOp loadOp) {
+      auto maybeStore = lsf.findStoreToForward(
+          loadOp, getSpecificUsers<fir::StoreOp>(loadOp.memref()));
+      if (maybeStore) {
+        auto storeOp = maybeStore.getValue();
+        LLVM_DEBUG(llvm::dbgs() << "FlangMemDataFlowOpt: In " << f.getName()
+                                << " erasing load " << loadOp
+                                << " with value from " << storeOp << '\n');
+        loadOp.getResult().replaceAllUsesWith(storeOp.value());
+        loadOp.erase();
+      }
+    });
+    f.walk([&](fir::AllocaOp alloca) {
+      for (auto &storeOp : getSpecificUsers<fir::StoreOp>(alloca.getResult())) {
+        if (!lsf.findReadForWrite(
+                storeOp, getSpecificUsers<fir::LoadOp>(storeOp.memref()))) {
+          LLVM_DEBUG(llvm::dbgs() << "FlangMemDataFlowOpt: In " << f.getName()
+                                  << " erasing store " << storeOp << '\n');
+          storeOp.erase();
+        }
+      }
+    });
+  }
+};
+} // namespace
+
+std::unique_ptr<mlir::Pass> fir::createMemDataFlowOptPass() {
+  return std::make_unique<MemDataFlowOpt>();
+}

flang/test/Fir/memref-data-flow.fir

+// RUN: fir-opt --split-input-file --fir-memref-dataflow-opt %s | FileCheck %s
+
+func @_QPf1dc(%arg0: !fir.ref<!fir.array<60xi32>>, %arg1: !fir.ref<!fir.array<60xi32>>, %arg2: !fir.ref<!fir.array<60xi32>>) {
+  %c1_i64 = arith.constant 1 : i64
+  %c60 = arith.constant 60 : index
+  %c0 = arith.constant 0 : index
+  %c1 = arith.constant 1 : index
+  %0 = fir.alloca i32 {bindc_name = "i", uniq_name = "_QFf1dcEi"}
+  %1 = fir.alloca !fir.array<60xi32> {bindc_name = "t1", uniq_name = "_QFf1dcEt1"}
+  br ^bb1(%c1, %c60 : index, index)
+^bb1(%2: index, %3: index):  // 2 preds: ^bb0, ^bb2
+  %4 = arith.cmpi sgt, %3, %c0 : index
+  cond_br %4, ^bb2, ^bb3
+^bb2:  // pred: ^bb1
+  %5 = fir.convert %2 : (index) -> i32
+  fir.store %5 to %0 : !fir.ref<i32>
+  %6 = fir.load %0 : !fir.ref<i32>
+  %7 = fir.convert %6 : (i32) -> i64
+  %8 = arith.subi %7, %c1_i64 : i64
+  %9 = fir.coordinate_of %arg0, %8 : (!fir.ref<!fir.array<60xi32>>, i64) -> !fir.ref<i32>
+  %10 = fir.load %9 : !fir.ref<i32>
+  %11 = arith.addi %10, %10 : i32
+  %12 = fir.coordinate_of %1, %8 : (!fir.ref<!fir.array<60xi32>>, i64) -> !fir.ref<i32>
+  fir.store %11 to %12 : !fir.ref<i32>
+  %13 = arith.addi %2, %c1 : index
+  %14 = arith.subi %3, %c1 : index
+  br ^bb1(%13, %14 : index, index)
+^bb3:  // pred: ^bb1
+  %15 = fir.convert %2 : (index) -> i32
+  fir.store %15 to %0 : !fir.ref<i32>
+  br ^bb4(%c1, %c60 : index, index)
+^bb4(%16: index, %17: index):  // 2 preds: ^bb3, ^bb5
+  %18 = arith.cmpi sgt, %17, %c0 : index
+  cond_br %18, ^bb5, ^bb6
+^bb5:  // pred: ^bb4
+  %19 = fir.convert %16 : (index) -> i32
+  fir.store %19 to %0 : !fir.ref<i32>
+  %20 = fir.load %0 : !fir.ref<i32>
+  %21 = fir.convert %20 : (i32) -> i64
+  %22 = arith.subi %21, %c1_i64 : i64
+  %23 = fir.coordinate_of %1, %22 : (!fir.ref<!fir.array<60xi32>>, i64) -> !fir.ref<i32>
+  %24 = fir.load %23 : !fir.ref<i32>
+  %25 = fir.coordinate_of %arg1, %22 : (!fir.ref<!fir.array<60xi32>>, i64) -> !fir.ref<i32>
+  %26 = fir.load %25 : !fir.ref<i32>
+  %27 = arith.muli %24, %26 : i32
+  %28 = fir.coordinate_of %arg2, %22 : (!fir.ref<!fir.array<60xi32>>, i64) -> !fir.ref<i32>
+  fir.store %27 to %28 : !fir.ref<i32>
+  %29 = arith.addi %16, %c1 : index
+  %30 = arith.subi %17, %c1 : index
+  br ^bb4(%29, %30 : index, index)
+^bb6:  // pred: ^bb4
+  %31 = fir.convert %16 : (index) -> i32
+  fir.store %31 to %0 : !fir.ref<i32>
+  return
+}
+
+// CHECK:   func @_QPf1dc(%[[VAL_0:.*]]: !fir.ref<!fir.array<60xi32>>, %[[VAL_1:.*]]: !fir.ref<!fir.array<60xi32>>, %[[VAL_2:.*]]: !fir.ref<!fir.array<60xi32>>) {
+// CHECK:    %[[VAL_3:.*]] = arith.constant 1 : i64
+// CHECK:    %[[VAL_4:.*]] = arith.constant 60 : index
+// CHECK:    %[[VAL_5:.*]] = arith.constant 0 : index
+// CHECK:    %[[VAL_6:.*]] = arith.constant 1 : index
+// CHECK:    %[[VAL_7:.*]] = fir.alloca i32 {bindc_name = "i", uniq_name = "_QFf1dcEi"}
+// CHECK:    %[[VAL_8:.*]] = fir.alloca !fir.array<60xi32> {bindc_name = "t1", uniq_name = "_QFf1dcEt1"}
+// CHECK:    br ^bb1(%[[VAL_6]], %[[VAL_4]] : index, index)
+// CHECK:  ^bb1(%[[VAL_9:.*]]: index, %[[VAL_10:.*]]: index):
+// CHECK:    %[[VAL_11:.*]] = arith.cmpi sgt, %[[VAL_10]], %[[VAL_5]] : index
+// CHECK:    cond_br %[[VAL_11]], ^bb2, ^bb3
+// CHECK:  ^bb2:
+// CHECK:    %[[VAL_12:.*]] = fir.convert %[[VAL_9]] : (index) -> i32
+// CHECK:    %[[VAL_13:.*]] = fir.convert %[[VAL_12]] : (i32) -> i64
+// CHECK:    %[[VAL_14:.*]] = arith.subi %[[VAL_13]], %[[VAL_3]] : i64
+// CHECK:    %[[VAL_15:.*]] = fir.coordinate_of %[[VAL_0]], %[[VAL_14]] : (!fir.ref<!fir.array<60xi32>>, i64) -> !fir.ref<i32>
+// CHECK:    %[[VAL_16:.*]] = fir.load %[[VAL_15]] : !fir.ref<i32>
+// CHECK:    %[[VAL_17:.*]] = arith.addi %[[VAL_16]], %[[VAL_16]] : i32
+// CHECK:    %[[VAL_18:.*]] = fir.coordinate_of %[[VAL_8]], %[[VAL_14]] : (!fir.ref<!fir.array<60xi32>>, i64) -> !fir.ref<i32>
+// CHECK:    fir.store %[[VAL_17]] to %[[VAL_18]] : !fir.ref<i32>
+// CHECK:    %[[VAL_19:.*]] = arith.addi %[[VAL_9]], %[[VAL_6]] : index
+// CHECK:    %[[VAL_20:.*]] = arith.subi %[[VAL_10]], %[[VAL_6]] : index
+// CHECK:    br ^bb1(%[[VAL_19]], %[[VAL_20]] : index, index)
+// CHECK:  ^bb3:
+// CHECK:    %[[VAL_21:.*]] = fir.convert %[[VAL_9]] : (index) -> i32
+// CHECK:    br ^bb4(%[[VAL_6]], %[[VAL_4]] : index, index)
+// CHECK:  ^bb4(%[[VAL_22:.*]]: index, %[[VAL_23:.*]]: index):
+// CHECK:    %[[VAL_24:.*]] = arith.cmpi sgt, %[[VAL_23]], %[[VAL_5]] : index
+// CHECK:    cond_br %[[VAL_24]], ^bb5, ^bb6
+// CHECK:  ^bb5:
+// CHECK:    %[[VAL_25:.*]] = fir.convert %[[VAL_22]] : (index) -> i32
+// CHECK:    %[[VAL_26:.*]] = fir.convert %[[VAL_25]] : (i32) -> i64
+// CHECK:    %[[VAL_27:.*]] = arith.subi %[[VAL_26]], %[[VAL_3]] : i64
+// CHECK:    %[[VAL_28:.*]] = fir.coordinate_of %[[VAL_8]], %[[VAL_27]] : (!fir.ref<!fir.array<60xi32>>, i64) -> !fir.ref<i32>
+// CHECK:    %[[VAL_29:.*]] = fir.load %[[VAL_28]] : !fir.ref<i32>
+// CHECK:    %[[VAL_30:.*]] = fir.coordinate_of %[[VAL_1]], %[[VAL_27]] : (!fir.ref<!fir.array<60xi32>>, i64) -> !fir.ref<i32>
+// CHECK:    %[[VAL_31:.*]] = fir.load %[[VAL_30]] : !fir.ref<i32>
+// CHECK:    %[[VAL_32:.*]] = arith.muli %[[VAL_29]], %[[VAL_31]] : i32
+// CHECK:    %[[VAL_33:.*]] = fir.coordinate_of %[[VAL_2]], %[[VAL_27]] : (!fir.ref<!fir.array<60xi32>>, i64) -> !fir.ref<i32>
+// CHECK:    fir.store %[[VAL_32]] to %[[VAL_33]] : !fir.ref<i32>
+// CHECK:    %[[VAL_34:.*]] = arith.addi %[[VAL_22]], %[[VAL_6]] : index
+// CHECK:    %[[VAL_35:.*]] = arith.subi %[[VAL_23]], %[[VAL_6]] : index
+// CHECK:    br ^bb4(%[[VAL_34]], %[[VAL_35]] : index, index)
+// CHECK:  ^bb6:
+// CHECK:    %[[VAL_36:.*]] = fir.convert %[[VAL_22]] : (index) -> i32
+// CHECK:    return
+// CHECK:  }
+
+// -----
+
+func @_QPf1dv(%arg0: !fir.ref<!fir.array<?xi32>>, %arg1: !fir.ref<!fir.array<?xi32>>, %arg2: !fir.ref<!fir.array<?xi32>>, %arg3: !fir.ref<i32>) {
+  %c1_i64 = arith.constant 1 : i64
+  %c0 = arith.constant 0 : index
+  %c1 = arith.constant 1 : index
+  %0 = fir.alloca i32 {bindc_name = "i", uniq_name = "_QFf1dvEi"}
+  %1 = fir.load %arg3 : !fir.ref<i32>
+  %2 = fir.convert %1 : (i32) -> index
+  %3 = fir.alloca !fir.array<?xi32>, %2 {bindc_name = "t1", uniq_name = "_QFf1dvEt1"}
+  br ^bb1(%c1, %2 : index, index)
+^bb1(%4: index, %5: index):  // 2 preds: ^bb0, ^bb2
+  %6 = arith.cmpi sgt, %5, %c0 : index
+  cond_br %6, ^bb2, ^bb3
+^bb2:  // pred: ^bb1
+  %7 = fir.convert %4 : (index) -> i32
+  fir.store %7 to %0 : !fir.ref<i32>
+  %8 = fir.load %0 : !fir.ref<i32>
+  %9 = fir.convert %8 : (i32) -> i64
+  %10 = arith.subi %9, %c1_i64 : i64
+  %11 = fir.coordinate_of %arg0, %10 : (!fir.ref<!fir.array<?xi32>>, i64) -> !fir.ref<i32>
+  %12 = fir.load %11 : !fir.ref<i32>
+  %13 = arith.addi %12, %12 : i32
+  %14 = fir.coordinate_of %3, %10 : (!fir.ref<!fir.array<?xi32>>, i64) -> !fir.ref<i32>
+  fir.store %13 to %14 : !fir.ref<i32>
+  %15 = arith.addi %4, %c1 : index
+  %16 = arith.subi %5, %c1 : index
+  br ^bb1(%15, %16 : index, index)
+^bb3:  // pred: ^bb1
+  %17 = fir.convert %4 : (index) -> i32
+  fir.store %17 to %0 : !fir.ref<i32>
+  %18 = fir.load %arg3 : !fir.ref<i32>
+  %19 = fir.convert %18 : (i32) -> index
+  br ^bb4(%c1, %19 : index, index)
+^bb4(%20: index, %21: index):  // 2 preds: ^bb3, ^bb5
+  %22 = arith.cmpi sgt, %21, %c0 : index
+  cond_br %22, ^bb5, ^bb6
+^bb5:  // pred: ^bb4
+  %23 = fir.convert %20 : (index) -> i32
+  fir.store %23 to %0 : !fir.ref<i32>
+  %24 = fir.load %0 : !fir.ref<i32>
+  %25 = fir.convert %24 : (i32) -> i64
+  %26 = arith.subi %25, %c1_i64 : i64
+  %27 = fir.coordinate_of %3, %26 : (!fir.ref<!fir.array<?xi32>>, i64) -> !fir.ref<i32>
+  %28 = fir.load %27 : !fir.ref<i32>
+  %29 = fir.coordinate_of %arg1, %26 : (!fir.ref<!fir.array<?xi32>>, i64) -> !fir.ref<i32>
+  %30 = fir.load %29 : !fir.ref<i32>
+  %31 = arith.muli %28, %30 : i32
+  %32 = fir.coordinate_of %arg2, %26 : (!fir.ref<!fir.array<?xi32>>, i64) -> !fir.ref<i32>
+  fir.store %31 to %32 : !fir.ref<i32>
+  %33 = arith.addi %20, %c1 : index
+  %34 = arith.subi %21, %c1 : index
+  br ^bb4(%33, %34 : index, index)
+^bb6:  // pred: ^bb4
+  %35 = fir.convert %20 : (index) -> i32
+  fir.store %35 to %0 : !fir.ref<i32>
+  return
+}
+
+// CHECK:   func @_QPf1dv(%[[VAL_0:.*]]: !fir.ref<!fir.array<?xi32>>, %[[VAL_1:.*]]: !fir.ref<!fir.array<?xi32>>, %[[VAL_2:.*]]: !fir.ref<!fir.array<?xi32>>, %[[VAL_3:.*]]: !fir.ref<i32>) {
+// CHECK:    %[[VAL_4:.*]] = arith.constant 1 : i64
+// CHECK:    %[[VAL_5:.*]] = arith.constant 0 : index
+// CHECK:    %[[VAL_6:.*]] = arith.constant 1 : index
+// CHECK:    %[[VAL_7:.*]] = fir.alloca i32 {bindc_name = "i", uniq_name = "_QFf1dvEi"}
+// CHECK:    %[[VAL_8:.*]] = fir.load %[[VAL_3]] : !fir.ref<i32>
+// CHECK:    %[[VAL_9:.*]] = fir.convert %[[VAL_8]] : (i32) -> index
+// CHECK:    %[[VAL_10:.*]] = fir.alloca !fir.array<?xi32>, %[[VAL_9]] {bindc_name = "t1", uniq_name = "_QFf1dvEt1"}
+// CHECK:    br ^bb1(%[[VAL_6]], %[[VAL_9]] : index, index)
+// CHECK:  ^bb1(%[[VAL_11:.*]]: index, %[[VAL_12:.*]]: index):
+// CHECK:    %[[VAL_13:.*]] = arith.cmpi sgt, %[[VAL_12]], %[[VAL_5]] : index
+// CHECK:    cond_br %[[VAL_13]], ^bb2, ^bb3
+// CHECK:  ^bb2:
+// CHECK:    %[[VAL_14:.*]] = fir.convert %[[VAL_11]] : (index) -> i32
+// CHECK:    %[[VAL_15:.*]] = fir.convert %[[VAL_14]] : (i32) -> i64
+// CHECK:    %[[VAL_16:.*]] = arith.subi %[[VAL_15]], %[[VAL_4]] : i64
+// CHECK:    %[[VAL_17:.*]] = fir.coordinate_of %[[VAL_0]], %[[VAL_16]] : (!fir.ref<!fir.array<?xi32>>, i64) -> !fir.ref<i32>
+// CHECK:    %[[VAL_18:.*]] = fir.load %[[VAL_17]] : !fir.ref<i32>
+// CHECK:    %[[VAL_19:.*]] = arith.addi %[[VAL_18]], %[[VAL_18]] : i32
+// CHECK:    %[[VAL_20:.*]] = fir.coordinate_of %[[VAL_10]], %[[VAL_16]] : (!fir.ref<!fir.array<?xi32>>, i64) -> !fir.ref<i32>
+// CHECK:    fir.store %[[VAL_19]] to %[[VAL_20]] : !fir.ref<i32>
+// CHECK:    %[[VAL_21:.*]] = arith.addi %[[VAL_11]], %[[VAL_6]] : index
+// CHECK:    %[[VAL_22:.*]] = arith.subi %[[VAL_12]], %[[VAL_6]] : index
+// CHECK:    br ^bb1(%[[VAL_21]], %[[VAL_22]] : index, index)
+// CHECK:  ^bb3:
+// CHECK:    %[[VAL_23:.*]] = fir.convert %[[VAL_11]] : (index) -> i32
+// CHECK:    %[[VAL_24:.*]] = fir.load %[[VAL_3]] : !fir.ref<i32>
+// CHECK:    %[[VAL_25:.*]] = fir.convert %[[VAL_24]] : (i32) -> index
+// CHECK:    br ^bb4(%[[VAL_6]], %[[VAL_25]] : index, index)
+// CHECK:  ^bb4(%[[VAL_26:.*]]: index, %[[VAL_27:.*]]: index):
+// CHECK:    %[[VAL_28:.*]] = arith.cmpi sgt, %[[VAL_27]], %[[VAL_5]] : index
+// CHECK:    cond_br %[[VAL_28]], ^bb5, ^bb6
+// CHECK:  ^bb5:
+// CHECK:    %[[VAL_29:.*]] = fir.convert %[[VAL_26]] : (index) -> i32
+// CHECK:    %[[VAL_30:.*]] = fir.convert %[[VAL_29]] : (i32) -> i64
+// CHECK:    %[[VAL_31:.*]] = arith.subi %[[VAL_30]], %[[VAL_4]] : i64
+// CHECK:    %[[VAL_32:.*]] = fir.coordinate_of %[[VAL_10]], %[[VAL_31]] : (!fir.ref<!fir.array<?xi32>>, i64) -> !fir.ref<i32>
+// CHECK:    %[[VAL_33:.*]] = fir.load %[[VAL_32]] : !fir.ref<i32>
+// CHECK:    %[[VAL_34:.*]] = fir.coordinate_of %[[VAL_1]], %[[VAL_31]] : (!fir.ref<!fir.array<?xi32>>, i64) -> !fir.ref<i32>
+// CHECK:    %[[VAL_35:.*]] = fir.load %[[VAL_34]] : !fir.ref<i32>
+// CHECK:    %[[VAL_36:.*]] = arith.muli %[[VAL_33]], %[[VAL_35]] : i32
+// CHECK:    %[[VAL_37:.*]] = fir.coordinate_of %[[VAL_2]], %[[VAL_31]] : (!fir.ref<!fir.array<?xi32>>, i64) -> !fir.ref<i32>
+// CHECK:    fir.store %[[VAL_36]] to %[[VAL_37]] : !fir.ref<i32>
+// CHECK:    %[[VAL_38:.*]] = arith.addi %[[VAL_26]], %[[VAL_6]] : index
+// CHECK:    %[[VAL_39:.*]] = arith.subi %[[VAL_27]], %[[VAL_6]] : index
+// CHECK:    br ^bb4(%[[VAL_38]], %[[VAL_39]] : index, index)
+// CHECK:  ^bb6:
+// CHECK:    %[[VAL_40:.*]] = fir.convert %[[VAL_26]] : (index) -> i32
+// CHECK:    return
+// CHECK:  }
+
+// -----
+
+func @_QPf2dc(%arg0: !fir.ref<!fir.array<3x3xi32>>, %arg1: !fir.ref<!fir.array<3x3xi32>>, %arg2: !fir.ref<!fir.array<3x3xi32>>) {
+  %c100_i32 = arith.constant 100 : i32
+  %c10000_i32 = arith.constant 10000 : i32
+  %c1_i64 = arith.constant 1 : i64
+  %c3 = arith.constant 3 : index
+  %c0 = arith.constant 0 : index
+  %c1 = arith.constant 1 : index
+  %0 = fir.alloca i32 {bindc_name = "i", uniq_name = "_QFf2dcEi"}
+  %1 = fir.alloca i32 {bindc_name = "j", uniq_name = "_QFf2dcEj"}
+  %2 = fir.alloca !fir.array<3x3xi32> {bindc_name = "t1", uniq_name = "_QFf2dcEt1"}
+  br ^bb1(%c1, %c3 : index, index)
+^bb1(%3: index, %4: index):  // 2 preds: ^bb0, ^bb5
+  %5 = arith.cmpi sgt, %4, %c0 : index
+  cond_br %5, ^bb2, ^bb6
+^bb2:  // pred: ^bb1
+  %6 = fir.convert %3 : (index) -> i32
+  fir.store %6 to %0 : !fir.ref<i32>
+  br ^bb3(%c1, %c3 : index, index)
+^bb3(%7: index, %8: index):  // 2 preds: ^bb2, ^bb4
+  %9 = arith.cmpi sgt, %8, %c0 : index
+  cond_br %9, ^bb4, ^bb5
+^bb4:  // pred: ^bb3
+  %10 = fir.convert %7 : (index) -> i32
+  fir.store %10 to %1 : !fir.ref<i32>
+  %11 = fir.load %0 : !fir.ref<i32>
+  %12 = fir.convert %11 : (i32) -> i64
+  %13 = arith.subi %12, %c1_i64 : i64
+  %14 = fir.load %1 : !fir.ref<i32>
+  %15 = fir.convert %14 : (i32) -> i64
+  %16 = arith.subi %15, %c1_i64 : i64
+  %17 = fir.coordinate_of %arg0, %13, %16 : (!fir.ref<!fir.array<3x3xi32>>, i64, i64) -> !fir.ref<i32>
+  %18 = fir.load %17 : !fir.ref<i32>
+  %19 = fir.coordinate_of %arg0, %16, %13 : (!fir.ref<!fir.array<3x3xi32>>, i64, i64) -> !fir.ref<i32>
+  %20 = fir.load %19 : !fir.ref<i32>
+  %21 = arith.muli %20, %c100_i32 : i32
+  %22 = arith.addi %18, %21 : i32
+  %23 = fir.coordinate_of %2, %13, %16 : (!fir.ref<!fir.array<3x3xi32>>, i64, i64) -> !fir.ref<i32>
+  fir.store %22 to %23 : !fir.ref<i32>
+  %24 = arith.addi %7, %c1 : index
+  %25 = arith.subi %8, %c1 : index
+  br ^bb3(%24, %25 : index, index)
+^bb5:  // pred: ^bb3
+  %26 = fir.convert %7 : (index) -> i32
+  fir.store %26 to %1 : !fir.ref<i32>
+  %27 = arith.addi %3, %c1 : index
+  %28 = arith.subi %4, %c1 : index
+  br ^bb1(%27, %28 : index, index)
+^bb6:  // pred: ^bb1
+  %29 = fir.convert %3 : (index) -> i32
+  fir.store %29 to %0 : !fir.ref<i32>
+  br ^bb7(%c1, %c3 : index, index)
+^bb7(%30: index, %31: index):  // 2 preds: ^bb6, ^bb11
+  %32 = arith.cmpi sgt, %31, %c0 : index
+  cond_br %32, ^bb8, ^bb12
+^bb8:  // pred: ^bb7
+  %33 = fir.convert %30 : (index) -> i32
+  fir.store %33 to %0 : !fir.ref<i32>
+  br ^bb9(%c1, %c3 : index, index)
+^bb9(%34: index, %35: index):  // 2 preds: ^bb8, ^bb10
+  %36 = arith.cmpi sgt, %35, %c0 : index
+  cond_br %36, ^bb10, ^bb11
+^bb10:  // pred: ^bb9
+  %37 = fir.convert %34 : (index) -> i32
+  fir.store %37 to %1 : !fir.ref<i32>
+  %38 = fir.load %0 : !fir.ref<i32>
+  %39 = fir.convert %38 : (i32) -> i64
+  %40 = arith.subi %39, %c1_i64 : i64
+  %41 = fir.load %1 : !fir.ref<i32>
+  %42 = fir.convert %41 : (i32) -> i64
+  %43 = arith.subi %42, %c1_i64 : i64
+  %44 = fir.coordinate_of %2, %40, %43 : (!fir.ref<!fir.array<3x3xi32>>, i64, i64) -> !fir.ref<i32>
+  %45 = fir.load %44 : !fir.ref<i32>
+  %46 = fir.coordinate_of %arg1, %40, %43 : (!fir.ref<!fir.array<3x3xi32>>, i64, i64) -> !fir.ref<i32>
+  %47 = fir.load %46 : !fir.ref<i32>
+  %48 = arith.muli %47, %c10000_i32 : i32
+  %49 = arith.addi %45, %48 : i32
+  %50 = fir.coordinate_of %arg2, %40, %43 : (!fir.ref<!fir.array<3x3xi32>>, i64, i64) -> !fir.ref<i32>
+  fir.store %49 to %50 : !fir.ref<i32>
+  %51 = arith.addi %34, %c1 : index
+  %52 = arith.subi %35, %c1 : index
+  br ^bb9(%51, %52 : index, index)
+^bb11:  // pred: ^bb9
+  %53 = fir.convert %34 : (index) -> i32
+  fir.store %53 to %1 : !fir.ref<i32>
+  %54 = arith.addi %30, %c1 : index
+  %55 = arith.subi %31, %c1 : index
+  br ^bb7(%54, %55 : index, index)
+^bb12:  // pred: ^bb7
+  %56 = fir.convert %30 : (index) -> i32
+  fir.store %56 to %0 : !fir.ref<i32>
+  return
+}
+
+// CHECK:   func @_QPf2dc(%[[VAL_0:.*]]: !fir.ref<!fir.array<3x3xi32>>, %[[VAL_1:.*]]: !fir.ref<!fir.array<3x3xi32>>, %[[VAL_2:.*]]: !fir.ref<!fir.array<3x3xi32>>) {
+// CHECK:    %[[VAL_3:.*]] = arith.constant 100 : i32
+// CHECK:    %[[VAL_4:.*]] = arith.constant 10000 : i32
+// CHECK:    %[[VAL_5:.*]] = arith.constant 1 : i64
+// CHECK:    %[[VAL_6:.*]] = arith.constant 3 : index
+// CHECK:    %[[VAL_7:.*]] = arith.constant 0 : index
+// CHECK:    %[[VAL_8:.*]] = arith.constant 1 : index
+// CHECK:    %[[VAL_9:.*]] = fir.alloca i32 {bindc_name = "i", uniq_name = "_QFf2dcEi"}
+// CHECK:    %[[VAL_10:.*]] = fir.alloca i32 {bindc_name = "j", uniq_name = "_QFf2dcEj"}
+// CHECK:    %[[VAL_11:.*]] = fir.alloca !fir.array<3x3xi32> {bindc_name = "t1", uniq_name = "_QFf2dcEt1"}
+// CHECK:    br ^bb1(%[[VAL_8]], %[[VAL_6]] : index, index)
+// CHECK:  ^bb1(%[[VAL_12:.*]]: index, %[[VAL_13:.*]]: index):
+// CHECK:    %[[VAL_14:.*]] = arith.cmpi sgt, %[[VAL_13]], %[[VAL_7]] : index
+// CHECK:    cond_br %[[VAL_14]], ^bb2, ^bb6
+// CHECK:  ^bb2:
+// CHECK:    %[[VAL_15:.*]] = fir.convert %[[VAL_12]] : (index) -> i32
+// CHECK:    br ^bb3(%[[VAL_8]], %[[VAL_6]] : index, index)
+// CHECK:  ^bb3(%[[VAL_16:.*]]: index, %[[VAL_17:.*]]: index):
+// CHECK:    %[[VAL_18:.*]] = arith.cmpi sgt, %[[VAL_17]], %[[VAL_7]] : index
+// CHECK:    cond_br %[[VAL_18]], ^bb4, ^bb5
+// CHECK:  ^bb4:
+// CHECK:    %[[VAL_19:.*]] = fir.convert %[[VAL_16]] : (index) -> i32
+// CHECK:    %[[VAL_20:.*]] = fir.convert %[[VAL_15]] : (i32) -> i64
+// CHECK:    %[[VAL_21:.*]] = arith.subi %[[VAL_20]], %[[VAL_5]] : i64
+// CHECK:    %[[VAL_22:.*]] = fir.convert %[[VAL_19]] : (i32) -> i64
+// CHECK:    %[[VAL_23:.*]] = arith.subi %[[VAL_22]], %[[VAL_5]] : i64
+// CHECK:    %[[VAL_24:.*]] = fir.coordinate_of %[[VAL_0]], %[[VAL_21]], %[[VAL_23]] : (!fir.ref<!fir.array<3x3xi32>>, i64, i64) -> !fir.ref<i32>
+// CHECK:    %[[VAL_25:.*]] = fir.load %[[VAL_24]] : !fir.ref<i32>
+// CHECK:    %[[VAL_26:.*]] = fir.coordinate_of %[[VAL_0]], %[[VAL_23]], %[[VAL_21]] : (!fir.ref<!fir.array<3x3xi32>>, i64, i64) -> !fir.ref<i32>
+// CHECK:    %[[VAL_27:.*]] = fir.load %[[VAL_26]] : !fir.ref<i32>
+// CHECK:    %[[VAL_28:.*]] = arith.muli %[[VAL_27]], %[[VAL_3]] : i32
+// CHECK:    %[[VAL_29:.*]] = arith.addi %[[VAL_25]], %[[VAL_28]] : i32
+// CHECK:    %[[VAL_30:.*]] = fir.coordinate_of %[[VAL_11]], %[[VAL_21]], %[[VAL_23]] : (!fir.ref<!fir.array<3x3xi32>>, i64, i64) -> !fir.ref<i32>
+// CHECK:    fir.store %[[VAL_29]] to %[[VAL_30]] : !fir.ref<i32>
+// CHECK:    %[[VAL_31:.*]] = arith.addi %[[VAL_16]], %[[VAL_8]] : index
+// CHECK:    %[[VAL_32:.*]] = arith.subi %[[VAL_17]], %[[VAL_8]] : index
+// CHECK:    br ^bb3(%[[VAL_31]], %[[VAL_32]] : index, index)
+// CHECK:  ^bb5:
+// CHECK:    %[[VAL_33:.*]] = fir.convert %[[VAL_16]] : (index) -> i32
+// CHECK:    %[[VAL_34:.*]] = arith.addi %[[VAL_12]], %[[VAL_8]] : index
+// CHECK:    %[[VAL_35:.*]] = arith.subi %[[VAL_13]], %[[VAL_8]] : index
+// CHECK:    br ^bb1(%[[VAL_34]], %[[VAL_35]] : index, index)
+// CHECK:  ^bb6:
+// CHECK:    %[[VAL_36:.*]] = fir.convert %[[VAL_12]] : (index) -> i32
+// CHECK:    br ^bb7(%[[VAL_8]], %[[VAL_6]] : index, index)
+// CHECK:  ^bb7(%[[VAL_37:.*]]: index, %[[VAL_38:.*]]: index):
+// CHECK:    %[[VAL_39:.*]] = arith.cmpi sgt, %[[VAL_38]], %[[VAL_7]] : index
+// CHECK:    cond_br %[[VAL_39]], ^bb8, ^bb12
+// CHECK:  ^bb8:
+// CHECK:    %[[VAL_40:.*]] = fir.convert %[[VAL_37]] : (index) -> i32
+// CHECK:    br ^bb9(%[[VAL_8]], %[[VAL_6]] : index, index)
+// CHECK:  ^bb9(%[[VAL_41:.*]]: index, %[[VAL_42:.*]]: index):
+// CHECK:    %[[VAL_43:.*]] = arith.cmpi sgt, %[[VAL_42]], %[[VAL_7]] : index
+// CHECK:    cond_br %[[VAL_43]], ^bb10, ^bb11
+// CHECK:  ^bb10:
+// CHECK:    %[[VAL_44:.*]] = fir.convert %[[VAL_41]] : (index) -> i32
+// CHECK:    %[[VAL_45:.*]] = fir.convert %[[VAL_40]] : (i32) -> i64
+// CHECK:    %[[VAL_46:.*]] = arith.subi %[[VAL_45]], %[[VAL_5]] : i64
+// CHECK:    %[[VAL_47:.*]] = fir.convert %[[VAL_44]] : (i32) -> i64
+// CHECK:    %[[VAL_48:.*]] = arith.subi %[[VAL_47]], %[[VAL_5]] : i64
+// CHECK:    %[[VAL_49:.*]] = fir.coordinate_of %[[VAL_11]], %[[VAL_46]], %[[VAL_48]] : (!fir.ref<!fir.array<3x3xi32>>, i64, i64) -> !fir.ref<i32>
+// CHECK:    %[[VAL_50:.*]] = fir.load %[[VAL_49]] : !fir.ref<i32>
+// CHECK:    %[[VAL_51:.*]] = fir.coordinate_of %[[VAL_1]], %[[VAL_46]], %[[VAL_48]] : (!fir.ref<!fir.array<3x3xi32>>, i64, i64) -> !fir.ref<i32>
+// CHECK:    %[[VAL_52:.*]] = fir.load %[[VAL_51]] : !fir.ref<i32>
+// CHECK:    %[[VAL_53:.*]] = arith.muli %[[VAL_52]], %[[VAL_4]] : i32
+// CHECK:    %[[VAL_54:.*]] = arith.addi %[[VAL_50]], %[[VAL_53]] : i32
+// CHECK:    %[[VAL_55:.*]] = fir.coordinate_of %[[VAL_2]], %[[VAL_46]], %[[VAL_48]] : (!fir.ref<!fir.array<3x3xi32>>, i64, i64) -> !fir.ref<i32>
+// CHECK:    fir.store %[[VAL_54]] to %[[VAL_55]] : !fir.ref<i32>
+// CHECK:    %[[VAL_56:.*]] = arith.addi %[[VAL_41]], %[[VAL_8]] : index
+// CHECK:    %[[VAL_57:.*]] = arith.subi %[[VAL_42]], %[[VAL_8]] : index
+// CHECK:    br ^bb9(%[[VAL_56]], %[[VAL_57]] : index, index)
+// CHECK:  ^bb11:
+// CHECK:    %[[VAL_58:.*]] = fir.convert %[[VAL_41]] : (index) -> i32
+// CHECK:    %[[VAL_59:.*]] = arith.addi %[[VAL_37]], %[[VAL_8]] : index
+// CHECK:    %[[VAL_60:.*]] = arith.subi %[[VAL_38]], %[[VAL_8]] : index
+// CHECK:    br ^bb7(%[[VAL_59]], %[[VAL_60]] : index, index)
+// CHECK:  ^bb12:
+// CHECK:    %[[VAL_61:.*]] = fir.convert %[[VAL_37]] : (index) -> i32
+// CHECK:    return
+// CHECK:  }
+
+// -----
+
+func @_QPf2dv(%arg0: !fir.ref<!fir.array<?x?xi32>>, %arg1: !fir.ref<!fir.array<?x?xi32>>, %arg2: !fir.ref<!fir.array<?x?xi32>>, %arg3: !fir.ref<i32>, %arg4: !fir.ref<i32>) {
+  %c100_i32 = arith.constant 100 : i32
+  %c10000_i32 = arith.constant 10000 : i32
+  %c0 = arith.constant 0 : index
+  %c1 = arith.constant 1 : index
+  %0 = fir.alloca i32 {bindc_name = "i", uniq_name = "_QFf2dvEi"}
+  %1 = fir.alloca i32 {bindc_name = "j", uniq_name = "_QFf2dvEj"}
+  %2 = fir.alloca i32 {bindc_name = "s1e", uniq_name = "_QFf2dvEs1e"}
+  %3 = fir.alloca i32 {bindc_name = "s2e", uniq_name = "_QFf2dvEs2e"}
+  %4 = fir.load %arg3 : !fir.ref<i32>
+  %5 = fir.convert %4 : (i32) -> index
+  %6 = fir.load %arg4 : !fir.ref<i32>
+  %7 = fir.convert %6 : (i32) -> index
+  %8 = fir.alloca !fir.array<?x?xi32>, %5, %7 {bindc_name = "t", uniq_name = "_QFf2dvEt"}
+  fir.store %4 to %2 : !fir.ref<i32>
+  %9 = fir.load %arg4 : !fir.ref<i32>
+  fir.store %9 to %3 : !fir.ref<i32>
+  %10 = fir.load %2 : !fir.ref<i32>
+  %11 = fir.convert %10 : (i32) -> index
+  br ^bb1(%c1, %11 : index, index)
+^bb1(%12: index, %13: index):  // 2 preds: ^bb0, ^bb5
+  %14 = arith.cmpi sgt, %13, %c0 : index
+  cond_br %14, ^bb2, ^bb6
+^bb2:  // pred: ^bb1
+  %15 = fir.convert %12 : (index) -> i32
+  fir.store %15 to %0 : !fir.ref<i32>
+  %16 = fir.load %3 : !fir.ref<i32>
+  %17 = fir.convert %16 : (i32) -> index
+  br ^bb3(%c1, %17 : index, index)
+^bb3(%18: index, %19: index):  // 2 preds: ^bb2, ^bb4
+  %20 = arith.cmpi sgt, %19, %c0 : index
+  cond_br %20, ^bb4, ^bb5
+^bb4:  // pred: ^bb3
+  %21 = fir.convert %18 : (index) -> i32
+  fir.store %21 to %1 : !fir.ref<i32>
+  %22 = fir.convert %arg0 : (!fir.ref<!fir.array<?x?xi32>>) -> !fir.ref<!fir.array<?xi32>>
+  %23 = fir.load %0 : !fir.ref<i32>
+  %24 = fir.convert %23 : (i32) -> index
+  %25 = arith.subi %24, %c1 : index
+  %26 = fir.load %1 : !fir.ref<i32>
+  %27 = fir.convert %26 : (i32) -> index
+  %28 = arith.subi %27, %c1 : index
+  %29 = arith.muli %5, %28 : index
+  %30 = arith.addi %29, %25 : index
+  %31 = fir.coordinate_of %22, %30 : (!fir.ref<!fir.array<?xi32>>, index) -> !fir.ref<i32>
+  %32 = fir.load %31 : !fir.ref<i32>
+  %33 = arith.muli %5, %25 : index
+  %34 = arith.addi %33, %28 : index
+  %35 = fir.coordinate_of %22, %34 : (!fir.ref<!fir.array<?xi32>>, index) -> !fir.ref<i32>
+  %36 = fir.load %35 : !fir.ref<i32>
+  %37 = arith.muli %36, %c100_i32 : i32
+  %38 = arith.addi %32, %37 : i32
+  %39 = fir.convert %8 : (!fir.ref<!fir.array<?x?xi32>>) -> !fir.ref<!fir.array<?xi32>>
+  %40 = fir.coordinate_of %39, %30 : (!fir.ref<!fir.array<?xi32>>, index) -> !fir.ref<i32>
+  fir.store %38 to %40 : !fir.ref<i32>
+  %41 = arith.addi %18, %c1 : index
+  %42 = arith.subi %19, %c1 : index
+  br ^bb3(%41, %42 : index, index)
+^bb5:  // pred: ^bb3
+  %43 = fir.convert %18 : (index) -> i32
+  fir.store %43 to %1 : !fir.ref<i32>
+  %44 = arith.addi %12, %c1 : index
+  %45 = arith.subi %13, %c1 : index
+  br ^bb1(%44, %45 : index, index)
+^bb6:  // pred: ^bb1
+  %46 = fir.convert %12 : (index) -> i32
+  fir.store %46 to %0 : !fir.ref<i32>
+  %47 = fir.load %2 : !fir.ref<i32>
+  %48 = fir.convert %47 : (i32) -> index
+  br ^bb7(%c1, %48 : index, index)
+^bb7(%49: index, %50: index):  // 2 preds: ^bb6, ^bb11
+  %51 = arith.cmpi sgt, %50, %c0 : index
+  cond_br %51, ^bb8, ^bb12
+^bb8:  // pred: ^bb7
+  %52 = fir.convert %49 : (index) -> i32
+  fir.store %52 to %0 : !fir.ref<i32>
+  %53 = fir.load %3 : !fir.ref<i32>
+  %54 = fir.convert %53 : (i32) -> index
+  br ^bb9(%c1, %54 : index, index)
+^bb9(%55: index, %56: index):  // 2 preds: ^bb8, ^bb10
+  %57 = arith.cmpi sgt, %56, %c0 : index
+  cond_br %57, ^bb10, ^bb11
+^bb10:  // pred: ^bb9
+  %58 = fir.convert %55 : (index) -> i32
+  fir.store %58 to %1 : !fir.ref<i32>
+  %59 = fir.convert %8 : (!fir.ref<!fir.array<?x?xi32>>) -> !fir.ref<!fir.array<?xi32>>
+  %60 = fir.load %0 : !fir.ref<i32>
+  %61 = fir.convert %60 : (i32) -> index
+  %62 = arith.subi %61, %c1 : index
+  %63 = fir.load %1 : !fir.ref<i32>
+  %64 = fir.convert %63 : (i32) -> index
+  %65 = arith.subi %64, %c1 : index
+  %66 = arith.muli %5, %65 : index
+  %67 = arith.addi %66, %62 : index
+  %68 = fir.coordinate_of %59, %67 : (!fir.ref<!fir.array<?xi32>>, index) -> !fir.ref<i32>
+  %69 = fir.load %68 : !fir.ref<i32>
+  %70 = fir.convert %arg1 : (!fir.ref<!fir.array<?x?xi32>>) -> !fir.ref<!fir.array<?xi32>>
+  %71 = fir.coordinate_of %70, %67 : (!fir.ref<!fir.array<?xi32>>, index) -> !fir.ref<i32>
+  %72 = fir.load %71 : !fir.ref<i32>
+  %73 = arith.muli %72, %c10000_i32 : i32
+  %74 = arith.addi %69, %73 : i32
+  %75 = fir.convert %arg2 : (!fir.ref<!fir.array<?x?xi32>>) -> !fir.ref<!fir.array<?xi32>>
+  %76 = fir.coordinate_of %75, %67 : (!fir.ref<!fir.array<?xi32>>, index) -> !fir.ref<i32>
+  fir.store %74 to %76 : !fir.ref<i32>
+  %77 = arith.addi %55, %c1 : index
+  %78 = arith.subi %56, %c1 : index
+  br ^bb9(%77, %78 : index, index)
+^bb11:  // pred: ^bb9
+  %79 = fir.convert %55 : (index) -> i32
+  fir.store %79 to %1 : !fir.ref<i32>
+  %80 = arith.addi %49, %c1 : index
+  %81 = arith.subi %50, %c1 : index
+  br ^bb7(%80, %81 : index, index)
+^bb12:  // pred: ^bb7
+  %82 = fir.convert %49 : (index) -> i32
+  fir.store %82 to %0 : !fir.ref<i32>
+  return
+}
+
+// CHECK:   func @_QPf2dv(%[[VAL_0:.*]]: !fir.ref<!fir.array<?x?xi32>>, %[[VAL_1:.*]]: !fir.ref<!fir.array<?x?xi32>>, %[[VAL_2:.*]]: !fir.ref<!fir.array<?x?xi32>>, %[[VAL_3:.*]]: !fir.ref<i32>, %[[VAL_4:.*]]: !fir.ref<i32>) {
+// CHECK:    %[[VAL_5:.*]] = arith.constant 100 : i32
+// CHECK:    %[[VAL_6:.*]] = arith.constant 10000 : i32
+// CHECK:    %[[VAL_7:.*]] = arith.constant 0 : index
+// CHECK:    %[[VAL_8:.*]] = arith.constant 1 : index
+// CHECK:    %[[VAL_9:.*]] = fir.alloca i32 {bindc_name = "i", uniq_name = "_QFf2dvEi"}
+// CHECK:    %[[VAL_10:.*]] = fir.alloca i32 {bindc_name = "j", uniq_name = "_QFf2dvEj"}
+// CHECK:    %[[VAL_11:.*]] = fir.alloca i32 {bindc_name = "s1e", uniq_name = "_QFf2dvEs1e"}
+// CHECK:    %[[VAL_12:.*]] = fir.alloca i32 {bindc_name = "s2e", uniq_name = "_QFf2dvEs2e"}
+// CHECK:    %[[VAL_13:.*]] = fir.load %[[VAL_3]] : !fir.ref<i32>
+// CHECK:    %[[VAL_14:.*]] = fir.convert %[[VAL_13]] : (i32) -> index
+// CHECK:    %[[VAL_15:.*]] = fir.load %[[VAL_4]] : !fir.ref<i32>
+// CHECK:    %[[VAL_16:.*]] = fir.convert %[[VAL_15]] : (i32) -> index
+// CHECK:    %[[VAL_17:.*]] = fir.alloca !fir.array<?x?xi32>, %[[VAL_14]], %[[VAL_16]] {bindc_name = "t", uniq_name = "_QFf2dvEt"}
+// CHECK:    %[[VAL_18:.*]] = fir.load %[[VAL_4]] : !fir.ref<i32>
+// CHECK:    %[[VAL_19:.*]] = fir.convert %[[VAL_13]] : (i32) -> index
+// CHECK:    br ^bb1(%[[VAL_8]], %[[VAL_19]] : index, index)
+// CHECK:  ^bb1(%[[VAL_20:.*]]: index, %[[VAL_21:.*]]: index):
+// CHECK:    %[[VAL_22:.*]] = arith.cmpi sgt, %[[VAL_21]], %[[VAL_7]] : index
+// CHECK:    cond_br %[[VAL_22]], ^bb2, ^bb6
+// CHECK:  ^bb2:
+// CHECK:    %[[VAL_23:.*]] = fir.convert %[[VAL_20]] : (index) -> i32
+// CHECK:    %[[VAL_24:.*]] = fir.convert %[[VAL_18]] : (i32) -> index
+// CHECK:    br ^bb3(%[[VAL_8]], %[[VAL_24]] : index, index)
+// CHECK:  ^bb3(%[[VAL_25:.*]]: index, %[[VAL_26:.*]]: index):
+// CHECK:    %[[VAL_27:.*]] = arith.cmpi sgt, %[[VAL_26]], %[[VAL_7]] : index
+// CHECK:    cond_br %[[VAL_27]], ^bb4, ^bb5
+// CHECK:  ^bb4:
+// CHECK:    %[[VAL_28:.*]] = fir.convert %[[VAL_25]] : (index) -> i32
+// CHECK:    %[[VAL_29:.*]] = fir.convert %[[VAL_0]] : (!fir.ref<!fir.array<?x?xi32>>) -> !fir.ref<!fir.array<?xi32>>
+// CHECK:    %[[VAL_30:.*]] = fir.convert %[[VAL_23]] : (i32) -> index
+// CHECK:    %[[VAL_31:.*]] = arith.subi %[[VAL_30]], %[[VAL_8]] : index
+// CHECK:    %[[VAL_32:.*]] = fir.convert %[[VAL_28]] : (i32) -> index
+// CHECK:    %[[VAL_33:.*]] = arith.subi %[[VAL_32]], %[[VAL_8]] : index
+// CHECK:    %[[VAL_34:.*]] = arith.muli %[[VAL_14]], %[[VAL_33]] : index
+// CHECK:    %[[VAL_35:.*]] = arith.addi %[[VAL_34]], %[[VAL_31]] : index
+// CHECK:    %[[VAL_36:.*]] = fir.coordinate_of %[[VAL_29]], %[[VAL_35]] : (!fir.ref<!fir.array<?xi32>>, index) -> !fir.ref<i32>
+// CHECK:    %[[VAL_37:.*]] = fir.load %[[VAL_36]] : !fir.ref<i32>
+// CHECK:    %[[VAL_38:.*]] = arith.muli %[[VAL_14]], %[[VAL_31]] : index
+// CHECK:    %[[VAL_39:.*]] = arith.addi %[[VAL_38]], %[[VAL_33]] : index
+// CHECK:    %[[VAL_40:.*]] = fir.coordinate_of %[[VAL_29]], %[[VAL_39]] : (!fir.ref<!fir.array<?xi32>>, index) -> !fir.ref<i32>
+// CHECK:    %[[VAL_41:.*]] = fir.load %[[VAL_40]] : !fir.ref<i32>
+// CHECK:    %[[VAL_42:.*]] = arith.muli %[[VAL_41]], %[[VAL_5]] : i32
+// CHECK:    %[[VAL_43:.*]] = arith.addi %[[VAL_37]], %[[VAL_42]] : i32
+// CHECK:    %[[VAL_44:.*]] = fir.convert %[[VAL_17]] : (!fir.ref<!fir.array<?x?xi32>>) -> !fir.ref<!fir.array<?xi32>>
+// CHECK:    %[[VAL_45:.*]] = fir.coordinate_of %[[VAL_44]], %[[VAL_35]] : (!fir.ref<!fir.array<?xi32>>, index) -> !fir.ref<i32>
+// CHECK:    fir.store %[[VAL_43]] to %[[VAL_45]] : !fir.ref<i32>
+// CHECK:    %[[VAL_46:.*]] = arith.addi %[[VAL_25]], %[[VAL_8]] : index
+// CHECK:    %[[VAL_47:.*]] = arith.subi %[[VAL_26]], %[[VAL_8]] : index
+// CHECK:    br ^bb3(%[[VAL_46]], %[[VAL_47]] : index, index)
+// CHECK:  ^bb5:
+// CHECK:    %[[VAL_48:.*]] = fir.convert %[[VAL_25]] : (index) -> i32
+// CHECK:    %[[VAL_49:.*]] = arith.addi %[[VAL_20]], %[[VAL_8]] : index
+// CHECK:    %[[VAL_50:.*]] = arith.subi %[[VAL_21]], %[[VAL_8]] : index
+// CHECK:    br ^bb1(%[[VAL_49]], %[[VAL_50]] : index, index)
+// CHECK:  ^bb6:
+// CHECK:    %[[VAL_51:.*]] = fir.convert %[[VAL_20]] : (index) -> i32
+// CHECK:    %[[VAL_52:.*]] = fir.convert %[[VAL_13]] : (i32) -> index
+// CHECK:    br ^bb7(%[[VAL_8]], %[[VAL_52]] : index, index)
+// CHECK:  ^bb7(%[[VAL_53:.*]]: index, %[[VAL_54:.*]]: index):
+// CHECK:    %[[VAL_55:.*]] = arith.cmpi sgt, %[[VAL_54]], %[[VAL_7]] : index
+// CHECK:    cond_br %[[VAL_55]], ^bb8, ^bb12
+// CHECK:  ^bb8:
+// CHECK:    %[[VAL_56:.*]] = fir.convert %[[VAL_53]] : (index) -> i32
+// CHECK:    %[[VAL_57:.*]] = fir.convert %[[VAL_18]] : (i32) -> index
+// CHECK:    br ^bb9(%[[VAL_8]], %[[VAL_57]] : index, index)
+// CHECK:  ^bb9(%[[VAL_58:.*]]: index, %[[VAL_59:.*]]: index):
+// CHECK:    %[[VAL_60:.*]] = arith.cmpi sgt, %[[VAL_59]], %[[VAL_7]] : index
+// CHECK:    cond_br %[[VAL_60]], ^bb10, ^bb11
+// CHECK:  ^bb10:
+// CHECK:    %[[VAL_61:.*]] = fir.convert %[[VAL_58]] : (index) -> i32
+// CHECK:    %[[VAL_62:.*]] = fir.convert %[[VAL_17]] : (!fir.ref<!fir.array<?x?xi32>>) -> !fir.ref<!fir.array<?xi32>>
+// CHECK:    %[[VAL_63:.*]] = fir.convert %[[VAL_56]] : (i32) -> index
+// CHECK:    %[[VAL_64:.*]] = arith.subi %[[VAL_63]], %[[VAL_8]] : index
+// CHECK:    %[[VAL_65:.*]] = fir.convert %[[VAL_61]] : (i32) -> index
+// CHECK:    %[[VAL_66:.*]] = arith.subi %[[VAL_65]], %[[VAL_8]] : index
+// CHECK:    %[[VAL_67:.*]] = arith.muli %[[VAL_14]], %[[VAL_66]] : index
+// CHECK:    %[[VAL_68:.*]] = arith.addi %[[VAL_67]], %[[VAL_64]] : index
+// CHECK:    %[[VAL_69:.*]] = fir.coordinate_of %[[VAL_62]], %[[VAL_68]] : (!fir.ref<!fir.array<?xi32>>, index) -> !fir.ref<i32>
+// CHECK:    %[[VAL_70:.*]] = fir.load %[[VAL_69]] : !fir.ref<i32>
+// CHECK:    %[[VAL_71:.*]] = fir.convert %[[VAL_1]] : (!fir.ref<!fir.array<?x?xi32>>) -> !fir.ref<!fir.array<?xi32>>
+// CHECK:    %[[VAL_72:.*]] = fir.coordinate_of %[[VAL_71]], %[[VAL_68]] : (!fir.ref<!fir.array<?xi32>>, index) -> !fir.ref<i32>
+// CHECK:    %[[VAL_73:.*]] = fir.load %[[VAL_72]] : !fir.ref<i32>
+// CHECK:    %[[VAL_74:.*]] = arith.muli %[[VAL_73]], %[[VAL_6]] : i32
+// CHECK:    %[[VAL_75:.*]] = arith.addi %[[VAL_70]], %[[VAL_74]] : i32
+// CHECK:    %[[VAL_76:.*]] = fir.convert %[[VAL_2]] : (!fir.ref<!fir.array<?x?xi32>>) -> !fir.ref<!fir.array<?xi32>>
+// CHECK:    %[[VAL_77:.*]] = fir.coordinate_of %[[VAL_76]], %[[VAL_68]] : (!fir.ref<!fir.array<?xi32>>, index) -> !fir.ref<i32>
+// CHECK:    fir.store %[[VAL_75]] to %[[VAL_77]] : !fir.ref<i32>
+// CHECK:    %[[VAL_78:.*]] = arith.addi %[[VAL_58]], %[[VAL_8]] : index
+// CHECK:    %[[VAL_79:.*]] = arith.subi %[[VAL_59]], %[[VAL_8]] : index
+// CHECK:    br ^bb9(%[[VAL_78]], %[[VAL_79]] : index, index)
+// CHECK:  ^bb11:
+// CHECK:    %[[VAL_80:.*]] = fir.convert %[[VAL_58]] : (index) -> i32
+// CHECK:    %[[VAL_81:.*]] = arith.addi %[[VAL_53]], %[[VAL_8]] : index
+// CHECK:    %[[VAL_82:.*]] = arith.subi %[[VAL_54]], %[[VAL_8]] : index
+// CHECK:    br ^bb7(%[[VAL_81]], %[[VAL_82]] : index, index)
+// CHECK:  ^bb12:
+// CHECK:    %[[VAL_83:.*]] = fir.convert %[[VAL_53]] : (index) -> i32
+// CHECK:    return
+// CHECK:  }
+
+// -----
+
+func @_QPf3dc(%arg0: !fir.ref<!fir.array<3x3x3xi32>>, %arg1: !fir.ref<!fir.array<3x3x3xi32>>, %arg2: !fir.ref<!fir.array<3x3x3xi32>>) {
+  %c100_i32 = arith.constant 100 : i32
+  %c10000_i32 = arith.constant 10000 : i32
+  %c1_i64 = arith.constant 1 : i64
+  %c3 = arith.constant 3 : index
+  %c0 = arith.constant 0 : index
+  %c1 = arith.constant 1 : index
+  %0 = fir.alloca i32 {bindc_name = "i", uniq_name = "_QFf3dcEi"}
+  %1 = fir.alloca i32 {bindc_name = "j", uniq_name = "_QFf3dcEj"}
+  %2 = fir.alloca i32 {bindc_name = "k", uniq_name = "_QFf3dcEk"}
+  %3 = fir.alloca !fir.array<3x3x3xi32> {bindc_name = "t1", uniq_name = "_QFf3dcEt1"}
+  br ^bb1(%c1, %c3 : index, index)
+^bb1(%4: index, %5: index):  // 2 preds: ^bb0, ^bb8
+  %6 = arith.cmpi sgt, %5, %c0 : index
+  cond_br %6, ^bb2, ^bb9
+^bb2:  // pred: ^bb1
+  %7 = fir.convert %4 : (index) -> i32
+  fir.store %7 to %0 : !fir.ref<i32>
+  br ^bb3(%c1, %c3 : index, index)
+^bb3(%8: index, %9: index):  // 2 preds: ^bb2, ^bb7
+  %10 = arith.cmpi sgt, %9, %c0 : index
+  cond_br %10, ^bb4, ^bb8
+^bb4:  // pred: ^bb3
+  %11 = fir.convert %8 : (index) -> i32
+  fir.store %11 to %1 : !fir.ref<i32>
+  br ^bb5(%c1, %c3 : index, index)
+^bb5(%12: index, %13: index):  // 2 preds: ^bb4, ^bb6
+  %14 = arith.cmpi sgt, %13, %c0 : index
+  cond_br %14, ^bb6, ^bb7
+^bb6:  // pred: ^bb5
+  %15 = fir.convert %12 : (index) -> i32
+  fir.store %15 to %2 : !fir.ref<i32>
+  %16 = fir.load %0 : !fir.ref<i32>
+  %17 = fir.convert %16 : (i32) -> i64
+  %18 = arith.subi %17, %c1_i64 : i64
+  %19 = fir.load %1 : !fir.ref<i32>
+  %20 = fir.convert %19 : (i32) -> i64
+  %21 = arith.subi %20, %c1_i64 : i64
+  %22 = fir.load %2 : !fir.ref<i32>
+  %23 = fir.convert %22 : (i32) -> i64
+  %24 = arith.subi %23, %c1_i64 : i64
+  %25 = fir.coordinate_of %arg0, %18, %21, %24 : (!fir.ref<!fir.array<3x3x3xi32>>, i64, i64, i64) -> !fir.ref<i32>
+  %26 = fir.load %25 : !fir.ref<i32>
+  %27 = fir.coordinate_of %arg0, %24, %21, %18 : (!fir.ref<!fir.array<3x3x3xi32>>, i64, i64, i64) -> !fir.ref<i32>
+  %28 = fir.load %27 : !fir.ref<i32>
+  %29 = arith.muli %28, %c100_i32 : i32
+  %30 = arith.addi %26, %29 : i32
+  %31 = fir.coordinate_of %3, %18, %21, %24 : (!fir.ref<!fir.array<3x3x3xi32>>, i64, i64, i64) -> !fir.ref<i32>
+  fir.store %30 to %31 : !fir.ref<i32>
+  %32 = arith.addi %12, %c1 : index
+  %33 = arith.subi %13, %c1 : index
+  br ^bb5(%32, %33 : index, index)
+^bb7:  // pred: ^bb5
+  %34 = fir.convert %12 : (index) -> i32
+  fir.store %34 to %2 : !fir.ref<i32>
+  %35 = arith.addi %8, %c1 : index
+  %36 = arith.subi %9, %c1 : index
+  br ^bb3(%35, %36 : index, index)
+^bb8:  // pred: ^bb3
+  %37 = fir.convert %8 : (index) -> i32
+  fir.store %37 to %1 : !fir.ref<i32>
+  %38 = arith.addi %4, %c1 : index
+  %39 = arith.subi %5, %c1 : index
+  br ^bb1(%38, %39 : index, index)
+^bb9:  // pred: ^bb1
+  %40 = fir.convert %4 : (index) -> i32
+  fir.store %40 to %0 : !fir.ref<i32>
+  br ^bb10(%c1, %c3 : index, index)
+^bb10(%41: index, %42: index):  // 2 preds: ^bb9, ^bb17
+  %43 = arith.cmpi sgt, %42, %c0 : index
+  cond_br %43, ^bb11, ^bb18
+^bb11:  // pred: ^bb10
+  %44 = fir.convert %41 : (index) -> i32
+  fir.store %44 to %0 : !fir.ref<i32>
+  br ^bb12(%c1, %c3 : index, index)
+^bb12(%45: index, %46: index):  // 2 preds: ^bb11, ^bb16
+  %47 = arith.cmpi sgt, %46, %c0 : index
+  cond_br %47, ^bb13, ^bb17
+^bb13:  // pred: ^bb12
+  %48 = fir.convert %45 : (index) -> i32
+  fir.store %48 to %1 : !fir.ref<i32>
+  br ^bb14(%c1, %c3 : index, index)
+^bb14(%49: index, %50: index):  // 2 preds: ^bb13, ^bb15
+  %51 = arith.cmpi sgt, %50, %c0 : index
+  cond_br %51, ^bb15, ^bb16
+^bb15:  // pred: ^bb14
+  %52 = fir.convert %49 : (index) -> i32
+  fir.store %52 to %2 : !fir.ref<i32>
+  %53 = fir.load %0 : !fir.ref<i32>
+  %54 = fir.convert %53 : (i32) -> i64
+  %55 = arith.subi %54, %c1_i64 : i64
+  %56 = fir.load %1 : !fir.ref<i32>
+  %57 = fir.convert %56 : (i32) -> i64
+  %58 = arith.subi %57, %c1_i64 : i64
+  %59 = fir.load %2 : !fir.ref<i32>
+  %60 = fir.convert %59 : (i32) -> i64
+  %61 = arith.subi %60, %c1_i64 : i64
+  %62 = fir.coordinate_of %3, %55, %58, %61 : (!fir.ref<!fir.array<3x3x3xi32>>, i64, i64, i64) -> !fir.ref<i32>
+  %63 = fir.load %62 : !fir.ref<i32>
+  %64 = fir.coordinate_of %arg1, %55, %58, %61 : (!fir.ref<!fir.array<3x3x3xi32>>, i64, i64, i64) -> !fir.ref<i32>
+  %65 = fir.load %64 : !fir.ref<i32>
+  %66 = arith.muli %65, %c10000_i32 : i32
+  %67 = arith.addi %63, %66 : i32
+  %68 = fir.coordinate_of %arg2, %55, %58, %61 : (!fir.ref<!fir.array<3x3x3xi32>>, i64, i64, i64) -> !fir.ref<i32>
+  fir.store %67 to %68 : !fir.ref<i32>
+  %69 = arith.addi %49, %c1 : index
+  %70 = arith.subi %50, %c1 : index
+  br ^bb14(%69, %70 : index, index)
+^bb16:  // pred: ^bb14
+  %71 = fir.convert %49 : (index) -> i32
+  fir.store %71 to %2 : !fir.ref<i32>
+  %72 = arith.addi %45, %c1 : index
+  %73 = arith.subi %46, %c1 : index
+  br ^bb12(%72, %73 : index, index)
+^bb17:  // pred: ^bb12
+  %74 = fir.convert %45 : (index) -> i32
+  fir.store %74 to %1 : !fir.ref<i32>
+  %75 = arith.addi %41, %c1 : index
+  %76 = arith.subi %42, %c1 : index
+  br ^bb10(%75, %76 : index, index)
+^bb18:  // pred: ^bb10
+  %77 = fir.convert %41 : (index) -> i32
+  fir.store %77 to %0 : !fir.ref<i32>
+  return
+}
+
+// CHECK:   func @_QPf3dc(%[[VAL_0:.*]]: !fir.ref<!fir.array<3x3x3xi32>>, %[[VAL_1:.*]]: !fir.ref<!fir.array<3x3x3xi32>>, %[[VAL_2:.*]]: !fir.ref<!fir.array<3x3x3xi32>>) {
+// CHECK:    %[[VAL_3:.*]] = arith.constant 100 : i32
+// CHECK:    %[[VAL_4:.*]] = arith.constant 10000 : i32
+// CHECK:    %[[VAL_5:.*]] = arith.constant 1 : i64
+// CHECK:    %[[VAL_6:.*]] = arith.constant 3 : index
+// CHECK:    %[[VAL_7:.*]] = arith.constant 0 : index
+// CHECK:    %[[VAL_8:.*]] = arith.constant 1 : index
+// CHECK:    %[[VAL_9:.*]] = fir.alloca i32 {bindc_name = "i", uniq_name = "_QFf3dcEi"}
+// CHECK:    %[[VAL_10:.*]] = fir.alloca i32 {bindc_name = "j", uniq_name = "_QFf3dcEj"}
+// CHECK:    %[[VAL_11:.*]] = fir.alloca i32 {bindc_name = "k", uniq_name = "_QFf3dcEk"}
+// CHECK:    %[[VAL_12:.*]] = fir.alloca !fir.array<3x3x3xi32> {bindc_name = "t1", uniq_name = "_QFf3dcEt1"}
+// CHECK:    br ^bb1(%[[VAL_8]], %[[VAL_6]] : index, index)
+// CHECK:  ^bb1(%[[VAL_13:.*]]: index, %[[VAL_14:.*]]: index):
+// CHECK:    %[[VAL_15:.*]] = arith.cmpi sgt, %[[VAL_14]], %[[VAL_7]] : index
+// CHECK:    cond_br %[[VAL_15]], ^bb2, ^bb9
+// CHECK:  ^bb2:
+// CHECK:    %[[VAL_16:.*]] = fir.convert %[[VAL_13]] : (index) -> i32
+// CHECK:    br ^bb3(%[[VAL_8]], %[[VAL_6]] : index, index)
+// CHECK:  ^bb3(%[[VAL_17:.*]]: index, %[[VAL_18:.*]]: index):
+// CHECK:    %[[VAL_19:.*]] = arith.cmpi sgt, %[[VAL_18]], %[[VAL_7]] : index
+// CHECK:    cond_br %[[VAL_19]], ^bb4, ^bb8
+// CHECK:  ^bb4:
+// CHECK:    %[[VAL_20:.*]] = fir.convert %[[VAL_17]] : (index) -> i32
+// CHECK:    br ^bb5(%[[VAL_8]], %[[VAL_6]] : index, index)
+// CHECK:  ^bb5(%[[VAL_21:.*]]: index, %[[VAL_22:.*]]: index):
+// CHECK:    %[[VAL_23:.*]] = arith.cmpi sgt, %[[VAL_22]], %[[VAL_7]] : index
+// CHECK:    cond_br %[[VAL_23]], ^bb6, ^bb7
+// CHECK:  ^bb6:
+// CHECK:    %[[VAL_24:.*]] = fir.convert %[[VAL_21]] : (index) -> i32
+// CHECK:    %[[VAL_25:.*]] = fir.convert %[[VAL_16]] : (i32) -> i64
+// CHECK:    %[[VAL_26:.*]] = arith.subi %[[VAL_25]], %[[VAL_5]] : i64
+// CHECK:    %[[VAL_27:.*]] = fir.convert %[[VAL_20]] : (i32) -> i64
+// CHECK:    %[[VAL_28:.*]] = arith.subi %[[VAL_27]], %[[VAL_5]] : i64
+// CHECK:    %[[VAL_29:.*]] = fir.convert %[[VAL_24]] : (i32) -> i64
+// CHECK:    %[[VAL_30:.*]] = arith.subi %[[VAL_29]], %[[VAL_5]] : i64
+// CHECK:    %[[VAL_31:.*]] = fir.coordinate_of %[[VAL_0]], %[[VAL_26]], %[[VAL_28]], %[[VAL_30]] : (!fir.ref<!fir.array<3x3x3xi32>>, i64, i64, i64) -> !fir.ref<i32>
+// CHECK:    %[[VAL_32:.*]] = fir.load %[[VAL_31]] : !fir.ref<i32>
+// CHECK:    %[[VAL_33:.*]] = fir.coordinate_of %[[VAL_0]], %[[VAL_30]], %[[VAL_28]], %[[VAL_26]] : (!fir.ref<!fir.array<3x3x3xi32>>, i64, i64, i64) -> !fir.ref<i32>
+// CHECK:    %[[VAL_34:.*]] = fir.load %[[VAL_33]] : !fir.ref<i32>
+// CHECK:    %[[VAL_35:.*]] = arith.muli %[[VAL_34]], %[[VAL_3]] : i32
+// CHECK:    %[[VAL_36:.*]] = arith.addi %[[VAL_32]], %[[VAL_35]] : i32
+// CHECK:    %[[VAL_37:.*]] = fir.coordinate_of %[[VAL_12]], %[[VAL_26]], %[[VAL_28]], %[[VAL_30]] : (!fir.ref<!fir.array<3x3x3xi32>>, i64, i64, i64) -> !fir.ref<i32>
+// CHECK:    fir.store %[[VAL_36]] to %[[VAL_37]] : !fir.ref<i32>
+// CHECK:    %[[VAL_38:.*]] = arith.addi %[[VAL_21]], %[[VAL_8]] : index
+// CHECK:    %[[VAL_39:.*]] = arith.subi %[[VAL_22]], %[[VAL_8]] : index
+// CHECK:    br ^bb5(%[[VAL_38]], %[[VAL_39]] : index, index)
+// CHECK:  ^bb7:
+// CHECK:    %[[VAL_40:.*]] = fir.convert %[[VAL_21]] : (index) -> i32
+// CHECK:    %[[VAL_41:.*]] = arith.addi %[[VAL_17]], %[[VAL_8]] : index
+// CHECK:    %[[VAL_42:.*]] = arith.subi %[[VAL_18]], %[[VAL_8]] : index
+// CHECK:    br ^bb3(%[[VAL_41]], %[[VAL_42]] : index, index)
+// CHECK:  ^bb8:
+// CHECK:    %[[VAL_43:.*]] = fir.convert %[[VAL_17]] : (index) -> i32
+// CHECK:    %[[VAL_44:.*]] = arith.addi %[[VAL_13]], %[[VAL_8]] : index
+// CHECK:    %[[VAL_45:.*]] = arith.subi %[[VAL_14]], %[[VAL_8]] : index
+// CHECK:    br ^bb1(%[[VAL_44]], %[[VAL_45]] : index, index)
+// CHECK:  ^bb9:
+// CHECK:    %[[VAL_46:.*]] = fir.convert %[[VAL_13]] : (index) -> i32
+// CHECK:    br ^bb10(%[[VAL_8]], %[[VAL_6]] : index, index)
+// CHECK:  ^bb10(%[[VAL_47:.*]]: index, %[[VAL_48:.*]]: index):
+// CHECK:    %[[VAL_49:.*]] = arith.cmpi sgt, %[[VAL_48]], %[[VAL_7]] : index
+// CHECK:    cond_br %[[VAL_49]], ^bb11, ^bb18
+// CHECK:  ^bb11:
+// CHECK:    %[[VAL_50:.*]] = fir.convert %[[VAL_47]] : (index) -> i32
+// CHECK:    br ^bb12(%[[VAL_8]], %[[VAL_6]] : index, index)
+// CHECK:  ^bb12(%[[VAL_51:.*]]: index, %[[VAL_52:.*]]: index):
+// CHECK:    %[[VAL_53:.*]] = arith.cmpi sgt, %[[VAL_52]], %[[VAL_7]] : index
+// CHECK:    cond_br %[[VAL_53]], ^bb13, ^bb17
+// CHECK:  ^bb13:
+// CHECK:    %[[VAL_54:.*]] = fir.convert %[[VAL_51]] : (index) -> i32
+// CHECK:    br ^bb14(%[[VAL_8]], %[[VAL_6]] : index, index)
+// CHECK:  ^bb14(%[[VAL_55:.*]]: index, %[[VAL_56:.*]]: index):
+// CHECK:    %[[VAL_57:.*]] = arith.cmpi sgt, %[[VAL_56]], %[[VAL_7]] : index
+// CHECK:    cond_br %[[VAL_57]], ^bb15, ^bb16
+// CHECK:  ^bb15:
+// CHECK:    %[[VAL_58:.*]] = fir.convert %[[VAL_55]] : (index) -> i32
+// CHECK:    %[[VAL_59:.*]] = fir.convert %[[VAL_50]] : (i32) -> i64
+// CHECK:    %[[VAL_60:.*]] = arith.subi %[[VAL_59]], %[[VAL_5]] : i64
+// CHECK:    %[[VAL_61:.*]] = fir.convert %[[VAL_54]] : (i32) -> i64
+// CHECK:    %[[VAL_62:.*]] = arith.subi %[[VAL_61]], %[[VAL_5]] : i64
+// CHECK:    %[[VAL_63:.*]] = fir.convert %[[VAL_58]] : (i32) -> i64
+// CHECK:    %[[VAL_64:.*]] = arith.subi %[[VAL_63]], %[[VAL_5]] : i64
+// CHECK:    %[[VAL_65:.*]] = fir.coordinate_of %[[VAL_12]], %[[VAL_60]], %[[VAL_62]], %[[VAL_64]] : (!fir.ref<!fir.array<3x3x3xi32>>, i64, i64, i64) -> !fir.ref<i32>
+// CHECK:    %[[VAL_66:.*]] = fir.load %[[VAL_65]] : !fir.ref<i32>
+// CHECK:    %[[VAL_67:.*]] = fir.coordinate_of %[[VAL_1]], %[[VAL_60]], %[[VAL_62]], %[[VAL_64]] : (!fir.ref<!fir.array<3x3x3xi32>>, i64, i64, i64) -> !fir.ref<i32>
+// CHECK:    %[[VAL_68:.*]] = fir.load %[[VAL_67]] : !fir.ref<i32>
+// CHECK:    %[[VAL_69:.*]] = arith.muli %[[VAL_68]], %[[VAL_4]] : i32
+// CHECK:    %[[VAL_70:.*]] = arith.addi %[[VAL_66]], %[[VAL_69]] : i32
+// CHECK:    %[[VAL_71:.*]] = fir.coordinate_of %[[VAL_2]], %[[VAL_60]], %[[VAL_62]], %[[VAL_64]] : (!fir.ref<!fir.array<3x3x3xi32>>, i64, i64, i64) -> !fir.ref<i32>
+// CHECK:    fir.store %[[VAL_70]] to %[[VAL_71]] : !fir.ref<i32>
+// CHECK:    %[[VAL_72:.*]] = arith.addi %[[VAL_55]], %[[VAL_8]] : index
+// CHECK:    %[[VAL_73:.*]] = arith.subi %[[VAL_56]], %[[VAL_8]] : index
+// CHECK:    br ^bb14(%[[VAL_72]], %[[VAL_73]] : index, index)
+// CHECK:  ^bb16:
+// CHECK:    %[[VAL_74:.*]] = fir.convert %[[VAL_55]] : (index) -> i32
+// CHECK:    %[[VAL_75:.*]] = arith.addi %[[VAL_51]], %[[VAL_8]] : index
+// CHECK:    %[[VAL_76:.*]] = arith.subi %[[VAL_52]], %[[VAL_8]] : index
+// CHECK:    br ^bb12(%[[VAL_75]], %[[VAL_76]] : index, index)
+// CHECK:  ^bb17:
+// CHECK:    %[[VAL_77:.*]] = fir.convert %[[VAL_51]] : (index) -> i32
+// CHECK:    %[[VAL_78:.*]] = arith.addi %[[VAL_47]], %[[VAL_8]] : index
+// CHECK:    %[[VAL_79:.*]] = arith.subi %[[VAL_48]], %[[VAL_8]] : index
+// CHECK:    br ^bb10(%[[VAL_78]], %[[VAL_79]] : index, index)
+// CHECK:  ^bb18:
+// CHECK:    %[[VAL_80:.*]] = fir.convert %[[VAL_47]] : (index) -> i32
+// CHECK:    return
+// CHECK:  }
+
+// -----
+
+func @_QPf3dv(%arg0: !fir.ref<!fir.array<?x?x?xi32>>, %arg1: !fir.ref<!fir.array<?x?x?xi32>>, %arg2: !fir.ref<!fir.array<?x?x?xi32>>, %arg3: !fir.ref<i32>, %arg4: !fir.ref<i32>, %arg5: !fir.ref<i32>) {
+  %c100_i32 = arith.constant 100 : i32
+  %c10000_i32 = arith.constant 10000 : i32
+  %c0 = arith.constant 0 : index
+  %c1 = arith.constant 1 : index
+  %0 = fir.alloca i32 {bindc_name = "i", uniq_name = "_QFf3dvEi"}
+  %1 = fir.alloca i32 {bindc_name = "j", uniq_name = "_QFf3dvEj"}
+  %2 = fir.alloca i32 {bindc_name = "k", uniq_name = "_QFf3dvEk"}
+  %3 = fir.alloca i32 {bindc_name = "s1e", uniq_name = "_QFf3dvEs1e"}
+  %4 = fir.alloca i32 {bindc_name = "s2e", uniq_name = "_QFf3dvEs2e"}
+  %5 = fir.alloca i32 {bindc_name = "s3e", uniq_name = "_QFf3dvEs3e"}
+  %6 = fir.load %arg3 : !fir.ref<i32>
+  %7 = fir.convert %6 : (i32) -> index
+  %8 = fir.load %arg4 : !fir.ref<i32>
+  %9 = fir.convert %8 : (i32) -> index
+  %10 = fir.load %arg5 : !fir.ref<i32>
+  %11 = fir.convert %10 : (i32) -> index
+  %12 = fir.alloca !fir.array<?x?x?xi32>, %7, %9, %11 {bindc_name = "t1", uniq_name = "_QFf3dvEt1"}
+  fir.store %6 to %3 : !fir.ref<i32>
+  %13 = fir.load %arg4 : !fir.ref<i32>
+  fir.store %13 to %4 : !fir.ref<i32>
+  %14 = fir.load %arg5 : !fir.ref<i32>
+  fir.store %14 to %5 : !fir.ref<i32>
+  %15 = fir.load %3 : !fir.ref<i32>
+  %16 = fir.convert %15 : (i32) -> index
+  br ^bb1(%c1, %16 : index, index)
+^bb1(%17: index, %18: index):  // 2 preds: ^bb0, ^bb8
+  %19 = arith.cmpi sgt, %18, %c0 : index
+  cond_br %19, ^bb2, ^bb9
+^bb2:  // pred: ^bb1
+  %20 = fir.convert %17 : (index) -> i32
+  fir.store %20 to %0 : !fir.ref<i32>
+  %21 = fir.load %4 : !fir.ref<i32>
+  %22 = fir.convert %21 : (i32) -> index
+  br ^bb3(%c1, %22 : index, index)
+^bb3(%23: index, %24: index):  // 2 preds: ^bb2, ^bb7
+  %25 = arith.cmpi sgt, %24, %c0 : index
+  cond_br %25, ^bb4, ^bb8
+^bb4:  // pred: ^bb3
+  %26 = fir.convert %23 : (index) -> i32
+  fir.store %26 to %1 : !fir.ref<i32>
+  %27 = fir.load %5 : !fir.ref<i32>
+  %28 = fir.convert %27 : (i32) -> index
+  br ^bb5(%c1, %28 : index, index)
+^bb5(%29: index, %30: index):  // 2 preds: ^bb4, ^bb6
+  %31 = arith.cmpi sgt, %30, %c0 : index
+  cond_br %31, ^bb6, ^bb7
+^bb6:  // pred: ^bb5
+  %32 = fir.convert %29 : (index) -> i32
+  fir.store %32 to %2 : !fir.ref<i32>
+  %33 = fir.convert %arg0 : (!fir.ref<!fir.array<?x?x?xi32>>) -> !fir.ref<!fir.array<?xi32>>
+  %34 = fir.load %0 : !fir.ref<i32>
+  %35 = fir.convert %34 : (i32) -> index
+  %36 = arith.subi %35, %c1 : index
+  %37 = fir.load %1 : !fir.ref<i32>
+  %38 = fir.convert %37 : (i32) -> index
+  %39 = arith.subi %38, %c1 : index
+  %40 = arith.muli %7, %39 : index
+  %41 = arith.addi %40, %36 : index
+  %42 = arith.muli %7, %9 : index
+  %43 = fir.load %2 : !fir.ref<i32>
+  %44 = fir.convert %43 : (i32) -> index
+  %45 = arith.subi %44, %c1 : index
+  %46 = arith.muli %42, %45 : index
+  %47 = arith.addi %46, %41 : index
+  %48 = fir.coordinate_of %33, %47 : (!fir.ref<!fir.array<?xi32>>, index) -> !fir.ref<i32>
+  %49 = fir.load %48 : !fir.ref<i32>
+  %50 = arith.addi %40, %45 : index
+  %51 = arith.muli %42, %36 : index
+  %52 = arith.addi %51, %50 : index
+  %53 = fir.coordinate_of %33, %52 : (!fir.ref<!fir.array<?xi32>>, index) -> !fir.ref<i32>
+  %54 = fir.load %53 : !fir.ref<i32>
+  %55 = arith.muli %54, %c100_i32 : i32
+  %56 = arith.addi %49, %55 : i32
+  %57 = fir.convert %12 : (!fir.ref<!fir.array<?x?x?xi32>>) -> !fir.ref<!fir.array<?xi32>>
+  %58 = fir.coordinate_of %57, %47 : (!fir.ref<!fir.array<?xi32>>, index) -> !fir.ref<i32>
+  fir.store %56 to %58 : !fir.ref<i32>
+  %59 = arith.addi %29, %c1 : index
+  %60 = arith.subi %30, %c1 : index
+  br ^bb5(%59, %60 : index, index)
+^bb7:  // pred: ^bb5
+  %61 = fir.convert %29 : (index) -> i32
+  fir.store %61 to %2 : !fir.ref<i32>
+  %62 = arith.addi %23, %c1 : index
+  %63 = arith.subi %24, %c1 : index
+  br ^bb3(%62, %63 : index, index)
+^bb8:  // pred: ^bb3
+  %64 = fir.convert %23 : (index) -> i32
+  fir.store %64 to %1 : !fir.ref<i32>
+  %65 = arith.addi %17, %c1 : index
+  %66 = arith.subi %18, %c1 : index
+  br ^bb1(%65, %66 : index, index)
+^bb9:  // pred: ^bb1
+  %67 = fir.convert %17 : (index) -> i32
+  fir.store %67 to %0 : !fir.ref<i32>
+  %68 = fir.load %3 : !fir.ref<i32>
+  %69 = fir.convert %68 : (i32) -> index
+  br ^bb10(%c1, %69 : index, index)
+^bb10(%70: index, %71: index):  // 2 preds: ^bb9, ^bb17
+  %72 = arith.cmpi sgt, %71, %c0 : index
+  cond_br %72, ^bb11, ^bb18
+^bb11:  // pred: ^bb10
+  %73 = fir.convert %70 : (index) -> i32
+  fir.store %73 to %0 : !fir.ref<i32>
+  %74 = fir.load %4 : !fir.ref<i32>
+  %75 = fir.convert %74 : (i32) -> index
+  br ^bb12(%c1, %75 : index, index)
+^bb12(%76: index, %77: index):  // 2 preds: ^bb11, ^bb16
+  %78 = arith.cmpi sgt, %77, %c0 : index
+  cond_br %78, ^bb13, ^bb17
+^bb13:  // pred: ^bb12
+  %79 = fir.convert %76 : (index) -> i32
+  fir.store %79 to %1 : !fir.ref<i32>
+  %80 = fir.load %5 : !fir.ref<i32>
+  %81 = fir.convert %80 : (i32) -> index
+  br ^bb14(%c1, %81 : index, index)
+^bb14(%82: index, %83: index):  // 2 preds: ^bb13, ^bb15
+  %84 = arith.cmpi sgt, %83, %c0 : index
+  cond_br %84, ^bb15, ^bb16
+^bb15:  // pred: ^bb14
+  %85 = fir.convert %82 : (index) -> i32
+  fir.store %85 to %2 : !fir.ref<i32>
+  %86 = fir.convert %12 : (!fir.ref<!fir.array<?x?x?xi32>>) -> !fir.ref<!fir.array<?xi32>>
+  %87 = fir.load %0 : !fir.ref<i32>
+  %88 = fir.convert %87 : (i32) -> index
+  %89 = arith.subi %88, %c1 : index
+  %90 = fir.load %1 : !fir.ref<i32>
+  %91 = fir.convert %90 : (i32) -> index
+  %92 = arith.subi %91, %c1 : index
+  %93 = arith.muli %7, %92 : index
+  %94 = arith.addi %93, %89 : index
+  %95 = arith.muli %7, %9 : index
+  %96 = fir.load %2 : !fir.ref<i32>
+  %97 = fir.convert %96 : (i32) -> index
+  %98 = arith.subi %97, %c1 : index
+  %99 = arith.muli %95, %98 : index
+  %100 = arith.addi %99, %94 : index
+  %101 = fir.coordinate_of %86, %100 : (!fir.ref<!fir.array<?xi32>>, index) -> !fir.ref<i32>
+  %102 = fir.load %101 : !fir.ref<i32>
+  %103 = fir.convert %arg1 : (!fir.ref<!fir.array<?x?x?xi32>>) -> !fir.ref<!fir.array<?xi32>>
+  %104 = fir.coordinate_of %103, %100 : (!fir.ref<!fir.array<?xi32>>, index) -> !fir.ref<i32>
+  %105 = fir.load %104 : !fir.ref<i32>
+  %106 = arith.muli %105, %c10000_i32 : i32
+  %107 = arith.addi %102, %106 : i32
+  %108 = fir.convert %arg2 : (!fir.ref<!fir.array<?x?x?xi32>>) -> !fir.ref<!fir.array<?xi32>>
+  %109 = fir.coordinate_of %108, %100 : (!fir.ref<!fir.array<?xi32>>, index) -> !fir.ref<i32>
+  fir.store %107 to %109 : !fir.ref<i32>
+  %110 = arith.addi %82, %c1 : index
+  %111 = arith.subi %83, %c1 : index
+  br ^bb14(%110, %111 : index, index)
+^bb16:  // pred: ^bb14
+  %112 = fir.convert %82 : (index) -> i32
+  fir.store %112 to %2 : !fir.ref<i32>
+  %113 = arith.addi %76, %c1 : index
+  %114 = arith.subi %77, %c1 : index
+  br ^bb12(%113, %114 : index, index)
+^bb17:  // pred: ^bb12
+  %115 = fir.convert %76 : (index) -> i32
+  fir.store %115 to %1 : !fir.ref<i32>
+  %116 = arith.addi %70, %c1 : index
+  %117 = arith.subi %71, %c1 : index
+  br ^bb10(%116, %117 : index, index)
+^bb18:  // pred: ^bb10
+  %118 = fir.convert %70 : (index) -> i32
+  fir.store %118 to %0 : !fir.ref<i32>
+  return
+}
+
+// CHECK:  func @_QPf3dv(%[[VAL_0:.*]]: !fir.ref<!fir.array<?x?x?xi32>>, %[[VAL_1:.*]]: !fir.ref<!fir.array<?x?x?xi32>>, %[[VAL_2:.*]]: !fir.ref<!fir.array<?x?x?xi32>>, %[[VAL_3:.*]]: !fir.ref<i32>, %[[VAL_4:.*]]: !fir.ref<i32>, %[[VAL_5:.*]]: !fir.ref<i32>) {
+// CHECK:    %[[VAL_6:.*]] = arith.constant 100 : i32
+// CHECK:    %[[VAL_7:.*]] = arith.constant 10000 : i32
+// CHECK:    %[[VAL_8:.*]] = arith.constant 0 : index
+// CHECK:    %[[VAL_9:.*]] = arith.constant 1 : index
+// CHECK:    %[[VAL_10:.*]] = fir.alloca i32 {bindc_name = "i", uniq_name = "_QFf3dvEi"}
+// CHECK:    %[[VAL_11:.*]] = fir.alloca i32 {bindc_name = "j", uniq_name = "_QFf3dvEj"}
+// CHECK:    %[[VAL_12:.*]] = fir.alloca i32 {bindc_name = "k", uniq_name = "_QFf3dvEk"}
+// CHECK:    %[[VAL_13:.*]] = fir.alloca i32 {bindc_name = "s1e", uniq_name = "_QFf3dvEs1e"}
+// CHECK:    %[[VAL_14:.*]] = fir.alloca i32 {bindc_name = "s2e", uniq_name = "_QFf3dvEs2e"}
+// CHECK:    %[[VAL_15:.*]] = fir.alloca i32 {bindc_name = "s3e", uniq_name = "_QFf3dvEs3e"}
+// CHECK:    %[[VAL_16:.*]] = fir.load %[[VAL_3]] : !fir.ref<i32>
+// CHECK:    %[[VAL_17:.*]] = fir.convert %[[VAL_16]] : (i32) -> index
+// CHECK:    %[[VAL_18:.*]] = fir.load %[[VAL_4]] : !fir.ref<i32>
+// CHECK:    %[[VAL_19:.*]] = fir.convert %[[VAL_18]] : (i32) -> index
+// CHECK:    %[[VAL_20:.*]] = fir.load %[[VAL_5]] : !fir.ref<i32>
+// CHECK:    %[[VAL_21:.*]] = fir.convert %[[VAL_20]] : (i32) -> index
+// CHECK:    %[[VAL_22:.*]] = fir.alloca !fir.array<?x?x?xi32>, %[[VAL_17]], %[[VAL_19]], %[[VAL_21]] {bindc_name = "t1", uniq_name = "_QFf3dvEt1"}
+// CHECK:    %[[VAL_23:.*]] = fir.load %[[VAL_4]] : !fir.ref<i32>
+// CHECK:    %[[VAL_24:.*]] = fir.load %[[VAL_5]] : !fir.ref<i32>
+// CHECK:    %[[VAL_25:.*]] = fir.convert %[[VAL_16]] : (i32) -> index
+// CHECK:    br ^bb1(%[[VAL_9]], %[[VAL_25]] : index, index)
+// CHECK:  ^bb1(%[[VAL_26:.*]]: index, %[[VAL_27:.*]]: index):
+// CHECK:    %[[VAL_28:.*]] = arith.cmpi sgt, %[[VAL_27]], %[[VAL_8]] : index
+// CHECK:    cond_br %[[VAL_28]], ^bb2, ^bb9
+// CHECK:  ^bb2:
+// CHECK:    %[[VAL_29:.*]] = fir.convert %[[VAL_26]] : (index) -> i32
+// CHECK:    %[[VAL_30:.*]] = fir.convert %[[VAL_23]] : (i32) -> index
+// CHECK:    br ^bb3(%[[VAL_9]], %[[VAL_30]] : index, index)
+// CHECK:  ^bb3(%[[VAL_31:.*]]: index, %[[VAL_32:.*]]: index):
+// CHECK:    %[[VAL_33:.*]] = arith.cmpi sgt, %[[VAL_32]], %[[VAL_8]] : index
+// CHECK:    cond_br %[[VAL_33]], ^bb4, ^bb8
+// CHECK:  ^bb4:
+// CHECK:    %[[VAL_34:.*]] = fir.convert %[[VAL_31]] : (index) -> i32
+// CHECK:    %[[VAL_35:.*]] = fir.convert %[[VAL_24]] : (i32) -> index
+// CHECK:    br ^bb5(%[[VAL_9]], %[[VAL_35]] : index, index)
+// CHECK:  ^bb5(%[[VAL_36:.*]]: index, %[[VAL_37:.*]]: index):
+// CHECK:    %[[VAL_38:.*]] = arith.cmpi sgt, %[[VAL_37]], %[[VAL_8]] : index
+// CHECK:    cond_br %[[VAL_38]], ^bb6, ^bb7
+// CHECK:  ^bb6:
+// CHECK:    %[[VAL_39:.*]] = fir.convert %[[VAL_36]] : (index) -> i32
+// CHECK:    %[[VAL_40:.*]] = fir.convert %[[VAL_0]] : (!fir.ref<!fir.array<?x?x?xi32>>) -> !fir.ref<!fir.array<?xi32>>
+// CHECK:    %[[VAL_41:.*]] = fir.convert %[[VAL_29]] : (i32) -> index
+// CHECK:    %[[VAL_42:.*]] = arith.subi %[[VAL_41]], %[[VAL_9]] : index
+// CHECK:    %[[VAL_43:.*]] = fir.convert %[[VAL_34]] : (i32) -> index
+// CHECK:    %[[VAL_44:.*]] = arith.subi %[[VAL_43]], %[[VAL_9]] : index
+// CHECK:    %[[VAL_45:.*]] = arith.muli %[[VAL_17]], %[[VAL_44]] : index
+// CHECK:    %[[VAL_46:.*]] = arith.addi %[[VAL_45]], %[[VAL_42]] : index
+// CHECK:    %[[VAL_47:.*]] = arith.muli %[[VAL_17]], %[[VAL_19]] : index
+// CHECK:    %[[VAL_48:.*]] = fir.convert %[[VAL_39]] : (i32) -> index
+// CHECK:    %[[VAL_49:.*]] = arith.subi %[[VAL_48]], %[[VAL_9]] : index
+// CHECK:    %[[VAL_50:.*]] = arith.muli %[[VAL_47]], %[[VAL_49]] : index
+// CHECK:    %[[VAL_51:.*]] = arith.addi %[[VAL_50]], %[[VAL_46]] : index
+// CHECK:    %[[VAL_52:.*]] = fir.coordinate_of %[[VAL_40]], %[[VAL_51]] : (!fir.ref<!fir.array<?xi32>>, index) -> !fir.ref<i32>
+// CHECK:    %[[VAL_53:.*]] = fir.load %[[VAL_52]] : !fir.ref<i32>
+// CHECK:    %[[VAL_54:.*]] = arith.addi %[[VAL_45]], %[[VAL_49]] : index
+// CHECK:    %[[VAL_55:.*]] = arith.muli %[[VAL_47]], %[[VAL_42]] : index
+// CHECK:    %[[VAL_56:.*]] = arith.addi %[[VAL_55]], %[[VAL_54]] : index
+// CHECK:    %[[VAL_57:.*]] = fir.coordinate_of %[[VAL_40]], %[[VAL_56]] : (!fir.ref<!fir.array<?xi32>>, index) -> !fir.ref<i32>
+// CHECK:    %[[VAL_58:.*]] = fir.load %[[VAL_57]] : !fir.ref<i32>
+// CHECK:    %[[VAL_59:.*]] = arith.muli %[[VAL_58]], %[[VAL_6]] : i32
+// CHECK:    %[[VAL_60:.*]] = arith.addi %[[VAL_53]], %[[VAL_59]] : i32
+// CHECK:    %[[VAL_61:.*]] = fir.convert %[[VAL_22]] : (!fir.ref<!fir.array<?x?x?xi32>>) -> !fir.ref<!fir.array<?xi32>>
+// CHECK:    %[[VAL_62:.*]] = fir.coordinate_of %[[VAL_61]], %[[VAL_51]] : (!fir.ref<!fir.array<?xi32>>, index) -> !fir.ref<i32>
+// CHECK:    fir.store %[[VAL_60]] to %[[VAL_62]] : !fir.ref<i32>
+// CHECK:    %[[VAL_63:.*]] = arith.addi %[[VAL_36]], %[[VAL_9]] : index
+// CHECK:    %[[VAL_64:.*]] = arith.subi %[[VAL_37]], %[[VAL_9]] : index
+// CHECK:    br ^bb5(%[[VAL_63]], %[[VAL_64]] : index, index)
+// CHECK:  ^bb7:
+// CHECK:    %[[VAL_65:.*]] = fir.convert %[[VAL_36]] : (index) -> i32
+// CHECK:    %[[VAL_66:.*]] = arith.addi %[[VAL_31]], %[[VAL_9]] : index
+// CHECK:    %[[VAL_67:.*]] = arith.subi %[[VAL_32]], %[[VAL_9]] : index
+// CHECK:    br ^bb3(%[[VAL_66]], %[[VAL_67]] : index, index)
+// CHECK:  ^bb8:
+// CHECK:    %[[VAL_68:.*]] = fir.convert %[[VAL_31]] : (index) -> i32
+// CHECK:    %[[VAL_69:.*]] = arith.addi %[[VAL_26]], %[[VAL_9]] : index
+// CHECK:    %[[VAL_70:.*]] = arith.subi %[[VAL_27]], %[[VAL_9]] : index
+// CHECK:    br ^bb1(%[[VAL_69]], %[[VAL_70]] : index, index)
+// CHECK:  ^bb9:
+// CHECK:    %[[VAL_71:.*]] = fir.convert %[[VAL_26]] : (index) -> i32
+// CHECK:    %[[VAL_72:.*]] = fir.convert %[[VAL_16]] : (i32) -> index
+// CHECK:    br ^bb10(%[[VAL_9]], %[[VAL_72]] : index, index)
+// CHECK:  ^bb10(%[[VAL_73:.*]]: index, %[[VAL_74:.*]]: index):
+// CHECK:    %[[VAL_75:.*]] = arith.cmpi sgt, %[[VAL_74]], %[[VAL_8]] : index
+// CHECK:    cond_br %[[VAL_75]], ^bb11, ^bb18
+// CHECK:  ^bb11:
+// CHECK:    %[[VAL_76:.*]] = fir.convert %[[VAL_73]] : (index) -> i32
+// CHECK:    %[[VAL_77:.*]] = fir.convert %[[VAL_23]] : (i32) -> index
+// CHECK:    br ^bb12(%[[VAL_9]], %[[VAL_77]] : index, index)
+// CHECK:  ^bb12(%[[VAL_78:.*]]: index, %[[VAL_79:.*]]: index):
+// CHECK:    %[[VAL_80:.*]] = arith.cmpi sgt, %[[VAL_79]], %[[VAL_8]] : index
+// CHECK:    cond_br %[[VAL_80]], ^bb13, ^bb17
+// CHECK:  ^bb13:
+// CHECK:    %[[VAL_81:.*]] = fir.convert %[[VAL_78]] : (index) -> i32
+// CHECK:    %[[VAL_82:.*]] = fir.convert %[[VAL_24]] : (i32) -> index
+// CHECK:    br ^bb14(%[[VAL_9]], %[[VAL_82]] : index, index)
+// CHECK:  ^bb14(%[[VAL_83:.*]]: index, %[[VAL_84:.*]]: index):
+// CHECK:    %[[VAL_85:.*]] = arith.cmpi sgt, %[[VAL_84]], %[[VAL_8]] : index
+// CHECK:    cond_br %[[VAL_85]], ^bb15, ^bb16
+// CHECK:  ^bb15:
+// CHECK:    %[[VAL_86:.*]] = fir.convert %[[VAL_83]] : (index) -> i32
+// CHECK:    %[[VAL_87:.*]] = fir.convert %[[VAL_22]] : (!fir.ref<!fir.array<?x?x?xi32>>) -> !fir.ref<!fir.array<?xi32>>
+// CHECK:    %[[VAL_88:.*]] = fir.convert %[[VAL_76]] : (i32) -> index
+// CHECK:    %[[VAL_89:.*]] = arith.subi %[[VAL_88]], %[[VAL_9]] : index
+// CHECK:    %[[VAL_90:.*]] = fir.convert %[[VAL_81]] : (i32) -> index
+// CHECK:    %[[VAL_91:.*]] = arith.subi %[[VAL_90]], %[[VAL_9]] : index
+// CHECK:    %[[VAL_92:.*]] = arith.muli %[[VAL_17]], %[[VAL_91]] : index
+// CHECK:    %[[VAL_93:.*]] = arith.addi %[[VAL_92]], %[[VAL_89]] : index
+// CHECK:    %[[VAL_94:.*]] = arith.muli %[[VAL_17]], %[[VAL_19]] : index
+// CHECK:    %[[VAL_95:.*]] = fir.convert %[[VAL_86]] : (i32) -> index
+// CHECK:    %[[VAL_96:.*]] = arith.subi %[[VAL_95]], %[[VAL_9]] : index
+// CHECK:    %[[VAL_97:.*]] = arith.muli %[[VAL_94]], %[[VAL_96]] : index
+// CHECK:    %[[VAL_98:.*]] = arith.addi %[[VAL_97]], %[[VAL_93]] : index
+// CHECK:    %[[VAL_99:.*]] = fir.coordinate_of %[[VAL_87]], %[[VAL_98]] : (!fir.ref<!fir.array<?xi32>>, index) -> !fir.ref<i32>
+// CHECK:    %[[VAL_100:.*]] = fir.load %[[VAL_99]] : !fir.ref<i32>
+// CHECK:    %[[VAL_101:.*]] = fir.convert %[[VAL_1]] : (!fir.ref<!fir.array<?x?x?xi32>>) -> !fir.ref<!fir.array<?xi32>>
+// CHECK:    %[[VAL_102:.*]] = fir.coordinate_of %[[VAL_101]], %[[VAL_98]] : (!fir.ref<!fir.array<?xi32>>, index) -> !fir.ref<i32>
+// CHECK:    %[[VAL_103:.*]] = fir.load %[[VAL_102]] : !fir.ref<i32>
+// CHECK:    %[[VAL_104:.*]] = arith.muli %[[VAL_103]], %[[VAL_7]] : i32
+// CHECK:    %[[VAL_105:.*]] = arith.addi %[[VAL_100]], %[[VAL_104]] : i32
+// CHECK:    %[[VAL_106:.*]] = fir.convert %[[VAL_2]] : (!fir.ref<!fir.array<?x?x?xi32>>) -> !fir.ref<!fir.array<?xi32>>
+// CHECK:    %[[VAL_107:.*]] = fir.coordinate_of %[[VAL_106]], %[[VAL_98]] : (!fir.ref<!fir.array<?xi32>>, index) -> !fir.ref<i32>
+// CHECK:    fir.store %[[VAL_105]] to %[[VAL_107]] : !fir.ref<i32>
+// CHECK:    %[[VAL_108:.*]] = arith.addi %[[VAL_83]], %[[VAL_9]] : index
+// CHECK:    %[[VAL_109:.*]] = arith.subi %[[VAL_84]], %[[VAL_9]] : index
+// CHECK:    br ^bb14(%[[VAL_108]], %[[VAL_109]] : index, index)
+// CHECK:  ^bb16:
+// CHECK:    %[[VAL_110:.*]] = fir.convert %[[VAL_83]] : (index) -> i32
+// CHECK:    %[[VAL_111:.*]] = arith.addi %[[VAL_78]], %[[VAL_9]] : index
+// CHECK:    %[[VAL_112:.*]] = arith.subi %[[VAL_79]], %[[VAL_9]] : index
+// CHECK:    br ^bb12(%[[VAL_111]], %[[VAL_112]] : index, index)
+// CHECK:  ^bb17:
+// CHECK:    %[[VAL_113:.*]] = fir.convert %[[VAL_78]] : (index) -> i32
+// CHECK:    %[[VAL_114:.*]] = arith.addi %[[VAL_73]], %[[VAL_9]] : index
+// CHECK:    %[[VAL_115:.*]] = arith.subi %[[VAL_74]], %[[VAL_9]] : index
+// CHECK:    br ^bb10(%[[VAL_114]], %[[VAL_115]] : index, index)
+// CHECK:  ^bb18:
+// CHECK:    %[[VAL_116:.*]] = fir.convert %[[VAL_73]] : (index) -> i32
+// CHECK:    return
+// CHECK:  }