[flang] Check for global name conflicts (19.2)

[klausler]

Summary

Global names should be checked for conflicts even when not BIND(C).

[jeanPerier]

LGTM

flang/lib/Semantics/check-declarations.cpp

private:
   parser::Message *SayWithDeclaration(const Symbol &symbol, A &&...x) {
     parser::Message *msg{messages_.Say(std::forward<A>(x)...)};
     if (msg && messages_.at().begin() != symbol.name().begin()) {
       evaluate::AttachDeclaration(*msg, symbol);
     }
     return msg;
   }
   bool IsResultOkToDiffer(const FunctionResult &);
+  void CheckGlobalName(const Symbol &);
   void CheckBindC(const Symbol &);
   void CheckBindCFunctionResult(const Symbol &);
   // Check functions for defined I/O procedures
   void CheckDefinedIoProc(
       const Symbol &, const GenericDetails &, GenericKind::DefinedIo);
   bool CheckDioDummyIsData(const Symbol &, const Symbol *, std::size_t);
   void CheckDioDummyIsDerived(const Symbol &, const Symbol &,
       GenericKind::DefinedIo ioKind, const Symbol &);
private:
   const Scope *scope_{nullptr};
   bool scopeIsUninstantiatedPDT_{false};
   // This symbol is the one attached to the innermost enclosing scope
   // that has a symbol.
   const Symbol *innermostSymbol_{nullptr};
   // Cache of calls to Procedure::Characterize(Symbol)
   std::map<SymbolRef, std::optional<Procedure>, SymbolAddressCompare>
       characterizeCache_;
-  // Collection of symbols with BIND(C) names
-  std::map<std::string, SymbolRef> bindC_;
   // Collection of module procedure symbols with non-BIND(C)
   // global names, qualified by their module.
   std::map<std::pair<SourceName, const Symbol *>, SymbolRef> moduleProcs_;
+  // Collection of symbols with global names, BIND(C) or otherwise
+  std::map<std::string, SymbolRef> globalNames_;
   // Derived types that have defined input/output procedures
   std::vector<TypeWithDefinedIo> seenDefinedIoTypes_;
 };
 
 class DistinguishabilityHelper {
 public:
   DistinguishabilityHelper(SemanticsContext &context) : context_{context} {}
   void Add(const Symbol &, GenericKind, const Symbol &, const Procedure &);
common::visit(
           [&](const GenericDetails &x) { CheckGeneric(symbol, x); },
           [](const auto &) {},
       },
       symbol.details());
   if (symbol.attrs().test(Attr::VOLATILE)) {
     CheckVolatile(symbol, derived);
   }
   CheckBindC(symbol);
+  CheckGlobalName(symbol);
   if (isDone) {
     return; // following checks do not apply
   }
   if (symbol.attrs().test(Attr::PROTECTED)) {
     if (symbol.owner().kind() != Scope::Kind::Module) { // C854
       messages_.Say(
           "A PROTECTED entity must be in the specification part of a module"_err_en_US);
     }
if (InPure()) {
     if (IsProcedure(symbol) && !IsPureProcedure(symbol) && IsDummy(symbol)) {
       messages_.Say(
           "A dummy procedure of a pure subprogram must be pure"_err_en_US);
     }
   }
   if (type) { // Section 7.2, paragraph 7
     bool canHaveAssumedParameter{IsNamedConstant(symbol) ||
         (IsAssumedLengthCharacter(symbol) && // C722
-            IsExternal(symbol)) ||
+            (IsExternal(symbol) ||
+                ClassifyProcedure(symbol) ==
+                    ProcedureDefinitionClass::Dummy)) ||
         symbol.test(Symbol::Flag::ParentComp)};
     if (!IsStmtFunctionDummy(symbol)) { // C726
       if (const auto *object{symbol.detailsIf<ObjectEntityDetails>()}) {
         canHaveAssumedParameter |= object->isDummy() ||
             (object->isFuncResult() &&
                 type->category() == DeclTypeSpec::Character) ||
             IsStmtFunctionResult(symbol); // Avoids multiple messages
       } else {
if (InPure() && InFunction() && IsFunctionResult(symbol)) {
         if (auto bad{FindPolymorphicAllocatableUltimateComponent(*derived)}) {
           SayWithDeclaration(*bad,
               "Result of pure function may not have polymorphic ALLOCATABLE ultimate component '%s'"_err_en_US,
               bad.BuildResultDesignatorName());
         }
       }
     }
   }
-  if (IsAssumedLengthCharacter(symbol) && IsExternal(symbol)) { // C723
+  if (IsAssumedLengthCharacter(symbol) && IsFunction(symbol)) { // C723
     if (symbol.attrs().test(Attr::RECURSIVE)) {
       messages_.Say(
           "An assumed-length CHARACTER(*) function cannot be RECURSIVE"_err_en_US);
     }
     if (symbol.Rank() > 0) {
       messages_.Say(
           "An assumed-length CHARACTER(*) function cannot return an array"_err_en_US);
     }
+    if (!IsStmtFunction(symbol)) {
       if (IsElementalProcedure(symbol)) {
         messages_.Say(
             "An assumed-length CHARACTER(*) function cannot be ELEMENTAL"_err_en_US);
       } else if (IsPureProcedure(symbol)) {
         messages_.Say(
             "An assumed-length CHARACTER(*) function cannot be PURE"_err_en_US);
       }
+    }
     if (const Symbol *result{FindFunctionResult(symbol)}) {
       if (IsPointer(*result)) {
         messages_.Say(
             "An assumed-length CHARACTER(*) function cannot return a POINTER"_err_en_US);
       }
-    } else if (IsPointer(symbol)) {
+    } else if (IsProcedurePointer(symbol) && IsDummy(symbol)) {
       messages_.Say(
-          "A procedure pointer should not have assumed-length CHARACTER(*) result type"_port_en_US);
+          "A dummy procedure pointer should not have assumed-length CHARACTER(*) result type"_port_en_US);
+      // The non-dummy case is a hard error that's caught elsewhere.
     }
   }
   if (symbol.attrs().test(Attr::VALUE)) {
     CheckValue(symbol, derived);
   }
   if (symbol.attrs().test(Attr::CONTIGUOUS) && IsPointer(symbol) &&
       symbol.Rank() == 0) { // C830
     messages_.Say("CONTIGUOUS POINTER must be an array"_err_en_US);
void CheckHelper::Check(const Symbol &symbol) {
   if (symbol.owner().IsModule() && IsAutomatic(symbol)) {
     messages_.Say(
         "Automatic data object '%s' may not appear in the specification part"
         " of a module"_err_en_US,
         symbol.name());
   }
 }
 
-void CheckHelper::CheckCommonBlock(const Symbol &symbol) { CheckBindC(symbol); }
+void CheckHelper::CheckCommonBlock(const Symbol &symbol) {
+  CheckGlobalName(symbol);
+  CheckBindC(symbol);
+}
 
 void CheckHelper::CheckBindCFunctionResult(const Symbol &symbol) { // C1553
   if (!innermostSymbol_ || !IsBindCProcedure(*innermostSymbol_)) {
     return;
   }
   if (IsPointer(symbol) || IsAllocatable(symbol)) {
     messages_.Say(
         "BIND(C) function result cannot have ALLOCATABLE or POINTER attribute"_err_en_US);
if (!details.isDummy() && details.isFunction() &&
           "A function interface may not declare an assumed-length CHARACTER(*) result"_err_en_US);
     }
   }
   CheckLocalVsGlobal(symbol);
   CheckModuleProcedureDef(symbol);
 }
 
 void CheckHelper::CheckLocalVsGlobal(const Symbol &symbol) {
-  if (IsProcedure(symbol) && IsExternal(symbol)) {
+  if (IsExternal(symbol)) {
     if (const Symbol *global{FindGlobal(symbol)}; global && global != &symbol) {
       std::string interfaceName{symbol.name().ToString()};
       if (const auto *bind{symbol.GetBindName()}) {
         interfaceName = *bind;
       }
       std::string definitionName{global->name().ToString()};
       if (const auto *bind{global->GetBindName()}) {
         definitionName = *bind;
if (const Symbol *global{FindGlobal(symbol)}; global && global != &symbol) {
               }
             } else if (!globalChars->CanBeCalledViaImplicitInterface()) {
               msg = messages_.Say(
                   "The global subprogram '%s' may not be referenced via the implicit interface '%s'"_err_en_US,
                   global->name(), symbol.name());
             }
           }
         }
+        if (msg) {
+          if (msg->IsFatal()) {
+            context_.SetError(symbol);
+          }
           evaluate::AttachDeclaration(msg, *global);
           evaluate::AttachDeclaration(msg, symbol);
         }
       }
     }
   }
+}
 
 void CheckHelper::CheckDerivedType(
     const Symbol &derivedType, const DerivedTypeDetails &details) {
   if (details.isForwardReferenced() && !context_.HasError(derivedType)) {
     messages_.Say("The derived type '%s' has not been defined"_err_en_US,
         derivedType.name());
   }
   const Scope *scope{derivedType.scope()};
if (ultimate.has<DerivedTypeDetails>()) {
           addSpecifics(*pair2.second);
         }
       }
     }
   }
   helper.Check(scope);
 }
 
-static const std::string *DefinesBindCName(const Symbol &symbol) {
+static bool IsSubprogramDefinition(const Symbol &symbol) {
   const auto *subp{symbol.detailsIf<SubprogramDetails>()};
-  if ((subp && !subp->isInterface()) || symbol.has<ObjectEntityDetails>() ||
-      symbol.has<CommonBlockDetails>()) {
-    // Symbol defines data or entry point
-    return symbol.GetBindName();
+  return subp && !subp->isInterface() && symbol.scope() &&
+      symbol.scope()->kind() == Scope::Kind::Subprogram;
+}
+
+static bool IsBlockData(const Symbol &symbol) {
+  return symbol.scope() && symbol.scope()->kind() == Scope::Kind::BlockData;
+}
+
+static bool IsExternalProcedureDefinition(const Symbol &symbol) {
+  return IsBlockData(symbol) ||
+      (IsSubprogramDefinition(symbol) &&
+          (IsExternal(symbol) || symbol.GetBindName()));
+}
+
+static std::optional<std::string> DefinesGlobalName(const Symbol &symbol) {
+  if (const auto *module{symbol.detailsIf<ModuleDetails>()}) {
+    if (!module->isSubmodule() && !symbol.owner().IsIntrinsicModules()) {
+      return symbol.name().ToString();
+    }
+  } else if (IsBlockData(symbol)) {
+    return symbol.name().ToString();
   } else {
-    return nullptr;
+    const std::string *bindC{symbol.GetBindName()};
+    if (symbol.has<CommonBlockDetails>() ||
+        IsExternalProcedureDefinition(symbol)) {
+      return bindC ? *bindC : symbol.name().ToString();
+    } else if (bindC &&
+        (symbol.has<ObjectEntityDetails>() || IsModuleProcedure(symbol))) {
+      return *bindC;
+    }
+  }
+  return std::nullopt;
+}
+
+// 19.2 p2
+void CheckHelper::CheckGlobalName(const Symbol &symbol) {
+  if (auto global{DefinesGlobalName(symbol)}) {
+    auto pair{globalNames_.emplace(std::move(*global), symbol)};
+    if (!pair.second) {
+      const Symbol &other{*pair.first->second};
+      if (context_.HasError(symbol) || context_.HasError(other)) {
+        // don't pile on
+      } else if (symbol.has<CommonBlockDetails>() &&
+          other.has<CommonBlockDetails>() && symbol.name() == other.name()) {
+        // Two common blocks can have the same global name so long as
+        // they're not in the same scope.
+      } else if ((IsProcedure(symbol) || IsBlockData(symbol)) &&
+          (IsProcedure(other) || IsBlockData(other)) &&
+          (!IsExternalProcedureDefinition(symbol) ||
+              !IsExternalProcedureDefinition(other))) {
+        // both are procedures/BLOCK DATA, not both definitions
+      } else if (symbol.has<ModuleDetails>()) {
+        messages_.Say(symbol.name(),
+            "Module '%s' conflicts with a global name"_port_en_US,
+            pair.first->first);
+      } else if (other.has<ModuleDetails>()) {
+        messages_.Say(symbol.name(),
+            "Global name '%s' conflicts with a module"_port_en_US,
+            pair.first->first);
+      } else if (auto *msg{messages_.Say(symbol.name(),
+                     "Two entities have the same global name '%s'"_err_en_US,
+                     pair.first->first)}) {
+        msg->Attach(other.name(), "Conflicting declaration"_en_US);
+        context_.SetError(symbol);
+        context_.SetError(other);
+      }
+    }
   }
 }
 
 void CheckHelper::CheckBindC(const Symbol &symbol) {
   if (!symbol.attrs().test(Attr::BIND_C)) {
     return;
   }
   CheckConflicting(symbol, Attr::BIND_C, Attr::PARAMETER);
   CheckConflicting(symbol, Attr::BIND_C, Attr::ELEMENTAL);
   if (symbol.has<ObjectEntityDetails>() && !symbol.owner().IsModule()) {
     messages_.Say(symbol.name(),
         "A variable with BIND(C) attribute may only appear in the specification part of a module"_err_en_US);
     context_.SetError(symbol);
   }
-  if (const std::string *name{DefinesBindCName(symbol)}) {
-    auto pair{bindC_.emplace(*name, symbol)};
-    if (!pair.second) {
-      const Symbol &other{*pair.first->second};
-      if (symbol.has<CommonBlockDetails>() && other.has<CommonBlockDetails>() &&
-          symbol.name() == other.name()) {
-        // Two common blocks can have the same BIND(C) name so long as
-        // they're not in the same scope.
-      } else if (!context_.HasError(other)) {
-        if (auto *msg{messages_.Say(symbol.name(),
-                "Two entities have the same BIND(C) name '%s'"_err_en_US,
-                *name)}) {
-          msg->Attach(other.name(), "Conflicting declaration"_en_US);
-        }
-        context_.SetError(symbol);
-        context_.SetError(other);
-      }
-    }
-  }
   if (const auto *proc{symbol.detailsIf<ProcEntityDetails>()}) {
     if (!proc->procInterface() ||
         !proc->procInterface()->attrs().test(Attr::BIND_C)) {
       messages_.Say(symbol.name(),
           "An interface name with BIND attribute must be specified if the BIND attribute is specified in a procedure declaration statement"_err_en_US);
       context_.SetError(symbol);
     }
   } else if (const auto *derived{symbol.detailsIf<DerivedTypeDetails>()}) {

flang/lib/Semantics/resolve-names.cpp

bool ScopeHandler::ConvertToProcEntity(Symbol &symbol) {
   if (symbol.has<ProcEntityDetails>()) {
     // nothing to do
   } else if (symbol.has<UnknownDetails>()) {
     symbol.set_details(ProcEntityDetails{});
   } else if (auto *details{symbol.detailsIf<EntityDetails>()}) {
     if (IsFunctionResult(symbol) &&
         !(IsPointer(symbol) && symbol.attrs().test(Attr::EXTERNAL))) {
       // Don't turn function result into a procedure pointer unless both
-      // POUNTER and EXTERNAL
+      // POINTER and EXTERNAL
       return false;
     }
     funcResultStack_.CompleteTypeIfFunctionResult(symbol);
     symbol.set_details(ProcEntityDetails{std::move(*details)});
     if (symbol.GetType() && !symbol.test(Symbol::Flag::Implicit)) {
       CHECK(!symbol.test(Symbol::Flag::Subroutine));
       symbol.set(Symbol::Flag::Function);
     }
for (auto it{range.first}; it != range.second; ++it) {
     } else if (kind == ProcedureKind::ModuleProcedure) {
       Say(*name, "'%s' is not a module procedure"_err_en_US);
       continue;
     } else {
       switch (defClass) {
       case ProcedureDefinitionClass::Intrinsic:
       case ProcedureDefinitionClass::External:
       case ProcedureDefinitionClass::Internal:
+      case ProcedureDefinitionClass::Dummy:
+      case ProcedureDefinitionClass::Pointer:
         break;
       case ProcedureDefinitionClass::None:
         Say(*name, "'%s' is not a procedure"_err_en_US);
         continue;
       default:
         Say(*name,
             "'%s' is not a procedure that can appear in a generic interface"_err_en_US);
         continue;

flang/lib/Semantics/tools.cpp

 }
 
 ProcedureDefinitionClass ClassifyProcedure(const Symbol &symbol) { // 15.2.2
   const Symbol &ultimate{symbol.GetUltimate()};
   if (!IsProcedure(ultimate)) {
     return ProcedureDefinitionClass::None;
   } else if (ultimate.attrs().test(Attr::INTRINSIC)) {
     return ProcedureDefinitionClass::Intrinsic;
-  } else if (ultimate.attrs().test(Attr::EXTERNAL)) {
-    return ProcedureDefinitionClass::External;
-  } else if (const auto *procDetails{ultimate.detailsIf<ProcEntityDetails>()}) {
-    if (procDetails->isDummy()) {
-      return ProcedureDefinitionClass::Dummy;
-    } else if (IsPointer(ultimate)) {
-      return ProcedureDefinitionClass::Pointer;
-    }
+  } else if (IsDummy(ultimate)) {
+  } else if (IsProcedurePointer(symbol)) {
+  } else if (ultimate.attrs().test(Attr::EXTERNAL)) {
+    return ProcedureDefinitionClass::External;
   } else if (const auto *nameDetails{
                  ultimate.detailsIf<SubprogramNameDetails>()}) {
     switch (nameDetails->kind()) {
     case SubprogramKind::Module:
       return ProcedureDefinitionClass::Module;
     case SubprogramKind::Internal:
       return ProcedureDefinitionClass::Internal;
     }

flang/test/Lower/pointer-initial-target-2.f90

block data tied
   common /c2/ x2, p2
 ! CHECK-LABEL: fir.global @_QBc1 : tuple<f32, !fir.array<4xi8>, !fir.box<!fir.ptr<f32>>>
   ! CHECK: fir.address_of(@_QBc2) : !fir.ref<tuple<f32, !fir.array<4xi8>, !fir.box<!fir.ptr<f32>>>>
 ! CHECK-LABEL: fir.global @_QBc2 : tuple<f32, !fir.array<4xi8>, !fir.box<!fir.ptr<f32>>>
   ! CHECK: fir.address_of(@_QBc1) : !fir.ref<tuple<f32, !fir.array<4xi8>, !fir.box<!fir.ptr<f32>>>>
 end block data
 
 ! Test pointer in a common with initial target in the same common.
-block data snake
+block data bdsnake
   integer, target :: b = 42
   integer, pointer :: p => b
   common /snake/ p, b
 ! CHECK-LABEL: fir.global @_QBsnake : tuple<!fir.box<!fir.ptr<i32>>, i32>
   ! CHECK: %[[tuple0:.*]] = fir.undefined tuple<!fir.box<!fir.ptr<i32>>, i32>
   ! CHECK: %[[snakeAddr:.*]] = fir.address_of(@_QBsnake) : !fir.ref<tuple<!fir.box<!fir.ptr<i32>>, i32>>
   ! CHECK: %[[byteView:.*]] = fir.convert %[[snakeAddr:.*]] : (!fir.ref<tuple<!fir.box<!fir.ptr<i32>>, i32>>) -> !fir.ref<!fir.array<?xi8>>
   ! CHECK: %[[coor:.*]] = fir.coordinate_of %[[byteView]], %c24{{.*}} : (!fir.ref<!fir.array<?xi8>>, index) -> !fir.ref<i8>

flang/test/Semantics/bind-c01.f90

 ! RUN: %python %S/test_errors.py %s %flang_fc1
 ! Check for multiple symbols being defined with with same BIND(C) name
 
 module m1
   integer, bind(c, name="x1") :: x1
-  !ERROR: Two entities have the same BIND(C) name 'x1'
+  !ERROR: Two entities have the same global name 'x1'
   integer, bind(c, name=" x1 ") :: x2
  contains
   subroutine x3() bind(c, name="x3")
   end subroutine
 end module
 
-!ERROR: Two entities have the same BIND(C) name 'x3'
+!ERROR: Two entities have the same global name 'x3'
 subroutine x4() bind(c, name=" x3 ")
 end subroutine
 
 ! Ensure no error in this situation
 module m2
  interface
   subroutine x5() bind(c, name=" x5 ")
   end subroutine

flang/test/Semantics/bind-c02.f90

module m
   !ERROR: Only variable and named common block can be in BIND statement
   bind(c) :: proc
   !ERROR: Only variable and named common block can be in BIND statement
   bind(c) :: pc1
 
   !ERROR: Only variable and named common block can be in BIND statement
   bind(c) :: sub
 
+  !PORTABILITY: Global name 'm' conflicts with a module
   !PORTABILITY: Name 'm' declared in a module should not have the same name as the module
   bind(c) :: m ! no error for implicit type variable
 
   type my_type
     integer :: i
   end type
   !ERROR: Only variable and named common block can be in BIND statement
   bind(c) :: my_type

flang/test/Semantics/call01.f90

contains
   character(1) function nested
     !ERROR: Assumed-length CHARACTER(*) function 'f14' cannot call itself
     !ERROR: Assumed-length character function must be defined with a length to be called
     nested = f14(n-1) ! 15.6.2.1(3)
   end function nested
 end function
 
 subroutine s01(f1, f2, fp1, fp2)
-  !PORTABILITY: A procedure pointer should not have assumed-length CHARACTER(*) result type
+  !PORTABILITY: A dummy procedure pointer should not have assumed-length CHARACTER(*) result type
   character*(*) :: f1, f3, fp1
   external :: f1, f3
   pointer :: fp1
-  !PORTABILITY: A procedure pointer should not have assumed-length CHARACTER(*) result type
+  !PORTABILITY: A dummy procedure pointer should not have assumed-length CHARACTER(*) result type
   procedure(character*(*)), pointer :: fp2
   interface
     character*(*) function f2()
     end function
     !ERROR: A function interface may not declare an assumed-length CHARACTER(*) result
     character*(*) function f4()
     end function
   end interface
   print *, f1()
   print *, f2()
   !ERROR: Assumed-length character function must be defined with a length to be called
   print *, f3()
   print *, fp1()
   print *, fp2()
 end subroutine

flang/test/Semantics/call31.f90

 ! RUN: %python %S/test_errors.py %s %flang_fc1 -Werror
 ! Confirm enforcement of constraint C723 in F2018 for procedure pointers
 
       module m
        contains
         subroutine subr(parg)
-          !PORTABILITY: A procedure pointer should not have assumed-length CHARACTER(*) result type
+          !PORTABILITY: A dummy procedure pointer should not have assumed-length CHARACTER(*) result type
           procedure(character(*)), pointer :: parg
-          !PORTABILITY: A procedure pointer should not have assumed-length CHARACTER(*) result type
+          !ERROR: An assumed (*) type parameter may be used only for a (non-statement function) dummy argument, associate name, named constant, or external function result
           procedure(character(*)), pointer :: plocal
           print *, parg()
           plocal => parg
           call subr_1(plocal)
         end subroutine
 
         subroutine subr_1(parg_1)
-          !PORTABILITY: A procedure pointer should not have assumed-length CHARACTER(*) result type
+          !PORTABILITY: A dummy procedure pointer should not have assumed-length CHARACTER(*) result type
           procedure(character(*)), pointer :: parg_1
           print *, parg_1()
         end subroutine
       end module
 
       character(*) function f()
         f = 'abcdefgh'
       end function

flang/test/Semantics/declarations03.f90

 ! RUN: %python %S/test_errors.py %s %flang_fc1
 ! test bind(c) name conflict
 
 module m
 
   integer :: x, y, z, w, i, j, k
 
-  !ERROR: Two entities have the same BIND(C) name 'aa'
+  !ERROR: Two entities have the same global name 'aa'
   common /blk1/ x, /blk2/ y
   bind(c, name="aa") :: /blk1/, /blk2/
 
   integer :: t
-  !ERROR: Two entities have the same BIND(C) name 'bb'
+  !ERROR: Two entities have the same global name 'bb'
   common /blk3/ z
   bind(c, name="bb") :: /blk3/, t
 
   integer :: t2
-  !ERROR: Two entities have the same BIND(C) name 'cc'
+  !ERROR: Two entities have the same global name 'cc'
   common /blk4/ w
   bind(c, name="cc") :: t2, /blk4/
 
   !ERROR: The entity 'blk5' has multiple BIND names
   common /blk5/ i
   bind(c, name="dd") :: /blk5/
   bind(c, name="ee") :: /blk5/
 
-  !ERROR: Two entities have the same BIND(C) name 'ff'
+  !ERROR: Two entities have the same global name 'ff'
   common /blk6/ j, /blk7/ k
   bind(c, name="ff") :: /blk6/
   bind(c, name="ff") :: /blk7/
 
   !ERROR: The entity 's1' has multiple BIND names
   integer :: s1
   bind(c, name="gg") :: s1
   bind(c, name="hh") :: s1
 
-  !ERROR: Two entities have the same BIND(C) name 'ii'
+  !ERROR: Two entities have the same global name 'ii'
   integer :: s2, s3
   bind(c, name="ii") :: s2
   bind(c, name="ii") :: s3
 
   !ERROR: The entity 's4' has multiple BIND names
   integer, bind(c, name="ss1") :: s4
   bind(c, name="jj") :: s4
 
subroutine common2()
   bind(c, name='xcom') /com/ ! no error
 end subroutine
 
 module a
   integer, bind(c, name="int") :: i
 end module
 
 module b
-  !ERROR: Two entities have the same BIND(C) name 'int'
+  !ERROR: Two entities have the same global name 'int'
   integer, bind(c, name="int") :: i
 end module

flang/test/Semantics/declarations04.f90

+! RUN: %python %S/test_errors.py %s %flang_fc1
+! test global name conflicts
+
+subroutine ext1
+end
+
+subroutine ext2
+  !ERROR: Two entities have the same global name 'ext1'
+  common /ext1/ x
+end
+
+module ext4
+ contains
+  !ERROR: Two entities have the same global name 'ext2'
+  subroutine foo() bind(c,name="ext2")
+  end
+  !ERROR: Two entities have the same global name 'ext3'
+  subroutine bar() bind(c,name="ext3")
+  end
+end
+
+block data ext3
+  !PORTABILITY: Global name 'ext4' conflicts with a module
+  common /ext4/ x
+end