maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity
llvm-project/flang/test/Semantics/modfile32.f90

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

325 lines
6.5 KiB
Fortran
Raw Normal View History

[flang][NFC] Simplify semantics test scripts There were several different ways of handling the option to f18 to find predefined modules: - test_errors.sh was created by cmake substituting FLANG_INTRINSIC_MODULES_DIR into test_errors.sh.in - some tests used the flang script which has the option built it - some tests used %f18_with_includes which was replaced by the path to f18 plus the -I option - some included -I../../include/flang in their run command To make this more consistent, change %f18 to include the -intrinsic-module-directory option and use it everywhere, including to replace %flang and %f18_with_includes. This requires changing all of the invocations of the test scripts to put %f18 at the end so that it can expand to more than one argument. This eliminates the need to generate test_errors.sh which means we don't need flang/test/Semantics/CMakeLists.txt or the %B substitution. That makes the test_errors.sh command like the others, replacing %B/test/Semantics/test_errors.sh with %S/test_errors.sh. Also remove the OPTIONS: functionality as custom options can be included in the RUN: command. And remove -I/../../include/flang as that is now always included. Differential Revision: https://reviews.llvm.org/D79634
2020-05-12 02:38:53 +08:00
! RUN: %S/test_modfile.sh %s %t %f18
[flang] Generic name resolution in expression analysis Implement the basics of resolving generic names in expressions. `ExpressionAnalyzer::ResolveGeneric` maps the symbol for a generic name to the specific procedure appropriate for the actual arguments. Extract `CheckExplicitInterface` out of `CheckArguments` so that it can be tried for each specific procedure of the generic as part of the test to see which is compatible. Note that it may be there is an elemental and non-elemental specific procedure that is compatible with the actual arguments. In that case the generic is resolved to the non-elemental one. Test this by using generic functions in specification expressions that must be written to module files. Verify how the generics were resolved by looking at the generated `.mod` files. There is more work to be done in this area: the passed-object dummy argument is not considered and in some cases generated module files are not correct. Original-commit: flang-compiler/f18@50e458045a3de42bd60515956e09f0f2d654ae1e Reviewed-on: https://github.com/flang-compiler/f18/pull/778
2019-10-10 07:08:13 +08:00
! Resolution of generic names in expressions.
! Test by using generic function in a specification expression that needs
! to be written to a .mod file.
! Resolve based on number of arguments
module m1
interface f
pure integer(8) function f1(x)
real, intent(in) :: x
end
pure integer(8) function f2(x, y)
real, intent(in) :: x, y
end
pure integer(8) function f3(x, y, z, w)
real, intent(in) :: x, y, z, w
optional :: w
end
end interface
contains
subroutine s1(x, z)
real :: z(f(x)) ! resolves to f1
end
subroutine s2(x, y, z)
real :: z(f(x, y)) ! resolves to f2
end
subroutine s3(x, y, z, w)
real :: w(f(x, y, z)) ! resolves to f3
end
subroutine s4(x, y, z, w, u)
real :: u(f(x, y, z, w)) ! resolves to f3
end
end
!Expect: m1.mod
!module m1
! interface f
! procedure :: f1
! procedure :: f2
! procedure :: f3
! end interface
! interface
! pure function f1(x)
! real(4), intent(in) :: x
! integer(8) :: f1
! end
! end interface
! interface
! pure function f2(x, y)
! real(4), intent(in) :: x
! real(4), intent(in) :: y
! integer(8) :: f2
! end
! end interface
! interface
! pure function f3(x, y, z, w)
! real(4), intent(in) :: x
! real(4), intent(in) :: y
! real(4), intent(in) :: z
! real(4), intent(in), optional :: w
! integer(8) :: f3
! end
! end interface
!contains
! subroutine s1(x, z)
! real(4) :: x
! real(4) :: z(1_8:f1(x))
! end
! subroutine s2(x, y, z)
! real(4) :: x
! real(4) :: y
! real(4) :: z(1_8:f2(x, y))
! end
! subroutine s3(x, y, z, w)
! real(4) :: x
! real(4) :: y
! real(4) :: z
! real(4) :: w(1_8:f3(x, y, z))
! end
! subroutine s4(x, y, z, w, u)
! real(4) :: x
! real(4) :: y
! real(4) :: z
! real(4) :: w
! real(4) :: u(1_8:f3(x, y, z, w))
! end
!end
! Resolve based on type or kind
module m2
interface f
pure integer(8) function f_real4(x)
real(4), intent(in) :: x
end
pure integer(8) function f_real8(x)
real(8), intent(in) :: x
end
pure integer(8) function f_integer(x)
integer, intent(in) :: x
end
end interface
contains
subroutine s1(x, y)
real(4) :: x
real :: y(f(x)) ! resolves to f_real4
end
subroutine s2(x, y)
real(8) :: x
real :: y(f(x)) ! resolves to f_real8
end
subroutine s3(x, y)
integer :: x
real :: y(f(x)) ! resolves to f_integer
end
end
!Expect: m2.mod
!module m2
! interface f
! procedure :: f_real4
! procedure :: f_real8
! procedure :: f_integer
! end interface
! interface
! pure function f_real4(x)
! real(4), intent(in) :: x
! integer(8) :: f_real4
! end
! end interface
! interface
! pure function f_real8(x)
! real(8), intent(in) :: x
! integer(8) :: f_real8
! end
! end interface
! interface
! pure function f_integer(x)
! integer(4), intent(in) :: x
! integer(8) :: f_integer
! end
! end interface
!contains
! subroutine s1(x, y)
! real(4) :: x
! real(4) :: y(1_8:f_real4(x))
! end
! subroutine s2(x, y)
! real(8) :: x
! real(4) :: y(1_8:f_real8(x))
! end
! subroutine s3(x, y)
! integer(4) :: x
! real(4) :: y(1_8:f_integer(x))
! end
!end
! Resolve based on rank
module m3a
interface f
procedure :: f_elem
procedure :: f_vector
end interface
contains
pure integer(8) elemental function f_elem(x) result(result)
real, intent(in) :: x
result = 1_8
end
pure integer(8) function f_vector(x) result(result)
real, intent(in) :: x(:)
result = 2_8
end
end
!Expect: m3a.mod
!module m3a
! interface f
! procedure :: f_elem
! procedure :: f_vector
! end interface
!contains
! elemental pure function f_elem(x) result(result)
! real(4), intent(in) :: x
! integer(8) :: result
! end
! pure function f_vector(x) result(result)
! real(4), intent(in) :: x(:)
! integer(8) :: result
! end
!end
module m3b
use m3a
contains
subroutine s1(x, y)
real :: x
real :: y(f(x)) ! resolves to f_elem
end
subroutine s2(x, y)
real :: x(10)
real :: y(f(x)) ! resolves to f_vector (preferred over elemental one)
end
subroutine s3(x, y)
real :: x(10, 10)
real :: y(ubound(f(x), 1)) ! resolves to f_elem
end
end
!Expect: m3b.mod
!module m3b
! use m3a, only: f
! use m3a, only: f_elem
! use m3a, only: f_vector
!contains
! subroutine s1(x, y)
! real(4) :: x
! real(4) :: y(1_8:f_elem(x))
! end
! subroutine s2(x, y)
! real(4) :: x(1_8:10_8)
! real(4) :: y(1_8:f_vector(x))
! end
! subroutine s3(x, y)
! real(4) :: x(1_8:10_8, 1_8:10_8)
[flang] Fold TRIM Accept IS_CONTIGUOUS and fold it test folding is_contiguous Original-commit: flang-compiler/f18@c75a0791b14811477572c6a82a961071ed82c01e Reviewed-on: https://github.com/flang-compiler/f18/pull/911
2020-01-08 05:39:42 +08:00
! real(4) :: y(1_8:10_8)
[flang] Generic name resolution in expression analysis Implement the basics of resolving generic names in expressions. `ExpressionAnalyzer::ResolveGeneric` maps the symbol for a generic name to the specific procedure appropriate for the actual arguments. Extract `CheckExplicitInterface` out of `CheckArguments` so that it can be tried for each specific procedure of the generic as part of the test to see which is compatible. Note that it may be there is an elemental and non-elemental specific procedure that is compatible with the actual arguments. In that case the generic is resolved to the non-elemental one. Test this by using generic functions in specification expressions that must be written to module files. Verify how the generics were resolved by looking at the generated `.mod` files. There is more work to be done in this area: the passed-object dummy argument is not considered and in some cases generated module files are not correct. Original-commit: flang-compiler/f18@50e458045a3de42bd60515956e09f0f2d654ae1e Reviewed-on: https://github.com/flang-compiler/f18/pull/778
2019-10-10 07:08:13 +08:00
! end
!end
[flang] Resolve defined operators to specifics Most of these changes involve moving code around so that it case be used for `DefinedUnary` and `DefinedBinary`. The functional changes are in the `Analyze` member functions for those cases where the arguments are now analyzed, the generic is resolved, and a `FunctionRef` is created. Add `ArgumentAnalyzer` to handling building of the `ActualArguments` of a call. This allows the code to be shared with the defined unary and defined binary cases. Move `AnalyzeActualArgument` and `AnalyzeActualArgument` into that class (renaming both to `Analyze`). Create an overload of `GetCalleeAndArguments` for the `Name` case so it can be used for defined ops where we don't have a `ProcedureDesignator`. Move `IsGenericDefinedOp` to `tools.h` to make it available to the new code. We were using `semantics::CheckExplicitInterface` to resolve a generic interface to a specific procedure based on actual arguments. The problem with that is that it performs too many checks. We just want to get the right specific; there may be errors reported later during call analysis. To fix this, add a new function, `CheckInterfaceForGeneric`, to perform this check. It shares code with `CheckExplicitInterface`, but it passes in a null scope to indicate that the full set of checks aren't necessary in `CheckExplicitInterfaceArg`. Instead we lift the call to `TypeAndShape::IsCompatibleWith` out of `CheckExplicitDataArg`, and skip the latter when there is no scope. Original-commit: flang-compiler/f18@fff2d1580f26719e0c384c66576aa6620d04faff Reviewed-on: https://github.com/flang-compiler/f18/pull/786
2019-10-23 00:31:33 +08:00
! Resolve defined unary operator based on type
module m4
interface operator(.foo.)
pure integer(8) function f_real(x)
real, intent(in) :: x
end
pure integer(8) function f_integer(x)
integer, intent(in) :: x
end
end interface
contains
subroutine s1(x, y)
real :: x
real :: y(.foo. x) ! resolves to f_real
end
subroutine s2(x, y)
integer :: x
real :: y(.foo. x) ! resolves to f_integer
end
end
!Expect: m4.mod
!module m4
! interface operator(.foo.)
! procedure :: f_real
! procedure :: f_integer
! end interface
! interface
! pure function f_real(x)
! real(4), intent(in) :: x
! integer(8) :: f_real
! end
! end interface
! interface
! pure function f_integer(x)
! integer(4), intent(in) :: x
! integer(8) :: f_integer
! end
! end interface
!contains
! subroutine s1(x, y)
! real(4) :: x
! real(4) :: y(1_8:f_real(x))
! end
! subroutine s2(x, y)
! integer(4) :: x
! real(4) :: y(1_8:f_integer(x))
! end
!end
! Resolve defined binary operator based on type
module m5
interface operator(.foo.)
pure integer(8) function f1(x, y)
real, intent(in) :: x
real, intent(in) :: y
end
pure integer(8) function f2(x, y)
real, intent(in) :: x
complex, intent(in) :: y
end
end interface
contains
subroutine s1(x, y)
complex :: x
real :: y(1.0 .foo. x) ! resolves to f2
end
subroutine s2(x, y)
real :: x
real :: y(1.0 .foo. x) ! resolves to f1
end
end
!Expect: m5.mod
!module m5
! interface operator(.foo.)
! procedure :: f1
! procedure :: f2
! end interface
! interface
! pure function f1(x, y)
! real(4), intent(in) :: x
! real(4), intent(in) :: y
! integer(8) :: f1
! end
! end interface
! interface
! pure function f2(x, y)
! real(4), intent(in) :: x
! complex(4), intent(in) :: y
! integer(8) :: f2
! end
! end interface
!contains
! subroutine s1(x, y)
! complex(4) :: x
! real(4) :: y(1_8:f2(1._4, x))
! end
! subroutine s2(x, y)
! real(4) :: x
! real(4) :: y(1_8:f1(1._4, x))
! end
!end