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