Merge pull request #1321 from flang-compiler/revert-1307-ch-haptr

Revert "Change host associations so they are not "promoted" to !fir.ptr"

Author: schweitzpgi

flang/include/flang/Lower/ConvertExpr.h

@@ -206,8 +206,7 @@ mlir::Value createSubroutineCall(AbstractConverter &converter,
 // pass-by-ref semantics for a VALUE parameter. The optimizer may be able to
 // eliminate these.
 inline mlir::NamedAttribute getAdaptToByRefAttr(fir::FirOpBuilder &builder) {
-  return {mlir::Identifier::get(fir::getAdaptToByRefAttrName(),
-                                builder.getContext()),
+  return {mlir::Identifier::get("adapt.valuebyref", builder.getContext()),
           builder.getUnitAttr()};
 }
 

flang/include/flang/Optimizer/Dialect/FIROps.h

@@ -38,14 +38,6 @@ mlir::ParseResult parseSelector(mlir::OpAsmParser &parser,
                                 mlir::OpAsmParser::OperandType &selector,
                                 mlir::Type &type);
 
-static constexpr llvm::StringRef getAdaptToByRefAttrName() {
-  return "adapt.valuebyref";
-}
-
-static constexpr llvm::StringRef getNormalizedLowerBoundAttrName() {
-  return "normalized.lb";
-}
-
 } // namespace fir
 
 #define GET_OP_CLASSES

flang/lib/Lower/HostAssociations.cpp

@@ -124,12 +124,12 @@ class CapturedSymbols {
 
 /// Class defining simple scalars are captured in internal procedures.
 /// Simple scalars are non character intrinsic scalars. They are captured
-/// as `!fir.ref<T>`, for example `!fir.ref<i32>` for `INTEGER*4`.
+/// as !fir.ptr<T> (.e.g !fir.ptr<i32> for INTEGER(4)).
 class CapturedSimpleScalars : public CapturedSymbols<CapturedSimpleScalars> {
 public:
   static mlir::Type getType(Fortran::lower::AbstractConverter &converter,
                             const Fortran::semantics::Symbol &sym) {
-    return fir::ReferenceType::get(converter.genType(sym));
+    return fir::PointerType::get(converter.genType(sym));
   }
 
   static void instantiateHostTuple(const InstantiateHostTuple &args,
@@ -311,21 +311,21 @@ class CapturedAllocatableAndPointer
 };
 
 /// Class defining how arrays are captured inside internal procedures.
-/// Array are captured via a `fir.box<fir.array<T>>` descriptor that belongs to
-/// the host tuple. This allows capturing lower bounds, which can be done by
-/// providing a ShapeShiftOp argument to the EmboxOp.
+/// Array are captured via a fir.box<fir.ptr<T>> pointer descriptor that
+/// belongs to the host tuple. This allows capturing lower bounds, which
+/// a non pointer descriptor (fir.box<T>) would not allow.
 class CapturedArrays : public CapturedSymbols<CapturedArrays> {
 
   // Note: Constant shape arrays are not specialized (their base address would
   // be sufficient information inside the tuple). They could be specialized in
-  // a later FIR pass, or a CapturedStaticShapeArrays could be added to deal
+  // a later FIR pass, or A CapturedStaticShapeArrays could be added to deal
   // with them here.
 public:
   static mlir::Type getType(Fortran::lower::AbstractConverter &converter,
                             const Fortran::semantics::Symbol &sym) {
     mlir::Type type = converter.genType(sym);
     assert(type.isa<fir::SequenceType>() && "must be a sequence type");
-    return fir::BoxType::get(type);
+    return fir::BoxType::get(fir::PointerType::get(type));
   }
 
   static void instantiateHostTuple(const InstantiateHostTuple &args,
@@ -435,7 +435,6 @@ typename T::Result
 walkCaptureCategories(T visitor, Fortran::lower::AbstractConverter &converter,
                       const Fortran::semantics::Symbol &sym) {
   if (isDerivedWithLengthParameters(sym))
-    // Should be boxed.
     TODO(converter.genLocation(sym.name()),
          "host associated derived type with length parameters");
   Fortran::lower::BoxAnalyzer ba;

flang/lib/Optimizer/Builder/BoxValue.cpp

@@ -182,13 +182,15 @@ llvm::raw_ostream &fir::operator<<(llvm::raw_ostream &os,
 /// always be called, so it should not have any functional side effects,
 /// the const is here to enforce that.
 bool fir::MutableBoxValue::verify() const {
-  mlir::Type type = fir::dyn_cast_ptrEleTy(getAddr().getType());
+  auto type = fir::dyn_cast_ptrEleTy(getAddr().getType());
   if (!type)
     return false;
   auto box = type.dyn_cast<fir::BoxType>();
   if (!box)
     return false;
-  // A boxed value always takes a memory reference,
+  auto eleTy = box.getEleTy();
+  if (!eleTy.isa<fir::PointerType>() && !eleTy.isa<fir::HeapType>())
+    return false;
 
   auto nParams = lenParams.size();
   if (isCharacter()) {

flang/lib/Optimizer/CodeGen/CodeGen.cpp

@@ -1482,19 +1482,13 @@ struct XEmboxOpConversion : public EmboxCommonConversion<fir::cg::XEmboxOp> {
         }
       }
       if (!skipNext) {
-        // Lower bound is normalized to 0 for BIND(C) interoperability.
+        // store lower bound (normally 0)
         auto lb = zero;
-        bool isaPointerOrAllocatable =
-            eleTy.isa<fir::PointerType>() || eleTy.isa<fir::HeapType>();
-        // Lower bound is defaults to 1 for POINTER, ALLOCATABLE, and
-        // denormalized descriptors.
-        if (isaPointerOrAllocatable || !normalizedLowerBound(xbox))
+        if (eleTy.isa<fir::PointerType>() || eleTy.isa<fir::HeapType>()) {
           lb = one;
-        // If there is a shifted origin and this is not a normalized descriptor
-        // then use the value from the shift op as the lower bound.
-        if (hasShift &&
-            (isaPointerOrAllocatable || !normalizedLowerBound(xbox)))
-          lb = operands[shiftOff];
+          if (hasShift)
+            lb = operands[shiftOff];
+        }
         dest = insertLowerBound(rewriter, loc, dest, descIdx, lb);
 
         // store extent
@@ -1553,13 +1547,6 @@ struct XEmboxOpConversion : public EmboxCommonConversion<fir::cg::XEmboxOp> {
     rewriter.replaceOp(xbox, result);
     return success();
   }
-
-  /// Return true if `xbox` has a normalized lower bounds attribute. A box value
-  /// that is neither a POINTER nor an ALLOCATABLE should be normalized to a
-  /// zero origin lower bound for interoperability with BIND(C).
-  inline static bool normalizedLowerBound(fir::cg::XEmboxOp xbox) {
-    return xbox->hasAttr(fir::getNormalizedLowerBoundAttrName());
-  }
 };
 
 /// Create a new box given a box reference.

flang/test/Fir/box.fir

@@ -145,10 +145,10 @@ func @box6(%0 : !fir.ref<!fir.array<?x?x?x?xf32>>, %1 : index, %2 : index) -> i3
   // CHECK: %[[sdp2:.*]] = sdiv i64 %[[dp2]], 2
   // CHECK: %[[cmp:.*]] = icmp sgt i64 %[[sdp2]], 0
   // CHECK: %[[extent:.*]] = select i1 %[[cmp]], i64 %[[sdp2]], i64 0
-  // CHECK: insertvalue { float*, i64, i32, i8, i8, i8, i8, [2 x [3 x i64]] } { float* undef, i64 4, i32 20180515, i8 2, i8 25, i8 0, i8 0, [2 x [3 x i64]] [{{\[}}3 x i64] [i64 1, i64 undef, i64 undef], [3 x i64] undef] }, i64 %[[extent]], 7, 0, 1
+  // CHECK: insertvalue { float*, i64, i32, i8, i8, i8, i8, [2 x [3 x i64]] } { float* undef, i64 4, i32 20180515, i8 2, i8 25, i8 0, i8 0, [2 x [3 x i64]] [{{\[}}3 x i64] [i64 0, i64 undef, i64 undef], [3 x i64] undef] }, i64 %[[extent]], 7, 0, 1
   // CHECK: insertvalue { float*, i64, i32, i8, i8, i8, i8, [2 x [3 x i64]] } %{{.*}}, i64 800, 7, 0, 2
   // CHECK: %[[op25:.*]] = add i64 25000, %[[i100p40]]
-  // CHECK: insertvalue { float*, i64, i32, i8, i8, i8, i8, [2 x [3 x i64]] } %{{.*}}, i64 1, 7, 1, 0
+  // CHECK: insertvalue { float*, i64, i32, i8, i8, i8, i8, [2 x [3 x i64]] } %{{.*}}, i64 0, 7, 1, 0
   // CHECK: insertvalue { float*, i64, i32, i8, i8, i8, i8, [2 x [3 x i64]] } %{{.*}}, i64 4, 7, 1, 1
   // CHECK: insertvalue { float*, i64, i32, i8, i8, i8, i8, [2 x [3 x i64]] } %{{.*}}, i64 120000, 7, 1, 2
   // CHECK: %[[op300:.*]] = add i64 300000, %[[op25]]

flang/test/Fir/embox.fir

@@ -13,7 +13,7 @@ func @_QPtest_slice() {
 // CHECK:  %[[a3:.*]] = getelementptr [20 x i32], [20 x i32]* %[[a2]], i64 0, i64 0, 
 // CHECK:  %[[a4:.*]] = insertvalue { i32*, i64, i32, i8, i8, i8, i8, [1 x [3 x i64]] }  
 // CHECK:  { i32* undef, i64 4, i32 20180515, i8 1, i8 9, i8 0, i8 0, [1 x [3 x i64]] 
-// CHECK: [i64 1, i64 5, i64 8]] }, i32* %[[a3]], 0, 
+// CHECK: [i64 0, i64 5, i64 8]] }, i32* %[[a3]], 0, 
 // CHECK:  store { i32*, i64, i32, i8, i8, i8, i8, [1 x [3 x i64]] } %[[a4]], { i32*, i64, i32, i8, i8, i8, i8, [1 x [3 x i64]] }* %[[a1]], align 8
 // CHECK:  call void @_QPtest_callee({ i32*, i64, i32, i8, i8, i8, i8, [1 x [3 x i64]] }* %[[a1]]), 
   %c20 = arith.constant 20 : index
@@ -40,7 +40,7 @@ func @_QPtest_dt_slice() {
 // CHECK:  %[[a4:.*]] = getelementptr [20 x %_QFtest_dt_sliceTt], [20 x %_QFtest_dt_sliceTt]* %[[a3]], i64 0, i64 0, i32 0,
 // CHECK: %[[a5:.*]] = insertvalue { i32*, i64, i32, i8, i8, i8, i8, [1 x [3 x i64]] }
 // CHECK-SAME: { i32* undef, i64 4, i32 20180515, i8 1, i8 9, i8 0, i8 0, [1 x [3 x i64]]
-// CHECK-SAME: [i64 1, i64 5, i64 mul
+// CHECK-SAME: [i64 0, i64 5, i64 mul
 // CHECK-SAME: (i64 ptrtoint (%_QFtest_dt_sliceTt* getelementptr (%_QFtest_dt_sliceTt, %_QFtest_dt_sliceTt* null, i64 1) to i64), i64 2)]] }
 // CHECK-SAME: , i32* %[[a4]], 0