Commit 44deaf7e authored by Alex Bradbury's avatar Alex Bradbury
Browse files

[DWARF][RISCV] Add support for RISC-V relocations needed for debug info 

When code relaxation is enabled many RISC-V fixups are not resolved but
instead relocations are emitted. This happens even for DWARF debug
sections. Therefore, to properly support the parsing of DWARF debug info
we need to be able to resolve RISC-V relocations. This patch adds:

* Support for RISC-V relocations in RelocationResolver
* DWARF support for two relocations per object file offset
* DWARF changes to support relocations in more DIE fields

The two relocations per offset change is needed because some RISC-V
relocations (used for label differences) come in pairs.

Relocations can also be emitted for DWARF fields where relocations were
not yet evaluated. Adding relocation support for some of these fields is
essencial. On the other hand, LLVM currently emits RISC-V relocations
for fixups that could be safely evaluated, since they can never be
affected by code relaxations. This patch also adds relocation support
for the fields affected by those extraneous relocations (the DWARF unit
entry Length, and the DWARF debug line entry TotalLength and
PrologueLength), for testing purposes.

Differential Revision: https://reviews.llvm.org/D62062
Patch by Luís Marques.

llvm-svn: 366402
parent 1d5cbb75

lld/ELF/DWARF.cpp

+2 −1
Original line number Diff line number Diff line
@@ -110,7 +110,8 @@ LLDDwarfObj<ELFT>::findAux(const InputSectionBase &sec, uint64_t pos, 
  DataRefImpl d;

  d.p = getAddend<ELFT>(rel);

  return RelocAddrEntry{secIndex, RelocationRef(d, nullptr),

                        LLDRelocationResolver<RelTy>::resolve, val};

                        val,      Optional<object::RelocationRef>(),

                        0,        LLDRelocationResolver<RelTy>::resolve};

}



template <class ELFT>

llvm/include/llvm/DebugInfo/DWARF/DWARFRelocMap.h

+3 −1
Original line number Diff line number Diff line
@@ -20,8 +20,10 @@ namespace llvm { 
struct RelocAddrEntry {

  uint64_t SectionIndex;

  object::RelocationRef Reloc;

  object::RelocationResolver Resolver;

  uint64_t SymbolValue;

  Optional<object::RelocationRef> Reloc2;

  uint64_t SymbolValue2;

  object::RelocationResolver Resolver;

};



/// In place of applying the relocations to the data we've read from disk we use

llvm/lib/DebugInfo/DWARF/DWARFContext.cpp

+19 −3
Original line number Diff line number Diff line
@@ -1651,9 +1651,25 @@ public: 
        //

        // TODO Don't store Resolver in every RelocAddrEntry.

        if (Supports && Supports(Reloc.getType())) {

          Map->try_emplace(Reloc.getOffset(),

          auto I = Map->try_emplace(

              Reloc.getOffset(),

              RelocAddrEntry{SymInfoOrErr->SectionIndex, Reloc,

                                          Resolver, SymInfoOrErr->Address});

                             SymInfoOrErr->Address,

                             Optional<object::RelocationRef>(), 0, Resolver});

          // If we didn't successfully insert that's because we already had a

          // relocation for that offset. Store it as a second relocation in the

          // same RelocAddrEntry instead.

          if (!I.second) {

            RelocAddrEntry &entry = I.first->getSecond();

            if (entry.Reloc2) {

              ErrorPolicy EP = HandleError(createError(

                  "At most two relocations per offset are supported"));

              if (EP == ErrorPolicy::Halt)

                return;

            }

            entry.Reloc2 = Reloc;

            entry.SymbolValue2 = SymInfoOrErr->Address;

          }

        } else {

          SmallString<32> Type;

          Reloc.getTypeName(Type);

llvm/lib/DebugInfo/DWARF/DWARFDataExtractor.cpp

+4 −1
Original line number Diff line number Diff line
@@ -24,7 +24,10 @@ uint64_t DWARFDataExtractor::getRelocatedValue(uint32_t Size, uint32_t *Off, 
    return A;

  if (SecNdx)

    *SecNdx = E->SectionIndex;

  return E->Resolver(E->Reloc, E->SymbolValue, A);

  uint64_t R = E->Resolver(E->Reloc, E->SymbolValue, A);

  if (E->Reloc2)

    R = E->Resolver(*E->Reloc2, E->SymbolValue2, R);

  return R;

}



Optional<uint64_t>

llvm/lib/DebugInfo/DWARF/DWARFDebugLine.cpp

+4 −3
Original line number Diff line number Diff line
@@ -300,7 +300,7 @@ Error DWARFDebugLine::Prologue::parse(const DWARFDataExtractor &DebugLineData, 
  const uint64_t PrologueOffset = *OffsetPtr;



  clear();

  TotalLength = DebugLineData.getU32(OffsetPtr);

  TotalLength = DebugLineData.getRelocatedValue(4, OffsetPtr);

  if (TotalLength == UINT32_MAX) {

    FormParams.Format = dwarf::DWARF64;

    TotalLength = DebugLineData.getU64(OffsetPtr);
@@ -325,7 +325,8 @@ Error DWARFDebugLine::Prologue::parse(const DWARFDataExtractor &DebugLineData, 
    SegSelectorSize = DebugLineData.getU8(OffsetPtr);

  }



  PrologueLength = DebugLineData.getUnsigned(OffsetPtr, sizeofPrologueLength());

  PrologueLength =

      DebugLineData.getRelocatedValue(sizeofPrologueLength(), OffsetPtr);

  const uint64_t EndPrologueOffset = PrologueLength + *OffsetPtr;

  MinInstLength = DebugLineData.getU8(OffsetPtr);

  if (getVersion() >= 4)
@@ -754,7 +755,7 @@ Error DWARFDebugLine::LineTable::parse( 
        // requires the use of DW_LNS_advance_pc. Such assemblers, however,

        // can use DW_LNS_fixed_advance_pc instead, sacrificing compression.

        {

          uint16_t PCOffset = DebugLineData.getU16(OffsetPtr);

          uint16_t PCOffset = DebugLineData.getRelocatedValue(2, OffsetPtr);

          State.Row.Address.Address += PCOffset;

          if (OS)

            *OS