16 #include "llvm/Config/config.h"
22 #ifdef HAVE_SYS_TIME_H
25 #ifdef HAVE_SYS_RESOURCE_H
26 #include <sys/resource.h>
28 #ifdef HAVE_SYS_STAT_H
34 #if defined(HAVE_MALLINFO) || defined(HAVE_MALLINFO2)
37 #if defined(HAVE_MALLCTL)
38 #include <malloc_np.h>
40 #ifdef HAVE_MALLOC_MALLOC_H
41 #include <malloc/malloc.h>
43 #ifdef HAVE_SYS_IOCTL_H
44 # include <sys/ioctl.h>
58 static std::pair<std::chrono::microseconds, std::chrono::microseconds> getRUsageTimes() {
59 #if defined(HAVE_GETRUSAGE)
61 ::getrusage(RUSAGE_SELF, &RU);
64 #warning Cannot get usage times on this platform
70 static_assert(
sizeof(
Pid) >=
sizeof(pid_t),
71 "Process::Pid should be big enough to store pid_t");
72 return Pid(::getpid());
78 #if defined(HAVE_GETPAGESIZE)
79 static const int page_size = ::getpagesize();
80 #elif defined(HAVE_SYSCONF)
81 static long page_size = ::sysconf(_SC_PAGE_SIZE);
83 #error Cannot get the page size on this machine
88 return static_cast<unsigned>(page_size);
92 #if defined(HAVE_MALLINFO2)
96 #elif defined(HAVE_MALLINFO)
100 #elif defined(HAVE_MALLOC_ZONE_STATISTICS) && defined(HAVE_MALLOC_MALLOC_H)
101 malloc_statistics_t
Stats;
102 malloc_zone_statistics(malloc_default_zone(), &
Stats);
103 return Stats.size_in_use;
104 #elif defined(HAVE_MALLCTL)
107 if (mallctl(
"stats.allocated", &alloc, &sz, NULL, 0) == 0)
110 #elif defined(HAVE_SBRK)
113 static char *StartOfMemory =
reinterpret_cast<char*
>(::sbrk(0));
114 char *EndOfMemory = (
char*)sbrk(0);
115 if (EndOfMemory != ((
char*)-1) && StartOfMemory != ((
char*)-1))
116 return EndOfMemory - StartOfMemory;
119 #warning Cannot get malloc info on this platform
125 std::chrono::nanoseconds &sys_time) {
127 std::tie(user_time, sys_time) = getRUsageTimes();
130 #if defined(HAVE_MACH_MACH_H) && !defined(__GNU__)
131 #include <mach/mach.h>
140 rlim.rlim_cur = rlim.rlim_max = 0;
141 setrlimit(RLIMIT_CORE, &rlim);
144 #if defined(HAVE_MACH_MACH_H) && !defined(__GNU__)
148 mach_msg_type_number_t Count = 0;
149 exception_mask_t OriginalMasks[EXC_TYPES_COUNT];
150 exception_port_t OriginalPorts[EXC_TYPES_COUNT];
151 exception_behavior_t OriginalBehaviors[EXC_TYPES_COUNT];
152 thread_state_flavor_t OriginalFlavors[EXC_TYPES_COUNT];
154 task_get_exception_ports(mach_task_self(), EXC_MASK_ALL, OriginalMasks,
155 &Count, OriginalPorts, OriginalBehaviors,
157 if (err == KERN_SUCCESS) {
159 for (
unsigned i = 0;
i != Count; ++
i)
160 task_set_exception_ports(mach_task_self(), OriginalMasks[
i],
161 MACH_PORT_NULL, OriginalBehaviors[
i],
166 signal(SIGABRT, _exit);
167 signal(SIGILL, _exit);
168 signal(SIGFPE, _exit);
169 signal(SIGSEGV, _exit);
170 signal(SIGBUS, _exit);
177 std::string NameStr =
Name.str();
178 const char *Val = ::getenv(NameStr.c_str());
181 return std::string(Val);
187 FDCloser(
int &FD) : FD(FD), KeepOpen(
false) {}
188 void keepOpen() { KeepOpen =
true; }
190 if (!KeepOpen && FD >= 0)
195 FDCloser(
const FDCloser &) =
delete;
196 void operator=(
const FDCloser &) =
delete;
205 FDCloser FDC(NullFD);
206 const int StandardFDs[] = {STDIN_FILENO, STDOUT_FILENO, STDERR_FILENO};
207 for (
int StandardFD : StandardFDs) {
211 assert(errno &&
"expected errno to be set if fstat failed!");
214 return std::error_code(errno, std::generic_category());
219 assert(errno == EBADF &&
"expected errno to have EBADF at this point!");
224 auto Open = [&]() { return ::open(
"/dev/null", O_RDWR); };
226 return std::error_code(errno, std::generic_category());
229 if (NullFD == StandardFD)
231 else if (dup2(NullFD, StandardFD) < 0)
232 return std::error_code(errno, std::generic_category());
234 return std::error_code();
239 sigset_t FullSet, SavedSet;
240 if (sigfillset(&FullSet) < 0 || sigfillset(&SavedSet) < 0)
241 return std::error_code(errno, std::generic_category());
244 #if LLVM_ENABLE_THREADS
245 if (
int EC = pthread_sigmask(SIG_SETMASK, &FullSet, &SavedSet))
246 return std::error_code(EC, std::generic_category());
248 if (sigprocmask(SIG_SETMASK, &FullSet, &SavedSet) < 0)
249 return std::error_code(errno, std::generic_category());
254 int ErrnoFromClose = 0;
256 ErrnoFromClose = errno;
259 #if LLVM_ENABLE_THREADS
260 EC = pthread_sigmask(SIG_SETMASK, &SavedSet,
nullptr);
262 if (sigprocmask(SIG_SETMASK, &SavedSet,
nullptr) < 0)
268 return std::error_code(ErrnoFromClose, std::generic_category());
269 return std::error_code(EC, std::generic_category());
293 static unsigned getColumns() {
295 if (
const char *ColumnsStr = std::getenv(
"COLUMNS")) {
296 int Columns = std::atoi(ColumnsStr);
320 #ifdef LLVM_ENABLE_TERMINFO
324 extern "C" int setupterm(
char *term,
int filedes,
int *errret);
325 extern "C" struct term *set_curterm(
struct term *termp);
326 extern "C" int del_curterm(
struct term *termp);
327 extern "C" int tigetnum(
char *capname);
330 #ifdef LLVM_ENABLE_TERMINFO
334 bool checkTerminalEnvironmentForColors() {
335 if (
const char *TermStr = std::getenv(
"TERM")) {
338 .
Case(
"cygwin",
true)
351 static bool terminalHasColors(
int fd) {
352 #ifdef LLVM_ENABLE_TERMINFO
354 std::lock_guard<std::mutex>
G(*TermColorMutex);
356 struct term *previous_term = set_curterm(
nullptr);
358 if (setupterm(
nullptr, fd, &errret) != 0)
376 int colors_ti = tigetnum(
const_cast<char *
>(
"colors"));
377 bool HasColors = colors_ti >= 0 ? colors_ti : checkTerminalEnvironmentForColors();
381 struct term *termp = set_curterm(previous_term);
382 (void)del_curterm(termp);
389 return checkTerminalEnvironmentForColors();
432 #if !HAVE_DECL_ARC4RANDOM
433 static unsigned GetRandomNumberSeed() {
435 int urandomFD = open(
"/dev/urandom", O_RDONLY);
437 if (urandomFD != -1) {
441 int count =
read(urandomFD, (
void *)&seed,
sizeof(seed));
446 if (
count ==
sizeof(seed))
453 return hash_combine(Now.time_since_epoch().count(), ::getpid());
458 #if HAVE_DECL_ARC4RANDOM
461 static int x = (
static_cast<void>(::srand(GetRandomNumberSeed())), 0);
467 [[noreturn]]
void Process::ExitNoCleanup(
int RetCode) { _Exit(RetCode); }