1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
|
//===-- InitLLVM.cpp -----------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include "llvm/Support/InitLLVM.h"
#include "llvm/ADT/StringRef.h"
#include "llvm/Support/AutoConvert.h"
#include "llvm/Support/Error.h"
#include "llvm/Support/ErrorHandling.h"
#include "llvm/Support/ManagedStatic.h"
#include "llvm/Support/Signals.h"
#ifdef _WIN32
#include "llvm/Support/Windows/WindowsSupport.h"
#endif
#if defined(HAVE_UNISTD_H)
#include <unistd.h>
#else
#ifndef STDIN_FILENO
#define STDIN_FILENO 0
#endif
#ifndef STDOUT_FILENO
#define STDOUT_FILENO 1
#endif
#ifndef STDERR_FILENO
#define STDERR_FILENO 2
#endif
#endif
static void RaiseLimits() {
#ifdef _AIX
// AIX has restrictive memory soft-limits out-of-box, so raise them if needed.
auto RaiseLimit = [](int resource) {
struct rlimit r;
getrlimit(resource, &r);
// Increase the soft limit to the hard limit, if necessary and
// possible.
if (r.rlim_cur != RLIM_INFINITY && r.rlim_cur != r.rlim_max) {
r.rlim_cur = r.rlim_max;
setrlimit(resource, &r);
}
};
// Address space size.
RaiseLimit(RLIMIT_AS);
// Heap size.
RaiseLimit(RLIMIT_DATA);
// Stack size.
RaiseLimit(RLIMIT_STACK);
#ifdef RLIMIT_RSS
// Resident set size.
RaiseLimit(RLIMIT_RSS);
#endif
#endif
}
void CleanupStdHandles(void *Cookie) {
llvm::raw_ostream *Outs = &llvm::outs(), *Errs = &llvm::errs();
Outs->flush();
Errs->flush();
llvm::restoreStdHandleAutoConversion(STDIN_FILENO);
llvm::restoreStdHandleAutoConversion(STDOUT_FILENO);
llvm::restoreStdHandleAutoConversion(STDERR_FILENO);
}
using namespace llvm;
using namespace llvm::sys;
InitLLVM::InitLLVM(int &Argc, const char **&Argv,
bool InstallPipeSignalExitHandler) {
#ifndef NDEBUG
static std::atomic<bool> Initialized{false};
assert(!Initialized && "InitLLVM was already initialized!");
Initialized = true;
#endif
// Bring stdin/stdout/stderr into a known state.
sys::AddSignalHandler(CleanupStdHandles, nullptr);
if (InstallPipeSignalExitHandler)
// The pipe signal handler must be installed before any other handlers are
// registered. This is because the Unix \ref RegisterHandlers function does
// not perform a sigaction() for SIGPIPE unless a one-shot handler is
// present, to allow long-lived processes (like lldb) to fully opt-out of
// llvm's SIGPIPE handling and ignore the signal safely.
sys::SetOneShotPipeSignalFunction(sys::DefaultOneShotPipeSignalHandler);
// Initialize the stack printer after installing the one-shot pipe signal
// handler, so we can perform a sigaction() for SIGPIPE on Unix if requested.
StackPrinter.emplace(Argc, Argv);
sys::PrintStackTraceOnErrorSignal(Argv[0]);
install_out_of_memory_new_handler();
RaiseLimits();
#ifdef __MVS__
// We use UTF-8 as the internal character encoding. On z/OS, all external
// output is encoded in EBCDIC. In order to be able to read all
// error messages, we turn conversion to EBCDIC on for stderr fd.
std::string Banner = std::string(Argv[0]) + ": ";
ExitOnError ExitOnErr(Banner);
// If turning on conversion for stderr fails then the error message
// may be garbled. There is no solution to this problem.
ExitOnErr(errorCodeToError(llvm::enableAutoConversion(STDERR_FILENO)));
ExitOnErr(errorCodeToError(llvm::enableAutoConversion(STDOUT_FILENO)));
#endif
#ifdef _WIN32
// We use UTF-8 as the internal character encoding. On Windows,
// arguments passed to main() may not be encoded in UTF-8. In order
// to reliably detect encoding of command line arguments, we use an
// Windows API to obtain arguments, convert them to UTF-8, and then
// write them back to the Argv vector.
//
// There's probably other way to do the same thing (e.g. using
// wmain() instead of main()), but this way seems less intrusive
// than that.
std::string Banner = std::string(Argv[0]) + ": ";
ExitOnError ExitOnErr(Banner);
ExitOnErr(errorCodeToError(windows::GetCommandLineArguments(Args, Alloc)));
// GetCommandLineArguments doesn't terminate the vector with a
// nullptr. Do it to make it compatible with the real argv.
Args.push_back(nullptr);
Argc = Args.size() - 1;
Argv = Args.data();
#endif
}
InitLLVM::~InitLLVM() {
CleanupStdHandles(nullptr);
llvm_shutdown();
}
|
