mirror of
https://github.com/llvm/llvm-project.git
synced 2025-04-27 15:26:06 +00:00
f80a27e3c6
layout for PIE binaries, ask the OS how much stack space is already in use to avoid stack overflow if we are run with more than 512K of combined command line arguments + environment variables. llvm-svn: 284271
230 lines
8.4 KiB
C++
230 lines
8.4 KiB
C++
//===-- cc1_main.cpp - Clang CC1 Compiler Frontend ------------------------===//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file is distributed under the University of Illinois Open Source
|
|
// License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// This is the entry point to the clang -cc1 functionality, which implements the
|
|
// core compiler functionality along with a number of additional tools for
|
|
// demonstration and testing purposes.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "llvm/Option/Arg.h"
|
|
#include "clang/CodeGen/ObjectFilePCHContainerOperations.h"
|
|
#include "clang/Config/config.h"
|
|
#include "clang/Driver/DriverDiagnostic.h"
|
|
#include "clang/Driver/Options.h"
|
|
#include "clang/Frontend/CompilerInstance.h"
|
|
#include "clang/Frontend/CompilerInvocation.h"
|
|
#include "clang/Frontend/FrontendDiagnostic.h"
|
|
#include "clang/Frontend/TextDiagnosticBuffer.h"
|
|
#include "clang/Frontend/TextDiagnosticPrinter.h"
|
|
#include "clang/Frontend/Utils.h"
|
|
#include "clang/FrontendTool/Utils.h"
|
|
#include "llvm/ADT/Statistic.h"
|
|
#include "llvm/LinkAllPasses.h"
|
|
#include "llvm/Option/ArgList.h"
|
|
#include "llvm/Option/OptTable.h"
|
|
#include "llvm/Support/Compiler.h"
|
|
#include "llvm/Support/ErrorHandling.h"
|
|
#include "llvm/Support/ManagedStatic.h"
|
|
#include "llvm/Support/Signals.h"
|
|
#include "llvm/Support/TargetSelect.h"
|
|
#include "llvm/Support/Timer.h"
|
|
#include "llvm/Support/raw_ostream.h"
|
|
#include <cstdio>
|
|
|
|
#ifdef CLANG_HAVE_RLIMITS
|
|
#include <sys/resource.h>
|
|
#endif
|
|
|
|
using namespace clang;
|
|
using namespace llvm::opt;
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// Main driver
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
static void LLVMErrorHandler(void *UserData, const std::string &Message,
|
|
bool GenCrashDiag) {
|
|
DiagnosticsEngine &Diags = *static_cast<DiagnosticsEngine*>(UserData);
|
|
|
|
Diags.Report(diag::err_fe_error_backend) << Message;
|
|
|
|
// Run the interrupt handlers to make sure any special cleanups get done, in
|
|
// particular that we remove files registered with RemoveFileOnSignal.
|
|
llvm::sys::RunInterruptHandlers();
|
|
|
|
// We cannot recover from llvm errors. When reporting a fatal error, exit
|
|
// with status 70 to generate crash diagnostics. For BSD systems this is
|
|
// defined as an internal software error. Otherwise, exit with status 1.
|
|
exit(GenCrashDiag ? 70 : 1);
|
|
}
|
|
|
|
#ifdef LINK_POLLY_INTO_TOOLS
|
|
namespace polly {
|
|
void initializePollyPasses(llvm::PassRegistry &Registry);
|
|
}
|
|
#endif
|
|
|
|
#ifdef CLANG_HAVE_RLIMITS
|
|
// The amount of stack we think is "sufficient". If less than this much is
|
|
// available, we may be unable to reach our template instantiation depth
|
|
// limit and other similar limits.
|
|
// FIXME: Unify this with the stack we request when spawning a thread to build
|
|
// a module.
|
|
static const int kSufficientStack = 8 << 20;
|
|
|
|
#if defined(__linux__) && defined(__PIE__)
|
|
static size_t getCurrentStackAllocation() {
|
|
// If we can't compute the current stack usage, allow for 512K of command
|
|
// line arguments and environment.
|
|
size_t Usage = 512 * 1024;
|
|
if (FILE *StatFile = fopen("/proc/self/stat", "r")) {
|
|
// We assume that the stack extends from its current address to the end of
|
|
// the environment space. In reality, there is another string literal (the
|
|
// program name) after the environment, but this is close enough (we only
|
|
// need to be within 100K or so).
|
|
unsigned long StackPtr, EnvEnd;
|
|
if (fscanf(StatFile,
|
|
"%*d %*s %*c %*d %*d %*d %*d %*d %*u %*lu %*lu %*lu %*lu %*lu "
|
|
"%*lu %*ld %*ld %*ld %*ld %*ld %*ld %*llu %*lu %*ld %*lu %*lu "
|
|
"%*lu %*lu %lu %*lu %*lu %*lu %*lu %*lu %*llu %*lu %*lu %*d %*d "
|
|
"%*u %*u %*llu %*lu %*ld %*lu %*lu %*lu %*lu %*lu %*lu %lu %*d",
|
|
&StackPtr, &EnvEnd) == 2) {
|
|
Usage = StackPtr < EnvEnd ? EnvEnd - StackPtr : StackPtr - EnvEnd;
|
|
}
|
|
fclose(StatFile);
|
|
}
|
|
return Usage;
|
|
}
|
|
|
|
#include <alloca.h>
|
|
|
|
LLVM_ATTRIBUTE_NOINLINE
|
|
static void ensureStackAddressSpace(int ExtraChunks = 0) {
|
|
// Linux kernels prior to 4.1 will sometimes locate the heap of a PIE binary
|
|
// relatively close to the stack (they are only guaranteed to be 128MiB
|
|
// apart). This results in crashes if we happen to heap-allocate more than
|
|
// 128MiB before we reach our stack high-water mark.
|
|
//
|
|
// To avoid these crashes, ensure that we have sufficient virtual memory
|
|
// pages allocated before we start running.
|
|
size_t Curr = getCurrentStackAllocation();
|
|
const int kTargetStack = kSufficientStack - 256 * 1024;
|
|
if (Curr < kTargetStack) {
|
|
volatile char *volatile Alloc =
|
|
static_cast<volatile char *>(alloca(kTargetStack - Curr));
|
|
Alloc[0] = 0;
|
|
Alloc[kTargetStack - Curr - 1] = 0;
|
|
}
|
|
}
|
|
#else
|
|
static void ensureStackAddressSpace() {}
|
|
#endif
|
|
|
|
/// Attempt to ensure that we have at least 8MiB of usable stack space.
|
|
static void ensureSufficientStack() {
|
|
struct rlimit rlim;
|
|
if (getrlimit(RLIMIT_STACK, &rlim) != 0)
|
|
return;
|
|
|
|
// Increase the soft stack limit to our desired level, if necessary and
|
|
// possible.
|
|
if (rlim.rlim_cur != RLIM_INFINITY && rlim.rlim_cur < kSufficientStack) {
|
|
// Try to allocate sufficient stack.
|
|
if (rlim.rlim_max == RLIM_INFINITY || rlim.rlim_max >= kSufficientStack)
|
|
rlim.rlim_cur = kSufficientStack;
|
|
else if (rlim.rlim_cur == rlim.rlim_max)
|
|
return;
|
|
else
|
|
rlim.rlim_cur = rlim.rlim_max;
|
|
|
|
if (setrlimit(RLIMIT_STACK, &rlim) != 0 ||
|
|
rlim.rlim_cur != kSufficientStack)
|
|
return;
|
|
}
|
|
|
|
// We should now have a stack of size at least kSufficientStack. Ensure
|
|
// that we can actually use that much, if necessary.
|
|
ensureStackAddressSpace();
|
|
}
|
|
#else
|
|
static void ensureSufficientStack() {}
|
|
#endif
|
|
|
|
int cc1_main(ArrayRef<const char *> Argv, const char *Argv0, void *MainAddr) {
|
|
ensureSufficientStack();
|
|
|
|
std::unique_ptr<CompilerInstance> Clang(new CompilerInstance());
|
|
IntrusiveRefCntPtr<DiagnosticIDs> DiagID(new DiagnosticIDs());
|
|
|
|
// Register the support for object-file-wrapped Clang modules.
|
|
auto PCHOps = Clang->getPCHContainerOperations();
|
|
PCHOps->registerWriter(llvm::make_unique<ObjectFilePCHContainerWriter>());
|
|
PCHOps->registerReader(llvm::make_unique<ObjectFilePCHContainerReader>());
|
|
|
|
// Initialize targets first, so that --version shows registered targets.
|
|
llvm::InitializeAllTargets();
|
|
llvm::InitializeAllTargetMCs();
|
|
llvm::InitializeAllAsmPrinters();
|
|
llvm::InitializeAllAsmParsers();
|
|
|
|
#ifdef LINK_POLLY_INTO_TOOLS
|
|
llvm::PassRegistry &Registry = *llvm::PassRegistry::getPassRegistry();
|
|
polly::initializePollyPasses(Registry);
|
|
#endif
|
|
|
|
// Buffer diagnostics from argument parsing so that we can output them using a
|
|
// well formed diagnostic object.
|
|
IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts = new DiagnosticOptions();
|
|
TextDiagnosticBuffer *DiagsBuffer = new TextDiagnosticBuffer;
|
|
DiagnosticsEngine Diags(DiagID, &*DiagOpts, DiagsBuffer);
|
|
bool Success = CompilerInvocation::CreateFromArgs(
|
|
Clang->getInvocation(), Argv.begin(), Argv.end(), Diags);
|
|
|
|
// Infer the builtin include path if unspecified.
|
|
if (Clang->getHeaderSearchOpts().UseBuiltinIncludes &&
|
|
Clang->getHeaderSearchOpts().ResourceDir.empty())
|
|
Clang->getHeaderSearchOpts().ResourceDir =
|
|
CompilerInvocation::GetResourcesPath(Argv0, MainAddr);
|
|
|
|
// Create the actual diagnostics engine.
|
|
Clang->createDiagnostics();
|
|
if (!Clang->hasDiagnostics())
|
|
return 1;
|
|
|
|
// Set an error handler, so that any LLVM backend diagnostics go through our
|
|
// error handler.
|
|
llvm::install_fatal_error_handler(LLVMErrorHandler,
|
|
static_cast<void*>(&Clang->getDiagnostics()));
|
|
|
|
DiagsBuffer->FlushDiagnostics(Clang->getDiagnostics());
|
|
if (!Success)
|
|
return 1;
|
|
|
|
// Execute the frontend actions.
|
|
Success = ExecuteCompilerInvocation(Clang.get());
|
|
|
|
// If any timers were active but haven't been destroyed yet, print their
|
|
// results now. This happens in -disable-free mode.
|
|
llvm::TimerGroup::printAll(llvm::errs());
|
|
|
|
// Our error handler depends on the Diagnostics object, which we're
|
|
// potentially about to delete. Uninstall the handler now so that any
|
|
// later errors use the default handling behavior instead.
|
|
llvm::remove_fatal_error_handler();
|
|
|
|
// When running with -disable-free, don't do any destruction or shutdown.
|
|
if (Clang->getFrontendOpts().DisableFree) {
|
|
BuryPointer(std::move(Clang));
|
|
return !Success;
|
|
}
|
|
|
|
return !Success;
|
|
}
|