Emit DWARF info for all code section in an assembly file

[olista01]

Summary

Currently, when using llvm as an assembler, DWARF debug information is only
generated for the .text section. This patch modifies this so that DWARF info
is emitted for all executable sections.

[olista01]

Added -gdwarf-N options to llvm-mc.

Added error if trying to compile an asm file with multiple sections using -gdwarf-2.

Se also D2737, for clang part adding -gdwarf-N options to cc1as.

[rengolin]

tools/llvm-mc/llvm-mc.cpp

412 ↗

(On Diff #6982)

This will give preference to Dwarf 4 irrespective of how many other flags are in the command line, even if they're after the -gdwarf-4.

[olista01]

I couldn't find any way to accept the last -gdwarf-N option in llvm-mc (without using clang's argument parsing), but this change makes it so that only one -gdwarf-N option can be used.

[olista01]

Ping?

[rengolin]

Hi Oliver,

I can't comment on the validity of taking only one option.

I think it's rather limiting, but this is an internal tool, so it should be fine.

I'll let others review the code.

cheers,
--renato

[keith.walker.arm]

I think that only allowing a single -gdwarf-N option to llvm-mc seems sensible to me, until a specific requirement to support mulitple instances is raised (and the work to support it can then be implemented when there is a specific requirement).

The code to support describing mulitple code sections in DWARF looks OK to me.

[rengolin]

Thanks Keith,

Oliver, LGTM.

--renato

[echristo]

What do you mean by a single option? What won't work?

[rengolin]

Eric,

Things like:

$ llvm-mc -gdwarf-2 -gdwarf-3 -gdwarf-4

llvm-mc doesn't have the tools Clang has for dealing with multiple contradictory compiler flags. Since llvm-mc is an internal tool, we don't need to deal with it, so just make it an error.

cheers,
--renato

[echristo]

Rename the option then. llvm-mc isn't attempting to be compatible with (or used as) an assembler interface except for testing. Just make it -dwarf-version or something.

Haven't had a chance to check the rest of the patch yet.

[rengolin]

That's another option, yes. I don't mind either way.

[echristo]

Added some comments. Thanks!

include/llvm/MC/MCContext.h

25

SetVector here perhaps? Stable iteration is important, but I'm not sure how many we expect here. I.e. are we expecting the full pain of large -ffunction-sections C++ or hand-written code?

138

debug_ranges yes?

383

80-columns?

384–389

We never check for NULL at the use. Either we should assert in the lookup routine or in the use, but we should check somehow.

lib/MC/MCDwarf.cpp

567–568

If we're using this for ranges and aranges then we should just pull it out into a separate "finalizeSections" routine or some such.

585–586

Update comment.

611–625

Needs a full sentence here :)

657

EmitInt16.

691

LineSectionSymbol?

806

Use consistent variable naming please.

885–886

Unrelatedly this seems like it should be near the top.

[echristo]

lib/MC/MCDwarf.cpp

897

Might want to make these two routines member functions rather than static and just have the variables be member variables. It should clean up a few conditionals in the patch.

912

Reword? Seems confusing as written.

916–918

Comment please.

lib/MC/MCParser/AsmParser.cpp

1583–1584

"for the current section and it contains code"?

1586–1587

Maybe just check if the section is a text section instead of looking up in the set?

lib/MC/MCParser/ELFAsmParser.cpp

548–565

Formatting seems odd. clang-format?

554

Formatting.

test/MC/ARM/dwarf-asm-multiple-sections.s

56 ↗

(On Diff #7059)

Check the relocations in the info section?

test/MC/ARM/dwarf-asm-nonstandard-section.s

44 ↗

(On Diff #7059)

Same here.

test/MC/ARM/dwarf-asm-single-section.s

44 ↗

(On Diff #7059)

Ditto.

test/MC/ARM/ldr-pseudo.s

19 ↗

(On Diff #7059)

What's going on here?

test/MC/ARM/ltorg.s

16 ↗

(On Diff #7059)

Ditto.

tools/llvm-mc/llvm-mc.cpp

156 ↗

(On Diff #7059)

Let's just use a different command line option where you can set it. There's no need to make it identical to an assembler.

[echristo]

I've replied to the patch in phabricator.

[olista01]

include/llvm/MC/MCContext.h

25

This set should stay small for sane use-cases. This code is only used when the input is an assembly file, there is a separate code path if we are generating native code from IR.

Done.

138

Both. Done.

383

Done

384–389

Done

lib/MC/MCDwarf.cpp

567–568

Done

585–586

Done

611–625

Done

657

EmitInt16 is a method of AsmPrinter, and we are not outputting assembly here. Every other place in this file uses EmitIntValue.

691

Done

806

Done

885–886

Done

897

Everything in this class is currently static, and there doesn't seem to be a big enough advantage to make the change.

912

Done

916–918

Done

lib/MC/MCParser/AsmParser.cpp

1583–1584

We are emitting an instruction, so the section contains code (or will do very soon).

1586–1587

Ditto

lib/MC/MCParser/ELFAsmParser.cpp

548–565

Done

554

Done

test/MC/ARM/dwarf-asm-multiple-sections.s

56 ↗

(On Diff #7059)

Done

test/MC/ARM/dwarf-asm-nonstandard-section.s

44 ↗

(On Diff #7059)

Done

test/MC/ARM/dwarf-asm-single-section.s

44 ↗

(On Diff #7059)

Done

test/MC/ARM/ldr-pseudo.s

19 ↗

(On Diff #7059)

These tests were broken by the extra symbol inserted to reference the beginning of each section, which changed anonymous symbol names.

test/MC/ARM/ltorg.s

16 ↗

(On Diff #7059)

Ditto

tools/llvm-mc/llvm-mc.cpp

156 ↗

(On Diff #7059)

We don't have to make it identical to the assembler, but I don't see a good reason to have a different option to clang, either. As it is now, we behave the exact same way as clang if the option is given 0 or 1 times, and give a sensible error message if it is given more than 1 time ("llvm-mc: for the -gdwarf-3 option: may only occur zero or one times").

[olista01]

Things mentioned in inline comments, plus:

• Don't check DWARF version if we are not generating DWARF
• Fix tests to not be dependent on length of compilation working dir
• Fix tests to match changes in output format of llvm-dwarfdump

[olista01]

Ping?

[olista01]

Ping?

[echristo]

Sorry, been trying to get to this. As you can see Dave is working in
the same file so you'll likely need to rebase your patch. I'd like to
get the refactoring I mentioned done first.

Let's split the testcase generalization out, and I really don't want
to add -gdwarf-N to llvm-mc.

-eric

[echristo]

lib/MC/MCDwarf.cpp

657

Seems sad. I guess that can be a refactor.

[olista01]

Rebased onto current trunk.

• Only minor changes needed, correcting offsets in the tests

[olista01]

Let's split the testcase generalization out

Done, see new dependency

I really don't want to add -gdwarf-N to llvm-mc

Why is that? I understand that we don't _have_ to maintain compatibility with clang, but I can't see a good reason not to. This way, the same options are accepted for the common cases (zero or one uses of -gdwarf-N), and an understandable error is thrown in the more complex case of multiple uses or it.

Seems sad. I guess that can be a refactor. (EmitIntValue -> EmitInt16)

Yes, but that would be a separate patch.

[rengolin]

Hi Oliver,

Independent of the other comments by Eric, I agree that -dwarf-version N would be simpler to implement in this case. The main point here is to provide the functionality, not command-line compatibility.

cheers,
--renato

[olista01]

Changed to make llvm-mc accept -dwarf-version N rather than -gdwarf-N.

[rengolin]

Hi Oliver,

This looks good to me.

--renato

[olista01]

echristo: ping?

[echristo]

This patch LGTM.

[olista01]

After rebasing, one test has started failing: test/MC/ELF/gen-dwarf.s. This was because we do not track which sections have had instructions emitted when we are emitting assembly (as opposed to object files). My patch was using this information to avoid emitting DWARF information for empty sections. Because of this, I have modified my patch to emit DWARF for all sections.

[echristo]

Could you pull the patch setting the dwarf version for the compile unit out into a separate patch? It seems pretty easily separable.

Some additional comments inline as well.

Thanks for all of the work here, it's shaping up nicely!

-eric

include/llvm/MC/MCContext.h

138

Do you mean debug_aranges or debug_ranges? You use aranges here and then DW_AT_ranges below.

386

Function names:

http://llvm.org/docs/CodingStandards.html#name-types-functions-variables-and-enumerators-properly

Also these functions appear to be a bit heavyweight to be defined inline. Bring them out of line?

lib/MC/MCDwarf.cpp

514

Is the argument necessary or can you use the same lookup you do in other places?

523–528

Same comment on ranges as below.

690

You still need a DW_AT_low_pc as the offset for the for the ranges section. Take a look at the code that does this for compile units in DwarfDebug.cpp (as of right now line 986) for a bit of an explanation.

800

I don't think we're likely to ever emit more than one range list for assembly files are we?

tools/llvm-mc/llvm-mc.cpp

157 ↗

(On Diff #8304)

3 is a bit odd in that it's not the same as the defaults for any target :)

[dblaikie]

General comments:

Test coverage:

1. a test case with more than one section, but only one section with instructions (it'd be nice for this not to use ranges, but just high_pc/low_pc)
2. a test case with more than one section, but at least two sections with instructions and at least one section without (just to make sure we can omit those sections while still including a ranges section with the other sections)

The refactoring into a single data structure containing a mapping from section to start/end symbols would be nice.

Probably a bridge too far, but this starts to look almost, sort of, like what we'd like to have for source level debugging handling too. It might be nice to consider a generic range list representation that can handle all the ranges and emission. Though source level debugging needs the concept of multiple ranges even in a single section, which is an added complication compared to this code.

include/llvm/MC/MCContext.h

139

Having 3 data structures all with the same key and related values is a bit of a pity. Could we get a struct (or even just a pair) of start/end symbol and have one map to that pair?

I assume "GenDwarfSections" is then just the key set from that map, right? So you don't need a separate data structure for that as well, you can just use the presence/absence in the map

Also - I assume the iteration order over the keys is important for stability of the output of the ranges section, so this might need to be a MapVector rather than just a DenseMap?

382

With the suggested data structure changes above, these get/set functions probably just turn into one or two functions (two if you need const overloads, one if you don't) that, given an MCSection* returns the pair/structure containing the start and end.

386

I think we can move to using nullptr these days - could just fix this in all places in your patch, but not strictly necessary I suppose.

391

If you do the "hasInstructions" check here then you could avoid creating end symbols and just remove the elements from the container entirely - that would address the issue of creating ranges with only one range later on, right?

lib/MC/MCDwarf.cpp

573

Perhaps rather than creating end labels, etc, for sections that don't have any instructions anyway, and using another data structure, we could just remove the element from the Sections set/map immediately - then iterate the map later on?

700

Would this break on an empty asm file (or one with only data, perhaps?)?

811

This SwitchSection call seems bogus/dangerous - if we ever leave the loop via the continue on the next line, then we'll emit the range terminator into the section we were just looking at, not the range section.

812

So this code would result in us possibly emitting a ranges section with only one range/section, right? (if there were multiple sections but only one turns out to have instructions)

That can probably be tidied up later, though.

852

Again, seems easier to just remove the sections that aren't relevant (& I'm not sure why this pass and the other one that checks for instructions and builds another data structure and closes ranges is separate - perhaps once the sections are just removed there won't be a need for two passes)

858

Seems like this could go in separately - if we have null begin/end data today (when we track only one range) we should do the same thing, right? Be good to just add that check (then rephrase it to the empty test here in the following commit) and test case first, possibly, maybe...

lib/MC/MCParser/ELFAsmParser.cpp

553

Rather than doing a count and then an insertion, you should just be able to insert and use the bool in the returned iterator/bool pair to determine if this is the first time the section has been added to the list.

557

What does GCC do here? (silently fall back to just describing the .text section?)

560

Shouldn't this condition be the same as the one above (ie: if the element isn't in the sections list it also doesn't have a start sym?) Seems unnecessary to do two lookups. (& based on the suggested data structure change this would be one insertion, check whether the insertion succeeded (because the element wasn't already present), then provide the necessary error and/or create the start symbol)

pair = sections.insert(make_pair(section, range()));
if (pair.second) {

if (dwarf <= 2 && sections > 1)
  error
start = createTempSymbol
emit(start);
pair.first->start = start;

}

Something like that anyway.

[olista01]

You still need a DW_AT_low_pc as the offset for the for the ranges section.

I don't think we need DW_AT_low_pc when the input is assembly, as it is optional in the DWARF spec and we do not emit any debug info which could use it.

The two reasons to include DW_AT_low_pc as well as DW_AT_ranges are:

• Specifying the default base address for the .debug_ranges section. We do not need this as we have a base address entry for each section in .debug_ranges, so the default never gets used.
• Specifying the default base address for the .debug_loc section. We do not need this as we never emit the .debug_loc section for an assembly file.

What does GCC do here?

GCC seems to do the same as I am doing:

• If no sections contain code, don't emit any debug info (not even .debug_abbrev)
• If exactly one section contains code, use low_pc and high_pc
• Otherwise, use .debug_ranges

[echristo]

Looks pretty good. I'd split the DwarfVersion out of this commit and go ahead and put that in separately.

The rest of the patch looks good outside of the comments and the discussion about address base that is going on.

Thanks for all of the work!

lib/MC/MCContext.cpp

32

Extraneous whitespace addition.

342

Comment what's going on in the function.

345

auto?

lib/MC/MCDwarf.cpp

657

This can go in separately yes?

lib/MC/MCParser/ELFAsmParser.cpp

552

Think this can probably go in separately along with the refactor you've done for the section handling. If it doesn't make sense don't worry about it.

[olista01]

I have split out the setting of the dwarf version into D3399.

[echristo]

As far as the Address Base:

That's weird. It's strictly larger to do it this way and using an offset of 0 is the same effect for this case and what gcc does if you _don't_ just assemble it. (since, of course, it's actually gas making this decision).

So I don't see what using an offset gets us in this case versus using DW_AT_low_pc other than bit identical output to gas.

[olista01]

Sorry, I let this patch slip off my radar, but I'm still interested in progressing it.

So I don't see what using an offset gets us in this case versus using DW_AT_low_pc other than bit identical output to gas.

If I understand it correctly, you are suggesting using the DW_AT_low_pc as the base address for the first range, and a base address selection entry to set the base address of each subsequent range (each range covers one code section). This seems like unnecessary complexity for the sake of 4 bytes. Also, the size of the abbrev will be increased by adding DW_AT_low_pc, reducing the size difference.

[olista01]

Ping?

[olista01]

Ping?

[olista01]

Thanks, committed revision 211273.

[dblaikie]

Sounds like this message caused a bug:
http://llvm.org/bugs/show_bug.cgi?id=20879

include/llvm/ADT/MapVector.h

public:
   }
 
   /// \brief Remove the last element from the vector.
   void pop_back() {
     typename MapType::iterator Pos = Map.find(Vector.back().first);
     Map.erase(Pos);
     Vector.pop_back();
   }
+
+  /// \brief Remove the element given by Iterator.
+  /// Returns an iterator to the element following the one which was removed,
+  /// which may be end().
+  typename VectorType::iterator erase(typename VectorType::iterator Iterator) {
+    typename MapType::iterator MapIterator = Map.find(Iterator->first);
+    Map.erase(MapIterator);
+    return Vector.erase(Iterator);
+  }
 };
 
 }
 
 #endif

include/llvm/MC/MCContext.h

 //===- MCContext.h - Machine Code Context -----------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_MC_MCCONTEXT_H
 #define LLVM_MC_MCCONTEXT_H
 
 #include "llvm/ADT/DenseMap.h"
+#include "llvm/ADT/SetVector.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/MC/MCDwarf.h"
+#include "llvm/MC/MCStreamer.h"
 #include "llvm/MC/SectionKind.h"
 #include "llvm/Support/Allocator.h"
 #include "llvm/Support/Compiler.h"
 #include "llvm/Support/raw_ostream.h"
 #include <map>
 #include <vector> // FIXME: Shouldn't be needed.
 
 namespace llvm {
   class MCAsmInfo;
   class MCExpr;
   class MCSection;
   class MCSymbol;
   class MCLabel;
   struct MCDwarfFile;
private:
 
     /// Generate dwarf debugging info for assembly source files.
     bool GenDwarfForAssembly;
 
     /// The current dwarf file number when generate dwarf debugging info for
     /// assembly source files.
     unsigned GenDwarfFileNumber;
 
-    /// The default initial text section that we generate dwarf debugging line
-    /// info for when generating dwarf assembly source files.
-    const MCSection *GenDwarfSection;
-    /// Symbols created for the start and end of this section.
-    MCSymbol *GenDwarfSectionStartSym, *GenDwarfSectionEndSym;
+    /// Symbols created for the start and end of each section, used for
+    /// generating the .debug_ranges and .debug_aranges sections.
+    MapVector<const MCSection *, std::pair<MCSymbol *, MCSymbol *> >
+    SectionStartEndSyms;
 
     /// The information gathered from labels that will have dwarf label
     /// entries when generating dwarf assembly source files.
     std::vector<MCGenDwarfLabelEntry> MCGenDwarfLabelEntries;
 
     /// The string to embed in the debug information for the compile unit, if
     /// non-empty.
     StringRef DwarfDebugFlags;
 
     /// The string to embed in as the dwarf AT_producer for the compile unit, if
public:
     const MCDwarfLoc &getCurrentDwarfLoc() { return CurrentDwarfLoc; }
 
     bool getGenDwarfForAssembly() { return GenDwarfForAssembly; }
     void setGenDwarfForAssembly(bool Value) { GenDwarfForAssembly = Value; }
     unsigned getGenDwarfFileNumber() { return GenDwarfFileNumber; }
     void setGenDwarfFileNumber(unsigned FileNumber) {
       GenDwarfFileNumber = FileNumber;
     }
-    const MCSection *getGenDwarfSection() { return GenDwarfSection; }
-    void setGenDwarfSection(const MCSection *Sec) { GenDwarfSection = Sec; }
-    MCSymbol *getGenDwarfSectionStartSym() { return GenDwarfSectionStartSym; }
-    void setGenDwarfSectionStartSym(MCSymbol *Sym) {
-      GenDwarfSectionStartSym = Sym;
-    }
-    MCSymbol *getGenDwarfSectionEndSym() { return GenDwarfSectionEndSym; }
-    void setGenDwarfSectionEndSym(MCSymbol *Sym) {
-      GenDwarfSectionEndSym = Sym;
+    MapVector<const MCSection *, std::pair<MCSymbol *, MCSymbol *> > &
+    getGenDwarfSectionSyms() {
+      return SectionStartEndSyms;
+    }
+    std::pair<MapVector<const MCSection *,
+                        std::pair<MCSymbol *, MCSymbol *> >::iterator,
+              bool>
+    addGenDwarfSection(const MCSection *Sec) {
+      return SectionStartEndSyms.insert(
+          std::make_pair(Sec, std::make_pair(nullptr, nullptr)));
     }
+    void finalizeDwarfSections(MCStreamer &MCOS);
     const std::vector<MCGenDwarfLabelEntry> &getMCGenDwarfLabelEntries() const {
       return MCGenDwarfLabelEntries;
     }
     void addMCGenDwarfLabelEntry(const MCGenDwarfLabelEntry &E) {
       MCGenDwarfLabelEntries.push_back(E);
     }
 
     void setDwarfDebugFlags(StringRef S) { DwarfDebugFlags = S; }

include/llvm/MC/MCObjectStreamer.h

void EmitDwarfAdvanceLineAddr(int64_t LineDelta, const MCSymbol *LastLabel,
                                 unsigned PointerSize) override;
   void EmitDwarfAdvanceFrameAddr(const MCSymbol *LastLabel,
                                  const MCSymbol *Label) override;
   void EmitGPRel32Value(const MCExpr *Value) override;
   void EmitGPRel64Value(const MCExpr *Value) override;
   void EmitFill(uint64_t NumBytes, uint8_t FillValue) override;
   void EmitZeros(uint64_t NumBytes) override;
   void FinishImpl() override;
+
+  virtual bool mayHaveInstructions() const {
+    return getCurrentSectionData()->hasInstructions();
+  }
 };
 
 } // end namespace llvm
 
 #endif

include/llvm/MC/MCStreamer.h

public:
 
   /// Flush - Causes any cached state to be written out.
   virtual void Flush() {}
 
   /// FinishImpl - Streamer specific finalization.
   virtual void FinishImpl() = 0;
   /// Finish - Finish emission of machine code.
   void Finish();
+
+  virtual bool mayHaveInstructions() const { return true; }
 };
 
 /// createNullStreamer - Create a dummy machine code streamer, which does
 /// nothing. This is useful for timing the assembler front end.
 MCStreamer *createNullStreamer(MCContext &Ctx);
 
 /// createAsmStreamer - Create a machine code streamer which will print out
 /// assembly for the native target, suitable for compiling with a native

lib/MC/MCContext.cpp

 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/Signals.h"
 #include "llvm/Support/SourceMgr.h"
 #include <map>
 
 using namespace llvm;
 
 MCContext::MCContext(const MCAsmInfo *mai, const MCRegisterInfo *mri,
                      const MCObjectFileInfo *mofi, const SourceMgr *mgr,
                      bool DoAutoReset)
     : SrcMgr(mgr), MAI(mai), MRI(mri), MOFI(mofi), Allocator(),
       Symbols(Allocator), UsedNames(Allocator), NextUniqueID(0),
       CurrentDwarfLoc(0, 0, 0, DWARF2_FLAG_IS_STMT, 0, 0), DwarfLocSeen(false),
       GenDwarfForAssembly(false), GenDwarfFileNumber(0),
       AllowTemporaryLabels(true), DwarfCompileUnitID(0),
       AutoReset(DoAutoReset) {

 bool MCContext::isValidDwarfFileNumber(unsigned FileNumber, unsigned CUID) {
   const SmallVectorImpl<MCDwarfFile>& MCDwarfFiles = getMCDwarfFiles(CUID);
   if(FileNumber == 0 || FileNumber >= MCDwarfFiles.size())
     return false;
 
   return !MCDwarfFiles[FileNumber].Name.empty();
 }
 
+/// finalizeDwarfSections - Emit end symbols for each non-empty code section.
+/// Also remove empty sections from SectionStartEndSyms, to avoid generating
+/// useless debug info for them.
+void MCContext::finalizeDwarfSections(MCStreamer &MCOS) {
+  MCContext &context = MCOS.getContext();
+
+  auto sec = SectionStartEndSyms.begin();
+  while (sec != SectionStartEndSyms.end()) {
+    assert(sec->second.first && "Start symbol must be set by now");
+    MCOS.SwitchSection(sec->first);
+    if (MCOS.mayHaveInstructions()) {
+      MCSymbol *SectionEndSym = context.CreateTempSymbol();
+      MCOS.EmitLabel(SectionEndSym);
+      sec->second.second = SectionEndSym;
+      ++sec;
+    } else {
+      MapVector<const MCSection *, std::pair<MCSymbol *, MCSymbol *> >::iterator
+        to_erase = sec;
+      sec = SectionStartEndSyms.erase(to_erase);
+    }
+  }
+}
+
 void MCContext::FatalError(SMLoc Loc, const Twine &Msg) {
   // If we have a source manager and a location, use it. Otherwise just
   // use the generic report_fatal_error().
   if (!SrcMgr || Loc == SMLoc())
     report_fatal_error(Msg, false);
 
   // Use the source manager to print the message.
   SrcMgr->PrintMessage(Loc, SourceMgr::DK_Error, Msg);
 
   // If we reached here, we are failing ungracefully. Run the interrupt handlers
   // to make sure any special cleanups get done, in particular that we remove
   // files registered with RemoveFileOnSignal.
   sys::RunInterruptHandlers();
   exit(1);
 }

lib/MC/MCDwarf.cpp

 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/Twine.h"
 #include "llvm/Config/config.h"
 #include "llvm/MC/MCAsmInfo.h"
 #include "llvm/MC/MCContext.h"
 #include "llvm/MC/MCExpr.h"
 #include "llvm/MC/MCObjectFileInfo.h"
+#include "llvm/MC/MCObjectStreamer.h"
 #include "llvm/MC/MCRegisterInfo.h"
+#include "llvm/MC/MCSection.h"
 #include "llvm/MC/MCStreamer.h"
 #include "llvm/MC/MCSymbol.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/LEB128.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/SourceMgr.h"
 #include "llvm/Support/raw_ostream.h"

 // Utility function to write a tuple for .debug_abbrev.
 static void EmitAbbrev(MCStreamer *MCOS, uint64_t Name, uint64_t Form) {
   MCOS->EmitULEB128IntValue(Name);
   MCOS->EmitULEB128IntValue(Form);
 }
 
 // When generating dwarf for assembly source files this emits
 // the data for .debug_abbrev section which contains three DIEs.
 static void EmitGenDwarfAbbrev(MCStreamer *MCOS) {
   MCContext &context = MCOS->getContext();
   MCOS->SwitchSection(context.getObjectFileInfo()->getDwarfAbbrevSection());
 
   // DW_TAG_compile_unit DIE abbrev (1).
   MCOS->EmitULEB128IntValue(1);
   MCOS->EmitULEB128IntValue(dwarf::DW_TAG_compile_unit);
   MCOS->EmitIntValue(dwarf::DW_CHILDREN_yes, 1);
   EmitAbbrev(MCOS, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4);
+  if (MCOS->getContext().getGenDwarfSectionSyms().size() > 1) {
+    EmitAbbrev(MCOS, dwarf::DW_AT_ranges, dwarf::DW_FORM_data4);
+  } else {
     EmitAbbrev(MCOS, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr);
     EmitAbbrev(MCOS, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr);
+  }
   EmitAbbrev(MCOS, dwarf::DW_AT_name, dwarf::DW_FORM_string);
   if (!context.getCompilationDir().empty())
     EmitAbbrev(MCOS, dwarf::DW_AT_comp_dir, dwarf::DW_FORM_string);
   StringRef DwarfDebugFlags = context.getDwarfDebugFlags();
   if (!DwarfDebugFlags.empty())
     EmitAbbrev(MCOS, dwarf::DW_AT_APPLE_flags, dwarf::DW_FORM_string);
   EmitAbbrev(MCOS, dwarf::DW_AT_producer, dwarf::DW_FORM_string);
   EmitAbbrev(MCOS, dwarf::DW_AT_language, dwarf::DW_FORM_data2);
static void EmitGenDwarfAbbrev(MCStreamer *MCOS) {
   MCOS->EmitIntValue(dwarf::DW_CHILDREN_no, 1);
   EmitAbbrev(MCOS, 0, 0);
 
   // Terminate the abbreviations for this compilation unit.
   MCOS->EmitIntValue(0, 1);
 }
 
 // When generating dwarf for assembly source files this emits the data for
-// .debug_aranges section.  Which contains a header and a table of pairs of
-// PointerSize'ed values for the address and size of section(s) with line table
-// entries (just the default .text in our case) and a terminating pair of zeros.
+// .debug_aranges section. This section contains a header and a table of pairs
+// of PointerSize'ed values for the address and size of section(s) with line
+// table entries.
 static void EmitGenDwarfAranges(MCStreamer *MCOS,
                                 const MCSymbol *InfoSectionSymbol) {
   MCContext &context = MCOS->getContext();
 
-  // Create a symbol at the end of the section that we are creating the dwarf
-  // debugging info to use later in here as part of the expression to calculate
-  // the size of the section for the table.
-  MCOS->SwitchSection(context.getGenDwarfSection());
-  MCSymbol *SectionEndSym = context.CreateTempSymbol();
-  MCOS->EmitLabel(SectionEndSym);
-  context.setGenDwarfSectionEndSym(SectionEndSym);
+  auto &Sections = context.getGenDwarfSectionSyms();
 
   MCOS->SwitchSection(context.getObjectFileInfo()->getDwarfARangesSection());
 
   // This will be the length of the .debug_aranges section, first account for
   // the size of each item in the header (see below where we emit these items).
   int Length = 4 + 2 + 4 + 1 + 1;
 
   // Figure the padding after the header before the table of address and size
   // pairs who's values are PointerSize'ed.
   const MCAsmInfo *asmInfo = context.getAsmInfo();
   int AddrSize = asmInfo->getPointerSize();
   int Pad = 2 * AddrSize - (Length & (2 * AddrSize - 1));
   if (Pad == 2 * AddrSize)
     Pad = 0;
   Length += Pad;
 
   // Add the size of the pair of PointerSize'ed values for the address and size
-  // of the one default .text section we have in the table.
-  Length += 2 * AddrSize;
+  // of each section we have in the table.
+  Length += 2 * AddrSize * Sections.size();
   // And the pair of terminating zeros.
   Length += 2 * AddrSize;
 
 
   // Emit the header for this section.
   // The 4 byte length not including the 4 byte value for the length.
   MCOS->EmitIntValue(Length - 4, 4);
   // The 2 byte version, which is 2.
   MCOS->EmitIntValue(2, 2);
   // The 4 byte offset to the compile unit in the .debug_info from the start
   // of the .debug_info.
   if (InfoSectionSymbol)
     MCOS->EmitSymbolValue(InfoSectionSymbol, 4);
   else
     MCOS->EmitIntValue(0, 4);
   // The 1 byte size of an address.
   MCOS->EmitIntValue(AddrSize, 1);
   // The 1 byte size of a segment descriptor, we use a value of zero.
   MCOS->EmitIntValue(0, 1);
   // Align the header with the padding if needed, before we put out the table.
   for(int i = 0; i < Pad; i++)
     MCOS->EmitIntValue(0, 1);
 
-  // Now emit the table of pairs of PointerSize'ed values for the section(s)
-  // address and size, in our case just the one default .text section.
+  // Now emit the table of pairs of PointerSize'ed values for the section
+  // addresses and sizes.
+  for (const auto &sec : Sections) {
+    MCSymbol* StartSymbol = sec.second.first;
+    MCSymbol* EndSymbol = sec.second.second;
+    assert(StartSymbol && "StartSymbol must not be NULL");
+    assert(EndSymbol && "EndSymbol must not be NULL");
+
     const MCExpr *Addr = MCSymbolRefExpr::Create(
-    context.getGenDwarfSectionStartSym(), MCSymbolRefExpr::VK_None, context);
+      StartSymbol, MCSymbolRefExpr::VK_None, context);
     const MCExpr *Size = MakeStartMinusEndExpr(*MCOS,
-    *context.getGenDwarfSectionStartSym(), *SectionEndSym, 0);
+      *StartSymbol, *EndSymbol, 0);
     MCOS->EmitValue(Addr, AddrSize);
     MCOS->EmitAbsValue(Size, AddrSize);
+  }
 
   // And finally the pair of terminating zeros.
   MCOS->EmitIntValue(0, AddrSize);
   MCOS->EmitIntValue(0, AddrSize);
 }
 
 // When generating dwarf for assembly source files this emits the data for
 // .debug_info section which contains three parts.  The header, the compile_unit
 // DIE and a list of label DIEs.
 static void EmitGenDwarfInfo(MCStreamer *MCOS,
                              const MCSymbol *AbbrevSectionSymbol,
-                             const MCSymbol *LineSectionSymbol) {
+                             const MCSymbol *LineSectionSymbol,
+                             const MCSymbol *RangesSectionSymbol) {
   MCContext &context = MCOS->getContext();
 
   MCOS->SwitchSection(context.getObjectFileInfo()->getDwarfInfoSection());
 
   // Create a symbol at the start and end of this section used in here for the
   // expression to calculate the length in the header.
   MCSymbol *InfoStart = context.CreateTempSymbol();
   MCOS->EmitLabel(InfoStart);
   MCSymbol *InfoEnd = context.CreateTempSymbol();
 
   // First part: the header.
 
   // The 4 byte total length of the information for this compilation unit, not
   // including these 4 bytes.
   const MCExpr *Length = MakeStartMinusEndExpr(*MCOS, *InfoStart, *InfoEnd, 4);
   MCOS->EmitAbsValue(Length, 4);
 
   // The 2 byte DWARF version.
   MCOS->EmitIntValue(context.getDwarfVersion(), 2);
 
   // The 4 byte offset to the debug abbrevs from the start of the .debug_abbrev,
   // it is at the start of that section so this is zero.
   if (AbbrevSectionSymbol) {
     MCOS->EmitSymbolValue(AbbrevSectionSymbol, 4);
   } else {
     MCOS->EmitIntValue(0, 4);
   }
static void EmitGenDwarfInfo(MCStreamer *MCOS,
   // DW_AT_stmt_list, a 4 byte offset from the start of the .debug_line section,
   // which is at the start of that section so this is zero.
   if (LineSectionSymbol) {
     MCOS->EmitSymbolValue(LineSectionSymbol, 4);
   } else {
     MCOS->EmitIntValue(0, 4);
   }
 
+  if (RangesSectionSymbol) {
+    // There are multiple sections containing code, so we must use the
+    // .debug_ranges sections.
+
+    // AT_ranges, the 4 byte offset from the start of the .debug_ranges section
+    // to the address range list for this compilation unit.
+    MCOS->EmitSymbolValue(RangesSectionSymbol, 4);
+  } else {
+    // If we only have one non-empty code section, we can use the simpler
+    // AT_low_pc and AT_high_pc attributes.
+
+    // Find the first (and only) non-empty text section
+    auto &Sections = context.getGenDwarfSectionSyms();
+    const auto TextSection = Sections.begin();
+    assert(TextSection != Sections.end() && "No text section found");
+
+    MCSymbol* StartSymbol = TextSection->second.first;
+    MCSymbol* EndSymbol = TextSection->second.second;
+    assert(StartSymbol && "StartSymbol must not be NULL");
+    assert(EndSymbol && "EndSymbol must not be NULL");
+
     // AT_low_pc, the first address of the default .text section.
     const MCExpr *Start = MCSymbolRefExpr::Create(
-    context.getGenDwarfSectionStartSym(), MCSymbolRefExpr::VK_None, context);
+        StartSymbol, MCSymbolRefExpr::VK_None, context);
     MCOS->EmitValue(Start, AddrSize);
 
     // AT_high_pc, the last address of the default .text section.
     const MCExpr *End = MCSymbolRefExpr::Create(
-    context.getGenDwarfSectionEndSym(), MCSymbolRefExpr::VK_None, context);
+      EndSymbol, MCSymbolRefExpr::VK_None, context);
     MCOS->EmitValue(End, AddrSize);
+  }
 
   // AT_name, the name of the source file.  Reconstruct from the first directory
   // and file table entries.
   const SmallVectorImpl<std::string> &MCDwarfDirs = context.getMCDwarfDirs();
   if (MCDwarfDirs.size() > 0) {
     MCOS->EmitBytes(MCDwarfDirs[0]);
     MCOS->EmitBytes("/");
   }
static void EmitGenDwarfInfo(MCStreamer *MCOS,
 
   // Add the NULL DIE terminating the Compile Unit DIE's.
   MCOS->EmitIntValue(0, 1);
 
   // Now set the value of the symbol at the end of the info section.
   MCOS->EmitLabel(InfoEnd);
 }
 
+// When generating dwarf for assembly source files this emits the data for
+// .debug_ranges section. We only emit one range list, which spans all of the
+// executable sections of this file.
+static void EmitGenDwarfRanges(MCStreamer *MCOS) {
+  MCContext &context = MCOS->getContext();
+  auto &Sections = context.getGenDwarfSectionSyms();
+
+  const MCAsmInfo *AsmInfo = context.getAsmInfo();
+  int AddrSize = AsmInfo->getPointerSize();
+
+  MCOS->SwitchSection(context.getObjectFileInfo()->getDwarfRangesSection());
+
+  for (const auto sec : Sections) {
+
+    MCSymbol* StartSymbol = sec.second.first;
+    MCSymbol* EndSymbol = sec.second.second;
+    assert(StartSymbol && "StartSymbol must not be NULL");
+    assert(EndSymbol && "EndSymbol must not be NULL");
+
+    // Emit a base address selection entry for the start of this section
+    const MCExpr *SectionStartAddr = MCSymbolRefExpr::Create(
+      StartSymbol, MCSymbolRefExpr::VK_None, context);
+    MCOS->EmitFill(AddrSize, 0xFF);
+    MCOS->EmitValue(SectionStartAddr, AddrSize);
+
+    // Emit a range list entry spanning this section
+    const MCExpr *SectionSize = MakeStartMinusEndExpr(*MCOS,
+      *StartSymbol, *EndSymbol, 0);
+    MCOS->EmitIntValue(0, AddrSize);
+    MCOS->EmitAbsValue(SectionSize, AddrSize);
+  }
+
+  // Emit end of list entry
+  MCOS->EmitIntValue(0, AddrSize);
+  MCOS->EmitIntValue(0, AddrSize);
+}
+
 //
 // When generating dwarf for assembly source files this emits the Dwarf
 // sections.
 //
 void MCGenDwarfInfo::Emit(MCStreamer *MCOS) {
-  // Create the dwarf sections in this order (.debug_line already created).
   MCContext &context = MCOS->getContext();
+
+  // Create the dwarf sections in this order (.debug_line already created).
   const MCAsmInfo *AsmInfo = context.getAsmInfo();
   bool CreateDwarfSectionSymbols =
       AsmInfo->doesDwarfUseRelocationsAcrossSections();
   MCSymbol *LineSectionSymbol = nullptr;
   if (CreateDwarfSectionSymbols)
     LineSectionSymbol = MCOS->getDwarfLineTableSymbol(0);
   MCSymbol *AbbrevSectionSymbol = nullptr;
   MCSymbol *InfoSectionSymbol = nullptr;
+  MCSymbol *RangesSectionSymbol = NULL;
+
+  // Create end symbols for each section, and remove empty sections
+  MCOS->getContext().finalizeDwarfSections(*MCOS);
+
+  // If there are no sections to generate debug info for, we don't need
+  // to do anything
+  if (MCOS->getContext().getGenDwarfSectionSyms().empty())
+    return;
+
+  // We only need to use the .debug_ranges section if we have multiple
+  // code sections.
+  const bool UseRangesSection =
+      MCOS->getContext().getGenDwarfSectionSyms().size() > 1;
+  CreateDwarfSectionSymbols |= UseRangesSection;
+
   MCOS->SwitchSection(context.getObjectFileInfo()->getDwarfInfoSection());
   if (CreateDwarfSectionSymbols) {
     InfoSectionSymbol = context.CreateTempSymbol();
     MCOS->EmitLabel(InfoSectionSymbol);
   }
   MCOS->SwitchSection(context.getObjectFileInfo()->getDwarfAbbrevSection());
   if (CreateDwarfSectionSymbols) {
     AbbrevSectionSymbol = context.CreateTempSymbol();
     MCOS->EmitLabel(AbbrevSectionSymbol);
   }
-  MCOS->SwitchSection(context.getObjectFileInfo()->getDwarfARangesSection());
+  if (UseRangesSection) {
+    MCOS->SwitchSection(context.getObjectFileInfo()->getDwarfRangesSection());
+    if (CreateDwarfSectionSymbols) {
+      RangesSectionSymbol = context.CreateTempSymbol();
+      MCOS->EmitLabel(RangesSectionSymbol);
+    }
+  }
 
-  // If there are no line table entries then do not emit any section contents.
-  if (!context.hasMCLineSections())
-    return;
+  assert((RangesSectionSymbol != NULL) || !UseRangesSection);
+
+  MCOS->SwitchSection(context.getObjectFileInfo()->getDwarfARangesSection());
 
   // Output the data for .debug_aranges section.
   EmitGenDwarfAranges(MCOS, InfoSectionSymbol);
 
+  if (UseRangesSection)
+    EmitGenDwarfRanges(MCOS);
+
   // Output the data for .debug_abbrev section.
   EmitGenDwarfAbbrev(MCOS);
 
   // Output the data for .debug_info section.
-  EmitGenDwarfInfo(MCOS, AbbrevSectionSymbol, LineSectionSymbol);
+  EmitGenDwarfInfo(MCOS, AbbrevSectionSymbol, LineSectionSymbol,
+                   RangesSectionSymbol);
 }
 
 //
 // When generating dwarf for assembly source files this is called when symbol
 // for a label is created.  If this symbol is not a temporary and is in the
 // section that dwarf is being generated for, save the needed info to create
 // a dwarf label.
 //
 void MCGenDwarfLabelEntry::Make(MCSymbol *Symbol, MCStreamer *MCOS,
                                      SourceMgr &SrcMgr, SMLoc &Loc) {
-  // We won't create dwarf labels for temporary symbols or symbols not in
-  // the default text.
+  // We won't create dwarf labels for temporary symbols.
   if (Symbol->isTemporary())
     return;
   MCContext &context = MCOS->getContext();
-  if (context.getGenDwarfSection() != MCOS->getCurrentSection().first)
+  // We won't create dwarf labels for symbols in sections that we are not
+  // generating debug info for.
+  if (!context.getGenDwarfSectionSyms().count(MCOS->getCurrentSection().first))
     return;
 
   // The dwarf label's name does not have the symbol name's leading
   // underbar if any.
   StringRef Name = Symbol->getName();
   if (Name.startswith("_"))
     Name = Name.substr(1, Name.size()-1);
 

lib/MC/MCParser/AsmParser.cpp

bool AsmParser::Run(bool NoInitialTextSection, bool NoFinalize) {
   Lex();
 
   HadError = false;
   AsmCond StartingCondState = TheCondState;
 
   // If we are generating dwarf for assembly source files save the initial text
   // section and generate a .file directive.
   if (getContext().getGenDwarfForAssembly()) {
-    getContext().setGenDwarfSection(getStreamer().getCurrentSection().first);
     MCSymbol *SectionStartSym = getContext().CreateTempSymbol();
     getStreamer().EmitLabel(SectionStartSym);
-    getContext().setGenDwarfSectionStartSym(SectionStartSym);
+    auto InsertResult = getContext().addGenDwarfSection(
+        getStreamer().getCurrentSection().first);
+    assert(InsertResult.second && ".text section should not have debug info yet");
+    InsertResult.first->second.first = SectionStartSym;
     getContext().setGenDwarfFileNumber(getStreamer().EmitDwarfFileDirective(
         0, StringRef(), getContext().getMainFileName()));
   }
 
   // While we have input, parse each statement.
   while (Lexer.isNot(AsmToken::Eof)) {
     ParseStatementInfo Info;
     if (!parseStatement(Info))
for (unsigned i = 0; i != Info.ParsedOperands.size(); ++i) {
         OS << ", ";
       Info.ParsedOperands[i]->print(OS);
     }
     OS << "]";
 
     printMessage(IDLoc, SourceMgr::DK_Note, OS.str());
   }
 
-  // If we are generating dwarf for assembly source files and the current
-  // section is the initial text section then generate a .loc directive for
-  // the instruction.
+  // If we are generating dwarf for the current section then generate a .loc
+  // directive for the instruction.
   if (!HadError && getContext().getGenDwarfForAssembly() &&
-      getContext().getGenDwarfSection() ==
-          getStreamer().getCurrentSection().first) {
+      getContext().getGenDwarfSectionSyms().count(
+        getStreamer().getCurrentSection().first)) {
 
     unsigned Line = SrcMgr.FindLineNumber(IDLoc, CurBuffer);
 
     // If we previously parsed a cpp hash file line comment then make sure the
     // current Dwarf File is for the CppHashFilename if not then emit the
     // Dwarf File table for it and adjust the line number for the .loc.
     if (CppHashFilename.size() != 0) {
       unsigned FileNumber = getStreamer().EmitDwarfFileDirective(
for (unsigned Parameter = 0; !NParameters || Parameter < NParameters;
     unsigned PI = Parameter;
     if (!FA.Name.empty()) {
       unsigned FAI = 0;
       for (FAI = 0; FAI < NParameters; ++FAI)
         if (M->Parameters[FAI].Name == FA.Name)
           break;
 
       if (FAI >= NParameters) {
-  assert(M && "expected macro to be defined");
+    assert(M && "expected macro to be defined");
         Error(IDLoc,
               "parameter named '" + FA.Name + "' does not exist for macro '" +
               M->Name + "'");
         return true;
       }
       PI = FAI;
     }
 

lib/MC/MCParser/ELFAsmParser.cpp

public:
   bool ParseDirectiveSymver(StringRef, SMLoc);
   bool ParseDirectiveVersion(StringRef, SMLoc);
   bool ParseDirectiveWeakref(StringRef, SMLoc);
   bool ParseDirectiveSymbolAttribute(StringRef, SMLoc);
   bool ParseDirectiveSubsection(StringRef, SMLoc);
 
 private:
   bool ParseSectionName(StringRef &SectionName);
-  bool ParseSectionArguments(bool IsPush);
+  bool ParseSectionArguments(bool IsPush, SMLoc loc);
   unsigned parseSunStyleSectionFlags();
 };
 
 }
 
 /// ParseDirectiveSymbolAttribute
 ///  ::= { ".local", ".weak", ... } [ identifier ( , identifier )* ]
 bool ELFAsmParser::ParseDirectiveSymbolAttribute(StringRef Directive, SMLoc) {
unsigned ELFAsmParser::parseSunStyleSectionFlags() {
   }
   return flags;
 }
 
 
 bool ELFAsmParser::ParseDirectivePushSection(StringRef s, SMLoc loc) {
   getStreamer().PushSection();
 
-  if (ParseSectionArguments(/*IsPush=*/true)) {
+  if (ParseSectionArguments(/*IsPush=*/true, loc)) {
     getStreamer().PopSection();
     return true;
   }
 
   return false;
 }
 
 bool ELFAsmParser::ParseDirectivePopSection(StringRef, SMLoc) {
   if (!getStreamer().PopSection())
     return TokError(".popsection without corresponding .pushsection");
   return false;
 }
 
 // FIXME: This is a work in progress.
-bool ELFAsmParser::ParseDirectiveSection(StringRef, SMLoc) {
-  return ParseSectionArguments(/*IsPush=*/false);
+bool ELFAsmParser::ParseDirectiveSection(StringRef, SMLoc loc) {
+  return ParseSectionArguments(/*IsPush=*/false, loc);
 }
 
-bool ELFAsmParser::ParseSectionArguments(bool IsPush) {
+bool ELFAsmParser::ParseSectionArguments(bool IsPush, SMLoc loc) {
   StringRef SectionName;
 
   if (ParseSectionName(SectionName))
     return TokError("expected identifier in directive");
 
   StringRef TypeName;
   int64_t Size = 0;
   StringRef GroupName;
if (const MCSectionELF *Section =
             cast_or_null<MCSectionELF>(CurrentSection.first))
       if (const MCSymbol *Group = Section->getGroup()) {
         GroupName = Group->getName();
         Flags |= ELF::SHF_GROUP;
       }
   }
 
   SectionKind Kind = computeSectionKind(Flags, Size);
-  getStreamer().SwitchSection(getContext().getELFSection(SectionName, Type,
-                                                         Flags, Kind, Size,
-                                                         GroupName),
-                              Subsection);
+  const MCSection *ELFSection = getContext().getELFSection(
+      SectionName, Type, Flags, Kind, Size, GroupName);
+  getStreamer().SwitchSection(ELFSection, Subsection);
+
+  if (getContext().getGenDwarfForAssembly()) {
+    auto &Sections = getContext().getGenDwarfSectionSyms();
+    auto InsertResult = Sections.insert(
+        std::make_pair(ELFSection, std::make_pair(nullptr, nullptr)));
+    if (InsertResult.second) {
+      if (getContext().getDwarfVersion() <= 2)
+        Error(loc, "DWARF2 only supports one section per compilation unit");
+
+      MCSymbol *SectionStartSymbol = getContext().CreateTempSymbol();
+      getStreamer().EmitLabel(SectionStartSymbol);
+      InsertResult.first->second.first = SectionStartSymbol;
+    }
+  }
+
   return false;
 }
 
 bool ELFAsmParser::ParseDirectivePrevious(StringRef DirName, SMLoc) {
   MCSectionSubPair PreviousSection = getStreamer().getPreviousSection();
   if (PreviousSection.first == NULL)
       return TokError(".previous without corresponding .section");
   getStreamer().SwitchSection(PreviousSection.first, PreviousSection.second);