[flang] add hlfir.null to implement NULL()

[jeanPerier]

Summary

In HLFIR, the address of a Fortran entity in lowering must be defined
by an operation that has the FortranVariableOpInterface (it is a sanity
requirement to ensure that the mlir::Value propagated in certain places
of lowering can be reasoned about).
fir.zero_bits does not have this interface and it makes little sense to
add it since it can "zero initialize" more types than just addresses.

Creating an hlfir.declare for null addresses is a bit too much (what
would be the name), and it would be noisy in the IR.

Instead add a small hlfir.null operation whose codegen is simply a
replacement by fir.zero_bits.

It may also later help dealing with the NULL(MOLD) cases in a nicer
way (the current lowering of this uses special handling it).

[PeteSteinfeld]

All builds and tests correctly and looks good.

[vdonaldson]

flang/include/flang/Optimizer/HLFIR/HLFIROps.td

469

This formatting looks a little odd.

[jeanPerier]

Remove extra space caught by Val.

flang/include/flang/Optimizer/HLFIR/HLFIROps.td

def hlfir_ApplyOp : hlfir_Op<"apply", [NoMemoryEffect, AttrSizedOperandSegments]> {
   }];
 
   let builders = [
     OpBuilder<(ins "mlir::Value":$expr, "mlir::ValueRange":$indices,
       "mlir::ValueRange":$typeparams)>
   ];
 }
 
+def hlfir_NullOp : hlfir_Op<"null", [NoMemoryEffect, fir_FortranVariableOpInterface]> {
+  let summary = "create a NULL() address";
+
+  let description = [{
+    Create a NULL() address.
+    So far is not intended to represent NULL(MOLD).
+  }];
+
+  let results = (outs AnyFortranVariable);
+  let builders = [OpBuilder<(ins)>];
+
+  let assemblyFormat = "type(results) attr-dict";
+  let extraClassDeclaration = [{
+    // Implement FortranVariableInterface interface.
+    std::optional<fir::FortranVariableFlagsEnum> getFortranAttrs() const {
+      return std::nullopt;
+    }
+    mlir::Value getShape() const {return mlir::Value{};}
+    mlir::OperandRange getExplicitTypeParams() const {
+      // Return an empty range.
+      return {(*this)->getOperands().begin(), (*this)->getOperands().begin()};
+    }
+  }];
+}
+
 #endif // FORTRAN_DIALECT_HLFIR_OPS

flang/lib/Optimizer/HLFIR/IR/HLFIROps.cpp

void hlfir::ApplyOp::build(mlir::OpBuilder &builder,
                            mlir::ValueRange indices,
                            mlir::ValueRange typeparams) {
   mlir::Type resultType = expr.getType();
   if (auto exprType = resultType.dyn_cast<hlfir::ExprType>())
     resultType = exprType.getElementExprType();
   build(builder, odsState, resultType, expr, indices, typeparams);
 }
 
+//===----------------------------------------------------------------------===//
+// NullOp
+//===----------------------------------------------------------------------===//
+
+void hlfir::NullOp::build(mlir::OpBuilder &builder,
+                          mlir::OperationState &odsState) {
+  return build(builder, odsState,
+               fir::ReferenceType::get(builder.getNoneType()));
+}
+
 #define GET_OP_CLASSES
 #include "flang/Optimizer/HLFIR/HLFIROps.cpp.inc"

flang/lib/Optimizer/HLFIR/Transforms/ConvertToFIR.cpp

public:
   matchAndRewrite(hlfir::NoReassocOp noreassoc,
                   mlir::PatternRewriter &rewriter) const override {
     rewriter.replaceOpWithNewOp<fir::NoReassocOp>(noreassoc,
                                                   noreassoc.getVal());
     return mlir::success();
   }
 };
 
+class NullOpConversion : public mlir::OpRewritePattern<hlfir::NullOp> {
+public:
+  explicit NullOpConversion(mlir::MLIRContext *ctx) : OpRewritePattern{ctx} {}
+
+  mlir::LogicalResult
+  matchAndRewrite(hlfir::NullOp nullop,
+                  mlir::PatternRewriter &rewriter) const override {
+    rewriter.replaceOpWithNewOp<fir::ZeroOp>(nullop, nullop.getType());
+    return mlir::success();
+  }
+};
+
 class ConvertHLFIRtoFIR
     : public hlfir::impl::ConvertHLFIRtoFIRBase<ConvertHLFIRtoFIR> {
 public:
   void runOnOperation() override {
     // TODO: like "bufferize-hlfir" pass, runtime signature may be added
     // by this pass. This requires the pass to run on the ModuleOp. It would
     // probably be more optimal to have it run on FuncOp and find a way to
     // generate the signatures in a thread safe way.
     auto module = this->getOperation();
     auto *context = &getContext();
     mlir::RewritePatternSet patterns(context);
-    patterns.insert<AssignOpConversion, DeclareOpConversion,
-                    DesignateOpConversion, NoReassocOpConversion>(context);
+    patterns
+        .insert<AssignOpConversion, DeclareOpConversion, DesignateOpConversion,
+                NoReassocOpConversion, NullOpConversion>(context);
     mlir::ConversionTarget target(*context);
     target.addIllegalDialect<hlfir::hlfirDialect>();
     target.markUnknownOpDynamicallyLegal(
         [](mlir::Operation *) { return true; });
     if (mlir::failed(mlir::applyPartialConversion(module, target,
                                                   std::move(patterns)))) {
       mlir::emitError(mlir::UnknownLoc::get(context),
                       "failure in HLFIR to FIR conversion pass");

flang/test/HLFIR/null-codegen.fir

+// Test hlfir.null code generation to FIR
+
+// RUN: fir-opt %s -convert-hlfir-to-fir | FileCheck %s
+
+func.func @test() {
+  // CHECK: fir.zero_bits !fir.ref<none>
+  %0 = hlfir.null !fir.ref<none>
+  return
+}

flang/test/HLFIR/null.fir

+// Test hlfir.null operation parse, verify (no errors), and unparse.
+
+// RUN: fir-opt %s | fir-opt | FileCheck %s
+
+func.func @test() {
+  // CHECK: hlfir.null !fir.ref<none>
+  %0 = hlfir.null !fir.ref<none>
+  return
+}