[flang] retain binding label of entry subprograms

[jeanPerier]

Summary

When processing an entry-stmt in name resolution, attrs_ was
reset before SetBindNameOn was called, causing the symbol to lose
the binding label information.

flang/lib/Semantics/resolve-names.cpp

private:
   // so that it can be replaced by a later definition.
   bool HandlePreviousCalls(const parser::Name &, Symbol &, Symbol::Flag);
   void CheckExtantProc(const parser::Name &, Symbol::Flag);
   // Create a subprogram symbol in the current scope and push a new scope.
   Symbol &PushSubprogramScope(const parser::Name &, Symbol::Flag,
       const parser::LanguageBindingSpec * = nullptr);
   Symbol *GetSpecificFromGeneric(const parser::Name &);
   SubprogramDetails &PostSubprogramStmt(const parser::Name &);
+  void PostEntryStmt(const parser::EntryStmt &stmt);
 };
 
 class DeclarationVisitor : public ArraySpecVisitor,
                            public virtual ScopeHandler {
 public:
   using ArraySpecVisitor::Post;
   using ScopeHandler::Post;
   using ScopeHandler::Pre;
SubprogramDetails &SubprogramVisitor::PostSubprogramStmt(
   symbol.attrs() |= EndAttrs();
   if (symbol.attrs().test(Attr::MODULE)) {
     symbol.attrs().set(Attr::EXTERNAL, false);
   }
   return symbol.get<SubprogramDetails>();
 }
 
 void SubprogramVisitor::Post(const parser::EntryStmt &stmt) {
-  auto attrs{EndAttrs()}; // needs to be called even if early return
+  PostEntryStmt(stmt);
+  EndAttrs();
+}
+
+void SubprogramVisitor::PostEntryStmt(const parser::EntryStmt &stmt) {
   Scope &inclusiveScope{InclusiveScope()};
   const Symbol *subprogram{inclusiveScope.symbol()};
   if (!subprogram) {
     CHECK(context().AnyFatalError());
     return;
   }
   const auto &name{std::get<parser::Name>(stmt.t)};
   const parser::Name *resultName{nullptr};
if (const auto *dummyName{std::get_if<parser::Name>(&dummyArg.u)}) {
       }
       entryDetails.add_alternateReturn();
     }
   }
 
   Symbol::Flag subpFlag{
       inFunction ? Symbol::Flag::Function : Symbol::Flag::Subroutine};
   Scope &outer{inclusiveScope.parent()}; // global or module scope
-  if (outer.IsModule() && !attrs.test(Attr::PRIVATE)) {
-    attrs.set(Attr::PUBLIC);
+  if (outer.IsModule() && attrs_ && !attrs_->test(Attr::PRIVATE)) {
+    attrs_->set(Attr::PUBLIC);
   }
   if (Symbol * extant{FindSymbol(outer, name)}) {
     if (!HandlePreviousCalls(name, *extant, subpFlag)) {
       if (outer.IsGlobal()) {
         Say2(name, "'%s' is already defined as a global identifier"_err_en_US,
             *extant, "Previous definition of '%s'"_en_US);
       } else {
         SayAlreadyDeclared(name, *extant);
       }
       return;
     }
   }
 
-  Symbol *entrySymbol{&MakeSymbol(outer, name.source, attrs)};
+  Symbol *entrySymbol{&MakeSymbol(outer, name.source, GetAttrs())};
   if (auto *generic{entrySymbol->detailsIf<GenericDetails>()}) {
     CHECK(generic->specific());
     entrySymbol = generic->specific();
   }
   entrySymbol->set_details(std::move(entryDetails));
   SetBindNameOn(*entrySymbol);
   entrySymbol->set(subpFlag);
   Resolve(name, *entrySymbol);

flang/test/Lower/program-units-fir-mangling.f90

 ! CHECK: }
 end function
 
 ! CHECK-LABEL: func @bEtA() -> f32 attributes {fir.sym_name = "_QPalpha"} {
 function alpha() bind(c, name =" bEtA ")
 ! CHECK: }
 end function
 
+! CHECK-LABEL: func @bc1() attributes {fir.sym_name = "_QPbind_c_s"} {
+subroutine bind_c_s() Bind(C,Name='bc1')
+  ! CHECK: return
+end subroutine bind_c_s
+
+! CHECK-LABEL: func @_QPbind_c_s() {
+subroutine bind_c_s()
+  ! CHECK: fir.call @_QPbind_c_q() : () -> ()
+  ! CHECK: return
+  call bind_c_q
+end
+
+! CHECK-LABEL: func @_QPbind_c_q() {
+subroutine bind_c_q()
+  interface
+    subroutine bind_c_s() Bind(C, name='bc1')
+    end
+  end interface
+  ! CHECK: fir.call @bc1() : () -> ()
+  ! CHECK: return
+  call bind_c_s
+end
+
+! Test that BIND(C) label is taken into account for ENTRY symbols.
+! CHECK-LABEL: func @_QPsub_with_entries() {
+subroutine sub_with_entries
+! CHECK-LABEL: func @bar() attributes {fir.sym_name = "_QPsome_entry"} {
+ entry some_entry() bind(c, name="bar")
+! CHECK-LABEL: func @_QPnormal_entry() {
+ entry normal_entry()
+! CHECK-LABEL: func @some_other_entry() attributes {fir.sym_name = "_QPsome_other_entry"} {
+ entry some_other_entry() bind(c)
+end subroutine
+
 ! CHECK-LABEL: fir.global internal @_QFfooEpi : f32 {