llvm-6502/lib/DebugInfo/DWARFDebugAranges.cpp

//===-- DWARFDebugAranges.cpp -----------------------------------*- C++ -*-===//
//
//                     The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//

#include "DWARFDebugAranges.h"
#include "DWARFCompileUnit.h"
#include "DWARFContext.h"
#include "llvm/Support/Format.h"
#include "llvm/Support/raw_ostream.h"
#include <algorithm>
#include <cassert>
using namespace llvm;

// Compare function DWARFDebugAranges::Range structures
static bool RangeLessThan(const DWARFDebugAranges::Range &range1,
                          const DWARFDebugAranges::Range &range2) {
  return range1.LoPC < range2.LoPC;
}

namespace {
  class CountArangeDescriptors {
  public:
    CountArangeDescriptors(uint32_t &count_ref) : Count(count_ref) {}
    void operator()(const DWARFDebugArangeSet &Set) {
      Count += Set.getNumDescriptors();
    }
    uint32_t &Count;
  };

  class AddArangeDescriptors {
  public:
    AddArangeDescriptors(DWARFDebugAranges::RangeColl &Ranges,
                         DWARFDebugAranges::ParsedCUOffsetColl &CUOffsets)
      : RangeCollection(Ranges),
        CUOffsetCollection(CUOffsets) {}
    void operator()(const DWARFDebugArangeSet &Set) {
      DWARFDebugAranges::Range Range;
      Range.Offset = Set.getCompileUnitDIEOffset();
      CUOffsetCollection.insert(Range.Offset);

      for (uint32_t i = 0, n = Set.getNumDescriptors(); i < n; ++i) {
        const DWARFDebugArangeSet::Descriptor *ArangeDescPtr =
            Set.getDescriptor(i);
        Range.LoPC = ArangeDescPtr->Address;
        Range.Length = ArangeDescPtr->Length;

        // Insert each item in increasing address order so binary searching
        // can later be done!
        DWARFDebugAranges::RangeColl::iterator InsertPos =
          std::lower_bound(RangeCollection.begin(), RangeCollection.end(),
                           Range, RangeLessThan);
        RangeCollection.insert(InsertPos, Range);
      }

    }
    DWARFDebugAranges::RangeColl &RangeCollection;
    DWARFDebugAranges::ParsedCUOffsetColl &CUOffsetCollection;
  };
}

bool DWARFDebugAranges::extract(DataExtractor debug_aranges_data) {
  if (debug_aranges_data.isValidOffset(0)) {
    uint32_t offset = 0;

    typedef std::vector<DWARFDebugArangeSet> SetCollection;
    SetCollection sets;

    DWARFDebugArangeSet set;
    Range range;
    while (set.extract(debug_aranges_data, &offset))
      sets.push_back(set);

    uint32_t count = 0;

    std::for_each(sets.begin(), sets.end(), CountArangeDescriptors(count));

    if (count > 0) {
      Aranges.reserve(count);
      AddArangeDescriptors range_adder(Aranges, ParsedCUOffsets);
      std::for_each(sets.begin(), sets.end(), range_adder);
    }
  }
  return false;
}

bool DWARFDebugAranges::generate(DWARFContext *ctx) {
  if (ctx) {
    const uint32_t num_compile_units = ctx->getNumCompileUnits();
    for (uint32_t cu_idx = 0; cu_idx < num_compile_units; ++cu_idx) {
      if (DWARFCompileUnit *cu = ctx->getCompileUnitAtIndex(cu_idx)) {
        uint32_t CUOffset = cu->getOffset();
        if (ParsedCUOffsets.insert(CUOffset).second)
          cu->buildAddressRangeTable(this, true);
      }
    }
  }
  sort(true, /* overlap size */ 0);
  return !isEmpty();
}

void DWARFDebugAranges::dump(raw_ostream &OS) const {
  const uint32_t num_ranges = getNumRanges();
  for (uint32_t i = 0; i < num_ranges; ++i) {
    const Range &range = Aranges[i];
    OS << format("0x%8.8x: [0x%8.8" PRIx64 " - 0x%8.8" PRIx64 ")\n",
                 range.Offset, (uint64_t)range.LoPC, (uint64_t)range.HiPC());
  }
}

void DWARFDebugAranges::Range::dump(raw_ostream &OS) const {
  OS << format("{0x%8.8x}: [0x%8.8" PRIx64 " - 0x%8.8" PRIx64 ")\n",
               Offset, LoPC, HiPC());
}

void DWARFDebugAranges::appendRange(uint32_t offset, uint64_t low_pc,
                                    uint64_t high_pc) {
  if (!Aranges.empty()) {
    if (Aranges.back().Offset == offset && Aranges.back().HiPC() == low_pc) {
      Aranges.back().setHiPC(high_pc);
      return;
    }
  }
  Aranges.push_back(Range(low_pc, high_pc, offset));
}

void DWARFDebugAranges::sort(bool minimize, uint32_t n) {
  const size_t orig_arange_size = Aranges.size();
  // Size of one? If so, no sorting is needed
  if (orig_arange_size <= 1)
    return;
  // Sort our address range entries
  std::stable_sort(Aranges.begin(), Aranges.end(), RangeLessThan);

  if (!minimize)
    return;

  // Most address ranges are contiguous from function to function
  // so our new ranges will likely be smaller. We calculate the size
  // of the new ranges since although std::vector objects can be resized,
  // the will never reduce their allocated block size and free any excesss
  // memory, so we might as well start a brand new collection so it is as
  // small as possible.

  // First calculate the size of the new minimal arange vector
  // so we don't have to do a bunch of re-allocations as we
  // copy the new minimal stuff over to the new collection.
  size_t minimal_size = 1;
  for (size_t i = 1; i < orig_arange_size; ++i) {
    if (!Range::SortedOverlapCheck(Aranges[i-1], Aranges[i], n))
      ++minimal_size;
  }

  // If the sizes are the same, then no consecutive aranges can be
  // combined, we are done.
  if (minimal_size == orig_arange_size)
    return;

  // Else, make a new RangeColl that _only_ contains what we need.
  RangeColl minimal_aranges;
  minimal_aranges.resize(minimal_size);
  uint32_t j = 0;
  minimal_aranges[j] = Aranges[0];
  for (size_t i = 1; i < orig_arange_size; ++i) {
    if(Range::SortedOverlapCheck (minimal_aranges[j], Aranges[i], n)) {
      minimal_aranges[j].setHiPC (Aranges[i].HiPC());
    } else {
      // Only increment j if we aren't merging
      minimal_aranges[++j] = Aranges[i];
    }
  }
  assert (j+1 == minimal_size);

  // Now swap our new minimal aranges into place. The local
  // minimal_aranges will then contian the old big collection
  // which will get freed.
  minimal_aranges.swap(Aranges);
}

uint32_t DWARFDebugAranges::findAddress(uint64_t address) const {
  if (!Aranges.empty()) {
    Range range(address);
    RangeCollIterator begin = Aranges.begin();
    RangeCollIterator end = Aranges.end();
    RangeCollIterator pos = std::lower_bound(begin, end, range, RangeLessThan);

    if (pos != end && pos->LoPC <= address && address < pos->HiPC()) {
      return pos->Offset;
    } else if (pos != begin) {
      --pos;
      if (pos->LoPC <= address && address < pos->HiPC())
        return (*pos).Offset;
    }
  }
  return -1U;
}

bool
DWARFDebugAranges::allRangesAreContiguous(uint64_t &LoPC, uint64_t &HiPC) const{
  if (Aranges.empty())
    return false;

  uint64_t next_addr = 0;
  RangeCollIterator begin = Aranges.begin();
  for (RangeCollIterator pos = begin, end = Aranges.end(); pos != end;
       ++pos) {
    if (pos != begin && pos->LoPC != next_addr)
      return false;
    next_addr = pos->HiPC();
  }
  // We checked for empty at the start of function so front() will be valid.
  LoPC = Aranges.front().LoPC;
  // We checked for empty at the start of function so back() will be valid.
  HiPC = Aranges.back().HiPC();
  return true;
}

bool DWARFDebugAranges::getMaxRange(uint64_t &LoPC, uint64_t &HiPC) const {
  if (Aranges.empty())
    return false;
  // We checked for empty at the start of function so front() will be valid.
  LoPC = Aranges.front().LoPC;
  // We checked for empty at the start of function so back() will be valid.
  HiPC = Aranges.back().HiPC();
  return true;
}