mingw: Use aro instead of clang for preprocessing import libs

Closes ziglang#17753

src/mingw.zig

@@ -288,10 +288,6 @@ pub fn buildImportLib(comp: *Compilation, lib_name: []const u8) !void {
  else => |e| return e,
  };
 
- // We need to invoke `zig clang` to use the preprocessor.
- if (!build_options.have_llvm) return error.ZigCompilerNotBuiltWithLLVMExtensions;
- const self_exe_path = comp.self_exe_path orelse return error.PreprocessorDisabled;
-
  const target = comp.getTarget();
 
  var cache: Cache = .{
@@ -305,6 +301,7 @@ pub fn buildImportLib(comp: *Compilation, lib_name: []const u8) !void {
  cache.hash.addBytes(build_options.version);
  cache.hash.addOptionalBytes(comp.zig_lib_directory.path);
  cache.hash.add(target.cpu.arch);
+ cache.hash.addBytes("aro");
 
  var man = cache.obtain();
  defer man.deinit();
@@ -337,74 +334,66 @@ pub fn buildImportLib(comp: *Compilation, lib_name: []const u8) !void {
  "o", &digest, final_def_basename,
  });
 
- const target_def_arg = switch (target.cpu.arch) {
- .x86 => "-DDEF_I386",
- .x86_64 => "-DDEF_X64",
- .arm, .armeb, .thumb, .thumbeb, .aarch64_32 => "-DDEF_ARM32",
- .aarch64, .aarch64_be => "-DDEF_ARM64",
+ const target_defines = switch (target.cpu.arch) {
+ .x86 => "#define DEF_I386\n",
+ .x86_64 => "#define DEF_X64\n",
+ .arm, .armeb, .thumb, .thumbeb, .aarch64_32 => "#define DEF_ARM32\n",
+ .aarch64, .aarch64_be => "#define DEF_ARM64\n",
  else => unreachable,
  };
 
- const args = [_][]const u8{
- self_exe_path,
- "clang",
- "-x",
- "c",
- def_file_path,
- "-Wp,-w",
- "-undef",
- "-P",
- "-I",
- try comp.zig_lib_directory.join(arena, &[_][]const u8{ "libc", "mingw", "def-include" }),
- target_def_arg,
- "-E",
- "-o",
- def_final_path,
- };
+ if (builtin.zig_backend == .stage2_c) @panic("the CBE cannot compile Aro yet!");
+ const aro = @import("aro");
+ var aro_comp = aro.Compilation.init(comp.gpa);
+ defer aro_comp.deinit();
 
- if (comp.verbose_cc) {
- Compilation.dump_argv(&args);
+ const include_dir = try comp.zig_lib_directory.join(arena, &[_][]const u8{ "libc", "mingw", "def-include" });
+
+ if (comp.verbose_cc) print: {
+ std.debug.getStderrMutex().lock();
+ defer std.debug.getStderrMutex().unlock();
+ const stderr = std.io.getStdErr().writer();
+ nosuspend stderr.print("def file: {s}\n", .{def_file_path}) catch break :print;
+ nosuspend stderr.print("include dir: {s}\n", .{include_dir}) catch break :print;
+ nosuspend stderr.print("output path: {s}\n", .{def_final_path}) catch break :print;
  }
 
- if (std.process.can_spawn) {
- var child = std.ChildProcess.init(&args, arena);
- child.stdin_behavior = .Ignore;
- child.stdout_behavior = .Pipe;
- child.stderr_behavior = .Pipe;
-
- try child.spawn();
-
- const stderr = try child.stderr.?.reader().readAllAlloc(arena, std.math.maxInt(usize));
-
- const term = child.wait() catch |err| {
- // TODO surface a proper error here
- log.err("unable to spawn {s}: {s}", .{ args[0], @errorName(err) });
- return error.ClangPreprocessorFailed;
- };
- switch (term) {
- .Exited => |code| {
- if (code != 0) {
- // TODO surface a proper error here
- log.err("clang exited with code {d} and stderr: {s}", .{ code, stderr });
- return error.ClangPreprocessorFailed;
- }
- },
- else => {
- // TODO surface a proper error here
- log.err("clang terminated unexpectedly with stderr: {s}", .{stderr});
- return error.ClangPreprocessorFailed;
- },
+ try aro_comp.include_dirs.append(include_dir);
+
+ const builtin_macros = try aro_comp.generateBuiltinMacros();
+ const user_macros = try aro_comp.addSourceFromBuffer("<command line>", target_defines);
+ const def_file_source = try aro_comp.addSourceFromPath(def_file_path);
+
+ var pp = aro.Preprocessor.init(&aro_comp);
+ defer pp.deinit();
+ pp.linemarkers = .none;
+ pp.preserve_whitespace = true;
+
+ _ = try pp.preprocess(builtin_macros);
+ _ = try pp.preprocess(user_macros);
+ const eof = try pp.preprocess(def_file_source);
+ try pp.tokens.append(pp.comp.gpa, eof);
+
+ for (aro_comp.diag.list.items) |diagnostic| {
+ if (diagnostic.kind == .@"fatal error" or diagnostic.kind == .@"error") {
+ aro_comp.renderErrors();
+ return error.AroPreprocessorFailed;
  }
- } else {
- log.err("unable to spawn {s}: spawning child process not supported on {s}", .{ args[0], @tagName(builtin.os.tag) });
- return error.ClangPreprocessorFailed;
+ }
+
+ {
+ // new scope to ensure definition file is written before passing the path to WriteImportLibrary
+ const def_final_file = try comp.global_cache_directory.handle.createFile(def_final_path, .{ .truncate = true });
+ defer def_final_file.close();
+ try pp.prettyPrintTokens(def_final_file.writer());
  }
 
  const lib_final_path = try comp.global_cache_directory.join(comp.gpa, &[_][]const u8{
  "o", &digest, final_lib_basename,
  });
  errdefer comp.gpa.free(lib_final_path);
 
+ if (!build_options.have_llvm) return error.ZigCompilerNotBuiltWithLLVMExtensions;
  const llvm_bindings = @import("codegen/llvm/bindings.zig");
  const llvm = @import("codegen/llvm.zig");
  const arch_tag = llvm.targetArch(target.cpu.arch);