maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity
llvm-project/flang/lib/Evaluate/intrinsics.cpp

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

2416 lines
102 KiB
C++
Raw Normal View History

[flang] [LLVMify F18] Compiler module folders should have capitalised names (flang-compiler/f18#980) This patch renames the modules in f18 to use a capital letter in the module name Signed-off-by: Caroline Concatto <caroline.concatto@arm.com> Original-commit: flang-compiler/f18@d2eb7a1c443d1539ef12b6f027074a0eb15b1ea0 Reviewed-on: https://github.com/flang-compiler/f18/pull/980
2020-02-25 23:11:52 +08:00
//===-- lib/Evaluate/intrinsics.cpp ---------------------------------------===//
[flang] initial intrinsics table Original-commit: flang-compiler/f18@8b5c3adf887cf88752937a4fa5507c0d66051d3b Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-09-29 08:02:11 +08:00
//
[flang] Flang relicensing changes for LLVM Apache 2.0 license This changes the license information in many of the flang source files. - Renamed LICENSE to LICENSE.txt. - NVIDIA Copyright lines have been removed. - Initial lines for files follow the LLVM coding convention (file name on the first line; Emacs mode information on the first line). - License references have been replaced with the abridged LLVM text. - License information was removed from the test files. - No file header was placed on test files (these weren't in most LLVM test files). - License information was added to documentation files where it was missing. We did not add brief file summaries to the initial line. See http://llvm.org/docs/DeveloperPolicy.html#new-llvm-project-license-framework for a description of the new license. See http://llvm.org/docs/CodingStandards.html#file-headers for a description of the new LLVM standard file header. Original-commit: flang-compiler/f18@add6cde7244b926ca457a1c74c21fea071b85329 Reviewed-on: https://github.com/flang-compiler/f18/pull/887
2019-12-21 04:52:07 +08:00
// 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
[flang] initial intrinsics table Original-commit: flang-compiler/f18@8b5c3adf887cf88752937a4fa5507c0d66051d3b Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-09-29 08:02:11 +08:00
//
[flang] Minor format change to LLVM license lines Replace comment lines containing all dashes with the proper ===-----....----=== markers. Original-commit: flang-compiler/f18@a8936b0d4187a9a9ef43f9d34055a3213beeb9d2 Reviewed-on: https://github.com/flang-compiler/f18/pull/922
2020-01-11 04:12:03 +08:00
//===----------------------------------------------------------------------===//
[flang] initial intrinsics table Original-commit: flang-compiler/f18@8b5c3adf887cf88752937a4fa5507c0d66051d3b Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-09-29 08:02:11 +08:00
[flang] [LLVMify F18] Compiler module folders should have capitalised names (flang-compiler/f18#980) This patch renames the modules in f18 to use a capital letter in the module name Signed-off-by: Caroline Concatto <caroline.concatto@arm.com> Original-commit: flang-compiler/f18@d2eb7a1c443d1539ef12b6f027074a0eb15b1ea0 Reviewed-on: https://github.com/flang-compiler/f18/pull/980
2020-02-25 23:11:52 +08:00
#include "flang/Evaluate/intrinsics.h"
#include "flang/Common/Fortran.h"
#include "flang/Common/enum-set.h"
#include "flang/Common/idioms.h"
#include "flang/Evaluate/common.h"
#include "flang/Evaluate/expression.h"
#include "flang/Evaluate/fold.h"
#include "flang/Evaluate/shape.h"
#include "flang/Evaluate/tools.h"
#include "flang/Evaluate/type.h"
[flang] [LLVMify F18] Replace the use std::ostream with LLVM streams llvm::ostream This patch replaces the occurrence of std::ostream by llvm::raw_ostream. In LLVM Coding Standards[1] "All new code should use raw_ostream instead of ostream".[1] As a consequence, this patch also replaces the use of: std::stringstream by llvm::raw_string_ostream or llvm::raw_ostream* std::ofstream by llvm::raw_fd_ostream std::endl by '\n' and flush()[2] std::cout by llvm::outs() and std::cerr by llvm::errs() It also replaces std::strerro by llvm::sys::StrError** , but NOT in Fortran runtime libraries *std::stringstream were replaced by llvm::raw_ostream in all methods that used std::stringstream as a parameter. Moreover, it removes the pointers to these streams. [1]https://llvm.org/docs/CodingStandards.html [2]https://releases.llvm.org/2.5/docs/CodingStandards.html#ll_avoidendl Signed-off-by: Caroline Concatto <caroline.concatto@arm.com> Running clang-format-7 Signed-off-by: Caroline Concatto <caroline.concatto@arm.com> Removing residue of ostream library Signed-off-by: Caroline Concatto <caroline.concatto@arm.com> Original-commit: flang-compiler/f18@a3507d44b8911e6024033aa583c1dc54e0eb89fd Reviewed-on: https://github.com/flang-compiler/f18/pull/1047
2020-02-28 23:11:03 +08:00
#include "llvm/Support/raw_ostream.h"
[flang] rearrange arguments into dummy argument order Original-commit: flang-compiler/f18@3bab0f55de1b66d38bd15a841459c3a36cf29d30 Reviewed-on: https://github.com/flang-compiler/f18/pull/219 Tree-same-pre-rewrite: false
2018-10-19 01:50:55 +08:00
#include <algorithm>
[flang] intrinsic pattern matching Original-commit: flang-compiler/f18@ca0ee1660a6449c34c7276284e5e63b90ae97540 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-05 04:43:33 +08:00
#include <map>
#include <string>
#include <utility>
[flang] initial intrinsics table Original-commit: flang-compiler/f18@8b5c3adf887cf88752937a4fa5507c0d66051d3b Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-09-29 08:02:11 +08:00
[flang] error messages Original-commit: flang-compiler/f18@392a7330736a8fd444ef92ed5c8ef7dcbc94d461 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-06 02:32:54 +08:00
using namespace Fortran::parser::literals;
[flang] initial intrinsics table Original-commit: flang-compiler/f18@8b5c3adf887cf88752937a4fa5507c0d66051d3b Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-09-29 08:02:11 +08:00
namespace Fortran::evaluate {
[flang] Fold array operations Original-commit: flang-compiler/f18@e6c86ecfd10b77aeac63722c08487ae5de0a0c27 Reviewed-on: https://github.com/flang-compiler/f18/pull/420
2019-04-19 05:11:15 +08:00
class FoldingContext;
[flang] initial intrinsics table Original-commit: flang-compiler/f18@8b5c3adf887cf88752937a4fa5507c0d66051d3b Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-09-29 08:02:11 +08:00
[flang] intrinsic pattern matching Original-commit: flang-compiler/f18@ca0ee1660a6449c34c7276284e5e63b90ae97540 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-05 04:43:33 +08:00
// This file defines the supported intrinsic procedures and implements
// their recognition and validation. It is largely table-driven. See
[Flang] Move markdown files(.MD) from documentation/ to docs/ Summary: Other LLVM sub-projects use docs/ folder for documentation files. Follow LLVM project policy. Modify `documentation/` references in sources to `docs/`. This patch doesn't modify files to reStructuredText(.rst) file format. Reviewed By: DavidTruby, sscalpone Differential Revision: https://reviews.llvm.org/D85884
2020-08-18 17:35:51 +08:00
// docs/intrinsics.md and section 16 of the Fortran 2018 standard
[flang] intrinsic pattern matching Original-commit: flang-compiler/f18@ca0ee1660a6449c34c7276284e5e63b90ae97540 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-05 04:43:33 +08:00
// for full details on each of the intrinsics. Be advised, they have
// complicated details, and the design of these tables has to accommodate
// that complexity.
[flang] initial intrinsics table Original-commit: flang-compiler/f18@8b5c3adf887cf88752937a4fa5507c0d66051d3b Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-09-29 08:02:11 +08:00
[flang] intrinsic pattern matching Original-commit: flang-compiler/f18@ca0ee1660a6449c34c7276284e5e63b90ae97540 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-05 04:43:33 +08:00
// Dummy arguments to generic intrinsic procedures are each specified by
// their keyword name (rarely used, but always defined), allowable type
[flang] error messages Original-commit: flang-compiler/f18@392a7330736a8fd444ef92ed5c8ef7dcbc94d461 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-06 02:32:54 +08:00
// categories, a kind pattern, a rank pattern, and information about
// optionality and defaults. The kind and rank patterns are represented
// here with code values that are significant to the matching/validation engine.
[flang] initial intrinsics table Original-commit: flang-compiler/f18@8b5c3adf887cf88752937a4fa5507c0d66051d3b Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-09-29 08:02:11 +08:00
[flang] Improve error message for procedure passed as invalid argument to an intrinsic Support forward references to sibling module procedures Add tests, handle corner cases Rename new test Original-commit: flang-compiler/f18@234bb519cd38d0b9234fc0b4a8d11cfcb9935e6a Reviewed-on: https://github.com/flang-compiler/f18/pull/1076
2020-03-14 03:19:44 +08:00
// An actual argument to an intrinsic procedure may be a procedure itself
// only if the dummy argument is Rank::reduceOperation,
// KindCode::addressable, or the special case of NULL(MOLD=procedurePointer).
[flang] intrinsic pattern matching Original-commit: flang-compiler/f18@ca0ee1660a6449c34c7276284e5e63b90ae97540 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-05 04:43:33 +08:00
// These are small bit-sets of type category enumerators.
// Note that typeless (BOZ literal) values don't have a distinct type category.
// These typeless arguments are represented in the tables as if they were
// INTEGER with a special "typeless" kind code. Arguments of intrinsic types
[flang] lib/evaluate work for structure constructors Original-commit: flang-compiler/f18@76a192f9c9b009ea52409f25b81dcb7aa2866234 Reviewed-on: https://github.com/flang-compiler/f18/pull/439
2019-05-04 02:29:15 +08:00
// that can also be typeless values are encoded with an "elementalOrBOZ"
[flang] error messages Original-commit: flang-compiler/f18@392a7330736a8fd444ef92ed5c8ef7dcbc94d461 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-06 02:32:54 +08:00
// rank pattern.
[flang] Fold array operations Original-commit: flang-compiler/f18@e6c86ecfd10b77aeac63722c08487ae5de0a0c27 Reviewed-on: https://github.com/flang-compiler/f18/pull/420
2019-04-19 05:11:15 +08:00
// Assumed-type (TYPE(*)) dummy arguments can be forwarded along to some
[flang] Fix bug flang-compiler/f18#643 Original-commit: flang-compiler/f18@29bb4312e1f2861fa04f847c8e552ca894989593 Reviewed-on: https://github.com/flang-compiler/f18/pull/646
2019-08-13 01:56:18 +08:00
// intrinsic functions that accept AnyType + Rank::anyOrAssumedRank or
// AnyType + Kind::addressable.
[flang] intrinsic pattern matching Original-commit: flang-compiler/f18@ca0ee1660a6449c34c7276284e5e63b90ae97540 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-05 04:43:33 +08:00
using CategorySet = common::EnumSet<TypeCategory, 8>;
[flang] improve naming, silence bogus warnings Original-commit: flang-compiler/f18@f884fcb2c5f55871cbe7b472ca1145e9ffad0fe2 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-16 03:17:30 +08:00
static constexpr CategorySet IntType{TypeCategory::Integer};
static constexpr CategorySet RealType{TypeCategory::Real};
static constexpr CategorySet ComplexType{TypeCategory::Complex};
static constexpr CategorySet CharType{TypeCategory::Character};
static constexpr CategorySet LogicalType{TypeCategory::Logical};
static constexpr CategorySet IntOrRealType{IntType | RealType};
static constexpr CategorySet FloatingType{RealType | ComplexType};
static constexpr CategorySet NumericType{IntType | RealType | ComplexType};
static constexpr CategorySet RelatableType{IntType | RealType | CharType};
[flang] Update preprocessing document, commentary Extend documentation on preprocessing IsSimplyContiguous basic skeleton Apply suggested improvements to mod-file.cc Checks for new call13.f90 (15.4.2.2 explicit interfaces) Implement checking for procedures that can be called via an implicit interface Argument checking, test fixing Better argument checking Better derived type compatibility checking Treat externals as if implicitly interfaced Extend IEEE_EXCEPTIONS module so tests still pass with argument checking SAME_TYPE_AS and EXTENDS_TYPE_OF intrinsic inquiry functions Define interfaces for most intrinsic subroutines Better PASS arguments More with PASS() argument Prep for review address comments fix comment Remove formatted expression from specification expression error message per review more review comments Original-commit: flang-compiler/f18@3cca775da9302e3a2acec4a34800cd7666899b5f Reviewed-on: https://github.com/flang-compiler/f18/pull/776
2019-09-17 07:58:13 +08:00
static constexpr CategorySet DerivedType{TypeCategory::Derived};
[flang] intrinsic pattern matching Original-commit: flang-compiler/f18@ca0ee1660a6449c34c7276284e5e63b90ae97540 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-05 04:43:33 +08:00
static constexpr CategorySet IntrinsicType{
[flang] improve naming, silence bogus warnings Original-commit: flang-compiler/f18@f884fcb2c5f55871cbe7b472ca1145e9ffad0fe2 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-16 03:17:30 +08:00
IntType | RealType | ComplexType | CharType | LogicalType};
[flang] Update preprocessing document, commentary Extend documentation on preprocessing IsSimplyContiguous basic skeleton Apply suggested improvements to mod-file.cc Checks for new call13.f90 (15.4.2.2 explicit interfaces) Implement checking for procedures that can be called via an implicit interface Argument checking, test fixing Better argument checking Better derived type compatibility checking Treat externals as if implicitly interfaced Extend IEEE_EXCEPTIONS module so tests still pass with argument checking SAME_TYPE_AS and EXTENDS_TYPE_OF intrinsic inquiry functions Define interfaces for most intrinsic subroutines Better PASS arguments More with PASS() argument Prep for review address comments fix comment Remove formatted expression from specification expression error message per review more review comments Original-commit: flang-compiler/f18@3cca775da9302e3a2acec4a34800cd7666899b5f Reviewed-on: https://github.com/flang-compiler/f18/pull/776
2019-09-17 07:58:13 +08:00
static constexpr CategorySet AnyType{IntrinsicType | DerivedType};
[flang] initial intrinsics table Original-commit: flang-compiler/f18@8b5c3adf887cf88752937a4fa5507c0d66051d3b Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-09-29 08:02:11 +08:00
[flang] unit testing, better error messages Original-commit: flang-compiler/f18@f3876008d03751fff5d9490cbb1c7b7539e5c095 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-13 07:01:55 +08:00
ENUM_CLASS(KindCode, none, defaultIntegerKind,
[flang] Reformat with latest clang-format and .clang-format Original-commit: flang-compiler/f18@9fe84f45d7fd685051004678d6b5775dcc4c6f8f Reviewed-on: https://github.com/flang-compiler/f18/pull/1094
2020-03-29 12:00:16 +08:00
defaultRealKind, // is also the default COMPLEX kind
[flang] unit testing, better error messages Original-commit: flang-compiler/f18@f3876008d03751fff5d9490cbb1c7b7539e5c095 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-13 07:01:55 +08:00
doublePrecision, defaultCharKind, defaultLogicalKind,
[flang] Reformat with latest clang-format and .clang-format Original-commit: flang-compiler/f18@9fe84f45d7fd685051004678d6b5775dcc4c6f8f Reviewed-on: https://github.com/flang-compiler/f18/pull/1094
2020-03-29 12:00:16 +08:00
any, // matches any kind value; each instance is independent
same, // match any kind, but all "same" kinds must be equal
operand, // match any kind, with promotion (non-standard)
typeless, // BOZ literals are INTEGER with this kind
teamType, // TEAM_TYPE from module ISO_FORTRAN_ENV (for coarrays)
kindArg, // this argument is KIND=
effectiveKind, // for function results: "kindArg" value, possibly defaulted
dimArg, // this argument is DIM=
likeMultiply, // for DOT_PRODUCT and MATMUL
subscript, // address-sized integer
size, // default KIND= for SIZE(), UBOUND, &c.
addressable, // for PRESENT(), &c.; anything (incl. procedure) but BOZ
[flang] Failed call to CHECK() for call to ASSOCIATED(NULL()) Calling "ASSOCATED(NULL()) was causing an internal check of the compiler to fail. I fixed this by changing the entry for "ASSOCIATED" in the intrinsics table to accept "AnyPointer" which contains a new "KindCode" of "pointerType". I also changed the function "FromActual()" to return a typeless intrinsic when called on a pointer, which duplicates its behavior for BOZ literals. This required changing the analysis of procedure arguments. While testing processing for procedure arguments, I found another bad call to `CHECK()` which I fixed. I made several other changes: -- I implemented constant folding for ASSOCIATED(). -- I fixed handling of NULL() in relational operations. -- I implemented semantic analysis for ASSOCIATED(). -- I noticed that the semantics for ASSOCIATED() are similar to those for pointer assignment. So I extracted the code that pointer assignment uses for procedure pointer compatibility to a place where it could be used by the semantic analysis for ASSOCIATED(). -- I couldn't figure out how to make the general semantic analysis for procedure arguments work with ASSOCIATED()'s second argument, which can be either a pointer or a target. So I stopped using normal semantic analysis for arguments for ASSOCIATED(). -- I added tests for all of this. Differential Revision: https://reviews.llvm.org/D88313
2020-09-26 00:03:17 +08:00
nullPointerType, // for ASSOCIATED(NULL())
[flang] unit testing, better error messages Original-commit: flang-compiler/f18@f3876008d03751fff5d9490cbb1c7b7539e5c095 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-13 07:01:55 +08:00
)
[flang] initial intrinsics table Original-commit: flang-compiler/f18@8b5c3adf887cf88752937a4fa5507c0d66051d3b Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-09-29 08:02:11 +08:00
struct TypePattern {
CategorySet categorySet;
[flang] buildable checkpoint before merging with master Original-commit: flang-compiler/f18@78c5b8c4110bac9ce93c0845569e5ebbe47f596a Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-02 02:27:45 +08:00
KindCode kindCode{KindCode::none};
[flang] [LLVMify F18] Replace the use std::ostream with LLVM streams llvm::ostream This patch replaces the occurrence of std::ostream by llvm::raw_ostream. In LLVM Coding Standards[1] "All new code should use raw_ostream instead of ostream".[1] As a consequence, this patch also replaces the use of: std::stringstream by llvm::raw_string_ostream or llvm::raw_ostream* std::ofstream by llvm::raw_fd_ostream std::endl by '\n' and flush()[2] std::cout by llvm::outs() and std::cerr by llvm::errs() It also replaces std::strerro by llvm::sys::StrError** , but NOT in Fortran runtime libraries *std::stringstream were replaced by llvm::raw_ostream in all methods that used std::stringstream as a parameter. Moreover, it removes the pointers to these streams. [1]https://llvm.org/docs/CodingStandards.html [2]https://releases.llvm.org/2.5/docs/CodingStandards.html#ll_avoidendl Signed-off-by: Caroline Concatto <caroline.concatto@arm.com> Running clang-format-7 Signed-off-by: Caroline Concatto <caroline.concatto@arm.com> Removing residue of ostream library Signed-off-by: Caroline Concatto <caroline.concatto@arm.com> Original-commit: flang-compiler/f18@a3507d44b8911e6024033aa583c1dc54e0eb89fd Reviewed-on: https://github.com/flang-compiler/f18/pull/1047
2020-02-28 23:11:03 +08:00
llvm::raw_ostream &Dump(llvm::raw_ostream &) const;
[flang] initial intrinsics table Original-commit: flang-compiler/f18@8b5c3adf887cf88752937a4fa5507c0d66051d3b Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-09-29 08:02:11 +08:00
};
[flang] intrinsic pattern matching Original-commit: flang-compiler/f18@ca0ee1660a6449c34c7276284e5e63b90ae97540 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-05 04:43:33 +08:00
// Abbreviations for argument and result patterns in the intrinsic prototypes:
// Match specific kinds of intrinsic types
[flang] Add -i8, -r8, &c. options to f18 development driver Original-commit: flang-compiler/f18@ff7f338126562ce539879a59d3da5707c76ae11a Reviewed-on: https://github.com/flang-compiler/f18/pull/213
2018-10-17 05:42:22 +08:00
static constexpr TypePattern DefaultInt{IntType, KindCode::defaultIntegerKind};
static constexpr TypePattern DefaultReal{RealType, KindCode::defaultRealKind};
static constexpr TypePattern DefaultComplex{
ComplexType, KindCode::defaultRealKind};
static constexpr TypePattern DefaultChar{CharType, KindCode::defaultCharKind};
static constexpr TypePattern DefaultLogical{
[flang] improve naming, silence bogus warnings Original-commit: flang-compiler/f18@f884fcb2c5f55871cbe7b472ca1145e9ffad0fe2 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-16 03:17:30 +08:00
LogicalType, KindCode::defaultLogicalKind};
static constexpr TypePattern BOZ{IntType, KindCode::typeless};
static constexpr TypePattern TEAM_TYPE{IntType, KindCode::teamType};
static constexpr TypePattern DoublePrecision{
RealType, KindCode::doublePrecision};
[flang] Add DOUBLE COMPLEX intrinsics & ASSOCIATED Original-commit: flang-compiler/f18@fbcc2c0b5daf10010e2917c27e4ac5be1d470a12 Reviewed-on: https://github.com/flang-compiler/f18/pull/531 Tree-same-pre-rewrite: false
2019-06-22 05:04:40 +08:00
static constexpr TypePattern DoublePrecisionComplex{
ComplexType, KindCode::doublePrecision};
[flang] Add LOC()/%LOC() intrinsics Original-commit: flang-compiler/f18@3a6b90c9f5c1a21a40323e56e2c26f6161d2f79c Reviewed-on: https://github.com/flang-compiler/f18/pull/538 Tree-same-pre-rewrite: false
2019-07-02 04:22:22 +08:00
static constexpr TypePattern SubscriptInt{IntType, KindCode::subscript};
[flang] intrinsic pattern matching Original-commit: flang-compiler/f18@ca0ee1660a6449c34c7276284e5e63b90ae97540 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-05 04:43:33 +08:00
// Match any kind of some intrinsic or derived types
[flang] improve naming, silence bogus warnings Original-commit: flang-compiler/f18@f884fcb2c5f55871cbe7b472ca1145e9ffad0fe2 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-16 03:17:30 +08:00
static constexpr TypePattern AnyInt{IntType, KindCode::any};
static constexpr TypePattern AnyReal{RealType, KindCode::any};
static constexpr TypePattern AnyIntOrReal{IntOrRealType, KindCode::any};
static constexpr TypePattern AnyComplex{ComplexType, KindCode::any};
[flang] PRECISION, RANGE, RADIX Original-commit: flang-compiler/f18@de0bf5a18f74f2041c85149e52781e8f80d0352b Reviewed-on: https://github.com/flang-compiler/f18/pull/472 Tree-same-pre-rewrite: false
2019-05-30 06:38:33 +08:00
static constexpr TypePattern AnyFloating{FloatingType, KindCode::any};
[flang] improve naming, silence bogus warnings Original-commit: flang-compiler/f18@f884fcb2c5f55871cbe7b472ca1145e9ffad0fe2 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-16 03:17:30 +08:00
static constexpr TypePattern AnyNumeric{NumericType, KindCode::any};
static constexpr TypePattern AnyChar{CharType, KindCode::any};
static constexpr TypePattern AnyLogical{LogicalType, KindCode::any};
static constexpr TypePattern AnyRelatable{RelatableType, KindCode::any};
[flang] basic skeleton of assignment analyzer remove needless template<> on some function overloads dodge bogus compiler warning from gcc 8.1.0 only stricter typing of expressions in symbols adjust modfile12.f90 expected test results add Unwrap, massage folding a bit Use Unwrap to simplify folding Move KindSelector analysis into expression semantics fix crash checkpoint updates to TypeParamInquiry support of %KIND type parameter inquiry equality testing for expressions checkpoint during PDT implementation reformat checkpoint derived type instantiation checkpoint resolve merge debugging failed tests fix failing resolve37.f90 test all existing tests pass clean up all build warnings fix bug update copyright dates fix copyright dates address review comments review comment merge with master after peeling off changes bugfixing new feature fix warning from old g++s tweaks after merging with latest head more bugfixing making modfile17.f90 test work Make kinds into expressions in symbol table types big refactor for deferring kinds in intrinsic types modfile17.f90 test passes clean up TODOs Simplify types as stored in scopes Test KIND parameter default init expressions, debug them Update copyright dates address comments remove dead line address comments Original-commit: flang-compiler/f18@1f43d0a04813dc02909e9952ee479d13f630df4c Reviewed-on: https://github.com/flang-compiler/f18/pull/260 Tree-same-pre-rewrite: false
2018-12-05 02:55:32 +08:00
static constexpr TypePattern AnyIntrinsic{IntrinsicType, KindCode::any};
[flang] Update preprocessing document, commentary Extend documentation on preprocessing IsSimplyContiguous basic skeleton Apply suggested improvements to mod-file.cc Checks for new call13.f90 (15.4.2.2 explicit interfaces) Implement checking for procedures that can be called via an implicit interface Argument checking, test fixing Better argument checking Better derived type compatibility checking Treat externals as if implicitly interfaced Extend IEEE_EXCEPTIONS module so tests still pass with argument checking SAME_TYPE_AS and EXTENDS_TYPE_OF intrinsic inquiry functions Define interfaces for most intrinsic subroutines Better PASS arguments More with PASS() argument Prep for review address comments fix comment Remove formatted expression from specification expression error message per review more review comments Original-commit: flang-compiler/f18@3cca775da9302e3a2acec4a34800cd7666899b5f Reviewed-on: https://github.com/flang-compiler/f18/pull/776
2019-09-17 07:58:13 +08:00
static constexpr TypePattern ExtensibleDerived{DerivedType, KindCode::any};
static constexpr TypePattern AnyData{AnyType, KindCode::any};
[flang] intrinsic pattern matching Original-commit: flang-compiler/f18@ca0ee1660a6449c34c7276284e5e63b90ae97540 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-05 04:43:33 +08:00
[flang] Fix bug flang-compiler/f18#643 Original-commit: flang-compiler/f18@29bb4312e1f2861fa04f847c8e552ca894989593 Reviewed-on: https://github.com/flang-compiler/f18/pull/646
2019-08-13 01:56:18 +08:00
// Type is irrelevant, but not BOZ (for PRESENT(), OPTIONAL(), &c.)
static constexpr TypePattern Addressable{AnyType, KindCode::addressable};
[flang] intrinsic pattern matching Original-commit: flang-compiler/f18@ca0ee1660a6449c34c7276284e5e63b90ae97540 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-05 04:43:33 +08:00
// Match some kind of some intrinsic type(s); all "Same" values must match,
// even when not in the same category (e.g., SameComplex and SameReal).
// Can be used to specify a result so long as at least one argument is
// a "Same".
[flang] improve naming, silence bogus warnings Original-commit: flang-compiler/f18@f884fcb2c5f55871cbe7b472ca1145e9ffad0fe2 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-16 03:17:30 +08:00
static constexpr TypePattern SameInt{IntType, KindCode::same};
static constexpr TypePattern SameReal{RealType, KindCode::same};
static constexpr TypePattern SameIntOrReal{IntOrRealType, KindCode::same};
static constexpr TypePattern SameComplex{ComplexType, KindCode::same};
static constexpr TypePattern SameFloating{FloatingType, KindCode::same};
static constexpr TypePattern SameNumeric{NumericType, KindCode::same};
static constexpr TypePattern SameChar{CharType, KindCode::same};
static constexpr TypePattern SameLogical{LogicalType, KindCode::same};
static constexpr TypePattern SameRelatable{RelatableType, KindCode::same};
[flang] intrinsic pattern matching Original-commit: flang-compiler/f18@ca0ee1660a6449c34c7276284e5e63b90ae97540 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-05 04:43:33 +08:00
static constexpr TypePattern SameIntrinsic{IntrinsicType, KindCode::same};
static constexpr TypePattern SameDerivedType{
CategorySet{TypeCategory::Derived}, KindCode::same};
static constexpr TypePattern SameType{AnyType, KindCode::same};
[flang] Extension: relax "same kind" rules on some intrinsics Original-commit: flang-compiler/f18@ce5130f84bcb78007180ee87661c84b1483a476c Reviewed-on: https://github.com/flang-compiler/f18/pull/590 Tree-same-pre-rewrite: false
2019-07-18 03:51:52 +08:00
// Match some kind of some INTEGER or REAL type(s); when argument types
// &/or kinds differ, their values are converted as if they were operands to
// an intrinsic operation like addition. This is a nonstandard but nearly
// universal extension feature.
static constexpr TypePattern OperandReal{RealType, KindCode::operand};
static constexpr TypePattern OperandIntOrReal{IntOrRealType, KindCode::operand};
[flang] Failed call to CHECK() for call to ASSOCIATED(NULL()) Calling "ASSOCATED(NULL()) was causing an internal check of the compiler to fail. I fixed this by changing the entry for "ASSOCIATED" in the intrinsics table to accept "AnyPointer" which contains a new "KindCode" of "pointerType". I also changed the function "FromActual()" to return a typeless intrinsic when called on a pointer, which duplicates its behavior for BOZ literals. This required changing the analysis of procedure arguments. While testing processing for procedure arguments, I found another bad call to `CHECK()` which I fixed. I made several other changes: -- I implemented constant folding for ASSOCIATED(). -- I fixed handling of NULL() in relational operations. -- I implemented semantic analysis for ASSOCIATED(). -- I noticed that the semantics for ASSOCIATED() are similar to those for pointer assignment. So I extracted the code that pointer assignment uses for procedure pointer compatibility to a place where it could be used by the semantic analysis for ASSOCIATED(). -- I couldn't figure out how to make the general semantic analysis for procedure arguments work with ASSOCIATED()'s second argument, which can be either a pointer or a target. So I stopped using normal semantic analysis for arguments for ASSOCIATED(). -- I added tests for all of this. Differential Revision: https://reviews.llvm.org/D88313
2020-09-26 00:03:17 +08:00
// For ASSOCIATED, the first argument is a typeless pointer
static constexpr TypePattern AnyPointer{AnyType, KindCode::nullPointerType};
[flang] remove arg->intValue field Original-commit: flang-compiler/f18@721dc920227378d09d89758903c50538b61ffec3 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-10 03:07:29 +08:00
// For DOT_PRODUCT and MATMUL, the result type depends on the arguments
[flang] improve naming, silence bogus warnings Original-commit: flang-compiler/f18@f884fcb2c5f55871cbe7b472ca1145e9ffad0fe2 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-16 03:17:30 +08:00
static constexpr TypePattern ResultLogical{LogicalType, KindCode::likeMultiply};
static constexpr TypePattern ResultNumeric{NumericType, KindCode::likeMultiply};
[flang] remove arg->intValue field Original-commit: flang-compiler/f18@721dc920227378d09d89758903c50538b61ffec3 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-10 03:07:29 +08:00
[flang] intrinsic pattern matching Original-commit: flang-compiler/f18@ca0ee1660a6449c34c7276284e5e63b90ae97540 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-05 04:43:33 +08:00
// Result types with known category and KIND=
[flang] improve naming, silence bogus warnings Original-commit: flang-compiler/f18@f884fcb2c5f55871cbe7b472ca1145e9ffad0fe2 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-16 03:17:30 +08:00
static constexpr TypePattern KINDInt{IntType, KindCode::effectiveKind};
static constexpr TypePattern KINDReal{RealType, KindCode::effectiveKind};
static constexpr TypePattern KINDComplex{ComplexType, KindCode::effectiveKind};
static constexpr TypePattern KINDChar{CharType, KindCode::effectiveKind};
static constexpr TypePattern KINDLogical{LogicalType, KindCode::effectiveKind};
[flang] initial intrinsics table Original-commit: flang-compiler/f18@8b5c3adf887cf88752937a4fa5507c0d66051d3b Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-09-29 08:02:11 +08:00
// The default rank pattern for dummy arguments and function results is
// "elemental".
[flang] unit testing, better error messages Original-commit: flang-compiler/f18@f3876008d03751fff5d9490cbb1c7b7539e5c095 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-13 07:01:55 +08:00
ENUM_CLASS(Rank,
[flang] Reformat with latest clang-format and .clang-format Original-commit: flang-compiler/f18@9fe84f45d7fd685051004678d6b5775dcc4c6f8f Reviewed-on: https://github.com/flang-compiler/f18/pull/1094
2020-03-29 12:00:16 +08:00
elemental, // scalar, or array that conforms with other array arguments
elementalOrBOZ, // elemental, or typeless BOZ literal scalar
[flang] unit testing, better error messages Original-commit: flang-compiler/f18@f3876008d03751fff5d9490cbb1c7b7539e5c095 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-13 07:01:55 +08:00
scalar, vector,
[flang] Reformat with latest clang-format and .clang-format Original-commit: flang-compiler/f18@9fe84f45d7fd685051004678d6b5775dcc4c6f8f Reviewed-on: https://github.com/flang-compiler/f18/pull/1094
2020-03-29 12:00:16 +08:00
shape, // INTEGER vector of known length and no negative element
[flang] unit testing, better error messages Original-commit: flang-compiler/f18@f3876008d03751fff5d9490cbb1c7b7539e5c095 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-13 07:01:55 +08:00
matrix,
[flang] Reformat with latest clang-format and .clang-format Original-commit: flang-compiler/f18@9fe84f45d7fd685051004678d6b5775dcc4c6f8f Reviewed-on: https://github.com/flang-compiler/f18/pull/1094
2020-03-29 12:00:16 +08:00
array, // not scalar, rank is known and greater than zero
known, // rank is known and can be scalar
anyOrAssumedRank, // rank can be unknown; assumed-type TYPE(*) allowed
conformable, // scalar, or array of same rank & shape as "array" argument
reduceOperation, // a pure function with constraints for REDUCE
dimReduced, // scalar if no DIM= argument, else rank(array)-1
[flang] Correct shape analysis for transformational intrinsic functions Correct the analysis of references to transformational intrinsic functions that have different semantics based on the presence or absence of a DIM= argument; add shape analysis for UNPACK(). Differential Revision: https://reviews.llvm.org/D94716
2021-01-15 04:54:31 +08:00
dimRemovedOrScalar, // rank(array)-1 (less DIM) or scalar
locReduced, // vector(1:rank) if no DIM= argument, else rank(array)-1
[flang] Reformat with latest clang-format and .clang-format Original-commit: flang-compiler/f18@9fe84f45d7fd685051004678d6b5775dcc4c6f8f Reviewed-on: https://github.com/flang-compiler/f18/pull/1094
2020-03-29 12:00:16 +08:00
rankPlus1, // rank(known)+1
shaped, // rank is length of SHAPE vector
[flang] unit testing, better error messages Original-commit: flang-compiler/f18@f3876008d03751fff5d9490cbb1c7b7539e5c095 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-13 07:01:55 +08:00
)
[flang] initial intrinsics table Original-commit: flang-compiler/f18@8b5c3adf887cf88752937a4fa5507c0d66051d3b Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-09-29 08:02:11 +08:00
[flang] Correct shape analysis for transformational intrinsic functions Correct the analysis of references to transformational intrinsic functions that have different semantics based on the presence or absence of a DIM= argument; add shape analysis for UNPACK(). Differential Revision: https://reviews.llvm.org/D94716
2021-01-15 04:54:31 +08:00
ENUM_CLASS(Optionality, required, optional, missing,
[flang] Reformat with latest clang-format and .clang-format Original-commit: flang-compiler/f18@9fe84f45d7fd685051004678d6b5775dcc4c6f8f Reviewed-on: https://github.com/flang-compiler/f18/pull/1094
2020-03-29 12:00:16 +08:00
defaultsToSameKind, // for MatchingDefaultKIND
defaultsToDefaultForResult, // for DefaultingKIND
defaultsToSizeKind, // for SizeDefaultKIND
repeats, // for MAX/MIN and their several variants
[flang] unit testing, better error messages Original-commit: flang-compiler/f18@f3876008d03751fff5d9490cbb1c7b7539e5c095 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-13 07:01:55 +08:00
)
[flang] initial intrinsics table Original-commit: flang-compiler/f18@8b5c3adf887cf88752937a4fa5507c0d66051d3b Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-09-29 08:02:11 +08:00
struct IntrinsicDummyArgument {
[flang] buildable checkpoint before merging with master Original-commit: flang-compiler/f18@78c5b8c4110bac9ce93c0845569e5ebbe47f596a Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-02 02:27:45 +08:00
const char *keyword{nullptr};
[flang] initial intrinsics table Original-commit: flang-compiler/f18@8b5c3adf887cf88752937a4fa5507c0d66051d3b Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-09-29 08:02:11 +08:00
TypePattern typePattern;
[flang] intrinsic pattern matching Original-commit: flang-compiler/f18@ca0ee1660a6449c34c7276284e5e63b90ae97540 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-05 04:43:33 +08:00
Rank rank{Rank::elemental};
[flang] error messages Original-commit: flang-compiler/f18@392a7330736a8fd444ef92ed5c8ef7dcbc94d461 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-06 02:32:54 +08:00
Optionality optionality{Optionality::required};
[flang] Document and use intrinsic subroutine argument intents Check INTENT(OUT)/INTENT(INOUT) constraints for actual argument of intrinsic procedure calls. - Adding a common::Intent field to the IntrinsicDummyArgument in the intrinsic table. - Propagating it to the DummyDataObject intent field so that it can later be used in CheckExplicitDataArg semantic checks. - Add related tests. - Fix regression (C846 false error), C846 INTENT(OUT) rule does not apply to intrinsic call. Propagate the information that we are in an intrinsic call up to CheckExplicitDataArg (that is doing this check). Still enforce C846 on intrinsics other than MOVE_ALLOC (for which allocatable coarrays are explicitly allowed) since it's not clear it is allowed in all intrinsics and allowing this would lead to runtime penalties in the intrinsic runtime. Differential Revision: https://reviews.llvm.org/D89473
2020-10-20 18:39:26 +08:00
common::Intent intent{common::Intent::In};
[flang] [LLVMify F18] Replace the use std::ostream with LLVM streams llvm::ostream This patch replaces the occurrence of std::ostream by llvm::raw_ostream. In LLVM Coding Standards[1] "All new code should use raw_ostream instead of ostream".[1] As a consequence, this patch also replaces the use of: std::stringstream by llvm::raw_string_ostream or llvm::raw_ostream* std::ofstream by llvm::raw_fd_ostream std::endl by '\n' and flush()[2] std::cout by llvm::outs() and std::cerr by llvm::errs() It also replaces std::strerro by llvm::sys::StrError** , but NOT in Fortran runtime libraries *std::stringstream were replaced by llvm::raw_ostream in all methods that used std::stringstream as a parameter. Moreover, it removes the pointers to these streams. [1]https://llvm.org/docs/CodingStandards.html [2]https://releases.llvm.org/2.5/docs/CodingStandards.html#ll_avoidendl Signed-off-by: Caroline Concatto <caroline.concatto@arm.com> Running clang-format-7 Signed-off-by: Caroline Concatto <caroline.concatto@arm.com> Removing residue of ostream library Signed-off-by: Caroline Concatto <caroline.concatto@arm.com> Original-commit: flang-compiler/f18@a3507d44b8911e6024033aa583c1dc54e0eb89fd Reviewed-on: https://github.com/flang-compiler/f18/pull/1047
2020-02-28 23:11:03 +08:00
llvm::raw_ostream &Dump(llvm::raw_ostream &) const;
[flang] initial intrinsics table Original-commit: flang-compiler/f18@8b5c3adf887cf88752937a4fa5507c0d66051d3b Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-09-29 08:02:11 +08:00
};
[flang] intrinsic pattern matching Original-commit: flang-compiler/f18@ca0ee1660a6449c34c7276284e5e63b90ae97540 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-05 04:43:33 +08:00
// constexpr abbreviations for popular arguments:
// DefaultingKIND is a KIND= argument whose default value is the appropriate
// KIND(0), KIND(0.0), KIND(''), &c. value for the function result.
[flang] error messages Original-commit: flang-compiler/f18@392a7330736a8fd444ef92ed5c8ef7dcbc94d461 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-06 02:32:54 +08:00
static constexpr IntrinsicDummyArgument DefaultingKIND{"kind",
[flang] improve naming, silence bogus warnings Original-commit: flang-compiler/f18@f884fcb2c5f55871cbe7b472ca1145e9ffad0fe2 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-16 03:17:30 +08:00
{IntType, KindCode::kindArg}, Rank::scalar,
[flang] Dodge gcc 8.2.0 build problem (NFC) Add explicit member initializers to the declarations of some constexpr values added in a recent patch to avoid an apparent problem with gcc 8.2.0 with default initializers. Differential revision: https://reviews.llvm.org/D90696
2020-11-04 02:45:01 +08:00
Optionality::defaultsToDefaultForResult, common::Intent::In};
[flang] intrinsic pattern matching Original-commit: flang-compiler/f18@ca0ee1660a6449c34c7276284e5e63b90ae97540 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-05 04:43:33 +08:00
// MatchingDefaultKIND is a KIND= argument whose default value is the
// kind of any "Same" function argument (viz., the one whose kind pattern is
// "same").
[flang] error messages Original-commit: flang-compiler/f18@392a7330736a8fd444ef92ed5c8ef7dcbc94d461 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-06 02:32:54 +08:00
static constexpr IntrinsicDummyArgument MatchingDefaultKIND{"kind",
[flang] Dodge gcc 8.2.0 build problem (NFC) Add explicit member initializers to the declarations of some constexpr values added in a recent patch to avoid an apparent problem with gcc 8.2.0 with default initializers. Differential revision: https://reviews.llvm.org/D90696
2020-11-04 02:45:01 +08:00
{IntType, KindCode::kindArg}, Rank::scalar, Optionality::defaultsToSameKind,
common::Intent::In};
[flang] enable semantic analysis by default back out -Mnolargearray default temporarily Fix C_F_POINTER(SHAPE=) argument check, it can be any kind of integer Revert default result kind of SIZE() & al. to standard by default Remove needless usage of -fdebug-semantics Original-commit: flang-compiler/f18@57058a5b163eaa90c7e0f387ea4918f9efa8184c Reviewed-on: https://github.com/flang-compiler/f18/pull/907
2020-01-04 08:32:23 +08:00
// SizeDefaultKind is a KIND= argument whose default value should be
// the kind of INTEGER used for address calculations, and can be
// set so with a compiler flag; but the standard mandates the
// kind of default INTEGER.
static constexpr IntrinsicDummyArgument SizeDefaultKIND{"kind",
[flang] Dodge gcc 8.2.0 build problem (NFC) Add explicit member initializers to the declarations of some constexpr values added in a recent patch to avoid an apparent problem with gcc 8.2.0 with default initializers. Differential revision: https://reviews.llvm.org/D90696
2020-11-04 02:45:01 +08:00
{IntType, KindCode::kindArg}, Rank::scalar, Optionality::defaultsToSizeKind,
common::Intent::In};
static constexpr IntrinsicDummyArgument RequiredDIM{"dim",
{IntType, KindCode::dimArg}, Rank::scalar, Optionality::required,
common::Intent::In};
static constexpr IntrinsicDummyArgument OptionalDIM{"dim",
{IntType, KindCode::dimArg}, Rank::scalar, Optionality::optional,
common::Intent::In};
[flang] Correct shape analysis for transformational intrinsic functions Correct the analysis of references to transformational intrinsic functions that have different semantics based on the presence or absence of a DIM= argument; add shape analysis for UNPACK(). Differential Revision: https://reviews.llvm.org/D94716
2021-01-15 04:54:31 +08:00
static constexpr IntrinsicDummyArgument MissingDIM{"dim",
{IntType, KindCode::dimArg}, Rank::scalar, Optionality::missing,
common::Intent::In};
[flang] Dodge gcc 8.2.0 build problem (NFC) Add explicit member initializers to the declarations of some constexpr values added in a recent patch to avoid an apparent problem with gcc 8.2.0 with default initializers. Differential revision: https://reviews.llvm.org/D90696
2020-11-04 02:45:01 +08:00
static constexpr IntrinsicDummyArgument OptionalMASK{"mask", AnyLogical,
Rank::conformable, Optionality::optional, common::Intent::In};
[flang] initial intrinsics table Original-commit: flang-compiler/f18@8b5c3adf887cf88752937a4fa5507c0d66051d3b Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-09-29 08:02:11 +08:00
struct IntrinsicInterface {
[flang] Reformat with latest clang-format and .clang-format Original-commit: flang-compiler/f18@9fe84f45d7fd685051004678d6b5775dcc4c6f8f Reviewed-on: https://github.com/flang-compiler/f18/pull/1094
2020-03-29 12:00:16 +08:00
static constexpr int maxArguments{7}; // if not a MAX/MIN(...)
[flang] buildable checkpoint before merging with master Original-commit: flang-compiler/f18@78c5b8c4110bac9ce93c0845569e5ebbe47f596a Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-02 02:27:45 +08:00
const char *name{nullptr};
[flang] initial intrinsics table Original-commit: flang-compiler/f18@8b5c3adf887cf88752937a4fa5507c0d66051d3b Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-09-29 08:02:11 +08:00
IntrinsicDummyArgument dummy[maxArguments];
TypePattern result;
[flang] intrinsic pattern matching Original-commit: flang-compiler/f18@ca0ee1660a6449c34c7276284e5e63b90ae97540 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-05 04:43:33 +08:00
Rank rank{Rank::elemental};
[flang] New implementation for checks for constraints C741 through C750 Summary: Most of these checks were already implemented, and I just added references to them to the code and tests. Also, much of this code was already reviewed in the old flang/f18 GitHub repository, but I didn't get to merge it before we switched repositories. I implemented the check for C747 to not allow coarray components in derived types that are of type C_PTR, C_FUNPTR, or type TEAM_TYPE. I implemented the check for C748 that requires a data component whose type has a coarray ultimate component to be a nonpointer, nonallocatable scalar and not be a coarray. I implemented the check for C750 that adds additional restrictions to the bounds expressions of a derived type component that's an array. These bounds expressions are sepcification expressions as defined in 10.1.11. There was already code in lib/Evaluate/check-expression.cpp to check semantics for specification expressions, but it did not check for the extra requirements of C750. C750 prohibits specification functions, the intrinsic functions ALLOCATED, ASSOCIATED, EXTENDS_TYPE_OF, PRESENT, and SAME_TYPE_AS. It also requires every specification inquiry reference to be a constant expression, and requires that the value of the bound not depend on the value of a variable. To implement these additional checks, I added code to the intrinsic proc table to get the intrinsic class of a procedure. I also added an enumeration to distinguish between specification expressions for derived type component bounds versus for type parameters. I then changed the code to pass an enumeration value to "CheckSpecificationExpr()" to indicate that the expression was a bounds expression and used this value to determine whether to emit an error message when violations of C750 are found. I changed the implementation of IsPureProcedure() to handle statement functions and changed some references in the code that tested for the PURE attribute to call IsPureProcedure(). I also fixed some unrelated tests that got new errors when I implemented these new checks. Reviewers: tskeith, DavidTruby, sscalpone Subscribers: jfb, llvm-commits Tags: #llvm, #flang Differential Revision: https://reviews.llvm.org/D79263
2020-05-02 04:00:28 +08:00
IntrinsicClass intrinsicClass{IntrinsicClass::elementalFunction};
[flang] refactor a bit, and rearrange actual arguments into dummy order on intrinsic calls Original-commit: flang-compiler/f18@1f50ace68b00a7db4b75ebce5616032501e48457 Reviewed-on: https://github.com/flang-compiler/f18/pull/219 Tree-same-pre-rewrite: false
2018-10-18 06:09:48 +08:00
std::optional<SpecificCall> Match(const CallCharacteristics &,
[flang] Move default intrinsic type kinds from lib/semantics to lib/common Original-commit: flang-compiler/f18@887e72dd613f411808d1b9e9e7b64601a3b67af8 Reviewed-on: https://github.com/flang-compiler/f18/pull/265 Tree-same-pre-rewrite: false
2019-01-19 04:40:47 +08:00
const common::IntrinsicTypeDefaultKinds &, ActualArguments &,
[flang] Fold array operations Original-commit: flang-compiler/f18@e6c86ecfd10b77aeac63722c08487ae5de0a0c27 Reviewed-on: https://github.com/flang-compiler/f18/pull/420
2019-04-19 05:11:15 +08:00
FoldingContext &context) const;
[flang] checkpoint Original-commit: flang-compiler/f18@e7b0f456c9bba153c51c6e775a60e6d01e488271 Reviewed-on: https://github.com/flang-compiler/f18/pull/304 Tree-same-pre-rewrite: false
2019-02-23 07:45:30 +08:00
int CountArguments() const;
[flang] [LLVMify F18] Replace the use std::ostream with LLVM streams llvm::ostream This patch replaces the occurrence of std::ostream by llvm::raw_ostream. In LLVM Coding Standards[1] "All new code should use raw_ostream instead of ostream".[1] As a consequence, this patch also replaces the use of: std::stringstream by llvm::raw_string_ostream or llvm::raw_ostream* std::ofstream by llvm::raw_fd_ostream std::endl by '\n' and flush()[2] std::cout by llvm::outs() and std::cerr by llvm::errs() It also replaces std::strerro by llvm::sys::StrError** , but NOT in Fortran runtime libraries *std::stringstream were replaced by llvm::raw_ostream in all methods that used std::stringstream as a parameter. Moreover, it removes the pointers to these streams. [1]https://llvm.org/docs/CodingStandards.html [2]https://releases.llvm.org/2.5/docs/CodingStandards.html#ll_avoidendl Signed-off-by: Caroline Concatto <caroline.concatto@arm.com> Running clang-format-7 Signed-off-by: Caroline Concatto <caroline.concatto@arm.com> Removing residue of ostream library Signed-off-by: Caroline Concatto <caroline.concatto@arm.com> Original-commit: flang-compiler/f18@a3507d44b8911e6024033aa583c1dc54e0eb89fd Reviewed-on: https://github.com/flang-compiler/f18/pull/1047
2020-02-28 23:11:03 +08:00
llvm::raw_ostream &Dump(llvm::raw_ostream &) const;
[flang] initial intrinsics table Original-commit: flang-compiler/f18@8b5c3adf887cf88752937a4fa5507c0d66051d3b Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-09-29 08:02:11 +08:00
};
[flang] checkpoint Original-commit: flang-compiler/f18@e7b0f456c9bba153c51c6e775a60e6d01e488271 Reviewed-on: https://github.com/flang-compiler/f18/pull/304 Tree-same-pre-rewrite: false
2019-02-23 07:45:30 +08:00
int IntrinsicInterface::CountArguments() const {
int n{0};
[flang] Remove most comparisons to nullptr Remove needless usage of has_value() Original-commit: flang-compiler/f18@1da7fcf7a54066b18e521620ecedb79c7cd2eb97 Reviewed-on: https://github.com/flang-compiler/f18/pull/822
2019-11-10 01:29:31 +08:00
while (n < maxArguments && dummy[n].keyword) {
[flang] checkpoint Original-commit: flang-compiler/f18@e7b0f456c9bba153c51c6e775a60e6d01e488271 Reviewed-on: https://github.com/flang-compiler/f18/pull/304 Tree-same-pre-rewrite: false
2019-02-23 07:45:30 +08:00
++n;
}
return n;
}
[flang] review comments Original-commit: flang-compiler/f18@daaf080dbcc3c6a051aa9444cd141077890b0472 Reviewed-on: https://github.com/flang-compiler/f18/pull/212
2018-10-16 04:39:51 +08:00
// GENERIC INTRINSIC FUNCTION INTERFACES
// Each entry in this table defines a pattern. Some intrinsic
// functions have more than one such pattern. Besides the name
// of the intrinsic function, each pattern has specifications for
// the dummy arguments and for the result of the function.
[flang] work in progress checkpoint: changes build, tests all pass many fixes, ready to test more Further CLASS(*) support More fixes for CLASS(*) Hide data members of DynamicType implement PRESENT() intrinsic Original-commit: flang-compiler/f18@044ba12c20f77c130e3c468914ddc2d6c8652c6e Reviewed-on: https://github.com/flang-compiler/f18/pull/466 Tree-same-pre-rewrite: false
2019-05-14 00:33:18 +08:00
// The dummy argument patterns each have a name (these are from the
[flang] review comments Original-commit: flang-compiler/f18@daaf080dbcc3c6a051aa9444cd141077890b0472 Reviewed-on: https://github.com/flang-compiler/f18/pull/212
2018-10-16 04:39:51 +08:00
// standard, but rarely appear in actual code), a type and kind
// pattern, allowable ranks, and optionality indicators.
// Be advised, the default rank pattern is "elemental".
[flang] buildable checkpoint before merging with master Original-commit: flang-compiler/f18@78c5b8c4110bac9ce93c0845569e5ebbe47f596a Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-02 02:27:45 +08:00
static const IntrinsicInterface genericIntrinsicFunction[]{
[flang] intrinsic pattern matching Original-commit: flang-compiler/f18@ca0ee1660a6449c34c7276284e5e63b90ae97540 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-05 04:43:33 +08:00
{"abs", {{"a", SameIntOrReal}}, SameIntOrReal},
{"abs", {{"a", SameComplex}}, SameReal},
[flang] Allow BOZ argument to more intrinsics; generalize BOZ conversions in folding Original-commit: flang-compiler/f18@6df0136ee889f3c27b33d3ddac970af1b7a52c68 Reviewed-on: https://github.com/flang-compiler/f18/pull/557 Tree-same-pre-rewrite: false
2019-07-10 02:54:11 +08:00
{"achar", {{"i", AnyInt, Rank::elementalOrBOZ}, DefaultingKIND}, KINDChar},
[flang] intrinsic pattern matching Original-commit: flang-compiler/f18@ca0ee1660a6449c34c7276284e5e63b90ae97540 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-05 04:43:33 +08:00
{"acos", {{"x", SameFloating}}, SameFloating},
[flang] Apply implicit typing to names in COMMON that appear in specification expressions Extend semantic analysis of expressions to catch missing cases Fix statement function semantics, add degree trig intrinsics Add GetUltimate to rewrite of bare namelist Address review comments Original-commit: flang-compiler/f18@52ff319de2e750733660d8e7e938e09159a3c11c Reviewed-on: https://github.com/flang-compiler/f18/pull/871
2019-12-12 07:06:24 +08:00
{"acosd", {{"x", SameFloating}}, SameFloating},
[flang] intrinsic pattern matching Original-commit: flang-compiler/f18@ca0ee1660a6449c34c7276284e5e63b90ae97540 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-05 04:43:33 +08:00
{"acosh", {{"x", SameFloating}}, SameFloating},
{"adjustl", {{"string", SameChar}}, SameChar},
{"adjustr", {{"string", SameChar}}, SameChar},
{"aimag", {{"x", SameComplex}}, SameReal},
{"aint", {{"a", SameReal}, MatchingDefaultKIND}, KINDReal},
{"all", {{"mask", SameLogical, Rank::array}, OptionalDIM}, SameLogical,
[flang] New implementation for checks for constraints C741 through C750 Summary: Most of these checks were already implemented, and I just added references to them to the code and tests. Also, much of this code was already reviewed in the old flang/f18 GitHub repository, but I didn't get to merge it before we switched repositories. I implemented the check for C747 to not allow coarray components in derived types that are of type C_PTR, C_FUNPTR, or type TEAM_TYPE. I implemented the check for C748 that requires a data component whose type has a coarray ultimate component to be a nonpointer, nonallocatable scalar and not be a coarray. I implemented the check for C750 that adds additional restrictions to the bounds expressions of a derived type component that's an array. These bounds expressions are sepcification expressions as defined in 10.1.11. There was already code in lib/Evaluate/check-expression.cpp to check semantics for specification expressions, but it did not check for the extra requirements of C750. C750 prohibits specification functions, the intrinsic functions ALLOCATED, ASSOCIATED, EXTENDS_TYPE_OF, PRESENT, and SAME_TYPE_AS. It also requires every specification inquiry reference to be a constant expression, and requires that the value of the bound not depend on the value of a variable. To implement these additional checks, I added code to the intrinsic proc table to get the intrinsic class of a procedure. I also added an enumeration to distinguish between specification expressions for derived type component bounds versus for type parameters. I then changed the code to pass an enumeration value to "CheckSpecificationExpr()" to indicate that the expression was a bounds expression and used this value to determine whether to emit an error message when violations of C750 are found. I changed the implementation of IsPureProcedure() to handle statement functions and changed some references in the code that tested for the PURE attribute to call IsPureProcedure(). I also fixed some unrelated tests that got new errors when I implemented these new checks. Reviewers: tskeith, DavidTruby, sscalpone Subscribers: jfb, llvm-commits Tags: #llvm, #flang Differential Revision: https://reviews.llvm.org/D79263
2020-05-02 04:00:28 +08:00
Rank::dimReduced, IntrinsicClass::transformationalFunction},
{"allocated", {{"array", AnyData, Rank::array}}, DefaultLogical,
Rank::elemental, IntrinsicClass::inquiryFunction},
{"allocated", {{"scalar", AnyData, Rank::scalar}}, DefaultLogical,
Rank::elemental, IntrinsicClass::inquiryFunction},
[flang] intrinsic pattern matching Original-commit: flang-compiler/f18@ca0ee1660a6449c34c7276284e5e63b90ae97540 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-05 04:43:33 +08:00
{"anint", {{"a", SameReal}, MatchingDefaultKIND}, KINDReal},
{"any", {{"mask", SameLogical, Rank::array}, OptionalDIM}, SameLogical,
[flang] New implementation for checks for constraints C741 through C750 Summary: Most of these checks were already implemented, and I just added references to them to the code and tests. Also, much of this code was already reviewed in the old flang/f18 GitHub repository, but I didn't get to merge it before we switched repositories. I implemented the check for C747 to not allow coarray components in derived types that are of type C_PTR, C_FUNPTR, or type TEAM_TYPE. I implemented the check for C748 that requires a data component whose type has a coarray ultimate component to be a nonpointer, nonallocatable scalar and not be a coarray. I implemented the check for C750 that adds additional restrictions to the bounds expressions of a derived type component that's an array. These bounds expressions are sepcification expressions as defined in 10.1.11. There was already code in lib/Evaluate/check-expression.cpp to check semantics for specification expressions, but it did not check for the extra requirements of C750. C750 prohibits specification functions, the intrinsic functions ALLOCATED, ASSOCIATED, EXTENDS_TYPE_OF, PRESENT, and SAME_TYPE_AS. It also requires every specification inquiry reference to be a constant expression, and requires that the value of the bound not depend on the value of a variable. To implement these additional checks, I added code to the intrinsic proc table to get the intrinsic class of a procedure. I also added an enumeration to distinguish between specification expressions for derived type component bounds versus for type parameters. I then changed the code to pass an enumeration value to "CheckSpecificationExpr()" to indicate that the expression was a bounds expression and used this value to determine whether to emit an error message when violations of C750 are found. I changed the implementation of IsPureProcedure() to handle statement functions and changed some references in the code that tested for the PURE attribute to call IsPureProcedure(). I also fixed some unrelated tests that got new errors when I implemented these new checks. Reviewers: tskeith, DavidTruby, sscalpone Subscribers: jfb, llvm-commits Tags: #llvm, #flang Differential Revision: https://reviews.llvm.org/D79263
2020-05-02 04:00:28 +08:00
Rank::dimReduced, IntrinsicClass::transformationalFunction},
[flang] intrinsic pattern matching Original-commit: flang-compiler/f18@ca0ee1660a6449c34c7276284e5e63b90ae97540 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-05 04:43:33 +08:00
{"asin", {{"x", SameFloating}}, SameFloating},
[flang] Apply implicit typing to names in COMMON that appear in specification expressions Extend semantic analysis of expressions to catch missing cases Fix statement function semantics, add degree trig intrinsics Add GetUltimate to rewrite of bare namelist Address review comments Original-commit: flang-compiler/f18@52ff319de2e750733660d8e7e938e09159a3c11c Reviewed-on: https://github.com/flang-compiler/f18/pull/871
2019-12-12 07:06:24 +08:00
{"asind", {{"x", SameFloating}}, SameFloating},
[flang] intrinsic pattern matching Original-commit: flang-compiler/f18@ca0ee1660a6449c34c7276284e5e63b90ae97540 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-05 04:43:33 +08:00
{"asinh", {{"x", SameFloating}}, SameFloating},
[flang] Add DOUBLE COMPLEX intrinsics & ASSOCIATED Original-commit: flang-compiler/f18@fbcc2c0b5daf10010e2917c27e4ac5be1d470a12 Reviewed-on: https://github.com/flang-compiler/f18/pull/531 Tree-same-pre-rewrite: false
2019-06-22 05:04:40 +08:00
{"associated",
[flang] Failed call to CHECK() for call to ASSOCIATED(NULL()) Calling "ASSOCATED(NULL()) was causing an internal check of the compiler to fail. I fixed this by changing the entry for "ASSOCIATED" in the intrinsics table to accept "AnyPointer" which contains a new "KindCode" of "pointerType". I also changed the function "FromActual()" to return a typeless intrinsic when called on a pointer, which duplicates its behavior for BOZ literals. This required changing the analysis of procedure arguments. While testing processing for procedure arguments, I found another bad call to `CHECK()` which I fixed. I made several other changes: -- I implemented constant folding for ASSOCIATED(). -- I fixed handling of NULL() in relational operations. -- I implemented semantic analysis for ASSOCIATED(). -- I noticed that the semantics for ASSOCIATED() are similar to those for pointer assignment. So I extracted the code that pointer assignment uses for procedure pointer compatibility to a place where it could be used by the semantic analysis for ASSOCIATED(). -- I couldn't figure out how to make the general semantic analysis for procedure arguments work with ASSOCIATED()'s second argument, which can be either a pointer or a target. So I stopped using normal semantic analysis for arguments for ASSOCIATED(). -- I added tests for all of this. Differential Revision: https://reviews.llvm.org/D88313
2020-09-26 00:03:17 +08:00
{{"pointer", AnyPointer, Rank::known},
[flang] Fix bug flang-compiler/f18#643 Original-commit: flang-compiler/f18@29bb4312e1f2861fa04f847c8e552ca894989593 Reviewed-on: https://github.com/flang-compiler/f18/pull/646
2019-08-13 01:56:18 +08:00
{"target", Addressable, Rank::known, Optionality::optional}},
[flang] New implementation for checks for constraints C741 through C750 Summary: Most of these checks were already implemented, and I just added references to them to the code and tests. Also, much of this code was already reviewed in the old flang/f18 GitHub repository, but I didn't get to merge it before we switched repositories. I implemented the check for C747 to not allow coarray components in derived types that are of type C_PTR, C_FUNPTR, or type TEAM_TYPE. I implemented the check for C748 that requires a data component whose type has a coarray ultimate component to be a nonpointer, nonallocatable scalar and not be a coarray. I implemented the check for C750 that adds additional restrictions to the bounds expressions of a derived type component that's an array. These bounds expressions are sepcification expressions as defined in 10.1.11. There was already code in lib/Evaluate/check-expression.cpp to check semantics for specification expressions, but it did not check for the extra requirements of C750. C750 prohibits specification functions, the intrinsic functions ALLOCATED, ASSOCIATED, EXTENDS_TYPE_OF, PRESENT, and SAME_TYPE_AS. It also requires every specification inquiry reference to be a constant expression, and requires that the value of the bound not depend on the value of a variable. To implement these additional checks, I added code to the intrinsic proc table to get the intrinsic class of a procedure. I also added an enumeration to distinguish between specification expressions for derived type component bounds versus for type parameters. I then changed the code to pass an enumeration value to "CheckSpecificationExpr()" to indicate that the expression was a bounds expression and used this value to determine whether to emit an error message when violations of C750 are found. I changed the implementation of IsPureProcedure() to handle statement functions and changed some references in the code that tested for the PURE attribute to call IsPureProcedure(). I also fixed some unrelated tests that got new errors when I implemented these new checks. Reviewers: tskeith, DavidTruby, sscalpone Subscribers: jfb, llvm-commits Tags: #llvm, #flang Differential Revision: https://reviews.llvm.org/D79263
2020-05-02 04:00:28 +08:00
DefaultLogical, Rank::elemental, IntrinsicClass::inquiryFunction},
[flang] intrinsic pattern matching Original-commit: flang-compiler/f18@ca0ee1660a6449c34c7276284e5e63b90ae97540 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-05 04:43:33 +08:00
{"atan", {{"x", SameFloating}}, SameFloating},
[flang] Apply implicit typing to names in COMMON that appear in specification expressions Extend semantic analysis of expressions to catch missing cases Fix statement function semantics, add degree trig intrinsics Add GetUltimate to rewrite of bare namelist Address review comments Original-commit: flang-compiler/f18@52ff319de2e750733660d8e7e938e09159a3c11c Reviewed-on: https://github.com/flang-compiler/f18/pull/871
2019-12-12 07:06:24 +08:00
{"atand", {{"x", SameFloating}}, SameFloating},
[flang] Extension: relax "same kind" rules on some intrinsics Original-commit: flang-compiler/f18@ce5130f84bcb78007180ee87661c84b1483a476c Reviewed-on: https://github.com/flang-compiler/f18/pull/590 Tree-same-pre-rewrite: false
2019-07-18 03:51:52 +08:00
{"atan", {{"y", OperandReal}, {"x", OperandReal}}, OperandReal},
[flang] Apply implicit typing to names in COMMON that appear in specification expressions Extend semantic analysis of expressions to catch missing cases Fix statement function semantics, add degree trig intrinsics Add GetUltimate to rewrite of bare namelist Address review comments Original-commit: flang-compiler/f18@52ff319de2e750733660d8e7e938e09159a3c11c Reviewed-on: https://github.com/flang-compiler/f18/pull/871
2019-12-12 07:06:24 +08:00
{"atand", {{"y", OperandReal}, {"x", OperandReal}}, OperandReal},
[flang] Extension: relax "same kind" rules on some intrinsics Original-commit: flang-compiler/f18@ce5130f84bcb78007180ee87661c84b1483a476c Reviewed-on: https://github.com/flang-compiler/f18/pull/590 Tree-same-pre-rewrite: false
2019-07-18 03:51:52 +08:00
{"atan2", {{"y", OperandReal}, {"x", OperandReal}}, OperandReal},
[flang] Apply implicit typing to names in COMMON that appear in specification expressions Extend semantic analysis of expressions to catch missing cases Fix statement function semantics, add degree trig intrinsics Add GetUltimate to rewrite of bare namelist Address review comments Original-commit: flang-compiler/f18@52ff319de2e750733660d8e7e938e09159a3c11c Reviewed-on: https://github.com/flang-compiler/f18/pull/871
2019-12-12 07:06:24 +08:00
{"atan2d", {{"y", OperandReal}, {"x", OperandReal}}, OperandReal},
[flang] intrinsic pattern matching Original-commit: flang-compiler/f18@ca0ee1660a6449c34c7276284e5e63b90ae97540 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-05 04:43:33 +08:00
{"atanh", {{"x", SameFloating}}, SameFloating},
{"bessel_j0", {{"x", SameReal}}, SameReal},
{"bessel_j1", {{"x", SameReal}}, SameReal},
{"bessel_jn", {{"n", AnyInt}, {"x", SameReal}}, SameReal},
[flang] remove arg->intValue field Original-commit: flang-compiler/f18@721dc920227378d09d89758903c50538b61ffec3 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-10 03:07:29 +08:00
{"bessel_jn",
{{"n1", AnyInt, Rank::scalar}, {"n2", AnyInt, Rank::scalar},
{"x", SameReal, Rank::scalar}},
[flang] New implementation for checks for constraints C741 through C750 Summary: Most of these checks were already implemented, and I just added references to them to the code and tests. Also, much of this code was already reviewed in the old flang/f18 GitHub repository, but I didn't get to merge it before we switched repositories. I implemented the check for C747 to not allow coarray components in derived types that are of type C_PTR, C_FUNPTR, or type TEAM_TYPE. I implemented the check for C748 that requires a data component whose type has a coarray ultimate component to be a nonpointer, nonallocatable scalar and not be a coarray. I implemented the check for C750 that adds additional restrictions to the bounds expressions of a derived type component that's an array. These bounds expressions are sepcification expressions as defined in 10.1.11. There was already code in lib/Evaluate/check-expression.cpp to check semantics for specification expressions, but it did not check for the extra requirements of C750. C750 prohibits specification functions, the intrinsic functions ALLOCATED, ASSOCIATED, EXTENDS_TYPE_OF, PRESENT, and SAME_TYPE_AS. It also requires every specification inquiry reference to be a constant expression, and requires that the value of the bound not depend on the value of a variable. To implement these additional checks, I added code to the intrinsic proc table to get the intrinsic class of a procedure. I also added an enumeration to distinguish between specification expressions for derived type component bounds versus for type parameters. I then changed the code to pass an enumeration value to "CheckSpecificationExpr()" to indicate that the expression was a bounds expression and used this value to determine whether to emit an error message when violations of C750 are found. I changed the implementation of IsPureProcedure() to handle statement functions and changed some references in the code that tested for the PURE attribute to call IsPureProcedure(). I also fixed some unrelated tests that got new errors when I implemented these new checks. Reviewers: tskeith, DavidTruby, sscalpone Subscribers: jfb, llvm-commits Tags: #llvm, #flang Differential Revision: https://reviews.llvm.org/D79263
2020-05-02 04:00:28 +08:00
SameReal, Rank::vector, IntrinsicClass::transformationalFunction},
[flang] intrinsic pattern matching Original-commit: flang-compiler/f18@ca0ee1660a6449c34c7276284e5e63b90ae97540 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-05 04:43:33 +08:00
{"bessel_y0", {{"x", SameReal}}, SameReal},
{"bessel_y1", {{"x", SameReal}}, SameReal},
{"bessel_yn", {{"n", AnyInt}, {"x", SameReal}}, SameReal},
[flang] remove arg->intValue field Original-commit: flang-compiler/f18@721dc920227378d09d89758903c50538b61ffec3 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-10 03:07:29 +08:00
{"bessel_yn",
{{"n1", AnyInt, Rank::scalar}, {"n2", AnyInt, Rank::scalar},
{"x", SameReal, Rank::scalar}},
[flang] New implementation for checks for constraints C741 through C750 Summary: Most of these checks were already implemented, and I just added references to them to the code and tests. Also, much of this code was already reviewed in the old flang/f18 GitHub repository, but I didn't get to merge it before we switched repositories. I implemented the check for C747 to not allow coarray components in derived types that are of type C_PTR, C_FUNPTR, or type TEAM_TYPE. I implemented the check for C748 that requires a data component whose type has a coarray ultimate component to be a nonpointer, nonallocatable scalar and not be a coarray. I implemented the check for C750 that adds additional restrictions to the bounds expressions of a derived type component that's an array. These bounds expressions are sepcification expressions as defined in 10.1.11. There was already code in lib/Evaluate/check-expression.cpp to check semantics for specification expressions, but it did not check for the extra requirements of C750. C750 prohibits specification functions, the intrinsic functions ALLOCATED, ASSOCIATED, EXTENDS_TYPE_OF, PRESENT, and SAME_TYPE_AS. It also requires every specification inquiry reference to be a constant expression, and requires that the value of the bound not depend on the value of a variable. To implement these additional checks, I added code to the intrinsic proc table to get the intrinsic class of a procedure. I also added an enumeration to distinguish between specification expressions for derived type component bounds versus for type parameters. I then changed the code to pass an enumeration value to "CheckSpecificationExpr()" to indicate that the expression was a bounds expression and used this value to determine whether to emit an error message when violations of C750 are found. I changed the implementation of IsPureProcedure() to handle statement functions and changed some references in the code that tested for the PURE attribute to call IsPureProcedure(). I also fixed some unrelated tests that got new errors when I implemented these new checks. Reviewers: tskeith, DavidTruby, sscalpone Subscribers: jfb, llvm-commits Tags: #llvm, #flang Differential Revision: https://reviews.llvm.org/D79263
2020-05-02 04:00:28 +08:00
SameReal, Rank::vector, IntrinsicClass::transformationalFunction},
[flang] intrinsic pattern matching Original-commit: flang-compiler/f18@ca0ee1660a6449c34c7276284e5e63b90ae97540 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-05 04:43:33 +08:00
{"bge",
[flang] error messages Original-commit: flang-compiler/f18@392a7330736a8fd444ef92ed5c8ef7dcbc94d461 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-06 02:32:54 +08:00
{{"i", AnyInt, Rank::elementalOrBOZ},
{"j", AnyInt, Rank::elementalOrBOZ}},
[flang] Add -i8, -r8, &c. options to f18 development driver Original-commit: flang-compiler/f18@ff7f338126562ce539879a59d3da5707c76ae11a Reviewed-on: https://github.com/flang-compiler/f18/pull/213
2018-10-17 05:42:22 +08:00
DefaultLogical},
[flang] intrinsic pattern matching Original-commit: flang-compiler/f18@ca0ee1660a6449c34c7276284e5e63b90ae97540 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-05 04:43:33 +08:00
{"bgt",
[flang] error messages Original-commit: flang-compiler/f18@392a7330736a8fd444ef92ed5c8ef7dcbc94d461 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-06 02:32:54 +08:00
{{"i", AnyInt, Rank::elementalOrBOZ},
{"j", AnyInt, Rank::elementalOrBOZ}},
[flang] Add -i8, -r8, &c. options to f18 development driver Original-commit: flang-compiler/f18@ff7f338126562ce539879a59d3da5707c76ae11a Reviewed-on: https://github.com/flang-compiler/f18/pull/213
2018-10-17 05:42:22 +08:00
DefaultLogical},
[flang] Address comments; allow "real,parameter::x=tiny(x)" Original-commit: flang-compiler/f18@e865358871da6211790b2869a58db7239d9c2e68 Reviewed-on: https://github.com/flang-compiler/f18/pull/602
2019-07-26 01:16:28 +08:00
{"bit_size", {{"i", SameInt, Rank::anyOrAssumedRank}}, SameInt,
[flang] New implementation for checks for constraints C741 through C750 Summary: Most of these checks were already implemented, and I just added references to them to the code and tests. Also, much of this code was already reviewed in the old flang/f18 GitHub repository, but I didn't get to merge it before we switched repositories. I implemented the check for C747 to not allow coarray components in derived types that are of type C_PTR, C_FUNPTR, or type TEAM_TYPE. I implemented the check for C748 that requires a data component whose type has a coarray ultimate component to be a nonpointer, nonallocatable scalar and not be a coarray. I implemented the check for C750 that adds additional restrictions to the bounds expressions of a derived type component that's an array. These bounds expressions are sepcification expressions as defined in 10.1.11. There was already code in lib/Evaluate/check-expression.cpp to check semantics for specification expressions, but it did not check for the extra requirements of C750. C750 prohibits specification functions, the intrinsic functions ALLOCATED, ASSOCIATED, EXTENDS_TYPE_OF, PRESENT, and SAME_TYPE_AS. It also requires every specification inquiry reference to be a constant expression, and requires that the value of the bound not depend on the value of a variable. To implement these additional checks, I added code to the intrinsic proc table to get the intrinsic class of a procedure. I also added an enumeration to distinguish between specification expressions for derived type component bounds versus for type parameters. I then changed the code to pass an enumeration value to "CheckSpecificationExpr()" to indicate that the expression was a bounds expression and used this value to determine whether to emit an error message when violations of C750 are found. I changed the implementation of IsPureProcedure() to handle statement functions and changed some references in the code that tested for the PURE attribute to call IsPureProcedure(). I also fixed some unrelated tests that got new errors when I implemented these new checks. Reviewers: tskeith, DavidTruby, sscalpone Subscribers: jfb, llvm-commits Tags: #llvm, #flang Differential Revision: https://reviews.llvm.org/D79263
2020-05-02 04:00:28 +08:00
Rank::scalar, IntrinsicClass::inquiryFunction},
[flang] intrinsic pattern matching Original-commit: flang-compiler/f18@ca0ee1660a6449c34c7276284e5e63b90ae97540 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-05 04:43:33 +08:00
{"ble",
[flang] error messages Original-commit: flang-compiler/f18@392a7330736a8fd444ef92ed5c8ef7dcbc94d461 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-06 02:32:54 +08:00
{{"i", AnyInt, Rank::elementalOrBOZ},
{"j", AnyInt, Rank::elementalOrBOZ}},
[flang] Add -i8, -r8, &c. options to f18 development driver Original-commit: flang-compiler/f18@ff7f338126562ce539879a59d3da5707c76ae11a Reviewed-on: https://github.com/flang-compiler/f18/pull/213
2018-10-17 05:42:22 +08:00
DefaultLogical},
[flang] intrinsic pattern matching Original-commit: flang-compiler/f18@ca0ee1660a6449c34c7276284e5e63b90ae97540 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-05 04:43:33 +08:00
{"blt",
[flang] error messages Original-commit: flang-compiler/f18@392a7330736a8fd444ef92ed5c8ef7dcbc94d461 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-06 02:32:54 +08:00
{{"i", AnyInt, Rank::elementalOrBOZ},
{"j", AnyInt, Rank::elementalOrBOZ}},
[flang] Add -i8, -r8, &c. options to f18 development driver Original-commit: flang-compiler/f18@ff7f338126562ce539879a59d3da5707c76ae11a Reviewed-on: https://github.com/flang-compiler/f18/pull/213
2018-10-17 05:42:22 +08:00
DefaultLogical},
[flang] Allow BOZ argument to more intrinsics; generalize BOZ conversions in folding Original-commit: flang-compiler/f18@6df0136ee889f3c27b33d3ddac970af1b7a52c68 Reviewed-on: https://github.com/flang-compiler/f18/pull/557 Tree-same-pre-rewrite: false
2019-07-10 02:54:11 +08:00
{"btest", {{"i", AnyInt, Rank::elementalOrBOZ}, {"pos", AnyInt}},
DefaultLogical},
[flang] intrinsic pattern matching Original-commit: flang-compiler/f18@ca0ee1660a6449c34c7276284e5e63b90ae97540 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-05 04:43:33 +08:00
{"ceiling", {{"a", AnyReal}, DefaultingKIND}, KINDInt},
[flang] Allow BOZ argument to more intrinsics; generalize BOZ conversions in folding Original-commit: flang-compiler/f18@6df0136ee889f3c27b33d3ddac970af1b7a52c68 Reviewed-on: https://github.com/flang-compiler/f18/pull/557 Tree-same-pre-rewrite: false
2019-07-10 02:54:11 +08:00
{"char", {{"i", AnyInt, Rank::elementalOrBOZ}, DefaultingKIND}, KINDChar},
[flang] intrinsic pattern matching Original-commit: flang-compiler/f18@ca0ee1660a6449c34c7276284e5e63b90ae97540 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-05 04:43:33 +08:00
{"cmplx", {{"x", AnyComplex}, DefaultingKIND}, KINDComplex},
[flang] initial intrinsics table Original-commit: flang-compiler/f18@8b5c3adf887cf88752937a4fa5507c0d66051d3b Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-09-29 08:02:11 +08:00
{"cmplx",
[flang] Fix arg specs for CMPLX intrinsic Original-commit: flang-compiler/f18@3586b8a6469c91092f68beb76b77501c3920bb4b Reviewed-on: https://github.com/flang-compiler/f18/pull/477 Tree-same-pre-rewrite: false
2019-06-05 01:50:34 +08:00
{{"x", AnyIntOrReal, Rank::elementalOrBOZ},
{"y", AnyIntOrReal, Rank::elementalOrBOZ, Optionality::optional},
[flang] lib/evaluate work for structure constructors Original-commit: flang-compiler/f18@76a192f9c9b009ea52409f25b81dcb7aa2866234 Reviewed-on: https://github.com/flang-compiler/f18/pull/439
2019-05-04 02:29:15 +08:00
DefaultingKIND},
[flang] intrinsic pattern matching Original-commit: flang-compiler/f18@ca0ee1660a6449c34c7276284e5e63b90ae97540 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-05 04:43:33 +08:00
KINDComplex},
[flang] New implementation for checks for constraints C741 through C750 Summary: Most of these checks were already implemented, and I just added references to them to the code and tests. Also, much of this code was already reviewed in the old flang/f18 GitHub repository, but I didn't get to merge it before we switched repositories. I implemented the check for C747 to not allow coarray components in derived types that are of type C_PTR, C_FUNPTR, or type TEAM_TYPE. I implemented the check for C748 that requires a data component whose type has a coarray ultimate component to be a nonpointer, nonallocatable scalar and not be a coarray. I implemented the check for C750 that adds additional restrictions to the bounds expressions of a derived type component that's an array. These bounds expressions are sepcification expressions as defined in 10.1.11. There was already code in lib/Evaluate/check-expression.cpp to check semantics for specification expressions, but it did not check for the extra requirements of C750. C750 prohibits specification functions, the intrinsic functions ALLOCATED, ASSOCIATED, EXTENDS_TYPE_OF, PRESENT, and SAME_TYPE_AS. It also requires every specification inquiry reference to be a constant expression, and requires that the value of the bound not depend on the value of a variable. To implement these additional checks, I added code to the intrinsic proc table to get the intrinsic class of a procedure. I also added an enumeration to distinguish between specification expressions for derived type component bounds versus for type parameters. I then changed the code to pass an enumeration value to "CheckSpecificationExpr()" to indicate that the expression was a bounds expression and used this value to determine whether to emit an error message when violations of C750 are found. I changed the implementation of IsPureProcedure() to handle statement functions and changed some references in the code that tested for the PURE attribute to call IsPureProcedure(). I also fixed some unrelated tests that got new errors when I implemented these new checks. Reviewers: tskeith, DavidTruby, sscalpone Subscribers: jfb, llvm-commits Tags: #llvm, #flang Differential Revision: https://reviews.llvm.org/D79263
2020-05-02 04:00:28 +08:00
{"command_argument_count", {}, DefaultInt, Rank::scalar,
IntrinsicClass::transformationalFunction},
[flang] intrinsic pattern matching Original-commit: flang-compiler/f18@ca0ee1660a6449c34c7276284e5e63b90ae97540 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-05 04:43:33 +08:00
{"conjg", {{"z", SameComplex}}, SameComplex},
{"cos", {{"x", SameFloating}}, SameFloating},
[flang] Apply implicit typing to names in COMMON that appear in specification expressions Extend semantic analysis of expressions to catch missing cases Fix statement function semantics, add degree trig intrinsics Add GetUltimate to rewrite of bare namelist Address review comments Original-commit: flang-compiler/f18@52ff319de2e750733660d8e7e938e09159a3c11c Reviewed-on: https://github.com/flang-compiler/f18/pull/871
2019-12-12 07:06:24 +08:00
{"cosd", {{"x", SameFloating}}, SameFloating},
[flang] intrinsic pattern matching Original-commit: flang-compiler/f18@ca0ee1660a6449c34c7276284e5e63b90ae97540 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-05 04:43:33 +08:00
{"cosh", {{"x", SameFloating}}, SameFloating},
{"count", {{"mask", AnyLogical, Rank::array}, OptionalDIM, DefaultingKIND},
[flang] New implementation for checks for constraints C741 through C750 Summary: Most of these checks were already implemented, and I just added references to them to the code and tests. Also, much of this code was already reviewed in the old flang/f18 GitHub repository, but I didn't get to merge it before we switched repositories. I implemented the check for C747 to not allow coarray components in derived types that are of type C_PTR, C_FUNPTR, or type TEAM_TYPE. I implemented the check for C748 that requires a data component whose type has a coarray ultimate component to be a nonpointer, nonallocatable scalar and not be a coarray. I implemented the check for C750 that adds additional restrictions to the bounds expressions of a derived type component that's an array. These bounds expressions are sepcification expressions as defined in 10.1.11. There was already code in lib/Evaluate/check-expression.cpp to check semantics for specification expressions, but it did not check for the extra requirements of C750. C750 prohibits specification functions, the intrinsic functions ALLOCATED, ASSOCIATED, EXTENDS_TYPE_OF, PRESENT, and SAME_TYPE_AS. It also requires every specification inquiry reference to be a constant expression, and requires that the value of the bound not depend on the value of a variable. To implement these additional checks, I added code to the intrinsic proc table to get the intrinsic class of a procedure. I also added an enumeration to distinguish between specification expressions for derived type component bounds versus for type parameters. I then changed the code to pass an enumeration value to "CheckSpecificationExpr()" to indicate that the expression was a bounds expression and used this value to determine whether to emit an error message when violations of C750 are found. I changed the implementation of IsPureProcedure() to handle statement functions and changed some references in the code that tested for the PURE attribute to call IsPureProcedure(). I also fixed some unrelated tests that got new errors when I implemented these new checks. Reviewers: tskeith, DavidTruby, sscalpone Subscribers: jfb, llvm-commits Tags: #llvm, #flang Differential Revision: https://reviews.llvm.org/D79263
2020-05-02 04:00:28 +08:00
KINDInt, Rank::dimReduced, IntrinsicClass::transformationalFunction},
[flang] initial intrinsics table Original-commit: flang-compiler/f18@8b5c3adf887cf88752937a4fa5507c0d66051d3b Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-09-29 08:02:11 +08:00
{"cshift",
[flang] Correct shape analysis for transformational intrinsic functions Correct the analysis of references to transformational intrinsic functions that have different semantics based on the presence or absence of a DIM= argument; add shape analysis for UNPACK(). Differential Revision: https://reviews.llvm.org/D94716
2021-01-15 04:54:31 +08:00
{{"array", SameType, Rank::array},
{"shift", AnyInt, Rank::dimRemovedOrScalar}, OptionalDIM},
[flang] New implementation for checks for constraints C741 through C750 Summary: Most of these checks were already implemented, and I just added references to them to the code and tests. Also, much of this code was already reviewed in the old flang/f18 GitHub repository, but I didn't get to merge it before we switched repositories. I implemented the check for C747 to not allow coarray components in derived types that are of type C_PTR, C_FUNPTR, or type TEAM_TYPE. I implemented the check for C748 that requires a data component whose type has a coarray ultimate component to be a nonpointer, nonallocatable scalar and not be a coarray. I implemented the check for C750 that adds additional restrictions to the bounds expressions of a derived type component that's an array. These bounds expressions are sepcification expressions as defined in 10.1.11. There was already code in lib/Evaluate/check-expression.cpp to check semantics for specification expressions, but it did not check for the extra requirements of C750. C750 prohibits specification functions, the intrinsic functions ALLOCATED, ASSOCIATED, EXTENDS_TYPE_OF, PRESENT, and SAME_TYPE_AS. It also requires every specification inquiry reference to be a constant expression, and requires that the value of the bound not depend on the value of a variable. To implement these additional checks, I added code to the intrinsic proc table to get the intrinsic class of a procedure. I also added an enumeration to distinguish between specification expressions for derived type component bounds versus for type parameters. I then changed the code to pass an enumeration value to "CheckSpecificationExpr()" to indicate that the expression was a bounds expression and used this value to determine whether to emit an error message when violations of C750 are found. I changed the implementation of IsPureProcedure() to handle statement functions and changed some references in the code that tested for the PURE attribute to call IsPureProcedure(). I also fixed some unrelated tests that got new errors when I implemented these new checks. Reviewers: tskeith, DavidTruby, sscalpone Subscribers: jfb, llvm-commits Tags: #llvm, #flang Differential Revision: https://reviews.llvm.org/D79263
2020-05-02 04:00:28 +08:00
SameType, Rank::conformable, IntrinsicClass::transformationalFunction},
[flang] refactor a bit, and rearrange actual arguments into dummy order on intrinsic calls Original-commit: flang-compiler/f18@1f50ace68b00a7db4b75ebce5616032501e48457 Reviewed-on: https://github.com/flang-compiler/f18/pull/219 Tree-same-pre-rewrite: false
2018-10-18 06:09:48 +08:00
{"dble", {{"a", AnyNumeric, Rank::elementalOrBOZ}}, DoublePrecision},
[flang] Add DIGITS to intrinsic function table; fix results of some others Original-commit: flang-compiler/f18@6d5caef352e1ffe28315c27c4d46adfe36b55173 Reviewed-on: https://github.com/flang-compiler/f18/pull/623 Tree-same-pre-rewrite: false
2019-08-06 00:42:06 +08:00
{"digits", {{"x", AnyIntOrReal, Rank::anyOrAssumedRank}}, DefaultInt,
[flang] New implementation for checks for constraints C741 through C750 Summary: Most of these checks were already implemented, and I just added references to them to the code and tests. Also, much of this code was already reviewed in the old flang/f18 GitHub repository, but I didn't get to merge it before we switched repositories. I implemented the check for C747 to not allow coarray components in derived types that are of type C_PTR, C_FUNPTR, or type TEAM_TYPE. I implemented the check for C748 that requires a data component whose type has a coarray ultimate component to be a nonpointer, nonallocatable scalar and not be a coarray. I implemented the check for C750 that adds additional restrictions to the bounds expressions of a derived type component that's an array. These bounds expressions are sepcification expressions as defined in 10.1.11. There was already code in lib/Evaluate/check-expression.cpp to check semantics for specification expressions, but it did not check for the extra requirements of C750. C750 prohibits specification functions, the intrinsic functions ALLOCATED, ASSOCIATED, EXTENDS_TYPE_OF, PRESENT, and SAME_TYPE_AS. It also requires every specification inquiry reference to be a constant expression, and requires that the value of the bound not depend on the value of a variable. To implement these additional checks, I added code to the intrinsic proc table to get the intrinsic class of a procedure. I also added an enumeration to distinguish between specification expressions for derived type component bounds versus for type parameters. I then changed the code to pass an enumeration value to "CheckSpecificationExpr()" to indicate that the expression was a bounds expression and used this value to determine whether to emit an error message when violations of C750 are found. I changed the implementation of IsPureProcedure() to handle statement functions and changed some references in the code that tested for the PURE attribute to call IsPureProcedure(). I also fixed some unrelated tests that got new errors when I implemented these new checks. Reviewers: tskeith, DavidTruby, sscalpone Subscribers: jfb, llvm-commits Tags: #llvm, #flang Differential Revision: https://reviews.llvm.org/D79263
2020-05-02 04:00:28 +08:00
Rank::scalar, IntrinsicClass::inquiryFunction},
[flang] Extension: relax "same kind" rules on some intrinsics Original-commit: flang-compiler/f18@ce5130f84bcb78007180ee87661c84b1483a476c Reviewed-on: https://github.com/flang-compiler/f18/pull/590 Tree-same-pre-rewrite: false
2019-07-18 03:51:52 +08:00
{"dim", {{"x", OperandIntOrReal}, {"y", OperandIntOrReal}},
OperandIntOrReal},
[flang] remove arg->intValue field Original-commit: flang-compiler/f18@721dc920227378d09d89758903c50538b61ffec3 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-10 03:07:29 +08:00
{"dot_product",
{{"vector_a", AnyLogical, Rank::vector},
{"vector_b", AnyLogical, Rank::vector}},
[flang] New implementation for checks for constraints C741 through C750 Summary: Most of these checks were already implemented, and I just added references to them to the code and tests. Also, much of this code was already reviewed in the old flang/f18 GitHub repository, but I didn't get to merge it before we switched repositories. I implemented the check for C747 to not allow coarray components in derived types that are of type C_PTR, C_FUNPTR, or type TEAM_TYPE. I implemented the check for C748 that requires a data component whose type has a coarray ultimate component to be a nonpointer, nonallocatable scalar and not be a coarray. I implemented the check for C750 that adds additional restrictions to the bounds expressions of a derived type component that's an array. These bounds expressions are sepcification expressions as defined in 10.1.11. There was already code in lib/Evaluate/check-expression.cpp to check semantics for specification expressions, but it did not check for the extra requirements of C750. C750 prohibits specification functions, the intrinsic functions ALLOCATED, ASSOCIATED, EXTENDS_TYPE_OF, PRESENT, and SAME_TYPE_AS. It also requires every specification inquiry reference to be a constant expression, and requires that the value of the bound not depend on the value of a variable. To implement these additional checks, I added code to the intrinsic proc table to get the intrinsic class of a procedure. I also added an enumeration to distinguish between specification expressions for derived type component bounds versus for type parameters. I then changed the code to pass an enumeration value to "CheckSpecificationExpr()" to indicate that the expression was a bounds expression and used this value to determine whether to emit an error message when violations of C750 are found. I changed the implementation of IsPureProcedure() to handle statement functions and changed some references in the code that tested for the PURE attribute to call IsPureProcedure(). I also fixed some unrelated tests that got new errors when I implemented these new checks. Reviewers: tskeith, DavidTruby, sscalpone Subscribers: jfb, llvm-commits Tags: #llvm, #flang Differential Revision: https://reviews.llvm.org/D79263
2020-05-02 04:00:28 +08:00
ResultLogical, Rank::scalar, IntrinsicClass::transformationalFunction},
[flang] remove arg->intValue field Original-commit: flang-compiler/f18@721dc920227378d09d89758903c50538b61ffec3 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-10 03:07:29 +08:00
{"dot_product",
{{"vector_a", AnyComplex, Rank::vector},
{"vector_b", AnyNumeric, Rank::vector}},
[flang] New implementation for checks for constraints C741 through C750 Summary: Most of these checks were already implemented, and I just added references to them to the code and tests. Also, much of this code was already reviewed in the old flang/f18 GitHub repository, but I didn't get to merge it before we switched repositories. I implemented the check for C747 to not allow coarray components in derived types that are of type C_PTR, C_FUNPTR, or type TEAM_TYPE. I implemented the check for C748 that requires a data component whose type has a coarray ultimate component to be a nonpointer, nonallocatable scalar and not be a coarray. I implemented the check for C750 that adds additional restrictions to the bounds expressions of a derived type component that's an array. These bounds expressions are sepcification expressions as defined in 10.1.11. There was already code in lib/Evaluate/check-expression.cpp to check semantics for specification expressions, but it did not check for the extra requirements of C750. C750 prohibits specification functions, the intrinsic functions ALLOCATED, ASSOCIATED, EXTENDS_TYPE_OF, PRESENT, and SAME_TYPE_AS. It also requires every specification inquiry reference to be a constant expression, and requires that the value of the bound not depend on the value of a variable. To implement these additional checks, I added code to the intrinsic proc table to get the intrinsic class of a procedure. I also added an enumeration to distinguish between specification expressions for derived type component bounds versus for type parameters. I then changed the code to pass an enumeration value to "CheckSpecificationExpr()" to indicate that the expression was a bounds expression and used this value to determine whether to emit an error message when violations of C750 are found. I changed the implementation of IsPureProcedure() to handle statement functions and changed some references in the code that tested for the PURE attribute to call IsPureProcedure(). I also fixed some unrelated tests that got new errors when I implemented these new checks. Reviewers: tskeith, DavidTruby, sscalpone Subscribers: jfb, llvm-commits Tags: #llvm, #flang Differential Revision: https://reviews.llvm.org/D79263
2020-05-02 04:00:28 +08:00
ResultNumeric, Rank::scalar, // conjugates vector_a
IntrinsicClass::transformationalFunction},
[flang] remove arg->intValue field Original-commit: flang-compiler/f18@721dc920227378d09d89758903c50538b61ffec3 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-10 03:07:29 +08:00
{"dot_product",
{{"vector_a", AnyIntOrReal, Rank::vector},
{"vector_b", AnyNumeric, Rank::vector}},
[flang] New implementation for checks for constraints C741 through C750 Summary: Most of these checks were already implemented, and I just added references to them to the code and tests. Also, much of this code was already reviewed in the old flang/f18 GitHub repository, but I didn't get to merge it before we switched repositories. I implemented the check for C747 to not allow coarray components in derived types that are of type C_PTR, C_FUNPTR, or type TEAM_TYPE. I implemented the check for C748 that requires a data component whose type has a coarray ultimate component to be a nonpointer, nonallocatable scalar and not be a coarray. I implemented the check for C750 that adds additional restrictions to the bounds expressions of a derived type component that's an array. These bounds expressions are sepcification expressions as defined in 10.1.11. There was already code in lib/Evaluate/check-expression.cpp to check semantics for specification expressions, but it did not check for the extra requirements of C750. C750 prohibits specification functions, the intrinsic functions ALLOCATED, ASSOCIATED, EXTENDS_TYPE_OF, PRESENT, and SAME_TYPE_AS. It also requires every specification inquiry reference to be a constant expression, and requires that the value of the bound not depend on the value of a variable. To implement these additional checks, I added code to the intrinsic proc table to get the intrinsic class of a procedure. I also added an enumeration to distinguish between specification expressions for derived type component bounds versus for type parameters. I then changed the code to pass an enumeration value to "CheckSpecificationExpr()" to indicate that the expression was a bounds expression and used this value to determine whether to emit an error message when violations of C750 are found. I changed the implementation of IsPureProcedure() to handle statement functions and changed some references in the code that tested for the PURE attribute to call IsPureProcedure(). I also fixed some unrelated tests that got new errors when I implemented these new checks. Reviewers: tskeith, DavidTruby, sscalpone Subscribers: jfb, llvm-commits Tags: #llvm, #flang Differential Revision: https://reviews.llvm.org/D79263
2020-05-02 04:00:28 +08:00
ResultNumeric, Rank::scalar, IntrinsicClass::transformationalFunction},
[flang] Add -i8, -r8, &c. options to f18 development driver Original-commit: flang-compiler/f18@ff7f338126562ce539879a59d3da5707c76ae11a Reviewed-on: https://github.com/flang-compiler/f18/pull/213
2018-10-17 05:42:22 +08:00
{"dprod", {{"x", DefaultReal}, {"y", DefaultReal}}, DoublePrecision},
[flang] intrinsic pattern matching Original-commit: flang-compiler/f18@ca0ee1660a6449c34c7276284e5e63b90ae97540 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-05 04:43:33 +08:00
{"dshiftl",
[flang] error messages Original-commit: flang-compiler/f18@392a7330736a8fd444ef92ed5c8ef7dcbc94d461 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-06 02:32:54 +08:00
{{"i", SameInt}, {"j", SameInt, Rank::elementalOrBOZ},
[flang] intrinsic pattern matching Original-commit: flang-compiler/f18@ca0ee1660a6449c34c7276284e5e63b90ae97540 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-05 04:43:33 +08:00
{"shift", AnyInt}},
SameInt},
{"dshiftl", {{"i", BOZ}, {"j", SameInt}, {"shift", AnyInt}}, SameInt},
{"dshiftr",
[flang] error messages Original-commit: flang-compiler/f18@392a7330736a8fd444ef92ed5c8ef7dcbc94d461 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-06 02:32:54 +08:00
{{"i", SameInt}, {"j", SameInt, Rank::elementalOrBOZ},
[flang] intrinsic pattern matching Original-commit: flang-compiler/f18@ca0ee1660a6449c34c7276284e5e63b90ae97540 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-05 04:43:33 +08:00
{"shift", AnyInt}},
SameInt},
{"dshiftr", {{"i", BOZ}, {"j", SameInt}, {"shift", AnyInt}}, SameInt},
[flang] initial intrinsics table Original-commit: flang-compiler/f18@8b5c3adf887cf88752937a4fa5507c0d66051d3b Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-09-29 08:02:11 +08:00
{"eoshift",
[flang] intrinsic pattern matching Original-commit: flang-compiler/f18@ca0ee1660a6449c34c7276284e5e63b90ae97540 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-05 04:43:33 +08:00
{{"array", SameIntrinsic, Rank::array},
[flang] Correct shape analysis for transformational intrinsic functions Correct the analysis of references to transformational intrinsic functions that have different semantics based on the presence or absence of a DIM= argument; add shape analysis for UNPACK(). Differential Revision: https://reviews.llvm.org/D94716
2021-01-15 04:54:31 +08:00
{"shift", AnyInt, Rank::dimRemovedOrScalar},
{"boundary", SameIntrinsic, Rank::dimReduced,
[flang] error messages Original-commit: flang-compiler/f18@392a7330736a8fd444ef92ed5c8ef7dcbc94d461 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-06 02:32:54 +08:00
Optionality::optional},
[flang] intrinsic pattern matching Original-commit: flang-compiler/f18@ca0ee1660a6449c34c7276284e5e63b90ae97540 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-05 04:43:33 +08:00
OptionalDIM},
[flang] New implementation for checks for constraints C741 through C750 Summary: Most of these checks were already implemented, and I just added references to them to the code and tests. Also, much of this code was already reviewed in the old flang/f18 GitHub repository, but I didn't get to merge it before we switched repositories. I implemented the check for C747 to not allow coarray components in derived types that are of type C_PTR, C_FUNPTR, or type TEAM_TYPE. I implemented the check for C748 that requires a data component whose type has a coarray ultimate component to be a nonpointer, nonallocatable scalar and not be a coarray. I implemented the check for C750 that adds additional restrictions to the bounds expressions of a derived type component that's an array. These bounds expressions are sepcification expressions as defined in 10.1.11. There was already code in lib/Evaluate/check-expression.cpp to check semantics for specification expressions, but it did not check for the extra requirements of C750. C750 prohibits specification functions, the intrinsic functions ALLOCATED, ASSOCIATED, EXTENDS_TYPE_OF, PRESENT, and SAME_TYPE_AS. It also requires every specification inquiry reference to be a constant expression, and requires that the value of the bound not depend on the value of a variable. To implement these additional checks, I added code to the intrinsic proc table to get the intrinsic class of a procedure. I also added an enumeration to distinguish between specification expressions for derived type component bounds versus for type parameters. I then changed the code to pass an enumeration value to "CheckSpecificationExpr()" to indicate that the expression was a bounds expression and used this value to determine whether to emit an error message when violations of C750 are found. I changed the implementation of IsPureProcedure() to handle statement functions and changed some references in the code that tested for the PURE attribute to call IsPureProcedure(). I also fixed some unrelated tests that got new errors when I implemented these new checks. Reviewers: tskeith, DavidTruby, sscalpone Subscribers: jfb, llvm-commits Tags: #llvm, #flang Differential Revision: https://reviews.llvm.org/D79263
2020-05-02 04:00:28 +08:00
SameIntrinsic, Rank::conformable,
IntrinsicClass::transformationalFunction},
[flang] initial intrinsics table Original-commit: flang-compiler/f18@8b5c3adf887cf88752937a4fa5507c0d66051d3b Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-09-29 08:02:11 +08:00
{"eoshift",
[flang] intrinsic pattern matching Original-commit: flang-compiler/f18@ca0ee1660a6449c34c7276284e5e63b90ae97540 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-05 04:43:33 +08:00
{{"array", SameDerivedType, Rank::array},
[flang] Correct shape analysis for transformational intrinsic functions Correct the analysis of references to transformational intrinsic functions that have different semantics based on the presence or absence of a DIM= argument; add shape analysis for UNPACK(). Differential Revision: https://reviews.llvm.org/D94716
2021-01-15 04:54:31 +08:00
{"shift", AnyInt, Rank::dimReduced},
{"boundary", SameDerivedType, Rank::dimReduced}, OptionalDIM},
[flang] New implementation for checks for constraints C741 through C750 Summary: Most of these checks were already implemented, and I just added references to them to the code and tests. Also, much of this code was already reviewed in the old flang/f18 GitHub repository, but I didn't get to merge it before we switched repositories. I implemented the check for C747 to not allow coarray components in derived types that are of type C_PTR, C_FUNPTR, or type TEAM_TYPE. I implemented the check for C748 that requires a data component whose type has a coarray ultimate component to be a nonpointer, nonallocatable scalar and not be a coarray. I implemented the check for C750 that adds additional restrictions to the bounds expressions of a derived type component that's an array. These bounds expressions are sepcification expressions as defined in 10.1.11. There was already code in lib/Evaluate/check-expression.cpp to check semantics for specification expressions, but it did not check for the extra requirements of C750. C750 prohibits specification functions, the intrinsic functions ALLOCATED, ASSOCIATED, EXTENDS_TYPE_OF, PRESENT, and SAME_TYPE_AS. It also requires every specification inquiry reference to be a constant expression, and requires that the value of the bound not depend on the value of a variable. To implement these additional checks, I added code to the intrinsic proc table to get the intrinsic class of a procedure. I also added an enumeration to distinguish between specification expressions for derived type component bounds versus for type parameters. I then changed the code to pass an enumeration value to "CheckSpecificationExpr()" to indicate that the expression was a bounds expression and used this value to determine whether to emit an error message when violations of C750 are found. I changed the implementation of IsPureProcedure() to handle statement functions and changed some references in the code that tested for the PURE attribute to call IsPureProcedure(). I also fixed some unrelated tests that got new errors when I implemented these new checks. Reviewers: tskeith, DavidTruby, sscalpone Subscribers: jfb, llvm-commits Tags: #llvm, #flang Differential Revision: https://reviews.llvm.org/D79263
2020-05-02 04:00:28 +08:00
SameDerivedType, Rank::conformable,
IntrinsicClass::transformationalFunction},
[flang] Fold more model inquiry intrinsics Original-commit: flang-compiler/f18@a3d82893b768865aa51f105f92805f61a87d95f1 Reviewed-on: https://github.com/flang-compiler/f18/pull/602 Tree-same-pre-rewrite: false
2019-07-25 04:55:29 +08:00
{"epsilon", {{"x", SameReal, Rank::anyOrAssumedRank}}, SameReal,
[flang] New implementation for checks for constraints C741 through C750 Summary: Most of these checks were already implemented, and I just added references to them to the code and tests. Also, much of this code was already reviewed in the old flang/f18 GitHub repository, but I didn't get to merge it before we switched repositories. I implemented the check for C747 to not allow coarray components in derived types that are of type C_PTR, C_FUNPTR, or type TEAM_TYPE. I implemented the check for C748 that requires a data component whose type has a coarray ultimate component to be a nonpointer, nonallocatable scalar and not be a coarray. I implemented the check for C750 that adds additional restrictions to the bounds expressions of a derived type component that's an array. These bounds expressions are sepcification expressions as defined in 10.1.11. There was already code in lib/Evaluate/check-expression.cpp to check semantics for specification expressions, but it did not check for the extra requirements of C750. C750 prohibits specification functions, the intrinsic functions ALLOCATED, ASSOCIATED, EXTENDS_TYPE_OF, PRESENT, and SAME_TYPE_AS. It also requires every specification inquiry reference to be a constant expression, and requires that the value of the bound not depend on the value of a variable. To implement these additional checks, I added code to the intrinsic proc table to get the intrinsic class of a procedure. I also added an enumeration to distinguish between specification expressions for derived type component bounds versus for type parameters. I then changed the code to pass an enumeration value to "CheckSpecificationExpr()" to indicate that the expression was a bounds expression and used this value to determine whether to emit an error message when violations of C750 are found. I changed the implementation of IsPureProcedure() to handle statement functions and changed some references in the code that tested for the PURE attribute to call IsPureProcedure(). I also fixed some unrelated tests that got new errors when I implemented these new checks. Reviewers: tskeith, DavidTruby, sscalpone Subscribers: jfb, llvm-commits Tags: #llvm, #flang Differential Revision: https://reviews.llvm.org/D79263
2020-05-02 04:00:28 +08:00
Rank::scalar, IntrinsicClass::inquiryFunction},
[flang] intrinsic pattern matching Original-commit: flang-compiler/f18@ca0ee1660a6449c34c7276284e5e63b90ae97540 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-05 04:43:33 +08:00
{"erf", {{"x", SameReal}}, SameReal},
{"erfc", {{"x", SameReal}}, SameReal},
{"erfc_scaled", {{"x", SameReal}}, SameReal},
{"exp", {{"x", SameFloating}}, SameFloating},
[flang] New implementation for checks for constraints C741 through C750 Summary: Most of these checks were already implemented, and I just added references to them to the code and tests. Also, much of this code was already reviewed in the old flang/f18 GitHub repository, but I didn't get to merge it before we switched repositories. I implemented the check for C747 to not allow coarray components in derived types that are of type C_PTR, C_FUNPTR, or type TEAM_TYPE. I implemented the check for C748 that requires a data component whose type has a coarray ultimate component to be a nonpointer, nonallocatable scalar and not be a coarray. I implemented the check for C750 that adds additional restrictions to the bounds expressions of a derived type component that's an array. These bounds expressions are sepcification expressions as defined in 10.1.11. There was already code in lib/Evaluate/check-expression.cpp to check semantics for specification expressions, but it did not check for the extra requirements of C750. C750 prohibits specification functions, the intrinsic functions ALLOCATED, ASSOCIATED, EXTENDS_TYPE_OF, PRESENT, and SAME_TYPE_AS. It also requires every specification inquiry reference to be a constant expression, and requires that the value of the bound not depend on the value of a variable. To implement these additional checks, I added code to the intrinsic proc table to get the intrinsic class of a procedure. I also added an enumeration to distinguish between specification expressions for derived type component bounds versus for type parameters. I then changed the code to pass an enumeration value to "CheckSpecificationExpr()" to indicate that the expression was a bounds expression and used this value to determine whether to emit an error message when violations of C750 are found. I changed the implementation of IsPureProcedure() to handle statement functions and changed some references in the code that tested for the PURE attribute to call IsPureProcedure(). I also fixed some unrelated tests that got new errors when I implemented these new checks. Reviewers: tskeith, DavidTruby, sscalpone Subscribers: jfb, llvm-commits Tags: #llvm, #flang Differential Revision: https://reviews.llvm.org/D79263
2020-05-02 04:00:28 +08:00
{"exp", {{"x", SameFloating}}, SameFloating},
[flang] Add -i8, -r8, &c. options to f18 development driver Original-commit: flang-compiler/f18@ff7f338126562ce539879a59d3da5707c76ae11a Reviewed-on: https://github.com/flang-compiler/f18/pull/213
2018-10-17 05:42:22 +08:00
{"exponent", {{"x", AnyReal}}, DefaultInt},
[flang] New implementation for checks for constraints C741 through C750 Summary: Most of these checks were already implemented, and I just added references to them to the code and tests. Also, much of this code was already reviewed in the old flang/f18 GitHub repository, but I didn't get to merge it before we switched repositories. I implemented the check for C747 to not allow coarray components in derived types that are of type C_PTR, C_FUNPTR, or type TEAM_TYPE. I implemented the check for C748 that requires a data component whose type has a coarray ultimate component to be a nonpointer, nonallocatable scalar and not be a coarray. I implemented the check for C750 that adds additional restrictions to the bounds expressions of a derived type component that's an array. These bounds expressions are sepcification expressions as defined in 10.1.11. There was already code in lib/Evaluate/check-expression.cpp to check semantics for specification expressions, but it did not check for the extra requirements of C750. C750 prohibits specification functions, the intrinsic functions ALLOCATED, ASSOCIATED, EXTENDS_TYPE_OF, PRESENT, and SAME_TYPE_AS. It also requires every specification inquiry reference to be a constant expression, and requires that the value of the bound not depend on the value of a variable. To implement these additional checks, I added code to the intrinsic proc table to get the intrinsic class of a procedure. I also added an enumeration to distinguish between specification expressions for derived type component bounds versus for type parameters. I then changed the code to pass an enumeration value to "CheckSpecificationExpr()" to indicate that the expression was a bounds expression and used this value to determine whether to emit an error message when violations of C750 are found. I changed the implementation of IsPureProcedure() to handle statement functions and changed some references in the code that tested for the PURE attribute to call IsPureProcedure(). I also fixed some unrelated tests that got new errors when I implemented these new checks. Reviewers: tskeith, DavidTruby, sscalpone Subscribers: jfb, llvm-commits Tags: #llvm, #flang Differential Revision: https://reviews.llvm.org/D79263
2020-05-02 04:00:28 +08:00
{"exp", {{"x", SameFloating}}, SameFloating},
[flang] Update preprocessing document, commentary Extend documentation on preprocessing IsSimplyContiguous basic skeleton Apply suggested improvements to mod-file.cc Checks for new call13.f90 (15.4.2.2 explicit interfaces) Implement checking for procedures that can be called via an implicit interface Argument checking, test fixing Better argument checking Better derived type compatibility checking Treat externals as if implicitly interfaced Extend IEEE_EXCEPTIONS module so tests still pass with argument checking SAME_TYPE_AS and EXTENDS_TYPE_OF intrinsic inquiry functions Define interfaces for most intrinsic subroutines Better PASS arguments More with PASS() argument Prep for review address comments fix comment Remove formatted expression from specification expression error message per review more review comments Original-commit: flang-compiler/f18@3cca775da9302e3a2acec4a34800cd7666899b5f Reviewed-on: https://github.com/flang-compiler/f18/pull/776
2019-09-17 07:58:13 +08:00
{"extends_type_of",
{{"a", ExtensibleDerived, Rank::anyOrAssumedRank},
{"mold", ExtensibleDerived, Rank::anyOrAssumedRank}},
[flang] New implementation for checks for constraints C741 through C750 Summary: Most of these checks were already implemented, and I just added references to them to the code and tests. Also, much of this code was already reviewed in the old flang/f18 GitHub repository, but I didn't get to merge it before we switched repositories. I implemented the check for C747 to not allow coarray components in derived types that are of type C_PTR, C_FUNPTR, or type TEAM_TYPE. I implemented the check for C748 that requires a data component whose type has a coarray ultimate component to be a nonpointer, nonallocatable scalar and not be a coarray. I implemented the check for C750 that adds additional restrictions to the bounds expressions of a derived type component that's an array. These bounds expressions are sepcification expressions as defined in 10.1.11. There was already code in lib/Evaluate/check-expression.cpp to check semantics for specification expressions, but it did not check for the extra requirements of C750. C750 prohibits specification functions, the intrinsic functions ALLOCATED, ASSOCIATED, EXTENDS_TYPE_OF, PRESENT, and SAME_TYPE_AS. It also requires every specification inquiry reference to be a constant expression, and requires that the value of the bound not depend on the value of a variable. To implement these additional checks, I added code to the intrinsic proc table to get the intrinsic class of a procedure. I also added an enumeration to distinguish between specification expressions for derived type component bounds versus for type parameters. I then changed the code to pass an enumeration value to "CheckSpecificationExpr()" to indicate that the expression was a bounds expression and used this value to determine whether to emit an error message when violations of C750 are found. I changed the implementation of IsPureProcedure() to handle statement functions and changed some references in the code that tested for the PURE attribute to call IsPureProcedure(). I also fixed some unrelated tests that got new errors when I implemented these new checks. Reviewers: tskeith, DavidTruby, sscalpone Subscribers: jfb, llvm-commits Tags: #llvm, #flang Differential Revision: https://reviews.llvm.org/D79263
2020-05-02 04:00:28 +08:00
DefaultLogical, Rank::scalar, IntrinsicClass::inquiryFunction},
[flang] initial intrinsics table Original-commit: flang-compiler/f18@8b5c3adf887cf88752937a4fa5507c0d66051d3b Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-09-29 08:02:11 +08:00
{"findloc",
[flang] finish most intrinsic table entries Original-commit: flang-compiler/f18@134bd885af5c67ae7fc2291778397546a3d1c189 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-12 05:51:14 +08:00
{{"array", AnyNumeric, Rank::array},
[flang] Refactor SymbolOrComponent typedef to NamedEntity class Original-commit: flang-compiler/f18@e8ec4b88bd6084beeae6a0d3037e019bc1d24c6b Reviewed-on: https://github.com/flang-compiler/f18/pull/531 Tree-same-pre-rewrite: false
2019-06-26 04:07:32 +08:00
{"value", AnyNumeric, Rank::scalar}, RequiredDIM, OptionalMASK,
[flang] enable semantic analysis by default back out -Mnolargearray default temporarily Fix C_F_POINTER(SHAPE=) argument check, it can be any kind of integer Revert default result kind of SIZE() & al. to standard by default Remove needless usage of -fdebug-semantics Original-commit: flang-compiler/f18@57058a5b163eaa90c7e0f387ea4918f9efa8184c Reviewed-on: https://github.com/flang-compiler/f18/pull/907
2020-01-04 08:32:23 +08:00
SizeDefaultKIND,
[flang] error messages Original-commit: flang-compiler/f18@392a7330736a8fd444ef92ed5c8ef7dcbc94d461 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-06 02:32:54 +08:00
{"back", AnyLogical, Rank::scalar, Optionality::optional}},
[flang] Correct shape analysis for transformational intrinsic functions Correct the analysis of references to transformational intrinsic functions that have different semantics based on the presence or absence of a DIM= argument; add shape analysis for UNPACK(). Differential Revision: https://reviews.llvm.org/D94716
2021-01-15 04:54:31 +08:00
KINDInt, Rank::locReduced, IntrinsicClass::transformationalFunction},
[flang] Refactor SymbolOrComponent typedef to NamedEntity class Original-commit: flang-compiler/f18@e8ec4b88bd6084beeae6a0d3037e019bc1d24c6b Reviewed-on: https://github.com/flang-compiler/f18/pull/531 Tree-same-pre-rewrite: false
2019-06-26 04:07:32 +08:00
{"findloc",
{{"array", AnyNumeric, Rank::array},
[flang] Correct shape analysis for transformational intrinsic functions Correct the analysis of references to transformational intrinsic functions that have different semantics based on the presence or absence of a DIM= argument; add shape analysis for UNPACK(). Differential Revision: https://reviews.llvm.org/D94716
2021-01-15 04:54:31 +08:00
{"value", AnyNumeric, Rank::scalar}, MissingDIM, OptionalMASK,
SizeDefaultKIND,
[flang] Refactor SymbolOrComponent typedef to NamedEntity class Original-commit: flang-compiler/f18@e8ec4b88bd6084beeae6a0d3037e019bc1d24c6b Reviewed-on: https://github.com/flang-compiler/f18/pull/531 Tree-same-pre-rewrite: false
2019-06-26 04:07:32 +08:00
{"back", AnyLogical, Rank::scalar, Optionality::optional}},
[flang] New implementation for checks for constraints C741 through C750 Summary: Most of these checks were already implemented, and I just added references to them to the code and tests. Also, much of this code was already reviewed in the old flang/f18 GitHub repository, but I didn't get to merge it before we switched repositories. I implemented the check for C747 to not allow coarray components in derived types that are of type C_PTR, C_FUNPTR, or type TEAM_TYPE. I implemented the check for C748 that requires a data component whose type has a coarray ultimate component to be a nonpointer, nonallocatable scalar and not be a coarray. I implemented the check for C750 that adds additional restrictions to the bounds expressions of a derived type component that's an array. These bounds expressions are sepcification expressions as defined in 10.1.11. There was already code in lib/Evaluate/check-expression.cpp to check semantics for specification expressions, but it did not check for the extra requirements of C750. C750 prohibits specification functions, the intrinsic functions ALLOCATED, ASSOCIATED, EXTENDS_TYPE_OF, PRESENT, and SAME_TYPE_AS. It also requires every specification inquiry reference to be a constant expression, and requires that the value of the bound not depend on the value of a variable. To implement these additional checks, I added code to the intrinsic proc table to get the intrinsic class of a procedure. I also added an enumeration to distinguish between specification expressions for derived type component bounds versus for type parameters. I then changed the code to pass an enumeration value to "CheckSpecificationExpr()" to indicate that the expression was a bounds expression and used this value to determine whether to emit an error message when violations of C750 are found. I changed the implementation of IsPureProcedure() to handle statement functions and changed some references in the code that tested for the PURE attribute to call IsPureProcedure(). I also fixed some unrelated tests that got new errors when I implemented these new checks. Reviewers: tskeith, DavidTruby, sscalpone Subscribers: jfb, llvm-commits Tags: #llvm, #flang Differential Revision: https://reviews.llvm.org/D79263
2020-05-02 04:00:28 +08:00
KINDInt, Rank::vector, IntrinsicClass::transformationalFunction},
[flang] initial intrinsics table Original-commit: flang-compiler/f18@8b5c3adf887cf88752937a4fa5507c0d66051d3b Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-09-29 08:02:11 +08:00
{"findloc",
[flang] intrinsic pattern matching Original-commit: flang-compiler/f18@ca0ee1660a6449c34c7276284e5e63b90ae97540 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-05 04:43:33 +08:00
{{"array", SameChar, Rank::array}, {"value", SameChar, Rank::scalar},
[flang] enable semantic analysis by default back out -Mnolargearray default temporarily Fix C_F_POINTER(SHAPE=) argument check, it can be any kind of integer Revert default result kind of SIZE() & al. to standard by default Remove needless usage of -fdebug-semantics Original-commit: flang-compiler/f18@57058a5b163eaa90c7e0f387ea4918f9efa8184c Reviewed-on: https://github.com/flang-compiler/f18/pull/907
2020-01-04 08:32:23 +08:00
RequiredDIM, OptionalMASK, SizeDefaultKIND,
[flang] error messages Original-commit: flang-compiler/f18@392a7330736a8fd444ef92ed5c8ef7dcbc94d461 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-06 02:32:54 +08:00
{"back", AnyLogical, Rank::scalar, Optionality::optional}},
[flang] Correct shape analysis for transformational intrinsic functions Correct the analysis of references to transformational intrinsic functions that have different semantics based on the presence or absence of a DIM= argument; add shape analysis for UNPACK(). Differential Revision: https://reviews.llvm.org/D94716
2021-01-15 04:54:31 +08:00
KINDInt, Rank::locReduced, IntrinsicClass::transformationalFunction},
[flang] Refactor SymbolOrComponent typedef to NamedEntity class Original-commit: flang-compiler/f18@e8ec4b88bd6084beeae6a0d3037e019bc1d24c6b Reviewed-on: https://github.com/flang-compiler/f18/pull/531 Tree-same-pre-rewrite: false
2019-06-26 04:07:32 +08:00
{"findloc",
{{"array", SameChar, Rank::array}, {"value", SameChar, Rank::scalar},
[flang] Correct shape analysis for transformational intrinsic functions Correct the analysis of references to transformational intrinsic functions that have different semantics based on the presence or absence of a DIM= argument; add shape analysis for UNPACK(). Differential Revision: https://reviews.llvm.org/D94716
2021-01-15 04:54:31 +08:00
MissingDIM, OptionalMASK, SizeDefaultKIND,
[flang] Refactor SymbolOrComponent typedef to NamedEntity class Original-commit: flang-compiler/f18@e8ec4b88bd6084beeae6a0d3037e019bc1d24c6b Reviewed-on: https://github.com/flang-compiler/f18/pull/531 Tree-same-pre-rewrite: false
2019-06-26 04:07:32 +08:00
{"back", AnyLogical, Rank::scalar, Optionality::optional}},
[flang] New implementation for checks for constraints C741 through C750 Summary: Most of these checks were already implemented, and I just added references to them to the code and tests. Also, much of this code was already reviewed in the old flang/f18 GitHub repository, but I didn't get to merge it before we switched repositories. I implemented the check for C747 to not allow coarray components in derived types that are of type C_PTR, C_FUNPTR, or type TEAM_TYPE. I implemented the check for C748 that requires a data component whose type has a coarray ultimate component to be a nonpointer, nonallocatable scalar and not be a coarray. I implemented the check for C750 that adds additional restrictions to the bounds expressions of a derived type component that's an array. These bounds expressions are sepcification expressions as defined in 10.1.11. There was already code in lib/Evaluate/check-expression.cpp to check semantics for specification expressions, but it did not check for the extra requirements of C750. C750 prohibits specification functions, the intrinsic functions ALLOCATED, ASSOCIATED, EXTENDS_TYPE_OF, PRESENT, and SAME_TYPE_AS. It also requires every specification inquiry reference to be a constant expression, and requires that the value of the bound not depend on the value of a variable. To implement these additional checks, I added code to the intrinsic proc table to get the intrinsic class of a procedure. I also added an enumeration to distinguish between specification expressions for derived type component bounds versus for type parameters. I then changed the code to pass an enumeration value to "CheckSpecificationExpr()" to indicate that the expression was a bounds expression and used this value to determine whether to emit an error message when violations of C750 are found. I changed the implementation of IsPureProcedure() to handle statement functions and changed some references in the code that tested for the PURE attribute to call IsPureProcedure(). I also fixed some unrelated tests that got new errors when I implemented these new checks. Reviewers: tskeith, DavidTruby, sscalpone Subscribers: jfb, llvm-commits Tags: #llvm, #flang Differential Revision: https://reviews.llvm.org/D79263
2020-05-02 04:00:28 +08:00
KINDInt, Rank::vector, IntrinsicClass::transformationalFunction},
[flang] initial intrinsics table Original-commit: flang-compiler/f18@8b5c3adf887cf88752937a4fa5507c0d66051d3b Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-09-29 08:02:11 +08:00
{"findloc",
[flang] intrinsic pattern matching Original-commit: flang-compiler/f18@ca0ee1660a6449c34c7276284e5e63b90ae97540 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-05 04:43:33 +08:00
{{"array", AnyLogical, Rank::array},
[flang] Refactor SymbolOrComponent typedef to NamedEntity class Original-commit: flang-compiler/f18@e8ec4b88bd6084beeae6a0d3037e019bc1d24c6b Reviewed-on: https://github.com/flang-compiler/f18/pull/531 Tree-same-pre-rewrite: false
2019-06-26 04:07:32 +08:00
{"value", AnyLogical, Rank::scalar}, RequiredDIM, OptionalMASK,
[flang] enable semantic analysis by default back out -Mnolargearray default temporarily Fix C_F_POINTER(SHAPE=) argument check, it can be any kind of integer Revert default result kind of SIZE() & al. to standard by default Remove needless usage of -fdebug-semantics Original-commit: flang-compiler/f18@57058a5b163eaa90c7e0f387ea4918f9efa8184c Reviewed-on: https://github.com/flang-compiler/f18/pull/907
2020-01-04 08:32:23 +08:00
SizeDefaultKIND,
[flang] error messages Original-commit: flang-compiler/f18@392a7330736a8fd444ef92ed5c8ef7dcbc94d461 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-06 02:32:54 +08:00
{"back", AnyLogical, Rank::scalar, Optionality::optional}},
[flang] Correct shape analysis for transformational intrinsic functions Correct the analysis of references to transformational intrinsic functions that have different semantics based on the presence or absence of a DIM= argument; add shape analysis for UNPACK(). Differential Revision: https://reviews.llvm.org/D94716
2021-01-15 04:54:31 +08:00
KINDInt, Rank::locReduced, IntrinsicClass::transformationalFunction},
[flang] Refactor SymbolOrComponent typedef to NamedEntity class Original-commit: flang-compiler/f18@e8ec4b88bd6084beeae6a0d3037e019bc1d24c6b Reviewed-on: https://github.com/flang-compiler/f18/pull/531 Tree-same-pre-rewrite: false
2019-06-26 04:07:32 +08:00
{"findloc",
{{"array", AnyLogical, Rank::array},
[flang] Correct shape analysis for transformational intrinsic functions Correct the analysis of references to transformational intrinsic functions that have different semantics based on the presence or absence of a DIM= argument; add shape analysis for UNPACK(). Differential Revision: https://reviews.llvm.org/D94716
2021-01-15 04:54:31 +08:00
{"value", AnyLogical, Rank::scalar}, MissingDIM, OptionalMASK,
SizeDefaultKIND,
[flang] Refactor SymbolOrComponent typedef to NamedEntity class Original-commit: flang-compiler/f18@e8ec4b88bd6084beeae6a0d3037e019bc1d24c6b Reviewed-on: https://github.com/flang-compiler/f18/pull/531 Tree-same-pre-rewrite: false
2019-06-26 04:07:32 +08:00
{"back", AnyLogical, Rank::scalar, Optionality::optional}},
[flang] New implementation for checks for constraints C741 through C750 Summary: Most of these checks were already implemented, and I just added references to them to the code and tests. Also, much of this code was already reviewed in the old flang/f18 GitHub repository, but I didn't get to merge it before we switched repositories. I implemented the check for C747 to not allow coarray components in derived types that are of type C_PTR, C_FUNPTR, or type TEAM_TYPE. I implemented the check for C748 that requires a data component whose type has a coarray ultimate component to be a nonpointer, nonallocatable scalar and not be a coarray. I implemented the check for C750 that adds additional restrictions to the bounds expressions of a derived type component that's an array. These bounds expressions are sepcification expressions as defined in 10.1.11. There was already code in lib/Evaluate/check-expression.cpp to check semantics for specification expressions, but it did not check for the extra requirements of C750. C750 prohibits specification functions, the intrinsic functions ALLOCATED, ASSOCIATED, EXTENDS_TYPE_OF, PRESENT, and SAME_TYPE_AS. It also requires every specification inquiry reference to be a constant expression, and requires that the value of the bound not depend on the value of a variable. To implement these additional checks, I added code to the intrinsic proc table to get the intrinsic class of a procedure. I also added an enumeration to distinguish between specification expressions for derived type component bounds versus for type parameters. I then changed the code to pass an enumeration value to "CheckSpecificationExpr()" to indicate that the expression was a bounds expression and used this value to determine whether to emit an error message when violations of C750 are found. I changed the implementation of IsPureProcedure() to handle statement functions and changed some references in the code that tested for the PURE attribute to call IsPureProcedure(). I also fixed some unrelated tests that got new errors when I implemented these new checks. Reviewers: tskeith, DavidTruby, sscalpone Subscribers: jfb, llvm-commits Tags: #llvm, #flang Differential Revision: https://reviews.llvm.org/D79263
2020-05-02 04:00:28 +08:00
KINDInt, Rank::vector, IntrinsicClass::transformationalFunction},
[flang] intrinsic pattern matching Original-commit: flang-compiler/f18@ca0ee1660a6449c34c7276284e5e63b90ae97540 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-05 04:43:33 +08:00
{"floor", {{"a", AnyReal}, DefaultingKIND}, KINDInt},
{"fraction", {{"x", SameReal}}, SameReal},
{"gamma", {{"x", SameReal}}, SameReal},
[flang] Fold more model inquiry intrinsics Original-commit: flang-compiler/f18@a3d82893b768865aa51f105f92805f61a87d95f1 Reviewed-on: https://github.com/flang-compiler/f18/pull/602 Tree-same-pre-rewrite: false
2019-07-25 04:55:29 +08:00
{"huge", {{"x", SameIntOrReal, Rank::anyOrAssumedRank}}, SameIntOrReal,
[flang] New implementation for checks for constraints C741 through C750 Summary: Most of these checks were already implemented, and I just added references to them to the code and tests. Also, much of this code was already reviewed in the old flang/f18 GitHub repository, but I didn't get to merge it before we switched repositories. I implemented the check for C747 to not allow coarray components in derived types that are of type C_PTR, C_FUNPTR, or type TEAM_TYPE. I implemented the check for C748 that requires a data component whose type has a coarray ultimate component to be a nonpointer, nonallocatable scalar and not be a coarray. I implemented the check for C750 that adds additional restrictions to the bounds expressions of a derived type component that's an array. These bounds expressions are sepcification expressions as defined in 10.1.11. There was already code in lib/Evaluate/check-expression.cpp to check semantics for specification expressions, but it did not check for the extra requirements of C750. C750 prohibits specification functions, the intrinsic functions ALLOCATED, ASSOCIATED, EXTENDS_TYPE_OF, PRESENT, and SAME_TYPE_AS. It also requires every specification inquiry reference to be a constant expression, and requires that the value of the bound not depend on the value of a variable. To implement these additional checks, I added code to the intrinsic proc table to get the intrinsic class of a procedure. I also added an enumeration to distinguish between specification expressions for derived type component bounds versus for type parameters. I then changed the code to pass an enumeration value to "CheckSpecificationExpr()" to indicate that the expression was a bounds expression and used this value to determine whether to emit an error message when violations of C750 are found. I changed the implementation of IsPureProcedure() to handle statement functions and changed some references in the code that tested for the PURE attribute to call IsPureProcedure(). I also fixed some unrelated tests that got new errors when I implemented these new checks. Reviewers: tskeith, DavidTruby, sscalpone Subscribers: jfb, llvm-commits Tags: #llvm, #flang Differential Revision: https://reviews.llvm.org/D79263
2020-05-02 04:00:28 +08:00
Rank::scalar, IntrinsicClass::inquiryFunction},
[flang] Extension: relax "same kind" rules on some intrinsics Original-commit: flang-compiler/f18@ce5130f84bcb78007180ee87661c84b1483a476c Reviewed-on: https://github.com/flang-compiler/f18/pull/590 Tree-same-pre-rewrite: false
2019-07-18 03:51:52 +08:00
{"hypot", {{"x", OperandReal}, {"y", OperandReal}}, OperandReal},
[flang] intrinsic pattern matching Original-commit: flang-compiler/f18@ca0ee1660a6449c34c7276284e5e63b90ae97540 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-05 04:43:33 +08:00
{"iachar", {{"c", AnyChar}, DefaultingKIND}, KINDInt},
[flang] Correct shape analysis for transformational intrinsic functions Correct the analysis of references to transformational intrinsic functions that have different semantics based on the presence or absence of a DIM= argument; add shape analysis for UNPACK(). Differential Revision: https://reviews.llvm.org/D94716
2021-01-15 04:54:31 +08:00
{"iall", {{"array", SameInt, Rank::array}, RequiredDIM, OptionalMASK},
[flang] New implementation for checks for constraints C741 through C750 Summary: Most of these checks were already implemented, and I just added references to them to the code and tests. Also, much of this code was already reviewed in the old flang/f18 GitHub repository, but I didn't get to merge it before we switched repositories. I implemented the check for C747 to not allow coarray components in derived types that are of type C_PTR, C_FUNPTR, or type TEAM_TYPE. I implemented the check for C748 that requires a data component whose type has a coarray ultimate component to be a nonpointer, nonallocatable scalar and not be a coarray. I implemented the check for C750 that adds additional restrictions to the bounds expressions of a derived type component that's an array. These bounds expressions are sepcification expressions as defined in 10.1.11. There was already code in lib/Evaluate/check-expression.cpp to check semantics for specification expressions, but it did not check for the extra requirements of C750. C750 prohibits specification functions, the intrinsic functions ALLOCATED, ASSOCIATED, EXTENDS_TYPE_OF, PRESENT, and SAME_TYPE_AS. It also requires every specification inquiry reference to be a constant expression, and requires that the value of the bound not depend on the value of a variable. To implement these additional checks, I added code to the intrinsic proc table to get the intrinsic class of a procedure. I also added an enumeration to distinguish between specification expressions for derived type component bounds versus for type parameters. I then changed the code to pass an enumeration value to "CheckSpecificationExpr()" to indicate that the expression was a bounds expression and used this value to determine whether to emit an error message when violations of C750 are found. I changed the implementation of IsPureProcedure() to handle statement functions and changed some references in the code that tested for the PURE attribute to call IsPureProcedure(). I also fixed some unrelated tests that got new errors when I implemented these new checks. Reviewers: tskeith, DavidTruby, sscalpone Subscribers: jfb, llvm-commits Tags: #llvm, #flang Differential Revision: https://reviews.llvm.org/D79263
2020-05-02 04:00:28 +08:00
SameInt, Rank::dimReduced, IntrinsicClass::transformationalFunction},
[flang] Correct shape analysis for transformational intrinsic functions Correct the analysis of references to transformational intrinsic functions that have different semantics based on the presence or absence of a DIM= argument; add shape analysis for UNPACK(). Differential Revision: https://reviews.llvm.org/D94716
2021-01-15 04:54:31 +08:00
{"iall", {{"array", SameInt, Rank::array}, MissingDIM, OptionalMASK},
SameInt, Rank::scalar, IntrinsicClass::transformationalFunction},
{"iany", {{"array", SameInt, Rank::array}, RequiredDIM, OptionalMASK},
[flang] New implementation for checks for constraints C741 through C750 Summary: Most of these checks were already implemented, and I just added references to them to the code and tests. Also, much of this code was already reviewed in the old flang/f18 GitHub repository, but I didn't get to merge it before we switched repositories. I implemented the check for C747 to not allow coarray components in derived types that are of type C_PTR, C_FUNPTR, or type TEAM_TYPE. I implemented the check for C748 that requires a data component whose type has a coarray ultimate component to be a nonpointer, nonallocatable scalar and not be a coarray. I implemented the check for C750 that adds additional restrictions to the bounds expressions of a derived type component that's an array. These bounds expressions are sepcification expressions as defined in 10.1.11. There was already code in lib/Evaluate/check-expression.cpp to check semantics for specification expressions, but it did not check for the extra requirements of C750. C750 prohibits specification functions, the intrinsic functions ALLOCATED, ASSOCIATED, EXTENDS_TYPE_OF, PRESENT, and SAME_TYPE_AS. It also requires every specification inquiry reference to be a constant expression, and requires that the value of the bound not depend on the value of a variable. To implement these additional checks, I added code to the intrinsic proc table to get the intrinsic class of a procedure. I also added an enumeration to distinguish between specification expressions for derived type component bounds versus for type parameters. I then changed the code to pass an enumeration value to "CheckSpecificationExpr()" to indicate that the expression was a bounds expression and used this value to determine whether to emit an error message when violations of C750 are found. I changed the implementation of IsPureProcedure() to handle statement functions and changed some references in the code that tested for the PURE attribute to call IsPureProcedure(). I also fixed some unrelated tests that got new errors when I implemented these new checks. Reviewers: tskeith, DavidTruby, sscalpone Subscribers: jfb, llvm-commits Tags: #llvm, #flang Differential Revision: https://reviews.llvm.org/D79263
2020-05-02 04:00:28 +08:00
SameInt, Rank::dimReduced, IntrinsicClass::transformationalFunction},
[flang] Correct shape analysis for transformational intrinsic functions Correct the analysis of references to transformational intrinsic functions that have different semantics based on the presence or absence of a DIM= argument; add shape analysis for UNPACK(). Differential Revision: https://reviews.llvm.org/D94716
2021-01-15 04:54:31 +08:00
{"iany", {{"array", SameInt, Rank::array}, MissingDIM, OptionalMASK},
SameInt, Rank::scalar, IntrinsicClass::transformationalFunction},
{"iparity", {{"array", SameInt, Rank::array}, RequiredDIM, OptionalMASK},
[flang] New implementation for checks for constraints C741 through C750 Summary: Most of these checks were already implemented, and I just added references to them to the code and tests. Also, much of this code was already reviewed in the old flang/f18 GitHub repository, but I didn't get to merge it before we switched repositories. I implemented the check for C747 to not allow coarray components in derived types that are of type C_PTR, C_FUNPTR, or type TEAM_TYPE. I implemented the check for C748 that requires a data component whose type has a coarray ultimate component to be a nonpointer, nonallocatable scalar and not be a coarray. I implemented the check for C750 that adds additional restrictions to the bounds expressions of a derived type component that's an array. These bounds expressions are sepcification expressions as defined in 10.1.11. There was already code in lib/Evaluate/check-expression.cpp to check semantics for specification expressions, but it did not check for the extra requirements of C750. C750 prohibits specification functions, the intrinsic functions ALLOCATED, ASSOCIATED, EXTENDS_TYPE_OF, PRESENT, and SAME_TYPE_AS. It also requires every specification inquiry reference to be a constant expression, and requires that the value of the bound not depend on the value of a variable. To implement these additional checks, I added code to the intrinsic proc table to get the intrinsic class of a procedure. I also added an enumeration to distinguish between specification expressions for derived type component bounds versus for type parameters. I then changed the code to pass an enumeration value to "CheckSpecificationExpr()" to indicate that the expression was a bounds expression and used this value to determine whether to emit an error message when violations of C750 are found. I changed the implementation of IsPureProcedure() to handle statement functions and changed some references in the code that tested for the PURE attribute to call IsPureProcedure(). I also fixed some unrelated tests that got new errors when I implemented these new checks. Reviewers: tskeith, DavidTruby, sscalpone Subscribers: jfb, llvm-commits Tags: #llvm, #flang Differential Revision: https://reviews.llvm.org/D79263
2020-05-02 04:00:28 +08:00
SameInt, Rank::dimReduced, IntrinsicClass::transformationalFunction},
[flang] Correct shape analysis for transformational intrinsic functions Correct the analysis of references to transformational intrinsic functions that have different semantics based on the presence or absence of a DIM= argument; add shape analysis for UNPACK(). Differential Revision: https://reviews.llvm.org/D94716
2021-01-15 04:54:31 +08:00
{"iparity", {{"array", SameInt, Rank::array}, MissingDIM, OptionalMASK},
SameInt, Rank::scalar, IntrinsicClass::transformationalFunction},
[flang] error messages Original-commit: flang-compiler/f18@392a7330736a8fd444ef92ed5c8ef7dcbc94d461 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-06 02:32:54 +08:00
{"iand", {{"i", SameInt}, {"j", SameInt, Rank::elementalOrBOZ}}, SameInt},
[flang] intrinsic pattern matching Original-commit: flang-compiler/f18@ca0ee1660a6449c34c7276284e5e63b90ae97540 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-05 04:43:33 +08:00
{"iand", {{"i", BOZ}, {"j", SameInt}}, SameInt},
{"ibclr", {{"i", SameInt}, {"pos", AnyInt}}, SameInt},
{"ibits", {{"i", SameInt}, {"pos", AnyInt}, {"len", AnyInt}}, SameInt},
{"ibset", {{"i", SameInt}, {"pos", AnyInt}}, SameInt},
{"ichar", {{"c", AnyChar}, DefaultingKIND}, KINDInt},
[flang] error messages Original-commit: flang-compiler/f18@392a7330736a8fd444ef92ed5c8ef7dcbc94d461 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-06 02:32:54 +08:00
{"ieor", {{"i", SameInt}, {"j", SameInt, Rank::elementalOrBOZ}}, SameInt},
[flang] intrinsic pattern matching Original-commit: flang-compiler/f18@ca0ee1660a6449c34c7276284e5e63b90ae97540 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-05 04:43:33 +08:00
{"ieor", {{"i", BOZ}, {"j", SameInt}}, SameInt},
{"image_status",
[flang] error messages Original-commit: flang-compiler/f18@392a7330736a8fd444ef92ed5c8ef7dcbc94d461 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-06 02:32:54 +08:00
{{"image", SameInt},
{"team", TEAM_TYPE, Rank::scalar, Optionality::optional}},
[flang] Add -i8, -r8, &c. options to f18 development driver Original-commit: flang-compiler/f18@ff7f338126562ce539879a59d3da5707c76ae11a Reviewed-on: https://github.com/flang-compiler/f18/pull/213
2018-10-17 05:42:22 +08:00
DefaultInt},
[flang] initial intrinsics table Original-commit: flang-compiler/f18@8b5c3adf887cf88752937a4fa5507c0d66051d3b Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-09-29 08:02:11 +08:00
{"index",
[flang] intrinsic pattern matching Original-commit: flang-compiler/f18@ca0ee1660a6449c34c7276284e5e63b90ae97540 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-05 04:43:33 +08:00
{{"string", SameChar}, {"substring", SameChar},
[flang] error messages Original-commit: flang-compiler/f18@392a7330736a8fd444ef92ed5c8ef7dcbc94d461 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-06 02:32:54 +08:00
{"back", AnyLogical, Rank::scalar, Optionality::optional},
[flang] Revert to returning default INTEGER for LEN() and offset-in-CHARACTER intrinsics; further shape analysis of intrinsic results Original-commit: flang-compiler/f18@561f5965b2309df3cd15d7e2a96d7e73f2f76e35 Reviewed-on: https://github.com/flang-compiler/f18/pull/782 Tree-same-pre-rewrite: false
2019-10-17 02:53:03 +08:00
DefaultingKIND},
[flang] intrinsic pattern matching Original-commit: flang-compiler/f18@ca0ee1660a6449c34c7276284e5e63b90ae97540 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-05 04:43:33 +08:00
KINDInt},
[flang] error messages Original-commit: flang-compiler/f18@392a7330736a8fd444ef92ed5c8ef7dcbc94d461 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-06 02:32:54 +08:00
{"int", {{"a", AnyNumeric, Rank::elementalOrBOZ}, DefaultingKIND}, KINDInt},
[flang] Implement int_ptr_kind. Split omp_lib.F90 into two files: a Fortran file used to create the omp_lib module and a .h file that can be used directly, which apparently some codes do. Because of the split, and wanting to avoid forcing use isc_c_binding, use int_ptr_kind() instead of c_intptr_t. Original-commit: flang-compiler/f18@ce6a9fb17322608096c09f2b4d533f4e86d56b74 Reviewed-on: https://github.com/flang-compiler/f18/pull/690 Tree-same-pre-rewrite: false
2019-08-27 05:58:10 +08:00
{"int_ptr_kind", {}, DefaultInt, Rank::scalar},
[flang] error messages Original-commit: flang-compiler/f18@392a7330736a8fd444ef92ed5c8ef7dcbc94d461 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-06 02:32:54 +08:00
{"ior", {{"i", SameInt}, {"j", SameInt, Rank::elementalOrBOZ}}, SameInt},
[flang] intrinsic pattern matching Original-commit: flang-compiler/f18@ca0ee1660a6449c34c7276284e5e63b90ae97540 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-05 04:43:33 +08:00
{"ior", {{"i", BOZ}, {"j", SameInt}}, SameInt},
{"ishft", {{"i", SameInt}, {"shift", AnyInt}}, SameInt},
{"ishftc",
{{"i", SameInt}, {"shift", AnyInt},
[flang] error messages Original-commit: flang-compiler/f18@392a7330736a8fd444ef92ed5c8ef7dcbc94d461 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-06 02:32:54 +08:00
{"size", AnyInt, Rank::elemental, Optionality::optional}},
[flang] intrinsic pattern matching Original-commit: flang-compiler/f18@ca0ee1660a6449c34c7276284e5e63b90ae97540 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-05 04:43:33 +08:00
SameInt},
[flang] Add isnan() extension intrinsic function, with folding It's nonstandard, but commonly implemented. Differential revision: https://reviews.llvm.org/D91213
2020-11-11 07:07:53 +08:00
{"isnan", {{"a", AnyFloating}}, DefaultLogical},
[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
{"is_contiguous", {{"array", Addressable, Rank::anyOrAssumedRank}},
[flang] New implementation for checks for constraints C741 through C750 Summary: Most of these checks were already implemented, and I just added references to them to the code and tests. Also, much of this code was already reviewed in the old flang/f18 GitHub repository, but I didn't get to merge it before we switched repositories. I implemented the check for C747 to not allow coarray components in derived types that are of type C_PTR, C_FUNPTR, or type TEAM_TYPE. I implemented the check for C748 that requires a data component whose type has a coarray ultimate component to be a nonpointer, nonallocatable scalar and not be a coarray. I implemented the check for C750 that adds additional restrictions to the bounds expressions of a derived type component that's an array. These bounds expressions are sepcification expressions as defined in 10.1.11. There was already code in lib/Evaluate/check-expression.cpp to check semantics for specification expressions, but it did not check for the extra requirements of C750. C750 prohibits specification functions, the intrinsic functions ALLOCATED, ASSOCIATED, EXTENDS_TYPE_OF, PRESENT, and SAME_TYPE_AS. It also requires every specification inquiry reference to be a constant expression, and requires that the value of the bound not depend on the value of a variable. To implement these additional checks, I added code to the intrinsic proc table to get the intrinsic class of a procedure. I also added an enumeration to distinguish between specification expressions for derived type component bounds versus for type parameters. I then changed the code to pass an enumeration value to "CheckSpecificationExpr()" to indicate that the expression was a bounds expression and used this value to determine whether to emit an error message when violations of C750 are found. I changed the implementation of IsPureProcedure() to handle statement functions and changed some references in the code that tested for the PURE attribute to call IsPureProcedure(). I also fixed some unrelated tests that got new errors when I implemented these new checks. Reviewers: tskeith, DavidTruby, sscalpone Subscribers: jfb, llvm-commits Tags: #llvm, #flang Differential Revision: https://reviews.llvm.org/D79263
2020-05-02 04:00:28 +08:00
DefaultLogical, Rank::elemental, IntrinsicClass::inquiryFunction},
[flang] Add -i8, -r8, &c. options to f18 development driver Original-commit: flang-compiler/f18@ff7f338126562ce539879a59d3da5707c76ae11a Reviewed-on: https://github.com/flang-compiler/f18/pull/213
2018-10-17 05:42:22 +08:00
{"is_iostat_end", {{"i", AnyInt}}, DefaultLogical},
{"is_iostat_eor", {{"i", AnyInt}}, DefaultLogical},
[flang] New implementation for checks for constraints C741 through C750 Summary: Most of these checks were already implemented, and I just added references to them to the code and tests. Also, much of this code was already reviewed in the old flang/f18 GitHub repository, but I didn't get to merge it before we switched repositories. I implemented the check for C747 to not allow coarray components in derived types that are of type C_PTR, C_FUNPTR, or type TEAM_TYPE. I implemented the check for C748 that requires a data component whose type has a coarray ultimate component to be a nonpointer, nonallocatable scalar and not be a coarray. I implemented the check for C750 that adds additional restrictions to the bounds expressions of a derived type component that's an array. These bounds expressions are sepcification expressions as defined in 10.1.11. There was already code in lib/Evaluate/check-expression.cpp to check semantics for specification expressions, but it did not check for the extra requirements of C750. C750 prohibits specification functions, the intrinsic functions ALLOCATED, ASSOCIATED, EXTENDS_TYPE_OF, PRESENT, and SAME_TYPE_AS. It also requires every specification inquiry reference to be a constant expression, and requires that the value of the bound not depend on the value of a variable. To implement these additional checks, I added code to the intrinsic proc table to get the intrinsic class of a procedure. I also added an enumeration to distinguish between specification expressions for derived type component bounds versus for type parameters. I then changed the code to pass an enumeration value to "CheckSpecificationExpr()" to indicate that the expression was a bounds expression and used this value to determine whether to emit an error message when violations of C750 are found. I changed the implementation of IsPureProcedure() to handle statement functions and changed some references in the code that tested for the PURE attribute to call IsPureProcedure(). I also fixed some unrelated tests that got new errors when I implemented these new checks. Reviewers: tskeith, DavidTruby, sscalpone Subscribers: jfb, llvm-commits Tags: #llvm, #flang Differential Revision: https://reviews.llvm.org/D79263
2020-05-02 04:00:28 +08:00
{"kind", {{"x", AnyIntrinsic}}, DefaultInt, Rank::elemental,
IntrinsicClass::inquiryFunction},
[flang] remove arg->intValue field Original-commit: flang-compiler/f18@721dc920227378d09d89758903c50538b61ffec3 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-10 03:07:29 +08:00
{"lbound",
[flang] Update preprocessing document, commentary Extend documentation on preprocessing IsSimplyContiguous basic skeleton Apply suggested improvements to mod-file.cc Checks for new call13.f90 (15.4.2.2 explicit interfaces) Implement checking for procedures that can be called via an implicit interface Argument checking, test fixing Better argument checking Better derived type compatibility checking Treat externals as if implicitly interfaced Extend IEEE_EXCEPTIONS module so tests still pass with argument checking SAME_TYPE_AS and EXTENDS_TYPE_OF intrinsic inquiry functions Define interfaces for most intrinsic subroutines Better PASS arguments More with PASS() argument Prep for review address comments fix comment Remove formatted expression from specification expression error message per review more review comments Original-commit: flang-compiler/f18@3cca775da9302e3a2acec4a34800cd7666899b5f Reviewed-on: https://github.com/flang-compiler/f18/pull/776
2019-09-17 07:58:13 +08:00
{{"array", AnyData, Rank::anyOrAssumedRank}, RequiredDIM,
[flang] enable semantic analysis by default back out -Mnolargearray default temporarily Fix C_F_POINTER(SHAPE=) argument check, it can be any kind of integer Revert default result kind of SIZE() & al. to standard by default Remove needless usage of -fdebug-semantics Original-commit: flang-compiler/f18@57058a5b163eaa90c7e0f387ea4918f9efa8184c Reviewed-on: https://github.com/flang-compiler/f18/pull/907
2020-01-04 08:32:23 +08:00
SizeDefaultKIND},
[flang] New implementation for checks for constraints C741 through C750 Summary: Most of these checks were already implemented, and I just added references to them to the code and tests. Also, much of this code was already reviewed in the old flang/f18 GitHub repository, but I didn't get to merge it before we switched repositories. I implemented the check for C747 to not allow coarray components in derived types that are of type C_PTR, C_FUNPTR, or type TEAM_TYPE. I implemented the check for C748 that requires a data component whose type has a coarray ultimate component to be a nonpointer, nonallocatable scalar and not be a coarray. I implemented the check for C750 that adds additional restrictions to the bounds expressions of a derived type component that's an array. These bounds expressions are sepcification expressions as defined in 10.1.11. There was already code in lib/Evaluate/check-expression.cpp to check semantics for specification expressions, but it did not check for the extra requirements of C750. C750 prohibits specification functions, the intrinsic functions ALLOCATED, ASSOCIATED, EXTENDS_TYPE_OF, PRESENT, and SAME_TYPE_AS. It also requires every specification inquiry reference to be a constant expression, and requires that the value of the bound not depend on the value of a variable. To implement these additional checks, I added code to the intrinsic proc table to get the intrinsic class of a procedure. I also added an enumeration to distinguish between specification expressions for derived type component bounds versus for type parameters. I then changed the code to pass an enumeration value to "CheckSpecificationExpr()" to indicate that the expression was a bounds expression and used this value to determine whether to emit an error message when violations of C750 are found. I changed the implementation of IsPureProcedure() to handle statement functions and changed some references in the code that tested for the PURE attribute to call IsPureProcedure(). I also fixed some unrelated tests that got new errors when I implemented these new checks. Reviewers: tskeith, DavidTruby, sscalpone Subscribers: jfb, llvm-commits Tags: #llvm, #flang Differential Revision: https://reviews.llvm.org/D79263
2020-05-02 04:00:28 +08:00
KINDInt, Rank::scalar, IntrinsicClass::inquiryFunction},
[flang] enable semantic analysis by default back out -Mnolargearray default temporarily Fix C_F_POINTER(SHAPE=) argument check, it can be any kind of integer Revert default result kind of SIZE() & al. to standard by default Remove needless usage of -fdebug-semantics Original-commit: flang-compiler/f18@57058a5b163eaa90c7e0f387ea4918f9efa8184c Reviewed-on: https://github.com/flang-compiler/f18/pull/907
2020-01-04 08:32:23 +08:00
{"lbound", {{"array", AnyData, Rank::anyOrAssumedRank}, SizeDefaultKIND},
[flang] New implementation for checks for constraints C741 through C750 Summary: Most of these checks were already implemented, and I just added references to them to the code and tests. Also, much of this code was already reviewed in the old flang/f18 GitHub repository, but I didn't get to merge it before we switched repositories. I implemented the check for C747 to not allow coarray components in derived types that are of type C_PTR, C_FUNPTR, or type TEAM_TYPE. I implemented the check for C748 that requires a data component whose type has a coarray ultimate component to be a nonpointer, nonallocatable scalar and not be a coarray. I implemented the check for C750 that adds additional restrictions to the bounds expressions of a derived type component that's an array. These bounds expressions are sepcification expressions as defined in 10.1.11. There was already code in lib/Evaluate/check-expression.cpp to check semantics for specification expressions, but it did not check for the extra requirements of C750. C750 prohibits specification functions, the intrinsic functions ALLOCATED, ASSOCIATED, EXTENDS_TYPE_OF, PRESENT, and SAME_TYPE_AS. It also requires every specification inquiry reference to be a constant expression, and requires that the value of the bound not depend on the value of a variable. To implement these additional checks, I added code to the intrinsic proc table to get the intrinsic class of a procedure. I also added an enumeration to distinguish between specification expressions for derived type component bounds versus for type parameters. I then changed the code to pass an enumeration value to "CheckSpecificationExpr()" to indicate that the expression was a bounds expression and used this value to determine whether to emit an error message when violations of C750 are found. I changed the implementation of IsPureProcedure() to handle statement functions and changed some references in the code that tested for the PURE attribute to call IsPureProcedure(). I also fixed some unrelated tests that got new errors when I implemented these new checks. Reviewers: tskeith, DavidTruby, sscalpone Subscribers: jfb, llvm-commits Tags: #llvm, #flang Differential Revision: https://reviews.llvm.org/D79263
2020-05-02 04:00:28 +08:00
KINDInt, Rank::vector, IntrinsicClass::inquiryFunction},
[flang] Add -i8, -r8, &c. options to f18 development driver Original-commit: flang-compiler/f18@ff7f338126562ce539879a59d3da5707c76ae11a Reviewed-on: https://github.com/flang-compiler/f18/pull/213
2018-10-17 05:42:22 +08:00
{"leadz", {{"i", AnyInt}}, DefaultInt},
[flang] Revert to returning default INTEGER for LEN() and offset-in-CHARACTER intrinsics; further shape analysis of intrinsic results Original-commit: flang-compiler/f18@561f5965b2309df3cd15d7e2a96d7e73f2f76e35 Reviewed-on: https://github.com/flang-compiler/f18/pull/782 Tree-same-pre-rewrite: false
2019-10-17 02:53:03 +08:00
{"len", {{"string", AnyChar, Rank::anyOrAssumedRank}, DefaultingKIND},
[flang] New implementation for checks for constraints C741 through C750 Summary: Most of these checks were already implemented, and I just added references to them to the code and tests. Also, much of this code was already reviewed in the old flang/f18 GitHub repository, but I didn't get to merge it before we switched repositories. I implemented the check for C747 to not allow coarray components in derived types that are of type C_PTR, C_FUNPTR, or type TEAM_TYPE. I implemented the check for C748 that requires a data component whose type has a coarray ultimate component to be a nonpointer, nonallocatable scalar and not be a coarray. I implemented the check for C750 that adds additional restrictions to the bounds expressions of a derived type component that's an array. These bounds expressions are sepcification expressions as defined in 10.1.11. There was already code in lib/Evaluate/check-expression.cpp to check semantics for specification expressions, but it did not check for the extra requirements of C750. C750 prohibits specification functions, the intrinsic functions ALLOCATED, ASSOCIATED, EXTENDS_TYPE_OF, PRESENT, and SAME_TYPE_AS. It also requires every specification inquiry reference to be a constant expression, and requires that the value of the bound not depend on the value of a variable. To implement these additional checks, I added code to the intrinsic proc table to get the intrinsic class of a procedure. I also added an enumeration to distinguish between specification expressions for derived type component bounds versus for type parameters. I then changed the code to pass an enumeration value to "CheckSpecificationExpr()" to indicate that the expression was a bounds expression and used this value to determine whether to emit an error message when violations of C750 are found. I changed the implementation of IsPureProcedure() to handle statement functions and changed some references in the code that tested for the PURE attribute to call IsPureProcedure(). I also fixed some unrelated tests that got new errors when I implemented these new checks. Reviewers: tskeith, DavidTruby, sscalpone Subscribers: jfb, llvm-commits Tags: #llvm, #flang Differential Revision: https://reviews.llvm.org/D79263
2020-05-02 04:00:28 +08:00
KINDInt, Rank::scalar, IntrinsicClass::inquiryFunction},
[flang] Revert to returning default INTEGER for LEN() and offset-in-CHARACTER intrinsics; further shape analysis of intrinsic results Original-commit: flang-compiler/f18@561f5965b2309df3cd15d7e2a96d7e73f2f76e35 Reviewed-on: https://github.com/flang-compiler/f18/pull/782 Tree-same-pre-rewrite: false
2019-10-17 02:53:03 +08:00
{"len_trim", {{"string", AnyChar}, DefaultingKIND}, KINDInt},
[flang] Add -i8, -r8, &c. options to f18 development driver Original-commit: flang-compiler/f18@ff7f338126562ce539879a59d3da5707c76ae11a Reviewed-on: https://github.com/flang-compiler/f18/pull/213
2018-10-17 05:42:22 +08:00
{"lge", {{"string_a", SameChar}, {"string_b", SameChar}}, DefaultLogical},
{"lgt", {{"string_a", SameChar}, {"string_b", SameChar}}, DefaultLogical},
{"lle", {{"string_a", SameChar}, {"string_b", SameChar}}, DefaultLogical},
{"llt", {{"string_a", SameChar}, {"string_b", SameChar}}, DefaultLogical},
[flang] checkpoint, all tests pass Fix name resolution for undeclared intrinsic actual arguments Original-commit: flang-compiler/f18@12470f06bcc09eb4858af9c3e412752d7ba71aee Reviewed-on: https://github.com/flang-compiler/f18/pull/818
2019-11-08 08:01:38 +08:00
{"loc", {{"loc_argument", Addressable, Rank::anyOrAssumedRank}},
SubscriptInt, Rank::scalar},
[flang] intrinsic pattern matching Original-commit: flang-compiler/f18@ca0ee1660a6449c34c7276284e5e63b90ae97540 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-05 04:43:33 +08:00
{"log", {{"x", SameFloating}}, SameFloating},
{"log10", {{"x", SameReal}}, SameReal},
{"logical", {{"l", AnyLogical}, DefaultingKIND}, KINDLogical},
{"log_gamma", {{"x", SameReal}}, SameReal},
[flang] remove arg->intValue field Original-commit: flang-compiler/f18@721dc920227378d09d89758903c50538b61ffec3 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-10 03:07:29 +08:00
{"matmul",
[flang] Shape analysis for result of MATMUL Implement shape analysis for the result of the MATMUL generic transformational intrinsic function, based on the shapes of its arguments. Correct the names of the arguments to match the standard, too. Reviewed By: PeteSteinfeld Differential Revision: https://reviews.llvm.org/D82250
2020-06-20 09:11:46 +08:00
{{"matrix_a", AnyLogical, Rank::vector},
{"matrix_b", AnyLogical, Rank::matrix}},
[flang] New implementation for checks for constraints C741 through C750 Summary: Most of these checks were already implemented, and I just added references to them to the code and tests. Also, much of this code was already reviewed in the old flang/f18 GitHub repository, but I didn't get to merge it before we switched repositories. I implemented the check for C747 to not allow coarray components in derived types that are of type C_PTR, C_FUNPTR, or type TEAM_TYPE. I implemented the check for C748 that requires a data component whose type has a coarray ultimate component to be a nonpointer, nonallocatable scalar and not be a coarray. I implemented the check for C750 that adds additional restrictions to the bounds expressions of a derived type component that's an array. These bounds expressions are sepcification expressions as defined in 10.1.11. There was already code in lib/Evaluate/check-expression.cpp to check semantics for specification expressions, but it did not check for the extra requirements of C750. C750 prohibits specification functions, the intrinsic functions ALLOCATED, ASSOCIATED, EXTENDS_TYPE_OF, PRESENT, and SAME_TYPE_AS. It also requires every specification inquiry reference to be a constant expression, and requires that the value of the bound not depend on the value of a variable. To implement these additional checks, I added code to the intrinsic proc table to get the intrinsic class of a procedure. I also added an enumeration to distinguish between specification expressions for derived type component bounds versus for type parameters. I then changed the code to pass an enumeration value to "CheckSpecificationExpr()" to indicate that the expression was a bounds expression and used this value to determine whether to emit an error message when violations of C750 are found. I changed the implementation of IsPureProcedure() to handle statement functions and changed some references in the code that tested for the PURE attribute to call IsPureProcedure(). I also fixed some unrelated tests that got new errors when I implemented these new checks. Reviewers: tskeith, DavidTruby, sscalpone Subscribers: jfb, llvm-commits Tags: #llvm, #flang Differential Revision: https://reviews.llvm.org/D79263
2020-05-02 04:00:28 +08:00
ResultLogical, Rank::vector, IntrinsicClass::transformationalFunction},
[flang] remove arg->intValue field Original-commit: flang-compiler/f18@721dc920227378d09d89758903c50538b61ffec3 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-10 03:07:29 +08:00
{"matmul",
[flang] Shape analysis for result of MATMUL Implement shape analysis for the result of the MATMUL generic transformational intrinsic function, based on the shapes of its arguments. Correct the names of the arguments to match the standard, too. Reviewed By: PeteSteinfeld Differential Revision: https://reviews.llvm.org/D82250
2020-06-20 09:11:46 +08:00
{{"matrix_a", AnyLogical, Rank::matrix},
{"matrix_b", AnyLogical, Rank::vector}},
[flang] New implementation for checks for constraints C741 through C750 Summary: Most of these checks were already implemented, and I just added references to them to the code and tests. Also, much of this code was already reviewed in the old flang/f18 GitHub repository, but I didn't get to merge it before we switched repositories. I implemented the check for C747 to not allow coarray components in derived types that are of type C_PTR, C_FUNPTR, or type TEAM_TYPE. I implemented the check for C748 that requires a data component whose type has a coarray ultimate component to be a nonpointer, nonallocatable scalar and not be a coarray. I implemented the check for C750 that adds additional restrictions to the bounds expressions of a derived type component that's an array. These bounds expressions are sepcification expressions as defined in 10.1.11. There was already code in lib/Evaluate/check-expression.cpp to check semantics for specification expressions, but it did not check for the extra requirements of C750. C750 prohibits specification functions, the intrinsic functions ALLOCATED, ASSOCIATED, EXTENDS_TYPE_OF, PRESENT, and SAME_TYPE_AS. It also requires every specification inquiry reference to be a constant expression, and requires that the value of the bound not depend on the value of a variable. To implement these additional checks, I added code to the intrinsic proc table to get the intrinsic class of a procedure. I also added an enumeration to distinguish between specification expressions for derived type component bounds versus for type parameters. I then changed the code to pass an enumeration value to "CheckSpecificationExpr()" to indicate that the expression was a bounds expression and used this value to determine whether to emit an error message when violations of C750 are found. I changed the implementation of IsPureProcedure() to handle statement functions and changed some references in the code that tested for the PURE attribute to call IsPureProcedure(). I also fixed some unrelated tests that got new errors when I implemented these new checks. Reviewers: tskeith, DavidTruby, sscalpone Subscribers: jfb, llvm-commits Tags: #llvm, #flang Differential Revision: https://reviews.llvm.org/D79263
2020-05-02 04:00:28 +08:00
ResultLogical, Rank::vector, IntrinsicClass::transformationalFunction},
[flang] remove arg->intValue field Original-commit: flang-compiler/f18@721dc920227378d09d89758903c50538b61ffec3 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-10 03:07:29 +08:00
{"matmul",
[flang] Shape analysis for result of MATMUL Implement shape analysis for the result of the MATMUL generic transformational intrinsic function, based on the shapes of its arguments. Correct the names of the arguments to match the standard, too. Reviewed By: PeteSteinfeld Differential Revision: https://reviews.llvm.org/D82250
2020-06-20 09:11:46 +08:00
{{"matrix_a", AnyLogical, Rank::matrix},
{"matrix_b", AnyLogical, Rank::matrix}},
[flang] New implementation for checks for constraints C741 through C750 Summary: Most of these checks were already implemented, and I just added references to them to the code and tests. Also, much of this code was already reviewed in the old flang/f18 GitHub repository, but I didn't get to merge it before we switched repositories. I implemented the check for C747 to not allow coarray components in derived types that are of type C_PTR, C_FUNPTR, or type TEAM_TYPE. I implemented the check for C748 that requires a data component whose type has a coarray ultimate component to be a nonpointer, nonallocatable scalar and not be a coarray. I implemented the check for C750 that adds additional restrictions to the bounds expressions of a derived type component that's an array. These bounds expressions are sepcification expressions as defined in 10.1.11. There was already code in lib/Evaluate/check-expression.cpp to check semantics for specification expressions, but it did not check for the extra requirements of C750. C750 prohibits specification functions, the intrinsic functions ALLOCATED, ASSOCIATED, EXTENDS_TYPE_OF, PRESENT, and SAME_TYPE_AS. It also requires every specification inquiry reference to be a constant expression, and requires that the value of the bound not depend on the value of a variable. To implement these additional checks, I added code to the intrinsic proc table to get the intrinsic class of a procedure. I also added an enumeration to distinguish between specification expressions for derived type component bounds versus for type parameters. I then changed the code to pass an enumeration value to "CheckSpecificationExpr()" to indicate that the expression was a bounds expression and used this value to determine whether to emit an error message when violations of C750 are found. I changed the implementation of IsPureProcedure() to handle statement functions and changed some references in the code that tested for the PURE attribute to call IsPureProcedure(). I also fixed some unrelated tests that got new errors when I implemented these new checks. Reviewers: tskeith, DavidTruby, sscalpone Subscribers: jfb, llvm-commits Tags: #llvm, #flang Differential Revision: https://reviews.llvm.org/D79263
2020-05-02 04:00:28 +08:00
ResultLogical, Rank::matrix, IntrinsicClass::transformationalFunction},
[flang] remove arg->intValue field Original-commit: flang-compiler/f18@721dc920227378d09d89758903c50538b61ffec3 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-10 03:07:29 +08:00
{"matmul",
[flang] Shape analysis for result of MATMUL Implement shape analysis for the result of the MATMUL generic transformational intrinsic function, based on the shapes of its arguments. Correct the names of the arguments to match the standard, too. Reviewed By: PeteSteinfeld Differential Revision: https://reviews.llvm.org/D82250
2020-06-20 09:11:46 +08:00
{{"matrix_a", AnyNumeric, Rank::vector},
{"matrix_b", AnyNumeric, Rank::matrix}},
[flang] New implementation for checks for constraints C741 through C750 Summary: Most of these checks were already implemented, and I just added references to them to the code and tests. Also, much of this code was already reviewed in the old flang/f18 GitHub repository, but I didn't get to merge it before we switched repositories. I implemented the check for C747 to not allow coarray components in derived types that are of type C_PTR, C_FUNPTR, or type TEAM_TYPE. I implemented the check for C748 that requires a data component whose type has a coarray ultimate component to be a nonpointer, nonallocatable scalar and not be a coarray. I implemented the check for C750 that adds additional restrictions to the bounds expressions of a derived type component that's an array. These bounds expressions are sepcification expressions as defined in 10.1.11. There was already code in lib/Evaluate/check-expression.cpp to check semantics for specification expressions, but it did not check for the extra requirements of C750. C750 prohibits specification functions, the intrinsic functions ALLOCATED, ASSOCIATED, EXTENDS_TYPE_OF, PRESENT, and SAME_TYPE_AS. It also requires every specification inquiry reference to be a constant expression, and requires that the value of the bound not depend on the value of a variable. To implement these additional checks, I added code to the intrinsic proc table to get the intrinsic class of a procedure. I also added an enumeration to distinguish between specification expressions for derived type component bounds versus for type parameters. I then changed the code to pass an enumeration value to "CheckSpecificationExpr()" to indicate that the expression was a bounds expression and used this value to determine whether to emit an error message when violations of C750 are found. I changed the implementation of IsPureProcedure() to handle statement functions and changed some references in the code that tested for the PURE attribute to call IsPureProcedure(). I also fixed some unrelated tests that got new errors when I implemented these new checks. Reviewers: tskeith, DavidTruby, sscalpone Subscribers: jfb, llvm-commits Tags: #llvm, #flang Differential Revision: https://reviews.llvm.org/D79263
2020-05-02 04:00:28 +08:00
ResultNumeric, Rank::vector, IntrinsicClass::transformationalFunction},
[flang] remove arg->intValue field Original-commit: flang-compiler/f18@721dc920227378d09d89758903c50538b61ffec3 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-10 03:07:29 +08:00
{"matmul",
[flang] Shape analysis for result of MATMUL Implement shape analysis for the result of the MATMUL generic transformational intrinsic function, based on the shapes of its arguments. Correct the names of the arguments to match the standard, too. Reviewed By: PeteSteinfeld Differential Revision: https://reviews.llvm.org/D82250
2020-06-20 09:11:46 +08:00
{{"matrix_a", AnyNumeric, Rank::matrix},
{"matrix_b", AnyNumeric, Rank::vector}},
[flang] New implementation for checks for constraints C741 through C750 Summary: Most of these checks were already implemented, and I just added references to them to the code and tests. Also, much of this code was already reviewed in the old flang/f18 GitHub repository, but I didn't get to merge it before we switched repositories. I implemented the check for C747 to not allow coarray components in derived types that are of type C_PTR, C_FUNPTR, or type TEAM_TYPE. I implemented the check for C748 that requires a data component whose type has a coarray ultimate component to be a nonpointer, nonallocatable scalar and not be a coarray. I implemented the check for C750 that adds additional restrictions to the bounds expressions of a derived type component that's an array. These bounds expressions are sepcification expressions as defined in 10.1.11. There was already code in lib/Evaluate/check-expression.cpp to check semantics for specification expressions, but it did not check for the extra requirements of C750. C750 prohibits specification functions, the intrinsic functions ALLOCATED, ASSOCIATED, EXTENDS_TYPE_OF, PRESENT, and SAME_TYPE_AS. It also requires every specification inquiry reference to be a constant expression, and requires that the value of the bound not depend on the value of a variable. To implement these additional checks, I added code to the intrinsic proc table to get the intrinsic class of a procedure. I also added an enumeration to distinguish between specification expressions for derived type component bounds versus for type parameters. I then changed the code to pass an enumeration value to "CheckSpecificationExpr()" to indicate that the expression was a bounds expression and used this value to determine whether to emit an error message when violations of C750 are found. I changed the implementation of IsPureProcedure() to handle statement functions and changed some references in the code that tested for the PURE attribute to call IsPureProcedure(). I also fixed some unrelated tests that got new errors when I implemented these new checks. Reviewers: tskeith, DavidTruby, sscalpone Subscribers: jfb, llvm-commits Tags: #llvm, #flang Differential Revision: https://reviews.llvm.org/D79263
2020-05-02 04:00:28 +08:00
ResultNumeric, Rank::vector, IntrinsicClass::transformationalFunction},
[flang] remove arg->intValue field Original-commit: flang-compiler/f18@721dc920227378d09d89758903c50538b61ffec3 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-10 03:07:29 +08:00
{"matmul",
[flang] Shape analysis for result of MATMUL Implement shape analysis for the result of the MATMUL generic transformational intrinsic function, based on the shapes of its arguments. Correct the names of the arguments to match the standard, too. Reviewed By: PeteSteinfeld Differential Revision: https://reviews.llvm.org/D82250
2020-06-20 09:11:46 +08:00
{{"matrix_a", AnyNumeric, Rank::matrix},
{"matrix_b", AnyNumeric, Rank::matrix}},
[flang] New implementation for checks for constraints C741 through C750 Summary: Most of these checks were already implemented, and I just added references to them to the code and tests. Also, much of this code was already reviewed in the old flang/f18 GitHub repository, but I didn't get to merge it before we switched repositories. I implemented the check for C747 to not allow coarray components in derived types that are of type C_PTR, C_FUNPTR, or type TEAM_TYPE. I implemented the check for C748 that requires a data component whose type has a coarray ultimate component to be a nonpointer, nonallocatable scalar and not be a coarray. I implemented the check for C750 that adds additional restrictions to the bounds expressions of a derived type component that's an array. These bounds expressions are sepcification expressions as defined in 10.1.11. There was already code in lib/Evaluate/check-expression.cpp to check semantics for specification expressions, but it did not check for the extra requirements of C750. C750 prohibits specification functions, the intrinsic functions ALLOCATED, ASSOCIATED, EXTENDS_TYPE_OF, PRESENT, and SAME_TYPE_AS. It also requires every specification inquiry reference to be a constant expression, and requires that the value of the bound not depend on the value of a variable. To implement these additional checks, I added code to the intrinsic proc table to get the intrinsic class of a procedure. I also added an enumeration to distinguish between specification expressions for derived type component bounds versus for type parameters. I then changed the code to pass an enumeration value to "CheckSpecificationExpr()" to indicate that the expression was a bounds expression and used this value to determine whether to emit an error message when violations of C750 are found. I changed the implementation of IsPureProcedure() to handle statement functions and changed some references in the code that tested for the PURE attribute to call IsPureProcedure(). I also fixed some unrelated tests that got new errors when I implemented these new checks. Reviewers: tskeith, DavidTruby, sscalpone Subscribers: jfb, llvm-commits Tags: #llvm, #flang Differential Revision: https://reviews.llvm.org/D79263
2020-05-02 04:00:28 +08:00
ResultNumeric, Rank::matrix, IntrinsicClass::transformationalFunction},
[flang] intrinsic pattern matching Original-commit: flang-compiler/f18@ca0ee1660a6449c34c7276284e5e63b90ae97540 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-05 04:43:33 +08:00
{"maskl", {{"i", AnyInt}, DefaultingKIND}, KINDInt},
{"maskr", {{"i", AnyInt}, DefaultingKIND}, KINDInt},
[flang] finish most intrinsic table entries Original-commit: flang-compiler/f18@134bd885af5c67ae7fc2291778397546a3d1c189 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-12 05:51:14 +08:00
{"max",
[flang] Extension: relax "same kind" rules on some intrinsics Original-commit: flang-compiler/f18@ce5130f84bcb78007180ee87661c84b1483a476c Reviewed-on: https://github.com/flang-compiler/f18/pull/590 Tree-same-pre-rewrite: false
2019-07-18 03:51:52 +08:00
{{"a1", OperandIntOrReal}, {"a2", OperandIntOrReal},
{"a3", OperandIntOrReal, Rank::elemental, Optionality::repeats}},
OperandIntOrReal},
{"max",
{{"a1", SameChar}, {"a2", SameChar},
{"a3", SameChar, Rank::elemental, Optionality::repeats}},
SameChar},
[flang] Fold more model inquiry intrinsics Original-commit: flang-compiler/f18@a3d82893b768865aa51f105f92805f61a87d95f1 Reviewed-on: https://github.com/flang-compiler/f18/pull/602 Tree-same-pre-rewrite: false
2019-07-25 04:55:29 +08:00
{"maxexponent", {{"x", AnyReal, Rank::anyOrAssumedRank}}, DefaultInt,
[flang] New implementation for checks for constraints C741 through C750 Summary: Most of these checks were already implemented, and I just added references to them to the code and tests. Also, much of this code was already reviewed in the old flang/f18 GitHub repository, but I didn't get to merge it before we switched repositories. I implemented the check for C747 to not allow coarray components in derived types that are of type C_PTR, C_FUNPTR, or type TEAM_TYPE. I implemented the check for C748 that requires a data component whose type has a coarray ultimate component to be a nonpointer, nonallocatable scalar and not be a coarray. I implemented the check for C750 that adds additional restrictions to the bounds expressions of a derived type component that's an array. These bounds expressions are sepcification expressions as defined in 10.1.11. There was already code in lib/Evaluate/check-expression.cpp to check semantics for specification expressions, but it did not check for the extra requirements of C750. C750 prohibits specification functions, the intrinsic functions ALLOCATED, ASSOCIATED, EXTENDS_TYPE_OF, PRESENT, and SAME_TYPE_AS. It also requires every specification inquiry reference to be a constant expression, and requires that the value of the bound not depend on the value of a variable. To implement these additional checks, I added code to the intrinsic proc table to get the intrinsic class of a procedure. I also added an enumeration to distinguish between specification expressions for derived type component bounds versus for type parameters. I then changed the code to pass an enumeration value to "CheckSpecificationExpr()" to indicate that the expression was a bounds expression and used this value to determine whether to emit an error message when violations of C750 are found. I changed the implementation of IsPureProcedure() to handle statement functions and changed some references in the code that tested for the PURE attribute to call IsPureProcedure(). I also fixed some unrelated tests that got new errors when I implemented these new checks. Reviewers: tskeith, DavidTruby, sscalpone Subscribers: jfb, llvm-commits Tags: #llvm, #flang Differential Revision: https://reviews.llvm.org/D79263
2020-05-02 04:00:28 +08:00
Rank::scalar, IntrinsicClass::inquiryFunction},
[flang] initial intrinsics table Original-commit: flang-compiler/f18@8b5c3adf887cf88752937a4fa5507c0d66051d3b Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-09-29 08:02:11 +08:00
{"maxloc",
[flang] Correct shape analysis for transformational intrinsic functions Correct the analysis of references to transformational intrinsic functions that have different semantics based on the presence or absence of a DIM= argument; add shape analysis for UNPACK(). Differential Revision: https://reviews.llvm.org/D94716
2021-01-15 04:54:31 +08:00
{{"array", AnyRelatable, Rank::array}, RequiredDIM, OptionalMASK,
[flang] enable semantic analysis by default back out -Mnolargearray default temporarily Fix C_F_POINTER(SHAPE=) argument check, it can be any kind of integer Revert default result kind of SIZE() & al. to standard by default Remove needless usage of -fdebug-semantics Original-commit: flang-compiler/f18@57058a5b163eaa90c7e0f387ea4918f9efa8184c Reviewed-on: https://github.com/flang-compiler/f18/pull/907
2020-01-04 08:32:23 +08:00
SizeDefaultKIND,
[flang] error messages Original-commit: flang-compiler/f18@392a7330736a8fd444ef92ed5c8ef7dcbc94d461 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-06 02:32:54 +08:00
{"back", AnyLogical, Rank::scalar, Optionality::optional}},
[flang] Correct shape analysis for transformational intrinsic functions Correct the analysis of references to transformational intrinsic functions that have different semantics based on the presence or absence of a DIM= argument; add shape analysis for UNPACK(). Differential Revision: https://reviews.llvm.org/D94716
2021-01-15 04:54:31 +08:00
KINDInt, Rank::locReduced, IntrinsicClass::transformationalFunction},
{"maxloc",
{{"array", AnyRelatable, Rank::array}, MissingDIM, OptionalMASK,
SizeDefaultKIND,
{"back", AnyLogical, Rank::scalar, Optionality::optional}},
KINDInt, Rank::locReduced, IntrinsicClass::transformationalFunction},
[flang] initial intrinsics table Original-commit: flang-compiler/f18@8b5c3adf887cf88752937a4fa5507c0d66051d3b Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-09-29 08:02:11 +08:00
{"maxval",
[flang] Correct shape analysis for transformational intrinsic functions Correct the analysis of references to transformational intrinsic functions that have different semantics based on the presence or absence of a DIM= argument; add shape analysis for UNPACK(). Differential Revision: https://reviews.llvm.org/D94716
2021-01-15 04:54:31 +08:00
{{"array", SameRelatable, Rank::array}, RequiredDIM, OptionalMASK},
[flang] New implementation for checks for constraints C741 through C750 Summary: Most of these checks were already implemented, and I just added references to them to the code and tests. Also, much of this code was already reviewed in the old flang/f18 GitHub repository, but I didn't get to merge it before we switched repositories. I implemented the check for C747 to not allow coarray components in derived types that are of type C_PTR, C_FUNPTR, or type TEAM_TYPE. I implemented the check for C748 that requires a data component whose type has a coarray ultimate component to be a nonpointer, nonallocatable scalar and not be a coarray. I implemented the check for C750 that adds additional restrictions to the bounds expressions of a derived type component that's an array. These bounds expressions are sepcification expressions as defined in 10.1.11. There was already code in lib/Evaluate/check-expression.cpp to check semantics for specification expressions, but it did not check for the extra requirements of C750. C750 prohibits specification functions, the intrinsic functions ALLOCATED, ASSOCIATED, EXTENDS_TYPE_OF, PRESENT, and SAME_TYPE_AS. It also requires every specification inquiry reference to be a constant expression, and requires that the value of the bound not depend on the value of a variable. To implement these additional checks, I added code to the intrinsic proc table to get the intrinsic class of a procedure. I also added an enumeration to distinguish between specification expressions for derived type component bounds versus for type parameters. I then changed the code to pass an enumeration value to "CheckSpecificationExpr()" to indicate that the expression was a bounds expression and used this value to determine whether to emit an error message when violations of C750 are found. I changed the implementation of IsPureProcedure() to handle statement functions and changed some references in the code that tested for the PURE attribute to call IsPureProcedure(). I also fixed some unrelated tests that got new errors when I implemented these new checks. Reviewers: tskeith, DavidTruby, sscalpone Subscribers: jfb, llvm-commits Tags: #llvm, #flang Differential Revision: https://reviews.llvm.org/D79263
2020-05-02 04:00:28 +08:00
SameRelatable, Rank::dimReduced,
IntrinsicClass::transformationalFunction},
[flang] Correct shape analysis for transformational intrinsic functions Correct the analysis of references to transformational intrinsic functions that have different semantics based on the presence or absence of a DIM= argument; add shape analysis for UNPACK(). Differential Revision: https://reviews.llvm.org/D94716
2021-01-15 04:54:31 +08:00
{"maxval",
{{"array", SameRelatable, Rank::array}, MissingDIM, OptionalMASK},
SameRelatable, Rank::scalar, IntrinsicClass::transformationalFunction},
[flang] finish most intrinsic table entries Original-commit: flang-compiler/f18@134bd885af5c67ae7fc2291778397546a3d1c189 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-12 05:51:14 +08:00
{"merge",
{{"tsource", SameType}, {"fsource", SameType}, {"mask", AnyLogical}},
SameType},
[flang] initial intrinsics table Original-commit: flang-compiler/f18@8b5c3adf887cf88752937a4fa5507c0d66051d3b Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-09-29 08:02:11 +08:00
{"merge_bits",
[flang] error messages Original-commit: flang-compiler/f18@392a7330736a8fd444ef92ed5c8ef7dcbc94d461 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-06 02:32:54 +08:00
{{"i", SameInt}, {"j", SameInt, Rank::elementalOrBOZ},
{"mask", SameInt, Rank::elementalOrBOZ}},
[flang] intrinsic pattern matching Original-commit: flang-compiler/f18@ca0ee1660a6449c34c7276284e5e63b90ae97540 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-05 04:43:33 +08:00
SameInt},
{"merge_bits",
[flang] error messages Original-commit: flang-compiler/f18@392a7330736a8fd444ef92ed5c8ef7dcbc94d461 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-06 02:32:54 +08:00
{{"i", BOZ}, {"j", SameInt}, {"mask", SameInt, Rank::elementalOrBOZ}},
[flang] intrinsic pattern matching Original-commit: flang-compiler/f18@ca0ee1660a6449c34c7276284e5e63b90ae97540 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-05 04:43:33 +08:00
SameInt},
[flang] finish most intrinsic table entries Original-commit: flang-compiler/f18@134bd885af5c67ae7fc2291778397546a3d1c189 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-12 05:51:14 +08:00
{"min",
[flang] Extension: relax "same kind" rules on some intrinsics Original-commit: flang-compiler/f18@ce5130f84bcb78007180ee87661c84b1483a476c Reviewed-on: https://github.com/flang-compiler/f18/pull/590 Tree-same-pre-rewrite: false
2019-07-18 03:51:52 +08:00
{{"a1", OperandIntOrReal}, {"a2", OperandIntOrReal},
{"a3", OperandIntOrReal, Rank::elemental, Optionality::repeats}},
OperandIntOrReal},
{"min",
{{"a1", SameChar}, {"a2", SameChar},
{"a3", SameChar, Rank::elemental, Optionality::repeats}},
SameChar},
[flang] Fold more model inquiry intrinsics Original-commit: flang-compiler/f18@a3d82893b768865aa51f105f92805f61a87d95f1 Reviewed-on: https://github.com/flang-compiler/f18/pull/602 Tree-same-pre-rewrite: false
2019-07-25 04:55:29 +08:00
{"minexponent", {{"x", AnyReal, Rank::anyOrAssumedRank}}, DefaultInt,
[flang] New implementation for checks for constraints C741 through C750 Summary: Most of these checks were already implemented, and I just added references to them to the code and tests. Also, much of this code was already reviewed in the old flang/f18 GitHub repository, but I didn't get to merge it before we switched repositories. I implemented the check for C747 to not allow coarray components in derived types that are of type C_PTR, C_FUNPTR, or type TEAM_TYPE. I implemented the check for C748 that requires a data component whose type has a coarray ultimate component to be a nonpointer, nonallocatable scalar and not be a coarray. I implemented the check for C750 that adds additional restrictions to the bounds expressions of a derived type component that's an array. These bounds expressions are sepcification expressions as defined in 10.1.11. There was already code in lib/Evaluate/check-expression.cpp to check semantics for specification expressions, but it did not check for the extra requirements of C750. C750 prohibits specification functions, the intrinsic functions ALLOCATED, ASSOCIATED, EXTENDS_TYPE_OF, PRESENT, and SAME_TYPE_AS. It also requires every specification inquiry reference to be a constant expression, and requires that the value of the bound not depend on the value of a variable. To implement these additional checks, I added code to the intrinsic proc table to get the intrinsic class of a procedure. I also added an enumeration to distinguish between specification expressions for derived type component bounds versus for type parameters. I then changed the code to pass an enumeration value to "CheckSpecificationExpr()" to indicate that the expression was a bounds expression and used this value to determine whether to emit an error message when violations of C750 are found. I changed the implementation of IsPureProcedure() to handle statement functions and changed some references in the code that tested for the PURE attribute to call IsPureProcedure(). I also fixed some unrelated tests that got new errors when I implemented these new checks. Reviewers: tskeith, DavidTruby, sscalpone Subscribers: jfb, llvm-commits Tags: #llvm, #flang Differential Revision: https://reviews.llvm.org/D79263
2020-05-02 04:00:28 +08:00
Rank::scalar, IntrinsicClass::inquiryFunction},
[flang] initial intrinsics table Original-commit: flang-compiler/f18@8b5c3adf887cf88752937a4fa5507c0d66051d3b Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-09-29 08:02:11 +08:00
{"minloc",
[flang] Correct shape analysis for transformational intrinsic functions Correct the analysis of references to transformational intrinsic functions that have different semantics based on the presence or absence of a DIM= argument; add shape analysis for UNPACK(). Differential Revision: https://reviews.llvm.org/D94716
2021-01-15 04:54:31 +08:00
{{"array", AnyRelatable, Rank::array}, RequiredDIM, OptionalMASK,
[flang] enable semantic analysis by default back out -Mnolargearray default temporarily Fix C_F_POINTER(SHAPE=) argument check, it can be any kind of integer Revert default result kind of SIZE() & al. to standard by default Remove needless usage of -fdebug-semantics Original-commit: flang-compiler/f18@57058a5b163eaa90c7e0f387ea4918f9efa8184c Reviewed-on: https://github.com/flang-compiler/f18/pull/907
2020-01-04 08:32:23 +08:00
SizeDefaultKIND,
[flang] error messages Original-commit: flang-compiler/f18@392a7330736a8fd444ef92ed5c8ef7dcbc94d461 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-06 02:32:54 +08:00
{"back", AnyLogical, Rank::scalar, Optionality::optional}},
[flang] Correct shape analysis for transformational intrinsic functions Correct the analysis of references to transformational intrinsic functions that have different semantics based on the presence or absence of a DIM= argument; add shape analysis for UNPACK(). Differential Revision: https://reviews.llvm.org/D94716
2021-01-15 04:54:31 +08:00
KINDInt, Rank::locReduced, IntrinsicClass::transformationalFunction},
{"minloc",
{{"array", AnyRelatable, Rank::array}, MissingDIM, OptionalMASK,
SizeDefaultKIND,
{"back", AnyLogical, Rank::scalar, Optionality::optional}},
KINDInt, Rank::locReduced, IntrinsicClass::transformationalFunction},
[flang] initial intrinsics table Original-commit: flang-compiler/f18@8b5c3adf887cf88752937a4fa5507c0d66051d3b Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-09-29 08:02:11 +08:00
{"minval",
[flang] Correct shape analysis for transformational intrinsic functions Correct the analysis of references to transformational intrinsic functions that have different semantics based on the presence or absence of a DIM= argument; add shape analysis for UNPACK(). Differential Revision: https://reviews.llvm.org/D94716
2021-01-15 04:54:31 +08:00
{{"array", SameRelatable, Rank::array}, RequiredDIM, OptionalMASK},
[flang] New implementation for checks for constraints C741 through C750 Summary: Most of these checks were already implemented, and I just added references to them to the code and tests. Also, much of this code was already reviewed in the old flang/f18 GitHub repository, but I didn't get to merge it before we switched repositories. I implemented the check for C747 to not allow coarray components in derived types that are of type C_PTR, C_FUNPTR, or type TEAM_TYPE. I implemented the check for C748 that requires a data component whose type has a coarray ultimate component to be a nonpointer, nonallocatable scalar and not be a coarray. I implemented the check for C750 that adds additional restrictions to the bounds expressions of a derived type component that's an array. These bounds expressions are sepcification expressions as defined in 10.1.11. There was already code in lib/Evaluate/check-expression.cpp to check semantics for specification expressions, but it did not check for the extra requirements of C750. C750 prohibits specification functions, the intrinsic functions ALLOCATED, ASSOCIATED, EXTENDS_TYPE_OF, PRESENT, and SAME_TYPE_AS. It also requires every specification inquiry reference to be a constant expression, and requires that the value of the bound not depend on the value of a variable. To implement these additional checks, I added code to the intrinsic proc table to get the intrinsic class of a procedure. I also added an enumeration to distinguish between specification expressions for derived type component bounds versus for type parameters. I then changed the code to pass an enumeration value to "CheckSpecificationExpr()" to indicate that the expression was a bounds expression and used this value to determine whether to emit an error message when violations of C750 are found. I changed the implementation of IsPureProcedure() to handle statement functions and changed some references in the code that tested for the PURE attribute to call IsPureProcedure(). I also fixed some unrelated tests that got new errors when I implemented these new checks. Reviewers: tskeith, DavidTruby, sscalpone Subscribers: jfb, llvm-commits Tags: #llvm, #flang Differential Revision: https://reviews.llvm.org/D79263
2020-05-02 04:00:28 +08:00
SameRelatable, Rank::dimReduced,
IntrinsicClass::transformationalFunction},
[flang] Correct shape analysis for transformational intrinsic functions Correct the analysis of references to transformational intrinsic functions that have different semantics based on the presence or absence of a DIM= argument; add shape analysis for UNPACK(). Differential Revision: https://reviews.llvm.org/D94716
2021-01-15 04:54:31 +08:00
{"minval",
{{"array", SameRelatable, Rank::array}, MissingDIM, OptionalMASK},
SameRelatable, Rank::scalar, IntrinsicClass::transformationalFunction},
[flang] Extension: relax "same kind" rules on some intrinsics Original-commit: flang-compiler/f18@ce5130f84bcb78007180ee87661c84b1483a476c Reviewed-on: https://github.com/flang-compiler/f18/pull/590 Tree-same-pre-rewrite: false
2019-07-18 03:51:52 +08:00
{"mod", {{"a", OperandIntOrReal}, {"p", OperandIntOrReal}},
OperandIntOrReal},
{"modulo", {{"a", OperandIntOrReal}, {"p", OperandIntOrReal}},
OperandIntOrReal},
[flang] intrinsic pattern matching Original-commit: flang-compiler/f18@ca0ee1660a6449c34c7276284e5e63b90ae97540 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-05 04:43:33 +08:00
{"nearest", {{"x", SameReal}, {"s", AnyReal}}, SameReal},
[flang] Add NEW_LINE intrinsic to the intrinsic table NEW_LINE intrinsic folding was already implemented but it had not yet been added the the intrinsic table and was therefore not yet recognised an intrinsic. Add related tests. Original-commit: flang-compiler/f18@42fcf5b5f1e63267a024afaad39f012982c8abc1 Reviewed-on: https://github.com/flang-compiler/f18/pull/734
2019-09-11 18:01:55 +08:00
{"new_line", {{"x", SameChar, Rank::anyOrAssumedRank}}, SameChar,
[flang] New implementation for checks for constraints C741 through C750 Summary: Most of these checks were already implemented, and I just added references to them to the code and tests. Also, much of this code was already reviewed in the old flang/f18 GitHub repository, but I didn't get to merge it before we switched repositories. I implemented the check for C747 to not allow coarray components in derived types that are of type C_PTR, C_FUNPTR, or type TEAM_TYPE. I implemented the check for C748 that requires a data component whose type has a coarray ultimate component to be a nonpointer, nonallocatable scalar and not be a coarray. I implemented the check for C750 that adds additional restrictions to the bounds expressions of a derived type component that's an array. These bounds expressions are sepcification expressions as defined in 10.1.11. There was already code in lib/Evaluate/check-expression.cpp to check semantics for specification expressions, but it did not check for the extra requirements of C750. C750 prohibits specification functions, the intrinsic functions ALLOCATED, ASSOCIATED, EXTENDS_TYPE_OF, PRESENT, and SAME_TYPE_AS. It also requires every specification inquiry reference to be a constant expression, and requires that the value of the bound not depend on the value of a variable. To implement these additional checks, I added code to the intrinsic proc table to get the intrinsic class of a procedure. I also added an enumeration to distinguish between specification expressions for derived type component bounds versus for type parameters. I then changed the code to pass an enumeration value to "CheckSpecificationExpr()" to indicate that the expression was a bounds expression and used this value to determine whether to emit an error message when violations of C750 are found. I changed the implementation of IsPureProcedure() to handle statement functions and changed some references in the code that tested for the PURE attribute to call IsPureProcedure(). I also fixed some unrelated tests that got new errors when I implemented these new checks. Reviewers: tskeith, DavidTruby, sscalpone Subscribers: jfb, llvm-commits Tags: #llvm, #flang Differential Revision: https://reviews.llvm.org/D79263
2020-05-02 04:00:28 +08:00
Rank::scalar, IntrinsicClass::inquiryFunction},
[flang] intrinsic pattern matching Original-commit: flang-compiler/f18@ca0ee1660a6449c34c7276284e5e63b90ae97540 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-05 04:43:33 +08:00
{"nint", {{"a", AnyReal}, DefaultingKIND}, KINDInt},
{"norm2", {{"x", SameReal, Rank::array}, OptionalDIM}, SameReal,
[flang] New implementation for checks for constraints C741 through C750 Summary: Most of these checks were already implemented, and I just added references to them to the code and tests. Also, much of this code was already reviewed in the old flang/f18 GitHub repository, but I didn't get to merge it before we switched repositories. I implemented the check for C747 to not allow coarray components in derived types that are of type C_PTR, C_FUNPTR, or type TEAM_TYPE. I implemented the check for C748 that requires a data component whose type has a coarray ultimate component to be a nonpointer, nonallocatable scalar and not be a coarray. I implemented the check for C750 that adds additional restrictions to the bounds expressions of a derived type component that's an array. These bounds expressions are sepcification expressions as defined in 10.1.11. There was already code in lib/Evaluate/check-expression.cpp to check semantics for specification expressions, but it did not check for the extra requirements of C750. C750 prohibits specification functions, the intrinsic functions ALLOCATED, ASSOCIATED, EXTENDS_TYPE_OF, PRESENT, and SAME_TYPE_AS. It also requires every specification inquiry reference to be a constant expression, and requires that the value of the bound not depend on the value of a variable. To implement these additional checks, I added code to the intrinsic proc table to get the intrinsic class of a procedure. I also added an enumeration to distinguish between specification expressions for derived type component bounds versus for type parameters. I then changed the code to pass an enumeration value to "CheckSpecificationExpr()" to indicate that the expression was a bounds expression and used this value to determine whether to emit an error message when violations of C750 are found. I changed the implementation of IsPureProcedure() to handle statement functions and changed some references in the code that tested for the PURE attribute to call IsPureProcedure(). I also fixed some unrelated tests that got new errors when I implemented these new checks. Reviewers: tskeith, DavidTruby, sscalpone Subscribers: jfb, llvm-commits Tags: #llvm, #flang Differential Revision: https://reviews.llvm.org/D79263
2020-05-02 04:00:28 +08:00
Rank::dimReduced, IntrinsicClass::transformationalFunction},
[flang] intrinsic pattern matching Original-commit: flang-compiler/f18@ca0ee1660a6449c34c7276284e5e63b90ae97540 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-05 04:43:33 +08:00
{"not", {{"i", SameInt}}, SameInt},
[flang] more intrinsics Original-commit: flang-compiler/f18@2e7210be5b2db80c8aa446c4313c8b8df697fac0 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-11 01:48:12 +08:00
// NULL() is a special case handled in Probe() below
[flang] Make 'num_images()' intrinsic I added 'num_images()' to the list of functions that are evaluated as intrinsic. I also added a test file in flang/test/Semantics to test calls to 'num_images()'. There was a call to 'num_images()' in flang/test/Semantics/call10.f90 that expected an error, now it no longer produces an error. So I edited that file accordingly. I also edited the intrinsics unit test to add further testing of 'num_images()'. Differential Revision: https://reviews.llvm.org/D83142
2020-07-08 03:31:06 +08:00
{"num_images", {}, DefaultInt, Rank::scalar,
IntrinsicClass::transformationalFunction},
{"num_images", {{"team_number", AnyInt, Rank::scalar}}, DefaultInt,
Rank::scalar, IntrinsicClass::transformationalFunction},
[flang] intrinsic pattern matching Original-commit: flang-compiler/f18@ca0ee1660a6449c34c7276284e5e63b90ae97540 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-05 04:43:33 +08:00
{"out_of_range",
[flang] finish most intrinsic table entries Original-commit: flang-compiler/f18@134bd885af5c67ae7fc2291778397546a3d1c189 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-12 05:51:14 +08:00
{{"x", AnyIntOrReal}, {"mold", AnyIntOrReal, Rank::scalar}},
[flang] Add -i8, -r8, &c. options to f18 development driver Original-commit: flang-compiler/f18@ff7f338126562ce539879a59d3da5707c76ae11a Reviewed-on: https://github.com/flang-compiler/f18/pull/213
2018-10-17 05:42:22 +08:00
DefaultLogical},
[flang] initial intrinsics table Original-commit: flang-compiler/f18@8b5c3adf887cf88752937a4fa5507c0d66051d3b Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-09-29 08:02:11 +08:00
{"out_of_range",
[flang] intrinsic pattern matching Original-commit: flang-compiler/f18@ca0ee1660a6449c34c7276284e5e63b90ae97540 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-05 04:43:33 +08:00
{{"x", AnyReal}, {"mold", AnyInt, Rank::scalar},
[flang] error messages Original-commit: flang-compiler/f18@392a7330736a8fd444ef92ed5c8ef7dcbc94d461 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-06 02:32:54 +08:00
{"round", AnyLogical, Rank::scalar, Optionality::optional}},
[flang] Add -i8, -r8, &c. options to f18 development driver Original-commit: flang-compiler/f18@ff7f338126562ce539879a59d3da5707c76ae11a Reviewed-on: https://github.com/flang-compiler/f18/pull/213
2018-10-17 05:42:22 +08:00
DefaultLogical},
{"out_of_range", {{"x", AnyReal}, {"mold", AnyReal}}, DefaultLogical},
[flang] initial intrinsics table Original-commit: flang-compiler/f18@8b5c3adf887cf88752937a4fa5507c0d66051d3b Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-09-29 08:02:11 +08:00
{"pack",
[flang] intrinsic pattern matching Original-commit: flang-compiler/f18@ca0ee1660a6449c34c7276284e5e63b90ae97540 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-05 04:43:33 +08:00
{{"array", SameType, Rank::array},
{"mask", AnyLogical, Rank::conformable},
[flang] error messages Original-commit: flang-compiler/f18@392a7330736a8fd444ef92ed5c8ef7dcbc94d461 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-06 02:32:54 +08:00
{"vector", SameType, Rank::vector, Optionality::optional}},
[flang] New implementation for checks for constraints C741 through C750 Summary: Most of these checks were already implemented, and I just added references to them to the code and tests. Also, much of this code was already reviewed in the old flang/f18 GitHub repository, but I didn't get to merge it before we switched repositories. I implemented the check for C747 to not allow coarray components in derived types that are of type C_PTR, C_FUNPTR, or type TEAM_TYPE. I implemented the check for C748 that requires a data component whose type has a coarray ultimate component to be a nonpointer, nonallocatable scalar and not be a coarray. I implemented the check for C750 that adds additional restrictions to the bounds expressions of a derived type component that's an array. These bounds expressions are sepcification expressions as defined in 10.1.11. There was already code in lib/Evaluate/check-expression.cpp to check semantics for specification expressions, but it did not check for the extra requirements of C750. C750 prohibits specification functions, the intrinsic functions ALLOCATED, ASSOCIATED, EXTENDS_TYPE_OF, PRESENT, and SAME_TYPE_AS. It also requires every specification inquiry reference to be a constant expression, and requires that the value of the bound not depend on the value of a variable. To implement these additional checks, I added code to the intrinsic proc table to get the intrinsic class of a procedure. I also added an enumeration to distinguish between specification expressions for derived type component bounds versus for type parameters. I then changed the code to pass an enumeration value to "CheckSpecificationExpr()" to indicate that the expression was a bounds expression and used this value to determine whether to emit an error message when violations of C750 are found. I changed the implementation of IsPureProcedure() to handle statement functions and changed some references in the code that tested for the PURE attribute to call IsPureProcedure(). I also fixed some unrelated tests that got new errors when I implemented these new checks. Reviewers: tskeith, DavidTruby, sscalpone Subscribers: jfb, llvm-commits Tags: #llvm, #flang Differential Revision: https://reviews.llvm.org/D79263
2020-05-02 04:00:28 +08:00
SameType, Rank::vector, IntrinsicClass::transformationalFunction},
[flang] intrinsic pattern matching Original-commit: flang-compiler/f18@ca0ee1660a6449c34c7276284e5e63b90ae97540 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-05 04:43:33 +08:00
{"parity", {{"mask", SameLogical, Rank::array}, OptionalDIM}, SameLogical,
[flang] New implementation for checks for constraints C741 through C750 Summary: Most of these checks were already implemented, and I just added references to them to the code and tests. Also, much of this code was already reviewed in the old flang/f18 GitHub repository, but I didn't get to merge it before we switched repositories. I implemented the check for C747 to not allow coarray components in derived types that are of type C_PTR, C_FUNPTR, or type TEAM_TYPE. I implemented the check for C748 that requires a data component whose type has a coarray ultimate component to be a nonpointer, nonallocatable scalar and not be a coarray. I implemented the check for C750 that adds additional restrictions to the bounds expressions of a derived type component that's an array. These bounds expressions are sepcification expressions as defined in 10.1.11. There was already code in lib/Evaluate/check-expression.cpp to check semantics for specification expressions, but it did not check for the extra requirements of C750. C750 prohibits specification functions, the intrinsic functions ALLOCATED, ASSOCIATED, EXTENDS_TYPE_OF, PRESENT, and SAME_TYPE_AS. It also requires every specification inquiry reference to be a constant expression, and requires that the value of the bound not depend on the value of a variable. To implement these additional checks, I added code to the intrinsic proc table to get the intrinsic class of a procedure. I also added an enumeration to distinguish between specification expressions for derived type component bounds versus for type parameters. I then changed the code to pass an enumeration value to "CheckSpecificationExpr()" to indicate that the expression was a bounds expression and used this value to determine whether to emit an error message when violations of C750 are found. I changed the implementation of IsPureProcedure() to handle statement functions and changed some references in the code that tested for the PURE attribute to call IsPureProcedure(). I also fixed some unrelated tests that got new errors when I implemented these new checks. Reviewers: tskeith, DavidTruby, sscalpone Subscribers: jfb, llvm-commits Tags: #llvm, #flang Differential Revision: https://reviews.llvm.org/D79263
2020-05-02 04:00:28 +08:00
Rank::dimReduced, IntrinsicClass::transformationalFunction},
[flang] Add -i8, -r8, &c. options to f18 development driver Original-commit: flang-compiler/f18@ff7f338126562ce539879a59d3da5707c76ae11a Reviewed-on: https://github.com/flang-compiler/f18/pull/213
2018-10-17 05:42:22 +08:00
{"popcnt", {{"i", AnyInt}}, DefaultInt},
{"poppar", {{"i", AnyInt}}, DefaultInt},
[flang] initial intrinsics table Original-commit: flang-compiler/f18@8b5c3adf887cf88752937a4fa5507c0d66051d3b Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-09-29 08:02:11 +08:00
{"product",
[flang] Correct shape analysis for transformational intrinsic functions Correct the analysis of references to transformational intrinsic functions that have different semantics based on the presence or absence of a DIM= argument; add shape analysis for UNPACK(). Differential Revision: https://reviews.llvm.org/D94716
2021-01-15 04:54:31 +08:00
{{"array", SameNumeric, Rank::array}, RequiredDIM, OptionalMASK},
[flang] New implementation for checks for constraints C741 through C750 Summary: Most of these checks were already implemented, and I just added references to them to the code and tests. Also, much of this code was already reviewed in the old flang/f18 GitHub repository, but I didn't get to merge it before we switched repositories. I implemented the check for C747 to not allow coarray components in derived types that are of type C_PTR, C_FUNPTR, or type TEAM_TYPE. I implemented the check for C748 that requires a data component whose type has a coarray ultimate component to be a nonpointer, nonallocatable scalar and not be a coarray. I implemented the check for C750 that adds additional restrictions to the bounds expressions of a derived type component that's an array. These bounds expressions are sepcification expressions as defined in 10.1.11. There was already code in lib/Evaluate/check-expression.cpp to check semantics for specification expressions, but it did not check for the extra requirements of C750. C750 prohibits specification functions, the intrinsic functions ALLOCATED, ASSOCIATED, EXTENDS_TYPE_OF, PRESENT, and SAME_TYPE_AS. It also requires every specification inquiry reference to be a constant expression, and requires that the value of the bound not depend on the value of a variable. To implement these additional checks, I added code to the intrinsic proc table to get the intrinsic class of a procedure. I also added an enumeration to distinguish between specification expressions for derived type component bounds versus for type parameters. I then changed the code to pass an enumeration value to "CheckSpecificationExpr()" to indicate that the expression was a bounds expression and used this value to determine whether to emit an error message when violations of C750 are found. I changed the implementation of IsPureProcedure() to handle statement functions and changed some references in the code that tested for the PURE attribute to call IsPureProcedure(). I also fixed some unrelated tests that got new errors when I implemented these new checks. Reviewers: tskeith, DavidTruby, sscalpone Subscribers: jfb, llvm-commits Tags: #llvm, #flang Differential Revision: https://reviews.llvm.org/D79263
2020-05-02 04:00:28 +08:00
SameNumeric, Rank::dimReduced,
IntrinsicClass::transformationalFunction},
[flang] Correct shape analysis for transformational intrinsic functions Correct the analysis of references to transformational intrinsic functions that have different semantics based on the presence or absence of a DIM= argument; add shape analysis for UNPACK(). Differential Revision: https://reviews.llvm.org/D94716
2021-01-15 04:54:31 +08:00
{"product", {{"array", SameNumeric, Rank::array}, MissingDIM, OptionalMASK},
SameNumeric, Rank::scalar, IntrinsicClass::transformationalFunction},
[flang] Add DIGITS to intrinsic function table; fix results of some others Original-commit: flang-compiler/f18@6d5caef352e1ffe28315c27c4d46adfe36b55173 Reviewed-on: https://github.com/flang-compiler/f18/pull/623 Tree-same-pre-rewrite: false
2019-08-06 00:42:06 +08:00
{"precision", {{"x", AnyFloating, Rank::anyOrAssumedRank}}, DefaultInt,
[flang] New implementation for checks for constraints C741 through C750 Summary: Most of these checks were already implemented, and I just added references to them to the code and tests. Also, much of this code was already reviewed in the old flang/f18 GitHub repository, but I didn't get to merge it before we switched repositories. I implemented the check for C747 to not allow coarray components in derived types that are of type C_PTR, C_FUNPTR, or type TEAM_TYPE. I implemented the check for C748 that requires a data component whose type has a coarray ultimate component to be a nonpointer, nonallocatable scalar and not be a coarray. I implemented the check for C750 that adds additional restrictions to the bounds expressions of a derived type component that's an array. These bounds expressions are sepcification expressions as defined in 10.1.11. There was already code in lib/Evaluate/check-expression.cpp to check semantics for specification expressions, but it did not check for the extra requirements of C750. C750 prohibits specification functions, the intrinsic functions ALLOCATED, ASSOCIATED, EXTENDS_TYPE_OF, PRESENT, and SAME_TYPE_AS. It also requires every specification inquiry reference to be a constant expression, and requires that the value of the bound not depend on the value of a variable. To implement these additional checks, I added code to the intrinsic proc table to get the intrinsic class of a procedure. I also added an enumeration to distinguish between specification expressions for derived type component bounds versus for type parameters. I then changed the code to pass an enumeration value to "CheckSpecificationExpr()" to indicate that the expression was a bounds expression and used this value to determine whether to emit an error message when violations of C750 are found. I changed the implementation of IsPureProcedure() to handle statement functions and changed some references in the code that tested for the PURE attribute to call IsPureProcedure(). I also fixed some unrelated tests that got new errors when I implemented these new checks. Reviewers: tskeith, DavidTruby, sscalpone Subscribers: jfb, llvm-commits Tags: #llvm, #flang Differential Revision: https://reviews.llvm.org/D79263
2020-05-02 04:00:28 +08:00
Rank::scalar, IntrinsicClass::inquiryFunction},
[flang] Fix bug flang-compiler/f18#643 Original-commit: flang-compiler/f18@29bb4312e1f2861fa04f847c8e552ca894989593 Reviewed-on: https://github.com/flang-compiler/f18/pull/646
2019-08-13 01:56:18 +08:00
{"present", {{"a", Addressable, Rank::anyOrAssumedRank}}, DefaultLogical,
[flang] New implementation for checks for constraints C741 through C750 Summary: Most of these checks were already implemented, and I just added references to them to the code and tests. Also, much of this code was already reviewed in the old flang/f18 GitHub repository, but I didn't get to merge it before we switched repositories. I implemented the check for C747 to not allow coarray components in derived types that are of type C_PTR, C_FUNPTR, or type TEAM_TYPE. I implemented the check for C748 that requires a data component whose type has a coarray ultimate component to be a nonpointer, nonallocatable scalar and not be a coarray. I implemented the check for C750 that adds additional restrictions to the bounds expressions of a derived type component that's an array. These bounds expressions are sepcification expressions as defined in 10.1.11. There was already code in lib/Evaluate/check-expression.cpp to check semantics for specification expressions, but it did not check for the extra requirements of C750. C750 prohibits specification functions, the intrinsic functions ALLOCATED, ASSOCIATED, EXTENDS_TYPE_OF, PRESENT, and SAME_TYPE_AS. It also requires every specification inquiry reference to be a constant expression, and requires that the value of the bound not depend on the value of a variable. To implement these additional checks, I added code to the intrinsic proc table to get the intrinsic class of a procedure. I also added an enumeration to distinguish between specification expressions for derived type component bounds versus for type parameters. I then changed the code to pass an enumeration value to "CheckSpecificationExpr()" to indicate that the expression was a bounds expression and used this value to determine whether to emit an error message when violations of C750 are found. I changed the implementation of IsPureProcedure() to handle statement functions and changed some references in the code that tested for the PURE attribute to call IsPureProcedure(). I also fixed some unrelated tests that got new errors when I implemented these new checks. Reviewers: tskeith, DavidTruby, sscalpone Subscribers: jfb, llvm-commits Tags: #llvm, #flang Differential Revision: https://reviews.llvm.org/D79263
2020-05-02 04:00:28 +08:00
Rank::scalar, IntrinsicClass::inquiryFunction},
[flang] Add DIGITS to intrinsic function table; fix results of some others Original-commit: flang-compiler/f18@6d5caef352e1ffe28315c27c4d46adfe36b55173 Reviewed-on: https://github.com/flang-compiler/f18/pull/623 Tree-same-pre-rewrite: false
2019-08-06 00:42:06 +08:00
{"radix", {{"x", AnyIntOrReal, Rank::anyOrAssumedRank}}, DefaultInt,
[flang] New implementation for checks for constraints C741 through C750 Summary: Most of these checks were already implemented, and I just added references to them to the code and tests. Also, much of this code was already reviewed in the old flang/f18 GitHub repository, but I didn't get to merge it before we switched repositories. I implemented the check for C747 to not allow coarray components in derived types that are of type C_PTR, C_FUNPTR, or type TEAM_TYPE. I implemented the check for C748 that requires a data component whose type has a coarray ultimate component to be a nonpointer, nonallocatable scalar and not be a coarray. I implemented the check for C750 that adds additional restrictions to the bounds expressions of a derived type component that's an array. These bounds expressions are sepcification expressions as defined in 10.1.11. There was already code in lib/Evaluate/check-expression.cpp to check semantics for specification expressions, but it did not check for the extra requirements of C750. C750 prohibits specification functions, the intrinsic functions ALLOCATED, ASSOCIATED, EXTENDS_TYPE_OF, PRESENT, and SAME_TYPE_AS. It also requires every specification inquiry reference to be a constant expression, and requires that the value of the bound not depend on the value of a variable. To implement these additional checks, I added code to the intrinsic proc table to get the intrinsic class of a procedure. I also added an enumeration to distinguish between specification expressions for derived type component bounds versus for type parameters. I then changed the code to pass an enumeration value to "CheckSpecificationExpr()" to indicate that the expression was a bounds expression and used this value to determine whether to emit an error message when violations of C750 are found. I changed the implementation of IsPureProcedure() to handle statement functions and changed some references in the code that tested for the PURE attribute to call IsPureProcedure(). I also fixed some unrelated tests that got new errors when I implemented these new checks. Reviewers: tskeith, DavidTruby, sscalpone Subscribers: jfb, llvm-commits Tags: #llvm, #flang Differential Revision: https://reviews.llvm.org/D79263
2020-05-02 04:00:28 +08:00
Rank::scalar, IntrinsicClass::inquiryFunction},
[flang] Fold more model inquiry intrinsics Original-commit: flang-compiler/f18@a3d82893b768865aa51f105f92805f61a87d95f1 Reviewed-on: https://github.com/flang-compiler/f18/pull/602 Tree-same-pre-rewrite: false
2019-07-25 04:55:29 +08:00
{"range", {{"x", AnyNumeric, Rank::anyOrAssumedRank}}, DefaultInt,
[flang] New implementation for checks for constraints C741 through C750 Summary: Most of these checks were already implemented, and I just added references to them to the code and tests. Also, much of this code was already reviewed in the old flang/f18 GitHub repository, but I didn't get to merge it before we switched repositories. I implemented the check for C747 to not allow coarray components in derived types that are of type C_PTR, C_FUNPTR, or type TEAM_TYPE. I implemented the check for C748 that requires a data component whose type has a coarray ultimate component to be a nonpointer, nonallocatable scalar and not be a coarray. I implemented the check for C750 that adds additional restrictions to the bounds expressions of a derived type component that's an array. These bounds expressions are sepcification expressions as defined in 10.1.11. There was already code in lib/Evaluate/check-expression.cpp to check semantics for specification expressions, but it did not check for the extra requirements of C750. C750 prohibits specification functions, the intrinsic functions ALLOCATED, ASSOCIATED, EXTENDS_TYPE_OF, PRESENT, and SAME_TYPE_AS. It also requires every specification inquiry reference to be a constant expression, and requires that the value of the bound not depend on the value of a variable. To implement these additional checks, I added code to the intrinsic proc table to get the intrinsic class of a procedure. I also added an enumeration to distinguish between specification expressions for derived type component bounds versus for type parameters. I then changed the code to pass an enumeration value to "CheckSpecificationExpr()" to indicate that the expression was a bounds expression and used this value to determine whether to emit an error message when violations of C750 are found. I changed the implementation of IsPureProcedure() to handle statement functions and changed some references in the code that tested for the PURE attribute to call IsPureProcedure(). I also fixed some unrelated tests that got new errors when I implemented these new checks. Reviewers: tskeith, DavidTruby, sscalpone Subscribers: jfb, llvm-commits Tags: #llvm, #flang Differential Revision: https://reviews.llvm.org/D79263
2020-05-02 04:00:28 +08:00
Rank::scalar, IntrinsicClass::inquiryFunction},
{"rank", {{"a", AnyData, Rank::anyOrAssumedRank}}, DefaultInt, Rank::scalar,
IntrinsicClass::inquiryFunction},
[flang] Fix clang-format issues identified during relicensing While running clang-format during the relicensing, there were a few files that showed minor format issues that could be cleaned up. These changes address them. Original-commit: flang-compiler/f18@b308f9e35a6d386b53ded90e84bbfac600f38867 Reviewed-on: https://github.com/flang-compiler/f18/pull/890
2019-12-24 03:16:00 +08:00
{"real", {{"a", SameComplex, Rank::elemental}},
[flang] Reformat with latest clang-format and .clang-format Original-commit: flang-compiler/f18@9fe84f45d7fd685051004678d6b5775dcc4c6f8f Reviewed-on: https://github.com/flang-compiler/f18/pull/1094
2020-03-29 12:00:16 +08:00
SameReal}, // 16.9.160(4)(ii)
[flang] error messages Original-commit: flang-compiler/f18@392a7330736a8fd444ef92ed5c8ef7dcbc94d461 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-06 02:32:54 +08:00
{"real", {{"a", AnyNumeric, Rank::elementalOrBOZ}, DefaultingKIND},
[flang] intrinsic pattern matching Original-commit: flang-compiler/f18@ca0ee1660a6449c34c7276284e5e63b90ae97540 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-05 04:43:33 +08:00
KINDReal},
[flang] finish most intrinsic table entries Original-commit: flang-compiler/f18@134bd885af5c67ae7fc2291778397546a3d1c189 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-12 05:51:14 +08:00
{"reduce",
{{"array", SameType, Rank::array},
[flang] Correct shape analysis for transformational intrinsic functions Correct the analysis of references to transformational intrinsic functions that have different semantics based on the presence or absence of a DIM= argument; add shape analysis for UNPACK(). Differential Revision: https://reviews.llvm.org/D94716
2021-01-15 04:54:31 +08:00
{"operation", SameType, Rank::reduceOperation}, RequiredDIM,
[flang] finish most intrinsic table entries Original-commit: flang-compiler/f18@134bd885af5c67ae7fc2291778397546a3d1c189 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-12 05:51:14 +08:00
OptionalMASK, {"identity", SameType, Rank::scalar},
{"ordered", AnyLogical, Rank::scalar, Optionality::optional}},
[flang] New implementation for checks for constraints C741 through C750 Summary: Most of these checks were already implemented, and I just added references to them to the code and tests. Also, much of this code was already reviewed in the old flang/f18 GitHub repository, but I didn't get to merge it before we switched repositories. I implemented the check for C747 to not allow coarray components in derived types that are of type C_PTR, C_FUNPTR, or type TEAM_TYPE. I implemented the check for C748 that requires a data component whose type has a coarray ultimate component to be a nonpointer, nonallocatable scalar and not be a coarray. I implemented the check for C750 that adds additional restrictions to the bounds expressions of a derived type component that's an array. These bounds expressions are sepcification expressions as defined in 10.1.11. There was already code in lib/Evaluate/check-expression.cpp to check semantics for specification expressions, but it did not check for the extra requirements of C750. C750 prohibits specification functions, the intrinsic functions ALLOCATED, ASSOCIATED, EXTENDS_TYPE_OF, PRESENT, and SAME_TYPE_AS. It also requires every specification inquiry reference to be a constant expression, and requires that the value of the bound not depend on the value of a variable. To implement these additional checks, I added code to the intrinsic proc table to get the intrinsic class of a procedure. I also added an enumeration to distinguish between specification expressions for derived type component bounds versus for type parameters. I then changed the code to pass an enumeration value to "CheckSpecificationExpr()" to indicate that the expression was a bounds expression and used this value to determine whether to emit an error message when violations of C750 are found. I changed the implementation of IsPureProcedure() to handle statement functions and changed some references in the code that tested for the PURE attribute to call IsPureProcedure(). I also fixed some unrelated tests that got new errors when I implemented these new checks. Reviewers: tskeith, DavidTruby, sscalpone Subscribers: jfb, llvm-commits Tags: #llvm, #flang Differential Revision: https://reviews.llvm.org/D79263
2020-05-02 04:00:28 +08:00
SameType, Rank::dimReduced, IntrinsicClass::transformationalFunction},
[flang] Correct shape analysis for transformational intrinsic functions Correct the analysis of references to transformational intrinsic functions that have different semantics based on the presence or absence of a DIM= argument; add shape analysis for UNPACK(). Differential Revision: https://reviews.llvm.org/D94716
2021-01-15 04:54:31 +08:00
{"reduce",
{{"array", SameType, Rank::array},
{"operation", SameType, Rank::reduceOperation}, MissingDIM,
OptionalMASK, {"identity", SameType, Rank::scalar},
{"ordered", AnyLogical, Rank::scalar, Optionality::optional}},
SameType, Rank::scalar, IntrinsicClass::transformationalFunction},
[flang] a few more intrinsics and some style guide comments Original-commit: flang-compiler/f18@b6696ef9236a79ebe13a8695b87061cff19cb3c8 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-11 07:45:17 +08:00
{"repeat", {{"string", SameChar, Rank::scalar}, {"ncopies", AnyInt}},
[flang] New implementation for checks for constraints C741 through C750 Summary: Most of these checks were already implemented, and I just added references to them to the code and tests. Also, much of this code was already reviewed in the old flang/f18 GitHub repository, but I didn't get to merge it before we switched repositories. I implemented the check for C747 to not allow coarray components in derived types that are of type C_PTR, C_FUNPTR, or type TEAM_TYPE. I implemented the check for C748 that requires a data component whose type has a coarray ultimate component to be a nonpointer, nonallocatable scalar and not be a coarray. I implemented the check for C750 that adds additional restrictions to the bounds expressions of a derived type component that's an array. These bounds expressions are sepcification expressions as defined in 10.1.11. There was already code in lib/Evaluate/check-expression.cpp to check semantics for specification expressions, but it did not check for the extra requirements of C750. C750 prohibits specification functions, the intrinsic functions ALLOCATED, ASSOCIATED, EXTENDS_TYPE_OF, PRESENT, and SAME_TYPE_AS. It also requires every specification inquiry reference to be a constant expression, and requires that the value of the bound not depend on the value of a variable. To implement these additional checks, I added code to the intrinsic proc table to get the intrinsic class of a procedure. I also added an enumeration to distinguish between specification expressions for derived type component bounds versus for type parameters. I then changed the code to pass an enumeration value to "CheckSpecificationExpr()" to indicate that the expression was a bounds expression and used this value to determine whether to emit an error message when violations of C750 are found. I changed the implementation of IsPureProcedure() to handle statement functions and changed some references in the code that tested for the PURE attribute to call IsPureProcedure(). I also fixed some unrelated tests that got new errors when I implemented these new checks. Reviewers: tskeith, DavidTruby, sscalpone Subscribers: jfb, llvm-commits Tags: #llvm, #flang Differential Revision: https://reviews.llvm.org/D79263
2020-05-02 04:00:28 +08:00
SameChar, Rank::scalar, IntrinsicClass::transformationalFunction},
[flang] initial intrinsics table Original-commit: flang-compiler/f18@8b5c3adf887cf88752937a4fa5507c0d66051d3b Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-09-29 08:02:11 +08:00
{"reshape",
[flang] intrinsic pattern matching Original-commit: flang-compiler/f18@ca0ee1660a6449c34c7276284e5e63b90ae97540 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-05 04:43:33 +08:00
{{"source", SameType, Rank::array}, {"shape", AnyInt, Rank::shape},
[flang] error messages Original-commit: flang-compiler/f18@392a7330736a8fd444ef92ed5c8ef7dcbc94d461 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-06 02:32:54 +08:00
{"pad", SameType, Rank::array, Optionality::optional},
{"order", AnyInt, Rank::vector, Optionality::optional}},
[flang] New implementation for checks for constraints C741 through C750 Summary: Most of these checks were already implemented, and I just added references to them to the code and tests. Also, much of this code was already reviewed in the old flang/f18 GitHub repository, but I didn't get to merge it before we switched repositories. I implemented the check for C747 to not allow coarray components in derived types that are of type C_PTR, C_FUNPTR, or type TEAM_TYPE. I implemented the check for C748 that requires a data component whose type has a coarray ultimate component to be a nonpointer, nonallocatable scalar and not be a coarray. I implemented the check for C750 that adds additional restrictions to the bounds expressions of a derived type component that's an array. These bounds expressions are sepcification expressions as defined in 10.1.11. There was already code in lib/Evaluate/check-expression.cpp to check semantics for specification expressions, but it did not check for the extra requirements of C750. C750 prohibits specification functions, the intrinsic functions ALLOCATED, ASSOCIATED, EXTENDS_TYPE_OF, PRESENT, and SAME_TYPE_AS. It also requires every specification inquiry reference to be a constant expression, and requires that the value of the bound not depend on the value of a variable. To implement these additional checks, I added code to the intrinsic proc table to get the intrinsic class of a procedure. I also added an enumeration to distinguish between specification expressions for derived type component bounds versus for type parameters. I then changed the code to pass an enumeration value to "CheckSpecificationExpr()" to indicate that the expression was a bounds expression and used this value to determine whether to emit an error message when violations of C750 are found. I changed the implementation of IsPureProcedure() to handle statement functions and changed some references in the code that tested for the PURE attribute to call IsPureProcedure(). I also fixed some unrelated tests that got new errors when I implemented these new checks. Reviewers: tskeith, DavidTruby, sscalpone Subscribers: jfb, llvm-commits Tags: #llvm, #flang Differential Revision: https://reviews.llvm.org/D79263
2020-05-02 04:00:28 +08:00
SameType, Rank::shaped, IntrinsicClass::transformationalFunction},
[flang] intrinsic pattern matching Original-commit: flang-compiler/f18@ca0ee1660a6449c34c7276284e5e63b90ae97540 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-05 04:43:33 +08:00
{"rrspacing", {{"x", SameReal}}, SameReal},
[flang] Update preprocessing document, commentary Extend documentation on preprocessing IsSimplyContiguous basic skeleton Apply suggested improvements to mod-file.cc Checks for new call13.f90 (15.4.2.2 explicit interfaces) Implement checking for procedures that can be called via an implicit interface Argument checking, test fixing Better argument checking Better derived type compatibility checking Treat externals as if implicitly interfaced Extend IEEE_EXCEPTIONS module so tests still pass with argument checking SAME_TYPE_AS and EXTENDS_TYPE_OF intrinsic inquiry functions Define interfaces for most intrinsic subroutines Better PASS arguments More with PASS() argument Prep for review address comments fix comment Remove formatted expression from specification expression error message per review more review comments Original-commit: flang-compiler/f18@3cca775da9302e3a2acec4a34800cd7666899b5f Reviewed-on: https://github.com/flang-compiler/f18/pull/776
2019-09-17 07:58:13 +08:00
{"same_type_as",
{{"a", ExtensibleDerived, Rank::anyOrAssumedRank},
{"b", ExtensibleDerived, Rank::anyOrAssumedRank}},
[flang] New implementation for checks for constraints C741 through C750 Summary: Most of these checks were already implemented, and I just added references to them to the code and tests. Also, much of this code was already reviewed in the old flang/f18 GitHub repository, but I didn't get to merge it before we switched repositories. I implemented the check for C747 to not allow coarray components in derived types that are of type C_PTR, C_FUNPTR, or type TEAM_TYPE. I implemented the check for C748 that requires a data component whose type has a coarray ultimate component to be a nonpointer, nonallocatable scalar and not be a coarray. I implemented the check for C750 that adds additional restrictions to the bounds expressions of a derived type component that's an array. These bounds expressions are sepcification expressions as defined in 10.1.11. There was already code in lib/Evaluate/check-expression.cpp to check semantics for specification expressions, but it did not check for the extra requirements of C750. C750 prohibits specification functions, the intrinsic functions ALLOCATED, ASSOCIATED, EXTENDS_TYPE_OF, PRESENT, and SAME_TYPE_AS. It also requires every specification inquiry reference to be a constant expression, and requires that the value of the bound not depend on the value of a variable. To implement these additional checks, I added code to the intrinsic proc table to get the intrinsic class of a procedure. I also added an enumeration to distinguish between specification expressions for derived type component bounds versus for type parameters. I then changed the code to pass an enumeration value to "CheckSpecificationExpr()" to indicate that the expression was a bounds expression and used this value to determine whether to emit an error message when violations of C750 are found. I changed the implementation of IsPureProcedure() to handle statement functions and changed some references in the code that tested for the PURE attribute to call IsPureProcedure(). I also fixed some unrelated tests that got new errors when I implemented these new checks. Reviewers: tskeith, DavidTruby, sscalpone Subscribers: jfb, llvm-commits Tags: #llvm, #flang Differential Revision: https://reviews.llvm.org/D79263
2020-05-02 04:00:28 +08:00
DefaultLogical, Rank::scalar, IntrinsicClass::inquiryFunction},
[flang] intrinsic pattern matching Original-commit: flang-compiler/f18@ca0ee1660a6449c34c7276284e5e63b90ae97540 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-05 04:43:33 +08:00
{"scale", {{"x", SameReal}, {"i", AnyInt}}, SameReal},
[flang] initial intrinsics table Original-commit: flang-compiler/f18@8b5c3adf887cf88752937a4fa5507c0d66051d3b Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-09-29 08:02:11 +08:00
{"scan",
[flang] intrinsic pattern matching Original-commit: flang-compiler/f18@ca0ee1660a6449c34c7276284e5e63b90ae97540 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-05 04:43:33 +08:00
{{"string", SameChar}, {"set", SameChar},
[flang] error messages Original-commit: flang-compiler/f18@392a7330736a8fd444ef92ed5c8ef7dcbc94d461 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-06 02:32:54 +08:00
{"back", AnyLogical, Rank::elemental, Optionality::optional},
[flang] Revert to returning default INTEGER for LEN() and offset-in-CHARACTER intrinsics; further shape analysis of intrinsic results Original-commit: flang-compiler/f18@561f5965b2309df3cd15d7e2a96d7e73f2f76e35 Reviewed-on: https://github.com/flang-compiler/f18/pull/782 Tree-same-pre-rewrite: false
2019-10-17 02:53:03 +08:00
DefaultingKIND},
[flang] intrinsic pattern matching Original-commit: flang-compiler/f18@ca0ee1660a6449c34c7276284e5e63b90ae97540 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-05 04:43:33 +08:00
KINDInt},
[flang] Add -i8, -r8, &c. options to f18 development driver Original-commit: flang-compiler/f18@ff7f338126562ce539879a59d3da5707c76ae11a Reviewed-on: https://github.com/flang-compiler/f18/pull/213
2018-10-17 05:42:22 +08:00
{"selected_char_kind", {{"name", DefaultChar, Rank::scalar}}, DefaultInt,
[flang] New implementation for checks for constraints C741 through C750 Summary: Most of these checks were already implemented, and I just added references to them to the code and tests. Also, much of this code was already reviewed in the old flang/f18 GitHub repository, but I didn't get to merge it before we switched repositories. I implemented the check for C747 to not allow coarray components in derived types that are of type C_PTR, C_FUNPTR, or type TEAM_TYPE. I implemented the check for C748 that requires a data component whose type has a coarray ultimate component to be a nonpointer, nonallocatable scalar and not be a coarray. I implemented the check for C750 that adds additional restrictions to the bounds expressions of a derived type component that's an array. These bounds expressions are sepcification expressions as defined in 10.1.11. There was already code in lib/Evaluate/check-expression.cpp to check semantics for specification expressions, but it did not check for the extra requirements of C750. C750 prohibits specification functions, the intrinsic functions ALLOCATED, ASSOCIATED, EXTENDS_TYPE_OF, PRESENT, and SAME_TYPE_AS. It also requires every specification inquiry reference to be a constant expression, and requires that the value of the bound not depend on the value of a variable. To implement these additional checks, I added code to the intrinsic proc table to get the intrinsic class of a procedure. I also added an enumeration to distinguish between specification expressions for derived type component bounds versus for type parameters. I then changed the code to pass an enumeration value to "CheckSpecificationExpr()" to indicate that the expression was a bounds expression and used this value to determine whether to emit an error message when violations of C750 are found. I changed the implementation of IsPureProcedure() to handle statement functions and changed some references in the code that tested for the PURE attribute to call IsPureProcedure(). I also fixed some unrelated tests that got new errors when I implemented these new checks. Reviewers: tskeith, DavidTruby, sscalpone Subscribers: jfb, llvm-commits Tags: #llvm, #flang Differential Revision: https://reviews.llvm.org/D79263
2020-05-02 04:00:28 +08:00
Rank::scalar, IntrinsicClass::transformationalFunction},
[flang] Add -i8, -r8, &c. options to f18 development driver Original-commit: flang-compiler/f18@ff7f338126562ce539879a59d3da5707c76ae11a Reviewed-on: https://github.com/flang-compiler/f18/pull/213
2018-10-17 05:42:22 +08:00
{"selected_int_kind", {{"r", AnyInt, Rank::scalar}}, DefaultInt,
[flang] New implementation for checks for constraints C741 through C750 Summary: Most of these checks were already implemented, and I just added references to them to the code and tests. Also, much of this code was already reviewed in the old flang/f18 GitHub repository, but I didn't get to merge it before we switched repositories. I implemented the check for C747 to not allow coarray components in derived types that are of type C_PTR, C_FUNPTR, or type TEAM_TYPE. I implemented the check for C748 that requires a data component whose type has a coarray ultimate component to be a nonpointer, nonallocatable scalar and not be a coarray. I implemented the check for C750 that adds additional restrictions to the bounds expressions of a derived type component that's an array. These bounds expressions are sepcification expressions as defined in 10.1.11. There was already code in lib/Evaluate/check-expression.cpp to check semantics for specification expressions, but it did not check for the extra requirements of C750. C750 prohibits specification functions, the intrinsic functions ALLOCATED, ASSOCIATED, EXTENDS_TYPE_OF, PRESENT, and SAME_TYPE_AS. It also requires every specification inquiry reference to be a constant expression, and requires that the value of the bound not depend on the value of a variable. To implement these additional checks, I added code to the intrinsic proc table to get the intrinsic class of a procedure. I also added an enumeration to distinguish between specification expressions for derived type component bounds versus for type parameters. I then changed the code to pass an enumeration value to "CheckSpecificationExpr()" to indicate that the expression was a bounds expression and used this value to determine whether to emit an error message when violations of C750 are found. I changed the implementation of IsPureProcedure() to handle statement functions and changed some references in the code that tested for the PURE attribute to call IsPureProcedure(). I also fixed some unrelated tests that got new errors when I implemented these new checks. Reviewers: tskeith, DavidTruby, sscalpone Subscribers: jfb, llvm-commits Tags: #llvm, #flang Differential Revision: https://reviews.llvm.org/D79263
2020-05-02 04:00:28 +08:00
Rank::scalar, IntrinsicClass::transformationalFunction},
[flang] finish most intrinsic table entries Original-commit: flang-compiler/f18@134bd885af5c67ae7fc2291778397546a3d1c189 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-12 05:51:14 +08:00
{"selected_real_kind",
{{"p", AnyInt, Rank::scalar},
{"r", AnyInt, Rank::scalar, Optionality::optional},
{"radix", AnyInt, Rank::scalar, Optionality::optional}},
[flang] New implementation for checks for constraints C741 through C750 Summary: Most of these checks were already implemented, and I just added references to them to the code and tests. Also, much of this code was already reviewed in the old flang/f18 GitHub repository, but I didn't get to merge it before we switched repositories. I implemented the check for C747 to not allow coarray components in derived types that are of type C_PTR, C_FUNPTR, or type TEAM_TYPE. I implemented the check for C748 that requires a data component whose type has a coarray ultimate component to be a nonpointer, nonallocatable scalar and not be a coarray. I implemented the check for C750 that adds additional restrictions to the bounds expressions of a derived type component that's an array. These bounds expressions are sepcification expressions as defined in 10.1.11. There was already code in lib/Evaluate/check-expression.cpp to check semantics for specification expressions, but it did not check for the extra requirements of C750. C750 prohibits specification functions, the intrinsic functions ALLOCATED, ASSOCIATED, EXTENDS_TYPE_OF, PRESENT, and SAME_TYPE_AS. It also requires every specification inquiry reference to be a constant expression, and requires that the value of the bound not depend on the value of a variable. To implement these additional checks, I added code to the intrinsic proc table to get the intrinsic class of a procedure. I also added an enumeration to distinguish between specification expressions for derived type component bounds versus for type parameters. I then changed the code to pass an enumeration value to "CheckSpecificationExpr()" to indicate that the expression was a bounds expression and used this value to determine whether to emit an error message when violations of C750 are found. I changed the implementation of IsPureProcedure() to handle statement functions and changed some references in the code that tested for the PURE attribute to call IsPureProcedure(). I also fixed some unrelated tests that got new errors when I implemented these new checks. Reviewers: tskeith, DavidTruby, sscalpone Subscribers: jfb, llvm-commits Tags: #llvm, #flang Differential Revision: https://reviews.llvm.org/D79263
2020-05-02 04:00:28 +08:00
DefaultInt, Rank::scalar, IntrinsicClass::transformationalFunction},
[flang] finish most intrinsic table entries Original-commit: flang-compiler/f18@134bd885af5c67ae7fc2291778397546a3d1c189 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-12 05:51:14 +08:00
{"selected_real_kind",
{{"p", AnyInt, Rank::scalar, Optionality::optional},
{"r", AnyInt, Rank::scalar},
{"radix", AnyInt, Rank::scalar, Optionality::optional}},
[flang] New implementation for checks for constraints C741 through C750 Summary: Most of these checks were already implemented, and I just added references to them to the code and tests. Also, much of this code was already reviewed in the old flang/f18 GitHub repository, but I didn't get to merge it before we switched repositories. I implemented the check for C747 to not allow coarray components in derived types that are of type C_PTR, C_FUNPTR, or type TEAM_TYPE. I implemented the check for C748 that requires a data component whose type has a coarray ultimate component to be a nonpointer, nonallocatable scalar and not be a coarray. I implemented the check for C750 that adds additional restrictions to the bounds expressions of a derived type component that's an array. These bounds expressions are sepcification expressions as defined in 10.1.11. There was already code in lib/Evaluate/check-expression.cpp to check semantics for specification expressions, but it did not check for the extra requirements of C750. C750 prohibits specification functions, the intrinsic functions ALLOCATED, ASSOCIATED, EXTENDS_TYPE_OF, PRESENT, and SAME_TYPE_AS. It also requires every specification inquiry reference to be a constant expression, and requires that the value of the bound not depend on the value of a variable. To implement these additional checks, I added code to the intrinsic proc table to get the intrinsic class of a procedure. I also added an enumeration to distinguish between specification expressions for derived type component bounds versus for type parameters. I then changed the code to pass an enumeration value to "CheckSpecificationExpr()" to indicate that the expression was a bounds expression and used this value to determine whether to emit an error message when violations of C750 are found. I changed the implementation of IsPureProcedure() to handle statement functions and changed some references in the code that tested for the PURE attribute to call IsPureProcedure(). I also fixed some unrelated tests that got new errors when I implemented these new checks. Reviewers: tskeith, DavidTruby, sscalpone Subscribers: jfb, llvm-commits Tags: #llvm, #flang Differential Revision: https://reviews.llvm.org/D79263
2020-05-02 04:00:28 +08:00
DefaultInt, Rank::scalar, IntrinsicClass::transformationalFunction},
[flang] finish most intrinsic table entries Original-commit: flang-compiler/f18@134bd885af5c67ae7fc2291778397546a3d1c189 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-12 05:51:14 +08:00
{"selected_real_kind",
{{"p", AnyInt, Rank::scalar, Optionality::optional},
{"r", AnyInt, Rank::scalar, Optionality::optional},
{"radix", AnyInt, Rank::scalar}},
[flang] New implementation for checks for constraints C741 through C750 Summary: Most of these checks were already implemented, and I just added references to them to the code and tests. Also, much of this code was already reviewed in the old flang/f18 GitHub repository, but I didn't get to merge it before we switched repositories. I implemented the check for C747 to not allow coarray components in derived types that are of type C_PTR, C_FUNPTR, or type TEAM_TYPE. I implemented the check for C748 that requires a data component whose type has a coarray ultimate component to be a nonpointer, nonallocatable scalar and not be a coarray. I implemented the check for C750 that adds additional restrictions to the bounds expressions of a derived type component that's an array. These bounds expressions are sepcification expressions as defined in 10.1.11. There was already code in lib/Evaluate/check-expression.cpp to check semantics for specification expressions, but it did not check for the extra requirements of C750. C750 prohibits specification functions, the intrinsic functions ALLOCATED, ASSOCIATED, EXTENDS_TYPE_OF, PRESENT, and SAME_TYPE_AS. It also requires every specification inquiry reference to be a constant expression, and requires that the value of the bound not depend on the value of a variable. To implement these additional checks, I added code to the intrinsic proc table to get the intrinsic class of a procedure. I also added an enumeration to distinguish between specification expressions for derived type component bounds versus for type parameters. I then changed the code to pass an enumeration value to "CheckSpecificationExpr()" to indicate that the expression was a bounds expression and used this value to determine whether to emit an error message when violations of C750 are found. I changed the implementation of IsPureProcedure() to handle statement functions and changed some references in the code that tested for the PURE attribute to call IsPureProcedure(). I also fixed some unrelated tests that got new errors when I implemented these new checks. Reviewers: tskeith, DavidTruby, sscalpone Subscribers: jfb, llvm-commits Tags: #llvm, #flang Differential Revision: https://reviews.llvm.org/D79263
2020-05-02 04:00:28 +08:00
DefaultInt, Rank::scalar, IntrinsicClass::transformationalFunction},
[flang] intrinsic pattern matching Original-commit: flang-compiler/f18@ca0ee1660a6449c34c7276284e5e63b90ae97540 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-05 04:43:33 +08:00
{"set_exponent", {{"x", SameReal}, {"i", AnyInt}}, SameReal},
[flang] enable semantic analysis by default back out -Mnolargearray default temporarily Fix C_F_POINTER(SHAPE=) argument check, it can be any kind of integer Revert default result kind of SIZE() & al. to standard by default Remove needless usage of -fdebug-semantics Original-commit: flang-compiler/f18@57058a5b163eaa90c7e0f387ea4918f9efa8184c Reviewed-on: https://github.com/flang-compiler/f18/pull/907
2020-01-04 08:32:23 +08:00
{"shape", {{"source", AnyData, Rank::anyOrAssumedRank}, SizeDefaultKIND},
[flang] New implementation for checks for constraints C741 through C750 Summary: Most of these checks were already implemented, and I just added references to them to the code and tests. Also, much of this code was already reviewed in the old flang/f18 GitHub repository, but I didn't get to merge it before we switched repositories. I implemented the check for C747 to not allow coarray components in derived types that are of type C_PTR, C_FUNPTR, or type TEAM_TYPE. I implemented the check for C748 that requires a data component whose type has a coarray ultimate component to be a nonpointer, nonallocatable scalar and not be a coarray. I implemented the check for C750 that adds additional restrictions to the bounds expressions of a derived type component that's an array. These bounds expressions are sepcification expressions as defined in 10.1.11. There was already code in lib/Evaluate/check-expression.cpp to check semantics for specification expressions, but it did not check for the extra requirements of C750. C750 prohibits specification functions, the intrinsic functions ALLOCATED, ASSOCIATED, EXTENDS_TYPE_OF, PRESENT, and SAME_TYPE_AS. It also requires every specification inquiry reference to be a constant expression, and requires that the value of the bound not depend on the value of a variable. To implement these additional checks, I added code to the intrinsic proc table to get the intrinsic class of a procedure. I also added an enumeration to distinguish between specification expressions for derived type component bounds versus for type parameters. I then changed the code to pass an enumeration value to "CheckSpecificationExpr()" to indicate that the expression was a bounds expression and used this value to determine whether to emit an error message when violations of C750 are found. I changed the implementation of IsPureProcedure() to handle statement functions and changed some references in the code that tested for the PURE attribute to call IsPureProcedure(). I also fixed some unrelated tests that got new errors when I implemented these new checks. Reviewers: tskeith, DavidTruby, sscalpone Subscribers: jfb, llvm-commits Tags: #llvm, #flang Differential Revision: https://reviews.llvm.org/D79263
2020-05-02 04:00:28 +08:00
KINDInt, Rank::vector, IntrinsicClass::inquiryFunction},
[flang] intrinsic pattern matching Original-commit: flang-compiler/f18@ca0ee1660a6449c34c7276284e5e63b90ae97540 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-05 04:43:33 +08:00
{"shifta", {{"i", SameInt}, {"shift", AnyInt}}, SameInt},
{"shiftl", {{"i", SameInt}, {"shift", AnyInt}}, SameInt},
{"shiftr", {{"i", SameInt}, {"shift", AnyInt}}, SameInt},
{"sign", {{"a", SameIntOrReal}, {"b", SameIntOrReal}}, SameIntOrReal},
{"sin", {{"x", SameFloating}}, SameFloating},
[flang] Apply implicit typing to names in COMMON that appear in specification expressions Extend semantic analysis of expressions to catch missing cases Fix statement function semantics, add degree trig intrinsics Add GetUltimate to rewrite of bare namelist Address review comments Original-commit: flang-compiler/f18@52ff319de2e750733660d8e7e938e09159a3c11c Reviewed-on: https://github.com/flang-compiler/f18/pull/871
2019-12-12 07:06:24 +08:00
{"sind", {{"x", SameFloating}}, SameFloating},
[flang] intrinsic pattern matching Original-commit: flang-compiler/f18@ca0ee1660a6449c34c7276284e5e63b90ae97540 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-05 04:43:33 +08:00
{"sinh", {{"x", SameFloating}}, SameFloating},
[flang] Add -i8, -r8, &c. options to f18 development driver Original-commit: flang-compiler/f18@ff7f338126562ce539879a59d3da5707c76ae11a Reviewed-on: https://github.com/flang-compiler/f18/pull/213
2018-10-17 05:42:22 +08:00
{"size",
[flang] Update preprocessing document, commentary Extend documentation on preprocessing IsSimplyContiguous basic skeleton Apply suggested improvements to mod-file.cc Checks for new call13.f90 (15.4.2.2 explicit interfaces) Implement checking for procedures that can be called via an implicit interface Argument checking, test fixing Better argument checking Better derived type compatibility checking Treat externals as if implicitly interfaced Extend IEEE_EXCEPTIONS module so tests still pass with argument checking SAME_TYPE_AS and EXTENDS_TYPE_OF intrinsic inquiry functions Define interfaces for most intrinsic subroutines Better PASS arguments More with PASS() argument Prep for review address comments fix comment Remove formatted expression from specification expression error message per review more review comments Original-commit: flang-compiler/f18@3cca775da9302e3a2acec4a34800cd7666899b5f Reviewed-on: https://github.com/flang-compiler/f18/pull/776
2019-09-17 07:58:13 +08:00
{{"array", AnyData, Rank::anyOrAssumedRank}, OptionalDIM,
[flang] enable semantic analysis by default back out -Mnolargearray default temporarily Fix C_F_POINTER(SHAPE=) argument check, it can be any kind of integer Revert default result kind of SIZE() & al. to standard by default Remove needless usage of -fdebug-semantics Original-commit: flang-compiler/f18@57058a5b163eaa90c7e0f387ea4918f9efa8184c Reviewed-on: https://github.com/flang-compiler/f18/pull/907
2020-01-04 08:32:23 +08:00
SizeDefaultKIND},
[flang] New implementation for checks for constraints C741 through C750 Summary: Most of these checks were already implemented, and I just added references to them to the code and tests. Also, much of this code was already reviewed in the old flang/f18 GitHub repository, but I didn't get to merge it before we switched repositories. I implemented the check for C747 to not allow coarray components in derived types that are of type C_PTR, C_FUNPTR, or type TEAM_TYPE. I implemented the check for C748 that requires a data component whose type has a coarray ultimate component to be a nonpointer, nonallocatable scalar and not be a coarray. I implemented the check for C750 that adds additional restrictions to the bounds expressions of a derived type component that's an array. These bounds expressions are sepcification expressions as defined in 10.1.11. There was already code in lib/Evaluate/check-expression.cpp to check semantics for specification expressions, but it did not check for the extra requirements of C750. C750 prohibits specification functions, the intrinsic functions ALLOCATED, ASSOCIATED, EXTENDS_TYPE_OF, PRESENT, and SAME_TYPE_AS. It also requires every specification inquiry reference to be a constant expression, and requires that the value of the bound not depend on the value of a variable. To implement these additional checks, I added code to the intrinsic proc table to get the intrinsic class of a procedure. I also added an enumeration to distinguish between specification expressions for derived type component bounds versus for type parameters. I then changed the code to pass an enumeration value to "CheckSpecificationExpr()" to indicate that the expression was a bounds expression and used this value to determine whether to emit an error message when violations of C750 are found. I changed the implementation of IsPureProcedure() to handle statement functions and changed some references in the code that tested for the PURE attribute to call IsPureProcedure(). I also fixed some unrelated tests that got new errors when I implemented these new checks. Reviewers: tskeith, DavidTruby, sscalpone Subscribers: jfb, llvm-commits Tags: #llvm, #flang Differential Revision: https://reviews.llvm.org/D79263
2020-05-02 04:00:28 +08:00
KINDInt, Rank::scalar, IntrinsicClass::inquiryFunction},
[flang] Implement STORAGE_SIZE(), SIZEOF(), C_SIZEOF() STORAGE_SIZE() is a standard inquiry intrinsic (size in bits of an array element of the same type as the argument); SIZEOF() is a common extension that returns the size in bytes of its argument; C_SIZEOF() is a renaming of SIZEOF() in module ISO_C_BINDING. STORAGE_SIZE() and SIZEOF() are implemented via rewrites to expressions; these expressions will be constant when the necessary type parameters and bounds are also constant. Code to calculate the sizes of types (with and without alignment) was isolated into Evaluate/type.* and /characteristics.*. Code in Semantics/compute-offsets.* to calculate sizes and alignments of derived types' scopes was exposed so that it can be called at type instantiation time (earlier than before) so that these inquiry intrinsics could be called from specification expressions. Differential Revision: https://reviews.llvm.org/D93322
2020-12-16 03:06:44 +08:00
{"sizeof", {{"a", AnyData, Rank::anyOrAssumedRank}}, SubscriptInt,
Rank::scalar, IntrinsicClass::inquiryFunction},
[flang] intrinsic pattern matching Original-commit: flang-compiler/f18@ca0ee1660a6449c34c7276284e5e63b90ae97540 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-05 04:43:33 +08:00
{"spacing", {{"x", SameReal}}, SameReal},
[flang] initial intrinsics table Original-commit: flang-compiler/f18@8b5c3adf887cf88752937a4fa5507c0d66051d3b Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-09-29 08:02:11 +08:00
{"spread",
[flang] Refactor SymbolOrComponent typedef to NamedEntity class Original-commit: flang-compiler/f18@e8ec4b88bd6084beeae6a0d3037e019bc1d24c6b Reviewed-on: https://github.com/flang-compiler/f18/pull/531 Tree-same-pre-rewrite: false
2019-06-26 04:07:32 +08:00
{{"source", SameType, Rank::known}, RequiredDIM,
[flang] intrinsic pattern matching Original-commit: flang-compiler/f18@ca0ee1660a6449c34c7276284e5e63b90ae97540 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-05 04:43:33 +08:00
{"ncopies", AnyInt, Rank::scalar}},
[flang] New implementation for checks for constraints C741 through C750 Summary: Most of these checks were already implemented, and I just added references to them to the code and tests. Also, much of this code was already reviewed in the old flang/f18 GitHub repository, but I didn't get to merge it before we switched repositories. I implemented the check for C747 to not allow coarray components in derived types that are of type C_PTR, C_FUNPTR, or type TEAM_TYPE. I implemented the check for C748 that requires a data component whose type has a coarray ultimate component to be a nonpointer, nonallocatable scalar and not be a coarray. I implemented the check for C750 that adds additional restrictions to the bounds expressions of a derived type component that's an array. These bounds expressions are sepcification expressions as defined in 10.1.11. There was already code in lib/Evaluate/check-expression.cpp to check semantics for specification expressions, but it did not check for the extra requirements of C750. C750 prohibits specification functions, the intrinsic functions ALLOCATED, ASSOCIATED, EXTENDS_TYPE_OF, PRESENT, and SAME_TYPE_AS. It also requires every specification inquiry reference to be a constant expression, and requires that the value of the bound not depend on the value of a variable. To implement these additional checks, I added code to the intrinsic proc table to get the intrinsic class of a procedure. I also added an enumeration to distinguish between specification expressions for derived type component bounds versus for type parameters. I then changed the code to pass an enumeration value to "CheckSpecificationExpr()" to indicate that the expression was a bounds expression and used this value to determine whether to emit an error message when violations of C750 are found. I changed the implementation of IsPureProcedure() to handle statement functions and changed some references in the code that tested for the PURE attribute to call IsPureProcedure(). I also fixed some unrelated tests that got new errors when I implemented these new checks. Reviewers: tskeith, DavidTruby, sscalpone Subscribers: jfb, llvm-commits Tags: #llvm, #flang Differential Revision: https://reviews.llvm.org/D79263
2020-05-02 04:00:28 +08:00
SameType, Rank::rankPlus1, IntrinsicClass::transformationalFunction},
[flang] intrinsic pattern matching Original-commit: flang-compiler/f18@ca0ee1660a6449c34c7276284e5e63b90ae97540 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-05 04:43:33 +08:00
{"sqrt", {{"x", SameFloating}}, SameFloating},
[flang] enable semantic analysis by default back out -Mnolargearray default temporarily Fix C_F_POINTER(SHAPE=) argument check, it can be any kind of integer Revert default result kind of SIZE() & al. to standard by default Remove needless usage of -fdebug-semantics Original-commit: flang-compiler/f18@57058a5b163eaa90c7e0f387ea4918f9efa8184c Reviewed-on: https://github.com/flang-compiler/f18/pull/907
2020-01-04 08:32:23 +08:00
{"storage_size", {{"a", AnyData, Rank::anyOrAssumedRank}, SizeDefaultKIND},
[flang] New implementation for checks for constraints C741 through C750 Summary: Most of these checks were already implemented, and I just added references to them to the code and tests. Also, much of this code was already reviewed in the old flang/f18 GitHub repository, but I didn't get to merge it before we switched repositories. I implemented the check for C747 to not allow coarray components in derived types that are of type C_PTR, C_FUNPTR, or type TEAM_TYPE. I implemented the check for C748 that requires a data component whose type has a coarray ultimate component to be a nonpointer, nonallocatable scalar and not be a coarray. I implemented the check for C750 that adds additional restrictions to the bounds expressions of a derived type component that's an array. These bounds expressions are sepcification expressions as defined in 10.1.11. There was already code in lib/Evaluate/check-expression.cpp to check semantics for specification expressions, but it did not check for the extra requirements of C750. C750 prohibits specification functions, the intrinsic functions ALLOCATED, ASSOCIATED, EXTENDS_TYPE_OF, PRESENT, and SAME_TYPE_AS. It also requires every specification inquiry reference to be a constant expression, and requires that the value of the bound not depend on the value of a variable. To implement these additional checks, I added code to the intrinsic proc table to get the intrinsic class of a procedure. I also added an enumeration to distinguish between specification expressions for derived type component bounds versus for type parameters. I then changed the code to pass an enumeration value to "CheckSpecificationExpr()" to indicate that the expression was a bounds expression and used this value to determine whether to emit an error message when violations of C750 are found. I changed the implementation of IsPureProcedure() to handle statement functions and changed some references in the code that tested for the PURE attribute to call IsPureProcedure(). I also fixed some unrelated tests that got new errors when I implemented these new checks. Reviewers: tskeith, DavidTruby, sscalpone Subscribers: jfb, llvm-commits Tags: #llvm, #flang Differential Revision: https://reviews.llvm.org/D79263
2020-05-02 04:00:28 +08:00
KINDInt, Rank::scalar, IntrinsicClass::inquiryFunction},
[flang] Correct shape analysis for transformational intrinsic functions Correct the analysis of references to transformational intrinsic functions that have different semantics based on the presence or absence of a DIM= argument; add shape analysis for UNPACK(). Differential Revision: https://reviews.llvm.org/D94716
2021-01-15 04:54:31 +08:00
{"sum", {{"array", SameNumeric, Rank::array}, RequiredDIM, OptionalMASK},
[flang] New implementation for checks for constraints C741 through C750 Summary: Most of these checks were already implemented, and I just added references to them to the code and tests. Also, much of this code was already reviewed in the old flang/f18 GitHub repository, but I didn't get to merge it before we switched repositories. I implemented the check for C747 to not allow coarray components in derived types that are of type C_PTR, C_FUNPTR, or type TEAM_TYPE. I implemented the check for C748 that requires a data component whose type has a coarray ultimate component to be a nonpointer, nonallocatable scalar and not be a coarray. I implemented the check for C750 that adds additional restrictions to the bounds expressions of a derived type component that's an array. These bounds expressions are sepcification expressions as defined in 10.1.11. There was already code in lib/Evaluate/check-expression.cpp to check semantics for specification expressions, but it did not check for the extra requirements of C750. C750 prohibits specification functions, the intrinsic functions ALLOCATED, ASSOCIATED, EXTENDS_TYPE_OF, PRESENT, and SAME_TYPE_AS. It also requires every specification inquiry reference to be a constant expression, and requires that the value of the bound not depend on the value of a variable. To implement these additional checks, I added code to the intrinsic proc table to get the intrinsic class of a procedure. I also added an enumeration to distinguish between specification expressions for derived type component bounds versus for type parameters. I then changed the code to pass an enumeration value to "CheckSpecificationExpr()" to indicate that the expression was a bounds expression and used this value to determine whether to emit an error message when violations of C750 are found. I changed the implementation of IsPureProcedure() to handle statement functions and changed some references in the code that tested for the PURE attribute to call IsPureProcedure(). I also fixed some unrelated tests that got new errors when I implemented these new checks. Reviewers: tskeith, DavidTruby, sscalpone Subscribers: jfb, llvm-commits Tags: #llvm, #flang Differential Revision: https://reviews.llvm.org/D79263
2020-05-02 04:00:28 +08:00
SameNumeric, Rank::dimReduced,
IntrinsicClass::transformationalFunction},
[flang] Correct shape analysis for transformational intrinsic functions Correct the analysis of references to transformational intrinsic functions that have different semantics based on the presence or absence of a DIM= argument; add shape analysis for UNPACK(). Differential Revision: https://reviews.llvm.org/D94716
2021-01-15 04:54:31 +08:00
{"sum", {{"array", SameNumeric, Rank::array}, MissingDIM, OptionalMASK},
SameNumeric, Rank::scalar, IntrinsicClass::transformationalFunction},
[flang] intrinsic pattern matching Original-commit: flang-compiler/f18@ca0ee1660a6449c34c7276284e5e63b90ae97540 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-05 04:43:33 +08:00
{"tan", {{"x", SameFloating}}, SameFloating},
[flang] Apply implicit typing to names in COMMON that appear in specification expressions Extend semantic analysis of expressions to catch missing cases Fix statement function semantics, add degree trig intrinsics Add GetUltimate to rewrite of bare namelist Address review comments Original-commit: flang-compiler/f18@52ff319de2e750733660d8e7e938e09159a3c11c Reviewed-on: https://github.com/flang-compiler/f18/pull/871
2019-12-12 07:06:24 +08:00
{"tand", {{"x", SameFloating}}, SameFloating},
[flang] intrinsic pattern matching Original-commit: flang-compiler/f18@ca0ee1660a6449c34c7276284e5e63b90ae97540 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-05 04:43:33 +08:00
{"tanh", {{"x", SameFloating}}, SameFloating},
[flang] New implementation for checks for constraints C741 through C750 Summary: Most of these checks were already implemented, and I just added references to them to the code and tests. Also, much of this code was already reviewed in the old flang/f18 GitHub repository, but I didn't get to merge it before we switched repositories. I implemented the check for C747 to not allow coarray components in derived types that are of type C_PTR, C_FUNPTR, or type TEAM_TYPE. I implemented the check for C748 that requires a data component whose type has a coarray ultimate component to be a nonpointer, nonallocatable scalar and not be a coarray. I implemented the check for C750 that adds additional restrictions to the bounds expressions of a derived type component that's an array. These bounds expressions are sepcification expressions as defined in 10.1.11. There was already code in lib/Evaluate/check-expression.cpp to check semantics for specification expressions, but it did not check for the extra requirements of C750. C750 prohibits specification functions, the intrinsic functions ALLOCATED, ASSOCIATED, EXTENDS_TYPE_OF, PRESENT, and SAME_TYPE_AS. It also requires every specification inquiry reference to be a constant expression, and requires that the value of the bound not depend on the value of a variable. To implement these additional checks, I added code to the intrinsic proc table to get the intrinsic class of a procedure. I also added an enumeration to distinguish between specification expressions for derived type component bounds versus for type parameters. I then changed the code to pass an enumeration value to "CheckSpecificationExpr()" to indicate that the expression was a bounds expression and used this value to determine whether to emit an error message when violations of C750 are found. I changed the implementation of IsPureProcedure() to handle statement functions and changed some references in the code that tested for the PURE attribute to call IsPureProcedure(). I also fixed some unrelated tests that got new errors when I implemented these new checks. Reviewers: tskeith, DavidTruby, sscalpone Subscribers: jfb, llvm-commits Tags: #llvm, #flang Differential Revision: https://reviews.llvm.org/D79263
2020-05-02 04:00:28 +08:00
{"tiny", {{"x", SameReal, Rank::anyOrAssumedRank}}, SameReal, Rank::scalar,
IntrinsicClass::inquiryFunction},
[flang] Add -i8, -r8, &c. options to f18 development driver Original-commit: flang-compiler/f18@ff7f338126562ce539879a59d3da5707c76ae11a Reviewed-on: https://github.com/flang-compiler/f18/pull/213
2018-10-17 05:42:22 +08:00
{"trailz", {{"i", AnyInt}}, DefaultInt},
[flang] remove arg->intValue field Original-commit: flang-compiler/f18@721dc920227378d09d89758903c50538b61ffec3 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-10 03:07:29 +08:00
{"transfer",
[flang] Update preprocessing document, commentary Extend documentation on preprocessing IsSimplyContiguous basic skeleton Apply suggested improvements to mod-file.cc Checks for new call13.f90 (15.4.2.2 explicit interfaces) Implement checking for procedures that can be called via an implicit interface Argument checking, test fixing Better argument checking Better derived type compatibility checking Treat externals as if implicitly interfaced Extend IEEE_EXCEPTIONS module so tests still pass with argument checking SAME_TYPE_AS and EXTENDS_TYPE_OF intrinsic inquiry functions Define interfaces for most intrinsic subroutines Better PASS arguments More with PASS() argument Prep for review address comments fix comment Remove formatted expression from specification expression error message per review more review comments Original-commit: flang-compiler/f18@3cca775da9302e3a2acec4a34800cd7666899b5f Reviewed-on: https://github.com/flang-compiler/f18/pull/776
2019-09-17 07:58:13 +08:00
{{"source", AnyData, Rank::known}, {"mold", SameType, Rank::scalar}},
[flang] New implementation for checks for constraints C741 through C750 Summary: Most of these checks were already implemented, and I just added references to them to the code and tests. Also, much of this code was already reviewed in the old flang/f18 GitHub repository, but I didn't get to merge it before we switched repositories. I implemented the check for C747 to not allow coarray components in derived types that are of type C_PTR, C_FUNPTR, or type TEAM_TYPE. I implemented the check for C748 that requires a data component whose type has a coarray ultimate component to be a nonpointer, nonallocatable scalar and not be a coarray. I implemented the check for C750 that adds additional restrictions to the bounds expressions of a derived type component that's an array. These bounds expressions are sepcification expressions as defined in 10.1.11. There was already code in lib/Evaluate/check-expression.cpp to check semantics for specification expressions, but it did not check for the extra requirements of C750. C750 prohibits specification functions, the intrinsic functions ALLOCATED, ASSOCIATED, EXTENDS_TYPE_OF, PRESENT, and SAME_TYPE_AS. It also requires every specification inquiry reference to be a constant expression, and requires that the value of the bound not depend on the value of a variable. To implement these additional checks, I added code to the intrinsic proc table to get the intrinsic class of a procedure. I also added an enumeration to distinguish between specification expressions for derived type component bounds versus for type parameters. I then changed the code to pass an enumeration value to "CheckSpecificationExpr()" to indicate that the expression was a bounds expression and used this value to determine whether to emit an error message when violations of C750 are found. I changed the implementation of IsPureProcedure() to handle statement functions and changed some references in the code that tested for the PURE attribute to call IsPureProcedure(). I also fixed some unrelated tests that got new errors when I implemented these new checks. Reviewers: tskeith, DavidTruby, sscalpone Subscribers: jfb, llvm-commits Tags: #llvm, #flang Differential Revision: https://reviews.llvm.org/D79263
2020-05-02 04:00:28 +08:00
SameType, Rank::scalar, IntrinsicClass::transformationalFunction},
[flang] remove arg->intValue field Original-commit: flang-compiler/f18@721dc920227378d09d89758903c50538b61ffec3 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-10 03:07:29 +08:00
{"transfer",
[flang] Update preprocessing document, commentary Extend documentation on preprocessing IsSimplyContiguous basic skeleton Apply suggested improvements to mod-file.cc Checks for new call13.f90 (15.4.2.2 explicit interfaces) Implement checking for procedures that can be called via an implicit interface Argument checking, test fixing Better argument checking Better derived type compatibility checking Treat externals as if implicitly interfaced Extend IEEE_EXCEPTIONS module so tests still pass with argument checking SAME_TYPE_AS and EXTENDS_TYPE_OF intrinsic inquiry functions Define interfaces for most intrinsic subroutines Better PASS arguments More with PASS() argument Prep for review address comments fix comment Remove formatted expression from specification expression error message per review more review comments Original-commit: flang-compiler/f18@3cca775da9302e3a2acec4a34800cd7666899b5f Reviewed-on: https://github.com/flang-compiler/f18/pull/776
2019-09-17 07:58:13 +08:00
{{"source", AnyData, Rank::known}, {"mold", SameType, Rank::array}},
[flang] New implementation for checks for constraints C741 through C750 Summary: Most of these checks were already implemented, and I just added references to them to the code and tests. Also, much of this code was already reviewed in the old flang/f18 GitHub repository, but I didn't get to merge it before we switched repositories. I implemented the check for C747 to not allow coarray components in derived types that are of type C_PTR, C_FUNPTR, or type TEAM_TYPE. I implemented the check for C748 that requires a data component whose type has a coarray ultimate component to be a nonpointer, nonallocatable scalar and not be a coarray. I implemented the check for C750 that adds additional restrictions to the bounds expressions of a derived type component that's an array. These bounds expressions are sepcification expressions as defined in 10.1.11. There was already code in lib/Evaluate/check-expression.cpp to check semantics for specification expressions, but it did not check for the extra requirements of C750. C750 prohibits specification functions, the intrinsic functions ALLOCATED, ASSOCIATED, EXTENDS_TYPE_OF, PRESENT, and SAME_TYPE_AS. It also requires every specification inquiry reference to be a constant expression, and requires that the value of the bound not depend on the value of a variable. To implement these additional checks, I added code to the intrinsic proc table to get the intrinsic class of a procedure. I also added an enumeration to distinguish between specification expressions for derived type component bounds versus for type parameters. I then changed the code to pass an enumeration value to "CheckSpecificationExpr()" to indicate that the expression was a bounds expression and used this value to determine whether to emit an error message when violations of C750 are found. I changed the implementation of IsPureProcedure() to handle statement functions and changed some references in the code that tested for the PURE attribute to call IsPureProcedure(). I also fixed some unrelated tests that got new errors when I implemented these new checks. Reviewers: tskeith, DavidTruby, sscalpone Subscribers: jfb, llvm-commits Tags: #llvm, #flang Differential Revision: https://reviews.llvm.org/D79263
2020-05-02 04:00:28 +08:00
SameType, Rank::vector, IntrinsicClass::transformationalFunction},
[flang] remove arg->intValue field Original-commit: flang-compiler/f18@721dc920227378d09d89758903c50538b61ffec3 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-10 03:07:29 +08:00
{"transfer",
[flang] Update preprocessing document, commentary Extend documentation on preprocessing IsSimplyContiguous basic skeleton Apply suggested improvements to mod-file.cc Checks for new call13.f90 (15.4.2.2 explicit interfaces) Implement checking for procedures that can be called via an implicit interface Argument checking, test fixing Better argument checking Better derived type compatibility checking Treat externals as if implicitly interfaced Extend IEEE_EXCEPTIONS module so tests still pass with argument checking SAME_TYPE_AS and EXTENDS_TYPE_OF intrinsic inquiry functions Define interfaces for most intrinsic subroutines Better PASS arguments More with PASS() argument Prep for review address comments fix comment Remove formatted expression from specification expression error message per review more review comments Original-commit: flang-compiler/f18@3cca775da9302e3a2acec4a34800cd7666899b5f Reviewed-on: https://github.com/flang-compiler/f18/pull/776
2019-09-17 07:58:13 +08:00
{{"source", AnyData, Rank::anyOrAssumedRank},
[flang] fix crash that Tim ran into Original-commit: flang-compiler/f18@498a8c6fb82be85a60d8ccb18e398c6a3336a035 Reviewed-on: https://github.com/flang-compiler/f18/pull/245
2018-12-15 03:23:14 +08:00
{"mold", SameType, Rank::anyOrAssumedRank},
[flang] remove arg->intValue field Original-commit: flang-compiler/f18@721dc920227378d09d89758903c50538b61ffec3 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-10 03:07:29 +08:00
{"size", AnyInt, Rank::scalar}},
[flang] New implementation for checks for constraints C741 through C750 Summary: Most of these checks were already implemented, and I just added references to them to the code and tests. Also, much of this code was already reviewed in the old flang/f18 GitHub repository, but I didn't get to merge it before we switched repositories. I implemented the check for C747 to not allow coarray components in derived types that are of type C_PTR, C_FUNPTR, or type TEAM_TYPE. I implemented the check for C748 that requires a data component whose type has a coarray ultimate component to be a nonpointer, nonallocatable scalar and not be a coarray. I implemented the check for C750 that adds additional restrictions to the bounds expressions of a derived type component that's an array. These bounds expressions are sepcification expressions as defined in 10.1.11. There was already code in lib/Evaluate/check-expression.cpp to check semantics for specification expressions, but it did not check for the extra requirements of C750. C750 prohibits specification functions, the intrinsic functions ALLOCATED, ASSOCIATED, EXTENDS_TYPE_OF, PRESENT, and SAME_TYPE_AS. It also requires every specification inquiry reference to be a constant expression, and requires that the value of the bound not depend on the value of a variable. To implement these additional checks, I added code to the intrinsic proc table to get the intrinsic class of a procedure. I also added an enumeration to distinguish between specification expressions for derived type component bounds versus for type parameters. I then changed the code to pass an enumeration value to "CheckSpecificationExpr()" to indicate that the expression was a bounds expression and used this value to determine whether to emit an error message when violations of C750 are found. I changed the implementation of IsPureProcedure() to handle statement functions and changed some references in the code that tested for the PURE attribute to call IsPureProcedure(). I also fixed some unrelated tests that got new errors when I implemented these new checks. Reviewers: tskeith, DavidTruby, sscalpone Subscribers: jfb, llvm-commits Tags: #llvm, #flang Differential Revision: https://reviews.llvm.org/D79263
2020-05-02 04:00:28 +08:00
SameType, Rank::vector, IntrinsicClass::transformationalFunction},
{"transpose", {{"matrix", SameType, Rank::matrix}}, SameType, Rank::matrix,
IntrinsicClass::transformationalFunction},
{"trim", {{"string", SameChar, Rank::scalar}}, SameChar, Rank::scalar,
IntrinsicClass::transformationalFunction},
[flang] remove arg->intValue field Original-commit: flang-compiler/f18@721dc920227378d09d89758903c50538b61ffec3 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-10 03:07:29 +08:00
{"ubound",
[flang] Update preprocessing document, commentary Extend documentation on preprocessing IsSimplyContiguous basic skeleton Apply suggested improvements to mod-file.cc Checks for new call13.f90 (15.4.2.2 explicit interfaces) Implement checking for procedures that can be called via an implicit interface Argument checking, test fixing Better argument checking Better derived type compatibility checking Treat externals as if implicitly interfaced Extend IEEE_EXCEPTIONS module so tests still pass with argument checking SAME_TYPE_AS and EXTENDS_TYPE_OF intrinsic inquiry functions Define interfaces for most intrinsic subroutines Better PASS arguments More with PASS() argument Prep for review address comments fix comment Remove formatted expression from specification expression error message per review more review comments Original-commit: flang-compiler/f18@3cca775da9302e3a2acec4a34800cd7666899b5f Reviewed-on: https://github.com/flang-compiler/f18/pull/776
2019-09-17 07:58:13 +08:00
{{"array", AnyData, Rank::anyOrAssumedRank}, RequiredDIM,
[flang] enable semantic analysis by default back out -Mnolargearray default temporarily Fix C_F_POINTER(SHAPE=) argument check, it can be any kind of integer Revert default result kind of SIZE() & al. to standard by default Remove needless usage of -fdebug-semantics Original-commit: flang-compiler/f18@57058a5b163eaa90c7e0f387ea4918f9efa8184c Reviewed-on: https://github.com/flang-compiler/f18/pull/907
2020-01-04 08:32:23 +08:00
SizeDefaultKIND},
[flang] New implementation for checks for constraints C741 through C750 Summary: Most of these checks were already implemented, and I just added references to them to the code and tests. Also, much of this code was already reviewed in the old flang/f18 GitHub repository, but I didn't get to merge it before we switched repositories. I implemented the check for C747 to not allow coarray components in derived types that are of type C_PTR, C_FUNPTR, or type TEAM_TYPE. I implemented the check for C748 that requires a data component whose type has a coarray ultimate component to be a nonpointer, nonallocatable scalar and not be a coarray. I implemented the check for C750 that adds additional restrictions to the bounds expressions of a derived type component that's an array. These bounds expressions are sepcification expressions as defined in 10.1.11. There was already code in lib/Evaluate/check-expression.cpp to check semantics for specification expressions, but it did not check for the extra requirements of C750. C750 prohibits specification functions, the intrinsic functions ALLOCATED, ASSOCIATED, EXTENDS_TYPE_OF, PRESENT, and SAME_TYPE_AS. It also requires every specification inquiry reference to be a constant expression, and requires that the value of the bound not depend on the value of a variable. To implement these additional checks, I added code to the intrinsic proc table to get the intrinsic class of a procedure. I also added an enumeration to distinguish between specification expressions for derived type component bounds versus for type parameters. I then changed the code to pass an enumeration value to "CheckSpecificationExpr()" to indicate that the expression was a bounds expression and used this value to determine whether to emit an error message when violations of C750 are found. I changed the implementation of IsPureProcedure() to handle statement functions and changed some references in the code that tested for the PURE attribute to call IsPureProcedure(). I also fixed some unrelated tests that got new errors when I implemented these new checks. Reviewers: tskeith, DavidTruby, sscalpone Subscribers: jfb, llvm-commits Tags: #llvm, #flang Differential Revision: https://reviews.llvm.org/D79263
2020-05-02 04:00:28 +08:00
KINDInt, Rank::scalar, IntrinsicClass::inquiryFunction},
[flang] enable semantic analysis by default back out -Mnolargearray default temporarily Fix C_F_POINTER(SHAPE=) argument check, it can be any kind of integer Revert default result kind of SIZE() & al. to standard by default Remove needless usage of -fdebug-semantics Original-commit: flang-compiler/f18@57058a5b163eaa90c7e0f387ea4918f9efa8184c Reviewed-on: https://github.com/flang-compiler/f18/pull/907
2020-01-04 08:32:23 +08:00
{"ubound", {{"array", AnyData, Rank::anyOrAssumedRank}, SizeDefaultKIND},
[flang] New implementation for checks for constraints C741 through C750 Summary: Most of these checks were already implemented, and I just added references to them to the code and tests. Also, much of this code was already reviewed in the old flang/f18 GitHub repository, but I didn't get to merge it before we switched repositories. I implemented the check for C747 to not allow coarray components in derived types that are of type C_PTR, C_FUNPTR, or type TEAM_TYPE. I implemented the check for C748 that requires a data component whose type has a coarray ultimate component to be a nonpointer, nonallocatable scalar and not be a coarray. I implemented the check for C750 that adds additional restrictions to the bounds expressions of a derived type component that's an array. These bounds expressions are sepcification expressions as defined in 10.1.11. There was already code in lib/Evaluate/check-expression.cpp to check semantics for specification expressions, but it did not check for the extra requirements of C750. C750 prohibits specification functions, the intrinsic functions ALLOCATED, ASSOCIATED, EXTENDS_TYPE_OF, PRESENT, and SAME_TYPE_AS. It also requires every specification inquiry reference to be a constant expression, and requires that the value of the bound not depend on the value of a variable. To implement these additional checks, I added code to the intrinsic proc table to get the intrinsic class of a procedure. I also added an enumeration to distinguish between specification expressions for derived type component bounds versus for type parameters. I then changed the code to pass an enumeration value to "CheckSpecificationExpr()" to indicate that the expression was a bounds expression and used this value to determine whether to emit an error message when violations of C750 are found. I changed the implementation of IsPureProcedure() to handle statement functions and changed some references in the code that tested for the PURE attribute to call IsPureProcedure(). I also fixed some unrelated tests that got new errors when I implemented these new checks. Reviewers: tskeith, DavidTruby, sscalpone Subscribers: jfb, llvm-commits Tags: #llvm, #flang Differential Revision: https://reviews.llvm.org/D79263
2020-05-02 04:00:28 +08:00
KINDInt, Rank::vector, IntrinsicClass::inquiryFunction},
[flang] remove arg->intValue field Original-commit: flang-compiler/f18@721dc920227378d09d89758903c50538b61ffec3 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-10 03:07:29 +08:00
{"unpack",
{{"vector", SameType, Rank::vector}, {"mask", AnyLogical, Rank::array},
{"field", SameType, Rank::conformable}},
[flang] New implementation for checks for constraints C741 through C750 Summary: Most of these checks were already implemented, and I just added references to them to the code and tests. Also, much of this code was already reviewed in the old flang/f18 GitHub repository, but I didn't get to merge it before we switched repositories. I implemented the check for C747 to not allow coarray components in derived types that are of type C_PTR, C_FUNPTR, or type TEAM_TYPE. I implemented the check for C748 that requires a data component whose type has a coarray ultimate component to be a nonpointer, nonallocatable scalar and not be a coarray. I implemented the check for C750 that adds additional restrictions to the bounds expressions of a derived type component that's an array. These bounds expressions are sepcification expressions as defined in 10.1.11. There was already code in lib/Evaluate/check-expression.cpp to check semantics for specification expressions, but it did not check for the extra requirements of C750. C750 prohibits specification functions, the intrinsic functions ALLOCATED, ASSOCIATED, EXTENDS_TYPE_OF, PRESENT, and SAME_TYPE_AS. It also requires every specification inquiry reference to be a constant expression, and requires that the value of the bound not depend on the value of a variable. To implement these additional checks, I added code to the intrinsic proc table to get the intrinsic class of a procedure. I also added an enumeration to distinguish between specification expressions for derived type component bounds versus for type parameters. I then changed the code to pass an enumeration value to "CheckSpecificationExpr()" to indicate that the expression was a bounds expression and used this value to determine whether to emit an error message when violations of C750 are found. I changed the implementation of IsPureProcedure() to handle statement functions and changed some references in the code that tested for the PURE attribute to call IsPureProcedure(). I also fixed some unrelated tests that got new errors when I implemented these new checks. Reviewers: tskeith, DavidTruby, sscalpone Subscribers: jfb, llvm-commits Tags: #llvm, #flang Differential Revision: https://reviews.llvm.org/D79263
2020-05-02 04:00:28 +08:00
SameType, Rank::conformable, IntrinsicClass::transformationalFunction},
[flang] initial intrinsics table Original-commit: flang-compiler/f18@8b5c3adf887cf88752937a4fa5507c0d66051d3b Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-09-29 08:02:11 +08:00
{"verify",
[flang] intrinsic pattern matching Original-commit: flang-compiler/f18@ca0ee1660a6449c34c7276284e5e63b90ae97540 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-05 04:43:33 +08:00
{{"string", SameChar}, {"set", SameChar},
[flang] error messages Original-commit: flang-compiler/f18@392a7330736a8fd444ef92ed5c8ef7dcbc94d461 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-06 02:32:54 +08:00
{"back", AnyLogical, Rank::elemental, Optionality::optional},
[flang] Revert to returning default INTEGER for LEN() and offset-in-CHARACTER intrinsics; further shape analysis of intrinsic results Original-commit: flang-compiler/f18@561f5965b2309df3cd15d7e2a96d7e73f2f76e35 Reviewed-on: https://github.com/flang-compiler/f18/pull/782 Tree-same-pre-rewrite: false
2019-10-17 02:53:03 +08:00
DefaultingKIND},
[flang] intrinsic pattern matching Original-commit: flang-compiler/f18@ca0ee1660a6449c34c7276284e5e63b90ae97540 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-05 04:43:33 +08:00
KINDInt},
[flang] initial intrinsics table Original-commit: flang-compiler/f18@8b5c3adf887cf88752937a4fa5507c0d66051d3b Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-09-29 08:02:11 +08:00
};
[flang] more intrinsics Original-commit: flang-compiler/f18@2e7210be5b2db80c8aa446c4313c8b8df697fac0 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-11 01:48:12 +08:00
// TODO: Coarray intrinsic functions
[flang] finish most intrinsic table entries Original-commit: flang-compiler/f18@134bd885af5c67ae7fc2291778397546a3d1c189 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-12 05:51:14 +08:00
// LCOBOUND, UCOBOUND, FAILED_IMAGES, GET_TEAM, IMAGE_INDEX,
[flang] Make 'num_images()' intrinsic I added 'num_images()' to the list of functions that are evaluated as intrinsic. I also added a test file in flang/test/Semantics to test calls to 'num_images()'. There was a call to 'num_images()' in flang/test/Semantics/call10.f90 that expected an error, now it no longer produces an error. So I edited that file accordingly. I also edited the intrinsics unit test to add further testing of 'num_images()'. Differential Revision: https://reviews.llvm.org/D83142
2020-07-08 03:31:06 +08:00
// STOPPED_IMAGES, TEAM_NUMBER, THIS_IMAGE,
[flang] finish most intrinsic table entries Original-commit: flang-compiler/f18@134bd885af5c67ae7fc2291778397546a3d1c189 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-12 05:51:14 +08:00
// COSHAPE
// TODO: Non-standard intrinsic functions
// AND, OR, XOR, LSHIFT, RSHIFT, SHIFT, ZEXT, IZEXT,
[flang] Apply implicit typing to names in COMMON that appear in specification expressions Extend semantic analysis of expressions to catch missing cases Fix statement function semantics, add degree trig intrinsics Add GetUltimate to rewrite of bare namelist Address review comments Original-commit: flang-compiler/f18@52ff319de2e750733660d8e7e938e09159a3c11c Reviewed-on: https://github.com/flang-compiler/f18/pull/871
2019-12-12 07:06:24 +08:00
// COMPL, EQV, NEQV, INT8, JINT, JNINT, KNINT,
[flang] Fix forward ref to derived type when symbol exists Fix some comments Original-commit: flang-compiler/f18@3274ed95459865057a2e77966863e6b01b5f6d35 Reviewed-on: https://github.com/flang-compiler/f18/pull/852
2019-12-04 02:21:37 +08:00
// QCMPLX, DFLOAT, QEXT, QFLOAT, QREAL, DNUM,
[flang] Implement STORAGE_SIZE(), SIZEOF(), C_SIZEOF() STORAGE_SIZE() is a standard inquiry intrinsic (size in bits of an array element of the same type as the argument); SIZEOF() is a common extension that returns the size in bytes of its argument; C_SIZEOF() is a renaming of SIZEOF() in module ISO_C_BINDING. STORAGE_SIZE() and SIZEOF() are implemented via rewrites to expressions; these expressions will be constant when the necessary type parameters and bounds are also constant. Code to calculate the sizes of types (with and without alignment) was isolated into Evaluate/type.* and /characteristics.*. Code in Semantics/compute-offsets.* to calculate sizes and alignments of derived types' scopes was exposed so that it can be called at type instantiation time (earlier than before) so that these inquiry intrinsics could be called from specification expressions. Differential Revision: https://reviews.llvm.org/D93322
2020-12-16 03:06:44 +08:00
// INUM, JNUM, KNUM, QNUM, RNUM, RAN, RANF, ILEN,
[flang] finish most intrinsic table entries Original-commit: flang-compiler/f18@134bd885af5c67ae7fc2291778397546a3d1c189 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-12 05:51:14 +08:00
// MCLOCK, SECNDS, COTAN, IBCHNG, ISHA, ISHC, ISHL, IXOR
// IARG, IARGC, NARGS, NUMARG, BADDRESS, IADDR, CACHESIZE,
[flang] Add isnan() extension intrinsic function, with folding It's nonstandard, but commonly implemented. Differential revision: https://reviews.llvm.org/D91213
2020-11-11 07:07:53 +08:00
// EOF, FP_CLASS, INT_PTR_KIND, MALLOC
[flang] finish most intrinsic table entries Original-commit: flang-compiler/f18@134bd885af5c67ae7fc2291778397546a3d1c189 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-12 05:51:14 +08:00
// probably more (these are PGI + Intel, possibly incomplete)
[flang] Add LOC()/%LOC() intrinsics Original-commit: flang-compiler/f18@3a6b90c9f5c1a21a40323e56e2c26f6161d2f79c Reviewed-on: https://github.com/flang-compiler/f18/pull/538 Tree-same-pre-rewrite: false
2019-07-02 04:22:22 +08:00
// TODO: Optionally warn on use of non-standard intrinsics:
// LOC, probably others
[flang] Extension: relax "same kind" rules on some intrinsics Original-commit: flang-compiler/f18@ce5130f84bcb78007180ee87661c84b1483a476c Reviewed-on: https://github.com/flang-compiler/f18/pull/590 Tree-same-pre-rewrite: false
2019-07-18 03:51:52 +08:00
// TODO: Optionally warn on operand promotion extension
[flang] initial intrinsics table Original-commit: flang-compiler/f18@8b5c3adf887cf88752937a4fa5507c0d66051d3b Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-09-29 08:02:11 +08:00
[flang] checkpoint Original-commit: flang-compiler/f18@e7b0f456c9bba153c51c6e775a60e6d01e488271 Reviewed-on: https://github.com/flang-compiler/f18/pull/304 Tree-same-pre-rewrite: false
2019-02-23 07:45:30 +08:00
// The following table contains the intrinsic functions listed in
// Tables 16.2 and 16.3 in Fortran 2018. The "unrestricted" functions
// in Table 16.2 can be used as actual arguments, PROCEDURE() interfaces,
// and procedure pointer targets.
[flang] Allow more argument types in some specific intrinsic Fix flang-compiler/f18#724. Allow all type kinds for arguments in restricted specific conversion intrinisc (no warning, this is ubiquitous). Allow MAX/MIN restricted intrinsic (AMAX0...) to be replaced by the related generic foolowed by a type conversion to the expected result type of the specific. Emit a warning because xlf and ifort are doing so but pgfortran is converting the arguments instead. Original-commit: flang-compiler/f18@c07adb94ed2b2b46284d6a4a4b23c4189ea1d936 Reviewed-on: https://github.com/flang-compiler/f18/pull/749 Tree-same-pre-rewrite: false
2019-09-17 00:34:10 +08:00
// Note that the restricted conversion functions dcmplx, dreal, float, idint,
[flang] Address editorial comments and use oxford comma Original-commit: flang-compiler/f18@88a8d1be035b8aacab277526ebc09802cf22e176 Reviewed-on: https://github.com/flang-compiler/f18/pull/749 Tree-same-pre-rewrite: false
2019-09-17 16:54:51 +08:00
// ifix, and sngl are extended to accept any argument kind because this is a
// common Fortran compilers behavior, and as far as we can tell, is safe and
// useful.
[flang] initial intrinsics table Original-commit: flang-compiler/f18@8b5c3adf887cf88752937a4fa5507c0d66051d3b Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-09-29 08:02:11 +08:00
struct SpecificIntrinsicInterface : public IntrinsicInterface {
const char *generic{nullptr};
[flang] checkpoint Original-commit: flang-compiler/f18@e7b0f456c9bba153c51c6e775a60e6d01e488271 Reviewed-on: https://github.com/flang-compiler/f18/pull/304 Tree-same-pre-rewrite: false
2019-02-23 07:45:30 +08:00
bool isRestrictedSpecific{false};
[flang] Allow more argument types in some specific intrinsic Fix flang-compiler/f18#724. Allow all type kinds for arguments in restricted specific conversion intrinisc (no warning, this is ubiquitous). Allow MAX/MIN restricted intrinsic (AMAX0...) to be replaced by the related generic foolowed by a type conversion to the expected result type of the specific. Emit a warning because xlf and ifort are doing so but pgfortran is converting the arguments instead. Original-commit: flang-compiler/f18@c07adb94ed2b2b46284d6a4a4b23c4189ea1d936 Reviewed-on: https://github.com/flang-compiler/f18/pull/749 Tree-same-pre-rewrite: false
2019-09-17 00:34:10 +08:00
// Exact actual/dummy type matching is required by default for specific
// intrinsics. If useGenericAndForceResultType is set, then the probing will
// also attempt to use the related generic intrinsic and to convert the result
[flang] AMAX0, MIN1... rewrite to MAX/MIN: make result conversion explicit Summary: This patch changes speficic extremum functions rewrite to generic MIN/MAX. It applies to AMAX0, AMIN0, AMAX1, AMIN1, MAX0, MIN0, MAX1, MIN1, DMAX1, and DMIN1. - Do not re-write specific extremums to MAX/MIN in intrinsic Probe and let folding rewrite it and introduc the conversion on the MIN/MAX result. - Also make operand promotion explicit in MIN/MAX folding. For instance, after this patch: AMAX0(int8, int4) is rewritten to REAL(MAX(int8, INT(int4, 8))) All this care is to avoid rewritting it to MAX(REAL(int8), REAL(int4)) that may not always be numerically equivalent to the first rewrite. Reviewers: klausler, schweitz, sscalpone, jdoerfert, DavidTruby Reviewed By: klausler, schweitz Subscribers: llvm-commits, flang-commits Tags: #flang, #llvm Differential Revision: https://reviews.llvm.org/D81940
2020-06-18 13:46:19 +08:00
// to the specific intrinsic result type if needed. This also prevents
// using the generic name so that folding can insert the conversion on the
// result and not the arguments.
//
[flang] Allow more argument types in some specific intrinsic Fix flang-compiler/f18#724. Allow all type kinds for arguments in restricted specific conversion intrinisc (no warning, this is ubiquitous). Allow MAX/MIN restricted intrinsic (AMAX0...) to be replaced by the related generic foolowed by a type conversion to the expected result type of the specific. Emit a warning because xlf and ifort are doing so but pgfortran is converting the arguments instead. Original-commit: flang-compiler/f18@c07adb94ed2b2b46284d6a4a4b23c4189ea1d936 Reviewed-on: https://github.com/flang-compiler/f18/pull/749 Tree-same-pre-rewrite: false
2019-09-17 00:34:10 +08:00
// This is not enabled on all specific intrinsics because an alternative
// is to convert the actual arguments to the required dummy types and this is
// not numerically equivalent.
[flang] AMAX0, MIN1... rewrite to MAX/MIN: make result conversion explicit Summary: This patch changes speficic extremum functions rewrite to generic MIN/MAX. It applies to AMAX0, AMIN0, AMAX1, AMIN1, MAX0, MIN0, MAX1, MIN1, DMAX1, and DMIN1. - Do not re-write specific extremums to MAX/MIN in intrinsic Probe and let folding rewrite it and introduc the conversion on the MIN/MAX result. - Also make operand promotion explicit in MIN/MAX folding. For instance, after this patch: AMAX0(int8, int4) is rewritten to REAL(MAX(int8, INT(int4, 8))) All this care is to avoid rewritting it to MAX(REAL(int8), REAL(int4)) that may not always be numerically equivalent to the first rewrite. Reviewers: klausler, schweitz, sscalpone, jdoerfert, DavidTruby Reviewed By: klausler, schweitz Subscribers: llvm-commits, flang-commits Tags: #flang, #llvm Differential Revision: https://reviews.llvm.org/D81940
2020-06-18 13:46:19 +08:00
// e.g. IABS(INT(i, 4)) not equiv to INT(ABS(i), 4).
[flang] Allow more argument types in some specific intrinsic Fix flang-compiler/f18#724. Allow all type kinds for arguments in restricted specific conversion intrinisc (no warning, this is ubiquitous). Allow MAX/MIN restricted intrinsic (AMAX0...) to be replaced by the related generic foolowed by a type conversion to the expected result type of the specific. Emit a warning because xlf and ifort are doing so but pgfortran is converting the arguments instead. Original-commit: flang-compiler/f18@c07adb94ed2b2b46284d6a4a4b23c4189ea1d936 Reviewed-on: https://github.com/flang-compiler/f18/pull/749 Tree-same-pre-rewrite: false
2019-09-17 00:34:10 +08:00
// This is allowed for restricted min/max specific functions because
// the expected behavior is clear from their definitions. A warning is though
[flang] AMAX0, MIN1... rewrite to MAX/MIN: make result conversion explicit Summary: This patch changes speficic extremum functions rewrite to generic MIN/MAX. It applies to AMAX0, AMIN0, AMAX1, AMIN1, MAX0, MIN0, MAX1, MIN1, DMAX1, and DMIN1. - Do not re-write specific extremums to MAX/MIN in intrinsic Probe and let folding rewrite it and introduc the conversion on the MIN/MAX result. - Also make operand promotion explicit in MIN/MAX folding. For instance, after this patch: AMAX0(int8, int4) is rewritten to REAL(MAX(int8, INT(int4, 8))) All this care is to avoid rewritting it to MAX(REAL(int8), REAL(int4)) that may not always be numerically equivalent to the first rewrite. Reviewers: klausler, schweitz, sscalpone, jdoerfert, DavidTruby Reviewed By: klausler, schweitz Subscribers: llvm-commits, flang-commits Tags: #flang, #llvm Differential Revision: https://reviews.llvm.org/D81940
2020-06-18 13:46:19 +08:00
// always emitted because other compilers' behavior is not ubiquitous here and
// the results in case of conversion overflow might not be equivalent.
// e.g for MIN0: INT(MIN(2147483647_8, 2*2147483647_8), 4) = 2147483647_4
// but: MIN(INT(2147483647_8, 4), INT(2*2147483647_8, 4)) = -2_4
// xlf and ifort return the first, and pgfortran the later. f18 will return
// the first because this matches more closely the MIN0 definition in
// Fortran 2018 table 16.3 (although it is still an extension to allow
// non default integer argument in MIN0).
[flang] Allow more argument types in some specific intrinsic Fix flang-compiler/f18#724. Allow all type kinds for arguments in restricted specific conversion intrinisc (no warning, this is ubiquitous). Allow MAX/MIN restricted intrinsic (AMAX0...) to be replaced by the related generic foolowed by a type conversion to the expected result type of the specific. Emit a warning because xlf and ifort are doing so but pgfortran is converting the arguments instead. Original-commit: flang-compiler/f18@c07adb94ed2b2b46284d6a4a4b23c4189ea1d936 Reviewed-on: https://github.com/flang-compiler/f18/pull/749 Tree-same-pre-rewrite: false
2019-09-17 00:34:10 +08:00
bool useGenericAndForceResultType{false};
[flang] initial intrinsics table Original-commit: flang-compiler/f18@8b5c3adf887cf88752937a4fa5507c0d66051d3b Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-09-29 08:02:11 +08:00
};
[flang] buildable checkpoint before merging with master Original-commit: flang-compiler/f18@78c5b8c4110bac9ce93c0845569e5ebbe47f596a Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-02 02:27:45 +08:00
static const SpecificIntrinsicInterface specificIntrinsicFunction[]{
[flang] Add -i8, -r8, &c. options to f18 development driver Original-commit: flang-compiler/f18@ff7f338126562ce539879a59d3da5707c76ae11a Reviewed-on: https://github.com/flang-compiler/f18/pull/213
2018-10-17 05:42:22 +08:00
{{"abs", {{"a", DefaultReal}}, DefaultReal}},
{{"acos", {{"x", DefaultReal}}, DefaultReal}},
{{"aimag", {{"z", DefaultComplex}}, DefaultReal}},
{{"aint", {{"a", DefaultReal}}, DefaultReal}},
{{"alog", {{"x", DefaultReal}}, DefaultReal}, "log"},
{{"alog10", {{"x", DefaultReal}}, DefaultReal}, "log10"},
[flang] finish most intrinsic table entries Original-commit: flang-compiler/f18@134bd885af5c67ae7fc2291778397546a3d1c189 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-12 05:51:14 +08:00
{{"amax0",
[flang] Add -i8, -r8, &c. options to f18 development driver Original-commit: flang-compiler/f18@ff7f338126562ce539879a59d3da5707c76ae11a Reviewed-on: https://github.com/flang-compiler/f18/pull/213
2018-10-17 05:42:22 +08:00
{{"a1", DefaultInt}, {"a2", DefaultInt},
{"a3", DefaultInt, Rank::elemental, Optionality::repeats}},
DefaultReal},
[flang] Interpret intrinsic table more correctly Original-commit: flang-compiler/f18@ff34f32447a8675caeae5c96549f1659c3a98ec3 Reviewed-on: https://github.com/flang-compiler/f18/pull/488 Tree-same-pre-rewrite: false
2019-06-06 06:40:59 +08:00
"max", true, true},
[flang] finish most intrinsic table entries Original-commit: flang-compiler/f18@134bd885af5c67ae7fc2291778397546a3d1c189 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-12 05:51:14 +08:00
{{"amax1",
[flang] Add -i8, -r8, &c. options to f18 development driver Original-commit: flang-compiler/f18@ff7f338126562ce539879a59d3da5707c76ae11a Reviewed-on: https://github.com/flang-compiler/f18/pull/213
2018-10-17 05:42:22 +08:00
{{"a1", DefaultReal}, {"a2", DefaultReal},
{"a3", DefaultReal, Rank::elemental, Optionality::repeats}},
DefaultReal},
[flang] Interpret intrinsic table more correctly Original-commit: flang-compiler/f18@ff34f32447a8675caeae5c96549f1659c3a98ec3 Reviewed-on: https://github.com/flang-compiler/f18/pull/488 Tree-same-pre-rewrite: false
2019-06-06 06:40:59 +08:00
"max", true, true},
[flang] finish most intrinsic table entries Original-commit: flang-compiler/f18@134bd885af5c67ae7fc2291778397546a3d1c189 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-12 05:51:14 +08:00
{{"amin0",
[flang] Add -i8, -r8, &c. options to f18 development driver Original-commit: flang-compiler/f18@ff7f338126562ce539879a59d3da5707c76ae11a Reviewed-on: https://github.com/flang-compiler/f18/pull/213
2018-10-17 05:42:22 +08:00
{{"a1", DefaultInt}, {"a2", DefaultInt},
{"a3", DefaultInt, Rank::elemental, Optionality::repeats}},
DefaultReal},
[flang] Interpret intrinsic table more correctly Original-commit: flang-compiler/f18@ff34f32447a8675caeae5c96549f1659c3a98ec3 Reviewed-on: https://github.com/flang-compiler/f18/pull/488 Tree-same-pre-rewrite: false
2019-06-06 06:40:59 +08:00
"min", true, true},
[flang] finish most intrinsic table entries Original-commit: flang-compiler/f18@134bd885af5c67ae7fc2291778397546a3d1c189 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-12 05:51:14 +08:00
{{"amin1",
[flang] Add -i8, -r8, &c. options to f18 development driver Original-commit: flang-compiler/f18@ff7f338126562ce539879a59d3da5707c76ae11a Reviewed-on: https://github.com/flang-compiler/f18/pull/213
2018-10-17 05:42:22 +08:00
{{"a1", DefaultReal}, {"a2", DefaultReal},
{"a3", DefaultReal, Rank::elemental, Optionality::repeats}},
DefaultReal},
[flang] Interpret intrinsic table more correctly Original-commit: flang-compiler/f18@ff34f32447a8675caeae5c96549f1659c3a98ec3 Reviewed-on: https://github.com/flang-compiler/f18/pull/488 Tree-same-pre-rewrite: false
2019-06-06 06:40:59 +08:00
"min", true, true},
[flang] Add -i8, -r8, &c. options to f18 development driver Original-commit: flang-compiler/f18@ff7f338126562ce539879a59d3da5707c76ae11a Reviewed-on: https://github.com/flang-compiler/f18/pull/213
2018-10-17 05:42:22 +08:00
{{"amod", {{"a", DefaultReal}, {"p", DefaultReal}}, DefaultReal}, "mod"},
{{"anint", {{"a", DefaultReal}}, DefaultReal}},
{{"asin", {{"x", DefaultReal}}, DefaultReal}},
{{"atan", {{"x", DefaultReal}}, DefaultReal}},
{{"atan2", {{"y", DefaultReal}, {"x", DefaultReal}}, DefaultReal}},
{{"cabs", {{"a", DefaultComplex}}, DefaultReal}, "abs"},
{{"ccos", {{"a", DefaultComplex}}, DefaultComplex}, "cos"},
[flang] Add DOUBLE COMPLEX intrinsics & ASSOCIATED Original-commit: flang-compiler/f18@fbcc2c0b5daf10010e2917c27e4ac5be1d470a12 Reviewed-on: https://github.com/flang-compiler/f18/pull/531 Tree-same-pre-rewrite: false
2019-06-22 05:04:40 +08:00
{{"cdabs", {{"a", DoublePrecisionComplex}}, DoublePrecision}, "abs"},
{{"cdcos", {{"a", DoublePrecisionComplex}}, DoublePrecisionComplex}, "cos"},
{{"cdexp", {{"a", DoublePrecisionComplex}}, DoublePrecisionComplex}, "exp"},
{{"cdlog", {{"a", DoublePrecisionComplex}}, DoublePrecisionComplex}, "log"},
{{"cdsin", {{"a", DoublePrecisionComplex}}, DoublePrecisionComplex}, "sin"},
{{"cdsqrt", {{"a", DoublePrecisionComplex}}, DoublePrecisionComplex},
"sqrt"},
[flang] Add -i8, -r8, &c. options to f18 development driver Original-commit: flang-compiler/f18@ff7f338126562ce539879a59d3da5707c76ae11a Reviewed-on: https://github.com/flang-compiler/f18/pull/213
2018-10-17 05:42:22 +08:00
{{"cexp", {{"a", DefaultComplex}}, DefaultComplex}, "exp"},
{{"clog", {{"a", DefaultComplex}}, DefaultComplex}, "log"},
{{"conjg", {{"a", DefaultComplex}}, DefaultComplex}},
{{"cos", {{"x", DefaultReal}}, DefaultReal}},
[flang] Apply implicit typing to names in COMMON that appear in specification expressions Extend semantic analysis of expressions to catch missing cases Fix statement function semantics, add degree trig intrinsics Add GetUltimate to rewrite of bare namelist Address review comments Original-commit: flang-compiler/f18@52ff319de2e750733660d8e7e938e09159a3c11c Reviewed-on: https://github.com/flang-compiler/f18/pull/871
2019-12-12 07:06:24 +08:00
{{"cosh", {{"x", DefaultReal}}, DefaultReal}},
[flang] Add -i8, -r8, &c. options to f18 development driver Original-commit: flang-compiler/f18@ff7f338126562ce539879a59d3da5707c76ae11a Reviewed-on: https://github.com/flang-compiler/f18/pull/213
2018-10-17 05:42:22 +08:00
{{"csin", {{"a", DefaultComplex}}, DefaultComplex}, "sin"},
{{"csqrt", {{"a", DefaultComplex}}, DefaultComplex}, "sqrt"},
{{"ctan", {{"a", DefaultComplex}}, DefaultComplex}, "tan"},
[flang] intrinsic pattern matching Original-commit: flang-compiler/f18@ca0ee1660a6449c34c7276284e5e63b90ae97540 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-05 04:43:33 +08:00
{{"dabs", {{"a", DoublePrecision}}, DoublePrecision}, "abs"},
{{"dacos", {{"x", DoublePrecision}}, DoublePrecision}, "acos"},
{{"dasin", {{"x", DoublePrecision}}, DoublePrecision}, "asin"},
{{"datan", {{"x", DoublePrecision}}, DoublePrecision}, "atan"},
{{"datan2", {{"y", DoublePrecision}, {"x", DoublePrecision}},
DoublePrecision},
"atan2"},
[flang] Allow more argument types in some specific intrinsic Fix flang-compiler/f18#724. Allow all type kinds for arguments in restricted specific conversion intrinisc (no warning, this is ubiquitous). Allow MAX/MIN restricted intrinsic (AMAX0...) to be replaced by the related generic foolowed by a type conversion to the expected result type of the specific. Emit a warning because xlf and ifort are doing so but pgfortran is converting the arguments instead. Original-commit: flang-compiler/f18@c07adb94ed2b2b46284d6a4a4b23c4189ea1d936 Reviewed-on: https://github.com/flang-compiler/f18/pull/749 Tree-same-pre-rewrite: false
2019-09-17 00:34:10 +08:00
{{"dcmplx", {{"x", AnyComplex}}, DoublePrecisionComplex}, "cmplx", true},
[flang] Add dcmplx to the intrinsic table and extensions documentation. Formatting change to dimag intrinsic table entry. Original-commit: flang-compiler/f18@7f9237531ca346306ff97ad99e11ea11c7fe0a49 Reviewed-on: https://github.com/flang-compiler/f18/pull/662
2019-08-15 02:32:32 +08:00
{{"dcmplx",
{{"x", AnyIntOrReal, Rank::elementalOrBOZ},
{"y", AnyIntOrReal, Rank::elementalOrBOZ, Optionality::optional}},
DoublePrecisionComplex},
[flang] Allow more argument types in some specific intrinsic Fix flang-compiler/f18#724. Allow all type kinds for arguments in restricted specific conversion intrinisc (no warning, this is ubiquitous). Allow MAX/MIN restricted intrinsic (AMAX0...) to be replaced by the related generic foolowed by a type conversion to the expected result type of the specific. Emit a warning because xlf and ifort are doing so but pgfortran is converting the arguments instead. Original-commit: flang-compiler/f18@c07adb94ed2b2b46284d6a4a4b23c4189ea1d936 Reviewed-on: https://github.com/flang-compiler/f18/pull/749 Tree-same-pre-rewrite: false
2019-09-17 00:34:10 +08:00
"cmplx", true},
{{"dreal", {{"a", AnyComplex}}, DoublePrecision}, "real", true},
[flang] Add DOUBLE COMPLEX intrinsics & ASSOCIATED Original-commit: flang-compiler/f18@fbcc2c0b5daf10010e2917c27e4ac5be1d470a12 Reviewed-on: https://github.com/flang-compiler/f18/pull/531 Tree-same-pre-rewrite: false
2019-06-22 05:04:40 +08:00
{{"dconjg", {{"a", DoublePrecisionComplex}}, DoublePrecisionComplex},
"conjg"},
[flang] intrinsic pattern matching Original-commit: flang-compiler/f18@ca0ee1660a6449c34c7276284e5e63b90ae97540 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-05 04:43:33 +08:00
{{"dcos", {{"x", DoublePrecision}}, DoublePrecision}, "cos"},
{{"dcosh", {{"x", DoublePrecision}}, DoublePrecision}, "cosh"},
{{"ddim", {{"x", DoublePrecision}, {"y", DoublePrecision}},
DoublePrecision},
"dim"},
[flang] Add dcmplx to the intrinsic table and extensions documentation. Formatting change to dimag intrinsic table entry. Original-commit: flang-compiler/f18@7f9237531ca346306ff97ad99e11ea11c7fe0a49 Reviewed-on: https://github.com/flang-compiler/f18/pull/662
2019-08-15 02:32:32 +08:00
{{"dimag", {{"a", DoublePrecisionComplex}}, DoublePrecision}, "aimag"},
[flang] intrinsic pattern matching Original-commit: flang-compiler/f18@ca0ee1660a6449c34c7276284e5e63b90ae97540 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-05 04:43:33 +08:00
{{"dexp", {{"x", DoublePrecision}}, DoublePrecision}, "exp"},
[flang] Add -i8, -r8, &c. options to f18 development driver Original-commit: flang-compiler/f18@ff7f338126562ce539879a59d3da5707c76ae11a Reviewed-on: https://github.com/flang-compiler/f18/pull/213
2018-10-17 05:42:22 +08:00
{{"dim", {{"x", DefaultReal}, {"y", DefaultReal}}, DefaultReal}},
[flang] intrinsic pattern matching Original-commit: flang-compiler/f18@ca0ee1660a6449c34c7276284e5e63b90ae97540 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-05 04:43:33 +08:00
{{"dint", {{"a", DoublePrecision}}, DoublePrecision}, "aint"},
{{"dlog", {{"x", DoublePrecision}}, DoublePrecision}, "log"},
{{"dlog10", {{"x", DoublePrecision}}, DoublePrecision}, "log10"},
[flang] finish most intrinsic table entries Original-commit: flang-compiler/f18@134bd885af5c67ae7fc2291778397546a3d1c189 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-12 05:51:14 +08:00
{{"dmax1",
{{"a1", DoublePrecision}, {"a2", DoublePrecision},
{"a3", DoublePrecision, Rank::elemental, Optionality::repeats}},
DoublePrecision},
[flang] Allow more argument types in some specific intrinsic Fix flang-compiler/f18#724. Allow all type kinds for arguments in restricted specific conversion intrinisc (no warning, this is ubiquitous). Allow MAX/MIN restricted intrinsic (AMAX0...) to be replaced by the related generic foolowed by a type conversion to the expected result type of the specific. Emit a warning because xlf and ifort are doing so but pgfortran is converting the arguments instead. Original-commit: flang-compiler/f18@c07adb94ed2b2b46284d6a4a4b23c4189ea1d936 Reviewed-on: https://github.com/flang-compiler/f18/pull/749 Tree-same-pre-rewrite: false
2019-09-17 00:34:10 +08:00
"max", true, true},
[flang] finish most intrinsic table entries Original-commit: flang-compiler/f18@134bd885af5c67ae7fc2291778397546a3d1c189 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-12 05:51:14 +08:00
{{"dmin1",
{{"a1", DoublePrecision}, {"a2", DoublePrecision},
{"a3", DoublePrecision, Rank::elemental, Optionality::repeats}},
DoublePrecision},
[flang] Allow more argument types in some specific intrinsic Fix flang-compiler/f18#724. Allow all type kinds for arguments in restricted specific conversion intrinisc (no warning, this is ubiquitous). Allow MAX/MIN restricted intrinsic (AMAX0...) to be replaced by the related generic foolowed by a type conversion to the expected result type of the specific. Emit a warning because xlf and ifort are doing so but pgfortran is converting the arguments instead. Original-commit: flang-compiler/f18@c07adb94ed2b2b46284d6a4a4b23c4189ea1d936 Reviewed-on: https://github.com/flang-compiler/f18/pull/749 Tree-same-pre-rewrite: false
2019-09-17 00:34:10 +08:00
"min", true, true},
[flang] intrinsic pattern matching Original-commit: flang-compiler/f18@ca0ee1660a6449c34c7276284e5e63b90ae97540 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-05 04:43:33 +08:00
{{"dmod", {{"a", DoublePrecision}, {"p", DoublePrecision}},
DoublePrecision},
"mod"},
{{"dnint", {{"a", DoublePrecision}}, DoublePrecision}, "anint"},
[flang] Add -i8, -r8, &c. options to f18 development driver Original-commit: flang-compiler/f18@ff7f338126562ce539879a59d3da5707c76ae11a Reviewed-on: https://github.com/flang-compiler/f18/pull/213
2018-10-17 05:42:22 +08:00
{{"dprod", {{"x", DefaultReal}, {"y", DefaultReal}}, DoublePrecision}},
[flang] intrinsic pattern matching Original-commit: flang-compiler/f18@ca0ee1660a6449c34c7276284e5e63b90ae97540 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-05 04:43:33 +08:00
{{"dsign", {{"a", DoublePrecision}, {"b", DoublePrecision}},
DoublePrecision},
"sign"},
{{"dsin", {{"x", DoublePrecision}}, DoublePrecision}, "sin"},
{{"dsinh", {{"x", DoublePrecision}}, DoublePrecision}, "sinh"},
{{"dsqrt", {{"x", DoublePrecision}}, DoublePrecision}, "sqrt"},
{{"dtan", {{"x", DoublePrecision}}, DoublePrecision}, "tan"},
{{"dtanh", {{"x", DoublePrecision}}, DoublePrecision}, "tanh"},
[flang] Add -i8, -r8, &c. options to f18 development driver Original-commit: flang-compiler/f18@ff7f338126562ce539879a59d3da5707c76ae11a Reviewed-on: https://github.com/flang-compiler/f18/pull/213
2018-10-17 05:42:22 +08:00
{{"exp", {{"x", DefaultReal}}, DefaultReal}},
[flang] Allow more argument types in some specific intrinsic Fix flang-compiler/f18#724. Allow all type kinds for arguments in restricted specific conversion intrinisc (no warning, this is ubiquitous). Allow MAX/MIN restricted intrinsic (AMAX0...) to be replaced by the related generic foolowed by a type conversion to the expected result type of the specific. Emit a warning because xlf and ifort are doing so but pgfortran is converting the arguments instead. Original-commit: flang-compiler/f18@c07adb94ed2b2b46284d6a4a4b23c4189ea1d936 Reviewed-on: https://github.com/flang-compiler/f18/pull/749 Tree-same-pre-rewrite: false
2019-09-17 00:34:10 +08:00
{{"float", {{"i", AnyInt}}, DefaultReal}, "real", true},
[flang] Add -i8, -r8, &c. options to f18 development driver Original-commit: flang-compiler/f18@ff7f338126562ce539879a59d3da5707c76ae11a Reviewed-on: https://github.com/flang-compiler/f18/pull/213
2018-10-17 05:42:22 +08:00
{{"iabs", {{"a", DefaultInt}}, DefaultInt}, "abs"},
{{"idim", {{"x", DefaultInt}, {"y", DefaultInt}}, DefaultInt}, "dim"},
[flang] Allow more argument types in some specific intrinsic Fix flang-compiler/f18#724. Allow all type kinds for arguments in restricted specific conversion intrinisc (no warning, this is ubiquitous). Allow MAX/MIN restricted intrinsic (AMAX0...) to be replaced by the related generic foolowed by a type conversion to the expected result type of the specific. Emit a warning because xlf and ifort are doing so but pgfortran is converting the arguments instead. Original-commit: flang-compiler/f18@c07adb94ed2b2b46284d6a4a4b23c4189ea1d936 Reviewed-on: https://github.com/flang-compiler/f18/pull/749 Tree-same-pre-rewrite: false
2019-09-17 00:34:10 +08:00
{{"idint", {{"a", AnyReal}}, DefaultInt}, "int", true},
[flang] Add -i8, -r8, &c. options to f18 development driver Original-commit: flang-compiler/f18@ff7f338126562ce539879a59d3da5707c76ae11a Reviewed-on: https://github.com/flang-compiler/f18/pull/213
2018-10-17 05:42:22 +08:00
{{"idnint", {{"a", DoublePrecision}}, DefaultInt}, "nint"},
[flang] Allow more argument types in some specific intrinsic Fix flang-compiler/f18#724. Allow all type kinds for arguments in restricted specific conversion intrinisc (no warning, this is ubiquitous). Allow MAX/MIN restricted intrinsic (AMAX0...) to be replaced by the related generic foolowed by a type conversion to the expected result type of the specific. Emit a warning because xlf and ifort are doing so but pgfortran is converting the arguments instead. Original-commit: flang-compiler/f18@c07adb94ed2b2b46284d6a4a4b23c4189ea1d936 Reviewed-on: https://github.com/flang-compiler/f18/pull/749 Tree-same-pre-rewrite: false
2019-09-17 00:34:10 +08:00
{{"ifix", {{"a", AnyReal}}, DefaultInt}, "int", true},
[flang] Add -i8, -r8, &c. options to f18 development driver Original-commit: flang-compiler/f18@ff7f338126562ce539879a59d3da5707c76ae11a Reviewed-on: https://github.com/flang-compiler/f18/pull/213
2018-10-17 05:42:22 +08:00
{{"index", {{"string", DefaultChar}, {"substring", DefaultChar}},
[flang] enable semantic analysis by default back out -Mnolargearray default temporarily Fix C_F_POINTER(SHAPE=) argument check, it can be any kind of integer Revert default result kind of SIZE() & al. to standard by default Remove needless usage of -fdebug-semantics Original-commit: flang-compiler/f18@57058a5b163eaa90c7e0f387ea4918f9efa8184c Reviewed-on: https://github.com/flang-compiler/f18/pull/907
2020-01-04 08:32:23 +08:00
DefaultInt}},
[flang] Add -i8, -r8, &c. options to f18 development driver Original-commit: flang-compiler/f18@ff7f338126562ce539879a59d3da5707c76ae11a Reviewed-on: https://github.com/flang-compiler/f18/pull/213
2018-10-17 05:42:22 +08:00
{{"isign", {{"a", DefaultInt}, {"b", DefaultInt}}, DefaultInt}, "sign"},
[flang] enable semantic analysis by default back out -Mnolargearray default temporarily Fix C_F_POINTER(SHAPE=) argument check, it can be any kind of integer Revert default result kind of SIZE() & al. to standard by default Remove needless usage of -fdebug-semantics Original-commit: flang-compiler/f18@57058a5b163eaa90c7e0f387ea4918f9efa8184c Reviewed-on: https://github.com/flang-compiler/f18/pull/907
2020-01-04 08:32:23 +08:00
{{"len", {{"string", DefaultChar, Rank::anyOrAssumedRank}}, DefaultInt,
[flang] Fix arg specs for CMPLX intrinsic Original-commit: flang-compiler/f18@3586b8a6469c91092f68beb76b77501c3920bb4b Reviewed-on: https://github.com/flang-compiler/f18/pull/477 Tree-same-pre-rewrite: false
2019-06-05 01:50:34 +08:00
Rank::scalar}},
[flang] Interpret intrinsic table more correctly Original-commit: flang-compiler/f18@ff34f32447a8675caeae5c96549f1659c3a98ec3 Reviewed-on: https://github.com/flang-compiler/f18/pull/488 Tree-same-pre-rewrite: false
2019-06-06 06:40:59 +08:00
{{"lge", {{"string_a", DefaultChar}, {"string_b", DefaultChar}},
DefaultLogical}},
{{"lgt", {{"string_a", DefaultChar}, {"string_b", DefaultChar}},
DefaultLogical}},
{{"lle", {{"string_a", DefaultChar}, {"string_b", DefaultChar}},
DefaultLogical}},
{{"llt", {{"string_a", DefaultChar}, {"string_b", DefaultChar}},
DefaultLogical}},
[flang] Add -i8, -r8, &c. options to f18 development driver Original-commit: flang-compiler/f18@ff7f338126562ce539879a59d3da5707c76ae11a Reviewed-on: https://github.com/flang-compiler/f18/pull/213
2018-10-17 05:42:22 +08:00
{{"log", {{"x", DefaultReal}}, DefaultReal}},
{{"log10", {{"x", DefaultReal}}, DefaultReal}},
[flang] finish most intrinsic table entries Original-commit: flang-compiler/f18@134bd885af5c67ae7fc2291778397546a3d1c189 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-12 05:51:14 +08:00
{{"max0",
[flang] Add -i8, -r8, &c. options to f18 development driver Original-commit: flang-compiler/f18@ff7f338126562ce539879a59d3da5707c76ae11a Reviewed-on: https://github.com/flang-compiler/f18/pull/213
2018-10-17 05:42:22 +08:00
{{"a1", DefaultInt}, {"a2", DefaultInt},
{"a3", DefaultInt, Rank::elemental, Optionality::repeats}},
DefaultInt},
[flang] Interpret intrinsic table more correctly Original-commit: flang-compiler/f18@ff34f32447a8675caeae5c96549f1659c3a98ec3 Reviewed-on: https://github.com/flang-compiler/f18/pull/488 Tree-same-pre-rewrite: false
2019-06-06 06:40:59 +08:00
"max", true, true},
[flang] finish most intrinsic table entries Original-commit: flang-compiler/f18@134bd885af5c67ae7fc2291778397546a3d1c189 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-12 05:51:14 +08:00
{{"max1",
[flang] Add -i8, -r8, &c. options to f18 development driver Original-commit: flang-compiler/f18@ff7f338126562ce539879a59d3da5707c76ae11a Reviewed-on: https://github.com/flang-compiler/f18/pull/213
2018-10-17 05:42:22 +08:00
{{"a1", DefaultReal}, {"a2", DefaultReal},
{"a3", DefaultReal, Rank::elemental, Optionality::repeats}},
DefaultInt},
[flang] Interpret intrinsic table more correctly Original-commit: flang-compiler/f18@ff34f32447a8675caeae5c96549f1659c3a98ec3 Reviewed-on: https://github.com/flang-compiler/f18/pull/488 Tree-same-pre-rewrite: false
2019-06-06 06:40:59 +08:00
"max", true, true},
[flang] finish most intrinsic table entries Original-commit: flang-compiler/f18@134bd885af5c67ae7fc2291778397546a3d1c189 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-12 05:51:14 +08:00
{{"min0",
[flang] Add -i8, -r8, &c. options to f18 development driver Original-commit: flang-compiler/f18@ff7f338126562ce539879a59d3da5707c76ae11a Reviewed-on: https://github.com/flang-compiler/f18/pull/213
2018-10-17 05:42:22 +08:00
{{"a1", DefaultInt}, {"a2", DefaultInt},
{"a3", DefaultInt, Rank::elemental, Optionality::repeats}},
DefaultInt},
[flang] Interpret intrinsic table more correctly Original-commit: flang-compiler/f18@ff34f32447a8675caeae5c96549f1659c3a98ec3 Reviewed-on: https://github.com/flang-compiler/f18/pull/488 Tree-same-pre-rewrite: false
2019-06-06 06:40:59 +08:00
"min", true, true},
[flang] finish most intrinsic table entries Original-commit: flang-compiler/f18@134bd885af5c67ae7fc2291778397546a3d1c189 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-12 05:51:14 +08:00
{{"min1",
[flang] Add -i8, -r8, &c. options to f18 development driver Original-commit: flang-compiler/f18@ff7f338126562ce539879a59d3da5707c76ae11a Reviewed-on: https://github.com/flang-compiler/f18/pull/213
2018-10-17 05:42:22 +08:00
{{"a1", DefaultReal}, {"a2", DefaultReal},
{"a3", DefaultReal, Rank::elemental, Optionality::repeats}},
DefaultInt},
[flang] Interpret intrinsic table more correctly Original-commit: flang-compiler/f18@ff34f32447a8675caeae5c96549f1659c3a98ec3 Reviewed-on: https://github.com/flang-compiler/f18/pull/488 Tree-same-pre-rewrite: false
2019-06-06 06:40:59 +08:00
"min", true, true},
[flang] Add -i8, -r8, &c. options to f18 development driver Original-commit: flang-compiler/f18@ff7f338126562ce539879a59d3da5707c76ae11a Reviewed-on: https://github.com/flang-compiler/f18/pull/213
2018-10-17 05:42:22 +08:00
{{"mod", {{"a", DefaultInt}, {"p", DefaultInt}}, DefaultInt}},
{{"nint", {{"a", DefaultReal}}, DefaultInt}},
{{"sign", {{"a", DefaultReal}, {"b", DefaultReal}}, DefaultReal}},
{{"sin", {{"x", DefaultReal}}, DefaultReal}},
{{"sinh", {{"x", DefaultReal}}, DefaultReal}},
[flang] Allow more argument types in some specific intrinsic Fix flang-compiler/f18#724. Allow all type kinds for arguments in restricted specific conversion intrinisc (no warning, this is ubiquitous). Allow MAX/MIN restricted intrinsic (AMAX0...) to be replaced by the related generic foolowed by a type conversion to the expected result type of the specific. Emit a warning because xlf and ifort are doing so but pgfortran is converting the arguments instead. Original-commit: flang-compiler/f18@c07adb94ed2b2b46284d6a4a4b23c4189ea1d936 Reviewed-on: https://github.com/flang-compiler/f18/pull/749 Tree-same-pre-rewrite: false
2019-09-17 00:34:10 +08:00
{{"sngl", {{"a", AnyReal}}, DefaultReal}, "real", true},
[flang] Add -i8, -r8, &c. options to f18 development driver Original-commit: flang-compiler/f18@ff7f338126562ce539879a59d3da5707c76ae11a Reviewed-on: https://github.com/flang-compiler/f18/pull/213
2018-10-17 05:42:22 +08:00
{{"sqrt", {{"x", DefaultReal}}, DefaultReal}},
{{"tan", {{"x", DefaultReal}}, DefaultReal}},
{{"tanh", {{"x", DefaultReal}}, DefaultReal}},
[flang] initial intrinsics table Original-commit: flang-compiler/f18@8b5c3adf887cf88752937a4fa5507c0d66051d3b Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-09-29 08:02:11 +08:00
};
[flang] Update preprocessing document, commentary Extend documentation on preprocessing IsSimplyContiguous basic skeleton Apply suggested improvements to mod-file.cc Checks for new call13.f90 (15.4.2.2 explicit interfaces) Implement checking for procedures that can be called via an implicit interface Argument checking, test fixing Better argument checking Better derived type compatibility checking Treat externals as if implicitly interfaced Extend IEEE_EXCEPTIONS module so tests still pass with argument checking SAME_TYPE_AS and EXTENDS_TYPE_OF intrinsic inquiry functions Define interfaces for most intrinsic subroutines Better PASS arguments More with PASS() argument Prep for review address comments fix comment Remove formatted expression from specification expression error message per review more review comments Original-commit: flang-compiler/f18@3cca775da9302e3a2acec4a34800cd7666899b5f Reviewed-on: https://github.com/flang-compiler/f18/pull/776
2019-09-17 07:58:13 +08:00
static const IntrinsicInterface intrinsicSubroutine[]{
[flang] Document and use intrinsic subroutine argument intents Check INTENT(OUT)/INTENT(INOUT) constraints for actual argument of intrinsic procedure calls. - Adding a common::Intent field to the IntrinsicDummyArgument in the intrinsic table. - Propagating it to the DummyDataObject intent field so that it can later be used in CheckExplicitDataArg semantic checks. - Add related tests. - Fix regression (C846 false error), C846 INTENT(OUT) rule does not apply to intrinsic call. Propagate the information that we are in an intrinsic call up to CheckExplicitDataArg (that is doing this check). Still enforce C846 on intrinsics other than MOVE_ALLOC (for which allocatable coarrays are explicitly allowed) since it's not clear it is allowed in all intrinsics and allowing this would lead to runtime penalties in the intrinsic runtime. Differential Revision: https://reviews.llvm.org/D89473
2020-10-20 18:39:26 +08:00
{"cpu_time",
{{"time", AnyReal, Rank::scalar, Optionality::required,
common::Intent::Out}},
{}, Rank::elemental, IntrinsicClass::impureSubroutine},
[flang] Update preprocessing document, commentary Extend documentation on preprocessing IsSimplyContiguous basic skeleton Apply suggested improvements to mod-file.cc Checks for new call13.f90 (15.4.2.2 explicit interfaces) Implement checking for procedures that can be called via an implicit interface Argument checking, test fixing Better argument checking Better derived type compatibility checking Treat externals as if implicitly interfaced Extend IEEE_EXCEPTIONS module so tests still pass with argument checking SAME_TYPE_AS and EXTENDS_TYPE_OF intrinsic inquiry functions Define interfaces for most intrinsic subroutines Better PASS arguments More with PASS() argument Prep for review address comments fix comment Remove formatted expression from specification expression error message per review more review comments Original-commit: flang-compiler/f18@3cca775da9302e3a2acec4a34800cd7666899b5f Reviewed-on: https://github.com/flang-compiler/f18/pull/776
2019-09-17 07:58:13 +08:00
{"date_and_time",
[flang] Document and use intrinsic subroutine argument intents Check INTENT(OUT)/INTENT(INOUT) constraints for actual argument of intrinsic procedure calls. - Adding a common::Intent field to the IntrinsicDummyArgument in the intrinsic table. - Propagating it to the DummyDataObject intent field so that it can later be used in CheckExplicitDataArg semantic checks. - Add related tests. - Fix regression (C846 false error), C846 INTENT(OUT) rule does not apply to intrinsic call. Propagate the information that we are in an intrinsic call up to CheckExplicitDataArg (that is doing this check). Still enforce C846 on intrinsics other than MOVE_ALLOC (for which allocatable coarrays are explicitly allowed) since it's not clear it is allowed in all intrinsics and allowing this would lead to runtime penalties in the intrinsic runtime. Differential Revision: https://reviews.llvm.org/D89473
2020-10-20 18:39:26 +08:00
{{"date", DefaultChar, Rank::scalar, Optionality::optional,
common::Intent::Out},
{"time", DefaultChar, Rank::scalar, Optionality::optional,
common::Intent::Out},
{"zone", DefaultChar, Rank::scalar, Optionality::optional,
common::Intent::Out},
{"values", AnyInt, Rank::vector, Optionality::optional,
common::Intent::Out}},
[flang] New implementation for checks for constraints C741 through C750 Summary: Most of these checks were already implemented, and I just added references to them to the code and tests. Also, much of this code was already reviewed in the old flang/f18 GitHub repository, but I didn't get to merge it before we switched repositories. I implemented the check for C747 to not allow coarray components in derived types that are of type C_PTR, C_FUNPTR, or type TEAM_TYPE. I implemented the check for C748 that requires a data component whose type has a coarray ultimate component to be a nonpointer, nonallocatable scalar and not be a coarray. I implemented the check for C750 that adds additional restrictions to the bounds expressions of a derived type component that's an array. These bounds expressions are sepcification expressions as defined in 10.1.11. There was already code in lib/Evaluate/check-expression.cpp to check semantics for specification expressions, but it did not check for the extra requirements of C750. C750 prohibits specification functions, the intrinsic functions ALLOCATED, ASSOCIATED, EXTENDS_TYPE_OF, PRESENT, and SAME_TYPE_AS. It also requires every specification inquiry reference to be a constant expression, and requires that the value of the bound not depend on the value of a variable. To implement these additional checks, I added code to the intrinsic proc table to get the intrinsic class of a procedure. I also added an enumeration to distinguish between specification expressions for derived type component bounds versus for type parameters. I then changed the code to pass an enumeration value to "CheckSpecificationExpr()" to indicate that the expression was a bounds expression and used this value to determine whether to emit an error message when violations of C750 are found. I changed the implementation of IsPureProcedure() to handle statement functions and changed some references in the code that tested for the PURE attribute to call IsPureProcedure(). I also fixed some unrelated tests that got new errors when I implemented these new checks. Reviewers: tskeith, DavidTruby, sscalpone Subscribers: jfb, llvm-commits Tags: #llvm, #flang Differential Revision: https://reviews.llvm.org/D79263
2020-05-02 04:00:28 +08:00
{}, Rank::elemental, IntrinsicClass::impureSubroutine},
[flang] Update preprocessing document, commentary Extend documentation on preprocessing IsSimplyContiguous basic skeleton Apply suggested improvements to mod-file.cc Checks for new call13.f90 (15.4.2.2 explicit interfaces) Implement checking for procedures that can be called via an implicit interface Argument checking, test fixing Better argument checking Better derived type compatibility checking Treat externals as if implicitly interfaced Extend IEEE_EXCEPTIONS module so tests still pass with argument checking SAME_TYPE_AS and EXTENDS_TYPE_OF intrinsic inquiry functions Define interfaces for most intrinsic subroutines Better PASS arguments More with PASS() argument Prep for review address comments fix comment Remove formatted expression from specification expression error message per review more review comments Original-commit: flang-compiler/f18@3cca775da9302e3a2acec4a34800cd7666899b5f Reviewed-on: https://github.com/flang-compiler/f18/pull/776
2019-09-17 07:58:13 +08:00
{"execute_command_line",
{{"command", DefaultChar, Rank::scalar},
{"wait", AnyLogical, Rank::scalar, Optionality::optional},
[flang] Document and use intrinsic subroutine argument intents Check INTENT(OUT)/INTENT(INOUT) constraints for actual argument of intrinsic procedure calls. - Adding a common::Intent field to the IntrinsicDummyArgument in the intrinsic table. - Propagating it to the DummyDataObject intent field so that it can later be used in CheckExplicitDataArg semantic checks. - Add related tests. - Fix regression (C846 false error), C846 INTENT(OUT) rule does not apply to intrinsic call. Propagate the information that we are in an intrinsic call up to CheckExplicitDataArg (that is doing this check). Still enforce C846 on intrinsics other than MOVE_ALLOC (for which allocatable coarrays are explicitly allowed) since it's not clear it is allowed in all intrinsics and allowing this would lead to runtime penalties in the intrinsic runtime. Differential Revision: https://reviews.llvm.org/D89473
2020-10-20 18:39:26 +08:00
{"exitstat", AnyInt, Rank::scalar, Optionality::optional,
common::Intent::InOut},
{"cmdstat", AnyInt, Rank::scalar, Optionality::optional,
common::Intent::Out},
{"cmdmsg", DefaultChar, Rank::scalar, Optionality::optional,
common::Intent::InOut}},
[flang] New implementation for checks for constraints C741 through C750 Summary: Most of these checks were already implemented, and I just added references to them to the code and tests. Also, much of this code was already reviewed in the old flang/f18 GitHub repository, but I didn't get to merge it before we switched repositories. I implemented the check for C747 to not allow coarray components in derived types that are of type C_PTR, C_FUNPTR, or type TEAM_TYPE. I implemented the check for C748 that requires a data component whose type has a coarray ultimate component to be a nonpointer, nonallocatable scalar and not be a coarray. I implemented the check for C750 that adds additional restrictions to the bounds expressions of a derived type component that's an array. These bounds expressions are sepcification expressions as defined in 10.1.11. There was already code in lib/Evaluate/check-expression.cpp to check semantics for specification expressions, but it did not check for the extra requirements of C750. C750 prohibits specification functions, the intrinsic functions ALLOCATED, ASSOCIATED, EXTENDS_TYPE_OF, PRESENT, and SAME_TYPE_AS. It also requires every specification inquiry reference to be a constant expression, and requires that the value of the bound not depend on the value of a variable. To implement these additional checks, I added code to the intrinsic proc table to get the intrinsic class of a procedure. I also added an enumeration to distinguish between specification expressions for derived type component bounds versus for type parameters. I then changed the code to pass an enumeration value to "CheckSpecificationExpr()" to indicate that the expression was a bounds expression and used this value to determine whether to emit an error message when violations of C750 are found. I changed the implementation of IsPureProcedure() to handle statement functions and changed some references in the code that tested for the PURE attribute to call IsPureProcedure(). I also fixed some unrelated tests that got new errors when I implemented these new checks. Reviewers: tskeith, DavidTruby, sscalpone Subscribers: jfb, llvm-commits Tags: #llvm, #flang Differential Revision: https://reviews.llvm.org/D79263
2020-05-02 04:00:28 +08:00
{}, Rank::elemental, IntrinsicClass::impureSubroutine},
[flang] Update preprocessing document, commentary Extend documentation on preprocessing IsSimplyContiguous basic skeleton Apply suggested improvements to mod-file.cc Checks for new call13.f90 (15.4.2.2 explicit interfaces) Implement checking for procedures that can be called via an implicit interface Argument checking, test fixing Better argument checking Better derived type compatibility checking Treat externals as if implicitly interfaced Extend IEEE_EXCEPTIONS module so tests still pass with argument checking SAME_TYPE_AS and EXTENDS_TYPE_OF intrinsic inquiry functions Define interfaces for most intrinsic subroutines Better PASS arguments More with PASS() argument Prep for review address comments fix comment Remove formatted expression from specification expression error message per review more review comments Original-commit: flang-compiler/f18@3cca775da9302e3a2acec4a34800cd7666899b5f Reviewed-on: https://github.com/flang-compiler/f18/pull/776
2019-09-17 07:58:13 +08:00
{"get_command",
[flang] Document and use intrinsic subroutine argument intents Check INTENT(OUT)/INTENT(INOUT) constraints for actual argument of intrinsic procedure calls. - Adding a common::Intent field to the IntrinsicDummyArgument in the intrinsic table. - Propagating it to the DummyDataObject intent field so that it can later be used in CheckExplicitDataArg semantic checks. - Add related tests. - Fix regression (C846 false error), C846 INTENT(OUT) rule does not apply to intrinsic call. Propagate the information that we are in an intrinsic call up to CheckExplicitDataArg (that is doing this check). Still enforce C846 on intrinsics other than MOVE_ALLOC (for which allocatable coarrays are explicitly allowed) since it's not clear it is allowed in all intrinsics and allowing this would lead to runtime penalties in the intrinsic runtime. Differential Revision: https://reviews.llvm.org/D89473
2020-10-20 18:39:26 +08:00
{{"command", DefaultChar, Rank::scalar, Optionality::optional,
common::Intent::Out},
{"length", AnyInt, Rank::scalar, Optionality::optional,
common::Intent::Out},
{"status", AnyInt, Rank::scalar, Optionality::optional,
common::Intent::Out},
{"errmsg", DefaultChar, Rank::scalar, Optionality::optional,
common::Intent::InOut}},
[flang] New implementation for checks for constraints C741 through C750 Summary: Most of these checks were already implemented, and I just added references to them to the code and tests. Also, much of this code was already reviewed in the old flang/f18 GitHub repository, but I didn't get to merge it before we switched repositories. I implemented the check for C747 to not allow coarray components in derived types that are of type C_PTR, C_FUNPTR, or type TEAM_TYPE. I implemented the check for C748 that requires a data component whose type has a coarray ultimate component to be a nonpointer, nonallocatable scalar and not be a coarray. I implemented the check for C750 that adds additional restrictions to the bounds expressions of a derived type component that's an array. These bounds expressions are sepcification expressions as defined in 10.1.11. There was already code in lib/Evaluate/check-expression.cpp to check semantics for specification expressions, but it did not check for the extra requirements of C750. C750 prohibits specification functions, the intrinsic functions ALLOCATED, ASSOCIATED, EXTENDS_TYPE_OF, PRESENT, and SAME_TYPE_AS. It also requires every specification inquiry reference to be a constant expression, and requires that the value of the bound not depend on the value of a variable. To implement these additional checks, I added code to the intrinsic proc table to get the intrinsic class of a procedure. I also added an enumeration to distinguish between specification expressions for derived type component bounds versus for type parameters. I then changed the code to pass an enumeration value to "CheckSpecificationExpr()" to indicate that the expression was a bounds expression and used this value to determine whether to emit an error message when violations of C750 are found. I changed the implementation of IsPureProcedure() to handle statement functions and changed some references in the code that tested for the PURE attribute to call IsPureProcedure(). I also fixed some unrelated tests that got new errors when I implemented these new checks. Reviewers: tskeith, DavidTruby, sscalpone Subscribers: jfb, llvm-commits Tags: #llvm, #flang Differential Revision: https://reviews.llvm.org/D79263
2020-05-02 04:00:28 +08:00
{}, Rank::elemental, IntrinsicClass::impureSubroutine},
[flang] Update preprocessing document, commentary Extend documentation on preprocessing IsSimplyContiguous basic skeleton Apply suggested improvements to mod-file.cc Checks for new call13.f90 (15.4.2.2 explicit interfaces) Implement checking for procedures that can be called via an implicit interface Argument checking, test fixing Better argument checking Better derived type compatibility checking Treat externals as if implicitly interfaced Extend IEEE_EXCEPTIONS module so tests still pass with argument checking SAME_TYPE_AS and EXTENDS_TYPE_OF intrinsic inquiry functions Define interfaces for most intrinsic subroutines Better PASS arguments More with PASS() argument Prep for review address comments fix comment Remove formatted expression from specification expression error message per review more review comments Original-commit: flang-compiler/f18@3cca775da9302e3a2acec4a34800cd7666899b5f Reviewed-on: https://github.com/flang-compiler/f18/pull/776
2019-09-17 07:58:13 +08:00
{"get_command_argument",
{{"number", AnyInt, Rank::scalar},
[flang] Document and use intrinsic subroutine argument intents Check INTENT(OUT)/INTENT(INOUT) constraints for actual argument of intrinsic procedure calls. - Adding a common::Intent field to the IntrinsicDummyArgument in the intrinsic table. - Propagating it to the DummyDataObject intent field so that it can later be used in CheckExplicitDataArg semantic checks. - Add related tests. - Fix regression (C846 false error), C846 INTENT(OUT) rule does not apply to intrinsic call. Propagate the information that we are in an intrinsic call up to CheckExplicitDataArg (that is doing this check). Still enforce C846 on intrinsics other than MOVE_ALLOC (for which allocatable coarrays are explicitly allowed) since it's not clear it is allowed in all intrinsics and allowing this would lead to runtime penalties in the intrinsic runtime. Differential Revision: https://reviews.llvm.org/D89473
2020-10-20 18:39:26 +08:00
{"value", DefaultChar, Rank::scalar, Optionality::optional,
common::Intent::Out},
{"length", AnyInt, Rank::scalar, Optionality::optional,
common::Intent::Out},
{"status", AnyInt, Rank::scalar, Optionality::optional,
common::Intent::Out},
{"errmsg", DefaultChar, Rank::scalar, Optionality::optional,
common::Intent::InOut}},
[flang] New implementation for checks for constraints C741 through C750 Summary: Most of these checks were already implemented, and I just added references to them to the code and tests. Also, much of this code was already reviewed in the old flang/f18 GitHub repository, but I didn't get to merge it before we switched repositories. I implemented the check for C747 to not allow coarray components in derived types that are of type C_PTR, C_FUNPTR, or type TEAM_TYPE. I implemented the check for C748 that requires a data component whose type has a coarray ultimate component to be a nonpointer, nonallocatable scalar and not be a coarray. I implemented the check for C750 that adds additional restrictions to the bounds expressions of a derived type component that's an array. These bounds expressions are sepcification expressions as defined in 10.1.11. There was already code in lib/Evaluate/check-expression.cpp to check semantics for specification expressions, but it did not check for the extra requirements of C750. C750 prohibits specification functions, the intrinsic functions ALLOCATED, ASSOCIATED, EXTENDS_TYPE_OF, PRESENT, and SAME_TYPE_AS. It also requires every specification inquiry reference to be a constant expression, and requires that the value of the bound not depend on the value of a variable. To implement these additional checks, I added code to the intrinsic proc table to get the intrinsic class of a procedure. I also added an enumeration to distinguish between specification expressions for derived type component bounds versus for type parameters. I then changed the code to pass an enumeration value to "CheckSpecificationExpr()" to indicate that the expression was a bounds expression and used this value to determine whether to emit an error message when violations of C750 are found. I changed the implementation of IsPureProcedure() to handle statement functions and changed some references in the code that tested for the PURE attribute to call IsPureProcedure(). I also fixed some unrelated tests that got new errors when I implemented these new checks. Reviewers: tskeith, DavidTruby, sscalpone Subscribers: jfb, llvm-commits Tags: #llvm, #flang Differential Revision: https://reviews.llvm.org/D79263
2020-05-02 04:00:28 +08:00
{}, Rank::elemental, IntrinsicClass::impureSubroutine},
[flang] Update preprocessing document, commentary Extend documentation on preprocessing IsSimplyContiguous basic skeleton Apply suggested improvements to mod-file.cc Checks for new call13.f90 (15.4.2.2 explicit interfaces) Implement checking for procedures that can be called via an implicit interface Argument checking, test fixing Better argument checking Better derived type compatibility checking Treat externals as if implicitly interfaced Extend IEEE_EXCEPTIONS module so tests still pass with argument checking SAME_TYPE_AS and EXTENDS_TYPE_OF intrinsic inquiry functions Define interfaces for most intrinsic subroutines Better PASS arguments More with PASS() argument Prep for review address comments fix comment Remove formatted expression from specification expression error message per review more review comments Original-commit: flang-compiler/f18@3cca775da9302e3a2acec4a34800cd7666899b5f Reviewed-on: https://github.com/flang-compiler/f18/pull/776
2019-09-17 07:58:13 +08:00
{"get_environment_variable",
{{"name", DefaultChar, Rank::scalar},
[flang] Document and use intrinsic subroutine argument intents Check INTENT(OUT)/INTENT(INOUT) constraints for actual argument of intrinsic procedure calls. - Adding a common::Intent field to the IntrinsicDummyArgument in the intrinsic table. - Propagating it to the DummyDataObject intent field so that it can later be used in CheckExplicitDataArg semantic checks. - Add related tests. - Fix regression (C846 false error), C846 INTENT(OUT) rule does not apply to intrinsic call. Propagate the information that we are in an intrinsic call up to CheckExplicitDataArg (that is doing this check). Still enforce C846 on intrinsics other than MOVE_ALLOC (for which allocatable coarrays are explicitly allowed) since it's not clear it is allowed in all intrinsics and allowing this would lead to runtime penalties in the intrinsic runtime. Differential Revision: https://reviews.llvm.org/D89473
2020-10-20 18:39:26 +08:00
{"value", DefaultChar, Rank::scalar, Optionality::optional,
common::Intent::Out},
{"length", AnyInt, Rank::scalar, Optionality::optional,
common::Intent::Out},
{"status", AnyInt, Rank::scalar, Optionality::optional,
common::Intent::Out},
[flang] Update preprocessing document, commentary Extend documentation on preprocessing IsSimplyContiguous basic skeleton Apply suggested improvements to mod-file.cc Checks for new call13.f90 (15.4.2.2 explicit interfaces) Implement checking for procedures that can be called via an implicit interface Argument checking, test fixing Better argument checking Better derived type compatibility checking Treat externals as if implicitly interfaced Extend IEEE_EXCEPTIONS module so tests still pass with argument checking SAME_TYPE_AS and EXTENDS_TYPE_OF intrinsic inquiry functions Define interfaces for most intrinsic subroutines Better PASS arguments More with PASS() argument Prep for review address comments fix comment Remove formatted expression from specification expression error message per review more review comments Original-commit: flang-compiler/f18@3cca775da9302e3a2acec4a34800cd7666899b5f Reviewed-on: https://github.com/flang-compiler/f18/pull/776
2019-09-17 07:58:13 +08:00
{"trim_name", AnyLogical, Rank::scalar, Optionality::optional},
[flang] Document and use intrinsic subroutine argument intents Check INTENT(OUT)/INTENT(INOUT) constraints for actual argument of intrinsic procedure calls. - Adding a common::Intent field to the IntrinsicDummyArgument in the intrinsic table. - Propagating it to the DummyDataObject intent field so that it can later be used in CheckExplicitDataArg semantic checks. - Add related tests. - Fix regression (C846 false error), C846 INTENT(OUT) rule does not apply to intrinsic call. Propagate the information that we are in an intrinsic call up to CheckExplicitDataArg (that is doing this check). Still enforce C846 on intrinsics other than MOVE_ALLOC (for which allocatable coarrays are explicitly allowed) since it's not clear it is allowed in all intrinsics and allowing this would lead to runtime penalties in the intrinsic runtime. Differential Revision: https://reviews.llvm.org/D89473
2020-10-20 18:39:26 +08:00
{"errmsg", DefaultChar, Rank::scalar, Optionality::optional,
common::Intent::InOut}},
[flang] New implementation for checks for constraints C741 through C750 Summary: Most of these checks were already implemented, and I just added references to them to the code and tests. Also, much of this code was already reviewed in the old flang/f18 GitHub repository, but I didn't get to merge it before we switched repositories. I implemented the check for C747 to not allow coarray components in derived types that are of type C_PTR, C_FUNPTR, or type TEAM_TYPE. I implemented the check for C748 that requires a data component whose type has a coarray ultimate component to be a nonpointer, nonallocatable scalar and not be a coarray. I implemented the check for C750 that adds additional restrictions to the bounds expressions of a derived type component that's an array. These bounds expressions are sepcification expressions as defined in 10.1.11. There was already code in lib/Evaluate/check-expression.cpp to check semantics for specification expressions, but it did not check for the extra requirements of C750. C750 prohibits specification functions, the intrinsic functions ALLOCATED, ASSOCIATED, EXTENDS_TYPE_OF, PRESENT, and SAME_TYPE_AS. It also requires every specification inquiry reference to be a constant expression, and requires that the value of the bound not depend on the value of a variable. To implement these additional checks, I added code to the intrinsic proc table to get the intrinsic class of a procedure. I also added an enumeration to distinguish between specification expressions for derived type component bounds versus for type parameters. I then changed the code to pass an enumeration value to "CheckSpecificationExpr()" to indicate that the expression was a bounds expression and used this value to determine whether to emit an error message when violations of C750 are found. I changed the implementation of IsPureProcedure() to handle statement functions and changed some references in the code that tested for the PURE attribute to call IsPureProcedure(). I also fixed some unrelated tests that got new errors when I implemented these new checks. Reviewers: tskeith, DavidTruby, sscalpone Subscribers: jfb, llvm-commits Tags: #llvm, #flang Differential Revision: https://reviews.llvm.org/D79263
2020-05-02 04:00:28 +08:00
{}, Rank::elemental, IntrinsicClass::impureSubroutine},
[flang] Update preprocessing document, commentary Extend documentation on preprocessing IsSimplyContiguous basic skeleton Apply suggested improvements to mod-file.cc Checks for new call13.f90 (15.4.2.2 explicit interfaces) Implement checking for procedures that can be called via an implicit interface Argument checking, test fixing Better argument checking Better derived type compatibility checking Treat externals as if implicitly interfaced Extend IEEE_EXCEPTIONS module so tests still pass with argument checking SAME_TYPE_AS and EXTENDS_TYPE_OF intrinsic inquiry functions Define interfaces for most intrinsic subroutines Better PASS arguments More with PASS() argument Prep for review address comments fix comment Remove formatted expression from specification expression error message per review more review comments Original-commit: flang-compiler/f18@3cca775da9302e3a2acec4a34800cd7666899b5f Reviewed-on: https://github.com/flang-compiler/f18/pull/776
2019-09-17 07:58:13 +08:00
{"move_alloc",
[flang] Document and use intrinsic subroutine argument intents Check INTENT(OUT)/INTENT(INOUT) constraints for actual argument of intrinsic procedure calls. - Adding a common::Intent field to the IntrinsicDummyArgument in the intrinsic table. - Propagating it to the DummyDataObject intent field so that it can later be used in CheckExplicitDataArg semantic checks. - Add related tests. - Fix regression (C846 false error), C846 INTENT(OUT) rule does not apply to intrinsic call. Propagate the information that we are in an intrinsic call up to CheckExplicitDataArg (that is doing this check). Still enforce C846 on intrinsics other than MOVE_ALLOC (for which allocatable coarrays are explicitly allowed) since it's not clear it is allowed in all intrinsics and allowing this would lead to runtime penalties in the intrinsic runtime. Differential Revision: https://reviews.llvm.org/D89473
2020-10-20 18:39:26 +08:00
{{"from", SameType, Rank::known, Optionality::required,
common::Intent::InOut},
{"to", SameType, Rank::known, Optionality::required,
common::Intent::Out},
{"stat", AnyInt, Rank::scalar, Optionality::optional,
common::Intent::Out},
{"errmsg", DefaultChar, Rank::scalar, Optionality::optional,
common::Intent::InOut}},
[flang] New implementation for checks for constraints C741 through C750 Summary: Most of these checks were already implemented, and I just added references to them to the code and tests. Also, much of this code was already reviewed in the old flang/f18 GitHub repository, but I didn't get to merge it before we switched repositories. I implemented the check for C747 to not allow coarray components in derived types that are of type C_PTR, C_FUNPTR, or type TEAM_TYPE. I implemented the check for C748 that requires a data component whose type has a coarray ultimate component to be a nonpointer, nonallocatable scalar and not be a coarray. I implemented the check for C750 that adds additional restrictions to the bounds expressions of a derived type component that's an array. These bounds expressions are sepcification expressions as defined in 10.1.11. There was already code in lib/Evaluate/check-expression.cpp to check semantics for specification expressions, but it did not check for the extra requirements of C750. C750 prohibits specification functions, the intrinsic functions ALLOCATED, ASSOCIATED, EXTENDS_TYPE_OF, PRESENT, and SAME_TYPE_AS. It also requires every specification inquiry reference to be a constant expression, and requires that the value of the bound not depend on the value of a variable. To implement these additional checks, I added code to the intrinsic proc table to get the intrinsic class of a procedure. I also added an enumeration to distinguish between specification expressions for derived type component bounds versus for type parameters. I then changed the code to pass an enumeration value to "CheckSpecificationExpr()" to indicate that the expression was a bounds expression and used this value to determine whether to emit an error message when violations of C750 are found. I changed the implementation of IsPureProcedure() to handle statement functions and changed some references in the code that tested for the PURE attribute to call IsPureProcedure(). I also fixed some unrelated tests that got new errors when I implemented these new checks. Reviewers: tskeith, DavidTruby, sscalpone Subscribers: jfb, llvm-commits Tags: #llvm, #flang Differential Revision: https://reviews.llvm.org/D79263
2020-05-02 04:00:28 +08:00
{}, Rank::elemental, IntrinsicClass::pureSubroutine},
[flang] Update preprocessing document, commentary Extend documentation on preprocessing IsSimplyContiguous basic skeleton Apply suggested improvements to mod-file.cc Checks for new call13.f90 (15.4.2.2 explicit interfaces) Implement checking for procedures that can be called via an implicit interface Argument checking, test fixing Better argument checking Better derived type compatibility checking Treat externals as if implicitly interfaced Extend IEEE_EXCEPTIONS module so tests still pass with argument checking SAME_TYPE_AS and EXTENDS_TYPE_OF intrinsic inquiry functions Define interfaces for most intrinsic subroutines Better PASS arguments More with PASS() argument Prep for review address comments fix comment Remove formatted expression from specification expression error message per review more review comments Original-commit: flang-compiler/f18@3cca775da9302e3a2acec4a34800cd7666899b5f Reviewed-on: https://github.com/flang-compiler/f18/pull/776
2019-09-17 07:58:13 +08:00
{"mvbits",
{{"from", SameInt}, {"frompos", AnyInt}, {"len", AnyInt},
[flang] Document and use intrinsic subroutine argument intents Check INTENT(OUT)/INTENT(INOUT) constraints for actual argument of intrinsic procedure calls. - Adding a common::Intent field to the IntrinsicDummyArgument in the intrinsic table. - Propagating it to the DummyDataObject intent field so that it can later be used in CheckExplicitDataArg semantic checks. - Add related tests. - Fix regression (C846 false error), C846 INTENT(OUT) rule does not apply to intrinsic call. Propagate the information that we are in an intrinsic call up to CheckExplicitDataArg (that is doing this check). Still enforce C846 on intrinsics other than MOVE_ALLOC (for which allocatable coarrays are explicitly allowed) since it's not clear it is allowed in all intrinsics and allowing this would lead to runtime penalties in the intrinsic runtime. Differential Revision: https://reviews.llvm.org/D89473
2020-10-20 18:39:26 +08:00
{"to", SameInt, Rank::elemental, Optionality::required,
common::Intent::Out},
{"topos", AnyInt}},
[flang] New implementation for checks for constraints C741 through C750 Summary: Most of these checks were already implemented, and I just added references to them to the code and tests. Also, much of this code was already reviewed in the old flang/f18 GitHub repository, but I didn't get to merge it before we switched repositories. I implemented the check for C747 to not allow coarray components in derived types that are of type C_PTR, C_FUNPTR, or type TEAM_TYPE. I implemented the check for C748 that requires a data component whose type has a coarray ultimate component to be a nonpointer, nonallocatable scalar and not be a coarray. I implemented the check for C750 that adds additional restrictions to the bounds expressions of a derived type component that's an array. These bounds expressions are sepcification expressions as defined in 10.1.11. There was already code in lib/Evaluate/check-expression.cpp to check semantics for specification expressions, but it did not check for the extra requirements of C750. C750 prohibits specification functions, the intrinsic functions ALLOCATED, ASSOCIATED, EXTENDS_TYPE_OF, PRESENT, and SAME_TYPE_AS. It also requires every specification inquiry reference to be a constant expression, and requires that the value of the bound not depend on the value of a variable. To implement these additional checks, I added code to the intrinsic proc table to get the intrinsic class of a procedure. I also added an enumeration to distinguish between specification expressions for derived type component bounds versus for type parameters. I then changed the code to pass an enumeration value to "CheckSpecificationExpr()" to indicate that the expression was a bounds expression and used this value to determine whether to emit an error message when violations of C750 are found. I changed the implementation of IsPureProcedure() to handle statement functions and changed some references in the code that tested for the PURE attribute to call IsPureProcedure(). I also fixed some unrelated tests that got new errors when I implemented these new checks. Reviewers: tskeith, DavidTruby, sscalpone Subscribers: jfb, llvm-commits Tags: #llvm, #flang Differential Revision: https://reviews.llvm.org/D79263
2020-05-02 04:00:28 +08:00
{}, Rank::elemental, IntrinsicClass::elementalSubroutine}, // elemental
[flang] Update preprocessing document, commentary Extend documentation on preprocessing IsSimplyContiguous basic skeleton Apply suggested improvements to mod-file.cc Checks for new call13.f90 (15.4.2.2 explicit interfaces) Implement checking for procedures that can be called via an implicit interface Argument checking, test fixing Better argument checking Better derived type compatibility checking Treat externals as if implicitly interfaced Extend IEEE_EXCEPTIONS module so tests still pass with argument checking SAME_TYPE_AS and EXTENDS_TYPE_OF intrinsic inquiry functions Define interfaces for most intrinsic subroutines Better PASS arguments More with PASS() argument Prep for review address comments fix comment Remove formatted expression from specification expression error message per review more review comments Original-commit: flang-compiler/f18@3cca775da9302e3a2acec4a34800cd7666899b5f Reviewed-on: https://github.com/flang-compiler/f18/pull/776
2019-09-17 07:58:13 +08:00
{"random_init",
{{"repeatable", AnyLogical, Rank::scalar},
{"image_distinct", AnyLogical, Rank::scalar}},
[flang] New implementation for checks for constraints C741 through C750 Summary: Most of these checks were already implemented, and I just added references to them to the code and tests. Also, much of this code was already reviewed in the old flang/f18 GitHub repository, but I didn't get to merge it before we switched repositories. I implemented the check for C747 to not allow coarray components in derived types that are of type C_PTR, C_FUNPTR, or type TEAM_TYPE. I implemented the check for C748 that requires a data component whose type has a coarray ultimate component to be a nonpointer, nonallocatable scalar and not be a coarray. I implemented the check for C750 that adds additional restrictions to the bounds expressions of a derived type component that's an array. These bounds expressions are sepcification expressions as defined in 10.1.11. There was already code in lib/Evaluate/check-expression.cpp to check semantics for specification expressions, but it did not check for the extra requirements of C750. C750 prohibits specification functions, the intrinsic functions ALLOCATED, ASSOCIATED, EXTENDS_TYPE_OF, PRESENT, and SAME_TYPE_AS. It also requires every specification inquiry reference to be a constant expression, and requires that the value of the bound not depend on the value of a variable. To implement these additional checks, I added code to the intrinsic proc table to get the intrinsic class of a procedure. I also added an enumeration to distinguish between specification expressions for derived type component bounds versus for type parameters. I then changed the code to pass an enumeration value to "CheckSpecificationExpr()" to indicate that the expression was a bounds expression and used this value to determine whether to emit an error message when violations of C750 are found. I changed the implementation of IsPureProcedure() to handle statement functions and changed some references in the code that tested for the PURE attribute to call IsPureProcedure(). I also fixed some unrelated tests that got new errors when I implemented these new checks. Reviewers: tskeith, DavidTruby, sscalpone Subscribers: jfb, llvm-commits Tags: #llvm, #flang Differential Revision: https://reviews.llvm.org/D79263
2020-05-02 04:00:28 +08:00
{}, Rank::elemental, IntrinsicClass::impureSubroutine},
[flang] Document and use intrinsic subroutine argument intents Check INTENT(OUT)/INTENT(INOUT) constraints for actual argument of intrinsic procedure calls. - Adding a common::Intent field to the IntrinsicDummyArgument in the intrinsic table. - Propagating it to the DummyDataObject intent field so that it can later be used in CheckExplicitDataArg semantic checks. - Add related tests. - Fix regression (C846 false error), C846 INTENT(OUT) rule does not apply to intrinsic call. Propagate the information that we are in an intrinsic call up to CheckExplicitDataArg (that is doing this check). Still enforce C846 on intrinsics other than MOVE_ALLOC (for which allocatable coarrays are explicitly allowed) since it's not clear it is allowed in all intrinsics and allowing this would lead to runtime penalties in the intrinsic runtime. Differential Revision: https://reviews.llvm.org/D89473
2020-10-20 18:39:26 +08:00
{"random_number",
{{"harvest", AnyReal, Rank::known, Optionality::required,
common::Intent::Out}},
{}, Rank::elemental, IntrinsicClass::impureSubroutine},
[flang] Update preprocessing document, commentary Extend documentation on preprocessing IsSimplyContiguous basic skeleton Apply suggested improvements to mod-file.cc Checks for new call13.f90 (15.4.2.2 explicit interfaces) Implement checking for procedures that can be called via an implicit interface Argument checking, test fixing Better argument checking Better derived type compatibility checking Treat externals as if implicitly interfaced Extend IEEE_EXCEPTIONS module so tests still pass with argument checking SAME_TYPE_AS and EXTENDS_TYPE_OF intrinsic inquiry functions Define interfaces for most intrinsic subroutines Better PASS arguments More with PASS() argument Prep for review address comments fix comment Remove formatted expression from specification expression error message per review more review comments Original-commit: flang-compiler/f18@3cca775da9302e3a2acec4a34800cd7666899b5f Reviewed-on: https://github.com/flang-compiler/f18/pull/776
2019-09-17 07:58:13 +08:00
{"random_seed",
[flang] Document and use intrinsic subroutine argument intents Check INTENT(OUT)/INTENT(INOUT) constraints for actual argument of intrinsic procedure calls. - Adding a common::Intent field to the IntrinsicDummyArgument in the intrinsic table. - Propagating it to the DummyDataObject intent field so that it can later be used in CheckExplicitDataArg semantic checks. - Add related tests. - Fix regression (C846 false error), C846 INTENT(OUT) rule does not apply to intrinsic call. Propagate the information that we are in an intrinsic call up to CheckExplicitDataArg (that is doing this check). Still enforce C846 on intrinsics other than MOVE_ALLOC (for which allocatable coarrays are explicitly allowed) since it's not clear it is allowed in all intrinsics and allowing this would lead to runtime penalties in the intrinsic runtime. Differential Revision: https://reviews.llvm.org/D89473
2020-10-20 18:39:26 +08:00
{{"size", DefaultInt, Rank::scalar, Optionality::optional,
common::Intent::Out},
[flang] Update preprocessing document, commentary Extend documentation on preprocessing IsSimplyContiguous basic skeleton Apply suggested improvements to mod-file.cc Checks for new call13.f90 (15.4.2.2 explicit interfaces) Implement checking for procedures that can be called via an implicit interface Argument checking, test fixing Better argument checking Better derived type compatibility checking Treat externals as if implicitly interfaced Extend IEEE_EXCEPTIONS module so tests still pass with argument checking SAME_TYPE_AS and EXTENDS_TYPE_OF intrinsic inquiry functions Define interfaces for most intrinsic subroutines Better PASS arguments More with PASS() argument Prep for review address comments fix comment Remove formatted expression from specification expression error message per review more review comments Original-commit: flang-compiler/f18@3cca775da9302e3a2acec4a34800cd7666899b5f Reviewed-on: https://github.com/flang-compiler/f18/pull/776
2019-09-17 07:58:13 +08:00
{"put", DefaultInt, Rank::vector, Optionality::optional},
[flang] Document and use intrinsic subroutine argument intents Check INTENT(OUT)/INTENT(INOUT) constraints for actual argument of intrinsic procedure calls. - Adding a common::Intent field to the IntrinsicDummyArgument in the intrinsic table. - Propagating it to the DummyDataObject intent field so that it can later be used in CheckExplicitDataArg semantic checks. - Add related tests. - Fix regression (C846 false error), C846 INTENT(OUT) rule does not apply to intrinsic call. Propagate the information that we are in an intrinsic call up to CheckExplicitDataArg (that is doing this check). Still enforce C846 on intrinsics other than MOVE_ALLOC (for which allocatable coarrays are explicitly allowed) since it's not clear it is allowed in all intrinsics and allowing this would lead to runtime penalties in the intrinsic runtime. Differential Revision: https://reviews.llvm.org/D89473
2020-10-20 18:39:26 +08:00
{"get", DefaultInt, Rank::vector, Optionality::optional,
common::Intent::Out}},
[flang] New implementation for checks for constraints C741 through C750 Summary: Most of these checks were already implemented, and I just added references to them to the code and tests. Also, much of this code was already reviewed in the old flang/f18 GitHub repository, but I didn't get to merge it before we switched repositories. I implemented the check for C747 to not allow coarray components in derived types that are of type C_PTR, C_FUNPTR, or type TEAM_TYPE. I implemented the check for C748 that requires a data component whose type has a coarray ultimate component to be a nonpointer, nonallocatable scalar and not be a coarray. I implemented the check for C750 that adds additional restrictions to the bounds expressions of a derived type component that's an array. These bounds expressions are sepcification expressions as defined in 10.1.11. There was already code in lib/Evaluate/check-expression.cpp to check semantics for specification expressions, but it did not check for the extra requirements of C750. C750 prohibits specification functions, the intrinsic functions ALLOCATED, ASSOCIATED, EXTENDS_TYPE_OF, PRESENT, and SAME_TYPE_AS. It also requires every specification inquiry reference to be a constant expression, and requires that the value of the bound not depend on the value of a variable. To implement these additional checks, I added code to the intrinsic proc table to get the intrinsic class of a procedure. I also added an enumeration to distinguish between specification expressions for derived type component bounds versus for type parameters. I then changed the code to pass an enumeration value to "CheckSpecificationExpr()" to indicate that the expression was a bounds expression and used this value to determine whether to emit an error message when violations of C750 are found. I changed the implementation of IsPureProcedure() to handle statement functions and changed some references in the code that tested for the PURE attribute to call IsPureProcedure(). I also fixed some unrelated tests that got new errors when I implemented these new checks. Reviewers: tskeith, DavidTruby, sscalpone Subscribers: jfb, llvm-commits Tags: #llvm, #flang Differential Revision: https://reviews.llvm.org/D79263
2020-05-02 04:00:28 +08:00
{}, Rank::elemental,
IntrinsicClass::impureSubroutine}, // TODO: at most one argument can be
// present
[flang] Update preprocessing document, commentary Extend documentation on preprocessing IsSimplyContiguous basic skeleton Apply suggested improvements to mod-file.cc Checks for new call13.f90 (15.4.2.2 explicit interfaces) Implement checking for procedures that can be called via an implicit interface Argument checking, test fixing Better argument checking Better derived type compatibility checking Treat externals as if implicitly interfaced Extend IEEE_EXCEPTIONS module so tests still pass with argument checking SAME_TYPE_AS and EXTENDS_TYPE_OF intrinsic inquiry functions Define interfaces for most intrinsic subroutines Better PASS arguments More with PASS() argument Prep for review address comments fix comment Remove formatted expression from specification expression error message per review more review comments Original-commit: flang-compiler/f18@3cca775da9302e3a2acec4a34800cd7666899b5f Reviewed-on: https://github.com/flang-compiler/f18/pull/776
2019-09-17 07:58:13 +08:00
{"system_clock",
[flang] Document and use intrinsic subroutine argument intents Check INTENT(OUT)/INTENT(INOUT) constraints for actual argument of intrinsic procedure calls. - Adding a common::Intent field to the IntrinsicDummyArgument in the intrinsic table. - Propagating it to the DummyDataObject intent field so that it can later be used in CheckExplicitDataArg semantic checks. - Add related tests. - Fix regression (C846 false error), C846 INTENT(OUT) rule does not apply to intrinsic call. Propagate the information that we are in an intrinsic call up to CheckExplicitDataArg (that is doing this check). Still enforce C846 on intrinsics other than MOVE_ALLOC (for which allocatable coarrays are explicitly allowed) since it's not clear it is allowed in all intrinsics and allowing this would lead to runtime penalties in the intrinsic runtime. Differential Revision: https://reviews.llvm.org/D89473
2020-10-20 18:39:26 +08:00
{{"count", AnyInt, Rank::scalar, Optionality::optional,
common::Intent::Out},
{"count_rate", AnyIntOrReal, Rank::scalar, Optionality::optional,
common::Intent::Out},
{"count_max", AnyInt, Rank::scalar, Optionality::optional,
common::Intent::Out}},
[flang] New implementation for checks for constraints C741 through C750 Summary: Most of these checks were already implemented, and I just added references to them to the code and tests. Also, much of this code was already reviewed in the old flang/f18 GitHub repository, but I didn't get to merge it before we switched repositories. I implemented the check for C747 to not allow coarray components in derived types that are of type C_PTR, C_FUNPTR, or type TEAM_TYPE. I implemented the check for C748 that requires a data component whose type has a coarray ultimate component to be a nonpointer, nonallocatable scalar and not be a coarray. I implemented the check for C750 that adds additional restrictions to the bounds expressions of a derived type component that's an array. These bounds expressions are sepcification expressions as defined in 10.1.11. There was already code in lib/Evaluate/check-expression.cpp to check semantics for specification expressions, but it did not check for the extra requirements of C750. C750 prohibits specification functions, the intrinsic functions ALLOCATED, ASSOCIATED, EXTENDS_TYPE_OF, PRESENT, and SAME_TYPE_AS. It also requires every specification inquiry reference to be a constant expression, and requires that the value of the bound not depend on the value of a variable. To implement these additional checks, I added code to the intrinsic proc table to get the intrinsic class of a procedure. I also added an enumeration to distinguish between specification expressions for derived type component bounds versus for type parameters. I then changed the code to pass an enumeration value to "CheckSpecificationExpr()" to indicate that the expression was a bounds expression and used this value to determine whether to emit an error message when violations of C750 are found. I changed the implementation of IsPureProcedure() to handle statement functions and changed some references in the code that tested for the PURE attribute to call IsPureProcedure(). I also fixed some unrelated tests that got new errors when I implemented these new checks. Reviewers: tskeith, DavidTruby, sscalpone Subscribers: jfb, llvm-commits Tags: #llvm, #flang Differential Revision: https://reviews.llvm.org/D79263
2020-05-02 04:00:28 +08:00
{}, Rank::elemental, IntrinsicClass::impureSubroutine},
[flang] Update preprocessing document, commentary Extend documentation on preprocessing IsSimplyContiguous basic skeleton Apply suggested improvements to mod-file.cc Checks for new call13.f90 (15.4.2.2 explicit interfaces) Implement checking for procedures that can be called via an implicit interface Argument checking, test fixing Better argument checking Better derived type compatibility checking Treat externals as if implicitly interfaced Extend IEEE_EXCEPTIONS module so tests still pass with argument checking SAME_TYPE_AS and EXTENDS_TYPE_OF intrinsic inquiry functions Define interfaces for most intrinsic subroutines Better PASS arguments More with PASS() argument Prep for review address comments fix comment Remove formatted expression from specification expression error message per review more review comments Original-commit: flang-compiler/f18@3cca775da9302e3a2acec4a34800cd7666899b5f Reviewed-on: https://github.com/flang-compiler/f18/pull/776
2019-09-17 07:58:13 +08:00
};
// TODO: Intrinsic subroutine EVENT_QUERY
[flang] finish most intrinsic table entries Original-commit: flang-compiler/f18@134bd885af5c67ae7fc2291778397546a3d1c189 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-12 05:51:14 +08:00
// TODO: Atomic intrinsic subroutines: ATOMIC_ADD &al.
// TODO: Collective intrinsic subroutines: CO_BROADCAST &al.
[flang] initial intrinsics table Original-commit: flang-compiler/f18@8b5c3adf887cf88752937a4fa5507c0d66051d3b Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-09-29 08:02:11 +08:00
[flang] intrinsic pattern matching Original-commit: flang-compiler/f18@ca0ee1660a6449c34c7276284e5e63b90ae97540 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-05 04:43:33 +08:00
// Intrinsic interface matching against the arguments of a particular
// procedure reference.
[flang] refactor a bit, and rearrange actual arguments into dummy order on intrinsic calls Original-commit: flang-compiler/f18@1f50ace68b00a7db4b75ebce5616032501e48457 Reviewed-on: https://github.com/flang-compiler/f18/pull/219 Tree-same-pre-rewrite: false
2018-10-18 06:09:48 +08:00
std::optional<SpecificCall> IntrinsicInterface::Match(
[flang] Extract IntrinsicTypeDefaultKinds, move it into semantics Original-commit: flang-compiler/f18@dd819b4727219010b30dcfc63e2bf0a894a0a7c9 Reviewed-on: https://github.com/flang-compiler/f18/pull/213 Tree-same-pre-rewrite: false
2018-10-16 06:28:47 +08:00
const CallCharacteristics &call,
[flang] Move default intrinsic type kinds from lib/semantics to lib/common Original-commit: flang-compiler/f18@887e72dd613f411808d1b9e9e7b64601a3b67af8 Reviewed-on: https://github.com/flang-compiler/f18/pull/265 Tree-same-pre-rewrite: false
2019-01-19 04:40:47 +08:00
const common::IntrinsicTypeDefaultKinds &defaults,
[flang] Fold array operations Original-commit: flang-compiler/f18@e6c86ecfd10b77aeac63722c08487ae5de0a0c27 Reviewed-on: https://github.com/flang-compiler/f18/pull/420
2019-04-19 05:11:15 +08:00
ActualArguments &arguments, FoldingContext &context) const {
auto &messages{context.messages()};
[flang] intrinsic pattern matching Original-commit: flang-compiler/f18@ca0ee1660a6449c34c7276284e5e63b90ae97540 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-05 04:43:33 +08:00
// Attempt to construct a 1-1 correspondence between the dummy arguments in
// a particular intrinsic procedure's generic interface and the actual
// arguments in a procedure reference.
[flang] rearrange arguments into dummy argument order Original-commit: flang-compiler/f18@3bab0f55de1b66d38bd15a841459c3a36cf29d30 Reviewed-on: https://github.com/flang-compiler/f18/pull/219 Tree-same-pre-rewrite: false
2018-10-19 01:50:55 +08:00
std::size_t dummyArgPatterns{0};
[flang] Remove most comparisons to nullptr Remove needless usage of has_value() Original-commit: flang-compiler/f18@1da7fcf7a54066b18e521620ecedb79c7cd2eb97 Reviewed-on: https://github.com/flang-compiler/f18/pull/822
2019-11-10 01:29:31 +08:00
for (; dummyArgPatterns < maxArguments && dummy[dummyArgPatterns].keyword;
[flang] rearrange arguments into dummy argument order Original-commit: flang-compiler/f18@3bab0f55de1b66d38bd15a841459c3a36cf29d30 Reviewed-on: https://github.com/flang-compiler/f18/pull/219 Tree-same-pre-rewrite: false
2018-10-19 01:50:55 +08:00
++dummyArgPatterns) {
[flang] intrinsic pattern matching Original-commit: flang-compiler/f18@ca0ee1660a6449c34c7276284e5e63b90ae97540 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-05 04:43:33 +08:00
}
[flang] rearrange arguments into dummy argument order Original-commit: flang-compiler/f18@3bab0f55de1b66d38bd15a841459c3a36cf29d30 Reviewed-on: https://github.com/flang-compiler/f18/pull/219 Tree-same-pre-rewrite: false
2018-10-19 01:50:55 +08:00
// MAX and MIN (and others that map to them) allow their last argument to
// be repeated indefinitely. The actualForDummy vector is sized
// and null-initialized to the non-repeated dummy argument count,
// but additional actual argument pointers can be pushed on it
// when this flag is set.
bool repeatLastDummy{dummyArgPatterns > 0 &&
dummy[dummyArgPatterns - 1].optionality == Optionality::repeats};
[flang] Implement MIN and MAX folding * Use Extremum<T> FoldOperation to fold MIN and MAX * Fix Extremum<T> FolOperation * For character, the length is the one of the longest argument. Define and use `CharacterUtils<Kind>::Resize` helper to do this. * For array of all types, Extremum<T> with Ordering::Less was behaving like Ordering::Greater. This is because the default `ApplyElementwise` for `Operation` was selected and it then called the Extremum<T> constructor without the ordering argument (which was an optional defaulted to Greater). Define a specific handler for Extremum<T> and make the ordering argument mandatory to prevent this kind of bug to pass f18 compilation in the futur. * Fix intrinsic.cc for MIN and MAX * When provided with two arguments, `Match` was adding an empty 3rd optional actual argument. Later code working on min and max was not expecting this and failing. The fix prevent this empty argument to be created by changing the initial size of `actualForDummy` to actually be the number of dummies that do not have `Optionality::Repeats` This commit fixes issue flang-compiler/f18#677. Original-commit: flang-compiler/f18@acb62f240b55d866797b9917f5a45dcd5ecc23e8 Reviewed-on: https://github.com/flang-compiler/f18/pull/803
2019-10-31 23:03:16 +08:00
std::size_t nonRepeatedDummies{
repeatLastDummy ? dummyArgPatterns - 1 : dummyArgPatterns};
std::vector<ActualArgument *> actualForDummy(nonRepeatedDummies, nullptr);
[flang] rearrange arguments into dummy argument order Original-commit: flang-compiler/f18@3bab0f55de1b66d38bd15a841459c3a36cf29d30 Reviewed-on: https://github.com/flang-compiler/f18/pull/219 Tree-same-pre-rewrite: false
2018-10-19 01:50:55 +08:00
int missingActualArguments{0};
[flang] refactor a bit, and rearrange actual arguments into dummy order on intrinsic calls Original-commit: flang-compiler/f18@1f50ace68b00a7db4b75ebce5616032501e48457 Reviewed-on: https://github.com/flang-compiler/f18/pull/219 Tree-same-pre-rewrite: false
2018-10-18 06:09:48 +08:00
for (std::optional<ActualArgument> &arg : arguments) {
[flang] Remove most comparisons to nullptr Remove needless usage of has_value() Original-commit: flang-compiler/f18@1da7fcf7a54066b18e521620ecedb79c7cd2eb97 Reviewed-on: https://github.com/flang-compiler/f18/pull/822
2019-11-10 01:29:31 +08:00
if (!arg) {
[flang] rearrange arguments into dummy argument order Original-commit: flang-compiler/f18@3bab0f55de1b66d38bd15a841459c3a36cf29d30 Reviewed-on: https://github.com/flang-compiler/f18/pull/219 Tree-same-pre-rewrite: false
2018-10-19 01:50:55 +08:00
++missingActualArguments;
} else {
[flang] Fix problems with passed-object arguments by deferring the identification of their index in the dummy argument list, simplifying their representation, completing the representation of their actual arguments, and (while I'm here) resolving calls to type-bound procedures whose bindings are known at compilation time. Button up class ActualArgument by making remaining data members private and adding accessors & mutators. Original-commit: flang-compiler/f18@5eb60ec41912b0963e41bbc1a3141164efcb7fbf Reviewed-on: https://github.com/flang-compiler/f18/pull/855
2019-12-06 02:24:18 +08:00
if (arg->isAlternateReturn()) {
[flang] refactor a bit, and rearrange actual arguments into dummy order on intrinsic calls Original-commit: flang-compiler/f18@1f50ace68b00a7db4b75ebce5616032501e48457 Reviewed-on: https://github.com/flang-compiler/f18/pull/219 Tree-same-pre-rewrite: false
2018-10-18 06:09:48 +08:00
messages.Say(
"alternate return specifier not acceptable on call to intrinsic '%s'"_err_en_US,
name);
return std::nullopt;
}
bool found{false};
[flang] rearrange arguments into dummy argument order Original-commit: flang-compiler/f18@3bab0f55de1b66d38bd15a841459c3a36cf29d30 Reviewed-on: https://github.com/flang-compiler/f18/pull/219 Tree-same-pre-rewrite: false
2018-10-19 01:50:55 +08:00
int slot{missingActualArguments};
[flang] Implement MIN and MAX folding * Use Extremum<T> FoldOperation to fold MIN and MAX * Fix Extremum<T> FolOperation * For character, the length is the one of the longest argument. Define and use `CharacterUtils<Kind>::Resize` helper to do this. * For array of all types, Extremum<T> with Ordering::Less was behaving like Ordering::Greater. This is because the default `ApplyElementwise` for `Operation` was selected and it then called the Extremum<T> constructor without the ordering argument (which was an optional defaulted to Greater). Define a specific handler for Extremum<T> and make the ordering argument mandatory to prevent this kind of bug to pass f18 compilation in the futur. * Fix intrinsic.cc for MIN and MAX * When provided with two arguments, `Match` was adding an empty 3rd optional actual argument. Later code working on min and max was not expecting this and failing. The fix prevent this empty argument to be created by changing the initial size of `actualForDummy` to actually be the number of dummies that do not have `Optionality::Repeats` This commit fixes issue flang-compiler/f18#677. Original-commit: flang-compiler/f18@acb62f240b55d866797b9917f5a45dcd5ecc23e8 Reviewed-on: https://github.com/flang-compiler/f18/pull/803
2019-10-31 23:03:16 +08:00
for (std::size_t j{0}; j < nonRepeatedDummies && !found; ++j) {
[flang] Correct shape analysis for transformational intrinsic functions Correct the analysis of references to transformational intrinsic functions that have different semantics based on the presence or absence of a DIM= argument; add shape analysis for UNPACK(). Differential Revision: https://reviews.llvm.org/D94716
2021-01-15 04:54:31 +08:00
if (dummy[j].optionality == Optionality::missing) {
continue;
}
[flang] Fix problems with passed-object arguments by deferring the identification of their index in the dummy argument list, simplifying their representation, completing the representation of their actual arguments, and (while I'm here) resolving calls to type-bound procedures whose bindings are known at compilation time. Button up class ActualArgument by making remaining data members private and adding accessors & mutators. Original-commit: flang-compiler/f18@5eb60ec41912b0963e41bbc1a3141164efcb7fbf Reviewed-on: https://github.com/flang-compiler/f18/pull/855
2019-12-06 02:24:18 +08:00
if (arg->keyword()) {
found = *arg->keyword() == dummy[j].keyword;
[flang] rearrange arguments into dummy argument order Original-commit: flang-compiler/f18@3bab0f55de1b66d38bd15a841459c3a36cf29d30 Reviewed-on: https://github.com/flang-compiler/f18/pull/219 Tree-same-pre-rewrite: false
2018-10-19 01:50:55 +08:00
if (found) {
if (const auto *previous{actualForDummy[j]}) {
[flang] Fix problems with passed-object arguments by deferring the identification of their index in the dummy argument list, simplifying their representation, completing the representation of their actual arguments, and (while I'm here) resolving calls to type-bound procedures whose bindings are known at compilation time. Button up class ActualArgument by making remaining data members private and adding accessors & mutators. Original-commit: flang-compiler/f18@5eb60ec41912b0963e41bbc1a3141164efcb7fbf Reviewed-on: https://github.com/flang-compiler/f18/pull/855
2019-12-06 02:24:18 +08:00
if (previous->keyword()) {
messages.Say(*arg->keyword(),
[flang] rearrange arguments into dummy argument order Original-commit: flang-compiler/f18@3bab0f55de1b66d38bd15a841459c3a36cf29d30 Reviewed-on: https://github.com/flang-compiler/f18/pull/219 Tree-same-pre-rewrite: false
2018-10-19 01:50:55 +08:00
"repeated keyword argument to intrinsic '%s'"_err_en_US,
name);
} else {
[flang] Fix problems with passed-object arguments by deferring the identification of their index in the dummy argument list, simplifying their representation, completing the representation of their actual arguments, and (while I'm here) resolving calls to type-bound procedures whose bindings are known at compilation time. Button up class ActualArgument by making remaining data members private and adding accessors & mutators. Original-commit: flang-compiler/f18@5eb60ec41912b0963e41bbc1a3141164efcb7fbf Reviewed-on: https://github.com/flang-compiler/f18/pull/855
2019-12-06 02:24:18 +08:00
messages.Say(*arg->keyword(),
[flang] rearrange arguments into dummy argument order Original-commit: flang-compiler/f18@3bab0f55de1b66d38bd15a841459c3a36cf29d30 Reviewed-on: https://github.com/flang-compiler/f18/pull/219 Tree-same-pre-rewrite: false
2018-10-19 01:50:55 +08:00
"keyword argument to intrinsic '%s' was supplied "
"positionally by an earlier actual argument"_err_en_US,
name);
}
return std::nullopt;
}
[flang] refactor a bit, and rearrange actual arguments into dummy order on intrinsic calls Original-commit: flang-compiler/f18@1f50ace68b00a7db4b75ebce5616032501e48457 Reviewed-on: https://github.com/flang-compiler/f18/pull/219 Tree-same-pre-rewrite: false
2018-10-18 06:09:48 +08:00
}
[flang] rearrange arguments into dummy argument order Original-commit: flang-compiler/f18@3bab0f55de1b66d38bd15a841459c3a36cf29d30 Reviewed-on: https://github.com/flang-compiler/f18/pull/219 Tree-same-pre-rewrite: false
2018-10-19 01:50:55 +08:00
} else {
[flang] Remove most comparisons to nullptr Remove needless usage of has_value() Original-commit: flang-compiler/f18@1da7fcf7a54066b18e521620ecedb79c7cd2eb97 Reviewed-on: https://github.com/flang-compiler/f18/pull/822
2019-11-10 01:29:31 +08:00
found = !actualForDummy[j] && slot-- == 0;
[flang] rearrange arguments into dummy argument order Original-commit: flang-compiler/f18@3bab0f55de1b66d38bd15a841459c3a36cf29d30 Reviewed-on: https://github.com/flang-compiler/f18/pull/219 Tree-same-pre-rewrite: false
2018-10-19 01:50:55 +08:00
}
if (found) {
actualForDummy[j] = &*arg;
[flang] intrinsic pattern matching Original-commit: flang-compiler/f18@ca0ee1660a6449c34c7276284e5e63b90ae97540 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-05 04:43:33 +08:00
}
}
[flang] refactor a bit, and rearrange actual arguments into dummy order on intrinsic calls Original-commit: flang-compiler/f18@1f50ace68b00a7db4b75ebce5616032501e48457 Reviewed-on: https://github.com/flang-compiler/f18/pull/219 Tree-same-pre-rewrite: false
2018-10-18 06:09:48 +08:00
if (!found) {
[flang] Fix problems with passed-object arguments by deferring the identification of their index in the dummy argument list, simplifying their representation, completing the representation of their actual arguments, and (while I'm here) resolving calls to type-bound procedures whose bindings are known at compilation time. Button up class ActualArgument by making remaining data members private and adding accessors & mutators. Original-commit: flang-compiler/f18@5eb60ec41912b0963e41bbc1a3141164efcb7fbf Reviewed-on: https://github.com/flang-compiler/f18/pull/855
2019-12-06 02:24:18 +08:00
if (repeatLastDummy && !arg->keyword()) {
[flang] rearrange arguments into dummy argument order Original-commit: flang-compiler/f18@3bab0f55de1b66d38bd15a841459c3a36cf29d30 Reviewed-on: https://github.com/flang-compiler/f18/pull/219 Tree-same-pre-rewrite: false
2018-10-19 01:50:55 +08:00
// MAX/MIN argument after the 2nd
actualForDummy.push_back(&*arg);
[flang] refactor a bit, and rearrange actual arguments into dummy order on intrinsic calls Original-commit: flang-compiler/f18@1f50ace68b00a7db4b75ebce5616032501e48457 Reviewed-on: https://github.com/flang-compiler/f18/pull/219 Tree-same-pre-rewrite: false
2018-10-18 06:09:48 +08:00
} else {
[flang] Fix problems with passed-object arguments by deferring the identification of their index in the dummy argument list, simplifying their representation, completing the representation of their actual arguments, and (while I'm here) resolving calls to type-bound procedures whose bindings are known at compilation time. Button up class ActualArgument by making remaining data members private and adding accessors & mutators. Original-commit: flang-compiler/f18@5eb60ec41912b0963e41bbc1a3141164efcb7fbf Reviewed-on: https://github.com/flang-compiler/f18/pull/855
2019-12-06 02:24:18 +08:00
if (arg->keyword()) {
messages.Say(*arg->keyword(),
[flang] rearrange arguments into dummy argument order Original-commit: flang-compiler/f18@3bab0f55de1b66d38bd15a841459c3a36cf29d30 Reviewed-on: https://github.com/flang-compiler/f18/pull/219 Tree-same-pre-rewrite: false
2018-10-19 01:50:55 +08:00
"unknown keyword argument to intrinsic '%s'"_err_en_US, name);
} else {
messages.Say(
"too many actual arguments for intrinsic '%s'"_err_en_US, name);
}
return std::nullopt;
[flang] refactor a bit, and rearrange actual arguments into dummy order on intrinsic calls Original-commit: flang-compiler/f18@1f50ace68b00a7db4b75ebce5616032501e48457 Reviewed-on: https://github.com/flang-compiler/f18/pull/219 Tree-same-pre-rewrite: false
2018-10-18 06:09:48 +08:00
}
[flang] intrinsic pattern matching Original-commit: flang-compiler/f18@ca0ee1660a6449c34c7276284e5e63b90ae97540 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-05 04:43:33 +08:00
}
}
}
[flang] rearrange arguments into dummy argument order Original-commit: flang-compiler/f18@3bab0f55de1b66d38bd15a841459c3a36cf29d30 Reviewed-on: https://github.com/flang-compiler/f18/pull/219 Tree-same-pre-rewrite: false
2018-10-19 01:50:55 +08:00
std::size_t dummies{actualForDummy.size()};
[flang] intrinsic pattern matching Original-commit: flang-compiler/f18@ca0ee1660a6449c34c7276284e5e63b90ae97540 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-05 04:43:33 +08:00
// Check types and kinds of the actual arguments against the intrinsic's
// interface. Ensure that two or more arguments that have to have the same
[flang] Extension: relax "same kind" rules on some intrinsics Original-commit: flang-compiler/f18@ce5130f84bcb78007180ee87661c84b1483a476c Reviewed-on: https://github.com/flang-compiler/f18/pull/590 Tree-same-pre-rewrite: false
2019-07-18 03:51:52 +08:00
// (or compatible) type and kind do so. Check for missing non-optional
// arguments now, too.
[flang] debug initial intrinsic table probes Original-commit: flang-compiler/f18@dce9a1e1734f6bbc4aff110ac943649f7dcc066a Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-09 06:35:19 +08:00
const ActualArgument *sameArg{nullptr};
[flang] Extension: relax "same kind" rules on some intrinsics Original-commit: flang-compiler/f18@ce5130f84bcb78007180ee87661c84b1483a476c Reviewed-on: https://github.com/flang-compiler/f18/pull/590 Tree-same-pre-rewrite: false
2019-07-18 03:51:52 +08:00
const ActualArgument *operandArg{nullptr};
[flang] intrinsic pattern matching Original-commit: flang-compiler/f18@ca0ee1660a6449c34c7276284e5e63b90ae97540 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-05 04:43:33 +08:00
const IntrinsicDummyArgument *kindDummyArg{nullptr};
[flang] debug initial intrinsic table probes Original-commit: flang-compiler/f18@dce9a1e1734f6bbc4aff110ac943649f7dcc066a Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-09 06:35:19 +08:00
const ActualArgument *kindArg{nullptr};
[flang] intrinsic pattern matching Original-commit: flang-compiler/f18@ca0ee1660a6449c34c7276284e5e63b90ae97540 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-05 04:43:33 +08:00
bool hasDimArg{false};
[flang] rearrange arguments into dummy argument order Original-commit: flang-compiler/f18@3bab0f55de1b66d38bd15a841459c3a36cf29d30 Reviewed-on: https://github.com/flang-compiler/f18/pull/219 Tree-same-pre-rewrite: false
2018-10-19 01:50:55 +08:00
for (std::size_t j{0}; j < dummies; ++j) {
const IntrinsicDummyArgument &d{dummy[std::min(j, dummyArgPatterns - 1)]};
[flang] intrinsic pattern matching Original-commit: flang-compiler/f18@ca0ee1660a6449c34c7276284e5e63b90ae97540 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-05 04:43:33 +08:00
if (d.typePattern.kindCode == KindCode::kindArg) {
[flang] Remove most comparisons to nullptr Remove needless usage of has_value() Original-commit: flang-compiler/f18@1da7fcf7a54066b18e521620ecedb79c7cd2eb97 Reviewed-on: https://github.com/flang-compiler/f18/pull/822
2019-11-10 01:29:31 +08:00
CHECK(!kindDummyArg);
[flang] intrinsic pattern matching Original-commit: flang-compiler/f18@ca0ee1660a6449c34c7276284e5e63b90ae97540 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-05 04:43:33 +08:00
kindDummyArg = &d;
}
[flang] rearrange arguments into dummy argument order Original-commit: flang-compiler/f18@3bab0f55de1b66d38bd15a841459c3a36cf29d30 Reviewed-on: https://github.com/flang-compiler/f18/pull/219 Tree-same-pre-rewrite: false
2018-10-19 01:50:55 +08:00
const ActualArgument *arg{actualForDummy[j]};
[flang] intrinsic pattern matching Original-commit: flang-compiler/f18@ca0ee1660a6449c34c7276284e5e63b90ae97540 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-05 04:43:33 +08:00
if (!arg) {
[flang] error messages Original-commit: flang-compiler/f18@392a7330736a8fd444ef92ed5c8ef7dcbc94d461 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-06 02:32:54 +08:00
if (d.optionality == Optionality::required) {
[flang] unit testing, better error messages Original-commit: flang-compiler/f18@f3876008d03751fff5d9490cbb1c7b7539e5c095 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-13 07:01:55 +08:00
messages.Say("missing mandatory '%s=' argument"_err_en_US, d.keyword);
[flang] Reformat with latest clang-format and .clang-format Original-commit: flang-compiler/f18@9fe84f45d7fd685051004678d6b5775dcc4c6f8f Reviewed-on: https://github.com/flang-compiler/f18/pull/1094
2020-03-29 12:00:16 +08:00
return std::nullopt; // missing non-OPTIONAL argument
[flang] error messages Original-commit: flang-compiler/f18@392a7330736a8fd444ef92ed5c8ef7dcbc94d461 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-06 02:32:54 +08:00
} else {
continue;
[flang] intrinsic pattern matching Original-commit: flang-compiler/f18@ca0ee1660a6449c34c7276284e5e63b90ae97540 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-05 04:43:33 +08:00
}
[flang] Correct shape analysis for transformational intrinsic functions Correct the analysis of references to transformational intrinsic functions that have different semantics based on the presence or absence of a DIM= argument; add shape analysis for UNPACK(). Differential Revision: https://reviews.llvm.org/D94716
2021-01-15 04:54:31 +08:00
} else if (d.optionality == Optionality::missing) {
messages.Say("unexpected '%s=' argument"_err_en_US, d.keyword);
return std::nullopt;
[flang] intrinsic pattern matching Original-commit: flang-compiler/f18@ca0ee1660a6449c34c7276284e5e63b90ae97540 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-05 04:43:33 +08:00
}
[flang] Fold array operations Original-commit: flang-compiler/f18@e6c86ecfd10b77aeac63722c08487ae5de0a0c27 Reviewed-on: https://github.com/flang-compiler/f18/pull/420
2019-04-19 05:11:15 +08:00
if (arg->GetAssumedTypeDummy()) {
// TYPE(*) assumed-type dummy argument forwarded to intrinsic
if (d.typePattern.categorySet == AnyType &&
[flang] Fix bug flang-compiler/f18#643 Original-commit: flang-compiler/f18@29bb4312e1f2861fa04f847c8e552ca894989593 Reviewed-on: https://github.com/flang-compiler/f18/pull/646
2019-08-13 01:56:18 +08:00
d.rank == Rank::anyOrAssumedRank &&
(d.typePattern.kindCode == KindCode::any ||
d.typePattern.kindCode == KindCode::addressable)) {
[flang] Fold array operations Original-commit: flang-compiler/f18@e6c86ecfd10b77aeac63722c08487ae5de0a0c27 Reviewed-on: https://github.com/flang-compiler/f18/pull/420
2019-04-19 05:11:15 +08:00
continue;
[flang] lib/evaluate work for structure constructors Original-commit: flang-compiler/f18@76a192f9c9b009ea52409f25b81dcb7aa2866234 Reviewed-on: https://github.com/flang-compiler/f18/pull/439
2019-05-04 02:29:15 +08:00
} else {
messages.Say("Assumed type TYPE(*) dummy argument not allowed "
"for '%s=' intrinsic argument"_err_en_US,
d.keyword);
return std::nullopt;
[flang] Fold array operations Original-commit: flang-compiler/f18@e6c86ecfd10b77aeac63722c08487ae5de0a0c27 Reviewed-on: https://github.com/flang-compiler/f18/pull/420
2019-04-19 05:11:15 +08:00
}
}
[flang] debug initial intrinsic table probes Original-commit: flang-compiler/f18@dce9a1e1734f6bbc4aff110ac943649f7dcc066a Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-09 06:35:19 +08:00
std::optional<DynamicType> type{arg->GetType()};
[flang] Remove most comparisons to nullptr Remove needless usage of has_value() Original-commit: flang-compiler/f18@1da7fcf7a54066b18e521620ecedb79c7cd2eb97 Reviewed-on: https://github.com/flang-compiler/f18/pull/822
2019-11-10 01:29:31 +08:00
if (!type) {
[flang] debug initial intrinsic table probes Original-commit: flang-compiler/f18@dce9a1e1734f6bbc4aff110ac943649f7dcc066a Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-09 06:35:19 +08:00
CHECK(arg->Rank() == 0);
[flang] Improve error message for procedure passed as invalid argument to an intrinsic Support forward references to sibling module procedures Add tests, handle corner cases Rename new test Original-commit: flang-compiler/f18@234bb519cd38d0b9234fc0b4a8d11cfcb9935e6a Reviewed-on: https://github.com/flang-compiler/f18/pull/1076
2020-03-14 03:19:44 +08:00
const Expr<SomeType> &expr{DEREF(arg->UnwrapExpr())};
if (std::holds_alternative<BOZLiteralConstant>(expr.u)) {
[flang] lib/evaluate work for structure constructors Original-commit: flang-compiler/f18@76a192f9c9b009ea52409f25b81dcb7aa2866234 Reviewed-on: https://github.com/flang-compiler/f18/pull/439
2019-05-04 02:29:15 +08:00
if (d.typePattern.kindCode == KindCode::typeless ||
d.rank == Rank::elementalOrBOZ) {
continue;
} else {
[flang]Verify C7107, C7108, C7109 from - Clause 7 constraint checks for f18. 1. Annotate the sources with constraint numbers. 2. Add tests for *C7107 (R765) digit shall have one of the values 0 or 1. *C7108 (R766) digit shall have one of the values 0 through 7. *C7109 (R764) A boz-literal-constant shall appear only as a data-stmt-constant in a DATA statement, or where explicitly allowed in 16.9 as an actual argument of an intrinsic procedure. Reviewed By: PeteSteinfeld Differential Revision: https://reviews.llvm.org/D84504
2020-07-24 16:19:29 +08:00
const IntrinsicDummyArgument &nextParam{dummy[j + 1]};
[flang] lib/evaluate work for structure constructors Original-commit: flang-compiler/f18@76a192f9c9b009ea52409f25b81dcb7aa2866234 Reviewed-on: https://github.com/flang-compiler/f18/pull/439
2019-05-04 02:29:15 +08:00
messages.Say(
[flang]Verify C7107, C7108, C7109 from - Clause 7 constraint checks for f18. 1. Annotate the sources with constraint numbers. 2. Add tests for *C7107 (R765) digit shall have one of the values 0 or 1. *C7108 (R766) digit shall have one of the values 0 through 7. *C7109 (R764) A boz-literal-constant shall appear only as a data-stmt-constant in a DATA statement, or where explicitly allowed in 16.9 as an actual argument of an intrinsic procedure. Reviewed By: PeteSteinfeld Differential Revision: https://reviews.llvm.org/D84504
2020-07-24 16:19:29 +08:00
"Typeless (BOZ) not allowed for both '%s=' & '%s=' arguments"_err_en_US, // C7109
d.keyword, nextParam.keyword);
[flang] lib/evaluate work for structure constructors Original-commit: flang-compiler/f18@76a192f9c9b009ea52409f25b81dcb7aa2866234 Reviewed-on: https://github.com/flang-compiler/f18/pull/439
2019-05-04 02:29:15 +08:00
}
} else {
[flang] Improve error message for procedure passed as invalid argument to an intrinsic Support forward references to sibling module procedures Add tests, handle corner cases Rename new test Original-commit: flang-compiler/f18@234bb519cd38d0b9234fc0b4a8d11cfcb9935e6a Reviewed-on: https://github.com/flang-compiler/f18/pull/1076
2020-03-14 03:19:44 +08:00
// NULL(), procedure, or procedure pointer
CHECK(IsProcedurePointer(expr));
if (d.typePattern.kindCode == KindCode::addressable ||
d.rank == Rank::reduceOperation) {
[flang] Fix bug flang-compiler/f18#643 Original-commit: flang-compiler/f18@29bb4312e1f2861fa04f847c8e552ca894989593 Reviewed-on: https://github.com/flang-compiler/f18/pull/646
2019-08-13 01:56:18 +08:00
continue;
[flang] Failed call to CHECK() for call to ASSOCIATED(NULL()) Calling "ASSOCATED(NULL()) was causing an internal check of the compiler to fail. I fixed this by changing the entry for "ASSOCIATED" in the intrinsics table to accept "AnyPointer" which contains a new "KindCode" of "pointerType". I also changed the function "FromActual()" to return a typeless intrinsic when called on a pointer, which duplicates its behavior for BOZ literals. This required changing the analysis of procedure arguments. While testing processing for procedure arguments, I found another bad call to `CHECK()` which I fixed. I made several other changes: -- I implemented constant folding for ASSOCIATED(). -- I fixed handling of NULL() in relational operations. -- I implemented semantic analysis for ASSOCIATED(). -- I noticed that the semantics for ASSOCIATED() are similar to those for pointer assignment. So I extracted the code that pointer assignment uses for procedure pointer compatibility to a place where it could be used by the semantic analysis for ASSOCIATED(). -- I couldn't figure out how to make the general semantic analysis for procedure arguments work with ASSOCIATED()'s second argument, which can be either a pointer or a target. So I stopped using normal semantic analysis for arguments for ASSOCIATED(). -- I added tests for all of this. Differential Revision: https://reviews.llvm.org/D88313
2020-09-26 00:03:17 +08:00
} else if (d.typePattern.kindCode == KindCode::nullPointerType) {
continue;
[flang] Fix bug flang-compiler/f18#643 Original-commit: flang-compiler/f18@29bb4312e1f2861fa04f847c8e552ca894989593 Reviewed-on: https://github.com/flang-compiler/f18/pull/646
2019-08-13 01:56:18 +08:00
} else {
[flang] Improve error message for procedure passed as invalid argument to an intrinsic Support forward references to sibling module procedures Add tests, handle corner cases Rename new test Original-commit: flang-compiler/f18@234bb519cd38d0b9234fc0b4a8d11cfcb9935e6a Reviewed-on: https://github.com/flang-compiler/f18/pull/1076
2020-03-14 03:19:44 +08:00
messages.Say(
"Actual argument for '%s=' may not be a procedure"_err_en_US,
[flang] Use LOC() in iso_c_binding for C_LOC and C_FUNLOC Original-commit: flang-compiler/f18@da02305d1baed2e4862568e00810495e7d5dd65b Reviewed-on: https://github.com/flang-compiler/f18/pull/538 Tree-same-pre-rewrite: false
2019-07-02 07:54:53 +08:00
d.keyword);
}
[flang] intrinsic pattern matching Original-commit: flang-compiler/f18@ca0ee1660a6449c34c7276284e5e63b90ae97540 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-05 04:43:33 +08:00
}
[flang] error messages Original-commit: flang-compiler/f18@392a7330736a8fd444ef92ed5c8ef7dcbc94d461 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-06 02:32:54 +08:00
return std::nullopt;
[flang] work in progress checkpoint: changes build, tests all pass many fixes, ready to test more Further CLASS(*) support More fixes for CLASS(*) Hide data members of DynamicType implement PRESENT() intrinsic Original-commit: flang-compiler/f18@044ba12c20f77c130e3c468914ddc2d6c8652c6e Reviewed-on: https://github.com/flang-compiler/f18/pull/466 Tree-same-pre-rewrite: false
2019-05-14 00:33:18 +08:00
} else if (!d.typePattern.categorySet.test(type->category())) {
[flang] lib/evaluate work for structure constructors Original-commit: flang-compiler/f18@76a192f9c9b009ea52409f25b81dcb7aa2866234 Reviewed-on: https://github.com/flang-compiler/f18/pull/439
2019-05-04 02:29:15 +08:00
messages.Say("Actual argument for '%s=' has bad type '%s'"_err_en_US,
[flang] Replace formatting of CharBlock & string Preserve generated strings until consumed by formatting. bugfix from premature push Address review comments Last fix(?) Use %s formatting for CharBlocks and strings Use new formatting and fix usage of std::forward<>() Use forward_list rather than vector to save strings Original-commit: flang-compiler/f18@8ea478420fd21a26a77c6b4e05c73529a566f4a5 Reviewed-on: https://github.com/flang-compiler/f18/pull/444 Tree-same-pre-rewrite: false
2019-05-07 00:33:45 +08:00
d.keyword, type->AsFortran());
[flang] Reformat with latest clang-format and .clang-format Original-commit: flang-compiler/f18@9fe84f45d7fd685051004678d6b5775dcc4c6f8f Reviewed-on: https://github.com/flang-compiler/f18/pull/1094
2020-03-29 12:00:16 +08:00
return std::nullopt; // argument has invalid type category
[flang] intrinsic pattern matching Original-commit: flang-compiler/f18@ca0ee1660a6449c34c7276284e5e63b90ae97540 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-05 04:43:33 +08:00
}
bool argOk{false};
switch (d.typePattern.kindCode) {
case KindCode::none:
case KindCode::typeless:
[flang] Reformat with latest clang-format and .clang-format Original-commit: flang-compiler/f18@9fe84f45d7fd685051004678d6b5775dcc4c6f8f Reviewed-on: https://github.com/flang-compiler/f18/pull/1094
2020-03-29 12:00:16 +08:00
case KindCode::teamType: // TODO: TEAM_TYPE
[flang] intrinsic pattern matching Original-commit: flang-compiler/f18@ca0ee1660a6449c34c7276284e5e63b90ae97540 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-05 04:43:33 +08:00
argOk = false;
break;
case KindCode::defaultIntegerKind:
[flang] work in progress checkpoint: changes build, tests all pass many fixes, ready to test more Further CLASS(*) support More fixes for CLASS(*) Hide data members of DynamicType implement PRESENT() intrinsic Original-commit: flang-compiler/f18@044ba12c20f77c130e3c468914ddc2d6c8652c6e Reviewed-on: https://github.com/flang-compiler/f18/pull/466 Tree-same-pre-rewrite: false
2019-05-14 00:33:18 +08:00
argOk = type->kind() == defaults.GetDefaultKind(TypeCategory::Integer);
[flang] intrinsic pattern matching Original-commit: flang-compiler/f18@ca0ee1660a6449c34c7276284e5e63b90ae97540 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-05 04:43:33 +08:00
break;
case KindCode::defaultRealKind:
[flang] work in progress checkpoint: changes build, tests all pass many fixes, ready to test more Further CLASS(*) support More fixes for CLASS(*) Hide data members of DynamicType implement PRESENT() intrinsic Original-commit: flang-compiler/f18@044ba12c20f77c130e3c468914ddc2d6c8652c6e Reviewed-on: https://github.com/flang-compiler/f18/pull/466 Tree-same-pre-rewrite: false
2019-05-14 00:33:18 +08:00
argOk = type->kind() == defaults.GetDefaultKind(TypeCategory::Real);
[flang] intrinsic pattern matching Original-commit: flang-compiler/f18@ca0ee1660a6449c34c7276284e5e63b90ae97540 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-05 04:43:33 +08:00
break;
case KindCode::doublePrecision:
[flang] work in progress checkpoint: changes build, tests all pass many fixes, ready to test more Further CLASS(*) support More fixes for CLASS(*) Hide data members of DynamicType implement PRESENT() intrinsic Original-commit: flang-compiler/f18@044ba12c20f77c130e3c468914ddc2d6c8652c6e Reviewed-on: https://github.com/flang-compiler/f18/pull/466 Tree-same-pre-rewrite: false
2019-05-14 00:33:18 +08:00
argOk = type->kind() == defaults.doublePrecisionKind();
[flang] intrinsic pattern matching Original-commit: flang-compiler/f18@ca0ee1660a6449c34c7276284e5e63b90ae97540 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-05 04:43:33 +08:00
break;
case KindCode::defaultCharKind:
[flang] work in progress checkpoint: changes build, tests all pass many fixes, ready to test more Further CLASS(*) support More fixes for CLASS(*) Hide data members of DynamicType implement PRESENT() intrinsic Original-commit: flang-compiler/f18@044ba12c20f77c130e3c468914ddc2d6c8652c6e Reviewed-on: https://github.com/flang-compiler/f18/pull/466 Tree-same-pre-rewrite: false
2019-05-14 00:33:18 +08:00
argOk = type->kind() == defaults.GetDefaultKind(TypeCategory::Character);
[flang] intrinsic pattern matching Original-commit: flang-compiler/f18@ca0ee1660a6449c34c7276284e5e63b90ae97540 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-05 04:43:33 +08:00
break;
case KindCode::defaultLogicalKind:
[flang] work in progress checkpoint: changes build, tests all pass many fixes, ready to test more Further CLASS(*) support More fixes for CLASS(*) Hide data members of DynamicType implement PRESENT() intrinsic Original-commit: flang-compiler/f18@044ba12c20f77c130e3c468914ddc2d6c8652c6e Reviewed-on: https://github.com/flang-compiler/f18/pull/466 Tree-same-pre-rewrite: false
2019-05-14 00:33:18 +08:00
argOk = type->kind() == defaults.GetDefaultKind(TypeCategory::Logical);
[flang] intrinsic pattern matching Original-commit: flang-compiler/f18@ca0ee1660a6449c34c7276284e5e63b90ae97540 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-05 04:43:33 +08:00
break;
[flang] Reformat with latest clang-format and .clang-format Original-commit: flang-compiler/f18@9fe84f45d7fd685051004678d6b5775dcc4c6f8f Reviewed-on: https://github.com/flang-compiler/f18/pull/1094
2020-03-29 12:00:16 +08:00
case KindCode::any:
argOk = true;
break;
[flang] intrinsic pattern matching Original-commit: flang-compiler/f18@ca0ee1660a6449c34c7276284e5e63b90ae97540 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-05 04:43:33 +08:00
case KindCode::kindArg:
[flang] work in progress checkpoint: changes build, tests all pass many fixes, ready to test more Further CLASS(*) support More fixes for CLASS(*) Hide data members of DynamicType implement PRESENT() intrinsic Original-commit: flang-compiler/f18@044ba12c20f77c130e3c468914ddc2d6c8652c6e Reviewed-on: https://github.com/flang-compiler/f18/pull/466 Tree-same-pre-rewrite: false
2019-05-14 00:33:18 +08:00
CHECK(type->category() == TypeCategory::Integer);
[flang] Remove most comparisons to nullptr Remove needless usage of has_value() Original-commit: flang-compiler/f18@1da7fcf7a54066b18e521620ecedb79c7cd2eb97 Reviewed-on: https://github.com/flang-compiler/f18/pull/822
2019-11-10 01:29:31 +08:00
CHECK(!kindArg);
[flang] intrinsic pattern matching Original-commit: flang-compiler/f18@ca0ee1660a6449c34c7276284e5e63b90ae97540 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-05 04:43:33 +08:00
kindArg = arg;
[flang] remove arg->intValue field Original-commit: flang-compiler/f18@721dc920227378d09d89758903c50538b61ffec3 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-10 03:07:29 +08:00
argOk = true;
[flang] intrinsic pattern matching Original-commit: flang-compiler/f18@ca0ee1660a6449c34c7276284e5e63b90ae97540 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-05 04:43:33 +08:00
break;
case KindCode::dimArg:
[flang] work in progress checkpoint: changes build, tests all pass many fixes, ready to test more Further CLASS(*) support More fixes for CLASS(*) Hide data members of DynamicType implement PRESENT() intrinsic Original-commit: flang-compiler/f18@044ba12c20f77c130e3c468914ddc2d6c8652c6e Reviewed-on: https://github.com/flang-compiler/f18/pull/466 Tree-same-pre-rewrite: false
2019-05-14 00:33:18 +08:00
CHECK(type->category() == TypeCategory::Integer);
[flang] intrinsic pattern matching Original-commit: flang-compiler/f18@ca0ee1660a6449c34c7276284e5e63b90ae97540 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-05 04:43:33 +08:00
hasDimArg = true;
argOk = true;
break;
case KindCode::same:
[flang] Remove most comparisons to nullptr Remove needless usage of has_value() Original-commit: flang-compiler/f18@1da7fcf7a54066b18e521620ecedb79c7cd2eb97 Reviewed-on: https://github.com/flang-compiler/f18/pull/822
2019-11-10 01:29:31 +08:00
if (!sameArg) {
[flang] intrinsic pattern matching Original-commit: flang-compiler/f18@ca0ee1660a6449c34c7276284e5e63b90ae97540 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-05 04:43:33 +08:00
sameArg = arg;
}
[flang] Trim duplicate error messages on intrinsics, and fix FINDLOC for Character data. Original-commit: flang-compiler/f18@48ab22e2130994653c5585cb290512543a3f599f Reviewed-on: https://github.com/flang-compiler/f18/pull/548 Tree-same-pre-rewrite: false
2019-07-04 03:19:35 +08:00
argOk = type->IsTkCompatibleWith(sameArg->GetType().value());
[flang] intrinsic pattern matching Original-commit: flang-compiler/f18@ca0ee1660a6449c34c7276284e5e63b90ae97540 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-05 04:43:33 +08:00
break;
[flang] Extension: relax "same kind" rules on some intrinsics Original-commit: flang-compiler/f18@ce5130f84bcb78007180ee87661c84b1483a476c Reviewed-on: https://github.com/flang-compiler/f18/pull/590 Tree-same-pre-rewrite: false
2019-07-18 03:51:52 +08:00
case KindCode::operand:
[flang] Remove most comparisons to nullptr Remove needless usage of has_value() Original-commit: flang-compiler/f18@1da7fcf7a54066b18e521620ecedb79c7cd2eb97 Reviewed-on: https://github.com/flang-compiler/f18/pull/822
2019-11-10 01:29:31 +08:00
if (!operandArg) {
[flang] Extension: relax "same kind" rules on some intrinsics Original-commit: flang-compiler/f18@ce5130f84bcb78007180ee87661c84b1483a476c Reviewed-on: https://github.com/flang-compiler/f18/pull/590 Tree-same-pre-rewrite: false
2019-07-18 03:51:52 +08:00
operandArg = arg;
} else if (auto prev{operandArg->GetType()}) {
if (type->category() == prev->category()) {
if (type->kind() > prev->kind()) {
operandArg = arg;
}
} else if (prev->category() == TypeCategory::Integer) {
operandArg = arg;
}
}
argOk = true;
break;
[flang] intrinsic pattern matching Original-commit: flang-compiler/f18@ca0ee1660a6449c34c7276284e5e63b90ae97540 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-05 04:43:33 +08:00
case KindCode::effectiveKind:
common::die("INTERNAL: KindCode::effectiveKind appears on argument '%s' "
"for intrinsic '%s'",
d.keyword, name);
break;
[flang] Reformat with latest clang-format and .clang-format Original-commit: flang-compiler/f18@9fe84f45d7fd685051004678d6b5775dcc4c6f8f Reviewed-on: https://github.com/flang-compiler/f18/pull/1094
2020-03-29 12:00:16 +08:00
case KindCode::addressable:
[flang] Failed call to CHECK() for call to ASSOCIATED(NULL()) Calling "ASSOCATED(NULL()) was causing an internal check of the compiler to fail. I fixed this by changing the entry for "ASSOCIATED" in the intrinsics table to accept "AnyPointer" which contains a new "KindCode" of "pointerType". I also changed the function "FromActual()" to return a typeless intrinsic when called on a pointer, which duplicates its behavior for BOZ literals. This required changing the analysis of procedure arguments. While testing processing for procedure arguments, I found another bad call to `CHECK()` which I fixed. I made several other changes: -- I implemented constant folding for ASSOCIATED(). -- I fixed handling of NULL() in relational operations. -- I implemented semantic analysis for ASSOCIATED(). -- I noticed that the semantics for ASSOCIATED() are similar to those for pointer assignment. So I extracted the code that pointer assignment uses for procedure pointer compatibility to a place where it could be used by the semantic analysis for ASSOCIATED(). -- I couldn't figure out how to make the general semantic analysis for procedure arguments work with ASSOCIATED()'s second argument, which can be either a pointer or a target. So I stopped using normal semantic analysis for arguments for ASSOCIATED(). -- I added tests for all of this. Differential Revision: https://reviews.llvm.org/D88313
2020-09-26 00:03:17 +08:00
case KindCode::nullPointerType:
[flang] Reformat with latest clang-format and .clang-format Original-commit: flang-compiler/f18@9fe84f45d7fd685051004678d6b5775dcc4c6f8f Reviewed-on: https://github.com/flang-compiler/f18/pull/1094
2020-03-29 12:00:16 +08:00
argOk = true;
break;
default:
CRASH_NO_CASE;
[flang] intrinsic pattern matching Original-commit: flang-compiler/f18@ca0ee1660a6449c34c7276284e5e63b90ae97540 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-05 04:43:33 +08:00
}
if (!argOk) {
[flang] error messages Original-commit: flang-compiler/f18@392a7330736a8fd444ef92ed5c8ef7dcbc94d461 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-06 02:32:54 +08:00
messages.Say(
[flang] Fix arg specs for CMPLX intrinsic Original-commit: flang-compiler/f18@3586b8a6469c91092f68beb76b77501c3920bb4b Reviewed-on: https://github.com/flang-compiler/f18/pull/477 Tree-same-pre-rewrite: false
2019-06-05 01:50:34 +08:00
"Actual argument for '%s=' has bad type or kind '%s'"_err_en_US,
[flang] Replace formatting of CharBlock & string Preserve generated strings until consumed by formatting. bugfix from premature push Address review comments Last fix(?) Use %s formatting for CharBlocks and strings Use new formatting and fix usage of std::forward<>() Use forward_list rather than vector to save strings Original-commit: flang-compiler/f18@8ea478420fd21a26a77c6b4e05c73529a566f4a5 Reviewed-on: https://github.com/flang-compiler/f18/pull/444 Tree-same-pre-rewrite: false
2019-05-07 00:33:45 +08:00
d.keyword, type->AsFortran());
[flang] intrinsic pattern matching Original-commit: flang-compiler/f18@ca0ee1660a6449c34c7276284e5e63b90ae97540 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-05 04:43:33 +08:00
return std::nullopt;
}
}
// Check the ranks of the arguments against the intrinsic's interface.
[flang] debug initial intrinsic table probes Original-commit: flang-compiler/f18@dce9a1e1734f6bbc4aff110ac943649f7dcc066a Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-09 06:35:19 +08:00
const ActualArgument *arrayArg{nullptr};
const ActualArgument *knownArg{nullptr};
[flang] fix original failure (reshape intrinsic argument check) Original-commit: flang-compiler/f18@8bba330b32d928a5cf5d581d139c0cec02294b58 Reviewed-on: https://github.com/flang-compiler/f18/pull/386 Tree-same-pre-rewrite: false
2019-04-04 07:04:13 +08:00
std::optional<int> shapeArgSize;
[flang] intrinsic pattern matching Original-commit: flang-compiler/f18@ca0ee1660a6449c34c7276284e5e63b90ae97540 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-05 04:43:33 +08:00
int elementalRank{0};
[flang] rearrange arguments into dummy argument order Original-commit: flang-compiler/f18@3bab0f55de1b66d38bd15a841459c3a36cf29d30 Reviewed-on: https://github.com/flang-compiler/f18/pull/219 Tree-same-pre-rewrite: false
2018-10-19 01:50:55 +08:00
for (std::size_t j{0}; j < dummies; ++j) {
const IntrinsicDummyArgument &d{dummy[std::min(j, dummyArgPatterns - 1)]};
if (const ActualArgument * arg{actualForDummy[j]}) {
[flang] Fold array operations Original-commit: flang-compiler/f18@e6c86ecfd10b77aeac63722c08487ae5de0a0c27 Reviewed-on: https://github.com/flang-compiler/f18/pull/420
2019-04-19 05:11:15 +08:00
if (IsAssumedRank(*arg) && d.rank != Rank::anyOrAssumedRank) {
[flang] Fix arg specs for CMPLX intrinsic Original-commit: flang-compiler/f18@3586b8a6469c91092f68beb76b77501c3920bb4b Reviewed-on: https://github.com/flang-compiler/f18/pull/477 Tree-same-pre-rewrite: false
2019-06-05 01:50:34 +08:00
messages.Say("Assumed-rank array cannot be forwarded to "
[flang] Address TODO: define IsAssumedRank predicate, use it Original-commit: flang-compiler/f18@f75c3e0ccfc763644afc3b0fe37861e3a5adcdd9 Reviewed-on: https://github.com/flang-compiler/f18/pull/225 Tree-same-pre-rewrite: false
2018-10-30 06:25:35 +08:00
"'%s=' argument"_err_en_US,
[flang] error messages Original-commit: flang-compiler/f18@392a7330736a8fd444ef92ed5c8ef7dcbc94d461 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-06 02:32:54 +08:00
d.keyword);
[flang] intrinsic pattern matching Original-commit: flang-compiler/f18@ca0ee1660a6449c34c7276284e5e63b90ae97540 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-05 04:43:33 +08:00
return std::nullopt;
}
[flang] debug initial intrinsic table probes Original-commit: flang-compiler/f18@dce9a1e1734f6bbc4aff110ac943649f7dcc066a Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-09 06:35:19 +08:00
int rank{arg->Rank()};
[flang] intrinsic pattern matching Original-commit: flang-compiler/f18@ca0ee1660a6449c34c7276284e5e63b90ae97540 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-05 04:43:33 +08:00
bool argOk{false};
switch (d.rank) {
case Rank::elemental:
[flang] error messages Original-commit: flang-compiler/f18@392a7330736a8fd444ef92ed5c8ef7dcbc94d461 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-06 02:32:54 +08:00
case Rank::elementalOrBOZ:
[flang] intrinsic pattern matching Original-commit: flang-compiler/f18@ca0ee1660a6449c34c7276284e5e63b90ae97540 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-05 04:43:33 +08:00
if (elementalRank == 0) {
[flang] debug initial intrinsic table probes Original-commit: flang-compiler/f18@dce9a1e1734f6bbc4aff110ac943649f7dcc066a Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-09 06:35:19 +08:00
elementalRank = rank;
[flang] intrinsic pattern matching Original-commit: flang-compiler/f18@ca0ee1660a6449c34c7276284e5e63b90ae97540 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-05 04:43:33 +08:00
}
[flang] debug initial intrinsic table probes Original-commit: flang-compiler/f18@dce9a1e1734f6bbc4aff110ac943649f7dcc066a Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-09 06:35:19 +08:00
argOk = rank == 0 || rank == elementalRank;
[flang] intrinsic pattern matching Original-commit: flang-compiler/f18@ca0ee1660a6449c34c7276284e5e63b90ae97540 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-05 04:43:33 +08:00
break;
[flang] Reformat with latest clang-format and .clang-format Original-commit: flang-compiler/f18@9fe84f45d7fd685051004678d6b5775dcc4c6f8f Reviewed-on: https://github.com/flang-compiler/f18/pull/1094
2020-03-29 12:00:16 +08:00
case Rank::scalar:
argOk = rank == 0;
break;
case Rank::vector:
argOk = rank == 1;
break;
[flang] intrinsic pattern matching Original-commit: flang-compiler/f18@ca0ee1660a6449c34c7276284e5e63b90ae97540 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-05 04:43:33 +08:00
case Rank::shape:
[flang] Remove most comparisons to nullptr Remove needless usage of has_value() Original-commit: flang-compiler/f18@1da7fcf7a54066b18e521620ecedb79c7cd2eb97 Reviewed-on: https://github.com/flang-compiler/f18/pull/822
2019-11-10 01:29:31 +08:00
CHECK(!shapeArgSize);
[flang] Fixes for RESHAPE() I fixed an assert caused by passing an empty array as the source= argument to RESHAPE(). In the process, I noticed that there were no tests for RESHAPE(), so I wrote a test that covers all the description in 16.9.163. In the process, I made the error messages more consistent and descriptive. I also changed the test to see if a reference to an intrinsic function was a constant to say that it is a constant if it's a refererence to an invalid intrinsic. This avoids emitting multiple messages for the same erroneous source. Differential Revision: https://reviews.llvm.org/D84904
2020-07-30 05:46:36 +08:00
if (rank != 1) {
messages.Say(
"'shape=' argument must be an array of rank 1"_err_en_US);
return std::nullopt;
} else {
[flang] Fold array operations Original-commit: flang-compiler/f18@e6c86ecfd10b77aeac63722c08487ae5de0a0c27 Reviewed-on: https://github.com/flang-compiler/f18/pull/420
2019-04-19 05:11:15 +08:00
if (auto shape{GetShape(context, *arg)}) {
[flang] checkpoint checkpoint checkpoint Original-commit: flang-compiler/f18@99d12a7215089b4aefdaef39a2407b84538c29ef Reviewed-on: https://github.com/flang-compiler/f18/pull/782 Tree-same-pre-rewrite: false
2019-10-09 06:21:09 +08:00
if (auto constShape{AsConstantShape(context, *shape)}) {
[flang] work in progress checkpoint: changes build, tests all pass many fixes, ready to test more Further CLASS(*) support More fixes for CLASS(*) Hide data members of DynamicType implement PRESENT() intrinsic Original-commit: flang-compiler/f18@044ba12c20f77c130e3c468914ddc2d6c8652c6e Reviewed-on: https://github.com/flang-compiler/f18/pull/466 Tree-same-pre-rewrite: false
2019-05-14 00:33:18 +08:00
shapeArgSize = constShape->At(ConstantSubscripts{1}).ToInt64();
[flang] Simplify expression visitor usage Original-commit: flang-compiler/f18@9ab121d6a6dc96b12042a242e5b4eec903455990 Reviewed-on: https://github.com/flang-compiler/f18/pull/386 Tree-same-pre-rewrite: false
2019-04-05 04:58:46 +08:00
CHECK(shapeArgSize >= 0);
argOk = true;
[flang] fix original failure (reshape intrinsic argument check) Original-commit: flang-compiler/f18@8bba330b32d928a5cf5d581d139c0cec02294b58 Reviewed-on: https://github.com/flang-compiler/f18/pull/386 Tree-same-pre-rewrite: false
2019-04-04 07:04:13 +08:00
}
}
}
if (!argOk) {
messages.Say(
"'shape=' argument must be a vector of known size"_err_en_US);
return std::nullopt;
}
[flang] intrinsic pattern matching Original-commit: flang-compiler/f18@ca0ee1660a6449c34c7276284e5e63b90ae97540 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-05 04:43:33 +08:00
break;
[flang] Reformat with latest clang-format and .clang-format Original-commit: flang-compiler/f18@9fe84f45d7fd685051004678d6b5775dcc4c6f8f Reviewed-on: https://github.com/flang-compiler/f18/pull/1094
2020-03-29 12:00:16 +08:00
case Rank::matrix:
argOk = rank == 2;
break;
[flang] intrinsic pattern matching Original-commit: flang-compiler/f18@ca0ee1660a6449c34c7276284e5e63b90ae97540 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-05 04:43:33 +08:00
case Rank::array:
[flang] debug initial intrinsic table probes Original-commit: flang-compiler/f18@dce9a1e1734f6bbc4aff110ac943649f7dcc066a Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-09 06:35:19 +08:00
argOk = rank > 0;
[flang] intrinsic pattern matching Original-commit: flang-compiler/f18@ca0ee1660a6449c34c7276284e5e63b90ae97540 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-05 04:43:33 +08:00
if (!arrayArg) {
arrayArg = arg;
} else {
[flang] debug initial intrinsic table probes Original-commit: flang-compiler/f18@dce9a1e1734f6bbc4aff110ac943649f7dcc066a Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-09 06:35:19 +08:00
argOk &= rank == arrayArg->Rank();
[flang] intrinsic pattern matching Original-commit: flang-compiler/f18@ca0ee1660a6449c34c7276284e5e63b90ae97540 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-05 04:43:33 +08:00
}
break;
case Rank::known:
[flang] Remove most comparisons to nullptr Remove needless usage of has_value() Original-commit: flang-compiler/f18@1da7fcf7a54066b18e521620ecedb79c7cd2eb97 Reviewed-on: https://github.com/flang-compiler/f18/pull/822
2019-11-10 01:29:31 +08:00
if (!knownArg) {
[flang] fix crash in ASSOCIATED() intrinsic with two arguments Original-commit: flang-compiler/f18@1a393ff43b627f1cf111d6a8a1a5403e285d7431 Reviewed-on: https://github.com/flang-compiler/f18/pull/565 Tree-same-pre-rewrite: false
2019-07-16 01:12:46 +08:00
knownArg = arg;
}
argOk = rank == knownArg->Rank();
[flang] intrinsic pattern matching Original-commit: flang-compiler/f18@ca0ee1660a6449c34c7276284e5e63b90ae97540 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-05 04:43:33 +08:00
break;
[flang] Reformat with latest clang-format and .clang-format Original-commit: flang-compiler/f18@9fe84f45d7fd685051004678d6b5775dcc4c6f8f Reviewed-on: https://github.com/flang-compiler/f18/pull/1094
2020-03-29 12:00:16 +08:00
case Rank::anyOrAssumedRank:
argOk = true;
break;
[flang] intrinsic pattern matching Original-commit: flang-compiler/f18@ca0ee1660a6449c34c7276284e5e63b90ae97540 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-05 04:43:33 +08:00
case Rank::conformable:
[flang] Remove most comparisons to nullptr Remove needless usage of has_value() Original-commit: flang-compiler/f18@1da7fcf7a54066b18e521620ecedb79c7cd2eb97 Reviewed-on: https://github.com/flang-compiler/f18/pull/822
2019-11-10 01:29:31 +08:00
CHECK(arrayArg);
[flang] debug initial intrinsic table probes Original-commit: flang-compiler/f18@dce9a1e1734f6bbc4aff110ac943649f7dcc066a Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-09 06:35:19 +08:00
argOk = rank == 0 || rank == arrayArg->Rank();
[flang] intrinsic pattern matching Original-commit: flang-compiler/f18@ca0ee1660a6449c34c7276284e5e63b90ae97540 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-05 04:43:33 +08:00
break;
[flang] Correct shape analysis for transformational intrinsic functions Correct the analysis of references to transformational intrinsic functions that have different semantics based on the presence or absence of a DIM= argument; add shape analysis for UNPACK(). Differential Revision: https://reviews.llvm.org/D94716
2021-01-15 04:54:31 +08:00
case Rank::dimReduced:
case Rank::dimRemovedOrScalar:
[flang] Remove most comparisons to nullptr Remove needless usage of has_value() Original-commit: flang-compiler/f18@1da7fcf7a54066b18e521620ecedb79c7cd2eb97 Reviewed-on: https://github.com/flang-compiler/f18/pull/822
2019-11-10 01:29:31 +08:00
CHECK(arrayArg);
[flang] Fix bug flang-compiler/f18#931: spurious error reported on CSHIFT Original-commit: flang-compiler/f18@bd9bd788652975ac11a24fd5d10197be80c78603 Reviewed-on: https://github.com/flang-compiler/f18/pull/932
2020-01-15 02:53:36 +08:00
argOk = rank == 0 || rank + 1 == arrayArg->Rank();
[flang] intrinsic pattern matching Original-commit: flang-compiler/f18@ca0ee1660a6449c34c7276284e5e63b90ae97540 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-05 04:43:33 +08:00
break;
[flang] finish most intrinsic table entries Original-commit: flang-compiler/f18@134bd885af5c67ae7fc2291778397546a3d1c189 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-12 05:51:14 +08:00
case Rank::reduceOperation:
[flang] Improve error message for procedure passed as invalid argument to an intrinsic Support forward references to sibling module procedures Add tests, handle corner cases Rename new test Original-commit: flang-compiler/f18@234bb519cd38d0b9234fc0b4a8d11cfcb9935e6a Reviewed-on: https://github.com/flang-compiler/f18/pull/1076
2020-03-14 03:19:44 +08:00
// TODO: validate the reduction operation -- it must be a pure
// function of two arguments with special constraints.
[flang] Remove most comparisons to nullptr Remove needless usage of has_value() Original-commit: flang-compiler/f18@1da7fcf7a54066b18e521620ecedb79c7cd2eb97 Reviewed-on: https://github.com/flang-compiler/f18/pull/822
2019-11-10 01:29:31 +08:00
CHECK(arrayArg);
[flang] finish most intrinsic table entries Original-commit: flang-compiler/f18@134bd885af5c67ae7fc2291778397546a3d1c189 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-12 05:51:14 +08:00
argOk = rank == 0;
break;
[flang] Correct shape analysis for transformational intrinsic functions Correct the analysis of references to transformational intrinsic functions that have different semantics based on the presence or absence of a DIM= argument; add shape analysis for UNPACK(). Differential Revision: https://reviews.llvm.org/D94716
2021-01-15 04:54:31 +08:00
case Rank::locReduced:
[flang] intrinsic pattern matching Original-commit: flang-compiler/f18@ca0ee1660a6449c34c7276284e5e63b90ae97540 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-05 04:43:33 +08:00
case Rank::rankPlus1:
case Rank::shaped:
common::die("INTERNAL: result-only rank code appears on argument '%s' "
"for intrinsic '%s'",
d.keyword, name);
}
if (!argOk) {
[flang] unit testing, better error messages Original-commit: flang-compiler/f18@f3876008d03751fff5d9490cbb1c7b7539e5c095 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-13 07:01:55 +08:00
messages.Say("'%s=' argument has unacceptable rank %d"_err_en_US,
[flang] debug initial intrinsic table probes Original-commit: flang-compiler/f18@dce9a1e1734f6bbc4aff110ac943649f7dcc066a Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-09 06:35:19 +08:00
d.keyword, rank);
[flang] intrinsic pattern matching Original-commit: flang-compiler/f18@ca0ee1660a6449c34c7276284e5e63b90ae97540 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-05 04:43:33 +08:00
return std::nullopt;
}
}
}
// Calculate the characteristics of the function result, if any
[flang] refactor a bit, and rearrange actual arguments into dummy order on intrinsic calls Original-commit: flang-compiler/f18@1f50ace68b00a7db4b75ebce5616032501e48457 Reviewed-on: https://github.com/flang-compiler/f18/pull/219 Tree-same-pre-rewrite: false
2018-10-18 06:09:48 +08:00
std::optional<DynamicType> resultType;
[flang] lib/evaluate work for structure constructors Original-commit: flang-compiler/f18@76a192f9c9b009ea52409f25b81dcb7aa2866234 Reviewed-on: https://github.com/flang-compiler/f18/pull/439
2019-05-04 02:29:15 +08:00
if (auto category{result.categorySet.LeastElement()}) {
// The intrinsic is not a subroutine.
[flang] refactor a bit, and rearrange actual arguments into dummy order on intrinsic calls Original-commit: flang-compiler/f18@1f50ace68b00a7db4b75ebce5616032501e48457 Reviewed-on: https://github.com/flang-compiler/f18/pull/219 Tree-same-pre-rewrite: false
2018-10-18 06:09:48 +08:00
if (call.isSubroutineCall) {
return std::nullopt;
[flang] more unit testing, fix a bug Original-commit: flang-compiler/f18@70189119df6ae84f995d6dd1fbdb6d03c784c723 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-13 07:25:39 +08:00
}
[flang] refactor a bit, and rearrange actual arguments into dummy order on intrinsic calls Original-commit: flang-compiler/f18@1f50ace68b00a7db4b75ebce5616032501e48457 Reviewed-on: https://github.com/flang-compiler/f18/pull/219 Tree-same-pre-rewrite: false
2018-10-18 06:09:48 +08:00
switch (result.kindCode) {
case KindCode::defaultIntegerKind:
CHECK(result.categorySet == IntType);
[flang] lib/evaluate work for structure constructors Original-commit: flang-compiler/f18@76a192f9c9b009ea52409f25b81dcb7aa2866234 Reviewed-on: https://github.com/flang-compiler/f18/pull/439
2019-05-04 02:29:15 +08:00
CHECK(*category == TypeCategory::Integer);
resultType = DynamicType{TypeCategory::Integer,
defaults.GetDefaultKind(TypeCategory::Integer)};
[flang] refactor a bit, and rearrange actual arguments into dummy order on intrinsic calls Original-commit: flang-compiler/f18@1f50ace68b00a7db4b75ebce5616032501e48457 Reviewed-on: https://github.com/flang-compiler/f18/pull/219 Tree-same-pre-rewrite: false
2018-10-18 06:09:48 +08:00
break;
case KindCode::defaultRealKind:
[flang] lib/evaluate work for structure constructors Original-commit: flang-compiler/f18@76a192f9c9b009ea52409f25b81dcb7aa2866234 Reviewed-on: https://github.com/flang-compiler/f18/pull/439
2019-05-04 02:29:15 +08:00
CHECK(result.categorySet == CategorySet{*category});
CHECK(FloatingType.test(*category));
resultType =
DynamicType{*category, defaults.GetDefaultKind(TypeCategory::Real)};
[flang] refactor a bit, and rearrange actual arguments into dummy order on intrinsic calls Original-commit: flang-compiler/f18@1f50ace68b00a7db4b75ebce5616032501e48457 Reviewed-on: https://github.com/flang-compiler/f18/pull/219 Tree-same-pre-rewrite: false
2018-10-18 06:09:48 +08:00
break;
case KindCode::doublePrecision:
[flang] Fix intrinsic table probing issue with DOUBLE COMPLEX The probing table was only expecting REAL for kind code `KindCode::doublePrecision` that is also used for `DoublePrecisionComplex`. Add related tests. Original-commit: flang-compiler/f18@342ed7e7694da2d71d0c701d5a1163be333cfa01 Reviewed-on: https://github.com/flang-compiler/f18/pull/680
2019-08-23 20:37:37 +08:00
CHECK(result.categorySet == CategorySet{*category});
CHECK(FloatingType.test(*category));
resultType = DynamicType{*category, defaults.doublePrecisionKind()};
[flang] refactor a bit, and rearrange actual arguments into dummy order on intrinsic calls Original-commit: flang-compiler/f18@1f50ace68b00a7db4b75ebce5616032501e48457 Reviewed-on: https://github.com/flang-compiler/f18/pull/219 Tree-same-pre-rewrite: false
2018-10-18 06:09:48 +08:00
break;
case KindCode::defaultCharKind:
CHECK(result.categorySet == CharType);
[flang] lib/evaluate work for structure constructors Original-commit: flang-compiler/f18@76a192f9c9b009ea52409f25b81dcb7aa2866234 Reviewed-on: https://github.com/flang-compiler/f18/pull/439
2019-05-04 02:29:15 +08:00
CHECK(*category == TypeCategory::Character);
resultType = DynamicType{TypeCategory::Character,
defaults.GetDefaultKind(TypeCategory::Character)};
[flang] refactor a bit, and rearrange actual arguments into dummy order on intrinsic calls Original-commit: flang-compiler/f18@1f50ace68b00a7db4b75ebce5616032501e48457 Reviewed-on: https://github.com/flang-compiler/f18/pull/219 Tree-same-pre-rewrite: false
2018-10-18 06:09:48 +08:00
break;
case KindCode::defaultLogicalKind:
CHECK(result.categorySet == LogicalType);
[flang] lib/evaluate work for structure constructors Original-commit: flang-compiler/f18@76a192f9c9b009ea52409f25b81dcb7aa2866234 Reviewed-on: https://github.com/flang-compiler/f18/pull/439
2019-05-04 02:29:15 +08:00
CHECK(*category == TypeCategory::Logical);
resultType = DynamicType{TypeCategory::Logical,
defaults.GetDefaultKind(TypeCategory::Logical)};
[flang] refactor a bit, and rearrange actual arguments into dummy order on intrinsic calls Original-commit: flang-compiler/f18@1f50ace68b00a7db4b75ebce5616032501e48457 Reviewed-on: https://github.com/flang-compiler/f18/pull/219 Tree-same-pre-rewrite: false
2018-10-18 06:09:48 +08:00
break;
case KindCode::same:
[flang] Remove most comparisons to nullptr Remove needless usage of has_value() Original-commit: flang-compiler/f18@1da7fcf7a54066b18e521620ecedb79c7cd2eb97 Reviewed-on: https://github.com/flang-compiler/f18/pull/822
2019-11-10 01:29:31 +08:00
CHECK(sameArg);
[flang] refactor a bit, and rearrange actual arguments into dummy order on intrinsic calls Original-commit: flang-compiler/f18@1f50ace68b00a7db4b75ebce5616032501e48457 Reviewed-on: https://github.com/flang-compiler/f18/pull/219 Tree-same-pre-rewrite: false
2018-10-18 06:09:48 +08:00
if (std::optional<DynamicType> aType{sameArg->GetType()}) {
[flang] work in progress checkpoint: changes build, tests all pass many fixes, ready to test more Further CLASS(*) support More fixes for CLASS(*) Hide data members of DynamicType implement PRESENT() intrinsic Original-commit: flang-compiler/f18@044ba12c20f77c130e3c468914ddc2d6c8652c6e Reviewed-on: https://github.com/flang-compiler/f18/pull/466 Tree-same-pre-rewrite: false
2019-05-14 00:33:18 +08:00
if (result.categorySet.test(aType->category())) {
[flang] refactor a bit, and rearrange actual arguments into dummy order on intrinsic calls Original-commit: flang-compiler/f18@1f50ace68b00a7db4b75ebce5616032501e48457 Reviewed-on: https://github.com/flang-compiler/f18/pull/219 Tree-same-pre-rewrite: false
2018-10-18 06:09:48 +08:00
resultType = *aType;
} else {
[flang] work in progress checkpoint: changes build, tests all pass many fixes, ready to test more Further CLASS(*) support More fixes for CLASS(*) Hide data members of DynamicType implement PRESENT() intrinsic Original-commit: flang-compiler/f18@044ba12c20f77c130e3c468914ddc2d6c8652c6e Reviewed-on: https://github.com/flang-compiler/f18/pull/466 Tree-same-pre-rewrite: false
2019-05-14 00:33:18 +08:00
resultType = DynamicType{*category, aType->kind()};
[flang] refactor a bit, and rearrange actual arguments into dummy order on intrinsic calls Original-commit: flang-compiler/f18@1f50ace68b00a7db4b75ebce5616032501e48457 Reviewed-on: https://github.com/flang-compiler/f18/pull/219 Tree-same-pre-rewrite: false
2018-10-18 06:09:48 +08:00
}
}
break;
[flang] Extension: relax "same kind" rules on some intrinsics Original-commit: flang-compiler/f18@ce5130f84bcb78007180ee87661c84b1483a476c Reviewed-on: https://github.com/flang-compiler/f18/pull/590 Tree-same-pre-rewrite: false
2019-07-18 03:51:52 +08:00
case KindCode::operand:
[flang] Remove most comparisons to nullptr Remove needless usage of has_value() Original-commit: flang-compiler/f18@1da7fcf7a54066b18e521620ecedb79c7cd2eb97 Reviewed-on: https://github.com/flang-compiler/f18/pull/822
2019-11-10 01:29:31 +08:00
CHECK(operandArg);
[flang] address review comment Original-commit: flang-compiler/f18@7012b6178654bca8b64ab9db334bb053b5c01965 Reviewed-on: https://github.com/flang-compiler/f18/pull/590
2019-07-20 01:37:55 +08:00
resultType = operandArg->GetType();
CHECK(!resultType || result.categorySet.test(resultType->category()));
[flang] Extension: relax "same kind" rules on some intrinsics Original-commit: flang-compiler/f18@ce5130f84bcb78007180ee87661c84b1483a476c Reviewed-on: https://github.com/flang-compiler/f18/pull/590 Tree-same-pre-rewrite: false
2019-07-18 03:51:52 +08:00
break;
[flang] refactor a bit, and rearrange actual arguments into dummy order on intrinsic calls Original-commit: flang-compiler/f18@1f50ace68b00a7db4b75ebce5616032501e48457 Reviewed-on: https://github.com/flang-compiler/f18/pull/219 Tree-same-pre-rewrite: false
2018-10-18 06:09:48 +08:00
case KindCode::effectiveKind:
[flang] Remove most comparisons to nullptr Remove needless usage of has_value() Original-commit: flang-compiler/f18@1da7fcf7a54066b18e521620ecedb79c7cd2eb97 Reviewed-on: https://github.com/flang-compiler/f18/pull/822
2019-11-10 01:29:31 +08:00
CHECK(kindDummyArg);
[flang] lib/evaluate work for structure constructors Original-commit: flang-compiler/f18@76a192f9c9b009ea52409f25b81dcb7aa2866234 Reviewed-on: https://github.com/flang-compiler/f18/pull/439
2019-05-04 02:29:15 +08:00
CHECK(result.categorySet == CategorySet{*category});
[flang] Remove most comparisons to nullptr Remove needless usage of has_value() Original-commit: flang-compiler/f18@1da7fcf7a54066b18e521620ecedb79c7cd2eb97 Reviewed-on: https://github.com/flang-compiler/f18/pull/822
2019-11-10 01:29:31 +08:00
if (kindArg) {
[flang] Defer conversions to objects; fix some intrinsic table entries more fixes Access components of constant structures Apply implicit typing to dummy args used in automatic array dimensions SELECTED_INT_KIND and SELECTED_REAL_KIND Finish SELECTED_{INT,REAL}_KIND and common cases of ALL()/ANY() Original-commit: flang-compiler/f18@e9f8e53e55867863ca06461fb6edd965c86352c7 Reviewed-on: https://github.com/flang-compiler/f18/pull/472 Tree-same-pre-rewrite: false
2019-05-22 07:58:46 +08:00
if (auto *expr{kindArg->UnwrapExpr()}) {
[flang] Fold array operations Original-commit: flang-compiler/f18@e6c86ecfd10b77aeac63722c08487ae5de0a0c27 Reviewed-on: https://github.com/flang-compiler/f18/pull/420
2019-04-19 05:11:15 +08:00
CHECK(expr->Rank() == 0);
if (auto code{ToInt64(*expr)}) {
[flang] lib/evaluate work for structure constructors Original-commit: flang-compiler/f18@76a192f9c9b009ea52409f25b81dcb7aa2866234 Reviewed-on: https://github.com/flang-compiler/f18/pull/439
2019-05-04 02:29:15 +08:00
if (IsValidKindOfIntrinsicType(*category, *code)) {
resultType = DynamicType{*category, static_cast<int>(*code)};
[flang] Fold array operations Original-commit: flang-compiler/f18@e6c86ecfd10b77aeac63722c08487ae5de0a0c27 Reviewed-on: https://github.com/flang-compiler/f18/pull/420
2019-04-19 05:11:15 +08:00
break;
}
[flang] remove arg->intValue field Original-commit: flang-compiler/f18@721dc920227378d09d89758903c50538b61ffec3 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-10 03:07:29 +08:00
}
}
[flang] refactor a bit, and rearrange actual arguments into dummy order on intrinsic calls Original-commit: flang-compiler/f18@1f50ace68b00a7db4b75ebce5616032501e48457 Reviewed-on: https://github.com/flang-compiler/f18/pull/219 Tree-same-pre-rewrite: false
2018-10-18 06:09:48 +08:00
messages.Say("'kind=' argument must be a constant scalar integer "
"whose value is a supported kind for the "
"intrinsic result type"_err_en_US);
return std::nullopt;
} else if (kindDummyArg->optionality == Optionality::defaultsToSameKind) {
[flang] Remove most comparisons to nullptr Remove needless usage of has_value() Original-commit: flang-compiler/f18@1da7fcf7a54066b18e521620ecedb79c7cd2eb97 Reviewed-on: https://github.com/flang-compiler/f18/pull/822
2019-11-10 01:29:31 +08:00
CHECK(sameArg);
[flang] refactor a bit, and rearrange actual arguments into dummy order on intrinsic calls Original-commit: flang-compiler/f18@1f50ace68b00a7db4b75ebce5616032501e48457 Reviewed-on: https://github.com/flang-compiler/f18/pull/219 Tree-same-pre-rewrite: false
2018-10-18 06:09:48 +08:00
resultType = *sameArg->GetType();
[flang] enable semantic analysis by default back out -Mnolargearray default temporarily Fix C_F_POINTER(SHAPE=) argument check, it can be any kind of integer Revert default result kind of SIZE() & al. to standard by default Remove needless usage of -fdebug-semantics Original-commit: flang-compiler/f18@57058a5b163eaa90c7e0f387ea4918f9efa8184c Reviewed-on: https://github.com/flang-compiler/f18/pull/907
2020-01-04 08:32:23 +08:00
} else if (kindDummyArg->optionality == Optionality::defaultsToSizeKind) {
[flang] lib/evaluate work for structure constructors Original-commit: flang-compiler/f18@76a192f9c9b009ea52409f25b81dcb7aa2866234 Reviewed-on: https://github.com/flang-compiler/f18/pull/439
2019-05-04 02:29:15 +08:00
CHECK(*category == TypeCategory::Integer);
resultType =
[flang] enable semantic analysis by default back out -Mnolargearray default temporarily Fix C_F_POINTER(SHAPE=) argument check, it can be any kind of integer Revert default result kind of SIZE() & al. to standard by default Remove needless usage of -fdebug-semantics Original-commit: flang-compiler/f18@57058a5b163eaa90c7e0f387ea4918f9efa8184c Reviewed-on: https://github.com/flang-compiler/f18/pull/907
2020-01-04 08:32:23 +08:00
DynamicType{TypeCategory::Integer, defaults.sizeIntegerKind()};
[flang] refactor a bit, and rearrange actual arguments into dummy order on intrinsic calls Original-commit: flang-compiler/f18@1f50ace68b00a7db4b75ebce5616032501e48457 Reviewed-on: https://github.com/flang-compiler/f18/pull/219 Tree-same-pre-rewrite: false
2018-10-18 06:09:48 +08:00
} else {
CHECK(kindDummyArg->optionality ==
Optionality::defaultsToDefaultForResult);
[flang] lib/evaluate work for structure constructors Original-commit: flang-compiler/f18@76a192f9c9b009ea52409f25b81dcb7aa2866234 Reviewed-on: https://github.com/flang-compiler/f18/pull/439
2019-05-04 02:29:15 +08:00
resultType = DynamicType{*category, defaults.GetDefaultKind(*category)};
[flang] remove arg->intValue field Original-commit: flang-compiler/f18@721dc920227378d09d89758903c50538b61ffec3 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-10 03:07:29 +08:00
}
[flang] refactor a bit, and rearrange actual arguments into dummy order on intrinsic calls Original-commit: flang-compiler/f18@1f50ace68b00a7db4b75ebce5616032501e48457 Reviewed-on: https://github.com/flang-compiler/f18/pull/219 Tree-same-pre-rewrite: false
2018-10-18 06:09:48 +08:00
break;
case KindCode::likeMultiply:
CHECK(dummies >= 2);
[flang] Remove most comparisons to nullptr Remove needless usage of has_value() Original-commit: flang-compiler/f18@1da7fcf7a54066b18e521620ecedb79c7cd2eb97 Reviewed-on: https://github.com/flang-compiler/f18/pull/822
2019-11-10 01:29:31 +08:00
CHECK(actualForDummy[0]);
CHECK(actualForDummy[1]);
[flang] refactor a bit, and rearrange actual arguments into dummy order on intrinsic calls Original-commit: flang-compiler/f18@1f50ace68b00a7db4b75ebce5616032501e48457 Reviewed-on: https://github.com/flang-compiler/f18/pull/219 Tree-same-pre-rewrite: false
2018-10-18 06:09:48 +08:00
resultType = actualForDummy[0]->GetType()->ResultTypeForMultiply(
*actualForDummy[1]->GetType());
break;
[flang] Add LOC()/%LOC() intrinsics Original-commit: flang-compiler/f18@3a6b90c9f5c1a21a40323e56e2c26f6161d2f79c Reviewed-on: https://github.com/flang-compiler/f18/pull/538 Tree-same-pre-rewrite: false
2019-07-02 04:22:22 +08:00
case KindCode::subscript:
CHECK(result.categorySet == IntType);
CHECK(*category == TypeCategory::Integer);
resultType =
DynamicType{TypeCategory::Integer, defaults.subscriptIntegerKind()};
break;
[flang] enable semantic analysis by default back out -Mnolargearray default temporarily Fix C_F_POINTER(SHAPE=) argument check, it can be any kind of integer Revert default result kind of SIZE() & al. to standard by default Remove needless usage of -fdebug-semantics Original-commit: flang-compiler/f18@57058a5b163eaa90c7e0f387ea4918f9efa8184c Reviewed-on: https://github.com/flang-compiler/f18/pull/907
2020-01-04 08:32:23 +08:00
case KindCode::size:
CHECK(result.categorySet == IntType);
CHECK(*category == TypeCategory::Integer);
resultType =
DynamicType{TypeCategory::Integer, defaults.sizeIntegerKind()};
break;
[flang] refactor a bit, and rearrange actual arguments into dummy order on intrinsic calls Original-commit: flang-compiler/f18@1f50ace68b00a7db4b75ebce5616032501e48457 Reviewed-on: https://github.com/flang-compiler/f18/pull/219 Tree-same-pre-rewrite: false
2018-10-18 06:09:48 +08:00
case KindCode::typeless:
case KindCode::teamType:
case KindCode::any:
case KindCode::kindArg:
case KindCode::dimArg:
common::die(
"INTERNAL: bad KindCode appears on intrinsic '%s' result", name);
break;
[flang] Reformat with latest clang-format and .clang-format Original-commit: flang-compiler/f18@9fe84f45d7fd685051004678d6b5775dcc4c6f8f Reviewed-on: https://github.com/flang-compiler/f18/pull/1094
2020-03-29 12:00:16 +08:00
default:
CRASH_NO_CASE;
[flang] intrinsic pattern matching Original-commit: flang-compiler/f18@ca0ee1660a6449c34c7276284e5e63b90ae97540 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-05 04:43:33 +08:00
}
[flang] lib/evaluate work for structure constructors Original-commit: flang-compiler/f18@76a192f9c9b009ea52409f25b81dcb7aa2866234 Reviewed-on: https://github.com/flang-compiler/f18/pull/439
2019-05-04 02:29:15 +08:00
} else {
if (!call.isSubroutineCall) {
return std::nullopt;
}
CHECK(result.kindCode == KindCode::none);
[flang] intrinsic pattern matching Original-commit: flang-compiler/f18@ca0ee1660a6449c34c7276284e5e63b90ae97540 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-05 04:43:33 +08:00
}
[flang] remove arg->intValue field Original-commit: flang-compiler/f18@721dc920227378d09d89758903c50538b61ffec3 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-10 03:07:29 +08:00
// At this point, the call is acceptable.
[flang] intrinsic pattern matching Original-commit: flang-compiler/f18@ca0ee1660a6449c34c7276284e5e63b90ae97540 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-05 04:43:33 +08:00
// Determine the rank of the function result.
int resultRank{0};
switch (rank) {
[flang] Reformat with latest clang-format and .clang-format Original-commit: flang-compiler/f18@9fe84f45d7fd685051004678d6b5775dcc4c6f8f Reviewed-on: https://github.com/flang-compiler/f18/pull/1094
2020-03-29 12:00:16 +08:00
case Rank::elemental:
resultRank = elementalRank;
break;
case Rank::scalar:
resultRank = 0;
break;
case Rank::vector:
resultRank = 1;
break;
case Rank::matrix:
resultRank = 2;
break;
[flang] remove arg->intValue field Original-commit: flang-compiler/f18@721dc920227378d09d89758903c50538b61ffec3 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-10 03:07:29 +08:00
case Rank::conformable:
[flang] Remove most comparisons to nullptr Remove needless usage of has_value() Original-commit: flang-compiler/f18@1da7fcf7a54066b18e521620ecedb79c7cd2eb97 Reviewed-on: https://github.com/flang-compiler/f18/pull/822
2019-11-10 01:29:31 +08:00
CHECK(arrayArg);
[flang] remove arg->intValue field Original-commit: flang-compiler/f18@721dc920227378d09d89758903c50538b61ffec3 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-10 03:07:29 +08:00
resultRank = arrayArg->Rank();
break;
[flang] intrinsic pattern matching Original-commit: flang-compiler/f18@ca0ee1660a6449c34c7276284e5e63b90ae97540 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-05 04:43:33 +08:00
case Rank::dimReduced:
[flang] Remove most comparisons to nullptr Remove needless usage of has_value() Original-commit: flang-compiler/f18@1da7fcf7a54066b18e521620ecedb79c7cd2eb97 Reviewed-on: https://github.com/flang-compiler/f18/pull/822
2019-11-10 01:29:31 +08:00
CHECK(arrayArg);
[flang] debug initial intrinsic table probes Original-commit: flang-compiler/f18@dce9a1e1734f6bbc4aff110ac943649f7dcc066a Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-09 06:35:19 +08:00
resultRank = hasDimArg ? arrayArg->Rank() - 1 : 0;
[flang] intrinsic pattern matching Original-commit: flang-compiler/f18@ca0ee1660a6449c34c7276284e5e63b90ae97540 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-05 04:43:33 +08:00
break;
[flang] Correct shape analysis for transformational intrinsic functions Correct the analysis of references to transformational intrinsic functions that have different semantics based on the presence or absence of a DIM= argument; add shape analysis for UNPACK(). Differential Revision: https://reviews.llvm.org/D94716
2021-01-15 04:54:31 +08:00
case Rank::locReduced:
[flang] Remove most comparisons to nullptr Remove needless usage of has_value() Original-commit: flang-compiler/f18@1da7fcf7a54066b18e521620ecedb79c7cd2eb97 Reviewed-on: https://github.com/flang-compiler/f18/pull/822
2019-11-10 01:29:31 +08:00
CHECK(arrayArg);
[flang] Correct shape analysis for transformational intrinsic functions Correct the analysis of references to transformational intrinsic functions that have different semantics based on the presence or absence of a DIM= argument; add shape analysis for UNPACK(). Differential Revision: https://reviews.llvm.org/D94716
2021-01-15 04:54:31 +08:00
resultRank = hasDimArg ? arrayArg->Rank() - 1 : 1;
[flang] Refactor SymbolOrComponent typedef to NamedEntity class Original-commit: flang-compiler/f18@e8ec4b88bd6084beeae6a0d3037e019bc1d24c6b Reviewed-on: https://github.com/flang-compiler/f18/pull/531 Tree-same-pre-rewrite: false
2019-06-26 04:07:32 +08:00
break;
[flang] intrinsic pattern matching Original-commit: flang-compiler/f18@ca0ee1660a6449c34c7276284e5e63b90ae97540 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-05 04:43:33 +08:00
case Rank::rankPlus1:
[flang] Remove most comparisons to nullptr Remove needless usage of has_value() Original-commit: flang-compiler/f18@1da7fcf7a54066b18e521620ecedb79c7cd2eb97 Reviewed-on: https://github.com/flang-compiler/f18/pull/822
2019-11-10 01:29:31 +08:00
CHECK(knownArg);
[flang] debug initial intrinsic table probes Original-commit: flang-compiler/f18@dce9a1e1734f6bbc4aff110ac943649f7dcc066a Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-09 06:35:19 +08:00
resultRank = knownArg->Rank() + 1;
[flang] intrinsic pattern matching Original-commit: flang-compiler/f18@ca0ee1660a6449c34c7276284e5e63b90ae97540 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-05 04:43:33 +08:00
break;
case Rank::shaped:
[flang] Remove most comparisons to nullptr Remove needless usage of has_value() Original-commit: flang-compiler/f18@1da7fcf7a54066b18e521620ecedb79c7cd2eb97 Reviewed-on: https://github.com/flang-compiler/f18/pull/822
2019-11-10 01:29:31 +08:00
CHECK(shapeArgSize);
[flang] fix original failure (reshape intrinsic argument check) Original-commit: flang-compiler/f18@8bba330b32d928a5cf5d581d139c0cec02294b58 Reviewed-on: https://github.com/flang-compiler/f18/pull/386 Tree-same-pre-rewrite: false
2019-04-04 07:04:13 +08:00
resultRank = *shapeArgSize;
[flang] intrinsic pattern matching Original-commit: flang-compiler/f18@ca0ee1660a6449c34c7276284e5e63b90ae97540 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-05 04:43:33 +08:00
break;
[flang] error messages Original-commit: flang-compiler/f18@392a7330736a8fd444ef92ed5c8ef7dcbc94d461 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-06 02:32:54 +08:00
case Rank::elementalOrBOZ:
[flang] intrinsic pattern matching Original-commit: flang-compiler/f18@ca0ee1660a6449c34c7276284e5e63b90ae97540 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-05 04:43:33 +08:00
case Rank::shape:
case Rank::array:
case Rank::known:
case Rank::anyOrAssumedRank:
[flang] finish most intrinsic table entries Original-commit: flang-compiler/f18@134bd885af5c67ae7fc2291778397546a3d1c189 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-12 05:51:14 +08:00
case Rank::reduceOperation:
[flang] Correct shape analysis for transformational intrinsic functions Correct the analysis of references to transformational intrinsic functions that have different semantics based on the presence or absence of a DIM= argument; add shape analysis for UNPACK(). Differential Revision: https://reviews.llvm.org/D94716
2021-01-15 04:54:31 +08:00
case Rank::dimRemovedOrScalar:
[flang] intrinsic pattern matching Original-commit: flang-compiler/f18@ca0ee1660a6449c34c7276284e5e63b90ae97540 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-05 04:43:33 +08:00
common::die("INTERNAL: bad Rank code on intrinsic '%s' result", name);
break;
}
CHECK(resultRank >= 0);
[flang] refactor a bit, and rearrange actual arguments into dummy order on intrinsic calls Original-commit: flang-compiler/f18@1f50ace68b00a7db4b75ebce5616032501e48457 Reviewed-on: https://github.com/flang-compiler/f18/pull/219 Tree-same-pre-rewrite: false
2018-10-18 06:09:48 +08:00
// Rearrange the actual arguments into dummy argument order.
ActualArguments rearranged(dummies);
[flang] rearrange arguments into dummy argument order Original-commit: flang-compiler/f18@3bab0f55de1b66d38bd15a841459c3a36cf29d30 Reviewed-on: https://github.com/flang-compiler/f18/pull/219 Tree-same-pre-rewrite: false
2018-10-19 01:50:55 +08:00
for (std::size_t j{0}; j < dummies; ++j) {
[flang] refactor a bit, and rearrange actual arguments into dummy order on intrinsic calls Original-commit: flang-compiler/f18@1f50ace68b00a7db4b75ebce5616032501e48457 Reviewed-on: https://github.com/flang-compiler/f18/pull/219 Tree-same-pre-rewrite: false
2018-10-18 06:09:48 +08:00
if (ActualArgument * arg{actualForDummy[j]}) {
[flang] rearrange arguments into dummy argument order Original-commit: flang-compiler/f18@3bab0f55de1b66d38bd15a841459c3a36cf29d30 Reviewed-on: https://github.com/flang-compiler/f18/pull/219 Tree-same-pre-rewrite: false
2018-10-19 01:50:55 +08:00
rearranged[j] = std::move(*arg);
[flang] refactor a bit, and rearrange actual arguments into dummy order on intrinsic calls Original-commit: flang-compiler/f18@1f50ace68b00a7db4b75ebce5616032501e48457 Reviewed-on: https://github.com/flang-compiler/f18/pull/219 Tree-same-pre-rewrite: false
2018-10-18 06:09:48 +08:00
}
}
[flang] Update preprocessing document, commentary Extend documentation on preprocessing IsSimplyContiguous basic skeleton Apply suggested improvements to mod-file.cc Checks for new call13.f90 (15.4.2.2 explicit interfaces) Implement checking for procedures that can be called via an implicit interface Argument checking, test fixing Better argument checking Better derived type compatibility checking Treat externals as if implicitly interfaced Extend IEEE_EXCEPTIONS module so tests still pass with argument checking SAME_TYPE_AS and EXTENDS_TYPE_OF intrinsic inquiry functions Define interfaces for most intrinsic subroutines Better PASS arguments More with PASS() argument Prep for review address comments fix comment Remove formatted expression from specification expression error message per review more review comments Original-commit: flang-compiler/f18@3cca775da9302e3a2acec4a34800cd7666899b5f Reviewed-on: https://github.com/flang-compiler/f18/pull/776
2019-09-17 07:58:13 +08:00
// Characterize the specific intrinsic procedure.
[flang] lib/evaluate work for structure constructors Original-commit: flang-compiler/f18@76a192f9c9b009ea52409f25b81dcb7aa2866234 Reviewed-on: https://github.com/flang-compiler/f18/pull/439
2019-05-04 02:29:15 +08:00
characteristics::DummyArguments dummyArgs;
std::optional<int> sameDummyArg;
[flang] Failed call to CHECK() for call to ASSOCIATED(NULL()) Calling "ASSOCATED(NULL()) was causing an internal check of the compiler to fail. I fixed this by changing the entry for "ASSOCIATED" in the intrinsics table to accept "AnyPointer" which contains a new "KindCode" of "pointerType". I also changed the function "FromActual()" to return a typeless intrinsic when called on a pointer, which duplicates its behavior for BOZ literals. This required changing the analysis of procedure arguments. While testing processing for procedure arguments, I found another bad call to `CHECK()` which I fixed. I made several other changes: -- I implemented constant folding for ASSOCIATED(). -- I fixed handling of NULL() in relational operations. -- I implemented semantic analysis for ASSOCIATED(). -- I noticed that the semantics for ASSOCIATED() are similar to those for pointer assignment. So I extracted the code that pointer assignment uses for procedure pointer compatibility to a place where it could be used by the semantic analysis for ASSOCIATED(). -- I couldn't figure out how to make the general semantic analysis for procedure arguments work with ASSOCIATED()'s second argument, which can be either a pointer or a target. So I stopped using normal semantic analysis for arguments for ASSOCIATED(). -- I added tests for all of this. Differential Revision: https://reviews.llvm.org/D88313
2020-09-26 00:03:17 +08:00
[flang] lib/evaluate work for structure constructors Original-commit: flang-compiler/f18@76a192f9c9b009ea52409f25b81dcb7aa2866234 Reviewed-on: https://github.com/flang-compiler/f18/pull/439
2019-05-04 02:29:15 +08:00
for (std::size_t j{0}; j < dummies; ++j) {
const IntrinsicDummyArgument &d{dummy[std::min(j, dummyArgPatterns - 1)]};
if (const auto &arg{rearranged[j]}) {
[flang] Use LOC() in iso_c_binding for C_LOC and C_FUNLOC Original-commit: flang-compiler/f18@da02305d1baed2e4862568e00810495e7d5dd65b Reviewed-on: https://github.com/flang-compiler/f18/pull/538 Tree-same-pre-rewrite: false
2019-07-02 07:54:53 +08:00
if (const Expr<SomeType> *expr{arg->UnwrapExpr()}) {
[flang] checkpoint checkpoint checkpoint Original-commit: flang-compiler/f18@99d12a7215089b4aefdaef39a2407b84538c29ef Reviewed-on: https://github.com/flang-compiler/f18/pull/782 Tree-same-pre-rewrite: false
2019-10-09 06:21:09 +08:00
auto dc{characteristics::DummyArgument::FromActual(
std::string{d.keyword}, *expr, context)};
[flang] Fix classification of shape inquiries in specification exprs In some contexts, including the motivating case of determining whether the expressions that define the shape of a variable are "constant expressions" in the sense of the Fortran standard, expression rewriting via Fold() is not necessary, and should not be required. The inquiry intrinsics LBOUND, UBOUND, and SIZE work correctly now in specification expressions and are classified correctly as being constant expressions (or not). Getting this right led to a fair amount of API clean-up as a consequence, including the folding of shapes and TypeAndShape objects, and new APIs for shapes that do not fold for those cases where folding isn't needed. Further, the symbol-testing predicate APIs in Evaluate/tools.h now all resolve any associations of their symbols and work transparently on use-, host-, and construct-association symbols; the tools used to resolve those associations have been defined and documented more precisely, and their clients adjusted as needed. Differential Revision: https://reviews.llvm.org/D94561
2021-01-13 07:36:45 +08:00
if (!dc) {
common::die("INTERNAL: could not characterize intrinsic function "
"actual argument '%s'",
expr->AsFortran().c_str());
return std::nullopt;
}
[flang] checkpoint checkpoint checkpoint Original-commit: flang-compiler/f18@99d12a7215089b4aefdaef39a2407b84538c29ef Reviewed-on: https://github.com/flang-compiler/f18/pull/782 Tree-same-pre-rewrite: false
2019-10-09 06:21:09 +08:00
dummyArgs.emplace_back(std::move(*dc));
[flang] Remove most comparisons to nullptr Remove needless usage of has_value() Original-commit: flang-compiler/f18@1da7fcf7a54066b18e521620ecedb79c7cd2eb97 Reviewed-on: https://github.com/flang-compiler/f18/pull/822
2019-11-10 01:29:31 +08:00
if (d.typePattern.kindCode == KindCode::same && !sameDummyArg) {
[flang] Use LOC() in iso_c_binding for C_LOC and C_FUNLOC Original-commit: flang-compiler/f18@da02305d1baed2e4862568e00810495e7d5dd65b Reviewed-on: https://github.com/flang-compiler/f18/pull/538 Tree-same-pre-rewrite: false
2019-07-02 07:54:53 +08:00
sameDummyArg = j;
[flang] lib/evaluate work for structure constructors Original-commit: flang-compiler/f18@76a192f9c9b009ea52409f25b81dcb7aa2866234 Reviewed-on: https://github.com/flang-compiler/f18/pull/439
2019-05-04 02:29:15 +08:00
}
} else {
[flang] Remove most comparisons to nullptr Remove needless usage of has_value() Original-commit: flang-compiler/f18@1da7fcf7a54066b18e521620ecedb79c7cd2eb97 Reviewed-on: https://github.com/flang-compiler/f18/pull/822
2019-11-10 01:29:31 +08:00
CHECK(arg->GetAssumedTypeDummy());
[flang] Update preprocessing document, commentary Extend documentation on preprocessing IsSimplyContiguous basic skeleton Apply suggested improvements to mod-file.cc Checks for new call13.f90 (15.4.2.2 explicit interfaces) Implement checking for procedures that can be called via an implicit interface Argument checking, test fixing Better argument checking Better derived type compatibility checking Treat externals as if implicitly interfaced Extend IEEE_EXCEPTIONS module so tests still pass with argument checking SAME_TYPE_AS and EXTENDS_TYPE_OF intrinsic inquiry functions Define interfaces for most intrinsic subroutines Better PASS arguments More with PASS() argument Prep for review address comments fix comment Remove formatted expression from specification expression error message per review more review comments Original-commit: flang-compiler/f18@3cca775da9302e3a2acec4a34800cd7666899b5f Reviewed-on: https://github.com/flang-compiler/f18/pull/776
2019-09-17 07:58:13 +08:00
dummyArgs.emplace_back(std::string{d.keyword},
characteristics::DummyDataObject{DynamicType::AssumedType()});
[flang] lib/evaluate work for structure constructors Original-commit: flang-compiler/f18@76a192f9c9b009ea52409f25b81dcb7aa2866234 Reviewed-on: https://github.com/flang-compiler/f18/pull/439
2019-05-04 02:29:15 +08:00
}
} else {
// optional argument is absent
CHECK(d.optionality != Optionality::required);
if (d.typePattern.kindCode == KindCode::same) {
dummyArgs.emplace_back(dummyArgs[sameDummyArg.value()]);
} else {
auto category{d.typePattern.categorySet.LeastElement().value()};
characteristics::TypeAndShape typeAndShape{
DynamicType{category, defaults.GetDefaultKind(category)}};
[flang] Merge pull request flang-compiler/f18#539 from flang-compiler/tsk1 Check that procedures of a generic are distinguishable Original-commit: flang-compiler/f18@a24701e313019dbf84179b79e234f92d61de0fa6 Reviewed-on: https://github.com/flang-compiler/f18/pull/539 Due to a conflicting rebase during the linearizing of flang-compiler/f18, this commit squashes a number of other commits: flang-compiler/f18@9b1343af36bd27b110f31dab39c3a18a657a5760 Some cleanup in characteristics.{h,cc} flang-compiler/f18@ddb70e53d2b4e2bba12686e4ac3c26052758fcc3 Merge branch 'master' of github.com:flang-compiler/f18 into tsk1 flang-compiler/f18@d1eef9506610a427f992180f6b59cafe09abb9b9 Merge branch 'master' of github.com:flang-compiler/f18 into tsk1 flang-compiler/f18@24a6d3ffbf4d26d92222b27faa155bb5b3f517f4 Make test_folding.sh stricter in test for warnings flang-compiler/f18@c2c5b640604acceb45823de8cb5716d6921da7d4 Replace SymbolList with SymbolVector flang-compiler/f18@c8499584dff12381c2ce6d4718761cd225b4d97a Add CopyAttrs to copy attributes from Symbol flang-compiler/f18@0573ffd8b2ed5757e06a4fc6d5ffc4401e800c32 Replace cascading detailsIf calls with std::visit flang-compiler/f18@28ec62b3ffeec1d25fde330069b050655bb52a5d Add name to characteristics::DummyArgument flang-compiler/f18@568eaf01145d4ee979423d06f2a65d07222f6841 Add name to CopySymbol() flang-compiler/f18@8c557b09e752da205cd300f63b5ca69806fb2e78 Check that procedures of a generic are distinguishable flang-compiler/f18@50515fd987fd5479567e1b497f6ba93974ffde76 Merge branch 'master' of github.com:flang-compiler/f18 into tsk1 flang-compiler/f18@a7963e98a4aedc97784b99903d04cdc48fd4c346 Address review comments flang-compiler/f18@edd65b3962dbaa1121c166d47c90730e39c25a04 Merge branch 'master' of github.com:flang-compiler/f18 into tsk1
2019-07-03 05:00:44 +08:00
dummyArgs.emplace_back(std::string{d.keyword},
[flang] lib/evaluate work for structure constructors Original-commit: flang-compiler/f18@76a192f9c9b009ea52409f25b81dcb7aa2866234 Reviewed-on: https://github.com/flang-compiler/f18/pull/439
2019-05-04 02:29:15 +08:00
characteristics::DummyDataObject{std::move(typeAndShape)});
}
[flang] Merge pull request flang-compiler/f18#539 from flang-compiler/tsk1 Check that procedures of a generic are distinguishable Original-commit: flang-compiler/f18@a24701e313019dbf84179b79e234f92d61de0fa6 Reviewed-on: https://github.com/flang-compiler/f18/pull/539 Due to a conflicting rebase during the linearizing of flang-compiler/f18, this commit squashes a number of other commits: flang-compiler/f18@9b1343af36bd27b110f31dab39c3a18a657a5760 Some cleanup in characteristics.{h,cc} flang-compiler/f18@ddb70e53d2b4e2bba12686e4ac3c26052758fcc3 Merge branch 'master' of github.com:flang-compiler/f18 into tsk1 flang-compiler/f18@d1eef9506610a427f992180f6b59cafe09abb9b9 Merge branch 'master' of github.com:flang-compiler/f18 into tsk1 flang-compiler/f18@24a6d3ffbf4d26d92222b27faa155bb5b3f517f4 Make test_folding.sh stricter in test for warnings flang-compiler/f18@c2c5b640604acceb45823de8cb5716d6921da7d4 Replace SymbolList with SymbolVector flang-compiler/f18@c8499584dff12381c2ce6d4718761cd225b4d97a Add CopyAttrs to copy attributes from Symbol flang-compiler/f18@0573ffd8b2ed5757e06a4fc6d5ffc4401e800c32 Replace cascading detailsIf calls with std::visit flang-compiler/f18@28ec62b3ffeec1d25fde330069b050655bb52a5d Add name to characteristics::DummyArgument flang-compiler/f18@568eaf01145d4ee979423d06f2a65d07222f6841 Add name to CopySymbol() flang-compiler/f18@8c557b09e752da205cd300f63b5ca69806fb2e78 Check that procedures of a generic are distinguishable flang-compiler/f18@50515fd987fd5479567e1b497f6ba93974ffde76 Merge branch 'master' of github.com:flang-compiler/f18 into tsk1 flang-compiler/f18@a7963e98a4aedc97784b99903d04cdc48fd4c346 Address review comments flang-compiler/f18@edd65b3962dbaa1121c166d47c90730e39c25a04 Merge branch 'master' of github.com:flang-compiler/f18 into tsk1
2019-07-03 05:00:44 +08:00
dummyArgs.back().SetOptional();
[flang] lib/evaluate work for structure constructors Original-commit: flang-compiler/f18@76a192f9c9b009ea52409f25b81dcb7aa2866234 Reviewed-on: https://github.com/flang-compiler/f18/pull/439
2019-05-04 02:29:15 +08:00
}
[flang] Document and use intrinsic subroutine argument intents Check INTENT(OUT)/INTENT(INOUT) constraints for actual argument of intrinsic procedure calls. - Adding a common::Intent field to the IntrinsicDummyArgument in the intrinsic table. - Propagating it to the DummyDataObject intent field so that it can later be used in CheckExplicitDataArg semantic checks. - Add related tests. - Fix regression (C846 false error), C846 INTENT(OUT) rule does not apply to intrinsic call. Propagate the information that we are in an intrinsic call up to CheckExplicitDataArg (that is doing this check). Still enforce C846 on intrinsics other than MOVE_ALLOC (for which allocatable coarrays are explicitly allowed) since it's not clear it is allowed in all intrinsics and allowing this would lead to runtime penalties in the intrinsic runtime. Differential Revision: https://reviews.llvm.org/D89473
2020-10-20 18:39:26 +08:00
dummyArgs.back().SetIntent(d.intent);
[flang] lib/evaluate work for structure constructors Original-commit: flang-compiler/f18@76a192f9c9b009ea52409f25b81dcb7aa2866234 Reviewed-on: https://github.com/flang-compiler/f18/pull/439
2019-05-04 02:29:15 +08:00
}
characteristics::Procedure::Attrs attrs;
if (elementalRank > 0) {
attrs.set(characteristics::Procedure::Attr::Elemental);
}
[flang] Update preprocessing document, commentary Extend documentation on preprocessing IsSimplyContiguous basic skeleton Apply suggested improvements to mod-file.cc Checks for new call13.f90 (15.4.2.2 explicit interfaces) Implement checking for procedures that can be called via an implicit interface Argument checking, test fixing Better argument checking Better derived type compatibility checking Treat externals as if implicitly interfaced Extend IEEE_EXCEPTIONS module so tests still pass with argument checking SAME_TYPE_AS and EXTENDS_TYPE_OF intrinsic inquiry functions Define interfaces for most intrinsic subroutines Better PASS arguments More with PASS() argument Prep for review address comments fix comment Remove formatted expression from specification expression error message per review more review comments Original-commit: flang-compiler/f18@3cca775da9302e3a2acec4a34800cd7666899b5f Reviewed-on: https://github.com/flang-compiler/f18/pull/776
2019-09-17 07:58:13 +08:00
if (call.isSubroutineCall) {
return SpecificCall{
SpecificIntrinsic{
name, characteristics::Procedure{std::move(dummyArgs), attrs}},
std::move(rearranged)};
} else {
[flang] Semantic checks for PURE subprograms (test call10.f90) Fix bug found in testing Original-commit: flang-compiler/f18@ccdd7326ba56c5a3cf8bc944516e3d1b93b25848 Reviewed-on: https://github.com/flang-compiler/f18/pull/825
2019-11-13 07:43:09 +08:00
attrs.set(characteristics::Procedure::Attr::Pure);
[flang] Update preprocessing document, commentary Extend documentation on preprocessing IsSimplyContiguous basic skeleton Apply suggested improvements to mod-file.cc Checks for new call13.f90 (15.4.2.2 explicit interfaces) Implement checking for procedures that can be called via an implicit interface Argument checking, test fixing Better argument checking Better derived type compatibility checking Treat externals as if implicitly interfaced Extend IEEE_EXCEPTIONS module so tests still pass with argument checking SAME_TYPE_AS and EXTENDS_TYPE_OF intrinsic inquiry functions Define interfaces for most intrinsic subroutines Better PASS arguments More with PASS() argument Prep for review address comments fix comment Remove formatted expression from specification expression error message per review more review comments Original-commit: flang-compiler/f18@3cca775da9302e3a2acec4a34800cd7666899b5f Reviewed-on: https://github.com/flang-compiler/f18/pull/776
2019-09-17 07:58:13 +08:00
characteristics::TypeAndShape typeAndShape{resultType.value(), resultRank};
characteristics::FunctionResult funcResult{std::move(typeAndShape)};
characteristics::Procedure chars{
std::move(funcResult), std::move(dummyArgs), attrs};
return SpecificCall{
SpecificIntrinsic{name, std::move(chars)}, std::move(rearranged)};
}
[flang] intrinsic pattern matching Original-commit: flang-compiler/f18@ca0ee1660a6449c34c7276284e5e63b90ae97540 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-05 04:43:33 +08:00
}
[flang] checkpoint Original-commit: flang-compiler/f18@e7b0f456c9bba153c51c6e775a60e6d01e488271 Reviewed-on: https://github.com/flang-compiler/f18/pull/304 Tree-same-pre-rewrite: false
2019-02-23 07:45:30 +08:00
class IntrinsicProcTable::Implementation {
public:
[flang] Move default intrinsic type kinds from lib/semantics to lib/common Original-commit: flang-compiler/f18@887e72dd613f411808d1b9e9e7b64601a3b67af8 Reviewed-on: https://github.com/flang-compiler/f18/pull/265 Tree-same-pre-rewrite: false
2019-01-19 04:40:47 +08:00
explicit Implementation(const common::IntrinsicTypeDefaultKinds &dfts)
[flang] Reformat with latest clang-format and .clang-format Original-commit: flang-compiler/f18@9fe84f45d7fd685051004678d6b5775dcc4c6f8f Reviewed-on: https://github.com/flang-compiler/f18/pull/1094
2020-03-29 12:00:16 +08:00
: defaults_{dfts} {
[flang] intrinsic pattern matching Original-commit: flang-compiler/f18@ca0ee1660a6449c34c7276284e5e63b90ae97540 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-05 04:43:33 +08:00
for (const IntrinsicInterface &f : genericIntrinsicFunction) {
[flang] checkpoint Original-commit: flang-compiler/f18@e7b0f456c9bba153c51c6e775a60e6d01e488271 Reviewed-on: https://github.com/flang-compiler/f18/pull/304 Tree-same-pre-rewrite: false
2019-02-23 07:45:30 +08:00
genericFuncs_.insert(std::make_pair(std::string{f.name}, &f));
[flang] intrinsic pattern matching Original-commit: flang-compiler/f18@ca0ee1660a6449c34c7276284e5e63b90ae97540 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-05 04:43:33 +08:00
}
for (const SpecificIntrinsicInterface &f : specificIntrinsicFunction) {
[flang] checkpoint Original-commit: flang-compiler/f18@e7b0f456c9bba153c51c6e775a60e6d01e488271 Reviewed-on: https://github.com/flang-compiler/f18/pull/304 Tree-same-pre-rewrite: false
2019-02-23 07:45:30 +08:00
specificFuncs_.insert(std::make_pair(std::string{f.name}, &f));
[flang] intrinsic pattern matching Original-commit: flang-compiler/f18@ca0ee1660a6449c34c7276284e5e63b90ae97540 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-05 04:43:33 +08:00
}
[flang] Update preprocessing document, commentary Extend documentation on preprocessing IsSimplyContiguous basic skeleton Apply suggested improvements to mod-file.cc Checks for new call13.f90 (15.4.2.2 explicit interfaces) Implement checking for procedures that can be called via an implicit interface Argument checking, test fixing Better argument checking Better derived type compatibility checking Treat externals as if implicitly interfaced Extend IEEE_EXCEPTIONS module so tests still pass with argument checking SAME_TYPE_AS and EXTENDS_TYPE_OF intrinsic inquiry functions Define interfaces for most intrinsic subroutines Better PASS arguments More with PASS() argument Prep for review address comments fix comment Remove formatted expression from specification expression error message per review more review comments Original-commit: flang-compiler/f18@3cca775da9302e3a2acec4a34800cd7666899b5f Reviewed-on: https://github.com/flang-compiler/f18/pull/776
2019-09-17 07:58:13 +08:00
for (const IntrinsicInterface &f : intrinsicSubroutine) {
subroutines_.insert(std::make_pair(std::string{f.name}, &f));
}
[flang] intrinsic pattern matching Original-commit: flang-compiler/f18@ca0ee1660a6449c34c7276284e5e63b90ae97540 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-05 04:43:33 +08:00
}
[flang] initial intrinsics table Original-commit: flang-compiler/f18@8b5c3adf887cf88752937a4fa5507c0d66051d3b Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-09-29 08:02:11 +08:00
[flang] checkpoint Original-commit: flang-compiler/f18@4d907e3184da8e236d7a3c524cbb4630886f75c9 Reviewed-on: https://github.com/flang-compiler/f18/pull/304 Tree-same-pre-rewrite: false
2019-02-27 06:26:28 +08:00
bool IsIntrinsic(const std::string &) const;
[flang] Tighten rules to resolve procedure as intrinsic procedure 2 Bug fixes: - Do not resolve procedure as intrinsic if they appeared in an EXTERNAL attribute statement (one path was not considering this flag) - Emit an error if a procedure resolved to be an intrinsic function (resp. subroutine) is used as a subroutine (resp. function). Lowering was attempted while the evaluate::Expression for the call was missing without any errors. 1 behavior change: - Do not implicitly resolve subroutines (resp. functions) as intrinsics because their name is the name of an intrinsic function (resp. subroutine). Add justification in documentation. Reviewed By: klausler, tskeith Differential Revision: https://reviews.llvm.org/D90049
2020-10-26 18:25:40 +08:00
bool IsIntrinsicFunction(const std::string &) const;
bool IsIntrinsicSubroutine(const std::string &) const;
[flang] checkpoint Original-commit: flang-compiler/f18@4d907e3184da8e236d7a3c524cbb4630886f75c9 Reviewed-on: https://github.com/flang-compiler/f18/pull/304 Tree-same-pre-rewrite: false
2019-02-27 06:26:28 +08:00
[flang] New implementation for checks for constraints C741 through C750 Summary: Most of these checks were already implemented, and I just added references to them to the code and tests. Also, much of this code was already reviewed in the old flang/f18 GitHub repository, but I didn't get to merge it before we switched repositories. I implemented the check for C747 to not allow coarray components in derived types that are of type C_PTR, C_FUNPTR, or type TEAM_TYPE. I implemented the check for C748 that requires a data component whose type has a coarray ultimate component to be a nonpointer, nonallocatable scalar and not be a coarray. I implemented the check for C750 that adds additional restrictions to the bounds expressions of a derived type component that's an array. These bounds expressions are sepcification expressions as defined in 10.1.11. There was already code in lib/Evaluate/check-expression.cpp to check semantics for specification expressions, but it did not check for the extra requirements of C750. C750 prohibits specification functions, the intrinsic functions ALLOCATED, ASSOCIATED, EXTENDS_TYPE_OF, PRESENT, and SAME_TYPE_AS. It also requires every specification inquiry reference to be a constant expression, and requires that the value of the bound not depend on the value of a variable. To implement these additional checks, I added code to the intrinsic proc table to get the intrinsic class of a procedure. I also added an enumeration to distinguish between specification expressions for derived type component bounds versus for type parameters. I then changed the code to pass an enumeration value to "CheckSpecificationExpr()" to indicate that the expression was a bounds expression and used this value to determine whether to emit an error message when violations of C750 are found. I changed the implementation of IsPureProcedure() to handle statement functions and changed some references in the code that tested for the PURE attribute to call IsPureProcedure(). I also fixed some unrelated tests that got new errors when I implemented these new checks. Reviewers: tskeith, DavidTruby, sscalpone Subscribers: jfb, llvm-commits Tags: #llvm, #flang Differential Revision: https://reviews.llvm.org/D79263
2020-05-02 04:00:28 +08:00
IntrinsicClass GetIntrinsicClass(const std::string &) const;
[flang] Expose specific to generic intrinsic name mapping The intrinsic lowering facility is based on the generic intrinsic names to avoid duplicating implementations. Specific intrinsics call are re-written to call to the generic versions by the front-end but this cannot be done when specific intrinsics are passed as arguments (the rewrite would give illegal/ambiguous unparsed Fortran). Solve the issue by making the specific to generic name mapping accessible to lowering and can be later used to generate the unrestricted intrinsic functions. Reviewed By: schweitz Differential Revision: https://reviews.llvm.org/D84842
2020-07-30 20:29:24 +08:00
std::string GetGenericIntrinsicName(const std::string &) const;
[flang] New implementation for checks for constraints C741 through C750 Summary: Most of these checks were already implemented, and I just added references to them to the code and tests. Also, much of this code was already reviewed in the old flang/f18 GitHub repository, but I didn't get to merge it before we switched repositories. I implemented the check for C747 to not allow coarray components in derived types that are of type C_PTR, C_FUNPTR, or type TEAM_TYPE. I implemented the check for C748 that requires a data component whose type has a coarray ultimate component to be a nonpointer, nonallocatable scalar and not be a coarray. I implemented the check for C750 that adds additional restrictions to the bounds expressions of a derived type component that's an array. These bounds expressions are sepcification expressions as defined in 10.1.11. There was already code in lib/Evaluate/check-expression.cpp to check semantics for specification expressions, but it did not check for the extra requirements of C750. C750 prohibits specification functions, the intrinsic functions ALLOCATED, ASSOCIATED, EXTENDS_TYPE_OF, PRESENT, and SAME_TYPE_AS. It also requires every specification inquiry reference to be a constant expression, and requires that the value of the bound not depend on the value of a variable. To implement these additional checks, I added code to the intrinsic proc table to get the intrinsic class of a procedure. I also added an enumeration to distinguish between specification expressions for derived type component bounds versus for type parameters. I then changed the code to pass an enumeration value to "CheckSpecificationExpr()" to indicate that the expression was a bounds expression and used this value to determine whether to emit an error message when violations of C750 are found. I changed the implementation of IsPureProcedure() to handle statement functions and changed some references in the code that tested for the PURE attribute to call IsPureProcedure(). I also fixed some unrelated tests that got new errors when I implemented these new checks. Reviewers: tskeith, DavidTruby, sscalpone Subscribers: jfb, llvm-commits Tags: #llvm, #flang Differential Revision: https://reviews.llvm.org/D79263
2020-05-02 04:00:28 +08:00
[flang] lib/evaluate work for structure constructors Original-commit: flang-compiler/f18@76a192f9c9b009ea52409f25b81dcb7aa2866234 Reviewed-on: https://github.com/flang-compiler/f18/pull/439
2019-05-04 02:29:15 +08:00
std::optional<SpecificCall> Probe(const CallCharacteristics &,
ActualArguments &, FoldingContext &, const IntrinsicProcTable &) const;
[flang] checkpoint Original-commit: flang-compiler/f18@e103152671f6f1a03417a265bbf581ec50b42d81 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-06 00:57:53 +08:00
[flang] Add IntrinsicProcTable::IsSpecificIntrinsicFunction This replaces IsUnrestrictedSpecificIntrinsicFunction and returns information that allows the caller to distinguish between restricted and unrestricted intrinsics. The new case in `resolve46.f90` used to get an internal error. Original-commit: flang-compiler/f18@4cb1ee10b90bbc5e3c4899ab136fad4d1e841195 Reviewed-on: https://github.com/flang-compiler/f18/pull/928 Tree-same-pre-rewrite: false
2020-01-07 07:56:32 +08:00
std::optional<SpecificIntrinsicFunctionInterface> IsSpecificIntrinsicFunction(
const std::string &) const;
[flang] checkpoint Original-commit: flang-compiler/f18@e7b0f456c9bba153c51c6e775a60e6d01e488271 Reviewed-on: https://github.com/flang-compiler/f18/pull/304 Tree-same-pre-rewrite: false
2019-02-23 07:45:30 +08:00
[flang] [LLVMify F18] Replace the use std::ostream with LLVM streams llvm::ostream This patch replaces the occurrence of std::ostream by llvm::raw_ostream. In LLVM Coding Standards[1] "All new code should use raw_ostream instead of ostream".[1] As a consequence, this patch also replaces the use of: std::stringstream by llvm::raw_string_ostream or llvm::raw_ostream* std::ofstream by llvm::raw_fd_ostream std::endl by '\n' and flush()[2] std::cout by llvm::outs() and std::cerr by llvm::errs() It also replaces std::strerro by llvm::sys::StrError** , but NOT in Fortran runtime libraries *std::stringstream were replaced by llvm::raw_ostream in all methods that used std::stringstream as a parameter. Moreover, it removes the pointers to these streams. [1]https://llvm.org/docs/CodingStandards.html [2]https://releases.llvm.org/2.5/docs/CodingStandards.html#ll_avoidendl Signed-off-by: Caroline Concatto <caroline.concatto@arm.com> Running clang-format-7 Signed-off-by: Caroline Concatto <caroline.concatto@arm.com> Removing residue of ostream library Signed-off-by: Caroline Concatto <caroline.concatto@arm.com> Original-commit: flang-compiler/f18@a3507d44b8911e6024033aa583c1dc54e0eb89fd Reviewed-on: https://github.com/flang-compiler/f18/pull/1047
2020-02-28 23:11:03 +08:00
llvm::raw_ostream &Dump(llvm::raw_ostream &) const;
[flang] checkpoint Original-commit: flang-compiler/f18@e7b0f456c9bba153c51c6e775a60e6d01e488271 Reviewed-on: https://github.com/flang-compiler/f18/pull/304 Tree-same-pre-rewrite: false
2019-02-23 07:45:30 +08:00
private:
[flang] lib/evaluate work for structure constructors Original-commit: flang-compiler/f18@76a192f9c9b009ea52409f25b81dcb7aa2866234 Reviewed-on: https://github.com/flang-compiler/f18/pull/439
2019-05-04 02:29:15 +08:00
DynamicType GetSpecificType(const TypePattern &) const;
[flang] Improve initializer semantics, esp. for component default values This patch plugs many holes in static initializer semantics, improves error messages for default initial values and other component properties in parameterized derived type instantiations, and cleans up several small issues noticed during development. We now do proper scalar expansion, folding, and type, rank, and shape conformance checking for component default initializers in derived types and PDT instantiations. The initial values of named constants are now guaranteed to have been folded when installed in the symbol table, and are no longer folded or scalar-expanded at each use in expression folding. Semantics documentation was extended with information about the various kinds of initializations in Fortran and when each of them are processed in the compiler. Some necessary concomitant changes have bulked this patch out a bit: * contextual messages attachments, which are now produced for parameterized derived type instantiations so that the user can figure out which instance caused a problem with a component, have been added as part of ContextualMessages, and their implementation was debugged * several APIs in evaluate::characteristics was changed so that a FoldingContext is passed as an argument rather than just its intrinsic procedure table; this affected client call sites in many files * new tools in Evaluate/check-expression.cpp to determine when an Expr actually is a single constant value and to validate a non-pointer variable initializer or object component default value * shape conformance checking has additional arguments that control whether scalar expansion is allowed * several now-unused functions and data members noticed and removed * several crashes and bogus errors exposed by testing this new code were fixed * a -fdebug-stack-trace option to enable LLVM's stack tracing on a crash, which might be useful in the future TL;DR: Initialization processing does more and takes place at the right times for all of the various kinds of things that can be initialized. Differential Review: https://reviews.llvm.org/D92783
2020-12-08 04:08:58 +08:00
SpecificCall HandleNull(ActualArguments &, FoldingContext &) const;
[flang] C_F_POINTER Emit INTRINSIC statements in module files Argument checking utility Complete error checking Original-commit: flang-compiler/f18@9c6a88f0482c1f222b37e0cc548c822f80ad00e7 Reviewed-on: https://github.com/flang-compiler/f18/pull/896
2019-12-26 04:29:50 +08:00
std::optional<SpecificCall> HandleC_F_Pointer(
ActualArguments &, FoldingContext &) const;
[flang] lib/evaluate work for structure constructors Original-commit: flang-compiler/f18@76a192f9c9b009ea52409f25b81dcb7aa2866234 Reviewed-on: https://github.com/flang-compiler/f18/pull/439
2019-05-04 02:29:15 +08:00
[flang] checkpoint Original-commit: flang-compiler/f18@e7b0f456c9bba153c51c6e775a60e6d01e488271 Reviewed-on: https://github.com/flang-compiler/f18/pull/304 Tree-same-pre-rewrite: false
2019-02-23 07:45:30 +08:00
common::IntrinsicTypeDefaultKinds defaults_;
std::multimap<std::string, const IntrinsicInterface *> genericFuncs_;
std::multimap<std::string, const SpecificIntrinsicInterface *> specificFuncs_;
[flang] Update preprocessing document, commentary Extend documentation on preprocessing IsSimplyContiguous basic skeleton Apply suggested improvements to mod-file.cc Checks for new call13.f90 (15.4.2.2 explicit interfaces) Implement checking for procedures that can be called via an implicit interface Argument checking, test fixing Better argument checking Better derived type compatibility checking Treat externals as if implicitly interfaced Extend IEEE_EXCEPTIONS module so tests still pass with argument checking SAME_TYPE_AS and EXTENDS_TYPE_OF intrinsic inquiry functions Define interfaces for most intrinsic subroutines Better PASS arguments More with PASS() argument Prep for review address comments fix comment Remove formatted expression from specification expression error message per review more review comments Original-commit: flang-compiler/f18@3cca775da9302e3a2acec4a34800cd7666899b5f Reviewed-on: https://github.com/flang-compiler/f18/pull/776
2019-09-17 07:58:13 +08:00
std::multimap<std::string, const IntrinsicInterface *> subroutines_;
[flang] initial intrinsics table Original-commit: flang-compiler/f18@8b5c3adf887cf88752937a4fa5507c0d66051d3b Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-09-29 08:02:11 +08:00
};
[flang] Tighten rules to resolve procedure as intrinsic procedure 2 Bug fixes: - Do not resolve procedure as intrinsic if they appeared in an EXTERNAL attribute statement (one path was not considering this flag) - Emit an error if a procedure resolved to be an intrinsic function (resp. subroutine) is used as a subroutine (resp. function). Lowering was attempted while the evaluate::Expression for the call was missing without any errors. 1 behavior change: - Do not implicitly resolve subroutines (resp. functions) as intrinsics because their name is the name of an intrinsic function (resp. subroutine). Add justification in documentation. Reviewed By: klausler, tskeith Differential Revision: https://reviews.llvm.org/D90049
2020-10-26 18:25:40 +08:00
bool IntrinsicProcTable::Implementation::IsIntrinsicFunction(
[flang] checkpoint Original-commit: flang-compiler/f18@4d907e3184da8e236d7a3c524cbb4630886f75c9 Reviewed-on: https://github.com/flang-compiler/f18/pull/304 Tree-same-pre-rewrite: false
2019-02-27 06:26:28 +08:00
const std::string &name) const {
auto specificRange{specificFuncs_.equal_range(name)};
if (specificRange.first != specificRange.second) {
return true;
}
auto genericRange{genericFuncs_.equal_range(name)};
if (genericRange.first != genericRange.second) {
return true;
}
[flang] Tighten rules to resolve procedure as intrinsic procedure 2 Bug fixes: - Do not resolve procedure as intrinsic if they appeared in an EXTERNAL attribute statement (one path was not considering this flag) - Emit an error if a procedure resolved to be an intrinsic function (resp. subroutine) is used as a subroutine (resp. function). Lowering was attempted while the evaluate::Expression for the call was missing without any errors. 1 behavior change: - Do not implicitly resolve subroutines (resp. functions) as intrinsics because their name is the name of an intrinsic function (resp. subroutine). Add justification in documentation. Reviewed By: klausler, tskeith Differential Revision: https://reviews.llvm.org/D90049
2020-10-26 18:25:40 +08:00
// special cases
return name == "null";
}
bool IntrinsicProcTable::Implementation::IsIntrinsicSubroutine(
const std::string &name) const {
[flang] Update preprocessing document, commentary Extend documentation on preprocessing IsSimplyContiguous basic skeleton Apply suggested improvements to mod-file.cc Checks for new call13.f90 (15.4.2.2 explicit interfaces) Implement checking for procedures that can be called via an implicit interface Argument checking, test fixing Better argument checking Better derived type compatibility checking Treat externals as if implicitly interfaced Extend IEEE_EXCEPTIONS module so tests still pass with argument checking SAME_TYPE_AS and EXTENDS_TYPE_OF intrinsic inquiry functions Define interfaces for most intrinsic subroutines Better PASS arguments More with PASS() argument Prep for review address comments fix comment Remove formatted expression from specification expression error message per review more review comments Original-commit: flang-compiler/f18@3cca775da9302e3a2acec4a34800cd7666899b5f Reviewed-on: https://github.com/flang-compiler/f18/pull/776
2019-09-17 07:58:13 +08:00
auto subrRange{subroutines_.equal_range(name)};
if (subrRange.first != subrRange.second) {
return true;
}
[flang] checkpoint Original-commit: flang-compiler/f18@4d907e3184da8e236d7a3c524cbb4630886f75c9 Reviewed-on: https://github.com/flang-compiler/f18/pull/304 Tree-same-pre-rewrite: false
2019-02-27 06:26:28 +08:00
// special cases
[flang] Tighten rules to resolve procedure as intrinsic procedure 2 Bug fixes: - Do not resolve procedure as intrinsic if they appeared in an EXTERNAL attribute statement (one path was not considering this flag) - Emit an error if a procedure resolved to be an intrinsic function (resp. subroutine) is used as a subroutine (resp. function). Lowering was attempted while the evaluate::Expression for the call was missing without any errors. 1 behavior change: - Do not implicitly resolve subroutines (resp. functions) as intrinsics because their name is the name of an intrinsic function (resp. subroutine). Add justification in documentation. Reviewed By: klausler, tskeith Differential Revision: https://reviews.llvm.org/D90049
2020-10-26 18:25:40 +08:00
return name == "__builtin_c_f_pointer";
}
bool IntrinsicProcTable::Implementation::IsIntrinsic(
const std::string &name) const {
return IsIntrinsicFunction(name) || IsIntrinsicSubroutine(name);
[flang] C_F_POINTER Emit INTRINSIC statements in module files Argument checking utility Complete error checking Original-commit: flang-compiler/f18@9c6a88f0482c1f222b37e0cc548c822f80ad00e7 Reviewed-on: https://github.com/flang-compiler/f18/pull/896
2019-12-26 04:29:50 +08:00
}
[flang] New implementation for checks for constraints C741 through C750 Summary: Most of these checks were already implemented, and I just added references to them to the code and tests. Also, much of this code was already reviewed in the old flang/f18 GitHub repository, but I didn't get to merge it before we switched repositories. I implemented the check for C747 to not allow coarray components in derived types that are of type C_PTR, C_FUNPTR, or type TEAM_TYPE. I implemented the check for C748 that requires a data component whose type has a coarray ultimate component to be a nonpointer, nonallocatable scalar and not be a coarray. I implemented the check for C750 that adds additional restrictions to the bounds expressions of a derived type component that's an array. These bounds expressions are sepcification expressions as defined in 10.1.11. There was already code in lib/Evaluate/check-expression.cpp to check semantics for specification expressions, but it did not check for the extra requirements of C750. C750 prohibits specification functions, the intrinsic functions ALLOCATED, ASSOCIATED, EXTENDS_TYPE_OF, PRESENT, and SAME_TYPE_AS. It also requires every specification inquiry reference to be a constant expression, and requires that the value of the bound not depend on the value of a variable. To implement these additional checks, I added code to the intrinsic proc table to get the intrinsic class of a procedure. I also added an enumeration to distinguish between specification expressions for derived type component bounds versus for type parameters. I then changed the code to pass an enumeration value to "CheckSpecificationExpr()" to indicate that the expression was a bounds expression and used this value to determine whether to emit an error message when violations of C750 are found. I changed the implementation of IsPureProcedure() to handle statement functions and changed some references in the code that tested for the PURE attribute to call IsPureProcedure(). I also fixed some unrelated tests that got new errors when I implemented these new checks. Reviewers: tskeith, DavidTruby, sscalpone Subscribers: jfb, llvm-commits Tags: #llvm, #flang Differential Revision: https://reviews.llvm.org/D79263
2020-05-02 04:00:28 +08:00
IntrinsicClass IntrinsicProcTable::Implementation::GetIntrinsicClass(
const std::string &name) const {
auto specificIntrinsic{specificFuncs_.find(name)};
if (specificIntrinsic != specificFuncs_.end()) {
return specificIntrinsic->second->intrinsicClass;
}
auto genericIntrinsic{genericFuncs_.find(name)};
if (genericIntrinsic != genericFuncs_.end()) {
return genericIntrinsic->second->intrinsicClass;
}
auto subrIntrinsic{subroutines_.find(name)};
if (subrIntrinsic != subroutines_.end()) {
return subrIntrinsic->second->intrinsicClass;
}
return IntrinsicClass::noClass;
}
[flang] Expose specific to generic intrinsic name mapping The intrinsic lowering facility is based on the generic intrinsic names to avoid duplicating implementations. Specific intrinsics call are re-written to call to the generic versions by the front-end but this cannot be done when specific intrinsics are passed as arguments (the rewrite would give illegal/ambiguous unparsed Fortran). Solve the issue by making the specific to generic name mapping accessible to lowering and can be later used to generate the unrestricted intrinsic functions. Reviewed By: schweitz Differential Revision: https://reviews.llvm.org/D84842
2020-07-30 20:29:24 +08:00
std::string IntrinsicProcTable::Implementation::GetGenericIntrinsicName(
const std::string &name) const {
auto specificIntrinsic{specificFuncs_.find(name)};
if (specificIntrinsic != specificFuncs_.end()) {
if (const char *genericName{specificIntrinsic->second->generic}) {
return {genericName};
}
}
return name;
}
[flang] C_F_POINTER Emit INTRINSIC statements in module files Argument checking utility Complete error checking Original-commit: flang-compiler/f18@9c6a88f0482c1f222b37e0cc548c822f80ad00e7 Reviewed-on: https://github.com/flang-compiler/f18/pull/896
2019-12-26 04:29:50 +08:00
bool CheckAndRearrangeArguments(ActualArguments &arguments,
parser::ContextualMessages &messages, const char *const dummyKeywords[],
std::size_t trailingOptionals) {
std::size_t numDummies{0};
while (dummyKeywords[numDummies]) {
++numDummies;
}
CHECK(trailingOptionals <= numDummies);
if (arguments.size() > numDummies) {
messages.Say("Too many actual arguments (%zd > %zd)"_err_en_US,
arguments.size(), numDummies);
return false;
}
ActualArguments rearranged(numDummies);
bool anyKeywords{false};
std::size_t position{0};
for (std::optional<ActualArgument> &arg : arguments) {
std::size_t dummyIndex{0};
if (arg && arg->keyword()) {
anyKeywords = true;
for (; dummyIndex < numDummies; ++dummyIndex) {
if (*arg->keyword() == dummyKeywords[dummyIndex]) {
break;
}
}
if (dummyIndex >= numDummies) {
messages.Say(*arg->keyword(),
"Unknown argument keyword '%s='"_err_en_US, *arg->keyword());
return false;
}
} else if (anyKeywords) {
messages.Say(
"A positional actual argument may not appear after any keyword arguments"_err_en_US);
return false;
} else {
dummyIndex = position++;
}
if (rearranged[dummyIndex]) {
messages.Say("Dummy argument '%s=' appears more than once"_err_en_US,
dummyKeywords[dummyIndex]);
return false;
}
rearranged[dummyIndex] = std::move(arg);
arg.reset();
}
bool anyMissing{false};
for (std::size_t j{0}; j < numDummies - trailingOptionals; ++j) {
if (!rearranged[j]) {
messages.Say("Dummy argument '%s=' is absent and not OPTIONAL"_err_en_US,
dummyKeywords[j]);
anyMissing = true;
}
}
arguments = std::move(rearranged);
return !anyMissing;
[flang] checkpoint Original-commit: flang-compiler/f18@4d907e3184da8e236d7a3c524cbb4630886f75c9 Reviewed-on: https://github.com/flang-compiler/f18/pull/304 Tree-same-pre-rewrite: false
2019-02-27 06:26:28 +08:00
}
[flang] lib/evaluate work for structure constructors Original-commit: flang-compiler/f18@76a192f9c9b009ea52409f25b81dcb7aa2866234 Reviewed-on: https://github.com/flang-compiler/f18/pull/439
2019-05-04 02:29:15 +08:00
// The NULL() intrinsic is a special case.
SpecificCall IntrinsicProcTable::Implementation::HandleNull(
[flang] Improve initializer semantics, esp. for component default values This patch plugs many holes in static initializer semantics, improves error messages for default initial values and other component properties in parameterized derived type instantiations, and cleans up several small issues noticed during development. We now do proper scalar expansion, folding, and type, rank, and shape conformance checking for component default initializers in derived types and PDT instantiations. The initial values of named constants are now guaranteed to have been folded when installed in the symbol table, and are no longer folded or scalar-expanded at each use in expression folding. Semantics documentation was extended with information about the various kinds of initializations in Fortran and when each of them are processed in the compiler. Some necessary concomitant changes have bulked this patch out a bit: * contextual messages attachments, which are now produced for parameterized derived type instantiations so that the user can figure out which instance caused a problem with a component, have been added as part of ContextualMessages, and their implementation was debugged * several APIs in evaluate::characteristics was changed so that a FoldingContext is passed as an argument rather than just its intrinsic procedure table; this affected client call sites in many files * new tools in Evaluate/check-expression.cpp to determine when an Expr actually is a single constant value and to validate a non-pointer variable initializer or object component default value * shape conformance checking has additional arguments that control whether scalar expansion is allowed * several now-unused functions and data members noticed and removed * several crashes and bogus errors exposed by testing this new code were fixed * a -fdebug-stack-trace option to enable LLVM's stack tracing on a crash, which might be useful in the future TL;DR: Initialization processing does more and takes place at the right times for all of the various kinds of things that can be initialized. Differential Review: https://reviews.llvm.org/D92783
2020-12-08 04:08:58 +08:00
ActualArguments &arguments, FoldingContext &context) const {
[flang] C_F_POINTER Emit INTRINSIC statements in module files Argument checking utility Complete error checking Original-commit: flang-compiler/f18@9c6a88f0482c1f222b37e0cc548c822f80ad00e7 Reviewed-on: https://github.com/flang-compiler/f18/pull/896
2019-12-26 04:29:50 +08:00
static const char *const keywords[]{"mold", nullptr};
if (CheckAndRearrangeArguments(arguments, context.messages(), keywords, 1) &&
arguments[0]) {
if (Expr<SomeType> * mold{arguments[0]->UnwrapExpr()}) {
[flang] Failed call to CHECK() for call to ASSOCIATED(NULL()) Calling "ASSOCATED(NULL()) was causing an internal check of the compiler to fail. I fixed this by changing the entry for "ASSOCIATED" in the intrinsics table to accept "AnyPointer" which contains a new "KindCode" of "pointerType". I also changed the function "FromActual()" to return a typeless intrinsic when called on a pointer, which duplicates its behavior for BOZ literals. This required changing the analysis of procedure arguments. While testing processing for procedure arguments, I found another bad call to `CHECK()` which I fixed. I made several other changes: -- I implemented constant folding for ASSOCIATED(). -- I fixed handling of NULL() in relational operations. -- I implemented semantic analysis for ASSOCIATED(). -- I noticed that the semantics for ASSOCIATED() are similar to those for pointer assignment. So I extracted the code that pointer assignment uses for procedure pointer compatibility to a place where it could be used by the semantic analysis for ASSOCIATED(). -- I couldn't figure out how to make the general semantic analysis for procedure arguments work with ASSOCIATED()'s second argument, which can be either a pointer or a target. So I stopped using normal semantic analysis for arguments for ASSOCIATED(). -- I added tests for all of this. Differential Revision: https://reviews.llvm.org/D88313
2020-09-26 00:03:17 +08:00
bool goodProcPointer{true};
[flang] C_F_POINTER Emit INTRINSIC statements in module files Argument checking utility Complete error checking Original-commit: flang-compiler/f18@9c6a88f0482c1f222b37e0cc548c822f80ad00e7 Reviewed-on: https://github.com/flang-compiler/f18/pull/896
2019-12-26 04:29:50 +08:00
if (IsAllocatableOrPointer(*mold)) {
characteristics::DummyArguments args;
std::optional<characteristics::FunctionResult> fResult;
if (IsProcedurePointer(*mold)) {
// MOLD= procedure pointer
const Symbol *last{GetLastSymbol(*mold)};
CHECK(last);
auto procPointer{
[flang] Improve initializer semantics, esp. for component default values This patch plugs many holes in static initializer semantics, improves error messages for default initial values and other component properties in parameterized derived type instantiations, and cleans up several small issues noticed during development. We now do proper scalar expansion, folding, and type, rank, and shape conformance checking for component default initializers in derived types and PDT instantiations. The initial values of named constants are now guaranteed to have been folded when installed in the symbol table, and are no longer folded or scalar-expanded at each use in expression folding. Semantics documentation was extended with information about the various kinds of initializations in Fortran and when each of them are processed in the compiler. Some necessary concomitant changes have bulked this patch out a bit: * contextual messages attachments, which are now produced for parameterized derived type instantiations so that the user can figure out which instance caused a problem with a component, have been added as part of ContextualMessages, and their implementation was debugged * several APIs in evaluate::characteristics was changed so that a FoldingContext is passed as an argument rather than just its intrinsic procedure table; this affected client call sites in many files * new tools in Evaluate/check-expression.cpp to determine when an Expr actually is a single constant value and to validate a non-pointer variable initializer or object component default value * shape conformance checking has additional arguments that control whether scalar expansion is allowed * several now-unused functions and data members noticed and removed * several crashes and bogus errors exposed by testing this new code were fixed * a -fdebug-stack-trace option to enable LLVM's stack tracing on a crash, which might be useful in the future TL;DR: Initialization processing does more and takes place at the right times for all of the various kinds of things that can be initialized. Differential Review: https://reviews.llvm.org/D92783
2020-12-08 04:08:58 +08:00
characteristics::Procedure::Characterize(*last, context)};
[flang] Failed call to CHECK() for call to ASSOCIATED(NULL()) Calling "ASSOCATED(NULL()) was causing an internal check of the compiler to fail. I fixed this by changing the entry for "ASSOCIATED" in the intrinsics table to accept "AnyPointer" which contains a new "KindCode" of "pointerType". I also changed the function "FromActual()" to return a typeless intrinsic when called on a pointer, which duplicates its behavior for BOZ literals. This required changing the analysis of procedure arguments. While testing processing for procedure arguments, I found another bad call to `CHECK()` which I fixed. I made several other changes: -- I implemented constant folding for ASSOCIATED(). -- I fixed handling of NULL() in relational operations. -- I implemented semantic analysis for ASSOCIATED(). -- I noticed that the semantics for ASSOCIATED() are similar to those for pointer assignment. So I extracted the code that pointer assignment uses for procedure pointer compatibility to a place where it could be used by the semantic analysis for ASSOCIATED(). -- I couldn't figure out how to make the general semantic analysis for procedure arguments work with ASSOCIATED()'s second argument, which can be either a pointer or a target. So I stopped using normal semantic analysis for arguments for ASSOCIATED(). -- I added tests for all of this. Differential Revision: https://reviews.llvm.org/D88313
2020-09-26 00:03:17 +08:00
// procPointer is null if there was an error with the analysis
// associated with the procedure pointer
if (procPointer) {
args.emplace_back("mold"s,
characteristics::DummyProcedure{common::Clone(*procPointer)});
fResult.emplace(std::move(*procPointer));
} else {
goodProcPointer = false;
}
[flang] C_F_POINTER Emit INTRINSIC statements in module files Argument checking utility Complete error checking Original-commit: flang-compiler/f18@9c6a88f0482c1f222b37e0cc548c822f80ad00e7 Reviewed-on: https://github.com/flang-compiler/f18/pull/896
2019-12-26 04:29:50 +08:00
} else if (auto type{mold->GetType()}) {
// MOLD= object pointer
characteristics::TypeAndShape typeAndShape{
*type, GetShape(context, *mold)};
args.emplace_back(
"mold"s, characteristics::DummyDataObject{typeAndShape});
fResult.emplace(std::move(typeAndShape));
} else {
context.messages().Say(
"MOLD= argument to NULL() lacks type"_err_en_US);
[flang] lib/evaluate work for structure constructors Original-commit: flang-compiler/f18@76a192f9c9b009ea52409f25b81dcb7aa2866234 Reviewed-on: https://github.com/flang-compiler/f18/pull/439
2019-05-04 02:29:15 +08:00
}
[flang] Failed call to CHECK() for call to ASSOCIATED(NULL()) Calling "ASSOCATED(NULL()) was causing an internal check of the compiler to fail. I fixed this by changing the entry for "ASSOCIATED" in the intrinsics table to accept "AnyPointer" which contains a new "KindCode" of "pointerType". I also changed the function "FromActual()" to return a typeless intrinsic when called on a pointer, which duplicates its behavior for BOZ literals. This required changing the analysis of procedure arguments. While testing processing for procedure arguments, I found another bad call to `CHECK()` which I fixed. I made several other changes: -- I implemented constant folding for ASSOCIATED(). -- I fixed handling of NULL() in relational operations. -- I implemented semantic analysis for ASSOCIATED(). -- I noticed that the semantics for ASSOCIATED() are similar to those for pointer assignment. So I extracted the code that pointer assignment uses for procedure pointer compatibility to a place where it could be used by the semantic analysis for ASSOCIATED(). -- I couldn't figure out how to make the general semantic analysis for procedure arguments work with ASSOCIATED()'s second argument, which can be either a pointer or a target. So I stopped using normal semantic analysis for arguments for ASSOCIATED(). -- I added tests for all of this. Differential Revision: https://reviews.llvm.org/D88313
2020-09-26 00:03:17 +08:00
if (goodProcPointer) {
fResult->attrs.set(characteristics::FunctionResult::Attr::Pointer);
characteristics::Procedure::Attrs attrs;
attrs.set(characteristics::Procedure::Attr::NullPointer);
characteristics::Procedure chars{
std::move(*fResult), std::move(args), attrs};
return SpecificCall{SpecificIntrinsic{"null"s, std::move(chars)},
std::move(arguments)};
}
[flang] lib/evaluate work for structure constructors Original-commit: flang-compiler/f18@76a192f9c9b009ea52409f25b81dcb7aa2866234 Reviewed-on: https://github.com/flang-compiler/f18/pull/439
2019-05-04 02:29:15 +08:00
}
}
[flang] C_F_POINTER Emit INTRINSIC statements in module files Argument checking utility Complete error checking Original-commit: flang-compiler/f18@9c6a88f0482c1f222b37e0cc548c822f80ad00e7 Reviewed-on: https://github.com/flang-compiler/f18/pull/896
2019-12-26 04:29:50 +08:00
context.messages().Say(
"MOLD= argument to NULL() must be a pointer or allocatable"_err_en_US);
[flang] lib/evaluate work for structure constructors Original-commit: flang-compiler/f18@76a192f9c9b009ea52409f25b81dcb7aa2866234 Reviewed-on: https://github.com/flang-compiler/f18/pull/439
2019-05-04 02:29:15 +08:00
}
characteristics::Procedure::Attrs attrs;
attrs.set(characteristics::Procedure::Attr::NullPointer);
[flang] C_F_POINTER Emit INTRINSIC statements in module files Argument checking utility Complete error checking Original-commit: flang-compiler/f18@9c6a88f0482c1f222b37e0cc548c822f80ad00e7 Reviewed-on: https://github.com/flang-compiler/f18/pull/896
2019-12-26 04:29:50 +08:00
attrs.set(characteristics::Procedure::Attr::Pure);
[flang] lib/evaluate work for structure constructors Original-commit: flang-compiler/f18@76a192f9c9b009ea52409f25b81dcb7aa2866234 Reviewed-on: https://github.com/flang-compiler/f18/pull/439
2019-05-04 02:29:15 +08:00
arguments.clear();
return SpecificCall{
SpecificIntrinsic{"null"s,
characteristics::Procedure{characteristics::DummyArguments{}, attrs}},
std::move(arguments)};
}
[flang] C_F_POINTER Emit INTRINSIC statements in module files Argument checking utility Complete error checking Original-commit: flang-compiler/f18@9c6a88f0482c1f222b37e0cc548c822f80ad00e7 Reviewed-on: https://github.com/flang-compiler/f18/pull/896
2019-12-26 04:29:50 +08:00
// Subroutine C_F_POINTER(CPTR=,FPTR=[,SHAPE=]) from
// intrinsic module ISO_C_BINDING (18.2.3.3)
std::optional<SpecificCall>
IntrinsicProcTable::Implementation::HandleC_F_Pointer(
ActualArguments &arguments, FoldingContext &context) const {
characteristics::Procedure::Attrs attrs;
attrs.set(characteristics::Procedure::Attr::Subroutine);
static const char *const keywords[]{"cptr", "fptr", "shape", nullptr};
characteristics::DummyArguments dummies;
if (CheckAndRearrangeArguments(arguments, context.messages(), keywords, 1)) {
CHECK(arguments.size() == 3);
if (const auto *expr{arguments[0].value().UnwrapExpr()}) {
if (expr->Rank() > 0) {
context.messages().Say(
"CPTR= argument to C_F_POINTER() must be scalar"_err_en_US);
}
if (auto type{expr->GetType()}) {
if (type->category() != TypeCategory::Derived ||
type->IsPolymorphic() ||
type->GetDerivedTypeSpec().typeSymbol().name() !=
"__builtin_c_ptr") {
context.messages().Say(
"CPTR= argument to C_F_POINTER() must be a C_PTR"_err_en_US);
}
characteristics::DummyDataObject cptr{
characteristics::TypeAndShape{*type}};
cptr.intent = common::Intent::In;
dummies.emplace_back("cptr"s, std::move(cptr));
}
}
if (const auto *expr{arguments[1].value().UnwrapExpr()}) {
int fptrRank{expr->Rank()};
if (auto type{expr->GetType()}) {
if (type->HasDeferredTypeParameter()) {
context.messages().Say(
"FPTR= argument to C_F_POINTER() may not have a deferred type parameter"_err_en_US);
}
if (ExtractCoarrayRef(*expr)) {
context.messages().Say(
"FPTR= argument to C_F_POINTER() may not be a coindexed object"_err_en_US);
}
characteristics::DummyDataObject fptr{
characteristics::TypeAndShape{*type, fptrRank}};
fptr.intent = common::Intent::Out;
fptr.attrs.set(characteristics::DummyDataObject::Attr::Pointer);
dummies.emplace_back("fptr"s, std::move(fptr));
}
if (arguments[2] && fptrRank == 0) {
context.messages().Say(
"SHAPE= argument to C_F_POINTER() may not appear when FPTR= is scalar"_err_en_US);
} else if (!arguments[2] && fptrRank > 0) {
context.messages().Say(
"SHAPE= argument to C_F_POINTER() must appear when FPTR= is an array"_err_en_US);
}
[flang] enable semantic analysis by default back out -Mnolargearray default temporarily Fix C_F_POINTER(SHAPE=) argument check, it can be any kind of integer Revert default result kind of SIZE() & al. to standard by default Remove needless usage of -fdebug-semantics Original-commit: flang-compiler/f18@57058a5b163eaa90c7e0f387ea4918f9efa8184c Reviewed-on: https://github.com/flang-compiler/f18/pull/907
2020-01-04 08:32:23 +08:00
if (arguments[2]) {
DynamicType shapeType{
TypeCategory::Integer, defaults_.sizeIntegerKind()};
if (auto type{arguments[2]->GetType()}) {
if (type->category() == TypeCategory::Integer) {
shapeType = *type;
}
}
characteristics::DummyDataObject shape{
characteristics::TypeAndShape{shapeType, 1}};
shape.intent = common::Intent::In;
shape.attrs.set(characteristics::DummyDataObject::Attr::Optional);
dummies.emplace_back("shape"s, std::move(shape));
}
[flang] C_F_POINTER Emit INTRINSIC statements in module files Argument checking utility Complete error checking Original-commit: flang-compiler/f18@9c6a88f0482c1f222b37e0cc548c822f80ad00e7 Reviewed-on: https://github.com/flang-compiler/f18/pull/896
2019-12-26 04:29:50 +08:00
}
}
if (dummies.size() == 3) {
return SpecificCall{
SpecificIntrinsic{"__builtin_c_f_pointer"s,
characteristics::Procedure{std::move(dummies), attrs}},
std::move(arguments)};
} else {
return std::nullopt;
}
}
[flang] Improve initializer semantics, esp. for component default values This patch plugs many holes in static initializer semantics, improves error messages for default initial values and other component properties in parameterized derived type instantiations, and cleans up several small issues noticed during development. We now do proper scalar expansion, folding, and type, rank, and shape conformance checking for component default initializers in derived types and PDT instantiations. The initial values of named constants are now guaranteed to have been folded when installed in the symbol table, and are no longer folded or scalar-expanded at each use in expression folding. Semantics documentation was extended with information about the various kinds of initializations in Fortran and when each of them are processed in the compiler. Some necessary concomitant changes have bulked this patch out a bit: * contextual messages attachments, which are now produced for parameterized derived type instantiations so that the user can figure out which instance caused a problem with a component, have been added as part of ContextualMessages, and their implementation was debugged * several APIs in evaluate::characteristics was changed so that a FoldingContext is passed as an argument rather than just its intrinsic procedure table; this affected client call sites in many files * new tools in Evaluate/check-expression.cpp to determine when an Expr actually is a single constant value and to validate a non-pointer variable initializer or object component default value * shape conformance checking has additional arguments that control whether scalar expansion is allowed * several now-unused functions and data members noticed and removed * several crashes and bogus errors exposed by testing this new code were fixed * a -fdebug-stack-trace option to enable LLVM's stack tracing on a crash, which might be useful in the future TL;DR: Initialization processing does more and takes place at the right times for all of the various kinds of things that can be initialized. Differential Review: https://reviews.llvm.org/D92783
2020-12-08 04:08:58 +08:00
static bool CheckAssociated(SpecificCall &call, FoldingContext &context) {
[flang] Failed call to CHECK() for call to ASSOCIATED(NULL()) Calling "ASSOCATED(NULL()) was causing an internal check of the compiler to fail. I fixed this by changing the entry for "ASSOCIATED" in the intrinsics table to accept "AnyPointer" which contains a new "KindCode" of "pointerType". I also changed the function "FromActual()" to return a typeless intrinsic when called on a pointer, which duplicates its behavior for BOZ literals. This required changing the analysis of procedure arguments. While testing processing for procedure arguments, I found another bad call to `CHECK()` which I fixed. I made several other changes: -- I implemented constant folding for ASSOCIATED(). -- I fixed handling of NULL() in relational operations. -- I implemented semantic analysis for ASSOCIATED(). -- I noticed that the semantics for ASSOCIATED() are similar to those for pointer assignment. So I extracted the code that pointer assignment uses for procedure pointer compatibility to a place where it could be used by the semantic analysis for ASSOCIATED(). -- I couldn't figure out how to make the general semantic analysis for procedure arguments work with ASSOCIATED()'s second argument, which can be either a pointer or a target. So I stopped using normal semantic analysis for arguments for ASSOCIATED(). -- I added tests for all of this. Differential Revision: https://reviews.llvm.org/D88313
2020-09-26 00:03:17 +08:00
bool ok{true};
if (const auto &pointerArg{call.arguments[0]}) {
if (const auto *pointerExpr{pointerArg->UnwrapExpr()}) {
if (const Symbol * pointerSymbol{GetLastSymbol(*pointerExpr)}) {
if (!pointerSymbol->attrs().test(semantics::Attr::POINTER)) {
[flang] Improve initializer semantics, esp. for component default values This patch plugs many holes in static initializer semantics, improves error messages for default initial values and other component properties in parameterized derived type instantiations, and cleans up several small issues noticed during development. We now do proper scalar expansion, folding, and type, rank, and shape conformance checking for component default initializers in derived types and PDT instantiations. The initial values of named constants are now guaranteed to have been folded when installed in the symbol table, and are no longer folded or scalar-expanded at each use in expression folding. Semantics documentation was extended with information about the various kinds of initializations in Fortran and when each of them are processed in the compiler. Some necessary concomitant changes have bulked this patch out a bit: * contextual messages attachments, which are now produced for parameterized derived type instantiations so that the user can figure out which instance caused a problem with a component, have been added as part of ContextualMessages, and their implementation was debugged * several APIs in evaluate::characteristics was changed so that a FoldingContext is passed as an argument rather than just its intrinsic procedure table; this affected client call sites in many files * new tools in Evaluate/check-expression.cpp to determine when an Expr actually is a single constant value and to validate a non-pointer variable initializer or object component default value * shape conformance checking has additional arguments that control whether scalar expansion is allowed * several now-unused functions and data members noticed and removed * several crashes and bogus errors exposed by testing this new code were fixed * a -fdebug-stack-trace option to enable LLVM's stack tracing on a crash, which might be useful in the future TL;DR: Initialization processing does more and takes place at the right times for all of the various kinds of things that can be initialized. Differential Review: https://reviews.llvm.org/D92783
2020-12-08 04:08:58 +08:00
AttachDeclaration(context.messages().Say(
"POINTER= argument of ASSOCIATED() must be a "
"POINTER"_err_en_US),
[flang] Failed call to CHECK() for call to ASSOCIATED(NULL()) Calling "ASSOCATED(NULL()) was causing an internal check of the compiler to fail. I fixed this by changing the entry for "ASSOCIATED" in the intrinsics table to accept "AnyPointer" which contains a new "KindCode" of "pointerType". I also changed the function "FromActual()" to return a typeless intrinsic when called on a pointer, which duplicates its behavior for BOZ literals. This required changing the analysis of procedure arguments. While testing processing for procedure arguments, I found another bad call to `CHECK()` which I fixed. I made several other changes: -- I implemented constant folding for ASSOCIATED(). -- I fixed handling of NULL() in relational operations. -- I implemented semantic analysis for ASSOCIATED(). -- I noticed that the semantics for ASSOCIATED() are similar to those for pointer assignment. So I extracted the code that pointer assignment uses for procedure pointer compatibility to a place where it could be used by the semantic analysis for ASSOCIATED(). -- I couldn't figure out how to make the general semantic analysis for procedure arguments work with ASSOCIATED()'s second argument, which can be either a pointer or a target. So I stopped using normal semantic analysis for arguments for ASSOCIATED(). -- I added tests for all of this. Differential Revision: https://reviews.llvm.org/D88313
2020-09-26 00:03:17 +08:00
*pointerSymbol);
} else {
const auto pointerProc{characteristics::Procedure::Characterize(
[flang] Improve initializer semantics, esp. for component default values This patch plugs many holes in static initializer semantics, improves error messages for default initial values and other component properties in parameterized derived type instantiations, and cleans up several small issues noticed during development. We now do proper scalar expansion, folding, and type, rank, and shape conformance checking for component default initializers in derived types and PDT instantiations. The initial values of named constants are now guaranteed to have been folded when installed in the symbol table, and are no longer folded or scalar-expanded at each use in expression folding. Semantics documentation was extended with information about the various kinds of initializations in Fortran and when each of them are processed in the compiler. Some necessary concomitant changes have bulked this patch out a bit: * contextual messages attachments, which are now produced for parameterized derived type instantiations so that the user can figure out which instance caused a problem with a component, have been added as part of ContextualMessages, and their implementation was debugged * several APIs in evaluate::characteristics was changed so that a FoldingContext is passed as an argument rather than just its intrinsic procedure table; this affected client call sites in many files * new tools in Evaluate/check-expression.cpp to determine when an Expr actually is a single constant value and to validate a non-pointer variable initializer or object component default value * shape conformance checking has additional arguments that control whether scalar expansion is allowed * several now-unused functions and data members noticed and removed * several crashes and bogus errors exposed by testing this new code were fixed * a -fdebug-stack-trace option to enable LLVM's stack tracing on a crash, which might be useful in the future TL;DR: Initialization processing does more and takes place at the right times for all of the various kinds of things that can be initialized. Differential Review: https://reviews.llvm.org/D92783
2020-12-08 04:08:58 +08:00
*pointerSymbol, context)};
[flang] Failed call to CHECK() for call to ASSOCIATED(NULL()) Calling "ASSOCATED(NULL()) was causing an internal check of the compiler to fail. I fixed this by changing the entry for "ASSOCIATED" in the intrinsics table to accept "AnyPointer" which contains a new "KindCode" of "pointerType". I also changed the function "FromActual()" to return a typeless intrinsic when called on a pointer, which duplicates its behavior for BOZ literals. This required changing the analysis of procedure arguments. While testing processing for procedure arguments, I found another bad call to `CHECK()` which I fixed. I made several other changes: -- I implemented constant folding for ASSOCIATED(). -- I fixed handling of NULL() in relational operations. -- I implemented semantic analysis for ASSOCIATED(). -- I noticed that the semantics for ASSOCIATED() are similar to those for pointer assignment. So I extracted the code that pointer assignment uses for procedure pointer compatibility to a place where it could be used by the semantic analysis for ASSOCIATED(). -- I couldn't figure out how to make the general semantic analysis for procedure arguments work with ASSOCIATED()'s second argument, which can be either a pointer or a target. So I stopped using normal semantic analysis for arguments for ASSOCIATED(). -- I added tests for all of this. Differential Revision: https://reviews.llvm.org/D88313
2020-09-26 00:03:17 +08:00
if (const auto &targetArg{call.arguments[1]}) {
if (const auto *targetExpr{targetArg->UnwrapExpr()}) {
std::optional<characteristics::Procedure> targetProc{
std::nullopt};
const Symbol *targetSymbol{GetLastSymbol(*targetExpr)};
bool isCall{false};
std::string targetName;
if (const auto *targetProcRef{// target is a function call
std::get_if<ProcedureRef>(&targetExpr->u)}) {
if (auto targetRefedChars{
characteristics::Procedure::Characterize(
[flang] Improve initializer semantics, esp. for component default values This patch plugs many holes in static initializer semantics, improves error messages for default initial values and other component properties in parameterized derived type instantiations, and cleans up several small issues noticed during development. We now do proper scalar expansion, folding, and type, rank, and shape conformance checking for component default initializers in derived types and PDT instantiations. The initial values of named constants are now guaranteed to have been folded when installed in the symbol table, and are no longer folded or scalar-expanded at each use in expression folding. Semantics documentation was extended with information about the various kinds of initializations in Fortran and when each of them are processed in the compiler. Some necessary concomitant changes have bulked this patch out a bit: * contextual messages attachments, which are now produced for parameterized derived type instantiations so that the user can figure out which instance caused a problem with a component, have been added as part of ContextualMessages, and their implementation was debugged * several APIs in evaluate::characteristics was changed so that a FoldingContext is passed as an argument rather than just its intrinsic procedure table; this affected client call sites in many files * new tools in Evaluate/check-expression.cpp to determine when an Expr actually is a single constant value and to validate a non-pointer variable initializer or object component default value * shape conformance checking has additional arguments that control whether scalar expansion is allowed * several now-unused functions and data members noticed and removed * several crashes and bogus errors exposed by testing this new code were fixed * a -fdebug-stack-trace option to enable LLVM's stack tracing on a crash, which might be useful in the future TL;DR: Initialization processing does more and takes place at the right times for all of the various kinds of things that can be initialized. Differential Review: https://reviews.llvm.org/D92783
2020-12-08 04:08:58 +08:00
*targetProcRef, context)}) {
[flang] Failed call to CHECK() for call to ASSOCIATED(NULL()) Calling "ASSOCATED(NULL()) was causing an internal check of the compiler to fail. I fixed this by changing the entry for "ASSOCIATED" in the intrinsics table to accept "AnyPointer" which contains a new "KindCode" of "pointerType". I also changed the function "FromActual()" to return a typeless intrinsic when called on a pointer, which duplicates its behavior for BOZ literals. This required changing the analysis of procedure arguments. While testing processing for procedure arguments, I found another bad call to `CHECK()` which I fixed. I made several other changes: -- I implemented constant folding for ASSOCIATED(). -- I fixed handling of NULL() in relational operations. -- I implemented semantic analysis for ASSOCIATED(). -- I noticed that the semantics for ASSOCIATED() are similar to those for pointer assignment. So I extracted the code that pointer assignment uses for procedure pointer compatibility to a place where it could be used by the semantic analysis for ASSOCIATED(). -- I couldn't figure out how to make the general semantic analysis for procedure arguments work with ASSOCIATED()'s second argument, which can be either a pointer or a target. So I stopped using normal semantic analysis for arguments for ASSOCIATED(). -- I added tests for all of this. Differential Revision: https://reviews.llvm.org/D88313
2020-09-26 00:03:17 +08:00
targetProc = *targetRefedChars;
targetName = targetProcRef->proc().GetName() + "()";
isCall = true;
}
} else if (targetSymbol && !targetProc) {
// proc that's not a call
targetProc = characteristics::Procedure::Characterize(
[flang] Improve initializer semantics, esp. for component default values This patch plugs many holes in static initializer semantics, improves error messages for default initial values and other component properties in parameterized derived type instantiations, and cleans up several small issues noticed during development. We now do proper scalar expansion, folding, and type, rank, and shape conformance checking for component default initializers in derived types and PDT instantiations. The initial values of named constants are now guaranteed to have been folded when installed in the symbol table, and are no longer folded or scalar-expanded at each use in expression folding. Semantics documentation was extended with information about the various kinds of initializations in Fortran and when each of them are processed in the compiler. Some necessary concomitant changes have bulked this patch out a bit: * contextual messages attachments, which are now produced for parameterized derived type instantiations so that the user can figure out which instance caused a problem with a component, have been added as part of ContextualMessages, and their implementation was debugged * several APIs in evaluate::characteristics was changed so that a FoldingContext is passed as an argument rather than just its intrinsic procedure table; this affected client call sites in many files * new tools in Evaluate/check-expression.cpp to determine when an Expr actually is a single constant value and to validate a non-pointer variable initializer or object component default value * shape conformance checking has additional arguments that control whether scalar expansion is allowed * several now-unused functions and data members noticed and removed * several crashes and bogus errors exposed by testing this new code were fixed * a -fdebug-stack-trace option to enable LLVM's stack tracing on a crash, which might be useful in the future TL;DR: Initialization processing does more and takes place at the right times for all of the various kinds of things that can be initialized. Differential Review: https://reviews.llvm.org/D92783
2020-12-08 04:08:58 +08:00
*targetSymbol, context);
[flang] Failed call to CHECK() for call to ASSOCIATED(NULL()) Calling "ASSOCATED(NULL()) was causing an internal check of the compiler to fail. I fixed this by changing the entry for "ASSOCIATED" in the intrinsics table to accept "AnyPointer" which contains a new "KindCode" of "pointerType". I also changed the function "FromActual()" to return a typeless intrinsic when called on a pointer, which duplicates its behavior for BOZ literals. This required changing the analysis of procedure arguments. While testing processing for procedure arguments, I found another bad call to `CHECK()` which I fixed. I made several other changes: -- I implemented constant folding for ASSOCIATED(). -- I fixed handling of NULL() in relational operations. -- I implemented semantic analysis for ASSOCIATED(). -- I noticed that the semantics for ASSOCIATED() are similar to those for pointer assignment. So I extracted the code that pointer assignment uses for procedure pointer compatibility to a place where it could be used by the semantic analysis for ASSOCIATED(). -- I couldn't figure out how to make the general semantic analysis for procedure arguments work with ASSOCIATED()'s second argument, which can be either a pointer or a target. So I stopped using normal semantic analysis for arguments for ASSOCIATED(). -- I added tests for all of this. Differential Revision: https://reviews.llvm.org/D88313
2020-09-26 00:03:17 +08:00
targetName = targetSymbol->name().ToString();
}
if (pointerProc) {
if (targetProc) {
// procedure pointer and procedure target
if (std::optional<parser::MessageFixedText> msg{
CheckProcCompatibility(
isCall, pointerProc, &*targetProc)}) {
AttachDeclaration(
[flang] Improve initializer semantics, esp. for component default values This patch plugs many holes in static initializer semantics, improves error messages for default initial values and other component properties in parameterized derived type instantiations, and cleans up several small issues noticed during development. We now do proper scalar expansion, folding, and type, rank, and shape conformance checking for component default initializers in derived types and PDT instantiations. The initial values of named constants are now guaranteed to have been folded when installed in the symbol table, and are no longer folded or scalar-expanded at each use in expression folding. Semantics documentation was extended with information about the various kinds of initializations in Fortran and when each of them are processed in the compiler. Some necessary concomitant changes have bulked this patch out a bit: * contextual messages attachments, which are now produced for parameterized derived type instantiations so that the user can figure out which instance caused a problem with a component, have been added as part of ContextualMessages, and their implementation was debugged * several APIs in evaluate::characteristics was changed so that a FoldingContext is passed as an argument rather than just its intrinsic procedure table; this affected client call sites in many files * new tools in Evaluate/check-expression.cpp to determine when an Expr actually is a single constant value and to validate a non-pointer variable initializer or object component default value * shape conformance checking has additional arguments that control whether scalar expansion is allowed * several now-unused functions and data members noticed and removed * several crashes and bogus errors exposed by testing this new code were fixed * a -fdebug-stack-trace option to enable LLVM's stack tracing on a crash, which might be useful in the future TL;DR: Initialization processing does more and takes place at the right times for all of the various kinds of things that can be initialized. Differential Review: https://reviews.llvm.org/D92783
2020-12-08 04:08:58 +08:00
context.messages().Say(std::move(*msg),
[flang] Failed call to CHECK() for call to ASSOCIATED(NULL()) Calling "ASSOCATED(NULL()) was causing an internal check of the compiler to fail. I fixed this by changing the entry for "ASSOCIATED" in the intrinsics table to accept "AnyPointer" which contains a new "KindCode" of "pointerType". I also changed the function "FromActual()" to return a typeless intrinsic when called on a pointer, which duplicates its behavior for BOZ literals. This required changing the analysis of procedure arguments. While testing processing for procedure arguments, I found another bad call to `CHECK()` which I fixed. I made several other changes: -- I implemented constant folding for ASSOCIATED(). -- I fixed handling of NULL() in relational operations. -- I implemented semantic analysis for ASSOCIATED(). -- I noticed that the semantics for ASSOCIATED() are similar to those for pointer assignment. So I extracted the code that pointer assignment uses for procedure pointer compatibility to a place where it could be used by the semantic analysis for ASSOCIATED(). -- I couldn't figure out how to make the general semantic analysis for procedure arguments work with ASSOCIATED()'s second argument, which can be either a pointer or a target. So I stopped using normal semantic analysis for arguments for ASSOCIATED(). -- I added tests for all of this. Differential Revision: https://reviews.llvm.org/D88313
2020-09-26 00:03:17 +08:00
"pointer '" + pointerSymbol->name().ToString() +
"'",
targetName),
*pointerSymbol);
}
} else {
// procedure pointer and object target
if (!IsNullPointer(*targetExpr)) {
AttachDeclaration(
[flang] Improve initializer semantics, esp. for component default values This patch plugs many holes in static initializer semantics, improves error messages for default initial values and other component properties in parameterized derived type instantiations, and cleans up several small issues noticed during development. We now do proper scalar expansion, folding, and type, rank, and shape conformance checking for component default initializers in derived types and PDT instantiations. The initial values of named constants are now guaranteed to have been folded when installed in the symbol table, and are no longer folded or scalar-expanded at each use in expression folding. Semantics documentation was extended with information about the various kinds of initializations in Fortran and when each of them are processed in the compiler. Some necessary concomitant changes have bulked this patch out a bit: * contextual messages attachments, which are now produced for parameterized derived type instantiations so that the user can figure out which instance caused a problem with a component, have been added as part of ContextualMessages, and their implementation was debugged * several APIs in evaluate::characteristics was changed so that a FoldingContext is passed as an argument rather than just its intrinsic procedure table; this affected client call sites in many files * new tools in Evaluate/check-expression.cpp to determine when an Expr actually is a single constant value and to validate a non-pointer variable initializer or object component default value * shape conformance checking has additional arguments that control whether scalar expansion is allowed * several now-unused functions and data members noticed and removed * several crashes and bogus errors exposed by testing this new code were fixed * a -fdebug-stack-trace option to enable LLVM's stack tracing on a crash, which might be useful in the future TL;DR: Initialization processing does more and takes place at the right times for all of the various kinds of things that can be initialized. Differential Review: https://reviews.llvm.org/D92783
2020-12-08 04:08:58 +08:00
context.messages().Say(
[flang] Failed call to CHECK() for call to ASSOCIATED(NULL()) Calling "ASSOCATED(NULL()) was causing an internal check of the compiler to fail. I fixed this by changing the entry for "ASSOCIATED" in the intrinsics table to accept "AnyPointer" which contains a new "KindCode" of "pointerType". I also changed the function "FromActual()" to return a typeless intrinsic when called on a pointer, which duplicates its behavior for BOZ literals. This required changing the analysis of procedure arguments. While testing processing for procedure arguments, I found another bad call to `CHECK()` which I fixed. I made several other changes: -- I implemented constant folding for ASSOCIATED(). -- I fixed handling of NULL() in relational operations. -- I implemented semantic analysis for ASSOCIATED(). -- I noticed that the semantics for ASSOCIATED() are similar to those for pointer assignment. So I extracted the code that pointer assignment uses for procedure pointer compatibility to a place where it could be used by the semantic analysis for ASSOCIATED(). -- I couldn't figure out how to make the general semantic analysis for procedure arguments work with ASSOCIATED()'s second argument, which can be either a pointer or a target. So I stopped using normal semantic analysis for arguments for ASSOCIATED(). -- I added tests for all of this. Differential Revision: https://reviews.llvm.org/D88313
2020-09-26 00:03:17 +08:00
"POINTER= argument '%s' is a procedure "
"pointer but the TARGET= argument '%s' is not a "
"procedure or procedure pointer"_err_en_US,
pointerSymbol->name(), targetName),
*pointerSymbol);
}
}
} else if (targetProc) {
// object pointer and procedure target
AttachDeclaration(
[flang] Improve initializer semantics, esp. for component default values This patch plugs many holes in static initializer semantics, improves error messages for default initial values and other component properties in parameterized derived type instantiations, and cleans up several small issues noticed during development. We now do proper scalar expansion, folding, and type, rank, and shape conformance checking for component default initializers in derived types and PDT instantiations. The initial values of named constants are now guaranteed to have been folded when installed in the symbol table, and are no longer folded or scalar-expanded at each use in expression folding. Semantics documentation was extended with information about the various kinds of initializations in Fortran and when each of them are processed in the compiler. Some necessary concomitant changes have bulked this patch out a bit: * contextual messages attachments, which are now produced for parameterized derived type instantiations so that the user can figure out which instance caused a problem with a component, have been added as part of ContextualMessages, and their implementation was debugged * several APIs in evaluate::characteristics was changed so that a FoldingContext is passed as an argument rather than just its intrinsic procedure table; this affected client call sites in many files * new tools in Evaluate/check-expression.cpp to determine when an Expr actually is a single constant value and to validate a non-pointer variable initializer or object component default value * shape conformance checking has additional arguments that control whether scalar expansion is allowed * several now-unused functions and data members noticed and removed * several crashes and bogus errors exposed by testing this new code were fixed * a -fdebug-stack-trace option to enable LLVM's stack tracing on a crash, which might be useful in the future TL;DR: Initialization processing does more and takes place at the right times for all of the various kinds of things that can be initialized. Differential Review: https://reviews.llvm.org/D92783
2020-12-08 04:08:58 +08:00
context.messages().Say(
"POINTER= argument '%s' is an object pointer "
"but the TARGET= argument '%s' is a "
"procedure designator"_err_en_US,
[flang] Failed call to CHECK() for call to ASSOCIATED(NULL()) Calling "ASSOCATED(NULL()) was causing an internal check of the compiler to fail. I fixed this by changing the entry for "ASSOCIATED" in the intrinsics table to accept "AnyPointer" which contains a new "KindCode" of "pointerType". I also changed the function "FromActual()" to return a typeless intrinsic when called on a pointer, which duplicates its behavior for BOZ literals. This required changing the analysis of procedure arguments. While testing processing for procedure arguments, I found another bad call to `CHECK()` which I fixed. I made several other changes: -- I implemented constant folding for ASSOCIATED(). -- I fixed handling of NULL() in relational operations. -- I implemented semantic analysis for ASSOCIATED(). -- I noticed that the semantics for ASSOCIATED() are similar to those for pointer assignment. So I extracted the code that pointer assignment uses for procedure pointer compatibility to a place where it could be used by the semantic analysis for ASSOCIATED(). -- I couldn't figure out how to make the general semantic analysis for procedure arguments work with ASSOCIATED()'s second argument, which can be either a pointer or a target. So I stopped using normal semantic analysis for arguments for ASSOCIATED(). -- I added tests for all of this. Differential Revision: https://reviews.llvm.org/D88313
2020-09-26 00:03:17 +08:00
pointerSymbol->name(), targetName),
*pointerSymbol);
} else {
// object pointer and target
[flang] Another validity of the TARGET= argument of ASSOCIATED() for objects In my previous implementation of the semantic checks for ASSOCIATED(), I had neglected to check the TARGET= argument for objects to ensure that it has either the POINTER or TARGET attributes. I added an implementation and a test. Differential Revision: https://reviews.llvm.org/D89717
2020-10-20 02:01:13 +08:00
if (const Symbol * targetSymbol{GetLastSymbol(*targetExpr)}) {
if (!(targetSymbol->attrs().test(semantics::Attr::POINTER) ||
targetSymbol->attrs().test(
semantics::Attr::TARGET))) {
AttachDeclaration(
[flang] Improve initializer semantics, esp. for component default values This patch plugs many holes in static initializer semantics, improves error messages for default initial values and other component properties in parameterized derived type instantiations, and cleans up several small issues noticed during development. We now do proper scalar expansion, folding, and type, rank, and shape conformance checking for component default initializers in derived types and PDT instantiations. The initial values of named constants are now guaranteed to have been folded when installed in the symbol table, and are no longer folded or scalar-expanded at each use in expression folding. Semantics documentation was extended with information about the various kinds of initializations in Fortran and when each of them are processed in the compiler. Some necessary concomitant changes have bulked this patch out a bit: * contextual messages attachments, which are now produced for parameterized derived type instantiations so that the user can figure out which instance caused a problem with a component, have been added as part of ContextualMessages, and their implementation was debugged * several APIs in evaluate::characteristics was changed so that a FoldingContext is passed as an argument rather than just its intrinsic procedure table; this affected client call sites in many files * new tools in Evaluate/check-expression.cpp to determine when an Expr actually is a single constant value and to validate a non-pointer variable initializer or object component default value * shape conformance checking has additional arguments that control whether scalar expansion is allowed * several now-unused functions and data members noticed and removed * several crashes and bogus errors exposed by testing this new code were fixed * a -fdebug-stack-trace option to enable LLVM's stack tracing on a crash, which might be useful in the future TL;DR: Initialization processing does more and takes place at the right times for all of the various kinds of things that can be initialized. Differential Review: https://reviews.llvm.org/D92783
2020-12-08 04:08:58 +08:00
context.messages().Say(
"TARGET= argument '%s' must have either "
"the POINTER or the TARGET "
"attribute"_err_en_US,
[flang] Another validity of the TARGET= argument of ASSOCIATED() for objects In my previous implementation of the semantic checks for ASSOCIATED(), I had neglected to check the TARGET= argument for objects to ensure that it has either the POINTER or TARGET attributes. I added an implementation and a test. Differential Revision: https://reviews.llvm.org/D89717
2020-10-20 02:01:13 +08:00
targetName),
*targetSymbol);
}
}
[flang] Failed call to CHECK() for call to ASSOCIATED(NULL()) Calling "ASSOCATED(NULL()) was causing an internal check of the compiler to fail. I fixed this by changing the entry for "ASSOCIATED" in the intrinsics table to accept "AnyPointer" which contains a new "KindCode" of "pointerType". I also changed the function "FromActual()" to return a typeless intrinsic when called on a pointer, which duplicates its behavior for BOZ literals. This required changing the analysis of procedure arguments. While testing processing for procedure arguments, I found another bad call to `CHECK()` which I fixed. I made several other changes: -- I implemented constant folding for ASSOCIATED(). -- I fixed handling of NULL() in relational operations. -- I implemented semantic analysis for ASSOCIATED(). -- I noticed that the semantics for ASSOCIATED() are similar to those for pointer assignment. So I extracted the code that pointer assignment uses for procedure pointer compatibility to a place where it could be used by the semantic analysis for ASSOCIATED(). -- I couldn't figure out how to make the general semantic analysis for procedure arguments work with ASSOCIATED()'s second argument, which can be either a pointer or a target. So I stopped using normal semantic analysis for arguments for ASSOCIATED(). -- I added tests for all of this. Differential Revision: https://reviews.llvm.org/D88313
2020-09-26 00:03:17 +08:00
if (const auto pointerType{pointerArg->GetType()}) {
if (const auto targetType{targetArg->GetType()}) {
ok = pointerType->IsTkCompatibleWith(*targetType);
}
}
}
}
}
}
}
}
} else {
// No arguments to ASSOCIATED()
ok = false;
}
if (!ok) {
[flang] Improve initializer semantics, esp. for component default values This patch plugs many holes in static initializer semantics, improves error messages for default initial values and other component properties in parameterized derived type instantiations, and cleans up several small issues noticed during development. We now do proper scalar expansion, folding, and type, rank, and shape conformance checking for component default initializers in derived types and PDT instantiations. The initial values of named constants are now guaranteed to have been folded when installed in the symbol table, and are no longer folded or scalar-expanded at each use in expression folding. Semantics documentation was extended with information about the various kinds of initializations in Fortran and when each of them are processed in the compiler. Some necessary concomitant changes have bulked this patch out a bit: * contextual messages attachments, which are now produced for parameterized derived type instantiations so that the user can figure out which instance caused a problem with a component, have been added as part of ContextualMessages, and their implementation was debugged * several APIs in evaluate::characteristics was changed so that a FoldingContext is passed as an argument rather than just its intrinsic procedure table; this affected client call sites in many files * new tools in Evaluate/check-expression.cpp to determine when an Expr actually is a single constant value and to validate a non-pointer variable initializer or object component default value * shape conformance checking has additional arguments that control whether scalar expansion is allowed * several now-unused functions and data members noticed and removed * several crashes and bogus errors exposed by testing this new code were fixed * a -fdebug-stack-trace option to enable LLVM's stack tracing on a crash, which might be useful in the future TL;DR: Initialization processing does more and takes place at the right times for all of the various kinds of things that can be initialized. Differential Review: https://reviews.llvm.org/D92783
2020-12-08 04:08:58 +08:00
context.messages().Say(
[flang] Failed call to CHECK() for call to ASSOCIATED(NULL()) Calling "ASSOCATED(NULL()) was causing an internal check of the compiler to fail. I fixed this by changing the entry for "ASSOCIATED" in the intrinsics table to accept "AnyPointer" which contains a new "KindCode" of "pointerType". I also changed the function "FromActual()" to return a typeless intrinsic when called on a pointer, which duplicates its behavior for BOZ literals. This required changing the analysis of procedure arguments. While testing processing for procedure arguments, I found another bad call to `CHECK()` which I fixed. I made several other changes: -- I implemented constant folding for ASSOCIATED(). -- I fixed handling of NULL() in relational operations. -- I implemented semantic analysis for ASSOCIATED(). -- I noticed that the semantics for ASSOCIATED() are similar to those for pointer assignment. So I extracted the code that pointer assignment uses for procedure pointer compatibility to a place where it could be used by the semantic analysis for ASSOCIATED(). -- I couldn't figure out how to make the general semantic analysis for procedure arguments work with ASSOCIATED()'s second argument, which can be either a pointer or a target. So I stopped using normal semantic analysis for arguments for ASSOCIATED(). -- I added tests for all of this. Differential Revision: https://reviews.llvm.org/D88313
2020-09-26 00:03:17 +08:00
"Arguments of ASSOCIATED() must be a POINTER and an optional valid target"_err_en_US);
}
return ok;
}
[flang] Fix source provenance of .NOT., add ALLOCATED intrinsic Original-commit: flang-compiler/f18@e7e0de9e0df189f803d609d123b54d3a65182890 Reviewed-on: https://github.com/flang-compiler/f18/pull/505 Tree-same-pre-rewrite: false
2019-06-20 02:50:07 +08:00
// Applies any semantic checks peculiar to an intrinsic.
[flang] Improve initializer semantics, esp. for component default values This patch plugs many holes in static initializer semantics, improves error messages for default initial values and other component properties in parameterized derived type instantiations, and cleans up several small issues noticed during development. We now do proper scalar expansion, folding, and type, rank, and shape conformance checking for component default initializers in derived types and PDT instantiations. The initial values of named constants are now guaranteed to have been folded when installed in the symbol table, and are no longer folded or scalar-expanded at each use in expression folding. Semantics documentation was extended with information about the various kinds of initializations in Fortran and when each of them are processed in the compiler. Some necessary concomitant changes have bulked this patch out a bit: * contextual messages attachments, which are now produced for parameterized derived type instantiations so that the user can figure out which instance caused a problem with a component, have been added as part of ContextualMessages, and their implementation was debugged * several APIs in evaluate::characteristics was changed so that a FoldingContext is passed as an argument rather than just its intrinsic procedure table; this affected client call sites in many files * new tools in Evaluate/check-expression.cpp to determine when an Expr actually is a single constant value and to validate a non-pointer variable initializer or object component default value * shape conformance checking has additional arguments that control whether scalar expansion is allowed * several now-unused functions and data members noticed and removed * several crashes and bogus errors exposed by testing this new code were fixed * a -fdebug-stack-trace option to enable LLVM's stack tracing on a crash, which might be useful in the future TL;DR: Initialization processing does more and takes place at the right times for all of the various kinds of things that can be initialized. Differential Review: https://reviews.llvm.org/D92783
2020-12-08 04:08:58 +08:00
static bool ApplySpecificChecks(SpecificCall &call, FoldingContext &context) {
[flang] Fix source provenance of .NOT., add ALLOCATED intrinsic Original-commit: flang-compiler/f18@e7e0de9e0df189f803d609d123b54d3a65182890 Reviewed-on: https://github.com/flang-compiler/f18/pull/505 Tree-same-pre-rewrite: false
2019-06-20 02:50:07 +08:00
bool ok{true};
const std::string &name{call.specificIntrinsic.name};
if (name == "allocated") {
if (const auto &arg{call.arguments[0]}) {
if (const auto *expr{arg->UnwrapExpr()}) {
if (const Symbol * symbol{GetLastSymbol(*expr)}) {
[flang] Address review comment re: ALLOCATED intrinsic argument Original-commit: flang-compiler/f18@b24381c7df20b3e8157172e0f070ba602f39b820 Reviewed-on: https://github.com/flang-compiler/f18/pull/611 Tree-same-pre-rewrite: false
2019-08-02 05:01:06 +08:00
ok = symbol->attrs().test(semantics::Attr::ALLOCATABLE);
[flang] Fix source provenance of .NOT., add ALLOCATED intrinsic Original-commit: flang-compiler/f18@e7e0de9e0df189f803d609d123b54d3a65182890 Reviewed-on: https://github.com/flang-compiler/f18/pull/505 Tree-same-pre-rewrite: false
2019-06-20 02:50:07 +08:00
}
}
}
if (!ok) {
[flang] Improve initializer semantics, esp. for component default values This patch plugs many holes in static initializer semantics, improves error messages for default initial values and other component properties in parameterized derived type instantiations, and cleans up several small issues noticed during development. We now do proper scalar expansion, folding, and type, rank, and shape conformance checking for component default initializers in derived types and PDT instantiations. The initial values of named constants are now guaranteed to have been folded when installed in the symbol table, and are no longer folded or scalar-expanded at each use in expression folding. Semantics documentation was extended with information about the various kinds of initializations in Fortran and when each of them are processed in the compiler. Some necessary concomitant changes have bulked this patch out a bit: * contextual messages attachments, which are now produced for parameterized derived type instantiations so that the user can figure out which instance caused a problem with a component, have been added as part of ContextualMessages, and their implementation was debugged * several APIs in evaluate::characteristics was changed so that a FoldingContext is passed as an argument rather than just its intrinsic procedure table; this affected client call sites in many files * new tools in Evaluate/check-expression.cpp to determine when an Expr actually is a single constant value and to validate a non-pointer variable initializer or object component default value * shape conformance checking has additional arguments that control whether scalar expansion is allowed * several now-unused functions and data members noticed and removed * several crashes and bogus errors exposed by testing this new code were fixed * a -fdebug-stack-trace option to enable LLVM's stack tracing on a crash, which might be useful in the future TL;DR: Initialization processing does more and takes place at the right times for all of the various kinds of things that can be initialized. Differential Review: https://reviews.llvm.org/D92783
2020-12-08 04:08:58 +08:00
context.messages().Say(
[flang] Fix source provenance of .NOT., add ALLOCATED intrinsic Original-commit: flang-compiler/f18@e7e0de9e0df189f803d609d123b54d3a65182890 Reviewed-on: https://github.com/flang-compiler/f18/pull/505 Tree-same-pre-rewrite: false
2019-06-20 02:50:07 +08:00
"Argument of ALLOCATED() must be an ALLOCATABLE object or component"_err_en_US);
}
[flang] Add DOUBLE COMPLEX intrinsics & ASSOCIATED Original-commit: flang-compiler/f18@fbcc2c0b5daf10010e2917c27e4ac5be1d470a12 Reviewed-on: https://github.com/flang-compiler/f18/pull/531 Tree-same-pre-rewrite: false
2019-06-22 05:04:40 +08:00
} else if (name == "associated") {
[flang] Improve initializer semantics, esp. for component default values This patch plugs many holes in static initializer semantics, improves error messages for default initial values and other component properties in parameterized derived type instantiations, and cleans up several small issues noticed during development. We now do proper scalar expansion, folding, and type, rank, and shape conformance checking for component default initializers in derived types and PDT instantiations. The initial values of named constants are now guaranteed to have been folded when installed in the symbol table, and are no longer folded or scalar-expanded at each use in expression folding. Semantics documentation was extended with information about the various kinds of initializations in Fortran and when each of them are processed in the compiler. Some necessary concomitant changes have bulked this patch out a bit: * contextual messages attachments, which are now produced for parameterized derived type instantiations so that the user can figure out which instance caused a problem with a component, have been added as part of ContextualMessages, and their implementation was debugged * several APIs in evaluate::characteristics was changed so that a FoldingContext is passed as an argument rather than just its intrinsic procedure table; this affected client call sites in many files * new tools in Evaluate/check-expression.cpp to determine when an Expr actually is a single constant value and to validate a non-pointer variable initializer or object component default value * shape conformance checking has additional arguments that control whether scalar expansion is allowed * several now-unused functions and data members noticed and removed * several crashes and bogus errors exposed by testing this new code were fixed * a -fdebug-stack-trace option to enable LLVM's stack tracing on a crash, which might be useful in the future TL;DR: Initialization processing does more and takes place at the right times for all of the various kinds of things that can be initialized. Differential Review: https://reviews.llvm.org/D92783
2020-12-08 04:08:58 +08:00
return CheckAssociated(call, context);
[flang] Add LOC()/%LOC() intrinsics Original-commit: flang-compiler/f18@3a6b90c9f5c1a21a40323e56e2c26f6161d2f79c Reviewed-on: https://github.com/flang-compiler/f18/pull/538 Tree-same-pre-rewrite: false
2019-07-02 04:22:22 +08:00
} else if (name == "loc") {
if (const auto &arg{call.arguments[0]}) {
[flang] Remove most comparisons to nullptr Remove needless usage of has_value() Original-commit: flang-compiler/f18@1da7fcf7a54066b18e521620ecedb79c7cd2eb97 Reviewed-on: https://github.com/flang-compiler/f18/pull/822
2019-11-10 01:29:31 +08:00
ok = arg->GetAssumedTypeDummy() || GetLastSymbol(arg->UnwrapExpr());
[flang] Add LOC()/%LOC() intrinsics Original-commit: flang-compiler/f18@3a6b90c9f5c1a21a40323e56e2c26f6161d2f79c Reviewed-on: https://github.com/flang-compiler/f18/pull/538 Tree-same-pre-rewrite: false
2019-07-02 04:22:22 +08:00
}
if (!ok) {
[flang] Improve initializer semantics, esp. for component default values This patch plugs many holes in static initializer semantics, improves error messages for default initial values and other component properties in parameterized derived type instantiations, and cleans up several small issues noticed during development. We now do proper scalar expansion, folding, and type, rank, and shape conformance checking for component default initializers in derived types and PDT instantiations. The initial values of named constants are now guaranteed to have been folded when installed in the symbol table, and are no longer folded or scalar-expanded at each use in expression folding. Semantics documentation was extended with information about the various kinds of initializations in Fortran and when each of them are processed in the compiler. Some necessary concomitant changes have bulked this patch out a bit: * contextual messages attachments, which are now produced for parameterized derived type instantiations so that the user can figure out which instance caused a problem with a component, have been added as part of ContextualMessages, and their implementation was debugged * several APIs in evaluate::characteristics was changed so that a FoldingContext is passed as an argument rather than just its intrinsic procedure table; this affected client call sites in many files * new tools in Evaluate/check-expression.cpp to determine when an Expr actually is a single constant value and to validate a non-pointer variable initializer or object component default value * shape conformance checking has additional arguments that control whether scalar expansion is allowed * several now-unused functions and data members noticed and removed * several crashes and bogus errors exposed by testing this new code were fixed * a -fdebug-stack-trace option to enable LLVM's stack tracing on a crash, which might be useful in the future TL;DR: Initialization processing does more and takes place at the right times for all of the various kinds of things that can be initialized. Differential Review: https://reviews.llvm.org/D92783
2020-12-08 04:08:58 +08:00
context.messages().Say(
[flang] Add LOC()/%LOC() intrinsics Original-commit: flang-compiler/f18@3a6b90c9f5c1a21a40323e56e2c26f6161d2f79c Reviewed-on: https://github.com/flang-compiler/f18/pull/538 Tree-same-pre-rewrite: false
2019-07-02 04:22:22 +08:00
"Argument of LOC() must be an object or procedure"_err_en_US);
}
[flang] Fix source provenance of .NOT., add ALLOCATED intrinsic Original-commit: flang-compiler/f18@e7e0de9e0df189f803d609d123b54d3a65182890 Reviewed-on: https://github.com/flang-compiler/f18/pull/505 Tree-same-pre-rewrite: false
2019-06-20 02:50:07 +08:00
} else if (name == "present") {
if (const auto &arg{call.arguments[0]}) {
if (const auto *expr{arg->UnwrapExpr()}) {
if (const Symbol * symbol{UnwrapWholeSymbolDataRef(*expr)}) {
ok = symbol->attrs().test(semantics::Attr::OPTIONAL);
}
}
}
if (!ok) {
[flang] Improve initializer semantics, esp. for component default values This patch plugs many holes in static initializer semantics, improves error messages for default initial values and other component properties in parameterized derived type instantiations, and cleans up several small issues noticed during development. We now do proper scalar expansion, folding, and type, rank, and shape conformance checking for component default initializers in derived types and PDT instantiations. The initial values of named constants are now guaranteed to have been folded when installed in the symbol table, and are no longer folded or scalar-expanded at each use in expression folding. Semantics documentation was extended with information about the various kinds of initializations in Fortran and when each of them are processed in the compiler. Some necessary concomitant changes have bulked this patch out a bit: * contextual messages attachments, which are now produced for parameterized derived type instantiations so that the user can figure out which instance caused a problem with a component, have been added as part of ContextualMessages, and their implementation was debugged * several APIs in evaluate::characteristics was changed so that a FoldingContext is passed as an argument rather than just its intrinsic procedure table; this affected client call sites in many files * new tools in Evaluate/check-expression.cpp to determine when an Expr actually is a single constant value and to validate a non-pointer variable initializer or object component default value * shape conformance checking has additional arguments that control whether scalar expansion is allowed * several now-unused functions and data members noticed and removed * several crashes and bogus errors exposed by testing this new code were fixed * a -fdebug-stack-trace option to enable LLVM's stack tracing on a crash, which might be useful in the future TL;DR: Initialization processing does more and takes place at the right times for all of the various kinds of things that can be initialized. Differential Review: https://reviews.llvm.org/D92783
2020-12-08 04:08:58 +08:00
context.messages().Say(
[flang] Fix source provenance of .NOT., add ALLOCATED intrinsic Original-commit: flang-compiler/f18@e7e0de9e0df189f803d609d123b54d3a65182890 Reviewed-on: https://github.com/flang-compiler/f18/pull/505 Tree-same-pre-rewrite: false
2019-06-20 02:50:07 +08:00
"Argument of PRESENT() must be the name of an OPTIONAL dummy argument"_err_en_US);
}
}
return ok;
[flang] Remove extra semicolon Original-commit: flang-compiler/f18@c94327b56b311de059d7cdcf26e59eaaec9117c4 Reviewed-on: https://github.com/flang-compiler/f18/pull/505
2019-06-20 03:37:49 +08:00
}
[flang] Fix source provenance of .NOT., add ALLOCATED intrinsic Original-commit: flang-compiler/f18@e7e0de9e0df189f803d609d123b54d3a65182890 Reviewed-on: https://github.com/flang-compiler/f18/pull/505 Tree-same-pre-rewrite: false
2019-06-20 02:50:07 +08:00
[flang] Refactor IntrinsicProcTable::Implementation::Probe for readability Original-commit: flang-compiler/f18@4a7211e42bfc1d709246b13cc659356d738edd45 Reviewed-on: https://github.com/flang-compiler/f18/pull/749 Tree-same-pre-rewrite: false
2019-09-17 18:11:35 +08:00
static DynamicType GetReturnType(const SpecificIntrinsicInterface &interface,
const common::IntrinsicTypeDefaultKinds &defaults) {
TypeCategory category{TypeCategory::Integer};
switch (interface.result.kindCode) {
[flang] Reformat with latest clang-format and .clang-format Original-commit: flang-compiler/f18@9fe84f45d7fd685051004678d6b5775dcc4c6f8f Reviewed-on: https://github.com/flang-compiler/f18/pull/1094
2020-03-29 12:00:16 +08:00
case KindCode::defaultIntegerKind:
break;
[flang] Refactor IntrinsicProcTable::Implementation::Probe for readability Original-commit: flang-compiler/f18@4a7211e42bfc1d709246b13cc659356d738edd45 Reviewed-on: https://github.com/flang-compiler/f18/pull/749 Tree-same-pre-rewrite: false
2019-09-17 18:11:35 +08:00
case KindCode::doublePrecision:
[flang] Reformat with latest clang-format and .clang-format Original-commit: flang-compiler/f18@9fe84f45d7fd685051004678d6b5775dcc4c6f8f Reviewed-on: https://github.com/flang-compiler/f18/pull/1094
2020-03-29 12:00:16 +08:00
case KindCode::defaultRealKind:
category = TypeCategory::Real;
break;
default:
CRASH_NO_CASE;
[flang] Refactor IntrinsicProcTable::Implementation::Probe for readability Original-commit: flang-compiler/f18@4a7211e42bfc1d709246b13cc659356d738edd45 Reviewed-on: https://github.com/flang-compiler/f18/pull/749 Tree-same-pre-rewrite: false
2019-09-17 18:11:35 +08:00
}
int kind{interface.result.kindCode == KindCode::doublePrecision
? defaults.doublePrecisionKind()
: defaults.GetDefaultKind(category)};
return DynamicType{category, kind};
}
[flang] error messages Original-commit: flang-compiler/f18@392a7330736a8fd444ef92ed5c8ef7dcbc94d461 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-06 02:32:54 +08:00
// Probe the configured intrinsic procedure pattern tables in search of a
// match for a given procedure reference.
[flang] refactor a bit, and rearrange actual arguments into dummy order on intrinsic calls Original-commit: flang-compiler/f18@1f50ace68b00a7db4b75ebce5616032501e48457 Reviewed-on: https://github.com/flang-compiler/f18/pull/219 Tree-same-pre-rewrite: false
2018-10-18 06:09:48 +08:00
std::optional<SpecificCall> IntrinsicProcTable::Implementation::Probe(
const CallCharacteristics &call, ActualArguments &arguments,
[flang] lib/evaluate work for structure constructors Original-commit: flang-compiler/f18@76a192f9c9b009ea52409f25b81dcb7aa2866234 Reviewed-on: https://github.com/flang-compiler/f18/pull/439
2019-05-04 02:29:15 +08:00
FoldingContext &context, const IntrinsicProcTable &intrinsics) const {
[flang] C_F_POINTER Emit INTRINSIC statements in module files Argument checking utility Complete error checking Original-commit: flang-compiler/f18@9c6a88f0482c1f222b37e0cc548c822f80ad00e7 Reviewed-on: https://github.com/flang-compiler/f18/pull/896
2019-12-26 04:29:50 +08:00
// All special cases handled here before the table probes below must
// also be recognized as special names in IsIntrinsic().
if (call.isSubroutineCall) {
if (call.name == "__builtin_c_f_pointer") {
return HandleC_F_Pointer(arguments, context);
}
} else {
if (call.name == "null") {
[flang] Improve initializer semantics, esp. for component default values This patch plugs many holes in static initializer semantics, improves error messages for default initial values and other component properties in parameterized derived type instantiations, and cleans up several small issues noticed during development. We now do proper scalar expansion, folding, and type, rank, and shape conformance checking for component default initializers in derived types and PDT instantiations. The initial values of named constants are now guaranteed to have been folded when installed in the symbol table, and are no longer folded or scalar-expanded at each use in expression folding. Semantics documentation was extended with information about the various kinds of initializations in Fortran and when each of them are processed in the compiler. Some necessary concomitant changes have bulked this patch out a bit: * contextual messages attachments, which are now produced for parameterized derived type instantiations so that the user can figure out which instance caused a problem with a component, have been added as part of ContextualMessages, and their implementation was debugged * several APIs in evaluate::characteristics was changed so that a FoldingContext is passed as an argument rather than just its intrinsic procedure table; this affected client call sites in many files * new tools in Evaluate/check-expression.cpp to determine when an Expr actually is a single constant value and to validate a non-pointer variable initializer or object component default value * shape conformance checking has additional arguments that control whether scalar expansion is allowed * several now-unused functions and data members noticed and removed * several crashes and bogus errors exposed by testing this new code were fixed * a -fdebug-stack-trace option to enable LLVM's stack tracing on a crash, which might be useful in the future TL;DR: Initialization processing does more and takes place at the right times for all of the various kinds of things that can be initialized. Differential Review: https://reviews.llvm.org/D92783
2020-12-08 04:08:58 +08:00
return HandleNull(arguments, context);
[flang] C_F_POINTER Emit INTRINSIC statements in module files Argument checking utility Complete error checking Original-commit: flang-compiler/f18@9c6a88f0482c1f222b37e0cc548c822f80ad00e7 Reviewed-on: https://github.com/flang-compiler/f18/pull/896
2019-12-26 04:29:50 +08:00
}
}
[flang] checkpoint Original-commit: flang-compiler/f18@e103152671f6f1a03417a265bbf581ec50b42d81 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-06 00:57:53 +08:00
if (call.isSubroutineCall) {
[flang] Apply implicit typing to names in COMMON that appear in specification expressions Extend semantic analysis of expressions to catch missing cases Fix statement function semantics, add degree trig intrinsics Add GetUltimate to rewrite of bare namelist Address review comments Original-commit: flang-compiler/f18@52ff319de2e750733660d8e7e938e09159a3c11c Reviewed-on: https://github.com/flang-compiler/f18/pull/871
2019-12-12 07:06:24 +08:00
auto subrRange{subroutines_.equal_range(call.name)};
[flang] Update preprocessing document, commentary Extend documentation on preprocessing IsSimplyContiguous basic skeleton Apply suggested improvements to mod-file.cc Checks for new call13.f90 (15.4.2.2 explicit interfaces) Implement checking for procedures that can be called via an implicit interface Argument checking, test fixing Better argument checking Better derived type compatibility checking Treat externals as if implicitly interfaced Extend IEEE_EXCEPTIONS module so tests still pass with argument checking SAME_TYPE_AS and EXTENDS_TYPE_OF intrinsic inquiry functions Define interfaces for most intrinsic subroutines Better PASS arguments More with PASS() argument Prep for review address comments fix comment Remove formatted expression from specification expression error message per review more review comments Original-commit: flang-compiler/f18@3cca775da9302e3a2acec4a34800cd7666899b5f Reviewed-on: https://github.com/flang-compiler/f18/pull/776
2019-09-17 07:58:13 +08:00
for (auto iter{subrRange.first}; iter != subrRange.second; ++iter) {
if (auto specificCall{
iter->second->Match(call, defaults_, arguments, context)}) {
return specificCall;
}
}
[flang] Tighten rules to resolve procedure as intrinsic procedure 2 Bug fixes: - Do not resolve procedure as intrinsic if they appeared in an EXTERNAL attribute statement (one path was not considering this flag) - Emit an error if a procedure resolved to be an intrinsic function (resp. subroutine) is used as a subroutine (resp. function). Lowering was attempted while the evaluate::Expression for the call was missing without any errors. 1 behavior change: - Do not implicitly resolve subroutines (resp. functions) as intrinsics because their name is the name of an intrinsic function (resp. subroutine). Add justification in documentation. Reviewed By: klausler, tskeith Differential Revision: https://reviews.llvm.org/D90049
2020-10-26 18:25:40 +08:00
if (IsIntrinsicFunction(call.name)) {
context.messages().Say(
"Cannot use intrinsic function '%s' as a subroutine"_err_en_US,
call.name);
}
[flang] Reformat with latest clang-format and .clang-format Original-commit: flang-compiler/f18@9fe84f45d7fd685051004678d6b5775dcc4c6f8f Reviewed-on: https://github.com/flang-compiler/f18/pull/1094
2020-03-29 12:00:16 +08:00
return std::nullopt; // TODO
[flang] checkpoint Original-commit: flang-compiler/f18@e103152671f6f1a03417a265bbf581ec50b42d81 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-06 00:57:53 +08:00
}
[flang] Refactor IntrinsicProcTable::Implementation::Probe for readability Original-commit: flang-compiler/f18@4a7211e42bfc1d709246b13cc659356d738edd45 Reviewed-on: https://github.com/flang-compiler/f18/pull/749 Tree-same-pre-rewrite: false
2019-09-17 18:11:35 +08:00
// Helper to avoid emitting errors before it is sure there is no match
[flang] Interpret intrinsic table more correctly Original-commit: flang-compiler/f18@ff34f32447a8675caeae5c96549f1659c3a98ec3 Reviewed-on: https://github.com/flang-compiler/f18/pull/488 Tree-same-pre-rewrite: false
2019-06-06 06:40:59 +08:00
parser::Messages localBuffer;
[flang] Refactor IntrinsicProcTable::Implementation::Probe for readability Original-commit: flang-compiler/f18@4a7211e42bfc1d709246b13cc659356d738edd45 Reviewed-on: https://github.com/flang-compiler/f18/pull/749 Tree-same-pre-rewrite: false
2019-09-17 18:11:35 +08:00
parser::Messages *finalBuffer{context.messages().messages()};
[flang] work in progress checkpoint: changes build, tests all pass many fixes, ready to test more Further CLASS(*) support More fixes for CLASS(*) Hide data members of DynamicType implement PRESENT() intrinsic Original-commit: flang-compiler/f18@044ba12c20f77c130e3c468914ddc2d6c8652c6e Reviewed-on: https://github.com/flang-compiler/f18/pull/466 Tree-same-pre-rewrite: false
2019-05-14 00:33:18 +08:00
parser::ContextualMessages localMessages{
[flang] Apply implicit typing to names in COMMON that appear in specification expressions Extend semantic analysis of expressions to catch missing cases Fix statement function semantics, add degree trig intrinsics Add GetUltimate to rewrite of bare namelist Address review comments Original-commit: flang-compiler/f18@52ff319de2e750733660d8e7e938e09159a3c11c Reviewed-on: https://github.com/flang-compiler/f18/pull/871
2019-12-12 07:06:24 +08:00
context.messages().at(), finalBuffer ? &localBuffer : nullptr};
[flang] work in progress checkpoint: changes build, tests all pass many fixes, ready to test more Further CLASS(*) support More fixes for CLASS(*) Hide data members of DynamicType implement PRESENT() intrinsic Original-commit: flang-compiler/f18@044ba12c20f77c130e3c468914ddc2d6c8652c6e Reviewed-on: https://github.com/flang-compiler/f18/pull/466 Tree-same-pre-rewrite: false
2019-05-14 00:33:18 +08:00
FoldingContext localContext{context, localMessages};
[flang] Refactor IntrinsicProcTable::Implementation::Probe for readability Original-commit: flang-compiler/f18@4a7211e42bfc1d709246b13cc659356d738edd45 Reviewed-on: https://github.com/flang-compiler/f18/pull/749 Tree-same-pre-rewrite: false
2019-09-17 18:11:35 +08:00
auto matchOrBufferMessages{
[&](const IntrinsicInterface &intrinsic,
parser::Messages &buffer) -> std::optional<SpecificCall> {
if (auto specificCall{
intrinsic.Match(call, defaults_, arguments, localContext)}) {
[flang] Remove most comparisons to nullptr Remove needless usage of has_value() Original-commit: flang-compiler/f18@1da7fcf7a54066b18e521620ecedb79c7cd2eb97 Reviewed-on: https://github.com/flang-compiler/f18/pull/822
2019-11-10 01:29:31 +08:00
if (finalBuffer) {
[flang] Refactor IntrinsicProcTable::Implementation::Probe for readability Original-commit: flang-compiler/f18@4a7211e42bfc1d709246b13cc659356d738edd45 Reviewed-on: https://github.com/flang-compiler/f18/pull/749 Tree-same-pre-rewrite: false
2019-09-17 18:11:35 +08:00
finalBuffer->Annex(std::move(localBuffer));
}
return specificCall;
} else if (buffer.empty()) {
buffer.Annex(std::move(localBuffer));
} else {
localBuffer.clear();
}
return std::nullopt;
}};
// Probe the generic intrinsic function table first.
[flang] begin unit testing Original-commit: flang-compiler/f18@c8b691a4ae7f911363831896ec95684838af19c8 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-12 08:01:31 +08:00
parser::Messages genericBuffer;
[flang] Apply implicit typing to names in COMMON that appear in specification expressions Extend semantic analysis of expressions to catch missing cases Fix statement function semantics, add degree trig intrinsics Add GetUltimate to rewrite of bare namelist Address review comments Original-commit: flang-compiler/f18@52ff319de2e750733660d8e7e938e09159a3c11c Reviewed-on: https://github.com/flang-compiler/f18/pull/871
2019-12-12 07:06:24 +08:00
auto genericRange{genericFuncs_.equal_range(call.name)};
[flang] checkpoint Original-commit: flang-compiler/f18@e103152671f6f1a03417a265bbf581ec50b42d81 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-06 00:57:53 +08:00
for (auto iter{genericRange.first}; iter != genericRange.second; ++iter) {
[flang] refactor a bit, and rearrange actual arguments into dummy order on intrinsic calls Original-commit: flang-compiler/f18@1f50ace68b00a7db4b75ebce5616032501e48457 Reviewed-on: https://github.com/flang-compiler/f18/pull/219 Tree-same-pre-rewrite: false
2018-10-18 06:09:48 +08:00
if (auto specificCall{
[flang] Refactor IntrinsicProcTable::Implementation::Probe for readability Original-commit: flang-compiler/f18@4a7211e42bfc1d709246b13cc659356d738edd45 Reviewed-on: https://github.com/flang-compiler/f18/pull/749 Tree-same-pre-rewrite: false
2019-09-17 18:11:35 +08:00
matchOrBufferMessages(*iter->second, genericBuffer)}) {
[flang] Improve initializer semantics, esp. for component default values This patch plugs many holes in static initializer semantics, improves error messages for default initial values and other component properties in parameterized derived type instantiations, and cleans up several small issues noticed during development. We now do proper scalar expansion, folding, and type, rank, and shape conformance checking for component default initializers in derived types and PDT instantiations. The initial values of named constants are now guaranteed to have been folded when installed in the symbol table, and are no longer folded or scalar-expanded at each use in expression folding. Semantics documentation was extended with information about the various kinds of initializations in Fortran and when each of them are processed in the compiler. Some necessary concomitant changes have bulked this patch out a bit: * contextual messages attachments, which are now produced for parameterized derived type instantiations so that the user can figure out which instance caused a problem with a component, have been added as part of ContextualMessages, and their implementation was debugged * several APIs in evaluate::characteristics was changed so that a FoldingContext is passed as an argument rather than just its intrinsic procedure table; this affected client call sites in many files * new tools in Evaluate/check-expression.cpp to determine when an Expr actually is a single constant value and to validate a non-pointer variable initializer or object component default value * shape conformance checking has additional arguments that control whether scalar expansion is allowed * several now-unused functions and data members noticed and removed * several crashes and bogus errors exposed by testing this new code were fixed * a -fdebug-stack-trace option to enable LLVM's stack tracing on a crash, which might be useful in the future TL;DR: Initialization processing does more and takes place at the right times for all of the various kinds of things that can be initialized. Differential Review: https://reviews.llvm.org/D92783
2020-12-08 04:08:58 +08:00
ApplySpecificChecks(*specificCall, context);
[flang] refactor a bit, and rearrange actual arguments into dummy order on intrinsic calls Original-commit: flang-compiler/f18@1f50ace68b00a7db4b75ebce5616032501e48457 Reviewed-on: https://github.com/flang-compiler/f18/pull/219 Tree-same-pre-rewrite: false
2018-10-18 06:09:48 +08:00
return specificCall;
[flang] checkpoint Original-commit: flang-compiler/f18@e103152671f6f1a03417a265bbf581ec50b42d81 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-06 00:57:53 +08:00
}
}
[flang] Refactor IntrinsicProcTable::Implementation::Probe for readability Original-commit: flang-compiler/f18@4a7211e42bfc1d709246b13cc659356d738edd45 Reviewed-on: https://github.com/flang-compiler/f18/pull/749 Tree-same-pre-rewrite: false
2019-09-17 18:11:35 +08:00
[flang] Interpret intrinsic table more correctly Original-commit: flang-compiler/f18@ff34f32447a8675caeae5c96549f1659c3a98ec3 Reviewed-on: https://github.com/flang-compiler/f18/pull/488 Tree-same-pre-rewrite: false
2019-06-06 06:40:59 +08:00
// Probe the specific intrinsic function table next.
parser::Messages specificBuffer;
[flang] Apply implicit typing to names in COMMON that appear in specification expressions Extend semantic analysis of expressions to catch missing cases Fix statement function semantics, add degree trig intrinsics Add GetUltimate to rewrite of bare namelist Address review comments Original-commit: flang-compiler/f18@52ff319de2e750733660d8e7e938e09159a3c11c Reviewed-on: https://github.com/flang-compiler/f18/pull/871
2019-12-12 07:06:24 +08:00
auto specificRange{specificFuncs_.equal_range(call.name)};
[flang] Interpret intrinsic table more correctly Original-commit: flang-compiler/f18@ff34f32447a8675caeae5c96549f1659c3a98ec3 Reviewed-on: https://github.com/flang-compiler/f18/pull/488 Tree-same-pre-rewrite: false
2019-06-06 06:40:59 +08:00
for (auto specIter{specificRange.first}; specIter != specificRange.second;
++specIter) {
// We only need to check the cases with distinct generic names.
if (const char *genericName{specIter->second->generic}) {
[flang] Refactor IntrinsicProcTable::Implementation::Probe for readability Original-commit: flang-compiler/f18@4a7211e42bfc1d709246b13cc659356d738edd45 Reviewed-on: https://github.com/flang-compiler/f18/pull/749 Tree-same-pre-rewrite: false
2019-09-17 18:11:35 +08:00
if (auto specificCall{
matchOrBufferMessages(*specIter->second, specificBuffer)}) {
[flang] AMAX0, MIN1... rewrite to MAX/MIN: make result conversion explicit Summary: This patch changes speficic extremum functions rewrite to generic MIN/MAX. It applies to AMAX0, AMIN0, AMAX1, AMIN1, MAX0, MIN0, MAX1, MIN1, DMAX1, and DMIN1. - Do not re-write specific extremums to MAX/MIN in intrinsic Probe and let folding rewrite it and introduc the conversion on the MIN/MAX result. - Also make operand promotion explicit in MIN/MAX folding. For instance, after this patch: AMAX0(int8, int4) is rewritten to REAL(MAX(int8, INT(int4, 8))) All this care is to avoid rewritting it to MAX(REAL(int8), REAL(int4)) that may not always be numerically equivalent to the first rewrite. Reviewers: klausler, schweitz, sscalpone, jdoerfert, DavidTruby Reviewed By: klausler, schweitz Subscribers: llvm-commits, flang-commits Tags: #flang, #llvm Differential Revision: https://reviews.llvm.org/D81940
2020-06-18 13:46:19 +08:00
if (!specIter->second->useGenericAndForceResultType) {
specificCall->specificIntrinsic.name = genericName;
}
[flang] Fix issue: Enforce specific intrinsic characteristics Fix issue flang-compiler/f18#661. The issue was that when probing a specific intrinsic, the constraints of the related generic intrinsic were tested instead of the more restrictive constraints of the specific intrinsic. Original-commit: flang-compiler/f18@dd971e901d137f0cef9136250402521dbe266288 Reviewed-on: https://github.com/flang-compiler/f18/pull/680 Tree-same-pre-rewrite: false
2019-08-23 20:03:41 +08:00
specificCall->specificIntrinsic.isRestrictedSpecific =
specIter->second->isRestrictedSpecific;
// TODO test feature AdditionalIntrinsics, warn on nonstandard
// specifics with DoublePrecisionComplex arguments.
return specificCall;
[flang] Interpret intrinsic table more correctly Original-commit: flang-compiler/f18@ff34f32447a8675caeae5c96549f1659c3a98ec3 Reviewed-on: https://github.com/flang-compiler/f18/pull/488 Tree-same-pre-rewrite: false
2019-06-06 06:40:59 +08:00
}
[flang] Refactor IntrinsicProcTable::Implementation::Probe for readability Original-commit: flang-compiler/f18@4a7211e42bfc1d709246b13cc659356d738edd45 Reviewed-on: https://github.com/flang-compiler/f18/pull/749 Tree-same-pre-rewrite: false
2019-09-17 18:11:35 +08:00
}
}
// If there was no exact match with a specific, try to match the related
// generic and convert the result to the specific required type.
for (auto specIter{specificRange.first}; specIter != specificRange.second;
++specIter) {
// We only need to check the cases with distinct generic names.
if (const char *genericName{specIter->second->generic}) {
[flang] Allow more argument types in some specific intrinsic Fix flang-compiler/f18#724. Allow all type kinds for arguments in restricted specific conversion intrinisc (no warning, this is ubiquitous). Allow MAX/MIN restricted intrinsic (AMAX0...) to be replaced by the related generic foolowed by a type conversion to the expected result type of the specific. Emit a warning because xlf and ifort are doing so but pgfortran is converting the arguments instead. Original-commit: flang-compiler/f18@c07adb94ed2b2b46284d6a4a4b23c4189ea1d936 Reviewed-on: https://github.com/flang-compiler/f18/pull/749 Tree-same-pre-rewrite: false
2019-09-17 00:34:10 +08:00
if (specIter->second->useGenericAndForceResultType) {
auto genericRange{genericFuncs_.equal_range(genericName)};
for (auto genIter{genericRange.first}; genIter != genericRange.second;
++genIter) {
[flang] Refactor IntrinsicProcTable::Implementation::Probe for readability Original-commit: flang-compiler/f18@4a7211e42bfc1d709246b13cc659356d738edd45 Reviewed-on: https://github.com/flang-compiler/f18/pull/749 Tree-same-pre-rewrite: false
2019-09-17 18:11:35 +08:00
if (auto specificCall{
matchOrBufferMessages(*genIter->second, specificBuffer)}) {
// Force the call result type to the specific intrinsic result type
DynamicType newType{GetReturnType(*specIter->second, defaults_)};
context.messages().Say(
[flang] AMAX0, MIN1... rewrite to MAX/MIN: make result conversion explicit Summary: This patch changes speficic extremum functions rewrite to generic MIN/MAX. It applies to AMAX0, AMIN0, AMAX1, AMIN1, MAX0, MIN0, MAX1, MIN1, DMAX1, and DMIN1. - Do not re-write specific extremums to MAX/MIN in intrinsic Probe and let folding rewrite it and introduc the conversion on the MIN/MAX result. - Also make operand promotion explicit in MIN/MAX folding. For instance, after this patch: AMAX0(int8, int4) is rewritten to REAL(MAX(int8, INT(int4, 8))) All this care is to avoid rewritting it to MAX(REAL(int8), REAL(int4)) that may not always be numerically equivalent to the first rewrite. Reviewers: klausler, schweitz, sscalpone, jdoerfert, DavidTruby Reviewed By: klausler, schweitz Subscribers: llvm-commits, flang-commits Tags: #flang, #llvm Differential Revision: https://reviews.llvm.org/D81940
2020-06-18 13:46:19 +08:00
"argument types do not match specific intrinsic '%s' "
[flang] Fix typos and style in some comments Original-commit: flang-compiler/f18@621ded353f6179045e8fc4c18ef13a4aa05293b9 Reviewed-on: https://github.com/flang-compiler/f18/pull/749
2019-09-18 23:04:52 +08:00
"requirements; using '%s' generic instead and converting the "
[flang] Address editorial comments and use oxford comma Original-commit: flang-compiler/f18@88a8d1be035b8aacab277526ebc09802cf22e176 Reviewed-on: https://github.com/flang-compiler/f18/pull/749 Tree-same-pre-rewrite: false
2019-09-17 16:54:51 +08:00
"result to %s if needed"_en_US,
[flang] Apply implicit typing to names in COMMON that appear in specification expressions Extend semantic analysis of expressions to catch missing cases Fix statement function semantics, add degree trig intrinsics Add GetUltimate to rewrite of bare namelist Address review comments Original-commit: flang-compiler/f18@52ff319de2e750733660d8e7e938e09159a3c11c Reviewed-on: https://github.com/flang-compiler/f18/pull/871
2019-12-12 07:06:24 +08:00
call.name, genericName, newType.AsFortran());
[flang] AMAX0, MIN1... rewrite to MAX/MIN: make result conversion explicit Summary: This patch changes speficic extremum functions rewrite to generic MIN/MAX. It applies to AMAX0, AMIN0, AMAX1, AMIN1, MAX0, MIN0, MAX1, MIN1, DMAX1, and DMIN1. - Do not re-write specific extremums to MAX/MIN in intrinsic Probe and let folding rewrite it and introduc the conversion on the MIN/MAX result. - Also make operand promotion explicit in MIN/MAX folding. For instance, after this patch: AMAX0(int8, int4) is rewritten to REAL(MAX(int8, INT(int4, 8))) All this care is to avoid rewritting it to MAX(REAL(int8), REAL(int4)) that may not always be numerically equivalent to the first rewrite. Reviewers: klausler, schweitz, sscalpone, jdoerfert, DavidTruby Reviewed By: klausler, schweitz Subscribers: llvm-commits, flang-commits Tags: #flang, #llvm Differential Revision: https://reviews.llvm.org/D81940
2020-06-18 13:46:19 +08:00
specificCall->specificIntrinsic.name = call.name;
[flang] Refactor IntrinsicProcTable::Implementation::Probe for readability Original-commit: flang-compiler/f18@4a7211e42bfc1d709246b13cc659356d738edd45 Reviewed-on: https://github.com/flang-compiler/f18/pull/749 Tree-same-pre-rewrite: false
2019-09-17 18:11:35 +08:00
specificCall->specificIntrinsic.characteristics.value()
.functionResult.value()
.SetType(newType);
[flang] Allow more argument types in some specific intrinsic Fix flang-compiler/f18#724. Allow all type kinds for arguments in restricted specific conversion intrinisc (no warning, this is ubiquitous). Allow MAX/MIN restricted intrinsic (AMAX0...) to be replaced by the related generic foolowed by a type conversion to the expected result type of the specific. Emit a warning because xlf and ifort are doing so but pgfortran is converting the arguments instead. Original-commit: flang-compiler/f18@c07adb94ed2b2b46284d6a4a4b23c4189ea1d936 Reviewed-on: https://github.com/flang-compiler/f18/pull/749 Tree-same-pre-rewrite: false
2019-09-17 00:34:10 +08:00
return specificCall;
}
}
}
[flang] Interpret intrinsic table more correctly Original-commit: flang-compiler/f18@ff34f32447a8675caeae5c96549f1659c3a98ec3 Reviewed-on: https://github.com/flang-compiler/f18/pull/488 Tree-same-pre-rewrite: false
2019-06-06 06:40:59 +08:00
}
}
[flang] Refactor IntrinsicProcTable::Implementation::Probe for readability Original-commit: flang-compiler/f18@4a7211e42bfc1d709246b13cc659356d738edd45 Reviewed-on: https://github.com/flang-compiler/f18/pull/749 Tree-same-pre-rewrite: false
2019-09-17 18:11:35 +08:00
[flang] Tighten rules to resolve procedure as intrinsic procedure 2 Bug fixes: - Do not resolve procedure as intrinsic if they appeared in an EXTERNAL attribute statement (one path was not considering this flag) - Emit an error if a procedure resolved to be an intrinsic function (resp. subroutine) is used as a subroutine (resp. function). Lowering was attempted while the evaluate::Expression for the call was missing without any errors. 1 behavior change: - Do not implicitly resolve subroutines (resp. functions) as intrinsics because their name is the name of an intrinsic function (resp. subroutine). Add justification in documentation. Reviewed By: klausler, tskeith Differential Revision: https://reviews.llvm.org/D90049
2020-10-26 18:25:40 +08:00
if (specificBuffer.empty() && genericBuffer.empty() &&
IsIntrinsicSubroutine(call.name)) {
context.messages().Say(
"Cannot use intrinsic subroutine '%s' as a function"_err_en_US,
call.name);
}
[flang] lib/evaluate work for structure constructors Original-commit: flang-compiler/f18@76a192f9c9b009ea52409f25b81dcb7aa2866234 Reviewed-on: https://github.com/flang-compiler/f18/pull/439
2019-05-04 02:29:15 +08:00
// No match; report the right errors, if any
[flang] Remove most comparisons to nullptr Remove needless usage of has_value() Original-commit: flang-compiler/f18@1da7fcf7a54066b18e521620ecedb79c7cd2eb97 Reviewed-on: https://github.com/flang-compiler/f18/pull/822
2019-11-10 01:29:31 +08:00
if (finalBuffer) {
[flang] Interpret intrinsic table more correctly Original-commit: flang-compiler/f18@ff34f32447a8675caeae5c96549f1659c3a98ec3 Reviewed-on: https://github.com/flang-compiler/f18/pull/488 Tree-same-pre-rewrite: false
2019-06-06 06:40:59 +08:00
if (specificBuffer.empty()) {
[flang] unit testing, better error messages Original-commit: flang-compiler/f18@f3876008d03751fff5d9490cbb1c7b7539e5c095 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-13 07:01:55 +08:00
finalBuffer->Annex(std::move(genericBuffer));
[flang] Interpret intrinsic table more correctly Original-commit: flang-compiler/f18@ff34f32447a8675caeae5c96549f1659c3a98ec3 Reviewed-on: https://github.com/flang-compiler/f18/pull/488 Tree-same-pre-rewrite: false
2019-06-06 06:40:59 +08:00
} else {
finalBuffer->Annex(std::move(specificBuffer));
[flang] begin unit testing Original-commit: flang-compiler/f18@c8b691a4ae7f911363831896ec95684838af19c8 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-12 08:01:31 +08:00
}
[flang] error messages Original-commit: flang-compiler/f18@392a7330736a8fd444ef92ed5c8ef7dcbc94d461 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-06 02:32:54 +08:00
}
[flang] checkpoint Original-commit: flang-compiler/f18@e103152671f6f1a03417a265bbf581ec50b42d81 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-06 00:57:53 +08:00
return std::nullopt;
}
[flang] Add IntrinsicProcTable::IsSpecificIntrinsicFunction This replaces IsUnrestrictedSpecificIntrinsicFunction and returns information that allows the caller to distinguish between restricted and unrestricted intrinsics. The new case in `resolve46.f90` used to get an internal error. Original-commit: flang-compiler/f18@4cb1ee10b90bbc5e3c4899ab136fad4d1e841195 Reviewed-on: https://github.com/flang-compiler/f18/pull/928 Tree-same-pre-rewrite: false
2020-01-07 07:56:32 +08:00
std::optional<SpecificIntrinsicFunctionInterface>
IntrinsicProcTable::Implementation::IsSpecificIntrinsicFunction(
[flang] checkpoint Original-commit: flang-compiler/f18@e7b0f456c9bba153c51c6e775a60e6d01e488271 Reviewed-on: https://github.com/flang-compiler/f18/pull/304 Tree-same-pre-rewrite: false
2019-02-23 07:45:30 +08:00
const std::string &name) const {
auto specificRange{specificFuncs_.equal_range(name)};
for (auto iter{specificRange.first}; iter != specificRange.second; ++iter) {
const SpecificIntrinsicInterface &specific{*iter->second};
[flang] Add IntrinsicProcTable::IsSpecificIntrinsicFunction This replaces IsUnrestrictedSpecificIntrinsicFunction and returns information that allows the caller to distinguish between restricted and unrestricted intrinsics. The new case in `resolve46.f90` used to get an internal error. Original-commit: flang-compiler/f18@4cb1ee10b90bbc5e3c4899ab136fad4d1e841195 Reviewed-on: https://github.com/flang-compiler/f18/pull/928 Tree-same-pre-rewrite: false
2020-01-07 07:56:32 +08:00
std::string genericName{name};
if (specific.generic) {
genericName = std::string(specific.generic);
}
characteristics::FunctionResult fResult{GetSpecificType(specific.result)};
characteristics::DummyArguments args;
int dummies{specific.CountArguments()};
for (int j{0}; j < dummies; ++j) {
characteristics::DummyDataObject dummy{
GetSpecificType(specific.dummy[j].typePattern)};
[flang] Document and use intrinsic subroutine argument intents Check INTENT(OUT)/INTENT(INOUT) constraints for actual argument of intrinsic procedure calls. - Adding a common::Intent field to the IntrinsicDummyArgument in the intrinsic table. - Propagating it to the DummyDataObject intent field so that it can later be used in CheckExplicitDataArg semantic checks. - Add related tests. - Fix regression (C846 false error), C846 INTENT(OUT) rule does not apply to intrinsic call. Propagate the information that we are in an intrinsic call up to CheckExplicitDataArg (that is doing this check). Still enforce C846 on intrinsics other than MOVE_ALLOC (for which allocatable coarrays are explicitly allowed) since it's not clear it is allowed in all intrinsics and allowing this would lead to runtime penalties in the intrinsic runtime. Differential Revision: https://reviews.llvm.org/D89473
2020-10-20 18:39:26 +08:00
dummy.intent = specific.dummy[j].intent;
[flang] Add IntrinsicProcTable::IsSpecificIntrinsicFunction This replaces IsUnrestrictedSpecificIntrinsicFunction and returns information that allows the caller to distinguish between restricted and unrestricted intrinsics. The new case in `resolve46.f90` used to get an internal error. Original-commit: flang-compiler/f18@4cb1ee10b90bbc5e3c4899ab136fad4d1e841195 Reviewed-on: https://github.com/flang-compiler/f18/pull/928 Tree-same-pre-rewrite: false
2020-01-07 07:56:32 +08:00
args.emplace_back(
std::string{specific.dummy[j].keyword}, std::move(dummy));
[flang] checkpoint Original-commit: flang-compiler/f18@e7b0f456c9bba153c51c6e775a60e6d01e488271 Reviewed-on: https://github.com/flang-compiler/f18/pull/304 Tree-same-pre-rewrite: false
2019-02-23 07:45:30 +08:00
}
[flang] Add IntrinsicProcTable::IsSpecificIntrinsicFunction This replaces IsUnrestrictedSpecificIntrinsicFunction and returns information that allows the caller to distinguish between restricted and unrestricted intrinsics. The new case in `resolve46.f90` used to get an internal error. Original-commit: flang-compiler/f18@4cb1ee10b90bbc5e3c4899ab136fad4d1e841195 Reviewed-on: https://github.com/flang-compiler/f18/pull/928 Tree-same-pre-rewrite: false
2020-01-07 07:56:32 +08:00
characteristics::Procedure::Attrs attrs;
attrs.set(characteristics::Procedure::Attr::Pure)
.set(characteristics::Procedure::Attr::Elemental);
characteristics::Procedure chars{
std::move(fResult), std::move(args), attrs};
return SpecificIntrinsicFunctionInterface{
std::move(chars), genericName, specific.isRestrictedSpecific};
[flang] checkpoint Original-commit: flang-compiler/f18@e7b0f456c9bba153c51c6e775a60e6d01e488271 Reviewed-on: https://github.com/flang-compiler/f18/pull/304 Tree-same-pre-rewrite: false
2019-02-23 07:45:30 +08:00
}
return std::nullopt;
}
DynamicType IntrinsicProcTable::Implementation::GetSpecificType(
const TypePattern &pattern) const {
const CategorySet &set{pattern.categorySet};
CHECK(set.count() == 1);
TypeCategory category{set.LeastElement().value()};
return DynamicType{category, defaults_.GetDefaultKind(category)};
}
[flang] Fix pimpl idiom for IntrinsicProcTable. The class IntrinsicProcTable uses the pimpl idiom and manages its own pointer-to-implementation. However, it violates the rule-of-five and does not implement a move-constructor or assignment-operator. Due to differences between compilers in implementation copy elision, these may or may not be used. Due to the missing user implementation for resource handling, using the results in runtime errors. Fix my using `std::unique_ptr` instead of custom resource management. Reviewed By: klausler Differential Revision: https://reviews.llvm.org/D88794
2020-10-24 11:59:57 +08:00
IntrinsicProcTable::~IntrinsicProcTable() = default;
[flang] initial intrinsics table Original-commit: flang-compiler/f18@8b5c3adf887cf88752937a4fa5507c0d66051d3b Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-09-29 08:02:11 +08:00
[flang] debug initial intrinsic table probes Original-commit: flang-compiler/f18@dce9a1e1734f6bbc4aff110ac943649f7dcc066a Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-09 06:35:19 +08:00
IntrinsicProcTable IntrinsicProcTable::Configure(
[flang] Move default intrinsic type kinds from lib/semantics to lib/common Original-commit: flang-compiler/f18@887e72dd613f411808d1b9e9e7b64601a3b67af8 Reviewed-on: https://github.com/flang-compiler/f18/pull/265 Tree-same-pre-rewrite: false
2019-01-19 04:40:47 +08:00
const common::IntrinsicTypeDefaultKinds &defaults) {
[flang] debug initial intrinsic table probes Original-commit: flang-compiler/f18@dce9a1e1734f6bbc4aff110ac943649f7dcc066a Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-09 06:35:19 +08:00
IntrinsicProcTable result;
[flang] Fix pimpl idiom for IntrinsicProcTable. The class IntrinsicProcTable uses the pimpl idiom and manages its own pointer-to-implementation. However, it violates the rule-of-five and does not implement a move-constructor or assignment-operator. Due to differences between compilers in implementation copy elision, these may or may not be used. Due to the missing user implementation for resource handling, using the results in runtime errors. Fix my using `std::unique_ptr` instead of custom resource management. Reviewed By: klausler Differential Revision: https://reviews.llvm.org/D88794
2020-10-24 11:59:57 +08:00
result.impl_ = std::make_unique<IntrinsicProcTable::Implementation>(defaults);
[flang] initial intrinsics table Original-commit: flang-compiler/f18@8b5c3adf887cf88752937a4fa5507c0d66051d3b Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-09-29 08:02:11 +08:00
return result;
}
[flang] checkpoint Original-commit: flang-compiler/f18@4d907e3184da8e236d7a3c524cbb4630886f75c9 Reviewed-on: https://github.com/flang-compiler/f18/pull/304 Tree-same-pre-rewrite: false
2019-02-27 06:26:28 +08:00
bool IntrinsicProcTable::IsIntrinsic(const std::string &name) const {
[flang] Enable more warnings, clean them up Original-commit: flang-compiler/f18@c6b3420e5fd7aca76453ae996bec1c8402a2ab43 Reviewed-on: https://github.com/flang-compiler/f18/pull/774 Tree-same-pre-rewrite: false
2019-10-03 03:40:52 +08:00
return DEREF(impl_).IsIntrinsic(name);
[flang] checkpoint Original-commit: flang-compiler/f18@4d907e3184da8e236d7a3c524cbb4630886f75c9 Reviewed-on: https://github.com/flang-compiler/f18/pull/304 Tree-same-pre-rewrite: false
2019-02-27 06:26:28 +08:00
}
[flang] Tighten rules to resolve procedure as intrinsic procedure 2 Bug fixes: - Do not resolve procedure as intrinsic if they appeared in an EXTERNAL attribute statement (one path was not considering this flag) - Emit an error if a procedure resolved to be an intrinsic function (resp. subroutine) is used as a subroutine (resp. function). Lowering was attempted while the evaluate::Expression for the call was missing without any errors. 1 behavior change: - Do not implicitly resolve subroutines (resp. functions) as intrinsics because their name is the name of an intrinsic function (resp. subroutine). Add justification in documentation. Reviewed By: klausler, tskeith Differential Revision: https://reviews.llvm.org/D90049
2020-10-26 18:25:40 +08:00
bool IntrinsicProcTable::IsIntrinsicFunction(const std::string &name) const {
return DEREF(impl_).IsIntrinsicFunction(name);
}
bool IntrinsicProcTable::IsIntrinsicSubroutine(const std::string &name) const {
return DEREF(impl_).IsIntrinsicSubroutine(name);
}
[flang] checkpoint Original-commit: flang-compiler/f18@4d907e3184da8e236d7a3c524cbb4630886f75c9 Reviewed-on: https://github.com/flang-compiler/f18/pull/304 Tree-same-pre-rewrite: false
2019-02-27 06:26:28 +08:00
[flang] New implementation for checks for constraints C741 through C750 Summary: Most of these checks were already implemented, and I just added references to them to the code and tests. Also, much of this code was already reviewed in the old flang/f18 GitHub repository, but I didn't get to merge it before we switched repositories. I implemented the check for C747 to not allow coarray components in derived types that are of type C_PTR, C_FUNPTR, or type TEAM_TYPE. I implemented the check for C748 that requires a data component whose type has a coarray ultimate component to be a nonpointer, nonallocatable scalar and not be a coarray. I implemented the check for C750 that adds additional restrictions to the bounds expressions of a derived type component that's an array. These bounds expressions are sepcification expressions as defined in 10.1.11. There was already code in lib/Evaluate/check-expression.cpp to check semantics for specification expressions, but it did not check for the extra requirements of C750. C750 prohibits specification functions, the intrinsic functions ALLOCATED, ASSOCIATED, EXTENDS_TYPE_OF, PRESENT, and SAME_TYPE_AS. It also requires every specification inquiry reference to be a constant expression, and requires that the value of the bound not depend on the value of a variable. To implement these additional checks, I added code to the intrinsic proc table to get the intrinsic class of a procedure. I also added an enumeration to distinguish between specification expressions for derived type component bounds versus for type parameters. I then changed the code to pass an enumeration value to "CheckSpecificationExpr()" to indicate that the expression was a bounds expression and used this value to determine whether to emit an error message when violations of C750 are found. I changed the implementation of IsPureProcedure() to handle statement functions and changed some references in the code that tested for the PURE attribute to call IsPureProcedure(). I also fixed some unrelated tests that got new errors when I implemented these new checks. Reviewers: tskeith, DavidTruby, sscalpone Subscribers: jfb, llvm-commits Tags: #llvm, #flang Differential Revision: https://reviews.llvm.org/D79263
2020-05-02 04:00:28 +08:00
IntrinsicClass IntrinsicProcTable::GetIntrinsicClass(
const std::string &name) const {
return DEREF(impl_).GetIntrinsicClass(name);
}
[flang] Expose specific to generic intrinsic name mapping The intrinsic lowering facility is based on the generic intrinsic names to avoid duplicating implementations. Specific intrinsics call are re-written to call to the generic versions by the front-end but this cannot be done when specific intrinsics are passed as arguments (the rewrite would give illegal/ambiguous unparsed Fortran). Solve the issue by making the specific to generic name mapping accessible to lowering and can be later used to generate the unrestricted intrinsic functions. Reviewed By: schweitz Differential Revision: https://reviews.llvm.org/D84842
2020-07-30 20:29:24 +08:00
std::string IntrinsicProcTable::GetGenericIntrinsicName(
const std::string &name) const {
return DEREF(impl_).GetGenericIntrinsicName(name);
}
[flang] refactor a bit, and rearrange actual arguments into dummy order on intrinsic calls Original-commit: flang-compiler/f18@1f50ace68b00a7db4b75ebce5616032501e48457 Reviewed-on: https://github.com/flang-compiler/f18/pull/219 Tree-same-pre-rewrite: false
2018-10-18 06:09:48 +08:00
std::optional<SpecificCall> IntrinsicProcTable::Probe(
const CallCharacteristics &call, ActualArguments &arguments,
[flang] Fold array operations Original-commit: flang-compiler/f18@e6c86ecfd10b77aeac63722c08487ae5de0a0c27 Reviewed-on: https://github.com/flang-compiler/f18/pull/420
2019-04-19 05:11:15 +08:00
FoldingContext &context) const {
[flang] Enable more warnings, clean them up Original-commit: flang-compiler/f18@c6b3420e5fd7aca76453ae996bec1c8402a2ab43 Reviewed-on: https://github.com/flang-compiler/f18/pull/774 Tree-same-pre-rewrite: false
2019-10-03 03:40:52 +08:00
return DEREF(impl_).Probe(call, arguments, context, *this);
[flang] initial intrinsics table Original-commit: flang-compiler/f18@8b5c3adf887cf88752937a4fa5507c0d66051d3b Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-09-29 08:02:11 +08:00
}
[flang] finish most intrinsic table entries Original-commit: flang-compiler/f18@134bd885af5c67ae7fc2291778397546a3d1c189 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-12 05:51:14 +08:00
[flang] Add IntrinsicProcTable::IsSpecificIntrinsicFunction This replaces IsUnrestrictedSpecificIntrinsicFunction and returns information that allows the caller to distinguish between restricted and unrestricted intrinsics. The new case in `resolve46.f90` used to get an internal error. Original-commit: flang-compiler/f18@4cb1ee10b90bbc5e3c4899ab136fad4d1e841195 Reviewed-on: https://github.com/flang-compiler/f18/pull/928 Tree-same-pre-rewrite: false
2020-01-07 07:56:32 +08:00
std::optional<SpecificIntrinsicFunctionInterface>
IntrinsicProcTable::IsSpecificIntrinsicFunction(const std::string &name) const {
return DEREF(impl_).IsSpecificIntrinsicFunction(name);
[flang] checkpoint Original-commit: flang-compiler/f18@e7b0f456c9bba153c51c6e775a60e6d01e488271 Reviewed-on: https://github.com/flang-compiler/f18/pull/304 Tree-same-pre-rewrite: false
2019-02-23 07:45:30 +08:00
}
[flang] [LLVMify F18] Replace the use std::ostream with LLVM streams llvm::ostream This patch replaces the occurrence of std::ostream by llvm::raw_ostream. In LLVM Coding Standards[1] "All new code should use raw_ostream instead of ostream".[1] As a consequence, this patch also replaces the use of: std::stringstream by llvm::raw_string_ostream or llvm::raw_ostream* std::ofstream by llvm::raw_fd_ostream std::endl by '\n' and flush()[2] std::cout by llvm::outs() and std::cerr by llvm::errs() It also replaces std::strerro by llvm::sys::StrError** , but NOT in Fortran runtime libraries *std::stringstream were replaced by llvm::raw_ostream in all methods that used std::stringstream as a parameter. Moreover, it removes the pointers to these streams. [1]https://llvm.org/docs/CodingStandards.html [2]https://releases.llvm.org/2.5/docs/CodingStandards.html#ll_avoidendl Signed-off-by: Caroline Concatto <caroline.concatto@arm.com> Running clang-format-7 Signed-off-by: Caroline Concatto <caroline.concatto@arm.com> Removing residue of ostream library Signed-off-by: Caroline Concatto <caroline.concatto@arm.com> Original-commit: flang-compiler/f18@a3507d44b8911e6024033aa583c1dc54e0eb89fd Reviewed-on: https://github.com/flang-compiler/f18/pull/1047
2020-02-28 23:11:03 +08:00
llvm::raw_ostream &TypePattern::Dump(llvm::raw_ostream &o) const {
[flang] unit testing, better error messages Original-commit: flang-compiler/f18@f3876008d03751fff5d9490cbb1c7b7539e5c095 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-13 07:01:55 +08:00
if (categorySet == AnyType) {
o << "any type";
} else {
const char *sep = "";
auto set{categorySet};
while (auto least{set.LeastElement()}) {
o << sep << EnumToString(*least);
sep = " or ";
set.reset(*least);
}
}
o << '(' << EnumToString(kindCode) << ')';
return o;
}
[flang] [LLVMify F18] Replace the use std::ostream with LLVM streams llvm::ostream This patch replaces the occurrence of std::ostream by llvm::raw_ostream. In LLVM Coding Standards[1] "All new code should use raw_ostream instead of ostream".[1] As a consequence, this patch also replaces the use of: std::stringstream by llvm::raw_string_ostream or llvm::raw_ostream* std::ofstream by llvm::raw_fd_ostream std::endl by '\n' and flush()[2] std::cout by llvm::outs() and std::cerr by llvm::errs() It also replaces std::strerro by llvm::sys::StrError** , but NOT in Fortran runtime libraries *std::stringstream were replaced by llvm::raw_ostream in all methods that used std::stringstream as a parameter. Moreover, it removes the pointers to these streams. [1]https://llvm.org/docs/CodingStandards.html [2]https://releases.llvm.org/2.5/docs/CodingStandards.html#ll_avoidendl Signed-off-by: Caroline Concatto <caroline.concatto@arm.com> Running clang-format-7 Signed-off-by: Caroline Concatto <caroline.concatto@arm.com> Removing residue of ostream library Signed-off-by: Caroline Concatto <caroline.concatto@arm.com> Original-commit: flang-compiler/f18@a3507d44b8911e6024033aa583c1dc54e0eb89fd Reviewed-on: https://github.com/flang-compiler/f18/pull/1047
2020-02-28 23:11:03 +08:00
llvm::raw_ostream &IntrinsicDummyArgument::Dump(llvm::raw_ostream &o) const {
[flang] unit testing, better error messages Original-commit: flang-compiler/f18@f3876008d03751fff5d9490cbb1c7b7539e5c095 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-13 07:01:55 +08:00
if (keyword) {
o << keyword << '=';
}
return typePattern.Dump(o)
[flang] Document and use intrinsic subroutine argument intents Check INTENT(OUT)/INTENT(INOUT) constraints for actual argument of intrinsic procedure calls. - Adding a common::Intent field to the IntrinsicDummyArgument in the intrinsic table. - Propagating it to the DummyDataObject intent field so that it can later be used in CheckExplicitDataArg semantic checks. - Add related tests. - Fix regression (C846 false error), C846 INTENT(OUT) rule does not apply to intrinsic call. Propagate the information that we are in an intrinsic call up to CheckExplicitDataArg (that is doing this check). Still enforce C846 on intrinsics other than MOVE_ALLOC (for which allocatable coarrays are explicitly allowed) since it's not clear it is allowed in all intrinsics and allowing this would lead to runtime penalties in the intrinsic runtime. Differential Revision: https://reviews.llvm.org/D89473
2020-10-20 18:39:26 +08:00
<< ' ' << EnumToString(rank) << ' ' << EnumToString(optionality)
<< EnumToString(intent);
[flang] unit testing, better error messages Original-commit: flang-compiler/f18@f3876008d03751fff5d9490cbb1c7b7539e5c095 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-13 07:01:55 +08:00
}
[flang] [LLVMify F18] Replace the use std::ostream with LLVM streams llvm::ostream This patch replaces the occurrence of std::ostream by llvm::raw_ostream. In LLVM Coding Standards[1] "All new code should use raw_ostream instead of ostream".[1] As a consequence, this patch also replaces the use of: std::stringstream by llvm::raw_string_ostream or llvm::raw_ostream* std::ofstream by llvm::raw_fd_ostream std::endl by '\n' and flush()[2] std::cout by llvm::outs() and std::cerr by llvm::errs() It also replaces std::strerro by llvm::sys::StrError** , but NOT in Fortran runtime libraries *std::stringstream were replaced by llvm::raw_ostream in all methods that used std::stringstream as a parameter. Moreover, it removes the pointers to these streams. [1]https://llvm.org/docs/CodingStandards.html [2]https://releases.llvm.org/2.5/docs/CodingStandards.html#ll_avoidendl Signed-off-by: Caroline Concatto <caroline.concatto@arm.com> Running clang-format-7 Signed-off-by: Caroline Concatto <caroline.concatto@arm.com> Removing residue of ostream library Signed-off-by: Caroline Concatto <caroline.concatto@arm.com> Original-commit: flang-compiler/f18@a3507d44b8911e6024033aa583c1dc54e0eb89fd Reviewed-on: https://github.com/flang-compiler/f18/pull/1047
2020-02-28 23:11:03 +08:00
llvm::raw_ostream &IntrinsicInterface::Dump(llvm::raw_ostream &o) const {
[flang] unit testing, better error messages Original-commit: flang-compiler/f18@f3876008d03751fff5d9490cbb1c7b7539e5c095 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-13 07:01:55 +08:00
o << name;
char sep{'('};
for (const auto &d : dummy) {
if (d.typePattern.kindCode == KindCode::none) {
break;
}
d.Dump(o << sep);
sep = ',';
}
if (sep == '(') {
o << "()";
}
return result.Dump(o << " -> ") << ' ' << EnumToString(rank);
}
[flang] [LLVMify F18] Replace the use std::ostream with LLVM streams llvm::ostream This patch replaces the occurrence of std::ostream by llvm::raw_ostream. In LLVM Coding Standards[1] "All new code should use raw_ostream instead of ostream".[1] As a consequence, this patch also replaces the use of: std::stringstream by llvm::raw_string_ostream or llvm::raw_ostream* std::ofstream by llvm::raw_fd_ostream std::endl by '\n' and flush()[2] std::cout by llvm::outs() and std::cerr by llvm::errs() It also replaces std::strerro by llvm::sys::StrError** , but NOT in Fortran runtime libraries *std::stringstream were replaced by llvm::raw_ostream in all methods that used std::stringstream as a parameter. Moreover, it removes the pointers to these streams. [1]https://llvm.org/docs/CodingStandards.html [2]https://releases.llvm.org/2.5/docs/CodingStandards.html#ll_avoidendl Signed-off-by: Caroline Concatto <caroline.concatto@arm.com> Running clang-format-7 Signed-off-by: Caroline Concatto <caroline.concatto@arm.com> Removing residue of ostream library Signed-off-by: Caroline Concatto <caroline.concatto@arm.com> Original-commit: flang-compiler/f18@a3507d44b8911e6024033aa583c1dc54e0eb89fd Reviewed-on: https://github.com/flang-compiler/f18/pull/1047
2020-02-28 23:11:03 +08:00
llvm::raw_ostream &IntrinsicProcTable::Implementation::Dump(
llvm::raw_ostream &o) const {
[flang] unit testing, better error messages Original-commit: flang-compiler/f18@f3876008d03751fff5d9490cbb1c7b7539e5c095 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-13 07:01:55 +08:00
o << "generic intrinsic functions:\n";
[flang] checkpoint Original-commit: flang-compiler/f18@e7b0f456c9bba153c51c6e775a60e6d01e488271 Reviewed-on: https://github.com/flang-compiler/f18/pull/304 Tree-same-pre-rewrite: false
2019-02-23 07:45:30 +08:00
for (const auto &iter : genericFuncs_) {
[flang] unit testing, better error messages Original-commit: flang-compiler/f18@f3876008d03751fff5d9490cbb1c7b7539e5c095 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-13 07:01:55 +08:00
iter.second->Dump(o << iter.first << ": ") << '\n';
}
o << "specific intrinsic functions:\n";
[flang] checkpoint Original-commit: flang-compiler/f18@e7b0f456c9bba153c51c6e775a60e6d01e488271 Reviewed-on: https://github.com/flang-compiler/f18/pull/304 Tree-same-pre-rewrite: false
2019-02-23 07:45:30 +08:00
for (const auto &iter : specificFuncs_) {
[flang] unit testing, better error messages Original-commit: flang-compiler/f18@f3876008d03751fff5d9490cbb1c7b7539e5c095 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-13 07:01:55 +08:00
iter.second->Dump(o << iter.first << ": ");
if (const char *g{iter.second->generic}) {
o << " -> " << g;
}
o << '\n';
}
[flang] Update preprocessing document, commentary Extend documentation on preprocessing IsSimplyContiguous basic skeleton Apply suggested improvements to mod-file.cc Checks for new call13.f90 (15.4.2.2 explicit interfaces) Implement checking for procedures that can be called via an implicit interface Argument checking, test fixing Better argument checking Better derived type compatibility checking Treat externals as if implicitly interfaced Extend IEEE_EXCEPTIONS module so tests still pass with argument checking SAME_TYPE_AS and EXTENDS_TYPE_OF intrinsic inquiry functions Define interfaces for most intrinsic subroutines Better PASS arguments More with PASS() argument Prep for review address comments fix comment Remove formatted expression from specification expression error message per review more review comments Original-commit: flang-compiler/f18@3cca775da9302e3a2acec4a34800cd7666899b5f Reviewed-on: https://github.com/flang-compiler/f18/pull/776
2019-09-17 07:58:13 +08:00
o << "subroutines:\n";
for (const auto &iter : subroutines_) {
iter.second->Dump(o << iter.first << ": ") << '\n';
}
[flang] unit testing, better error messages Original-commit: flang-compiler/f18@f3876008d03751fff5d9490cbb1c7b7539e5c095 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-13 07:01:55 +08:00
return o;
}
[flang] [LLVMify F18] Replace the use std::ostream with LLVM streams llvm::ostream This patch replaces the occurrence of std::ostream by llvm::raw_ostream. In LLVM Coding Standards[1] "All new code should use raw_ostream instead of ostream".[1] As a consequence, this patch also replaces the use of: std::stringstream by llvm::raw_string_ostream or llvm::raw_ostream* std::ofstream by llvm::raw_fd_ostream std::endl by '\n' and flush()[2] std::cout by llvm::outs() and std::cerr by llvm::errs() It also replaces std::strerro by llvm::sys::StrError** , but NOT in Fortran runtime libraries *std::stringstream were replaced by llvm::raw_ostream in all methods that used std::stringstream as a parameter. Moreover, it removes the pointers to these streams. [1]https://llvm.org/docs/CodingStandards.html [2]https://releases.llvm.org/2.5/docs/CodingStandards.html#ll_avoidendl Signed-off-by: Caroline Concatto <caroline.concatto@arm.com> Running clang-format-7 Signed-off-by: Caroline Concatto <caroline.concatto@arm.com> Removing residue of ostream library Signed-off-by: Caroline Concatto <caroline.concatto@arm.com> Original-commit: flang-compiler/f18@a3507d44b8911e6024033aa583c1dc54e0eb89fd Reviewed-on: https://github.com/flang-compiler/f18/pull/1047
2020-02-28 23:11:03 +08:00
llvm::raw_ostream &IntrinsicProcTable::Dump(llvm::raw_ostream &o) const {
[flang] unit testing, better error messages Original-commit: flang-compiler/f18@f3876008d03751fff5d9490cbb1c7b7539e5c095 Reviewed-on: https://github.com/flang-compiler/f18/pull/212 Tree-same-pre-rewrite: false
2018-10-13 07:01:55 +08:00
return impl_->Dump(o);
}
[flang] Document and use intrinsic subroutine argument intents Check INTENT(OUT)/INTENT(INOUT) constraints for actual argument of intrinsic procedure calls. - Adding a common::Intent field to the IntrinsicDummyArgument in the intrinsic table. - Propagating it to the DummyDataObject intent field so that it can later be used in CheckExplicitDataArg semantic checks. - Add related tests. - Fix regression (C846 false error), C846 INTENT(OUT) rule does not apply to intrinsic call. Propagate the information that we are in an intrinsic call up to CheckExplicitDataArg (that is doing this check). Still enforce C846 on intrinsics other than MOVE_ALLOC (for which allocatable coarrays are explicitly allowed) since it's not clear it is allowed in all intrinsics and allowing this would lead to runtime penalties in the intrinsic runtime. Differential Revision: https://reviews.llvm.org/D89473
2020-10-20 18:39:26 +08:00
// In general C846 prohibits allocatable coarrays to be passed to INTENT(OUT)
// dummy arguments. This rule does not apply to intrinsics in general.
// Some intrinsic explicitly allow coarray allocatable in their description.
// It is assumed that unless explicitly allowed for an intrinsic,
// this is forbidden.
// Since there are very few intrinsic identified that allow this, they are
// listed here instead of adding a field in the table.
bool AcceptsIntentOutAllocatableCoarray(const std::string &intrinsic) {
return intrinsic == "move_alloc";
}
[flang] Reformat with latest clang-format and .clang-format Original-commit: flang-compiler/f18@9fe84f45d7fd685051004678d6b5775dcc4c6f8f Reviewed-on: https://github.com/flang-compiler/f18/pull/1094
2020-03-29 12:00:16 +08:00
} // namespace Fortran::evaluate