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     default:
106         assert(false && "invalid CrashReason");
107         break;
108 
109         case eInvalidCrashReason:
110             str = "eInvalidCrashReason";
111             break;
112 
113         // SIGSEGV crash reasons.
114         case eInvalidAddress:
115             str = "eInvalidAddress";
116             break;
117         case ePrivilegedAddress:
118             str = "ePrivilegedAddress";
119             break;
120 
121         // SIGILL crash reasons.
122         case eIllegalOpcode:
123             str = "eIllegalOpcode";
124             break;
125         case eIllegalOperand:
126             str = "eIllegalOperand";
127             break;
128         case eIllegalAddressingMode:
129             str = "eIllegalAddressingMode";
130             break;
131         case eIllegalTrap:
132             str = "eIllegalTrap";
133             break;
134         case ePrivilegedOpcode:
135             str = "ePrivilegedOpcode";
136             break;
137         case ePrivilegedRegister:
138             str = "ePrivilegedRegister";
139             break;
140         case eCoprocessorError:
141             str = "eCoprocessorError";
142             break;
143         case eInternalStackError:
144             str = "eInternalStackError";
145             break;
146 
147         // SIGBUS crash reasons:
148         case eIllegalAlignment:
149             str = "eIllegalAlignment";
150             break;
151         case eIllegalAddress:
152             str = "eIllegalAddress";
153             break;
154         case eHardwareError:
155             str = "eHardwareError";
156             break;
157 
158         // SIGFPE crash reasons:
159         case eIntegerDivideByZero:
160             str = "eIntegerDivideByZero";
161             break;
162         case eIntegerOverflow:
163             str = "eIntegerOverflow";
164             break;
165         case eFloatDivideByZero:
166             str = "eFloatDivideByZero";
167             break;
168         case eFloatOverflow:
169             str = "eFloatOverflow";
170             break;
171         case eFloatUnderflow:
172             str = "eFloatUnderflow";
173             break;
174         case eFloatInexactResult:
175             str = "eFloatInexactResult";
176             break;
177         case eFloatInvalidOperation:
178             str = "eFloatInvalidOperation";
179             break;
180         case eFloatSubscriptRange:
181             str = "eFloatSubscriptRange";
182             break;
183     }
184 #endif
185 
186     return str;
187 }
188 
189 const char *
190 ProcessMessage::PrintCrashReason() const
191 {
192     return PrintCrashReason(m_crash_reason);
193 }
194 
195 const char *
196 ProcessMessage::PrintKind(Kind kind)
197 {
198 #ifdef LLDB_CONFIGURATION_BUILDANDINTEGRATION
199     // Just return the code in asci for integration builds.
200     chcar str[8];
201     sprintf(str, "%d", reason);
202 #else
203     const char *str = NULL;
204 
205     switch (kind)
206     {
207     default:
208         assert(false && "invalid Kind");
209         break;
210 
211     case eInvalidMessage:
212         str = "eInvalidMessage";
213         break;
214     case eExitMessage:
215         str = "eExitMessage";
216         break;
217     case eLimboMessage:
218         str = "eLimboMessage";
219         break;
220     case eSignalMessage:
221         str = "eSignalMessage";
222         break;
223     case eSignalDeliveredMessage:
224         str = "eSignalDeliveredMessage";
225         break;
226     case eTraceMessage:
227         str = "eTraceMessage";
228         break;
229     case eBreakpointMessage:
230         str = "eBreakpointMessage";
231         break;
232     case eCrashMessage:
233         str = "eCrashMessage";
234         break;
235     }
236 #endif
237 
238     return str;
239 }
240 
241 const char *
242 ProcessMessage::PrintKind() const
243 {
244     return PrintKind(m_kind);
245 }
246