[flang] Support check for BIND statement entity

[peixin]

Summary

As Fortran 2018 8.6.4(1), the BIND statement specifies the BIND attribute
for a list of variables and common blocks.

[klausler]

flang/lib/Semantics/resolve-names.cpp

3915

What happens if this symbol turns out later to be a procedure?

I think this sort of check should be done later in check-declarations, after name resolution has been done as the symbol table is complete.

[peixin]

flang/lib/Semantics/resolve-names.cpp

3915

What happens if this symbol turns out later to be a procedure?

This works for this case. Check the following case (modfile16.f90 in this patch):

real :: d
external :: d
bind(c, name='dd') :: d
real :: e
bind(c, name='ee') :: e
external :: e
bind(c, name='ff') :: f
real :: f
external :: f

You will get errors for d, e, and f. The reason is that it walks the parse-tree for DeclTypeSpecVisitor before parser::BindEntity. (https://github.com/llvm/llvm-project/blob/576b8245c838e822f709d8450f537c7909d45411/flang/lib/Semantics/resolve-names.cpp#L132-L144) For procedures, the symbol has EntityDetails, but GetType is empty.

I think this sort of check should be done later in check-declarations, after name resolution has been done as the symbol table is complete.

I tried to look at check-declarations, but I didn't figure out how to do it there since it is unknown if the BIND(C) attribute for procedure is from bind statement or procedure declaration statement. Let me dig some more again to see if it can be done in check-declarations.

[peixin]

flang/lib/Semantics/resolve-names.cpp

3915

@klausler It seems that this must be done here.

1. The derived type and module subroutine in bind statement will get fatal internal error: bind name not allowed on this kind of symbol in SetBindNameOn. (Check bind(c) :: sub and bind(c) :: my_type in the following test case bind-c02.f90).

2. It is unknown if the BIND(C) attribute for procedure is from bind statement or procedure declaration statement.

[peixin]

ping

[klausler]

Will this error be incorrectly triggered if a BIND(C) :: x declaration appears before any other declaration for a variable or COMMON block 'x'? What if a BIND(C) :: j declaration appears as the only declaration for an implicitly-typed variable "j"?

[peixin]

In D127120#3585747, @klausler wrote:

Will this error be incorrectly triggered if a BIND(C) :: x declaration appears before any other declaration for a variable or COMMON block 'x'? What if a BIND(C) :: j declaration appears as the only declaration for an implicitly-typed variable "j"?

Thanks for this. The previous fix is not correct for this. It should not check if there is the type for the entity. The bind statement is one declaration statement, so it is actually declaring one new entity. The real error is multiple declaration of one name. This is consistent with the errors in ifort.

[peixin]

ping

[klausler]

flang/lib/Semantics/check-declarations.cpp

1886

First, you can compare symbol names without converting them to strings. But I don't see why this test is needed here in BIND(C) checking in the first place; it does not seem to be specific to BIND(C). If a check like this is needed, wouldn't it be necessary for non-BIND(C) symbols as well?

[peixin]

Remove the unnecessary check.

[peixin]

flang/lib/Semantics/check-declarations.cpp

1886

I take a look at non-bind(C) symbols, and find out that LLVM Flang can support this. Check the following case:

module m
  integer :: m
end

LLVM Flang codegen supports this since the name mangling makes the module name and variable name unique. gfortran and ifort do not support this.

For BIND(C) symbols, it's the same issue. So, there is no necessary for the previous check.

[peixin]

ping

[klausler]

flang/lib/Semantics/resolve-names.cpp

3914

"named" constant

[peixin]

Fix the typo.

flang/lib/Semantics/check-declarations.cpp

static const std::string *DefinesBindCName(const Symbol &symbol) {
   }
 }
 
 void CheckHelper::CheckBindC(const Symbol &symbol) {
   if (!symbol.attrs().test(Attr::BIND_C)) {
     return;
   }
   CheckConflicting(symbol, Attr::BIND_C, Attr::PARAMETER);
   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
if (!pair.second) {
       }
     }
   }
   if (const auto *proc{symbol.detailsIf<ProcEntityDetails>()}) {
     if (!proc->interface().symbol() ||
         !proc->interface().symbol()->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);
     }
   }
 }
 
 bool CheckHelper::CheckDioDummyIsData(
     const Symbol &subp, const Symbol *arg, std::size_t position) {
   if (arg && arg->detailsIf<ObjectEntityDetails>()) {
     return true;

flang/lib/Semantics/resolve-names.cpp

bool DeclarationVisitor::Pre(const parser::BindEntity &x) {
   auto &name{std::get<parser::Name>(x.t)};
   Symbol *symbol;
   if (kind == parser::BindEntity::Kind::Object) {
     symbol = &HandleAttributeStmt(Attr::BIND_C, name);
   } else {
     symbol = &MakeCommonBlockSymbol(name);
     symbol->attrs().set(Attr::BIND_C);
   }
+  // 8.6.4(1)
+  // Some entities such as named constant or module name need to checked
+  // elsewhere. This is to skip the ICE caused by setting Bind name for non-name
+  // things such as data type and also checks for procedures.
+  if (symbol->has<CommonBlockDetails>() || symbol->has<ObjectEntityDetails>() ||
+      symbol->has<EntityDetails>()) {
     SetBindNameOn(*symbol);
+  } else {
+    Say(name,
+        "Only variable and named common block can be in BIND statement"_err_en_US);
+  }
   return false;
 }
 bool DeclarationVisitor::Pre(const parser::OldParameterStmt &x) {
   inOldStyleParameterStmt_ = true;
   Walk(x.v);
   inOldStyleParameterStmt_ = false;
   return false;
 }

flang/test/Semantics/bind-c02.f90

+! RUN: %python %S/test_errors.py %s %flang_fc1
+! Check for 8.6.4(1)
+! The BIND statement specifies the BIND attribute for a list of variables and
+! common blocks.
+
+module m
+
+  interface
+    subroutine proc() bind(c)
+    end
+  end interface
+  procedure(proc), bind(c) :: pc1
+  !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
+
+  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
+
+  enum, bind(c) ! no error
+    enumerator :: SUNDAY, MONDAY
+  end enum
+
+  integer :: x, y, z = 1
+  common /blk/ y
+  bind(c) :: x, /blk/, z ! no error for variable and common block
+
+  bind(c) :: implicit_i ! no error for implicit type variable
+
+  !ERROR: 'implicit_blk' appears as a COMMON block in a BIND statement but not in a COMMON statement
+  bind(c) :: /implicit_blk/
+
+contains
+
+  subroutine sub() bind(c)
+  end
+
+end