| //===-- ProcessMessage.cpp --------------------------------------*- C++ -*-===// |
| // |
| // The LLVM Compiler Infrastructure |
| // |
| // This file is distributed under the University of Illinois Open Source |
| // License. See LICENSE.TXT for details. |
| // |
| //===----------------------------------------------------------------------===// |
| |
| #include "ProcessMessage.h" |
| |
| #include <sstream> |
| |
| using namespace lldb_private; |
| |
| namespace { |
| |
| inline void AppendFaultAddr(std::string& str, lldb::addr_t addr) |
| { |
| std::stringstream ss; |
| ss << " (fault address: 0x" << std::hex << addr << ")"; |
| str += ss.str(); |
| } |
| |
| } |
| |
| const char * |
| ProcessMessage::GetCrashReasonString(CrashReason reason, lldb::addr_t fault_addr) |
| { |
| static std::string str; |
| |
| switch (reason) |
| { |
| default: |
| assert(false && "invalid CrashReason"); |
| break; |
| |
| case eInvalidAddress: |
| str = "invalid address"; |
| AppendFaultAddr(str, fault_addr); |
| break; |
| case ePrivilegedAddress: |
| str = "address access protected"; |
| AppendFaultAddr(str, fault_addr); |
| break; |
| case eIllegalOpcode: |
| str = "illegal instruction"; |
| break; |
| case eIllegalOperand: |
| str = "illegal instruction operand"; |
| break; |
| case eIllegalAddressingMode: |
| str = "illegal addressing mode"; |
| break; |
| case eIllegalTrap: |
| str = "illegal trap"; |
| break; |
| case ePrivilegedOpcode: |
| str = "privileged instruction"; |
| break; |
| case ePrivilegedRegister: |
| str = "privileged register"; |
| break; |
| case eCoprocessorError: |
| str = "coprocessor error"; |
| break; |
| case eInternalStackError: |
| str = "internal stack error"; |
| break; |
| case eIllegalAlignment: |
| str = "illegal alignment"; |
| break; |
| case eIllegalAddress: |
| str = "illegal address"; |
| break; |
| case eHardwareError: |
| str = "hardware error"; |
| break; |
| case eIntegerDivideByZero: |
| str = "integer divide by zero"; |
| break; |
| case eIntegerOverflow: |
| str = "integer overflow"; |
| break; |
| case eFloatDivideByZero: |
| str = "floating point divide by zero"; |
| break; |
| case eFloatOverflow: |
| str = "floating point overflow"; |
| break; |
| case eFloatUnderflow: |
| str = "floating point underflow"; |
| break; |
| case eFloatInexactResult: |
| str = "inexact floating point result"; |
| break; |
| case eFloatInvalidOperation: |
| str = "invalid floating point operation"; |
| break; |
| case eFloatSubscriptRange: |
| str = "invalid floating point subscript range"; |
| break; |
| } |
| |
| return str.c_str(); |
| } |
| |
| const char * |
| ProcessMessage::PrintCrashReason(CrashReason reason) |
| { |
| #ifdef LLDB_CONFIGURATION_BUILDANDINTEGRATION |
| // Just return the code in asci for integration builds. |
| chcar str[8]; |
| sprintf(str, "%d", reason); |
| #else |
| const char *str = NULL; |
| |
| switch (reason) |
| { |
| case eInvalidCrashReason: |
| str = "eInvalidCrashReason"; |
| break; |
| |
| // SIGSEGV crash reasons. |
| case eInvalidAddress: |
| str = "eInvalidAddress"; |
| break; |
| case ePrivilegedAddress: |
| str = "ePrivilegedAddress"; |
| break; |
| |
| // SIGILL crash reasons. |
| case eIllegalOpcode: |
| str = "eIllegalOpcode"; |
| break; |
| case eIllegalOperand: |
| str = "eIllegalOperand"; |
| break; |
| case eIllegalAddressingMode: |
| str = "eIllegalAddressingMode"; |
| break; |
| case eIllegalTrap: |
| str = "eIllegalTrap"; |
| break; |
| case ePrivilegedOpcode: |
| str = "ePrivilegedOpcode"; |
| break; |
| case ePrivilegedRegister: |
| str = "ePrivilegedRegister"; |
| break; |
| case eCoprocessorError: |
| str = "eCoprocessorError"; |
| break; |
| case eInternalStackError: |
| str = "eInternalStackError"; |
| break; |
| |
| // SIGBUS crash reasons: |
| case eIllegalAlignment: |
| str = "eIllegalAlignment"; |
| break; |
| case eIllegalAddress: |
| str = "eIllegalAddress"; |
| break; |
| case eHardwareError: |
| str = "eHardwareError"; |
| break; |
| |
| // SIGFPE crash reasons: |
| case eIntegerDivideByZero: |
| str = "eIntegerDivideByZero"; |
| break; |
| case eIntegerOverflow: |
| str = "eIntegerOverflow"; |
| break; |
| case eFloatDivideByZero: |
| str = "eFloatDivideByZero"; |
| break; |
| case eFloatOverflow: |
| str = "eFloatOverflow"; |
| break; |
| case eFloatUnderflow: |
| str = "eFloatUnderflow"; |
| break; |
| case eFloatInexactResult: |
| str = "eFloatInexactResult"; |
| break; |
| case eFloatInvalidOperation: |
| str = "eFloatInvalidOperation"; |
| break; |
| case eFloatSubscriptRange: |
| str = "eFloatSubscriptRange"; |
| break; |
| } |
| #endif |
| |
| return str; |
| } |
| |
| const char * |
| ProcessMessage::PrintCrashReason() const |
| { |
| return PrintCrashReason(m_crash_reason); |
| } |
| |
| const char * |
| ProcessMessage::PrintKind(Kind kind) |
| { |
| #ifdef LLDB_CONFIGURATION_BUILDANDINTEGRATION |
| // Just return the code in asci for integration builds. |
| chcar str[8]; |
| sprintf(str, "%d", reason); |
| #else |
| const char *str = NULL; |
| |
| switch (kind) |
| { |
| case eInvalidMessage: |
| str = "eInvalidMessage"; |
| break; |
| case eAttachMessage: |
| str = "eAttachMessage"; |
| break; |
| case eExitMessage: |
| str = "eExitMessage"; |
| break; |
| case eLimboMessage: |
| str = "eLimboMessage"; |
| break; |
| case eSignalMessage: |
| str = "eSignalMessage"; |
| break; |
| case eSignalDeliveredMessage: |
| str = "eSignalDeliveredMessage"; |
| break; |
| case eTraceMessage: |
| str = "eTraceMessage"; |
| break; |
| case eBreakpointMessage: |
| str = "eBreakpointMessage"; |
| break; |
| case eWatchpointMessage: |
| str = "eWatchpointMessage"; |
| break; |
| case eCrashMessage: |
| str = "eCrashMessage"; |
| break; |
| case eNewThreadMessage: |
| str = "eNewThreadMessage"; |
| break; |
| case eExecMessage: |
| str = "eExecMessage"; |
| break; |
| } |
| #endif |
| |
| return str; |
| } |
| |
| const char * |
| ProcessMessage::PrintKind() const |
| { |
| return PrintKind(m_kind); |
| } |