[flang] Turn on use-desc-for-alloc by default

[jeanPerier]

Summary

Currently, local allocatables and contiguous/scalar pointers (and some
other conditions) are lowered to a set of independent variables in FIR
(one for the address, one for each bound and one for character length).
The intention was to help LLVM get rids of descriptors. But LLVM knows
how to do that anyway in those cases:

subroutine foo(x)
 real, target :: x(100)
 real, pointer, contiguous :: p(:)
 p => x
 call bar(p(50))
end subroutine

The output fir the option on or off is the same after llvm opt -O1,
there is no descriptor anymore, the indirection is removed.

define void @foo_(ptr %0) local_unnamed_addr {
  %2 = getelementptr [100 x float], ptr %0, i64 0, i64 49
  tail call void @bar_(ptr %2)
  ret void
}

So the benefit of not using a descriptor in lowering is questionable,
and although it is abstracted as much as possible in the so called
MutableBoxValue class that represent allocatable/pointer in lowering
it is still causing bugs from time to time, and will also be a bit
problematic when emitting debug info for the pointer/allocatable.

In HLFIR lowering, the simplification to always use a descriptor in
lowering was already made. This patch allows decorrelating the impact
from this change from the bigger impact HLFIR will have so that it
is easier to get feedback if this causes performance issues.

The lowering tests relying on the previous behavior are only updated
to set back this option to true. The reason is that I think we should
preserve coverage of the code dealing with the "non descriptor" approach
in lowering until we actually get rid of it. The other reason is that
the test will have to be or are already covered by equivalent HLFIR
tests, which use descriptors.

[edit: fixed the example to pass p instead of x to bar, otherwise the test is pointless. The resulting LLVM is the same after opt -O1].

[tblah]

Could there be cases where LLVM optimization passes take longer to run because they are removing these descriptors we know we don't need? I would guess this is okay for real code but I was wondering if you have tried it?

[jeanPerier]

In D148910#4286583, @tblah wrote:

Could there be cases where LLVM optimization passes take longer to run because they are removing these descriptors we know we don't need? I would guess this is okay for real code but I was wondering if you have tried it?

Good question. The problem is the "we know we don't need". At that point of the lowering code, we do not really know that we do not need a descriptor, in fact, we still create one with this option turned off, because as soon as the pointer/allocatable is passed as a pointer/allocatable to the runtime or user code, we need a descriptor an we insert sync operation from/to these values after/before the call. This early optimization is only a win if the pointer/allocatable never escapes.

Here is some dumb numbers to illustrate:

program_1.f90

subroutine foo(x)
 real, target :: x(100)
 real, pointer, contiguous :: p(:)
 p => x
 call bar(p(50))
 ! ...
 ! ... repeat call bar(p(50)) 10000 times.
 ! ...
end subroutine

--use-desc-for-alloc=false:

• Number of .ll lines after codgeneration from FIR to LLVM: 50k.
• time flang-new -O1 (on a beefy X86_64 machine): 2s.

--use-desc-for-alloc=true:

• Number of .ll lines after codgeneration from FIR to LLVM: 180k.
• time flang-new -O1 (on a beefy X86_64 machine): 5s.

-> Same code after -O1, but x2 faster compilation with the previous --use-desc-for-alloc=false option.

program_2.f90:

subroutine foo(x)
 real, target :: x(100)
 real, pointer, contiguous :: p(:)
 interface
  subroutine bar_ptr(p)
    real, pointer, contiguous :: p(:)
  end subroutine
 end interface

 p => x
 call bar(p(50))
 ! ...
 ! ... repeat call bar_ptr(p(50)) 10000 times.
 ! ...
end subroutine

--use-desc-for-alloc=false:

• Number of .ll lines after codgeneration from FIR to LLVM: 300k.
• time flang-new -O1 (on a beefy X86_64 machine): 25s. And did not managed to get rid of all the intermediate descriptor sync, even at -O3!

--use-desc-for-alloc=true:

• Number of .ll lines after codgeneration from FIR to LLVM: 10k.
• time flang-new -O1 (on a beefy X86_64 machine): 0.8s.

-> x30 (!) faster compilation with the new --use-desc-for-alloc=true option, and better code with it (the sync from/to descriptor are not optimized away with -O3 with the --use-desc-for-alloc=flase). The reason for the sync optimization failure is that LLVM cannot guess that it can get rid of the code that sets-up the CFI code and versions in the descriptor when doing the sync from the values to the fir.box (it assumes the previous call may have modified those descriptor fields, and that it should keep these field updates generate by the fir.embox before the next calls).

Conclusion: the answer to your question depends of the actual workloads... I was able to write you stupid code that compiles 30x faster with this patch, but it is probably not representative (This only shows if passing the pointer/allocatabale to a procedure taking a pointer/allocatable a lot). The take-away is that the inserted "sync" operations of the current lowering are expensive and hard to optimize away, while it is easy to get rid of descriptors. So this was probably a premature optimization anyway. Overall, on "actual" workloads, I do not really expect we are able to measure much difference after this patch. But if you do see perf regressions, we can revert that and try to add a FIR pass to "scalarize" fir.box before we turn them into big LLVM structs and many insert/extract operations. This pass would be able to easily see the cost of scalarization, which we are not at that point.

[tblah]

Thanks for the detailed explanation.

This looks good to me. As you say in the description, merging this is the easiest way to find out early if doing this has unforeseen consequences.

Please wait for review from somebody else too, because I haven't worked much with FIR lowering.

[clementval]

LGTM

flang/lib/Lower/Allocatable.cpp

 /// By default fir memory operation fir::AllocMemOp/fir::FreeMemOp are used.
 /// This switch allow forcing the use of runtime and descriptors for everything.
 /// This is mainly intended as a debug switch.
 static llvm::cl::opt<bool> useAllocateRuntime(
     "use-alloc-runtime",
     llvm::cl::desc("Lower allocations to fortran runtime calls"),
     llvm::cl::init(false));
 /// Switch to force lowering of allocatable and pointers to descriptors in all
-/// cases for debug purposes.
+/// cases. This is now turned on by default since that is what will happen with
+/// HLFIR lowering, so this allows getting early feedback of the impact.
+/// If this turns out to cause performance regressions, a dedicated fir.box
+/// "discretization pass" would make more sense to cover all the fir.box usage
+/// (taking advantage of any future inlining for instance).
 static llvm::cl::opt<bool> useDescForMutableBox(
     "use-desc-for-alloc",
     llvm::cl::desc("Always use descriptors for POINTER and ALLOCATABLE"),
-    llvm::cl::init(false));
+    llvm::cl::init(true));
 
 //===----------------------------------------------------------------------===//
 // Error management
 //===----------------------------------------------------------------------===//
 
 namespace {
 // Manage STAT and ERRMSG specifier information across a sequence of runtime
 // calls for an ALLOCATE/DEALLOCATE stmt.

flang/test/Lower/Intrinsics/c_loc.f90

-! RUN: bbc -emit-fir %s -o - | FileCheck %s
-! RUN: %flang_fc1 -emit-fir %s -o - | FileCheck %s
+! RUN: bbc --use-desc-for-alloc=false --emit-fir %s -o - | FileCheck %s
+! RUN: %flang_fc1 -mllvm --use-desc-for-alloc=false -emit-fir %s -o - | FileCheck %s
 
 ! Test intrinsic module procedure c_loc
 
 ! CHECK-LABEL: func.func @_QPc_loc_scalar() {
 ! CHECK:         %[[VAL_0:.*]] = fir.address_of(@_QFc_loc_scalarEi) : !fir.ref<i32>
 ! CHECK:         %[[VAL_1:.*]] = fir.alloca !fir.type<_QM__fortran_builtinsT__builtin_c_ptr{__address:i64}> {bindc_name = "ptr", uniq_name = "_QFc_loc_scalarEptr"}
 ! CHECK:         %[[VAL_2:.*]] = fir.embox %[[VAL_0]] : (!fir.ref<i32>) -> !fir.box<i32>
 ! CHECK:         %[[VAL_3:.*]] = fir.alloca !fir.type<_QM__fortran_builtinsT__builtin_c_ptr{__address:i64}>

flang/test/Lower/Intrinsics/iall.f90

-! RUN: bbc -emit-fir %s -o - | FileCheck %s
+! RUN: bbc --use-desc-for-alloc=false -emit-fir %s -o - | FileCheck %s
 
 ! CHECK-LABEL: func @_QPiall_test_1(
 ! CHECK-SAME: %[[arg0:.*]]: !fir.box<!fir.array<?xi8>>{{.*}}) -> i8 {
 integer(1) function iall_test_1(a)
 integer(1) :: a(:)
 ! CHECK-DAG:  %[[c0:.*]] = arith.constant 0 : index
 ! CHECK-DAG:  %[[a1:.*]] = fir.absent !fir.box<i1>
 ! CHECK-DAG: %[[a3:.*]] = fir.convert %[[arg0]] : (!fir.box<!fir.array<?xi8>>) -> !fir.box<none>

flang/test/Lower/Intrinsics/iany.f90

-! RUN: bbc -emit-fir %s -o - | FileCheck %s
+! RUN: bbc --use-desc-for-alloc=false -emit-fir %s -o - | FileCheck %s
 
 ! CHECK-LABEL: func @_QPiany_test_1(
 ! CHECK-SAME: %[[arg0:.*]]: !fir.box<!fir.array<?xi8>>{{.*}}) -> i8 {
 integer(1) function iany_test_1(a)
 integer(1) :: a(:)
 ! CHECK-DAG:  %[[c0:.*]] = arith.constant 0 : index
 ! CHECK-DAG:  %[[a1:.*]] = fir.absent !fir.box<i1>
 ! CHECK-DAG: %[[a3:.*]] = fir.convert %[[arg0]] : (!fir.box<!fir.array<?xi8>>) -> !fir.box<none>

flang/test/Lower/Intrinsics/iparity.f90

-! RUN: bbc -emit-fir %s -o - | FileCheck %s
+! RUN: bbc --use-desc-for-alloc=false -emit-fir %s -o - | FileCheck %s
 
 ! CHECK-LABEL: func @_QPiparity_test_1(
 ! CHECK-SAME: %[[arg0:.*]]: !fir.box<!fir.array<?xi8>>{{.*}}) -> i8 {
 integer(1) function iparity_test_1(a)
 integer(1) :: a(:)
 ! CHECK-DAG:  %[[c0:.*]] = arith.constant 0 : index
 ! CHECK-DAG:  %[[a1:.*]] = fir.absent !fir.box<i1>
 ! CHECK-DAG: %[[a3:.*]] = fir.convert %[[arg0]] : (!fir.box<!fir.array<?xi8>>) -> !fir.box<none>

flang/test/Lower/Intrinsics/len.f90

-! RUN: bbc -emit-fir %s -o - | FileCheck %s
+! RUN: bbc --use-desc-for-alloc=false -emit-fir %s -o - | FileCheck %s
 
 ! CHECK-LABEL: len_test
 subroutine len_test(i, c)
   integer :: i
   character(*) :: c
   ! CHECK: %[[c:.*]]:2 = fir.unboxchar %arg1
   ! CHECK: %[[xx:.*]] = fir.convert %[[c]]#1 : (index) -> i32
   ! CHECK: fir.store %[[xx]] to %arg0

flang/test/Lower/Intrinsics/loc.f90

-! RUN: bbc -emit-fir %s -o - | FileCheck %s
-! RUN: %flang_fc1 -emit-fir %s -o - | FileCheck %s
+! RUN: bbc --use-desc-for-alloc=false -emit-fir %s -o - | FileCheck %s
+! RUN: %flang_fc1 -mllvm --use-desc-for-alloc=false -emit-fir %s -o - | FileCheck %s
 
 ! Test LOC intrinsic
 
 ! CHECK-LABEL: func.func @_QPloc_scalar() {
 subroutine loc_scalar()
   integer(8) :: p
   integer :: x
   p = loc(x)

flang/test/Lower/Intrinsics/move_alloc.f90

-  ! RUN: bbc -emit-fir %s -o - | FileCheck  %s
-  ! RUN: flang-new -fc1 -emit-fir %s -o - | FileCheck %s
+  ! RUN: bbc --use-desc-for-alloc=false -emit-fir %s -o - | FileCheck  %s
+  ! RUN: flang-new -fc1 -mllvm --use-desc-for-alloc=false -emit-fir %s -o - | FileCheck %s
 
 ! CHECK-LABEL: to_from_only
 subroutine to_from_only
   ! CHECK: %[[a1:.*]] = fir.alloca !fir.box<!fir.heap<!fir.array<?xi32>>>
   ! CHECK: %[[b1:.*]] = fir.alloca !fir.box<!fir.heap<!fir.array<?xi32>>>
   integer, allocatable :: from(:), to(:)
   allocate(from(20))
   ! CHECK: %[[errMsg:.*]] = fir.absent !fir.box<none>

flang/test/Lower/Intrinsics/product.f90

-! RUN: bbc -emit-fir %s -o - | FileCheck %s
+! RUN: bbc --use-desc-for-alloc=false -emit-fir %s -o - | FileCheck %s
 
 ! CHECK-LABEL: func @_QPproduct_test(
 ! CHECK-SAME: %[[arg0:.*]]: !fir.box<!fir.array<?xi32>>{{.*}}) -> i32
 integer function product_test(a)
 integer :: a(:)
 ! CHECK-DAG:  %[[c0:.*]] = arith.constant 0 : index
 ! CHECK-DAG:  %[[a1:.*]] = fir.absent !fir.box<i1>
 ! CHECK-DAG: %[[a3:.*]] = fir.convert %[[arg0]] : (!fir.box<!fir.array<?xi32>>) -> !fir.box<none>

flang/test/Lower/Intrinsics/sum.f90

-! RUN: bbc -emit-fir %s -o - | FileCheck %s
+! RUN: bbc --use-desc-for-alloc=false -emit-fir %s -o - | FileCheck %s
 
 ! CHECK-LABEL: func @_QPsum_test(
 ! CHECK-SAME: %[[arg0:.*]]: !fir.box<!fir.array<?xi32>>{{.*}}) -> i32 {
 integer function sum_test(a)
 integer :: a(:)
 ! CHECK-DAG:  %[[c0:.*]] = arith.constant 0 : index
 ! CHECK-DAG:  %[[a1:.*]] = fir.absent !fir.box<i1>
 ! CHECK-DAG: %[[a3:.*]] = fir.convert %[[arg0]] : (!fir.box<!fir.array<?xi32>>) -> !fir.box<none>

flang/test/Lower/Intrinsics/system_clock.f90

-! RUN: bbc -emit-fir %s -o - | FileCheck %s
+! RUN: bbc --use-desc-for-alloc=false -emit-fir %s -o - | FileCheck %s
 
 ! CHECK-LABEL: system_clock_test
 subroutine system_clock_test()
   integer(4) :: c
   integer(8) :: m
   real :: r
   ! CHECK-DAG: %[[c:.*]] = fir.alloca i32 {bindc_name = "c"
   ! CHECK-DAG: %[[m:.*]] = fir.alloca i64 {bindc_name = "m"

flang/test/Lower/OpenACC/acc-data-operands.f90

 ! This test checks lowering of complex OpenACC data operands.
 
-! RUN: bbc -fopenacc -emit-fir %s -o - | FileCheck %s
+! RUN: bbc --use-desc-for-alloc=false -fopenacc -emit-fir %s -o - | FileCheck %s
 
 module acc_data_operand
 
   type wrapper
     real :: data(100)
   end type
 
 contains

flang/test/Lower/OpenMP/atomic-read.f90

-! RUN: bbc -fopenmp -emit-fir %s -o - | FileCheck %s
+! RUN: bbc --use-desc-for-alloc=false -fopenmp -emit-fir %s -o - | FileCheck %s
 
 ! This test checks the lowering of atomic read
 
 !CHECK: func @_QQmain() attributes {fir.bindc_name = "ompatomic"} {
 !CHECK: %[[VAR_A:.*]] = fir.alloca !fir.char<1> {bindc_name = "a", uniq_name = "_QFEa"}
 !CHECK: %[[VAR_B:.*]] = fir.alloca !fir.char<1> {bindc_name = "b", uniq_name = "_QFEb"}
 !CHECK: %[[VAR_C:.*]] = fir.alloca !fir.logical<4> {bindc_name = "c", uniq_name = "_QFEc"}
 !CHECK: %[[VAR_D:.*]] = fir.alloca !fir.logical<4> {bindc_name = "d", uniq_name = "_QFEd"}

flang/test/Lower/OpenMP/atomic-update.f90

 ! This test checks lowering of atomic and atomic update constructs
-! RUN: bbc -fopenmp -emit-fir %s -o - | FileCheck %s
-! RUN: %flang_fc1 -emit-fir -fopenmp %s -o - | FileCheck %s
+! RUN: bbc --use-desc-for-alloc=false -fopenmp -emit-fir %s -o - | FileCheck %s
+! RUN: %flang_fc1 -mllvm --use-desc-for-alloc=false -emit-fir -fopenmp %s -o - | FileCheck %s
 
 program OmpAtomicUpdate
     use omp_lib
     integer :: x, y, z
     integer, pointer :: a, b
     integer, target :: c, d
     integer(1) :: i1
 

flang/test/Lower/OpenMP/atomic-write.f90

-! RUN: bbc -fopenmp -emit-fir %s -o - | FileCheck %s
+! RUN: bbc --use-desc-for-alloc=false -fopenmp -emit-fir %s -o - | FileCheck %s
 
 ! This test checks the lowering of atomic write
 
 !CHECK: func @_QQmain() attributes {fir.bindc_name = "ompatomicwrite"} {
 !CHECK: %[[VAR_X:.*]] = fir.alloca i32 {bindc_name = "x", uniq_name = "_QFEx"}
 !CHECK: %[[VAR_Y:.*]] = fir.alloca i32 {bindc_name = "y", uniq_name = "_QFEy"}
 !CHECK: %[[VAR_Z:.*]] = fir.alloca i32 {bindc_name = "z", uniq_name = "_QFEz"}
 !CHECK: %[[CONST_44:.*]] = arith.constant 44 : i32

flang/test/Lower/OpenMP/parallel-private-clause.f90

 ! This test checks lowering of OpenMP parallel Directive with
 ! `PRIVATE` clause present.
 
 ! REQUIRES: shell
-! RUN: bbc -fopenmp -emit-fir %s -o - | \
+! RUN: bbc --use-desc-for-alloc=false -fopenmp -emit-fir %s -o - | \
 ! RUN:   FileCheck %s --check-prefix=FIRDialect
 
 !FIRDialect: func @_QPprivate_clause(%[[ARG1:.*]]: !fir.ref<i32>{{.*}}, %[[ARG2:.*]]: !fir.ref<!fir.array<10xi32>>{{.*}}, %[[ARG3:.*]]: !fir.boxchar<1>{{.*}}, %[[ARG4:.*]]: !fir.boxchar<1>{{.*}}) {
 !FIRDialect-DAG: %[[ALPHA:.*]] = fir.alloca i32 {{{.*}}, uniq_name = "{{.*}}Ealpha"}
 !FIRDialect-DAG: %[[ALPHA_ARRAY:.*]] = fir.alloca !fir.array<10xi32> {{{.*}}, uniq_name = "{{.*}}Ealpha_array"}
 !FIRDialect-DAG: %[[BETA:.*]] = fir.alloca !fir.char<1,5> {{{.*}}, uniq_name = "{{.*}}Ebeta"}
 !FIRDialect-DAG: %[[BETA_ARRAY:.*]] = fir.alloca !fir.array<10x!fir.char<1,5>> {{{.*}}, uniq_name = "{{.*}}Ebeta_array"}
 

flang/test/Lower/allocatable-assignment.f90

 ! Test allocatable assignments
-! RUN: bbc -emit-fir %s -o - | FileCheck %s
+! RUN: bbc --use-desc-for-alloc=false -emit-fir %s -o - | FileCheck %s
 
 module alloc_assign
   type t
     integer :: i
   end type
 contains
 
 ! -----------------------------------------------------------------------------

flang/test/Lower/allocatable-polymorphic.f90

-! RUN: bbc -polymorphic-type -emit-fir %s -o - | FileCheck %s
-! RUN: bbc -polymorphic-type -emit-fir %s -o - | tco | FileCheck %s --check-prefix=LLVM
+! RUN: bbc --use-desc-for-alloc=false -polymorphic-type -emit-fir %s -o - | FileCheck %s
+! RUN: bbc --use-desc-for-alloc=false -polymorphic-type -emit-fir %s -o - | tco | FileCheck %s --check-prefix=LLVM
 
 module poly
   type p1
     integer :: a
     integer :: b
   contains
     procedure, nopass :: proc1 => proc1_p1
     procedure :: proc2 => proc2_p1

flang/test/Lower/allocatables.f90

-! RUN: bbc -emit-fir %s -o - | FileCheck %s
+! RUN: bbc --use-desc-for-alloc=false -emit-fir %s -o - | FileCheck %s
 
 ! Test lowering of allocatables using runtime for allocate/deallcoate statements.
 ! CHECK-LABEL: _QPfooscalar
 subroutine fooscalar()
   ! Test lowering of local allocatable specification
   real, allocatable :: x
   ! CHECK: %[[xAddrVar:.*]] = fir.alloca !fir.heap<f32> {{{.*}}uniq_name = "_QFfooscalarEx.addr"}
   ! CHECK: %[[nullAddr:.*]] = fir.zero_bits !fir.heap<f32>

flang/test/Lower/allocate-mold.f90

-! RUN: bbc -emit-fir %s -o - | FileCheck %s
+! RUN: bbc --use-desc-for-alloc=false -emit-fir %s -o - | FileCheck %s
 
 ! Test lowering of ALLOCATE statement with a MOLD argument for scalars
 
 subroutine scalar_mold_allocation()
   integer, allocatable :: a
   allocate(a, mold=9)
 end subroutine
 

flang/test/Lower/allocate-source-allocatables.f90

-! RUN: bbc -emit-fir %s -o - | FileCheck %s
+! RUN: bbc --use-desc-for-alloc=false -emit-fir %s -o - | FileCheck %s
 
 ! Test lowering of allocatables for allocate statements with source.
 
 ! CHECK-LABEL: func.func @_QPtest_allocatable_scalar(
 ! CHECK-SAME:                                        %[[VAL_0:.*]]: !fir.ref<f32> {fir.bindc_name = "a"}) {
 ! CHECK:         %[[VAL_1:.*]] = fir.address_of(@_QFtest_allocatable_scalarEx1) : !fir.ref<!fir.box<!fir.heap<f32>>>
 ! CHECK:         %[[VAL_2:.*]] = fir.address_of(@_QFtest_allocatable_scalarEx2) : !fir.ref<!fir.box<!fir.heap<f32>>>
 ! CHECK:         %[[VAL_3:.*]] = arith.constant false

flang/test/Lower/allocate-source-pointers.f90

-! RUN: bbc -emit-fir %s -o - | FileCheck %s
+! RUN: bbc --use-desc-for-alloc=false -emit-fir %s -o - | FileCheck %s
 
 ! Test lowering of pointers for allocate statements with source.
 
 ! CHECK-LABEL: func.func @_QPtest_pointer_scalar(
 ! CHECK-SAME:                                    %[[VAL_0:.*]]: !fir.ref<f32> {fir.bindc_name = "a"}) {
 ! CHECK:         %[[VAL_1:.*]] = fir.address_of(@_QFtest_pointer_scalarEx1) : !fir.ref<!fir.box<!fir.ptr<f32>>>
 ! CHECK:         %[[VAL_2:.*]] = fir.address_of(@_QFtest_pointer_scalarEx2) : !fir.ref<!fir.box<!fir.ptr<f32>>>
 ! CHECK:         %[[VAL_3:.*]] = arith.constant false

flang/test/Lower/array-constructor-2.f90

-! RUN: bbc %s -o - | FileCheck %s
+! RUN: bbc --use-desc-for-alloc=false %s -o - | FileCheck %s
 
 !  Constant array ctor.
 ! CHECK-LABEL: func @_QPtest1(
 subroutine test1(a, b)
   real :: a(3)
   integer :: b(4)
   integer, parameter :: constant_array(4) = [6, 7, 42, 9]
 

flang/test/Lower/character-assignment.f90

-! RUN: bbc %s -o - -emit-fir | FileCheck %s
+! RUN: bbc --use-desc-for-alloc=false %s -o - -emit-fir | FileCheck %s
 
 ! Simple character assignment tests
 ! CHECK-LABEL: _QPassign1
 subroutine assign1(lhs, rhs)
   character(*, 1) :: lhs, rhs
   ! CHECK: %[[lhs:.*]]:2 = fir.unboxchar %arg0
   ! CHECK: %[[rhs:.*]]:2 = fir.unboxchar %arg1
   lhs = rhs

flang/test/Lower/derived-type-finalization.f90

 ! Test derived type finalization
-! RUN: bbc -polymorphic-type -emit-fir %s -o - | FileCheck %s
+! RUN: bbc --use-desc-for-alloc=false -polymorphic-type -emit-fir %s -o - | FileCheck %s
 
 ! Missing tests:
 ! - finalization within BLOCK construct
 
 module derived_type_finalization
 
   type :: t1
     integer :: a

flang/test/Lower/do_loop.f90

-! RUN: bbc -emit-fir -o - %s | FileCheck %s
-! RUN: %flang_fc1 -emit-fir -o - %s | FileCheck %s
+! RUN: bbc --use-desc-for-alloc=false -emit-fir -o - %s | FileCheck %s
+! RUN: %flang_fc1 -mllvm --use-desc-for-alloc=false -emit-fir -o - %s | FileCheck %s
 
 ! Simple tests for structured ordered loops with loop-control.
 ! Tests the structure of the loop, storage to index variable and return and 
 ! storage of the final value of the index variable.
 
 ! Test a simple loop with the final value of the index variable read outside the loop
 ! CHECK-LABEL: simple_loop
 subroutine simple_loop

flang/test/Lower/forall/array-pointer.f90

 ! Test lowering of arrays of POINTER.
 !
 ! An array of pointer to T can be constructed by having an array of
 ! derived type, where the derived type has a pointer to T
 ! component. An entity with both the DIMENSION and POINTER attributes
 ! is a pointer to an array of T and never an array of pointer to T in
 ! Fortran.
 
-! RUN: bbc -emit-fir %s -o - | FileCheck %s
+! RUN: bbc --use-desc-for-alloc=false -emit-fir %s -o - | FileCheck %s
 
 module array_of_pointer_test
   type t
      integer, POINTER :: ip
   end type t
 
   type u
      integer :: v

flang/test/Lower/forall/forall-allocatable.f90

 ! Test forall lowering
 
-! RUN: bbc -emit-fir %s -o - | FileCheck %s
+! RUN: bbc --use-desc-for-alloc=false -emit-fir %s -o - | FileCheck %s
 
 subroutine forall_with_allocatable(a1)
   real :: a1(:)
   real, allocatable :: arr(:)
   forall (i=5:15)
      arr(i) = a1(i)
   end forall
 end subroutine forall_with_allocatable

flang/test/Lower/intentout-deallocate.f90

 ! Test correct deallocation of intent(out) allocatables.
-! RUN: bbc -emit-fir -polymorphic-type %s -o - | FileCheck %s
+! RUN: bbc --use-desc-for-alloc=false -emit-fir -polymorphic-type %s -o - | FileCheck %s
 
 module mod1
   type, bind(c) :: t1
     integer :: i
   end type
 
   type :: t
     integer :: a

flang/test/Lower/io-implied-do-fixes.f90

-! RUN: bbc -emit-fir %s -o - | FileCheck %s
+! RUN: bbc --use-desc-for-alloc=false -emit-fir %s -o - | FileCheck %s
 ! UNSUPPORTED: system-windows
 
 ! CHECK-LABEL: func @_QPido1
 ! CHECK: %[[J_REF_ADDR:.*]] = fir.alloca !fir.ptr<i32> {uniq_name = "_QFido1Eiptr.addr"}
 ! CHECK: %[[J_ADDR:.*]] = fir.load %[[J_REF_ADDR]] : !fir.ref<!fir.ptr<i32>>
 ! CHECK: %[[J_VAL_FINAL:.*]] = fir.do_loop %[[J_VAL:.*]] = %{{.*}} to %{{.*}} step %{{.*}} -> index {
 ! CHECK:   %[[J_VAL_CVT1:.*]] = fir.convert %[[J_VAL]] : (index) -> i32
 ! CHECK:   fir.store %[[J_VAL_CVT1]] to %[[J_ADDR]] : !fir.ptr<i32>

flang/test/Lower/parent-component.f90

 ! Test different ways of passing the parent component of an extended
 ! derived-type to a subroutine or the runtime.
 
-! RUN: bbc -emit-fir %s -o - | FileCheck %s
+! RUN: bbc --use-desc-for-alloc=false -emit-fir %s -o - | FileCheck %s
 
 program parent_comp
   type p
     integer :: a
   end type
 
   type, extends(p) :: c
     integer :: b

flang/test/Lower/pointer-assignments.f90

 ! Test lowering of pointer assignments
-! RUN: bbc -emit-fir %s -o - | FileCheck %s
+! RUN: bbc --use-desc-for-alloc=false -emit-fir %s -o - | FileCheck %s
 
 
 ! Note that p => NULL() are tested in pointer-disassociate.f90
 
 ! -----------------------------------------------------------------------------
 !     Test simple pointer assignments to contiguous right-hand side
 ! -----------------------------------------------------------------------------
 

flang/test/Lower/polymorphic.f90

-! RUN: bbc -polymorphic-type -emit-fir %s -o - | FileCheck %s
+! RUN: bbc --use-desc-for-alloc=false -polymorphic-type -emit-fir %s -o - | FileCheck %s
 
 ! Tests various aspect of the lowering of polymorphic entities.
 
 module polymorphic_test
   type p1
     integer :: a
     integer :: b
   contains