Prepare for inlining of SUM intrinsic

[Leporacanthicus]

Summary

Find calls to FortranASum{Real8,Integer4}, check for dim and mask
arguments being absent - then produce an inlineable simple
version of the sum function.

(No longer a prototype, please review for push to llvm/main - not sure how to make Phabricator update the review with actual commit message)

[mehdi_amini]

Just some quick skimming through, I had a few comments, hope this helps! :)

flang/lib/Optimizer/Transforms/InlineIntrinsics.cpp

41 ↗

(On Diff #428733)

This line is unnecessary (also a helper like this does not really pull its weight: RAUW+erase is a common pattern)

48 ↗

(On Diff #428733)

I think that technically this is a "partial_specialization", that would be a better suffix than "_inline" I believe.

Also Twine as local variable isn't recommended, it is a footgun.
You also don't gain anything since you will convert to string always below anyway, this should be equally fine:

std::string name = mlir::Twine{basename, "_inline"}.str();

52 ↗

(On Diff #428733)

Same as the call-site: a symbol-table should be built once and kept around.

120 ↗

(On Diff #428733)

The function does not do what the name says it does I believe, it looks at an operand.

122 ↗

(On Diff #428733)

Can't val.getDefiningOp() return nullptr?

126 ↗

(On Diff #428733)

(same as above)

129 ↗

(On Diff #428733)

The usual way to match for zero would be:

return (matchPattern(value, m_Zero()))

136 ↗

(On Diff #428733)

The two initializations here could move out of the walk (they're not free) and replaced by setting the insertion point on the builder.

137 ↗

(On Diff #428733)

Nit: reduce indentation with early return/continue (here and elsewhere/below).

140 ↗

(On Diff #428733)

This will be slow, a SymbolTable should be constructed on the module outside of the walk (and this method is not a good idea on the builder: it encourages anti-patterns like here)

Edit: actually this is even entirely unnecessary, you only need "callee".

141 ↗

(On Diff #428733)

This is the same thing as "callee"

142 ↗

(On Diff #428733)

Nit: specify the type instead of auto (here and elsewhere where it isn't redundant)

154 ↗

(On Diff #428733)

Can you get the type from the IR? That is using the type of one of the operands or the result instead of doing string matching and rebuilding a type?

157 ↗

(On Diff #428733)

(technically you can modify the call in-place, but this is fine as well.

[Leporacanthicus]

In D125407#3507337, @mehdi_amini wrote:

Just some quick skimming through, I had a few comments, hope this helps! :)

Appreicate the comments. This is definitely a hacky version to show the basic idea. I'm sure there will be much bigger changes than the things you've pointed out, but I will try to make the changed you suggested too.

A lot of it is "How the heck do I do this", and at least in Flang, we don't have much "modify MLIR based on finding something". This is definitely the most complicated [even if it's really quite trivial] that I've done in this kind of thing. And yes, the various things may return NULL or similar, and not properly checked is definitely part of "this is not finished".

Appreciate that you spent the time to comment on this.

[mehdi_amini]

(I didn't make it explicit, but the overall approach makes sense to me)

[peixin]

flang/lib/Optimizer/Transforms/InlineIntrinsics.cpp

89 ↗

(On Diff #428733)

There should be one lambda with std::function argument. In lambda, you create the fir::DoLoopOp and handle the loop info. Or even make it one general function so that it can be used for other intrinsics. In the caller, do the special operations as the intrinsic needed. Here is one example (D127047), which borrows the code from FIR. As I remembered, there is some code handing the fir::DoLoopOp. You can check if there are some helper functions you can use directly. With one good lambda/helper function, you can even do this for multiple-D arrays.

[Leporacanthicus]

Updates in this revision:

• Implement shape detection (so only work on 1D arrays)
• Fix off-by-one error in loop (found when testing on SNAP)
• Fix some review comments
• Rebase to llvm/main instead of fir-dev

Still to resolve:

• Tests
• Optimisation setting to enable/disable
• Probably fix some more review comments

[Leporacanthicus]

flang/lib/Optimizer/Transforms/InlineIntrinsics.cpp

41 ↗

(On Diff #428733)

Doh, missed the "don't need this line". Will fix in the next update.

48 ↗

(On Diff #428733)

For now, I've changed it to "_simplfiied", which should be good enough to make it [reasonably] unique. Yes, it's a partial specialization - or a simplification compared to the complete runtime function... :)

52 ↗

(On Diff #428733)

I'm not entirely sure precisely what you are asking for here. To keep a separate name -> function mapping (DenseMap or similar), or just keep some variable around in some other fashion?

89 ↗

(On Diff #428733)

I agree that the future design will have some form of split between a generic "create a new function" and "build the content for a particular intrinsic".

I think the right time to make that split is when we add a different of intrinsic for simplification, and we can better see what is shared and what isn't shared at that point. There may be more than one such split.

136 ↗

(On Diff #428733)

For some reason, it doesn't work when I move the builder out of the loop, it crashes on getNamedFunction(callee). Not sure if I'm doing something wrong. I moved the builder creation so that it only gets created when it's actually required.

141 ↗

(On Diff #428733)

I've rewritten the whole section of this code... Thanks for the "nudge" to rewrite it.

142 ↗

(On Diff #428733)

I _think_ I've removed all auto except where it's obvious.

154 ↗

(On Diff #428733)

Not done this for now. I think it's a good idea, so I will have a play with it over the next day or so [or hours, if it turns out real easy].

[awarzynski]

Hey Mats, thanks for working on this!

This is a prototype, not a finished version

Is this still the case? If not - could you update the summary? Folks might be hesitant to review otherwise.

Before diving into details, could you add some tests? Otherwise, it's not clear what the intended workflow for this is. Also, there might be some design details still requiring ironing out and I think that tests would clarify this.

[Leporacanthicus]

Updates since last time:

• Fix crash if no shape available.
• Add basic tests

[awarzynski]

Mostly looks good to me. I've left some suggestions inline. The key thing would be to add more tests. And to update the description. In particular:

This is a prototype, not a finished version,

I'd add more reviewers once the summary is updated. Thanks for working on this!

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

177–183

This name and description doesn't really reflect what is going on here, does it? This pass is more about injecting a specializations of intrinsics. In fact, it only deals with one intrinsic ATM :)

flang/lib/Optimizer/Transforms/SimplifyIntrinsics.cpp

35

A comment with some pseudo-code for the newly created function would be greatly appreciated!

38

Suggesting a more descriptive ... name :)

43–45

Can skip the braces here: https://llvm.org/docs/CodingStandards.html#don-t-use-braces-on-simple-single-statement-bodies-of-if-else-loop-statements.

49

[nit]

166

Could you write a test for this case as well?

168–169

Could you write a test that will exercise this?

flang/test/Transforms/simplifyintrinsics.fir

5

Could you use more descriptive names for functions? For example, sum_1d_array.

The main difference between the two tests is that one adds vectors, and the other adds 2d arrays, right? Why not make it clearer (as opposed to cryptic names like _QPtest.

36

You will also want CHECK-NOT: _FortranASumInteger4.

91

Could you add // CHECK-NOT: _FortranASumInteger4_simplified somewhere here?

[vzakhari]

FYI, I will be unavailable next week, so I will not be able to follow up on your comments.

flang/lib/Optimizer/Transforms/SimplifyIntrinsics.cpp

28

Since this function is currently SUM specific, can you please rename it to make it explicit? Please also add a header comment describing the parameters.

82

Is it possible that the input box has non-unit stride?

97

Is there some benefit in keeping the sum in memory? Can we make it a result of the loop and store it once at the end? No need to change it in this commit.

149

Please add comments describing either the pass in general or runOnOperation behavior.

[clementval]

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

177

Is there a specific reason to run on ModuleOp instead of FuncOp?

177–183

+1

[Leporacanthicus]

Update based on review:

• Add comments to code, change variable names.
• Add two more tests to cover all branches of the code.

[Leporacanthicus]

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

177

Probably no good reason - although I'm not sure it makes a huge difference if it is or isn't - we need to walk all the code either way.

I tried changing it quickly, but it needs further changes than just changing the FuncOp, so I will look at changing it in the next update - I'm sure there will be at least one more iteration before this is approved - if nothing else because I've "tixed" this.

flang/lib/Optimizer/Transforms/SimplifyIntrinsics.cpp

28

The idea is that this will take a function as argument, and be made generic, but trying to keep it simple for the first generation of this code ("don't complicate the API for something you could need in the future")

35

Done, in pseudo-Fortran, next to where the actual function is inserted - it should probably be split into a separate function at some point (when we start adding more functions) in the future, so I prefer to have it next to the code that inserts the code.

38

Done, but with a different var name.

82

I will dig into this, I need a way to produce it first.

97

Good point, I will look at this in a follow-up patch (once the code is optimised by LLVM, it makes no real difference - and I suspect it ends up with an alloca + load/add/store in LLVM either way, but it makes sense to use the result of the do-loop, to keep things consistent).

149

Description of the entire pass - as well as brief description of the actual checks below.

[clementval]

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

177

The advantage is that if you can run on FuncOp, multiple FuncOp can be processed in parallel.

[awarzynski]

Thanks for all the updates!

flang/lib/Optimizer/Transforms/SimplifyIntrinsics.cpp

9

181

I'm a bit unsure about this condition. What's args[3] and what's args[4]? And why isZero(args[3])?

flang/test/Transforms/simplifyintrinsics.fir

38

What if fir.call @_FortranASumInteger4({{.*}}) happens before fir.call @_FortranASumInteger4_simplified? Same for other instances of CHECK-NOT.

[clementval]

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

177

And you can probably run directly on Operation since each call can be dealt with individually.

[Leporacanthicus]

Updates to review comments:

• Add a few more comments, and update others.
• Add extra check-not lines.
• Change from mlir::ModuleOp to mlir::func::FuncOp for pass.

[Leporacanthicus]

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

177

I tried to use fir::CallOp, but it doesn't recognize that. If I try to include FIROps.h so it does recognize it, lots of errors occur, and I couldn't make that work at all. I tried mlir::Operation too, but I don't think that helps much, and I couldn't make it work.

I have updated to use `mlir::func::FuncOp' for now.

177

Does that mean you have to worry about locks and things updating the module? Or is that taken care of in some magic way? Or did I misunderstand "in parallel"?

flang/lib/Optimizer/Transforms/SimplifyIntrinsics.cpp

181

I've added another comment with the SUM C++ runtime prototype declaration, and added two variables to give names to args[3] and args[4]. As well as a comment to explain why args[1] and args[3] are ignored.

flang/test/Transforms/simplifyintrinsics.fir

38

Well, I guess I can add one before. But then what if it's two lines away? Or three? After all CHECK_NOT only checks between THIS and the NEXT line. Maybe the right thing is to add another run line using a NEWPREFIX, and ONLY have NEWPREFIX-NOT lines?

I don't know the right answer here, so I have just put one more CHECK-NOT line in each place.

[clementval]

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

177

If you modify parent operations (outside of the function) then you might have problem.

You have more information here: https://mlir.llvm.org/docs/PassManagement/#operation-pass

[awarzynski]

Thanks for the updates and addressing my comments. I've left a few more, but in general this looks good to me and I will approve once these are addressed too.

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

177–183

I think that it would make the description a bit more specific. Perhaps:

Qualifying intrinsic calls are replaced with calls to specialised and simplified intrinsic routines, which are inserted into the current module during the pass execution.

Or something similar :)

flang/lib/Optimizer/Transforms/SimplifyIntrinsics.cpp

182

SUM is not simplified here ;-) Instead, a call to SUM is replaced with a call to a simplified and specialised version of SUM.

206–207

It would be worth adding a test with two calls to SUM. This way you can verify that _FortranASumInteger4_simplified is only "injected" once.

[Leporacanthicus]

Updated test to cover "two calls in same module".

Amended a few comments.

[Leporacanthicus]

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

177

Thanks for the link. As per Slack discussion, to avoid breaking the rules, and adding functions to the module, this should be a mlir::ModuleOp pass - a comment is added to clarify this in the file too.

[awarzynski]

LGTM, thanks again for working on this! Please wait for other active reviewers to approve as well before merging.

[shraiysh]

LGTM, minor comments. Please let me know what you think!

flang/lib/Optimizer/Transforms/SimplifyIntrinsics.cpp

49

Two small comments -

1. Can we make the function name more descriptive (getOrCreateSumFunction)?
2. Also, it would be nice if we could return null value when this function is called requesting some other function (indicating that we do not generate that function yet). For example, if this function is called on max intrinsic, we will return implementation of sum and it would be nice if we could avoid that. Is it reliable to check the basename is to make this decision and return null?

[Leporacanthicus]

Added comment to clarify generic function name.
Added assert to catch "wrong use" of function.
Added new test for strided array values.

[peixin]

LGTM. Some nit comments.

BTW, do you consider add this option to the driver flang-new?

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

179

flang/lib/Optimizer/Transforms/SimplifyIntrinsics.cpp

17

It may need multiple loops for multi-D array.

133

else if (integer type)

res = ...

else

TODO

208

Do you consider match the data type instead of matching the string? https://github.com/llvm/llvm-project/blob/7912b1f8e7c845a97411cbfc176db56861cdf116/flang/lib/Optimizer/Builder/Runtime/Reduction.cpp#L864-L902

It's ok to me if you want keep the current method. You can also consider this when expand the inline to more data types. Anyway, this is not hard comment and fell free to ignore this.

flang/test/Transforms/simplifyintrinsics.fir

38

No need to add CHECK-NOT after _FortranASumInteger4_simplified.

98

This is not necessary to add it after _FortranASumInteger4. The same for the following.

[Leporacanthicus]

flang/lib/Optimizer/Transforms/SimplifyIntrinsics.cpp

49

So, my idea is that this will be changed when we add support for more functions, to take a function (lambda or similar) that actually fills in the function, and that ALL generation of new functions go through this one function.

I have added a comment to explain that, and I have also added an assert to check the name string, just in case someone believes the funcition will magically work for PRODUCT, MAXVAL or some other intrinsic.

[Leporacanthicus]

Update for review comments:

• add TODO to mark "this is not supported"
• clarify comment that number of loops may depend on dimensions

[Leporacanthicus]

flang/lib/Optimizer/Transforms/SimplifyIntrinsics.cpp

208

I will change that in the next version, when also introducing support for at least one more function - assuming there's no problems from that.

I have started on a follow-on patch, which refactors things for the purpose of supporting multiple functions.

flang/test/Transforms/simplifyintrinsics.fir

98

Can you explain why? I added it because we want to make sure it's not adding a new call.

[peixin]

flang/lib/Optimizer/Transforms/SimplifyIntrinsics.cpp

208

Sounds good to me.

flang/test/Transforms/simplifyintrinsics.fir

98

If you use CHECK-NEXT-NOT: in line 95, it will check if the next string has _FortranASumInteger4(.... If you use CHECK-NOT in line 95, it will check if there is one string of fir.call @_FortranASumInteger4(... after line 94 to the end. Check here.

[awarzynski]

flang/test/Transforms/simplifyintrinsics.fir

98

@peixin I'm not sure that this would work here. The docs only say that:

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

Which means that the following:

// CHECK-LABEL:   func.func @sum_2d_array_int
// CHECK-NOT:       fir.call @_FortranASumInteger4_simplified
// CHECK:           fir.call @_FortranASumInteger4

will reject this (desirable):

func.func @sum_2d_array_int {
  fir.call @_FortranASumInteger4_simplified 
  fir.call @_FortranASumInteger4

but will happily accept this (not desirable) :

func.func @sum_2d_array_int {
   fir.call @_FortranASumInteger4
   fir.call @_FortranASumInteger4_simplified

Here's a small reproducer that you can play with:

• input.f90

aaa
bbb
ccc
ddd

• experiment.f90

! RUN: cat %S/input.f90 | FileCheck %s

! CHECK: aaa
! CHECK-NOT: ccc
! CHECK: bbb
! CHECK: ddd

This test passes for me, which demonstrates that ! CHECK-NOT: ccc is not sufficient to protect against ccc appearing *after* bbb.

I think the best way to avoid duplicating CHECK-NOT would be this pattern:

! CHECK-DAG: <something expected>
! CHECK-NOT:       fir.call @_FortranASumInteger4_simplified
! CHECK-DAG: <something expected, e.g. return>

This way you can specify the there should be no calls to _FortranASumInteger4_simplified between two surrounding CHECK-DAG. But, IIUC, you can't mix it with CHECK-LABEL, so this it not available here.

Does this make sense to you or am I confusing everything and everyone? :)

[peixin]

flang/test/Transforms/simplifyintrinsics.fir

98

Right. My understanding was not correct. Thanks.

[vzakhari]

flang/lib/Optimizer/Transforms/SimplifyIntrinsics.cpp

28

I see. Thanks for explanation.

198

typo

234

nit, style: please try to make the anonymous namespace shorter (https://llvm.org/docs/CodingStandards.html#anonymous-namespaces)

[Leporacanthicus]

flang/lib/Optimizer/Transforms/SimplifyIntrinsics.cpp

234

Thanks for pointing that out. I changed the inline to static to make sure they are not interfering with other functions that may have same/similar names.

[vzakhari]

flang/lib/Optimizer/Transforms/SimplifyIntrinsics.cpp

234

Thanks! LGTM

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

 std::unique_ptr<mlir::Pass> createAffineDemotionPass();
 std::unique_ptr<mlir::Pass> createArrayValueCopyPass();
 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();
 std::unique_ptr<mlir::Pass> createMemoryAllocationPass();
+std::unique_ptr<mlir::Pass> createSimplifyIntrinsicsPass();
+
 std::unique_ptr<mlir::Pass>
 createMemoryAllocationPass(bool dynOnHeap, std::size_t maxStackSize);
 std::unique_ptr<mlir::Pass> createAnnotateConstantOperandsPass();
 std::unique_ptr<mlir::Pass> createSimplifyRegionLitePass();
 std::unique_ptr<mlir::Pass> createAlgebraicSimplificationPass();
 
 // declarative passes
 #define GEN_PASS_REGISTRATION
 #include "flang/Optimizer/Transforms/Passes.h.inc"
 
 } // namespace fir
 
 #endif // FORTRAN_OPTIMIZER_TRANSFORMS_PASSES_H

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

let description = [{
     potentially the entire allocation if all the accesses are forwarded.
   }];
   let constructor = "::fir::createMemDataFlowOptPass()";
   let dependentDialects = [
     "fir::FIROpsDialect", "mlir::func::FuncDialect"
   ];
 }
 
+// This needs to be a "mlir::ModuleOp" pass, because it inserts simplified
+// functions into the module, which is invalid if a finer grain mlir::Operation
+// is used as the pass specification says to not touch things outside hte scope
+// of the operation being processed.
+def SimplifyIntrinsics : Pass<"simplify-intrinsics", "mlir::ModuleOp"> {
+  let summary = "Intrinsics simplification";
+  let description = [{
+    Qualifying intrinsics calls are replaced with calls to a specialized and
+    simplified function. The simplified function is added to the current module.
+    This function can be inlined by a general purpose inlining pass.
+  }];
+  let constructor = "::fir::createSimplifyIntrinsicsPass()";
+}
+
 def MemoryAllocationOpt : Pass<"memory-allocation-opt", "mlir::func::FuncOp"> {
   let summary = "Convert stack to heap allocations and vice versa.";
   let description = [{
     Convert stack allocations to heap allocations and vice versa based on
     estimated size, lifetime, usage patterns, the call tree, etc.
   }];
   let dependentDialects = [ "fir::FIROpsDialect" ];
   let options = [

flang/lib/Optimizer/Transforms/CMakeLists.txt

 add_flang_library(FIRTransforms
   AbstractResult.cpp
   AffinePromotion.cpp
   AffineDemotion.cpp
   AnnotateConstant.cpp
   CharacterConversion.cpp
   ArrayValueCopy.cpp
   ExternalNameConversion.cpp
   MemoryAllocation.cpp
   MemRefDataFlowOpt.cpp
   RewriteLoop.cpp
   SimplifyRegionLite.cpp
   AlgebraicSimplification.cpp
+  SimplifyIntrinsics.cpp
 
   DEPENDS
   FIRBuilder
   FIRDialect
   FIRSupport
   FIROptTransformsPassIncGen
 
   LINK_LIBS

flang/lib/Optimizer/Transforms/SimplifyIntrinsics.cpp

+//===- SimplifyIntrinsics.cpp -- replace intrinsics with simpler form -----===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+//===----------------------------------------------------------------------===//
+/// \file
+/// This pass looks for suitable calls to runtime library for intrinsics that
+/// can be simplified/specialized and replaces with a specialized function.
+///
+/// For example, SUM(arr) can be specialized as a simple function with one loop,
+/// compared to the three arguments (plus file & line info) that the runtime
+/// call has.
+///
+/// The general idea is that besides making the call simpler, it can also be
+/// inlined by other passes that run after this pass, which further improves
+/// performance, particularly when the work done in the function is trivial
+/// and small in size.
+//===----------------------------------------------------------------------===//
+
+#include "PassDetail.h"
+#include "flang/Optimizer/Builder/BoxValue.h"
+#include "flang/Optimizer/Builder/FIRBuilder.h"
+#include "flang/Optimizer/Dialect/FIROps.h"
+#include "flang/Optimizer/Dialect/FIRType.h"
+#include "flang/Optimizer/Support/FIRContext.h"
+#include "flang/Optimizer/Transforms/Passes.h"
+#include "mlir/IR/Matchers.h"
+#include "mlir/Pass/Pass.h"
+#include "mlir/Transforms/DialectConversion.h"
+#include "mlir/Transforms/GreedyPatternRewriteDriver.h"
+#include "mlir/Transforms/RegionUtils.h"
+
+namespace {
+
+class SimplifyIntrinsicsPass
+    : public fir::SimplifyIntrinsicsBase<SimplifyIntrinsicsPass> {
+public:
+  mlir::func::FuncOp getOrCreateFunction(const mlir::Location &loc,
+                                         fir::FirOpBuilder &builder,
+                                         const mlir::Type &type,
+                                         const mlir::StringRef &basename);
+  void runOnOperation() override;
+};
+
+mlir::func::FuncOp SimplifyIntrinsicsPass::getOrCreateFunction(
+    const mlir::Location &loc, fir::FirOpBuilder &builder,
+    const mlir::Type &type, const mlir::StringRef &basename) {
+  std::string replacementName = mlir::Twine{basename, "_simplified"}.str();
+  mlir::ModuleOp module = builder.getModule();
+  // If we already have a function, just return it.
+  mlir::func::FuncOp newFunc =
+      fir::FirOpBuilder::getNamedFunction(module, replacementName);
+  if (newFunc)
+    return newFunc;
+
+  // Need to build the function!
+  // Basic idea:
+  // function FortranASum<T>_simplified(arr)
+  //   T, dimension(:) :: arr
+  //   T sum = 0
+  //   integer iter
+  //   do iter = 0, extent(arr)
+  //     sum = sum + arr[iter]
+  //   end do
+  //   FortranASum<T>_simplified = sum
+  // end function FortranASum<T>_simplified
+  mlir::Type boxType = fir::BoxType::get(builder.getNoneType());
+  mlir::FunctionType fType =
+      mlir::FunctionType::get(builder.getContext(), {boxType}, {type});
+  newFunc =
+      fir::FirOpBuilder::createFunction(loc, module, replacementName, fType);
+  auto inlineLinkage = mlir::LLVM::linkage::Linkage::LinkonceODR;
+  auto linkage =
+      mlir::LLVM::LinkageAttr::get(builder.getContext(), inlineLinkage);
+  newFunc->setAttr("llvm.linkage", linkage);
+
+  // Save the position of the original call.
+  mlir::OpBuilder::InsertPoint insertPt = builder.saveInsertionPoint();
+  builder.setInsertionPointToEnd(newFunc.addEntryBlock());
+
+  mlir::IndexType idxTy = builder.getIndexType();
+
+  mlir::Value zero = type.isa<mlir::FloatType>()
+                         ? builder.createRealConstant(loc, type, 0.0)
+                         : builder.createIntegerConstant(loc, type, 0);
+  mlir::Value sum = builder.create<fir::AllocaOp>(loc, type);
+  builder.create<fir::StoreOp>(loc, zero, sum);
+
+  mlir::Block::BlockArgListType args = newFunc.front().getArguments();
+  mlir::Value arg = args[0];
+
+  mlir::Value zeroIdx = builder.createIntegerConstant(loc, idxTy, 0);
+
+  fir::SequenceType::Shape flatShape = {fir::SequenceType::getUnknownExtent()};
+  mlir::Type arrTy = fir::SequenceType::get(flatShape, type);
+  mlir::Type boxArrTy = fir::BoxType::get(arrTy);
+  mlir::Value array = builder.create<fir::ConvertOp>(loc, boxArrTy, arg);
+  auto dims =
+      builder.create<fir::BoxDimsOp>(loc, idxTy, idxTy, idxTy, array, zeroIdx);
+  mlir::Value len = dims.getResult(1);
+  mlir::Value one = builder.createIntegerConstant(loc, idxTy, 1);
+  mlir::Value step = one;
+
+  // We use C indexing here, so len-1 as loopcount
+  mlir::Value loopCount = builder.create<mlir::arith::SubIOp>(loc, len, one);
+  auto loop = builder.create<fir::DoLoopOp>(loc, zeroIdx, loopCount, step);
+
+  // Begin loop code
+  mlir::OpBuilder::InsertPoint loopEndPt = builder.saveInsertionPoint();
+  builder.setInsertionPointToStart(loop.getBody());
+
+  mlir::Type eleRefTy = builder.getRefType(type);
+  mlir::Value index = loop.getInductionVar();
+  mlir::Value addr =
+      builder.create<fir::CoordinateOp>(loc, eleRefTy, array, index);
+  mlir::Value elem = builder.create<fir::LoadOp>(loc, addr);
+  mlir::Value sumVal = builder.create<fir::LoadOp>(loc, sum);
+
+  mlir::Value res;
+  if (type.isa<mlir::FloatType>())
+    res = builder.create<mlir::arith::AddFOp>(loc, elem, sumVal);
+  else
+    res = builder.create<mlir::arith::AddIOp>(loc, elem, sumVal);
+  builder.create<fir::StoreOp>(loc, res, sum);
+  // End of loop.
+  builder.restoreInsertionPoint(loopEndPt);
+
+  mlir::Value resultVal = builder.create<fir::LoadOp>(loc, sum);
+  builder.create<mlir::func::ReturnOp>(loc, resultVal);
+
+  // Now back to where we were adding code earlier...
+  builder.restoreInsertionPoint(insertPt);
+
+  return newFunc;
+}
+
+inline bool isOperandAbsent(mlir::Value val) {
+  if (mlir::Operation *op = val.getDefiningOp())
+    return mlir::isa_and_nonnull<fir::AbsentOp>(
+        op->getOperand(0).getDefiningOp());
+  return false;
+}
+
+inline bool isZero(mlir::Value val) {
+  if (mlir::Operation *op = val.getDefiningOp())
+    if (mlir::Operation *defOp = op->getOperand(0).getDefiningOp())
+      return mlir::matchPattern(defOp, mlir::m_Zero());
+  return false;
+}
+
+inline ::mlir::Value findShape(mlir::Value val) {
+  mlir::Operation *defOp = val.getDefiningOp();
+  while (defOp) {
+    defOp = defOp->getOperand(0).getDefiningOp();
+    if (fir::EmboxOp box = mlir::dyn_cast_or_null<fir::EmboxOp>(defOp))
+      return box.getShape();
+  }
+  return {};
+}
+
+inline unsigned getDimCount(mlir::Value val) {
+  if (mlir::Value shapeVal = findShape(val)) {
+    mlir::Type resType = shapeVal.getDefiningOp()->getResultTypes()[0];
+    return fir::getRankOfShapeType(resType);
+  }
+  return 0;
+}
+
+void SimplifyIntrinsicsPass::runOnOperation() {
+  mlir::ModuleOp module = getOperation();
+  fir::KindMapping kindMap = fir::getKindMapping(module);
+  module.walk([&](mlir::Operation *op) {
+    if (auto call = mlir::dyn_cast<fir::CallOp>(op)) {
+      if (mlir::SymbolRefAttr callee = call.getCalleeAttr()) {
+        mlir::StringRef funcName = callee.getLeafReference().getValue();
+        // Replace call to runtime function for SUM when it has single
+        // argument (no dim or mask argument) for 1D arrays with either
+        // Integer4 or Real8 types. Other forms are ignored.
+        // The new function is added to the module.
+        //
+        // Prototype for runtime call (from sum.cpp):
+        // RTNAME(Sum<T>) )(const Descriptor &x, const char *source, int line,
+        // int dim, const Descriptor *mask)
+        if (funcName.startswith("_FortranASum")) {
+          mlir::Operation::operand_range args = call.getArgs();
+          // args[1] and args[2] are source filename and line number, ignored.
+          const mlir::Value &dim = args[3];
+          const mlir::Value &mask = args[4];
+          // dim is zero when it is absent, which is an implementation
+          // detail in the runtime library.
+          bool dimAndMaskAbsent = isZero(dim) && isOperandAbsent(mask);
+          unsigned rank = getDimCount(args[0]);
+          if (dimAndMaskAbsent && rank == 1) {
+            mlir::Location loc = call.getLoc();
+            mlir::Type type;
+            fir::FirOpBuilder builder(op, kindMap);
+            if (funcName.endswith("Integer4")) {
+              type = mlir::IntegerType::get(builder.getContext(), 32);
+            } else if (funcName.endswith("Real8")) {
+              type = mlir::FloatType::getF64(builder.getContext());
+            } else {
+              return;
+            }
+            mlir::func::FuncOp newFunc =
+                getOrCreateFunction(loc, builder, type, funcName);
+            auto newCall = builder.create<fir::CallOp>(
+                loc, newFunc, mlir::ValueRange{args[0]});
+            call->replaceAllUsesWith(newCall.getResults());
+            call->dropAllReferences();
+            call->erase();
+          }
+        }
+      }
+    }
+  });
+}
+
+} // namespace
+
+std::unique_ptr<mlir::Pass> fir::createSimplifyIntrinsicsPass() {
+  return std::make_unique<SimplifyIntrinsicsPass>();
+}

flang/test/Transforms/simplifyintrinsics.fir

+// RUN: fir-opt --split-input-file --simplify-intrinsics %s | FileCheck %s
+
+// Call to SUM with 1D I32 array is replaced.
+module attributes {fir.defaultkind = "a1c4d8i4l4r4", fir.kindmap = "", llvm.target_triple = "native"} {
+  func.func @sum_1d_array_int(%arg0: !fir.ref<!fir.array<10xi32>> {fir.bindc_name = "a"}) -> i32 {
+    %c10 = arith.constant 10 : index
+    %0 = fir.alloca i32 {bindc_name = "test_sum_2", uniq_name = "_QFtest_sum_2Etest_sum_2"}
+    %1 = fir.shape %c10 : (index) -> !fir.shape<1>
+    %2 = fir.embox %arg0(%1) : (!fir.ref<!fir.array<10xi32>>, !fir.shape<1>) -> !fir.box<!fir.array<10xi32>>
+    %3 = fir.absent !fir.box<i1>
+    %c0 = arith.constant 0 : index
+    %4 = fir.address_of(@_QQcl.2E2F6973756D5F322E66393000) : !fir.ref<!fir.char<1,13>>
+    %c5_i32 = arith.constant 5 : i32
+    %5 = fir.convert %2 : (!fir.box<!fir.array<10xi32>>) -> !fir.box<none>
+    %6 = fir.convert %4 : (!fir.ref<!fir.char<1,13>>) -> !fir.ref<i8>
+    %7 = fir.convert %c0 : (index) -> i32
+    %8 = fir.convert %3 : (!fir.box<i1>) -> !fir.box<none>
+    %9 = fir.call @_FortranASumInteger4(%5, %6, %c5_i32, %7, %8) : (!fir.box<none>, !fir.ref<i8>, i32, i32, !fir.box<none>) -> i32
+    fir.store %9 to %0 : !fir.ref<i32>
+    %10 = fir.load %0 : !fir.ref<i32>
+    return %10 : i32
+  }
+  func.func private @_FortranASumInteger4(!fir.box<none>, !fir.ref<i8>, i32, i32, !fir.box<none>) -> i32 attributes {fir.runtime}
+  fir.global linkonce @_QQcl.2E2F6973756D5F322E66393000 constant : !fir.char<1,13> {
+    %0 = fir.string_lit "./isum_2.f90\00"(13) : !fir.char<1,13>
+    fir.has_value %0 : !fir.char<1,13>
+  }
+}
+
+
+// CHECK-LABEL:   func.func @sum_1d_array_int(
+// CHECK-SAME:                             %[[A:.*]]: !fir.ref<!fir.array<10xi32>> {fir.bindc_name = "a"}) -> i32 {
+// CHECK:           %[[SHAPE:.*]] = fir.shape %{{.*}} : (index) -> !fir.shape<1>
+// CHECK:           %[[A_BOX_I32:.*]] = fir.embox %[[A]](%[[SHAPE]]) : (!fir.ref<!fir.array<10xi32>>, !fir.shape<1>) -> !fir.box<!fir.array<10xi32>>
+// CHECK:           %[[A_BOX_NONE:.*]] = fir.convert %[[A_BOX_I32]] : (!fir.box<!fir.array<10xi32>>) -> !fir.box<none>
+// CHECK-NOT:       fir.call @_FortranASumInteger4({{.*}})
+// CHECK:           %[[RES:.*]] = fir.call @_FortranASumInteger4_simplified(%[[A_BOX_NONE]]) : (!fir.box<none>) -> i32
+// CHECK-NOT:       fir.call @_FortranASumInteger4({{.*}})
+// CHECK:           return %{{.*}} : i32
+// CHECK:         }
+// CHECK:         func.func private @_FortranASumInteger4(!fir.box<none>, !fir.ref<i8>, i32, i32, !fir.box<none>) -> i32 attributes {fir.runtime}
+
+// CHECK-LABEL:   func.func private @_FortranASumInteger4_simplified(
+// CHECK-SAME:                                                       %[[ARR:.*]]: !fir.box<none>) -> i32 attributes {llvm.linkage = #llvm.linkage<linkonce_odr>} {
+// CHECK:           %[[CI32_0:.*]] = arith.constant 0 : i32
+// CHECK:           %[[SUM:.*]] = fir.alloca i32
+// CHECK:           fir.store %[[CI32_0]] to %[[SUM]] : !fir.ref<i32>
+// CHECK:           %[[CINDEX_0:.*]] = arith.constant 0 : index
+// CHECK:           %[[ARR_BOX_I32:.*]] = fir.convert %[[ARR]] : (!fir.box<none>) -> !fir.box<!fir.array<?xi32>>
+// CHECK:           %[[DIMS:.*]]:3 = fir.box_dims %[[ARR_BOX_I32]], %[[CINDEX_0]] : (!fir.box<!fir.array<?xi32>>, index) -> (index, index, index)
+// CHECK:           %[[CINDEX_1:.*]] = arith.constant 1 : index
+// CHECK:           %[[EXTENT:.*]] = arith.subi %[[DIMS]]#1, %[[CINDEX_1]] : index
+// CHECK:           fir.do_loop %[[ITER:.*]] = %[[CINDEX_0]] to %[[EXTENT]] step %[[CINDEX_1]] {
+// CHECK:             %[[ITEM:.*]] = fir.coordinate_of %[[ARR_BOX_I32]], %[[ITER]] : (!fir.box<!fir.array<?xi32>>, index) -> !fir.ref<i32>
+// CHECK:             %[[ITEM_VAL:.*]] = fir.load %[[ITEM]] : !fir.ref<i32>
+// CHECK:             %[[SUM_VAL:.*]] = fir.load %[[SUM]] : !fir.ref<i32>
+// CHECK:             %[[NEW_SUM:.*]] = arith.addi %[[ITEM_VAL]], %[[SUM_VAL]] : i32
+// CHECK:             fir.store %[[NEW_SUM]] to %[[SUM]] : !fir.ref<i32>
+// CHECK:           }
+// CHECK:           %[[RET:.*]] = fir.load %[[SUM]] : !fir.ref<i32>
+// CHECK:           return %[[RET]] : i32
+// CHECK:         }
+
+// -----
+
+// Call to SUM with 2D I32 arrays is not replaced.
+module attributes {fir.defaultkind = "a1c4d8i4l4r4", fir.kindmap = "", llvm.target_triple = "native"} {
+  func.func @sum_2d_array_int(%arg0: !fir.ref<!fir.array<10x10xi32>> {fir.bindc_name = "a"}) -> i32 {
+    %c10 = arith.constant 10 : index
+    %c10_0 = arith.constant 10 : index
+    %0 = fir.alloca i32 {bindc_name = "test_sum_3", uniq_name = "_QFtest_sum_3Etest_sum_3"}
+    %1 = fir.shape %c10, %c10_0 : (index, index) -> !fir.shape<2>
+    %2 = fir.embox %arg0(%1) : (!fir.ref<!fir.array<10x10xi32>>, !fir.shape<2>) -> !fir.box<!fir.array<10x10xi32>>
+    %3 = fir.absent !fir.box<i1>
+    %c0 = arith.constant 0 : index
+    %4 = fir.address_of(@_QQcl.2E2F6973756D5F332E66393000) : !fir.ref<!fir.char<1,13>>
+    %c5_i32 = arith.constant 5 : i32
+    %5 = fir.convert %2 : (!fir.box<!fir.array<10x10xi32>>) -> !fir.box<none>
+    %6 = fir.convert %4 : (!fir.ref<!fir.char<1,13>>) -> !fir.ref<i8>
+    %7 = fir.convert %c0 : (index) -> i32
+    %8 = fir.convert %3 : (!fir.box<i1>) -> !fir.box<none>
+    %9 = fir.call @_FortranASumInteger4(%5, %6, %c5_i32, %7, %8) : (!fir.box<none>, !fir.ref<i8>, i32, i32, !fir.box<none>) -> i32
+    fir.store %9 to %0 : !fir.ref<i32>
+    %10 = fir.load %0 : !fir.ref<i32>
+    return %10 : i32
+  }
+  func.func private @_FortranASumInteger4(!fir.box<none>, !fir.ref<i8>, i32, i32, !fir.box<none>) -> i32 attributes {fir.runtime}
+  fir.global linkonce @_QQcl.2E2F6973756D5F332E66393000 constant : !fir.char<1,13> {
+    %0 = fir.string_lit "./isum_3.f90\00"(13) : !fir.char<1,13>
+    fir.has_value %0 : !fir.char<1,13>
+  }
+}
+
+// CHECK-LABEL:   func.func @sum_2d_array_int({{.*}} !fir.ref<!fir.array<10x10xi32>> {fir.bindc_name = "a"}) -> i32 {
+// CHECK-NOT:       fir.call @_FortranASumInteger4_simplified({{.*}})
+// CHECK:           fir.call @_FortranASumInteger4({{.*}}) : (!fir.box<none>, !fir.ref<i8>, i32, i32, !fir.box<none>) -> i32
+// CHECK-NOT:       fir.call @_FortranASumInteger4_simplified({{.*}})
+
+// -----
+
+// Call to SUM with 1D F64 is replaced.
+module attributes {fir.defaultkind = "a1c4d8i4l4r4", fir.kindmap = "", llvm.target_triple = "native"} {
+  func.func @sum_1d_real(%arg0: !fir.ref<!fir.array<10xf64>> {fir.bindc_name = "a"}) -> f64 {
+    %c10 = arith.constant 10 : index
+    %0 = fir.alloca f64 {bindc_name = "sum_1d_real", uniq_name = "_QFsum_1d_realEsum_1d_real"}
+    %1 = fir.shape %c10 : (index) -> !fir.shape<1>
+    %2 = fir.embox %arg0(%1) : (!fir.ref<!fir.array<10xf64>>, !fir.shape<1>) -> !fir.box<!fir.array<10xf64>>
+    %3 = fir.absent !fir.box<i1>
+    %c0 = arith.constant 0 : index
+    %4 = fir.address_of(@_QQcl.2E2F6973756D5F352E66393000) : !fir.ref<!fir.char<1,13>>
+    %c5_i32 = arith.constant 5 : i32
+    %5 = fir.convert %2 : (!fir.box<!fir.array<10xf64>>) -> !fir.box<none>
+    %6 = fir.convert %4 : (!fir.ref<!fir.char<1,13>>) -> !fir.ref<i8>
+    %7 = fir.convert %c0 : (index) -> i32
+    %8 = fir.convert %3 : (!fir.box<i1>) -> !fir.box<none>
+    %9 = fir.call @_FortranASumReal8(%5, %6, %c5_i32, %7, %8) : (!fir.box<none>, !fir.ref<i8>, i32, i32, !fir.box<none>) -> f64
+    fir.store %9 to %0 : !fir.ref<f64>
+    %10 = fir.load %0 : !fir.ref<f64>
+    return %10 : f64
+  }
+  func.func private @_FortranASumReal8(!fir.box<none>, !fir.ref<i8>, i32, i32, !fir.box<none>) -> f64 attributes {fir.runtime}
+  fir.global linkonce @_QQcl.2E2F6973756D5F352E66393000 constant : !fir.char<1,13> {
+    %0 = fir.string_lit "./isum_5.f90\00"(13) : !fir.char<1,13>
+    fir.has_value %0 : !fir.char<1,13>
+  }
+}
+
+
+// CHECK-LABEL:   func.func @sum_1d_real(
+// CHECK-SAME:                           %[[A:.*]]: !fir.ref<!fir.array<10xf64>> {fir.bindc_name = "a"}) -> f64 {
+// CHECK:           %[[CINDEX_10:.*]] = arith.constant 10 : index
+// CHECK:           %[[SHAPE:.*]] = fir.shape %[[CINDEX_10]] : (index) -> !fir.shape<1>
+// CHECK:           %[[A_BOX_F64:.*]] = fir.embox %[[A]](%[[SHAPE]]) : (!fir.ref<!fir.array<10xf64>>, !fir.shape<1>) -> !fir.box<!fir.array<10xf64>>
+// CHECK:           %[[A_BOX_NONE:.*]] = fir.convert %[[A_BOX_F64]] : (!fir.box<!fir.array<10xf64>>) -> !fir.box<none>
+// CHECK-NOT:       fir.call @_FortranASumReal8({{.*}})
+// CHECK:           %[[RES:.*]] = fir.call @_FortranASumReal8_simplified(%[[A_BOX_NONE]]) : (!fir.box<none>) -> f64
+// CHECK-NOT:       fir.call @_FortranASumReal8({{.*}})
+// CHECK:           return %{{.*}} : f64
+// CHECK:         }
+
+// CHECK-LABEL:   func.func private @_FortranASumReal8_simplified(
+// CHECK-SAME:                                                    %[[ARR:.*]]: !fir.box<none>) -> f64 attributes {llvm.linkage = #llvm.linkage<linkonce_odr>} {
+// CHECK:           %[[ZERO:.*]] = arith.constant 0.000000e+00 : f64
+// CHECK:           %[[SUM:.*]] = fir.alloca f64
+// CHECK:           fir.store %[[ZERO]] to %[[SUM]] : !fir.ref<f64>
+// CHECK:           %[[CINDEX_0:.*]] = arith.constant 0 : index
+// CHECK:           %[[ARR_BOX_F64:.*]] = fir.convert %[[ARR]] : (!fir.box<none>) -> !fir.box<!fir.array<?xf64>>
+// CHECK:           %[[DIMS:.*]]:3 = fir.box_dims %[[ARR_BOX_F64]], %[[CINDEX_0]] : (!fir.box<!fir.array<?xf64>>, index) -> (index, index, index)
+// CHECK:           %[[CINDEX_1:.*]] = arith.constant 1 : index
+// CHECK:           %[[EXTENT:.*]] = arith.subi %[[DIMS]]#1, %[[CINDEX_1]] : index
+// CHECK:           fir.do_loop %[[ITER:.*]] = %[[CINDEX_0]] to %[[EXTENT]] step %[[CINDEX_1]] {
+// CHECK:             %[[ITEM:.*]] = fir.coordinate_of %[[ARR_BOX_F64]], %[[ITER]] : (!fir.box<!fir.array<?xf64>>, index) -> !fir.ref<f64>
+// CHECK:             %[[ITEM_VAL:.*]] = fir.load %[[ITEM]] : !fir.ref<f64>
+// CHECK:             %[[SUM_VAL:.*]] = fir.load %[[SUM]] : !fir.ref<f64>
+// CHECK:             %[[NEW_SUM:.*]] = arith.addf %[[ITEM_VAL]], %[[SUM_VAL]] : f64
+// CHECK:             fir.store %[[NEW_SUM]] to %[[SUM]] : !fir.ref<f64>
+// CHECK:           }
+// CHECK:           %[[RES:.*]] = fir.load %[[SUM]] : !fir.ref<f64>
+// CHECK:           return %[[RES]] : f64
+// CHECK:         }
+
+// -----
+
+// Call to SUM with 1D COMPLEX array is not replaced.
+module attributes {fir.defaultkind = "a1c4d8i4l4r4", fir.kindmap = "", llvm.target_triple = "native"} {
+  func.func @sum_1d_complex(%arg0: !fir.ref<!fir.array<10x!fir.complex<4>>> {fir.bindc_name = "a"}) -> !fir.complex<4> {
+    %0 = fir.alloca !fir.complex<4>
+    %c10 = arith.constant 10 : index
+    %1 = fir.alloca !fir.complex<4> {bindc_name = "sum_1d_complex", uniq_name = "_QFsum_1d_complexEsum_1d_complex"}
+    %2 = fir.shape %c10 : (index) -> !fir.shape<1>
+    %3 = fir.embox %arg0(%2) : (!fir.ref<!fir.array<10x!fir.complex<4>>>, !fir.shape<1>) -> !fir.box<!fir.array<10x!fir.complex<4>>>
+    %4 = fir.absent !fir.box<i1>
+    %c0 = arith.constant 0 : index
+    %5 = fir.address_of(@_QQcl.2E2F6973756D5F362E66393000) : !fir.ref<!fir.char<1,13>>
+    %c5_i32 = arith.constant 5 : i32
+    %6 = fir.convert %0 : (!fir.ref<!fir.complex<4>>) -> !fir.ref<complex<f32>>
+    %7 = fir.convert %3 : (!fir.box<!fir.array<10x!fir.complex<4>>>) -> !fir.box<none>
+    %8 = fir.convert %5 : (!fir.ref<!fir.char<1,13>>) -> !fir.ref<i8>
+    %9 = fir.convert %c0 : (index) -> i32
+    %10 = fir.convert %4 : (!fir.box<i1>) -> !fir.box<none>
+    %11 = fir.call @_FortranACppSumComplex4(%6, %7, %8, %c5_i32, %9, %10) : (!fir.ref<complex<f32>>, !fir.box<none>, !fir.ref<i8>, i32, i32, !fir.box<none>) -> none
+    %12 = fir.load %0 : !fir.ref<!fir.complex<4>>
+    fir.store %12 to %1 : !fir.ref<!fir.complex<4>>
+    %13 = fir.load %1 : !fir.ref<!fir.complex<4>>
+    return %13 : !fir.complex<4>
+  }
+  func.func private @_FortranACppSumComplex4(!fir.ref<complex<f32>>, !fir.box<none>, !fir.ref<i8>, i32, i32, !fir.box<none>) -> none attributes {fir.runtime}
+  fir.global linkonce @_QQcl.2E2F6973756D5F362E66393000 constant : !fir.char<1,13> {
+    %0 = fir.string_lit "./isum_6.f90\00"(13) : !fir.char<1,13>
+    fir.has_value %0 : !fir.char<1,13>
+  }
+}
+
+// CHECK-LABEL:   func.func @sum_1d_complex(%{{.*}}: !fir.ref<!fir.array<10x!fir.complex<4>>> {fir.bindc_name = "a"}) -> !fir.complex<4> {
+// CHECK-NOT:       fir.call @_FortranACppSumComplex4_simplified({{.*}})
+// CHECK:           fir.call @_FortranACppSumComplex4({{.*}}) : (!fir.ref<complex<f32>>, !fir.box<none>, !fir.ref<i8>, i32, i32, !fir.box<none>) -> none
+// CHECK-NOT:       fir.call @_FortranACppSumComplex4_simplified({{.*}})
+
+// -----
+
+// Test that two functions calling the same SUM function
+// generates only ONE function declaration (and that both
+// calls are converted)
+module attributes {fir.defaultkind = "a1c4d8i4l4r4", fir.kindmap = "", llvm.target_triple = "native"} {
+  func.func @sum_1d_calla(%arg0: !fir.ref<!fir.array<10xi32>> {fir.bindc_name = "a"}) -> i32 {
+    %c10 = arith.constant 10 : index
+    %0 = fir.alloca i32 {bindc_name = "sum_1d_calla", uniq_name = "_QFsum_1d_callaEsum_1d_calla"}
+    %1 = fir.shape %c10 : (index) -> !fir.shape<1>
+    %2 = fir.embox %arg0(%1) : (!fir.ref<!fir.array<10xi32>>, !fir.shape<1>) -> !fir.box<!fir.array<10xi32>>
+    %3 = fir.absent !fir.box<i1>
+    %c0 = arith.constant 0 : index
+    %4 = fir.address_of(@_QQcl.2E2F6973756D5F372E66393000) : !fir.ref<!fir.char<1,13>>
+    %c5_i32 = arith.constant 5 : i32
+    %5 = fir.convert %2 : (!fir.box<!fir.array<10xi32>>) -> !fir.box<none>
+    %6 = fir.convert %4 : (!fir.ref<!fir.char<1,13>>) -> !fir.ref<i8>
+    %7 = fir.convert %c0 : (index) -> i32
+    %8 = fir.convert %3 : (!fir.box<i1>) -> !fir.box<none>
+    %9 = fir.call @_FortranASumInteger4(%5, %6, %c5_i32, %7, %8) : (!fir.box<none>, !fir.ref<i8>, i32, i32, !fir.box<none>) -> i32
+    fir.store %9 to %0 : !fir.ref<i32>
+    %10 = fir.load %0 : !fir.ref<i32>
+    return %10 : i32
+  }
+  func.func @sum_1d_callb(%arg0: !fir.ref<!fir.array<20xi32>> {fir.bindc_name = "a"}) -> i32 {
+    %c20 = arith.constant 20 : index
+    %0 = fir.alloca i32 {bindc_name = "sum_1d_callb", uniq_name = "_QFsum_1d_callbEsum_1d_callb"}
+    %1 = fir.shape %c20 : (index) -> !fir.shape<1>
+    %2 = fir.embox %arg0(%1) : (!fir.ref<!fir.array<20xi32>>, !fir.shape<1>) -> !fir.box<!fir.array<20xi32>>
+    %3 = fir.absent !fir.box<i1>
+    %c0 = arith.constant 0 : index
+    %4 = fir.address_of(@_QQcl.2E2F6973756D5F372E66393000) : !fir.ref<!fir.char<1,13>>
+    %c12_i32 = arith.constant 12 : i32
+    %5 = fir.convert %2 : (!fir.box<!fir.array<20xi32>>) -> !fir.box<none>
+    %6 = fir.convert %4 : (!fir.ref<!fir.char<1,13>>) -> !fir.ref<i8>
+    %7 = fir.convert %c0 : (index) -> i32
+    %8 = fir.convert %3 : (!fir.box<i1>) -> !fir.box<none>
+    %9 = fir.call @_FortranASumInteger4(%5, %6, %c12_i32, %7, %8) : (!fir.box<none>, !fir.ref<i8>, i32, i32, !fir.box<none>) -> i32
+    fir.store %9 to %0 : !fir.ref<i32>
+    %10 = fir.load %0 : !fir.ref<i32>
+    return %10 : i32
+  }
+  func.func private @_FortranASumInteger4(!fir.box<none>, !fir.ref<i8>, i32, i32, !fir.box<none>) -> i32 attributes {fir.runtime}
+  fir.global linkonce @_QQcl.2E2F6973756D5F372E66393000 constant : !fir.char<1,13> {
+    %0 = fir.string_lit "./isum_7.f90\00"(13) : !fir.char<1,13>
+    fir.has_value %0 : !fir.char<1,13>
+  }
+}
+
+// CHECK-LABEL:   func.func @sum_1d_calla(%{{.*}}) -> i32 {
+// CHECK-NOT:       fir.call @_FortranASumInteger4({{.*}})
+// CHECK:           fir.call @_FortranASumInteger4_simplified(%{{.*}})
+// CHECK-NOT:       fir.call @_FortranASumInteger4({{.*}})
+// CHECK:         }
+
+// CHECK-LABEL:   func.func @sum_1d_callb(%{{.*}}) -> i32 {
+// CHECK-NOT:       fir.call @_FortranASumInteger4({{.*}})
+// CHECK:           fir.call @_FortranASumInteger4_simplified(%{{.*}})
+// CHECK-NOT:       fir.call @_FortranASumInteger4({{.*}})
+// CHECK:         }
+
+// CHECK-LABEL:   func.func private @_FortranASumInteger4_simplified({{.*}}) -> i32 {{.*}} {
+// CHECK:           return %{{.*}} : i32
+// CHECK:         }
+// CHECK-NOT:   func.func private @_FortranASumInteger4_simplified({{.*}})