16 #include "llvm/Config/config.h"
21 #ifdef HAVE_SYS_TIME_H
24 #ifdef HAVE_SYS_RESOURCE_H
25 #include <sys/resource.h>
27 #ifdef HAVE_SYS_STAT_H
33 #if defined(HAVE_MALLINFO) || defined(HAVE_MALLINFO2)
36 #if defined(HAVE_MALLCTL)
37 #include <malloc_np.h>
39 #ifdef HAVE_MALLOC_MALLOC_H
40 #include <malloc/malloc.h>
42 #ifdef HAVE_SYS_IOCTL_H
43 # include <sys/ioctl.h>
57 static std::pair<std::chrono::microseconds, std::chrono::microseconds> getRUsageTimes() {
58 #if defined(HAVE_GETRUSAGE)
60 ::getrusage(RUSAGE_SELF, &RU);
63 #warning Cannot get usage times on this platform
69 static_assert(
sizeof(
Pid) >=
sizeof(pid_t),
70 "Process::Pid should be big enough to store pid_t");
71 return Pid(::getpid());
77 #if defined(HAVE_GETPAGESIZE)
78 static const int page_size = ::getpagesize();
79 #elif defined(HAVE_SYSCONF)
80 static long page_size = ::sysconf(_SC_PAGE_SIZE);
82 #error Cannot get the page size on this machine
87 return static_cast<unsigned>(page_size);
91 #if defined(HAVE_MALLINFO2)
95 #elif defined(HAVE_MALLINFO)
99 #elif defined(HAVE_MALLOC_ZONE_STATISTICS) && defined(HAVE_MALLOC_MALLOC_H)
100 malloc_statistics_t
Stats;
101 malloc_zone_statistics(malloc_default_zone(), &
Stats);
102 return Stats.size_in_use;
103 #elif defined(HAVE_MALLCTL)
106 if (mallctl(
"stats.allocated", &alloc, &sz, NULL, 0) == 0)
109 #elif defined(HAVE_SBRK)
112 static char *StartOfMemory =
reinterpret_cast<char*
>(::sbrk(0));
113 char *EndOfMemory = (
char*)sbrk(0);
114 if (EndOfMemory != ((
char*)-1) && StartOfMemory != ((
char*)-1))
115 return EndOfMemory - StartOfMemory;
118 #warning Cannot get malloc info on this platform
124 std::chrono::nanoseconds &sys_time) {
126 std::tie(user_time, sys_time) = getRUsageTimes();
129 #if defined(HAVE_MACH_MACH_H) && !defined(__GNU__)
130 #include <mach/mach.h>
139 rlim.rlim_cur = rlim.rlim_max = 0;
140 setrlimit(RLIMIT_CORE, &rlim);
143 #if defined(HAVE_MACH_MACH_H) && !defined(__GNU__)
147 mach_msg_type_number_t Count = 0;
148 exception_mask_t OriginalMasks[EXC_TYPES_COUNT];
149 exception_port_t OriginalPorts[EXC_TYPES_COUNT];
150 exception_behavior_t OriginalBehaviors[EXC_TYPES_COUNT];
151 thread_state_flavor_t OriginalFlavors[EXC_TYPES_COUNT];
153 task_get_exception_ports(mach_task_self(), EXC_MASK_ALL, OriginalMasks,
154 &Count, OriginalPorts, OriginalBehaviors,
156 if (err == KERN_SUCCESS) {
158 for (
unsigned i = 0;
i != Count; ++
i)
159 task_set_exception_ports(mach_task_self(), OriginalMasks[
i],
160 MACH_PORT_NULL, OriginalBehaviors[
i],
165 signal(SIGABRT, _exit);
166 signal(SIGILL, _exit);
167 signal(SIGFPE, _exit);
168 signal(SIGSEGV, _exit);
169 signal(SIGBUS, _exit);
176 std::string NameStr =
Name.str();
177 const char *Val = ::getenv(NameStr.c_str());
180 return std::string(Val);
186 FDCloser(
int &FD) : FD(FD), KeepOpen(
false) {}
187 void keepOpen() { KeepOpen =
true; }
189 if (!KeepOpen && FD >= 0)
194 FDCloser(
const FDCloser &) =
delete;
195 void operator=(
const FDCloser &) =
delete;
204 FDCloser FDC(NullFD);
205 const int StandardFDs[] = {STDIN_FILENO, STDOUT_FILENO, STDERR_FILENO};
206 for (
int StandardFD : StandardFDs) {
210 assert(errno &&
"expected errno to be set if fstat failed!");
213 return std::error_code(errno, std::generic_category());
218 assert(errno == EBADF &&
"expected errno to have EBADF at this point!");
223 auto Open = [&]() { return ::open(
"/dev/null", O_RDWR); };
225 return std::error_code(errno, std::generic_category());
228 if (NullFD == StandardFD)
230 else if (dup2(NullFD, StandardFD) < 0)
231 return std::error_code(errno, std::generic_category());
233 return std::error_code();
238 sigset_t FullSet, SavedSet;
239 if (sigfillset(&FullSet) < 0 || sigfillset(&SavedSet) < 0)
240 return std::error_code(errno, std::generic_category());
243 #if LLVM_ENABLE_THREADS
244 if (
int EC = pthread_sigmask(SIG_SETMASK, &FullSet, &SavedSet))
245 return std::error_code(EC, std::generic_category());
247 if (sigprocmask(SIG_SETMASK, &FullSet, &SavedSet) < 0)
248 return std::error_code(errno, std::generic_category());
253 int ErrnoFromClose = 0;
255 ErrnoFromClose = errno;
258 #if LLVM_ENABLE_THREADS
259 EC = pthread_sigmask(SIG_SETMASK, &SavedSet,
nullptr);
261 if (sigprocmask(SIG_SETMASK, &SavedSet,
nullptr) < 0)
267 return std::error_code(ErrnoFromClose, std::generic_category());
268 return std::error_code(EC, std::generic_category());
292 static unsigned getColumns() {
294 if (
const char *ColumnsStr = std::getenv(
"COLUMNS")) {
295 int Columns = std::atoi(ColumnsStr);
319 #ifdef LLVM_ENABLE_TERMINFO
323 extern "C" int setupterm(
char *term,
int filedes,
int *errret);
324 extern "C" struct term *set_curterm(
struct term *termp);
325 extern "C" int del_curterm(
struct term *termp);
326 extern "C" int tigetnum(
char *capname);
329 bool checkTerminalEnvironmentForColors() {
330 if (
const char *TermStr = std::getenv(
"TERM")) {
333 .
Case(
"cygwin",
true)
346 static bool terminalHasColors(
int fd) {
347 #ifdef LLVM_ENABLE_TERMINFO
349 static std::mutex TermColorMutex;
350 std::lock_guard<std::mutex>
G(TermColorMutex);
352 struct term *previous_term = set_curterm(
nullptr);
354 if (setupterm(
nullptr, fd, &errret) != 0)
372 int colors_ti = tigetnum(
const_cast<char *
>(
"colors"));
373 bool HasColors = colors_ti >= 0 ? colors_ti : checkTerminalEnvironmentForColors();
377 struct term *termp = set_curterm(previous_term);
378 (void)del_curterm(termp);
385 return checkTerminalEnvironmentForColors();
428 #if !HAVE_DECL_ARC4RANDOM
429 static unsigned GetRandomNumberSeed() {
431 int urandomFD = open(
"/dev/urandom", O_RDONLY);
433 if (urandomFD != -1) {
437 int count =
read(urandomFD, (
void *)&seed,
sizeof(seed));
442 if (
count ==
sizeof(seed))
449 return hash_combine(Now.time_since_epoch().count(), ::getpid());
454 #if HAVE_DECL_ARC4RANDOM
457 static int x = (
static_cast<void>(::srand(GetRandomNumberSeed())), 0);
463 [[noreturn]]
void Process::ExitNoCleanup(
int RetCode) { _Exit(RetCode); }