52cf07116b
Make core BOLT functionality more friendly to being used as a library instead of in our standalone driver llvm-bolt. To accomplish this, we augment BinaryContext with journaling streams that are to be used by most BOLT code whenever something needs to be logged to the screen. Users of the library can decide if logs should be printed to a file, no file or to the screen, as before. To illustrate this, this patch adds a new option `--log-file` that allows the user to redirect BOLT logging to a file on disk or completely hide it by using `--log-file=/dev/null`. Future BOLT code should now use `BinaryContext::outs()` for printing important messages instead of `llvm::outs()`. A new test log.test enforces this by verifying that no strings are print to screen once the `--log-file` option is used. In previous patches we also added a new BOLTError class to report common and fatal errors, so code shouldn't call exit(1) now. To easily handle problems as before (by quitting with exit(1)), callers can now use `BinaryContext::logBOLTErrorsAndQuitOnFatal(Error)` whenever code needs to deal with BOLT errors. To test this, we have fatal.s that checks we are correctly quitting and printing a fatal error to the screen. Because this is a significant change by itself, not all code was yet ported. Code from Profiler libs (DataAggregator and friends) still print errors directly to screen. Co-authored-by: Rafael Auler <rafaelauler@fb.com> Test Plan: NFC
120 lines
3.9 KiB
C++
120 lines
3.9 KiB
C++
//===- bolt/Passes/ADRRelaxationPass.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
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// This file implements the ADRRelaxationPass class.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "bolt/Passes/ADRRelaxationPass.h"
|
|
#include "bolt/Core/ParallelUtilities.h"
|
|
#include "bolt/Utils/CommandLineOpts.h"
|
|
#include <iterator>
|
|
|
|
using namespace llvm;
|
|
|
|
namespace opts {
|
|
extern cl::OptionCategory BoltCategory;
|
|
|
|
static cl::opt<bool>
|
|
AdrPassOpt("adr-relaxation",
|
|
cl::desc("Replace ARM non-local ADR instructions with ADRP"),
|
|
cl::init(true), cl::cat(BoltCategory), cl::ReallyHidden);
|
|
} // namespace opts
|
|
|
|
namespace llvm {
|
|
namespace bolt {
|
|
|
|
// We don't exit directly from runOnFunction since it would call ThreadPool
|
|
// destructor which might result in internal assert if we're not finished
|
|
// creating async jobs on the moment of exit. So we're finishing all parallel
|
|
// jobs and checking the exit flag after it.
|
|
static bool PassFailed = false;
|
|
|
|
void ADRRelaxationPass::runOnFunction(BinaryFunction &BF) {
|
|
if (PassFailed)
|
|
return;
|
|
|
|
BinaryContext &BC = BF.getBinaryContext();
|
|
for (BinaryBasicBlock &BB : BF) {
|
|
for (auto It = BB.begin(); It != BB.end(); ++It) {
|
|
MCInst &Inst = *It;
|
|
if (!BC.MIB->isADR(Inst))
|
|
continue;
|
|
|
|
const MCSymbol *Symbol = BC.MIB->getTargetSymbol(Inst);
|
|
if (!Symbol)
|
|
continue;
|
|
|
|
if (BF.hasIslandsInfo()) {
|
|
BinaryFunction::IslandInfo &Islands = BF.getIslandInfo();
|
|
if (Islands.Symbols.count(Symbol) || Islands.ProxySymbols.count(Symbol))
|
|
continue;
|
|
}
|
|
|
|
// Don't relax adr if it points to the same function and it is not split
|
|
// and BF initial size is < 1MB.
|
|
const unsigned OneMB = 0x100000;
|
|
if (!BF.isSplit() && BF.getSize() < OneMB) {
|
|
BinaryFunction *TargetBF = BC.getFunctionForSymbol(Symbol);
|
|
if (TargetBF && TargetBF == &BF)
|
|
continue;
|
|
}
|
|
|
|
MCPhysReg Reg;
|
|
BC.MIB->getADRReg(Inst, Reg);
|
|
int64_t Addend = BC.MIB->getTargetAddend(Inst);
|
|
InstructionListType Addr;
|
|
|
|
{
|
|
auto L = BC.scopeLock();
|
|
Addr = BC.MIB->materializeAddress(Symbol, BC.Ctx.get(), Reg, Addend);
|
|
}
|
|
|
|
if (It != BB.begin() && BC.MIB->isNoop(*std::prev(It))) {
|
|
It = BB.eraseInstruction(std::prev(It));
|
|
} else if (std::next(It) != BB.end() && BC.MIB->isNoop(*std::next(It))) {
|
|
BB.eraseInstruction(std::next(It));
|
|
} else if (!opts::StrictMode && !BF.isSimple()) {
|
|
// If the function is not simple, it may contain a jump table undetected
|
|
// by us. This jump table may use an offset from the branch instruction
|
|
// to land in the desired place. If we add new instructions, we
|
|
// invalidate this offset, so we have to rely on linker-inserted NOP to
|
|
// replace it with ADRP, and abort if it is not present.
|
|
auto L = BC.scopeLock();
|
|
BC.errs() << formatv(
|
|
"BOLT-ERROR: Cannot relax adr in non-simple function "
|
|
"{0}. Use --strict option to override\n",
|
|
BF.getOneName());
|
|
PassFailed = true;
|
|
return;
|
|
}
|
|
It = BB.replaceInstruction(It, Addr);
|
|
}
|
|
}
|
|
}
|
|
|
|
Error ADRRelaxationPass::runOnFunctions(BinaryContext &BC) {
|
|
if (!opts::AdrPassOpt || !BC.HasRelocations)
|
|
return Error::success();
|
|
|
|
ParallelUtilities::WorkFuncTy WorkFun = [&](BinaryFunction &BF) {
|
|
runOnFunction(BF);
|
|
};
|
|
|
|
ParallelUtilities::runOnEachFunction(
|
|
BC, ParallelUtilities::SchedulingPolicy::SP_TRIVIAL, WorkFun, nullptr,
|
|
"ADRRelaxationPass");
|
|
|
|
if (PassFailed)
|
|
return createFatalBOLTError("");
|
|
return Error::success();
|
|
}
|
|
|
|
} // end namespace bolt
|
|
} // end namespace llvm
|