move UseDwarfRangesBaseAddressSpecifier to front end flag

[mlekena]

Summary

Move UseDwarfRangesBaseAddressSpecifier handling to the MC options command line argument.
This is a change to make the flag more accessible without needing to pass in arguments directly to the
LLVM backend.

Following this change, what would be a better name for this flag given that the
current name is rather verbose? Are there any opinions around this?

[aprantl]

lib/CodeGen/AsmPrinter/DwarfDebug.cpp

89

The LLVM coding guidelines want us to never comment out code; just remove it instead.

[mlekena]

1. Updating D41364: move UseDwarfRangesBaseAddressSpecifier to front end flag #
2. Enter a brief description of the changes included in this update.
3. The first line is used as subject, next lines as comment. #
4. If you intended to create a new revision, use:
5. $ arc diff --create

Remove commented code as recommended to adhere to developers guide

[dblaikie]

As for a name (& might be worth using it here for the MCOption too) - maybe just "DwarfRangesBase" (Not sure if a "Use" prefix is helpful/necessary?), with the intent of the flag being -fdwarf-ranges-base

Open to hearing Adrian & others if they've got any other ideas (:

[echristo]

include/llvm/MC/MCTargetOptions.h

66

Might want to put this bool up near the other bools.

lib/CodeGen/AsmPrinter/DwarfDebug.cpp

87–88

Typically we don't comment things out. :)

[probinson]

test/DebugInfo/X86/range_reloc.ll

1

It looks like all this did was reorder some things. Is llc command processing really that sensitive to order?

include/llvm/MC/MCTargetOptions.h

public:
   /// Preserve Comments in Assembly.
   bool PreserveAsmComments : 1;
 
   int DwarfVersion = 0;
 
   std::string ABIName;
   std::string SplitDwarfFile;
 
+  /// Enable base address specification in dwarf ranges 
+  bool UseDwarfRangesBaseAddressSpecifier;
+
   /// 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
   /// textual name of the ABI that we want the backend to use, e.g. o32, or
   /// aapcs-linux.
   StringRef getABIName() const;
 };
 
 } // end namespace llvm
 
 #endif // LLVM_MC_MCTARGETOPTIONS_H

lib/CodeGen/AsmPrinter/DwarfDebug.cpp

 
 using namespace llvm;
 
 #define DEBUG_TYPE "dwarfdebug"
 
 static cl::opt<bool>
 DisableDebugInfoPrinting("disable-debug-info-print", cl::Hidden,
                          cl::desc("Disable debug info printing"));
 
-static cl::opt<bool> UseDwarfRangesBaseAddressSpecifier(
-    "use-dwarf-ranges-base-address-specifier", cl::Hidden,
-    cl::desc("Use base address specifiers in debug_ranges"), cl::init(false));
-
 static cl::opt<bool> GenerateARangeSection("generate-arange-section",
                                            cl::Hidden,
                                            cl::desc("Generate dwarf aranges"),
                                            cl::init(false));
 
 static cl::opt<bool> SplitDwarfCrossCuReferences(
     "split-dwarf-cross-cu-references", cl::Hidden,
     cl::desc("Enable cross-cu references in DWO files"), cl::init(false));
 
 enum DefaultOnOff { Default, Enable, Disable };
for (const RangeSpanList &List : TheCU->getRangeLists()) {
         // Don't bother with a base address entry if there's only one range in
         // this section in this range list - for example ranges for a CU will
         // usually consist of single regions from each of many sections
         // (-ffunction-sections, or just C++ inline functions) except under LTO
         // or optnone where there may be holes in a single CU's section
         // contrubutions.
         auto *Base = CUBase;
         if (!Base && P.second.size() > 1 &&
-            UseDwarfRangesBaseAddressSpecifier) {
+            Asm->TM.Options.MCOptions.UseDwarfRangesBaseAddressSpecifier) {
           BaseIsSet = true;
           // FIXME/use care: This may not be a useful base address if it's not
           // the lowest address/range in this object.
           Base = P.second.front()->getStart();
           Asm->OutStreamer->EmitIntValue(-1, Size);
           Asm->OutStreamer->EmitSymbolValue(Base, Size);
         } else if (BaseIsSet) {
           BaseIsSet = false;

test/DebugInfo/X86/range_reloc.ll

-; RUN: llc -filetype=asm -mtriple=x86_64-pc-linux-gnu %s -o - -use-dwarf-ranges-base-address-specifier | FileCheck --check-prefix=COMMON --check-prefix=BASE %s
+; RUN: llc -filetype=asm -mtriple=x86_64-pc-linux-gnu -use-dwarf-ranges-base-address-specifier %s -o  - | FileCheck --check-prefix=COMMON --check-prefix=BASE %s
 ; RUN: llc -filetype=asm -mtriple=x86_64-pc-linux-gnu %s -o - | FileCheck --check-prefix=COMMON --check-prefix=NOBASE %s
 
 ; Group ranges in a range list that apply to the same section and use a base
 ; address selection entry to reduce the number of relocations to one reloc per
 ; section per range list. DWARF5 debug_rnglist will be more efficient than this
 ; in terms of relocations, but it's still better than one reloc per entry in a
 ; range list.
 

tools/llc/llc.cpp

 
 static cl::opt<RunPassOption, true, cl::parser<std::string>> RunPass(
     "run-pass",
     cl::desc("Run compiler only for specified passes (comma separated list)"),
     cl::value_desc("pass-name"), cl::ZeroOrMore, cl::location(RunPassOpt));
 
 static int compileModule(char **, LLVMContext &);
 
+static cl::opt<bool> UseDwarfRangesBaseAddressSpecifier(
+    "use-dwarf-ranges-base-address-specifier", cl::Hidden,
+    cl::desc("Use base address specifiers in debug_ranges"), cl::init(false));
+
 static std::unique_ptr<ToolOutputFile> GetOutputStream(const char *TargetName,
                                                        Triple::OSType OS,
                                                        const char *ProgName) {
   // If we don't yet have an output filename, make one.
   if (OutputFilename.empty()) {
     if (InputFilename == "-")
       OutputFilename = "-";
     else {
static int compileModule(char **argv, LLVMContext &Context) {
   TargetOptions Options = InitTargetOptionsFromCodeGenFlags();
   Options.DisableIntegratedAS = NoIntegratedAssembler;
   Options.MCOptions.ShowMCEncoding = ShowMCEncoding;
   Options.MCOptions.MCUseDwarfDirectory = EnableDwarfDirectory;
   Options.MCOptions.AsmVerbose = AsmVerbose;
   Options.MCOptions.PreserveAsmComments = PreserveComments;
   Options.MCOptions.IASSearchPaths = IncludeDirs;
   Options.MCOptions.SplitDwarfFile = SplitDwarfFile;
+  Options.MCOptions.UseDwarfRangesBaseAddressSpecifier = UseDwarfRangesBaseAddressSpecifier;
 
   std::unique_ptr<TargetMachine> Target(TheTarget->createTargetMachine(
       TheTriple.getTriple(), CPUStr, FeaturesStr, Options, getRelocModel(),
       getCodeModel(), OLvl));
 
   assert(Target && "Could not allocate target machine!");
 
   // If we don't have a module then just exit now. We do this down