[CodeView] Emit S_OBJNAME record

[aganea]

Summary

We've had a longstanding incompatibility with MSVC where we don't emit a couple of CodeView records that normally go in each file. This patch aims to address the first of these records - the S_OBJNAME symbol. This symbol is very simple. It just contains the full path to the object file that the debug info is being emitted to.

When building from clang, the approach taken here is to use the target file name, as decided by the CompilerInstance::createDefaultOutputFile. It is then passed down to the backend through MCTargetOptions, to make it available to CodeViewDebug. The same approach is taken when using llc or LTO/ThinLTO (through LLD or llvm-lto2). When emitting to stdout (path is '-'), we emit the S_OBJNAME record with an empty name.

The objective of this patch is to support live code patching tools like Recode or Live++. They are different from Microsoft Edit & Continue, which we don't plan to support. Several changes are needed in LLVM to support these tools:

1. Emit S_OBJNAME (this patch)
2. Emit full cc1 cmd-line in LF_BUILDINFO, see D80833.
3. Emit two-byte nops, see D81301.
4. Emit the 'hotpatch' flag in S_COMPILE3, see D116511.

[rnk]

I'd back out the C API changes, but otherwise this makes sense to me. Let's check with @aprantl, though.

llvm/include/llvm-c/DebugInfo.h

202–203 ↗

(On Diff #133138)

I'd suggest leaving this alone, we can add a LLVMDIBuilderCreateCompileUnit2 if any frontend using the C API ever cares about this.

[aprantl]

Whenever changing IR / IR Metadata there also needs to be a Bitcode upgrade test in test/Bitcode with a .bc file of the old format, and an assembler round-trip test in test/Assembler.

That said, I'm wondering if this isn't a property that is better on the llvm::Module. For example, in an LTO compilation, do you really want the name of the individual bitcode-holding .o files or do you want the name of the lto.o file? Another example is the Swift frontend, which always generates at least DICompileUnits per llvm::Module. It would be more efficient to put, e.g., a NamedMDNode into the module so this information can be shared between the CUs.

[dblaikie]

Does this need to be the name of an actual object file? Any idea how this should work in the case of LTO?

For the .dwo file name, which must be the actual name of the final .dwo file (ie: intermediate IR 'object' file names are not relevant, only the final true object file because that's where the .dwo file comes from) this wasn't passed down through debug info metadata (because at the time the metadata's generated the final object file name is not known - that metadata might be merged, split, Thin merged, etc, before the final object is emitted) but through the MCOptions struct passed into LLVM's MC layer.

[zturner]

In D43002#1000711, @dblaikie wrote:

Does this need to be the name of an actual object file? Any idea how this should work in the case of LTO?

For the .dwo file name, which must be the actual name of the final .dwo file (ie: intermediate IR 'object' file names are not relevant, only the final true object file because that's where the .dwo file comes from) this wasn't passed down through debug info metadata (because at the time the metadata's generated the final object file name is not known - that metadata might be merged, split, Thin merged, etc, before the final object is emitted) but through the MCOptions struct passed into LLVM's MC layer.

I tested with MSVC LTCG (their name for LTO) and here's the behavior it exhibits.

1. When compiling with LTCG and outputting foo.obj, the output file is not recognized as a COFF object file. I believe this matches our behavior of outputting bitcode files.
2. When linking 2 LTCG object files together and getting a final PDB, the object name symbols reference the "pseudo-object files" mentioned in step 1.

I believe the reason for this behavior is that the final PDB contains information about every original compiland, regardless of whether it participated in LTO. I mentioned in the original patch description that the S_OBJNAME symbol is 1 out of 2 symbols that we don't yet emit. The other one emits more info including (among other things) the full command line used to generate the object file. So I think the idea here is that with all of this information combined, given only a PDB a person can reproduce the exact build. For that reason I think this needs to be the original bitcode-holding .o files.

[dblaikie]

Adrian - what do you think about Reid's point regarding not changing the C API unless needed? I'm fairly OK with that, but not sure. Seems like it could be a surprising "gotcha" where someone thinks they're doing the right things to produce CodeView but they're missing this because the API isn't exposed/suggesting that usage.

It would be more efficient to put, e.g., a NamedMDNode into the module so this information can be shared between the CUs.

I assume the string data itself is shared by the bitcode format? But I don't really know.

llvm/lib/CodeGen/AsmPrinter/CodeViewDebug.cpp

825–830

This is O(N^2) (erase is O(N)) & could be made O(N) (using a technique similar to the erase+remove idiom - using literal erase+remove probably isn't practical due to the stateful nature of the walk).

Is there no other logic for this already elsewhere in LLVM?

843–844

Probably best just to use another/separate declaration here? (I think such a thing might be specified in the style guide, but I'm not sure)

[zturner]

In D43002#1000801, @dblaikie wrote:

It would be more efficient to put, e.g., a NamedMDNode into the module so this information can be shared between the CUs.

I assume the string data itself is shared by the bitcode format? But I don't really know.

All of this code is new to me, so I'm still kind of fumbling along as I learn how all this stuff works together, but my impression was that Adrian's suggestion only really applied if I wanted the name of the lto.o file. Given that I need the name of the bitcode containing .o file, does any of this still apply? Is the current solution appropriate in that case?

llvm/lib/CodeGen/AsmPrinter/CodeViewDebug.cpp

825–830

Unfortunately there's not. But you're right, I can do this a bit more efficiently by keeping a separate read pointer and write pointer.

[aprantl]

In D43002#1000801, @dblaikie wrote:

Adrian - what do you think about Reid's point regarding not changing the C API unless needed? I'm fairly OK with that, but not sure. Seems like it could be a surprising "gotcha" where someone thinks they're doing the right things to produce CodeView but they're missing this because the API isn't exposed/suggesting that usage.

This depends on whether this is just a nice-to-have feature for Windows or if it is important enough to warrant creating a new API function.

It would be more efficient to put, e.g., a NamedMDNode into the module so this information can be shared between the CUs.

I assume the string data itself is shared by the bitcode format? But I don't really know.

I think that is correct.

There is still the question on how this is supposed to behave in an LTO build? Do you want the name of the shared LTO.o file for all CUs, or do you want to preserve the names of the bitcode-.o files? If the former is the case, then it makes more sense to make this a property of the Module, otherwise it needs to be on the DICompileUnit.

[aprantl]

clang/lib/CodeGen/CGDebugInfo.cpp

567 ↗

(On Diff #133138)

Should this not be gated on the debuginfo kind being codeview?

[zturner]

In D43002#1000838, @aprantl wrote:

This depends on whether this is just a nice-to-have feature for Windows or if it is important enough to warrant creating a new API function.

I can back out the api changes, it doesn't seem important enough to me until there is at least 1 active user of the c api who wants it.

There is still the question on how this is supposed to behave in an LTO build? Do you want the name of the shared LTO.o file for all CUs, or do you want to preserve the names of the bitcode-.o files? If the former is the case, then it makes more sense to make this a property of the Module, otherwise it needs to be on the DICompileUnit.

I mentioned in another response but it might have been overlooked. It needs to be the bitcode-.o files.

clang/lib/CodeGen/CGDebugInfo.cpp

567 ↗

(On Diff #133138)

Couldn't a non-CodeView processor just ignore this field if they aren't interested in it? I can't think of a good reason to gate it at this high of a level.

[aprantl]

In D43002#1000863, @zturner wrote:

In D43002#1000838, @aprantl wrote:

There is still the question on how this is supposed to behave in an LTO build? Do you want the name of the shared LTO.o file for all CUs, or do you want to preserve the names of the bitcode-.o files? If the former is the case, then it makes more sense to make this a property of the Module, otherwise it needs to be on the DICompileUnit.

I mentioned in another response but it might have been overlooked. It needs to be the bitcode-.o files.

Thanks.

Should this not be gated on the debuginfo kind being codeview?

Couldn't a non-CodeView processor just ignore this field if they aren't interested in it? I can't think of a good reason to gate it at this high of a level.

It needlessly increases the size of the intermediate products in the LTO case on non-windows platforms and every time we encode any paths in Clang build products we are inviting problems with non-reproducible builds.
Related question: does remapDIPath do the right thing for the *output* file?

[zturner]

Gated the passing of this flag behind a check for CodeView. I also removed the O(N^2) function anyway in favor of just calling make_absolute. This seems more correct anyway as it will handle the case where the output file is specified as an absolute path already.

[aprantl]

I think this is still missing the bitcode upgrade test.

llvm/test/DebugInfo/COFF/buildinfo.ll

42 ↗

(On Diff #133309)

Please strip all quoted attributes., they are bound to break in future versions

[thakis]

I was about to say "please make sure this honors -fdebug-prefix-map" but I suppose codeview probably contains so many absolute paths at the moment that we should instead have a concerted effort to make debug info cwd-independent at some later point instead.

[zturner]

Adds tests for bitcode upgrade and assembly roundtripping (as well as the necessary fixes to make these tests pass).

[aprantl]

clang/lib/CodeGen/CGDebugInfo.cpp

561 ↗

(On Diff #133446)

You don't need to create a local copy of the string here. You could just use a ?: in the createCompileUnit invocation.

llvm/test/Assembler/cu-outputfile.ll

1 ↗

(On Diff #133446)

We usually do llvm-as < %s | llvm-dis - | llvm-as -| llvm-dis - | FileCheck.

llvm/test/Bitcode/upgrade-cu-outputfile.ll

2 ↗

(On Diff #133446)

There should be a .bc file created by an llvm-as from before this patch checked into the repository and that should be used as input.

[zturner]

Modified the tests as suggested by @aprantl

[zturner]

@aprantl ping

[aprantl]

The only thing that's missing is a test for the correct hashing of the new field in unittests/IR/MetadataTest.cpp.

[aprantl]

To clarify my last comment: No need to check for the correct hashing, since DICompileUnits are always distinct, but extending DICompileUnitTest would be the right thing to do.

[rnk]

I was reviewing the records that msvc emits that clang does not, and I noticed this again.

Here's a thought. Why are we putting this on the compile unit in the first place? Why not use a global named metadata node? Most of the complexity in this patch is from going through DICompileUnit, when we can just claim a global named metadata node for the output object file. It could probably even point to a DIFile so we can preserve some information about whether the path is relative.

[dblaikie]

In D43002#1279796, @rnk wrote:

I was reviewing the records that msvc emits that clang does not, and I noticed this again.

Here's a thought. Why are we putting this on the compile unit in the first place? Why not use a global named metadata node? Most of the complexity in this patch is from going through DICompileUnit, when we can just claim a global named metadata node for the output object file. It could probably even point to a DIFile so we can preserve some information about whether the path is relative.

If this is meant to name the final object file that's emitted - perhaps it shouldn't be in metadata at all. The Split-DWARF DWO file name is similar: it must name the actual file that was emitted - and isn't related to the original modules that may've been generated. This data is passed down through an MCOption, if I recall correctly.

[aganea]

@zturner Do you mind if we took over this patch and finish it? This prevents using Live++ with Clang.

[• mathieupelo]

Hi, I just jumped on this project. I'm currently trying to get S_OBJECTNAME symbol in order to make Live++ work.
I was looking at the feed and I don't understand what you mean @rnk when you say "Why not use a global named metadata node?". Could you please give more clarification on what you mean here, it would help a lot.
Also, @dblaikie if the info shouldn't be in metadata, where do you think it should be ?
Thanks

[rnk]

Thinking about it again, maybe it should be an MCOption like David suggested. S_OBJNAME should probably refer to the final location of the native object file, which is only known to whoever sets up MCOptions. For example, with "fat" LTO, the linker is the one responsible for setting up the output file.

Named metadata nodes are things like !llvm.ident = {...} that you see at global scope in .ll files, but I don't think it's relevant.

As far as this patch is concerned, I don't think we should put this thing on the compile unit. The whole idea of compile units is to preserve the separation between compilation units through LTO, but we can't really do that in codeview anyway.

[• mathieupelo]

Hello, I as requested placed the outputfile name in the MCTargetOptions.h. However, I encountered an issue. @rnk

I didn’t find any way to go back to MCTargetOptions.h from the CompilerInvocation.cpp. I understand it would make sense that there is one somewhere, but I can’t find it. Do any of you know how I’m supposed to access the MCTargetOption? Should I create my own way there?
Sorry to waste your time and maybe the answer is simple to answer but I’m fairly new to this code so there is some aspects of the code I dont fully understand.

[aganea]

I'm taking over this patch, as discussed offline with Zachary.

I've re-implemented the patch to use the target/final file name of the .OBJ, as suggested.

The bulk of the changes is mostly to pass around the file name, down to the back end.

[echristo]

First question:

Since split dwarf has to do some similar things can we not use the same support? This seems to be a lot of changes for this.

Second question:

and if we can't use the same support can we make split dwarf use this? Having two separate methods for passing everything around is a bit painful.

[aganea]

Simplified. Now using CodeGenOptions to pass the object filename around.

[aganea]

In D43002#2061162, @echristo wrote:

First question:

Since split dwarf has to do some similar things can we not use the same support? This seems to be a lot of changes for this.

Second question:

and if we can't use the same support can we make split dwarf use this? Having two separate methods for passing everything around is a bit painful.

To answer both questions, I tried to converge but the uses are slightly different. In one case (DWARF) the -split-dwarf-file/-split-dwarf-output flags are passed down almost blindly to the back-end, whereas for COFF there's more logic to determine where the file should be emitted (see CompilerInstance::createOutputFile). We always need full path names in S_OBJNAME, whereas (it seems) split DWARF can handle relative paths (for example see llvm-mc -split-dwarf-file). I think the purpose is also different: the .dwo is for immediate debugger consumption, whereas the path in S_OBJNAME seems to be used more like a global identifier.

Please let me know if you feel this could be done differently.

[aganea]

Simplify.
Added coverage when using clang-cl since this is a MSVC-specific feature.
When -fdebug-compilation-dir=. is used, relative paths are now emitted in the S_OBJNAME record.

[aganea]

Ping.

[aganea]

Ping!

[rnk]

I think the biggest concern here is what to do about /Fa / -save-temps. If we do nothing, the S_OBJNAME record will change if you run the same compilation twice with and without those flags. Generally, we strive to ensure that the directly emitted object file is identical to one rinsed through textual assembly, but that doesn't always work. I'm not sure if /Fa works reliably since we switched to Intel style assembly syntax either.

clang/include/clang/Basic/CodeGenOptions.h

212 ↗

(On Diff #304364)

Let's bikeshed the name a bit. This thing is the -o//Fo value, plus some processing. It can be symbolic, as in -. It could be the name of a bitcode file with -flto. It could be the name of an assembly file if you do clang -S --target=x86_64-windows-msvc -g t.cpp -o t.s. It could be the name of an ELF file if you try hard. I think in any of these cases where the user directly emits something that isn't a COFF object, it's OK to use that name for the S_OBJNAME record.

What it is, is the name of the compiler's output file, as we would like it to appear in debug info. With that in mind, here are some ideas:

• CodeViewObjectName: very directly referring to S_OBJNAME
• ObjectFilename: very general
• ObjectFilenameForDebug: generalizing over cv/dwarf
• OutputFilenameForDebug: generalizing over assembly, bc, and obj

I think I like ObjectFilenameForDebug best. DebugObjectFilename seems like a no-go, since that sounds like the dwo file name.

---

This brings me to the case of -save-temps / /Fa. In these cases, the compile action is broken into pieces, and the assembler is invoked in a follow-up process. Does that mean the driver needs to pass an extra flag along to the -cc1 action? That would be a bummer.

clang/lib/Frontend/CompilerInstance.cpp

717

I think saving the output file name during output file creation seems like an unexpected side effect for this function. Can we handle it earlier, maybe near dwo file name handling?

clang/test/CodeGenCXX/debug-info-objname.cpp

4 ↗

(On Diff #304364)

I checked, this is also consistent with clang's regular /Z7 output for source filenames.

20–21 ↗

(On Diff #304364)

And this is the thing we rely on, so it should all work.

llvm/include/llvm/MC/MCTargetOptions.h

61

This should probably be in llvm/include/llvm/Target/TargetOptions.h. I think MCTargetOptions is intended to control assembler behavior, but this option is read while producing assembly in CodeGen, not during assembling.

llvm/lib/CodeGen/AsmPrinter/CodeViewDebug.cpp

761

This isn't unescaping them, it's just canonicalizing double slashes to one slash, right? Would llvm::sys::native suffice?

[aganea]

clang/include/clang/Basic/CodeGenOptions.h

212 ↗

(On Diff #304364)

I think we should fix -save-temps and /Fa, thanks for raising that! Would you mind if I added a new cc1 flag for that purpose? Something like -target-file-name.
When using -save-temps, each cc1 command doesn't know about the final filename, except for the last cc1 command. We would need to provide that name somehow when passing -S.

llvm/lib/CodeGen/AsmPrinter/CodeViewDebug.cpp

761

llvm::sys::path::native() doesn't remove consecutive (back)slashes. I think @zturner's main intent was when debugging in Visual Studio with arguments from LIT tests, they sometimes contain double backslashes.

[rnk]

clang/include/clang/Basic/CodeGenOptions.h

212 ↗

(On Diff #304364)

Yes, I think we'll need a new cc1 flag. I'd avoid "target" in the flag name, since it makes me thing of target as in platform, OS, ISA, etc. Maybe just -object-file-name? It's very boring, and reasonably specific.

llvm/lib/CodeGen/AsmPrinter/CodeViewDebug.cpp

761

I see. I think "unescape" shouldn't be in the name, this isn't about escape characters, it's about cleaning up or canonicalizing the path.

[dpaoliello]

@rnk @aganea Ping... Just wanted to see what was happening with this change, and if there is anything I can do to help get it merged in.

[aganea]

As suggested by @rnk

[aganea]

llvm/lib/CodeGen/AsmPrinter/CodeViewDebug.cpp

761

I removed this function. Now using sys::path::remove_dots which removes the consecutive slashes.

[aganea]

Ping! Any further comments? Thanks in advance for your time.

[rnk]

lgtm

Sorry for the delay, I got sick last week and read through email newest to oldest.

[MaskRay]

Some test nits:) I don't know CodeView :(

clang/test/CodeGenCXX/debug-info-objname.cpp

1 ↗

(On Diff #395663)

The whole file appears to be CRLF where almost all other tests use LF in llvm-project.

2 ↗

(On Diff #395663)

%T is deprecated in lit (https://llvm.org/docs/CommandGuide/lit.html#substitutions): it is easy to cause multi-threading file reuse problems because lit runs tests parallelly.

I personally prefer RUN: rm -rf %t && mkdir %t && cd %t if you need to cd.

My personal comment style for non-RUN non-CHECK lines is /// - it stands out in many editors and may help possible FileCheck/lit's future direction to catch stale CHECK prefixes.

30 ↗

(On Diff #395663)

Prefer --input-file or input redirection to cat xxx | yyy

36 ↗

(On Diff #395663)

{{[0-9]+}} -> [[#]]

[aganea]

In D43002#3205190, @MaskRay wrote:

Some test nits:) I don't know CodeView :(

Fixed, thanks @MaskRay !

clang/include/clang/CodeGen/BackendUtil.h

enum BackendAction {
     Backend_EmitObj        ///< Emit native object files
   };
 
   void EmitBackendOutput(DiagnosticsEngine &Diags, const HeaderSearchOptions &,
                          const CodeGenOptions &CGOpts,
                          const TargetOptions &TOpts, const LangOptions &LOpts,
                          const llvm::DataLayout &TDesc, llvm::Module *M,
                          BackendAction Action,
-                         std::unique_ptr<raw_pwrite_stream> OS);
+                         std::unique_ptr<raw_pwrite_stream> OS,
+                         const std::string &OutputFile);
 
   void EmbedBitcode(llvm::Module *M, const CodeGenOptions &CGOpts,
                     llvm::MemoryBufferRef Buf);
 
   llvm::Expected<llvm::BitcodeModule>
   FindThinLTOModule(llvm::MemoryBufferRef MBRef);
   llvm::BitcodeModule *
   FindThinLTOModule(llvm::MutableArrayRef<llvm::BitcodeModule> BMs);
 }
 
 #endif

clang/include/clang/Frontend/CompilerInstance.h

public:
   /// Create the default output file (from the invocation's options) and add it
   /// to the list of tracked output files.
   ///
   /// The files created by this function always use temporary files to write to
   /// their result (that is, the data is written to a temporary file which will
   /// atomically replace the target output on success).
   ///
   /// \return - Null on error.
-  std::unique_ptr<raw_pwrite_stream>
+  std::tuple<std::unique_ptr<raw_pwrite_stream>, std::string>
   createDefaultOutputFile(bool Binary = true, StringRef BaseInput = "",
                           StringRef Extension = "");
 
   /// Create a new output file and add it to the list of tracked output files,
   /// optionally deriving the output path name.
   ///
   /// \return - Null on error.
-  std::unique_ptr<raw_pwrite_stream>
+  std::tuple<std::unique_ptr<raw_pwrite_stream>, std::string>
   createOutputFile(StringRef OutputPath, bool Binary, bool RemoveFileOnSignal,
                    StringRef BaseInput, StringRef Extension, bool UseTemporary,
                    bool CreateMissingDirectories = false);
 
   /// Create a new output file, optionally deriving the output path name.
   ///
   /// If \p OutputPath is empty, then createOutputFile will derive an output
   /// path location as \p BaseInput, with any suffix removed, and \p Extension

clang/include/clang/Frontend/FrontendActions.h

public:
   /// create the PCHGenerator instance returned by CreateASTConsumer.
   ///
   /// \returns false if an error occurred, true otherwise.
   static bool ComputeASTConsumerArguments(CompilerInstance &CI,
                                           std::string &Sysroot);
 
   /// Creates file to write the PCH into and returns a stream to write it
   /// into. On error, returns null.
-  static std::unique_ptr<llvm::raw_pwrite_stream>
-  CreateOutputFile(CompilerInstance &CI, StringRef InFile,
-                   std::string &OutputFile);
+  static std::tuple<std::unique_ptr<raw_pwrite_stream>, std::string>
+  CreateOutputFile(CompilerInstance &CI, StringRef InFile);
 
   bool BeginSourceFileAction(CompilerInstance &CI) override;
 };
 
 class GenerateModuleAction : public ASTFrontendAction {
-  virtual std::unique_ptr<raw_pwrite_stream>
+  virtual std::tuple<std::unique_ptr<raw_pwrite_stream>, std::string>
   CreateOutputFile(CompilerInstance &CI, StringRef InFile) = 0;
 
 protected:
   std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &CI,
                                                  StringRef InFile) override;
 
   TranslationUnitKind getTranslationUnitKind() override {
     return TU_Module;
protected:
   TranslationUnitKind getTranslationUnitKind() override { return TU_Module; }
   bool hasASTFileSupport() const override { return false; }
 };
 
 class GenerateModuleFromModuleMapAction : public GenerateModuleAction {
 private:
   bool BeginSourceFileAction(CompilerInstance &CI) override;
 
-  std::unique_ptr<raw_pwrite_stream>
+  std::tuple<std::unique_ptr<raw_pwrite_stream>, std::string>
   CreateOutputFile(CompilerInstance &CI, StringRef InFile) override;
 };
 
 class GenerateModuleInterfaceAction : public GenerateModuleAction {
 private:
   bool BeginSourceFileAction(CompilerInstance &CI) override;
 
-  std::unique_ptr<raw_pwrite_stream>
+  std::tuple<std::unique_ptr<raw_pwrite_stream>, std::string>
   CreateOutputFile(CompilerInstance &CI, StringRef InFile) override;
 };
 
 class GenerateHeaderModuleAction : public GenerateModuleAction {
   /// The synthesized module input buffer for the current compilation.
   std::unique_ptr<llvm::MemoryBuffer> Buffer;
   std::vector<std::string> ModuleHeaders;
 
 private:
   bool PrepareToExecuteAction(CompilerInstance &CI) override;
   bool BeginSourceFileAction(CompilerInstance &CI) override;
 
-  std::unique_ptr<raw_pwrite_stream>
+  std::tuple<std::unique_ptr<raw_pwrite_stream>, std::string>
   CreateOutputFile(CompilerInstance &CI, StringRef InFile) override;
 };
 
 class SyntaxOnlyAction : public ASTFrontendAction {
 protected:
   std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &CI,
                                                  StringRef InFile) override;
 

clang/lib/CodeGen/BackendUtil.cpp

class EmitAssemblyHelper {
   /// Generates the TargetMachine.
   /// Leaves TM unchanged if it is unable to create the target machine.
   /// Some of our clang tests specify triples which are not built
   /// into clang. This is okay because these tests check the generated
   /// IR, and they require DataLayout which depends on the triple.
   /// In this case, we allow this method to fail and not report an error.
   /// When MustCreateTM is used, we print an error if we are unable to load
   /// the requested target.
-  void CreateTargetMachine(bool MustCreateTM);
+  void CreateTargetMachine(bool MustCreateTM, const std::string &OutputFile);
 
   /// Add passes necessary to emit assembly or LLVM IR.
   ///
   /// \return True on success.
   bool AddEmitPasses(legacy::PassManager &CodeGenPasses, BackendAction Action,
                      raw_pwrite_stream &OS, raw_pwrite_stream *DwoOS);
 
   std::unique_ptr<llvm::ToolOutputFile> openOutputFile(StringRef Path) {
public:
 
   ~EmitAssemblyHelper() {
     if (CodeGenOpts.DisableFree)
       BuryPointer(std::move(TM));
   }
 
   std::unique_ptr<TargetMachine> TM;
 
-  void EmitAssembly(BackendAction Action,
-                    std::unique_ptr<raw_pwrite_stream> OS);
+  void EmitAssembly(BackendAction Action, std::unique_ptr<raw_pwrite_stream> OS,
+                    const std::string &OSFile);
 
   void EmitAssemblyWithNewPassManager(BackendAction Action,
-                                      std::unique_ptr<raw_pwrite_stream> OS);
+                                      std::unique_ptr<raw_pwrite_stream> OS,
+                                      const std::string &OutputFile);
 };
 
 // We need this wrapper to access LangOpts and CGOpts from extension functions
 // that we add to the PassManagerBuilder.
 class PassManagerBuilderWrapper : public PassManagerBuilder {
 public:
   PassManagerBuilderWrapper(const Triple &TargetTriple,
                             const CodeGenOptions &CGOpts,
else {
     return CGFT_AssemblyFile;
   }
 }
 
 static void initTargetOptions(llvm::TargetOptions &Options,
                               const CodeGenOptions &CodeGenOpts,
                               const clang::TargetOptions &TargetOpts,
                               const LangOptions &LangOpts,
-                              const HeaderSearchOptions &HSOpts) {
+                              const HeaderSearchOptions &HSOpts,
+                              const std::string &OutputPathName) {
   Options.ThreadModel =
       llvm::StringSwitch<llvm::ThreadModel::Model>(CodeGenOpts.ThreadModel)
           .Case("posix", llvm::ThreadModel::POSIX)
           .Case("single", llvm::ThreadModel::Single);
 
   // Set float ABI type.
   assert((CodeGenOpts.FloatABI == "soft" || CodeGenOpts.FloatABI == "softfp" ||
           CodeGenOpts.FloatABI == "hard" || CodeGenOpts.FloatABI.empty()) &&
static void initTargetOptions(llvm::TargetOptions &Options,
   Options.EmulatedTLS = CodeGenOpts.EmulatedTLS;
   Options.ExplicitEmulatedTLS = CodeGenOpts.ExplicitEmulatedTLS;
   Options.DebuggerTuning = CodeGenOpts.getDebuggerTuning();
   Options.EmitStackSizeSection = CodeGenOpts.StackSizeSection;
   Options.EmitAddrsig = CodeGenOpts.Addrsig;
   Options.ForceDwarfFrameSection = CodeGenOpts.ForceDwarfFrameSection;
   Options.EmitCallSiteInfo = CodeGenOpts.EmitCallSiteInfo;
 
+  Options.MCOptions.OutputPathName = OutputPathName;
   Options.MCOptions.SplitDwarfFile = CodeGenOpts.SplitDwarfFile;
   Options.MCOptions.MCRelaxAll = CodeGenOpts.RelaxAll;
   Options.MCOptions.MCSaveTempLabels = CodeGenOpts.SaveTempLabels;
   Options.MCOptions.MCUseDwarfDirectory = !CodeGenOpts.NoDwarfDirectoryAsm;
   Options.MCOptions.MCNoExecStack = CodeGenOpts.NoExecStack;
   Options.MCOptions.MCIncrementalLinkerCompatible =
       CodeGenOpts.IncrementalLinkerCompatible;
   Options.MCOptions.MCFatalWarnings = CodeGenOpts.FatalWarnings;
if (!CodeGenOpts.LimitFloatPrecision.empty()) {
     BackendArgs.push_back("-limit-float-precision");
     BackendArgs.push_back(CodeGenOpts.LimitFloatPrecision.c_str());
   }
   BackendArgs.push_back(nullptr);
   llvm::cl::ParseCommandLineOptions(BackendArgs.size() - 1,
                                     BackendArgs.data());
 }
 
-void EmitAssemblyHelper::CreateTargetMachine(bool MustCreateTM) {
+void EmitAssemblyHelper::CreateTargetMachine(
+    bool MustCreateTM, const std::string &OutputPathName) {
   // Create the TargetMachine for generating code.
   std::string Error;
   std::string Triple = TheModule->getTargetTriple();
   const llvm::Target *TheTarget = TargetRegistry::lookupTarget(Triple, Error);
   if (!TheTarget) {
     if (MustCreateTM)
       Diags.Report(diag::err_fe_unable_to_create_target) << Error;
     return;
   }
 
   Optional<llvm::CodeModel::Model> CM = getCodeModel(CodeGenOpts);
   std::string FeaturesStr =
       llvm::join(TargetOpts.Features.begin(), TargetOpts.Features.end(), ",");
   llvm::Reloc::Model RM = CodeGenOpts.RelocationModel;
   CodeGenOpt::Level OptLevel = getCGOptLevel(CodeGenOpts);
 
   llvm::TargetOptions Options;
-  initTargetOptions(Options, CodeGenOpts, TargetOpts, LangOpts, HSOpts);
+  initTargetOptions(Options, CodeGenOpts, TargetOpts, LangOpts, HSOpts,
+                    OutputPathName);
   TM.reset(TheTarget->createTargetMachine(Triple, TargetOpts.CPU, FeaturesStr,
                                           Options, RM, CM, OptLevel));
 }
 
 bool EmitAssemblyHelper::AddEmitPasses(legacy::PassManager &CodeGenPasses,
                                        BackendAction Action,
                                        raw_pwrite_stream &OS,
                                        raw_pwrite_stream *DwoOS) {
if (TM->addPassesToEmitFile(CodeGenPasses, OS, DwoOS, CGFT,
     Diags.Report(diag::err_fe_unable_to_interface_with_target);
     return false;
   }
 
   return true;
 }
 
 void EmitAssemblyHelper::EmitAssembly(BackendAction Action,
-                                      std::unique_ptr<raw_pwrite_stream> OS) {
+                                      std::unique_ptr<raw_pwrite_stream> OS,
+                                      const std::string &OutputFile) {
   TimeRegion Region(FrontendTimesIsEnabled ? &CodeGenerationTime : nullptr);
 
   setCommandLineOpts(CodeGenOpts);
 
   bool UsesCodeGen = (Action != Backend_EmitNothing &&
                       Action != Backend_EmitBC &&
                       Action != Backend_EmitLL);
-  CreateTargetMachine(UsesCodeGen);
+  CreateTargetMachine(UsesCodeGen, OutputFile);
 
   if (UsesCodeGen && !TM)
     return;
   if (TM)
     TheModule->setDataLayout(TM->createDataLayout());
 
   legacy::PassManager PerModulePasses;
   PerModulePasses.add(

 ///
 /// Not all features are currently supported in this system, but where
 /// necessary it falls back to the legacy pass manager to at least provide
 /// basic functionality.
 ///
 /// This API is planned to have its functionality finished and then to replace
 /// `EmitAssembly` at some point in the future when the default switches.
 void EmitAssemblyHelper::EmitAssemblyWithNewPassManager(
-    BackendAction Action, std::unique_ptr<raw_pwrite_stream> OS) {
+    BackendAction Action, std::unique_ptr<raw_pwrite_stream> OS,
+    const std::string &OutputFile) {
   TimeRegion Region(FrontendTimesIsEnabled ? &CodeGenerationTime : nullptr);
   setCommandLineOpts(CodeGenOpts);
 
   bool RequiresCodeGen = (Action != Backend_EmitNothing &&
                           Action != Backend_EmitBC &&
                           Action != Backend_EmitLL);
-  CreateTargetMachine(RequiresCodeGen);
+  CreateTargetMachine(RequiresCodeGen, OutputFile);
 
   if (RequiresCodeGen && !TM)
     return;
   if (TM)
     TheModule->setDataLayout(TM->createDataLayout());
 
   Optional<PGOOptions> PGOOpt;
 
BitcodeModule *clang::FindThinLTOModule(MutableArrayRef<BitcodeModule> BMs) {
   for (BitcodeModule &BM : BMs) {
     Expected<BitcodeLTOInfo> LTOInfo = BM.getLTOInfo();
     if (LTOInfo && LTOInfo->IsThinLTO)
       return &BM;
   }
   return nullptr;
 }
 
-static void runThinLTOBackend(ModuleSummaryIndex *CombinedIndex, Module *M,
-                              const HeaderSearchOptions &HeaderOpts,
-                              const CodeGenOptions &CGOpts,
-                              const clang::TargetOptions &TOpts,
-                              const LangOptions &LOpts,
-                              std::unique_ptr<raw_pwrite_stream> OS,
-                              std::string SampleProfile,
-                              std::string ProfileRemapping,
-                              BackendAction Action) {
+static void
+runThinLTOBackend(ModuleSummaryIndex *CombinedIndex, Module *M,
+                  const clang::TargetOptions &TOpts, const LangOptions &LOpts,
+                  const std::string &OutputFile, std::string SampleProfile,
+                  std::string ProfileRemapping, BackendAction Action) {
   StringMap<DenseMap<GlobalValue::GUID, GlobalValueSummary *>>
       ModuleToDefinedGVSummaries;
   CombinedIndex->collectDefinedGVSummariesPerModule(ModuleToDefinedGVSummaries);
 
   setCommandLineOpts(CGOpts);
 
   // We can simply import the values mentioned in the combined index, since
   // we should only invoke this using the individual indexes written out
if (!BMOrErr) {
       });
       return;
     }
     ModuleMap.insert({I.first(), *BMOrErr});
 
     OwnedImports.push_back(std::move(*MBOrErr));
   }
   auto AddStream = [&](size_t Task) {
-    return std::make_unique<lto::NativeObjectStream>(std::move(OS));
+    return std::make_unique<lto::NativeObjectStream>(std::move(OS), OutputFile);
   };
   lto::Config Conf;
   if (CGOpts.SaveTempsFilePrefix != "") {
     if (Error E = Conf.addSaveTemps(CGOpts.SaveTempsFilePrefix + ".",
                                     /* UseInputModulePath */ false)) {
       handleAllErrors(std::move(E), [&](ErrorInfoBase &EIB) {
         errs() << "Error setting up ThinLTO save-temps: " << EIB.message()
                << '\n';
       });
     }
   }
   Conf.CPU = TOpts.CPU;
   Conf.CodeModel = getCodeModel(CGOpts);
   Conf.MAttrs = TOpts.Features;
   Conf.RelocModel = CGOpts.RelocationModel;
   Conf.CGOptLevel = getCGOptLevel(CGOpts);
   Conf.OptLevel = CGOpts.OptimizationLevel;
-  initTargetOptions(Conf.Options, CGOpts, TOpts, LOpts, HeaderOpts);
+  initTargetOptions(Conf.Options, CGOpts, TOpts, LOpts, HeaderOpts, OutputFile);
   Conf.SampleProfile = std::move(SampleProfile);
   Conf.PTO.LoopUnrolling = CGOpts.UnrollLoops;
   // For historical reasons, loop interleaving is set to mirror setting for loop
   // unrolling.
   Conf.PTO.LoopInterleaving = CGOpts.UnrollLoops;
   Conf.PTO.LoopVectorization = CGOpts.VectorizeLoop;
   Conf.PTO.SLPVectorization = CGOpts.VectorizeSLP;
   Conf.PTO.CallGraphProfile = CGOpts.CallGraphProfile;
if (Error E = thinBackend(
           Conf, -1, AddStream, *M, *CombinedIndex, ImportList,
           ModuleToDefinedGVSummaries[M->getModuleIdentifier()], ModuleMap)) {
     handleAllErrors(std::move(E), [&](ErrorInfoBase &EIB) {
       errs() << "Error running ThinLTO backend: " << EIB.message() << '\n';
     });
   }
 }
 
-void clang::EmitBackendOutput(DiagnosticsEngine &Diags,
-                              const HeaderSearchOptions &HeaderOpts,
-                              const CodeGenOptions &CGOpts,
-                              const clang::TargetOptions &TOpts,
-                              const LangOptions &LOpts,
-                              const llvm::DataLayout &TDesc, Module *M,
-                              BackendAction Action,
-                              std::unique_ptr<raw_pwrite_stream> OS) {
+void clang::EmitBackendOutput(
+    DiagnosticsEngine &Diags, const HeaderSearchOptions &HeaderOpts,
+    const CodeGenOptions &CGOpts, const clang::TargetOptions &TOpts,
+    const LangOptions &LOpts, const llvm::DataLayout &TDesc, Module *M,
+    BackendAction Action, std::unique_ptr<raw_pwrite_stream> OS,
+    const std::string &OutputFile) {
 
   llvm::TimeTraceScope TimeScope("Backend");
 
   std::unique_ptr<llvm::Module> EmptyModule;
   if (!CGOpts.ThinLTOIndexFile.empty()) {
     // If we are performing a ThinLTO importing compile, load the function index
     // into memory and pass it into runThinLTOBackend, which will run the
     // function importer and invoke LTO passes.
     Expected<std::unique_ptr<ModuleSummaryIndex>> IndexOrErr =
         llvm::getModuleSummaryIndexForFile(CGOpts.ThinLTOIndexFile,
                                            /*IgnoreEmptyThinLTOIndexFile*/true);
     if (!IndexOrErr) {
       logAllUnhandledErrors(IndexOrErr.takeError(), errs(),
                             "Error loading index file '" +
                             CGOpts.ThinLTOIndexFile + "': ");
       return;
     }
     std::unique_ptr<ModuleSummaryIndex> CombinedIndex = std::move(*IndexOrErr);
     // A null CombinedIndex means we should skip ThinLTO compilation
     // (LLVM will optionally ignore empty index files, returning null instead
     // of an error).
     if (CombinedIndex) {
       if (!CombinedIndex->skipModuleByDistributedBackend()) {
         runThinLTOBackend(CombinedIndex.get(), M, HeaderOpts, CGOpts, TOpts,
-                          LOpts, std::move(OS), CGOpts.SampleProfileFile,
-                          CGOpts.ProfileRemappingFile, Action);
+                          LOpts, std::move(OS), OutputFile,
+                          CGOpts.SampleProfileFile, CGOpts.ProfileRemappingFile,
+                          Action);
         return;
       }
       // Distributed indexing detected that nothing from the module is needed
       // for the final linking. So we can skip the compilation. We sill need to
       // output an empty object file to make sure that a linker does not fail
       // trying to read it. Also for some features, like CFI, we must skip
       // the compilation as CombinedIndex does not contain all required
       // information.
       EmptyModule = std::make_unique<llvm::Module>("empty", M->getContext());
       EmptyModule->setTargetTriple(M->getTargetTriple());
       M = EmptyModule.get();
     }
   }
 
   EmitAssemblyHelper AsmHelper(Diags, HeaderOpts, CGOpts, TOpts, LOpts, M);
 
   if (CGOpts.ExperimentalNewPassManager)
-    AsmHelper.EmitAssemblyWithNewPassManager(Action, std::move(OS));
+    AsmHelper.EmitAssemblyWithNewPassManager(Action, std::move(OS), OutputFile);
   else
-    AsmHelper.EmitAssembly(Action, std::move(OS));
+    AsmHelper.EmitAssembly(Action, std::move(OS), OutputFile);
 
   // Verify clang's TargetInfo DataLayout against the LLVM TargetMachine's
   // DataLayout.
   if (AsmHelper.TM) {
     std::string DLDesc = M->getDataLayout().getStringRepresentation();
     if (DLDesc != TDesc.getStringRepresentation()) {
       unsigned DiagID = Diags.getCustomDiagID(
           DiagnosticsEngine::Error, "backend data layout '%0' does not match "

clang/lib/CodeGen/CodeGenAction.cpp

class BackendConsumer : public ASTConsumer {
     virtual void anchor();
     DiagnosticsEngine &Diags;
     BackendAction Action;
     const HeaderSearchOptions &HeaderSearchOpts;
     const CodeGenOptions &CodeGenOpts;
     const TargetOptions &TargetOpts;
     const LangOptions &LangOpts;
     std::unique_ptr<raw_pwrite_stream> AsmOutStream;
+    std::string AsmOutputPathName;
     ASTContext *Context;
 
     Timer LLVMIRGeneration;
     unsigned LLVMIRGenerationRefCount;
 
     /// True if we've finished generating IR. This prevents us from generating
     /// additional LLVM IR after emitting output in HandleTranslationUnit. This
     /// can happen when Clang plugins trigger additional AST deserialization.
public:
     BackendConsumer(BackendAction Action, DiagnosticsEngine &Diags,
                     const HeaderSearchOptions &HeaderSearchOpts,
                     const PreprocessorOptions &PPOpts,
                     const CodeGenOptions &CodeGenOpts,
                     const TargetOptions &TargetOpts,
                     const LangOptions &LangOpts, bool TimePasses,
                     const std::string &InFile,
                     SmallVector<LinkModule, 4> LinkModules,
-                    std::unique_ptr<raw_pwrite_stream> OS, LLVMContext &C,
+                    std::unique_ptr<raw_pwrite_stream> OS,
+                    const std::string &OutputPathName, LLVMContext &C,
                     CoverageSourceInfo *CoverageInfo = nullptr)
         : Diags(Diags), Action(Action), HeaderSearchOpts(HeaderSearchOpts),
           CodeGenOpts(CodeGenOpts), TargetOpts(TargetOpts), LangOpts(LangOpts),
-          AsmOutStream(std::move(OS)), Context(nullptr),
+          AsmOutStream(std::move(OS)), AsmOutputPathName(OutputPathName),
+          Context(nullptr),
           LLVMIRGeneration("irgen", "LLVM IR Generation Time"),
           LLVMIRGenerationRefCount(0),
           Gen(CreateLLVMCodeGen(Diags, InFile, HeaderSearchOpts, PPOpts,
                                 CodeGenOpts, C, CoverageInfo)),
           LinkModules(std::move(LinkModules)) {
       FrontendTimesIsEnabled = TimePasses;
       llvm::TimePassesIsEnabled = TimePasses;
     }
void HandleTranslationUnit(ASTContext &C) override {
       // Link each LinkModule into our module.
       if (LinkInModules())
         return;
 
       EmbedBitcode(getModule(), CodeGenOpts, llvm::MemoryBufferRef());
 
       EmitBackendOutput(Diags, HeaderSearchOpts, CodeGenOpts, TargetOpts,
                         LangOpts, C.getTargetInfo().getDataLayout(),
-                        getModule(), Action, std::move(AsmOutStream));
+                        getModule(), Action, std::move(AsmOutStream),
+                        AsmOutputPathName);
 
       Ctx.setInlineAsmDiagnosticHandler(OldHandler, OldContext);
 
       Ctx.setDiagnosticHandler(std::move(OldDiagnosticHandler));
 
       if (OptRecordFile)
         OptRecordFile->keep();
     }
std::unique_ptr<llvm::Module> CodeGenAction::takeModule() {
   return std::move(TheModule);
 }
 
 llvm::LLVMContext *CodeGenAction::takeLLVMContext() {
   OwnsVMContext = false;
   return VMContext;
 }
 
-static std::unique_ptr<raw_pwrite_stream>
+static std::tuple<std::unique_ptr<raw_pwrite_stream>, std::string>
 GetOutputStream(CompilerInstance &CI, StringRef InFile, BackendAction Action) {
   switch (Action) {
   case Backend_EmitAssembly:
     return CI.createDefaultOutputFile(false, InFile, "s");
   case Backend_EmitLL:
     return CI.createDefaultOutputFile(false, InFile, "ll");
   case Backend_EmitBC:
     return CI.createDefaultOutputFile(true, InFile, "bc");
   case Backend_EmitNothing:
-    return nullptr;
+    return {nullptr, ""};
   case Backend_EmitMCNull:
-    return CI.createNullOutputFile();
+    return {CI.createNullOutputFile(), ""};
   case Backend_EmitObj:
     return CI.createDefaultOutputFile(true, InFile, "o");
   }
 
   llvm_unreachable("Invalid action!");
 }
 
 std::unique_ptr<ASTConsumer>
 CodeGenAction::CreateASTConsumer(CompilerInstance &CI, StringRef InFile) {
   BackendAction BA = static_cast<BackendAction>(Act);
+  std::string OutputPathName;
   std::unique_ptr<raw_pwrite_stream> OS = CI.takeOutputStream();
   if (!OS)
-    OS = GetOutputStream(CI, InFile, BA);
+    std::tie(OS, OutputPathName) = GetOutputStream(CI, InFile, BA);
 
   if (BA != Backend_EmitNothing && !OS)
     return nullptr;
 
   // Load bitcode modules to link with, if we need to.
   if (LinkModules.empty())
     for (const CodeGenOptions::BitcodeFileToLink &F :
          CI.getCodeGenOpts().LinkBitcodeFiles) {
if (CI.getCodeGenOpts().CoverageMapping) {
     CI.getPreprocessor().addPPCallbacks(
                                     std::unique_ptr<PPCallbacks>(CoverageInfo));
   }
 
   std::unique_ptr<BackendConsumer> Result(new BackendConsumer(
       BA, CI.getDiagnostics(), CI.getHeaderSearchOpts(),
       CI.getPreprocessorOpts(), CI.getCodeGenOpts(), CI.getTargetOpts(),
       CI.getLangOpts(), CI.getFrontendOpts().ShowTimers, std::string(InFile),
-      std::move(LinkModules), std::move(OS), *VMContext, CoverageInfo));
+      std::move(LinkModules), std::move(OS), OutputPathName, *VMContext,
+      CoverageInfo));
   BEConsumer = Result.get();
 
   // Enable generating macro debug info only when debug info is not disabled and
   // also macro debug info is enabled.
   if (CI.getCodeGenOpts().getDebugInfo() != codegenoptions::NoDebugInfo &&
       CI.getCodeGenOpts().MacroDebugInfo) {
     std::unique_ptr<PPCallbacks> Callbacks =
         std::make_unique<MacroPPCallbacks>(BEConsumer->getCodeGenerator(),

 
 void CodeGenAction::ExecuteAction() {
   // If this is an IR file, we have to treat it specially.
   if (getCurrentFileKind().getLanguage() == Language::LLVM_IR) {
     BackendAction BA = static_cast<BackendAction>(Act);
     CompilerInstance &CI = getCompilerInstance();
     auto &CodeGenOpts = CI.getCodeGenOpts();
     auto &Diagnostics = CI.getDiagnostics();
-    std::unique_ptr<raw_pwrite_stream> OS =
-        GetOutputStream(CI, getCurrentFile(), BA);
+    std::string OutputPathName;
+    std::unique_ptr<raw_pwrite_stream> OS;
+    std::tie(OS, OutputPathName) = GetOutputStream(CI, getCurrentFile(), BA);
     if (BA != Backend_EmitNothing && !OS)
       return;
 
     bool Invalid;
     SourceManager &SM = CI.getSourceManager();
     FileID FID = SM.getMainFileID();
     const llvm::MemoryBuffer *MainFile = SM.getBuffer(FID, &Invalid);
     if (Invalid)
if (Error E = OptRecordFileOrErr.takeError()) {
       return;
     }
     std::unique_ptr<llvm::ToolOutputFile> OptRecordFile =
         std::move(*OptRecordFileOrErr);
 
     EmitBackendOutput(Diagnostics, CI.getHeaderSearchOpts(), CodeGenOpts,
                       TargetOpts, CI.getLangOpts(),
                       CI.getTarget().getDataLayout(), TheModule.get(), BA,
-                      std::move(OS));
+                      std::move(OS), OutputPathName);
 
     if (OptRecordFile)
       OptRecordFile->keep();
     return;
   }
 
   // Otherwise follow the normal AST path.
   this->ASTFrontendAction::ExecuteAction();

clang/lib/CodeGen/ObjectFilePCHContainerOperations.cpp

void HandleTranslationUnit(ASTContext &Ctx) override {
 
     LLVM_DEBUG({
       // Print the IR for the PCH container to the debug output.
       llvm::SmallString<0> Buffer;
       clang::EmitBackendOutput(
           Diags, HeaderSearchOpts, CodeGenOpts, TargetOpts, LangOpts,
           Ctx.getTargetInfo().getDataLayout(), M.get(),
           BackendAction::Backend_EmitLL,
-          std::make_unique<llvm::raw_svector_ostream>(Buffer));
+          std::make_unique<llvm::raw_svector_ostream>(Buffer), OutputFileName);
       llvm::dbgs() << Buffer;
     });
 
     // Use the LLVM backend to emit the pch container.
     clang::EmitBackendOutput(Diags, HeaderSearchOpts, CodeGenOpts, TargetOpts,
                              LangOpts, Ctx.getTargetInfo().getDataLayout(),
                              M.get(), BackendAction::Backend_EmitObj,
-                             std::move(OS));
+                             std::move(OS), OutputFileName);
 
     // Free the memory for the temporary buffer.
     llvm::SmallVector<char, 0> Empty;
     SerializedAST = std::move(Empty);
   }
 };
 
 } // anonymous namespace

clang/lib/Frontend/CompilerInstance.cpp

 }
 
 void CompilerInstance::clearOutputFiles(bool EraseFiles) {
   for (OutputFile &OF : OutputFiles) {
     if (!OF.TempFilename.empty()) {
       if (EraseFiles) {
         llvm::sys::fs::remove(OF.TempFilename);
       } else {
-        SmallString<128> NewOutFile(OF.Filename);
-
-        // If '-working-directory' was passed, the output filename should be
-        // relative to that.
-        FileMgr->FixupRelativePath(NewOutFile);
         if (std::error_code ec =
-                llvm::sys::fs::rename(OF.TempFilename, NewOutFile)) {
+                llvm::sys::fs::rename(OF.TempFilename, OF.Filename)) {
           getDiagnostics().Report(diag::err_unable_to_rename_temp)
               << OF.TempFilename << OF.Filename << ec.message();
 
           llvm::sys::fs::remove(OF.TempFilename);
         }
       }
     } else if (!OF.Filename.empty() && EraseFiles)
       llvm::sys::fs::remove(OF.Filename);
   }
   OutputFiles.clear();
   if (DeleteBuiltModules) {
     for (auto &Module : BuiltModules)
       llvm::sys::fs::remove(Module.second);
     BuiltModules.clear();
   }
   NonSeekStream.reset();
 }
 
-std::unique_ptr<raw_pwrite_stream>
+std::tuple<std::unique_ptr<raw_pwrite_stream>, std::string>
 CompilerInstance::createDefaultOutputFile(bool Binary, StringRef InFile,
                                           StringRef Extension) {
   return createOutputFile(getFrontendOpts().OutputFile, Binary,
                           /*RemoveFileOnSignal=*/true, InFile, Extension,
                           getFrontendOpts().UseTemporary);
 }
 
 std::unique_ptr<raw_pwrite_stream> CompilerInstance::createNullOutputFile() {
   return std::make_unique<llvm::raw_null_ostream>();
 }
 
-std::unique_ptr<raw_pwrite_stream>
+std::tuple<std::unique_ptr<raw_pwrite_stream>, std::string>
 CompilerInstance::createOutputFile(StringRef OutputPath, bool Binary,
                                    bool RemoveFileOnSignal, StringRef InFile,
                                    StringRef Extension, bool UseTemporary,
                                    bool CreateMissingDirectories) {
   std::string OutputPathName, TempPathName;
   std::error_code EC;
   std::unique_ptr<raw_pwrite_stream> OS = createOutputFile(
       OutputPath, EC, Binary, RemoveFileOnSignal, InFile, Extension,
       UseTemporary, CreateMissingDirectories, &OutputPathName, &TempPathName);
   if (!OS) {
     getDiagnostics().Report(diag::err_fe_unable_to_open_output) << OutputPath
                                                                 << EC.message();
-    return nullptr;
+    return {nullptr, ""};
+  }
+
+  // If '-working-directory' was passed, the output filename should be
+  // relative to that.
+  if (OutputPathName != "-") {
+    SmallString<128> NewOutFile(OutputPathName);
+    FileMgr->makeAbsolutePath(NewOutFile);
+    OutputPathName = NewOutFile.str().str();
   }
 
   // Add the output file -- but don't try to remove "-", since this means we are
   // using stdin.
   addOutputFile(
       OutputFile((OutputPathName != "-") ? OutputPathName : "", TempPathName));
 
-  return OS;
+  return std::tuple<std::unique_ptr<raw_pwrite_stream>, std::string>(
+      std::move(OS), OutputPathName);
 }
 
 std::unique_ptr<llvm::raw_pwrite_stream> CompilerInstance::createOutputFile(
     StringRef OutputPath, std::error_code &Error, bool Binary,
     bool RemoveFileOnSignal, StringRef InFile, StringRef Extension,
     bool UseTemporary, bool CreateMissingDirectories,
     std::string *ResultPathName, std::string *TempPathName) {
   assert((!CreateMissingDirectories || UseTemporary) &&
          "CreateMissingDirectories is only allowed when using temporary files");
 
   std::string OutFile, TempFile;
   if (!OutputPath.empty()) {
     OutFile = std::string(OutputPath);
   } else if (InFile == "-") {

clang/lib/Frontend/FrontendActions.cpp

 }
 
 //===----------------------------------------------------------------------===//
 // AST Consumer Actions
 //===----------------------------------------------------------------------===//
 
 std::unique_ptr<ASTConsumer>
 ASTPrintAction::CreateASTConsumer(CompilerInstance &CI, StringRef InFile) {
-  if (std::unique_ptr<raw_ostream> OS =
-          CI.createDefaultOutputFile(false, InFile))
+  std::string OutputPathName;
+  std::unique_ptr<raw_ostream> OS;
+  std::tie(OS, OutputPathName) = CI.createDefaultOutputFile(false, InFile);
+  if (OS)
     return CreateASTPrinter(std::move(OS), CI.getFrontendOpts().ASTDumpFilter);
   return nullptr;
 }
 
 std::unique_ptr<ASTConsumer>
 ASTDumpAction::CreateASTConsumer(CompilerInstance &CI, StringRef InFile) {
   const FrontendOptions &Opts = CI.getFrontendOpts();
   return CreateASTDumper(nullptr /*Dump to stdout.*/, Opts.ASTDumpFilter,

 
 std::unique_ptr<ASTConsumer>
 GeneratePCHAction::CreateASTConsumer(CompilerInstance &CI, StringRef InFile) {
   std::string Sysroot;
   if (!ComputeASTConsumerArguments(CI, /*ref*/ Sysroot))
     return nullptr;
 
   std::string OutputFile;
-  std::unique_ptr<raw_pwrite_stream> OS =
-      CreateOutputFile(CI, InFile, /*ref*/ OutputFile);
+  std::unique_ptr<raw_pwrite_stream> OS;
+  std::tie(OS, OutputFile) = CreateOutputFile(CI, InFile);
   if (!OS)
     return nullptr;
 
   if (!CI.getFrontendOpts().RelocatablePCH)
     Sysroot.clear();
 
   const auto &FrontendOpts = CI.getFrontendOpts();
   auto Buffer = std::make_shared<PCHBuffer>();
bool GeneratePCHAction::ComputeASTConsumerArguments(CompilerInstance &CI,
   if (CI.getFrontendOpts().RelocatablePCH && Sysroot.empty()) {
     CI.getDiagnostics().Report(diag::err_relocatable_without_isysroot);
     return false;
   }
 
   return true;
 }
 
-std::unique_ptr<llvm::raw_pwrite_stream>
-GeneratePCHAction::CreateOutputFile(CompilerInstance &CI, StringRef InFile,
-                                    std::string &OutputFile) {
+std::tuple<std::unique_ptr<raw_pwrite_stream>, std::string>
+GeneratePCHAction::CreateOutputFile(CompilerInstance &CI, StringRef InFile) {
   // We use createOutputFile here because this is exposed via libclang, and we
   // must disable the RemoveFileOnSignal behavior.
   // We use a temporary to avoid race conditions.
-  std::unique_ptr<raw_pwrite_stream> OS =
-      CI.createOutputFile(CI.getFrontendOpts().OutputFile, /*Binary=*/true,
+  return CI.createOutputFile(CI.getFrontendOpts().OutputFile, /*Binary=*/true,
                              /*RemoveFileOnSignal=*/false, InFile,
-                          /*Extension=*/"", CI.getFrontendOpts().UseTemporary);
-  if (!OS)
-    return nullptr;
-
-  OutputFile = CI.getFrontendOpts().OutputFile;
-  return OS;
+                             /*Extension=*/"",
+                             CI.getFrontendOpts().UseTemporary);
 }
 
 bool GeneratePCHAction::shouldEraseOutputFiles() {
   if (getCompilerInstance().getPreprocessorOpts().AllowPCHWithCompilerErrors)
     return false;
   return ASTFrontendAction::shouldEraseOutputFiles();
 }
 
 bool GeneratePCHAction::BeginSourceFileAction(CompilerInstance &CI) {
   CI.getLangOpts().CompilingPCH = true;
   return true;
 }
 
 std::unique_ptr<ASTConsumer>
 GenerateModuleAction::CreateASTConsumer(CompilerInstance &CI,
                                         StringRef InFile) {
-  std::unique_ptr<raw_pwrite_stream> OS = CreateOutputFile(CI, InFile);
+  std::unique_ptr<raw_pwrite_stream> OS;
+  std::string OutputFile;
+  std::tie(OS, OutputFile) = CreateOutputFile(CI, InFile);
   if (!OS)
     return nullptr;
 
-  std::string OutputFile = CI.getFrontendOpts().OutputFile;
   std::string Sysroot;
 
   auto Buffer = std::make_shared<PCHBuffer>();
   std::vector<std::unique_ptr<ASTConsumer>> Consumers;
 
   Consumers.push_back(std::make_unique<PCHGenerator>(
       CI.getPreprocessor(), CI.getModuleCache(), OutputFile, Sysroot, Buffer,
       CI.getFrontendOpts().ModuleFileExtensions,
bool GenerateModuleFromModuleMapAction::BeginSourceFileAction(
   if (!CI.getLangOpts().Modules) {
     CI.getDiagnostics().Report(diag::err_module_build_requires_fmodules);
     return false;
   }
 
   return GenerateModuleAction::BeginSourceFileAction(CI);
 }
 
-std::unique_ptr<raw_pwrite_stream>
+std::tuple<std::unique_ptr<raw_pwrite_stream>, std::string>
 GenerateModuleFromModuleMapAction::CreateOutputFile(CompilerInstance &CI,
                                                     StringRef InFile) {
   // If no output file was provided, figure out where this module would go
   // in the module cache.
   if (CI.getFrontendOpts().OutputFile.empty()) {
     StringRef ModuleMapFile = CI.getFrontendOpts().OriginalModuleMap;
     if (ModuleMapFile.empty())
       ModuleMapFile = InFile;
if (!CI.getLangOpts().ModulesTS && !CI.getLangOpts().CPlusPlusModules) {
     return false;
   }
 
   CI.getLangOpts().setCompilingModule(LangOptions::CMK_ModuleInterface);
 
   return GenerateModuleAction::BeginSourceFileAction(CI);
 }
 
-std::unique_ptr<raw_pwrite_stream>
+std::tuple<std::unique_ptr<raw_pwrite_stream>, std::string>
 GenerateModuleInterfaceAction::CreateOutputFile(CompilerInstance &CI,
                                                 StringRef InFile) {
   return CI.createDefaultOutputFile(/*Binary=*/true, InFile, "pcm");
 }
 
 bool GenerateHeaderModuleAction::PrepareToExecuteAction(
     CompilerInstance &CI) {
   if (!CI.getLangOpts().Modules) {
for (StringRef Name : ModuleHeaders) {
     }
     Headers.push_back({std::string(Name), &FE->getFileEntry()});
   }
   HS.getModuleMap().createHeaderModule(CI.getLangOpts().CurrentModule, Headers);
 
   return GenerateModuleAction::BeginSourceFileAction(CI);
 }
 
-std::unique_ptr<raw_pwrite_stream>
+std::tuple<std::unique_ptr<raw_pwrite_stream>, std::string>
 GenerateHeaderModuleAction::CreateOutputFile(CompilerInstance &CI,
                                              StringRef InFile) {
   return CI.createDefaultOutputFile(/*Binary=*/true, InFile, "pcm");
 }
 
 SyntaxOnlyAction::~SyntaxOnlyAction() {
 }
 
while (next < end) {
       } else if (*cur == 0x0A)  // LF
         break;
 
       ++cur;
       ++next;
     }
   }
 
-  std::unique_ptr<raw_ostream> OS =
+  std::unique_ptr<raw_ostream> OS;
+  std::string OutputPathName;
+  std::tie(OS, OutputPathName) =
       CI.createDefaultOutputFile(BinaryMode, getCurrentFileOrBufferName());
   if (!OS) return;
 
   // If we're preprocessing a module map, start by dumping the contents of the
   // module itself before switching to the input buffer.
   auto &Input = getCurrentInput();
   if (Input.getKind().getFormat() == InputKind::ModuleMap) {
     if (Input.isFile()) {
if (Buffer) {
     unsigned Preamble =
         Lexer::ComputePreamble((*Buffer)->getBuffer(), CI.getLangOpts()).Size;
     llvm::outs().write((*Buffer)->getBufferStart(), Preamble);
   }
 }
 
 void DumpCompilerOptionsAction::ExecuteAction() {
   CompilerInstance &CI = getCompilerInstance();
-  std::unique_ptr<raw_ostream> OSP =
+  std::unique_ptr<raw_ostream> OSP;
+  std::string OutputPathName;
+  std::tie(OSP, OutputPathName) =
       CI.createDefaultOutputFile(false, getCurrentFile());
   if (!OSP)
     return;
 
   raw_ostream &OS = *OSP;
   const Preprocessor &PP = CI.getPreprocessor();
   const LangOptions &LangOpts = PP.getLangOpts();
 

clang/lib/Frontend/InterfaceStubFunctionsConsumer.cpp

struct Visitor : public RecursiveASTVisitor<Visitor> {
       std::set<const NamedDecl *> LateParsedDecls;
       std::set<NamedDecl *> NamedDecls;
       std::set<const ValueDecl *> ValueDecls;
     } v;
 
     v.TraverseDecl(context.getTranslationUnitDecl());
 
     MangledSymbols Symbols;
-    auto OS = Instance.createDefaultOutputFile(/*Binary=*/false, InFile, "ifs");
+    std::unique_ptr<raw_pwrite_stream> OS;
+    std::string OutputPathName;
+    std::tie(OS, OutputPathName) =
+        Instance.createDefaultOutputFile(/*Binary=*/false, InFile, "ifs");
     if (!OS)
       return;
 
     if (Instance.getLangOpts().DelayedTemplateParsing) {
       clang::Sema &S = Instance.getSema();
       for (const auto *FD : v.LateParsedDecls) {
         clang::LateParsedTemplate &LPT =
             *S.LateParsedTemplateMap.find(cast<FunctionDecl>(FD))->second;

clang/lib/Frontend/PrecompiledPreamble.cpp

PrecompilePreambleAction::CreateASTConsumer(CompilerInstance &CI,
   if (!GeneratePCHAction::ComputeASTConsumerArguments(CI, Sysroot))
     return nullptr;
 
   std::unique_ptr<llvm::raw_ostream> OS;
   if (InMemStorage) {
     OS = std::make_unique<llvm::raw_string_ostream>(*InMemStorage);
   } else {
     std::string OutputFile;
-    OS = GeneratePCHAction::CreateOutputFile(CI, InFile, OutputFile);
+    std::tie(OS, OutputFile) = GeneratePCHAction::CreateOutputFile(CI, InFile);
   }
   if (!OS)
     return nullptr;
 
   if (!CI.getFrontendOpts().RelocatablePCH)
     Sysroot.clear();
 
   return std::make_unique<PrecompilePreambleConsumer>(

clang/lib/Frontend/Rewrite/FrontendActions.cpp

 using namespace clang;
 
 //===----------------------------------------------------------------------===//
 // AST Consumer Actions
 //===----------------------------------------------------------------------===//
 
 std::unique_ptr<ASTConsumer>
 HTMLPrintAction::CreateASTConsumer(CompilerInstance &CI, StringRef InFile) {
-  if (std::unique_ptr<raw_ostream> OS =
-          CI.createDefaultOutputFile(false, InFile))
+  std::string OutputPathName;
+  std::unique_ptr<raw_ostream> OS;
+  std::tie(OS, OutputPathName) = CI.createDefaultOutputFile(false, InFile);
+  if (OS)
     return CreateHTMLPrinter(std::move(OS), CI.getPreprocessor());
   return nullptr;
 }
 
 FixItAction::FixItAction() {}
 FixItAction::~FixItAction() {}
 
 std::unique_ptr<ASTConsumer>
bool FixItRecompile::BeginInvocation(CompilerInstance &CI) {
 
   return true;
 }
 
 #if CLANG_ENABLE_OBJC_REWRITER
 
 std::unique_ptr<ASTConsumer>
 RewriteObjCAction::CreateASTConsumer(CompilerInstance &CI, StringRef InFile) {
-  if (std::unique_ptr<raw_ostream> OS =
-          CI.createDefaultOutputFile(false, InFile, "cpp")) {
+  std::string OutputPathName;
+  std::unique_ptr<raw_ostream> OS;
+  std::tie(OS, OutputPathName) =
+      CI.createDefaultOutputFile(false, InFile, "cpp");
+  if (OS) {
     if (CI.getLangOpts().ObjCRuntime.isNonFragile())
       return CreateModernObjCRewriter(
           std::string(InFile), std::move(OS), CI.getDiagnostics(),
           CI.getLangOpts(), CI.getDiagnosticOpts().NoRewriteMacros,
           (CI.getCodeGenOpts().getDebugInfo() != codegenoptions::NoDebugInfo));
     return CreateObjCRewriter(std::string(InFile), std::move(OS),
                               CI.getDiagnostics(), CI.getLangOpts(),
                               CI.getDiagnosticOpts().NoRewriteMacros);
   }
   return nullptr;
 }
 
 #endif
 
 //===----------------------------------------------------------------------===//
 // Preprocessor Actions
 //===----------------------------------------------------------------------===//
 
 void RewriteMacrosAction::ExecuteAction() {
   CompilerInstance &CI = getCompilerInstance();
-  std::unique_ptr<raw_ostream> OS =
+  std::string OutputPathName;
+  std::unique_ptr<raw_ostream> OS;
+  std::tie(OS, OutputPathName) =
       CI.createDefaultOutputFile(true, getCurrentFileOrBufferName());
-  if (!OS) return;
+  if (!OS)
+    return;
 
   RewriteMacrosInInput(CI.getPreprocessor(), OS.get());
 }
 
 void RewriteTestAction::ExecuteAction() {
   CompilerInstance &CI = getCompilerInstance();
-  std::unique_ptr<raw_ostream> OS =
+  std::string OutputPathName;
+  std::unique_ptr<raw_ostream> OS;
+  std::tie(OS, OutputPathName) =
       CI.createDefaultOutputFile(false, getCurrentFileOrBufferName());
   if (!OS) return;
 
   DoRewriteTest(CI.getPreprocessor(), OS.get());
 }
 
 class RewriteIncludesAction::RewriteImportsListener : public ASTReaderListener {
   CompilerInstance &CI;
void visitModuleFile(StringRef Filename,
     });
 
     (*OS) << "#pragma clang module endbuild /*" << MF->ModuleName << "*/\n";
   }
 };
 
 bool RewriteIncludesAction::BeginSourceFileAction(CompilerInstance &CI) {
   if (!OutputStream) {
-    OutputStream =
+    std::string OutputPathName;
+    std::tie(OutputStream, OutputPathName) =
         CI.createDefaultOutputFile(true, getCurrentFileOrBufferName());
     if (!OutputStream)
       return false;
   }
 
   auto &OS = *OutputStream;
 
   // If we're preprocessing a module map, start by dumping the contents of the

clang/tools/driver/cc1_main.cpp

int cc1_main(ArrayRef<const char *> Argv, const char *Argv0, void *MainAddr) {
   // If any timers were active but haven't been destroyed yet, print their
   // results now.  This happens in -disable-free mode.
   llvm::TimerGroup::printAll(llvm::errs());
   llvm::TimerGroup::clearAll();
 
   if (llvm::timeTraceProfilerEnabled()) {
     SmallString<128> Path(Clang->getFrontendOpts().OutputFile);
     llvm::sys::path::replace_extension(Path, "json");
-    if (auto profilerOutput =
-            Clang->createOutputFile(Path.str(),
-                                    /*Binary=*/false,
-                                    /*RemoveFileOnSignal=*/false, "",
-                                    /*Extension=*/"json",
-                                    /*useTemporary=*/false)) {
-
-      llvm::timeTraceProfilerWrite(*profilerOutput);
+    std::unique_ptr<raw_pwrite_stream> ProfilerOS;
+    std::string ProfilerOutputFilePath;
+    std::tie(ProfilerOS, ProfilerOutputFilePath) =
+                                /*useTemporary=*/false);
+    if (ProfilerOS) {
+      llvm::timeTraceProfilerWrite(*ProfilerOS);
       // FIXME(ibiryukov): make profilerOutput flush in destructor instead.
-      profilerOutput->flush();
+      ProfilerOS->flush();
       llvm::timeTraceProfilerCleanup();
       Clang->clearOutputFiles(false);
     }
   }
 
   // Our error handler depends on the Diagnostics object, which we're
   // potentially about to delete. Uninstall the handler now so that any
   // later errors use the default handling behavior instead.

lld/COFF/LTO.h

public:
   ~BitcodeCompiler();
 
   void add(BitcodeFile &f);
   std::vector<InputFile *> compile();
 
 private:
   std::unique_ptr<llvm::lto::LTO> ltoObj;
   std::vector<SmallString<0>> buf;
+  std::vector<std::string> objFilePath;
   std::vector<std::unique_ptr<MemoryBuffer>> files;
   std::unique_ptr<llvm::raw_fd_ostream> indexFile;
   llvm::DenseSet<StringRef> thinIndices;
 };
 }
 }
 
 #endif

lld/COFF/LTO.cpp

void BitcodeCompiler::add(BitcodeFile &f) {
   checkError(ltoObj->add(std::move(f.obj), resols));
 }
 
 // Merge all the bitcode files we have seen, codegen the result
 // and return the resulting objects.
 std::vector<InputFile *> BitcodeCompiler::compile() {
   unsigned maxTasks = ltoObj->getMaxTasks();
   buf.resize(maxTasks);
+  objFilePath.resize(maxTasks);
   files.resize(maxTasks);
 
   // The /lldltocache option specifies the path to a directory in which to cache
   // native object files for ThinLTO incremental builds. If a path was
   // specified, configure LTO to use it as the cache directory.
   lto::NativeObjectCache cache;
   if (!config->ltoCache.empty())
     cache = check(lto::localCache(
         config->ltoCache, [&](size_t task, std::unique_ptr<MemoryBuffer> mb) {
           files[task] = std::move(mb);
         }));
 
+  // Compute the target file names in advance, because we might need to write
+  // them into the S_OBJNAME CodeView record.
+  if (config->thinLTOIndexOnly) {
+    if (!config->ltoObjPath.empty())
+      objFilePath[0] = config->ltoObjPath.str();
+  } else {
+    for (unsigned i = 0; i != maxTasks; ++i) {
+      // Assign unique names to LTO objects. This ensures they have unique names
+      // in the PDB if one is produced. The names should look like:
+      // - foo.exe.lto.obj
+      // - foo.exe.lto.1.obj
+      // - ...
+      objFilePath[i] =
+          saver
+              .save(Twine(config->outputFile) + ".lto" +
+                    (i == 0 ? Twine("") : Twine('.') + Twine(i)) + ".obj")
+              .str();
+    }
+  }
+
   checkError(ltoObj->run(
       [&](size_t task) {
         return std::make_unique<lto::NativeObjectStream>(
-            std::make_unique<raw_svector_ostream>(buf[task]));
+            std::make_unique<raw_svector_ostream>(buf[task]),
+            objFilePath[task]);
       },
       cache));
 
   // Emit empty index files for non-indexed files
   for (StringRef s : thinIndices) {
     std::string path = getThinLTOOutputFile(s);
     openFile(path + ".thinlto.bc");
     if (config->thinLTOEmitImportsFiles)
       openFile(path + ".imports");
   }
 
   // ThinLTO with index only option is required to generate only the index
   // files. After that, we exit from linker and ThinLTO backend runs in a
   // distributed environment.
   if (config->thinLTOIndexOnly) {
     if (!config->ltoObjPath.empty())
-      saveBuffer(buf[0], config->ltoObjPath);
+      saveBuffer(buf[0], objFilePath[0]);
     if (indexFile)
       indexFile->close();
     return {};
   }
 
   if (!config->ltoCache.empty())
     pruneCache(config->ltoCache, config->ltoCachePolicy);
 
   std::vector<InputFile *> ret;
   for (unsigned i = 0; i != maxTasks; ++i) {
-    // Assign unique names to LTO objects. This ensures they have unique names
-    // in the PDB if one is produced. The names should look like:
-    // - foo.exe.lto.obj
-    // - foo.exe.lto.1.obj
-    // - ...
-    StringRef ltoObjName =
-        saver.save(Twine(config->outputFile) + ".lto" +
-                   (i == 0 ? Twine("") : Twine('.') + Twine(i)) + ".obj");
-
     // Get the native object contents either from the cache or from memory.  Do
     // not use the cached MemoryBuffer directly, or the PDB will not be
     // deterministic.
     StringRef objBuf;
     if (files[i])
       objBuf = files[i]->getBuffer();
     else
       objBuf = buf[i];
     if (objBuf.empty())
       continue;
 
     if (config->saveTemps)
-      saveBuffer(buf[i], ltoObjName);
-    ret.push_back(make<ObjFile>(MemoryBufferRef(objBuf, ltoObjName)));
+      saveBuffer(buf[i], objFilePath[i]);
+    ret.push_back(make<ObjFile>(MemoryBufferRef(objBuf, objFilePath[i])));
   }
 
   return ret;
 }

lld/ELF/LTO.cpp

cache = check(
                         [&](size_t task, std::unique_ptr<MemoryBuffer> mb) {
                           files[task] = std::move(mb);
                         }));
 
   if (!bitcodeFiles.empty())
     checkError(ltoObj->run(
         [&](size_t task) {
           return std::make_unique<lto::NativeObjectStream>(
-              std::make_unique<raw_svector_ostream>(buf[task]));
+              std::make_unique<raw_svector_ostream>(buf[task]),
+              /*OSPath=*/"");
         },
         cache));
 
   // Emit empty index files for non-indexed files
   for (StringRef s : thinIndices) {
     std::string path = getThinLTOOutputFile(s);
     openFile(path + ".thinlto.bc");
     if (config->thinLTOEmitImportsFiles)

lld/wasm/LTO.cpp

cache = check(
         lto::localCache(config->thinLTOCacheDir,
                         [&](size_t task, std::unique_ptr<MemoryBuffer> mb) {
                           files[task] = std::move(mb);
                         }));
 
   checkError(ltoObj->run(
       [&](size_t task) {
         return std::make_unique<lto::NativeObjectStream>(
-            std::make_unique<raw_svector_ostream>(buf[task]));
+            std::make_unique<raw_svector_ostream>(buf[task]), /*OSPath=*/"");
       },
       cache));
 
   if (!config->thinLTOCacheDir.empty())
     pruneCache(config->thinLTOCacheDir, config->thinLTOCachePolicy);
 
   std::vector<StringRef> ret;
   for (unsigned i = 0; i != maxTasks; ++i) {

llvm/include/llvm/LTO/LTO.h

 
 /// This class wraps an output stream for a native object. Most clients should
 /// just be able to return an instance of this base class from the stream
 /// callback, but if a client needs to perform some action after the stream is
 /// written to, that can be done by deriving from this class and overriding the
 /// destructor.
 class NativeObjectStream {
 public:
-  NativeObjectStream(std::unique_ptr<raw_pwrite_stream> OS) : OS(std::move(OS)) {}
+  NativeObjectStream(std::unique_ptr<raw_pwrite_stream> OS, std::string OSPath)
+      : OS(std::move(OS)), ObjectPathName(OSPath) {}
   std::unique_ptr<raw_pwrite_stream> OS;
+  std::string ObjectPathName;
   virtual ~NativeObjectStream() = default;
 };
 
 /// This type defines the callback to add a native object that is generated on
 /// the fly.
 ///
 /// Stream callbacks must be thread safe.
 using AddStreamFn =

llvm/include/llvm/MC/MCTargetOptions.h

public:
   /// Preserve Comments in Assembly.
   bool PreserveAsmComments : 1;
 
   int DwarfVersion = 0;
 
   std::string ABIName;
   std::string AssemblyLanguage;
   std::string SplitDwarfFile;
+  std::string OutputPathName;
 
   /// Additional paths to search for `.include` directives when using the
   /// integrated assembler.
   std::vector<std::string> IASSearchPaths;
 
   MCTargetOptions();
 
   /// getABIName - If this returns a non-empty string this represents the

llvm/include/llvm/Support/ToolOutputFile.h

 ///   - The file is automatically deleted when the ToolOutputFile
 ///     object is destroyed unless the client calls keep().
 class ToolOutputFile {
   /// This class is declared before the raw_fd_ostream so that it is constructed
   /// before the raw_fd_ostream is constructed and destructed after the
   /// raw_fd_ostream is destructed. It installs cleanups in its constructor and
   /// uninstalls them in its destructor.
   class CleanupInstaller {
+  public:
     /// The name of the file.
     std::string Filename;
-  public:
+
     /// The flag which indicates whether we should not delete the file.
     bool Keep;
 
     explicit CleanupInstaller(StringRef Filename);
     ~CleanupInstaller();
   } Installer;
 
   /// The contained stream. This is intentionally declared after Installer.
   raw_fd_ostream OS;
 
 public:
   /// This constructor's arguments are passed to raw_fd_ostream's
   /// constructor.
   ToolOutputFile(StringRef Filename, std::error_code &EC,
                  sys::fs::OpenFlags Flags);
 
   ToolOutputFile(StringRef Filename, int FD);
 
   /// Return the contained raw_fd_ostream.
   raw_fd_ostream &os() { return OS; }
 
   /// Indicate that the tool's job wrt this output file has been successful and
   /// the file should not be deleted.
   void keep() { Installer.Keep = true; }
+
+  const std::string &outputFilename() { return Installer.Filename; }
 };
 
 } // end llvm namespace
 
 #endif

llvm/lib/CodeGen/AsmPrinter/CodeViewDebug.h

class LLVM_LIBRARY_VISIBILITY CodeViewDebug : public DebugHandlerBase {
   /// section. Appears at the front of every .debug$S or .debug$T or .debug$P
   /// section.
   void emitCodeViewMagicVersion();
 
   void emitTypeInformation();
 
   void emitTypeGlobalHashes();
 
+  void emitObjName();
+
   void emitCompilerInformation();
 
   void emitBuildInfo();
 
   void emitInlineeLinesSubsection();
 
   void emitDebugInfoForThunk(const Function *GV,
                              FunctionInfo &FI,

llvm/lib/CodeGen/AsmPrinter/CodeViewDebug.cpp

void CodeViewDebug::endModule() {
   // of the payload followed by the payload itself.  The subsections are 4-byte
   // aligned.
 
   // Use the generic .debug$S section, and make a subsection for all the inlined
   // subprograms.
   switchToDebugSectionForSymbol(nullptr);
 
   MCSymbol *CompilerInfo = beginCVSubsection(DebugSubsectionKind::Symbols);
+  emitObjName();
   emitCompilerInformation();
   endCVSubsection(CompilerInfo);
 
   emitInlineeLinesSubsection();
 
   // Emit per-function debug information.
   for (auto &P : FnDebugInfo)
     if (!P.first->isDeclarationForLinker())
static SourceLanguage MapDWLangToCVLang(unsigned DWLang) {
   default:
     // There's no CodeView representation for this language, and CV doesn't
     // have an "unknown" option for the language field, so we'll use MASM,
     // as it's very low level.
     return SourceLanguage::Masm;
   }
 }
 
+static void unescapeSlashes(SmallVectorImpl<char> &Str) {
+  auto Read = Str.begin();
+  auto Write = Read;
+  while (Read != Str.end()) {
+    bool WasSlash = (*Read == '\\');
+    *Write++ = *Read++;
+    if (WasSlash && Read != Str.end() && *Read == '\\')
+      ++Read;
+  }
+  Str.resize(Write - Str.begin());
+}
+
+void CodeViewDebug::emitObjName() {
+  MCSymbol *CompilerEnd = beginSymbolRecord(SymbolKind::S_OBJNAME);
+
+  StringRef PathRef(Asm->TM.Options.MCOptions.OutputPathName);
+  assert(PathRef == "-" || !PathRef.empty());
+  llvm::SmallString<256> Path(PathRef);
+
+  if (Path == "-") {
+    // Don't emit the filename if we're writing to stdout.
+    Path.clear();
+  } else {
+    llvm::sys::fs::make_absolute(Path);
+    llvm::sys::path::remove_dots(Path, /*remove_dot_dot=*/true);
+    unescapeSlashes(Path);
+    assert(llvm::sys::path::is_absolute(Path));
+  }
+
+  OS.AddComment("Signature");
+  OS.emitInt32(0);
+
+  OS.AddComment("Object name");
+  emitNullTerminatedSymbolName(OS, Path);
+
+  endSymbolRecord(CompilerEnd);
+}
+
 namespace {
 struct Version {
   int Part[4];
 };
 } // end anonymous namespace
 
 // Takes a StringRef like "clang 4.0.0.0 (other nonsense 123)" and parses out
 // the version number.
if (isdigit(C)) {
         return V;
     } else if (N > 0)
       return V;
   }
   return V;
 }
 
 void CodeViewDebug::emitCompilerInformation() {
   MCSymbol *CompilerEnd = beginSymbolRecord(SymbolKind::S_COMPILE3);
   uint32_t Flags = 0;
 
   NamedMDNode *CUs = MMI->getModule()->getNamedMetadata("llvm.dbg.cu");
   const MDNode *Node = *CUs->operands().begin();
   const auto *CU = cast<DICompileUnit>(Node);
 
   // The low byte of the flags indicates the source language.
   Flags = MapDWLangToCVLang(CU->getSourceLanguage());
   // TODO:  Figure out which other flags need to be set.
 
   OS.AddComment("Flags and language");
   OS.emitInt32(Flags);
 
   OS.AddComment("CPUType");
   OS.emitInt16(static_cast<uint64_t>(TheCPU));
 
   StringRef CompilerVersion = CU->getProducer();
   Version FrontVer = parseVersion(CompilerVersion);
   OS.AddComment("Frontend version");
   for (int N = 0; N < 4; ++N)
     OS.emitInt16(FrontVer.Part[N]);
 
   // Some Microsoft tools, like Binscope, expect a backend version number of at
   // least 8.something, so we'll coerce the LLVM version into a form that
   // guarantees it'll be big enough without really lying about the version.
   int Major = 1000 * LLVM_VERSION_MAJOR +
               10 * LLVM_VERSION_MINOR +

llvm/lib/LTO/Caching.cpp

if (EC != errc::no_such_file_or_directory && EC != errc::permission_denied)
       report_fatal_error(Twine("Failed to open cache file ") + EntryPath +
                          ": " + EC.message() + "\n");
 
     // This native object stream is responsible for commiting the resulting
     // file to the cache and calling AddBuffer to add it to the link.
     struct CacheStream : NativeObjectStream {
       AddBufferFn AddBuffer;
       sys::fs::TempFile TempFile;
-      std::string EntryPath;
       unsigned Task;
 
       CacheStream(std::unique_ptr<raw_pwrite_stream> OS, AddBufferFn AddBuffer,
                   sys::fs::TempFile TempFile, std::string EntryPath,
                   unsigned Task)
-          : NativeObjectStream(std::move(OS)), AddBuffer(std::move(AddBuffer)),
-            TempFile(std::move(TempFile)), EntryPath(std::move(EntryPath)),
+          : NativeObjectStream(std::move(OS), std::move(EntryPath)),
+            AddBuffer(std::move(AddBuffer)), TempFile(std::move(TempFile)),
             Task(Task) {}
 
       ~CacheStream() {
         // Make sure the stream is closed before committing it.
         OS.reset();
 
         // Open the file first to avoid racing with a cache pruner.
         ErrorOr<std::unique_ptr<MemoryBuffer>> MBOrErr =
struct CacheStream : NativeObjectStream {
         // it already exists. We try to emulate this on Windows, but this may
         // fail with a permission denied error (for example, if the destination
         // is currently opened by another process that does not give us the
         // sharing permissions we need). Since the existing file should be
         // semantically equivalent to the one we are trying to write, we give
         // AddBuffer a copy of the bytes we wrote in that case. We do this
         // instead of just using the existing file, because the pruner might
         // delete the file before we get a chance to use it.
-        Error E = TempFile.keep(EntryPath);
+        Error E = TempFile.keep(ObjectPathName);
         E = handleErrors(std::move(E), [&](const ECError &E) -> Error {
           std::error_code EC = E.convertToErrorCode();
           if (EC != errc::permission_denied)
             return errorCodeToError(EC);
 
           auto MBCopy = MemoryBuffer::getMemBufferCopy((*MBOrErr)->getBuffer(),
-                                                       EntryPath);
+                                                       ObjectPathName);
           MBOrErr = std::move(MBCopy);
 
           // FIXME: should we consume the discard error?
           consumeError(TempFile.discard());
 
           return Error::success();
         });
 
         if (E)
           report_fatal_error(Twine("Failed to rename temporary file ") +
-                             TempFile.TmpName + " to " + EntryPath + ": " +
+                             TempFile.TmpName + " to " + ObjectPathName + ": " +
                              toString(std::move(E)) + "\n");
 
         AddBuffer(Task, std::move(*MBOrErr));
       }
     };
 
     return [=](size_t Task) -> std::unique_ptr<NativeObjectStream> {
       // Write to a temporary to avoid race condition

llvm/lib/LTO/LTOBackend.cpp

void codegen(const Config &Conf, TargetMachine *TM, AddStreamFn AddStream,
   if (!DwoFile.empty()) {
     std::error_code EC;
     DwoOut = std::make_unique<ToolOutputFile>(DwoFile, EC, sys::fs::OF_None);
     if (EC)
       report_fatal_error("Failed to open " + DwoFile + ": " + EC.message());
   }
 
   auto Stream = AddStream(Task);
+  TM->Options.MCOptions.OutputPathName = Stream->ObjectPathName;
+
   legacy::PassManager CodeGenPasses;
   if (TM->addPassesToEmitFile(CodeGenPasses, *Stream->OS,
                               DwoOut ? &DwoOut->os() : nullptr,
                               Conf.CGFileType))
     report_fatal_error("Failed to setup codegen");
   CodeGenPasses.run(Mod);
 
   if (DwoOut)

llvm/test/DebugInfo/COFF/globals.ll

 ; RUN: llc < %s | FileCheck %s --check-prefix=ASM
 ; RUN: llc < %s -filetype=obj | llvm-readobj - --codeview | FileCheck %s --check-prefix=OBJ
 ; RUN: llc < %s | llvm-mc -filetype=obj --triple=x86_64-windows | llvm-readobj - --codeview | FileCheck %s --check-prefix=OBJ
-; RUN: llc < %s -filetype=obj | obj2yaml | FileCheck %s --check-prefix=YAML
+; RUN: llc < %s -filetype=obj | obj2yaml | FileCheck %s --check-prefixes=YAML,YAML-STDOUT
+; RUN: llc < %s -filetype=obj -o %t
+; RUN: obj2yaml < %t | FileCheck %s --check-prefixes=YAML,YAML-FILE
 
 ; C++ source to regenerate:
 ; $ cat a.cpp
 ; int first;
 ; 
 ; template <typename T> struct A { static const int comdat = 3; };
 ; 
 ; thread_local const int *middle = &A<void>::comdat;

 ; OBJ-NEXT:      DisplayName: foo::Data::DataStatic
 ; OBJ-NEXT:      LinkageName: ?DataStatic@Data@foo@@2HA
 ; OBJ-NEXT:    }
 
 ; YAML-LABEL:  - Name:            '.debug$S'
 ; YAML:    Subsections:
 ; YAML:      - !Symbols
 ; YAML:        Records:
+; YAML:          - Kind:            S_OBJNAME
+; YAML:            ObjNameSym:
+; YAML:               Signature:       0
+; YAML-STDOUT         ObjectName:      ''
+; YAML-FILE           ObjectName:      '{{.*}}'
 ; YAML:          - Kind:            S_COMPILE3
 ; YAML:            Compile3Sym:
 
 ; YAML:      - !Symbols
 ; YAML-NEXT:        Records:
 ; YAML-LABEL:        - Kind:            S_GDATA32
 ; YAML-NEXT:            DataSym:
 ; YAML-NOT: Segment

llvm/test/DebugInfo/COFF/multifunction.ll

 ; String table
 ; X64: .cv_stringtable
 
 ; OBJ64:    Section {
 ; OBJ64:      Name: .debug$S (2E 64 65 62 75 67 24 53)
 ; OBJ64:      Characteristics [ (0x42300040)
 ; OBJ64:      ]
 ; OBJ64:      Relocations [
-; OBJ64-NEXT:   0x64 IMAGE_REL_AMD64_SECREL x
-; OBJ64-NEXT:   0x68 IMAGE_REL_AMD64_SECTION x
-; OBJ64-NEXT:   0x9C IMAGE_REL_AMD64_SECREL x
-; OBJ64-NEXT:   0xA0 IMAGE_REL_AMD64_SECTION x
-; OBJ64-NEXT:   0x100 IMAGE_REL_AMD64_SECREL y
-; OBJ64-NEXT:   0x104 IMAGE_REL_AMD64_SECTION y
-; OBJ64-NEXT:   0x138 IMAGE_REL_AMD64_SECREL y
-; OBJ64-NEXT:   0x13C IMAGE_REL_AMD64_SECTION y
-; OBJ64-NEXT:   0x19C IMAGE_REL_AMD64_SECREL f
-; OBJ64-NEXT:   0x1A0 IMAGE_REL_AMD64_SECTION f
-; OBJ64-NEXT:   0x1D4 IMAGE_REL_AMD64_SECREL f
-; OBJ64-NEXT:   0x1D8 IMAGE_REL_AMD64_SECTION f
+; OBJ64-NEXT:   0x70 IMAGE_REL_AMD64_SECREL x
+; OBJ64-NEXT:   0x74 IMAGE_REL_AMD64_SECTION x
+; OBJ64-NEXT:   0xA8 IMAGE_REL_AMD64_SECREL x
+; OBJ64-NEXT:   0xAC IMAGE_REL_AMD64_SECTION x
+; OBJ64-NEXT:   0x10C IMAGE_REL_AMD64_SECREL y
+; OBJ64-NEXT:   0x110 IMAGE_REL_AMD64_SECTION y
+; OBJ64-NEXT:   0x144 IMAGE_REL_AMD64_SECREL y
+; OBJ64-NEXT:   0x148 IMAGE_REL_AMD64_SECTION y
+; OBJ64-NEXT:   0x1A8 IMAGE_REL_AMD64_SECREL f
+; OBJ64-NEXT:   0x1AC IMAGE_REL_AMD64_SECTION f
+; OBJ64-NEXT:   0x1E0 IMAGE_REL_AMD64_SECREL f
+; OBJ64-NEXT:   0x1E4 IMAGE_REL_AMD64_SECTION f
 ; OBJ64-NEXT: ]
 ; OBJ64:      Subsection [
 ; OBJ64-NEXT:   SubSectionType: Symbols (0xF1)
 ; OBJ64:        {{.*}}Proc{{.*}}Sym {
 ; OBJ64:          Kind: S_LPROC32_ID (0x1146)
 ; OBJ64:          CodeSize: 0xE
 ; OBJ64:          DisplayName: x
 ; OBJ64:          LinkageName: x

llvm/test/DebugInfo/COFF/pr28747.ll

 ; RUN: llc < %s | FileCheck %s
 ; CHECK:             .section .debug$S,"dr"{{$}}
 ; CHECK-NEXT:        .p2align 2
 ; CHECK-NEXT:        .long 4
 ; CHECK-NEXT:        .long  241
 ; CHECK-NEXT:        .long  [[SUBSEC_END:.*]]-[[SUBSEC_START:.*]] # Subsection size
 ; CHECK-NEXT:        [[SUBSEC_START]]:
-; CHECK-NEXT:        .short [[C1_END:.*]]-[[C1_START:.*]] # Record length
-; CHECK:             [[C1_END]]:
+; CHECK-NEXT:        .short [[OBJNAME_END:.*]]-[[OBJNAME_START:.*]] # Record length
+; CHECK:             [[OBJNAME_END]]:
+; CHECK-NEXT:        .short [[COMPILE3_END:.*]]-[[COMPILE3_START:.*]] # Record length
+; CHECK:             [[COMPILE3_END]]:
 ; CHECK-NEXT:        [[SUBSEC_END]]:
 ; CHECK-NEXT:        .p2align 2
 ; CHECK-NEXT:        .cv_filechecksums
 ; CHECK-NEXT:        .cv_stringtable
 
 target datalayout = "e-m:x-p:32:32-i64:64-f80:32-n8:16:32-a:0:32-S32"
 target triple = "i686-pc-windows-msvc18.0.0"
 

llvm/test/DebugInfo/COFF/simple.ll

 ; X86-LABEL: .section        .debug$S,"dr"
 ; X86-NEXT: .p2align 2
 ; X86-NEXT: .long   4
 ; Symbol subsection
 ; X86-NEXT: .long   241
 ; X86-NEXT: .long [[COMPILE_END:.*]]-[[COMPILE_START:.*]] #
 ; Compiler information record
 ; X86-NEXT: [[COMPILE_START]]:
-; X86-NEXT: .short [[C1_END:.*]]-[[C1_START:.*]] #
-; X86:      [[C1_END]]:
+; X86-NEXT: .short [[OBJNAME_END:.*]]-[[OBJNAME_START:.*]] #
+; X86:      [[OBJNAME_END]]:
+; X86-NEXT: .short [[COMPILE3_END:.*]]-[[COMPILE3_START:.*]] #
+; X86:      [[COMPILE3_END]]:
 ; X86-NEXT: [[COMPILE_END]]:
 ; X86-NEXT: .p2align  2
 ; X86-NEXT: .cv_fpo_data _f
 ; X86-NEXT: .long 241  # Symbol subsection for f
 ; X86-NEXT: .long [[F1_END:.*]]-[[F1_START:.*]] # Subsection size
 ; X86-NEXT: [[F1_START]]:
 ; X86-NEXT: .short [[PROC_SEGMENT_END:.*]]-[[PROC_SEGMENT_START:.*]] #
 ; X86-NEXT: [[PROC_SEGMENT_START]]:

 ; String table
 ; X86-NEXT: .cv_stringtable
 
 ; OBJ32:    Section {
 ; OBJ32:      Name: .debug$S (2E 64 65 62 75 67 24 53)
 ; OBJ32:      Characteristics [ (0x42300040)
 ; OBJ32:      ]
 ; OBJ32:      Relocations [
-; OBJ32-NEXT:   0x44 IMAGE_REL_I386_DIR32NB _f
-; OBJ32-NEXT:   0x90 IMAGE_REL_I386_SECREL _f
-; OBJ32-NEXT:   0x94 IMAGE_REL_I386_SECTION _f
-; OBJ32-NEXT:   0xC8 IMAGE_REL_I386_SECREL _f
-; OBJ32-NEXT:   0xCC IMAGE_REL_I386_SECTION _f
+; OBJ32-NEXT:   0x50 IMAGE_REL_I386_DIR32NB _f
+; OBJ32-NEXT:   0x9C IMAGE_REL_I386_SECREL _f
+; OBJ32-NEXT:   0xA0 IMAGE_REL_I386_SECTION _f
+; OBJ32-NEXT:   0xD4 IMAGE_REL_I386_SECREL _f
+; OBJ32-NEXT:   0xD8 IMAGE_REL_I386_SECTION _f
 ; OBJ32-NEXT: ]
 ; OBJ32:      Subsection [
 ; OBJ32-NEXT:   SubSectionType: Symbols (0xF1)
 ; OBJ32:  Compile3Sym
 ; OBJ32:      ]
 ; OBJ32:      Subsection [
 ; OBJ32-NEXT:   SubSectionType: FrameData (0xF5)
 ; OBJ32:      ]

 ; X64-LABEL: .section        .debug$S,"dr"
 ; X64-NEXT: .p2align 2
 ; X64-NEXT: .long   4
 ; Symbol subsection
 ; X64-NEXT: .long   241
 ; X64-NEXT: .long [[COMPILE_END:.*]]-[[COMPILE_START:.*]] #
 ; Compiler information record
 ; X64-NEXT: [[COMPILE_START]]:
-; X64-NEXT: .short [[C1_END:.*]]-[[C1_START:.*]] #
-; X64:      [[C1_END]]:
+; X64-NEXT: .short [[OBJNAME_END:.*]]-[[OBJNAME_START:.*]] #
+; X64:      [[OBJNAME_END]]:
+; X64-NEXT: .short [[COMPILE3_END:.*]]-[[COMPILE3_START:.*]] #
+; X64:      [[COMPILE3_END]]:
 ; X64-NEXT: [[COMPILE_END]]:
 ; X64-NEXT: .p2align  2
 ; X64-NEXT: .long 241  # Symbol subsection for f
 ; X64-NEXT: .long [[F1_END:.*]]-[[F1_START:.*]] # Subsection size
 ; X64-NEXT: [[F1_START]]:
 ; X64-NEXT: .short [[PROC_SEGMENT_END:.*]]-[[PROC_SEGMENT_START:.*]] #
 ; X64-NEXT: [[PROC_SEGMENT_START]]:
 ; X64-NEXT: .short  4423

 ; String table
 ; X64-NEXT: .cv_stringtable
 
 ; OBJ64:    Section {
 ; OBJ64:      Name: .debug$S (2E 64 65 62 75 67 24 53)
 ; OBJ64:      Characteristics [ (0x42300040)
 ; OBJ64:      ]
 ; OBJ64:      Relocations [
-; OBJ64-NEXT:   0x64 IMAGE_REL_AMD64_SECREL f
-; OBJ64-NEXT:   0x68 IMAGE_REL_AMD64_SECTION f
-; OBJ64-NEXT:   0x9C IMAGE_REL_AMD64_SECREL f
-; OBJ64-NEXT:   0xA0 IMAGE_REL_AMD64_SECTION f
+; OBJ64-NEXT:   0x70 IMAGE_REL_AMD64_SECREL f
+; OBJ64-NEXT:   0x74 IMAGE_REL_AMD64_SECTION f
+; OBJ64-NEXT:   0xA8 IMAGE_REL_AMD64_SECREL f
+; OBJ64-NEXT:   0xAC IMAGE_REL_AMD64_SECTION f
 ; OBJ64-NEXT: ]
 ; OBJ64:      Subsection [
 ; OBJ64-NEXT:   SubSectionType: Symbols (0xF1)
 ; OBJ64:        {{.*}}Proc{{.*}}Sym {
 ; OBJ64:          CodeSize: 0xE
 ; OBJ64:          DisplayName: f
 ; OBJ64:          LinkageName: f
 ; OBJ64:        }

llvm/test/DebugInfo/COFF/vframe-fpo.ll

 ; ASM-NEXT:    calll   "?g@@YAXAAH00@Z"
 
 ; CODEVIEW:      CodeViewDebugInfo [
 ; CODEVIEW-NEXT:   Section: .debug$S (4)
 ; CODEVIEW-NEXT:   Magic: 0x4
 ; CODEVIEW-NEXT:   Subsection [
 ; CODEVIEW-NEXT:     SubSectionType: Symbols (0xF1)
 ; CODEVIEW-NEXT:     SubSectionSize:
-; CODEVIEW-NEXT:     Compile3Sym {
+; CODEVIEW-NEXT:     ObjNameSym {
+; CODEVIEW-NEXT:       Kind: S_OBJNAME (0x1101)
+; CODEVIEW:          Compile3Sym {
 ; CODEVIEW-NEXT:       Kind: S_COMPILE3 (0x113C)
 ; CODEVIEW:          }
 ; CODEVIEW:        ]
 ; CODEVIEW:        Subsection [
 ; CODEVIEW-NEXT:     SubSectionType: FrameData (0xF5)
 ; CODEVIEW-NEXT:     SubSectionSize:
 ; CODEVIEW-NEXT:     LinkageName: _main
 ; CODEVIEW:          FrameData {

llvm/test/MC/AArch64/coff-debug.ll

 ; RUN: llc -mtriple=aarch64-windows -filetype=obj -o - %s | \
-; RUN: llvm-readobj --codeview - | FileCheck %s
+; RUN: llvm-readobj --codeview - | FileCheck %s --check-prefixes=CHECK,STDOUT
+; RUN: llc -mtriple=aarch64-windows -filetype=obj -o %t %s
+; RUN: llvm-readobj --codeview %t | FileCheck %s --check-prefixes=CHECK,FILE
 
 ; ModuleID = 'a.c'
 source_filename = "a.c"
 target datalayout = "e-m:w-p:64:64-i32:32-i64:64-i128:128-n32:64-S128"
 target triple = "aarch64--windows-msvc18.0.0"
 
 ; Function Attrs: noinline nounwind optnone
 define i32 @main() #0 !dbg !7 {

 ; CHECK:     Name: main
 ; CHECK:   }
 ; CHECK: ]
 ; CHECK: CodeViewDebugInfo [
 ; CHECK:   Section: .debug$S (4)
 ; CHECK:   Magic: 0x4
 ; CHECK:   Subsection [
 ; CHECK:     SubSectionType: Symbols (0xF1)
+; CHECK:     ObjNameSym {
+; CHECK:       Kind: S_OBJNAME (0x1101)
+; CHECK:       Signature: 0x0
+; CHECK:       ObjectName:
+; FILE-SAME: {{.*}}
+; CHECK:     }
 ; CHECK:     Compile3Sym {
 ; CHECK:       Kind: S_COMPILE3 (0x113C)
 ; CHECK:       Language: C (0x0)
 ; CHECK:       Flags [ (0x0)
 ; CHECK:       ]
 ; CHECK:     }
 ; CHECK:   ]
 ; CHECK:   Subsection [

llvm/test/MC/ARM/coff-debugging-secrel.ll

 ; CHECK-ITANIUM:   }
 ; CHECK-ITANIUM:   Section {{.*}}.debug_pubnames {
 ; CHECK-ITANIUM:     0x6 IMAGE_REL_ARM_SECREL .debug_info
 ; CHECK-ITANIUM:   }
 ; CHECK-ITANIUM: ]
 
 ; CHECK-MSVC: Relocations [
 ; CHECK-MSVC:   Section {{.*}} .debug$S {
-; CHECK-MSVC:     0x64 IMAGE_REL_ARM_SECREL function
-; CHECK-MSVC:     0x68 IMAGE_REL_ARM_SECTION function
-; CHECK-MSVC:     0xA0 IMAGE_REL_ARM_SECREL function
-; CHECK-MSVC:     0xA4 IMAGE_REL_ARM_SECTION function
+; CHECK-MSVC:     0x70 IMAGE_REL_ARM_SECREL function
+; CHECK-MSVC:     0x74 IMAGE_REL_ARM_SECTION function
+; CHECK-MSVC:     0xAC IMAGE_REL_ARM_SECREL function
+; CHECK-MSVC:     0xB0 IMAGE_REL_ARM_SECTION function
 ; CHECK-MSVC:   }
 ; CHECK-MSVC: ]
 

llvm/test/MC/COFF/cv-compiler-info.ll

-; RUN: llc -mtriple i686-pc-windows-msvc < %s | FileCheck %s
+; RUN: llc -mtriple i686-pc-windows-msvc < %s | FileCheck %s --check-prefixes=CHECK,STDOUT
+; RUN: llc -mtriple i686-pc-windows-msvc < %s -o %t | FileCheck %s --input-file=%t --check-prefixes=CHECK,FILE
 ; ModuleID = 'D:\src\scopes\foo.cpp'
 source_filename = "D:\5Csrc\5Cscopes\5Cfoo.cpp"
 target datalayout = "e-m:x-p:32:32-i64:64-f80:32-n8:16:32-a:0:32-S32"
 target triple = "i686-pc-windows-msvc19.0.23918"
 
 ; Function Attrs: nounwind sspstrong
 define i32 @"\01?foo@@YAHXZ"() #0 !dbg !10 {
 entry:
   ret i32 42, !dbg !14
 }
 
 attributes #0 = { nounwind sspstrong "correctly-rounded-divide-sqrt-fp-math"="false" "disable-tail-calls"="false" "less-precise-fpmad"="false" "frame-pointer"="all" "no-infs-fp-math"="false" "no-jump-tables"="false" "no-nans-fp-math"="false" "no-signed-zeros-fp-math"="false" "no-trapping-math"="false" "stack-protector-buffer-size"="8" "target-cpu"="pentium4" "target-features"="+fxsr,+mmx,+sse,+sse2,+x87" "unsafe-fp-math"="false" "use-soft-float"="false" }
 
 !llvm.dbg.cu = !{!0}
 !llvm.module.flags = !{!7, !8}
 !llvm.ident = !{!9}
 
 !0 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus, file: !1, producer: "clang version 4.0.0 ", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug, enums: !2)
 ; One .debug$S section should contain an S_COMPILE3 record that identifies the
 ; source language and the version of the compiler based on the DICompileUnit.
 ; CHECK:  .section  .debug$S,"dr"
+; CHECK:        .short  4353                    # Record kind: S_OBJNAME
+; CHECK-NEXT:   .long   0                       # Signature
+; STDOUT-NEXT:  .byte   0                       # Object name
+; FILE-NEXT:    .asciz  "{{.*}}{{\\\\|/}}cv-compiler-info.ll.tmp" # Object name
 ; CHECK:    .short  4412                  # Record kind: S_COMPILE3
-; CHECK:    .long 1                       # Flags and language
-; CHECK:    .short  7                     # CPUType
-; CHECK:    .short  4                     # Frontend version
-; CHECK:    .short  0
-; CHECK:    .short  0
-; CHECK:    .short  0
-; CHECK:    .short  [[BACKEND_VERSION:[0-9]+]]  # Backend version
-; CHECK:    .short  0
-; CHECK:    .short  0
-; CHECK:    .short  0
-; CHECK:    .asciz  "clang version 4.0.0 "  # Null-terminated compiler version string
-; CHECK-NOT: .short 4412                  # Record kind: S_COMPILE3
+; CHECK-NEXT:   .long 1                       # Flags and language
+; CHECK-NEXT:   .short  7                     # CPUType
+; CHECK-NEXT:   .short  4                     # Frontend version
+; CHECK-NEXT:   .short  0
+; CHECK-NEXT:   .short  0
+; CHECK-NEXT:   .short  0
+; CHECK-NEXT:   .short  [[BACKEND_VERSION:[0-9]+]]  # Backend version
+; CHECK-NEXT:   .short  0
+; CHECK-NEXT:   .short  0
+; CHECK-NEXT:   .short  0
+; CHECK-NEXT:   .asciz  "clang version 4.0.0 "  # Null-terminated compiler version string
+; CHECK-NOT:    .short  4412                  # Record kind: S_COMPILE3
 !1 = !DIFile(filename: "D:\5Csrc\5Cscopes\5Cfoo.cpp", directory: "D:\5Csrc\5Cscopes\5Cclang")
 !2 = !{}
 !7 = !{i32 2, !"CodeView", i32 1}
 !8 = !{i32 2, !"Debug Info Version", i32 3}
 !9 = !{!"clang version 4.0.0 "}
 !10 = distinct !DISubprogram(name: "foo", linkageName: "\01?foo@@YAHXZ", scope: !1, file: !1, line: 1, type: !11, isLocal: false, isDefinition: true, scopeLine: 1, flags: DIFlagPrototyped, isOptimized: false, unit: !0, retainedNodes: !2)
 !11 = !DISubroutineType(types: !12)
 !12 = !{!13}
 !13 = !DIBasicType(name: "int", size: 32, align: 32, encoding: DW_ATE_signed)
 !14 = !DILocation(line: 2, scope: !10)

llvm/tools/llc/llc.cpp

static int compileModule(char **argv, LLVMContext &Context) {
   if (codegen::getFloatABIForCalls() != FloatABI::Default)
     Options.FloatABIType = codegen::getFloatABIForCalls();
 
   // Figure out where we are going to send the output.
   std::unique_ptr<ToolOutputFile> Out =
       GetOutputStream(TheTarget->getName(), TheTriple.getOS(), argv[0]);
   if (!Out) return 1;
 
+  // Ensure the filename is passed down to CodeViewDebug.
+  Target->Options.MCOptions.OutputPathName = Out->outputFilename();
+
   std::unique_ptr<ToolOutputFile> DwoOut;
   if (!SplitDwarfOutputFile.empty()) {
     std::error_code EC;
     DwoOut = std::make_unique<ToolOutputFile>(SplitDwarfOutputFile, EC,
                                                sys::fs::OF_None);
     if (EC) {
       WithColor::error(errs(), argv[0]) << EC.message() << '\n';
       return 1;

llvm/tools/llvm-lto2/llvm-lto2.cpp

static int run(int argc, char **argv) {
 
   auto AddStream =
       [&](size_t Task) -> std::unique_ptr<lto::NativeObjectStream> {
     std::string Path = OutputFilename + "." + utostr(Task);
 
     std::error_code EC;
     auto S = std::make_unique<raw_fd_ostream>(Path, EC, sys::fs::OF_None);
     check(EC, Path);
-    return std::make_unique<lto::NativeObjectStream>(std::move(S));
+    return std::make_unique<lto::NativeObjectStream>(std::move(S), Path);
   };
 
   auto AddBuffer = [&](size_t Task, std::unique_ptr<MemoryBuffer> MB) {
     *AddStream(Task)->OS << MB->getBuffer();
   };
 
   NativeObjectCache Cache;
   if (!CacheDir.empty())