Add a --dwarf64-str-offsets option value.

This option controls if llvm-dwp can promote a .debug_str_offsets table from DWARF32 to DWARF64.

Setting this option value to "enabled" allows promotion of a DWARF32 .debug_str_offsets table to DWARF64 only if any string in the .debug_str_offsets table exceeds UINT32_MAX.

Setting this option value to "disabled" (the default) will keep pre-existing behavior where all .debug_str_offsets tables will be emitted in the same format as are in each .dwo file.

Setting this option value to "always" forces all .debug_str_offsets tables to be emitted as DWARF64 tables. This is used for testing.

Removed the previous --force-dwarf64-str-offsets option.

Author: clayborg

llvm/include/llvm/DWP/DWP.h

@@ -22,6 +22,12 @@ enum OnCuIndexOverflow {
   Continue,
 };
 
+enum Dwarf64StrOffsets {
+  Disabled, ///< Don't do any conversion of .debug_str_offsets tables.
+  Enabled,  ///< Convert any .debug_str_offsets tables to DWARD64 if needed.
+  Always,   ///< Always emit .debug_str_offsets talbes as DWARF64 for testing.
+};
+
 struct UnitIndexEntry {
   DWARFUnitIndex::Entry::SectionContribution Contributions[8];
   std::string Name;
@@ -69,7 +75,7 @@ struct CompileUnitIdentifiers {
 
 LLVM_ABI Error write(MCStreamer &Out, ArrayRef<std::string> Inputs,
                      OnCuIndexOverflow OverflowOptValue,
-                     bool ForceDwarf64StringOffsets);
+                     Dwarf64StrOffsets StrOffsetsOptValue);
 
 typedef std::vector<std::pair<DWARFSectionKind, uint32_t>> SectionLengths;
 

llvm/lib/DWP/DWP.cpp

@@ -430,7 +430,7 @@ void writeStringsAndOffsets(MCStreamer &Out, DWPStringPool &Strings,
                             StringRef CurStrSection,
                             StringRef CurStrOffsetSection, uint16_t Version,
                             SectionLengths &SectionLength,
-                            const bool ForceDwarf64StringOffsets) {
+                            const Dwarf64StrOffsets StrOffsetsOptValue) {
   // Could possibly produce an error or warning if one of these was non-null but
   // the other was null.
   if (CurStrSection.empty() || CurStrOffsetSection.empty())
@@ -444,15 +444,19 @@ void writeStringsAndOffsets(MCStreamer &Out, DWPStringPool &Strings,
 
   // Keep track if any new string offsets exceed UINT32_MAX. If any do, we can
   // emit a DWARF64 .debug_str_offsets table for this compile unit. If the
-  // \a ForceDwarf64StringOffsets argument is true, then force the emission of
-  // DWARF64 .debug_str_offsets for testing.
+  // \a StrOffsetsOptValue argument is Dwarf64StrOffsets::Always, then force
+  // the emission of DWARF64 .debug_str_offsets for testing.
   uint32_t OldOffsetSize = 4;
-  uint32_t NewOffsetSize = ForceDwarf64StringOffsets ? 8 : 4;
+  uint32_t NewOffsetSize =
+      StrOffsetsOptValue == Dwarf64StrOffsets::Always ? 8 : 4;
   while (const char *S = Data.getCStr(&LocalOffset)) {
     uint64_t NewOffset = Strings.getOffset(S, LocalOffset - PrevOffset);
     OffsetRemapping[PrevOffset] = NewOffset;
-    if (NewOffset > UINT32_MAX)
+    // Only promote the .debug_str_offsets to DWARF64 if our setting allows it.
+    if (StrOffsetsOptValue != Dwarf64StrOffsets::Disabled &&
+        NewOffset > UINT32_MAX) {
       NewOffsetSize = 8;
+    }
     PrevOffset = LocalOffset;
   }
 
@@ -670,7 +674,7 @@ Error handleSection(
 
 Error write(MCStreamer &Out, ArrayRef<std::string> Inputs,
             OnCuIndexOverflow OverflowOptValue,
-            bool ForceDwarf64StringOffsets) {
+            Dwarf64StrOffsets StrOffsetsOptValue) {
   const auto &MCOFI = *Out.getContext().getObjectFileInfo();
   MCSection *const StrSection = MCOFI.getDwarfStrDWOSection();
   MCSection *const StrOffsetSection = MCOFI.getDwarfStrOffDWOSection();
@@ -764,7 +768,7 @@ Error write(MCStreamer &Out, ArrayRef<std::string> Inputs,
 
     writeStringsAndOffsets(Out, Strings, StrOffsetSection, CurStrSection,
                            CurStrOffsetSection, Header.Version, SectionLength,
-                           ForceDwarf64StringOffsets);
+                           StrOffsetsOptValue);
 
     for (auto Pair : SectionLength) {
       auto Index = getContributionIndex(Pair.first, IndexVersion);

llvm/test/tools/llvm-dwp/X86/dwarf64-str-offsets.test

@@ -6,10 +6,17 @@
 # 4GB .dwo file.
 
 # RUN: yaml2obj %s -o %t.dwo
-# RUN: llvm-dwp %t.dwo -o %t.32.dwp
-# RUN: llvm-dwp %t.dwo -o %t.64.dwp --force-dwarf64-str-offsets
-# RUN: llvm-dwarfdump --debug-str-offsets %t.32.dwp | FileCheck --check-prefixes=DWARF32 %s
-# RUN: llvm-dwarfdump --debug-str-offsets %t.64.dwp | FileCheck --check-prefixes=DWARF64 %s
+# RUN: llvm-dwp %t.dwo -o %t.dwp
+# RUN: llvm-dwp %t.dwo -o %t.default.dwp --dwarf64-str-offsets
+# RUN: llvm-dwp %t.dwo -o %t.disabled.dwp --dwarf64-str-offsets=disabled
+# RUN: llvm-dwp %t.dwo -o %t.enabled.dwp --dwarf64-str-offsets=enabled
+# RUN: llvm-dwp %t.dwo -o %t.always.dwp --dwarf64-str-offsets=always
+# RUN: not llvm-dwp %t.dwo -o %t.invalid.dwp --dwarf64-str-offsets=invalid 2>&1 | FileCheck --check-prefixes=ERROR %s
+# RUN: llvm-dwarfdump --debug-str-offsets %t.dwp | FileCheck --check-prefixes=DWARF32 %s
+# RUN: llvm-dwarfdump --debug-str-offsets %t.default.dwp | FileCheck --check-prefixes=DWARF32 %s
+# RUN: llvm-dwarfdump --debug-str-offsets %t.disabled.dwp | FileCheck --check-prefixes=DWARF32 %s
+# RUN: llvm-dwarfdump --debug-str-offsets %t.enabled.dwp | FileCheck --check-prefixes=DWARF32 %s
+# RUN: llvm-dwarfdump --debug-str-offsets %t.always.dwp | FileCheck --check-prefixes=DWARF64 %s
 
 # DWARF32:      .debug_str_offsets.dwo contents:
 # DWARF32-NEXT: 0x00000000: Contribution size = 36, Format = DWARF32, Version = 5
@@ -33,6 +40,8 @@
 # DWARF64-NEXT: 0x00000040: 0000000000000046 "simple.cpp"
 # DWARF64-NEXT: 0x00000048: 0000000000000051 "simple.dwo"
 
+# ERROR: invalid value for --dwarf64-str-offsets. Valid values are one of: "enabled", "disabled" or "always".
+
 --- !ELF
 FileHeader:
   Class:           ELFCLASS64

llvm/tools/llvm-dwp/Opts.td

@@ -16,7 +16,13 @@ def continueOnCuIndexOverflow_EQ : Joined<["-", "--"], "continue-on-cu-index-ove
     "\t\ttruncated but valid DWP file, discarding any DWO files that would not fit within \n"
     "\t\tthe 32 bit/4GB limits of the format.">,
   Values<"continue,soft-stop">;
-def forceDwarf64StringOffsets : Flag<["-", "--"], "force-dwarf64-str-offsets">,
-  Flags<[HelpHidden]>,
-  HelpText<"Force all .debug_str_offsets to be emitted as DWARF64 tables. This "
-    "option is used for testing.">;
+
+def dwarf64StringOffsets : Flag<["-", "--"], "dwarf64-str-offsets">;
+def dwarf64StringOffsets_EQ : Joined<["-", "--"], "dwarf64-str-offsets=">,
+  HelpText<"default = disabled, This setting doesn't convert DWARF32 .debug_str_offsets\n"
+    "tables in .dwo files to DWARF64 in the .dwp file. = enabled, This allows .debug_str\n"
+    "tables to exceed the 4GB limit and have any DWARF32 .debug_str_offsets tables\n"
+    "converted to DWARF64 only for tables that require 64 bit string offsets.\n"
+    "= always, This forces all .debug_str_offsets tables to be emitted as DWARF64.\n"
+    "This is used for testing.">,
+  Values<"disabled,enabled,always">;

llvm/tools/llvm-dwp/llvm-dwp.cpp

@@ -73,7 +73,6 @@ class DwpOptTable : public opt::GenericOptTable {
 static std::vector<std::string> ExecFilenames;
 static std::string OutputFilename;
 static std::string ContinueOption;
-static bool ForceDwarf64StringOffsets = false;
 
 static Expected<SmallVector<std::string, 16>>
 getDWOFilenames(StringRef ExecFilename) {
@@ -126,6 +125,8 @@ int llvm_dwp_main(int argc, char **argv, const llvm::ToolContext &) {
   llvm::BumpPtrAllocator A;
   llvm::StringSaver Saver{A};
   OnCuIndexOverflow OverflowOptValue = OnCuIndexOverflow::HardStop;
+  Dwarf64StrOffsets Dwarf64StrOffsetsValue = Dwarf64StrOffsets::Disabled;
+
   opt::InputArgList Args =
       Tbl.parseArgs(argc, argv, OPT_UNKNOWN, Saver, [&](StringRef Msg) {
         llvm::errs() << Msg << '\n';
@@ -161,8 +162,26 @@ int llvm_dwp_main(int argc, char **argv, const llvm::ToolContext &) {
       }
     }
   }
-  if (Args.getLastArg(OPT_forceDwarf64StringOffsets))
-    ForceDwarf64StringOffsets = true;
+
+  if (Arg *Arg = Args.getLastArg(OPT_dwarf64StringOffsets,
+                                 OPT_dwarf64StringOffsets_EQ)) {
+    if (Arg->getOption().matches(OPT_dwarf64StringOffsets)) {
+      Dwarf64StrOffsetsValue = Dwarf64StrOffsets::Enabled;
+    } else {
+      std::string OptValue = Arg->getValue();
+      if (OptValue == "disabled") {
+        Dwarf64StrOffsetsValue = Dwarf64StrOffsets::Disabled;
+      } else if (OptValue == "enabled") {
+        Dwarf64StrOffsetsValue = Dwarf64StrOffsets::Enabled;
+      } else if (OptValue == "always") {
+        Dwarf64StrOffsetsValue = Dwarf64StrOffsets::Always;
+      } else {
+        llvm::errs() << "invalid value for --dwarf64-str-offsets. Valid values "
+            "are one of: \"enabled\", \"disabled\" or \"always\".\n";
+        exit(1);
+      }
+    }
+  }
 
   for (const llvm::opt::Arg *A : Args.filtered(OPT_execFileNames))
     ExecFilenames.emplace_back(A->getValue());
@@ -278,7 +297,7 @@ int llvm_dwp_main(int argc, char **argv, const llvm::ToolContext &) {
     return error("no object streamer for target " + TripleName, Context);
 
   if (auto Err = write(*MS, DWOFilenames, OverflowOptValue,
-                       ForceDwarf64StringOffsets)) {
+                       Dwarf64StrOffsetsValue)) {
     logAllUnhandledErrors(std::move(Err), WithColor::error());
     return 1;
   }