`39ac9c3`

Fix fortsh link contract

Authored by

espadonne 3 weeks ago

SHA: 39ac9c35387a869d5e68b6b72766df1b422cc551
Parents: 1dd8886
Tree: ffe5328

7 changed files

Status	File	+	-
M	`src/driver/mod.rs`	0	1
M	`src/ir/lower.rs`	28	1
M	`src/testing.rs`	0	1
M	`tests/artifact_audit_29_10.rs`	45	11
M	`tests/cli_driver.rs`	152	0
M	`tests/i128_cross_object.rs`	37	6
M	`tests/sprint29_audit_realworld.rs`	40	6

src/driver/mod.rsmodified

      args.extend([
          rt_path,
          "-lSystem".into(),
 -        "-no_uuid".into(),
          "-syslibroot".into(),
          sysroot,
          "-e".into(),

src/ir/lower.rsmodified

              &no_host_param_consts,
              &no_host,
              None,
 +            None,
              &alloc_return_funcs,
              &optional_params,
              &descriptor_params,
      // and character-kind for each host-associated variable the
      // closure-passing ABI threads in as a hidden pointer param.
      host_decls: &[crate::ast::decl::SpannedDecl],
 +    host_link_name: Option<&str>,
      host_module: Option<&str>,
      alloc_return_funcs: &HashSet<String>,
      optional_params: &HashMap<String, Vec<bool>>,
                      &combined_uses,
                      &visible_param_consts,
                      &child_host_decls,
 +                    Some(body_fname.as_str()),
                      host_module,
                      alloc_return_funcs,
                      optional_params,
              let func_name = lowered_procedure_symbol_name(
                  name,
                  bind.as_ref(),
 +                host_link_name,
                  host_module,
                  internal_only,
                  internal_funcs,
                      &combined_uses,
                      &visible_param_consts,
                      &child_host_decls,
 +                    Some(func_name.as_str()),
                      host_module,
                      alloc_return_funcs,
                      optional_params,
              let func_name = lowered_procedure_symbol_name(
                  name,
                  bind.as_ref(),
 +                host_link_name,
                  host_module,
                  internal_only,
                  internal_funcs,
                      &combined_uses,
                      &visible_param_consts,
                      &child_host_decls,
 +                    Some(func_name.as_str()),
                      host_module,
                      alloc_return_funcs,
                      optional_params,
                      &combined_uses,
                      &visible_param_consts,
                      &no_host_decls,
 +                    None,
                      module_name,
                      alloc_return_funcs,
                      optional_params,
                      &combined_uses,
                      &visible_param_consts,
                      &no_host_decls,
 +                    None,
                      Some(parent.as_str()),
                      alloc_return_funcs,
                      optional_params,
      format!("afs_modproc_{}_{}", module_name.to_lowercase(), proc_name)
+ }
 +fn sanitize_internal_host_symbol(host_link_name: &str) -> String {
 +    host_link_name
 +        .chars()
 +        .map(|ch| {
 +            if ch.is_ascii_alphanumeric() {
 +                ch.to_ascii_lowercase()
 +            } else {
 +                '_'
 +            }
 +        })
 +        .collect()
 +}
++
  fn lowered_procedure_symbol_name(
      name: &str,
      bind: Option<&crate::ast::unit::BindInfo>,
 +    host_link_name: Option<&str>,
      host_module: Option<&str>,
      internal_only: bool,
      internal_funcs: &HashMap<String, u32>,
+     }
      if internal_only {
          if let Some(idx) = internal_funcs.get(&name.to_lowercase()) {
 -            return format!("afs_internal_{}", idx);
 +            let host_prefix = host_link_name
 +                .map(sanitize_internal_host_symbol)
 +                .filter(|prefix| !prefix.is_empty())
 +                .unwrap_or_else(|| "local".into());
 +            return format!("afs_internal_{}_{}", host_prefix, idx);
+         }
+     }
      if let Some(module_name) = host_module {

src/testing.rsmodified

              obj.to_str().unwrap(),
              &rt_path,
              "-lSystem",
 -            "-no_uuid",
              "-syslibroot",
              &sysroot,
              "-e",

tests/artifact_audit_29_10.rsmodified

      String::from_utf8_lossy(&output.stdout).into_owned()
+ }
 +fn normalize_lc_uuid(mut bytes: Vec<u8>) -> Vec<u8> {
 +    const MH_MAGIC_64: u32 = 0xfeedfacf;
 +    const LC_UUID: u32 = 0x1b;
 +    const MACH_HEADER_64_SIZE: usize = 32;
++
 +    if bytes.len() < MACH_HEADER_64_SIZE {
 +        return bytes;
 +    }
 +    let magic = u32::from_le_bytes(bytes[0..4].try_into().unwrap());
 +    if magic != MH_MAGIC_64 {
 +        return bytes;
 +    }
 +    let ncmds = u32::from_le_bytes(bytes[16..20].try_into().unwrap()) as usize;
 +    let mut offset = MACH_HEADER_64_SIZE;
 +    for _ in 0..ncmds {
 +        if offset + 8 > bytes.len() {
 +            break;
 +        }
 +        let cmd = u32::from_le_bytes(bytes[offset..offset + 4].try_into().unwrap());
 +        let cmdsize = u32::from_le_bytes(bytes[offset + 4..offset + 8].try_into().unwrap());
 +        let cmdsize = cmdsize as usize;
 +        if cmdsize < 8 || offset + cmdsize > bytes.len() {
 +            break;
 +        }
 +        if cmd == LC_UUID && cmdsize >= 24 {
 +            bytes[offset + 8..offset + 24].fill(0);
 +        }
 +        offset += cmdsize;
 +    }
 +    bytes
 +}
++
  fn opt_name(opt: OptLevel) -> &'static str {
      match opt {
          OptLevel::O0 => "-O0",
+ }
  #[test]
 -fn linked_binary_is_deterministic_for_same_output_path_and_has_no_uuid() {
 +fn linked_binary_is_deterministic_for_same_output_path_and_has_uuid() {
      let compiler = find_compiler();
      let source = fixture("module_init.f90");
      let stem = source.file_stem().unwrap().to_str().unwrap();
          compile_binary(&compiler, &source, opt, &bin_path);
          let load_commands = tool_output("otool", &["-l", bin_path.to_str().unwrap()]);
          assert!(
 -            !load_commands.contains("LC_UUID"),
 -            "linked binary at {} should omit LC_UUID for reproducible builds:\n{}",
 +            load_commands.contains("LC_UUID"),
 +            "linked binary at {} should carry LC_UUID so dyld accepts it:\n{}",
              opt,
              load_commands
          );
 -        let first = fs::read(&bin_path).expect("cannot read first binary image");
 +        let first = normalize_lc_uuid(fs::read(&bin_path).expect("cannot read first binary image"));
          compile_binary(&compiler, &source, opt, &bin_path);
 -        let second = fs::read(&bin_path).expect("cannot read second binary image");
 +        let second =
 +            normalize_lc_uuid(fs::read(&bin_path).expect("cannot read second binary image"));
          assert_eq!(
              first, second,
 -            "linked binary should be byte-identical when rebuilt at the same output path ({})",
 +            "linked binary should stay deterministic modulo LC_UUID when rebuilt at the same output path ({})",
              opt
          );
          compile_binary(&compiler, &source, opt, &bin_path);
          let load_commands = tool_output("otool", &["-l", bin_path.to_str().unwrap()]);
          assert!(
 -            !load_commands.contains("LC_UUID"),
 -            "runtime-heavy linked binary at {} should omit LC_UUID:\n{}",
 +            load_commands.contains("LC_UUID"),
 +            "runtime-heavy linked binary at {} should carry LC_UUID:\n{}",
              opt,
              load_commands
          );
 -        let first = fs::read(&bin_path).expect("cannot read first binary image");
 +        let first = normalize_lc_uuid(fs::read(&bin_path).expect("cannot read first binary image"));
          compile_binary(&compiler, &source, opt, &bin_path);
 -        let second = fs::read(&bin_path).expect("cannot read second binary image");
 +        let second =
 +            normalize_lc_uuid(fs::read(&bin_path).expect("cannot read second binary image"));
          assert_eq!(
              first, second,
 -            "runtime-heavy linked binary should be byte-identical when rebuilt at the same output path ({})",
 +            "runtime-heavy linked binary should stay deterministic modulo LC_UUID when rebuilt at the same output path ({})",
              opt
          );

tests/cli_driver.rsmodified

      let _ = std::fs::remove_dir_all(&dir);
+ }
 +#[test]
 +fn linked_binary_carries_uuid_and_launches() {
 +    let dir = unique_dir("linked_binary_uuid");
 +    let src = write_program_in(
 +        &dir,
 +        "hello.f90",
 +        "program hello\n  print *, 42\nend program hello\n",
 +    );
++
 +    let exe = dir.join("hello.bin");
 +    let compile = Command::new(compiler("armfortas"))
 +        .current_dir(&dir)
 +        .args([src.to_str().unwrap(), "-o", exe.to_str().unwrap()])
 +        .output()
 +        .expect("hello compile spawn failed");
 +    assert!(
 +        compile.status.success(),
 +        "linked hello should compile: {}",
 +        String::from_utf8_lossy(&compile.stderr)
 +    );
++
 +    let otool = Command::new("otool")
 +        .args(["-l", exe.to_str().unwrap()])
 +        .output()
 +        .expect("otool spawn failed");
 +    assert!(
 +        otool.status.success(),
 +        "otool should inspect linked hello: {}",
 +        String::from_utf8_lossy(&otool.stderr)
 +    );
 +    let load_commands = String::from_utf8_lossy(&otool.stdout);
 +    assert!(
 +        load_commands.contains("LC_UUID"),
 +        "linked hello should carry LC_UUID so dyld accepts it:\n{}",
 +        load_commands
 +    );
++
 +    let run = Command::new(&exe)
 +        .current_dir(&dir)
 +        .output()
 +        .expect("hello run spawn failed");
 +    assert!(
 +        run.status.success(),
 +        "linked hello should launch successfully:\nstdout:\n{}\nstderr:\n{}",
 +        String::from_utf8_lossy(&run.stdout),
 +        String::from_utf8_lossy(&run.stderr)
 +    );
++
 +    let _ = std::fs::remove_dir_all(&dir);
 +}
++
  #[test]
  fn same_named_module_helpers_link_without_colliding() {
      let dir = unique_dir("module_helper_link_names");
      let _ = std::fs::remove_dir_all(&dir);
+ }
 +#[test]
 +fn contained_helpers_link_without_cross_object_internal_symbol_collisions() {
 +    let dir = unique_dir("contained_helper_link_names");
 +    let mod_a = write_program_in(
 +        &dir,
 +        "mod_a.f90",
 +        "module mod_a\ncontains\n  subroutine run_a()\n    implicit none\n    call helper()\n  contains\n    subroutine helper()\n      print *, 11\n    end subroutine helper\n  end subroutine run_a\nend module mod_a\n",
 +    );
 +    let mod_b = write_program_in(
 +        &dir,
 +        "mod_b.f90",
 +        "module mod_b\ncontains\n  subroutine run_b()\n    implicit none\n    call helper()\n  contains\n    subroutine helper()\n      print *, 22\n    end subroutine helper\n  end subroutine run_b\nend module mod_b\n",
 +    );
 +    let main_src = write_program_in(
 +        &dir,
 +        "main.f90",
 +        "program p\n  use mod_a, only: run_a\n  use mod_b, only: run_b\n  call run_a()\n  call run_b()\nend program p\n",
 +    );
++
 +    let mod_a_obj = dir.join("mod_a.o");
 +    let compile_a = Command::new(compiler("armfortas"))
 +        .current_dir(&dir)
 +        .args([
 +            "-c",
 +            "-J",
 +            dir.to_str().unwrap(),
 +            mod_a.to_str().unwrap(),
 +            "-o",
 +            mod_a_obj.to_str().unwrap(),
 +        ])
 +        .output()
 +        .expect("mod_a compile spawn failed");
 +    assert!(
 +        compile_a.status.success(),
 +        "mod_a should compile: {}",
 +        String::from_utf8_lossy(&compile_a.stderr)
 +    );
++
 +    let mod_b_obj = dir.join("mod_b.o");
 +    let compile_b = Command::new(compiler("armfortas"))
 +        .current_dir(&dir)
 +        .args([
 +            "-c",
 +            "-I",
 +            dir.to_str().unwrap(),
 +            "-J",
 +            dir.to_str().unwrap(),
 +            mod_b.to_str().unwrap(),
 +            "-o",
 +            mod_b_obj.to_str().unwrap(),
 +        ])
 +        .output()
 +        .expect("mod_b compile spawn failed");
 +    assert!(
 +        compile_b.status.success(),
 +        "mod_b should compile: {}",
 +        String::from_utf8_lossy(&compile_b.stderr)
 +    );
++
 +    let main_obj = dir.join("main.o");
 +    let compile_main = Command::new(compiler("armfortas"))
 +        .current_dir(&dir)
 +        .args([
 +            "-c",
 +            "-I",
 +            dir.to_str().unwrap(),
 +            "-J",
 +            dir.to_str().unwrap(),
 +            main_src.to_str().unwrap(),
 +            "-o",
 +            main_obj.to_str().unwrap(),
 +        ])
 +        .output()
 +        .expect("main compile spawn failed");
 +    assert!(
 +        compile_main.status.success(),
 +        "main should compile: {}",
 +        String::from_utf8_lossy(&compile_main.stderr)
 +    );
++
 +    let exe = dir.join("contained_helpers.bin");
 +    let link = Command::new(compiler("armfortas"))
 +        .current_dir(&dir)
 +        .args([
 +            mod_a_obj.to_str().unwrap(),
 +            mod_b_obj.to_str().unwrap(),
 +            main_obj.to_str().unwrap(),
 +            "-o",
 +            exe.to_str().unwrap(),
 +        ])
 +        .output()
 +        .expect("contained helper link spawn failed");
 +    assert!(
 +        link.status.success(),
 +        "contained helpers in different objects should link cleanly: {}",
 +        String::from_utf8_lossy(&link.stderr)
 +    );
++
 +    let _ = std::fs::remove_dir_all(&dir);
 +}
++
  #[test]
  fn program_internal_char_helper_assignment_uses_internal_symbol() {
      let dir = unique_dir("program_internal_char_helper");

tests/i128_cross_object.rsmodified

      args.push(rt_path.to_string_lossy().into_owned());
      args.extend([
          "-lSystem".into(),
 -        "-no_uuid".into(),
          "-syslibroot".into(),
          sysroot,
          "-e".into(),
      String::from_utf8_lossy(&output.stdout).into_owned()
+ }
 +fn normalize_lc_uuid(mut bytes: Vec<u8>) -> Vec<u8> {
 +    const MH_MAGIC_64: u32 = 0xfeedfacf;
 +    const LC_UUID: u32 = 0x1b;
 +    const MACH_HEADER_64_SIZE: usize = 32;
++
 +    if bytes.len() < MACH_HEADER_64_SIZE {
 +        return bytes;
 +    }
 +    let magic = u32::from_le_bytes(bytes[0..4].try_into().unwrap());
 +    if magic != MH_MAGIC_64 {
 +        return bytes;
 +    }
 +    let ncmds = u32::from_le_bytes(bytes[16..20].try_into().unwrap()) as usize;
 +    let mut offset = MACH_HEADER_64_SIZE;
 +    for _ in 0..ncmds {
 +        if offset + 8 > bytes.len() {
 +            break;
 +        }
 +        let cmd = u32::from_le_bytes(bytes[offset..offset + 4].try_into().unwrap());
 +        let cmdsize = u32::from_le_bytes(bytes[offset + 4..offset + 8].try_into().unwrap());
 +        let cmdsize = cmdsize as usize;
 +        if cmdsize < 8 || offset + cmdsize > bytes.len() {
 +            break;
 +        }
 +        if cmd == LC_UUID && cmdsize >= 24 {
 +            bytes[offset + 8..offset + 24].fill(0);
 +        }
 +        offset += cmdsize;
 +    }
 +    bytes
 +}
++
  fn run_cross_object_case_named(
      program_name: &str,
      helper_name: &str,
      link_objects(&[&fortran_obj, &helper_obj], &binary);
      let load_commands = tool_output("otool", &["-l", binary.to_str().unwrap()]);
      assert!(
 -        !load_commands.contains("LC_UUID"),
 -        "linked cross-object integer(16) binary should omit LC_UUID:\n{}",
 +        load_commands.contains("LC_UUID"),
 +        "linked cross-object integer(16) binary should carry LC_UUID:\n{}",
          load_commands
      );
 -    let first = fs::read(&binary).expect("cannot read first linked binary");
 +    let first = normalize_lc_uuid(fs::read(&binary).expect("cannot read first linked binary"));
      link_objects(&[&fortran_obj, &helper_obj], &binary);
 -    let second = fs::read(&binary).expect("cannot read second linked binary");
 +    let second = normalize_lc_uuid(fs::read(&binary).expect("cannot read second linked binary"));
      assert_eq!(
          first, second,
 -        "linked cross-object integer(16) binary should be byte-identical across rebuilds"
 +        "linked cross-object integer(16) binary should stay deterministic modulo LC_UUID"
      );
      let _ = fs::remove_file(&fortran_obj);

tests/sprint29_audit_realworld.rsmodified

      String::from_utf8_lossy(&output.stdout).into_owned()
+ }
 +fn normalize_lc_uuid(mut bytes: Vec<u8>) -> Vec<u8> {
 +    const MH_MAGIC_64: u32 = 0xfeedfacf;
 +    const LC_UUID: u32 = 0x1b;
 +    const MACH_HEADER_64_SIZE: usize = 32;
++
 +    if bytes.len() < MACH_HEADER_64_SIZE {
 +        return bytes;
 +    }
 +    let magic = u32::from_le_bytes(bytes[0..4].try_into().unwrap());
 +    if magic != MH_MAGIC_64 {
 +        return bytes;
 +    }
 +    let ncmds = u32::from_le_bytes(bytes[16..20].try_into().unwrap()) as usize;
 +    let mut offset = MACH_HEADER_64_SIZE;
 +    for _ in 0..ncmds {
 +        if offset + 8 > bytes.len() {
 +            break;
 +        }
 +        let cmd = u32::from_le_bytes(bytes[offset..offset + 4].try_into().unwrap());
 +        let cmdsize = u32::from_le_bytes(bytes[offset + 4..offset + 8].try_into().unwrap());
 +        let cmdsize = cmdsize as usize;
 +        if cmdsize < 8 || offset + cmdsize > bytes.len() {
 +            break;
 +        }
 +        if cmd == LC_UUID && cmdsize >= 24 {
 +            bytes[offset + 8..offset + 24].fill(0);
 +        }
 +        offset += cmdsize;
 +    }
 +    bytes
 +}
++
  #[test]
  fn realworld_object_snapshots_stay_deterministic_at_o2() {
      for name in [
+ }
  #[test]
 -fn linked_realworld_binaries_are_deterministic_and_uuid_free() {
 +fn linked_realworld_binaries_are_deterministic_modulo_uuid() {
      let compiler = find_compiler();
      for name in [
              compile_binary(&compiler, &source, opt, &bin_path);
              let load_commands = tool_output("otool", &["-l", bin_path.to_str().unwrap()]);
              assert!(
 -                !load_commands.contains("LC_UUID"),
 -                "linked binary at {} should omit LC_UUID for {}:\n{}",
 +                load_commands.contains("LC_UUID"),
 +                "linked binary at {} should carry LC_UUID for {}:\n{}",
                  opt,
                  name,
                  load_commands
              );
 -            let first = fs::read(&bin_path).expect("cannot read first binary image");
 +            let first =
 +                normalize_lc_uuid(fs::read(&bin_path).expect("cannot read first binary image"));
              compile_binary(&compiler, &source, opt, &bin_path);
 -            let second = fs::read(&bin_path).expect("cannot read second binary image");
 +            let second =
 +                normalize_lc_uuid(fs::read(&bin_path).expect("cannot read second binary image"));
              assert_eq!(
                  first, second,
 -                "real-world linked binary should be byte-identical when rebuilt at the same output path ({} {})",
 +                "real-world linked binary should stay deterministic modulo LC_UUID when rebuilt at the same output path ({} {})",
                  name,
                  opt
              );