[flang][driver] Make `flang-new -fc1` accept MLIR files

[awarzynski]

Summary

This relatively small change will allow Flang's frontend driver,
flang-new -fc1, to consume and parse MLIR files. Semantically (i.e.
from user's perspective) this is identical to reading LLVM IR files.

Two file extensions are associated with MLIR files: .fir and .mlir. Note
that reading MLIR files makes only sense when running one of the
code-generation actions, i.e. when using one of the following action
flags: -S, -emit-obj, -emit-llvm, -emit-llvm-bc.

The majority of tests that required tco to run are updated to also run
with flang-new -fc1. A few tests are updated to use fir-opt instead
of tco (that's the preferred choice when testing a particular MLIR
pass). basic-program.fir is not updated as that test is intended to
verify the behaviour of tco specifically.

[rovka]

This looks good in general, but it's missing a couple of tests:

• a test with a file with a .mlir extension
• tests for the -x option

Also you could commit some of the unrelated test cleanups and tco -> fir-opt or tco -> flang transitions separately, right?

flang/include/flang/Frontend/FrontendOptions.h

128

Nit: Does this need a space before the '@'?

flang/lib/Frontend/CompilerInvocation.cpp

274

What's the difference between this switch and the one right above at line 265?

[awarzynski]

Thanks for taking a look!

In D126890#3555574, @rovka wrote:

This looks good in general, but it's missing a couple of tests:

• a test with a file with a .mlir extension

Sure, can do! Shall I add one with a .fir extension too?

• tests for the -x option

Well, the frontend driver doesn't really understand -x just yet:

bin/flang-new -fc1 -S -x ir file.dx -o -
error: unknown argument: '-x'

We'd need to add FC1Option to the definition of -x. But that should be a separate patch 🤔 .

Also you could commit some of the unrelated test cleanups and tco -> fir-opt or tco -> flang transitions separately, right?

Sure, see https://reviews.llvm.org/D126955.

flang/lib/Frontend/CompilerInvocation.cpp

274

No difference :) It's there the split the logic a bit.

This doesn't make that much sense in Flang (because it only supports a handful of input types), but this code was most likely inspired by Clang, in which case the separation helps to organise the code.

[awarzynski]

Address review comments

[peixin]

It seems that generating executable file from MLIR file is not supported in this patch, right? Will it be supported in future?

[awarzynski]

Add a test for -x

Note that this requires making this revision depend on
https://reviews.llvm.org/D127207

[awarzynski]

In D126890#3558252, @peixin wrote:

It seems that generating executable file from MLIR file is not supported in this patch, right?

As in, flang-new file.mlir --> executable? No. But you can lower your MLIR/FIR files to object files and just link them.

Will it be supported in future?

I don't see why not. We just need somebody to implement it ;-)

[ekieri]

Is it the right trade-off between test coverage and computational effort to have dual run lines for the tco cases? I would assume that in most cases, what is actually tested will be deferred to the same code by both tools. Could we get almost the same coverage for half the effort by using the one tool for half the tests and the other for the rest, or would we miss something important by doing that?

(ping @clementval, as you expressed opinions on a similar matter in D126955)

[peixin]

In D126890#3563319, @awarzynski wrote:

In D126890#3558252, @peixin wrote:

It seems that generating executable file from MLIR file is not supported in this patch, right?

As in, flang-new file.mlir --> executable? No. But you can lower your MLIR/FIR files to object files and just link them.

Will it be supported in future?

I don't see why not. We just need somebody to implement it ;-)

OK. Got it. Thanks.

[awarzynski]

In D126890#3564525, @ekieri wrote:

Is it the right trade-off between test coverage and computational effort to have dual run lines for the tco cases?

Running tests is fast :) Also, there's not that many tests in Flang and this patch only affects a small fraction of them. And given Flang build times, I think that it is safe to assume that the cost is insignificant.

I would assume that in most cases, what is actually tested will be deferred to the same code by both tools. Could we get almost the same coverage for half the effort by using the one tool for half the tests and the other for the rest, or would we miss something important by doing that?

Both tools drive the same set of libraries, but these libraries are very complex (i.e. require a lot of set-up that depends on user input) and the drivers are almost completely separate. It is hard to guarantee that the behavior is consistent without testing with both (in fact, we did see them diverge in the past - that happens when updates are made in one tool, but not in the other).

[rovka]

This LGTM, but please wait another day or two before committing in case anyone else still has comments.

flang/lib/Frontend/CompilerInvocation.cpp

274

Ok, but then the comment about suffixes is very obscure. Can we replace it with something clearer?

[awarzynski]

Update comment in parseFrontendArgs

[ekieri]

In D126890#3565592, @awarzynski wrote:

Both tools drive the same set of libraries, but these libraries are very complex (i.e. require a lot of set-up that depends on user input) and the drivers are almost completely separate. It is hard to guarantee that the behavior is consistent without testing with both (in fact, we did see them diverge in the past - that happens when updates are made in one tool, but not in the other).

Thanks for explaining! I agree testing both is important in this situation.

Although running a test is fast, running all of them takes a while, and flang's test suite will grow over time. As long as the tests add coverage this is as it should be, just wanted to make sure this was the case here.

[awarzynski]

In D126890#3567122, @ekieri wrote:

In D126890#3565592, @awarzynski wrote:

Both tools drive the same set of libraries, but these libraries are very complex (i.e. require a lot of set-up that depends on user input) and the drivers are almost completely separate. It is hard to guarantee that the behavior is consistent without testing with both (in fact, we did see them diverge in the past - that happens when updates are made in one tool, but not in the other).

Thanks for explaining! I agree testing both is important in this situation.

Thanks, can I assume that you are OK with this change?

Although running a test is fast, running all of them takes a while, and flang's test suite will grow over time.

Running tests is fast because it's something that's is trivial to parallelize. And one needs many beefy cores to build Flang anyway (sadly) :/ Also, there's ~1.5k tests in Flang ATM. ~16k in Clang. Not counting MLIR and LLVM. So this shouldn't really be a problem for a while.

[ekieri]

In D126890#3567559, @awarzynski wrote:

Thanks, can I assume that you are OK with this change?

Yes! I have not had the time to read it closely enough for the four magic letters, but no objections from my side.

Although running a test is fast, running all of them takes a while, and flang's test suite will grow over time.

Running tests is fast because it's something that's is trivial to parallelize. And one needs many beefy cores to build Flang anyway (sadly) :/ Also, there's ~1.5k tests in Flang ATM. ~16k in Clang. Not counting MLIR and LLVM. So this shouldn't really be a problem for a while.

Haha, my home computer is very much inappropriate for this.

[awarzynski]

In D126890#3567752, @ekieri wrote:

Haha, my home computer is very much inappropriate for this.

Your patience for building LLVM Flang is greatly appreciated! :D

[ekieri]

By the way, did you note that the CI has some trouble with the formatting?

[awarzynski]

In D126890#3567837, @ekieri wrote:

By the way, did you note that the CI has some trouble with the formatting?

Yes, but haven't noticed anything in the artifacts :(

flang/include/flang/Frontend/FrontendOptions.h

 
 /// \param suffix The file extension
 /// \return True if the file should be preprocessed
 bool isToBePreprocessed(llvm::StringRef suffix);
 
 enum class Language : uint8_t {
   Unknown,
 
+  /// MLIR: we accept this so that we can run the optimizer on it, and compile
+  /// it to LLVM IR, assembly or object code.
+  MLIR,
+
   /// LLVM IR: we accept this so that we can run the optimizer on it,
   /// and compile it to assembly or object code.
   LLVM_IR,
 
   /// @{ Languages that the frontend can parse and compile.
   Fortran,
+  ///@}
 };
 
 // Source file layout
 enum class FortranForm {
   /// The user has not specified a form. Base the form off the file extension.
   Unknown,
 
   /// -ffree-form

flang/lib/Frontend/CompilerInvocation.cpp

if (const llvm::opt::Arg *a =
     dashX = llvm::StringSwitch<InputKind>(xValue)
                 .Case("f90", Language::Fortran)
                 .Default(Language::Unknown);
 
     // Some special cases cannot be combined with suffixes.
     if (dashX.isUnknown())
       dashX = llvm::StringSwitch<InputKind>(xValue)
                   .Case("ir", Language::LLVM_IR)
+                  .Case("fir", Language::MLIR)
+                  .Case("mlir", Language::MLIR)
                   .Default(Language::Unknown);
 
     if (dashX.isUnknown())
       diags.Report(clang::diag::err_drv_invalid_value)
           << a->getAsString(args) << a->getValue();
   }
 
   // Collect the input files and save them in our instance of FrontendOptions.

flang/lib/Frontend/FrontendActions.cpp

 #include "flang/Parser/unparse.h"
 #include "flang/Semantics/runtime-type-info.h"
 #include "flang/Semantics/semantics.h"
 #include "flang/Semantics/unparse-with-symbols.h"
 
 #include "mlir/IR/Dialect.h"
 #include "mlir/Pass/PassManager.h"
 #include "mlir/Target/LLVMIR/ModuleTranslation.h"
+#include "mlir/Parser/Parser.h"
 #include "clang/Basic/Diagnostic.h"
 #include "clang/Basic/DiagnosticFrontend.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Analysis/TargetLibraryInfo.h"
 #include "llvm/Analysis/TargetTransformInfo.h"
 #include "llvm/Bitcode/BitcodeWriterPass.h"
 #include "llvm/IR/LegacyPassManager.h"
 #include "llvm/IRReader/IRReader.h"
bool CodeGenAction::beginSourceFileAction() {
   // If the input is an LLVM file, just parse it and return.
   if (this->getCurrentInput().getKind().getLanguage() == Language::LLVM_IR) {
     llvm::SMDiagnostic err;
     llvmModule = llvm::parseIRFile(getCurrentInput().getFile(), err, *llvmCtx);
 
     return (nullptr != llvmModule);
   }
 
+  // Load the MLIR dialects required by Flang
+  mlir::DialectRegistry registry;
+  mlirCtx = std::make_unique<mlir::MLIRContext>(registry);
+  fir::support::registerNonCodegenDialects(registry);
+  fir::support::loadNonCodegenDialects(*mlirCtx);
+  fir::support::loadDialects(*mlirCtx);
+  fir::support::registerLLVMTranslation(*mlirCtx);
+
+  // If the input is an MLIR file, just parse it and return.
+  if (this->getCurrentInput().getKind().getLanguage() == Language::MLIR) {
+    llvm::SourceMgr sourceMgr;
+    llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> fileOrErr =
+        llvm::MemoryBuffer::getFileOrSTDIN(getCurrentInput().getFile());
+    sourceMgr.AddNewSourceBuffer(std::move(*fileOrErr), llvm::SMLoc());
+    mlir::OwningOpRef<mlir::ModuleOp> module =
+        mlir::parseSourceFile<mlir::ModuleOp>(sourceMgr, mlirCtx.get());
+
+    if (!module || mlir::failed(module->verifyInvariants()))
+      return false;
+
+    mlirModule = std::make_unique<mlir::ModuleOp>(module.release());
+    return true;
+  }
+
   // Otherwise, generate an MLIR module from the input Fortran source
   assert(getCurrentInput().getKind().getLanguage() == Language::Fortran &&
          "Invalid input type - expecting a Fortran file");
   bool res = runPrescan() && runParse() && runSemanticChecks();
   if (!res)
     return res;
 
   CompilerInstance &ci = this->getInstance();
 
-  // Load the MLIR dialects required by Flang
-  mlir::DialectRegistry registry;
-  mlirCtx = std::make_unique<mlir::MLIRContext>(registry);
-  fir::support::registerNonCodegenDialects(registry);
-  fir::support::loadNonCodegenDialects(*mlirCtx);
-
   // Create a LoweringBridge
   const common::IntrinsicTypeDefaultKinds &defKinds =
       ci.getInvocation().getSemanticsContext().defaultKinds();
   fir::KindMapping kindMap(mlirCtx.get(),
       llvm::ArrayRef<fir::KindTy>{fir::fromDefaultKinds(defKinds)});
   lower::LoweringBridge lb = Fortran::lower::LoweringBridge::create(
       *mlirCtx, defKinds, ci.getInvocation().getSemanticsContext().intrinsics(),
       ci.getParsing().allCooked(), ci.getInvocation().getTargetOpts().triple,

flang/lib/Frontend/FrontendOptions.cpp

 
 InputKind FrontendOptions::getInputKindForExtension(llvm::StringRef extension) {
   if (isFixedFormSuffix(extension) || isFreeFormSuffix(extension)) {
     return Language::Fortran;
   }
 
   if (extension == "bc" || extension == "ll")
     return Language::LLVM_IR;
+  if (extension == "fir" || extension == "mlir")
+    return Language::MLIR;
 
   return Language::Unknown;
 }

flang/test/Fir/addrof.fir

 // RUN: tco %s | FileCheck %s
+// RUN: %flang_fc1 -emit-llvm %s -o - | FileCheck %s
 
 // CHECK: @var_x = external global i32
 fir.global @var_x : !fir.int<4> {}
 
 // CHECK-LABEL: define i32* @getAddressOfX
 func.func @getAddressOfX() -> !fir.ref<!fir.int<4>> {
   %1 = fir.address_of(@var_x) : !fir.ref<!fir.int<4>>
   // CHECK: ret i32* @var_x
   return %1 : !fir.ref<!fir.int<4>>
 }

flang/test/Fir/alloc.fir

 // RUN: tco %s | FileCheck %s
+// RUN: %flang_fc1 -emit-llvm  %s -o - | FileCheck %s
 
 // UNSUPPORTED: system-windows
 
 // CHECK-LABEL: define i32* @alloca_scalar_nonchar()
 // CHECK: alloca i32, i64 1
 func.func @alloca_scalar_nonchar() -> !fir.ref<i32> {
   %1 = fir.alloca i32
   return %1 : !fir.ref<i32>

flang/test/Fir/arrayset.fir

 // RUN: tco %s | FileCheck %s
+// RUN: %flang_fc1 -emit-llvm %s -o - | FileCheck %s
 
 // CHECK-LABEL: define void @x([10 x float]* %0)
 func.func @x(%arr : !fir.ref<!fir.array<10xf32>>) {
   %1 = arith.constant 0 : index
   %2 = arith.constant 9 : index
   %stepvar = arith.constant 1 : index
   // CHECK: alloca [10 x float], i64 1
   %a = fir.alloca !fir.array<10xf32>

flang/test/Fir/boxchar.fir

 // RUN: tco --target=x86_64-unknown-linux-gnu %s | FileCheck %s
+// RUN: %flang_fc1 -emit-llvm -triple x86_64-unknown-linux-gnu %s -o - | FileCheck %s
 
 // Test of building and passing boxchar.
 
 func.func private @callee(%x : !fir.boxchar<1>)
 
 // CHECK-LABEL: define void @get_name
 func.func @get_name() {
   %1 = fir.address_of (@name) : !fir.ref<!fir.char<1,9>>

flang/test/Fir/embox.fir

 // RUN: tco %s | FileCheck %s
+// RUN: %flang_fc1 -mmlir -disable-external-name-interop  -emit-llvm %s -o -| FileCheck %s
 
 
 // CHECK-LABEL: define void @_QPtest_callee({ i32*, i64, i32, i8, i8, i8, i8, [1 x [3 x i64]] }* %0)
 func.func @_QPtest_callee(%arg0: !fir.box<!fir.array<?xi32>>) {
   return
 }
 
 // CHECK-LABEL: define void @_QPtest_slice()

flang/test/Fir/global-initialization.fir

-// RUN: tco --fir-to-llvm-ir %s | FileCheck %s
+// RUN: fir-opt --fir-to-llvm-ir %s | FileCheck %s
 
 fir.global internal @_QEmask : !fir.array<32xi32> {
   %c0_i32 = arith.constant 1 : i32
   %0 = fir.undefined !fir.array<32xi32>
   %2 = fir.insert_on_range %0, %c0_i32 from (0) to (31) : (!fir.array<32xi32>, i32) -> !fir.array<32xi32>
   fir.has_value %2 : !fir.array<32xi32>
 }
 

flang/test/Fir/global.fir

 // RUN: tco %s | FileCheck %s
+// RUN: %flang_fc1 -emit-llvm  %s -o - | FileCheck %s
 
 // CHECK: @g_i0 = global i32 0
 fir.global @g_i0 : i32 {
   %1 = arith.constant 0 : i32
   fir.has_value %1 : i32
 }
 
 // CHECK: @g_i2 = global i32 2

flang/test/Fir/ignore-missing-type-descriptor.fir

 // Test the option to avoid failing if derived type descriptors are not found.
 // This is a debug option to allow manually writing derived type fir.embox without
 // having to care with providing an ABI compliant derived type descriptor object.
 // Missing derived type descriptor pointers are replaced by null pointers.
 // RUN: tco --ignore-missing-type-desc -o - %s | FileCheck %s
+// RUN: %flang_fc1 -emit-llvm  -mmlir --ignore-missing-type-desc -o - %s | FileCheck %s
 
 !some_freestyle_type = !fir.type<some_not_mangled_type{j:i32}>
 
 func.func private @bar(!fir.box<!some_freestyle_type>)
 
 func.func @test_embox(%addr: !fir.ref<!some_freestyle_type>) {
   %0 = fir.embox %addr : (!fir.ref<!some_freestyle_type>) -> !fir.box<!some_freestyle_type>
   fir.call @bar(%0) : (!fir.box<!some_freestyle_type>) -> ()
   return
 }
 // CHECK-LABEL: define void @test_embox(
 // CHECK-SAME: %some_not_mangled_type* %[[ADDR:.*]])
 // CHECK: insertvalue { %some_not_mangled_type*, i64, i32, i8, i8, i8, i8, i8*, [1 x i64] }
 // CHECK-SAME: { %some_not_mangled_type* undef, i64 ptrtoint (%some_not_mangled_type* getelementptr (%some_not_mangled_type, %some_not_mangled_type* null, i32 1) to i64),
 // CHECK-SAME: i32 20180515, i8 0, i8 42, i8 0, i8 1, i8* null, [1 x i64] undef },
 // CHECK-SAME: %some_not_mangled_type* %[[ADDR]], 0,

flang/test/Fir/inline.fir

 // RUN: tco --target=x86_64-unknown-linux-gnu --inline-all %s -o - | FileCheck %s
+// RUN: %flang_fc1 -triple x86_64-unknown-linux-gnu -mmlir --inline-all -emit-llvm %s -o - | FileCheck %s
 
 // CHECK-LABEL: @add
 func.func @add(%a : i32, %b : i32) -> i32 {
   // CHECK: %[[add:.*]] = add i32
   %p = arith.addi %a, %b : i32
   // CHECK: ret i32 %[[add]]
   return %p : i32
 }

flang/test/Fir/optional.fir

 // RUN: tco %s | FileCheck %s
+// RUN: %flang_fc1 -emit-llvm %s -o - | FileCheck %s
 
 // Test fir.is_present and fir.absent codegen
 
 // CHECK-LABEL: @foo1
 func.func @foo1(%arg0: !fir.box<!fir.array<?xf32>>) -> i1 {
   // CHECK: %[[ptr:.*]] = ptrtoint { float*, i64, i32, i8, i8, i8, i8, [1 x [3 x i64]] }* %{{.*}} to i64
   // CHECK: icmp ne i64 %[[ptr]], 0
   %0 = fir.is_present %arg0 : (!fir.box<!fir.array<?xf32>>) -> i1

flang/test/Fir/peephole.fir

 // RUN: tco %s | FileCheck %s
+// RUN: %flang_fc1 -emit-llvm %s -o - | FileCheck %s
 
 // Test peephole optimizations
 
 // CHECK-LABEL: define i8 @test_trunc(
 // CHECK-SAME: i256 %[[arg:.*]])
 // CHECK-NEXT: = trunc i256 %[[arg]] to i8
 // CHECK-NEXT: ret i8
 func.func @test_trunc(%0 : i256) -> i8 {

flang/test/Fir/rebox-susbtring.fir

 // Test translation to llvm IR of fir.rebox with substring array sections.
 
-// RUN: tco -o - -cg-rewrite --fir-to-llvm-ir -cse %s | FileCheck %s
+// RUN: fir-opt -o - -cg-rewrite --fir-to-llvm-ir -cse %s | FileCheck %s
 
 // Test a fir.rebox with a substring on a character array with constant
 // length (like c(:)(2:*) where c is a fir.box array with constant length).
 
 // CHECK-LABEL: llvm.func @char_section(
 // CHECK-SAME:                          %[[VAL_0:.*]]: !llvm.ptr<[[char20_descriptor_t:.*]]>)>>) {
 func.func @char_section(%arg0: !fir.box<!fir.array<?x!fir.char<1,20>>>) {
   %c7_i64 = arith.constant 7 : i64

flang/test/Fir/rebox.fir

 // RUN: tco %s | FileCheck %s
+// RUN: %flang_fc1 -emit-llvm %s -o - | FileCheck %s
 
 // Test applying slice on fir.box
 //   subroutine foo(x)
 //     real :: x(3:, 4:)
 //     call bar(x(5, 6:80:3))
 //   end subroutine
 
 func.func private @bar1(!fir.box<!fir.array<?xf32>>)

flang/test/Fir/select.fir

 // Test lowering FIR to LLVM IR of fir.select{|_rank|_case}
 
 // RUN: tco %s | FileCheck %s
+// RUN: %flang_fc1 -emit-llvm %s -o - | FileCheck %s
 
 // CHECK-LABEL: @f
 func.func @f(%a : i32) -> i32 {
    %1 = arith.constant 1 : i32
    %2 = arith.constant 42 : i32
 // CHECK: switch i32 %{{.*}}, label %{{.*}} [
 // CHECK:   i32 1, label %{{.*}}
 // CHECK: ]

flang/test/Fir/widechar.fir

 // RUN: tco %s | FileCheck %s
+// RUN: %flang_fc1 -emit-llvm %s -o - | FileCheck %s
 
 // CHECK-LABEL: @character_literal1
 func.func @character_literal1() -> !fir.char<1,13> {
   %0 = fir.string_lit "Hello, World!"(13) : !fir.char<1,13>
   // CHECK: ret [13 x i8] c"Hello, World!"
   return %0 : !fir.char<1,13>
 }
 

flang/test/Lower/common-block.f90

 ! RUN: bbc %s -o - | tco | FileCheck %s
+! RUN: %flang -emit-llvm -S -mmlir -disable-external-name-interop %s -o - | FileCheck %s
 
 ! CHECK: @_QB = common global [8 x i8] zeroinitializer
 ! CHECK: @_QBrien = common global [1 x i8] zeroinitializer
 ! CHECK: @_QBwith_empty_equiv = common global [8 x i8] zeroinitializer
 ! CHECK: @_QBx = global { float, float } { float 1.0{{.*}}, float 2.0{{.*}} }
 ! CHECK: @_QBy = common global [12 x i8] zeroinitializer
 ! CHECK: @_QBz = global { i32, [4 x i8], float } { i32 42, [4 x i8] undef, float 3.000000e+00 }
 

flang/test/Lower/complex-part.f90

 ! RUN: bbc %s -o - | tco | FileCheck %s
+! RUN: %flang -emit-llvm -S -mmlir -disable-external-name-interop %s -o - | FileCheck %s
 
   COMPLEX c
   c%RE = 3.14
   CALL sub(c)
 END
 
 ! Verify that the offset in the struct does not regress from i32.
 ! CHECK-LABEL: define void @_QQmain()
 ! CHECK: getelementptr { float, float }, { float, float }* %{{[0-9]+}}, i64 0, i32 0
 

flang/test/Lower/forall/character-1.f90

 ! RUN: bbc %s -o - | tco | FileCheck %s
+! RUN: %flang -emit-llvm -S -mmlir -disable-external-name-interop %s -o - | FileCheck %s
 ! Test from Fortran source through to LLVM IR.
 ! UNSUPPORTED: system-windows
 
 ! Assumed size array of assumed length character.
 program test
   character :: x(3) = (/ '1','2','3' /)
   call sub(x)
 contains
   subroutine sub(x)
     character(*) x(:)
     forall (i=1:2)
        x(i:i)(1:1) = x(i+1:i+1)(1:1)
     end forall
     print *,x
   end subroutine sub
 end program test
 
 ! CHECK-LABEL: define void @_QFPsub({
 ! CHECK-SAME: , [1 x [3 x i64]] }* %[[arg:.*]])
 ! CHECK: %[[extent:.*]] = getelementptr { {{.*}}, [1 x [3 x i64]] }, { {{.*}}, [1 x [3 x i64]] }* %[[arg]], i32 0, i32 7, i64 0, i32 1
 ! CHECK: %[[extval:.*]] = load i64, i64* %[[extent]]
 ! CHECK: %[[elesize:.*]] = getelementptr { {{.*}}, [1 x [3 x i64]] }, { {{.*}}, [1 x [3 x i64]] }* %[[arg]], i32 0, i32 1
 ! CHECK: %[[esval:.*]] = load i64, i64* %[[elesize]]
 ! CHECK: %[[mul:.*]] = mul i64 1, %[[esval]]
-! CHECK: %[[mul2:.*]] = mul i64 %[[mul]], %[[extval]], !dbg !18
+! CHECK: %[[mul2:.*]] = mul i64 %[[mul]], %[[extval]]
 ! CHECK: %[[buff:.*]] = call i8* @malloc(i64 %[[mul2]])
 ! CHECK: %[[to:.*]] = getelementptr i8, i8* %[[buff]], i64 %
 ! CHECK: call void @llvm.memmove.p0i8.p0i8.i64(i8* %[[to]], i8* %{{.*}}, i64 %{{.*}}, i1 false)
 ! CHECK: call void @free(i8* %[[buff]])
 ! CHECK: call i8* @_FortranAioBeginExternalListOutput