[flang] optionally lower scalar and explicit shape with fir.declare

[jeanPerier]

Summary

Lower scalar and explicit shape arrays to fir.declare under the -hlfir option.
Update the SymMap so that it can hold fir::FortranVariableInterface.

The plan is to go towards a SymMap that only contains fir::FortranVariableInterface
once current expression lowering can be replaced. This should make the SymMap lighter
than it is today (SymBox/ExtendedValue are above 256 bytes).

Assumed shape, allocatable and pointer are left TODOs for now. Anything with a
specification expression that is not a constant expression will only be able to
be lowered when the HLFIR expression lowering skeleton is added.

[clementval]

LGTM

[jeanPerier]

clang-format flang/include/flang/Lower/SymbolMap.h

[PeteSteinfeld]

I have some questions ...

flang/include/flang/Lower/SymbolMap.h

351–352

This function is not used anywhere. Will future changes will make use of it?

flang/lib/Lower/ConvertVariable.cpp

1341–1364

It doesn't look like this code will ever be reached.

1342

Did you mean for this blank line to be here?

flang/lib/Lower/SymbolMap.cpp

103–106

Should these be returning llvm::None?

113–116

Why does one of these terminate in a newline and the other doesn't?

[jeanPerier]

Remove unused and unreachable code. Remove extra blank line.

[jeanPerier]

Thanks @PeteSteinfeld

flang/include/flang/Lower/SymbolMap.h

351–352

Soon, but you are right, I'll just remove it until it is used.

flang/lib/Lower/ConvertVariable.cpp

1341–1364

Indeed, removed.

flang/lib/Lower/SymbolMap.cpp

103–106

I think it is equivalent. I removed this code anyway for now. I'll try to remember adding it back with llvm::None :).

113–116

Why does one of these terminate in a newline and the other doesn't?

It is a bit confusing, but os << *symBox; calls Fortran::lower::operator<<(llvm::raw_ostream &os, const Fortran::lower::SymbolBox &symBox) define just above that adds new lines on its own. The SymBox part should anyway be removed when the transition is over. So in both cases a new line is added.

[PeteSteinfeld]

Thanks for making these changes!

All builds and tests correctly and looks good.

flang/include/flang/Lower/SymbolMap.h

 //===----------------------------------------------------------------------===//
 
 #ifndef FORTRAN_LOWER_SYMBOLMAP_H
 #define FORTRAN_LOWER_SYMBOLMAP_H
 
 #include "flang/Common/reference.h"
 #include "flang/Optimizer/Builder/BoxValue.h"
 #include "flang/Optimizer/Dialect/FIRType.h"
+#include "flang/Optimizer/Dialect/FortranVariableInterface.h"
 #include "flang/Optimizer/Support/Matcher.h"
 #include "flang/Semantics/symbol.h"
 #include "mlir/IR/Value.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/Support/Compiler.h"
public:
   }
 
   friend llvm::raw_ostream &operator<<(llvm::raw_ostream &os,
                                        const SymMap &symMap);
 
   /// Dump the map. For debugging.
   LLVM_DUMP_METHOD void dump() const { llvm::errs() << *this << '\n'; }
 
+  void addVariableDefinition(semantics::SymbolRef symRef,
+                             fir::FortranVariableOpInterface definingOp,
+                             bool force = false) {
+    const auto *sym = &symRef.get().GetUltimate();
+    if (force)
+      symbolMapStack.back().erase(sym);
+    symbolMapStack.back().try_emplace(sym, definingOp);
+  }
+
 private:
   /// Add `symbol` to the current map and bind a `box`.
   void makeSym(semantics::SymbolRef symRef, const SymbolBox &box,
                bool force = false) {
     const auto *sym = &symRef.get().GetUltimate();
     if (force)
       symbolMapStack.back().erase(sym);
     assert(box && "cannot add an undefined symbol box");
     symbolMapStack.back().try_emplace(sym, box);
   }
 
-  llvm::SmallVector<llvm::DenseMap<const semantics::Symbol *, SymbolBox>>
+  llvm::SmallVector<
+      llvm::DenseMap<const semantics::Symbol *,
+                     std::variant<SymbolBox, fir::FortranVariableOpInterface>>>
       symbolMapStack;
 
   // Implied DO induction variables are not represented as Se::Symbol in
   // Ev::Expr. Keep the variable markers in their own stack.
   llvm::SmallVector<std::pair<AcDoVar, mlir::Value>> impliedDoStack;
 };
 
 } // namespace Fortran::lower
 
 #endif // FORTRAN_LOWER_SYMBOLMAP_H

flang/include/flang/Optimizer/Builder/FIRBuilder.h

mlir::Value convertToIndexType(mlir::Location loc, mlir::Value val) {
     return createConvert(loc, getIndexType(), val);
   }
 
   /// Construct one of the two forms of shape op from an array box.
   mlir::Value genShape(mlir::Location loc, const fir::AbstractArrayBox &arr);
   mlir::Value genShape(mlir::Location loc, llvm::ArrayRef<mlir::Value> shift,
                        llvm::ArrayRef<mlir::Value> exts);
   mlir::Value genShape(mlir::Location loc, llvm::ArrayRef<mlir::Value> exts);
+  mlir::Value genShift(mlir::Location loc, llvm::ArrayRef<mlir::Value> shift);
 
   /// Create one of the shape ops given an extended value. For a boxed value,
   /// this may create a `fir.shift` op.
   mlir::Value createShape(mlir::Location loc, const fir::ExtendedValue &exv);
 
   /// Create a slice op extended value. The value to be sliced, `exv`, must be
   /// an array.
   mlir::Value createSlice(mlir::Location loc, const fir::ExtendedValue &exv,

flang/lib/Lower/ConvertVariable.cpp

if (auto seqTy = fir::unwrapUntilSeqType(initVal.getType())) {
                                                                       : fst);
       return result;
     }
   }
   result.assign(shapeVec.begin(), shapeVec.end());
   return result;
 }
 
+static fir::FortranVariableFlagsAttr
+translateSymbolAttributes(mlir::MLIRContext *mlirContext,
+                          const Fortran::semantics::Symbol &sym) {
+  fir::FortranVariableFlagsEnum flags = fir::FortranVariableFlagsEnum::None;
+  const auto &attrs = sym.attrs();
+  if (attrs.test(Fortran::semantics::Attr::ALLOCATABLE))
+    flags = flags | fir::FortranVariableFlagsEnum::allocatable;
+  if (attrs.test(Fortran::semantics::Attr::ASYNCHRONOUS))
+    flags = flags | fir::FortranVariableFlagsEnum::asynchronous;
+  if (attrs.test(Fortran::semantics::Attr::BIND_C))
+    flags = flags | fir::FortranVariableFlagsEnum::bind_c;
+  if (attrs.test(Fortran::semantics::Attr::CONTIGUOUS))
+    flags = flags | fir::FortranVariableFlagsEnum::contiguous;
+  if (attrs.test(Fortran::semantics::Attr::INTENT_IN))
+    flags = flags | fir::FortranVariableFlagsEnum::intent_in;
+  if (attrs.test(Fortran::semantics::Attr::INTENT_INOUT))
+    flags = flags | fir::FortranVariableFlagsEnum::intent_inout;
+  if (attrs.test(Fortran::semantics::Attr::INTENT_OUT))
+    flags = flags | fir::FortranVariableFlagsEnum::intent_out;
+  if (attrs.test(Fortran::semantics::Attr::OPTIONAL))
+    flags = flags | fir::FortranVariableFlagsEnum::optional;
+  if (attrs.test(Fortran::semantics::Attr::PARAMETER))
+    flags = flags | fir::FortranVariableFlagsEnum::parameter;
+  if (attrs.test(Fortran::semantics::Attr::POINTER))
+    flags = flags | fir::FortranVariableFlagsEnum::pointer;
+  if (attrs.test(Fortran::semantics::Attr::TARGET))
+    flags = flags | fir::FortranVariableFlagsEnum::target;
+  if (attrs.test(Fortran::semantics::Attr::VALUE))
+    flags = flags | fir::FortranVariableFlagsEnum::value;
+  if (attrs.test(Fortran::semantics::Attr::VOLATILE))
+    flags = flags | fir::FortranVariableFlagsEnum::fortran_volatile;
+  if (flags == fir::FortranVariableFlagsEnum::None)
+    return {};
+  return fir::FortranVariableFlagsAttr::get(mlirContext, flags);
+}
+
 /// Map a symbol to its FIR address and evaluated specification expressions.
 /// Not for symbols lowered to fir.box.
 /// Will optionally create fir.declare.
 static void genDeclareSymbol(Fortran::lower::AbstractConverter &converter,
                              Fortran::lower::SymMap &symMap,
                              const Fortran::semantics::Symbol &sym,
                              mlir::Value base, mlir::Value len = {},
                              llvm::ArrayRef<mlir::Value> shape = llvm::None,
                              llvm::ArrayRef<mlir::Value> lbounds = llvm::None,
                              bool force = false) {
-  if (converter.getLoweringOptions().getLowerToHighLevelFIR())
-    TODO(genLocation(converter, sym),
-         "generate fir.declare when lowering symbol");
+  if (converter.getLoweringOptions().getLowerToHighLevelFIR()) {
+    fir::FirOpBuilder &builder = converter.getFirOpBuilder();
+    const mlir::Location loc = genLocation(converter, sym);
+    mlir::Value shapeOrShift;
+    if (!shape.empty() && !lbounds.empty())
+      shapeOrShift = builder.genShape(loc, shape, lbounds);
+    else if (!shape.empty())
+      shapeOrShift = builder.genShape(loc, shape);
+    else if (!lbounds.empty())
+      shapeOrShift = builder.genShift(loc, lbounds);
+    llvm::SmallVector<mlir::Value> lenParams;
+    if (len)
+      lenParams.emplace_back(len);
+    auto name = mlir::StringAttr::get(builder.getContext(),
+                                      Fortran::lower::mangle::mangleName(sym));
+    fir::FortranVariableFlagsAttr attributes =
+        translateSymbolAttributes(builder.getContext(), sym);
+    auto newBase = builder.create<fir::DeclareOp>(
+        loc, base.getType(), base, shapeOrShift, lenParams, name, attributes);
+    base = newBase;
+    symMap.addVariableDefinition(sym, newBase);
+    return;
+  }
 
   if (len) {
     if (!shape.empty()) {
       if (!lbounds.empty())
         symMap.addCharSymbolWithBounds(sym, base, len, shape, lbounds, force);
       else
         symMap.addCharSymbolWithShape(sym, base, len, shape, force);
     } else {

flang/lib/Lower/SymbolMap.cpp

 //===-- SymbolMap.cpp -----------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // Pretty printers for symbol boxes, etc.
 //
 //===----------------------------------------------------------------------===//
 
 #include "flang/Lower/SymbolMap.h"
+#include "flang/Optimizer/Builder/Todo.h"
 #include "mlir/IR/BuiltinTypes.h"
 #include "llvm/Support/Debug.h"
 
 #define DEBUG_TYPE "flang-lower-symbol-map"
 
 void Fortran::lower::SymMap::addSymbol(Fortran::semantics::SymbolRef sym,
                                        const fir::ExtendedValue &exv,
                                        bool force) {
   exv.match([&](const fir::UnboxedValue &v) { addSymbol(sym, v, force); },
             [&](const fir::CharBoxValue &v) { makeSym(sym, v, force); },
             [&](const fir::ArrayBoxValue &v) { makeSym(sym, v, force); },
             [&](const fir::CharArrayBoxValue &v) { makeSym(sym, v, force); },
             [&](const fir::BoxValue &v) { makeSym(sym, v, force); },
             [&](const fir::MutableBoxValue &v) { makeSym(sym, v, force); },
             [](auto) {
               llvm::report_fatal_error("value not added to symbol table");
             });
 }
 
+Fortran::lower::SymbolBox toSymbolBox(
+    std::variant<Fortran::lower::SymbolBox, fir::FortranVariableOpInterface>
+        symboxOrdefiningOp) {
+  if (const Fortran::lower::SymbolBox *symBox =
+          std::get_if<Fortran::lower::SymbolBox>(&symboxOrdefiningOp))
+    return *symBox;
+  auto definingOp =
+      std::get<fir::FortranVariableOpInterface>(symboxOrdefiningOp);
+  TODO(definingOp.getLoc(), "FortranVariableOpInterface lookup as SymbolBox");
+}
+
 Fortran::lower::SymbolBox
 Fortran::lower::SymMap::lookupSymbol(Fortran::semantics::SymbolRef symRef) {
   Fortran::semantics::SymbolRef sym = symRef.get().GetUltimate();
   for (auto jmap = symbolMapStack.rbegin(), jend = symbolMapStack.rend();
        jmap != jend; ++jmap) {
     auto iter = jmap->find(&*sym);
     if (iter != jmap->end())
-      return iter->second;
+      return toSymbolBox(iter->second);
   }
   return SymbolBox::None{};
 }
 
 Fortran::lower::SymbolBox Fortran::lower::SymMap::shallowLookupSymbol(
     Fortran::semantics::SymbolRef symRef) {
   auto &map = symbolMapStack.back();
   auto iter = map.find(&symRef.get().GetUltimate());
   if (iter != map.end())
-    return iter->second;
+    return toSymbolBox(iter->second);
   return SymbolBox::None{};
 }
 
 /// Skip one level when looking up the symbol. The use case is such as looking
 /// up the host variable symbol box by skipping the associated level in
 /// host-association in OpenMP code.
 Fortran::lower::SymbolBox Fortran::lower::SymMap::lookupOneLevelUpSymbol(
     Fortran::semantics::SymbolRef symRef) {
   Fortran::semantics::SymbolRef sym = symRef.get().GetUltimate();
   auto jmap = symbolMapStack.rbegin();
   auto jend = symbolMapStack.rend();
   if (jmap == jend)
     return SymbolBox::None{};
   // Skip one level in symbol map stack.
   for (++jmap; jmap != jend; ++jmap) {
     auto iter = jmap->find(&*sym);
     if (iter != jmap->end())
-      return iter->second;
+      return toSymbolBox(iter->second);
   }
   return SymbolBox::None{};
 }
 
 mlir::Value
 Fortran::lower::SymMap::lookupImpliedDo(Fortran::lower::SymMap::AcDoVar var) {
   for (auto [marker, binding] : llvm::reverse(impliedDoStack))
     if (var == marker)
       return binding;
   return {};
 }
 
 llvm::raw_ostream &
 Fortran::lower::operator<<(llvm::raw_ostream &os,
                            const Fortran::lower::SymbolBox &symBox) {
   symBox.match(
       [&](const Fortran::lower::SymbolBox::None &box) {
         os << "** symbol not properly mapped **\n";
       },
       [&](const Fortran::lower::SymbolBox::Intrinsic &val) {
         os << val.getAddr() << '\n';
       },
       [&](const auto &box) { os << box << '\n'; });
   return os;
 }
 
+static llvm::raw_ostream &
+dump(llvm::raw_ostream &os,
+     const std::variant<Fortran::lower::SymbolBox,
+                        fir::FortranVariableOpInterface> &symboxOrdefiningOp) {
+  if (const Fortran::lower::SymbolBox *symBox =
+          std::get_if<Fortran::lower::SymbolBox>(&symboxOrdefiningOp))
+    return os << *symBox;
+  auto definingOp =
+      std::get<fir::FortranVariableOpInterface>(symboxOrdefiningOp);
+  return os << definingOp << "\n";
+}
+
 llvm::raw_ostream &
 Fortran::lower::operator<<(llvm::raw_ostream &os,
                            const Fortran::lower::SymMap &symMap) {
   os << "Symbol map:\n";
   for (auto i : llvm::enumerate(symMap.symbolMapStack)) {
     os << " level " << i.index() << "<{\n";
-    for (auto iter : i.value())
+    for (auto iter : i.value()) {
       os << "  symbol @" << static_cast<const void *>(iter.first) << " ["
-         << *iter.first << "] ->\n    " << iter.second;
+         << *iter.first << "] ->\n    ";
+      dump(os, iter.second);
+    }
     os << " }>\n";
   }
   return os;
 }

flang/lib/Optimizer/Builder/FIRBuilder.cpp

 
 mlir::Value fir::FirOpBuilder::genShape(mlir::Location loc,
                                         const fir::AbstractArrayBox &arr) {
   if (arr.lboundsAllOne())
     return genShape(loc, arr.getExtents());
   return genShape(loc, arr.getLBounds(), arr.getExtents());
 }
 
+mlir::Value fir::FirOpBuilder::genShift(mlir::Location loc,
+                                        llvm::ArrayRef<mlir::Value> shift) {
+  auto shiftType = fir::ShiftType::get(getContext(), shift.size());
+  return create<fir::ShiftOp>(loc, shiftType, shift);
+}
+
 mlir::Value fir::FirOpBuilder::createShape(mlir::Location loc,
                                            const fir::ExtendedValue &exv) {
   return exv.match(
       [&](const fir::ArrayBoxValue &box) { return genShape(loc, box); },
       [&](const fir::CharArrayBoxValue &box) { return genShape(loc, box); },
       [&](const fir::BoxValue &box) -> mlir::Value {
         if (!box.getLBounds().empty()) {
           auto shiftType =

flang/test/Lower/HLFIR/convert-variable.f90

+! Test lowering of variables to fir.declare
+! RUN: bbc -emit-fir -hlfir %s -o - | FileCheck %s
+
+subroutine scalar_numeric(x)
+  integer :: x
+end subroutine
+! CHECK-LABEL: func.func @_QPscalar_numeric(
+! CHECK-SAME:    %[[VAL_0:.*]]: !fir.ref<i32>
+! CHECK:  %[[VAL_1:.*]] = fir.declare %[[VAL_0]] {uniq_name = "_QFscalar_numericEx"} : (!fir.ref<i32>) -> !fir.ref<i32>
+
+subroutine scalar_character(c)
+  character(*) :: c
+end subroutine
+! CHECK-LABEL: func.func @_QPscalar_character(
+! CHECK-SAME:    %[[VAL_0:.*]]: !fir.boxchar<1>
+! CHECK:  %[[VAL_1:.*]]:2 = fir.unboxchar %[[VAL_0]] : (!fir.boxchar<1>) -> (!fir.ref<!fir.char<1,?>>, index)
+! CHECK:  %[[VAL_2:.*]] = fir.declare %[[VAL_1]]#0 typeparams %[[VAL_1]]#1 {uniq_name = "_QFscalar_characterEc"} : (!fir.ref<!fir.char<1,?>>, index) -> !fir.ref<!fir.char<1,?>>
+
+subroutine scalar_character_cst_len(c)
+  character(10) :: c
+end subroutine
+! CHECK-LABEL: func.func @_QPscalar_character_cst_len(
+! CHECK-SAME:    %[[VAL_0:.*]]: !fir.boxchar<1>
+! CHECK:  %[[VAL_1:.*]]:2 = fir.unboxchar %[[VAL_0]] : (!fir.boxchar<1>) -> (!fir.ref<!fir.char<1,?>>, index)
+! CHECK:  %[[VAL_2:.*]] = arith.constant 10 : index
+! CHECK:  %[[VAL_3:.*]] = fir.declare %[[VAL_1]]#0 typeparams %[[VAL_2]] {uniq_name = "_QFscalar_character_cst_lenEc"} : (!fir.ref<!fir.char<1,?>>, index) -> !fir.ref<!fir.char<1,?>>
+
+subroutine array_numeric(x)
+  integer :: x(10, 20)
+end subroutine
+! CHECK-LABEL: func.func @_QParray_numeric(
+! CHECK-SAME:    %[[VAL_0:.*]]: !fir.ref<!fir.array<10x20xi32>>
+! CHECK:  %[[VAL_1:.*]] = arith.constant 10 : index
+! CHECK:  %[[VAL_2:.*]] = arith.constant 20 : index
+! CHECK:  %[[VAL_3:.*]] = fir.shape %[[VAL_1]], %[[VAL_2]] : (index, index) -> !fir.shape<2>
+! CHECK:  %[[VAL_4:.*]] = fir.declare %[[VAL_0]](%[[VAL_3]]) {uniq_name = "_QFarray_numericEx"} : (!fir.ref<!fir.array<10x20xi32>>, !fir.shape<2>) -> !fir.ref<!fir.array<10x20xi32>>
+
+
+subroutine array_numeric_lbounds(x)
+  integer :: x(-1:10, -2:20)
+end subroutine
+! CHECK-LABEL: func.func @_QParray_numeric_lbounds(
+! CHECK-SAME:    %[[VAL_0:.*]]: !fir.ref<!fir.array<12x23xi32>>
+! CHECK:  %[[VAL_1:.*]] = arith.constant -1 : index
+! CHECK:  %[[VAL_2:.*]] = arith.constant 12 : index
+! CHECK:  %[[VAL_3:.*]] = arith.constant -2 : index
+! CHECK:  %[[VAL_4:.*]] = arith.constant 23 : index
+! CHECK:  %[[VAL_5:.*]] = fir.shape_shift %[[VAL_2]], %[[VAL_1]], %[[VAL_4]], %[[VAL_3]] : (index, index, index, index) -> !fir.shapeshift<2>
+! CHECK:  %[[VAL_6:.*]] = fir.declare %[[VAL_0]](%[[VAL_5]]) {uniq_name = "_QFarray_numeric_lboundsEx"} : (!fir.ref<!fir.array<12x23xi32>>, !fir.shapeshift<2>) -> !fir.ref<!fir.array<12x23xi32>>
+
+subroutine array_character(c)
+  character(*) :: c(50)
+end subroutine
+! CHECK-LABEL: func.func @_QParray_character(
+! CHECK-SAME:    %[[VAL_0:.*]]: !fir.boxchar<1>
+! CHECK:  %[[VAL_1:.*]]:2 = fir.unboxchar %[[VAL_0]] : (!fir.boxchar<1>) -> (!fir.ref<!fir.char<1,?>>, index)
+! CHECK:  %[[VAL_2:.*]] = fir.convert %[[VAL_1]]#0 : (!fir.ref<!fir.char<1,?>>) -> !fir.ref<!fir.array<50x!fir.char<1,?>>>
+! CHECK:  %[[VAL_3:.*]] = arith.constant 50 : index
+! CHECK:  %[[VAL_4:.*]] = fir.shape %[[VAL_3]] : (index) -> !fir.shape<1>
+! CHECK:  %[[VAL_5:.*]] = fir.declare %[[VAL_2]](%[[VAL_4]]) typeparams %[[VAL_1]]#1 {uniq_name = "_QFarray_characterEc"} : (!fir.ref<!fir.array<50x!fir.char<1,?>>>, !fir.shape<1>, index) -> !fir.ref<!fir.array<50x!fir.char<1,?>>>
+
+subroutine scalar_numeric_attributes(x)
+  integer, optional, target, intent(in) :: x
+end subroutine
+! CHECK-LABEL: func.func @_QPscalar_numeric_attributes(
+! CHECK-SAME:    %[[VAL_0:.*]]: !fir.ref<i32>
+! CHECK:  %[[VAL_1:.*]] = fir.declare %[[VAL_0]] {fortran_attrs = #fir.var_attrs<intent_in, optional, target>, uniq_name = "_QFscalar_numeric_attributesEx"} : (!fir.ref<i32>) -> !fir.ref<i32>
+
+subroutine scalar_numeric_attributes_2(x)
+  real(16), value :: x(100)
+end subroutine
+! CHECK-LABEL: func.func @_QPscalar_numeric_attributes_2(
+! CHECK-SAME:    %[[VAL_0:.*]]: !fir.ref<!fir.array<100xf128>>
+! CHECK:  %[[VAL_1:.*]] = arith.constant 100 : index
+! CHECK:  %[[VAL_2:.*]] = fir.shape %[[VAL_1]] : (index) -> !fir.shape<1>
+! CHECK:  %[[VAL_3:.*]] = fir.declare %[[VAL_0]](%[[VAL_2]]) {fortran_attrs = #fir.var_attrs<value>, uniq_name = "_QFscalar_numeric_attributes_2Ex"} : (!fir.ref<!fir.array<100xf128>>, !fir.shape<1>) -> !fir.ref<!fir.array<100xf128>>
+
+subroutine scalar_numeric_attributes_3(x)
+  real, intent(in) :: x
+end subroutine
+! CHECK-LABEL: func.func @_QPscalar_numeric_attributes_3(
+! CHECK-SAME:    %[[VAL_0:.*]]: !fir.ref<f32>
+! CHECK:  %[[VAL_1:.*]] = fir.declare %[[VAL_0]] {fortran_attrs = #fir.var_attrs<intent_in>, uniq_name = "_QFscalar_numeric_attributes_3Ex"} : (!fir.ref<f32>) -> !fir.ref<f32>
+
+subroutine scalar_numeric_attributes_4(x)
+  logical(8), intent(out) :: x
+end subroutine
+! CHECK-LABEL: func.func @_QPscalar_numeric_attributes_4(
+! CHECK-SAME:    %[[VAL_0:.*]]: !fir.ref<!fir.logical<8>>
+! CHECK:  %[[VAL_1:.*]] = fir.declare %[[VAL_0]] {fortran_attrs = #fir.var_attrs<intent_out>, uniq_name = "_QFscalar_numeric_attributes_4Ex"} : (!fir.ref<!fir.logical<8>>) -> !fir.ref<!fir.logical<8>>
+
+subroutine scalar_numeric_parameter()
+  integer, parameter :: p = 42
+end subroutine
+! CHECK-LABEL: func.func @_QPscalar_numeric_parameter() {
+! CHECK:  %[[VAL_0:.*]] = fir.address_of(@_QFscalar_numeric_parameterECp) : !fir.ref<i32>
+! CHECK:  %[[VAL_1:.*]] = fir.declare %[[VAL_0]] {fortran_attrs = #fir.var_attrs<parameter>, uniq_name = "_QFscalar_numeric_parameterECp"} : (!fir.ref<i32>) -> !fir.ref<i32>

flang/test/Lower/HLFIR/expr-addr.f90

 ! Test lowering of of expressions as address
 ! RUN: %not_todo_cmd bbc -emit-fir -hlfir -o - %s 2>&1 | FileCheck %s
 
 subroutine foo(x)
   integer :: x
-  ! CHECK: not yet implemented: generate fir.declare when lowering symbol
+  ! CHECK: not yet implemented: lower expr to HLFIR address
   read (*,*) x
 end subroutine