This is an archive of the discontinued LLVM Phabricator instance.

Differential D145674

[flang] Simplify same_type_as condition
ClosedPublic

Authored by clementval on Mar 9 2023, 2:30 AM.

Details

Reviewers
PeteSteinfeld
Commits
rG188c02daaa24: [flang] Simplify same_type_as condition
Summary

Restore the behavior changed in D145384 and add proper
unit tests.

Unallocated unlimited poymorphic allocatable and disassociated
unlimited polymorphic pointer should return false.

Diff Detail

Event Timeline

clementval created this revision.Mar 9 2023, 2:30 AM
Herald added projects: Restricted Project, Restricted Project. · View Herald TranscriptMar 9 2023, 2:30 AM
Herald added a subscriber: sunshaoce. · View Herald Transcript
clementval requested review of this revision.Mar 9 2023, 2:30 AM
Herald added a subscriber: jdoerfert. · View Herald TranscriptMar 9 2023, 2:30 AM
Harbormaster completed remote builds in B218347: Diff 503706.Mar 9 2023, 2:50 AM
clementval added a child revision: D145679: [flang] Reset dynamic type for optional intent(out) allocatable polymorphic dummy.Mar 9 2023, 3:21 AM
PeteSteinfeld accepted this revision.Mar 9 2023, 6:19 AM

All builds and tests successfully and looks good.

This revision is now accepted and ready to land.Mar 9 2023, 6:19 AM
Closed by commit rG188c02daaa24: [flang] Simplify same_type_as condition (authored by clementval). · Explain WhyMar 9 2023, 6:47 AM
This revision was automatically updated to reflect the committed changes.
clementval added a commit: rG188c02daaa24: [flang] Simplify same_type_as condition.

Revision Contents

PathSize
flang/
runtime/
9 lines
unittests/
Runtime/
33 lines

Diff 503757

flang/runtime/derived-api.cpp

Show First 20 Lines • Show All 89 Lines • ▼ Show 20 Linesbool RTNAME(SameTypeAs)(const Descriptor &a, const Descriptor &b) {
// Unlimited polymorphic with intrinsic dynamic type. // Unlimited polymorphic with intrinsic dynamic type.
if (a.raw().type != CFI_type_struct && a.raw().type != CFI_type_other && if (a.raw().type != CFI_type_struct && a.raw().type != CFI_type_other &&
b.raw().type != CFI_type_struct && b.raw().type != CFI_type_other) b.raw().type != CFI_type_struct && b.raw().type != CFI_type_other)
return a.raw().type == b.raw().type; return a.raw().type == b.raw().type;
const typeInfo::DerivedType *derivedTypeA{GetDerivedType(a)}; const typeInfo::DerivedType *derivedTypeA{GetDerivedType(a)};
const typeInfo::DerivedType *derivedTypeB{GetDerivedType(b)}; const typeInfo::DerivedType *derivedTypeB{GetDerivedType(b)};
// One of the descriptor is an unallocated unlimited polymorphic descriptor. // No dynamic type in one or both descriptor.
// This is processor depedent according to the standard. Align the result if (derivedTypeA == nullptr || derivedTypeB == nullptr) {
// with other compilers. return false;
if ((!a.IsAllocated() && derivedTypeA == nullptr) ||
(!b.IsAllocated() && derivedTypeB == nullptr)) {
return true;
} }
// Exact match of derived type. // Exact match of derived type.
if (derivedTypeA == derivedTypeB) { if (derivedTypeA == derivedTypeB) {
return true; return true;
} }
// Otherwise compare with the name. Note 16.29 kind type parameters are not // Otherwise compare with the name. Note 16.29 kind type parameters are not
// considered in the test. // considered in the test.
▲ Show 20 Lines • Show All 48 Lines • Show Last 20 Lines

flang/unittests/Runtime/Derived.cpp

Show All 18 Lines auto i1{
Descriptor::Create(TypeCode{Fortran::common::TypeCategory::Integer, 4}, 4, Descriptor::Create(TypeCode{Fortran::common::TypeCategory::Integer, 4}, 4,
nullptr, 0, nullptr, CFI_attribute_pointer)}; nullptr, 0, nullptr, CFI_attribute_pointer)};
EXPECT_TRUE(RTNAME(SameTypeAs)(*i1, *i1)); EXPECT_TRUE(RTNAME(SameTypeAs)(*i1, *i1));
auto r1{Descriptor::Create(TypeCode{Fortran::common::TypeCategory::Real, 4}, auto r1{Descriptor::Create(TypeCode{Fortran::common::TypeCategory::Real, 4},
4, nullptr, 0, nullptr, CFI_attribute_pointer)}; 4, nullptr, 0, nullptr, CFI_attribute_pointer)};
EXPECT_FALSE(RTNAME(SameTypeAs)(*i1, *r1)); EXPECT_FALSE(RTNAME(SameTypeAs)(*i1, *r1));
// CLASS(*), ALLOCATABLE :: p1 // CLASS(*), ALLOCATABLE :: a1
auto p1{Descriptor::Create(TypeCode{Fortran::common::TypeCategory::Real, 4}, auto a1{Descriptor::Create(TypeCode{Fortran::common::TypeCategory::Real, 4},
4, nullptr, 0, nullptr, CFI_attribute_allocatable)}; 4, nullptr, 0, nullptr, CFI_attribute_allocatable)};
p1->raw().elem_len = 0; a1->raw().elem_len = 0;
p1->raw().type = CFI_type_other; a1->raw().type = CFI_type_other;
EXPECT_TRUE(RTNAME(SameTypeAs)(*i1, *p1)); EXPECT_FALSE(RTNAME(SameTypeAs)(*i1, *a1));
EXPECT_TRUE(RTNAME(SameTypeAs)(*p1, *i1)); EXPECT_FALSE(RTNAME(SameTypeAs)(*a1, *i1));
EXPECT_TRUE(RTNAME(SameTypeAs)(*r1, *p1)); EXPECT_FALSE(RTNAME(SameTypeAs)(*r1, *a1));
// CLASS(*), ALLOCATABLE :: p2 // CLASS(*), ALLOCATABLE :: a2
auto p2{Descriptor::Create(TypeCode{Fortran::common::TypeCategory::Real, 4}, auto a2{Descriptor::Create(TypeCode{Fortran::common::TypeCategory::Real, 4},
4, nullptr, 0, nullptr, CFI_attribute_allocatable)}; 4, nullptr, 0, nullptr, CFI_attribute_allocatable)};
p2->raw().elem_len = 0; a2->raw().elem_len = 0;
p2->raw().type = CFI_type_other; a2->raw().type = CFI_type_other;
EXPECT_FALSE(RTNAME(SameTypeAs)(*a1, *a2));
// CLASS(*), POINTER :: p1
auto p1{Descriptor::Create(TypeCode{Fortran::common::TypeCategory::Real, 4},
4, nullptr, 0, nullptr, CFI_attribute_pointer)};
p1->raw().elem_len = 0;
p1->raw().type = CFI_type_other;
EXPECT_TRUE(RTNAME(SameTypeAs)(*p1, *p2)); EXPECT_FALSE(RTNAME(SameTypeAs)(*i1, *p1));
EXPECT_FALSE(RTNAME(SameTypeAs)(*p1, *i1));
} }