contrib/llvm/tools/lldb/source/Plugins/Process/POSIX/ProcessMessage.cpp

   1 //===-- ProcessMessage.cpp --------------------------------------*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 #include "ProcessMessage.h"
  11
  12 #include <sstream>
  13
  14 using namespace lldb_private;
  15
  16 namespace {
  17
  18 inline void AppendFaultAddr(std::string& str, lldb::addr_t addr)
  19 {
  20     std::stringstream ss;
  21     ss << " (fault address: 0x" << std::hex << addr << ")";
  22     str += ss.str();
  23 }
  24
  25 }
  26
  27 const char *
  28 ProcessMessage::GetCrashReasonString(CrashReason reason, lldb::addr_t fault_addr)
  29 {
  30     static std::string str;
  31
  32     switch (reason)
  33     {
  34     default:
  35         assert(false && "invalid CrashReason");
  36         break;
  37
  38     case eInvalidAddress:
  39         str = "invalid address";
  40         AppendFaultAddr(str, fault_addr);
  41         break;
  42     case ePrivilegedAddress:
  43         str = "address access protected";
  44         AppendFaultAddr(str, fault_addr);
  45         break;
  46     case eIllegalOpcode:
  47         str = "illegal instruction";
  48         break;
  49     case eIllegalOperand:
  50         str = "illegal instruction operand";
  51         break;
  52     case eIllegalAddressingMode:
  53         str = "illegal addressing mode";
  54         break;
  55     case eIllegalTrap:
  56         str = "illegal trap";
  57         break;
  58     case ePrivilegedOpcode:
  59         str = "privileged instruction";
  60         break;
  61     case ePrivilegedRegister:
  62         str = "privileged register";
  63         break;
  64     case eCoprocessorError:
  65         str = "coprocessor error";
  66         break;
  67     case eInternalStackError:
  68         str = "internal stack error";
  69         break;
  70     case eIllegalAlignment:
  71         str = "illegal alignment";
  72         break;
  73     case eIllegalAddress:
  74         str = "illegal address";
  75         break;
  76     case eHardwareError:
  77         str = "hardware error";
  78         break;
  79     case eIntegerDivideByZero:
  80         str = "integer divide by zero";
  81         break;
  82     case eIntegerOverflow:
  83         str = "integer overflow";
  84         break;
  85     case eFloatDivideByZero:
  86         str = "floating point divide by zero";
  87         break;
  88     case eFloatOverflow:
  89         str = "floating point overflow";
  90         break;
  91     case eFloatUnderflow:
  92         str = "floating point underflow";
  93         break;
  94     case eFloatInexactResult:
  95         str = "inexact floating point result";
  96         break;
  97     case eFloatInvalidOperation:
  98         str = "invalid floating point operation";
  99         break;
 100     case eFloatSubscriptRange:
 101         str = "invalid floating point subscript range";
 102         break;
 103     }
 104
 105     return str.c_str();
 106 }
 107
 108 const char *
 109 ProcessMessage::PrintCrashReason(CrashReason reason)
 110 {
 111 #ifdef LLDB_CONFIGURATION_BUILDANDINTEGRATION
 112     // Just return the code in asci for integration builds.
 113     chcar str[8];
 114     sprintf(str, "%d", reason);
 115 #else
 116     const char *str = NULL;
 117
 118     switch (reason)
 119     {
 120         case eInvalidCrashReason:
 121             str = "eInvalidCrashReason";
 122             break;
 123
 124         // SIGSEGV crash reasons.
 125         case eInvalidAddress:
 126             str = "eInvalidAddress";
 127             break;
 128         case ePrivilegedAddress:
 129             str = "ePrivilegedAddress";
 130             break;
 131
 132         // SIGILL crash reasons.
 133         case eIllegalOpcode:
 134             str = "eIllegalOpcode";
 135             break;
 136         case eIllegalOperand:
 137             str = "eIllegalOperand";
 138             break;
 139         case eIllegalAddressingMode:
 140             str = "eIllegalAddressingMode";
 141             break;
 142         case eIllegalTrap:
 143             str = "eIllegalTrap";
 144             break;
 145         case ePrivilegedOpcode:
 146             str = "ePrivilegedOpcode";
 147             break;
 148         case ePrivilegedRegister:
 149             str = "ePrivilegedRegister";
 150             break;
 151         case eCoprocessorError:
 152             str = "eCoprocessorError";
 153             break;
 154         case eInternalStackError:
 155             str = "eInternalStackError";
 156             break;
 157
 158         // SIGBUS crash reasons:
 159         case eIllegalAlignment:
 160             str = "eIllegalAlignment";
 161             break;
 162         case eIllegalAddress:
 163             str = "eIllegalAddress";
 164             break;
 165         case eHardwareError:
 166             str = "eHardwareError";
 167             break;
 168
 169         // SIGFPE crash reasons:
 170         case eIntegerDivideByZero:
 171             str = "eIntegerDivideByZero";
 172             break;
 173         case eIntegerOverflow:
 174             str = "eIntegerOverflow";
 175             break;
 176         case eFloatDivideByZero:
 177             str = "eFloatDivideByZero";
 178             break;
 179         case eFloatOverflow:
 180             str = "eFloatOverflow";
 181             break;
 182         case eFloatUnderflow:
 183             str = "eFloatUnderflow";
 184             break;
 185         case eFloatInexactResult:
 186             str = "eFloatInexactResult";
 187             break;
 188         case eFloatInvalidOperation:
 189             str = "eFloatInvalidOperation";
 190             break;
 191         case eFloatSubscriptRange:
 192             str = "eFloatSubscriptRange";
 193             break;
 194     }
 195 #endif
 196
 197     return str;
 198 }
 199
 200 const char *
 201 ProcessMessage::PrintCrashReason() const
 202 {
 203     return PrintCrashReason(m_crash_reason);
 204 }
 205
 206 const char *
 207 ProcessMessage::PrintKind(Kind kind)
 208 {
 209 #ifdef LLDB_CONFIGURATION_BUILDANDINTEGRATION
 210     // Just return the code in asci for integration builds.
 211     chcar str[8];
 212     sprintf(str, "%d", reason);
 213 #else
 214     const char *str = NULL;
 215
 216     switch (kind)
 217     {
 218     case eInvalidMessage:
 219         str = "eInvalidMessage";
 220         break;
 221     case eExitMessage:
 222         str = "eExitMessage";
 223         break;
 224     case eLimboMessage:
 225         str = "eLimboMessage";
 226         break;
 227     case eSignalMessage:
 228         str = "eSignalMessage";
 229         break;
 230     case eSignalDeliveredMessage:
 231         str = "eSignalDeliveredMessage";
 232         break;
 233     case eTraceMessage:
 234         str = "eTraceMessage";
 235         break;
 236     case eBreakpointMessage:
 237         str = "eBreakpointMessage";
 238         break;
 239     case eWatchpointMessage:
 240         str = "eWatchpointMessage";
 241         break;
 242     case eCrashMessage:
 243         str = "eCrashMessage";
 244         break;
 245     case eNewThreadMessage:
 246         str = "eNewThreadMessage";
 247         break;
 248     }
 249 #endif
 250
 251     return str;
 252 }
 253
 254 const char *
 255 ProcessMessage::PrintKind() const
 256 {
 257     return PrintKind(m_kind);
 258 }