intel/llvm
1
0
Fork 0
mirror of https://github.com/intel/llvm.git synced 2026-02-02 01:30:24 +08:00
Code Issues Packages Projects Releases Wiki Activity
Files
25ce98670077a3fec5c384fed65f4ac663a56f7b
llvm/flang/lib/Lower/CallInterface.cpp

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

1419 lines
60 KiB
C++
Raw Normal View History

[flang] Initial lowering for empty program This patch enable lowering from Fortran to FIR for a basic empty program. It brings all the infrastructure needed for that. As discussed previously, this is the first patch for lowering and follow up patches should be smaller. With this patch we can lower the following code: ``` program basic end program ``` To a the FIR equivalent: ``` func @_QQmain() { return } ``` Follow up patch will add lowering of more complex constructs. Reviewed By: kiranchandramohan, schweitz, PeteSteinfeld Differential Revision: https://reviews.llvm.org/D118436
2022-01-28 22:39:44 +01:00
//===-- CallInterface.cpp -- Procedure call interface ---------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include "flang/Lower/CallInterface.h"
#include "flang/Evaluate/fold.h"
#include "flang/Lower/Bridge.h"
#include "flang/Lower/Mangler.h"
#include "flang/Lower/PFTBuilder.h"
[flang] Add lowering for host association This patches adds the code to handle host association for inner subroutines and functions. This patch is part of the upstreaming effort from fir-dev branch. Reviewed By: jeanPerier Differential Revision: https://reviews.llvm.org/D121134 Co-authored-by: Eric Schweitz <eschweitz@nvidia.com> Co-authored-by: Jean Perier <jperier@nvidia.com> Co-authored-by: V Donaldson <vdonaldson@nvidia.com>
2022-03-07 19:55:48 +01:00
#include "flang/Lower/StatementContext.h"
[flang] Initial lowering for empty program This patch enable lowering from Fortran to FIR for a basic empty program. It brings all the infrastructure needed for that. As discussed previously, this is the first patch for lowering and follow up patches should be smaller. With this patch we can lower the following code: ``` program basic end program ``` To a the FIR equivalent: ``` func @_QQmain() { return } ``` Follow up patch will add lowering of more complex constructs. Reviewed By: kiranchandramohan, schweitz, PeteSteinfeld Differential Revision: https://reviews.llvm.org/D118436
2022-01-28 22:39:44 +01:00
#include "flang/Lower/Support/Utils.h"
[flang] Add lowering for host association This patches adds the code to handle host association for inner subroutines and functions. This patch is part of the upstreaming effort from fir-dev branch. Reviewed By: jeanPerier Differential Revision: https://reviews.llvm.org/D121134 Co-authored-by: Eric Schweitz <eschweitz@nvidia.com> Co-authored-by: Jean Perier <jperier@nvidia.com> Co-authored-by: V Donaldson <vdonaldson@nvidia.com>
2022-03-07 19:55:48 +01:00
#include "flang/Optimizer/Builder/Character.h"
[flang] Initial lowering for empty program This patch enable lowering from Fortran to FIR for a basic empty program. It brings all the infrastructure needed for that. As discussed previously, this is the first patch for lowering and follow up patches should be smaller. With this patch we can lower the following code: ``` program basic end program ``` To a the FIR equivalent: ``` func @_QQmain() { return } ``` Follow up patch will add lowering of more complex constructs. Reviewed By: kiranchandramohan, schweitz, PeteSteinfeld Differential Revision: https://reviews.llvm.org/D118436
2022-01-28 22:39:44 +01:00
#include "flang/Optimizer/Builder/FIRBuilder.h"
[flang][NFC] Move Todo.h from Lower to Optimizer Remove a backwards dependence from Optimizer -> Lower by moving Todo.h to the optimizer and out of lowering. This patch is part of the upstreaming effort from fir-dev branch. Co-authored-by: Eric Schweitz <eschweitz@nvidia.com> Reviewed By: jeanPerier Differential Revision: https://reviews.llvm.org/D127292
2022-06-10 08:50:40 +02:00
#include "flang/Optimizer/Builder/Todo.h"
[flang] Initial lowering for empty program This patch enable lowering from Fortran to FIR for a basic empty program. It brings all the infrastructure needed for that. As discussed previously, this is the first patch for lowering and follow up patches should be smaller. With this patch we can lower the following code: ``` program basic end program ``` To a the FIR equivalent: ``` func @_QQmain() { return } ``` Follow up patch will add lowering of more complex constructs. Reviewed By: kiranchandramohan, schweitz, PeteSteinfeld Differential Revision: https://reviews.llvm.org/D118436
2022-01-28 22:39:44 +01:00
#include "flang/Optimizer/Dialect/FIRDialect.h"
#include "flang/Optimizer/Dialect/FIROpsSupport.h"
#include "flang/Optimizer/Support/InternalNames.h"
#include "flang/Semantics/symbol.h"
#include "flang/Semantics/tools.h"
[flang] Add #include <optional> (NFC) This patch adds #include <optional> to those files containing llvm::Optional<...> or Optional<...>. I'll post a separate patch to actually replace llvm::Optional with std::optional. This is part of an effort to migrate from llvm::Optional to std::optional: https://discourse.llvm.org/t/deprecating-llvm-optional-x-hasvalue-getvalue-getvalueor/63716
2023-01-07 20:55:47 -08:00
#include <optional>
[flang] Initial lowering for empty program This patch enable lowering from Fortran to FIR for a basic empty program. It brings all the infrastructure needed for that. As discussed previously, this is the first patch for lowering and follow up patches should be smaller. With this patch we can lower the following code: ``` program basic end program ``` To a the FIR equivalent: ``` func @_QQmain() { return } ``` Follow up patch will add lowering of more complex constructs. Reviewed By: kiranchandramohan, schweitz, PeteSteinfeld Differential Revision: https://reviews.llvm.org/D118436
2022-01-28 22:39:44 +01:00
//===----------------------------------------------------------------------===//
// BIND(C) mangling helpers
//===----------------------------------------------------------------------===//
// Return the binding label (from BIND(C...)) or the mangled name of a symbol.
[flang] Block construct A block construct is an execution control construct that supports declaration scopes contained within a parent subprogram scope or another block scope. (blocks may be nested.) This is implemented by applying basic scope processing to the block level. Name uniquing/mangling is extended to support this. The term "block" is heavily overloaded in Fortran standards. Prior name uniquing used tag `B` for common block objects. Existing tag choices were modified to free up `B` for block construct entities, and `C` for common blocks, and resolve additional issues with other tags. The "old tag -> new tag" changes can be summarized as: -> B -- block construct -> new B -> C -- common block C -> YI -- intrinsic type descriptor; not currently generated CT -> Y -- nonintrinsic type descriptor; not currently generated G -> N -- namelist group L -> -- block data; not needed -> deleted Existing name uniquing components consist of a tag followed by a name from user source code, such as a module, subprogram, or variable name. Block constructs are different in that they may be anonymous. (Like other constructs, a block may have a `block-construct-name` that can be used in exit statements, but this name is optional.) So blocks are given a numeric compiler-generated preorder index starting with `B1`, `B2`, and so on, on a per-procedure basis. Name uniquing is also modified to include component names for all containing procedures rather than for just the immediate host. This fixes an existing name clash bug with same-named entities in same-named host subprograms contained in different-named containing subprograms, and variations of the bug involving modules and submodules. F18 clause 9.7.3.1 (Deallocation of allocatable variables) paragraph 1 has a requirement that an allocated, unsaved allocatable local variable must be deallocated on procedure exit. The following paragraph 2 states: When a BLOCK construct terminates, any unsaved allocated allocatable local variable of the construct is deallocated. Similarly, F18 clause 7.5.6.3 (When finalization occurs) paragraph 3 has a requirement that a nonpointer, nonallocatable object must be finalized on procedure exit. The following paragraph 4 states: A nonpointer nonallocatable local variable of a BLOCK construct is finalized immediately before it would become undefined due to termination of the BLOCK construct. These deallocation and finalization requirements, along with stack restoration requirements, require knowledge of block exits. In addition to normal block termination at an end-block-stmt, a block may be terminated by executing a branching statement that targets a statement outside of the block. This includes Single-target branch statements: - goto - exit - cycle - return Bounded multiple-target branch statements: - arithmetic goto - IO statement with END, EOR, or ERR specifiers Unbounded multiple-target branch statements: - call with alternate return specs - computed goto - assigned goto Lowering code is extended to determine if one of these branches exits one or more relevant blocks or other constructs, and adds a mechanism to insert any necessary deallocation, finalization, or stack restoration code at the source of the branch. For a single-target branch it suffices to generate the exit code just prior to taking the indicated branch. Each target of a multiple-target branch must be analyzed individually. Where necessary, the code must first branch to an intermediate basic block that contains exit code, followed by a branch to the original target statement. This patch implements an `activeConstructStack` construct exit mechanism that queries a new `activeConstruct` PFT bit to insert stack restoration code at block exits. It ties in to existing code in ConvertVariable.cpp routine `instantiateLocal` which has code for finalization, making block exit finalization on par with subprogram exit finalization. Deallocation is as yet unimplemented for subprograms or blocks. This may result in memory leaks for affected objects at either the subprogram or block level. Deallocation cases can be addressed uniformly for both scopes in a future patch, presumably with code insertion in routine `instantiateLocal`. The exit code mechanism is not limited to block construct exits. It is also available for use with other constructs. In particular, it is used to replace custom deallocation code for a select case construct character selector expression where applicable. This functionality is also added to select type and associate constructs. It is available for use with other constructs, such as select rank and image control constructs, if that turns out to be necessary. Overlapping nonfunctional changes include eliminating "FIR" from some routine names and eliminating obsolete spaces in comments.
2023-02-27 14:05:53 -08:00
static std::string getMangledName(Fortran::lower::AbstractConverter &converter,
[flang] Handle BINC(C) variables and add TODO for corner cases - BIND(C) was ignored in lowering for objects (it can be used on module and common blocks): use the bind name as the fir.global name. - When an procedure is declared BIND(C) indirectly via an interface, it should have a BIND(C) name. This was not the case because GetBindName()/bindingName() return nothing in this case: detect this case in mangler.cpp and use the symbol name. Add TODOs for corner cases: - BIND(C) module variables may be initialized on the C side. This does not fit well with the current linkage strategy. Add a TODO until this is revisited. - BIND(C) internal procedures should not have a binding label (see Fortran 2018 section 18.10.2 point 2), yet we currently lower them as if they were BIND(C) external procedure. I think this and the indirect interface case should really be handled by symbol.GetBindName instead of adding more logic in lowering to deal with this case: add a TODO. This patch is part of the upstreaming effort from fir-dev branch. Reviewed By: klausler Differential Revision: https://reviews.llvm.org/D128340 Co-authored-by: Jean Perier <jperier@nvidia.com>
2022-06-22 20:46:30 +02:00
const Fortran::semantics::Symbol &symbol) {
[flang] Initial lowering for empty program This patch enable lowering from Fortran to FIR for a basic empty program. It brings all the infrastructure needed for that. As discussed previously, this is the first patch for lowering and follow up patches should be smaller. With this patch we can lower the following code: ``` program basic end program ``` To a the FIR equivalent: ``` func @_QQmain() { return } ``` Follow up patch will add lowering of more complex constructs. Reviewed By: kiranchandramohan, schweitz, PeteSteinfeld Differential Revision: https://reviews.llvm.org/D118436
2022-01-28 22:39:44 +01:00
const std::string *bindName = symbol.GetBindName();
[flang] Handle BINC(C) variables and add TODO for corner cases - BIND(C) was ignored in lowering for objects (it can be used on module and common blocks): use the bind name as the fir.global name. - When an procedure is declared BIND(C) indirectly via an interface, it should have a BIND(C) name. This was not the case because GetBindName()/bindingName() return nothing in this case: detect this case in mangler.cpp and use the symbol name. Add TODOs for corner cases: - BIND(C) module variables may be initialized on the C side. This does not fit well with the current linkage strategy. Add a TODO until this is revisited. - BIND(C) internal procedures should not have a binding label (see Fortran 2018 section 18.10.2 point 2), yet we currently lower them as if they were BIND(C) external procedure. I think this and the indirect interface case should really be handled by symbol.GetBindName instead of adding more logic in lowering to deal with this case: add a TODO. This patch is part of the upstreaming effort from fir-dev branch. Reviewed By: klausler Differential Revision: https://reviews.llvm.org/D128340 Co-authored-by: Jean Perier <jperier@nvidia.com>
2022-06-22 20:46:30 +02:00
// TODO: update GetBindName so that it does not return a label for internal
// procedures.
if (bindName && Fortran::semantics::ClassifyProcedure(symbol) ==
Fortran::semantics::ProcedureDefinitionClass::Internal)
[flang] Block construct A block construct is an execution control construct that supports declaration scopes contained within a parent subprogram scope or another block scope. (blocks may be nested.) This is implemented by applying basic scope processing to the block level. Name uniquing/mangling is extended to support this. The term "block" is heavily overloaded in Fortran standards. Prior name uniquing used tag `B` for common block objects. Existing tag choices were modified to free up `B` for block construct entities, and `C` for common blocks, and resolve additional issues with other tags. The "old tag -> new tag" changes can be summarized as: -> B -- block construct -> new B -> C -- common block C -> YI -- intrinsic type descriptor; not currently generated CT -> Y -- nonintrinsic type descriptor; not currently generated G -> N -- namelist group L -> -- block data; not needed -> deleted Existing name uniquing components consist of a tag followed by a name from user source code, such as a module, subprogram, or variable name. Block constructs are different in that they may be anonymous. (Like other constructs, a block may have a `block-construct-name` that can be used in exit statements, but this name is optional.) So blocks are given a numeric compiler-generated preorder index starting with `B1`, `B2`, and so on, on a per-procedure basis. Name uniquing is also modified to include component names for all containing procedures rather than for just the immediate host. This fixes an existing name clash bug with same-named entities in same-named host subprograms contained in different-named containing subprograms, and variations of the bug involving modules and submodules. F18 clause 9.7.3.1 (Deallocation of allocatable variables) paragraph 1 has a requirement that an allocated, unsaved allocatable local variable must be deallocated on procedure exit. The following paragraph 2 states: When a BLOCK construct terminates, any unsaved allocated allocatable local variable of the construct is deallocated. Similarly, F18 clause 7.5.6.3 (When finalization occurs) paragraph 3 has a requirement that a nonpointer, nonallocatable object must be finalized on procedure exit. The following paragraph 4 states: A nonpointer nonallocatable local variable of a BLOCK construct is finalized immediately before it would become undefined due to termination of the BLOCK construct. These deallocation and finalization requirements, along with stack restoration requirements, require knowledge of block exits. In addition to normal block termination at an end-block-stmt, a block may be terminated by executing a branching statement that targets a statement outside of the block. This includes Single-target branch statements: - goto - exit - cycle - return Bounded multiple-target branch statements: - arithmetic goto - IO statement with END, EOR, or ERR specifiers Unbounded multiple-target branch statements: - call with alternate return specs - computed goto - assigned goto Lowering code is extended to determine if one of these branches exits one or more relevant blocks or other constructs, and adds a mechanism to insert any necessary deallocation, finalization, or stack restoration code at the source of the branch. For a single-target branch it suffices to generate the exit code just prior to taking the indicated branch. Each target of a multiple-target branch must be analyzed individually. Where necessary, the code must first branch to an intermediate basic block that contains exit code, followed by a branch to the original target statement. This patch implements an `activeConstructStack` construct exit mechanism that queries a new `activeConstruct` PFT bit to insert stack restoration code at block exits. It ties in to existing code in ConvertVariable.cpp routine `instantiateLocal` which has code for finalization, making block exit finalization on par with subprogram exit finalization. Deallocation is as yet unimplemented for subprograms or blocks. This may result in memory leaks for affected objects at either the subprogram or block level. Deallocation cases can be addressed uniformly for both scopes in a future patch, presumably with code insertion in routine `instantiateLocal`. The exit code mechanism is not limited to block construct exits. It is also available for use with other constructs. In particular, it is used to replace custom deallocation code for a select case construct character selector expression where applicable. This functionality is also added to select type and associate constructs. It is available for use with other constructs, such as select rank and image control constructs, if that turns out to be necessary. Overlapping nonfunctional changes include eliminating "FIR" from some routine names and eliminating obsolete spaces in comments.
2023-02-27 14:05:53 -08:00
TODO(converter.getCurrentLocation(), "BIND(C) internal procedures");
return bindName ? *bindName : converter.mangleName(symbol);
[flang] Initial lowering for empty program This patch enable lowering from Fortran to FIR for a basic empty program. It brings all the infrastructure needed for that. As discussed previously, this is the first patch for lowering and follow up patches should be smaller. With this patch we can lower the following code: ``` program basic end program ``` To a the FIR equivalent: ``` func @_QQmain() { return } ``` Follow up patch will add lowering of more complex constructs. Reviewed By: kiranchandramohan, schweitz, PeteSteinfeld Differential Revision: https://reviews.llvm.org/D118436
2022-01-28 22:39:44 +01:00
}
[flang][hlfir] Lower procedure designators to HLFIR - Add a convertProcedureDesignatorToHLFIR that converts the fir::ExtendedValue from the current lowering to a fir.boxproc/tuple<fir.boxproc, len> mlir::Value. - Allow fir.boxproc/tuple<fir.boxproc, len> as hlfir::Entity values (a function is an address, but from a Fortran entity point of view, procedure that are not procedure pointers cannot be assigned to, so it makes a lot more sense to consider those as values). - Modify symbol association to not generate an hlfir.declare for dummy procedures. They are not needed and allowing hlfir.declare to declare function values would make its verifier and handling overly complex for little benefits (maybe an hlfir.declare_proc could be added if it turnout out useful later for debug info and attributes storing purposes). - Allow translation from hlfir::Entity to fir::ExtendedValue. convertToBox return type had to be relaxed because some intrinsics handles both object and procedure arguments and need to lower their object arguments "asBox". fir::BoxValue is not intended to carry dummy procedures (all its member functions would make little sense and its verifier does not accept such type). Note that AsAddr, AsValue and AsBox will always return the same MLIR value for procedure designators because they are always handled the same way in FIR. Differential Revision: https://reviews.llvm.org/D143585
2023-02-09 09:02:43 +01:00
mlir::Type Fortran::lower::getUntypedBoxProcType(mlir::MLIRContext *context) {
llvm::SmallVector<mlir::Type> resultTys;
llvm::SmallVector<mlir::Type> inputTys;
auto untypedFunc = mlir::FunctionType::get(context, inputTys, resultTys);
return fir::BoxProcType::get(context, untypedFunc);
}
[flang] Add lowering for host association This patches adds the code to handle host association for inner subroutines and functions. This patch is part of the upstreaming effort from fir-dev branch. Reviewed By: jeanPerier Differential Revision: https://reviews.llvm.org/D121134 Co-authored-by: Eric Schweitz <eschweitz@nvidia.com> Co-authored-by: Jean Perier <jperier@nvidia.com> Co-authored-by: V Donaldson <vdonaldson@nvidia.com>
2022-03-07 19:55:48 +01:00
/// Return the type of a dummy procedure given its characteristic (if it has
/// one).
[flang][hlfir] Lower procedure designators to HLFIR - Add a convertProcedureDesignatorToHLFIR that converts the fir::ExtendedValue from the current lowering to a fir.boxproc/tuple<fir.boxproc, len> mlir::Value. - Allow fir.boxproc/tuple<fir.boxproc, len> as hlfir::Entity values (a function is an address, but from a Fortran entity point of view, procedure that are not procedure pointers cannot be assigned to, so it makes a lot more sense to consider those as values). - Modify symbol association to not generate an hlfir.declare for dummy procedures. They are not needed and allowing hlfir.declare to declare function values would make its verifier and handling overly complex for little benefits (maybe an hlfir.declare_proc could be added if it turnout out useful later for debug info and attributes storing purposes). - Allow translation from hlfir::Entity to fir::ExtendedValue. convertToBox return type had to be relaxed because some intrinsics handles both object and procedure arguments and need to lower their object arguments "asBox". fir::BoxValue is not intended to carry dummy procedures (all its member functions would make little sense and its verifier does not accept such type). Note that AsAddr, AsValue and AsBox will always return the same MLIR value for procedure designators because they are always handled the same way in FIR. Differential Revision: https://reviews.llvm.org/D143585
2023-02-09 09:02:43 +01:00
static mlir::Type getProcedureDesignatorType(
[flang] Add lowering for host association This patches adds the code to handle host association for inner subroutines and functions. This patch is part of the upstreaming effort from fir-dev branch. Reviewed By: jeanPerier Differential Revision: https://reviews.llvm.org/D121134 Co-authored-by: Eric Schweitz <eschweitz@nvidia.com> Co-authored-by: Jean Perier <jperier@nvidia.com> Co-authored-by: V Donaldson <vdonaldson@nvidia.com>
2022-03-07 19:55:48 +01:00
const Fortran::evaluate::characteristics::Procedure *,
Fortran::lower::AbstractConverter &converter) {
// TODO: Get actual function type of the dummy procedure, at least when an
// interface is given. The result type should be available even if the arity
// and type of the arguments is not.
// In general, that is a nice to have but we cannot guarantee to find the
// function type that will match the one of the calls, we may not even know
// how many arguments the dummy procedure accepts (e.g. if a procedure
// pointer is only transiting through the current procedure without being
// called), so a function type cast must always be inserted.
[flang][hlfir] Lower procedure designators to HLFIR - Add a convertProcedureDesignatorToHLFIR that converts the fir::ExtendedValue from the current lowering to a fir.boxproc/tuple<fir.boxproc, len> mlir::Value. - Allow fir.boxproc/tuple<fir.boxproc, len> as hlfir::Entity values (a function is an address, but from a Fortran entity point of view, procedure that are not procedure pointers cannot be assigned to, so it makes a lot more sense to consider those as values). - Modify symbol association to not generate an hlfir.declare for dummy procedures. They are not needed and allowing hlfir.declare to declare function values would make its verifier and handling overly complex for little benefits (maybe an hlfir.declare_proc could be added if it turnout out useful later for debug info and attributes storing purposes). - Allow translation from hlfir::Entity to fir::ExtendedValue. convertToBox return type had to be relaxed because some intrinsics handles both object and procedure arguments and need to lower their object arguments "asBox". fir::BoxValue is not intended to carry dummy procedures (all its member functions would make little sense and its verifier does not accept such type). Note that AsAddr, AsValue and AsBox will always return the same MLIR value for procedure designators because they are always handled the same way in FIR. Differential Revision: https://reviews.llvm.org/D143585
2023-02-09 09:02:43 +01:00
return Fortran::lower::getUntypedBoxProcType(&converter.getMLIRContext());
[flang] Add lowering for host association This patches adds the code to handle host association for inner subroutines and functions. This patch is part of the upstreaming effort from fir-dev branch. Reviewed By: jeanPerier Differential Revision: https://reviews.llvm.org/D121134 Co-authored-by: Eric Schweitz <eschweitz@nvidia.com> Co-authored-by: Jean Perier <jperier@nvidia.com> Co-authored-by: V Donaldson <vdonaldson@nvidia.com>
2022-03-07 19:55:48 +01:00
}
[flang] Lower function and subroutine calls This patch introduce basic function/subroutine calls. Because of the state of lowering only simple scalar arguments can be used in the calls. This will be enhanced in follow up patches with arrays, allocatable, pointer ans so on. ``` subroutine sub1() end subroutine sub2() call sub1() end ``` This patch is part of the upstreaming effort from fir-dev branch. Reviewed By: schweitz Differential Revision: https://reviews.llvm.org/D120419 Co-authored-by: Eric Schweitz <eschweitz@nvidia.com> Co-authored-by: Jean Perier <jperier@nvidia.com> Co-authored-by: V Donaldson <vdonaldson@nvidia.com>
2022-02-23 19:48:07 +01:00
//===----------------------------------------------------------------------===//
// Caller side interface implementation
//===----------------------------------------------------------------------===//
bool Fortran::lower::CallerInterface::hasAlternateReturns() const {
return procRef.hasAlternateReturns();
}
std::string Fortran::lower::CallerInterface::getMangledName() const {
const Fortran::evaluate::ProcedureDesignator &proc = procRef.proc();
if (const Fortran::semantics::Symbol *symbol = proc.GetSymbol())
[flang] Block construct A block construct is an execution control construct that supports declaration scopes contained within a parent subprogram scope or another block scope. (blocks may be nested.) This is implemented by applying basic scope processing to the block level. Name uniquing/mangling is extended to support this. The term "block" is heavily overloaded in Fortran standards. Prior name uniquing used tag `B` for common block objects. Existing tag choices were modified to free up `B` for block construct entities, and `C` for common blocks, and resolve additional issues with other tags. The "old tag -> new tag" changes can be summarized as: -> B -- block construct -> new B -> C -- common block C -> YI -- intrinsic type descriptor; not currently generated CT -> Y -- nonintrinsic type descriptor; not currently generated G -> N -- namelist group L -> -- block data; not needed -> deleted Existing name uniquing components consist of a tag followed by a name from user source code, such as a module, subprogram, or variable name. Block constructs are different in that they may be anonymous. (Like other constructs, a block may have a `block-construct-name` that can be used in exit statements, but this name is optional.) So blocks are given a numeric compiler-generated preorder index starting with `B1`, `B2`, and so on, on a per-procedure basis. Name uniquing is also modified to include component names for all containing procedures rather than for just the immediate host. This fixes an existing name clash bug with same-named entities in same-named host subprograms contained in different-named containing subprograms, and variations of the bug involving modules and submodules. F18 clause 9.7.3.1 (Deallocation of allocatable variables) paragraph 1 has a requirement that an allocated, unsaved allocatable local variable must be deallocated on procedure exit. The following paragraph 2 states: When a BLOCK construct terminates, any unsaved allocated allocatable local variable of the construct is deallocated. Similarly, F18 clause 7.5.6.3 (When finalization occurs) paragraph 3 has a requirement that a nonpointer, nonallocatable object must be finalized on procedure exit. The following paragraph 4 states: A nonpointer nonallocatable local variable of a BLOCK construct is finalized immediately before it would become undefined due to termination of the BLOCK construct. These deallocation and finalization requirements, along with stack restoration requirements, require knowledge of block exits. In addition to normal block termination at an end-block-stmt, a block may be terminated by executing a branching statement that targets a statement outside of the block. This includes Single-target branch statements: - goto - exit - cycle - return Bounded multiple-target branch statements: - arithmetic goto - IO statement with END, EOR, or ERR specifiers Unbounded multiple-target branch statements: - call with alternate return specs - computed goto - assigned goto Lowering code is extended to determine if one of these branches exits one or more relevant blocks or other constructs, and adds a mechanism to insert any necessary deallocation, finalization, or stack restoration code at the source of the branch. For a single-target branch it suffices to generate the exit code just prior to taking the indicated branch. Each target of a multiple-target branch must be analyzed individually. Where necessary, the code must first branch to an intermediate basic block that contains exit code, followed by a branch to the original target statement. This patch implements an `activeConstructStack` construct exit mechanism that queries a new `activeConstruct` PFT bit to insert stack restoration code at block exits. It ties in to existing code in ConvertVariable.cpp routine `instantiateLocal` which has code for finalization, making block exit finalization on par with subprogram exit finalization. Deallocation is as yet unimplemented for subprograms or blocks. This may result in memory leaks for affected objects at either the subprogram or block level. Deallocation cases can be addressed uniformly for both scopes in a future patch, presumably with code insertion in routine `instantiateLocal`. The exit code mechanism is not limited to block construct exits. It is also available for use with other constructs. In particular, it is used to replace custom deallocation code for a select case construct character selector expression where applicable. This functionality is also added to select type and associate constructs. It is available for use with other constructs, such as select rank and image control constructs, if that turns out to be necessary. Overlapping nonfunctional changes include eliminating "FIR" from some routine names and eliminating obsolete spaces in comments.
2023-02-27 14:05:53 -08:00
return ::getMangledName(converter, symbol->GetUltimate());
[flang] Lower function and subroutine calls This patch introduce basic function/subroutine calls. Because of the state of lowering only simple scalar arguments can be used in the calls. This will be enhanced in follow up patches with arrays, allocatable, pointer ans so on. ``` subroutine sub1() end subroutine sub2() call sub1() end ``` This patch is part of the upstreaming effort from fir-dev branch. Reviewed By: schweitz Differential Revision: https://reviews.llvm.org/D120419 Co-authored-by: Eric Schweitz <eschweitz@nvidia.com> Co-authored-by: Jean Perier <jperier@nvidia.com> Co-authored-by: V Donaldson <vdonaldson@nvidia.com>
2022-02-23 19:48:07 +01:00
assert(proc.GetSpecificIntrinsic() &&
"expected intrinsic procedure in designator");
return proc.GetName();
}
const Fortran::semantics::Symbol *
Fortran::lower::CallerInterface::getProcedureSymbol() const {
return procRef.proc().GetSymbol();
}
bool Fortran::lower::CallerInterface::isIndirectCall() const {
if (const Fortran::semantics::Symbol *symbol = procRef.proc().GetSymbol())
return Fortran::semantics::IsPointer(*symbol) ||
Fortran::semantics::IsDummy(*symbol);
return false;
}
[flang] Lower type-bound procedure call needing dynamic dispatch to fir.dispatch Lower call with polymorphic entities to fir.dispatch operation. This patch only focus one lowering with simple scalar polymorphic entities. A follow-up patch will deal with allocatble, pointer and array of polymorphic entities as they require box manipulation for the passed-object. Reviewed By: jeanPerier Differential Revision: https://reviews.llvm.org/D135649
2022-10-12 15:24:21 +02:00
bool Fortran::lower::CallerInterface::requireDispatchCall() const {
// calls with NOPASS attribute still have their component so check if it is
// polymorphic.
if (const Fortran::evaluate::Component *component =
procRef.proc().GetComponent()) {
if (Fortran::semantics::IsPolymorphic(component->GetFirstSymbol()))
return true;
}
// calls with PASS attribute have the passed-object already set in its
// arguments. Just check if their is one.
std::optional<unsigned> passArg = getPassArgIndex();
if (passArg)
return true;
return false;
}
std::optional<unsigned>
Fortran::lower::CallerInterface::getPassArgIndex() const {
unsigned passArgIdx = 0;
Remove redundant initialization of std::optional (NFC)
2023-01-14 14:06:18 -08:00
std::optional<unsigned> passArg;
[flang] Lower type-bound procedure call needing dynamic dispatch to fir.dispatch Lower call with polymorphic entities to fir.dispatch operation. This patch only focus one lowering with simple scalar polymorphic entities. A follow-up patch will deal with allocatble, pointer and array of polymorphic entities as they require box manipulation for the passed-object. Reviewed By: jeanPerier Differential Revision: https://reviews.llvm.org/D135649
2022-10-12 15:24:21 +02:00
for (const auto &arg : getCallDescription().arguments()) {
if (arg && arg->isPassedObject()) {
passArg = passArgIdx;
break;
}
++passArgIdx;
}
[flang] Update fir.dispatch op lowering for tbp with character result Take into account the result passed as arguments when computing the pass object index. Reviewed By: jeanPerier Differential Revision: https://reviews.llvm.org/D138712
2022-11-25 21:23:50 +01:00
if (!passArg)
return passArg;
// Take into account result inserted as arguments.
if (std::optional<Fortran::lower::CallInterface<
Fortran::lower::CallerInterface>::PassedEntity>
resultArg = getPassedResult()) {
if (resultArg->passBy == PassEntityBy::AddressAndLength)
passArg = *passArg + 2;
else if (resultArg->passBy == PassEntityBy::BaseAddress)
passArg = *passArg + 1;
}
[flang] Lower type-bound procedure call needing dynamic dispatch to fir.dispatch Lower call with polymorphic entities to fir.dispatch operation. This patch only focus one lowering with simple scalar polymorphic entities. A follow-up patch will deal with allocatble, pointer and array of polymorphic entities as they require box manipulation for the passed-object. Reviewed By: jeanPerier Differential Revision: https://reviews.llvm.org/D135649
2022-10-12 15:24:21 +02:00
return passArg;
}
[flang] Lower function and subroutine calls This patch introduce basic function/subroutine calls. Because of the state of lowering only simple scalar arguments can be used in the calls. This will be enhanced in follow up patches with arrays, allocatable, pointer ans so on. ``` subroutine sub1() end subroutine sub2() call sub1() end ``` This patch is part of the upstreaming effort from fir-dev branch. Reviewed By: schweitz Differential Revision: https://reviews.llvm.org/D120419 Co-authored-by: Eric Schweitz <eschweitz@nvidia.com> Co-authored-by: Jean Perier <jperier@nvidia.com> Co-authored-by: V Donaldson <vdonaldson@nvidia.com>
2022-02-23 19:48:07 +01:00
const Fortran::semantics::Symbol *
Fortran::lower::CallerInterface::getIfIndirectCallSymbol() const {
if (const Fortran::semantics::Symbol *symbol = procRef.proc().GetSymbol())
if (Fortran::semantics::IsPointer(*symbol) ||
Fortran::semantics::IsDummy(*symbol))
return symbol;
return nullptr;
}
mlir::Location Fortran::lower::CallerInterface::getCalleeLocation() const {
const Fortran::evaluate::ProcedureDesignator &proc = procRef.proc();
// FIXME: If the callee is defined in the same file but after the current
// unit we cannot get its location here and the funcOp is created at the
// wrong location (i.e, the caller location).
if (const Fortran::semantics::Symbol *symbol = proc.GetSymbol())
return converter.genLocation(symbol->name());
// Use current location for intrinsics.
return converter.getCurrentLocation();
}
// Get dummy argument characteristic for a procedure with implicit interface
// from the actual argument characteristic. The actual argument may not be a F77
// entity. The attribute must be dropped and the shape, if any, must be made
// explicit.
static Fortran::evaluate::characteristics::DummyDataObject
asImplicitArg(Fortran::evaluate::characteristics::DummyDataObject &&dummy) {
Fortran::evaluate::Shape shape =
dummy.type.attrs().none() ? dummy.type.shape()
: Fortran::evaluate::Shape(dummy.type.Rank());
return Fortran::evaluate::characteristics::DummyDataObject(
Fortran::evaluate::characteristics::TypeAndShape(dummy.type.type(),
std::move(shape)));
}
static Fortran::evaluate::characteristics::DummyArgument
asImplicitArg(Fortran::evaluate::characteristics::DummyArgument &&dummy) {
return std::visit(
Fortran::common::visitors{
[&](Fortran::evaluate::characteristics::DummyDataObject &obj) {
return Fortran::evaluate::characteristics::DummyArgument(
std::move(dummy.name), asImplicitArg(std::move(obj)));
},
[&](Fortran::evaluate::characteristics::DummyProcedure &proc) {
return Fortran::evaluate::characteristics::DummyArgument(
std::move(dummy.name), std::move(proc));
},
[](Fortran::evaluate::characteristics::AlternateReturn &x) {
return Fortran::evaluate::characteristics::DummyArgument(
std::move(x));
}},
dummy.u);
}
[flang][hlfir] Ramp-up support of implicit interface mismatches There is a lot of Fortran code that takes advantage of F77 implicit interface to pass arguments with a different type than those from the subprogram definition (which is well defined if the storage and passing convention are the same or compatible). When the definition and calls are in different files, there is nothing special to do: the actual arguments are already used to compute the call interface. The trouble for lowering comes when the definition is in the same compilation unit (Semantics raises warning). Then, lowering will be provided with the interface from the definition to prepare the argument, and this leads to many ad-hoc handling (see builder.convertWithSemantics) in the current lowering to cope with the dummy/actual mismatches on a case by case basis. The current lowering to FIR is not even complete for all mismatch cases that can be found in the wild (see https://github.com/llvm/llvm-project/issues/60550), it is crashing or hitting asserts for many of the added tests. For HLFIR, instead of coping on a case by case basis, the call interface will be recomputed according to the actual arguments when calling an external procedure that can be called with an explicit interface. One extra case still has to be handled manually because it may happen in calls with explicit interfaces: passing a character procedure designator to a non character procedure dummy (and vice-versa) is widely accepted even with explicit interfaces (and flang semantic accepts it). Yet, this "mismatch" cannot be dealt with a simple fir.convert because character dummy procedure are passed with a different passing convention: an extra argument is hoisted for the result length (in FIR, there is no extra argument yet, but the MLIR func argument is a tuple<fir.boxproc, len>). Differential Revision: https://reviews.llvm.org/D143636
2023-02-10 08:56:53 +01:00
static bool isExternalDefinedInSameCompilationUnit(
const Fortran::evaluate::ProcedureDesignator &proc) {
if (const auto *symbol{proc.GetSymbol()})
return symbol->has<Fortran::semantics::SubprogramDetails>() &&
symbol->owner().IsGlobal();
return false;
}
[flang] Lower function and subroutine calls This patch introduce basic function/subroutine calls. Because of the state of lowering only simple scalar arguments can be used in the calls. This will be enhanced in follow up patches with arrays, allocatable, pointer ans so on. ``` subroutine sub1() end subroutine sub2() call sub1() end ``` This patch is part of the upstreaming effort from fir-dev branch. Reviewed By: schweitz Differential Revision: https://reviews.llvm.org/D120419 Co-authored-by: Eric Schweitz <eschweitz@nvidia.com> Co-authored-by: Jean Perier <jperier@nvidia.com> Co-authored-by: V Donaldson <vdonaldson@nvidia.com>
2022-02-23 19:48:07 +01:00
Fortran::evaluate::characteristics::Procedure
Fortran::lower::CallerInterface::characterize() const {
Fortran::evaluate::FoldingContext &foldingContext =
converter.getFoldingContext();
std::optional<Fortran::evaluate::characteristics::Procedure> characteristic =
Fortran::evaluate::characteristics::Procedure::Characterize(
procRef.proc(), foldingContext);
assert(characteristic && "Failed to get characteristic from procRef");
// The characteristic may not contain the argument characteristic if the
[flang][hlfir] Ramp-up support of implicit interface mismatches There is a lot of Fortran code that takes advantage of F77 implicit interface to pass arguments with a different type than those from the subprogram definition (which is well defined if the storage and passing convention are the same or compatible). When the definition and calls are in different files, there is nothing special to do: the actual arguments are already used to compute the call interface. The trouble for lowering comes when the definition is in the same compilation unit (Semantics raises warning). Then, lowering will be provided with the interface from the definition to prepare the argument, and this leads to many ad-hoc handling (see builder.convertWithSemantics) in the current lowering to cope with the dummy/actual mismatches on a case by case basis. The current lowering to FIR is not even complete for all mismatch cases that can be found in the wild (see https://github.com/llvm/llvm-project/issues/60550), it is crashing or hitting asserts for many of the added tests. For HLFIR, instead of coping on a case by case basis, the call interface will be recomputed according to the actual arguments when calling an external procedure that can be called with an explicit interface. One extra case still has to be handled manually because it may happen in calls with explicit interfaces: passing a character procedure designator to a non character procedure dummy (and vice-versa) is widely accepted even with explicit interfaces (and flang semantic accepts it). Yet, this "mismatch" cannot be dealt with a simple fir.convert because character dummy procedure are passed with a different passing convention: an extra argument is hoisted for the result length (in FIR, there is no extra argument yet, but the MLIR func argument is a tuple<fir.boxproc, len>). Differential Revision: https://reviews.llvm.org/D143636
2023-02-10 08:56:53 +01:00
// ProcedureDesignator has no interface, or may mismatch in case of implicit
// interface.
if (!characteristic->HasExplicitInterface() ||
(converter.getLoweringOptions().getLowerToHighLevelFIR() &&
isExternalDefinedInSameCompilationUnit(procRef.proc()) &&
characteristic->CanBeCalledViaImplicitInterface())) {
// In HLFIR lowering, calls to subprogram with implicit interfaces are
// always prepared according to the actual arguments. This is to support
// cases where the implicit interfaces are "abused" in old and not so old
// Fortran code (e.g, passing REAL(8) to CHARACTER(8), passing object
// pointers to procedure dummies, passing regular procedure dummies to
// character procedure dummies, omitted arguments....).
// In all those case, if the subprogram definition is in the same
// compilation unit, the "characteristic" from Characterize will be the one
// from the definition, in case of "abuses" (for which semantics raise a
// warning), lowering will be placed in a difficult position if it is given
// the dummy characteristic from the definition and an actual that has
// seemingly nothing to do with it: it would need to battle to anticipate
// and handle these mismatches (e.g., be able to prepare a fir.boxchar<>
// from a fir.real<> and so one). This was the approach of the lowering to
// FIR, and usually lead to compiler bug every time a new "abuse" was met in
// the wild.
// Instead, in HLFIR, the dummy characteristic is always computed from the
// actual for subprogram with implicit interfaces, and in case of call site
// vs fun.func MLIR function type signature mismatch, a function cast is
// done before placing the call. This is a hammer that should cover all
// cases and behave like existing compiler that "do not see" the definition
// when placing the call.
characteristic->dummyArguments.clear();
[flang] Lower function and subroutine calls This patch introduce basic function/subroutine calls. Because of the state of lowering only simple scalar arguments can be used in the calls. This will be enhanced in follow up patches with arrays, allocatable, pointer ans so on. ``` subroutine sub1() end subroutine sub2() call sub1() end ``` This patch is part of the upstreaming effort from fir-dev branch. Reviewed By: schweitz Differential Revision: https://reviews.llvm.org/D120419 Co-authored-by: Eric Schweitz <eschweitz@nvidia.com> Co-authored-by: Jean Perier <jperier@nvidia.com> Co-authored-by: V Donaldson <vdonaldson@nvidia.com>
2022-02-23 19:48:07 +01:00
for (const std::optional<Fortran::evaluate::ActualArgument> &arg :
procRef.arguments()) {
[flang][hlfir] Ramp-up support of implicit interface mismatches There is a lot of Fortran code that takes advantage of F77 implicit interface to pass arguments with a different type than those from the subprogram definition (which is well defined if the storage and passing convention are the same or compatible). When the definition and calls are in different files, there is nothing special to do: the actual arguments are already used to compute the call interface. The trouble for lowering comes when the definition is in the same compilation unit (Semantics raises warning). Then, lowering will be provided with the interface from the definition to prepare the argument, and this leads to many ad-hoc handling (see builder.convertWithSemantics) in the current lowering to cope with the dummy/actual mismatches on a case by case basis. The current lowering to FIR is not even complete for all mismatch cases that can be found in the wild (see https://github.com/llvm/llvm-project/issues/60550), it is crashing or hitting asserts for many of the added tests. For HLFIR, instead of coping on a case by case basis, the call interface will be recomputed according to the actual arguments when calling an external procedure that can be called with an explicit interface. One extra case still has to be handled manually because it may happen in calls with explicit interfaces: passing a character procedure designator to a non character procedure dummy (and vice-versa) is widely accepted even with explicit interfaces (and flang semantic accepts it). Yet, this "mismatch" cannot be dealt with a simple fir.convert because character dummy procedure are passed with a different passing convention: an extra argument is hoisted for the result length (in FIR, there is no extra argument yet, but the MLIR func argument is a tuple<fir.boxproc, len>). Differential Revision: https://reviews.llvm.org/D143636
2023-02-10 08:56:53 +01:00
// "arg" may be null if this is a call with missing arguments compared
// to the subprogram definition. Do not compute any characteristic
// in this case.
if (arg.has_value()) {
if (arg.value().isAlternateReturn()) {
characteristic->dummyArguments.emplace_back(
Fortran::evaluate::characteristics::AlternateReturn{});
} else {
// Argument cannot be optional with implicit interface
const Fortran::lower::SomeExpr *expr = arg.value().UnwrapExpr();
assert(expr && "argument in call with implicit interface cannot be "
"assumed type");
std::optional<Fortran::evaluate::characteristics::DummyArgument>
argCharacteristic =
Fortran::evaluate::characteristics::DummyArgument::FromActual(
"actual", *expr, foldingContext);
assert(argCharacteristic &&
"failed to characterize argument in implicit call");
characteristic->dummyArguments.emplace_back(
asImplicitArg(std::move(*argCharacteristic)));
}
[flang] Lower function and subroutine calls This patch introduce basic function/subroutine calls. Because of the state of lowering only simple scalar arguments can be used in the calls. This will be enhanced in follow up patches with arrays, allocatable, pointer ans so on. ``` subroutine sub1() end subroutine sub2() call sub1() end ``` This patch is part of the upstreaming effort from fir-dev branch. Reviewed By: schweitz Differential Revision: https://reviews.llvm.org/D120419 Co-authored-by: Eric Schweitz <eschweitz@nvidia.com> Co-authored-by: Jean Perier <jperier@nvidia.com> Co-authored-by: V Donaldson <vdonaldson@nvidia.com>
2022-02-23 19:48:07 +01:00
}
}
}
return *characteristic;
}
void Fortran::lower::CallerInterface::placeInput(
const PassedEntity &passedEntity, mlir::Value arg) {
assert(static_cast<int>(actualInputs.size()) > passedEntity.firArgument &&
passedEntity.firArgument >= 0 &&
passedEntity.passBy != CallInterface::PassEntityBy::AddressAndLength &&
"bad arg position");
actualInputs[passedEntity.firArgument] = arg;
}
void Fortran::lower::CallerInterface::placeAddressAndLengthInput(
const PassedEntity &passedEntity, mlir::Value addr, mlir::Value len) {
assert(static_cast<int>(actualInputs.size()) > passedEntity.firArgument &&
static_cast<int>(actualInputs.size()) > passedEntity.firLength &&
passedEntity.firArgument >= 0 && passedEntity.firLength >= 0 &&
passedEntity.passBy == CallInterface::PassEntityBy::AddressAndLength &&
"bad arg position");
actualInputs[passedEntity.firArgument] = addr;
actualInputs[passedEntity.firLength] = len;
}
bool Fortran::lower::CallerInterface::verifyActualInputs() const {
if (getNumFIRArguments() != actualInputs.size())
return false;
for (mlir::Value arg : actualInputs) {
if (!arg)
return false;
}
return true;
}
void Fortran::lower::CallerInterface::walkResultLengths(
ExprVisitor visitor) const {
assert(characteristic && "characteristic was not computed");
const Fortran::evaluate::characteristics::FunctionResult &result =
characteristic->functionResult.value();
const Fortran::evaluate::characteristics::TypeAndShape *typeAndShape =
result.GetTypeAndShape();
assert(typeAndShape && "no result type");
Fortran::evaluate::DynamicType dynamicType = typeAndShape->type();
// Visit result length specification expressions that are explicit.
if (dynamicType.category() == Fortran::common::TypeCategory::Character) {
if (std::optional<Fortran::evaluate::ExtentExpr> length =
dynamicType.GetCharLength())
visitor(toEvExpr(*length));
[flang] Avoid crash in lowering for unlimited polymorphic function return The dynamic type of an unlimited polymorphic entity has the derived category but does not have derived type spec. This leads to a crash for a nullptr dereference. This patch avoids this crash by checking if that the dynamic type is not unlimited polymorphic before dereferencing the derived type spec. Reviewed By: PeteSteinfeld Differential Revision: https://reviews.llvm.org/D138691
2022-11-25 13:47:25 +01:00
} else if (dynamicType.category() == common::TypeCategory::Derived &&
!dynamicType.IsUnlimitedPolymorphic()) {
[flang] Lower basic derived types This patch lowers basic derived type to FIR. This patch is part of the upstreaming effort from fir-dev branch. Reviewed By: PeteSteinfeld Differential Revision: https://reviews.llvm.org/D121383 Co-authored-by: V Donaldson <vdonaldson@nvidia.com> Co-authored-by: Jean Perier <jperier@nvidia.com> Co-authored-by: Eric Schweitz <eschweitz@nvidia.com>
2022-03-10 18:06:20 +01:00
const Fortran::semantics::DerivedTypeSpec &derivedTypeSpec =
dynamicType.GetDerivedTypeSpec();
if (Fortran::semantics::CountLenParameters(derivedTypeSpec) > 0)
TODO(converter.getCurrentLocation(),
"function result with derived type length parameters");
[flang] Lower function and subroutine calls This patch introduce basic function/subroutine calls. Because of the state of lowering only simple scalar arguments can be used in the calls. This will be enhanced in follow up patches with arrays, allocatable, pointer ans so on. ``` subroutine sub1() end subroutine sub2() call sub1() end ``` This patch is part of the upstreaming effort from fir-dev branch. Reviewed By: schweitz Differential Revision: https://reviews.llvm.org/D120419 Co-authored-by: Eric Schweitz <eschweitz@nvidia.com> Co-authored-by: Jean Perier <jperier@nvidia.com> Co-authored-by: V Donaldson <vdonaldson@nvidia.com>
2022-02-23 19:48:07 +01:00
}
}
// Compute extent expr from shapeSpec of an explicit shape.
// TODO: Allow evaluate shape analysis to work in a mode where it disregards
// the non-constant aspects when building the shape to avoid having this here.
static Fortran::evaluate::ExtentExpr
getExtentExpr(const Fortran::semantics::ShapeSpec &shapeSpec) {
const auto &ubound = shapeSpec.ubound().GetExplicit();
const auto &lbound = shapeSpec.lbound().GetExplicit();
assert(lbound && ubound && "shape must be explicit");
return Fortran::common::Clone(*ubound) - Fortran::common::Clone(*lbound) +
Fortran::evaluate::ExtentExpr{1};
}
void Fortran::lower::CallerInterface::walkResultExtents(
ExprVisitor visitor) const {
// Walk directly the result symbol shape (the characteristic shape may contain
// descriptor inquiries to it that would fail to lower on the caller side).
[flang] Lower boxed procedure In FIR, we want to wrap function pointers in a special box known as a boxproc value. Fortran has a limited form of dynamic scoping [https://tinyurl.com/2p8v2hw7] between "host procedures" and "internal procedures". There are a number of implementations possible. Boxproc typed values abstract away the implementation details of when a function pointer can be passed directly (as a raw address) and when a function pointer has to account for the presence of a dynamic scope. When lowering Fortran syntax to FIR, all function pointers are emboxed as boxproc values. When creating LLVM IR, we must strip away the abstraction and produce low-level LLVM "assembly" code. This patch implements that transformation as converting the boxproc values to either raw function pointers or executable trampolines on the stack as needed. The trampoline then captures the dynamic scope context within an executable thunk that can be passed instead of the function's raw address. Some extra handling is required for Fortran functions that return a character value to deal with LEN values here. Some of the code in Bridge.cpp and ConvertExpr.cpp and be re-arranged to faciliate the upstreaming effort. This patch is part of the upstreaming effort from fir-dev branch. Reviewed By: jeanPerier, PeteSteinfeld Differential Revision: https://reviews.llvm.org/D122223 Co-authored-by: mleair <leairmark@gmail.com> Co-authored-by: Jean Perier <jperier@nvidia.com> Co-authored-by: Eric Schweitz <eschweitz@nvidia.com> Co-authored-by: V Donaldson <vdonaldson@nvidia.com> Co-authored-by: Kiran Chandramohan <kiran.chandramohan@arm.com>
2022-03-22 15:40:32 +01:00
const Fortran::semantics::SubprogramDetails *interfaceDetails =
getInterfaceDetails();
if (interfaceDetails) {
const Fortran::semantics::Symbol &result = interfaceDetails->result();
[flang] Lower function and subroutine calls This patch introduce basic function/subroutine calls. Because of the state of lowering only simple scalar arguments can be used in the calls. This will be enhanced in follow up patches with arrays, allocatable, pointer ans so on. ``` subroutine sub1() end subroutine sub2() call sub1() end ``` This patch is part of the upstreaming effort from fir-dev branch. Reviewed By: schweitz Differential Revision: https://reviews.llvm.org/D120419 Co-authored-by: Eric Schweitz <eschweitz@nvidia.com> Co-authored-by: Jean Perier <jperier@nvidia.com> Co-authored-by: V Donaldson <vdonaldson@nvidia.com>
2022-02-23 19:48:07 +01:00
if (const auto *objectDetails =
result.detailsIf<Fortran::semantics::ObjectEntityDetails>())
if (objectDetails->shape().IsExplicitShape())
for (const Fortran::semantics::ShapeSpec &shapeSpec :
objectDetails->shape())
visitor(Fortran::evaluate::AsGenericExpr(getExtentExpr(shapeSpec)));
} else {
if (procRef.Rank() != 0)
fir::emitFatalError(
converter.getCurrentLocation(),
"only scalar functions may not have an interface symbol");
}
}
bool Fortran::lower::CallerInterface::mustMapInterfaceSymbols() const {
assert(characteristic && "characteristic was not computed");
const std::optional<Fortran::evaluate::characteristics::FunctionResult>
&result = characteristic->functionResult;
if (!result || result->CanBeReturnedViaImplicitInterface() ||
[flang] Lower boxed procedure In FIR, we want to wrap function pointers in a special box known as a boxproc value. Fortran has a limited form of dynamic scoping [https://tinyurl.com/2p8v2hw7] between "host procedures" and "internal procedures". There are a number of implementations possible. Boxproc typed values abstract away the implementation details of when a function pointer can be passed directly (as a raw address) and when a function pointer has to account for the presence of a dynamic scope. When lowering Fortran syntax to FIR, all function pointers are emboxed as boxproc values. When creating LLVM IR, we must strip away the abstraction and produce low-level LLVM "assembly" code. This patch implements that transformation as converting the boxproc values to either raw function pointers or executable trampolines on the stack as needed. The trampoline then captures the dynamic scope context within an executable thunk that can be passed instead of the function's raw address. Some extra handling is required for Fortran functions that return a character value to deal with LEN values here. Some of the code in Bridge.cpp and ConvertExpr.cpp and be re-arranged to faciliate the upstreaming effort. This patch is part of the upstreaming effort from fir-dev branch. Reviewed By: jeanPerier, PeteSteinfeld Differential Revision: https://reviews.llvm.org/D122223 Co-authored-by: mleair <leairmark@gmail.com> Co-authored-by: Jean Perier <jperier@nvidia.com> Co-authored-by: Eric Schweitz <eschweitz@nvidia.com> Co-authored-by: V Donaldson <vdonaldson@nvidia.com> Co-authored-by: Kiran Chandramohan <kiran.chandramohan@arm.com>
2022-03-22 15:40:32 +01:00
!getInterfaceDetails())
[flang] Lower function and subroutine calls This patch introduce basic function/subroutine calls. Because of the state of lowering only simple scalar arguments can be used in the calls. This will be enhanced in follow up patches with arrays, allocatable, pointer ans so on. ``` subroutine sub1() end subroutine sub2() call sub1() end ``` This patch is part of the upstreaming effort from fir-dev branch. Reviewed By: schweitz Differential Revision: https://reviews.llvm.org/D120419 Co-authored-by: Eric Schweitz <eschweitz@nvidia.com> Co-authored-by: Jean Perier <jperier@nvidia.com> Co-authored-by: V Donaldson <vdonaldson@nvidia.com>
2022-02-23 19:48:07 +01:00
return false;
bool allResultSpecExprConstant = true;
auto visitor = [&](const Fortran::lower::SomeExpr &e) {
allResultSpecExprConstant &= Fortran::evaluate::IsConstantExpr(e);
};
walkResultLengths(visitor);
walkResultExtents(visitor);
return !allResultSpecExprConstant;
}
mlir::Value Fortran::lower::CallerInterface::getArgumentValue(
const semantics::Symbol &sym) const {
mlir::Location loc = converter.getCurrentLocation();
[flang] Lower boxed procedure In FIR, we want to wrap function pointers in a special box known as a boxproc value. Fortran has a limited form of dynamic scoping [https://tinyurl.com/2p8v2hw7] between "host procedures" and "internal procedures". There are a number of implementations possible. Boxproc typed values abstract away the implementation details of when a function pointer can be passed directly (as a raw address) and when a function pointer has to account for the presence of a dynamic scope. When lowering Fortran syntax to FIR, all function pointers are emboxed as boxproc values. When creating LLVM IR, we must strip away the abstraction and produce low-level LLVM "assembly" code. This patch implements that transformation as converting the boxproc values to either raw function pointers or executable trampolines on the stack as needed. The trampoline then captures the dynamic scope context within an executable thunk that can be passed instead of the function's raw address. Some extra handling is required for Fortran functions that return a character value to deal with LEN values here. Some of the code in Bridge.cpp and ConvertExpr.cpp and be re-arranged to faciliate the upstreaming effort. This patch is part of the upstreaming effort from fir-dev branch. Reviewed By: jeanPerier, PeteSteinfeld Differential Revision: https://reviews.llvm.org/D122223 Co-authored-by: mleair <leairmark@gmail.com> Co-authored-by: Jean Perier <jperier@nvidia.com> Co-authored-by: Eric Schweitz <eschweitz@nvidia.com> Co-authored-by: V Donaldson <vdonaldson@nvidia.com> Co-authored-by: Kiran Chandramohan <kiran.chandramohan@arm.com>
2022-03-22 15:40:32 +01:00
const Fortran::semantics::SubprogramDetails *ifaceDetails =
getInterfaceDetails();
if (!ifaceDetails)
[flang] Lower function and subroutine calls This patch introduce basic function/subroutine calls. Because of the state of lowering only simple scalar arguments can be used in the calls. This will be enhanced in follow up patches with arrays, allocatable, pointer ans so on. ``` subroutine sub1() end subroutine sub2() call sub1() end ``` This patch is part of the upstreaming effort from fir-dev branch. Reviewed By: schweitz Differential Revision: https://reviews.llvm.org/D120419 Co-authored-by: Eric Schweitz <eschweitz@nvidia.com> Co-authored-by: Jean Perier <jperier@nvidia.com> Co-authored-by: V Donaldson <vdonaldson@nvidia.com>
2022-02-23 19:48:07 +01:00
fir::emitFatalError(
loc, "mapping actual and dummy arguments requires an interface");
const std::vector<Fortran::semantics::Symbol *> &dummies =
[flang] Lower boxed procedure In FIR, we want to wrap function pointers in a special box known as a boxproc value. Fortran has a limited form of dynamic scoping [https://tinyurl.com/2p8v2hw7] between "host procedures" and "internal procedures". There are a number of implementations possible. Boxproc typed values abstract away the implementation details of when a function pointer can be passed directly (as a raw address) and when a function pointer has to account for the presence of a dynamic scope. When lowering Fortran syntax to FIR, all function pointers are emboxed as boxproc values. When creating LLVM IR, we must strip away the abstraction and produce low-level LLVM "assembly" code. This patch implements that transformation as converting the boxproc values to either raw function pointers or executable trampolines on the stack as needed. The trampoline then captures the dynamic scope context within an executable thunk that can be passed instead of the function's raw address. Some extra handling is required for Fortran functions that return a character value to deal with LEN values here. Some of the code in Bridge.cpp and ConvertExpr.cpp and be re-arranged to faciliate the upstreaming effort. This patch is part of the upstreaming effort from fir-dev branch. Reviewed By: jeanPerier, PeteSteinfeld Differential Revision: https://reviews.llvm.org/D122223 Co-authored-by: mleair <leairmark@gmail.com> Co-authored-by: Jean Perier <jperier@nvidia.com> Co-authored-by: Eric Schweitz <eschweitz@nvidia.com> Co-authored-by: V Donaldson <vdonaldson@nvidia.com> Co-authored-by: Kiran Chandramohan <kiran.chandramohan@arm.com>
2022-03-22 15:40:32 +01:00
ifaceDetails->dummyArgs();
[flang] Lower function and subroutine calls This patch introduce basic function/subroutine calls. Because of the state of lowering only simple scalar arguments can be used in the calls. This will be enhanced in follow up patches with arrays, allocatable, pointer ans so on. ``` subroutine sub1() end subroutine sub2() call sub1() end ``` This patch is part of the upstreaming effort from fir-dev branch. Reviewed By: schweitz Differential Revision: https://reviews.llvm.org/D120419 Co-authored-by: Eric Schweitz <eschweitz@nvidia.com> Co-authored-by: Jean Perier <jperier@nvidia.com> Co-authored-by: V Donaldson <vdonaldson@nvidia.com>
2022-02-23 19:48:07 +01:00
auto it = std::find(dummies.begin(), dummies.end(), &sym);
if (it == dummies.end())
fir::emitFatalError(loc, "symbol is not a dummy in this call");
FirValue mlirArgIndex = passedArguments[it - dummies.begin()].firArgument;
return actualInputs[mlirArgIndex];
}
mlir::Type Fortran::lower::CallerInterface::getResultStorageType() const {
if (passedResult)
return fir::dyn_cast_ptrEleTy(inputs[passedResult->firArgument].type);
assert(saveResult && !outputs.empty());
return outputs[0].type;
}
const Fortran::semantics::Symbol &
Fortran::lower::CallerInterface::getResultSymbol() const {
mlir::Location loc = converter.getCurrentLocation();
[flang] Lower boxed procedure In FIR, we want to wrap function pointers in a special box known as a boxproc value. Fortran has a limited form of dynamic scoping [https://tinyurl.com/2p8v2hw7] between "host procedures" and "internal procedures". There are a number of implementations possible. Boxproc typed values abstract away the implementation details of when a function pointer can be passed directly (as a raw address) and when a function pointer has to account for the presence of a dynamic scope. When lowering Fortran syntax to FIR, all function pointers are emboxed as boxproc values. When creating LLVM IR, we must strip away the abstraction and produce low-level LLVM "assembly" code. This patch implements that transformation as converting the boxproc values to either raw function pointers or executable trampolines on the stack as needed. The trampoline then captures the dynamic scope context within an executable thunk that can be passed instead of the function's raw address. Some extra handling is required for Fortran functions that return a character value to deal with LEN values here. Some of the code in Bridge.cpp and ConvertExpr.cpp and be re-arranged to faciliate the upstreaming effort. This patch is part of the upstreaming effort from fir-dev branch. Reviewed By: jeanPerier, PeteSteinfeld Differential Revision: https://reviews.llvm.org/D122223 Co-authored-by: mleair <leairmark@gmail.com> Co-authored-by: Jean Perier <jperier@nvidia.com> Co-authored-by: Eric Schweitz <eschweitz@nvidia.com> Co-authored-by: V Donaldson <vdonaldson@nvidia.com> Co-authored-by: Kiran Chandramohan <kiran.chandramohan@arm.com>
2022-03-22 15:40:32 +01:00
const Fortran::semantics::SubprogramDetails *ifaceDetails =
getInterfaceDetails();
if (!ifaceDetails)
[flang] Lower function and subroutine calls This patch introduce basic function/subroutine calls. Because of the state of lowering only simple scalar arguments can be used in the calls. This will be enhanced in follow up patches with arrays, allocatable, pointer ans so on. ``` subroutine sub1() end subroutine sub2() call sub1() end ``` This patch is part of the upstreaming effort from fir-dev branch. Reviewed By: schweitz Differential Revision: https://reviews.llvm.org/D120419 Co-authored-by: Eric Schweitz <eschweitz@nvidia.com> Co-authored-by: Jean Perier <jperier@nvidia.com> Co-authored-by: V Donaldson <vdonaldson@nvidia.com>
2022-02-23 19:48:07 +01:00
fir::emitFatalError(
loc, "mapping actual and dummy arguments requires an interface");
[flang] Lower boxed procedure In FIR, we want to wrap function pointers in a special box known as a boxproc value. Fortran has a limited form of dynamic scoping [https://tinyurl.com/2p8v2hw7] between "host procedures" and "internal procedures". There are a number of implementations possible. Boxproc typed values abstract away the implementation details of when a function pointer can be passed directly (as a raw address) and when a function pointer has to account for the presence of a dynamic scope. When lowering Fortran syntax to FIR, all function pointers are emboxed as boxproc values. When creating LLVM IR, we must strip away the abstraction and produce low-level LLVM "assembly" code. This patch implements that transformation as converting the boxproc values to either raw function pointers or executable trampolines on the stack as needed. The trampoline then captures the dynamic scope context within an executable thunk that can be passed instead of the function's raw address. Some extra handling is required for Fortran functions that return a character value to deal with LEN values here. Some of the code in Bridge.cpp and ConvertExpr.cpp and be re-arranged to faciliate the upstreaming effort. This patch is part of the upstreaming effort from fir-dev branch. Reviewed By: jeanPerier, PeteSteinfeld Differential Revision: https://reviews.llvm.org/D122223 Co-authored-by: mleair <leairmark@gmail.com> Co-authored-by: Jean Perier <jperier@nvidia.com> Co-authored-by: Eric Schweitz <eschweitz@nvidia.com> Co-authored-by: V Donaldson <vdonaldson@nvidia.com> Co-authored-by: Kiran Chandramohan <kiran.chandramohan@arm.com>
2022-03-22 15:40:32 +01:00
return ifaceDetails->result();
}
const Fortran::semantics::SubprogramDetails *
Fortran::lower::CallerInterface::getInterfaceDetails() const {
if (const Fortran::semantics::Symbol *iface =
procRef.proc().GetInterfaceSymbol())
return iface->GetUltimate()
.detailsIf<Fortran::semantics::SubprogramDetails>();
return nullptr;
[flang] Lower function and subroutine calls This patch introduce basic function/subroutine calls. Because of the state of lowering only simple scalar arguments can be used in the calls. This will be enhanced in follow up patches with arrays, allocatable, pointer ans so on. ``` subroutine sub1() end subroutine sub2() call sub1() end ``` This patch is part of the upstreaming effort from fir-dev branch. Reviewed By: schweitz Differential Revision: https://reviews.llvm.org/D120419 Co-authored-by: Eric Schweitz <eschweitz@nvidia.com> Co-authored-by: Jean Perier <jperier@nvidia.com> Co-authored-by: V Donaldson <vdonaldson@nvidia.com>
2022-02-23 19:48:07 +01:00
}
[flang] Initial lowering for empty program This patch enable lowering from Fortran to FIR for a basic empty program. It brings all the infrastructure needed for that. As discussed previously, this is the first patch for lowering and follow up patches should be smaller. With this patch we can lower the following code: ``` program basic end program ``` To a the FIR equivalent: ``` func @_QQmain() { return } ``` Follow up patch will add lowering of more complex constructs. Reviewed By: kiranchandramohan, schweitz, PeteSteinfeld Differential Revision: https://reviews.llvm.org/D118436
2022-01-28 22:39:44 +01:00
//===----------------------------------------------------------------------===//
// Callee side interface implementation
//===----------------------------------------------------------------------===//
[flang] Lower basic function with scalar integer/logical return value This patch allows the lowring of simple empty function with a scalar integer or logical return value. The code in ConvertType.cpp is cleaned up as well. This file was landed together with the initial flang push and lowering was still a prototype at that time. Some more cleaning will come with follow up patches. This patch is part of the upstreaming effort from fir-dev branch. Reviewed By: PeteSteinfeld Differential Revision: https://reviews.llvm.org/D119698 Co-authored-by: Jean Perier <jperier@nvidia.com>
2022-02-14 21:31:46 +01:00
bool Fortran::lower::CalleeInterface::hasAlternateReturns() const {
return !funit.isMainProgram() &&
Fortran::semantics::HasAlternateReturns(funit.getSubprogramSymbol());
}
[flang] Initial lowering for empty program This patch enable lowering from Fortran to FIR for a basic empty program. It brings all the infrastructure needed for that. As discussed previously, this is the first patch for lowering and follow up patches should be smaller. With this patch we can lower the following code: ``` program basic end program ``` To a the FIR equivalent: ``` func @_QQmain() { return } ``` Follow up patch will add lowering of more complex constructs. Reviewed By: kiranchandramohan, schweitz, PeteSteinfeld Differential Revision: https://reviews.llvm.org/D118436
2022-01-28 22:39:44 +01:00
std::string Fortran::lower::CalleeInterface::getMangledName() const {
if (funit.isMainProgram())
return fir::NameUniquer::doProgramEntry().str();
[flang] Block construct A block construct is an execution control construct that supports declaration scopes contained within a parent subprogram scope or another block scope. (blocks may be nested.) This is implemented by applying basic scope processing to the block level. Name uniquing/mangling is extended to support this. The term "block" is heavily overloaded in Fortran standards. Prior name uniquing used tag `B` for common block objects. Existing tag choices were modified to free up `B` for block construct entities, and `C` for common blocks, and resolve additional issues with other tags. The "old tag -> new tag" changes can be summarized as: -> B -- block construct -> new B -> C -- common block C -> YI -- intrinsic type descriptor; not currently generated CT -> Y -- nonintrinsic type descriptor; not currently generated G -> N -- namelist group L -> -- block data; not needed -> deleted Existing name uniquing components consist of a tag followed by a name from user source code, such as a module, subprogram, or variable name. Block constructs are different in that they may be anonymous. (Like other constructs, a block may have a `block-construct-name` that can be used in exit statements, but this name is optional.) So blocks are given a numeric compiler-generated preorder index starting with `B1`, `B2`, and so on, on a per-procedure basis. Name uniquing is also modified to include component names for all containing procedures rather than for just the immediate host. This fixes an existing name clash bug with same-named entities in same-named host subprograms contained in different-named containing subprograms, and variations of the bug involving modules and submodules. F18 clause 9.7.3.1 (Deallocation of allocatable variables) paragraph 1 has a requirement that an allocated, unsaved allocatable local variable must be deallocated on procedure exit. The following paragraph 2 states: When a BLOCK construct terminates, any unsaved allocated allocatable local variable of the construct is deallocated. Similarly, F18 clause 7.5.6.3 (When finalization occurs) paragraph 3 has a requirement that a nonpointer, nonallocatable object must be finalized on procedure exit. The following paragraph 4 states: A nonpointer nonallocatable local variable of a BLOCK construct is finalized immediately before it would become undefined due to termination of the BLOCK construct. These deallocation and finalization requirements, along with stack restoration requirements, require knowledge of block exits. In addition to normal block termination at an end-block-stmt, a block may be terminated by executing a branching statement that targets a statement outside of the block. This includes Single-target branch statements: - goto - exit - cycle - return Bounded multiple-target branch statements: - arithmetic goto - IO statement with END, EOR, or ERR specifiers Unbounded multiple-target branch statements: - call with alternate return specs - computed goto - assigned goto Lowering code is extended to determine if one of these branches exits one or more relevant blocks or other constructs, and adds a mechanism to insert any necessary deallocation, finalization, or stack restoration code at the source of the branch. For a single-target branch it suffices to generate the exit code just prior to taking the indicated branch. Each target of a multiple-target branch must be analyzed individually. Where necessary, the code must first branch to an intermediate basic block that contains exit code, followed by a branch to the original target statement. This patch implements an `activeConstructStack` construct exit mechanism that queries a new `activeConstruct` PFT bit to insert stack restoration code at block exits. It ties in to existing code in ConvertVariable.cpp routine `instantiateLocal` which has code for finalization, making block exit finalization on par with subprogram exit finalization. Deallocation is as yet unimplemented for subprograms or blocks. This may result in memory leaks for affected objects at either the subprogram or block level. Deallocation cases can be addressed uniformly for both scopes in a future patch, presumably with code insertion in routine `instantiateLocal`. The exit code mechanism is not limited to block construct exits. It is also available for use with other constructs. In particular, it is used to replace custom deallocation code for a select case construct character selector expression where applicable. This functionality is also added to select type and associate constructs. It is available for use with other constructs, such as select rank and image control constructs, if that turns out to be necessary. Overlapping nonfunctional changes include eliminating "FIR" from some routine names and eliminating obsolete spaces in comments.
2023-02-27 14:05:53 -08:00
return ::getMangledName(converter, funit.getSubprogramSymbol());
[flang] Initial lowering for empty program This patch enable lowering from Fortran to FIR for a basic empty program. It brings all the infrastructure needed for that. As discussed previously, this is the first patch for lowering and follow up patches should be smaller. With this patch we can lower the following code: ``` program basic end program ``` To a the FIR equivalent: ``` func @_QQmain() { return } ``` Follow up patch will add lowering of more complex constructs. Reviewed By: kiranchandramohan, schweitz, PeteSteinfeld Differential Revision: https://reviews.llvm.org/D118436
2022-01-28 22:39:44 +01:00
}
const Fortran::semantics::Symbol *
Fortran::lower::CalleeInterface::getProcedureSymbol() const {
if (funit.isMainProgram())
[flang] Adding fir::getSymbolAttrName attribute to the function corresponding to the main subprogram. This is because the source name cannot be deconstructed from _QQmain Differential revision: https://reviews.llvm.org/D144295
2023-02-17 12:44:33 -08:00
return funit.getMainProgramSymbol();
[flang] Initial lowering for empty program This patch enable lowering from Fortran to FIR for a basic empty program. It brings all the infrastructure needed for that. As discussed previously, this is the first patch for lowering and follow up patches should be smaller. With this patch we can lower the following code: ``` program basic end program ``` To a the FIR equivalent: ``` func @_QQmain() { return } ``` Follow up patch will add lowering of more complex constructs. Reviewed By: kiranchandramohan, schweitz, PeteSteinfeld Differential Revision: https://reviews.llvm.org/D118436
2022-01-28 22:39:44 +01:00
return &funit.getSubprogramSymbol();
}
mlir::Location Fortran::lower::CalleeInterface::getCalleeLocation() const {
// FIXME: do NOT use unknown for the anonymous PROGRAM case. We probably
// should just stash the location in the funit regardless.
return converter.genLocation(funit.getStartingSourceLoc());
}
[flang] Lower basic function with scalar integer/logical return value This patch allows the lowring of simple empty function with a scalar integer or logical return value. The code in ConvertType.cpp is cleaned up as well. This file was landed together with the initial flang push and lowering was still a prototype at that time. Some more cleaning will come with follow up patches. This patch is part of the upstreaming effort from fir-dev branch. Reviewed By: PeteSteinfeld Differential Revision: https://reviews.llvm.org/D119698 Co-authored-by: Jean Perier <jperier@nvidia.com>
2022-02-14 21:31:46 +01:00
Fortran::evaluate::characteristics::Procedure
Fortran::lower::CalleeInterface::characterize() const {
Fortran::evaluate::FoldingContext &foldingContext =
converter.getFoldingContext();
std::optional<Fortran::evaluate::characteristics::Procedure> characteristic =
Fortran::evaluate::characteristics::Procedure::Characterize(
funit.getSubprogramSymbol(), foldingContext);
assert(characteristic && "Fail to get characteristic from symbol");
return *characteristic;
}
bool Fortran::lower::CalleeInterface::isMainProgram() const {
return funit.isMainProgram();
}
[mlir:NFC] Remove the forward declaration of FuncOp in the mlir namespace FuncOp has been moved to the `func` namespace for a little over a month, the using directive can be dropped now.
2022-04-18 11:53:47 -07:00
mlir::func::FuncOp
Fortran::lower::CalleeInterface::addEntryBlockAndMapArguments() {
[flang] Handle BINC(C) variables and add TODO for corner cases - BIND(C) was ignored in lowering for objects (it can be used on module and common blocks): use the bind name as the fir.global name. - When an procedure is declared BIND(C) indirectly via an interface, it should have a BIND(C) name. This was not the case because GetBindName()/bindingName() return nothing in this case: detect this case in mangler.cpp and use the symbol name. Add TODOs for corner cases: - BIND(C) module variables may be initialized on the C side. This does not fit well with the current linkage strategy. Add a TODO until this is revisited. - BIND(C) internal procedures should not have a binding label (see Fortran 2018 section 18.10.2 point 2), yet we currently lower them as if they were BIND(C) external procedure. I think this and the indirect interface case should really be handled by symbol.GetBindName instead of adding more logic in lowering to deal with this case: add a TODO. This patch is part of the upstreaming effort from fir-dev branch. Reviewed By: klausler Differential Revision: https://reviews.llvm.org/D128340 Co-authored-by: Jean Perier <jperier@nvidia.com>
2022-06-22 20:46:30 +02:00
// Check for bugs in the front end. The front end must not present multiple
// definitions of the same procedure.
if (!func.getBlocks().empty())
fir::emitFatalError(func.getLoc(),
"cannot process subprogram that was already processed");
// On the callee side, directly map the mlir::value argument of the function
// block to the Fortran symbols.
[flang] Initial lowering for empty program This patch enable lowering from Fortran to FIR for a basic empty program. It brings all the infrastructure needed for that. As discussed previously, this is the first patch for lowering and follow up patches should be smaller. With this patch we can lower the following code: ``` program basic end program ``` To a the FIR equivalent: ``` func @_QQmain() { return } ``` Follow up patch will add lowering of more complex constructs. Reviewed By: kiranchandramohan, schweitz, PeteSteinfeld Differential Revision: https://reviews.llvm.org/D118436
2022-01-28 22:39:44 +01:00
func.addEntryBlock();
[flang] Handle lowering arguments in subroutine and function This patch adds infrsatrcutrue to be able to lower arguments in functions and subroutines. This patch is part of the upstreaming effort from fir-dev branch. Reviewed By: PeteSteinfeld Differential Revision: https://reviews.llvm.org/D119957 Co-authored-by: Eric Schweitz <eschweitz@nvidia.com> Co-authored-by: Jean Perier <jperier@nvidia.com>
2022-02-16 20:27:23 +01:00
mapPassedEntities();
[flang] Initial lowering for empty program This patch enable lowering from Fortran to FIR for a basic empty program. It brings all the infrastructure needed for that. As discussed previously, this is the first patch for lowering and follow up patches should be smaller. With this patch we can lower the following code: ``` program basic end program ``` To a the FIR equivalent: ``` func @_QQmain() { return } ``` Follow up patch will add lowering of more complex constructs. Reviewed By: kiranchandramohan, schweitz, PeteSteinfeld Differential Revision: https://reviews.llvm.org/D118436
2022-01-28 22:39:44 +01:00
return func;
}
[flang] Add lowering for host association This patches adds the code to handle host association for inner subroutines and functions. This patch is part of the upstreaming effort from fir-dev branch. Reviewed By: jeanPerier Differential Revision: https://reviews.llvm.org/D121134 Co-authored-by: Eric Schweitz <eschweitz@nvidia.com> Co-authored-by: Jean Perier <jperier@nvidia.com> Co-authored-by: V Donaldson <vdonaldson@nvidia.com>
2022-03-07 19:55:48 +01:00
bool Fortran::lower::CalleeInterface::hasHostAssociated() const {
[flang] Do not convey captured globals through host link Addresses and properties (bounds, length parameters) of host variables associated in an internal procedure were all passed via an extra tuple argument of the internal procedure. This extra tuple is in general an overhead: it must be created and passed, and require creating thunks when taking the address of the internal procedure. This patch allows not using the tuple for host global variables (from modules, common block, or local saved variables) since they can be instantiated from the fir.global symbol in the internal procedure instead. Add a fir.internal_proc attribute to mlir::FuncOp for internal procedures so that ArrayValueCopy can still detect internal procedures even if they do not have a tuple argument. Differential Revision: https://reviews.llvm.org/D140288
2022-12-20 13:49:38 +01:00
return funit.parentHasTupleHostAssoc();
[flang] Add lowering for host association This patches adds the code to handle host association for inner subroutines and functions. This patch is part of the upstreaming effort from fir-dev branch. Reviewed By: jeanPerier Differential Revision: https://reviews.llvm.org/D121134 Co-authored-by: Eric Schweitz <eschweitz@nvidia.com> Co-authored-by: Jean Perier <jperier@nvidia.com> Co-authored-by: V Donaldson <vdonaldson@nvidia.com>
2022-03-07 19:55:48 +01:00
}
mlir::Type Fortran::lower::CalleeInterface::getHostAssociatedTy() const {
assert(hasHostAssociated());
return funit.parentHostAssoc().getArgumentType(converter);
}
mlir::Value Fortran::lower::CalleeInterface::getHostAssociatedTuple() const {
assert(hasHostAssociated() || !funit.getHostAssoc().empty());
return converter.hostAssocTupleValue();
}
[flang] Do not convey captured globals through host link Addresses and properties (bounds, length parameters) of host variables associated in an internal procedure were all passed via an extra tuple argument of the internal procedure. This extra tuple is in general an overhead: it must be created and passed, and require creating thunks when taking the address of the internal procedure. This patch allows not using the tuple for host global variables (from modules, common block, or local saved variables) since they can be instantiated from the fir.global symbol in the internal procedure instead. Add a fir.internal_proc attribute to mlir::FuncOp for internal procedures so that ArrayValueCopy can still detect internal procedures even if they do not have a tuple argument. Differential Revision: https://reviews.llvm.org/D140288
2022-12-20 13:49:38 +01:00
void Fortran::lower::CalleeInterface::setFuncAttrs(
mlir::func::FuncOp func) const {
if (funit.parentHasHostAssoc())
func->setAttr(fir::getInternalProcedureAttrName(),
mlir::UnitAttr::get(func->getContext()));
}
[flang] Initial lowering for empty program This patch enable lowering from Fortran to FIR for a basic empty program. It brings all the infrastructure needed for that. As discussed previously, this is the first patch for lowering and follow up patches should be smaller. With this patch we can lower the following code: ``` program basic end program ``` To a the FIR equivalent: ``` func @_QQmain() { return } ``` Follow up patch will add lowering of more complex constructs. Reviewed By: kiranchandramohan, schweitz, PeteSteinfeld Differential Revision: https://reviews.llvm.org/D118436
2022-01-28 22:39:44 +01:00
//===----------------------------------------------------------------------===//
[flang] Block construct A block construct is an execution control construct that supports declaration scopes contained within a parent subprogram scope or another block scope. (blocks may be nested.) This is implemented by applying basic scope processing to the block level. Name uniquing/mangling is extended to support this. The term "block" is heavily overloaded in Fortran standards. Prior name uniquing used tag `B` for common block objects. Existing tag choices were modified to free up `B` for block construct entities, and `C` for common blocks, and resolve additional issues with other tags. The "old tag -> new tag" changes can be summarized as: -> B -- block construct -> new B -> C -- common block C -> YI -- intrinsic type descriptor; not currently generated CT -> Y -- nonintrinsic type descriptor; not currently generated G -> N -- namelist group L -> -- block data; not needed -> deleted Existing name uniquing components consist of a tag followed by a name from user source code, such as a module, subprogram, or variable name. Block constructs are different in that they may be anonymous. (Like other constructs, a block may have a `block-construct-name` that can be used in exit statements, but this name is optional.) So blocks are given a numeric compiler-generated preorder index starting with `B1`, `B2`, and so on, on a per-procedure basis. Name uniquing is also modified to include component names for all containing procedures rather than for just the immediate host. This fixes an existing name clash bug with same-named entities in same-named host subprograms contained in different-named containing subprograms, and variations of the bug involving modules and submodules. F18 clause 9.7.3.1 (Deallocation of allocatable variables) paragraph 1 has a requirement that an allocated, unsaved allocatable local variable must be deallocated on procedure exit. The following paragraph 2 states: When a BLOCK construct terminates, any unsaved allocated allocatable local variable of the construct is deallocated. Similarly, F18 clause 7.5.6.3 (When finalization occurs) paragraph 3 has a requirement that a nonpointer, nonallocatable object must be finalized on procedure exit. The following paragraph 4 states: A nonpointer nonallocatable local variable of a BLOCK construct is finalized immediately before it would become undefined due to termination of the BLOCK construct. These deallocation and finalization requirements, along with stack restoration requirements, require knowledge of block exits. In addition to normal block termination at an end-block-stmt, a block may be terminated by executing a branching statement that targets a statement outside of the block. This includes Single-target branch statements: - goto - exit - cycle - return Bounded multiple-target branch statements: - arithmetic goto - IO statement with END, EOR, or ERR specifiers Unbounded multiple-target branch statements: - call with alternate return specs - computed goto - assigned goto Lowering code is extended to determine if one of these branches exits one or more relevant blocks or other constructs, and adds a mechanism to insert any necessary deallocation, finalization, or stack restoration code at the source of the branch. For a single-target branch it suffices to generate the exit code just prior to taking the indicated branch. Each target of a multiple-target branch must be analyzed individually. Where necessary, the code must first branch to an intermediate basic block that contains exit code, followed by a branch to the original target statement. This patch implements an `activeConstructStack` construct exit mechanism that queries a new `activeConstruct` PFT bit to insert stack restoration code at block exits. It ties in to existing code in ConvertVariable.cpp routine `instantiateLocal` which has code for finalization, making block exit finalization on par with subprogram exit finalization. Deallocation is as yet unimplemented for subprograms or blocks. This may result in memory leaks for affected objects at either the subprogram or block level. Deallocation cases can be addressed uniformly for both scopes in a future patch, presumably with code insertion in routine `instantiateLocal`. The exit code mechanism is not limited to block construct exits. It is also available for use with other constructs. In particular, it is used to replace custom deallocation code for a select case construct character selector expression where applicable. This functionality is also added to select type and associate constructs. It is available for use with other constructs, such as select rank and image control constructs, if that turns out to be necessary. Overlapping nonfunctional changes include eliminating "FIR" from some routine names and eliminating obsolete spaces in comments.
2023-02-27 14:05:53 -08:00
// CallInterface implementation: this part is common to both caller and callee.
[flang] Initial lowering for empty program This patch enable lowering from Fortran to FIR for a basic empty program. It brings all the infrastructure needed for that. As discussed previously, this is the first patch for lowering and follow up patches should be smaller. With this patch we can lower the following code: ``` program basic end program ``` To a the FIR equivalent: ``` func @_QQmain() { return } ``` Follow up patch will add lowering of more complex constructs. Reviewed By: kiranchandramohan, schweitz, PeteSteinfeld Differential Revision: https://reviews.llvm.org/D118436
2022-01-28 22:39:44 +01:00
//===----------------------------------------------------------------------===//
[mlir:NFC] Remove the forward declaration of FuncOp in the mlir namespace FuncOp has been moved to the `func` namespace for a little over a month, the using directive can be dropped now.
2022-04-18 11:53:47 -07:00
static void addSymbolAttribute(mlir::func::FuncOp func,
[flang] Initial lowering for empty program This patch enable lowering from Fortran to FIR for a basic empty program. It brings all the infrastructure needed for that. As discussed previously, this is the first patch for lowering and follow up patches should be smaller. With this patch we can lower the following code: ``` program basic end program ``` To a the FIR equivalent: ``` func @_QQmain() { return } ``` Follow up patch will add lowering of more complex constructs. Reviewed By: kiranchandramohan, schweitz, PeteSteinfeld Differential Revision: https://reviews.llvm.org/D118436
2022-01-28 22:39:44 +01:00
const Fortran::semantics::Symbol &sym,
mlir::MLIRContext &mlirContext) {
// Only add this on bind(C) functions for which the symbol is not reflected in
// the current context.
if (!Fortran::semantics::IsBindCProcedure(sym))
return;
std::string name =
Fortran::lower::mangle::mangleName(sym, /*keepExternalInScope=*/true);
func->setAttr(fir::getSymbolAttrName(),
mlir::StringAttr::get(&mlirContext, name));
}
/// Declare drives the different actions to be performed while analyzing the
[mlir:NFC] Remove the forward declaration of FuncOp in the mlir namespace FuncOp has been moved to the `func` namespace for a little over a month, the using directive can be dropped now.
2022-04-18 11:53:47 -07:00
/// signature and building/finding the mlir::func::FuncOp.
[flang] Initial lowering for empty program This patch enable lowering from Fortran to FIR for a basic empty program. It brings all the infrastructure needed for that. As discussed previously, this is the first patch for lowering and follow up patches should be smaller. With this patch we can lower the following code: ``` program basic end program ``` To a the FIR equivalent: ``` func @_QQmain() { return } ``` Follow up patch will add lowering of more complex constructs. Reviewed By: kiranchandramohan, schweitz, PeteSteinfeld Differential Revision: https://reviews.llvm.org/D118436
2022-01-28 22:39:44 +01:00
template <typename T>
void Fortran::lower::CallInterface<T>::declare() {
[flang] Lower basic function with scalar integer/logical return value This patch allows the lowring of simple empty function with a scalar integer or logical return value. The code in ConvertType.cpp is cleaned up as well. This file was landed together with the initial flang push and lowering was still a prototype at that time. Some more cleaning will come with follow up patches. This patch is part of the upstreaming effort from fir-dev branch. Reviewed By: PeteSteinfeld Differential Revision: https://reviews.llvm.org/D119698 Co-authored-by: Jean Perier <jperier@nvidia.com>
2022-02-14 21:31:46 +01:00
if (!side().isMainProgram()) {
characteristic.emplace(side().characterize());
bool isImplicit = characteristic->CanBeCalledViaImplicitInterface();
determineInterface(isImplicit, *characteristic);
}
// No input/output for main program
[flang] Initial lowering for empty program This patch enable lowering from Fortran to FIR for a basic empty program. It brings all the infrastructure needed for that. As discussed previously, this is the first patch for lowering and follow up patches should be smaller. With this patch we can lower the following code: ``` program basic end program ``` To a the FIR equivalent: ``` func @_QQmain() { return } ``` Follow up patch will add lowering of more complex constructs. Reviewed By: kiranchandramohan, schweitz, PeteSteinfeld Differential Revision: https://reviews.llvm.org/D118436
2022-01-28 22:39:44 +01:00
// Create / get funcOp for direct calls. For indirect calls (only meaningful
// on the caller side), no funcOp has to be created here. The mlir::Value
// holding the indirection is used when creating the fir::CallOp.
if (!side().isIndirectCall()) {
std::string name = side().getMangledName();
mlir::ModuleOp module = converter.getModuleOp();
func = fir::FirOpBuilder::getNamedFunction(module, name);
if (!func) {
mlir::Location loc = side().getCalleeLocation();
mlir::FunctionType ty = genFunctionType();
func = fir::FirOpBuilder::createFunction(loc, module, name, ty);
[flang] Adding fir::getSymbolAttrName attribute to the function corresponding to the main subprogram. This is because the source name cannot be deconstructed from _QQmain Differential revision: https://reviews.llvm.org/D144295
2023-02-17 12:44:33 -08:00
if (const Fortran::semantics::Symbol *sym = side().getProcedureSymbol()) {
if (side().isMainProgram()) {
func->setAttr(fir::getSymbolAttrName(),
mlir::StringAttr::get(&converter.getMLIRContext(),
sym->name().ToString()));
} else {
addSymbolAttribute(func, *sym, converter.getMLIRContext());
}
}
[flang] Handle lowering arguments in subroutine and function This patch adds infrsatrcutrue to be able to lower arguments in functions and subroutines. This patch is part of the upstreaming effort from fir-dev branch. Reviewed By: PeteSteinfeld Differential Revision: https://reviews.llvm.org/D119957 Co-authored-by: Eric Schweitz <eschweitz@nvidia.com> Co-authored-by: Jean Perier <jperier@nvidia.com>
2022-02-16 20:27:23 +01:00
for (const auto &placeHolder : llvm::enumerate(inputs))
if (!placeHolder.value().attributes.empty())
func.setArgAttrs(placeHolder.index(), placeHolder.value().attributes);
[flang] Do not convey captured globals through host link Addresses and properties (bounds, length parameters) of host variables associated in an internal procedure were all passed via an extra tuple argument of the internal procedure. This extra tuple is in general an overhead: it must be created and passed, and require creating thunks when taking the address of the internal procedure. This patch allows not using the tuple for host global variables (from modules, common block, or local saved variables) since they can be instantiated from the fir.global symbol in the internal procedure instead. Add a fir.internal_proc attribute to mlir::FuncOp for internal procedures so that ArrayValueCopy can still detect internal procedures even if they do not have a tuple argument. Differential Revision: https://reviews.llvm.org/D140288
2022-12-20 13:49:38 +01:00
side().setFuncAttrs(func);
[flang] Initial lowering for empty program This patch enable lowering from Fortran to FIR for a basic empty program. It brings all the infrastructure needed for that. As discussed previously, this is the first patch for lowering and follow up patches should be smaller. With this patch we can lower the following code: ``` program basic end program ``` To a the FIR equivalent: ``` func @_QQmain() { return } ``` Follow up patch will add lowering of more complex constructs. Reviewed By: kiranchandramohan, schweitz, PeteSteinfeld Differential Revision: https://reviews.llvm.org/D118436
2022-01-28 22:39:44 +01:00
}
}
}
[mlir:NFC] Remove the forward declaration of FuncOp in the mlir namespace FuncOp has been moved to the `func` namespace for a little over a month, the using directive can be dropped now.
2022-04-18 11:53:47 -07:00
/// Once the signature has been analyzed and the mlir::func::FuncOp was
/// built/found, map the fir inputs to Fortran entities (the symbols or
/// expressions).
[flang] Handle lowering arguments in subroutine and function This patch adds infrsatrcutrue to be able to lower arguments in functions and subroutines. This patch is part of the upstreaming effort from fir-dev branch. Reviewed By: PeteSteinfeld Differential Revision: https://reviews.llvm.org/D119957 Co-authored-by: Eric Schweitz <eschweitz@nvidia.com> Co-authored-by: Jean Perier <jperier@nvidia.com>
2022-02-16 20:27:23 +01:00
template <typename T>
void Fortran::lower::CallInterface<T>::mapPassedEntities() {
// map back fir inputs to passed entities
if constexpr (std::is_same_v<T, Fortran::lower::CalleeInterface>) {
assert(inputs.size() == func.front().getArguments().size() &&
"function previously created with different number of arguments");
for (auto [fst, snd] : llvm::zip(inputs, func.front().getArguments()))
mapBackInputToPassedEntity(fst, snd);
} else {
// On the caller side, map the index of the mlir argument position
// to Fortran ActualArguments.
int firPosition = 0;
for (const FirPlaceHolder &placeHolder : inputs)
mapBackInputToPassedEntity(placeHolder, firPosition++);
}
}
template <typename T>
void Fortran::lower::CallInterface<T>::mapBackInputToPassedEntity(
const FirPlaceHolder &placeHolder, FirValue firValue) {
PassedEntity &passedEntity =
placeHolder.passedEntityPosition == FirPlaceHolder::resultEntityPosition
? passedResult.value()
: passedArguments[placeHolder.passedEntityPosition];
if (placeHolder.property == Property::CharLength)
passedEntity.firLength = firValue;
else
passedEntity.firArgument = firValue;
}
[flang] Lower function and subroutine calls This patch introduce basic function/subroutine calls. Because of the state of lowering only simple scalar arguments can be used in the calls. This will be enhanced in follow up patches with arrays, allocatable, pointer ans so on. ``` subroutine sub1() end subroutine sub2() call sub1() end ``` This patch is part of the upstreaming effort from fir-dev branch. Reviewed By: schweitz Differential Revision: https://reviews.llvm.org/D120419 Co-authored-by: Eric Schweitz <eschweitz@nvidia.com> Co-authored-by: Jean Perier <jperier@nvidia.com> Co-authored-by: V Donaldson <vdonaldson@nvidia.com>
2022-02-23 19:48:07 +01:00
/// Helpers to access ActualArgument/Symbols
static const Fortran::evaluate::ActualArguments &
getEntityContainer(const Fortran::evaluate::ProcedureRef &proc) {
return proc.arguments();
}
[flang] Handle lowering arguments in subroutine and function This patch adds infrsatrcutrue to be able to lower arguments in functions and subroutines. This patch is part of the upstreaming effort from fir-dev branch. Reviewed By: PeteSteinfeld Differential Revision: https://reviews.llvm.org/D119957 Co-authored-by: Eric Schweitz <eschweitz@nvidia.com> Co-authored-by: Jean Perier <jperier@nvidia.com>
2022-02-16 20:27:23 +01:00
static const std::vector<Fortran::semantics::Symbol *> &
getEntityContainer(Fortran::lower::pft::FunctionLikeUnit &funit) {
return funit.getSubprogramSymbol()
.get<Fortran::semantics::SubprogramDetails>()
.dummyArgs();
}
[flang] Lower function and subroutine calls This patch introduce basic function/subroutine calls. Because of the state of lowering only simple scalar arguments can be used in the calls. This will be enhanced in follow up patches with arrays, allocatable, pointer ans so on. ``` subroutine sub1() end subroutine sub2() call sub1() end ``` This patch is part of the upstreaming effort from fir-dev branch. Reviewed By: schweitz Differential Revision: https://reviews.llvm.org/D120419 Co-authored-by: Eric Schweitz <eschweitz@nvidia.com> Co-authored-by: Jean Perier <jperier@nvidia.com> Co-authored-by: V Donaldson <vdonaldson@nvidia.com>
2022-02-23 19:48:07 +01:00
static const Fortran::evaluate::ActualArgument *getDataObjectEntity(
const std::optional<Fortran::evaluate::ActualArgument> &arg) {
if (arg)
return &*arg;
return nullptr;
}
[flang] Handle lowering arguments in subroutine and function This patch adds infrsatrcutrue to be able to lower arguments in functions and subroutines. This patch is part of the upstreaming effort from fir-dev branch. Reviewed By: PeteSteinfeld Differential Revision: https://reviews.llvm.org/D119957 Co-authored-by: Eric Schweitz <eschweitz@nvidia.com> Co-authored-by: Jean Perier <jperier@nvidia.com>
2022-02-16 20:27:23 +01:00
static const Fortran::semantics::Symbol &
getDataObjectEntity(const Fortran::semantics::Symbol *arg) {
assert(arg && "expect symbol for data object entity");
return *arg;
}
[flang] Lower simple character return Handles function with character return. Character scalar results are passed as arguments in lowering so that an assumed length character function callee can access the result length. This patch is part of the upstreaming effort from fir-dev branch. Reviewed By: PeteSteinfeld, schweitz Differential Revision: https://reviews.llvm.org/D120558 Co-authored-by: Eric Schweitz <eschweitz@nvidia.com> Co-authored-by: Jean Perier <jperier@nvidia.com> Co-authored-by: V Donaldson <vdonaldson@nvidia.com>
2022-02-25 18:21:44 +01:00
static const Fortran::evaluate::ActualArgument *
getResultEntity(const Fortran::evaluate::ProcedureRef &) {
return nullptr;
}
static const Fortran::semantics::Symbol &
getResultEntity(Fortran::lower::pft::FunctionLikeUnit &funit) {
return funit.getSubprogramSymbol()
.get<Fortran::semantics::SubprogramDetails>()
.result();
}
[flang] Add lowering for host association This patches adds the code to handle host association for inner subroutines and functions. This patch is part of the upstreaming effort from fir-dev branch. Reviewed By: jeanPerier Differential Revision: https://reviews.llvm.org/D121134 Co-authored-by: Eric Schweitz <eschweitz@nvidia.com> Co-authored-by: Jean Perier <jperier@nvidia.com> Co-authored-by: V Donaldson <vdonaldson@nvidia.com>
2022-03-07 19:55:48 +01:00
/// Bypass helpers to manipulate entities since they are not any symbol/actual
/// argument to associate. See SignatureBuilder below.
using FakeEntity = bool;
using FakeEntities = llvm::SmallVector<FakeEntity>;
static FakeEntities
getEntityContainer(const Fortran::evaluate::characteristics::Procedure &proc) {
FakeEntities enities(proc.dummyArguments.size());
return enities;
}
static const FakeEntity &getDataObjectEntity(const FakeEntity &e) { return e; }
static FakeEntity
getResultEntity(const Fortran::evaluate::characteristics::Procedure &proc) {
return false;
}
[flang] Lower basic function with scalar integer/logical return value This patch allows the lowring of simple empty function with a scalar integer or logical return value. The code in ConvertType.cpp is cleaned up as well. This file was landed together with the initial flang push and lowering was still a prototype at that time. Some more cleaning will come with follow up patches. This patch is part of the upstreaming effort from fir-dev branch. Reviewed By: PeteSteinfeld Differential Revision: https://reviews.llvm.org/D119698 Co-authored-by: Jean Perier <jperier@nvidia.com>
2022-02-14 21:31:46 +01:00
/// This is the actual part that defines the FIR interface based on the
/// characteristic. It directly mutates the CallInterface members.
template <typename T>
class Fortran::lower::CallInterfaceImpl {
using CallInterface = Fortran::lower::CallInterface<T>;
[flang] Handle lowering arguments in subroutine and function This patch adds infrsatrcutrue to be able to lower arguments in functions and subroutines. This patch is part of the upstreaming effort from fir-dev branch. Reviewed By: PeteSteinfeld Differential Revision: https://reviews.llvm.org/D119957 Co-authored-by: Eric Schweitz <eschweitz@nvidia.com> Co-authored-by: Jean Perier <jperier@nvidia.com>
2022-02-16 20:27:23 +01:00
using PassEntityBy = typename CallInterface::PassEntityBy;
using PassedEntity = typename CallInterface::PassedEntity;
[flang] Lower simple character return Handles function with character return. Character scalar results are passed as arguments in lowering so that an assumed length character function callee can access the result length. This patch is part of the upstreaming effort from fir-dev branch. Reviewed By: PeteSteinfeld, schweitz Differential Revision: https://reviews.llvm.org/D120558 Co-authored-by: Eric Schweitz <eschweitz@nvidia.com> Co-authored-by: Jean Perier <jperier@nvidia.com> Co-authored-by: V Donaldson <vdonaldson@nvidia.com>
2022-02-25 18:21:44 +01:00
using FirValue = typename CallInterface::FirValue;
[flang] Handle lowering arguments in subroutine and function This patch adds infrsatrcutrue to be able to lower arguments in functions and subroutines. This patch is part of the upstreaming effort from fir-dev branch. Reviewed By: PeteSteinfeld Differential Revision: https://reviews.llvm.org/D119957 Co-authored-by: Eric Schweitz <eschweitz@nvidia.com> Co-authored-by: Jean Perier <jperier@nvidia.com>
2022-02-16 20:27:23 +01:00
using FortranEntity = typename CallInterface::FortranEntity;
[flang] Lower basic function with scalar integer/logical return value This patch allows the lowring of simple empty function with a scalar integer or logical return value. The code in ConvertType.cpp is cleaned up as well. This file was landed together with the initial flang push and lowering was still a prototype at that time. Some more cleaning will come with follow up patches. This patch is part of the upstreaming effort from fir-dev branch. Reviewed By: PeteSteinfeld Differential Revision: https://reviews.llvm.org/D119698 Co-authored-by: Jean Perier <jperier@nvidia.com>
2022-02-14 21:31:46 +01:00
using FirPlaceHolder = typename CallInterface::FirPlaceHolder;
using Property = typename CallInterface::Property;
using TypeAndShape = Fortran::evaluate::characteristics::TypeAndShape;
[flang] Handle lowering arguments in subroutine and function This patch adds infrsatrcutrue to be able to lower arguments in functions and subroutines. This patch is part of the upstreaming effort from fir-dev branch. Reviewed By: PeteSteinfeld Differential Revision: https://reviews.llvm.org/D119957 Co-authored-by: Eric Schweitz <eschweitz@nvidia.com> Co-authored-by: Jean Perier <jperier@nvidia.com>
2022-02-16 20:27:23 +01:00
using DummyCharacteristics =
Fortran::evaluate::characteristics::DummyArgument;
[flang] Lower basic function with scalar integer/logical return value This patch allows the lowring of simple empty function with a scalar integer or logical return value. The code in ConvertType.cpp is cleaned up as well. This file was landed together with the initial flang push and lowering was still a prototype at that time. Some more cleaning will come with follow up patches. This patch is part of the upstreaming effort from fir-dev branch. Reviewed By: PeteSteinfeld Differential Revision: https://reviews.llvm.org/D119698 Co-authored-by: Jean Perier <jperier@nvidia.com>
2022-02-14 21:31:46 +01:00
public:
CallInterfaceImpl(CallInterface &i)
: interface(i), mlirContext{i.converter.getMLIRContext()} {}
void buildImplicitInterface(
const Fortran::evaluate::characteristics::Procedure &procedure) {
// Handle result
if (const std::optional<Fortran::evaluate::characteristics::FunctionResult>
&result = procedure.functionResult)
[flang] Lower character result of bind(c) function by value BIND(C) Function returning character must return it by value and not as hidden argument like done currently. This patch update the code to return it by value for both use cases. Reviewed By: PeteSteinfeld Differential Revision: https://reviews.llvm.org/D134530
2022-09-24 08:58:50 +02:00
handleImplicitResult(*result, procedure.IsBindC());
[flang] Lower basic function with scalar integer/logical return value This patch allows the lowring of simple empty function with a scalar integer or logical return value. The code in ConvertType.cpp is cleaned up as well. This file was landed together with the initial flang push and lowering was still a prototype at that time. Some more cleaning will come with follow up patches. This patch is part of the upstreaming effort from fir-dev branch. Reviewed By: PeteSteinfeld Differential Revision: https://reviews.llvm.org/D119698 Co-authored-by: Jean Perier <jperier@nvidia.com>
2022-02-14 21:31:46 +01:00
else if (interface.side().hasAlternateReturns())
addFirResult(mlir::IndexType::get(&mlirContext),
FirPlaceHolder::resultEntityPosition, Property::Value);
[flang] Handle lowering arguments in subroutine and function This patch adds infrsatrcutrue to be able to lower arguments in functions and subroutines. This patch is part of the upstreaming effort from fir-dev branch. Reviewed By: PeteSteinfeld Differential Revision: https://reviews.llvm.org/D119957 Co-authored-by: Eric Schweitz <eschweitz@nvidia.com> Co-authored-by: Jean Perier <jperier@nvidia.com>
2022-02-16 20:27:23 +01:00
// Handle arguments
const auto &argumentEntities =
getEntityContainer(interface.side().getCallDescription());
for (auto pair : llvm::zip(procedure.dummyArguments, argumentEntities)) {
const Fortran::evaluate::characteristics::DummyArgument
&argCharacteristics = std::get<0>(pair);
std::visit(
Fortran::common::visitors{
[&](const auto &dummy) {
const auto &entity = getDataObjectEntity(std::get<1>(pair));
handleImplicitDummy(&argCharacteristics, dummy, entity);
},
[&](const Fortran::evaluate::characteristics::AlternateReturn &) {
// nothing to do
},
},
argCharacteristics.u);
}
[flang] Lower basic function with scalar integer/logical return value This patch allows the lowring of simple empty function with a scalar integer or logical return value. The code in ConvertType.cpp is cleaned up as well. This file was landed together with the initial flang push and lowering was still a prototype at that time. Some more cleaning will come with follow up patches. This patch is part of the upstreaming effort from fir-dev branch. Reviewed By: PeteSteinfeld Differential Revision: https://reviews.llvm.org/D119698 Co-authored-by: Jean Perier <jperier@nvidia.com>
2022-02-14 21:31:46 +01:00
}
[flang] Handle lowering of ranked array This patch adds lowering of ranked array as function return. This patch is part of the upstreaming effort from fir-dev branch. Reviewed By: PeteSteinfeld Differential Revision: https://reviews.llvm.org/D119835 Co-authored-by: Jean Perier <jperier@nvidia.com>
2022-02-15 16:00:28 +01:00
void buildExplicitInterface(
const Fortran::evaluate::characteristics::Procedure &procedure) {
[flang] Lower character result of bind(c) function by value BIND(C) Function returning character must return it by value and not as hidden argument like done currently. This patch update the code to return it by value for both use cases. Reviewed By: PeteSteinfeld Differential Revision: https://reviews.llvm.org/D134530
2022-09-24 08:58:50 +02:00
bool isBindC = procedure.IsBindC();
[flang] Handle lowering of ranked array This patch adds lowering of ranked array as function return. This patch is part of the upstreaming effort from fir-dev branch. Reviewed By: PeteSteinfeld Differential Revision: https://reviews.llvm.org/D119835 Co-authored-by: Jean Perier <jperier@nvidia.com>
2022-02-15 16:00:28 +01:00
// Handle result
if (const std::optional<Fortran::evaluate::characteristics::FunctionResult>
&result = procedure.functionResult) {
if (result->CanBeReturnedViaImplicitInterface())
[flang] Lower character result of bind(c) function by value BIND(C) Function returning character must return it by value and not as hidden argument like done currently. This patch update the code to return it by value for both use cases. Reviewed By: PeteSteinfeld Differential Revision: https://reviews.llvm.org/D134530
2022-09-24 08:58:50 +02:00
handleImplicitResult(*result, isBindC);
[flang] Handle lowering of ranked array This patch adds lowering of ranked array as function return. This patch is part of the upstreaming effort from fir-dev branch. Reviewed By: PeteSteinfeld Differential Revision: https://reviews.llvm.org/D119835 Co-authored-by: Jean Perier <jperier@nvidia.com>
2022-02-15 16:00:28 +01:00
else
handleExplicitResult(*result);
} else if (interface.side().hasAlternateReturns()) {
addFirResult(mlir::IndexType::get(&mlirContext),
FirPlaceHolder::resultEntityPosition, Property::Value);
}
[flang] Handle allocatable dummy arguments This patch handles allocatable dummy argument lowering in function and subroutines. This patch is part of the upstreaming effort from fir-dev branch. Reviewed By: schweitz Differential Revision: https://reviews.llvm.org/D120483 Co-authored-by: Jean Perier <jperier@nvidia.com>
2022-02-24 17:16:02 +01:00
// Handle arguments
const auto &argumentEntities =
getEntityContainer(interface.side().getCallDescription());
for (auto pair : llvm::zip(procedure.dummyArguments, argumentEntities)) {
const Fortran::evaluate::characteristics::DummyArgument
&argCharacteristics = std::get<0>(pair);
std::visit(
Fortran::common::visitors{
[&](const Fortran::evaluate::characteristics::DummyDataObject
&dummy) {
const auto &entity = getDataObjectEntity(std::get<1>(pair));
if (dummy.CanBePassedViaImplicitInterface())
handleImplicitDummy(&argCharacteristics, dummy, entity);
else
handleExplicitDummy(&argCharacteristics, dummy, entity,
isBindC);
},
[&](const Fortran::evaluate::characteristics::DummyProcedure
&dummy) {
const auto &entity = getDataObjectEntity(std::get<1>(pair));
handleImplicitDummy(&argCharacteristics, dummy, entity);
},
[&](const Fortran::evaluate::characteristics::AlternateReturn &) {
// nothing to do
},
},
argCharacteristics.u);
}
[flang] Handle lowering of ranked array This patch adds lowering of ranked array as function return. This patch is part of the upstreaming effort from fir-dev branch. Reviewed By: PeteSteinfeld Differential Revision: https://reviews.llvm.org/D119835 Co-authored-by: Jean Perier <jperier@nvidia.com>
2022-02-15 16:00:28 +01:00
}
[flang] Add lowering for host association This patches adds the code to handle host association for inner subroutines and functions. This patch is part of the upstreaming effort from fir-dev branch. Reviewed By: jeanPerier Differential Revision: https://reviews.llvm.org/D121134 Co-authored-by: Eric Schweitz <eschweitz@nvidia.com> Co-authored-by: Jean Perier <jperier@nvidia.com> Co-authored-by: V Donaldson <vdonaldson@nvidia.com>
2022-03-07 19:55:48 +01:00
void appendHostAssocTupleArg(mlir::Type tupTy) {
[flang] Remove 'using namespace mlir;` from header files Currently, CGOps.h and FIROps.h contain `using namespace mlir;`. Every file that includes one of these header files (directly and transitively) will have the MLIR namespace enabled. With name-clashes within sub-projects (LLVM and MLIR, MLIR and Flang), this is not desired. Also, it is not possible to "un-use" a namespace once it is "used". Instead, we should try to limit `using namespace` to implementation files (i.e. *.cpp). This patch removes `using namespace mlir;` from header files and adjusts other files accordingly. In header and TableGen files, extra namespace qualifier is added when referring to symbols defined in MLIR. Similar approach is adopted in source files that didn't require many changes. In files that would require a lot of changes, `using namespace mlir;` is added instead. Differential Revision: https://reviews.llvm.org/D120897
2022-03-03 13:25:09 +00:00
mlir::MLIRContext *ctxt = tupTy.getContext();
[flang] Add lowering for host association This patches adds the code to handle host association for inner subroutines and functions. This patch is part of the upstreaming effort from fir-dev branch. Reviewed By: jeanPerier Differential Revision: https://reviews.llvm.org/D121134 Co-authored-by: Eric Schweitz <eschweitz@nvidia.com> Co-authored-by: Jean Perier <jperier@nvidia.com> Co-authored-by: V Donaldson <vdonaldson@nvidia.com>
2022-03-07 19:55:48 +01:00
addFirOperand(tupTy, nextPassedArgPosition(), Property::BaseAddress,
{mlir::NamedAttribute{
mlir::StringAttr::get(ctxt, fir::getHostAssocAttrName()),
mlir::UnitAttr::get(ctxt)}});
interface.passedArguments.emplace_back(
PassedEntity{PassEntityBy::BaseAddress, std::nullopt,
interface.side().getHostAssociatedTuple(), emptyValue()});
}
[flang] Use std::optional instead of llvm::Optional (NFC) This patch replaces (llvm::|)Optional< with std::optional<. I'll post a separate patch to remove #include "llvm/ADT/Optional.h". This is part of an effort to migrate from llvm::Optional to std::optional: https://discourse.llvm.org/t/deprecating-llvm-optional-x-hasvalue-getvalue-getvalueor/63716
2023-01-07 22:26:48 -08:00
static std::optional<Fortran::evaluate::DynamicType> getResultDynamicType(
[flang] Add lowering for host association This patches adds the code to handle host association for inner subroutines and functions. This patch is part of the upstreaming effort from fir-dev branch. Reviewed By: jeanPerier Differential Revision: https://reviews.llvm.org/D121134 Co-authored-by: Eric Schweitz <eschweitz@nvidia.com> Co-authored-by: Jean Perier <jperier@nvidia.com> Co-authored-by: V Donaldson <vdonaldson@nvidia.com>
2022-03-07 19:55:48 +01:00
const Fortran::evaluate::characteristics::Procedure &procedure) {
if (const std::optional<Fortran::evaluate::characteristics::FunctionResult>
&result = procedure.functionResult)
if (const auto *resultTypeAndShape = result->GetTypeAndShape())
return resultTypeAndShape->type();
[flang] Use std::nullopt instead of None (NFC) This patch mechanically replaces None with std::nullopt where the compiler would warn if None were deprecated. The intent is to reduce the amount of manual work required in migrating from Optional to std::optional. This is part of an effort to migrate from llvm::Optional to std::optional: https://discourse.llvm.org/t/deprecating-llvm-optional-x-hasvalue-getvalue-getvalueor/63716
2022-12-03 12:14:21 -08:00
return std::nullopt;
[flang] Add lowering for host association This patches adds the code to handle host association for inner subroutines and functions. This patch is part of the upstreaming effort from fir-dev branch. Reviewed By: jeanPerier Differential Revision: https://reviews.llvm.org/D121134 Co-authored-by: Eric Schweitz <eschweitz@nvidia.com> Co-authored-by: Jean Perier <jperier@nvidia.com> Co-authored-by: V Donaldson <vdonaldson@nvidia.com>
2022-03-07 19:55:48 +01:00
}
static bool mustPassLengthWithDummyProcedure(
const Fortran::evaluate::characteristics::Procedure &procedure) {
// When passing a character function designator `bar` as dummy procedure to
// `foo` (e.g. `foo(bar)`), pass the result length of `bar` to `foo` so that
// `bar` can be called inside `foo` even if its length is assumed there.
// From an ABI perspective, the extra length argument must be handled
// exactly as if passing a character object. Using an argument of
// fir.boxchar type gives the expected behavior: after codegen, the
// fir.boxchar lengths are added after all the arguments as extra value
// arguments (the extra arguments order is the order of the fir.boxchar).
// This ABI is compatible with ifort, nag, nvfortran, and xlf, but not
// gfortran. Gfortran does not pass the length and is therefore unable to
// handle later call to `bar` in `foo` where the length would be assumed. If
// the result is an array, nag and ifort and xlf still pass the length, but
// not nvfortran (and gfortran). It is not clear it is possible to call an
// array function with assumed length (f18 forbides defining such
// interfaces). Hence, passing the length is most likely useless, but stick
// with ifort/nag/xlf interface here.
[flang] Use std::optional instead of llvm::Optional (NFC) This patch replaces (llvm::|)Optional< with std::optional<. I'll post a separate patch to remove #include "llvm/ADT/Optional.h". This is part of an effort to migrate from llvm::Optional to std::optional: https://discourse.llvm.org/t/deprecating-llvm-optional-x-hasvalue-getvalue-getvalueor/63716
2023-01-07 22:26:48 -08:00
if (std::optional<Fortran::evaluate::DynamicType> type =
[flang] Add lowering for host association This patches adds the code to handle host association for inner subroutines and functions. This patch is part of the upstreaming effort from fir-dev branch. Reviewed By: jeanPerier Differential Revision: https://reviews.llvm.org/D121134 Co-authored-by: Eric Schweitz <eschweitz@nvidia.com> Co-authored-by: Jean Perier <jperier@nvidia.com> Co-authored-by: V Donaldson <vdonaldson@nvidia.com>
2022-03-07 19:55:48 +01:00
getResultDynamicType(procedure))
return type->category() == Fortran::common::TypeCategory::Character;
return false;
}
[flang] Lower basic function with scalar integer/logical return value This patch allows the lowring of simple empty function with a scalar integer or logical return value. The code in ConvertType.cpp is cleaned up as well. This file was landed together with the initial flang push and lowering was still a prototype at that time. Some more cleaning will come with follow up patches. This patch is part of the upstreaming effort from fir-dev branch. Reviewed By: PeteSteinfeld Differential Revision: https://reviews.llvm.org/D119698 Co-authored-by: Jean Perier <jperier@nvidia.com>
2022-02-14 21:31:46 +01:00
private:
void handleImplicitResult(
[flang] Lower character result of bind(c) function by value BIND(C) Function returning character must return it by value and not as hidden argument like done currently. This patch update the code to return it by value for both use cases. Reviewed By: PeteSteinfeld Differential Revision: https://reviews.llvm.org/D134530
2022-09-24 08:58:50 +02:00
const Fortran::evaluate::characteristics::FunctionResult &result,
bool isBindC) {
[flang] Lower basic function with scalar integer/logical return value This patch allows the lowring of simple empty function with a scalar integer or logical return value. The code in ConvertType.cpp is cleaned up as well. This file was landed together with the initial flang push and lowering was still a prototype at that time. Some more cleaning will come with follow up patches. This patch is part of the upstreaming effort from fir-dev branch. Reviewed By: PeteSteinfeld Differential Revision: https://reviews.llvm.org/D119698 Co-authored-by: Jean Perier <jperier@nvidia.com>
2022-02-14 21:31:46 +01:00
if (result.IsProcedurePointer())
TODO(interface.converter.getCurrentLocation(),
"procedure pointer result not yet handled");
const Fortran::evaluate::characteristics::TypeAndShape *typeAndShape =
result.GetTypeAndShape();
assert(typeAndShape && "expect type for non proc pointer result");
Fortran::evaluate::DynamicType dynamicType = typeAndShape->type();
[flang] Lower simple character return Handles function with character return. Character scalar results are passed as arguments in lowering so that an assumed length character function callee can access the result length. This patch is part of the upstreaming effort from fir-dev branch. Reviewed By: PeteSteinfeld, schweitz Differential Revision: https://reviews.llvm.org/D120558 Co-authored-by: Eric Schweitz <eschweitz@nvidia.com> Co-authored-by: Jean Perier <jperier@nvidia.com> Co-authored-by: V Donaldson <vdonaldson@nvidia.com>
2022-02-25 18:21:44 +01:00
// Character result allocated by caller and passed as hidden arguments
[flang] Lower basic function with scalar integer/logical return value This patch allows the lowring of simple empty function with a scalar integer or logical return value. The code in ConvertType.cpp is cleaned up as well. This file was landed together with the initial flang push and lowering was still a prototype at that time. Some more cleaning will come with follow up patches. This patch is part of the upstreaming effort from fir-dev branch. Reviewed By: PeteSteinfeld Differential Revision: https://reviews.llvm.org/D119698 Co-authored-by: Jean Perier <jperier@nvidia.com>
2022-02-14 21:31:46 +01:00
if (dynamicType.category() == Fortran::common::TypeCategory::Character) {
[flang] Lower character result of bind(c) function by value BIND(C) Function returning character must return it by value and not as hidden argument like done currently. This patch update the code to return it by value for both use cases. Reviewed By: PeteSteinfeld Differential Revision: https://reviews.llvm.org/D134530
2022-09-24 08:58:50 +02:00
if (isBindC) {
mlir::Type mlirType = translateDynamicType(dynamicType);
addFirResult(mlirType, FirPlaceHolder::resultEntityPosition,
Property::Value);
} else {
handleImplicitCharacterResult(dynamicType);
}
[flang] Lower basic function with scalar integer/logical return value This patch allows the lowring of simple empty function with a scalar integer or logical return value. The code in ConvertType.cpp is cleaned up as well. This file was landed together with the initial flang push and lowering was still a prototype at that time. Some more cleaning will come with follow up patches. This patch is part of the upstreaming effort from fir-dev branch. Reviewed By: PeteSteinfeld Differential Revision: https://reviews.llvm.org/D119698 Co-authored-by: Jean Perier <jperier@nvidia.com>
2022-02-14 21:31:46 +01:00
} else if (dynamicType.category() ==
Fortran::common::TypeCategory::Derived) {
[flang] Add lowering for host association This patches adds the code to handle host association for inner subroutines and functions. This patch is part of the upstreaming effort from fir-dev branch. Reviewed By: jeanPerier Differential Revision: https://reviews.llvm.org/D121134 Co-authored-by: Eric Schweitz <eschweitz@nvidia.com> Co-authored-by: Jean Perier <jperier@nvidia.com> Co-authored-by: V Donaldson <vdonaldson@nvidia.com>
2022-03-07 19:55:48 +01:00
// Derived result need to be allocated by the caller and the result value
// must be saved. Derived type in implicit interface cannot have length
// parameters.
setSaveResult();
mlir::Type mlirType = translateDynamicType(dynamicType);
addFirResult(mlirType, FirPlaceHolder::resultEntityPosition,
Property::Value);
[flang] Lower basic function with scalar integer/logical return value This patch allows the lowring of simple empty function with a scalar integer or logical return value. The code in ConvertType.cpp is cleaned up as well. This file was landed together with the initial flang push and lowering was still a prototype at that time. Some more cleaning will come with follow up patches. This patch is part of the upstreaming effort from fir-dev branch. Reviewed By: PeteSteinfeld Differential Revision: https://reviews.llvm.org/D119698 Co-authored-by: Jean Perier <jperier@nvidia.com>
2022-02-14 21:31:46 +01:00
} else {
// All result other than characters/derived are simply returned by value
// in implicit interfaces
mlir::Type mlirType =
getConverter().genType(dynamicType.category(), dynamicType.kind());
addFirResult(mlirType, FirPlaceHolder::resultEntityPosition,
Property::Value);
}
}
[flang] Lower simple character return Handles function with character return. Character scalar results are passed as arguments in lowering so that an assumed length character function callee can access the result length. This patch is part of the upstreaming effort from fir-dev branch. Reviewed By: PeteSteinfeld, schweitz Differential Revision: https://reviews.llvm.org/D120558 Co-authored-by: Eric Schweitz <eschweitz@nvidia.com> Co-authored-by: Jean Perier <jperier@nvidia.com> Co-authored-by: V Donaldson <vdonaldson@nvidia.com>
2022-02-25 18:21:44 +01:00
void
handleImplicitCharacterResult(const Fortran::evaluate::DynamicType &type) {
int resultPosition = FirPlaceHolder::resultEntityPosition;
setPassedResult(PassEntityBy::AddressAndLength,
getResultEntity(interface.side().getCallDescription()));
mlir::Type lenTy = mlir::IndexType::get(&mlirContext);
std::optional<std::int64_t> constantLen = type.knownLength();
fir::CharacterType::LenType len =
constantLen ? *constantLen : fir::CharacterType::unknownLen();
mlir::Type charRefTy = fir::ReferenceType::get(
fir::CharacterType::get(&mlirContext, type.kind(), len));
mlir::Type boxCharTy = fir::BoxCharType::get(&mlirContext, type.kind());
addFirOperand(charRefTy, resultPosition, Property::CharAddress);
addFirOperand(lenTy, resultPosition, Property::CharLength);
/// For now, also return it by boxchar
addFirResult(boxCharTy, resultPosition, Property::BoxChar);
}
[flang] Handle lowering arguments in subroutine and function This patch adds infrsatrcutrue to be able to lower arguments in functions and subroutines. This patch is part of the upstreaming effort from fir-dev branch. Reviewed By: PeteSteinfeld Differential Revision: https://reviews.llvm.org/D119957 Co-authored-by: Eric Schweitz <eschweitz@nvidia.com> Co-authored-by: Jean Perier <jperier@nvidia.com>
2022-02-16 20:27:23 +01:00
/// Return a vector with an attribute with the name of the argument if this
/// is a callee interface and the name is available. Otherwise, just return
/// an empty vector.
llvm::SmallVector<mlir::NamedAttribute>
dummyNameAttr(const FortranEntity &entity) {
if constexpr (std::is_same_v<FortranEntity,
std::optional<Fortran::common::Reference<
const Fortran::semantics::Symbol>>>) {
if (entity.has_value()) {
const Fortran::semantics::Symbol *argument = &*entity.value();
// "fir.bindc_name" is used for arguments for the sake of consistency
// with other attributes carrying surface syntax names in FIR.
return {mlir::NamedAttribute(
mlir::StringAttr::get(&mlirContext, "fir.bindc_name"),
mlir::StringAttr::get(&mlirContext,
toStringRef(argument->name())))};
}
}
return {};
}
[flang] Add lowering for host association This patches adds the code to handle host association for inner subroutines and functions. This patch is part of the upstreaming effort from fir-dev branch. Reviewed By: jeanPerier Differential Revision: https://reviews.llvm.org/D121134 Co-authored-by: Eric Schweitz <eschweitz@nvidia.com> Co-authored-by: Jean Perier <jperier@nvidia.com> Co-authored-by: V Donaldson <vdonaldson@nvidia.com>
2022-03-07 19:55:48 +01:00
void handleImplicitDummy(
const DummyCharacteristics *characteristics,
const Fortran::evaluate::characteristics::DummyDataObject &obj,
const FortranEntity &entity) {
Fortran::evaluate::DynamicType dynamicType = obj.type.type();
if (dynamicType.category() == Fortran::common::TypeCategory::Character) {
mlir::Type boxCharTy =
fir::BoxCharType::get(&mlirContext, dynamicType.kind());
addFirOperand(boxCharTy, nextPassedArgPosition(), Property::BoxChar,
dummyNameAttr(entity));
addPassedArg(PassEntityBy::BoxChar, entity, characteristics);
} else {
// non-PDT derived type allowed in implicit interface.
mlir::Type type = translateDynamicType(dynamicType);
fir::SequenceType::Shape bounds = getBounds(obj.type.shape());
if (!bounds.empty())
type = fir::SequenceType::get(bounds, type);
mlir::Type refType = fir::ReferenceType::get(type);
addFirOperand(refType, nextPassedArgPosition(), Property::BaseAddress,
dummyNameAttr(entity));
addPassedArg(PassEntityBy::BaseAddress, entity, characteristics);
}
}
[flang] Handle allocatable dummy arguments This patch handles allocatable dummy argument lowering in function and subroutines. This patch is part of the upstreaming effort from fir-dev branch. Reviewed By: schweitz Differential Revision: https://reviews.llvm.org/D120483 Co-authored-by: Jean Perier <jperier@nvidia.com>
2022-02-24 17:16:02 +01:00
// Define when an explicit argument must be passed in a fir.box.
bool dummyRequiresBox(
const Fortran::evaluate::characteristics::DummyDataObject &obj) {
using ShapeAttr = Fortran::evaluate::characteristics::TypeAndShape::Attr;
using ShapeAttrs = Fortran::evaluate::characteristics::TypeAndShape::Attrs;
constexpr ShapeAttrs shapeRequiringBox = {
ShapeAttr::AssumedShape, ShapeAttr::DeferredShape,
ShapeAttr::AssumedRank, ShapeAttr::Coarray};
if ((obj.type.attrs() & shapeRequiringBox).any())
// Need to pass shape/coshape info in fir.box.
return true;
[flang] Change TYPE(*) arrays passing convention - Fix the BIND(C) assumed-shape case: TYPE(*) assumed shape are passed via CFI_cdesc_t according to Fortran 2018 standard 18.3.6 point 2 (5). - Align the none BIND(C) case with the BIND(C) case. There is little point passing TYPE(*) assumed size via descriptor, use a simple address. C710 ensures there is no way the knowledge of the actual type will be required when manipulating the dummy. Differential Revision: https://reviews.llvm.org/D148130
2023-04-14 08:43:33 +02:00
if (obj.type.type().IsPolymorphic() && !obj.type.type().IsAssumedType())
[flang] Handle allocatable dummy arguments This patch handles allocatable dummy argument lowering in function and subroutines. This patch is part of the upstreaming effort from fir-dev branch. Reviewed By: schweitz Differential Revision: https://reviews.llvm.org/D120483 Co-authored-by: Jean Perier <jperier@nvidia.com>
2022-02-24 17:16:02 +01:00
// Need to pass dynamic type info in fir.box.
return true;
if (const Fortran::semantics::DerivedTypeSpec *derived =
Fortran::evaluate::GetDerivedTypeSpec(obj.type.type()))
[flang] Do not pass derived type by descriptor when not needed A missing "!" in the call interface lowering caused all derived type arguments without length parameters that require and explicit interface to be passed via fir.box (runtime descriptor). This was not the intent: there is no point passing a simple derived type scalars or explicit shapes by descriptor just because they have an attribute like TARGET. This would actually be problematic with existing code that is not always 100% compliant: some code implicitly calls procedures with TARGET dummy attributes (this is not something a compiler can enforce if the call and procedure definition are not in the same file). Add a Scope::IsDerivedTypeWithLengthParameter to avoid passing derived types with only kind parameters by descriptor. There is no point, the callee knows about the kind parameter values. Differential Revision: https://reviews.llvm.org/D123990
2022-04-20 09:57:41 +02:00
if (const Fortran::semantics::Scope *scope = derived->scope())
// Need to pass length type parameters in fir.box if any.
return scope->IsDerivedTypeWithLengthParameter();
[flang] Handle allocatable dummy arguments This patch handles allocatable dummy argument lowering in function and subroutines. This patch is part of the upstreaming effort from fir-dev branch. Reviewed By: schweitz Differential Revision: https://reviews.llvm.org/D120483 Co-authored-by: Jean Perier <jperier@nvidia.com>
2022-02-24 17:16:02 +01:00
return false;
}
mlir::Type
translateDynamicType(const Fortran::evaluate::DynamicType &dynamicType) {
Fortran::common::TypeCategory cat = dynamicType.category();
// DERIVED
if (cat == Fortran::common::TypeCategory::Derived) {
[flang] Keep current polymorphic implementation under a flag It is useful for couple of test suite like NAG to keep failing with a TODO until the polymorphic entities is implemented all the way done to codegen. This pass adds a flag to LoweringOptions for experimental development. This flag is off by default and can be enable in `bbc` with `-polymorphic-type`. Options can be added in the driver and tco when needed. Reviewed By: PeteSteinfeld Differential Revision: https://reviews.llvm.org/D135283
2022-10-05 23:04:59 +02:00
// TODO is kept under experimental flag until feature is complete.
if (dynamicType.IsPolymorphic() &&
[NFC][flang] Lowering options clean-up. This change-set defines the LoweringOptions the same way other options are defined in Flang. Differential Revision: https://reviews.llvm.org/D137207
2022-11-01 15:12:43 -07:00
!getConverter().getLoweringOptions().getPolymorphicTypeImpl())
[flang] Keep current polymorphic implementation under a flag It is useful for couple of test suite like NAG to keep failing with a TODO until the polymorphic entities is implemented all the way done to codegen. This pass adds a flag to LoweringOptions for experimental development. This flag is off by default and can be enable in `bbc` with `-polymorphic-type`. Options can be added in the driver and tco when needed. Reviewed By: PeteSteinfeld Differential Revision: https://reviews.llvm.org/D135283
2022-10-05 23:04:59 +02:00
TODO(interface.converter.getCurrentLocation(),
"support for polymorphic types");
[flang] Lower polymorphic entities types in dummy argument and function result This patch updates lowering to produce the correct fir.class types for various polymorphic and unlimited polymoprhic entities cases. This is only the lowering. Some TODOs have been added to the CodeGen part to avoid errors since this part still need to be updated as well. The fir.class<*> representation for unlimited polymorphic entities mentioned in the document has been updated to fir.class<none> to avoid useless work in pretty parse/printer. This patch is part of the implementation of the poltymorphic entities. https://github.com/llvm/llvm-project/blob/main/flang/docs/PolymorphicEntities.md Depends on D134957 Reviewed By: jeanPerier Differential Revision: https://reviews.llvm.org/D134959
2022-10-04 09:42:39 +02:00
if (dynamicType.IsUnlimitedPolymorphic())
return mlir::NoneType::get(&mlirContext);
[flang] Lower basic derived types This patch lowers basic derived type to FIR. This patch is part of the upstreaming effort from fir-dev branch. Reviewed By: PeteSteinfeld Differential Revision: https://reviews.llvm.org/D121383 Co-authored-by: V Donaldson <vdonaldson@nvidia.com> Co-authored-by: Jean Perier <jperier@nvidia.com> Co-authored-by: Eric Schweitz <eschweitz@nvidia.com>
2022-03-10 18:06:20 +01:00
return getConverter().genType(dynamicType.GetDerivedTypeSpec());
[flang] Handle allocatable dummy arguments This patch handles allocatable dummy argument lowering in function and subroutines. This patch is part of the upstreaming effort from fir-dev branch. Reviewed By: schweitz Differential Revision: https://reviews.llvm.org/D120483 Co-authored-by: Jean Perier <jperier@nvidia.com>
2022-02-24 17:16:02 +01:00
}
// CHARACTER with compile time constant length.
if (cat == Fortran::common::TypeCategory::Character)
[flang] Add test for allocatable on the callee side This patch adds couple of tests for allocatable on the callee side. Lowering for some missing underlying features is added as well. This patch is part of the upstreaming effort from fir-dev branch. Depends on D120744 Reviewed By: PeteSteinfeld, schweitz Differential Revision: https://reviews.llvm.org/D120746 Co-authored-by: Eric Schweitz <eschweitz@nvidia.com> Co-authored-by: Jean Perier <jperier@nvidia.com> Co-authored-by: V Donaldson <vdonaldson@nvidia.com>
2022-03-01 22:57:58 +01:00
if (std::optional<std::int64_t> constantLen =
toInt64(dynamicType.GetCharLength()))
return getConverter().genType(cat, dynamicType.kind(), {*constantLen});
[flang] Handle allocatable dummy arguments This patch handles allocatable dummy argument lowering in function and subroutines. This patch is part of the upstreaming effort from fir-dev branch. Reviewed By: schweitz Differential Revision: https://reviews.llvm.org/D120483 Co-authored-by: Jean Perier <jperier@nvidia.com>
2022-02-24 17:16:02 +01:00
// INTEGER, REAL, LOGICAL, COMPLEX, and CHARACTER with dynamic length.
return getConverter().genType(cat, dynamicType.kind());
}
void handleExplicitDummy(
const DummyCharacteristics *characteristics,
const Fortran::evaluate::characteristics::DummyDataObject &obj,
const FortranEntity &entity, bool isBindC) {
using Attrs = Fortran::evaluate::characteristics::DummyDataObject::Attr;
bool isValueAttr = false;
[[maybe_unused]] mlir::Location loc =
interface.converter.getCurrentLocation();
llvm::SmallVector<mlir::NamedAttribute> attrs = dummyNameAttr(entity);
auto addMLIRAttr = [&](llvm::StringRef attr) {
attrs.emplace_back(mlir::StringAttr::get(&mlirContext, attr),
mlir::UnitAttr::get(&mlirContext));
};
if (obj.attrs.test(Attrs::Optional))
addMLIRAttr(fir::getOptionalAttrName());
if (obj.attrs.test(Attrs::Asynchronous))
[flang][NFC] Unify todo messages This patch is part of the upstreaming effort from fir-dev branch. Reviewed By: jeanPerier Differential Revision: https://reviews.llvm.org/D128186 Co-authored-by: Peter Steinfeld <psteinfeld@nvidia.com>
2022-06-20 15:43:44 +02:00
TODO(loc, "ASYNCHRONOUS in procedure interface");
[flang] Handle allocatable dummy arguments This patch handles allocatable dummy argument lowering in function and subroutines. This patch is part of the upstreaming effort from fir-dev branch. Reviewed By: schweitz Differential Revision: https://reviews.llvm.org/D120483 Co-authored-by: Jean Perier <jperier@nvidia.com>
2022-02-24 17:16:02 +01:00
if (obj.attrs.test(Attrs::Contiguous))
addMLIRAttr(fir::getContiguousAttrName());
if (obj.attrs.test(Attrs::Value))
isValueAttr = true; // TODO: do we want an mlir::Attribute as well?
if (obj.attrs.test(Attrs::Volatile))
[flang][NFC] Unify todo messages This patch is part of the upstreaming effort from fir-dev branch. Reviewed By: jeanPerier Differential Revision: https://reviews.llvm.org/D128186 Co-authored-by: Peter Steinfeld <psteinfeld@nvidia.com>
2022-06-20 15:43:44 +02:00
TODO(loc, "VOLATILE in procedure interface");
[flang] Handle allocatable dummy arguments This patch handles allocatable dummy argument lowering in function and subroutines. This patch is part of the upstreaming effort from fir-dev branch. Reviewed By: schweitz Differential Revision: https://reviews.llvm.org/D120483 Co-authored-by: Jean Perier <jperier@nvidia.com>
2022-02-24 17:16:02 +01:00
if (obj.attrs.test(Attrs::Target))
addMLIRAttr(fir::getTargetAttrName());
// TODO: intents that require special care (e.g finalization)
using ShapeAttr = Fortran::evaluate::characteristics::TypeAndShape::Attr;
const Fortran::evaluate::characteristics::TypeAndShape::Attrs &shapeAttrs =
obj.type.attrs();
if (shapeAttrs.test(ShapeAttr::AssumedRank))
[flang][NFC] Unify todo messages This patch is part of the upstreaming effort from fir-dev branch. Reviewed By: jeanPerier Differential Revision: https://reviews.llvm.org/D128186 Co-authored-by: Peter Steinfeld <psteinfeld@nvidia.com>
2022-06-20 15:43:44 +02:00
TODO(loc, "assumed rank in procedure interface");
[flang] Handle allocatable dummy arguments This patch handles allocatable dummy argument lowering in function and subroutines. This patch is part of the upstreaming effort from fir-dev branch. Reviewed By: schweitz Differential Revision: https://reviews.llvm.org/D120483 Co-authored-by: Jean Perier <jperier@nvidia.com>
2022-02-24 17:16:02 +01:00
if (shapeAttrs.test(ShapeAttr::Coarray))
[flang][NFC] Unify todo messages This patch is part of the upstreaming effort from fir-dev branch. Reviewed By: jeanPerier Differential Revision: https://reviews.llvm.org/D128186 Co-authored-by: Peter Steinfeld <psteinfeld@nvidia.com>
2022-06-20 15:43:44 +02:00
TODO(loc, "coarray in procedure interface");
[flang] Handle allocatable dummy arguments This patch handles allocatable dummy argument lowering in function and subroutines. This patch is part of the upstreaming effort from fir-dev branch. Reviewed By: schweitz Differential Revision: https://reviews.llvm.org/D120483 Co-authored-by: Jean Perier <jperier@nvidia.com>
2022-02-24 17:16:02 +01:00
// So far assume that if the argument cannot be passed by implicit interface
// it must be by box. That may no be always true (e.g for simple optionals)
Fortran::evaluate::DynamicType dynamicType = obj.type.type();
mlir::Type type = translateDynamicType(dynamicType);
fir::SequenceType::Shape bounds = getBounds(obj.type.shape());
if (!bounds.empty())
type = fir::SequenceType::get(bounds, type);
if (obj.attrs.test(Attrs::Allocatable))
type = fir::HeapType::get(type);
if (obj.attrs.test(Attrs::Pointer))
type = fir::PointerType::get(type);
[flang] Lower TYPE(*) as fir.box<none> This patch lowers `TYPE(*)` correctly to fir.box<none>. Reviewed By: jeanPerier Differential Revision: https://reviews.llvm.org/D135141
2022-10-04 21:29:28 +02:00
mlir::Type boxType = fir::wrapInClassOrBoxType(
type, obj.type.type().IsPolymorphic(), obj.type.type().IsAssumedType());
[flang] Handle allocatable dummy arguments This patch handles allocatable dummy argument lowering in function and subroutines. This patch is part of the upstreaming effort from fir-dev branch. Reviewed By: schweitz Differential Revision: https://reviews.llvm.org/D120483 Co-authored-by: Jean Perier <jperier@nvidia.com>
2022-02-24 17:16:02 +01:00
[flang] Change TYPE(*) arrays passing convention - Fix the BIND(C) assumed-shape case: TYPE(*) assumed shape are passed via CFI_cdesc_t according to Fortran 2018 standard 18.3.6 point 2 (5). - Align the none BIND(C) case with the BIND(C) case. There is little point passing TYPE(*) assumed size via descriptor, use a simple address. C710 ensures there is no way the knowledge of the actual type will be required when manipulating the dummy. Differential Revision: https://reviews.llvm.org/D148130
2023-04-14 08:43:33 +02:00
if (obj.attrs.test(Attrs::Allocatable) || obj.attrs.test(Attrs::Pointer)) {
[flang] Lower polymorphic entities types in dummy argument and function result This patch updates lowering to produce the correct fir.class types for various polymorphic and unlimited polymoprhic entities cases. This is only the lowering. Some TODOs have been added to the CodeGen part to avoid errors since this part still need to be updated as well. The fir.class<*> representation for unlimited polymorphic entities mentioned in the document has been updated to fir.class<none> to avoid useless work in pretty parse/printer. This patch is part of the implementation of the poltymorphic entities. https://github.com/llvm/llvm-project/blob/main/flang/docs/PolymorphicEntities.md Depends on D134957 Reviewed By: jeanPerier Differential Revision: https://reviews.llvm.org/D134959
2022-10-04 09:42:39 +02:00
// Pass as fir.ref<fir.box> or fir.ref<fir.class>
[flang] Handle allocatable dummy arguments This patch handles allocatable dummy argument lowering in function and subroutines. This patch is part of the upstreaming effort from fir-dev branch. Reviewed By: schweitz Differential Revision: https://reviews.llvm.org/D120483 Co-authored-by: Jean Perier <jperier@nvidia.com>
2022-02-24 17:16:02 +01:00
mlir::Type boxRefType = fir::ReferenceType::get(boxType);
addFirOperand(boxRefType, nextPassedArgPosition(), Property::MutableBox,
attrs);
addPassedArg(PassEntityBy::MutableBox, entity, characteristics);
} else if (dummyRequiresBox(obj)) {
[flang] Lower polymorphic entities types in dummy argument and function result This patch updates lowering to produce the correct fir.class types for various polymorphic and unlimited polymoprhic entities cases. This is only the lowering. Some TODOs have been added to the CodeGen part to avoid errors since this part still need to be updated as well. The fir.class<*> representation for unlimited polymorphic entities mentioned in the document has been updated to fir.class<none> to avoid useless work in pretty parse/printer. This patch is part of the implementation of the poltymorphic entities. https://github.com/llvm/llvm-project/blob/main/flang/docs/PolymorphicEntities.md Depends on D134957 Reviewed By: jeanPerier Differential Revision: https://reviews.llvm.org/D134959
2022-10-04 09:42:39 +02:00
// Pass as fir.box or fir.class
[flang][NFC] Add todo in CallInterface Add a todo for assumed shape dummy argument with VALUE attribute since this is not implemented yet. This patch is part of the upstreaming effort from fir-dev branch. Reviewed By: jeanPerier Differential Revision: https://reviews.llvm.org/D121581
2022-03-14 10:41:50 +01:00
if (isValueAttr)
TODO(loc, "assumed shape dummy argument with VALUE attribute");
[flang] Handle allocatable dummy arguments This patch handles allocatable dummy argument lowering in function and subroutines. This patch is part of the upstreaming effort from fir-dev branch. Reviewed By: schweitz Differential Revision: https://reviews.llvm.org/D120483 Co-authored-by: Jean Perier <jperier@nvidia.com>
2022-02-24 17:16:02 +01:00
addFirOperand(boxType, nextPassedArgPosition(), Property::Box, attrs);
addPassedArg(PassEntityBy::Box, entity, characteristics);
} else if (dynamicType.category() ==
Fortran::common::TypeCategory::Character) {
// Pass as fir.box_char
mlir::Type boxCharTy =
fir::BoxCharType::get(&mlirContext, dynamicType.kind());
addFirOperand(boxCharTy, nextPassedArgPosition(), Property::BoxChar,
attrs);
addPassedArg(isValueAttr ? PassEntityBy::CharBoxValueAttribute
: PassEntityBy::BoxChar,
entity, characteristics);
} else {
[flang] Fix the interface for numerical/logical scalar with VALUE attribute Programmers may use procedure without BIND(C) attribute to interoperate with C code. For numerical/logical scalar with VALUE attribute, pass the argument by value so that the behavior is consistent with gfortran or nvfortran. The argument with the OPTIONAL attribute cannot be passed by value since the actual argument may be absent. For the derived type, pass-by-value is not supported yet, so pass the argument by reference for now. Reviewed By: jeanPerier Differential Revision: https://reviews.llvm.org/D136260
2022-10-22 09:15:02 +08:00
// Pass as fir.ref unless it's by VALUE and BIND(C). Also pass-by-value
// for numerical/logical scalar without OPTIONAL so that the behavior is
// consistent with gfortran/nvfortran.
// TODO: pass-by-value for derived type is not supported yet
[flang] Handle allocatable dummy arguments This patch handles allocatable dummy argument lowering in function and subroutines. This patch is part of the upstreaming effort from fir-dev branch. Reviewed By: schweitz Differential Revision: https://reviews.llvm.org/D120483 Co-authored-by: Jean Perier <jperier@nvidia.com>
2022-02-24 17:16:02 +01:00
mlir::Type passType = fir::ReferenceType::get(type);
PassEntityBy passBy = PassEntityBy::BaseAddress;
Property prop = Property::BaseAddress;
if (isValueAttr) {
[flang][RFC] Change the interface for non-BIND(C) CPTR type with VALUE attribute When the `type(c_ptr/c_funptr)` argument has value attribute in non-BIND(C) procedure, it is passed by VALUE in gfortran. ifort does not do this. Be consistent with gfortran. Fix #58756. Reviewed By: PeteSteinfeld, jeanPerier Differential Revision: https://reviews.llvm.org/D137237
2022-11-04 22:19:38 +08:00
bool isBuiltinCptrType = fir::isa_builtin_cptr_type(type);
[flang] Fix the interface for numerical/logical scalar with VALUE attribute Programmers may use procedure without BIND(C) attribute to interoperate with C code. For numerical/logical scalar with VALUE attribute, pass the argument by value so that the behavior is consistent with gfortran or nvfortran. The argument with the OPTIONAL attribute cannot be passed by value since the actual argument may be absent. For the derived type, pass-by-value is not supported yet, so pass the argument by reference for now. Reviewed By: jeanPerier Differential Revision: https://reviews.llvm.org/D136260
2022-10-22 09:15:02 +08:00
if (isBindC || (!type.isa<fir::SequenceType>() &&
!obj.attrs.test(Attrs::Optional) &&
[flang][RFC] Change the interface for non-BIND(C) CPTR type with VALUE attribute When the `type(c_ptr/c_funptr)` argument has value attribute in non-BIND(C) procedure, it is passed by VALUE in gfortran. ifort does not do this. Be consistent with gfortran. Fix #58756. Reviewed By: PeteSteinfeld, jeanPerier Differential Revision: https://reviews.llvm.org/D137237
2022-11-04 22:19:38 +08:00
(dynamicType.category() !=
Fortran::common::TypeCategory::Derived ||
isBuiltinCptrType))) {
[flang] Handle allocatable dummy arguments This patch handles allocatable dummy argument lowering in function and subroutines. This patch is part of the upstreaming effort from fir-dev branch. Reviewed By: schweitz Differential Revision: https://reviews.llvm.org/D120483 Co-authored-by: Jean Perier <jperier@nvidia.com>
2022-02-24 17:16:02 +01:00
passBy = PassEntityBy::Value;
prop = Property::Value;
[flang][RFC] Change the interface for non-BIND(C) CPTR type with VALUE attribute When the `type(c_ptr/c_funptr)` argument has value attribute in non-BIND(C) procedure, it is passed by VALUE in gfortran. ifort does not do this. Be consistent with gfortran. Fix #58756. Reviewed By: PeteSteinfeld, jeanPerier Differential Revision: https://reviews.llvm.org/D137237
2022-11-04 22:19:38 +08:00
if (isBuiltinCptrType) {
[flang] Support lowering of C_PTR and C_FUNPTR argument with VALUE attribute As Fortran 2018 18.3.2, C_PTR is interoperable with any C object pointer type. C_FUNPTR is interoperable with any C function pointer type. As 18.3.6, a C pointer can correspond to a Fortran dummy argument of type C_PTR with the VALUE attribute. The interface for type(C_PTR)/type(C_FUNPTR) argument with value attribute is different from the the usual derived type. For type(C_PTR) or type(C_FUNPTR), the component is the address, and the interface is a pointer even with VALUE attribute. For a usual derived type such as the drived type with the component of integer 64, the interface is a i64 value when it has VALUE attribute on aarch64 linux. To lower the type(C_PTR)/type(C_FUNPTR) argument with value attribute, get the value of the component of the type(C_PTR)/type(C_FUNPTR), which is the address, and then convert it to the pointer and pass it. Reviewed By: Jean Perier Differential Revision: https://reviews.llvm.org/D131583
2022-08-29 22:29:34 +08:00
auto recTy = type.dyn_cast<fir::RecordType>();
mlir::Type fieldTy = recTy.getTypeList()[0].second;
passType = fir::ReferenceType::get(fieldTy);
} else {
passType = type;
}
[flang] Handle allocatable dummy arguments This patch handles allocatable dummy argument lowering in function and subroutines. This patch is part of the upstreaming effort from fir-dev branch. Reviewed By: schweitz Differential Revision: https://reviews.llvm.org/D120483 Co-authored-by: Jean Perier <jperier@nvidia.com>
2022-02-24 17:16:02 +01:00
} else {
passBy = PassEntityBy::BaseAddressValueAttribute;
}
}
addFirOperand(passType, nextPassedArgPosition(), prop, attrs);
addPassedArg(passBy, entity, characteristics);
}
}
[flang] Handle lowering arguments in subroutine and function This patch adds infrsatrcutrue to be able to lower arguments in functions and subroutines. This patch is part of the upstreaming effort from fir-dev branch. Reviewed By: PeteSteinfeld Differential Revision: https://reviews.llvm.org/D119957 Co-authored-by: Eric Schweitz <eschweitz@nvidia.com> Co-authored-by: Jean Perier <jperier@nvidia.com>
2022-02-16 20:27:23 +01:00
void handleImplicitDummy(
const DummyCharacteristics *characteristics,
[flang] Add lowering for host association This patches adds the code to handle host association for inner subroutines and functions. This patch is part of the upstreaming effort from fir-dev branch. Reviewed By: jeanPerier Differential Revision: https://reviews.llvm.org/D121134 Co-authored-by: Eric Schweitz <eschweitz@nvidia.com> Co-authored-by: Jean Perier <jperier@nvidia.com> Co-authored-by: V Donaldson <vdonaldson@nvidia.com>
2022-03-07 19:55:48 +01:00
const Fortran::evaluate::characteristics::DummyProcedure &proc,
[flang] Handle lowering arguments in subroutine and function This patch adds infrsatrcutrue to be able to lower arguments in functions and subroutines. This patch is part of the upstreaming effort from fir-dev branch. Reviewed By: PeteSteinfeld Differential Revision: https://reviews.llvm.org/D119957 Co-authored-by: Eric Schweitz <eschweitz@nvidia.com> Co-authored-by: Jean Perier <jperier@nvidia.com>
2022-02-16 20:27:23 +01:00
const FortranEntity &entity) {
[flang] Add lowering for host association This patches adds the code to handle host association for inner subroutines and functions. This patch is part of the upstreaming effort from fir-dev branch. Reviewed By: jeanPerier Differential Revision: https://reviews.llvm.org/D121134 Co-authored-by: Eric Schweitz <eschweitz@nvidia.com> Co-authored-by: Jean Perier <jperier@nvidia.com> Co-authored-by: V Donaldson <vdonaldson@nvidia.com>
2022-03-07 19:55:48 +01:00
if (proc.attrs.test(
Fortran::evaluate::characteristics::DummyProcedure::Attr::Pointer))
TODO(interface.converter.getCurrentLocation(),
"procedure pointer arguments");
// Otherwise, it is a dummy procedure.
const Fortran::evaluate::characteristics::Procedure &procedure =
proc.procedure.value();
mlir::Type funcType =
getProcedureDesignatorType(&procedure, interface.converter);
[flang] Use std::optional instead of llvm::Optional (NFC) This patch replaces (llvm::|)Optional< with std::optional<. I'll post a separate patch to remove #include "llvm/ADT/Optional.h". This is part of an effort to migrate from llvm::Optional to std::optional: https://discourse.llvm.org/t/deprecating-llvm-optional-x-hasvalue-getvalue-getvalueor/63716
2023-01-07 22:26:48 -08:00
std::optional<Fortran::evaluate::DynamicType> resultTy =
[flang] Add lowering for host association This patches adds the code to handle host association for inner subroutines and functions. This patch is part of the upstreaming effort from fir-dev branch. Reviewed By: jeanPerier Differential Revision: https://reviews.llvm.org/D121134 Co-authored-by: Eric Schweitz <eschweitz@nvidia.com> Co-authored-by: Jean Perier <jperier@nvidia.com> Co-authored-by: V Donaldson <vdonaldson@nvidia.com>
2022-03-07 19:55:48 +01:00
getResultDynamicType(procedure);
if (resultTy && mustPassLengthWithDummyProcedure(procedure)) {
// The result length of dummy procedures that are character functions must
// be passed so that the dummy procedure can be called if it has assumed
// length on the callee side.
mlir::Type tupleType =
fir::factory::getCharacterProcedureTupleType(funcType);
llvm::StringRef charProcAttr = fir::getCharacterProcedureDummyAttrName();
addFirOperand(tupleType, nextPassedArgPosition(), Property::CharProcTuple,
{mlir::NamedAttribute{
mlir::StringAttr::get(&mlirContext, charProcAttr),
mlir::UnitAttr::get(&mlirContext)}});
addPassedArg(PassEntityBy::CharProcTuple, entity, characteristics);
return;
[flang] Handle lowering arguments in subroutine and function This patch adds infrsatrcutrue to be able to lower arguments in functions and subroutines. This patch is part of the upstreaming effort from fir-dev branch. Reviewed By: PeteSteinfeld Differential Revision: https://reviews.llvm.org/D119957 Co-authored-by: Eric Schweitz <eschweitz@nvidia.com> Co-authored-by: Jean Perier <jperier@nvidia.com>
2022-02-16 20:27:23 +01:00
}
[flang] Add lowering for host association This patches adds the code to handle host association for inner subroutines and functions. This patch is part of the upstreaming effort from fir-dev branch. Reviewed By: jeanPerier Differential Revision: https://reviews.llvm.org/D121134 Co-authored-by: Eric Schweitz <eschweitz@nvidia.com> Co-authored-by: Jean Perier <jperier@nvidia.com> Co-authored-by: V Donaldson <vdonaldson@nvidia.com>
2022-03-07 19:55:48 +01:00
addFirOperand(funcType, nextPassedArgPosition(), Property::BaseAddress);
addPassedArg(PassEntityBy::BaseAddress, entity, characteristics);
[flang] Handle lowering arguments in subroutine and function This patch adds infrsatrcutrue to be able to lower arguments in functions and subroutines. This patch is part of the upstreaming effort from fir-dev branch. Reviewed By: PeteSteinfeld Differential Revision: https://reviews.llvm.org/D119957 Co-authored-by: Eric Schweitz <eschweitz@nvidia.com> Co-authored-by: Jean Perier <jperier@nvidia.com>
2022-02-16 20:27:23 +01:00
}
[flang] Add lowering for host association This patches adds the code to handle host association for inner subroutines and functions. This patch is part of the upstreaming effort from fir-dev branch. Reviewed By: jeanPerier Differential Revision: https://reviews.llvm.org/D121134 Co-authored-by: Eric Schweitz <eschweitz@nvidia.com> Co-authored-by: Jean Perier <jperier@nvidia.com> Co-authored-by: V Donaldson <vdonaldson@nvidia.com>
2022-03-07 19:55:48 +01:00
void handleExplicitResult(
const Fortran::evaluate::characteristics::FunctionResult &result) {
using Attr = Fortran::evaluate::characteristics::FunctionResult::Attr;
if (result.IsProcedurePointer())
TODO(interface.converter.getCurrentLocation(),
"procedure pointer results");
const Fortran::evaluate::characteristics::TypeAndShape *typeAndShape =
result.GetTypeAndShape();
assert(typeAndShape && "expect type for non proc pointer result");
mlir::Type mlirType = translateDynamicType(typeAndShape->type());
fir::SequenceType::Shape bounds = getBounds(typeAndShape->shape());
[flang] Lower polymorphic entities types in dummy argument and function result This patch updates lowering to produce the correct fir.class types for various polymorphic and unlimited polymoprhic entities cases. This is only the lowering. Some TODOs have been added to the CodeGen part to avoid errors since this part still need to be updated as well. The fir.class<*> representation for unlimited polymorphic entities mentioned in the document has been updated to fir.class<none> to avoid useless work in pretty parse/printer. This patch is part of the implementation of the poltymorphic entities. https://github.com/llvm/llvm-project/blob/main/flang/docs/PolymorphicEntities.md Depends on D134957 Reviewed By: jeanPerier Differential Revision: https://reviews.llvm.org/D134959
2022-10-04 09:42:39 +02:00
const auto *resTypeAndShape{result.GetTypeAndShape()};
bool resIsPolymorphic =
resTypeAndShape && resTypeAndShape->type().IsPolymorphic();
[flang] Lower TYPE(*) as fir.box<none> This patch lowers `TYPE(*)` correctly to fir.box<none>. Reviewed By: jeanPerier Differential Revision: https://reviews.llvm.org/D135141
2022-10-04 21:29:28 +02:00
bool resIsAssumedType =
resTypeAndShape && resTypeAndShape->type().IsAssumedType();
[flang] Add lowering for host association This patches adds the code to handle host association for inner subroutines and functions. This patch is part of the upstreaming effort from fir-dev branch. Reviewed By: jeanPerier Differential Revision: https://reviews.llvm.org/D121134 Co-authored-by: Eric Schweitz <eschweitz@nvidia.com> Co-authored-by: Jean Perier <jperier@nvidia.com> Co-authored-by: V Donaldson <vdonaldson@nvidia.com>
2022-03-07 19:55:48 +01:00
if (!bounds.empty())
mlirType = fir::SequenceType::get(bounds, mlirType);
if (result.attrs.test(Attr::Allocatable))
[flang] Lower polymorphic entities types in dummy argument and function result This patch updates lowering to produce the correct fir.class types for various polymorphic and unlimited polymoprhic entities cases. This is only the lowering. Some TODOs have been added to the CodeGen part to avoid errors since this part still need to be updated as well. The fir.class<*> representation for unlimited polymorphic entities mentioned in the document has been updated to fir.class<none> to avoid useless work in pretty parse/printer. This patch is part of the implementation of the poltymorphic entities. https://github.com/llvm/llvm-project/blob/main/flang/docs/PolymorphicEntities.md Depends on D134957 Reviewed By: jeanPerier Differential Revision: https://reviews.llvm.org/D134959
2022-10-04 09:42:39 +02:00
mlirType = fir::wrapInClassOrBoxType(fir::HeapType::get(mlirType),
[flang] Lower TYPE(*) as fir.box<none> This patch lowers `TYPE(*)` correctly to fir.box<none>. Reviewed By: jeanPerier Differential Revision: https://reviews.llvm.org/D135141
2022-10-04 21:29:28 +02:00
resIsPolymorphic, resIsAssumedType);
[flang] Add lowering for host association This patches adds the code to handle host association for inner subroutines and functions. This patch is part of the upstreaming effort from fir-dev branch. Reviewed By: jeanPerier Differential Revision: https://reviews.llvm.org/D121134 Co-authored-by: Eric Schweitz <eschweitz@nvidia.com> Co-authored-by: Jean Perier <jperier@nvidia.com> Co-authored-by: V Donaldson <vdonaldson@nvidia.com>
2022-03-07 19:55:48 +01:00
if (result.attrs.test(Attr::Pointer))
[flang] Lower polymorphic entities types in dummy argument and function result This patch updates lowering to produce the correct fir.class types for various polymorphic and unlimited polymoprhic entities cases. This is only the lowering. Some TODOs have been added to the CodeGen part to avoid errors since this part still need to be updated as well. The fir.class<*> representation for unlimited polymorphic entities mentioned in the document has been updated to fir.class<none> to avoid useless work in pretty parse/printer. This patch is part of the implementation of the poltymorphic entities. https://github.com/llvm/llvm-project/blob/main/flang/docs/PolymorphicEntities.md Depends on D134957 Reviewed By: jeanPerier Differential Revision: https://reviews.llvm.org/D134959
2022-10-04 09:42:39 +02:00
mlirType = fir::wrapInClassOrBoxType(fir::PointerType::get(mlirType),
[flang] Lower TYPE(*) as fir.box<none> This patch lowers `TYPE(*)` correctly to fir.box<none>. Reviewed By: jeanPerier Differential Revision: https://reviews.llvm.org/D135141
2022-10-04 21:29:28 +02:00
resIsPolymorphic, resIsAssumedType);
[flang] Add lowering for host association This patches adds the code to handle host association for inner subroutines and functions. This patch is part of the upstreaming effort from fir-dev branch. Reviewed By: jeanPerier Differential Revision: https://reviews.llvm.org/D121134 Co-authored-by: Eric Schweitz <eschweitz@nvidia.com> Co-authored-by: Jean Perier <jperier@nvidia.com> Co-authored-by: V Donaldson <vdonaldson@nvidia.com>
2022-03-07 19:55:48 +01:00
if (fir::isa_char(mlirType)) {
// Character scalar results must be passed as arguments in lowering so
// that an assumed length character function callee can access the result
// length. A function with a result requiring an explicit interface does
// not have to be compatible with assumed length function, but most
// compilers supports it.
handleImplicitCharacterResult(typeAndShape->type());
return;
}
addFirResult(mlirType, FirPlaceHolder::resultEntityPosition,
Property::Value);
// Explicit results require the caller to allocate the storage and save the
// function result in the storage with a fir.save_result.
setSaveResult();
[flang] Handle lowering arguments in subroutine and function This patch adds infrsatrcutrue to be able to lower arguments in functions and subroutines. This patch is part of the upstreaming effort from fir-dev branch. Reviewed By: PeteSteinfeld Differential Revision: https://reviews.llvm.org/D119957 Co-authored-by: Eric Schweitz <eschweitz@nvidia.com> Co-authored-by: Jean Perier <jperier@nvidia.com>
2022-02-16 20:27:23 +01:00
}
[flang] Add lowering for host association This patches adds the code to handle host association for inner subroutines and functions. This patch is part of the upstreaming effort from fir-dev branch. Reviewed By: jeanPerier Differential Revision: https://reviews.llvm.org/D121134 Co-authored-by: Eric Schweitz <eschweitz@nvidia.com> Co-authored-by: Jean Perier <jperier@nvidia.com> Co-authored-by: V Donaldson <vdonaldson@nvidia.com>
2022-03-07 19:55:48 +01:00
fir::SequenceType::Shape getBounds(const Fortran::evaluate::Shape &shape) {
fir::SequenceType::Shape bounds;
for (const std::optional<Fortran::evaluate::ExtentExpr> &extent : shape) {
fir::SequenceType::Extent bound = fir::SequenceType::getUnknownExtent();
if (std::optional<std::int64_t> i = toInt64(extent))
bound = *i;
bounds.emplace_back(bound);
}
return bounds;
}
std::optional<std::int64_t>
toInt64(std::optional<
Fortran::evaluate::Expr<Fortran::evaluate::SubscriptInteger>>
expr) {
if (expr)
return Fortran::evaluate::ToInt64(Fortran::evaluate::Fold(
getConverter().getFoldingContext(), toEvExpr(*expr)));
return std::nullopt;
}
[flang] Use std::nullopt instead of None (NFC) This patch mechanically replaces None with std::nullopt where the compiler would warn if None were deprecated. The intent is to reduce the amount of manual work required in migrating from Optional to std::optional. This is part of an effort to migrate from llvm::Optional to std::optional: https://discourse.llvm.org/t/deprecating-llvm-optional-x-hasvalue-getvalue-getvalueor/63716
2022-12-03 12:14:21 -08:00
void addFirOperand(
mlir::Type type, int entityPosition, Property p,
llvm::ArrayRef<mlir::NamedAttribute> attributes = std::nullopt) {
[flang] Handle lowering arguments in subroutine and function This patch adds infrsatrcutrue to be able to lower arguments in functions and subroutines. This patch is part of the upstreaming effort from fir-dev branch. Reviewed By: PeteSteinfeld Differential Revision: https://reviews.llvm.org/D119957 Co-authored-by: Eric Schweitz <eschweitz@nvidia.com> Co-authored-by: Jean Perier <jperier@nvidia.com>
2022-02-16 20:27:23 +01:00
interface.inputs.emplace_back(
FirPlaceHolder{type, entityPosition, p, attributes});
}
void
addFirResult(mlir::Type type, int entityPosition, Property p,
[flang] Use std::nullopt instead of None (NFC) This patch mechanically replaces None with std::nullopt where the compiler would warn if None were deprecated. The intent is to reduce the amount of manual work required in migrating from Optional to std::optional. This is part of an effort to migrate from llvm::Optional to std::optional: https://discourse.llvm.org/t/deprecating-llvm-optional-x-hasvalue-getvalue-getvalueor/63716
2022-12-03 12:14:21 -08:00
llvm::ArrayRef<mlir::NamedAttribute> attributes = std::nullopt) {
[flang] Handle lowering arguments in subroutine and function This patch adds infrsatrcutrue to be able to lower arguments in functions and subroutines. This patch is part of the upstreaming effort from fir-dev branch. Reviewed By: PeteSteinfeld Differential Revision: https://reviews.llvm.org/D119957 Co-authored-by: Eric Schweitz <eschweitz@nvidia.com> Co-authored-by: Jean Perier <jperier@nvidia.com>
2022-02-16 20:27:23 +01:00
interface.outputs.emplace_back(
FirPlaceHolder{type, entityPosition, p, attributes});
}
void addPassedArg(PassEntityBy p, FortranEntity entity,
const DummyCharacteristics *characteristics) {
interface.passedArguments.emplace_back(
[flang] Add lowering for host association This patches adds the code to handle host association for inner subroutines and functions. This patch is part of the upstreaming effort from fir-dev branch. Reviewed By: jeanPerier Differential Revision: https://reviews.llvm.org/D121134 Co-authored-by: Eric Schweitz <eschweitz@nvidia.com> Co-authored-by: Jean Perier <jperier@nvidia.com> Co-authored-by: V Donaldson <vdonaldson@nvidia.com>
2022-03-07 19:55:48 +01:00
PassedEntity{p, entity, emptyValue(), emptyValue(), characteristics});
[flang] Lower basic function with scalar integer/logical return value This patch allows the lowring of simple empty function with a scalar integer or logical return value. The code in ConvertType.cpp is cleaned up as well. This file was landed together with the initial flang push and lowering was still a prototype at that time. Some more cleaning will come with follow up patches. This patch is part of the upstreaming effort from fir-dev branch. Reviewed By: PeteSteinfeld Differential Revision: https://reviews.llvm.org/D119698 Co-authored-by: Jean Perier <jperier@nvidia.com>
2022-02-14 21:31:46 +01:00
}
[flang] Lower simple character return Handles function with character return. Character scalar results are passed as arguments in lowering so that an assumed length character function callee can access the result length. This patch is part of the upstreaming effort from fir-dev branch. Reviewed By: PeteSteinfeld, schweitz Differential Revision: https://reviews.llvm.org/D120558 Co-authored-by: Eric Schweitz <eschweitz@nvidia.com> Co-authored-by: Jean Perier <jperier@nvidia.com> Co-authored-by: V Donaldson <vdonaldson@nvidia.com>
2022-02-25 18:21:44 +01:00
void setPassedResult(PassEntityBy p, FortranEntity entity) {
interface.passedResult =
PassedEntity{p, entity, emptyValue(), emptyValue()};
}
void setSaveResult() { interface.saveResult = true; }
[flang] Handle lowering arguments in subroutine and function This patch adds infrsatrcutrue to be able to lower arguments in functions and subroutines. This patch is part of the upstreaming effort from fir-dev branch. Reviewed By: PeteSteinfeld Differential Revision: https://reviews.llvm.org/D119957 Co-authored-by: Eric Schweitz <eschweitz@nvidia.com> Co-authored-by: Jean Perier <jperier@nvidia.com>
2022-02-16 20:27:23 +01:00
int nextPassedArgPosition() { return interface.passedArguments.size(); }
[flang] Lower basic function with scalar integer/logical return value This patch allows the lowring of simple empty function with a scalar integer or logical return value. The code in ConvertType.cpp is cleaned up as well. This file was landed together with the initial flang push and lowering was still a prototype at that time. Some more cleaning will come with follow up patches. This patch is part of the upstreaming effort from fir-dev branch. Reviewed By: PeteSteinfeld Differential Revision: https://reviews.llvm.org/D119698 Co-authored-by: Jean Perier <jperier@nvidia.com>
2022-02-14 21:31:46 +01:00
[flang] Lower simple character return Handles function with character return. Character scalar results are passed as arguments in lowering so that an assumed length character function callee can access the result length. This patch is part of the upstreaming effort from fir-dev branch. Reviewed By: PeteSteinfeld, schweitz Differential Revision: https://reviews.llvm.org/D120558 Co-authored-by: Eric Schweitz <eschweitz@nvidia.com> Co-authored-by: Jean Perier <jperier@nvidia.com> Co-authored-by: V Donaldson <vdonaldson@nvidia.com>
2022-02-25 18:21:44 +01:00
static FirValue emptyValue() {
if constexpr (std::is_same_v<Fortran::lower::CalleeInterface, T>) {
return {};
} else {
return -1;
}
}
[flang] Lower basic function with scalar integer/logical return value This patch allows the lowring of simple empty function with a scalar integer or logical return value. The code in ConvertType.cpp is cleaned up as well. This file was landed together with the initial flang push and lowering was still a prototype at that time. Some more cleaning will come with follow up patches. This patch is part of the upstreaming effort from fir-dev branch. Reviewed By: PeteSteinfeld Differential Revision: https://reviews.llvm.org/D119698 Co-authored-by: Jean Perier <jperier@nvidia.com>
2022-02-14 21:31:46 +01:00
Fortran::lower::AbstractConverter &getConverter() {
return interface.converter;
}
CallInterface &interface;
mlir::MLIRContext &mlirContext;
};
[flang] Lower function and subroutine calls This patch introduce basic function/subroutine calls. Because of the state of lowering only simple scalar arguments can be used in the calls. This will be enhanced in follow up patches with arrays, allocatable, pointer ans so on. ``` subroutine sub1() end subroutine sub2() call sub1() end ``` This patch is part of the upstreaming effort from fir-dev branch. Reviewed By: schweitz Differential Revision: https://reviews.llvm.org/D120419 Co-authored-by: Eric Schweitz <eschweitz@nvidia.com> Co-authored-by: Jean Perier <jperier@nvidia.com> Co-authored-by: V Donaldson <vdonaldson@nvidia.com>
2022-02-23 19:48:07 +01:00
template <typename T>
bool Fortran::lower::CallInterface<T>::PassedEntity::isOptional() const {
if (!characteristics)
return false;
return characteristics->IsOptional();
}
template <typename T>
bool Fortran::lower::CallInterface<T>::PassedEntity::mayBeModifiedByCall()
const {
if (!characteristics)
return true;
[flang] Lower procedure ref to user defined elemental procedures (part 1) Lower procedure ref to user defined elemental procedure when: - there are no arguments that may be dynamically optional - for functions, the result has no length parameters - the reference can be unordered - there are not character by value arguments This uses the recently added hlfir.elemental operation and tools. The "core" of the argument preparation is shared between elemental and non elemental calls (genUserCalls is code moved without any functional changes) Differential Revision: https://reviews.llvm.org/D140118
2022-12-16 12:59:12 +01:00
if (characteristics->GetIntent() == Fortran::common::Intent::In)
return false;
[flang][hlfir] Lower post f77 user calls In lowering to HLFIR, deal with user calls involving a mix of: - dummy with VALUE - Polymorphism - contiguous dummy - assumed shape dummy - OPTIONAL arguments - NULL() passed to OPTIONAL arguments. - elemental calls Does not deal with assumed ranked dummy arguments. This patch unifies the preparation of all arguments that must be passed in memory and are not passed as allocatable/pointers. For optionals, the same argument preparation is done, except the utility that generates the IR for the argument preparation is called inside a fir.if. The addressing of array arguments in elemental calls is delayed so that it can also happen during this argument preparation, and be placed in the fir.if when the array may be absent. Structure helpers are added to convey a prepared dummy argument and the data that may be needed to do the clean-up after the call (temporary storage deallocation or copy-out). And a utility is added to wrap the preparation code inside a fir.if and convey these values through the fir.if. Certain aspects of this patch brings the HLFIR lowering support beyond what the current lowering to FIR supports (e.g. handling of NULL(), handling of optional in elemental calls, handling of copy-in/copy-out involving polymorphic entities). Differential Revision: https://reviews.llvm.org/D142695
2023-02-01 11:43:22 +01:00
return !hasValueAttribute();
[flang] Lower function and subroutine calls This patch introduce basic function/subroutine calls. Because of the state of lowering only simple scalar arguments can be used in the calls. This will be enhanced in follow up patches with arrays, allocatable, pointer ans so on. ``` subroutine sub1() end subroutine sub2() call sub1() end ``` This patch is part of the upstreaming effort from fir-dev branch. Reviewed By: schweitz Differential Revision: https://reviews.llvm.org/D120419 Co-authored-by: Eric Schweitz <eschweitz@nvidia.com> Co-authored-by: Jean Perier <jperier@nvidia.com> Co-authored-by: V Donaldson <vdonaldson@nvidia.com>
2022-02-23 19:48:07 +01:00
}
template <typename T>
bool Fortran::lower::CallInterface<T>::PassedEntity::mayBeReadByCall() const {
if (!characteristics)
return true;
return characteristics->GetIntent() != Fortran::common::Intent::Out;
}
[flang] Deallocate intent(out) allocatables From Fortran 2018 standard 9.7.3.2 point 6: When a procedure is invoked, any allocated allocatable object that is an actual argument corresponding to an INTENT (OUT) allocatable dummy argument is deallocated; any allocated allocatable object that is a subobject of an actual argument corresponding to an INTENT (OUT) dummy argument is deallocated. Deallocation is done on the callee side. For BIND(C) procedure, the deallocation is also done on the caller side. Reviewed By: jeanPerier Differential Revision: https://reviews.llvm.org/D133348
2022-09-08 10:15:36 +02:00
template <typename T>
bool Fortran::lower::CallInterface<T>::PassedEntity::isIntentOut() const {
if (!characteristics)
return true;
return characteristics->GetIntent() == Fortran::common::Intent::Out;
}
[flang] Lowers calls to procedure with CONTIGUOUS assumed shape dummies Copy-in/copy-out was not triggered when calling a procedure with a CONTIGUOUS assumed shape. The actual argument must be copied-in/out if it is not contiguous. The copy-in/copy-out takes care of argument optionality, and uses a runtime check in order to only do the copy if the actual is not contiguous at runtime. This was already implemented for explicit shape dummy arguments. This patch takes advantage of this implementation to deal with the copy-in copy-out aspects. It only need add code to deals with wrapping the created bare contiguous address into a fir.box (runtime descriptor), taking care of the optional box aspects. Using this existing code is only possible for actual argument that can be passed via a bare address. Add a TODO for polymorphic entity, PDTs and assumed rank where the existing copy-in/copy-out code may fail (these copies are more complex) and that cannot be tested currently. Differential Revision: https://reviews.llvm.org/D134543
2022-09-26 15:09:30 +02:00
template <typename T>
bool Fortran::lower::CallInterface<T>::PassedEntity::mustBeMadeContiguous()
const {
if (!characteristics)
return true;
const auto *dummy =
std::get_if<Fortran::evaluate::characteristics::DummyDataObject>(
&characteristics->u);
if (!dummy)
return false;
const auto &shapeAttrs = dummy->type.attrs();
using ShapeAttrs = Fortran::evaluate::characteristics::TypeAndShape::Attr;
if (shapeAttrs.test(ShapeAttrs::AssumedRank) ||
shapeAttrs.test(ShapeAttrs::AssumedShape))
return dummy->attrs.test(
Fortran::evaluate::characteristics::DummyDataObject::Attr::Contiguous);
if (shapeAttrs.test(ShapeAttrs::DeferredShape))
return false;
// Explicit shape arrays are contiguous.
return dummy->type.Rank() > 0;
}
[flang] Lower function and subroutine calls This patch introduce basic function/subroutine calls. Because of the state of lowering only simple scalar arguments can be used in the calls. This will be enhanced in follow up patches with arrays, allocatable, pointer ans so on. ``` subroutine sub1() end subroutine sub2() call sub1() end ``` This patch is part of the upstreaming effort from fir-dev branch. Reviewed By: schweitz Differential Revision: https://reviews.llvm.org/D120419 Co-authored-by: Eric Schweitz <eschweitz@nvidia.com> Co-authored-by: Jean Perier <jperier@nvidia.com> Co-authored-by: V Donaldson <vdonaldson@nvidia.com>
2022-02-23 19:48:07 +01:00
[flang][hlfir] Lower post f77 user calls In lowering to HLFIR, deal with user calls involving a mix of: - dummy with VALUE - Polymorphism - contiguous dummy - assumed shape dummy - OPTIONAL arguments - NULL() passed to OPTIONAL arguments. - elemental calls Does not deal with assumed ranked dummy arguments. This patch unifies the preparation of all arguments that must be passed in memory and are not passed as allocatable/pointers. For optionals, the same argument preparation is done, except the utility that generates the IR for the argument preparation is called inside a fir.if. The addressing of array arguments in elemental calls is delayed so that it can also happen during this argument preparation, and be placed in the fir.if when the array may be absent. Structure helpers are added to convey a prepared dummy argument and the data that may be needed to do the clean-up after the call (temporary storage deallocation or copy-out). And a utility is added to wrap the preparation code inside a fir.if and convey these values through the fir.if. Certain aspects of this patch brings the HLFIR lowering support beyond what the current lowering to FIR supports (e.g. handling of NULL(), handling of optional in elemental calls, handling of copy-in/copy-out involving polymorphic entities). Differential Revision: https://reviews.llvm.org/D142695
2023-02-01 11:43:22 +01:00
template <typename T>
bool Fortran::lower::CallInterface<T>::PassedEntity::hasValueAttribute() const {
if (!characteristics)
return false;
const auto *dummy =
std::get_if<Fortran::evaluate::characteristics::DummyDataObject>(
&characteristics->u);
return dummy &&
dummy->attrs.test(
Fortran::evaluate::characteristics::DummyDataObject::Attr::Value);
}
[flang] Lower basic function with scalar integer/logical return value This patch allows the lowring of simple empty function with a scalar integer or logical return value. The code in ConvertType.cpp is cleaned up as well. This file was landed together with the initial flang push and lowering was still a prototype at that time. Some more cleaning will come with follow up patches. This patch is part of the upstreaming effort from fir-dev branch. Reviewed By: PeteSteinfeld Differential Revision: https://reviews.llvm.org/D119698 Co-authored-by: Jean Perier <jperier@nvidia.com>
2022-02-14 21:31:46 +01:00
template <typename T>
void Fortran::lower::CallInterface<T>::determineInterface(
bool isImplicit,
const Fortran::evaluate::characteristics::Procedure &procedure) {
CallInterfaceImpl<T> impl(*this);
if (isImplicit)
impl.buildImplicitInterface(procedure);
else
[flang] Handle lowering of ranked array This patch adds lowering of ranked array as function return. This patch is part of the upstreaming effort from fir-dev branch. Reviewed By: PeteSteinfeld Differential Revision: https://reviews.llvm.org/D119835 Co-authored-by: Jean Perier <jperier@nvidia.com>
2022-02-15 16:00:28 +01:00
impl.buildExplicitInterface(procedure);
[flang] Add lowering for host association This patches adds the code to handle host association for inner subroutines and functions. This patch is part of the upstreaming effort from fir-dev branch. Reviewed By: jeanPerier Differential Revision: https://reviews.llvm.org/D121134 Co-authored-by: Eric Schweitz <eschweitz@nvidia.com> Co-authored-by: Jean Perier <jperier@nvidia.com> Co-authored-by: V Donaldson <vdonaldson@nvidia.com>
2022-03-07 19:55:48 +01:00
// We only expect the extra host asspciations argument from the callee side as
// the definition of internal procedures will be present, and we'll always
// have a FuncOp definition in the ModuleOp, when lowering.
if constexpr (std::is_same_v<T, Fortran::lower::CalleeInterface>) {
if (side().hasHostAssociated())
impl.appendHostAssocTupleArg(side().getHostAssociatedTy());
}
[flang] Lower basic function with scalar integer/logical return value This patch allows the lowring of simple empty function with a scalar integer or logical return value. The code in ConvertType.cpp is cleaned up as well. This file was landed together with the initial flang push and lowering was still a prototype at that time. Some more cleaning will come with follow up patches. This patch is part of the upstreaming effort from fir-dev branch. Reviewed By: PeteSteinfeld Differential Revision: https://reviews.llvm.org/D119698 Co-authored-by: Jean Perier <jperier@nvidia.com>
2022-02-14 21:31:46 +01:00
}
[flang] Initial lowering for empty program This patch enable lowering from Fortran to FIR for a basic empty program. It brings all the infrastructure needed for that. As discussed previously, this is the first patch for lowering and follow up patches should be smaller. With this patch we can lower the following code: ``` program basic end program ``` To a the FIR equivalent: ``` func @_QQmain() { return } ``` Follow up patch will add lowering of more complex constructs. Reviewed By: kiranchandramohan, schweitz, PeteSteinfeld Differential Revision: https://reviews.llvm.org/D118436
2022-01-28 22:39:44 +01:00
template <typename T>
mlir::FunctionType Fortran::lower::CallInterface<T>::genFunctionType() {
[flang] Lower basic function with scalar integer/logical return value This patch allows the lowring of simple empty function with a scalar integer or logical return value. The code in ConvertType.cpp is cleaned up as well. This file was landed together with the initial flang push and lowering was still a prototype at that time. Some more cleaning will come with follow up patches. This patch is part of the upstreaming effort from fir-dev branch. Reviewed By: PeteSteinfeld Differential Revision: https://reviews.llvm.org/D119698 Co-authored-by: Jean Perier <jperier@nvidia.com>
2022-02-14 21:31:46 +01:00
llvm::SmallVector<mlir::Type> returnTys;
[flang] Handle lowering arguments in subroutine and function This patch adds infrsatrcutrue to be able to lower arguments in functions and subroutines. This patch is part of the upstreaming effort from fir-dev branch. Reviewed By: PeteSteinfeld Differential Revision: https://reviews.llvm.org/D119957 Co-authored-by: Eric Schweitz <eschweitz@nvidia.com> Co-authored-by: Jean Perier <jperier@nvidia.com>
2022-02-16 20:27:23 +01:00
llvm::SmallVector<mlir::Type> inputTys;
[flang] Lower basic function with scalar integer/logical return value This patch allows the lowring of simple empty function with a scalar integer or logical return value. The code in ConvertType.cpp is cleaned up as well. This file was landed together with the initial flang push and lowering was still a prototype at that time. Some more cleaning will come with follow up patches. This patch is part of the upstreaming effort from fir-dev branch. Reviewed By: PeteSteinfeld Differential Revision: https://reviews.llvm.org/D119698 Co-authored-by: Jean Perier <jperier@nvidia.com>
2022-02-14 21:31:46 +01:00
for (const FirPlaceHolder &placeHolder : outputs)
returnTys.emplace_back(placeHolder.type);
[flang] Handle lowering arguments in subroutine and function This patch adds infrsatrcutrue to be able to lower arguments in functions and subroutines. This patch is part of the upstreaming effort from fir-dev branch. Reviewed By: PeteSteinfeld Differential Revision: https://reviews.llvm.org/D119957 Co-authored-by: Eric Schweitz <eschweitz@nvidia.com> Co-authored-by: Jean Perier <jperier@nvidia.com>
2022-02-16 20:27:23 +01:00
for (const FirPlaceHolder &placeHolder : inputs)
inputTys.emplace_back(placeHolder.type);
return mlir::FunctionType::get(&converter.getMLIRContext(), inputTys,
returnTys);
[flang] Initial lowering for empty program This patch enable lowering from Fortran to FIR for a basic empty program. It brings all the infrastructure needed for that. As discussed previously, this is the first patch for lowering and follow up patches should be smaller. With this patch we can lower the following code: ``` program basic end program ``` To a the FIR equivalent: ``` func @_QQmain() { return } ``` Follow up patch will add lowering of more complex constructs. Reviewed By: kiranchandramohan, schweitz, PeteSteinfeld Differential Revision: https://reviews.llvm.org/D118436
2022-01-28 22:39:44 +01:00
}
[flang] Add lowering for host association This patches adds the code to handle host association for inner subroutines and functions. This patch is part of the upstreaming effort from fir-dev branch. Reviewed By: jeanPerier Differential Revision: https://reviews.llvm.org/D121134 Co-authored-by: Eric Schweitz <eschweitz@nvidia.com> Co-authored-by: Jean Perier <jperier@nvidia.com> Co-authored-by: V Donaldson <vdonaldson@nvidia.com>
2022-03-07 19:55:48 +01:00
template <typename T>
llvm::SmallVector<mlir::Type>
Fortran::lower::CallInterface<T>::getResultType() const {
llvm::SmallVector<mlir::Type> types;
for (const FirPlaceHolder &out : outputs)
types.emplace_back(out.type);
return types;
}
[flang] Initial lowering for empty program This patch enable lowering from Fortran to FIR for a basic empty program. It brings all the infrastructure needed for that. As discussed previously, this is the first patch for lowering and follow up patches should be smaller. With this patch we can lower the following code: ``` program basic end program ``` To a the FIR equivalent: ``` func @_QQmain() { return } ``` Follow up patch will add lowering of more complex constructs. Reviewed By: kiranchandramohan, schweitz, PeteSteinfeld Differential Revision: https://reviews.llvm.org/D118436
2022-01-28 22:39:44 +01:00
template class Fortran::lower::CallInterface<Fortran::lower::CalleeInterface>;
[flang] Lower function and subroutine calls This patch introduce basic function/subroutine calls. Because of the state of lowering only simple scalar arguments can be used in the calls. This will be enhanced in follow up patches with arrays, allocatable, pointer ans so on. ``` subroutine sub1() end subroutine sub2() call sub1() end ``` This patch is part of the upstreaming effort from fir-dev branch. Reviewed By: schweitz Differential Revision: https://reviews.llvm.org/D120419 Co-authored-by: Eric Schweitz <eschweitz@nvidia.com> Co-authored-by: Jean Perier <jperier@nvidia.com> Co-authored-by: V Donaldson <vdonaldson@nvidia.com>
2022-02-23 19:48:07 +01:00
template class Fortran::lower::CallInterface<Fortran::lower::CallerInterface>;
[flang] Add lowering for host association This patches adds the code to handle host association for inner subroutines and functions. This patch is part of the upstreaming effort from fir-dev branch. Reviewed By: jeanPerier Differential Revision: https://reviews.llvm.org/D121134 Co-authored-by: Eric Schweitz <eschweitz@nvidia.com> Co-authored-by: Jean Perier <jperier@nvidia.com> Co-authored-by: V Donaldson <vdonaldson@nvidia.com>
2022-03-07 19:55:48 +01:00
//===----------------------------------------------------------------------===//
// Function Type Translation
//===----------------------------------------------------------------------===//
/// Build signature from characteristics when there is no Fortran entity to
/// associate with the arguments (i.e, this is not a call site or a procedure
/// declaration. This is needed when dealing with function pointers/dummy
/// arguments.
class SignatureBuilder;
template <>
struct Fortran::lower::PassedEntityTypes<SignatureBuilder> {
using FortranEntity = FakeEntity;
using FirValue = int;
};
/// SignatureBuilder is a CRTP implementation of CallInterface intended to
/// help translating characteristics::Procedure to mlir::FunctionType using
/// the CallInterface translation.
class SignatureBuilder
: public Fortran::lower::CallInterface<SignatureBuilder> {
public:
SignatureBuilder(const Fortran::evaluate::characteristics::Procedure &p,
Fortran::lower::AbstractConverter &c, bool forceImplicit)
: CallInterface{c}, proc{p} {
bool isImplicit = forceImplicit || proc.CanBeCalledViaImplicitInterface();
determineInterface(isImplicit, proc);
}
/// Does the procedure characteristics being translated have alternate
/// returns ?
bool hasAlternateReturns() const {
for (const Fortran::evaluate::characteristics::DummyArgument &dummy :
proc.dummyArguments)
if (std::holds_alternative<
Fortran::evaluate::characteristics::AlternateReturn>(dummy.u))
return true;
return false;
};
/// This is only here to fulfill CRTP dependencies and should not be called.
std::string getMangledName() const {
llvm_unreachable("trying to get name from SignatureBuilder");
}
/// This is only here to fulfill CRTP dependencies and should not be called.
mlir::Location getCalleeLocation() const {
llvm_unreachable("trying to get callee location from SignatureBuilder");
}
/// This is only here to fulfill CRTP dependencies and should not be called.
const Fortran::semantics::Symbol *getProcedureSymbol() const {
llvm_unreachable("trying to get callee symbol from SignatureBuilder");
};
Fortran::evaluate::characteristics::Procedure characterize() const {
return proc;
}
/// SignatureBuilder cannot be used on main program.
static constexpr bool isMainProgram() { return false; }
/// Return the characteristics::Procedure that is being translated to
/// mlir::FunctionType.
const Fortran::evaluate::characteristics::Procedure &
getCallDescription() const {
return proc;
}
/// This is not the description of an indirect call.
static constexpr bool isIndirectCall() { return false; }
/// Return the translated signature.
mlir::FunctionType getFunctionType() { return genFunctionType(); }
// Copy of base implementation.
static constexpr bool hasHostAssociated() { return false; }
mlir::Type getHostAssociatedTy() const {
llvm_unreachable("getting host associated type in SignatureBuilder");
}
private:
const Fortran::evaluate::characteristics::Procedure &proc;
};
mlir::FunctionType Fortran::lower::translateSignature(
const Fortran::evaluate::ProcedureDesignator &proc,
Fortran::lower::AbstractConverter &converter) {
std::optional<Fortran::evaluate::characteristics::Procedure> characteristics =
Fortran::evaluate::characteristics::Procedure::Characterize(
proc, converter.getFoldingContext());
// Most unrestricted intrinsic characteristic has the Elemental attribute
// which triggers CanBeCalledViaImplicitInterface to return false. However,
// using implicit interface rules is just fine here.
bool forceImplicit = proc.GetSpecificIntrinsic();
return SignatureBuilder{characteristics.value(), converter, forceImplicit}
.getFunctionType();
}
[mlir:NFC] Remove the forward declaration of FuncOp in the mlir namespace FuncOp has been moved to the `func` namespace for a little over a month, the using directive can be dropped now.
2022-04-18 11:53:47 -07:00
mlir::func::FuncOp Fortran::lower::getOrDeclareFunction(
[flang] Add lowering for host association This patches adds the code to handle host association for inner subroutines and functions. This patch is part of the upstreaming effort from fir-dev branch. Reviewed By: jeanPerier Differential Revision: https://reviews.llvm.org/D121134 Co-authored-by: Eric Schweitz <eschweitz@nvidia.com> Co-authored-by: Jean Perier <jperier@nvidia.com> Co-authored-by: V Donaldson <vdonaldson@nvidia.com>
2022-03-07 19:55:48 +01:00
llvm::StringRef name, const Fortran::evaluate::ProcedureDesignator &proc,
Fortran::lower::AbstractConverter &converter) {
mlir::ModuleOp module = converter.getModuleOp();
[mlir:NFC] Remove the forward declaration of FuncOp in the mlir namespace FuncOp has been moved to the `func` namespace for a little over a month, the using directive can be dropped now.
2022-04-18 11:53:47 -07:00
mlir::func::FuncOp func = fir::FirOpBuilder::getNamedFunction(module, name);
[flang] Add lowering for host association This patches adds the code to handle host association for inner subroutines and functions. This patch is part of the upstreaming effort from fir-dev branch. Reviewed By: jeanPerier Differential Revision: https://reviews.llvm.org/D121134 Co-authored-by: Eric Schweitz <eschweitz@nvidia.com> Co-authored-by: Jean Perier <jperier@nvidia.com> Co-authored-by: V Donaldson <vdonaldson@nvidia.com>
2022-03-07 19:55:48 +01:00
if (func)
return func;
const Fortran::semantics::Symbol *symbol = proc.GetSymbol();
assert(symbol && "non user function in getOrDeclareFunction");
// getOrDeclareFunction is only used for functions not defined in the current
// program unit, so use the location of the procedure designator symbol, which
// is the first occurrence of the procedure in the program unit.
mlir::Location loc = converter.genLocation(symbol->name());
std::optional<Fortran::evaluate::characteristics::Procedure> characteristics =
Fortran::evaluate::characteristics::Procedure::Characterize(
proc, converter.getFoldingContext());
mlir::FunctionType ty = SignatureBuilder{characteristics.value(), converter,
/*forceImplicit=*/false}
.getFunctionType();
[mlir:NFC] Remove the forward declaration of FuncOp in the mlir namespace FuncOp has been moved to the `func` namespace for a little over a month, the using directive can be dropped now.
2022-04-18 11:53:47 -07:00
mlir::func::FuncOp newFunc =
[flang] Add lowering for host association This patches adds the code to handle host association for inner subroutines and functions. This patch is part of the upstreaming effort from fir-dev branch. Reviewed By: jeanPerier Differential Revision: https://reviews.llvm.org/D121134 Co-authored-by: Eric Schweitz <eschweitz@nvidia.com> Co-authored-by: Jean Perier <jperier@nvidia.com> Co-authored-by: V Donaldson <vdonaldson@nvidia.com>
2022-03-07 19:55:48 +01:00
fir::FirOpBuilder::createFunction(loc, module, name, ty);
addSymbolAttribute(newFunc, *symbol, converter.getMLIRContext());
return newFunc;
}
// Is it required to pass a dummy procedure with \p characteristics as a tuple
// containing the function address and the result length ?
static bool mustPassLengthWithDummyProcedure(
const std::optional<Fortran::evaluate::characteristics::Procedure>
&characteristics) {
return characteristics &&
Fortran::lower::CallInterfaceImpl<SignatureBuilder>::
mustPassLengthWithDummyProcedure(*characteristics);
}
bool Fortran::lower::mustPassLengthWithDummyProcedure(
const Fortran::evaluate::ProcedureDesignator &procedure,
Fortran::lower::AbstractConverter &converter) {
std::optional<Fortran::evaluate::characteristics::Procedure> characteristics =
Fortran::evaluate::characteristics::Procedure::Characterize(
procedure, converter.getFoldingContext());
return ::mustPassLengthWithDummyProcedure(characteristics);
}
mlir::Type Fortran::lower::getDummyProcedureType(
const Fortran::semantics::Symbol &dummyProc,
Fortran::lower::AbstractConverter &converter) {
std::optional<Fortran::evaluate::characteristics::Procedure> iface =
Fortran::evaluate::characteristics::Procedure::Characterize(
dummyProc, converter.getFoldingContext());
mlir::Type procType = getProcedureDesignatorType(
iface.has_value() ? &*iface : nullptr, converter);
if (::mustPassLengthWithDummyProcedure(iface))
return fir::factory::getCharacterProcedureTupleType(procType);
return procType;
}
[flang] Support lowering of C_PTR and C_FUNPTR argument with VALUE attribute As Fortran 2018 18.3.2, C_PTR is interoperable with any C object pointer type. C_FUNPTR is interoperable with any C function pointer type. As 18.3.6, a C pointer can correspond to a Fortran dummy argument of type C_PTR with the VALUE attribute. The interface for type(C_PTR)/type(C_FUNPTR) argument with value attribute is different from the the usual derived type. For type(C_PTR) or type(C_FUNPTR), the component is the address, and the interface is a pointer even with VALUE attribute. For a usual derived type such as the drived type with the component of integer 64, the interface is a i64 value when it has VALUE attribute on aarch64 linux. To lower the type(C_PTR)/type(C_FUNPTR) argument with value attribute, get the value of the component of the type(C_PTR)/type(C_FUNPTR), which is the address, and then convert it to the pointer and pass it. Reviewed By: Jean Perier Differential Revision: https://reviews.llvm.org/D131583
2022-08-29 22:29:34 +08:00
bool Fortran::lower::isCPtrArgByValueType(mlir::Type ty) {
return ty.isa<fir::ReferenceType>() &&
fir::isa_integer(fir::unwrapRefType(ty));
}
Reference in New Issue Copy Permalink