Pass -dumpdir to clang in compile-and-link mode (#28045)

In Clang 17+ (matching GCC 11), compiling and linking in a single
command passes `-dumpdir <output>-` to `clang -cc1` so that auxiliary
output files (such as `.dwo` from `-gsplit-dwarf` or `.json` from
`-ftime-trace`) are named `<output>-<input>.<ext>` in the current
working directory rather than being written to `/tmp` alongside the
temporary object file.

Pass `-dumpdir <target>-` for all non-assembly compilations in
`phase_compile_inputs` instead of manually passing
`-Xclang -split-dwarf-file` and `-Xclang -split-dwarf-output`.

Author: sbc100

ChangeLog.md

@@ -20,6 +20,11 @@ See docs/process.md for more on how version tagging works.
 
 6.0.14 (in development)
 -----------------------
+- When compiling and linking in a single command, auxiliary compiler output
+  files (such as `.dwo` files from `-gsplit-dwarf` or `.json` files from
+  `-ftime-trace`) are now named `<output>-<input>.<ext>`, matching the behavior
+  of `clang`. Previously, `.dwo` files were named `<input>.dwo` and other
+  auxiliary files were written to the temporary directory. (#28045)
 - libunwind and compiler-rt were updated to LLVM 23.1.3. (#28011, #28014)
 - mimalloc was updated to 3.5.3. (#28026)
 

emcc.py

@@ -586,14 +586,16 @@ def compile_source_file(input_file):
       if ext == '.pcm':
         cmd = [c for c in cmd if not c.startswith('-fprebuilt-module-path=')]
     cmd += [*compile_args, '-c', input_file, '-o', output_file]
-    if options.requested_debug == '-gsplit-dwarf':
+    if ext not in ASSEMBLY_EXTENSIONS:
       # When running in COMPILE_AND_LINK mode we compile objects to a temporary location
-      # but we want the `.dwo` file to be generated in the current working directory,
-      # like it is under clang.  We could avoid this hack if we use the clang driver
-      # to generate the temporary files, but that would also involve using the clang
-      # driver to perform linking which would be a big change.
-      cmd += ['-Xclang', '-split-dwarf-file', '-Xclang', unsuffixed_basename(input_file) + '.dwo']
-      cmd += ['-Xclang', '-split-dwarf-output', '-Xclang', unsuffixed_basename(input_file) + '.dwo']
+      # but we want side-effect files (such as `.dwo` or `-ftime-trace` `.json` files)
+      # to be generated in the current working directory, like they are under clang.
+      # We could avoid this hack if we use the clang driver to generate the temporary
+      # files, but that would also involve using the clang driver to perform linking
+      # which would be a big change.
+      # See https://github.com/emscripten-core/emscripten/pull/27866
+      target = options.output_file or 'a.out.js'
+      cmd += ['-dumpdir', f'{target}-']
     shared.check_call(cmd)
     if not shared.SKIP_SUBPROCS:
       assert os.path.exists(output_file)

test/test_other.py

@@ -10459,27 +10459,27 @@ def test_separate_dwarf(self):
   def test_split_dwarf_dwp(self):
     self.run_process([EMCC, test_file('hello_world.c'), '-g', '-gsplit-dwarf'])
     self.assertExists('a.out.wasm')
-    self.assertExists('hello_world.dwo')
+    self.assertExists('a.out.js-hello_world.dwo')
 
     # The wasm will have full debug info for libc (ignore that), but only a
     # skeleton for hello_world.c (no subprogram for main)
     dwdump = self.run_process([LLVM_DWARFDUMP, 'a.out.wasm'], stdout=PIPE).stdout
-    self.assertIn('DW_AT_GNU_dwo_name\t("hello_world.dwo")', dwdump)
+    self.assertIn('DW_AT_GNU_dwo_name\t("a.out.js-hello_world.dwo")', dwdump)
     self.assertNotIn('DW_AT_name\t("main")', dwdump)
 
     # The dwo will have a subprogram for main in a section with a .dwo suffix
-    dwdump = self.run_process([LLVM_DWARFDUMP, 'hello_world.dwo'],
+    dwdump = self.run_process([LLVM_DWARFDUMP, 'a.out.js-hello_world.dwo'],
                               stdout=PIPE).stdout
     self.assertIn('.debug_info.dwo contents:', dwdump)
-    self.assertIn('DW_AT_GNU_dwo_name\t("hello_world.dwo")', dwdump)
+    self.assertIn('DW_AT_GNU_dwo_name\t("a.out.js-hello_world.dwo")', dwdump)
     self.assertIn('DW_AT_name\t("main")', dwdump)
 
     # Check that dwp runs, and results in usable output as well
     self.run_process([LLVM_DWP, '-e', 'a.out.wasm', '-o', 'a.out.wasm.dwp'])
     self.assertExists('a.out.wasm.dwp')
-    self.run_process([LLVM_DWARFDUMP, 'a.out.wasm.dwp'], stdout=PIPE)
+    dwdump = self.run_process([LLVM_DWARFDUMP, 'a.out.wasm.dwp'], stdout=PIPE).stdout
     self.assertIn('.debug_info.dwo contents:', dwdump)
-    self.assertIn('DW_AT_GNU_dwo_name\t("hello_world.dwo")', dwdump)
+    self.assertIn('DW_AT_GNU_dwo_name\t("a.out.js-hello_world.dwo")', dwdump)
     self.assertIn('DW_AT_name\t("main")', dwdump)
 
   def test_separate_dwarf_with_filename(self):
@@ -13499,7 +13499,13 @@ def test_split_dwarf_implicit_compile(self):
     # Verify that the dwo file is generated in the current working directory, even when implicitly
     # compiling (compile+link).
     self.run_process([EMCC, test_file('hello_world.c'), '-g', '-gsplit-dwarf'])
-    self.assertExists('hello_world.dwo')
+    self.assertExists('a.out.js-hello_world.dwo')
+
+  def test_ftime_trace_implicit_compile(self):
+    # Verify that the time-trace json file is generated in the current working directory, even when
+    # implicitly compiling (compile+link).
+    self.run_process([EMCC, test_file('hello_world.c'), '-ftime-trace'])
+    self.assertExists('a.out.js-hello_world.json')
 
   @parameterized({
     '': ([],),