squiid/llvm
1
0
Fork 0
Code Issues Pull requests Activity

[flang] Add -i8, -r8, &c. options to f18 development driver

Browse source 
Original-commit: flang-compiler/f18@ff7f338126
Reviewed-on: https://github.com/flang-compiler/f18/pull/213
This commit is contained in:
peter klausler 2018-10-16 14:42:22 -07:00
parent 76effcc5fb
commit 7c402d9c50
6 changed files with 211 additions and 125 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

3
flang/documentation/extensions.md
View file

@ -77,4 +77,5 @@ Extensions and legacy features deliberately not supported
* Default exponent of zero, e.g. `3.14159E`
* Characters in defined operators that are neither letters nor digits
* `B` suffix on unquoted octal constants
* `Z` prefix on unquoted hexadecimal constants
* `Z` prefix on unquoted hexadecimal constants (dangerous)
* `T` and `F` as abbreviations for `.TRUE.` and `.FALSE.` (dangerous)

255
flang/lib/evaluate/intrinsics.cc
View file

@ -87,11 +87,12 @@ struct TypePattern {
// Abbreviations for argument and result patterns in the intrinsic prototypes:
// Match specific kinds of intrinsic types
static constexpr TypePattern DftInt{IntType, KindCode::defaultIntegerKind};
static constexpr TypePattern DftReal{RealType, KindCode::defaultRealKind};
static constexpr TypePattern DftComplex{ComplexType, KindCode::defaultRealKind};
static constexpr TypePattern DftChar{CharType, KindCode::defaultCharKind};
static constexpr TypePattern DftLogical{
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{
LogicalType, KindCode::defaultLogicalKind};
static constexpr TypePattern BOZ{IntType, KindCode::typeless};
static constexpr TypePattern TEAM_TYPE{IntType, KindCode::teamType};
@ -160,6 +161,7 @@ ENUM_CLASS(Rank,
ENUM_CLASS(Optionality, required, optional,
defaultsToSameKind, // for MatchingDefaultKIND
defaultsToDefaultForResult, // for DefaultingKIND
defaultsToSubscriptKind, // for SubscriptDefaultKIND
repeats, // for MAX/MIN and their several variants
)
@ -183,6 +185,11 @@ static constexpr IntrinsicDummyArgument DefaultingKIND{"kind",
static constexpr IntrinsicDummyArgument MatchingDefaultKIND{"kind",
{IntType, KindCode::kindArg}, Rank::scalar,
Optionality::defaultsToSameKind};
// SubscriptDefaultKind is a KIND= argument whose default value is
// the kind of INTEGER used for address calculations.
static constexpr IntrinsicDummyArgument SubscriptDefaultKIND{"kind",
{IntType, KindCode::kindArg}, Rank::scalar,
Optionality::defaultsToSubscriptKind};
static constexpr IntrinsicDummyArgument OptionalDIM{
"dim", {IntType, KindCode::dimArg}, Rank::scalar, Optionality::optional};
static constexpr IntrinsicDummyArgument OptionalMASK{
@ -247,20 +254,20 @@ static const IntrinsicInterface genericIntrinsicFunction[]{
{"bge",
{{"i", AnyInt, Rank::elementalOrBOZ},
{"j", AnyInt, Rank::elementalOrBOZ}},
DftLogical},
DefaultLogical},
{"bgt",
{{"i", AnyInt, Rank::elementalOrBOZ},
{"j", AnyInt, Rank::elementalOrBOZ}},
DftLogical},
DefaultLogical},
{"ble",
{{"i", AnyInt, Rank::elementalOrBOZ},
{"j", AnyInt, Rank::elementalOrBOZ}},
DftLogical},
DefaultLogical},
{"blt",
{{"i", AnyInt, Rank::elementalOrBOZ},
{"j", AnyInt, Rank::elementalOrBOZ}},
DftLogical},
{"btest", {{"i", AnyInt}, {"pos", AnyInt}}, DftLogical},
DefaultLogical},
{"btest", {{"i", AnyInt}, {"pos", AnyInt}}, DefaultLogical},
{"ceiling", {{"a", AnyReal}, DefaultingKIND}, KINDInt},
{"char", {{"i", AnyInt}, DefaultingKIND}, KINDChar},
{"cmplx", {{"x", AnyComplex}, DefaultingKIND}, KINDComplex},
@ -268,7 +275,7 @@ static const IntrinsicInterface genericIntrinsicFunction[]{
{{"x", SameIntOrReal, Rank::elementalOrBOZ},
{"y", SameIntOrReal, Rank::elementalOrBOZ}, DefaultingKIND},
KINDComplex},
{"command_argument_count", {}, DftInt, Rank::scalar},
{"command_argument_count", {}, DefaultInt, Rank::scalar},
{"conjg", {{"z", SameComplex}}, SameComplex},
{"cos", {{"x", SameFloating}}, SameFloating},
{"cosh", {{"x", SameFloating}}, SameFloating},
@ -291,7 +298,7 @@ static const IntrinsicInterface genericIntrinsicFunction[]{
{{"vector_a", AnyIntOrReal, Rank::vector},
{"vector_b", AnyNumeric, Rank::vector}},
ResultNumeric, Rank::scalar},
{"dprod", {{"x", DftReal}, {"y", DftReal}}, DoublePrecision},
{"dprod", {{"x", DefaultReal}, {"y", DefaultReal}}, DoublePrecision},
{"dshiftl",
{{"i", SameInt}, {"j", SameInt, Rank::elementalOrBOZ},
{"shift", AnyInt}},
@ -318,22 +325,22 @@ static const IntrinsicInterface genericIntrinsicFunction[]{
{"erfc", {{"x", SameReal}}, SameReal},
{"erfc_scaled", {{"x", SameReal}}, SameReal},
{"exp", {{"x", SameFloating}}, SameFloating},
{"exponent", {{"x", AnyReal}}, DftInt},
{"exponent", {{"x", AnyReal}}, DefaultInt},
{"findloc",
{{"array", AnyNumeric, Rank::array},
{"value", AnyNumeric, Rank::scalar}, OptionalDIM, OptionalMASK,
DefaultingKIND,
SubscriptDefaultKIND,
{"back", AnyLogical, Rank::scalar, Optionality::optional}},
KINDInt, Rank::dimReduced},
{"findloc",
{{"array", SameChar, Rank::array}, {"value", SameChar, Rank::scalar},
OptionalDIM, OptionalMASK, DefaultingKIND,
OptionalDIM, OptionalMASK, SubscriptDefaultKIND,
{"back", AnyLogical, Rank::scalar, Optionality::optional}},
KINDInt, Rank::dimReduced},
{"findloc",
{{"array", AnyLogical, Rank::array},
{"value", AnyLogical, Rank::scalar}, OptionalDIM, OptionalMASK,
DefaultingKIND,
SubscriptDefaultKIND,
{"back", AnyLogical, Rank::scalar, Optionality::optional}},
KINDInt, Rank::dimReduced},
{"floor", {{"a", AnyReal}, DefaultingKIND}, KINDInt},
@ -358,11 +365,11 @@ static const IntrinsicInterface genericIntrinsicFunction[]{
{"image_status",
{{"image", SameInt},
{"team", TEAM_TYPE, Rank::scalar, Optionality::optional}},
DftInt},
DefaultInt},
{"index",
{{"string", SameChar}, {"substring", SameChar},
{"back", AnyLogical, Rank::scalar, Optionality::optional},
DefaultingKIND},
SubscriptDefaultKIND},
KINDInt},
{"int", {{"a", AnyNumeric, Rank::elementalOrBOZ}, DefaultingKIND}, KINDInt},
{"ior", {{"i", SameInt}, {"j", SameInt, Rank::elementalOrBOZ}}, SameInt},
@ -372,21 +379,23 @@ static const IntrinsicInterface genericIntrinsicFunction[]{
{{"i", SameInt}, {"shift", AnyInt},
{"size", AnyInt, Rank::elemental, Optionality::optional}},
SameInt},
{"is_iostat_end", {{"i", AnyInt}}, DftLogical},
{"is_iostat_eor", {{"i", AnyInt}}, DftLogical},
{"lbound", {{"array", Anything, Rank::anyOrAssumedRank}, DefaultingKIND},
{"is_iostat_end", {{"i", AnyInt}}, DefaultLogical},
{"is_iostat_eor", {{"i", AnyInt}}, DefaultLogical},
{"lbound",
{{"array", Anything, Rank::anyOrAssumedRank}, SubscriptDefaultKIND},
KINDInt, Rank::vector},
{"lbound",
{{"array", Anything, Rank::anyOrAssumedRank},
{"dim", {IntType, KindCode::dimArg}, Rank::scalar}, DefaultingKIND},
{"dim", {IntType, KindCode::dimArg}, Rank::scalar},
SubscriptDefaultKIND},
KINDInt, Rank::scalar},
{"leadz", {{"i", AnyInt}}, DftInt},
{"len", {{"string", AnyChar}, DefaultingKIND}, KINDInt},
{"len_trim", {{"string", AnyChar}, DefaultingKIND}, KINDInt},
{"lge", {{"string_a", SameChar}, {"string_b", SameChar}}, DftLogical},
{"lgt", {{"string_a", SameChar}, {"string_b", SameChar}}, DftLogical},
{"lle", {{"string_a", SameChar}, {"string_b", SameChar}}, DftLogical},
{"llt", {{"string_a", SameChar}, {"string_b", SameChar}}, DftLogical},
{"leadz", {{"i", AnyInt}}, DefaultInt},
{"len", {{"string", AnyChar}, SubscriptDefaultKIND}, KINDInt},
{"len_trim", {{"string", AnyChar}, SubscriptDefaultKIND}, KINDInt},
{"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},
{"log", {{"x", SameFloating}}, SameFloating},
{"log10", {{"x", SameReal}}, SameReal},
{"logical", {{"l", AnyLogical}, DefaultingKIND}, KINDLogical},
@ -423,7 +432,7 @@ static const IntrinsicInterface genericIntrinsicFunction[]{
SameRelatable},
{"maxloc",
{{"array", AnyRelatable, Rank::array}, OptionalDIM, OptionalMASK,
DefaultingKIND,
SubscriptDefaultKIND,
{"back", AnyLogical, Rank::scalar, Optionality::optional}},
KINDInt, Rank::dimReduced},
{"maxval",
@ -445,7 +454,7 @@ static const IntrinsicInterface genericIntrinsicFunction[]{
SameRelatable},
{"minloc",
{{"array", AnyRelatable, Rank::array}, OptionalDIM, OptionalMASK,
DefaultingKIND,
SubscriptDefaultKIND,
{"back", AnyLogical, Rank::scalar, Optionality::optional}},
KINDInt, Rank::dimReduced},
{"minval",
@ -461,12 +470,12 @@ static const IntrinsicInterface genericIntrinsicFunction[]{
// NULL() is a special case handled in Probe() below
{"out_of_range",
{{"x", AnyIntOrReal}, {"mold", AnyIntOrReal, Rank::scalar}},
DftLogical},
DefaultLogical},
{"out_of_range",
{{"x", AnyReal}, {"mold", AnyInt, Rank::scalar},
{"round", AnyLogical, Rank::scalar, Optionality::optional}},
DftLogical},
{"out_of_range", {{"x", AnyReal}, {"mold", AnyReal}}, DftLogical},
DefaultLogical},
{"out_of_range", {{"x", AnyReal}, {"mold", AnyReal}}, DefaultLogical},
{"pack",
{{"array", SameType, Rank::array},
{"mask", AnyLogical, Rank::conformable},
@ -474,8 +483,8 @@ static const IntrinsicInterface genericIntrinsicFunction[]{
SameType, Rank::vector},
{"parity", {{"mask", SameLogical, Rank::array}, OptionalDIM}, SameLogical,
Rank::dimReduced},
{"popcnt", {{"i", AnyInt}}, DftInt},
{"poppar", {{"i", AnyInt}}, DftInt},
{"popcnt", {{"i", AnyInt}}, DefaultInt},
{"poppar", {{"i", AnyInt}}, DefaultInt},
{"product",
{{"array", SameNumeric, Rank::array}, OptionalDIM, OptionalMASK},
SameNumeric, Rank::dimReduced},
@ -499,28 +508,30 @@ static const IntrinsicInterface genericIntrinsicFunction[]{
{"scan",
{{"string", SameChar}, {"set", SameChar},
{"back", AnyLogical, Rank::elemental, Optionality::optional},
DefaultingKIND},
SubscriptDefaultKIND},
KINDInt},
{"selected_char_kind", {{"name", DftChar, Rank::scalar}}, DftInt,
{"selected_char_kind", {{"name", DefaultChar, Rank::scalar}}, DefaultInt,
Rank::scalar},
{"selected_int_kind", {{"r", AnyInt, Rank::scalar}}, DefaultInt,
Rank::scalar},
{"selected_int_kind", {{"r", AnyInt, Rank::scalar}}, DftInt, Rank::scalar},
{"selected_real_kind",
{{"p", AnyInt, Rank::scalar},
{"r", AnyInt, Rank::scalar, Optionality::optional},
{"radix", AnyInt, Rank::scalar, Optionality::optional}},
DftInt, Rank::scalar},
DefaultInt, Rank::scalar},
{"selected_real_kind",
{{"p", AnyInt, Rank::scalar, Optionality::optional},
{"r", AnyInt, Rank::scalar},
{"radix", AnyInt, Rank::scalar, Optionality::optional}},
DftInt, Rank::scalar},
DefaultInt, Rank::scalar},
{"selected_real_kind",
{{"p", AnyInt, Rank::scalar, Optionality::optional},
{"r", AnyInt, Rank::scalar, Optionality::optional},
{"radix", AnyInt, Rank::scalar}},
DftInt, Rank::scalar},
DefaultInt, Rank::scalar},
{"set_exponent", {{"x", SameReal}, {"i", AnyInt}}, SameReal},
{"shape", {{"source", Anything, Rank::anyOrAssumedRank}, DefaultingKIND},
{"shape",
{{"source", Anything, Rank::anyOrAssumedRank}, SubscriptDefaultKIND},
KINDInt, Rank::vector},
{"shifta", {{"i", SameInt}, {"shift", AnyInt}}, SameInt},
{"shiftl", {{"i", SameInt}, {"shift", AnyInt}}, SameInt},
@ -528,11 +539,13 @@ static const IntrinsicInterface genericIntrinsicFunction[]{
{"sign", {{"a", SameIntOrReal}, {"b", SameIntOrReal}}, SameIntOrReal},
{"sin", {{"x", SameFloating}}, SameFloating},
{"sinh", {{"x", SameFloating}}, SameFloating},
{"size", {{"array", Anything, Rank::anyOrAssumedRank}, DefaultingKIND},
{"size",
{{"array", Anything, Rank::anyOrAssumedRank}, SubscriptDefaultKIND},
KINDInt, Rank::vector},
{"size",
{{"array", Anything, Rank::anyOrAssumedRank},
{"dim", {IntType, KindCode::dimArg}, Rank::scalar}, DefaultingKIND},
{"dim", {IntType, KindCode::dimArg}, Rank::scalar},
SubscriptDefaultKIND},
KINDInt, Rank::scalar},
{"spacing", {{"x", SameReal}}, SameReal},
{"spread",
@ -545,7 +558,7 @@ static const IntrinsicInterface genericIntrinsicFunction[]{
SameNumeric, Rank::dimReduced},
{"tan", {{"x", SameFloating}}, SameFloating},
{"tanh", {{"x", SameFloating}}, SameFloating},
{"trailz", {{"i", AnyInt}}, DftInt},
{"trailz", {{"i", AnyInt}}, DefaultInt},
{"transfer",
{{"source", Anything, Rank::known}, {"mold", SameType, Rank::scalar}},
SameType, Rank::scalar},
@ -558,11 +571,13 @@ static const IntrinsicInterface genericIntrinsicFunction[]{
SameType, Rank::vector},
{"transpose", {{"matrix", SameType, Rank::matrix}}, SameType, Rank::matrix},
{"trim", {{"string", SameChar, Rank::scalar}}, SameChar, Rank::scalar},
{"ubound", {{"array", Anything, Rank::anyOrAssumedRank}, DefaultingKIND},
{"ubound",
{{"array", Anything, Rank::anyOrAssumedRank}, SubscriptDefaultKIND},
KINDInt, Rank::vector},
{"ubound",
{{"array", Anything, Rank::anyOrAssumedRank},
{"dim", {IntType, KindCode::dimArg}, Rank::scalar}, DefaultingKIND},
{"dim", {IntType, KindCode::dimArg}, Rank::scalar},
SubscriptDefaultKIND},
KINDInt, Rank::scalar},
{"unpack",
{{"vector", SameType, Rank::vector}, {"mask", AnyLogical, Rank::array},
@ -571,7 +586,7 @@ static const IntrinsicInterface genericIntrinsicFunction[]{
{"verify",
{{"string", SameChar}, {"set", SameChar},
{"back", AnyLogical, Rank::elemental, Optionality::optional},
DefaultingKIND},
SubscriptDefaultKIND},
KINDInt},
};
@ -603,46 +618,46 @@ struct SpecificIntrinsicInterface : public IntrinsicInterface {
};
static const SpecificIntrinsicInterface specificIntrinsicFunction[]{
{{"abs", {{"a", DftReal}}, DftReal}},
{{"acos", {{"x", DftReal}}, DftReal}},
{{"aimag", {{"z", DftComplex}}, DftReal}},
{{"aint", {{"a", DftReal}}, DftReal}},
{{"alog", {{"x", DftReal}}, DftReal}, "log"},
{{"alog10", {{"x", DftReal}}, DftReal}, "log10"},
{{"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"},
{{"amax0",
{{"a1", DftInt}, {"a2", DftInt},
{"a3", DftInt, Rank::elemental, Optionality::repeats}},
DftReal},
{{"a1", DefaultInt}, {"a2", DefaultInt},
{"a3", DefaultInt, Rank::elemental, Optionality::repeats}},
DefaultReal},
"max", true},
{{"amax1",
{{"a1", DftReal}, {"a2", DftReal},
{"a3", DftReal, Rank::elemental, Optionality::repeats}},
DftReal},
{{"a1", DefaultReal}, {"a2", DefaultReal},
{"a3", DefaultReal, Rank::elemental, Optionality::repeats}},
DefaultReal},
"max", true},
{{"amin0",
{{"a1", DftInt}, {"a2", DftInt},
{"a3", DftInt, Rank::elemental, Optionality::repeats}},
DftReal},
{{"a1", DefaultInt}, {"a2", DefaultInt},
{"a3", DefaultInt, Rank::elemental, Optionality::repeats}},
DefaultReal},
"min", true},
{{"amin1",
{{"a1", DftReal}, {"a2", DftReal},
{"a3", DftReal, Rank::elemental, Optionality::repeats}},
DftReal},
{{"a1", DefaultReal}, {"a2", DefaultReal},
{"a3", DefaultReal, Rank::elemental, Optionality::repeats}},
DefaultReal},
"min", true},
{{"amod", {{"a", DftReal}, {"p", DftReal}}, DftReal}, "mod"},
{{"anint", {{"a", DftReal}}, DftReal}},
{{"asin", {{"x", DftReal}}, DftReal}},
{{"atan", {{"x", DftReal}}, DftReal}},
{{"atan2", {{"y", DftReal}, {"x", DftReal}}, DftReal}},
{{"cabs", {{"a", DftComplex}}, DftReal}, "abs"},
{{"ccos", {{"a", DftComplex}}, DftComplex}, "cos"},
{{"cexp", {{"a", DftComplex}}, DftComplex}, "exp"},
{{"clog", {{"a", DftComplex}}, DftComplex}, "log"},
{{"conjg", {{"a", DftComplex}}, DftComplex}},
{{"cos", {{"x", DftReal}}, DftReal}},
{{"csin", {{"a", DftComplex}}, DftComplex}, "sin"},
{{"csqrt", {{"a", DftComplex}}, DftComplex}, "sqrt"},
{{"ctan", {{"a", DftComplex}}, DftComplex}, "tan"},
{{"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"},
{{"cexp", {{"a", DefaultComplex}}, DefaultComplex}, "exp"},
{{"clog", {{"a", DefaultComplex}}, DefaultComplex}, "log"},
{{"conjg", {{"a", DefaultComplex}}, DefaultComplex}},
{{"cos", {{"x", DefaultReal}}, DefaultReal}},
{{"csin", {{"a", DefaultComplex}}, DefaultComplex}, "sin"},
{{"csqrt", {{"a", DefaultComplex}}, DefaultComplex}, "sqrt"},
{{"ctan", {{"a", DefaultComplex}}, DefaultComplex}, "tan"},
{{"dabs", {{"a", DoublePrecision}}, DoublePrecision}, "abs"},
{{"dacos", {{"x", DoublePrecision}}, DoublePrecision}, "acos"},
{{"dasin", {{"x", DoublePrecision}}, DoublePrecision}, "asin"},
@ -650,14 +665,15 @@ static const SpecificIntrinsicInterface specificIntrinsicFunction[]{
{{"datan2", {{"y", DoublePrecision}, {"x", DoublePrecision}},
DoublePrecision},
"atan2"},
{{"dble", {{"a", DftReal}, DefaultingKIND}, DoublePrecision}, "real", true},
{{"dble", {{"a", DefaultReal}, DefaultingKIND}, DoublePrecision}, "real",
true},
{{"dcos", {{"x", DoublePrecision}}, DoublePrecision}, "cos"},
{{"dcosh", {{"x", DoublePrecision}}, DoublePrecision}, "cosh"},
{{"ddim", {{"x", DoublePrecision}, {"y", DoublePrecision}},
DoublePrecision},
"dim"},
{{"dexp", {{"x", DoublePrecision}}, DoublePrecision}, "exp"},
{{"dim", {{"x", DftReal}, {"y", DftReal}}, DftReal}},
{{"dim", {{"x", DefaultReal}, {"y", DefaultReal}}, DefaultReal}},
{{"dint", {{"a", DoublePrecision}}, DoublePrecision}, "aint"},
{{"dlog", {{"x", DoublePrecision}}, DoublePrecision}, "log"},
{{"dlog10", {{"x", DoublePrecision}}, DoublePrecision}, "log10"},
@ -675,7 +691,7 @@ static const SpecificIntrinsicInterface specificIntrinsicFunction[]{
DoublePrecision},
"mod"},
{{"dnint", {{"a", DoublePrecision}}, DoublePrecision}, "anint"},
{{"dprod", {{"x", DftReal}, {"y", DftReal}}, DoublePrecision}},
{{"dprod", {{"x", DefaultReal}, {"y", DefaultReal}}, DoublePrecision}},
{{"dsign", {{"a", DoublePrecision}, {"b", DoublePrecision}},
DoublePrecision},
"sign"},
@ -684,47 +700,48 @@ static const SpecificIntrinsicInterface specificIntrinsicFunction[]{
{{"dsqrt", {{"x", DoublePrecision}}, DoublePrecision}, "sqrt"},
{{"dtan", {{"x", DoublePrecision}}, DoublePrecision}, "tan"},
{{"dtanh", {{"x", DoublePrecision}}, DoublePrecision}, "tanh"},
{{"exp", {{"x", DftReal}}, DftReal}},
{{"float", {{"i", DftInt}}, DftReal}, "real", true},
{{"iabs", {{"a", DftInt}}, DftInt}, "abs"},
{{"idim", {{"x", DftInt}, {"y", DftInt}}, DftInt}, "dim"},
{{"idint", {{"a", DoublePrecision}}, DftInt}, "int", true},
{{"idnint", {{"a", DoublePrecision}}, DftInt}, "nint"},
{{"ifix", {{"a", DftReal}}, DftInt}, "int", true},
{{"index", {{"string", DftChar}, {"substring", DftChar}}, DftInt}},
{{"isign", {{"a", DftInt}, {"b", DftInt}}, DftInt}, "sign"},
{{"len", {{"string", DftChar}}, DftInt}},
{{"log", {{"x", DftReal}}, DftReal}},
{{"log10", {{"x", DftReal}}, DftReal}},
{{"exp", {{"x", DefaultReal}}, DefaultReal}},
{{"float", {{"i", DefaultInt}}, DefaultReal}, "real", true},
{{"iabs", {{"a", DefaultInt}}, DefaultInt}, "abs"},
{{"idim", {{"x", DefaultInt}, {"y", DefaultInt}}, DefaultInt}, "dim"},
{{"idint", {{"a", DoublePrecision}}, DefaultInt}, "int", true},
{{"idnint", {{"a", DoublePrecision}}, DefaultInt}, "nint"},
{{"ifix", {{"a", DefaultReal}}, DefaultInt}, "int", true},
{{"index", {{"string", DefaultChar}, {"substring", DefaultChar}},
DefaultInt}},
{{"isign", {{"a", DefaultInt}, {"b", DefaultInt}}, DefaultInt}, "sign"},
{{"len", {{"string", DefaultChar}}, DefaultInt}},
{{"log", {{"x", DefaultReal}}, DefaultReal}},
{{"log10", {{"x", DefaultReal}}, DefaultReal}},
{{"max0",
{{"a1", DftInt}, {"a2", DftInt},
{"a3", DftInt, Rank::elemental, Optionality::repeats}},
DftInt},
{{"a1", DefaultInt}, {"a2", DefaultInt},
{"a3", DefaultInt, Rank::elemental, Optionality::repeats}},
DefaultInt},
"max", true},
{{"max1",
{{"a1", DftReal}, {"a2", DftReal},
{"a3", DftReal, Rank::elemental, Optionality::repeats}},
DftInt},
{{"a1", DefaultReal}, {"a2", DefaultReal},
{"a3", DefaultReal, Rank::elemental, Optionality::repeats}},
DefaultInt},
"max", true},
{{"min0",
{{"a1", DftInt}, {"a2", DftInt},
{"a3", DftInt, Rank::elemental, Optionality::repeats}},
DftInt},
{{"a1", DefaultInt}, {"a2", DefaultInt},
{"a3", DefaultInt, Rank::elemental, Optionality::repeats}},
DefaultInt},
"min", true},
{{"min1",
{{"a1", DftReal}, {"a2", DftReal},
{"a3", DftReal, Rank::elemental, Optionality::repeats}},
DftInt},
{{"a1", DefaultReal}, {"a2", DefaultReal},
{"a3", DefaultReal, Rank::elemental, Optionality::repeats}},
DefaultInt},
"min", true},
{{"mod", {{"a", DftInt}, {"p", DftInt}}, DftInt}},
{{"nint", {{"a", DftReal}}, DftInt}},
{{"sign", {{"a", DftReal}, {"b", DftReal}}, DftReal}},
{{"sin", {{"x", DftReal}}, DftReal}},
{{"sinh", {{"x", DftReal}}, DftReal}},
{{"sngl", {{"a", DoublePrecision}}, DftReal}, "real", true},
{{"sqrt", {{"x", DftReal}}, DftReal}},
{{"tan", {{"x", DftReal}}, DftReal}},
{{"tanh", {{"x", DftReal}}, DftReal}},
{{"mod", {{"a", DefaultInt}, {"p", DefaultInt}}, DefaultInt}},
{{"nint", {{"a", DefaultReal}}, DefaultInt}},
{{"sign", {{"a", DefaultReal}, {"b", DefaultReal}}, DefaultReal}},
{{"sin", {{"x", DefaultReal}}, DefaultReal}},
{{"sinh", {{"x", DefaultReal}}, DefaultReal}},
{{"sngl", {{"a", DoublePrecision}}, DefaultReal}, "real", true},
{{"sqrt", {{"x", DefaultReal}}, DefaultReal}},
{{"tan", {{"x", DefaultReal}}, DefaultReal}},
{{"tanh", {{"x", DefaultReal}}, DefaultReal}},
};
// TODO: Intrinsic subroutines
@ -1017,6 +1034,10 @@ std::optional<SpecificIntrinsic> IntrinsicInterface::Match(
} else if (kindDummyArg->optionality == Optionality::defaultsToSameKind) {
CHECK(sameArg != nullptr);
resultType = *sameArg->GetType();
} else if (kindDummyArg->optionality ==
Optionality::defaultsToSubscriptKind) {
CHECK(resultType.category == TypeCategory::Integer);
resultType.kind = defaults.subscriptIntegerKind();
} else {
CHECK(
kindDummyArg->optionality == Optionality::defaultsToDefaultForResult);

48
flang/lib/semantics/default-kinds.cc
View file

@ -17,7 +17,53 @@
namespace Fortran::semantics {
IntrinsicTypeDefaultKinds::IntrinsicTypeDefaultKinds() {}
IntrinsicTypeDefaultKinds::IntrinsicTypeDefaultKinds() {
#if __x86_64__
quadPrecisionKind_ = 10;
#endif
}
IntrinsicTypeDefaultKinds &IntrinsicTypeDefaultKinds::set_defaultIntegerKind(
int k) {
defaultIntegerKind_ = k;
return *this;
}
IntrinsicTypeDefaultKinds &IntrinsicTypeDefaultKinds::set_subscriptIntegerKind(
int k) {
subscriptIntegerKind_ = k;
return *this;
}
IntrinsicTypeDefaultKinds &IntrinsicTypeDefaultKinds::set_defaultRealKind(
int k) {
defaultRealKind_ = k;
return *this;
}
IntrinsicTypeDefaultKinds &IntrinsicTypeDefaultKinds::set_doublePrecisionKind(
int k) {
doublePrecisionKind_ = k;
return *this;
}
IntrinsicTypeDefaultKinds &IntrinsicTypeDefaultKinds::set_quadPrecisionKind(
int k) {
quadPrecisionKind_ = k;
return *this;
}
IntrinsicTypeDefaultKinds &IntrinsicTypeDefaultKinds::set_defaultCharacterKind(
int k) {
defaultCharacterKind_ = k;
return *this;
}
IntrinsicTypeDefaultKinds &IntrinsicTypeDefaultKinds::set_defaultLogicalKind(
int k) {
defaultLogicalKind_ = k;
return *this;
}
int IntrinsicTypeDefaultKinds::GetDefaultKind(TypeCategory category) const {
switch (category) {

13
flang/lib/semantics/default-kinds.h
View file

@ -26,12 +26,19 @@ using Fortran::common::TypeCategory;
class IntrinsicTypeDefaultKinds {
public:
// TODO: Support compile-time options to default reals, ints, or both to
// KIND=8
IntrinsicTypeDefaultKinds();
int subscriptIntegerKind() const { return subscriptIntegerKind_; }
int doublePrecisionKind() const { return doublePrecisionKind_; }
int quadPrecisionKind() const { return quadPrecisionKind_; }
IntrinsicTypeDefaultKinds &set_defaultIntegerKind(int);
IntrinsicTypeDefaultKinds &set_subscriptIntegerKind(int);
IntrinsicTypeDefaultKinds &set_defaultRealKind(int);
IntrinsicTypeDefaultKinds &set_doublePrecisionKind(int);
IntrinsicTypeDefaultKinds &set_quadPrecisionKind(int);
IntrinsicTypeDefaultKinds &set_defaultCharacterKind(int);
IntrinsicTypeDefaultKinds &set_defaultLogicalKind(int);
int GetDefaultKind(TypeCategory) const;
private:
@ -44,7 +51,7 @@ private:
int subscriptIntegerKind_{8}; // for large arrays
int defaultRealKind_{defaultIntegerKind_};
int doublePrecisionKind_{2 * defaultRealKind_};
int quadPrecisionKind_{2 * doublePrecisionKind_}; // TODO: x86-64: 10
int quadPrecisionKind_{2 * doublePrecisionKind_};
int defaultCharacterKind_{1};
int defaultLogicalKind_{defaultIntegerKind_};
};

3
flang/lib/semantics/semantics.h
View file

@ -33,6 +33,9 @@ public:
explicit Semantics(const IntrinsicTypeDefaultKinds &dftKinds)
: defaultKinds_{dftKinds} {}
const parser::Messages &messages() const { return messages_; }
const IntrinsicTypeDefaultKinds &defaultKinds() const {
return defaultKinds_;
}
Semantics &set_searchDirectories(const std::vector<std::string> &);
Semantics &set_moduleDirectory(const std::string &);
bool AnyFatalError() const { return messages_.AnyFatalError(); }

14
flang/tools/f18/f18.cc
View file

@ -220,7 +220,7 @@ std::string CompileFortran(std::string path, Fortran::parser::Options options,
Fortran::parser::Messages messages;
Fortran::parser::ContextualMessages contextualMessages{whole, &messages};
Fortran::evaluate::FoldingContext context{contextualMessages};
Fortran::semantics::IntrinsicTypeDefaultKinds defaults;
const auto &defaults{semantics.defaultKinds()};
auto intrinsics{
Fortran::evaluate::IntrinsicProcTable::Configure(defaults)};
Fortran::semantics::AnalyzeExpressions(
@ -335,6 +335,8 @@ int main(int argc, char *const argv[]) {
options.predefinitions.emplace_back("__F18_MINOR__", "1");
options.predefinitions.emplace_back("__F18_PATCHLEVEL__", "1");
Fortran::semantics::IntrinsicTypeDefaultKinds defaultKinds;
std::vector<std::string> fortranSources, otherSources, relocatables;
bool anyFiles{false};
@ -439,6 +441,12 @@ int main(int argc, char *const argv[]) {
} else if (arg.substr(0, 2) == "-U") {
options.predefinitions.emplace_back(
arg.substr(2), std::optional<std::string>{});
} else if (arg == "-r8" || arg == "-fdefault-real-8") {
defaultKinds.set_defaultRealKind(8);
} else if (arg == "-i8" || arg == "-fdefault-integer-8") {
defaultKinds.set_defaultIntegerKind(8);
} else if (arg == "-fno-large-arrays") {
defaultKinds.set_subscriptIntegerKind(4);
} else if (arg == "-help" || arg == "--help" || arg == "-?") {
std::cerr
<< "f18 options:\n"
@ -448,6 +456,8 @@ int main(int argc, char *const argv[]) {
<< " -M[no]backslash disable[enable] \\escapes in literals\n"
<< " -Mstandard enable conformance warnings\n"
<< " -Mx,125,4 set bit 2 in xflag[125] (all Kanji mode)\n"
<< " -r8 | -fdefault-real-8 | -i8 | -fdefault-integer-8 "
"change default kinds of intrinsic types\n"
<< " -Werror treat warnings as errors\n"
<< " -ed enable fixed form D lines\n"
<< " -E prescan & preprocess only\n"
@ -498,8 +508,6 @@ int main(int argc, char *const argv[]) {
driver.pgf90Args.push_back("-Mbackslash");
}
// TODO: Configure these kinds based on command line settings
Fortran::semantics::IntrinsicTypeDefaultKinds defaultKinds;
Fortran::semantics::Semantics semantics{defaultKinds};
semantics.set_searchDirectories(options.searchDirectories);
semantics.set_moduleDirectory(driver.moduleDirectory);