StackFrameBase.cc

/*
 * Copyright (c) 2008-2014, Pedigree Developers
 *
 * Please see the CONTRIB file in the root of the source tree for a full
 * list of contributors.
 *
 * Permission to use, copy, modify, and distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */
 
#include <config.h>
 
#if DEBUGGER
 
#include "pedigree/kernel/processor/StackFrameBase.h"
 
StackFrameBase::StackFrameBase(const ProcessorState& State, uintptr_t basePointer,
                               LargeStaticString mangledSymbol)
    : m_Symbol(), m_State(State), m_BasePointer(basePointer) {
  // Demangle the given symbol, storing in m_Symbol for future use.
  demangle(mangledSymbol, &m_Symbol);
}
 
StackFrameBase::~StackFrameBase() = default;
 
void StackFrameBase::prettyPrint(HugeStaticString& buf) {
  bool bIsMember = isClassMember();
 
  buf += static_cast<const char*>(m_Symbol.name);
  buf += '(';
 
  if (bIsMember) {
    buf += "this=0x";
    buf.append(getParameter(0), 16);
    buf += ", ";
  }
  for (size_t i = 0; i < m_Symbol.nParams; i++) {
    if (i != 0)
      buf += ", ";
 
    format(getParameter((bIsMember) ? i + 1 : i), m_Symbol.params[i], buf);
  }
 
  buf += ")\n";
}
 
void StackFrameBase::format(uintptr_t n, const LargeStaticString& type, HugeStaticString& dest) {
  // Is the type a char * or const char *?
  if (type == "char*" || type == "const char*") {
    // LargeStaticString tmp(reinterpret_cast<const char*>(n));
    // dest += '"';
    // dest += tmp.left(22); // Only 22 characters max.
    // dest += '"';
    dest.append("(");
    dest.append(type);
    dest.append(") 0x");
#if BITS_32
    dest.append(n, 16, 8, '0');
#endif
#if BITS_64
    dest.append(n, 16, 16, '0');
#endif
  }
  // char? or const char?
  else if (type == "char" || type == "const char") {
    dest += '\'';
    dest += static_cast<char>(n);
    dest += '\'';
  }
  // bool?
  else if (type == "bool" || type == "const bool") {
    bool b = static_cast<bool>(n);
    if (b)
      dest += "true";
    else
      dest += "false";
  }
  // 16-bit value?
  else if (type == "short") {
    dest += "0x";
    dest.append(static_cast<short>(n), 16);
  } else if (type == "unsigned short") {
    dest += "0x";
    dest.append(static_cast<unsigned short>(n), 16);
  }
  // 32-bit value, in 64-bit mode?
  else if (type == "int") {
    dest += "0x";
    dest.append(static_cast<int>(n), 16);
  } else if (type == "unsigned int") {
    dest += "0x";
    dest.append(static_cast<unsigned int>(n), 16);
  }
  // Else just use a hex integer, represented as a cast.
  else {
    dest += "(";
    dest += static_cast<const char*>(type);
    dest += ")0x";
    dest.append(n, 16);
  }
}
 
bool StackFrameBase::isClassMember() {
  int nScopeIdx = m_Symbol.name.last(':');
  if (nScopeIdx == -1)
    return false;
 
  int i;
  for (i = nScopeIdx - 2; i >= 0 && m_Symbol.name[i] != ':'; i--)
    ;
  i++;
 
  if (m_Symbol.name[i] >= 'A' && m_Symbol.name[i] <= 'Z')
    return true;
  else
    return false;
}
 
#endif