[flang-commits] [flang] [flang] Lower special bind(c) cases without binding labels (PR #65758)
via flang-commits
flang-commits at lists.llvm.org
Fri Sep 8 06:55:18 PDT 2023
https://github.com/jeanPerier created https://github.com/llvm/llvm-project/pull/65758:
1. Deal with BIND(C,NAME="")
BIND(C,NAME="") is different from BIND(C). The latter implies that there us a binding label which is the Fortran symbol name (no Fortran mangling must be added like underscores). The former implies there is no binding label (the name in the object file must be the same as if it there was no BIND(C) attribute at all).
This is correctly implemented in the front-end, but lowering mistakenly overrode this in the code dealing with the case where BIND(C) is inherited from a procedure interface (which I am not sure can be handled in name resolution SetBindNameOn, since it is not clear to me that the procedure interface symbol is set already).
2. Deal with BIND(C) internal procedure
Also according to 18.10.2, BIND(C) does not give a p Prevent name resolution from adding a label to them, otherwise, bindc_internal_proc.f90 was not going through semantics (bogus error about conflicting global names). Nothing TODO in lowering other than removing the TODO.
>From d6e524b081683b0700fa3816cf7c699e43fa3525 Mon Sep 17 00:00:00 2001
From: Jean Perier <jperier at nvidia.com>
Date: Fri, 8 Sep 2023 00:57:01 -0700
Subject: [PATCH] [flang] Lower special bind(c) cases without binding labels
1. Deal with BIND(C,NAME="")
BIND(C,NAME="") is different from BIND(C). The latter implies that there
us a binding label which is the Fortran symbol name (no Fortran mangling
must be added like underscores). The former implies there is no binding
label (the name in the object file must be the same as if it there was
no BIND(C) attribute at all).
This is correctly implemented in the front-end, but lowering mistakenly
overrode this in the code dealing with the case where BIND(C) is
inherited from a procedure interface (which I am not sure can be handled
in name resolution SetBindNameOn, since it is not clear to me that the
procedure interface symbol is set already).
2. Deal with BIND(C) internal procedure
Also according to 18.10.2, BIND(C) does not give a p
Prevent name resolution from adding a label to them, otherwise,
bindc_internal_proc.f90 was not going through semantics (bogus error
about conflicting global names). Nothing TODO in lowering other than
removing the TODO.
---
flang/lib/Lower/CallInterface.cpp | 22 ++++-------------
flang/lib/Lower/Mangler.cpp | 13 ++++++----
flang/lib/Semantics/resolve-names.cpp | 3 +++
flang/test/Lower/HLFIR/bindc_empty_name.f90 | 23 ++++++++++++++++++
.../test/Lower/HLFIR/bindc_internal_proc.f90 | 24 +++++++++++++++++++
5 files changed, 62 insertions(+), 23 deletions(-)
create mode 100644 flang/test/Lower/HLFIR/bindc_empty_name.f90
create mode 100644 flang/test/Lower/HLFIR/bindc_internal_proc.f90
diff --git a/flang/lib/Lower/CallInterface.cpp b/flang/lib/Lower/CallInterface.cpp
index 034bce4b13885c0..49c4b2aae9ae262 100644
--- a/flang/lib/Lower/CallInterface.cpp
+++ b/flang/lib/Lower/CallInterface.cpp
@@ -23,22 +23,6 @@
#include "flang/Semantics/tools.h"
#include <optional>
-//===----------------------------------------------------------------------===//
-// BIND(C) mangling helpers
-//===----------------------------------------------------------------------===//
-
-// Return the binding label (from BIND(C...)) or the mangled name of a symbol.
-static std::string getMangledName(Fortran::lower::AbstractConverter &converter,
- const Fortran::semantics::Symbol &symbol) {
- const std::string *bindName = symbol.GetBindName();
- // TODO: update GetBindName so that it does not return a label for internal
- // procedures.
- if (bindName && Fortran::semantics::ClassifyProcedure(symbol) ==
- Fortran::semantics::ProcedureDefinitionClass::Internal)
- TODO(converter.getCurrentLocation(), "BIND(C) internal procedures");
- return bindName ? *bindName : converter.mangleName(symbol);
-}
-
mlir::Type Fortran::lower::getUntypedBoxProcType(mlir::MLIRContext *context) {
llvm::SmallVector<mlir::Type> resultTys;
llvm::SmallVector<mlir::Type> inputTys;
@@ -72,8 +56,10 @@ bool Fortran::lower::CallerInterface::hasAlternateReturns() const {
std::string Fortran::lower::CallerInterface::getMangledName() const {
const Fortran::evaluate::ProcedureDesignator &proc = procRef.proc();
+ // Return the binding label (from BIND(C...)) or the mangled name of the
+ // symbol.
if (const Fortran::semantics::Symbol *symbol = proc.GetSymbol())
- return ::getMangledName(converter, symbol->GetUltimate());
+ return converter.mangleName(symbol->GetUltimate());
assert(proc.GetSpecificIntrinsic() &&
"expected intrinsic procedure in designator");
return proc.GetName();
@@ -420,7 +406,7 @@ bool Fortran::lower::CalleeInterface::hasAlternateReturns() const {
std::string Fortran::lower::CalleeInterface::getMangledName() const {
if (funit.isMainProgram())
return fir::NameUniquer::doProgramEntry().str();
- return ::getMangledName(converter, funit.getSubprogramSymbol());
+ return converter.mangleName(funit.getSubprogramSymbol());
}
const Fortran::semantics::Symbol *
diff --git a/flang/lib/Lower/Mangler.cpp b/flang/lib/Lower/Mangler.cpp
index 4ea6238eded0026..0c5c97efb98ebb7 100644
--- a/flang/lib/Lower/Mangler.cpp
+++ b/flang/lib/Lower/Mangler.cpp
@@ -99,11 +99,14 @@ Fortran::lower::mangle::mangleName(const Fortran::semantics::Symbol &symbol,
// TODO: A procedure that inherits BIND(C) through another interface
// (procedure(iface)) should be dealt with in GetBindName() or some wrapper.
- if (!Fortran::semantics::IsPointer(ultimateSymbol) &&
- Fortran::semantics::IsBindCProcedure(ultimateSymbol) &&
- Fortran::semantics::ClassifyProcedure(symbol) !=
- Fortran::semantics::ProcedureDefinitionClass::Internal)
- return ultimateSymbol.name().ToString();
+ if (const auto *procDetails{
+ ultimateSymbol.detailsIf<Fortran::semantics::ProcEntityDetails>()})
+ if (procDetails->procInterface() &&
+ !Fortran::semantics::IsPointer(ultimateSymbol) &&
+ Fortran::semantics::IsBindCProcedure(*procDetails->procInterface()) &&
+ Fortran::semantics::ClassifyProcedure(symbol) !=
+ Fortran::semantics::ProcedureDefinitionClass::Internal)
+ return ultimateSymbol.name().ToString();
llvm::StringRef symbolName = toStringRef(ultimateSymbol.name());
llvm::SmallVector<llvm::StringRef> modules;
diff --git a/flang/lib/Semantics/resolve-names.cpp b/flang/lib/Semantics/resolve-names.cpp
index 0b4b940fa1d1c70..e2e1f202766a849 100644
--- a/flang/lib/Semantics/resolve-names.cpp
+++ b/flang/lib/Semantics/resolve-names.cpp
@@ -1753,6 +1753,9 @@ void AttrsVisitor::SetBindNameOn(Symbol &symbol) {
}
auto last{label->find_last_not_of(" ")};
label = label->substr(first, last - first + 1);
+ } else if (ClassifyProcedure(symbol) == ProcedureDefinitionClass::Internal) {
+ // BIND(C) does not give an implicit binding label to internal procedures.
+ return;
} else {
label = symbol.name().ToString();
}
diff --git a/flang/test/Lower/HLFIR/bindc_empty_name.f90 b/flang/test/Lower/HLFIR/bindc_empty_name.f90
new file mode 100644
index 000000000000000..9a0142e9913ef17
--- /dev/null
+++ b/flang/test/Lower/HLFIR/bindc_empty_name.f90
@@ -0,0 +1,23 @@
+! Test that lowering makes a difference between NAME="" and no NAME
+! in BIND(C). See Fortran 2018 standard 18.10.2 point 2.
+! BIND(C, NAME="") implies there is no binding label, meaning that
+! the Fortran mangled name has to be used.
+! RUN: bbc -emit-hlfir %s -o - | FileCheck %s
+
+!CHECK: func.func @_QPfoo(%{{.*}}: !fir.ref<i16>
+subroutine foo(x) bind(c, name="")
+ integer(2) :: x
+end subroutine
+
+!CHECK: func.func @bar(%{{.*}}: !fir.ref<i32>
+subroutine foo(x) bind(c, name="bar")
+ integer(4) :: x
+end subroutine
+
+!CHECK: func.func @_QMinamodule1Pfoo(%{{.*}}: !fir.ref<i64>
+module inamodule1
+contains
+subroutine foo(x) bind(c, name="")
+ integer(8) :: x
+end subroutine
+end module
diff --git a/flang/test/Lower/HLFIR/bindc_internal_proc.f90 b/flang/test/Lower/HLFIR/bindc_internal_proc.f90
new file mode 100644
index 000000000000000..027c94f95a326e5
--- /dev/null
+++ b/flang/test/Lower/HLFIR/bindc_internal_proc.f90
@@ -0,0 +1,24 @@
+! Test that internal procedure with BIND(C) do not have binding labels,
+! that is, that they are generated using usual flang mangling for non BIND(C)
+! internal procedures.
+! RUN: bbc -emit-hlfir %s -o - | FileCheck %s
+
+!CHECK: func.func @_QFsub1Pfoo(%{{.*}}: i32
+subroutine sub1()
+ call foo(42)
+contains
+ subroutine foo(i) bind(c)
+ integer, value :: i
+ print *, i
+ end subroutine
+end subroutine
+
+!CHECK: func.func @_QFsub2Pfoo(%{{.*}}: i64
+subroutine sub2()
+ call foo(42_8)
+contains
+ subroutine foo(i) bind(c)
+ integer(8), value :: i
+ print *, i
+ end subroutine
+end subroutine
More information about the flang-commits
mailing list