[DEBUGINFO] Add support for emission of the inlined strings.

[ABataev]

Summary

Patch adds an option for emission of inlined strings rather than
.debug_str section.

[probinson]

lib/CodeGen/AsmPrinter/DwarfDebug.cpp

118 ↗

(On Diff #134625)

Are you intending to add platform-specific defaulting within DwarfDebug? If not, then this is a simple on/off switch that defaults to off.

test/DebugInfo/Generic/inlined-strings.ll

38 ↗

(On Diff #134625)

This is spelled incorrectly (I expect you want DW_FORM_strp), and only verifies that the form does not appear after the last positive matching string.

I would be more inclined to run the test twice, once with Enable and once with Disable, with checks along the lines of

ENABLE-NOT: DW_FORM_str{{(p|x)}}
ENABLE: DW_FORM_string
ENABLE-NOT: DW_FORM_str{{(p|x)}}

DISABLE-NOT: DW_FORM_string
DISABLE: DW_FORM_str{{p|x)}}
DISABLE-NOT: DW_FORM_string

That makes the test specific to the behavior of the option, and the forms it produces, omitting irrelevant concerns about tags and attributes.

[ABataev]

lib/CodeGen/AsmPrinter/DwarfDebug.cpp

118 ↗

(On Diff #134625)

Yes, this is what Eric Christofer suggested to do as the first step. I'll enable it for NVPTX target

test/DebugInfo/Generic/inlined-strings.ll

38 ↗

(On Diff #134625)

1. I don't care about some particular form here, I'm just checking that there are no any strings at all, in any form.
2. There are a lot of tests already where this new option is disabled by default and they have checks for DW_form_strp and other forms.

[probinson]

test/DebugInfo/Generic/inlined-strings.ll

38 ↗

(On Diff #134625)

1. Actually you want to specifically verify that you have at least one string, that it uses DW_FORM_string, and that no strings use any of the indirect forms.
2. Fair. In that case, just do:

CHECK-NOT: DW_FORM_str{{(p|x)}}
CHECK: DW_FORM_string
CHECK-NOT: DW_FORM_str{{(p|x)}}

[ABataev]

Improved test checks

[probinson]

test/DebugInfo/Generic/inlined-strings.ll

38 ↗

(On Diff #134625)

Actually I meant the above 3 CHECK lines were all you needed, for the entire test. Sorry for not making that clear.

[ABataev]

test/DebugInfo/Generic/inlined-strings.ll

38 ↗

(On Diff #134625)

But these new checks are still good?

[probinson]

test/DebugInfo/Generic/inlined-strings.ll

38 ↗

(On Diff #134625)

They are overkill. The 3 lines from my previous comment are all you need.

[probinson]

Instead of all the elaborate checks, you could use llvm-dwarfdump -debug-str (dump just the .debug_str section) and then use CHECK-NOT: " to prove it's empty.

test/DebugInfo/Generic/inlined-strings.ll

4 ↗

(On Diff #134667)

You can avoid generating the temp file here. Instead of > %t you do -o - and then pipe it to llvm-dwarfdump with an input file of -.

[probinson]

In D43390#1010744, @probinson wrote:

Instead of all the elaborate checks, you could use llvm-dwarfdump -debug-str (dump just the .debug_str section) and then use CHECK-NOT: " to prove it's empty.

Actually never mind. Losing all the debug info would also pass that check, so my previous 3-line recommendation stands.

[ABataev]

Fixed test checks.

[probinson]

Fix the temp-file thing in the test and LGTM.

[echristo]

One inline typo, otherwise fix up what Paul asked for and LGTM.

-eric

lib/CodeGen/AsmPrinter/DwarfDebug.h

497 ↗

(On Diff #134711)

wether - > whether

[dblaikie]

What's the motivation for this change? Do you have a platform that doesn't support debug_string?

[echristo]

In D43390#1013397, @dblaikie wrote:

What's the motivation for this change? Do you have a platform that doesn't support debug_string?

Yep. Exactly. Apparently nvptx doesn't.

llvm/trunk/lib/CodeGen/AsmPrinter/DwarfDebug.h

class DwarfDebug : public DebugHandlerBase {
   bool UseGNUTLSOpcode;
 
   /// Whether to use DWARF 2 bitfields (instead of the DWARF 4 format).
   bool UseDWARF2Bitfields;
 
   /// Whether to emit all linkage names, or just abstract subprograms.
   bool UseAllLinkageNames;
 
+  /// Use inlined strings.
+  bool UseInlineStrings = false;
+
   /// DWARF5 Experimental Options
   /// @{
   bool HasDwarfAccelTables;
   bool HasAppleExtensionAttributes;
   bool HasSplitDwarf;
 
   /// Whether to generate the DWARF v5 string offsets table.
   /// It consists of a series of contributions, each preceded by a header.
public:
   /// Returns whether to use DW_OP_GNU_push_tls_address, instead of the
   /// standard DW_OP_form_tls_address opcode
   bool useGNUTLSOpcode() const { return UseGNUTLSOpcode; }
 
   /// Returns whether to use the DWARF2 format for bitfields instyead of the
   /// DWARF4 format.
   bool useDWARF2Bitfields() const { return UseDWARF2Bitfields; }
 
+  /// Returns whether to use inline strings.
+  bool useInlineStrings() const { return UseInlineStrings; }
+
   // Experimental DWARF5 features.
 
   /// Returns whether or not to emit tables that dwarf consumers can
   /// use to accelerate lookup.
   bool useDwarfAccelTables() const { return HasDwarfAccelTables; }
 
   bool useAppleExtensionAttributes() const {
     return HasAppleExtensionAttributes;

llvm/trunk/lib/CodeGen/AsmPrinter/DwarfDebug.cpp

 static cl::opt<DefaultOnOff>
 DwarfAccelTables("dwarf-accel-tables", cl::Hidden,
                  cl::desc("Output prototype dwarf accelerator tables."),
                  cl::values(clEnumVal(Default, "Default for platform"),
                             clEnumVal(Enable, "Enabled"),
                             clEnumVal(Disable, "Disabled")),
                  cl::init(Default));
 
+static cl::opt<DefaultOnOff>
+DwarfInlinedStrings("dwarf-inlined-strings", cl::Hidden,
+                 cl::desc("Use inlined strings rather than string section."),
+                 cl::values(clEnumVal(Default, "Default for platform"),
+                            clEnumVal(Enable, "Enabled"),
+                            clEnumVal(Disable, "Disabled")),
+                 cl::init(Default));
+
 enum LinkageNameOption {
   DefaultLinkageNames,
   AllLinkageNames,
   AbstractLinkageNames
 };
 
 static cl::opt<LinkageNameOption>
     DwarfLinkageNames("dwarf-linkage-names", cl::Hidden,
DwarfDebug::DwarfDebug(AsmPrinter *A, Module *M)
   // Turn on accelerator tables by default, if tuning for LLDB and the target is
   // supported.
   if (DwarfAccelTables == Default)
     HasDwarfAccelTables =
         tuneForLLDB() && A->TM.getTargetTriple().isOSBinFormatMachO();
   else
     HasDwarfAccelTables = DwarfAccelTables == Enable;
 
+  UseInlineStrings = DwarfInlinedStrings == Enable;
   HasAppleExtensionAttributes = tuneForLLDB();
 
   // Handle split DWARF.
   HasSplitDwarf = !Asm->TM.Options.MCOptions.SplitDwarfFile.empty();
 
   // SCE defaults to linkage names only for abstract subprograms.
   if (DwarfLinkageNames == DefaultLinkageNames)
     UseAllLinkageNames = !tuneForSCE();

llvm/trunk/lib/CodeGen/AsmPrinter/DwarfUnit.cpp

 
 void DwarfUnit::addSInt(DIELoc &Die, Optional<dwarf::Form> Form,
                         int64_t Integer) {
   addSInt(Die, (dwarf::Attribute)0, Form, Integer);
 }
 
 void DwarfUnit::addString(DIE &Die, dwarf::Attribute Attribute,
                           StringRef String) {
+  if (DD->useInlineStrings()) {
+    Die.addValue(DIEValueAllocator, Attribute, dwarf::DW_FORM_string,
+                 new (DIEValueAllocator)
+                     DIEInlineString(String, DIEValueAllocator));
+    return;
+  }
   auto StringPoolEntry = DU->getStringPool().getEntry(*Asm, String);
   dwarf::Form IxForm =
       isDwoUnit() ? dwarf::DW_FORM_GNU_str_index : dwarf::DW_FORM_strp;
   // For DWARF v5 and beyond, use the smallest strx? form possible.
   if (useSegmentedStringOffsetsTable()) {
     IxForm = dwarf::DW_FORM_strx1;
     unsigned Index = StringPoolEntry.getIndex();
     if (Index > 0xffffff)

llvm/trunk/test/DebugInfo/Generic/inlined-strings.ll

+; REQUIRES: object-emission
+
+; RUN: %llc_dwarf -O0 -filetype=obj < %s -dwarf-inlined-strings=Enable -o - | llvm-dwarfdump -show-form - | FileCheck %s
+
+; Also test that the null streamer doesn't crash with debug info.
+; RUN: %llc_dwarf -O0 -filetype=null < %s -dwarf-inlined-strings=Enable
+
+; generated from the following source compiled to bitcode with clang -g -O1
+; static int i;
+; int main() {
+;   (void)&i;
+; }
+
+; CHECK-NOT: DW_FORM_str{{(p|x)}}
+; CHECK: DW_FORM_string
+; CHECK-NOT: DW_FORM_str{{(p|x)}}
+
+
+source_filename = "test/DebugInfo/Generic/global.ll"
+
+; Function Attrs: nounwind readnone uwtable
+define i32 @main() #0 !dbg !9 {
+entry:
+  ret i32 0, !dbg !12
+}
+
+attributes #0 = { nounwind readnone uwtable "less-precise-fpmad"="false" "no-frame-pointer-elim"="false" "no-infs-fp-math"="false" "no-nans-fp-math"="false" "unsafe-fp-math"="false" "use-soft-float"="false" }
+
+!llvm.dbg.cu = !{!0}
+!llvm.module.flags = !{!7, !8}
+
+!0 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus, file: !1, producer: "clang version 3.4 ", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, enums: !2, retainedTypes: !2, globals: !3, imports: !2)
+!1 = !DIFile(filename: "global.cpp", directory: "/tmp")
+!2 = !{}
+!3 = !{!4}
+!4 = !DIGlobalVariableExpression(var: !5, expr: !DIExpression())
+!5 = !DIGlobalVariable(name: "i", linkageName: "_ZL1i", scope: null, file: !1, line: 1, type: !6, isLocal: true, isDefinition: true)
+!6 = !DIBasicType(name: "int", size: 32, align: 32, encoding: DW_ATE_signed)
+!7 = !{i32 2, !"Dwarf Version", i32 3}
+!8 = !{i32 1, !"Debug Info Version", i32 3}
+!9 = distinct !DISubprogram(name: "main", scope: !1, file: !1, line: 2, type: !10, isLocal: false, isDefinition: true, scopeLine: 2, virtualIndex: 6, flags: DIFlagPrototyped, isOptimized: true, unit: !0, variables: !2)
+!10 = !DISubroutineType(types: !11)
+!11 = !{!6}
+!12 = !DILocation(line: 4, scope: !9)
+