16#include "llvm/Config/config.h"
17#include "llvm/Config/llvm-config.h"
22#include <sys/resource.h>
25#if defined(HAVE_MALLINFO) || defined(HAVE_MALLINFO2)
28#if defined(HAVE_MALLCTL)
31#ifdef HAVE_MALLOC_MALLOC_H
32#include <malloc/malloc.h>
43static std::pair<std::chrono::microseconds, std::chrono::microseconds>
45#if defined(HAVE_GETRUSAGE)
47 ::getrusage(RUSAGE_SELF, &RU);
51#warning Cannot get usage times on this platform
53 return {std::chrono::microseconds::zero(), std::chrono::microseconds::zero()};
58 static_assert(
sizeof(Pid) >=
sizeof(pid_t),
59 "Process::Pid should be big enough to store pid_t");
60 return Pid(::getpid());
66#if defined(HAVE_GETPAGESIZE)
67 static const int page_size = ::getpagesize();
68#elif defined(HAVE_SYSCONF)
69 static long page_size = ::sysconf(_SC_PAGE_SIZE);
71#error Cannot get the page size on this machine
76 return static_cast<unsigned>(page_size);
79size_t Process::GetMallocUsage() {
80#if defined(HAVE_MALLINFO2)
84#elif defined(HAVE_MALLINFO)
88#elif defined(HAVE_MALLOC_ZONE_STATISTICS) && defined(HAVE_MALLOC_MALLOC_H)
89 malloc_statistics_t
Stats;
90 malloc_zone_statistics(malloc_default_zone(), &
Stats);
91 return Stats.size_in_use;
92#elif defined(HAVE_MALLCTL)
95 if (mallctl(
"stats.allocated", &alloc, &sz, NULL, 0) == 0)
98#elif defined(HAVE_SBRK)
101 static char *StartOfMemory =
reinterpret_cast<char *
>(::sbrk(0));
102 char *EndOfMemory = (
char *)sbrk(0);
103 if (EndOfMemory != ((
char *)-1) && StartOfMemory != ((
char *)-1))
104 return EndOfMemory - StartOfMemory;
108#warning Cannot get malloc info on this platform
115 std::chrono::nanoseconds &user_time,
116 std::chrono::nanoseconds &sys_time) {
117 elapsed = std::chrono::system_clock::now();
118 std::tie(user_time, sys_time) = getRUsageTimes();
121#if defined(HAVE_MACH_MACH_H) && !defined(__GNU__)
122#include <mach/mach.h>
128void Process::PreventCoreFiles() {
130 getrlimit(RLIMIT_CORE, &rlim);
146 rlim.rlim_cur = std::min<rlim_t>(1, rlim.rlim_max);
150 setrlimit(RLIMIT_CORE, &rlim);
152#if defined(HAVE_MACH_MACH_H) && !defined(__GNU__)
156 mach_msg_type_number_t Count = 0;
157 exception_mask_t OriginalMasks[EXC_TYPES_COUNT];
158 exception_port_t OriginalPorts[EXC_TYPES_COUNT];
159 exception_behavior_t OriginalBehaviors[EXC_TYPES_COUNT];
160 thread_state_flavor_t OriginalFlavors[EXC_TYPES_COUNT];
161 kern_return_t err = task_get_exception_ports(
162 mach_task_self(), EXC_MASK_ALL, OriginalMasks, &Count, OriginalPorts,
163 OriginalBehaviors, OriginalFlavors);
164 if (err == KERN_SUCCESS) {
166 for (
unsigned i = 0; i != Count; ++i)
167 task_set_exception_ports(mach_task_self(), OriginalMasks[i],
168 MACH_PORT_NULL, OriginalBehaviors[i],
173 signal(SIGABRT, _exit);
174 signal(SIGILL, _exit);
175 signal(SIGFPE, _exit);
176 signal(SIGSEGV, _exit);
177 signal(SIGBUS, _exit);
184 std::string NameStr =
Name.str();
185 const char *Val = ::getenv(NameStr.c_str());
188 return std::string(Val);
194 FDCloser(
int &FD) : FD(FD), KeepOpen(
false) {}
195 void keepOpen() { KeepOpen =
true; }
197 if (!KeepOpen && FD >= 0)
202 FDCloser(
const FDCloser &) =
delete;
203 void operator=(
const FDCloser &) =
delete;
210std::error_code Process::FixupStandardFileDescriptors() {
212 FDCloser FDC(NullFD);
213 const int StandardFDs[] = {STDIN_FILENO, STDOUT_FILENO, STDERR_FILENO};
214 for (
int StandardFD : StandardFDs) {
218 assert(errno &&
"expected errno to be set if fstat failed!");
226 assert(errno == EBADF &&
"expected errno to have EBADF at this point!");
231 auto Open = [&]() { return ::open(
"/dev/null", O_RDWR); };
236 if (NullFD == StandardFD)
238 else if (dup2(NullFD, StandardFD) < 0)
241 return std::error_code();
244std::error_code Process::SafelyCloseFileDescriptor(
int FD) {
246 sigset_t FullSet, SavedSet;
247 if (sigfillset(&FullSet) < 0 || sigfillset(&SavedSet) < 0)
251#if LLVM_ENABLE_THREADS
252 if (
int EC = pthread_sigmask(SIG_SETMASK, &FullSet, &SavedSet))
253 return std::error_code(EC, std::generic_category());
255 if (sigprocmask(SIG_SETMASK, &FullSet, &SavedSet) < 0)
261 int ErrnoFromClose = 0;
263 ErrnoFromClose = errno;
266#if LLVM_ENABLE_THREADS
267 EC = pthread_sigmask(SIG_SETMASK, &SavedSet,
nullptr);
269 if (sigprocmask(SIG_SETMASK, &SavedSet,
nullptr) < 0)
275 return std::error_code(ErrnoFromClose, std::generic_category());
276 return std::error_code(EC, std::generic_category());
279bool Process::StandardInIsUserInput() {
280 return FileDescriptorIsDisplayed(STDIN_FILENO);
283bool Process::StandardOutIsDisplayed() {
284 return FileDescriptorIsDisplayed(STDOUT_FILENO);
287bool Process::StandardErrIsDisplayed() {
288 return FileDescriptorIsDisplayed(STDERR_FILENO);
291bool Process::FileDescriptorIsDisplayed(
int fd) {
300static unsigned getColumns() {
302 if (
const char *ColumnsStr = std::getenv(
"COLUMNS")) {
303 int Columns = std::atoi(ColumnsStr);
313unsigned Process::StandardOutColumns() {
314 if (!StandardOutIsDisplayed())
320unsigned Process::StandardErrColumns() {
321 if (!StandardErrIsDisplayed())
327static bool terminalHasColors() {
330 if (
const char *TermStr = std::getenv(
"TERM")) {
333 .
Case(
"cygwin",
true)
346bool Process::FileDescriptorHasColors(
int fd) {
349 return FileDescriptorIsDisplayed(fd) && terminalHasColors();
352bool Process::StandardOutHasColors() {
353 return FileDescriptorHasColors(STDOUT_FILENO);
356bool Process::StandardErrHasColors() {
357 return FileDescriptorHasColors(STDERR_FILENO);
360void Process::UseANSIEscapeCodes(
bool ) {
364bool Process::ColorNeedsFlush() {
369const char *Process::OutputColor(
char code,
bool bold,
bool bg) {
370 return colorcodes[bg ? 1 : 0][bold ? 1 : 0][code & 15];
373const char *Process::OutputBold(
bool bg) {
return "\033[1m"; }
375const char *Process::OutputReverse() {
return "\033[7m"; }
377const char *Process::ResetColor() {
return "\033[0m"; }
379#if !HAVE_DECL_ARC4RANDOM
380static unsigned GetRandomNumberSeed() {
382 int urandomFD = open(
"/dev/urandom", O_RDONLY);
384 if (urandomFD != -1) {
388 int count =
read(urandomFD, (
void *)&seed,
sizeof(seed));
393 if (count ==
sizeof(seed))
399 const auto Now = std::chrono::high_resolution_clock::now();
400 return hash_combine(Now.time_since_epoch().count(), ::getpid());
405#if HAVE_DECL_ARC4RANDOM
408 static int x = (
static_cast<void>(::srand(GetRandomNumberSeed())), 0);
414[[noreturn]]
void Process::ExitNoCleanup(
int RetCode) { _Exit(RetCode); }
block placement Basic Block Placement Stats
static bool coreFilesPrevented
static const char colorcodes[2][2][16][11]
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
Tagged union holding either a T or a Error.
StringRef - Represent a constant reference to a string, i.e.
A switch()-like statement whose cases are string literals.
StringSwitch & Case(StringLiteral S, T Value)
StringSwitch & StartsWith(StringLiteral S, T Value)
StringSwitch & EndsWith(StringLiteral S, T Value)
static unsigned GetRandomNumber()
Get the result of a process wide random number generator.
value_type read(const void *memory, endianness endian)
Read a value of a particular endianness from memory.
decltype(auto) RetryAfterSignal(const FailT &Fail, const Fun &F, const Args &... As)
std::chrono::nanoseconds toDuration(FILETIME Time)
std::chrono::time_point< std::chrono::system_clock, D > TimePoint
A time point on the system clock.
This is an optimization pass for GlobalISel generic memory operations.
auto count(R &&Range, const E &Element)
Wrapper function around std::count to count the number of times an element Element occurs in the give...
Error errorCodeToError(std::error_code EC)
Helper for converting an std::error_code to a Error.
hash_code hash_combine(const Ts &...args)
Combine values into a single hash_code.
std::error_code errnoAsErrorCode()
Helper to get errno as an std::error_code.