Allow globals-only i128 backend

Status	File	+	-
M	`src/driver/mod.rs`	2	2
M	`src/ir/inst.rs`	44	0
M	`src/testing.rs`	9	4
A	`tests/fixtures/integer16_globals_backend.f90`	8	0
A	`tests/i128_backend_data.rs`	95	0

src/driver/mod.rsmodified


         return Err(format!("internal error: IR verification failed:\n{}", msg));
     }
     let module_has_i128 = ir_module.contains_i128();
+    if ir_module.contains_i128_outside_globals() && opts.opt_level != OptLevel::O0 {
         return Err(
             "integer(16) / i128 optimization is not yet supported; use -O0 --emit-ir for now"
                 .into(),

         return Ok(());
     }
 
+    if module_has_i128 && !ir_module.i128_backend_data_only_supported() {
         return Err(
             "backend does not yet support integer(16) / i128 codegen; use --emit-ir for now"
                 .into(),

src/ir/inst.rsmodified

                      })
              })
+     }
++
++    /// True when `i128` appears anywhere outside module-global storage.
++    ///
++    /// Globals-only `i128` is the first staged backend surface we support:
++    /// the optimizer may ignore it and the emitter can lay it out as raw data.
++    /// Parameters, returns, instruction results, block params, and extern
++    /// signatures still imply unsupported ABI or codegen work.
++    pub fn contains_i128_outside_globals(&self) -> bool {
++        self.extern_funcs.iter().any(|func| sig_contains_i128(self, &func.sig))
++            || self.functions.iter().any(|func| {
++                type_contains_i128(self, &func.return_type)
++                    || func.params.iter().any(|param| type_contains_i128(self, &param.ty))
++                    || func.blocks.iter().any(|block| {
++                        block.params.iter().any(|param| type_contains_i128(self, &param.ty))
++                            || block.insts.iter().any(|inst| type_contains_i128(self, &inst.ty))
++                    })
++            })
++    }
++
++    /// True when every `i128` use in the module is a global data shape that
++    /// the current backend emitter can lay out directly.
++    pub fn i128_backend_data_only_supported(&self) -> bool {
++        !self.contains_i128_outside_globals()
++            && self
++                .globals
++                .iter()
++                .all(|global| global_i128_backend_data_supported(self, global))
++    }
+ }
  fn sig_contains_i128(module: &Module, sig: &super::types::FuncSig) -> bool {
          _ => false,
+     }
+ }
++
++fn global_i128_backend_data_supported(module: &Module, global: &Global) -> bool {
++    match &global.ty {
++        IrType::Int(IntWidth::I128) => matches!(
++            global.initializer,
++            Some(GlobalInit::Int(_)) | Some(GlobalInit::Zero) | None
++        ),
++        IrType::Array(elem_ty, _) if matches!(elem_ty.as_ref(), IrType::Int(IntWidth::I128)) => {
++            matches!(
++                global.initializer,
++                Some(GlobalInit::IntArray(_)) | Some(GlobalInit::Zero) | None
++            )
++        }
++        _ => !type_contains_i128(module, &global.ty),
++    }
++}

src/testing.rsmodified

          })
          && request.opt_level != OptLevel::O0;
--    if module_has_i128 && needs_optimized_pipeline {
++    if ir_module.contains_i128_outside_globals() && needs_optimized_pipeline {
          return Err(CaptureFailure {
              input: input.clone(),
              opt_level: request.opt_level,
      }
      let backend_ir = optimized_module.as_ref().unwrap_or(&ir_module);
--    if module_has_i128 {
++    if module_has_i128 && !backend_ir.i128_backend_data_only_supported() {
          return Err(CaptureFailure {
              input: input.clone(),
              opt_level: request.opt_level,
          );
      }
--    let asm_text = emit_module_asm(&allocated);
++    let asm_text = emit_module_asm(backend_ir, &allocated);
      if wants(Stage::Asm) {
          stages.insert(Stage::Asm, CapturedStage::Text(asm_text.clone()));
      }
      out
  }
--fn emit_module_asm(allocated: &[MachineFunction]) -> String {
++fn emit_module_asm(module: &crate::ir::inst::Module, allocated: &[MachineFunction]) -> String {
      let mut asm_text = String::new();
      asm_text.push_str(".section __TEXT,__text,regular,pure_instructions\n");
      for mf in allocated {
          asm_text.push('\n');
      }
++    if !module.globals.is_empty() {
++        asm_text.push_str(&emit::emit_globals(&module.globals));
++        asm_text.push('\n');
++    }
++
      if let Some(user_func) = allocated.first() {
          if user_func.name != "main" {
              let _ = write!(

tests/fixtures/integer16_globals_backend.f90added

++module integer16_globals_backend
++  implicit none
++  integer(16), save :: big_scalar = 18446744073709551616_16
++  integer(16), save :: big_array(2) = [1_16, 9223372036854775808_16]
++contains
++  subroutine touch()
++  end subroutine touch
++end module integer16_globals_backend

tests/i128_backend_data.rsadded

++use std::collections::BTreeSet;
++use std::path::PathBuf;
++
++use armfortas::driver::OptLevel;
++use armfortas::testing::{capture_from_path, CaptureRequest, CapturedStage, Stage};
++
++fn fixture(name: &str) -> PathBuf {
++    let path = PathBuf::from("tests/fixtures").join(name);
++    assert!(path.exists(), "missing test fixture {}", path.display());
++    path
++}
++
++fn capture_text(request: CaptureRequest, stage: Stage) -> String {
++    let result = capture_from_path(&request).expect("capture should succeed");
++    match result.get(stage) {
++        Some(CapturedStage::Text(text)) => text.clone(),
++        Some(CapturedStage::Run(_)) => panic!("expected text stage for {}", stage.as_str()),
++        None => panic!("missing requested stage {}", stage.as_str()),
++    }
++}
++
++#[test]
++fn globals_only_i128_backend_emits_expected_words_in_asm() {
++    let asm = capture_text(
++        CaptureRequest {
++            input: fixture("integer16_globals_backend.f90"),
++            requested: BTreeSet::from([Stage::Asm]),
++            opt_level: OptLevel::O0,
++        },
++        Stage::Asm,
++    );
++
++    assert!(
++        asm.contains(".section __DATA,__data"),
++        "asm should emit a data section for i128 globals:\n{}",
++        asm
++    );
++    assert!(
++        asm.matches(".p2align 4").count() >= 2,
++        "scalar and array i128 globals should request 16-byte alignment:\n{}",
++        asm
++    );
++    assert!(
++        asm.contains(".quad 0x0000000000000000\n    .quad 0x0000000000000001"),
++        "scalar i128 global should emit low/high 64-bit words:\n{}",
++        asm
++    );
++    assert!(
++        asm.contains(".quad 0x0000000000000001\n    .quad 0x0000000000000000"),
++        "array i128 initializer should emit the first element's word pair:\n{}",
++        asm
++    );
++    assert!(
++        asm.contains(".quad 0x8000000000000000\n    .quad 0x0000000000000000"),
++        "array i128 initializer should emit the second element's word pair:\n{}",
++        asm
++    );
++}
++
++#[test]
++fn globals_only_i128_object_snapshot_is_deterministic_at_o2() {
++    let source = fixture("integer16_globals_backend.f90");
++    let first = capture_text(
++        CaptureRequest {
++            input: source.clone(),
++            requested: BTreeSet::from([Stage::Obj]),
++            opt_level: OptLevel::O2,
++        },
++        Stage::Obj,
++    );
++    let second = capture_text(
++        CaptureRequest {
++            input: source,
++            requested: BTreeSet::from([Stage::Obj]),
++            opt_level: OptLevel::O2,
++        },
++        Stage::Obj,
++    );
++
++    assert!(
++        first.contains("_afs_mod_integer16_globals_backend_big_scalar"),
++        "object snapshot should retain the i128 scalar global symbol:\n{}",
++        first
++    );
++    assert!(
++        first.contains("_afs_mod_integer16_globals_backend_big_array"),
++        "object snapshot should retain the i128 array global symbol:\n{}",
++        first
++    );
++
++    assert_eq!(
++        first, second,
++        "globals-only i128 object snapshots should be deterministic at O2"
++    );
++}

`@@ -230,7 +230,7 @@` pub fn compile(opts: &Options) -> Result<(), String> {
230	return Err(format!("internal error: IR verification failed:\n{}", msg));	230	return Err(format!("internal error: IR verification failed:\n{}", msg));
231	}	231	}
232	let module_has_i128 = ir_module.contains_i128();	232	let module_has_i128 = ir_module.contains_i128();
233	- if module_has_i128 && opts.opt_level != OptLevel::O0 {	233	+ if ir_module.contains_i128_outside_globals() && opts.opt_level != OptLevel::O0 {
234	return Err(	234	return Err(
235	"integer(16) / i128 optimization is not yet supported; use -O0 --emit-ir for now"	235	"integer(16) / i128 optimization is not yet supported; use -O0 --emit-ir for now"
236	.into(),	236	.into(),
`@@ -265,7 +265,7 @@` pub fn compile(opts: &Options) -> Result<(), String> {
265	return Ok(());	265	return Ok(());
266	}	266	}
267		267
268	- if module_has_i128 {	268	+ if module_has_i128 && !ir_module.i128_backend_data_only_supported() {
269	return Err(	269	return Err(
270	"backend does not yet support integer(16) / i128 codegen; use --emit-ir for now"	270	"backend does not yet support integer(16) / i128 codegen; use --emit-ir for now"
271	.into(),	271	.into(),

fortrangoingonforty/armfortas / `209204c`

5 changed files