LLVM 19.0.0git
Program.inc
Go to the documentation of this file.
1//===- llvm/Support/Unix/Program.inc ----------------------------*- C++ -*-===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9// This file implements the Unix specific portion of the Program class.
10//
11//===----------------------------------------------------------------------===//
12
13//===----------------------------------------------------------------------===//
14//=== WARNING: Implementation here must contain only generic UNIX
15//=== code that is guaranteed to work on *all* UNIX variants.
16//===----------------------------------------------------------------------===//
17
19
20#include "Unix.h"
22#include "llvm/Config/config.h"
25#include "llvm/Support/Errc.h"
27#include "llvm/Support/Path.h"
31#if HAVE_SYS_STAT_H
32#include <sys/stat.h>
33#endif
34#if HAVE_SYS_RESOURCE_H
35#include <sys/resource.h>
36#endif
37#if HAVE_SIGNAL_H
38#include <signal.h>
39#endif
40#if HAVE_FCNTL_H
41#include <fcntl.h>
42#endif
43#if HAVE_UNISTD_H
44#include <unistd.h>
45#endif
46#ifdef HAVE_POSIX_SPAWN
47#include <spawn.h>
48
49#if defined(__APPLE__)
50#include <TargetConditionals.h>
51#endif
52
53#if defined(__APPLE__) && !(defined(TARGET_OS_IPHONE) && TARGET_OS_IPHONE)
54#define USE_NSGETENVIRON 1
55#else
56#define USE_NSGETENVIRON 0
57#endif
58
59#if !USE_NSGETENVIRON
60extern char **environ;
61#else
62#include <crt_externs.h> // _NSGetEnviron
63#endif
64#endif
65
66using namespace llvm;
67using namespace sys;
68
69ProcessInfo::ProcessInfo() : Pid(0), ReturnCode(0) {}
70
71ErrorOr<std::string> sys::findProgramByName(StringRef Name,
72 ArrayRef<StringRef> Paths) {
73 assert(!Name.empty() && "Must have a name!");
74 // Use the given path verbatim if it contains any slashes; this matches
75 // the behavior of sh(1) and friends.
76 if (Name.contains('/'))
77 return std::string(Name);
78
79 SmallVector<StringRef, 16> EnvironmentPaths;
80 if (Paths.empty())
81 if (const char *PathEnv = std::getenv("PATH")) {
82 SplitString(PathEnv, EnvironmentPaths, ":");
83 Paths = EnvironmentPaths;
84 }
85
86 for (auto Path : Paths) {
87 if (Path.empty())
88 continue;
89
90 // Check to see if this first directory contains the executable...
91 SmallString<128> FilePath(Path);
92 sys::path::append(FilePath, Name);
93 if (sys::fs::can_execute(FilePath.c_str()))
94 return std::string(FilePath); // Found the executable!
95 }
96 return errc::no_such_file_or_directory;
97}
98
99static bool RedirectIO(std::optional<StringRef> Path, int FD, std::string *ErrMsg) {
100 if (!Path) // Noop
101 return false;
102 std::string File;
103 if (Path->empty())
104 // Redirect empty paths to /dev/null
105 File = "/dev/null";
106 else
107 File = std::string(*Path);
108
109 // Open the file
110 int InFD = open(File.c_str(), FD == 0 ? O_RDONLY : O_WRONLY | O_CREAT, 0666);
111 if (InFD == -1) {
112 MakeErrMsg(ErrMsg, "Cannot open file '" + File + "' for " +
113 (FD == 0 ? "input" : "output"));
114 return true;
115 }
116
117 // Install it as the requested FD
118 if (dup2(InFD, FD) == -1) {
119 MakeErrMsg(ErrMsg, "Cannot dup2");
120 close(InFD);
121 return true;
122 }
123 close(InFD); // Close the original FD
124 return false;
125}
126
127#ifdef HAVE_POSIX_SPAWN
128static bool RedirectIO_PS(const std::string *Path, int FD, std::string *ErrMsg,
129 posix_spawn_file_actions_t *FileActions) {
130 if (!Path) // Noop
131 return false;
132 const char *File;
133 if (Path->empty())
134 // Redirect empty paths to /dev/null
135 File = "/dev/null";
136 else
137 File = Path->c_str();
138
139 if (int Err = posix_spawn_file_actions_addopen(
140 FileActions, FD, File, FD == 0 ? O_RDONLY : O_WRONLY | O_CREAT, 0666))
141 return MakeErrMsg(ErrMsg, "Cannot posix_spawn_file_actions_addopen", Err);
142 return false;
143}
144#endif
145
146static void TimeOutHandler(int Sig) {}
147
148static void SetMemoryLimits(unsigned size) {
149#if HAVE_SYS_RESOURCE_H && HAVE_GETRLIMIT && HAVE_SETRLIMIT
150 struct rlimit r;
151 __typeof__(r.rlim_cur) limit = (__typeof__(r.rlim_cur))(size)*1048576;
152
153 // Heap size
154 getrlimit(RLIMIT_DATA, &r);
155 r.rlim_cur = limit;
156 setrlimit(RLIMIT_DATA, &r);
157#ifdef RLIMIT_RSS
158 // Resident set size.
159 getrlimit(RLIMIT_RSS, &r);
160 r.rlim_cur = limit;
161 setrlimit(RLIMIT_RSS, &r);
162#endif
163#endif
164}
165
166static std::vector<const char *>
167toNullTerminatedCStringArray(ArrayRef<StringRef> Strings, StringSaver &Saver) {
168 std::vector<const char *> Result;
169 for (StringRef S : Strings)
170 Result.push_back(Saver.save(S).data());
171 Result.push_back(nullptr);
172 return Result;
173}
174
175static bool Execute(ProcessInfo &PI, StringRef Program,
177 std::optional<ArrayRef<StringRef>> Env,
178 ArrayRef<std::optional<StringRef>> Redirects,
179 unsigned MemoryLimit, std::string *ErrMsg,
180 BitVector *AffinityMask, bool DetachProcess) {
181 if (!llvm::sys::fs::exists(Program)) {
182 if (ErrMsg)
183 *ErrMsg = std::string("Executable \"") + Program.str() +
184 std::string("\" doesn't exist!");
185 return false;
186 }
187
188 assert(!AffinityMask && "Starting a process with an affinity mask is "
189 "currently not supported on Unix!");
190
192 StringSaver Saver(Allocator);
193 std::vector<const char *> ArgVector, EnvVector;
194 const char **Argv = nullptr;
195 const char **Envp = nullptr;
196 ArgVector = toNullTerminatedCStringArray(Args, Saver);
197 Argv = ArgVector.data();
198 if (Env) {
199 EnvVector = toNullTerminatedCStringArray(*Env, Saver);
200 Envp = EnvVector.data();
201 }
202
203 // If this OS has posix_spawn and there is no memory limit being implied, use
204 // posix_spawn. It is more efficient than fork/exec.
205#ifdef HAVE_POSIX_SPAWN
206 // Cannot use posix_spawn if you would like to detach the process
207 if (MemoryLimit == 0 && !DetachProcess) {
208 posix_spawn_file_actions_t FileActionsStore;
209 posix_spawn_file_actions_t *FileActions = nullptr;
210
211 // If we call posix_spawn_file_actions_addopen we have to make sure the
212 // c strings we pass to it stay alive until the call to posix_spawn,
213 // so we copy any StringRefs into this variable.
214 std::string RedirectsStorage[3];
215
216 if (!Redirects.empty()) {
217 assert(Redirects.size() == 3);
218 std::string *RedirectsStr[3] = {nullptr, nullptr, nullptr};
219 for (int I = 0; I < 3; ++I) {
220 if (Redirects[I]) {
221 RedirectsStorage[I] = std::string(*Redirects[I]);
222 RedirectsStr[I] = &RedirectsStorage[I];
223 }
224 }
225
226 FileActions = &FileActionsStore;
227 posix_spawn_file_actions_init(FileActions);
228
229 // Redirect stdin/stdout.
230 if (RedirectIO_PS(RedirectsStr[0], 0, ErrMsg, FileActions) ||
231 RedirectIO_PS(RedirectsStr[1], 1, ErrMsg, FileActions))
232 return false;
233 if (!Redirects[1] || !Redirects[2] || *Redirects[1] != *Redirects[2]) {
234 // Just redirect stderr
235 if (RedirectIO_PS(RedirectsStr[2], 2, ErrMsg, FileActions))
236 return false;
237 } else {
238 // If stdout and stderr should go to the same place, redirect stderr
239 // to the FD already open for stdout.
240 if (int Err = posix_spawn_file_actions_adddup2(FileActions, 1, 2))
241 return !MakeErrMsg(ErrMsg, "Can't redirect stderr to stdout", Err);
242 }
243 }
244
245 if (!Envp)
246#if !USE_NSGETENVIRON
247 Envp = const_cast<const char **>(environ);
248#else
249 // environ is missing in dylibs.
250 Envp = const_cast<const char **>(*_NSGetEnviron());
251#endif
252
253 constexpr int maxRetries = 8;
254 int retries = 0;
255 pid_t PID;
256 int Err;
257 do {
258 PID = 0; // Make Valgrind happy.
259 Err = posix_spawn(&PID, Program.str().c_str(), FileActions,
260 /*attrp*/ nullptr, const_cast<char **>(Argv),
261 const_cast<char **>(Envp));
262 } while (Err == EINTR && ++retries < maxRetries);
263
264 if (FileActions)
265 posix_spawn_file_actions_destroy(FileActions);
266
267 if (Err)
268 return !MakeErrMsg(ErrMsg, "posix_spawn failed", Err);
269
270 PI.Pid = PID;
271 PI.Process = PID;
272
273 return true;
274 }
275#endif // HAVE_POSIX_SPAWN
276
277 // Create a child process.
278 int child = fork();
279 switch (child) {
280 // An error occurred: Return to the caller.
281 case -1:
282 MakeErrMsg(ErrMsg, "Couldn't fork");
283 return false;
284
285 // Child process: Execute the program.
286 case 0: {
287 // Redirect file descriptors...
288 if (!Redirects.empty()) {
289 // Redirect stdin
290 if (RedirectIO(Redirects[0], 0, ErrMsg)) {
291 return false;
292 }
293 // Redirect stdout
294 if (RedirectIO(Redirects[1], 1, ErrMsg)) {
295 return false;
296 }
297 if (Redirects[1] && Redirects[2] && *Redirects[1] == *Redirects[2]) {
298 // If stdout and stderr should go to the same place, redirect stderr
299 // to the FD already open for stdout.
300 if (-1 == dup2(1, 2)) {
301 MakeErrMsg(ErrMsg, "Can't redirect stderr to stdout");
302 return false;
303 }
304 } else {
305 // Just redirect stderr
306 if (RedirectIO(Redirects[2], 2, ErrMsg)) {
307 return false;
308 }
309 }
310 }
311
312 if (DetachProcess) {
313 // Detach from controlling terminal
314 if (::setsid() == -1) {
315 MakeErrMsg(ErrMsg, "Could not detach process, ::setsid failed");
316 return false;
317 }
318 }
319
320 // Set memory limits
321 if (MemoryLimit != 0) {
322 SetMemoryLimits(MemoryLimit);
323 }
324
325 // Execute!
326 std::string PathStr = std::string(Program);
327 if (Envp != nullptr)
328 execve(PathStr.c_str(), const_cast<char **>(Argv),
329 const_cast<char **>(Envp));
330 else
331 execv(PathStr.c_str(), const_cast<char **>(Argv));
332 // If the execve() failed, we should exit. Follow Unix protocol and
333 // return 127 if the executable was not found, and 126 otherwise.
334 // Use _exit rather than exit so that atexit functions and static
335 // object destructors cloned from the parent process aren't
336 // redundantly run, and so that any data buffered in stdio buffers
337 // cloned from the parent aren't redundantly written out.
338 _exit(errno == ENOENT ? 127 : 126);
339 }
340
341 // Parent process: Break out of the switch to do our processing.
342 default:
343 break;
344 }
345
346 PI.Pid = child;
347 PI.Process = child;
348
349 return true;
350}
351
352namespace llvm {
353namespace sys {
354
355#if defined(_AIX)
356static pid_t(wait4)(pid_t pid, int *status, int options, struct rusage *usage);
357#elif !defined(__Fuchsia__)
358using ::wait4;
359#endif
360
361} // namespace sys
362} // namespace llvm
363
364#ifdef _AIX
365#ifndef _ALL_SOURCE
366extern "C" pid_t(wait4)(pid_t pid, int *status, int options,
367 struct rusage *usage);
368#endif
369pid_t(llvm::sys::wait4)(pid_t pid, int *status, int options,
370 struct rusage *usage) {
371 assert(pid > 0 && "Only expecting to handle actual PID values!");
372 assert((options & ~WNOHANG) == 0 && "Expecting WNOHANG at most!");
373 assert(usage && "Expecting usage collection!");
374
375 // AIX wait4 does not work well with WNOHANG.
376 if (!(options & WNOHANG))
377 return ::wait4(pid, status, options, usage);
378
379 // For WNOHANG, we use waitid (which supports WNOWAIT) until the child process
380 // has terminated.
381 siginfo_t WaitIdInfo;
382 WaitIdInfo.si_pid = 0;
383 int WaitIdRetVal =
384 waitid(P_PID, pid, &WaitIdInfo, WNOWAIT | WEXITED | options);
385
386 if (WaitIdRetVal == -1 || WaitIdInfo.si_pid == 0)
387 return WaitIdRetVal;
388
389 assert(WaitIdInfo.si_pid == pid);
390
391 // The child has already terminated, so a blocking wait on it is okay in the
392 // absence of indiscriminate `wait` calls from the current process (which
393 // would cause the call here to fail with ECHILD).
394 return ::wait4(pid, status, options & ~WNOHANG, usage);
395}
396#endif
397
399 std::optional<unsigned> SecondsToWait,
400 std::string *ErrMsg,
401 std::optional<ProcessStatistics> *ProcStat,
402 bool Polling) {
403 struct sigaction Act, Old;
404 assert(PI.Pid && "invalid pid to wait on, process not started?");
405
406 int WaitPidOptions = 0;
407 pid_t ChildPid = PI.Pid;
408 bool WaitUntilTerminates = false;
409 if (!SecondsToWait) {
410 WaitUntilTerminates = true;
411 } else {
412 if (*SecondsToWait == 0)
413 WaitPidOptions = WNOHANG;
414
415 // Install a timeout handler. The handler itself does nothing, but the
416 // simple fact of having a handler at all causes the wait below to return
417 // with EINTR, unlike if we used SIG_IGN.
418 memset(&Act, 0, sizeof(Act));
419 Act.sa_handler = TimeOutHandler;
420 sigemptyset(&Act.sa_mask);
421 sigaction(SIGALRM, &Act, &Old);
422 // FIXME The alarm signal may be delivered to another thread.
423 alarm(*SecondsToWait);
424 }
425
426 // Parent process: Wait for the child process to terminate.
427 int status = 0;
428 ProcessInfo WaitResult;
429#ifndef __Fuchsia__
430 rusage Info;
431 if (ProcStat)
432 ProcStat->reset();
433
434 do {
435 WaitResult.Pid = sys::wait4(ChildPid, &status, WaitPidOptions, &Info);
436 } while (WaitUntilTerminates && WaitResult.Pid == -1 && errno == EINTR);
437#endif
438
439 if (WaitResult.Pid != PI.Pid) {
440 if (WaitResult.Pid == 0) {
441 // Non-blocking wait.
442 return WaitResult;
443 } else {
444 if (SecondsToWait && errno == EINTR && !Polling) {
445 // Kill the child.
446 kill(PI.Pid, SIGKILL);
447
448 // Turn off the alarm and restore the signal handler
449 alarm(0);
450 sigaction(SIGALRM, &Old, nullptr);
451
452 // Wait for child to die
453 // FIXME This could grab some other child process out from another
454 // waiting thread and then leave a zombie anyway.
455 if (wait(&status) != ChildPid)
456 MakeErrMsg(ErrMsg, "Child timed out but wouldn't die");
457 else
458 MakeErrMsg(ErrMsg, "Child timed out", 0);
459
460 WaitResult.ReturnCode = -2; // Timeout detected
461 return WaitResult;
462 } else if (errno != EINTR) {
463 MakeErrMsg(ErrMsg, "Error waiting for child process");
464 WaitResult.ReturnCode = -1;
465 return WaitResult;
466 }
467 }
468 }
469
470 // We exited normally without timeout, so turn off the timer.
471 if (SecondsToWait && !WaitUntilTerminates) {
472 alarm(0);
473 sigaction(SIGALRM, &Old, nullptr);
474 }
475
476#ifndef __Fuchsia__
477 if (ProcStat) {
478 std::chrono::microseconds UserT = toDuration(Info.ru_utime);
479 std::chrono::microseconds KernelT = toDuration(Info.ru_stime);
480 uint64_t PeakMemory = 0;
481#if !defined(__HAIKU__) && !defined(__MVS__)
482 PeakMemory = static_cast<uint64_t>(Info.ru_maxrss);
483#endif
484 *ProcStat = ProcessStatistics{UserT + KernelT, UserT, PeakMemory};
485 }
486#endif
487
488 // Return the proper exit status. Detect error conditions
489 // so we can return -1 for them and set ErrMsg informatively.
490 int result = 0;
491 if (WIFEXITED(status)) {
492 result = WEXITSTATUS(status);
493 WaitResult.ReturnCode = result;
494
495 if (result == 127) {
496 if (ErrMsg)
497 *ErrMsg = llvm::sys::StrError(ENOENT);
498 WaitResult.ReturnCode = -1;
499 return WaitResult;
500 }
501 if (result == 126) {
502 if (ErrMsg)
503 *ErrMsg = "Program could not be executed";
504 WaitResult.ReturnCode = -1;
505 return WaitResult;
506 }
507 } else if (WIFSIGNALED(status)) {
508 if (ErrMsg) {
509 *ErrMsg = strsignal(WTERMSIG(status));
510#ifdef WCOREDUMP
511 if (WCOREDUMP(status))
512 *ErrMsg += " (core dumped)";
513#endif
514 }
515 // Return a special value to indicate that the process received an unhandled
516 // signal during execution as opposed to failing to execute.
517 WaitResult.ReturnCode = -2;
518 }
519 return WaitResult;
520}
521
522std::error_code llvm::sys::ChangeStdinMode(fs::OpenFlags Flags) {
523 if (!(Flags & fs::OF_Text))
524 return ChangeStdinToBinary();
525 return std::error_code();
526}
527
528std::error_code llvm::sys::ChangeStdoutMode(fs::OpenFlags Flags) {
529 if (!(Flags & fs::OF_Text))
530 return ChangeStdoutToBinary();
531 return std::error_code();
532}
533
534std::error_code llvm::sys::ChangeStdinToBinary() {
535#ifdef __MVS__
536 return disableAutoConversion(STDIN_FILENO);
537#else
538 // Do nothing, as Unix doesn't differentiate between text and binary.
539 return std::error_code();
540#endif
541}
542
543std::error_code llvm::sys::ChangeStdoutToBinary() {
544 // Do nothing, as Unix doesn't differentiate between text and binary.
545 return std::error_code();
546}
547
548std::error_code
550 WindowsEncodingMethod Encoding /*unused*/) {
551 std::error_code EC;
552 llvm::raw_fd_ostream OS(FileName, EC,
554
555 if (EC)
556 return EC;
557
558 OS << Contents;
559
560 if (OS.has_error())
561 return make_error_code(errc::io_error);
562
563 return EC;
564}
565
567 ArrayRef<StringRef> Args) {
568 static long ArgMax = sysconf(_SC_ARG_MAX);
569 // POSIX requires that _POSIX_ARG_MAX is 4096, which is the lowest possible
570 // value for ARG_MAX on a POSIX compliant system.
571 static long ArgMin = _POSIX_ARG_MAX;
572
573 // This the same baseline used by xargs.
574 long EffectiveArgMax = 128 * 1024;
575
576 if (EffectiveArgMax > ArgMax)
577 EffectiveArgMax = ArgMax;
578 else if (EffectiveArgMax < ArgMin)
579 EffectiveArgMax = ArgMin;
580
581 // System says no practical limit.
582 if (ArgMax == -1)
583 return true;
584
585 // Conservatively account for space required by environment variables.
586 long HalfArgMax = EffectiveArgMax / 2;
587
588 size_t ArgLength = Program.size() + 1;
589 for (StringRef Arg : Args) {
590 // Ensure that we do not exceed the MAX_ARG_STRLEN constant on Linux, which
591 // does not have a constant unlike what the man pages would have you
592 // believe. Since this limit is pretty high, perform the check
593 // unconditionally rather than trying to be aggressive and limiting it to
594 // Linux only.
595 if (Arg.size() >= (32 * 4096))
596 return false;
597
598 ArgLength += Arg.size() + 1;
599 if (ArgLength > size_t(HalfArgMax)) {
600 return false;
601 }
602 }
603
604 return true;
605}
Analysis containing CSE Info
Definition: CSEInfo.cpp:27
std::string Name
#define I(x, y, z)
Definition: MD5.cpp:58
static bool Execute(ProcessInfo &PI, StringRef Program, ArrayRef< StringRef > Args, std::optional< ArrayRef< StringRef > > Env, ArrayRef< std::optional< StringRef > > Redirects, unsigned MemoryLimit, std::string *ErrMsg, BitVector *AffinityMask, bool DetachProcess)
Basic Register Allocator
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
raw_pwrite_stream & OS
This file contains some functions that are useful when dealing with strings.
static bool MakeErrMsg(std::string *ErrMsg, const std::string &prefix, int errnum=-1)
This function builds an error message into ErrMsg using the prefix string and the Unix error number g...
Definition: Unix.h:59
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...
Definition: ArrayRef.h:41
bool empty() const
empty - Check if the array is empty.
Definition: ArrayRef.h:160
Allocate memory in an ever growing pool, as if by bump-pointer.
Definition: Allocator.h:66
Represents either an error or a value T.
Definition: ErrorOr.h:56
SmallString - A SmallString is just a SmallVector with methods and accessors that make it work better...
Definition: SmallString.h:26
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
Definition: SmallVector.h:1209
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:50
std::string str() const
str - Get the contents as an std::string.
Definition: StringRef.h:223
constexpr size_t size() const
size - Get the string size.
Definition: StringRef.h:137
constexpr const char * data() const
data - Get a pointer to the start of the string (which may not be null terminated).
Definition: StringRef.h:131
Saves strings in the provided stable storage and returns a StringRef with a stable character pointer.
Definition: StringSaver.h:21
StringRef save(const char *S)
Definition: StringSaver.h:30
A raw_ostream that writes to a file descriptor.
Definition: raw_ostream.h:471
std::vector< std::string > ArgVector
LVOptions & options()
Definition: LVOptions.h:445
std::error_code status(const Twine &path, file_status &result, bool follow=true)
Get file status as if by POSIX stat().
bool exists(const basic_file_status &status)
Does file exist?
Definition: Path.cpp:1078
@ OF_TextWithCRLF
The file should be opened in text mode and use a carriage linefeed '\r '.
Definition: FileSystem.h:768
std::chrono::nanoseconds toDuration(FILETIME Time)
std::string StrError()
Returns a string representation of the errno value, using whatever thread-safe variant of strerror() ...
std::error_code ChangeStdinMode(fs::OpenFlags Flags)
std::error_code ChangeStdinToBinary()
ProcessInfo Wait(const ProcessInfo &PI, std::optional< unsigned > SecondsToWait, std::string *ErrMsg=nullptr, std::optional< ProcessStatistics > *ProcStat=nullptr, bool Polling=false)
This function waits for the process specified by PI to finish.
bool commandLineFitsWithinSystemLimits(StringRef Program, ArrayRef< StringRef > Args)
Return true if the given arguments fit within system-specific argument length limits.
std::error_code ChangeStdoutMode(fs::OpenFlags Flags)
WindowsEncodingMethod
File encoding options when writing contents that a non-UTF8 tool will read (on Windows systems).
Definition: Program.h:172
std::error_code ChangeStdoutToBinary()
std::error_code writeFileWithEncoding(StringRef FileName, StringRef Contents, WindowsEncodingMethod Encoding=WEM_UTF8)
Saves the UTF8-encoded contents string into the file FileName using a specific encoding.
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
std::error_code make_error_code(BitcodeError E)
This struct encapsulates information about a process.
Definition: Program.h:46
process_t Process
The process identifier.
Definition: Program.h:50
int ReturnCode
Platform-dependent process object.
Definition: Program.h:53
This struct encapsulates information about a process execution.
Definition: Program.h:59