[flang-commits] [PATCH] D123944: [flang] Fix UBOUND() constant folding for parentheses expr

[Mike K via Phabricator via flang-commits]

This revision was automatically updated to reflect the committed changes.
Closed by commit rG92e22c97e9ef: [flang] Fix UBOUND() constant folding for parentheses expr (authored by FruitClover).

Repository:
  rG LLVM Github Monorepo

CHANGES SINCE LAST ACTION
  https://reviews.llvm.org/D123944/new/

https://reviews.llvm.org/D123944

Files:
  flang/lib/Evaluate/fold-integer.cpp
  flang/test/Evaluate/folding08.f90


Index: flang/test/Evaluate/folding08.f90
===================================================================
--- flang/test/Evaluate/folding08.f90
+++ flang/test/Evaluate/folding08.f90
@@ -105,33 +105,45 @@
          ubound(a3, 2) == 1 .and. &
          ubound(a3, 3) == 6
   end subroutine
-  subroutine test4_lbound_parentheses
-    ! Test lbound with (x) expressions
+  subroutine test4_bound_parentheses
+    ! Test [ul]bound with (x) expressions
     integer :: a1(1) = 0
     logical, parameter :: test_lba1 = all(lbound((a1)) == [1])
+    logical, parameter :: test_uba1 = all(ubound((a1)) == [1])
     integer :: a2(0:2) = 0
     logical, parameter :: test_lba2 = all(lbound((a2)) == [1])
+    logical, parameter :: test_uba2 = all(ubound((a2)) == [3])
     integer :: a3(-1:0) = 0
     logical, parameter :: test_lba3 = all(lbound((a3)) == [1])
+    logical, parameter :: test_uba3 = all(ubound((a3)) == [2])
     integer :: a4(-5:-1, 2:5) = 0
     logical, parameter :: test_lba4 = all(lbound((a4)) == [1, 1])
+    logical, parameter :: test_uba4 = all(ubound((a4)) == [5, 4])
 
     ! Exercise with DIM=
     logical, parameter :: test_lba4_dim = lbound((a4), 1) == 1 .and. &
          lbound((a4), 2) == 1
+    logical, parameter :: test_uba4_dim = ubound((a4), 1) == 5 .and. &
+         ubound((a4), 2) == 4
 
     ! Exercise with parameter types
     integer, parameter :: pa1(1) = 0
     logical, parameter :: test_lbpa1 = all(lbound((pa1)) == [1])
+    logical, parameter :: test_ubpa1 = all(ubound((pa1)) == [1])
     integer, parameter :: pa2(0:2) = 0
     logical, parameter :: test_lbpa2 = all(lbound((pa2)) == [1])
+    logical, parameter :: test_ubpa2 = all(ubound((pa2)) == [3])
     integer, parameter :: pa3(-1:0) = 0
     logical, parameter :: test_lbpa3 = all(lbound((pa3)) == [1])
+    logical, parameter :: test_ubpa3 = all(ubound((pa3)) == [2])
     integer, parameter :: pa4(-5:-1, 2:5) = 0
     logical, parameter :: test_lbpa4 = all(lbound((pa4)) == [1, 1])
+    logical, parameter :: test_ubpa4 = all(ubound((pa4)) == [5, 4])
 
     ! Exercise with DIM=
     logical, parameter :: test_lbpa4_dim = lbound((pa4), 1) == 1 .and. &
          lbound((pa4), 2) == 1
+    logical, parameter :: test_ubpa4_dim = ubound((pa4), 1) == 5 .and. &
+         ubound((pa4), 2) == 4
   end
 end
Index: flang/lib/Evaluate/fold-integer.cpp
===================================================================
--- flang/lib/Evaluate/fold-integer.cpp
+++ flang/lib/Evaluate/fold-integer.cpp
@@ -70,14 +70,31 @@
         return x.lbounds();
       }
     } else {
-      return x.ComputeUbounds(dim_);
+      // Return the upper bound
+      if (arrayFromParenthesesExpr) {
+        // Underlying array comes from (x) expression - return shapes
+        if (dim_) {
+          return {x.shape().at(*dim_)};
+        } else {
+          return x.shape();
+        }
+      } else {
+        return x.ComputeUbounds(dim_);
+      }
     }
   }
 
   template <typename T> ConstantSubscripts Get(const Parentheses<T> &x) {
-    // LBOUND for (x) is [1, ..., 1] cause of temp variable inside
-    // parentheses (lower bound is omitted, the default value is 1).
-    return ConstantSubscripts(x.Rank(), ConstantSubscript{1});
+    // Cause of temp variable inside parentheses - return [1, ... 1] for lower
+    // bounds and shape for upper bounds
+    if (getLbound_) {
+      return ConstantSubscripts(x.Rank(), ConstantSubscript{1});
+    } else {
+      // Indicate that underlying array comes from parentheses expression.
+      // Continue to unwrap expression until we hit a constant
+      arrayFromParenthesesExpr = true;
+      return Get(x.left());
+    }
   }
 
   template <typename T> ConstantSubscripts Get(const Expr<T> &x) {
@@ -89,6 +106,7 @@
 
   const std::optional<ConstantSubscript> dim_;
   const bool getLbound_;
+  bool arrayFromParenthesesExpr{false};
 };
 
 template <int KIND>


-------------- next part --------------
A non-text attachment was scrubbed...
Name: D123944.425733.patch
Type: text/x-patch
Size: 3911 bytes
Desc: not available
URL: <http://lists.llvm.org/pipermail/flang-commits/attachments/20220428/bb839e62/attachment-0001.bin>