Change debug-info-for-profiling from a TargetOption to a function attribute.

[danielcdh]

Summary

LTO requires the debug-info-for-profiling to be a function attribute.

[ahatanak]

lib/CodeGen/AsmPrinter/DwarfDebug.cpp

1136

Is debug-info-for-profiling used to turn on and off debug info for profiling on a per-function basis? I'm not very familiar with this function, but it looks like HasDebugInfoForProfiling is initialized to false in the constructor and then it will always be true after beginFunction is called on a function that has attribute debug-info-for-profiling=true.

[mehdi_amini]

include/llvm/IR/Attributes.td

182 ↗

(On Diff #85982)

That'll be long in the IR, where there is already a long list, what about "prof-dbg-info" or something like that that would make sense?

lib/CodeGen/AsmPrinter/DwarfDebug.cpp

1136

Yep that seems broken to me. If foo has the attribute and not bar, we'll emit the profiling debug info for bar if foo is processed first.

[danielcdh]

lib/CodeGen/AsmPrinter/DwarfDebug.cpp

1136

The issue is that I cannot check for function's attributes in DwarfUnit::applySubprogramAttributes, any suggestions on how I can pass down this attribute to that function?

[mehdi_amini]

lib/CodeGen/AsmPrinter/DwarfDebug.cpp

1136

Why not do here HasDebugInfoForProfiling = MF->getFunction()->debugInfoForProfiling(); ?

[probinson]

Is there a reason to make this a function attribute rather than a flag carried in the metadata? Having something related to debug info as an attribute seems odd.

test/DebugInfo/Inputs/gmlt_profiling.ll

5 ↗

(On Diff #85982)

f2() does not appear in any checks and is not used anywhere else in the test. Why is it here?

7 ↗

(On Diff #85982)

f3() and f4() do not appear in any checks, why are they here?

14 ↗

(On Diff #85982)

Writing checks for dwarfdump output is tricky because you're really trying to match several attribute lines within the same DWARF entry. So here you want something like this:

CHECK: DW_TAG_subprogram
CHECK-NOT: {{DW_TAG|NULL}}
CHECK: DW_AT_name {{.*}} "f1"
CHECK-NEXT: DW_AT_decl_file
CHECK-NEXT: DW_AT_decl_line

This assumes that name/file/line appear in that exact sequence, but there are lots of debug-info tests with that kind of assumption. Unless/until we get a fancier debug-info matcher this is the kind of thing we have to do.

43 ↗

(On Diff #85982)

Generally we encourage people to remove attributes that aren't relevant or necessary to the test. Here, probably only "debug-info-for-profiling" is the relevant one? Removing the others helps clarify what the test is about.

[danielcdh]

lib/CodeGen/AsmPrinter/DwarfDebug.cpp

1136

Because the llvm::DwarfDebug::beginFunction is called first before llvm::DwarfUnit::applySubprogramAttributes are called.

E.g. you have f1, f2, f3

the call sequence is:
beginFunction(f1)
beginFunction(f2)
beginFunction(f3)
applySubprogramAttributes(subprogramof_f1)
applySubprogramAttributes(subprogramof_f2)
applySubprogramAttributes(subprogramof_f3)

The current logic is, if there is any function that has HasDebugInfoForProfiling=true, then all function will have it.

[probinson]

lib/CodeGen/AsmPrinter/DwarfDebug.cpp

1136

All the more reason to put it at module or CU level, rather than function level.

[mehdi_amini]

lib/CodeGen/AsmPrinter/DwarfDebug.cpp

1136

If the behavior you want is to have it enabled for the module, then yes like @probinson says a module level construct would make more sense.

I don't enough about -gmlt to know what we would expect if we have a.cpp and b.cpp and we build with LTO one with -g and the other one with -gmlt ?

[danielcdh]

change to use module flags.

[danielcdh]

lib/CodeGen/AsmPrinter/DwarfDebug.cpp

1136

Updated to use module flag for this.

test/DebugInfo/Inputs/gmlt_profiling.ll

14 ↗

(On Diff #85982)

Done, but the CHECK-NOT cannot be used because we have DW_AT_low_pc and DW_AT_high_pc in between.

[mehdi_amini]

lib/CodeGen/AsmPrinter/DwarfDebug.cpp

1136

Can you clarify what is the behavior in this case:

what we would expect if we have a.cpp and b.cpp and we build with LTO one with -g and the other one with -gmlt ?

[danielcdh]

lib/CodeGen/AsmPrinter/DwarfDebug.cpp

1136

I am not debug info expert, Eric may have more accurate answer.

My understanding is that one will have more debug info emitted, the other will only have line table emitted. What will happen in LTO?

[mehdi_amini]

lib/CodeGen/AsmPrinter/DwarfDebug.cpp

1136

I'm asking because I haven ming that of DebugInfoForProfiling will be enabled by -gmlt, but that may not be true? If so when/how is DebugInfoForProfiling set?

[danielcdh]

lib/CodeGen/AsmPrinter/DwarfDebug.cpp

1136

It will be set with -fdebug-info-for-profiling.

A follow-up cfe patch is in: https://reviews.llvm.org/D29205

[mehdi_amini]

lib/CodeGen/AsmPrinter/DwarfDebug.cpp

1136

Ok so back to my question:

what we would expect if we have a.cpp and b.cpp and we build with LTO one with -g and the other one with -fdebug-info-for-profiling? How does your module flag affect that?

[danielcdh]

lib/CodeGen/AsmPrinter/DwarfDebug.cpp

1136

-fdebug-info-for-profiling is orthogonal with -g/-gmlt. So I guess the question should be:

what we would expect if we have a.cpp and b.cpp and we build with LTO, a.cpp with -fdebug-info-for-profiling and b.cpp without the flag? How does your module flag affect that?

The answer is

• a.cpp will have the flag and thus all the logic guarded by this flag in backend will be executed.
• b.cpp will not have it and will not have related code executed.
• If some functions are imported from b.cpp to a.cpp, it will inherit the flag from a.cpp thus have related code executed.
• If some functions are imported from a.cpp to c.cpp, it will inherit the flag from b.cpp thus not have related code executed.

I guess this also applies to the cases that a.cpp is built with -g and b.cpp is built with -gmlt.

[mehdi_amini]

lib/CodeGen/AsmPrinter/DwarfDebug.cpp

1136

During Monolithic LTO, the two files are *merged*. There is a single CodeGen happening.

I'm still trying to figure out what is the impact of If some functions are imported from b.cpp to a.cpp, it will inherit the flag from a.cpp thus have related code executed, because I don't know enough about -fdebug-info-for-profiling.

I think I originally misread this comment:

// Under -gmlt, skip building the subprogram if there are no inlined
// subroutines inside it. But with -fdebug-info-for-profiling, the subprogram
// is still needed as we need its source location.

If I understand correctly, the module flag would make the debug info emission more conservative. Does it mean that adding -fdebug-info-for-profiling with -g does not have any effect on the Dwarf emission? It is only in effect with DICompileUnit::LineTablesOnly?

[danielcdh]

lib/CodeGen/AsmPrinter/DwarfDebug.cpp

1136

-fdebug-info-for-profiling has the following implication:

1. emit extra subprogram info (e.g. decl_line) even with -gmlt
2. emit discriminator and encode optimization effects to discriminator.

For #1, -g also emits these extra info, thus it only applies to -gmlt
For #2, which is under review in https://reviews.llvm.org/D26420, it applies to both -g and -gmlt builds.

[mehdi_amini]

lib/CodeGen/AsmPrinter/DwarfDebug.cpp

1136

Thanks for the explanation!
With this I'm fine with the module flag.

If @probinson does not have any other comment that LGTM.

[probinson]

Regarding the mixed-mode LTO question, my understanding is that if we have a module-level flag then it would apply to everything in the merged module. The merged module will still have debug info organized per original compilation unit. So, if we have a per-CU flag and compiled flag-on.cpp and flag-off.cpp, then functions from flag-on.cpp would get the extra info and functions from flag-off.cpp would not, with the caveat that if you inline a function across compilation units, then the flag from the CU for the caller would apply.

I believe we have a module flag here, so the entire module would be treated as if -fdebug-info-for-profiling had been turned on for all CUs.

(Did I get that right?)

test/DebugInfo/Inputs/gmlt_profiling.ll

14 ↗

(On Diff #85982)

The CHECK-NOT should not match a DW_AT line. You need it to ensure that the attributes belong to the same TAG that you found.

[danielcdh]

After a lengthy discussion with @dblaikie (Thanks David for the input), let me add some more context to this patch.

• What is the impact of adding -fdebug-info-for-profiling
  • It will not affect the generated code
  • It will increase the debug info size in -gmlt by ~17%
  • It will not increase the debug info size in -g binary
  • The compile time change should be negligible

• What we use a binary built with out -fdebug-info-for-profiling to collect profile
  • The profile will be inaccurate and will yield sub-optimal performance when used to drive SamplePGO

• What is the motivating example that you want to compile some sources with -fdebug-info-for-profiling and some without
  • If the debug info size is a concern for -gmlt binary, then one would want to only enable this flag for sources that is performance-critical

[danielcdh]

In D29203#658981, @probinson wrote:

Regarding the mixed-mode LTO question, my understanding is that if we have a module-level flag then it would apply to everything in the merged module. The merged module will still have debug info organized per original compilation unit. So, if we have a per-CU flag and compiled flag-on.cpp and flag-off.cpp, then functions from flag-on.cpp would get the extra info and functions from flag-off.cpp would not, with the caveat that if you inline a function across compilation units, then the flag from the CU for the caller would apply.

I believe we have a module flag here, so the entire module would be treated as if -fdebug-info-for-profiling had been turned on for all CUs.

I think you are right. If we always emit this module flag (with value 0 or 1), when there are some CUs built with this flag, and some CUs without, in LTO, it will emit a warning and turn this flag on for all CUs.

Dehao

(Did I get that right?)

[mehdi_amini]

In D29203#658997, @danielcdh wrote:

• What is the motivating example that you want to compile some sources with -fdebug-info-for-profiling and some without
  • If the debug info size is a concern for -gmlt binary, then one would want to only enable this flag for sources that is performance-critical

This is an argument *against* a module flag.

[danielcdh]

In D29203#659019, @mehdi_amini wrote:

In D29203#658997, @danielcdh wrote:

• What is the motivating example that you want to compile some sources with -fdebug-info-for-profiling and some without
  • If the debug info size is a concern for -gmlt binary, then one would want to only enable this flag for sources that is performance-critical

This is an argument *against* a module flag.

Right ;-) I think I need to raise the point before close the patch.

But my opinion is that this use cases (if any) would be rare because:

• 17% seem small, but people may have other opinions
• adding per-CU flag is manual and tedious
• per-CU flag may need to change as new source coming in/old source change that updates the hot CU distribution

That being said, I would think it's better to force this flag in LTO when mixed flag situation happens. But will let upstream decide if this would be a feature or a bug.

Thanks,
Dehao

[danielcdh]

Change to use DICompileUnit to pass down the flag.

[probinson]

test/DebugInfo/Inputs/gmlt_profiling.ll

7 ↗

(On Diff #86117)

The CHECK-NOT needs to go before DW_AT_name.
You are using CHECK-NEXT to guarantee that decl_file and decl_line are in the same tag as DW_AT_name.

[dblaikie]

include/llvm/IR/DebugInfoMetadata.h

1140–1142

I don't think this accessor is needed

lib/CodeGen/AsmPrinter/DwarfDebug.h

266–268 ↗

(On Diff #86117)

Presumably this (& the accessor below) can be removed now?

lib/IR/Module.cpp

468–475 ↗

(On Diff #86117)

Presumably this should go away now that it's in the CU metadata.

test/DebugInfo/Generic/gmlt.test

0

This line should probably be in gmlt_profiling.ll

0

This line should probably be in gmlt.ll (both gmlt.ll and gmlt_profiling.ll would move from test/DebugInfo/Inputs to test/DebugInfo/Generic)

[danielcdh]

update also remove TargetOption.DebugInfoForProfiling.

[aprantl]

I didn't see a binary bitcode upgrade testcase — could you please add one?

[aprantl]

include/llvm/IR/DIBuilder.h

107–110

Missing doxygen for the new(er) flag(s).

[aprantl]

It might also be a good idea to document the purpose of the flag in SourceLevelDebugging.rst,

[danielcdh]

Add bitcode test.

[danielcdh]

update doxygen.

[danielcdh]

In D29203#659334, @aprantl wrote:

It might also be a good idea to document the purpose of the flag in SourceLevelDebugging.rst,

Could you help suggest which section I should add related doc? I think it would be good to add to the doc that introduces different debug level, but seems no such content exists in the current doc.

[aprantl]

That document clearly needs a some love :-)
I would suggest adding a new Compile Unit section to either of the two Debugging information format sections (which should be merged) and adding a stub about global (compile-unit-wide) flags that influence the DWARF/CodeView debug info generator.

[danielcdh]

In D29203#659527, @aprantl wrote:

That document clearly needs a some love :-)
I would suggest adding a new Compile Unit section to either of the two Debugging information format sections (which should be merged) and adding a stub about global (compile-unit-wide) flags that influence the DWARF/CodeView debug info generator.

Sounds reasonable. But that seems quite some extra work that is outside the scope of this patch. Shall we start a separate thread to improve the documentation of the debug info?

[aprantl]

Works for me.

[aprantl]

Commented on bitcode test

test/Bitcode/upgrade-debug-info-for-profiling.ll

5

This probably isn't necessary.

14

Perhaps I'm confused about what this is testing*, but shouldn't the default be debugInfoForProfiling: false?

*) I was expecting a DICompilieUnit produced by today's trunk without a bitcode record for the new flag, so we can verify that the old bitcode format is updated correctly.

[danielcdh]

update upgrading test

[danielcdh]

test/Bitcode/upgrade-debug-info-for-profiling.ll

14

Not sure if I understand what to test in this upgrade test.

What I did here:

1. build the .ll file with the current trunk without this patch to produce the .bc file
2. check "debugInfoForProfiling: true" does *not* exists in the llvm-dis output.

Am I doing the right thing?

[aprantl]

I added one comment to the testcase, otherwise this is fine now.

test/Bitcode/upgrade-debug-info-for-profiling.ll

8

Ah I didn't see the -NOT.
It is better to write this as
CHECK: DICompileUnit(language: DW_LANG_C99, file: !{{[0-9]+]], emissionKind: FullDebug)
otherwise /bin/true would also pass this test.

[danielcdh]

update

[dblaikie]

Looks good

[danielcdh]

update a test to point to the correct location.

[dlj]

test/DebugInfo/Generic/gmlt.test

0

Moving this file to Generic/ means that other tests (notably, under X86/) now use files not within their Inputs, or within their parents' Inputs. Was that the intent of this comment?

[danielcdh]

This change was addressing one of the review comments.

test/DebugInfo/X86/gmlt.test do now depends on the input file from test/DebugInfo/Generic/gmlt.ll. If this is an issue, I can send another patch to move gmlt.ll back to test/DebugInfo/Input and add test/DebugInfo/Generic/gmlt.test back.

[danielcdh]

updated in r293852

[danielcdh]

I should have discovered the breaking x86 version of the test earlier...

Thanks for the reviews!

include/llvm/IR/DIBuilder.h

public:
     ///                      string is directly embedded in debug info
     ///                      output which may be used by a tool
     ///                      analyzing generated debugging information.
     /// \param RV            This indicates runtime version for languages like
     ///                      Objective-C.
     /// \param SplitName     The name of the file that we'll split debug info
     ///                      out into.
     /// \param Kind          The kind of debug information to generate.
     /// \param DWOId         The DWOId if this is a split skeleton compile unit.
+    /// \param SplitDebugInlining    Whether to emit inline debug info.
+    /// \param DebugInfoFOrProfiling Whether to emit extra debug info for
+    ///                              profile collection.
     DICompileUnit *
     createCompileUnit(unsigned Lang, DIFile *File, StringRef Producer,
                       bool isOptimized, StringRef Flags, unsigned RV,
                       StringRef SplitName = StringRef(),
                       DICompileUnit::DebugEmissionKind Kind =
                           DICompileUnit::DebugEmissionKind::FullDebug,
-                      uint64_t DWOId = 0, bool SplitDebugInlining = true);
+                      uint64_t DWOId = 0, bool SplitDebugInlining = true,
+                      bool DebugInfoForProfiling = false);
 
     /// Create a file descriptor to hold debugging information for a file.
     /// \param Filename  File name.
     /// \param Directory Directory.
     /// \param CSKind    Checksum kind (e.g. CSK_None, CSK_MD5, CSK_SHA1, etc.).
     /// \param Checksum  Checksum data.
     DIFile *createFile(StringRef Filename, StringRef Directory,
                        DIFile::ChecksumKind CSKind = DIFile::CSK_None,

include/llvm/IR/DebugInfoMetadata.h

 
 private:
   unsigned SourceLanguage;
   bool IsOptimized;
   unsigned RuntimeVersion;
   unsigned EmissionKind;
   uint64_t DWOId;
   bool SplitDebugInlining;
+  bool DebugInfoForProfiling;
 
   DICompileUnit(LLVMContext &C, StorageType Storage, unsigned SourceLanguage,
                 bool IsOptimized, unsigned RuntimeVersion,
                 unsigned EmissionKind, uint64_t DWOId, bool SplitDebugInlining,
-                ArrayRef<Metadata *> Ops)
+                bool DebugInfoForProfiling, ArrayRef<Metadata *> Ops)
       : DIScope(C, DICompileUnitKind, Storage, dwarf::DW_TAG_compile_unit, Ops),
         SourceLanguage(SourceLanguage), IsOptimized(IsOptimized),
         RuntimeVersion(RuntimeVersion), EmissionKind(EmissionKind),
-        DWOId(DWOId), SplitDebugInlining(SplitDebugInlining) {
+        DWOId(DWOId), SplitDebugInlining(SplitDebugInlining),
+        DebugInfoForProfiling(DebugInfoForProfiling) {
     assert(Storage != Uniqued);
   }
   ~DICompileUnit() = default;
 
   static DICompileUnit *
   getImpl(LLVMContext &Context, unsigned SourceLanguage, DIFile *File,
           StringRef Producer, bool IsOptimized, StringRef Flags,
           unsigned RuntimeVersion, StringRef SplitDebugFilename,
           unsigned EmissionKind, DICompositeTypeArray EnumTypes,
           DIScopeArray RetainedTypes,
           DIGlobalVariableExpressionArray GlobalVariables,
           DIImportedEntityArray ImportedEntities, DIMacroNodeArray Macros,
-          uint64_t DWOId, bool SplitDebugInlining, StorageType Storage,
-          bool ShouldCreate = true) {
+          uint64_t DWOId, bool SplitDebugInlining, bool DebugInfoForProfiling,
+          StorageType Storage, bool ShouldCreate = true) {
     return getImpl(Context, SourceLanguage, File,
                    getCanonicalMDString(Context, Producer), IsOptimized,
                    getCanonicalMDString(Context, Flags), RuntimeVersion,
                    getCanonicalMDString(Context, SplitDebugFilename),
                    EmissionKind, EnumTypes.get(), RetainedTypes.get(),
                    GlobalVariables.get(), ImportedEntities.get(), Macros.get(),
-                   DWOId, SplitDebugInlining, Storage, ShouldCreate);
+                   DWOId, SplitDebugInlining, DebugInfoForProfiling, Storage,
+                   ShouldCreate);
   }
   static DICompileUnit *
   getImpl(LLVMContext &Context, unsigned SourceLanguage, Metadata *File,
           MDString *Producer, bool IsOptimized, MDString *Flags,
           unsigned RuntimeVersion, MDString *SplitDebugFilename,
           unsigned EmissionKind, Metadata *EnumTypes, Metadata *RetainedTypes,
           Metadata *GlobalVariables, Metadata *ImportedEntities,
           Metadata *Macros, uint64_t DWOId, bool SplitDebugInlining,
-          StorageType Storage, bool ShouldCreate = true);
+          bool DebugInfoForProfiling, StorageType Storage,
+          bool ShouldCreate = true);
 
   TempDICompileUnit cloneImpl() const {
     return getTemporary(getContext(), getSourceLanguage(), getFile(),
                         getProducer(), isOptimized(), getFlags(),
                         getRuntimeVersion(), getSplitDebugFilename(),
                         getEmissionKind(), getEnumTypes(), getRetainedTypes(),
                         getGlobalVariables(), getImportedEntities(),
-                        getMacros(), DWOId, getSplitDebugInlining());
+                        getMacros(), DWOId, getSplitDebugInlining(),
+                        getDebugInfoForProfiling());
   }
 
 public:
   static void get() = delete;
   static void getIfExists() = delete;
 
   DEFINE_MDNODE_GET_DISTINCT_TEMPORARY(
       DICompileUnit,
       (unsigned SourceLanguage, DIFile *File, StringRef Producer,
        bool IsOptimized, StringRef Flags, unsigned RuntimeVersion,
        StringRef SplitDebugFilename, DebugEmissionKind EmissionKind,
        DICompositeTypeArray EnumTypes, DIScopeArray RetainedTypes,
        DIGlobalVariableExpressionArray GlobalVariables,
        DIImportedEntityArray ImportedEntities, DIMacroNodeArray Macros,
-       uint64_t DWOId, bool SplitDebugInlining),
+       uint64_t DWOId, bool SplitDebugInlining, bool DebugInfoForProfiling),
       (SourceLanguage, File, Producer, IsOptimized, Flags, RuntimeVersion,
        SplitDebugFilename, EmissionKind, EnumTypes, RetainedTypes,
-       GlobalVariables, ImportedEntities, Macros, DWOId, SplitDebugInlining))
+       GlobalVariables, ImportedEntities, Macros, DWOId, SplitDebugInlining,
+       DebugInfoForProfiling))
   DEFINE_MDNODE_GET_DISTINCT_TEMPORARY(
       DICompileUnit,
       (unsigned SourceLanguage, Metadata *File, MDString *Producer,
        bool IsOptimized, MDString *Flags, unsigned RuntimeVersion,
        MDString *SplitDebugFilename, unsigned EmissionKind, Metadata *EnumTypes,
        Metadata *RetainedTypes, Metadata *GlobalVariables,
        Metadata *ImportedEntities, Metadata *Macros, uint64_t DWOId,
-       bool SplitDebugInlining),
+       bool SplitDebugInlining, bool DebugInfoForProfiling),
       (SourceLanguage, File, Producer, IsOptimized, Flags, RuntimeVersion,
        SplitDebugFilename, EmissionKind, EnumTypes, RetainedTypes,
-       GlobalVariables, ImportedEntities, Macros, DWOId, SplitDebugInlining))
+       GlobalVariables, ImportedEntities, Macros, DWOId, SplitDebugInlining,
+       DebugInfoForProfiling))
 
   TempDICompileUnit clone() const { return cloneImpl(); }
 
   unsigned getSourceLanguage() const { return SourceLanguage; }
   bool isOptimized() const { return IsOptimized; }
   unsigned getRuntimeVersion() const { return RuntimeVersion; }
   DebugEmissionKind getEmissionKind() const {
     return (DebugEmissionKind)EmissionKind;
   }
+  bool getDebugInfoForProfiling() const { return DebugInfoForProfiling; }
   StringRef getProducer() const { return getStringOperand(1); }
   StringRef getFlags() const { return getStringOperand(2); }
   StringRef getSplitDebugFilename() const { return getStringOperand(3); }
   DICompositeTypeArray getEnumTypes() const {
     return cast_or_null<MDTuple>(getRawEnumTypes());
   }
   DIScopeArray getRetainedTypes() const {
     return cast_or_null<MDTuple>(getRawRetainedTypes());
   }
   DIGlobalVariableExpressionArray getGlobalVariables() const {
     return cast_or_null<MDTuple>(getRawGlobalVariables());

include/llvm/Target/TargetOptions.h

TargetOptions()
           UnsafeFPMath(false), NoInfsFPMath(false), NoNaNsFPMath(false),
           NoTrappingFPMath(false),
           HonorSignDependentRoundingFPMathOption(false), NoZerosInBSS(false),
           GuaranteedTailCallOpt(false), StackAlignmentOverride(0),
           StackSymbolOrdering(true), EnableFastISel(false), UseInitArray(false),
           DisableIntegratedAS(false), CompressDebugSections(false),
           RelaxELFRelocations(false), FunctionSections(false),
           DataSections(false), UniqueSectionNames(true), TrapUnreachable(false),
-          EmulatedTLS(false), EnableIPRA(false), DebugInfoForProfiling(false),
+          EmulatedTLS(false), EnableIPRA(false),
           FloatABIType(FloatABI::Default),
           AllowFPOpFusion(FPOpFusion::Standard),
           ThreadModel(ThreadModel::POSIX),
           EABIVersion(EABI::Default), DebuggerTuning(DebuggerKind::Default),
           FPDenormalMode(FPDenormal::IEEE),
           ExceptionModel(ExceptionHandling::None) {}
 
     /// PrintMachineCode - This flag is enabled when the -print-machineinstrs
public:
 
     /// EmulatedTLS - This flag enables emulated TLS model, using emutls
     /// function in the runtime library..
     unsigned EmulatedTLS : 1;
 
     /// This flag enables InterProcedural Register Allocation (IPRA).
     unsigned EnableIPRA : 1;
 
-    /// This flag enables emitting extra debug info for sample profiling.
-    unsigned DebugInfoForProfiling : 1;
-
     /// FloatABIType - This setting is set by -float-abi=xxx option is specfied
     /// on the command line. This setting may either be Default, Soft, or Hard.
     /// Default selects the target's default behavior. Soft selects the ABI for
     /// software floating point, but does not indicate that FP hardware may not
     /// be used. Such a combination is unfortunately popular (e.g.
     /// arm-apple-darwin). Hard presumes that the normal FP ABI is used.
     FloatABI::ABIType FloatABIType;
 
return
     ARE_EQUAL(FloatABIType) &&
     ARE_EQUAL(AllowFPOpFusion) &&
     ARE_EQUAL(ThreadModel) &&
     ARE_EQUAL(EABIVersion) &&
     ARE_EQUAL(DebuggerTuning) &&
     ARE_EQUAL(FPDenormalMode) &&
     ARE_EQUAL(ExceptionModel) &&
     ARE_EQUAL(MCOptions) &&
-    ARE_EQUAL(EnableIPRA) &&
-    ARE_EQUAL(DebugInfoForProfiling);
+    ARE_EQUAL(EnableIPRA);
 #undef ARE_EQUAL
 }
 
 inline bool operator!=(const TargetOptions &LHS,
                        const TargetOptions &RHS) {
   return !(LHS == RHS);
 }
 
 } // End llvm namespace
 
 #endif

lib/AsmParser/LLParser.cpp

#define VISIT_MD_FIELDS(OPTIONAL, REQUIRED)                                    \
   OPTIONAL(splitDebugFilename, MDStringField, );                               \
   OPTIONAL(emissionKind, EmissionKindField, );                                 \
   OPTIONAL(enums, MDField, );                                                  \
   OPTIONAL(retainedTypes, MDField, );                                          \
   OPTIONAL(globals, MDField, );                                                \
   OPTIONAL(imports, MDField, );                                                \
   OPTIONAL(macros, MDField, );                                                 \
   OPTIONAL(dwoId, MDUnsignedField, );                                          \
-  OPTIONAL(splitDebugInlining, MDBoolField, = true);
+  OPTIONAL(splitDebugInlining, MDBoolField, = true);                           \
+  OPTIONAL(debugInfoForProfiling, MDBoolField, = false);
   PARSE_MD_FIELDS();
 #undef VISIT_MD_FIELDS
 
   Result = DICompileUnit::getDistinct(
       Context, language.Val, file.Val, producer.Val, isOptimized.Val, flags.Val,
       runtimeVersion.Val, splitDebugFilename.Val, emissionKind.Val, enums.Val,
       retainedTypes.Val, globals.Val, imports.Val, macros.Val, dwoId.Val,
-      splitDebugInlining.Val);
+      splitDebugInlining.Val, debugInfoForProfiling.Val);
   return false;
 }
 
 /// ParseDISubprogram:
 ///   ::= !DISubprogram(scope: !0, name: "foo", linkageName: "_Zfoo",
 ///                     file: !1, line: 7, type: !2, isLocal: false,
 ///                     isDefinition: true, scopeLine: 8, containingType: !3,
 ///                     virtuality: DW_VIRTUALTIY_pure_virtual,

lib/Bitcode/Reader/MetadataLoader.cpp

MetadataList.assignValue(
             (Context, getMDString(Record[1]), getMDString(Record[2]),
              Record.size() == 3 ? DIFile::CSK_None
                                 : static_cast<DIFile::ChecksumKind>(Record[3]),
              Record.size() == 3 ? nullptr : getMDString(Record[4]))),
         NextMetadataNo++);
     break;
   }
   case bitc::METADATA_COMPILE_UNIT: {
-    if (Record.size() < 14 || Record.size() > 17)
+    if (Record.size() < 14 || Record.size() > 18)
       return error("Invalid record");
 
     // Ignore Record[0], which indicates whether this compile unit is
     // distinct.  It's always distinct.
     IsDistinct = true;
     auto *CU = DICompileUnit::getDistinct(
         Context, Record[1], getMDOrNull(Record[2]), getMDString(Record[3]),
         Record[4], getMDString(Record[5]), Record[6], getMDString(Record[7]),
         Record[8], getMDOrNull(Record[9]), getMDOrNull(Record[10]),
         getMDOrNull(Record[12]), getMDOrNull(Record[13]),
         Record.size() <= 15 ? nullptr : getMDOrNull(Record[15]),
         Record.size() <= 14 ? 0 : Record[14],
-        Record.size() <= 16 ? true : Record[16]);
+        Record.size() <= 16 ? true : Record[16],
+        Record.size() <= 17 ? false : Record[17]);
 
     MetadataList.assignValue(CU, NextMetadataNo++);
 
     // Move the Upgrade the list of subprograms.
     if (Metadata *SPs = getMDOrNullWithoutPlaceholders(Record[11]))
       CUSubprograms.push_back({CU, SPs});
     break;
   }

lib/Bitcode/Writer/BitcodeWriter.cpp

void ModuleBitcodeWriter::writeDICompileUnit(const DICompileUnit *N,
   Record.push_back(VE.getMetadataOrNullID(N->getEnumTypes().get()));
   Record.push_back(VE.getMetadataOrNullID(N->getRetainedTypes().get()));
   Record.push_back(/* subprograms */ 0);
   Record.push_back(VE.getMetadataOrNullID(N->getGlobalVariables().get()));
   Record.push_back(VE.getMetadataOrNullID(N->getImportedEntities().get()));
   Record.push_back(N->getDWOId());
   Record.push_back(VE.getMetadataOrNullID(N->getMacros().get()));
   Record.push_back(N->getSplitDebugInlining());
+  Record.push_back(N->getDebugInfoForProfiling());
 
   Stream.EmitRecord(bitc::METADATA_COMPILE_UNIT, Record, Abbrev);
   Record.clear();
 }
 
 void ModuleBitcodeWriter::writeDISubprogram(const DISubprogram *N,
                                             SmallVectorImpl<uint64_t> &Record,
                                             unsigned Abbrev) {

lib/CodeGen/AsmPrinter/DwarfDebug.cpp

 
 // Gather pre-function debug information.  Assumes being called immediately
 // after the function entry point has been emitted.
 void DwarfDebug::beginFunction(const MachineFunction *MF) {
   CurFn = MF;
 
   // If there's no debug info for the function we're not going to do anything.
   if (!MMI->hasDebugInfo())
     return;
 
   auto DI = MF->getFunction()->getSubprogram();
   if (!DI)
     return;
 
   // Grab the lexical scopes for the function, if we don't have any of those
   // then we're not going to be able to do anything.
   DebugHandlerBase::beginFunction(MF);
void DwarfDebug::endFunction(const MachineFunction *MF) {
   collectVariableInfo(TheCU, SP, ProcessedVars);
 
   // Add the range of this function to the list of ranges for the CU.
   TheCU.addRange(RangeSpan(Asm->getFunctionBegin(), Asm->getFunctionEnd()));
 
   // Under -gmlt, skip building the subprogram if there are no inlined
   // subroutines inside it. But with -fdebug-info-for-profiling, the subprogram
   // is still needed as we need its source location.
-  if (!Asm->TM.Options.DebugInfoForProfiling &&
+  if (!TheCU.getCUNode()->getDebugInfoForProfiling() &&
       TheCU.getCUNode()->getEmissionKind() == DICompileUnit::LineTablesOnly &&
       LScopes.getAbstractScopesList().empty() && !IsDarwin) {
     assert(InfoHolder.getScopeVariables().empty());
     assert(DbgValues.empty());
     // FIXME: This wouldn't be true in LTO with a -g (with inlining) CU followed
     // by a -gmlt CU. Add a test and remove this assertion.
     assert(AbstractVariables.empty());
     PrevLabel = nullptr;

lib/CodeGen/AsmPrinter/DwarfUnit.cpp

bool DwarfUnit::applySubprogramDefinitionAttributes(const DISubprogram *SP,
   return true;
 }
 
 void DwarfUnit::applySubprogramAttributes(const DISubprogram *SP, DIE &SPDie,
                                           bool SkipSPAttributes) {
   // If -fdebug-info-for-profiling is enabled, need to emit the subprogram
   // and its source location.
   bool SkipSPSourceLocation = SkipSPAttributes &&
-                              !Asm->TM.Options.DebugInfoForProfiling;
+                              !CUNode->getDebugInfoForProfiling();
   if (!SkipSPSourceLocation)
     if (applySubprogramDefinitionAttributes(SP, SPDie))
       return;
 
   // Constructors and operators for anonymous aggregates do not have names.
   if (!SP->getName().empty())
     addString(SPDie, dwarf::DW_AT_name, SP->getName());
 

lib/IR/AsmWriter.cpp

static void writeDICompileUnit(raw_ostream &Out, const DICompileUnit *N,
   Printer.printEmissionKind("emissionKind", N->getEmissionKind());
   Printer.printMetadata("enums", N->getRawEnumTypes());
   Printer.printMetadata("retainedTypes", N->getRawRetainedTypes());
   Printer.printMetadata("globals", N->getRawGlobalVariables());
   Printer.printMetadata("imports", N->getRawImportedEntities());
   Printer.printMetadata("macros", N->getRawMacros());
   Printer.printInt("dwoId", N->getDWOId());
   Printer.printBool("splitDebugInlining", N->getSplitDebugInlining(), true);
+  Printer.printBool("debugInfoForProfiling", N->getDebugInfoForProfiling(),
+                    false);
   Out << ")";
 }
 
 static void writeDISubprogram(raw_ostream &Out, const DISubprogram *N,
                               TypePrinting *TypePrinter, SlotTracker *Machine,
                               const Module *Context) {
   Out << "!DISubprogram(";
   MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);

lib/IR/DIBuilder.cpp

if (!N || isa<DICompileUnit>(N))
     return nullptr;
   return cast<DIScope>(N);
 }
 
 DICompileUnit *DIBuilder::createCompileUnit(
     unsigned Lang, DIFile *File, StringRef Producer, bool isOptimized,
     StringRef Flags, unsigned RunTimeVer, StringRef SplitName,
     DICompileUnit::DebugEmissionKind Kind, uint64_t DWOId,
-    bool SplitDebugInlining) {
+    bool SplitDebugInlining, bool DebugInfoForProfiling) {
 
   assert(((Lang <= dwarf::DW_LANG_Fortran08 && Lang >= dwarf::DW_LANG_C89) ||
           (Lang <= dwarf::DW_LANG_hi_user && Lang >= dwarf::DW_LANG_lo_user)) &&
          "Invalid Language tag");
 
   assert(!CUNode && "Can only make one compile unit per DIBuilder instance");
   CUNode = DICompileUnit::getDistinct(
       VMContext, Lang, File, Producer, isOptimized, Flags, RunTimeVer,
       SplitName, Kind, nullptr, nullptr, nullptr, nullptr, nullptr, DWOId,
-      SplitDebugInlining);
+      SplitDebugInlining, DebugInfoForProfiling);
 
   // Create a named metadata so that it is easier to find cu in a module.
   NamedMDNode *NMD = M.getOrInsertNamedMetadata("llvm.dbg.cu");
   NMD->addOperand(CUNode);
   trackIfUnresolved(CUNode);
   return CUNode;
 }
 

lib/IR/DebugInfo.cpp

DICompileUnit *getReplacementCU(DICompileUnit *CU) {
     MDTuple *RetainedTypes = nullptr;
     MDTuple *GlobalVariables = nullptr;
     MDTuple *ImportedEntities = nullptr;
     return DICompileUnit::getDistinct(
         CU->getContext(), CU->getSourceLanguage(), File, CU->getProducer(),
         CU->isOptimized(), CU->getFlags(), CU->getRuntimeVersion(),
         CU->getSplitDebugFilename(), DICompileUnit::LineTablesOnly, EnumTypes,
         RetainedTypes, GlobalVariables, ImportedEntities, CU->getMacros(),
-        CU->getDWOId(), CU->getSplitDebugInlining());
+        CU->getDWOId(), CU->getSplitDebugInlining(),
+        CU->getDebugInfoForProfiling());
   }
 
   DILocation *getReplacementMDLocation(DILocation *MLD) {
     auto *Scope = map(MLD->getScope());
     auto *InlinedAt = map(MLD->getInlinedAt());
     if (MLD->isDistinct())
       return DILocation::getDistinct(MLD->getContext(), MLD->getLine(),
                                      MLD->getColumn(), Scope, InlinedAt);

lib/IR/DebugInfoMetadata.cpp

 }
 
 DICompileUnit *DICompileUnit::getImpl(
     LLVMContext &Context, unsigned SourceLanguage, Metadata *File,
     MDString *Producer, bool IsOptimized, MDString *Flags,
     unsigned RuntimeVersion, MDString *SplitDebugFilename,
     unsigned EmissionKind, Metadata *EnumTypes, Metadata *RetainedTypes,
     Metadata *GlobalVariables, Metadata *ImportedEntities, Metadata *Macros,
-    uint64_t DWOId, bool SplitDebugInlining, StorageType Storage,
-    bool ShouldCreate) {
+    uint64_t DWOId, bool SplitDebugInlining, bool DebugInfoForProfiling,
+    StorageType Storage, bool ShouldCreate) {
   assert(Storage != Uniqued && "Cannot unique DICompileUnit");
   assert(isCanonical(Producer) && "Expected canonical MDString");
   assert(isCanonical(Flags) && "Expected canonical MDString");
   assert(isCanonical(SplitDebugFilename) && "Expected canonical MDString");
 
   Metadata *Ops[] = {
       File,      Producer,      Flags,           SplitDebugFilename,
       EnumTypes, RetainedTypes, GlobalVariables, ImportedEntities,
       Macros};
   return storeImpl(new (array_lengthof(Ops))
                        DICompileUnit(Context, Storage, SourceLanguage,
                                      IsOptimized, RuntimeVersion, EmissionKind,
-                                     DWOId, SplitDebugInlining, Ops),
+                                     DWOId, SplitDebugInlining,
+                                     DebugInfoForProfiling, Ops),
                    Storage);
 }
 
 Optional<DICompileUnit::DebugEmissionKind>
 DICompileUnit::getEmissionKind(StringRef Str) {
   return StringSwitch<Optional<DebugEmissionKind>>(Str)
       .Case("NoDebug", NoDebug)
       .Case("FullDebug", FullDebug)

lib/Target/TargetMachine.cpp

 #include "llvm/Target/TargetLoweringObjectFile.h"
 #include "llvm/Target/TargetSubtargetInfo.h"
 using namespace llvm;
 
 cl::opt<bool> EnableIPRA("enable-ipra", cl::init(false), cl::Hidden,
                          cl::desc("Enable interprocedural register allocation "
                                   "to reduce load/store at procedure calls."));
 
-cl::opt<bool> DebugInfoForProfiling(
-    "debug-info-for-profiling", cl::init(false), cl::Hidden,
-    cl::desc("Emit extra debug info to make sample profile more accurate."));
-
 //---------------------------------------------------------------------------
 // TargetMachine Class
 //
 
 TargetMachine::TargetMachine(const Target &T, StringRef DataLayoutString,
                              const Triple &TT, StringRef CPU, StringRef FS,
                              const TargetOptions &Options)
     : TheTarget(T), DL(DataLayoutString), TargetTriple(TT), TargetCPU(CPU),
       TargetFS(FS), AsmInfo(nullptr), MRI(nullptr), MII(nullptr), STI(nullptr),
       RequireStructuredCFG(false), DefaultOptions(Options), Options(Options) {
   if (EnableIPRA.getNumOccurrences())
     this->Options.EnableIPRA = EnableIPRA;
-  if (DebugInfoForProfiling.getNumOccurrences())
-    this->Options.DebugInfoForProfiling = DebugInfoForProfiling;
 }
 
 TargetMachine::~TargetMachine() {
   delete AsmInfo;
   delete MRI;
   delete MII;
   delete STI;
 }

test/Bitcode/upgrade-debug-info-for-profiling.ll

+; RUN: llvm-dis < %s.bc | FileCheck %s
+; RUN: verify-uselistorder < %s.bc
+
+!llvm.module.flags = !{!0}
+!0 = !{i32 2, !"Debug Info Version", i32 3}
+
+!llvm.dbg.cu = !{!1}
+; CHECK-NOT: DICompileUnit{{.*}} debugInfoForProfiling: true
+!1 = distinct !DICompileUnit(language: DW_LANG_C99, file: !2, emissionKind: FullDebug)
+!2 = !DIFile(filename: "foo.c", directory: "/path/to/dir")

test/DebugInfo/Generic/gmlt.ll

 ; REQUIRES: object-emission
+; RUN: %llc_dwarf -O0 -filetype=obj < %S/gmlt.ll | llvm-dwarfdump - | FileCheck %S/gmlt.ll
+
+; There's a darwin specific test in X86/gmlt, so it's okay to XFAIL this here.
+; XFAIL: darwin
 
 ; Generated from the following source compiled with clang++ -gmlt:
 ; void f1() {}
 ; void __attribute__((section("__TEXT,__bar"))) f2() {}
 ; void __attribute__((always_inline)) f3() { f1(); }
 ; void f4() { f3(); }
 
 ; Check that

 ; Make sure we don't have any other subprograms here (subprograms with no
 ; inlined subroutines are omitted by design to save space)
 
 ; CHECK-NOT: {{DW_TAG|DW_AT}}
 ; CHECK: NULL
 ; CHECK-NOT: {{DW_TAG|DW_AT}}
 ; CHECK: NULL
 
-; PROFILING: DW_TAG_subprogram
-; PROFILING: DW_AT_name {{.*}} "f1"
-; With -debug-info-for-profiling, we need to emit decl_file a-nd decl_line
-; of the subprogram.
-; PROFILING: DW_AT_decl_file
-; PROFILING: DW_AT_decl_line
-
 ; CHECK: .debug_ranges contents:
 
 ; ... some addresses (depends on platform (such as platforms with function
 ; reordering in the linker), and looks wonky on platforms with zero values
 ; written in relocation places (dumper needs to be fixed to read the
 ; relocations rather than interpret that as the end of a range list))
 
 ; CHECK: 00000000 <End of list>

test/DebugInfo/Generic/gmlt.test

-; REQUIRES: object-emission
-; RUN: %llc_dwarf -O0 -filetype=obj < %S/../Inputs/gmlt.ll | llvm-dwarfdump - | FileCheck %S/../Inputs/gmlt.ll
-; RUN: %llc_dwarf -O0 -filetype=obj -debug-info-for-profiling < %S/../Inputs/gmlt.ll | llvm-dwarfdump - | FileCheck %S/../Inputs/gmlt.ll --check-prefixes=PROFILING
-
-; There's a darwin specific test in X86/gmlt, so it's okay to XFAIL this here.
-; XFAIL: darwin

test/DebugInfo/Generic/gmlt_profiling.ll

+; REQUIRES: object-emission
+; RUN: %llc_dwarf -O0 -filetype=obj < %S/gmlt_profiling.ll | llvm-dwarfdump - | FileCheck %S/gmlt_profiling.ll
+
+; There's a darwin specific test in X86/gmlt, so it's okay to XFAIL this here.
+; XFAIL: darwin
+
+; CHECK: .debug_info
+; CHECK: DW_TAG_subprogram
+; CHECK-NOT: DW_TAG
+; CHECK: DW_AT_name {{.*}} "f1"
+; With debug-info-for-profiling attribute, we need to emit decl_file and
+; decl_line of the subprogram.
+; CHECK-NEXT: DW_AT_decl_file
+; CHECK-NEXT: DW_AT_decl_line
+
+; Function Attrs: nounwind uwtable
+define void @_Z2f1v() !dbg !4 {
+entry:
+  ret void, !dbg !13
+}
+
+!llvm.dbg.cu = !{!0}
+!llvm.module.flags = !{!10, !11}
+!llvm.ident = !{!12}
+
+!0 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus, producer: "clang version 3.6.0 ", isOptimized: false, emissionKind: LineTablesOnly, file: !1, enums: !2, retainedTypes: !2, globals: !2, imports: !2, debugInfoForProfiling: true)
+!1 = !DIFile(filename: "gmlt.cpp", directory: "/tmp/dbginfo")
+!2 = !{}
+!4 = distinct !DISubprogram(name: "f1", line: 1, isLocal: false, isDefinition: true, virtualIndex: 6, flags: DIFlagPrototyped, isOptimized: false, unit: !0, scopeLine: 1, file: !1, scope: !5, type: !6, variables: !2)
+!5 = !DIFile(filename: "gmlt.cpp", directory: "/tmp/dbginfo")
+!6 = !DISubroutineType(types: !2)
+!10 = !{i32 2, !"Dwarf Version", i32 4}
+!11 = !{i32 2, !"Debug Info Version", i32 3}
+!12 = !{!"clang version 3.6.0 "}
+!13 = !DILocation(line: 1, column: 12, scope: !4)

unittests/IR/MetadataTest.cpp

protected:
   }
   DIFile *getFile() {
     return DIFile::getDistinct(Context, "file.c", "/path/to/dir");
   }
   DICompileUnit *getUnit() {
     return DICompileUnit::getDistinct(Context, 1, getFile(), "clang", false,
                                       "-g", 2, "", DICompileUnit::FullDebug,
                                       getTuple(), getTuple(), getTuple(),
-                                      getTuple(), getTuple(), 0, true);
+                                      getTuple(), getTuple(), 0, true, false);
   }
   DIType *getBasicType(StringRef Name) {
     return DIBasicType::get(Context, dwarf::DW_TAG_unspecified_type, Name);
   }
   DIType *getDerivedType() {
     return DIDerivedType::getDistinct(
         Context, dwarf::DW_TAG_pointer_type, "", nullptr, 0, nullptr,
         getBasicType("basictype"), 1, 2, 0, DINode::FlagZero);
TEST_F(DICompileUnitTest, get) {
   MDTuple *RetainedTypes = getTuple();
   MDTuple *GlobalVariables = getTuple();
   MDTuple *ImportedEntities = getTuple();
   uint64_t DWOId = 0x10000000c0ffee;
   MDTuple *Macros = getTuple();
   auto *N = DICompileUnit::getDistinct(
       Context, SourceLanguage, File, Producer, IsOptimized, Flags,
       RuntimeVersion, SplitDebugFilename, EmissionKind, EnumTypes,
-      RetainedTypes, GlobalVariables, ImportedEntities, Macros, DWOId, true);
+      RetainedTypes, GlobalVariables, ImportedEntities, Macros, DWOId, true,
+      false);
 
   EXPECT_EQ(dwarf::DW_TAG_compile_unit, N->getTag());
   EXPECT_EQ(SourceLanguage, N->getSourceLanguage());
   EXPECT_EQ(File, N->getFile());
   EXPECT_EQ(Producer, N->getProducer());
   EXPECT_EQ(IsOptimized, N->isOptimized());
   EXPECT_EQ(Flags, N->getFlags());
   EXPECT_EQ(RuntimeVersion, N->getRuntimeVersion());
TEST_F(DICompileUnitTest, replaceArrays) {
   auto EmissionKind = DICompileUnit::FullDebug;
   MDTuple *EnumTypes = MDTuple::getDistinct(Context, None);
   MDTuple *RetainedTypes = MDTuple::getDistinct(Context, None);
   MDTuple *ImportedEntities = MDTuple::getDistinct(Context, None);
   uint64_t DWOId = 0xc0ffee;
   auto *N = DICompileUnit::getDistinct(
       Context, SourceLanguage, File, Producer, IsOptimized, Flags,
       RuntimeVersion, SplitDebugFilename, EmissionKind, EnumTypes,
-      RetainedTypes, nullptr, ImportedEntities, nullptr, DWOId, true);
+      RetainedTypes, nullptr, ImportedEntities, nullptr, DWOId, true, false);
 
   auto *GlobalVariables = MDTuple::getDistinct(Context, None);
   EXPECT_EQ(nullptr, N->getGlobalVariables().get());
   N->replaceGlobalVariables(GlobalVariables);
   EXPECT_EQ(GlobalVariables, N->getGlobalVariables().get());
   N->replaceGlobalVariables(nullptr);
   EXPECT_EQ(nullptr, N->getGlobalVariables().get());