================
@@ -1250,6 +1253,508 @@ getSafeRepackAttrs(Fortran::lower::AbstractConverter
&converter) {
return attrs.empty() ? mlir::ArrayAttr{} : builder.getArrayAttr(attrs);
}
+//===----------------------------------------------------------------------===//
+// -finit-local= helpers
+//===----------------------------------------------------------------------===//
+
+/// Returns true if \p derived or any of its components (recursively) is a
+/// PowerPC vector type. fir::VectorType does not implement
+/// DataLayoutTypeInterface. Two pre-fix failure modes existed:
+/// - Direct vector local: silently initialized to zero regardless of mode
+/// (historical behavior); at the current head genByteSplatInit would
+/// hit llvm_unreachable instead.
+/// - Derived-type local with a vector component: crashed in record-size
+/// calculation when DataLayoutTypeInterface was queried.
+/// Excluding both cases at eligibility time avoids both failure modes.
+static bool
+containsVectorComponent(const Fortran::semantics::DerivedTypeSpec &derived) {
+ if (derived.IsVectorType())
+ return true;
+ const Fortran::semantics::Scope *scope = derived.GetScope();
+ if (!scope)
+ return false;
+ const Fortran::semantics::Symbol &typeSym = derived.typeSymbol();
+ const auto *details =
+ typeSym.detailsIf<Fortran::semantics::DerivedTypeDetails>();
+ if (!details)
+ return false;
+ for (const Fortran::semantics::SourceName &compName :
+ details->componentNames()) {
+ auto it = scope->find(compName);
+ if (it == scope->cend())
+ continue;
+ const Fortran::semantics::Symbol &comp = it->second.get();
+ if (const Fortran::semantics::DeclTypeSpec *compTy = comp.GetType())
+ if (const Fortran::semantics::DerivedTypeSpec *compDerived =
+ compTy->AsDerived())
+ if (containsVectorComponent(*compDerived))
+ return true;
+ }
+ return false;
+}
+
+/// Returns true when \p var is an automatic local variable eligible for
+/// -finit-local= initialization. Excluded: variables without a symbol,
+/// globals, dummy arguments, SAVE'd vars, ALLOCATABLE/POINTER, vars in
+/// an EQUIVALENCE set, vars with explicit or default initialization, and
+/// CUDA variables whose storage is always unreachable by a plain fir.store
+/// (constant, shared, usedevice). The Device case is deferred to genInitLocal
+/// which applies cuf::isCUDADeviceContext to distinguish cuf.alloc from
+/// fir.alloca storage.
+static bool shouldInitLocal(const Fortran::lower::pft::Variable &var) {
+ if (!var.hasSymbol() || var.isGlobal())
+ return false;
+ const Fortran::semantics::Symbol &sym = var.getSymbol();
+ if (Fortran::semantics::IsDummy(sym))
+ return false;
+ // Function result variables own the return-value storage and must not be
+ // pre-initialized: the function body is responsible for setting the result.
+ if (sym.IsFuncResult())
+ return false;
+ // Main-program locals have implicit SAVE semantics (Fortran 2018 8.5.16p4).
+ // IsSaved() does not catch this case because the SAVE attribute is implicit
+ // rather than explicit, so check the enclosing scope kind directly.
+ if (sym.owner().kind() == Fortran::semantics::Scope::Kind::MainProgram)
+ return false;
+ if (Fortran::semantics::IsSaved(sym))
+ return false;
+ if (Fortran::semantics::IsAllocatableOrPointer(sym))
+ return false;
+ if (Fortran::lower::hasDefaultInitialization(sym))
+ return false;
+ if (const auto *obj =
+ sym.detailsIf<Fortran::semantics::ObjectEntityDetails>())
+ if (obj->init())
+ return false;
+ if (Fortran::semantics::FindEquivalenceSet(sym))
+ return false;
+ // Cray pointees own no storage of their own; their FIR base is a
+ // pointer-box descriptor. Initializing it would overwrite the
+ // descriptor, not the pointee storage.
+ if (sym.test(Fortran::semantics::Symbol::Flag::CrayPointee))
+ return false;
+ // PowerPC vector types (vector(real(4)) etc.) lower to fir::VectorType
+ // which does not implement DataLayoutTypeInterface at the HLFIR level.
+ // Without this guard:
+ // - A direct vector local would hit llvm_unreachable in genByteSplatInit
+ // (historically it silently fell back to zero before that assert was
+ // added).
+ // - A derived-type local with a vector component would crash in
+ // record-size calculation when DataLayoutTypeInterface was queried.
+ // Exclude both cases by walking components recursively.
+ if (const Fortran::semantics::DeclTypeSpec *declTy = sym.GetType())
+ if (const Fortran::semantics::DerivedTypeSpec *derived =
+ declTy->AsDerived())
+ if (containsVectorComponent(*derived))
+ return false;
+ // CUDA storage accessibility:
+ // constant / shared / usedevice: always unreachable by a plain fir.store
+ // from the host -- skip.
+ // device: the allocation choice (cuf.alloc vs fir.alloca) depends on
+ // whether the insertion point is in a device context; that check
+ // requires the MLIR builder and is deferred to genInitLocal, which
+ // calls cuf::isCUDADeviceContext(builder.getRegion()) after this
+ // predicate returns true.
+ // managed / unified / pinned: host-accessible unified memory --
initialize.
+ if (auto cudaAttr = Fortran::semantics::GetCUDADataAttr(&sym)) {
+ switch (*cudaAttr) {
+ case Fortran::common::CUDADataAttr::Constant:
+ case Fortran::common::CUDADataAttr::Shared:
+ case Fortran::common::CUDADataAttr::UseDevice:
+ return false;
+ default:
+ break;
+ }
+ }
+ return true;
+}
+
+/// Build a constant whose every byte equals \p bytePat.
+/// Handles: integer, float (bitcast from integer splat), complex (both parts),
+/// and logical (raw integer, stored via bitcasted address by the caller).
+/// Character, derived-type, and sequence types are all intercepted by
+/// genInitLocalStore or initAddr before this function is called and must
+/// not reach it. fir::VectorType (PowerPC vector types, direct or as a
+/// derived-type component) is excluded upstream by shouldInitLocal via
+/// containsVectorComponent and will never reach this function.
+static mlir::Value genByteSplatInit(fir::FirOpBuilder &builder,
+ mlir::Location loc, mlir::Type ty,
+ uint8_t bytePat) {
+ mlir::Type eleTy = fir::unwrapSequenceType(ty);
+
+ // Build a signless integer constant from a byte splat. arith.constant
+ // requires a signless integer type; callers that need a non-signless result
+ // (e.g. unsigned ui32) must fir.convert the returned value themselves.
+ auto makeIntCst = [&](unsigned bits) -> mlir::Value {
+ llvm::APInt byteVal(8, bytePat);
+ llvm::APInt splat = llvm::APInt::getSplat(bits, byteVal);
+ mlir::Type intTy = builder.getIntegerType(bits);
+ return mlir::arith::ConstantOp::create(
+ builder, loc, intTy, builder.getIntegerAttr(intTy, splat));
+ };
+
+ if (auto fpTy = mlir::dyn_cast<mlir::FloatType>(eleTy)) {
+ mlir::Value intCst = makeIntCst(fpTy.getWidth());
+ return mlir::arith::BitcastOp::create(builder, loc, fpTy, intCst);
+ }
+ if (auto intTy = mlir::dyn_cast<mlir::IntegerType>(eleTy)) {
+ mlir::Value cst = makeIntCst(intTy.getWidth());
+ // arith.constant only supports signless integers; fir.convert reinterprets
+ // the bit pattern into the declared signed or unsigned type without
+ // changing any bits, satisfying FIR verification for !fir.ref<ui32> etc.
+ if (!intTy.isSignless())
+ cst = builder.createConvert(loc, intTy, cst);
+ return cst;
+ }
+ // Complex: apply the byte pattern to each (real, imag) part.
+ if (auto cplxTy = mlir::dyn_cast<mlir::ComplexType>(eleTy)) {
+ mlir::Type partTy = cplxTy.getElementType();
+ mlir::Value partVal = genByteSplatInit(builder, loc, partTy, bytePat);
+ return mlir::complex::CreateOp::create(builder, loc, cplxTy, partVal,
+ partVal);
+ }
+ // LOGICAL(k) has a fixed size of k bytes under the default kind mapping,
+ // but a non-default mapping (e.g. --kind-mapping=l4:8) may map LOGICAL(4)
+ // to a single byte. Use KindMapping::getLogicalBitsize so the constant
+ // width matches the actual allocation size.
+ // The caller stores it via a bitcasted address to preserve the bit pattern
+ // (fir.convert from integer to !fir.logical normalizes nonzero -> true).
+ if (auto logTy = mlir::dyn_cast<fir::LogicalType>(eleTy)) {
+ return
makeIntCst(builder.getKindMap().getLogicalBitsize(logTy.getFKind()));
+ }
+ // All types that pass shouldInitLocal and reach genInitLocalStore are
+ // handled explicitly above (integer, float, complex, logical) or are
+ // intercepted before this call (character, record, sequence).
+ // PowerPC vector types (direct or as a derived-type component) are excluded
+ // by shouldInitLocal via containsVectorComponent and never reach here.
+ // A silent zero for an unhandled type would violate the hex-mode contract,
+ // so assert rather than fall back silently.
+ llvm_unreachable("genByteSplatInit: unhandled type in hex mode");
+}
+
+/// Emit a store of the -finit-local= pattern for a single scalar address.
+/// Fixed-length CHARACTER in hex mode: byte-loop over every byte of storage.
+/// LOGICAL stores via a bitcasted integer address to preserve the raw bit
+/// pattern past fir.convert normalization.
+/// All byte-view and coordinate types carry the source address volatility so
+/// that final stores are emitted as "store volatile" when the variable is
+/// volatile.
+static void genInitLocalStore(fir::FirOpBuilder &builder, mlir::Location loc,
+ mlir::Type ty, mlir::Value addr,
+ Fortran::lower::InitLocalKind mode,
+ uint8_t hexByte) {
+ // Fixed-length CHARACTER: for hex mode emit a compile-time byte-loop so
+ // every code-unit gets the requested pattern. Zero falls through to
+ // fir.zero_bits below.
+ if (auto charTy = mlir::dyn_cast<fir::CharacterType>(ty)) {
+ // CHARACTER(0) has zero-length storage -- nothing to initialize.
+ if (charTy.getLen() == 0)
+ return;
+ if (mode == Fortran::lower::InitLocalKind::Hex) {
+ // Loop over every byte of the character storage. For kind=1 each
+ // code unit is one byte; for kind=2/4 (UTF-16/32) each code unit is
+ // kind bytes wide. We use a kind=1 singleton as the view element so
+ // fir.coordinate_of advances exactly one byte per step, and iterate
+ // nUnits * kindBytes times to cover all bytes. Use KindMapping to
+ // get the true byte width under any --kind-mapping override.
+ int64_t nUnits = charTy.hasConstantLen() ? charTy.getLen() : 0;
+ int64_t kindBytes =
+ builder.getKindMap().getCharacterBitsize(charTy.getFKind()) / 8;
----------------
MattPD wrote:
This byte view writes outside the allocation when a kind mapping changes the
CHARACTER width. The element type should be an invariant `i8` rather than
`fir.char<1>`.
`fir::CharacterType::getSingleton(context, 1)` is CHARACTER kind 1, and the
LLVM type converter resolves it through the same `KindMapping` that the new
byte count consults. The count therefore honors the mapping while the stride
does not.
With `--kind-mapping=a1:16`, `character(kind=1,len=2)` occupies four bytes. The
loop runs four times. Each `fir.coordinate_of` advances two bytes. The stores
land at offsets 0, 2, 4, and 6, so two of them fall past the allocation while
bytes 1 and 3 are never written.
You can reproduce this by saving the following as `repro.f90`:
```fortran
subroutine s(sink)
integer :: sink
character(kind=1, len=2) :: c
sink = ichar(c(1:1))
end
```
```console
flang -fc1 -emit-llvm -mmlir --kind-mapping=a1:16 -finit-local=0xAA repro.f90
-o -
```
The emitted allocation is `[2 x i16]`, and the loop emits four `[1 x i16]`
accesses.
The runtime-length path at line 1725 has the same mismatch. With
`-finit-local=zero` it allocates `2n` bytes, runs `2n` iterations, and stores
two bytes at each two-byte step, so the writes cover `4n` bytes. An `i8` view
would hold the stride at one byte on both paths, and it would need to carry the
volatility flag this commit adds.
https://github.com/llvm/llvm-project/pull/216164
_______________________________________________
cfe-commits mailing list
[email protected]
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
