[flang] Block containing an interface

[vdonaldson]

Summary

Name mangling may be invoked for an interface procedure contained in
a block in a context that does not have access to block ID mapping.
Procedures can't be defined inside a block, so name mangling doesn't
need a block map. Relax an assert to account for this.

block
  interface
    subroutine ss(n) bind(c)
      integer :: n
    end subroutine
  end interface
  call ss(5)
end

[PeteSteinfeld]

All builds and tests correctly and looks good.

[vdonaldson]

https://reviews.llvm.org/D154127

flang/lib/Lower/Mangler.cpp

return std::visit(
           [](const auto &) -> std::string { TODO_NOLOC("symbol mangling"); },
       },
       ultimateSymbol.details());
 }
 
 std::string
 Fortran::lower::mangle::mangleName(const Fortran::semantics::Symbol &symbol,
                                    bool keepExternalInScope) {
-  assert(symbol.owner().kind() !=
-             Fortran::semantics::Scope::Kind::BlockConstruct &&
+  assert((symbol.owner().kind() !=
+              Fortran::semantics::Scope::Kind::BlockConstruct ||
+          symbol.has<Fortran::semantics::SubprogramDetails>()) &&
          "block object mangling must specify a scopeBlockIdMap");
   ScopeBlockIdMap scopeBlockIdMap;
   return mangleName(symbol, scopeBlockIdMap, keepExternalInScope);
 }
 
 std::string Fortran::lower::mangle::mangleName(
     const Fortran::semantics::DerivedTypeSpec &derivedType,
     ScopeBlockIdMap &scopeBlockIdMap) {

flang/test/Lower/block.f90

 ! RUN: bbc -emit-fir -o - %s | FileCheck %s
 
 ! CHECK-LABEL: func @_QQmain
 program bb ! block stack management and exits
+    ! CHECK:   %[[V_0:[0-9]+]] = fir.alloca i32 {adapt.valuebyref}
     ! CHECK:   %[[V_1:[0-9]+]] = fir.alloca i32 {bindc_name = "i", uniq_name = "_QFEi"}
     integer :: i, j
     ! CHECK:   fir.store %c0{{.*}} to %[[V_1]] : !fir.ref<i32>
     i = 0
     ! CHECK:   %[[V_3:[0-9]+]] = fir.call @llvm.stacksave()
     ! CHECK:   fir.store %{{.*}} to %[[V_1]] : !fir.ref<i32>
     ! CHECK:   br ^bb1
     ! CHECK: ^bb1:  // 2 preds: ^bb0, ^bb16
program bb ! block stack management and exits
     ! CHECK:   br ^bb1
     ! CHECK: ^bb17:  // pred: ^bb1
     ! CHECK:   fir.store %{{.*}} to %[[V_1]] : !fir.ref<i32>
     ! CHECK:   cf.br ^bb18
     ! CHECK: ^bb18:  // 2 preds: ^bb11, ^bb17
     ! CHECK:   fir.call @llvm.stackrestore(%[[V_3]])
     ! CHECK:   br ^bb19
     ! CHECK: ^bb19:  // 2 preds: ^bb13, ^bb18
-    ! CHECK:   return
     block
       i = i + 1 ! 1 increment
       do j = 1, 5
         block
           i = i + 1; if (j == 1) goto 1   ! inner block - 5 increments, 1 goto
           i = i + 1; if (j == 2) goto 2   ! inner block - 4 increments, 1 goto
           i = i + 1; if (j == 3) goto 10  ! outer block - 3 increments, 1 goto
           i = i + 1; if (j == 4) goto 11  ! outer block - 2 increments, 1 goto
 1         i = i + 1; if (j == 5) goto 12  ! outer block - 2 increments, 1 goto
           i = i + 1; if (j == 6) goto 100 ! program     - 1 increment
 2       end block
 10      i = i + 1 ! 3 increments
 11    end do
       i = i + 1 ! 0 increments
 12  end block
 100 print*, i ! expect 21
+
+    ! CHECK: %[[V_51:[0-9]+]] = fir.call @llvm.stacksave() fastmath<contract> : () -> !fir.ref<i8>
+    ! CHECK: fir.store %c5{{.*}} to %[[V_0]] : !fir.ref<i32>
+    ! CHECK: fir.call @ss(%[[V_0]]) fastmath<contract> : (!fir.ref<i32>) -> ()
+    ! CHECK: fir.call @llvm.stackrestore(%[[V_51]]) fastmath<contract> : (!fir.ref<i8>) -> ()
+    block
+      interface
+        subroutine ss(n) bind(c)
+          integer :: n
+        end subroutine
+      end interface
+      call ss(5)
+    end block
 end
+
+subroutine ss(n) bind(c)
+    print*, n
+end subroutine