hexdump.cxx

Go to the documentation of this file.

/*
 * Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration.
 */
 
 
#include "CxxUtils/hexdump.h"
#include "CxxUtils/procmaps.h"
#include <format>
#include <cstdint>
#include <array>
#include <bit>
#include <unistd.h>
 
 
namespace {
// Number of bytes to dump on one line.
constexpr unsigned int width = 16;
}
 
 
namespace CxxUtils {
 

void hexdump (std::ostream& s, const void* addr, size_t n, size_t offset /*= 0*/)
{
  const char* ptr = reinterpret_cast<const char*> (addr);
  size_t ipos = 0;
 
  char cbuf[width + 1]{};
  std::array<unsigned char, 4> bbuf{};
 
  while (n-- > 0) {
    if ((ipos % width) == 0) {
      s << std::format("{:016x} ", reinterpret_cast<uintptr_t>(ptr + ipos) - offset);
    }
    if ((ipos % 4) == 0) {
      s << " ";
    }
    bbuf[ipos % 4] = static_cast<unsigned char>(ptr[ipos]);
    cbuf[ipos % width] = std::isgraph(static_cast<unsigned char>(ptr[ipos])) ? ptr[ipos] : '.';
 
    ++ipos;
    if ((ipos % 4) == 0) {
      s << std::format("{:08x}", static_cast<unsigned int>(std::bit_cast<uint32_t>(bbuf)));
    }
    if ((ipos % width) == 0) {
      s << "  " << cbuf << "\n";
    }
  }
 
  if ((ipos % width) > 0) {
    unsigned ntrail = (ipos % 4);
    if (ntrail > 0) {
      for (unsigned i = ntrail; i < 4; i++) {
        bbuf[i] = 0;
      }
      s << std::format("{:0{}x}", static_cast<unsigned int>(std::bit_cast<uint32_t>(bbuf)), 2*ntrail);
    }
    while ((ipos % width) != 0) {
      if ((ipos % 4) == 0) {
        s << " ";
      }
      s << "  ";
      cbuf[ipos % width] = ' ';
      ++ipos;
    }
    s << "  " << cbuf << "\n";
  }
}
 

void safeHexdump (std::ostream& s, const void* addr, size_t n, size_t offset /*= 0*/)
{
  const char* ptr = reinterpret_cast<const char*> (addr);
 
  // Adjust to start at width-byte boundary.
  size_t nadj = reinterpret_cast<uintptr_t>(ptr) % width;
  if (nadj > 0) {
    ptr -= nadj;
    n += nadj;
  }
 
  long pagesize_ret = sysconf (_SC_PAGESIZE);
  if (pagesize_ret < 0 || pagesize_ret >= 1024*1024*1024) {
    std::abort();
  }
  size_t pagesize = pagesize_ret;
  
 
  procmaps m;
 
  // Print page by page.
  while (n > 0) {
    uintptr_t iptr = reinterpret_cast<uintptr_t>(ptr);
    size_t thispage = ((iptr + pagesize) & ~(pagesize-1)) - iptr;
    if (thispage > n) {
      thispage = n;
    }
    const procmaps::Entry* ent = m.getEntry (ptr);
    if (ent && ent->readable) {
      hexdump (s, ptr, thispage, offset);
    }
    else {
      s << std::format("{:016x}  --- is not readable\n",
                       reinterpret_cast<uintptr_t>(ptr) - offset);
      if (ent) {
        thispage = std::max (ent->endAddress - iptr, thispage);
      }
    }
    ptr += thispage;
    n -= thispage;
  }
}
 
 
} // namespace CxxUtils