Bug Summary

File:tools/lldb/source/Host/common/Host.cpp
Warning:line 273, column 15
Use of memory after it is freed

Annotated Source Code

1//===-- Host.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// C includes
11#include <errno(*__errno_location ()).h>
12#include <limits.h>
13#include <stdlib.h>
14#include <sys/types.h>
15#ifndef _WIN32
16#include <dlfcn.h>
17#include <grp.h>
18#include <netdb.h>
19#include <pwd.h>
20#include <sys/stat.h>
21#include <unistd.h>
22#endif
23
24#if defined(__APPLE__)
25#include <mach-o/dyld.h>
26#include <mach/mach_init.h>
27#include <mach/mach_port.h>
28#endif
29
30#if defined(__linux__1) || defined(__FreeBSD__) || \
31 defined(__FreeBSD_kernel__) || defined(__APPLE__) || \
32 defined(__NetBSD__) || defined(__OpenBSD__)
33#if !defined(__ANDROID__)
34#include <spawn.h>
35#endif
36#include <sys/syscall.h>
37#include <sys/wait.h>
38#endif
39
40#if defined(__FreeBSD__)
41#include <pthread_np.h>
42#endif
43
44#if defined(__NetBSD__)
45#include <lwp.h>
46#endif
47
48// C++ Includes
49#include <csignal>
50
51// Other libraries and framework includes
52// Project includes
53
54#include "lldb/Core/ArchSpec.h"
55#include "lldb/Host/Host.h"
56#include "lldb/Host/HostInfo.h"
57#include "lldb/Host/HostProcess.h"
58#include "lldb/Host/MonitoringProcessLauncher.h"
59#include "lldb/Host/Predicate.h"
60#include "lldb/Host/ProcessLauncher.h"
61#include "lldb/Host/ThreadLauncher.h"
62#include "lldb/Host/posix/ConnectionFileDescriptorPosix.h"
63#include "lldb/Target/FileAction.h"
64#include "lldb/Target/ProcessLaunchInfo.h"
65#include "lldb/Target/UnixSignals.h"
66#include "lldb/Utility/CleanUp.h"
67#include "lldb/Utility/DataBufferLLVM.h"
68#include "lldb/Utility/FileSpec.h"
69#include "lldb/Utility/Log.h"
70#include "lldb/Utility/Status.h"
71#include "lldb/lldb-private-forward.h"
72#include "llvm/ADT/SmallString.h"
73#include "llvm/ADT/StringSwitch.h"
74#include "llvm/Support/Errno.h"
75#include "llvm/Support/FileSystem.h"
76
77#if defined(_WIN32)
78#include "lldb/Host/windows/ConnectionGenericFileWindows.h"
79#include "lldb/Host/windows/ProcessLauncherWindows.h"
80#else
81#include "lldb/Host/posix/ProcessLauncherPosixFork.h"
82#endif
83
84#if defined(__APPLE__)
85#ifndef _POSIX_SPAWN_DISABLE_ASLR
86#define _POSIX_SPAWN_DISABLE_ASLR 0x0100
87#endif
88
89extern "C" {
90int __pthread_chdir(const char *path);
91int __pthread_fchdir(int fildes);
92}
93
94#endif
95
96using namespace lldb;
97using namespace lldb_private;
98
99#if !defined(__APPLE__) && !defined(_WIN32)
100struct MonitorInfo {
101 lldb::pid_t pid; // The process ID to monitor
102 Host::MonitorChildProcessCallback
103 callback; // The callback function to call when "pid" exits or signals
104 bool monitor_signals; // If true, call the callback when "pid" gets signaled.
105};
106
107static thread_result_t MonitorChildProcessThreadFunction(void *arg);
108
109HostThread Host::StartMonitoringChildProcess(
110 const Host::MonitorChildProcessCallback &callback, lldb::pid_t pid,
111 bool monitor_signals) {
112 MonitorInfo *info_ptr = new MonitorInfo();
113
114 info_ptr->pid = pid;
115 info_ptr->callback = callback;
116 info_ptr->monitor_signals = monitor_signals;
117
118 char thread_name[256];
119 ::snprintf(thread_name, sizeof(thread_name),
120 "<lldb.host.wait4(pid=%" PRIu64"l" "u" ")>", pid);
121 return ThreadLauncher::LaunchThread(
122 thread_name, MonitorChildProcessThreadFunction, info_ptr, NULL__null);
123}
124
125#ifndef __linux__1
126//------------------------------------------------------------------
127// Scoped class that will disable thread canceling when it is
128// constructed, and exception safely restore the previous value it
129// when it goes out of scope.
130//------------------------------------------------------------------
131class ScopedPThreadCancelDisabler {
132public:
133 ScopedPThreadCancelDisabler() {
134 // Disable the ability for this thread to be cancelled
135 int err = ::pthread_setcancelstate(PTHREAD_CANCEL_DISABLEPTHREAD_CANCEL_DISABLE, &m_old_state);
136 if (err != 0)
137 m_old_state = -1;
138 }
139
140 ~ScopedPThreadCancelDisabler() {
141 // Restore the ability for this thread to be cancelled to what it
142 // previously was.
143 if (m_old_state != -1)
144 ::pthread_setcancelstate(m_old_state, 0);
145 }
146
147private:
148 int m_old_state; // Save the old cancelability state.
149};
150#endif // __linux__
151
152#ifdef __linux__1
153#if defined(__GNUC__4) && (__GNUC__4 < 4 || (__GNUC__4 == 4 && __GNUC_MINOR__2 < 8))
154static __thread volatile sig_atomic_t g_usr1_called;
155#else
156static thread_local volatile sig_atomic_t g_usr1_called;
157#endif
158
159static void SigUsr1Handler(int) { g_usr1_called = 1; }
160#endif // __linux__
161
162static bool CheckForMonitorCancellation() {
163#ifdef __linux__1
164 if (g_usr1_called) {
165 g_usr1_called = 0;
166 return true;
167 }
168#else
169 ::pthread_testcancel();
170#endif
171 return false;
172}
173
174static thread_result_t MonitorChildProcessThreadFunction(void *arg) {
175 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS(1u << 1)));
176 const char *function = __FUNCTION__;
177 if (log)
1
Assuming 'log' is null
2
Taking false branch
178 log->Printf("%s (arg = %p) thread starting...", function, arg);
179
180 MonitorInfo *info = (MonitorInfo *)arg;
181
182 const Host::MonitorChildProcessCallback callback = info->callback;
183 const bool monitor_signals = info->monitor_signals;
184
185 assert(info->pid <= UINT32_MAX)((info->pid <= (4294967295U)) ? static_cast<void>
(0) : __assert_fail ("info->pid <= UINT32_MAX", "/build/llvm-toolchain-snapshot-6.0~svn316259/tools/lldb/source/Host/common/Host.cpp"
, 185, __PRETTY_FUNCTION__))
;
186 const ::pid_t pid = monitor_signals ? -1 * getpgid(info->pid) : info->pid;
3
Assuming 'monitor_signals' is 0
4
'?' condition is false
187
188 delete info;
5
Memory is released
189
190 int status = -1;
191#if defined(__FreeBSD__) || defined(__FreeBSD_kernel__) || defined(__OpenBSD__)
192#define __WALL0x40000000 0
193#endif
194 const int options = __WALL0x40000000;
195
196#ifdef __linux__1
197 // This signal is only used to interrupt the thread from waitpid
198 struct sigaction sigUsr1Action;
199 memset(&sigUsr1Action, 0, sizeof(sigUsr1Action));
200 sigUsr1Action.sa_handler__sigaction_handler.sa_handler = SigUsr1Handler;
201 ::sigaction(SIGUSR110, &sigUsr1Action, nullptr);
202#endif // __linux__
203
204 while (1) {
6
Loop condition is true. Entering loop body
205 log = lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS(1u << 1));
206 if (log)
7
Assuming 'log' is null
8
Taking false branch
207 log->Printf("%s ::waitpid (pid = %" PRIi32"i" ", &status, options = %i)...",
208 function, pid, options);
209
210 if (CheckForMonitorCancellation())
9
Taking false branch
211 break;
212
213 // Get signals from all children with same process group of pid
214 const ::pid_t wait_pid = ::waitpid(pid, &status, options);
215
216 if (CheckForMonitorCancellation())
10
Taking false branch
217 break;
218
219 if (wait_pid == -1) {
11
Assuming the condition is false
12
Taking false branch
220 if (errno(*__errno_location ()) == EINTR4)
221 continue;
222 else {
223 LLDB_LOG(log,do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/build/llvm-toolchain-snapshot-6.0~svn316259/tools/lldb/source/Host/common/Host.cpp"
, __FUNCTION__, "arg = {0}, thread exiting because waitpid failed ({1})..."
, arg, llvm::sys::StrError()); } while (0)
224 "arg = {0}, thread exiting because waitpid failed ({1})...",do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/build/llvm-toolchain-snapshot-6.0~svn316259/tools/lldb/source/Host/common/Host.cpp"
, __FUNCTION__, "arg = {0}, thread exiting because waitpid failed ({1})..."
, arg, llvm::sys::StrError()); } while (0)
225 arg, llvm::sys::StrError())do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/build/llvm-toolchain-snapshot-6.0~svn316259/tools/lldb/source/Host/common/Host.cpp"
, __FUNCTION__, "arg = {0}, thread exiting because waitpid failed ({1})..."
, arg, llvm::sys::StrError()); } while (0)
;
226 break;
227 }
228 } else if (wait_pid > 0) {
13
Assuming 'wait_pid' is > 0
14
Taking true branch
229 bool exited = false;
230 int signal = 0;
231 int exit_status = 0;
232 const char *status_cstr = NULL__null;
233 if (WIFSTOPPED(status)(((status) & 0xff) == 0x7f)) {
15
Taking false branch
234 signal = WSTOPSIG(status)(((status) & 0xff00) >> 8);
235 status_cstr = "STOPPED";
236 } else if (WIFEXITED(status)(((status) & 0x7f) == 0)) {
16
Taking true branch
237 exit_status = WEXITSTATUS(status)(((status) & 0xff00) >> 8);
238 status_cstr = "EXITED";
239 exited = true;
240 } else if (WIFSIGNALED(status)(((signed char) (((status) & 0x7f) + 1) >> 1) > 0
)
) {
241 signal = WTERMSIG(status)((status) & 0x7f);
242 status_cstr = "SIGNALED";
243 if (wait_pid == abs(pid)) {
244 exited = true;
245 exit_status = -1;
246 }
247 } else {
248 status_cstr = "(\?\?\?)";
249 }
250
251 // Scope for pthread_cancel_disabler
252 {
253#ifndef __linux__1
254 ScopedPThreadCancelDisabler pthread_cancel_disabler;
255#endif
256
257 log = lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS(1u << 1));
258 if (log)
17
Assuming 'log' is non-null
18
Taking true branch
259 log->Printf("%s ::waitpid (pid = %" PRIi32"i"
260 ", &status, options = %i) => pid = %" PRIi32"i"
261 ", status = 0x%8.8x (%s), signal = %i, exit_state = %i",
262 function, pid, options, wait_pid, status, status_cstr,
263 signal, exit_status);
264
265 if (exited || (signal != 0 && monitor_signals)) {
266 bool callback_return = false;
267 if (callback)
19
Taking false branch
268 callback_return = callback(wait_pid, exited, signal, exit_status);
269
270 // If our process exited, then this thread should exit
271 if (exited && wait_pid == abs(pid)) {
20
Taking true branch
272 if (log)
21
Taking true branch
273 log->Printf("%s (arg = %p) thread exiting because pid received "
22
Use of memory after it is freed
274 "exit signal...",
275 __FUNCTION__, arg);
276 break;
277 }
278 // If the callback returns true, it means this process should
279 // exit
280 if (callback_return) {
281 if (log)
282 log->Printf("%s (arg = %p) thread exiting because callback "
283 "returned true...",
284 __FUNCTION__, arg);
285 break;
286 }
287 }
288 }
289 }
290 }
291
292 log = lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS(1u << 1));
293 if (log)
294 log->Printf("%s (arg = %p) thread exiting...", __FUNCTION__, arg);
295
296 return NULL__null;
297}
298
299#endif // #if !defined (__APPLE__) && !defined (_WIN32)
300
301#if !defined(__APPLE__)
302
303void Host::SystemLog(SystemLogType type, const char *format, va_list args) {
304 vfprintf(stderrstderr, format, args);
305}
306
307#endif
308
309void Host::SystemLog(SystemLogType type, const char *format, ...) {
310 va_list args;
311 va_start(args, format)__builtin_va_start(args, format);
312 SystemLog(type, format, args);
313 va_end(args)__builtin_va_end(args);
314}
315
316lldb::pid_t Host::GetCurrentProcessID() { return ::getpid(); }
317
318#ifndef _WIN32
319
320lldb::thread_t Host::GetCurrentThread() {
321 return lldb::thread_t(pthread_self());
322}
323
324const char *Host::GetSignalAsCString(int signo) {
325 switch (signo) {
326 case SIGHUP1:
327 return "SIGHUP"; // 1 hangup
328 case SIGINT2:
329 return "SIGINT"; // 2 interrupt
330 case SIGQUIT3:
331 return "SIGQUIT"; // 3 quit
332 case SIGILL4:
333 return "SIGILL"; // 4 illegal instruction (not reset when caught)
334 case SIGTRAP5:
335 return "SIGTRAP"; // 5 trace trap (not reset when caught)
336 case SIGABRT6:
337 return "SIGABRT"; // 6 abort()
338#if defined(SIGPOLL29)
339#if !defined(SIGIO29) || (SIGPOLL29 != SIGIO29)
340 // Under some GNU/Linux, SIGPOLL and SIGIO are the same. Causing the build to
341 // fail with 'multiple define cases with same value'
342 case SIGPOLL29:
343 return "SIGPOLL"; // 7 pollable event ([XSR] generated, not supported)
344#endif
345#endif
346#if defined(SIGEMT)
347 case SIGEMT:
348 return "SIGEMT"; // 7 EMT instruction
349#endif
350 case SIGFPE8:
351 return "SIGFPE"; // 8 floating point exception
352 case SIGKILL9:
353 return "SIGKILL"; // 9 kill (cannot be caught or ignored)
354 case SIGBUS7:
355 return "SIGBUS"; // 10 bus error
356 case SIGSEGV11:
357 return "SIGSEGV"; // 11 segmentation violation
358 case SIGSYS31:
359 return "SIGSYS"; // 12 bad argument to system call
360 case SIGPIPE13:
361 return "SIGPIPE"; // 13 write on a pipe with no one to read it
362 case SIGALRM14:
363 return "SIGALRM"; // 14 alarm clock
364 case SIGTERM15:
365 return "SIGTERM"; // 15 software termination signal from kill
366 case SIGURG23:
367 return "SIGURG"; // 16 urgent condition on IO channel
368 case SIGSTOP19:
369 return "SIGSTOP"; // 17 sendable stop signal not from tty
370 case SIGTSTP20:
371 return "SIGTSTP"; // 18 stop signal from tty
372 case SIGCONT18:
373 return "SIGCONT"; // 19 continue a stopped process
374 case SIGCHLD17:
375 return "SIGCHLD"; // 20 to parent on child stop or exit
376 case SIGTTIN21:
377 return "SIGTTIN"; // 21 to readers pgrp upon background tty read
378 case SIGTTOU22:
379 return "SIGTTOU"; // 22 like TTIN for output if (tp->t_local&LTOSTOP)
380#if defined(SIGIO29)
381 case SIGIO29:
382 return "SIGIO"; // 23 input/output possible signal
383#endif
384 case SIGXCPU24:
385 return "SIGXCPU"; // 24 exceeded CPU time limit
386 case SIGXFSZ25:
387 return "SIGXFSZ"; // 25 exceeded file size limit
388 case SIGVTALRM26:
389 return "SIGVTALRM"; // 26 virtual time alarm
390 case SIGPROF27:
391 return "SIGPROF"; // 27 profiling time alarm
392#if defined(SIGWINCH28)
393 case SIGWINCH28:
394 return "SIGWINCH"; // 28 window size changes
395#endif
396#if defined(SIGINFO)
397 case SIGINFO:
398 return "SIGINFO"; // 29 information request
399#endif
400 case SIGUSR110:
401 return "SIGUSR1"; // 30 user defined signal 1
402 case SIGUSR212:
403 return "SIGUSR2"; // 31 user defined signal 2
404 default:
405 break;
406 }
407 return NULL__null;
408}
409
410#endif
411
412#if !defined(__APPLE__) // see Host.mm
413
414bool Host::GetBundleDirectory(const FileSpec &file, FileSpec &bundle) {
415 bundle.Clear();
416 return false;
417}
418
419bool Host::ResolveExecutableInBundle(FileSpec &file) { return false; }
420#endif
421
422#ifndef _WIN32
423
424FileSpec Host::GetModuleFileSpecForHostAddress(const void *host_addr) {
425 FileSpec module_filespec;
426#if !defined(__ANDROID__)
427 Dl_info info;
428 if (::dladdr(host_addr, &info)) {
429 if (info.dli_fname)
430 module_filespec.SetFile(info.dli_fname, true);
431 }
432#endif
433 return module_filespec;
434}
435
436#endif
437
438#if !defined(__linux__1)
439bool Host::FindProcessThreads(const lldb::pid_t pid, TidMap &tids_to_attach) {
440 return false;
441}
442#endif
443
444struct ShellInfo {
445 ShellInfo()
446 : process_reaped(false), pid(LLDB_INVALID_PROCESS_ID0), signo(-1),
447 status(-1) {}
448
449 lldb_private::Predicate<bool> process_reaped;
450 lldb::pid_t pid;
451 int signo;
452 int status;
453};
454
455static bool
456MonitorShellCommand(std::shared_ptr<ShellInfo> shell_info, lldb::pid_t pid,
457 bool exited, // True if the process did exit
458 int signo, // Zero for no signal
459 int status) // Exit value of process if signal is zero
460{
461 shell_info->pid = pid;
462 shell_info->signo = signo;
463 shell_info->status = status;
464 // Let the thread running Host::RunShellCommand() know that the process
465 // exited and that ShellInfo has been filled in by broadcasting to it
466 shell_info->process_reaped.SetValue(true, eBroadcastAlways);
467 return true;
468}
469
470Status Host::RunShellCommand(const char *command, const FileSpec &working_dir,
471 int *status_ptr, int *signo_ptr,
472 std::string *command_output_ptr,
473 uint32_t timeout_sec, bool run_in_default_shell) {
474 return RunShellCommand(Args(command), working_dir, status_ptr, signo_ptr,
475 command_output_ptr, timeout_sec, run_in_default_shell);
476}
477
478Status Host::RunShellCommand(const Args &args, const FileSpec &working_dir,
479 int *status_ptr, int *signo_ptr,
480 std::string *command_output_ptr,
481 uint32_t timeout_sec, bool run_in_default_shell) {
482 Status error;
483 ProcessLaunchInfo launch_info;
484 launch_info.SetArchitecture(HostInfo::GetArchitecture());
485 if (run_in_default_shell) {
486 // Run the command in a shell
487 launch_info.SetShell(HostInfo::GetDefaultShell());
488 launch_info.GetArguments().AppendArguments(args);
489 const bool localhost = true;
490 const bool will_debug = false;
491 const bool first_arg_is_full_shell_command = false;
492 launch_info.ConvertArgumentsForLaunchingInShell(
493 error, localhost, will_debug, first_arg_is_full_shell_command, 0);
494 } else {
495 // No shell, just run it
496 const bool first_arg_is_executable = true;
497 launch_info.SetArguments(args, first_arg_is_executable);
498 }
499
500 if (working_dir)
501 launch_info.SetWorkingDirectory(working_dir);
502 llvm::SmallString<PATH_MAX4096> output_file_path;
503
504 if (command_output_ptr) {
505 // Create a temporary file to get the stdout/stderr and redirect the
506 // output of the command into this file. We will later read this file
507 // if all goes well and fill the data into "command_output_ptr"
508 FileSpec tmpdir_file_spec;
509 if (HostInfo::GetLLDBPath(ePathTypeLLDBTempSystemDir, tmpdir_file_spec)) {
510 tmpdir_file_spec.AppendPathComponent("lldb-shell-output.%%%%%%");
511 llvm::sys::fs::createUniqueFile(tmpdir_file_spec.GetPath(),
512 output_file_path);
513 } else {
514 llvm::sys::fs::createTemporaryFile("lldb-shell-output.%%%%%%", "",
515 output_file_path);
516 }
517 }
518
519 FileSpec output_file_spec{output_file_path.c_str(), false};
520
521 launch_info.AppendSuppressFileAction(STDIN_FILENO0, true, false);
522 if (output_file_spec) {
523 launch_info.AppendOpenFileAction(STDOUT_FILENO1, output_file_spec, false,
524 true);
525 launch_info.AppendDuplicateFileAction(STDOUT_FILENO1, STDERR_FILENO2);
526 } else {
527 launch_info.AppendSuppressFileAction(STDOUT_FILENO1, false, true);
528 launch_info.AppendSuppressFileAction(STDERR_FILENO2, false, true);
529 }
530
531 std::shared_ptr<ShellInfo> shell_info_sp(new ShellInfo());
532 const bool monitor_signals = false;
533 launch_info.SetMonitorProcessCallback(
534 std::bind(MonitorShellCommand, shell_info_sp, std::placeholders::_1,
535 std::placeholders::_2, std::placeholders::_3,
536 std::placeholders::_4),
537 monitor_signals);
538
539 error = LaunchProcess(launch_info);
540 const lldb::pid_t pid = launch_info.GetProcessID();
541
542 if (error.Success() && pid == LLDB_INVALID_PROCESS_ID0)
543 error.SetErrorString("failed to get process ID");
544
545 if (error.Success()) {
546 bool timed_out = false;
547 shell_info_sp->process_reaped.WaitForValueEqualTo(
548 true, std::chrono::seconds(timeout_sec), &timed_out);
549 if (timed_out) {
550 error.SetErrorString("timed out waiting for shell command to complete");
551
552 // Kill the process since it didn't complete within the timeout specified
553 Kill(pid, SIGKILL9);
554 // Wait for the monitor callback to get the message
555 timed_out = false;
556 shell_info_sp->process_reaped.WaitForValueEqualTo(
557 true, std::chrono::seconds(1), &timed_out);
558 } else {
559 if (status_ptr)
560 *status_ptr = shell_info_sp->status;
561
562 if (signo_ptr)
563 *signo_ptr = shell_info_sp->signo;
564
565 if (command_output_ptr) {
566 command_output_ptr->clear();
567 uint64_t file_size = output_file_spec.GetByteSize();
568 if (file_size > 0) {
569 if (file_size > command_output_ptr->max_size()) {
570 error.SetErrorStringWithFormat(
571 "shell command output is too large to fit into a std::string");
572 } else {
573 auto Buffer =
574 DataBufferLLVM::CreateFromPath(output_file_spec.GetPath());
575 if (error.Success())
576 command_output_ptr->assign(Buffer->GetChars(),
577 Buffer->GetByteSize());
578 }
579 }
580 }
581 }
582 }
583
584 llvm::sys::fs::remove(output_file_spec.GetPath());
585 return error;
586}
587
588// The functions below implement process launching for non-Apple-based platforms
589#if !defined(__APPLE__)
590Status Host::LaunchProcess(ProcessLaunchInfo &launch_info) {
591 std::unique_ptr<ProcessLauncher> delegate_launcher;
592#if defined(_WIN32)
593 delegate_launcher.reset(new ProcessLauncherWindows());
594#else
595 delegate_launcher.reset(new ProcessLauncherPosixFork());
596#endif
597 MonitoringProcessLauncher launcher(std::move(delegate_launcher));
598
599 Status error;
600 HostProcess process = launcher.LaunchProcess(launch_info, error);
601
602 // TODO(zturner): It would be better if the entire HostProcess were returned
603 // instead of writing
604 // it into this structure.
605 launch_info.SetProcessID(process.GetProcessId());
606
607 return error;
608}
609#endif // !defined(__APPLE__)
610
611#ifndef _WIN32
612void Host::Kill(lldb::pid_t pid, int signo) { ::kill(pid, signo); }
613
614#endif
615
616#if !defined(__APPLE__)
617bool Host::OpenFileInExternalEditor(const FileSpec &file_spec,
618 uint32_t line_no) {
619 return false;
620}
621
622#endif
623
624const UnixSignalsSP &Host::GetUnixSignals() {
625 static const auto s_unix_signals_sp =
626 UnixSignals::Create(HostInfo::GetArchitecture());
627 return s_unix_signals_sp;
628}
629
630std::unique_ptr<Connection> Host::CreateDefaultConnection(llvm::StringRef url) {
631#if defined(_WIN32)
632 if (url.startswith("file://"))
633 return std::unique_ptr<Connection>(new ConnectionGenericFile());
634#endif
635 return std::unique_ptr<Connection>(new ConnectionFileDescriptor());
636}
637
638#if defined(LLVM_ON_UNIX1)
639WaitStatus WaitStatus::Decode(int wstatus) {
640 if (WIFEXITED(wstatus)(((wstatus) & 0x7f) == 0))
641 return {Exit, uint8_t(WEXITSTATUS(wstatus)(((wstatus) & 0xff00) >> 8))};
642 else if (WIFSIGNALED(wstatus)(((signed char) (((wstatus) & 0x7f) + 1) >> 1) >
0)
)
643 return {Signal, uint8_t(WTERMSIG(wstatus)((wstatus) & 0x7f))};
644 else if (WIFSTOPPED(wstatus)(((wstatus) & 0xff) == 0x7f))
645 return {Stop, uint8_t(WSTOPSIG(wstatus)(((wstatus) & 0xff00) >> 8))};
646 llvm_unreachable("Unknown wait status")::llvm::llvm_unreachable_internal("Unknown wait status", "/build/llvm-toolchain-snapshot-6.0~svn316259/tools/lldb/source/Host/common/Host.cpp"
, 646)
;
647}
648#endif
649
650void llvm::format_provider<WaitStatus>::format(const WaitStatus &WS,
651 raw_ostream &OS,
652 StringRef Options) {
653 if (Options == "g") {
654 char type;
655 switch (WS.type) {
656 case WaitStatus::Exit:
657 type = 'W';
658 break;
659 case WaitStatus::Signal:
660 type = 'X';
661 break;
662 case WaitStatus::Stop:
663 type = 'S';
664 break;
665 }
666 OS << formatv("{0}{1:x-2}", type, WS.status);
667 return;
668 }
669
670 assert(Options.empty())((Options.empty()) ? static_cast<void> (0) : __assert_fail
("Options.empty()", "/build/llvm-toolchain-snapshot-6.0~svn316259/tools/lldb/source/Host/common/Host.cpp"
, 670, __PRETTY_FUNCTION__))
;
671 const char *desc;
672 switch(WS.type) {
673 case WaitStatus::Exit:
674 desc = "Exited with status";
675 break;
676 case WaitStatus::Signal:
677 desc = "Killed by signal";
678 break;
679 case WaitStatus::Stop:
680 desc = "Stopped by signal";
681 break;
682 }
683 OS << desc << " " << int(WS.status);
684}