`e6f0227`

Fall back to actual's descriptor backing in proc-pointer call dispatch

Authored by

espadonne 3 days ago

Committed by mfwolffe

SHA: e6f02276c774a717a16bf316c236a0eaf1d5cf77
Parents: f465834
Tree: d204062

2 changed files

Status	File	+	-
M	`src/ir/lower/core.rs`	17	0
M	`src/ir/lower/expr.rs`	29	10

src/ir/lower/core.rsmodified

      info.allocatable || info.descriptor_arg
+ }
 +/// True if `expr` is a simple Name reference to a local whose runtime
 +/// representation is a descriptor (assumed-shape, allocatable, pointer
 +/// array). Used as a fallback when an abstract-interface mask lookup
 +/// misses, so we still pass the descriptor instead of the data pointer.
 +pub(super) fn actual_is_descriptor_array(
 +    locals: &HashMap<String, LocalInfo>,
 +    expr: &crate::ast::expr::SpannedExpr,
 +) -> bool {
 +    if let Expr::Name { name } = &expr.node {
 +        if let Some(info) = locals.get(&name.to_lowercase()) {
 +            return local_uses_array_descriptor(info)
 +                || (!info.dims.is_empty() && info.descriptor_arg);
 +        }
 +    }
 +    false
 +}
++
  const DESC_CHAR_SLOT_TABLE: i32 = 1 << 3;
  pub(super) fn array_descriptor_addr(b: &mut FuncBuilder, info: &LocalInfo) -> ValueId {

src/ir/lower/expr.rsmodified

+                                     )
                                      .unwrap_or(IrType::Int(IntWidth::I32));
                                      // Honor the abstract-interface descriptor
 -                                    // mask when forwarding actuals.  Without
 -                                    // this, an assumed-shape dummy
 -                                    // (`real(8), intent(in) :: x(:)`) received
 -                                    // only a base data pointer in place of
 -                                    // the descriptor — the callee then read
 -                                    // dims/rank out of the array elements'
 -                                    // bytes and segfaulted (stdlib's iterative
 -                                    // solvers all dispatch dot_product through
 -                                    // a procedure-pointer field this way).
 +                                    // mask when forwarding actuals.  When an
 +                                    // actual is a descriptor-backed array
 +                                    // (assumed-shape dummy / allocatable /
 +                                    // pointer), pass its full descriptor —
 +                                    // the callee declared via the abstract
 +                                    // interface must take a descriptor for
 +                                    // assumed-shape parameters. Without this,
 +                                    // `lower_arg_by_ref_full` returned the
 +                                    // base data pointer (loaded out of the
 +                                    // descriptor) and the callee tried to
 +                                    // read rank/dims out of the array elements'
 +                                    // bytes — stdlib's iterative solvers all
 +                                    // dispatch dot_product/matvec through a
 +                                    // procedure-pointer field of a class arg
 +                                    // this way and SEGV'd deep inside
 +                                    // stdlib_dot_product_dp on an indirect
 +                                    // load whose target was the array's first
 +                                    // f64 (1.0 = bits 0x3ff0...).
                                      let callee_descriptor_args =
                                          first_procedure_lookup(&abi_lookup_keys, |k| {
                                              descriptor_params
                                              e,
                                          ) = &arg.value
+                                         {
 -                                            let wants_descriptor = callee_descriptor_args
 +                                            let mask_says_descriptor = callee_descriptor_args
                                                  .as_ref()
                                                  .map(|mask| mask.get(i).copied().unwrap_or(false))
                                                  .unwrap_or(false);
 +                                            // Fallback: if the lookup missed
 +                                            // (abstract iface not in
 +                                            // descriptor_params), inspect the
 +                                            // actual itself. A descriptor-
 +                                            // backed local must be passed by
 +                                            // descriptor regardless.
 +                                            let actual_is_descriptor_backed =
 +                                                actual_is_descriptor_array(locals, e);
 +                                            let wants_descriptor = mask_says_descriptor
 +                                                || actual_is_descriptor_backed;
                                              let v = if wants_descriptor {
                                                  lower_arg_descriptor(
                                                      b,