`20fb85b`

Honor type_spec in reshape ArrayConstructor lowering

F2018 §7.8: a typed array constructor '[T :: ...]' has element type T
regardless of the element expressions' types. The reshape lowering at
lower_reshape_array_expr_descriptor inferred elem_ty solely via
first_array_constructor_type_info, which examines the first value
expression. For 'reshape([real(dp) :: 1, 2, 3, 4], [2, 2])' the values
are integer literals (4 bytes), so the materialised descriptor was
elem_size=4 instead of 8.

The malformed elem_size propagated through the reshape result; when
passed to an assumed-shape dummy 'a(:,:)' and used as SOURCE= in an
ALLOCATE, afs_prepare_array_copy saw 'dest.elem_size != source.elem_size'
(8 != 4), freed the freshly-allocated dest buffer, zeroed base_addr,
and the next read of 'amat(1,1)' SEGV'd. Surfaced across stdlib's det /
determinant / eig / qr clusters whose examples invoke
'det(reshape([real(dp)::1,2,3,4], [2,2]))'.

Consult type_spec first; fall back to first-element inference only when
no type_spec is present.

Authored by mfwolffe <wolffemf@dukes.jmu.edu> 6 days ago

SHA: 20fb85bb5e67aed3accc3356da6603346b499116
Parents: 8e5daf7
Tree: b86f7ff

2 changed files

Status	File	+	-
M	`src/ir/lower/core.rs`	16	2
M	`tests/cli_driver.rs`	66	0

src/ir/lower/core.rsmodified

      // assignment plans handle them, but RESHAPE consumes the descriptor
      // directly. Try materialization first; fall back to the regular
      // descriptor path for Names, intrinsic calls, etc.
 -    let (source_desc, elem_ty) = if let Expr::ArrayConstructor { values, .. } = &source_expr.node {
 -        let elem_ty = first_array_constructor_type_info(values, Some(locals), st, type_layouts)
 +    let (source_desc, elem_ty) = if let Expr::ArrayConstructor { values, type_spec } = &source_expr.node {
 +        // F2018 §7.8: a typed array constructor `[T :: ...]` has element
 +        // type T regardless of the element expressions' types.  For
 +        // `reshape([real(dp) :: 1, 2, 3, 4], [2, 2])` the values are
 +        // integer literals, but the constructor's type is real(dp) — so
 +        // its descriptor must carry elem_size=8.  Without consulting
 +        // type_spec first the materialised descriptor was elem_size=4
 +        // (integer), and downstream `allocate(amat(...), source=…)` then
 +        // saw an elem_size mismatch in afs_prepare_array_copy and
 +        // freed the freshly-allocated dest, producing a SEGV on the
 +        // next read of `amat(1,1)`.
 +        let elem_ty = type_spec
 +            .as_ref()
 +            .and_then(|s| crate::sema::types::type_spec_to_fortran_type(s, st))
 +            .and_then(|fty| fortran_type_to_type_info(&fty))
 +            .or_else(|| first_array_constructor_type_info(values, Some(locals), st, type_layouts))
              .map(|ti| type_info_to_ir_type(&ti))
              .unwrap_or(IrType::Float(FloatWidth::F32));
          let desc = lower_runtime_array_constructor_descriptor(

tests/cli_driver.rsmodified

      let _ = std::fs::remove_file(&src);
+ }
 +#[test]
 +fn reshape_typed_array_constructor_preserves_elem_size_through_assumed_shape() {
 +    // F2018 §7.8: a typed array constructor `[T :: ...]` has element
 +    // type T regardless of the element expressions' types.  The reshape
 +    // lowering used to ignore type_spec and infer elem_ty from the
 +    // first value — `[real(dp) :: 1, 2, 3, 4]` would resolve as integer
 +    // (4 bytes) instead of real(dp) (8 bytes).  The malformed elem_size
 +    // then propagated through the reshape result descriptor; when
 +    // passed to an assumed-shape dummy and used as the SOURCE= of an
 +    // ALLOCATE, afs_prepare_array_copy saw `dest.elem_size != source.elem_size`,
 +    // freed the freshly-allocated dest buffer, zeroed base_addr, and
 +    // SEGV'd on the next read.  Surfaced in stdlib's det / determinant /
 +    // eig / qr clusters where examples invoke
 +    // `det(reshape([real(dp)::1,2,3,4], [2,2]))`.
 +    let src = write_program(
 +        r#"
 +module m
 +  implicit none
 +  integer, parameter :: dp = kind(1.0d0)
 +contains
 +  function probe(a) result(s)
 +    real(dp), intent(in) :: a(:, :)
 +    real(dp) :: s
 +    real(dp), allocatable :: amat(:, :)
 +    allocate(amat(size(a,1), size(a,2)), source=a)
 +    s = amat(1, 1) + amat(2, 2)
 +    deallocate(amat)
 +  end function
 +end module
 +program t
 +  use m
 +  implicit none
 +  real(dp) :: r
 +  r = probe(reshape([real(dp) :: 1, 2, 3, 4], [2, 2]))
 +  if (abs(r - 5.0_dp) > 1.0e-12_dp) error stop 1
 +  print *, 'ok'
 +end program
 +"#,
 +        "f90",
 +    );
 +    let out = unique_path("reshape_typed_ac_elem_size", "bin");
 +    let compile = Command::new(compiler("armfortas"))
 +        .args([src.to_str().unwrap(), "-o", out.to_str().unwrap()])
 +        .output()
 +        .expect("reshape-typed-ac compile spawn failed");
 +    assert!(
 +        compile.status.success(),
 +        "should compile cleanly: {}",
 +        String::from_utf8_lossy(&compile.stderr)
 +    );
 +    let run = Command::new(&out).output().expect("run failed");
 +    assert!(
 +        run.status.success(),
 +        "reshape→source= runtime failed: status={:?} stderr={}",
 +        run.status,
 +        String::from_utf8_lossy(&run.stderr)
 +    );
 +    assert!(
 +        String::from_utf8_lossy(&run.stdout).contains("ok"),
 +        "expected 'ok' from reshape→source=: {}",
 +        String::from_utf8_lossy(&run.stdout)
 +    );
 +    let _ = std::fs::remove_file(&out);
 +    let _ = std::fs::remove_file(&src);
 +}
++
  #[test]
  fn allocate_with_source_from_assumed_shape_dummy_populates_base_addr() {
      // F2018 §9.7.1.2: ALLOCATE(..., SOURCE=expr) requires only that