[flang][hlfir] Separate -emit-fir and -emit-hlfir for bbc

[tblah]

Summary

In review for https://reviews.llvm.org/D146278, @vzakhari asked to
separate -emit-fir and -emit-hlfir. This will allow FIR to be easily
outputted after the HLFIR passes have been run.

The new semantics are as follows:

Action	-hlfir?	Result
===========	=======	===============================
-emit-hlfir	N	Outputs HLFIR
-emit-hlfir	Y	Outputs HLFIR
-emit-fir	N	Outputs FIR, using old lowering
-emit-fir	Y	Outputs FIR, lowering via HLFIR

This is tested in flang/test/HLFIR/hlfir-flags.f90

Depends on: D151088

[vzakhari]

Thank you!

[jeanPerier]

Thank you!

[tblah]

Updating with new HLFIR tests since last revision

[tblah]

Add new upstream HLFIR test

flang/test/HLFIR/boxchar_emboxing.f90

-! RUN: bbc -polymorphic-type -emit-fir -hlfir %s -o - | FileCheck %s
+! RUN: bbc -polymorphic-type -emit-hlfir %s -o - | FileCheck %s
 
 ! CHECK-LABEL:   func.func @_QPtest1(
 ! CHECK-SAME:                        %[[VAL_0:.*]]: !fir.class<none> {fir.bindc_name = "x"}) {
 ! CHECK:           %[[VAL_1:.*]]:2 = hlfir.declare %[[VAL_0]] {uniq_name = "_QFtest1Ex"} : (!fir.class<none>) -> (!fir.class<none>, !fir.class<none>)
 ! CHECK:           fir.select_type %[[VAL_1]]#1 : !fir.class<none> [#fir.type_is<!fir.char<1,?>>, ^bb1, unit, ^bb2]
 ! CHECK:         ^bb1:
 ! CHECK:           %[[VAL_2:.*]] = fir.box_addr %[[VAL_1]]#1 : (!fir.class<none>) -> !fir.ref<!fir.char<1,?>>
 ! CHECK:           %[[VAL_3:.*]] = fir.box_elesize %[[VAL_1]]#1 : (!fir.class<none>) -> index

flang/test/HLFIR/c_ptr_byvalue.f90

-! RUN: bbc -emit-fir -hlfir %s -o - | FileCheck %s
+! RUN: bbc -emit-hlfir %s -o - | FileCheck %s
 
 ! CHECK-LABEL:   func.func @_QPtest1() {
 ! CHECK:           %[[VAL_110:.*]]:3 = hlfir.associate %{{.*}} {uniq_name = "adapt.cptrbyval"} : (!hlfir.expr<!fir.type<_QM__fortran_builtinsT__builtin_c_ptr{__address:i64}>>) -> (!fir.ref<!fir.type<_QM__fortran_builtinsT__builtin_c_ptr{__address:i64}>>, !fir.ref<!fir.type<_QM__fortran_builtinsT__builtin_c_ptr{__address:i64}>>, i1)
 ! CHECK:           %[[VAL_111:.*]] = fir.field_index __address, !fir.type<_QM__fortran_builtinsT__builtin_c_ptr{__address:i64}>
 ! CHECK:           %[[VAL_112:.*]] = fir.coordinate_of %[[VAL_110]]#1, %[[VAL_111]] : (!fir.ref<!fir.type<_QM__fortran_builtinsT__builtin_c_ptr{__address:i64}>>, !fir.field) -> !fir.ref<i64>
 ! CHECK:           %[[VAL_113:.*]] = fir.load %[[VAL_112]] : !fir.ref<i64>
 ! CHECK:           %[[VAL_114:.*]] = fir.convert %[[VAL_113]] : (i64) -> !fir.ref<i64>
 ! CHECK:           hlfir.end_associate %[[VAL_110]]#1, %[[VAL_110]]#2 : !fir.ref<!fir.type<_QM__fortran_builtinsT__builtin_c_ptr{__address:i64}>>, i1

flang/test/HLFIR/call_with_poly_dummy.f90

-! RUN: bbc -polymorphic-type -emit-fir -hlfir %s -o - | FileCheck %s
+! RUN: bbc -polymorphic-type -emit-hlfir %s -o - | FileCheck %s
 
 ! Test passing arguments to subprograms with polymorphic dummy arguments.
 
 ! CHECK-LABEL:   func.func @_QPtest1() {
 ! CHECK:           %[[VAL_0:.*]] = arith.constant 17 : i32
 ! CHECK:           %[[VAL_1:.*]]:3 = hlfir.associate %[[VAL_0]] {uniq_name = "adapt.valuebyref"} : (i32) -> (!fir.ref<i32>, !fir.ref<i32>, i1)
 ! CHECK:           %[[VAL_2:.*]] = fir.embox %[[VAL_1]]#0 : (!fir.ref<i32>) -> !fir.box<i32>
 ! CHECK:           %[[VAL_3:.*]] = fir.rebox %[[VAL_2]] : (!fir.box<i32>) -> !fir.class<none>

flang/test/HLFIR/extents-of-shape-of.f90

-! RUN: bbc -emit-fir -hlfir %s -o - | FileCheck --check-prefix CHECK-ALL --check-prefix CHECK-HLFIR %s
-! RUN: bbc -emit-fir -hlfir %s -o - | fir-opt --lower-hlfir-intrinsics | fir-opt --bufferize-hlfir | fir-opt --convert-hlfir-to-fir | FileCheck --check-prefix CHECK-ALL --check-prefix CHECK-FIR %s
+! RUN: bbc -emit-hlfir %s -o - | FileCheck --check-prefix CHECK-ALL --check-prefix CHECK-HLFIR %s
+! RUN: bbc -emit-hlfir %s -o - | fir-opt --lower-hlfir-intrinsics | fir-opt --bufferize-hlfir | fir-opt --convert-hlfir-to-fir | FileCheck --check-prefix CHECK-ALL --check-prefix CHECK-FIR %s
 subroutine foo(a, b)
   real :: a(2, 2), b(:, :)
   interface
     elemental subroutine elem_sub(x)
       real, intent(in) :: x
     end subroutine
   end interface
   call elem_sub(matmul(a, b))

flang/test/HLFIR/hlfir-flags.f90

-! Test -flang-experimental-hlfir, -emit-hlfir, -emit-fir flags
+! Test -flang-experimental-hlfir (flang-new), -hlfir (bbc), -emit-hlfir, -emit-fir flags
 ! RUN: %flang_fc1 -emit-hlfir -o - %s | FileCheck --check-prefix HLFIR --check-prefix ALL %s
+! RUN: bbc -emit-hlfir -o - %s | FileCheck --check-prefix HLFIR --check-prefix ALL %s
 ! RUN: %flang_fc1 -emit-hlfir -flang-experimental-hlfir -o - %s | FileCheck --check-prefix HLFIR --check-prefix ALL %s
+! RUN: bbc -emit-hlfir -hlfir -o - %s | FileCheck --check-prefix HLFIR --check-prefix ALL %s
 ! RUN: %flang_fc1 -emit-fir -o - %s | FileCheck %s --check-prefix NO-HLFIR --check-prefix ALL
+! RUN: bbc -emit-fir -o - %s | FileCheck %s --check-prefix NO-HLFIR --check-prefix ALL
 ! RUN: %flang_fc1 -emit-fir -flang-experimental-hlfir -o - %s | FileCheck --check-prefix FIR --check-prefix ALL %s
+! RUN: bbc -emit-fir -hlfir -o - %s | FileCheck --check-prefix FIR --check-prefix ALL %s
 
-! | Action      | -flang-experimental-hlfir? | Result                          |
-! | =========== | ========================== | =============================== |
-! | -emit-hlfir | N                          | Outputs HLFIR                   |
-! | -emit-hlfir | Y                          | Outputs HLFIR                   |
-! | -emit-fir   | N                          | Outputs FIR, using old lowering |
-! | -emit-fir   | Y                          | Outputs FIR, lowering via HLFIR |
+! | Action      | -flang-experimental-hlfir / -hlfir? | Result                          |
+! | =========== | =================================== | =============================== |
+! | -emit-hlfir | N                                   | Outputs HLFIR                   |
+! | -emit-hlfir | Y                                   | Outputs HLFIR                   |
+! | -emit-fir   | N                                   | Outputs FIR, using old lowering |
+! | -emit-fir   | Y                                   | Outputs FIR, lowering via HLFIR |
 
 subroutine test(a, res)
   real :: a(:), res
   res = SUM(a)
 end subroutine
 ! ALL-LABEL: func.func @_QPtest
 ! ALL:             %[[A:.*]]: !fir.box<!fir.array<?xf32>>
 ! ALL:             %[[RES:.*]]: !fir.ref<f32>

flang/test/HLFIR/mul_transpose.f90

-! RUN: bbc -emit-fir -hlfir %s -o - | FileCheck --check-prefix CHECK-BASE --check-prefix CHECK-ALL %s
-! RUN: bbc -emit-fir -hlfir %s -o - | fir-opt --canonicalize | FileCheck --check-prefix CHECK-CANONICAL --check-prefix CHECK-ALL %s
-! RUN: bbc -emit-fir -hlfir %s -o - | fir-opt --lower-hlfir-intrinsics | FileCheck --check-prefix CHECK-LOWERING --check-prefix CHECK-ALL %s
-! RUN: bbc -emit-fir -hlfir %s -o - | fir-opt --canonicalize | fir-opt --lower-hlfir-intrinsics | FileCheck --check-prefix CHECK-LOWERING-OPT --check-prefix CHECK-ALL %s
-! RUN: bbc -emit-fir -hlfir %s -o - | fir-opt --lower-hlfir-intrinsics | fir-opt --bufferize-hlfir | FileCheck --check-prefix CHECK-BUFFERING --check-prefix CHECK-ALL %s
+! RUN: bbc -emit-hlfir %s -o - | FileCheck --check-prefix CHECK-BASE --check-prefix CHECK-ALL %s
+! RUN: bbc -emit-hlfir %s -o - | fir-opt --canonicalize | FileCheck --check-prefix CHECK-CANONICAL --check-prefix CHECK-ALL %s
+! RUN: bbc -emit-hlfir %s -o - | fir-opt --lower-hlfir-intrinsics | FileCheck --check-prefix CHECK-LOWERING --check-prefix CHECK-ALL %s
+! RUN: bbc -emit-hlfir %s -o - | fir-opt --canonicalize | fir-opt --lower-hlfir-intrinsics | FileCheck --check-prefix CHECK-LOWERING-OPT --check-prefix CHECK-ALL %s
+! RUN: bbc -emit-hlfir %s -o - | fir-opt --lower-hlfir-intrinsics | fir-opt --bufferize-hlfir | FileCheck --check-prefix CHECK-BUFFERING --check-prefix CHECK-ALL %s
 
 ! Test passing a hlfir.expr from one intrinsic to another
 subroutine mul_transpose(a, b, res)
   real a(2,1), b(2,2), res(1,2)
   res = MATMUL(TRANSPOSE(a), b)
 endsubroutine
 
 ! CHECK-ALL-LABEL:    func.func @_QPmul_transpose

flang/test/HLFIR/optional_dummy.f90

-! RUN: bbc -emit-fir -hlfir %s -o - | FileCheck %s
+! RUN: bbc -emit-hlfir %s -o - | FileCheck %s
 
 ! Check that the lowering does not generate fir.box_addr for
 ! the optional box. It will cause segfault during execution.
 
 ! CHECK-LABEL:   func.func @_QPtest(
 ! CHECK-SAME:        %[[VAL_0:.*]]: !fir.box<!fir.array<?xi32>> {fir.bindc_name = "ext_buf", fir.contiguous, fir.optional}) {
 ! CHECK:           %[[VAL_1:.*]]:2 = hlfir.declare %[[VAL_0]] {fortran_attrs = #fir.var_attrs<contiguous, optional>, uniq_name = "_QFtestEext_buf"} : (!fir.box<!fir.array<?xi32>>) -> (!fir.box<!fir.array<?xi32>>, !fir.box<!fir.array<?xi32>>)
 ! CHECK:           %[[VAL_2:.*]] = fir.is_present %[[VAL_1]]#1 : (!fir.box<!fir.array<?xi32>>) -> i1

flang/test/Lower/HLFIR/all.f90

 ! Test lowering of ALL intrinsic to HLFIR
-! RUN: bbc -emit-fir -hlfir -o - %s 2>&1 | FileCheck %s
+! RUN: bbc -emit-hlfir -o - %s 2>&1 | FileCheck %s
 
 ! simple 1 argument ALL
 subroutine all1(a, s)
   logical :: a(:), s
   s = ALL(a)
 end subroutine
 ! CHECK-LABEL: func.func @_QPall1(
 ! CHECK:           %[[ARG0:.*]]: !fir.box<!fir.array<?x!fir.logical<4>>>

flang/test/Lower/HLFIR/allocatable-and-pointer-components.f90

 ! Test lowering of whole allocatable and pointer components to HLFIR
-! RUN: bbc -emit-fir -hlfir -o - %s -I nw | FileCheck %s
+! RUN: bbc -emit-hlfir -o - %s -I nw | FileCheck %s
 
 module def_test_types
   type t1
     real, pointer :: p(:)
   end type
   type t2
     real, allocatable :: a(:)
   end type

flang/test/Lower/HLFIR/allocatable-and-pointer-status-change.f90

 ! Test lowering of allocate, deallocate and pointer assignment statements to
 ! HLFIR.
-! RUN: bbc -emit-fir -hlfir -o - %s -I nw | FileCheck %s
+! RUN: bbc -emit-hlfir -o - %s -I nw | FileCheck %s
 
 subroutine allocation(x)
   character(*), allocatable :: x(:)
 ! CHECK-LABEL: func.func @_QPallocation(
 ! CHECK:  %[[VAL_3:.*]]:2 = hlfir.declare %[[VAL_0:[a-z0-9]*]] typeparams %[[VAL_2:[a-z0-9]*]] {fortran_attrs = #fir.var_attrs<allocatable>,  {{.*}}Ex
   deallocate(x)
 ! CHECK:  %[[VAL_4:.*]] = fir.load %[[VAL_3]]#1 : !fir.ref<!fir.box<!fir.heap<!fir.array<?x!fir.char<1,?>>>>>
 ! CHECK:  %[[VAL_5:.*]] = fir.box_addr %[[VAL_4]] : (!fir.box<!fir.heap<!fir.array<?x!fir.char<1,?>>>>) -> !fir.heap<!fir.array<?x!fir.char<1,?>>>

flang/test/Lower/HLFIR/allocatable-and-pointer-subparts.f90

 ! Test lowering of allocatable and pointer sub-part reference to HLFIR
 ! As opposed to whole reference, a pointer/allocatable dereference must
 ! be inserted and addressed in a following hlfir.designate to address
 ! the sub-part.
 
-! RUN: bbc -emit-fir -hlfir -o - %s -I nw | FileCheck %s
+! RUN: bbc -emit-hlfir -o - %s -I nw | FileCheck %s
 
 module m
   type t1
     real :: x
   end type
   type t2
     type(t1), pointer :: p
   end type

flang/test/Lower/HLFIR/allocatables-and-pointers.f90

 ! Test lowering of whole allocatable and pointers to HLFIR
-! RUN: bbc -emit-fir -hlfir -o - %s 2>&1 | FileCheck %s
+! RUN: bbc -emit-hlfir -o - %s 2>&1 | FileCheck %s
 
 subroutine passing_allocatable(x)
   interface
     subroutine takes_allocatable(y)
       real, allocatable :: y(:)
     end subroutine
     subroutine takes_array(y)
       real :: y(*)

flang/test/Lower/HLFIR/any.f90

 ! Test lowering of ANY intrinsic to HLFIR
-! RUN: bbc -emit-fir -hlfir -o - %s 2>&1 | FileCheck %s
+! RUN: bbc -emit-hlfir -o - %s 2>&1 | FileCheck %s
 ! simple 1 argument ANY
 subroutine any1(a, s)
   logical :: a(:), s
   s = ANY(a)
 end subroutine
 ! CHECK-LABEL: func.func @_QPany1(
 ! CHECK:           %[[ARG0:.*]]: !fir.box<!fir.array<?x!fir.logical<4>>>
 ! CHECK:           %[[ARG1:.*]]: !fir.ref<!fir.logical<4>>

flang/test/Lower/HLFIR/array-ctor-as-elemental-nested.f90

 ! Test lowering of nested array constructors as hlfir.elemental.
-! RUN: bbc -emit-fir -hlfir -o - %s | FileCheck %s
+! RUN: bbc -emit-hlfir -o - %s | FileCheck %s
 
 ! hlfir.end_associate and hlfir.destroy used to be generated
 ! after hlfir.yield_element for the outermost hlfir.elemental.
 
 ! CHECK-LABEL:   func.func @_QPtest(
 ! CHECK-SAME:                       %[[VAL_0:.*]]: !fir.ref<f32> {fir.bindc_name = "pi"},
 ! CHECK-SAME:                       %[[VAL_1:.*]]: !fir.ref<!fir.array<2xf32>> {fir.bindc_name = "h1"}) {
 ! CHECK:           %[[VAL_2:.*]] = arith.constant 2 : index

flang/test/Lower/HLFIR/array-ctor-as-elemental.f90

 ! Test lowering of array constructors as hlfir.elemental.
-! RUN: bbc -emit-fir -hlfir -o - %s | FileCheck %s
+! RUN: bbc -emit-hlfir -o - %s | FileCheck %s
 
 subroutine test_as_simple_elemental(n)
   integer :: n
   call takes_int([(n+i, i=1,4)])
 end subroutine
 ! CHECK-LABEL:   func.func @_QPtest_as_simple_elemental(
 ! CHECK-SAME:                                           %[[VAL_0:.*]]: !fir.ref<i32> {fir.bindc_name = "n"}) {
 ! CHECK:           %[[VAL_1:.*]]:2 = hlfir.declare %[[VAL_0]] {uniq_name = "_QFtest_as_simple_elementalEn"} : (!fir.ref<i32>) -> (!fir.ref<i32>, !fir.ref<i32>)

flang/test/Lower/HLFIR/array-ctor-as-inlined-temp.f90

 ! Test lowering of array constructors as inlined temporary.
-! RUN: bbc -emit-fir -hlfir -o - %s | FileCheck %s
+! RUN: bbc -emit-hlfir -o - %s | FileCheck %s
 
 subroutine test_simple(i)
   call takes_int([42, i])
 end subroutine
 ! CHECK-LABEL: func.func @_QPtest_simple(
 ! CHECK:  %[[VAL_1:.*]]:2 = hlfir.declare {{.*}}Ei
 ! CHECK:  %[[VAL_2:.*]] = arith.constant 2 : index
 ! CHECK:  %[[VAL_3:.*]] = arith.constant 1 : index

flang/test/Lower/HLFIR/array-ctor-as-runtime-temp.f90

 ! Test lowering of array constructors requiring runtime library help to HLFIR.
-! RUN: bbc -emit-fir -hlfir -o - %s | FileCheck %s
+! RUN: bbc -emit-hlfir -o - %s | FileCheck %s
 module arrayctor
 contains
 
 subroutine test_loops()
   call takes_int([((i, i=1,ifoo()), j=1,ibar())])
 end subroutine
 ! CHECK-LABEL:   func.func @_QMarrayctorPtest_loops() {
 ! CHECK:           %[[VAL_0:.*]] = fir.alloca i32

flang/test/Lower/HLFIR/array-ctor-character.f90

 ! Test lowering of character array constructors to HLFIR.
-! RUN: bbc -emit-fir -hlfir -o - %s | FileCheck %s
+! RUN: bbc -emit-hlfir -o - %s | FileCheck %s
 
 module chararrayctor
   character(3), target :: ctarg1 = "abc"
   character(3), target :: ctarg2 = "def"
 contains
 
   subroutine test_pre_computed_length(c1, c2)
     character(*) :: c1, c2

flang/test/Lower/HLFIR/array-ctor-derived.f90

 ! Test lowering of derived type array constructors to HLFIR.
-! RUN: bbc -emit-fir -hlfir --polymorphic-type -o - %s | FileCheck %s
+! RUN: bbc -emit-hlfir --polymorphic-type -o - %s | FileCheck %s
 
 module types
   type simple
     integer :: i
     integer :: j
   end type
 end module
 module derivedarrayctor

flang/test/Lower/HLFIR/array-ctor-index.f90

 ! Check that the implied-do index value is converted to proper type.
-! RUN: bbc -emit-fir -hlfir -o - %s | FileCheck %s
+! RUN: bbc -emit-hlfir -o - %s | FileCheck %s
 
 function test1(k)
   integer*1 :: k
   integer*1 :: test1(4)
   test1 = ([(i*k, integer(8)::i=1,4)])
 end function test1
 ! CHECK-LABEL:   func.func @_QPtest1(
 ! CHECK-SAME:                        %[[VAL_0:.*]]: !fir.ref<i8> {fir.bindc_name = "k"}) -> !fir.array<4xi8> {

flang/test/Lower/HLFIR/assignment-intrinsics.f90

 ! Test lowering of intrinsic assignments to HLFIR
-! RUN: bbc -emit-fir -hlfir -o - %s 2>&1 | FileCheck %s
+! RUN: bbc -emit-hlfir -o - %s 2>&1 | FileCheck %s
 
 ! -----------------------------------------------------------------------------
 !     Test assignments with scalar variable LHS and RHS
 ! -----------------------------------------------------------------------------
 
 subroutine scalar_int(x, y)
   integer :: x, y
   x = y

flang/test/Lower/HLFIR/associate-construct.f90

 ! Test lowering of associate construct to HLFIR
-! RUN: bbc -emit-fir -hlfir -o - %s | FileCheck %s
+! RUN: bbc -emit-hlfir -o - %s | FileCheck %s
 
 subroutine associate_expr(x)
   integer :: x(:)
   associate(y => x + 42)
     print *, y
   end associate
 end subroutine
 ! CHECK-LABEL: func.func @_QPassociate_expr(

flang/test/Lower/HLFIR/binary-ops.f90

 ! Test lowering of binary intrinsic operations to HLFIR
-! RUN: bbc -emit-fir -hlfir -o - %s 2>&1 | FileCheck %s
+! RUN: bbc -emit-hlfir -o - %s 2>&1 | FileCheck %s
 
 subroutine int_add(x, y, z)
  integer :: x, y, z
  x = y + z
 end subroutine
 ! CHECK-LABEL: func.func @_QPint_add(
 ! CHECK:  %[[VAL_4:.*]]:2 = hlfir.declare %{{.*}}y"} : (!fir.ref<i32>) -> (!fir.ref<i32>, !fir.ref<i32>)
 ! CHECK:  %[[VAL_5:.*]]:2 = hlfir.declare %{{.*}}z"} : (!fir.ref<i32>) -> (!fir.ref<i32>, !fir.ref<i32>)

flang/test/Lower/HLFIR/c_ptr-constant-init.f90

 ! Test creation of outlined literal array with c_ptr/c_funptr elements.
-! RUN: bbc -hlfir -emit-fir -o - %s | FileCheck %s
+! RUN: bbc -emit-hlfir -o - %s | FileCheck %s
 
 subroutine test
   use, intrinsic :: iso_c_binding
   type t1
      type(c_ptr) :: d(1)
   end type t1
   type(t1), parameter :: x(1) = t1(c_null_ptr)
   type(t1) :: y(1)

flang/test/Lower/HLFIR/calls-assumed-shape.f90

 ! Test lowering of calls involving assumed shape arrays or arrays with
 ! VALUE attribute.
-! RUN: bbc -emit-fir -hlfir -polymorphic-type -o - %s | FileCheck %s
+! RUN: bbc -emit-hlfir -polymorphic-type -o - %s | FileCheck %s
 
 subroutine test_assumed_to_assumed(x)
   interface
     subroutine takes_assumed(x)
       real :: x(:)
     end subroutine
   end interface
   real :: x(:)

flang/test/Lower/HLFIR/calls-character-singleton-result.f90

 ! Test handling of intrinsics and BIND(C) functions returning CHARACTER(1).
 ! This is a special case because characters are always returned
 ! or handled in memory otherwise.
 
-! RUN: bbc -emit-fir -hlfir -o - %s | FileCheck %s
+! RUN: bbc -emit-hlfir -o - %s | FileCheck %s
 
 subroutine scalar_char(c, i)
   character(1) :: c
   integer(8) :: i
   c = char(i)
 end subroutine
 ! CHECK-LABEL: func.func @_QPscalar_char(
 ! CHECK:  %[[VAL_2:.*]] = fir.alloca !fir.char<1>

flang/test/Lower/HLFIR/calls-constant-expr-arg-polymorphic.f90

-! RUN: bbc -emit-fir -hlfir --polymorphic-type -o - %s | FileCheck %s
+! RUN: bbc -emit-hlfir --polymorphic-type -o - %s | FileCheck %s
 
 ! Test when constant argument are copied in memory
 ! and passed to polymorphic arguments.
 ! The copy is done in case the dummy later appear in a
 ! copy-out that would create write to this memory location.
   type t1
     integer :: i
   end type

flang/test/Lower/HLFIR/calls-constant-expr-arg.f90

-! RUN: bbc -emit-fir -hlfir -o - %s | FileCheck %s
+! RUN: bbc -emit-hlfir -o - %s | FileCheck %s
 
 ! Test that the constant array expression actual argument
 ! is placed into a temporary inside 'test' subroutine before
 ! the call to 'sub'. This is required because the compiler-generated
 ! copy-out inside 'sub' after the call to 'sub2' will write
 ! into the dummy argument 'i'. If the constant array expression is passed
 ! directly byref to 'sub', the copy-out will try to modify readonly memory.
 subroutine sub(i, n)

flang/test/Lower/HLFIR/calls-f77.f90

 ! Test lowering of F77 calls to HLFIR
-! RUN: bbc -emit-fir -hlfir -o - %s 2>&1 | FileCheck %s
+! RUN: bbc -emit-hlfir -o - %s 2>&1 | FileCheck %s
 
 ! -----------------------------------------------------------------------------
 !     Test lowering of F77 procedure reference arguments
 ! -----------------------------------------------------------------------------
 
 subroutine call_no_arg()
   call void()
 end subroutine

flang/test/Lower/HLFIR/calls-optional.f90

 ! Test lowering of user calls involving passing an actual argument
 ! that is syntactically present, but may be absent at runtime (is
 ! an optional or a pointer/allocatable).
 !
-! RUN: bbc -emit-fir -hlfir -polymorphic-type -o - %s | FileCheck %s
+! RUN: bbc -emit-hlfir -polymorphic-type -o - %s | FileCheck %s
 
 subroutine optional_copy_in_out(x)
   interface
     subroutine takes_optional_explicit(x)
       real, optional :: x(*)
     end subroutine
   end interface
   real, optional :: x(:)

flang/test/Lower/HLFIR/concat.f90

 ! Test lowering of character concatenation to HLFIR
-! RUN: bbc -emit-fir -hlfir -o - %s 2>&1 | FileCheck %s
+! RUN: bbc -emit-hlfir -o - %s 2>&1 | FileCheck %s
 
 subroutine concat(c1, c2, c3)
   character(*) :: c1, c2, c3
   c1 = c2 // c3
 end subroutine
 ! CHECK-LABEL: func.func @_QPconcat
 ! CHECK:  hlfir.declare {{.*}}c1
 ! CHECK:  %[[VAL_5:.*]]:2 = fir.unboxchar %{{.*}} : (!fir.boxchar<1>) -> (!fir.ref<!fir.char<1,?>>, index)

flang/test/Lower/HLFIR/constant-derived.f90

 ! Test lowering of Constant<SomeDerived>.
-! RUN: bbc -hlfir -emit-fir -o - -I nowhere %s 2>&1 | FileCheck %s
+! RUN: bbc -emit-hlfir -o - -I nowhere %s 2>&1 | FileCheck %s
 
 subroutine test_constant_scalar()
   type myderived
     integer :: i
     integer :: j = 42
     real :: x(2)
     character(10) :: c
   end type

flang/test/Lower/HLFIR/constant.f90

 ! Test lowering of Constant<T>.
-! RUN: bbc -hlfir -emit-fir -o - %s 2>&1 | FileCheck %s
+! RUN: bbc -emit-hlfir -o - %s 2>&1 | FileCheck %s
 
 ! CHECK-LABEL: func.func @_QPtest_constant_scalar()
 subroutine test_constant_scalar()
   print *, (10., 20.)
   ! CHECK-DAG:  %[[VAL_0:.*]] = arith.constant 2.000000e+01 : f32
   ! CHECK-DAG:  %[[VAL_1:.*]] = arith.constant 1.000000e+01 : f32
   ! CHECK:  %[[VAL_7:.*]] = fir.undefined !fir.complex<4>
   ! CHECK:  %[[VAL_8:.*]] = fir.insert_value %[[VAL_7]], %[[VAL_1]], [0 : index] : (!fir.complex<4>, f32) -> !fir.complex<4>

flang/test/Lower/HLFIR/conversion-ops.f90

 ! Test lowering of intrinsic conversions to HLFIR
-! RUN: bbc -emit-fir -hlfir -o - %s 2>&1 | FileCheck %s
+! RUN: bbc -emit-hlfir -o - %s 2>&1 | FileCheck %s
 
 subroutine test
   integer(4) :: i4
   integer(8) :: i8
   real(4) :: r4
   real(8) :: r8
   complex(4) :: z4
   complex(8) :: z8

flang/test/Lower/HLFIR/convert-variable.f90

 ! Test lowering of variables to fir.declare
-! RUN: bbc -emit-fir -hlfir %s -o - | FileCheck %s
+! RUN: bbc -emit-hlfir %s -o - | FileCheck %s
 
 subroutine scalar_numeric(x)
   integer :: x
 end subroutine
 ! CHECK-LABEL: func.func @_QPscalar_numeric(
 ! CHECK-SAME:    %[[VAL_0:.*]]: !fir.ref<i32>
 ! CHECK:  %[[VAL_1:.*]] = hlfir.declare %[[VAL_0]] {uniq_name = "_QFscalar_numericEx"} : (!fir.ref<i32>) -> (!fir.ref<i32>, !fir.ref<i32>)
 

flang/test/Lower/HLFIR/descriptor-inquiries.f90

 ! Test lowering of extent and lower bound inquires that
 ! come in lowering as evaluate::DescriptorInquiry.
 
-! RUN: bbc -emit-fir -hlfir -o - %s | FileCheck %s
+! RUN: bbc -emit-hlfir -o - %s | FileCheck %s
 
 subroutine test_assumed_shape(x, r)
   integer(8) :: r
   real :: x(:,:)
   r = size(x, dim=2, kind=8)
 end subroutine
 ! CHECK-LABEL: func.func @_QPtest_assumed_shape(
 ! CHECK:  %[[VAL_3:.*]]:2 = hlfir.declare {{.*}}Ex

flang/test/Lower/HLFIR/designators-component-ref.f90

 ! Test lowering of component reference to HLFIR
-! RUN: bbc -emit-fir -hlfir -o - %s | FileCheck %s
+! RUN: bbc -emit-hlfir -o - %s | FileCheck %s
 module comp_ref
 type t1
   integer :: scalar_i
   real :: scalar_x
 end type
 
 type t2
   integer :: scalar_i2

flang/test/Lower/HLFIR/designators.f90

 ! Test lowering of designators to HLFIR
-! RUN: bbc -emit-fir -hlfir -o - %s 2>&1 | FileCheck %s
+! RUN: bbc -emit-hlfir -o - %s 2>&1 | FileCheck %s
 
 subroutine array_ref(x, n)
   real :: x(:)
   integer(8) :: n
   print *, x(n)
 end subroutine
 ! CHECK-LABEL: func.func @_QParray_ref(
 ! CHECK:  %[[VAL_2:.*]]:2 = hlfir.declare %{{.*}} {uniq_name = "_QFarray_refEn"} : (!fir.ref<i64>) -> (!fir.ref<i64>, !fir.ref<i64>)

flang/test/Lower/HLFIR/dummy-argument-optional.f90

-! RUN: bbc -emit-fir -hlfir -o - %s | FileCheck %s
+! RUN: bbc -emit-hlfir -o - %s | FileCheck %s
 
 ! Test OPTIONAL lowering on caller/callee
 module opt
   implicit none
 contains
 
 ! Test optional character function
 ! CHECK-LABEL: func @_QMoptPchar_proc(

flang/test/Lower/HLFIR/elemental-array-ops.f90

 ! Test lowering of elemental intrinsic operations with array arguments to HLFIR
-! RUN: bbc -emit-fir -hlfir -o - %s 2>&1 | FileCheck %s
+! RUN: bbc -emit-hlfir -o - %s 2>&1 | FileCheck %s
 
 subroutine binary(x, y)
   integer :: x(100), y(100)
   x = x+y
 end subroutine
 ! CHECK-LABEL: func.func @_QPbinary(
 ! CHECK:  %[[VAL_4:.*]]:2 = hlfir.declare %{{.*}}(%[[VAL_3:[^)]*]]) {{.*}}x
 ! CHECK:  %[[VAL_7:.*]]:2 = hlfir.declare %{{.*}}(%[[VAL_6:[^)]*]]) {{.*}}y

flang/test/Lower/HLFIR/elemental-intrinsics.f90

 ! Test lowering of intrinsic elemental procedure reference to HLFIR
 ! The goal here is not to test every intrinsics, it is to test the
 ! lowering framework for elemental intrinsics. This test various
 ! intrinsics that have different number or arguments and argument types.
-! RUN: bbc -emit-fir -hlfir -o - %s | FileCheck %s
+! RUN: bbc -emit-hlfir -o - %s | FileCheck %s
 
 subroutine simple_elemental(x,y)
   real :: x(100), y(100)
   x = acos(y)
 end subroutine
 ! CHECK-LABEL: func.func @_QPsimple_elemental(
 ! CHECK:  %[[VAL_4:.*]]:2 = hlfir.declare %[[VAL_0:[a-z0-9]*]](%[[VAL_3:[a-z0-9]*]])  {{.*}}Ex
 ! CHECK:  %[[VAL_7:.*]]:2 = hlfir.declare %[[VAL_1:[a-z0-9]*]](%[[VAL_6:[a-z0-9]*]])  {{.*}}Ey

flang/test/Lower/HLFIR/elemental-user-procedure-ref-polymorphic.f90

 ! Test lowering of user defined elemental procedure reference to HLFIR
 ! With polymorphic arguments.
-! RUN: bbc -emit-fir -hlfir -I nw -polymorphic-type -o - %s 2>&1 | FileCheck %s
+! RUN: bbc -emit-hlfir -I nw -polymorphic-type -o - %s 2>&1 | FileCheck %s
 module def_some_types
   type :: t
     integer :: i
   end type
 end module
 
 subroutine test_polymporphic_array(scalar)
   use def_some_types

flang/test/Lower/HLFIR/elemental-user-procedure-ref.f90

 ! Test lowering of user defined elemental procedure reference to HLFIR
-! RUN: bbc -emit-fir -hlfir -o - %s 2>&1 | FileCheck %s
+! RUN: bbc -emit-hlfir -o - %s 2>&1 | FileCheck %s
 
 subroutine by_addr(x, y)
   integer :: x
   real :: y(100)
   interface
     real elemental function elem(a, b)
       integer, intent(in) :: a
       real, intent(in) :: b

flang/test/Lower/HLFIR/expr-addr.f90

 ! Test lowering of of expressions as address
-! RUN: bbc -emit-fir -hlfir -o - %s 2>&1 | FileCheck %s
+! RUN: bbc -emit-hlfir -o - %s 2>&1 | FileCheck %s
 
 ! CHECK-LABEL: func.func @_QPfoo(
 ! CHECK-SAME: %[[arg0:.*]]: !fir.ref<i32>
 subroutine foo(x)
   integer :: x
   read (*,*) x
   ! CHECK: %[[x:.]]:2 = hlfir.declare %[[arg0]] {uniq_name = "_QFfooEx"} : (!fir.ref<i32>) -> (!fir.ref<i32>, !fir.ref<i32>)
   ! CHECK: %[[x_cast:.*]] = fir.convert %[[x]]#1 : (!fir.ref<i32>) -> !fir.ref<i64>

flang/test/Lower/HLFIR/expr-as-inquired.f90

 ! Test lowering to HLFIR of the intrinsic lowering framework
 ! "asInquired" option.
 
-! RUN: bbc -emit-fir -hlfir -o - %s | FileCheck %s
+! RUN: bbc -emit-hlfir -o - %s | FileCheck %s
 
 subroutine test_isAllocated(x, l)
   logical :: l
   real, allocatable :: x(:)
   l = allocated(x)
 end subroutine
 ! CHECK-LABEL: func.func @_QPtest_isallocated(
 ! CHECK:  %[[VAL_2:.*]]:2 = hlfir.declare %{{.*}}  {{.*}}El

flang/test/Lower/HLFIR/expr-value.f90

 ! Test lowering of of expressions as values
-! RUN: bbc -emit-fir -hlfir -o - %s 2>&1 | FileCheck %s
+! RUN: bbc -emit-hlfir -o - %s 2>&1 | FileCheck %s
 
 ! CHECK-LABEL: func.func @_QPfoo()
 subroutine foo()
   print *, 42
   ! CHECK: %[[c42:.*]] = arith.constant 42 : i32
   ! CHECK: fir.call @_FortranAioOutputInteger32(%{{.*}}, %[[c42]]) {{.*}}: (!fir.ref<i8>, i32) -> i1
 end subroutine
 
 ! CHECK-LABEL: func.func @_QPfoo_designator(
 ! CHECK-SAME: %[[arg0:.*]]: !fir.ref<i32>
 subroutine foo_designator(n)
   !CHECK:  %[[n:.*]]:2 = hlfir.declare %[[arg0]] {uniq_name = "_QFfoo_designatorEn"} : (!fir.ref<i32>) -> (!fir.ref<i32>, !fir.ref<i32>)
   print *, n
   ! CHECK: %[[nval:.*]] = fir.load %[[n]]#1 : !fir.ref<i32>
   ! CHECK: fir.call @_FortranAioOutputInteger32(%{{.*}}, %[[nval]]) {{.*}}: (!fir.ref<i8>, i32) -> i1
 end subroutine

flang/test/Lower/HLFIR/function-return.f90

 ! Test lowering of function return to HLFIR
-! RUN: bbc -emit-fir -hlfir -o - %s 2>&1 | FileCheck %s
+! RUN: bbc -emit-hlfir -o - %s 2>&1 | FileCheck %s
 
 integer function simple_return()
   simple_return = 42
 end function
 ! CHECK-LABEL: func.func @_QPsimple_return() -> i32 {
 ! CHECK:  %[[VAL_0:.*]] = fir.alloca i32
 ! CHECK:  %[[VAL_1:.*]]:2 = hlfir.declare %[[VAL_0]] {uniq_name = "_QFsimple_returnEsimple_return"} : (!fir.ref<i32>) -> (!fir.ref<i32>, !fir.ref<i32>)
 ! CHECK:  %[[VAL_2:.*]] = arith.constant 42 : i32

flang/test/Lower/HLFIR/ignore-rank-unlimited-polymorphic.f90

 ! Test passing mismatching rank arguments to unlimited polymorphic
 ! dummy with IGNORE_TKR(R).
-! RUN: bbc -hlfir -emit-fir -polymorphic-type -o - -I nowhere %s 2>&1 | FileCheck %s
+! RUN: bbc -emit-hlfir -polymorphic-type -o - -I nowhere %s 2>&1 | FileCheck %s
 
 module m
   interface
      subroutine callee(x)
        class(*) :: x
        !dir$ ignore_tkr (r) x
      end subroutine callee
   end interface

flang/test/Lower/HLFIR/implicit-call-mismatch.f90

 ! Test questionable but existing abuses of implicit interfaces.
 ! Lowering must close the eyes and do as if it did not know
 ! about the function definition since semantic lets these
 ! programs through with a warning.
-! RUN: bbc -emit-fir -hlfir %s -o - | FileCheck %s
+! RUN: bbc -emit-hlfir %s -o - | FileCheck %s
 
 subroutine takes_char(c)
   character(8) :: c
 end subroutine
 
 subroutine pass_real_to_char(r)
   real(8) :: r
   call takes_char(r)

flang/test/Lower/HLFIR/implicit-type-conversion.f90

-! RUN: bbc -emit-fir -hlfir %s -o - | FileCheck %s
+! RUN: bbc -emit-hlfir %s -o - | FileCheck %s
 
 ! CHECK-LABEL:   func.func @_QPtest1(
 ! CHECK-SAME:                        %[[VAL_0:.*]]: !fir.ref<i32> {fir.bindc_name = "x"},
 ! CHECK-SAME:                        %[[VAL_1:.*]]: !fir.ref<!fir.logical<4>> {fir.bindc_name = "y"}) {
 ! CHECK:           %[[VAL_2:.*]]:2 = hlfir.declare %[[VAL_0]] {uniq_name = "_QFtest1Ex"} : (!fir.ref<i32>) -> (!fir.ref<i32>, !fir.ref<i32>)
 ! CHECK:           %[[VAL_3:.*]]:2 = hlfir.declare %[[VAL_1]] {uniq_name = "_QFtest1Ey"} : (!fir.ref<!fir.logical<4>>) -> (!fir.ref<!fir.logical<4>>, !fir.ref<!fir.logical<4>>)
 ! CHECK:           %[[VAL_4:.*]] = fir.load %[[VAL_3]]#0 : !fir.ref<!fir.logical<4>>
 ! CHECK:           %[[VAL_5:.*]] = fir.convert %[[VAL_4]] : (!fir.logical<4>) -> i32

flang/test/Lower/HLFIR/internal-procedures.f90

 ! Test captured variables instantiation inside internal procedures
 ! when lowering to HLFIR.
-! RUN: bbc -emit-fir -hlfir -o - %s | FileCheck %s
+! RUN: bbc -emit-hlfir -o - %s | FileCheck %s
 subroutine test_explicit_shape_array(x, n)
   integer(8) :: n
   real :: x(n)
 contains
 subroutine internal
   call takes_array(x)
 end subroutine
 end subroutine

flang/test/Lower/HLFIR/intrinsic-assumed-type.f90

 ! Test lowering of intrinsic procedure to HLFIR with assumed types
 ! arguments. These are a bit special because semantics do not represent
 ! assumed types actual arguments with an evaluate::Expr like for usual
 ! arguments.
-! RUN: bbc -emit-fir -hlfir --polymorphic-type -o - %s | FileCheck %s
+! RUN: bbc -emit-hlfir --polymorphic-type -o - %s | FileCheck %s
 
 subroutine assumed_type_to_intrinsic(a)
   type(*) :: a(:)
   if (is_contiguous(a)) call something()
 end subroutine
 ! CHECK-LABEL:   func.func @_QPassumed_type_to_intrinsic(
 ! CHECK:  %[[VAL_1:.*]]:2 = hlfir.declare {{.*}}a"
 ! CHECK:  %[[VAL_2:.*]] = fir.convert %[[VAL_1]]#1 : (!fir.box<!fir.array<?xnone>>) -> !fir.box<none>

flang/test/Lower/HLFIR/intrinsic-module-procedures.f90

 ! Test lowering of intrinsic module procedures to HLFIR. This
 ! test is not meant to test every intrinsic module procedure,
 ! it only tests that the HFLIR procedure reference lowering
 ! infrastructure properly detects and dispatches intrinsic module
 ! procedure calls.
-! RUN: bbc -emit-fir -hlfir -o - %s | FileCheck %s
+! RUN: bbc -emit-hlfir -o - %s | FileCheck %s
 
 subroutine foo(cptr, x)
   use iso_c_binding, only : c_ptr, c_loc
   type(c_ptr) :: cptr
   integer, target :: x
   cptr = c_loc(x)
 end subroutine
 ! CHECK-LABEL: func.func @_QPfoo(

flang/test/Lower/HLFIR/intrinsic-subroutines.f90

 ! Test lowering of intrinsic subroutines to HLFIR what matters here
 ! is not to test each subroutine, but to check how their
 ! lowering interfaces with the rest of lowering.
-! RUN: bbc -emit-fir -hlfir -o - %s | FileCheck %s
+! RUN: bbc -emit-hlfir -o - %s | FileCheck %s
 
 subroutine test_subroutine(x)
  real :: x
  call cpu_time(x)
 end subroutine
 ! CHECK-LABEL: func.func @_QPtest_subroutine(
 ! CHECK:  %[[VAL_1:.*]]:2 = hlfir.declare %{{.*}}
 ! CHECK:  %[[VAL_2:.*]] = fir.call @_FortranACpuTime() fastmath<contract> : () -> f64
 ! CHECK:  %[[VAL_3:.*]] = fir.convert %[[VAL_2]] : (f64) -> f32
 ! CHECK:  fir.store %[[VAL_3]] to %[[VAL_1]]#1 : !fir.ref<f32>

flang/test/Lower/HLFIR/matmul.f90

 ! Test lowering of MATMUL intrinsic to HLFIR
-! RUN: bbc -emit-fir -hlfir -o - %s 2>&1 | FileCheck %s
+! RUN: bbc -emit-hlfir -o - %s 2>&1 | FileCheck %s
 
 subroutine matmul1(lhs, rhs, res)
   integer :: lhs(:,:), rhs(:,:), res(:,:)
   res = MATMUL(lhs, rhs)
 endsubroutine
 ! CHECK-LABEL: func.func @_QPmatmul1
 ! CHECK:           %[[LHS:.*]]: !fir.box<!fir.array<?x?xi32>> {fir.bindc_name = "lhs"}
 ! CHECK:           %[[RHS:.*]]: !fir.box<!fir.array<?x?xi32>> {fir.bindc_name = "rhs"}

flang/test/Lower/HLFIR/null.f90

 ! Test lowering of NULL(MOLD) to HLFIR.
-! RUN: bbc -emit-fir -hlfir -o - %s | FileCheck %s
+! RUN: bbc -emit-hlfir -o - %s | FileCheck %s
 subroutine test1(mold)
   integer, pointer :: mold(:)
   interface
     subroutine takes_ptr(p)
       integer, pointer :: p(:)
     end subroutine
   end interface
   call takes_ptr(null(mold))

flang/test/Lower/HLFIR/parent-component-ref.f90

 ! Test lowering of parent component references to HLFIR.
-! RUN: bbc -emit-fir -hlfir -polymorphic-type -o - %s -I nw | FileCheck %s
+! RUN: bbc -emit-hlfir -polymorphic-type -o - %s -I nw | FileCheck %s
 
 module pc_types
   type t
     integer :: i
   end type
   type, extends(t) :: t2
     integer :: j
   end type

flang/test/Lower/HLFIR/procedure-designators.f90

 ! Test lowering of procedure designators to HLFIR.
-! RUN: bbc -emit-fir -hlfir -o - %s | FileCheck %s
+! RUN: bbc -emit-hlfir -o - %s | FileCheck %s
 
 module test_proc_designator
   interface
     subroutine simple()
     end subroutine
     character(10) function return_char(x)
        integer :: x
     end function

flang/test/Lower/HLFIR/product.f90

 ! Test lowering of PRODUCT intrinsic to HLFIR
-! RUN: bbc -emit-fir -hlfir -o - %s 2>&1 | FileCheck %s
+! RUN: bbc -emit-hlfir -o - %s 2>&1 | FileCheck %s
 
 ! simple 1 argument PRODUCT
 subroutine product1(a, s)
   integer :: a(:), s
   s = PRODUCT(a)
 end subroutine
 ! CHECK-LABEL: func.func @_QPproduct1(
 ! CHECK:           %[[ARG0:.*]]: !fir.box<!fir.array<?xi32>> {fir.bindc_name = "a"}, %[[ARG1:.*]]: !fir.ref<i32>

flang/test/Lower/HLFIR/statement-functions.f90

 ! Test lowering of statement functions to HLFIR
-! RUN: bbc -emit-fir -hlfir -o - %s 2>&1 | FileCheck %s
+! RUN: bbc -emit-hlfir -o - %s 2>&1 | FileCheck %s
 
 subroutine numeric_test(x)
   integer :: x(:), i, stmt_func
   stmt_func(i) = x(i)
   call bar(stmt_func(42))
 end subroutine
 ! CHECK-LABEL: func.func @_QPnumeric_test(
 ! CHECK:  %[[VAL_4:.*]]:2 = hlfir.declare %[[VAL_0:[^)]*]] {{.*}}x"

flang/test/Lower/HLFIR/substrings.f90

 ! Test lowering of substrings to HLFIR
 ! Note: cse is run to make the expected output more readable by sharing
 ! the boilerplate between the different susbtring cases.
-! RUN: bbc -emit-fir -hlfir -o - %s | fir-opt -cse -o - | FileCheck %s
+! RUN: bbc -emit-hlfir -o - %s | fir-opt -cse -o - | FileCheck %s
 
 ! CHECK-LABEL:   func.func @_QPcst_len(
 subroutine cst_len(array, scalar)
   character(10) :: array(100), scalar
 ! CHECK:  %[[VAL_5:.*]] = arith.constant 100 : index
 ! CHECK:  %[[VAL_7:.*]]:2 = hlfir.declare %{{.*}}(%[[VAL_6:.*]]) typeparams %[[VAL_3:[^ ]*]] {{.*}}array"
 ! CHECK:  %[[VAL_9:.*]]:2 = hlfir.declare %{{.*}} typeparams %[[VAL_3]] {{.*}}scalar"
   print *, array(:)(2:5)

flang/test/Lower/HLFIR/sum.f90

 ! Test lowering of SUM intrinsic to HLFIR
-! RUN: bbc -emit-fir -hlfir -o - %s 2>&1 | FileCheck %s
+! RUN: bbc -emit-hlfir -o - %s 2>&1 | FileCheck %s
 
 ! simple 1 argument SUM
 subroutine sum1(a, s)
   integer :: a(:), s
   s = SUM(a)
 end subroutine
 ! CHECK-LABEL: func.func @_QPsum1(
 ! CHECK:           %[[ARG0:.*]]: !fir.box<!fir.array<?xi32>> {fir.bindc_name = "a"}, %[[ARG1:.*]]: !fir.ref<i32>

flang/test/Lower/HLFIR/transformational.f90

 ! Test lowering of transformational intrinsic to HLFIR what matters here
 ! is not to test each transformational, but to check how their
 ! lowering interfaces with the rest of lowering.
-! RUN: bbc -emit-fir -hlfir -o - %s | FileCheck %s
+! RUN: bbc -emit-hlfir -o - %s | FileCheck %s
 
 subroutine test_transformational_implemented_with_runtime_allocation(x)
   real :: x(10, 10)
   ! MINLOC result is allocated inside the runtime and returned in
   ! a descriptor that was passed by reference to the runtime.
   ! Lowering does the following:
   !  - declares the temp created by the runtime as an hlfir variable.
   !  - "moves" this variable to an hlfir.expr

flang/test/Lower/HLFIR/transpose.f90

 ! Test lowering of TRANSPOSE intrinsic to HLFIR
-! RUN: bbc -emit-fir -hlfir -o - %s 2>&1 | FileCheck %s
+! RUN: bbc -emit-hlfir -o - %s 2>&1 | FileCheck %s
 
 subroutine transpose1(m, res)
   integer :: m(1,2), res(2, 1)
   res = TRANSPOSE(m)
 endsubroutine
 ! CHECK-LABEL: func.func @_QPtranspose1
 ! CHECK:           %[[M_ARG:.*]]: !fir.ref<!fir.array<1x2xi32>>
 ! CHECK:           %[[RES_ARG:.*]]: !fir.ref<!fir.array<2x1xi32>>
 ! CHECK-DAG:     %[[ARG:.*]]:2 = hlfir.declare %[[M_ARG]](%[[M_SHAPE:.*]]) {[[NAME:.*]]} : (!fir.ref<!fir.array<1x2xi32>>, !fir.shape<2>) -> (!fir.ref<!fir.array<1x2xi32>>, !fir.ref<!fir.array<1x2xi32>>)
 ! CHECK-DAG:     %[[RES:.*]]:2 = hlfir.declare %[[RES_ARG]](%[[RES_SHAPE:.*]]) {[[NAME2:.*]]} : (!fir.ref<!fir.array<2x1xi32>>, !fir.shape<2>) -> (!fir.ref<!fir.array<2x1xi32>>, !fir.ref<!fir.array<2x1xi32>>)
 ! CHECK:         %[[EXPR:.*]] = hlfir.transpose %[[ARG]]#0 : (!fir.ref<!fir.array<1x2xi32>>) -> !hlfir.expr<2x1xi32>
 ! CHECK-NEXT:    hlfir.assign %[[EXPR]] to %[[RES]]#0
 ! CHECK-NEXT:    hlfir.destroy %[[EXPR]]
 ! CHECK-NEXT:    return
 ! CHECK-NEXT:  }

flang/test/Lower/HLFIR/unary-ops.f90

 ! Test lowering of unary intrinsic operations to HLFIR
-! RUN: bbc -emit-fir -hlfir -o - %s 2>&1 | FileCheck %s
+! RUN: bbc -emit-hlfir -o - %s 2>&1 | FileCheck %s
 
 subroutine parentheses_numeric_var(x)
   integer :: x
   call bar((x))
 end subroutine
 ! CHECK-LABEL: func.func @_QPparentheses_numeric_var(
 ! CHECK:  %[[VAL_2:.*]] = fir.load %{{.*}} : !fir.ref<i32>
 ! CHECK:  %[[VAL_3:.*]] = hlfir.no_reassoc %[[VAL_2]] : i32

flang/test/Lower/HLFIR/vector-subscript-as-value.f90

 ! Test lowering of vector subscript designators outside of the
 ! assignment left-and side and input IO context.
-! RUN: bbc -emit-fir -hlfir -o - -I nw %s 2>&1 | FileCheck %s
+! RUN: bbc -emit-hlfir -o - -I nw %s 2>&1 | FileCheck %s
 
 subroutine foo(x, y)
   integer :: x(100)
   integer(8) :: y(20)
   call bar(x(y))
 end subroutine
 ! CHECK-LABEL:   func.func @_QPfoo(
 ! CHECK:  %[[VAL_2:.*]] = arith.constant 100 : index

flang/test/Lower/HLFIR/vector-subscript-lhs.f90

 ! Test lowering of vector subscripted designators in assignment
 ! left-hand sides.
-! RUN: bbc -emit-fir -hlfir -o - -I nw %s 2>&1 | FileCheck %s
+! RUN: bbc -emit-hlfir -o - -I nw %s 2>&1 | FileCheck %s
 
 subroutine test_simple(x, vector)
   integer(8) :: vector(10)
   real :: x(:)
   x(vector) = 42.
 end subroutine
 ! CHECK-LABEL:   func.func @_QPtest_simple(
 ! CHECK:  %[[VAL_4:.*]]:2 = hlfir.declare {{.*}}Evector

flang/test/Lower/HLFIR/where.f90

 ! Test lowering of WHERE construct and statements to HLFIR.
-! RUN: bbc --hlfir -emit-fir -o - %s | FileCheck %s
+! RUN: bbc -emit-hlfir -o - %s | FileCheck %s
 
 module where_defs
   logical :: mask(10)
   real :: x(10), y(10)
   real, allocatable :: a(:), b(:)
   interface
     function return_temporary_mask()
       logical, allocatable :: return_temporary_mask(:)

flang/tools/bbc/bbc.cpp

static llvm::cl::opt<std::string>
     moduleSuffix("module-suffix", llvm::cl::desc("module file suffix override"),
                  llvm::cl::init(".mod"));
 
 static llvm::cl::opt<bool>
     emitFIR("emit-fir",
             llvm::cl::desc("Dump the FIR created by lowering and exit"),
             llvm::cl::init(false));
 
+static llvm::cl::opt<bool>
+    emitHLFIR("emit-hlfir",
+            llvm::cl::desc("Dump the HLFIR created by lowering and exit"),
+            llvm::cl::init(false));
+
 static llvm::cl::opt<bool> warnStdViolation("Mstandard",
                                             llvm::cl::desc("emit warnings"),
                                             llvm::cl::init(false));
 
 static llvm::cl::opt<bool> warnIsError("Werror",
                                        llvm::cl::desc("warnings are errors"),
                                        llvm::cl::init(false));
 
static mlir::LogicalResult convertFortranSourceToMLIR(
   mlir::MLIRContext ctx(registry);
   fir::support::loadNonCodegenDialects(ctx);
   auto &defKinds = semanticsContext.defaultKinds();
   fir::KindMapping kindMap(
       &ctx, llvm::ArrayRef<fir::KindTy>{fir::fromDefaultKinds(defKinds)});
   // Use default lowering options for bbc.
   Fortran::lower::LoweringOptions loweringOptions{};
   loweringOptions.setPolymorphicTypeImpl(enablePolymorphic);
-  loweringOptions.setLowerToHighLevelFIR(useHLFIR);
+  loweringOptions.setLowerToHighLevelFIR(useHLFIR || emitHLFIR);
   auto burnside = Fortran::lower::LoweringBridge::create(
       ctx, semanticsContext, defKinds, semanticsContext.intrinsics(),
       semanticsContext.targetCharacteristics(), parsing.allCooked(), "",
       kindMap, loweringOptions, {});
   burnside.lower(parseTree, semanticsContext);
   mlir::ModuleOp mlirModule = burnside.getModule();
   if (enableOpenMP) {
     auto offloadModuleOpts = OffloadModuleOpts(
static mlir::LogicalResult convertFortranSourceToMLIR(
   (void)mlir::applyPassManagerCLOptions(pm);
   if (passPipeline.hasAnyOccurrences()) {
     // run the command-line specified pipeline
     hlfir::registerHLFIRPasses();
     (void)passPipeline.addToPipeline(pm, [&](const llvm::Twine &msg) {
       mlir::emitError(mlir::UnknownLoc::get(&ctx)) << msg;
       return mlir::failure();
     });
-  } else if (emitFIR) {
+  } else if (emitFIR || emitHLFIR) {
     // --emit-fir: Build the IR, verify it, and dump the IR if the IR passes
     // verification. Use --dump-module-on-failure to dump invalid IR.
     pm.addPass(std::make_unique<Fortran::lower::VerifierPass>());
     if (mlir::failed(pm.run(mlirModule))) {
       llvm::errs() << "FATAL: verification of lowering to FIR failed";
       return mlir::failure();
     }
+
+    if (emitFIR && useHLFIR) {
+      // lower HLFIR to FIR
+      fir::createHLFIRToFIRPassPipeline(pm, llvm::OptimizationLevel::O2);
+      if (mlir::failed(pm.run(mlirModule))) {
+        llvm::errs() << "FATAL: lowering from HLFIR to FIR failed";
+        return mlir::failure();
+      }
+    }
+
     printModule(mlirModule, out);
     return mlir::success();
   } else {
     // run the default canned pipeline
     pm.addPass(std::make_unique<Fortran::lower::VerifierPass>());
 
     // Add O2 optimizer pass pipeline.
     fir::createDefaultFIROptimizerPassPipeline(pm, llvm::OptimizationLevel::O2);