RPCS3/llvm-mirror
1
0
Fork 0
mirror of https://github.com/RPCS3/llvm-mirror.git synced 2024-11-22 10:42:39 +01:00
Code Issues Projects Releases Wiki Activity
a9dc6631f3
llvm-mirror/lib/MC/MCCodePadder.cpp
Omer Paparo Bivas 3f4c58083e [MC] Adding code padding for performance stability - infrastructure. NFC. 
Infrastructure designed for padding code with nop instructions in key places such that preformance improvement will be achieved.
The infrastructure is implemented such that the padding is done in the Assembler after the layout is done and all IPs and alignments are known.
This patch by itself in a NFC. Future patches will make use of this infrastructure to implement required policies for code padding.

Reviewers:
aaboud
zvi
craig.topper
gadi.haber

Differential revision: https://reviews.llvm.org/D34393

Change-Id: I92110d0c0a757080a8405636914a93ef6f8ad00e
llvm-svn: 316413
2017-10-24 06:16:03 +00:00

372 lines
15 KiB
C++
Raw Blame History

//===- MCCodePadder.cpp - Target MC Code Padder ---------------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#include "llvm/MC/MCAsmLayout.h"
#include "llvm/MC/MCCodePadder.h"
#include "llvm/MC/MCObjectStreamer.h"
#include <algorithm>
#include <limits>
#include <numeric>
using namespace llvm;
//---------------------------------------------------------------------------
// MCCodePadder
//
MCCodePadder::~MCCodePadder() {
for (auto *Policy : CodePaddingPolicies)
delete Policy;
}
bool MCCodePadder::addPolicy(MCCodePaddingPolicy *Policy) {
assert(Policy && "Policy must be valid");
return CodePaddingPolicies.insert(Policy).second;
}
void MCCodePadder::handleBasicBlockStart(MCObjectStreamer *OS,
const MCCodePaddingContext &Context) {
assert(OS != nullptr && "OS must be valid");
assert(this->OS == nullptr && "Still handling another basic block");
this->OS = OS;
ArePoliciesActive = usePoliciesForBasicBlock(Context);
bool InsertionPoint = basicBlockRequiresInsertionPoint(Context);
assert((!InsertionPoint ||
OS->getCurrentFragment()->getKind() != MCFragment::FT_Align) &&
"Cannot insert padding nops right after an alignment fragment as it "
"will ruin the alignment");
uint64_t PoliciesMask = MCPaddingFragment::PFK_None;
if (ArePoliciesActive) {
PoliciesMask = std::accumulate(
CodePaddingPolicies.begin(), CodePaddingPolicies.end(),
MCPaddingFragment::PFK_None,
[&Context](uint64_t Mask,
const MCCodePaddingPolicy *Policy) -> uint64_t {
return Policy->basicBlockRequiresPaddingFragment(Context)
? (Mask | Policy->getKindMask())
: Mask;
});
}
if (InsertionPoint || PoliciesMask != MCPaddingFragment::PFK_None) {
MCPaddingFragment *PaddingFragment = OS->getOrCreatePaddingFragment();
if (InsertionPoint)
PaddingFragment->setAsInsertionPoint();
PaddingFragment->setPaddingPoliciesMask(
PaddingFragment->getPaddingPoliciesMask() | PoliciesMask);
}
}
void MCCodePadder::handleBasicBlockEnd(const MCCodePaddingContext &Context) {
assert(this->OS != nullptr && "Not handling a basic block");
OS = nullptr;
}
void MCCodePadder::handleInstructionBegin(const MCInst &Inst) {
if (!OS)
return; // instruction was emitted outside a function
assert(CurrHandledInstFragment == nullptr && "Can't start handling an "
"instruction while still "
"handling another instruction");
bool InsertionPoint = instructionRequiresInsertionPoint(Inst);
assert((!InsertionPoint ||
OS->getCurrentFragment()->getKind() != MCFragment::FT_Align) &&
"Cannot insert padding nops right after an alignment fragment as it "
"will ruin the alignment");
uint64_t PoliciesMask = MCPaddingFragment::PFK_None;
if (ArePoliciesActive) {
PoliciesMask = std::accumulate(
CodePaddingPolicies.begin(), CodePaddingPolicies.end(),
MCPaddingFragment::PFK_None,
[&Inst](uint64_t Mask, const MCCodePaddingPolicy *Policy) -> uint64_t {
return Policy->instructionRequiresPaddingFragment(Inst)
? (Mask | Policy->getKindMask())
: Mask;
});
}
MCFragment *CurrFragment = OS->getCurrentFragment();
// CurrFragment can be a previously created MCPaddingFragment. If so, let's
// update it with the information we have, such as the instruction that it
// should point to.
bool needToUpdateCurrFragment =
CurrFragment != nullptr &&
CurrFragment->getKind() == MCFragment::FT_Padding;
if (InsertionPoint || PoliciesMask != MCPaddingFragment::PFK_None ||
needToUpdateCurrFragment) {
// temporarily holding the fragment as CurrHandledInstFragment, to be
// updated after the instruction will be written
CurrHandledInstFragment = OS->getOrCreatePaddingFragment();
if (InsertionPoint)
CurrHandledInstFragment->setAsInsertionPoint();
CurrHandledInstFragment->setPaddingPoliciesMask(
CurrHandledInstFragment->getPaddingPoliciesMask() | PoliciesMask);
}
}
void MCCodePadder::handleInstructionEnd(const MCInst &Inst) {
if (!OS)
return; // instruction was emitted outside a function
if (CurrHandledInstFragment == nullptr)
return;
MCFragment *InstFragment = OS->getCurrentFragment();
if (MCDataFragment *InstDataFragment =
dyn_cast_or_null<MCDataFragment>(InstFragment))
// Inst is a fixed size instruction and was encoded into a MCDataFragment.
// Let the fragment hold it and its size. Its size is the current size of
// the data fragment, as the padding fragment was inserted right before it
// and nothing was written yet except Inst
CurrHandledInstFragment->setInstAndInstSize(
Inst, InstDataFragment->getContents().size());
else if (MCRelaxableFragment *InstRelaxableFragment =
dyn_cast_or_null<MCRelaxableFragment>(InstFragment))
// Inst may be relaxed and its size may vary.
// Let the fragment hold the instruction and the MCRelaxableFragment
// that's holding it.
CurrHandledInstFragment->setInstAndInstFragment(Inst,
InstRelaxableFragment);
else
llvm_unreachable("After encoding an instruction current fragment must be "
"either a MCDataFragment or a MCRelaxableFragment");
CurrHandledInstFragment = nullptr;
}
MCPFRange &MCCodePadder::getJurisdiction(MCPaddingFragment *Fragment,
MCAsmLayout &Layout) {
auto JurisdictionLocation = FragmentToJurisdiction.find(Fragment);
if (JurisdictionLocation != FragmentToJurisdiction.end())
return JurisdictionLocation->second;
MCPFRange Jurisdiction;
// Forward scanning the fragments in this section, starting from the given
// fragments, and adding relevant MCPaddingFragments to the Jurisdiction
for (MCFragment *CurrFragment = Fragment; CurrFragment != nullptr;
CurrFragment = CurrFragment->getNextNode()) {
MCPaddingFragment *CurrPaddingFragment =
dyn_cast<MCPaddingFragment>(CurrFragment);
if (CurrPaddingFragment == nullptr)
continue;
if (CurrPaddingFragment != Fragment &&
CurrPaddingFragment->isInsertionPoint())
// Found next insertion point Fragment. From now on it's its jurisdiction.
break;
for (const auto *Policy : CodePaddingPolicies) {
if (CurrPaddingFragment->hasPaddingPolicy(Policy->getKindMask())) {
Jurisdiction.push_back(CurrPaddingFragment);
break;
}
}
}
auto InsertionResult =
FragmentToJurisdiction.insert(std::make_pair(Fragment, Jurisdiction));
assert(InsertionResult.second &&
"Insertion to FragmentToJurisdiction failed");
return InsertionResult.first->second;
}
uint64_t MCCodePadder::getMaxWindowSize(MCPaddingFragment *Fragment,
MCAsmLayout &Layout) {
auto MaxFragmentSizeLocation = FragmentToMaxWindowSize.find(Fragment);
if (MaxFragmentSizeLocation != FragmentToMaxWindowSize.end())
return MaxFragmentSizeLocation->second;
MCPFRange &Jurisdiction = getJurisdiction(Fragment, Layout);
uint64_t JurisdictionMask = MCPaddingFragment::PFK_None;
for (const auto *Protege : Jurisdiction)
JurisdictionMask |= Protege->getPaddingPoliciesMask();
uint64_t MaxFragmentSize = UINT64_C(0);
for (const auto *Policy : CodePaddingPolicies)
if ((JurisdictionMask & Policy->getKindMask()) !=
MCPaddingFragment::PFK_None)
MaxFragmentSize = std::max(MaxFragmentSize, Policy->getWindowSize());
auto InsertionResult =
FragmentToMaxWindowSize.insert(std::make_pair(Fragment, MaxFragmentSize));
assert(InsertionResult.second &&
"Insertion to FragmentToMaxWindowSize failed");
return InsertionResult.first->second;
}
bool MCCodePadder::relaxFragment(MCPaddingFragment *Fragment,
MCAsmLayout &Layout) {
if (!Fragment->isInsertionPoint())
return false;
uint64_t OldSize = Fragment->getSize();
uint64_t MaxWindowSize = getMaxWindowSize(Fragment, Layout);
if (MaxWindowSize == UINT64_C(0))
return false;
assert(isPowerOf2_64(MaxWindowSize) &&
"MaxWindowSize must be an integer power of 2");
uint64_t SectionAlignment = Fragment->getParent()->getAlignment();
assert(isPowerOf2_64(SectionAlignment) &&
"SectionAlignment must be an integer power of 2");
MCPFRange &Jurisdiction = getJurisdiction(Fragment, Layout);
uint64_t OptimalSize = UINT64_C(0);
double OptimalWeight = std::numeric_limits<double>::max();
uint64_t MaxFragmentSize = MaxWindowSize - UINT16_C(1);
for (uint64_t Size = UINT64_C(0); Size <= MaxFragmentSize; ++Size) {
Fragment->setSize(Size);
Layout.invalidateFragmentsFrom(Fragment);
double SizeWeight = 0.0;
// The section is guaranteed to be aligned to SectionAlignment, but that
// doesn't guarantee the exact section offset w.r.t. the policies window
// size.
// As a concrete example, the section could be aligned to 16B, but a
// policy's window size can be 32B. That means that the section actual start
// address can either be 0mod32 or 16mod32. The said policy will act
// differently for each case, so we need to take both into consideration.
for (uint64_t Offset = UINT64_C(0); Offset < MaxWindowSize;
Offset += SectionAlignment) {
double OffsetWeight = std::accumulate(
CodePaddingPolicies.begin(), CodePaddingPolicies.end(), 0.0,
[&Jurisdiction, &Offset, &Layout](
double Weight, const MCCodePaddingPolicy *Policy) -> double {
double PolicyWeight =
Policy->computeRangePenaltyWeight(Jurisdiction, Offset, Layout);
assert(PolicyWeight >= 0.0 && "A penalty weight must be positive");
return Weight + PolicyWeight;
});
SizeWeight = std::max(SizeWeight, OffsetWeight);
}
if (SizeWeight < OptimalWeight) {
OptimalWeight = SizeWeight;
OptimalSize = Size;
}
if (OptimalWeight == 0.0)
break;
}
Fragment->setSize(OptimalSize);
Layout.invalidateFragmentsFrom(Fragment);
return OldSize != OptimalSize;
}
//---------------------------------------------------------------------------
// MCCodePaddingPolicy
//
uint64_t MCCodePaddingPolicy::getNextFragmentOffset(const MCFragment *Fragment,
const MCAsmLayout &Layout) {
assert(Fragment != nullptr && "Fragment cannot be null");
MCFragment const *NextFragment = Fragment->getNextNode();
return NextFragment == nullptr
? Layout.getSectionAddressSize(Fragment->getParent())
: Layout.getFragmentOffset(NextFragment);
}
uint64_t
MCCodePaddingPolicy::getFragmentInstByte(const MCPaddingFragment *Fragment,
MCAsmLayout &Layout) const {
uint64_t InstByte = getNextFragmentOffset(Fragment, Layout);
if (InstByteIsLastByte)
InstByte += Fragment->getInstSize() - UINT64_C(1);
return InstByte;
}
uint64_t
MCCodePaddingPolicy::computeWindowEndAddress(const MCPaddingFragment *Fragment,
uint64_t Offset,
MCAsmLayout &Layout) const {
uint64_t InstByte = getFragmentInstByte(Fragment, Layout);
return alignTo(InstByte + UINT64_C(1) + Offset, WindowSize) - Offset;
}
double MCCodePaddingPolicy::computeRangePenaltyWeight(
const MCPFRange &Range, uint64_t Offset, MCAsmLayout &Layout) const {
SmallVector<MCPFRange, 8> Windows;
SmallVector<MCPFRange, 8>::iterator CurrWindowLocation = Windows.end();
for (const MCPaddingFragment *Fragment : Range) {
if (!Fragment->hasPaddingPolicy(getKindMask()))
continue;
uint64_t FragmentWindowEndAddress =
computeWindowEndAddress(Fragment, Offset, Layout);
if (CurrWindowLocation == Windows.end() ||
FragmentWindowEndAddress !=
computeWindowEndAddress(*CurrWindowLocation->begin(), Offset,
Layout)) {
// next window is starting
Windows.push_back(MCPFRange());
CurrWindowLocation = Windows.end() - 1;
}
CurrWindowLocation->push_back(Fragment);
}
if (Windows.empty())
return 0.0;
double RangeWeight = 0.0;
SmallVector<MCPFRange, 8>::iterator I = Windows.begin();
RangeWeight += computeFirstWindowPenaltyWeight(*I, Offset, Layout);
++I;
RangeWeight += std::accumulate(
I, Windows.end(), 0.0,
[this, &Layout, &Offset](double Weight, MCPFRange &Window) -> double {
return Weight += computeWindowPenaltyWeight(Window, Offset, Layout);
});
return RangeWeight;
}
double MCCodePaddingPolicy::computeFirstWindowPenaltyWeight(
const MCPFRange &Window, uint64_t Offset, MCAsmLayout &Layout) const {
if (Window.empty())
return 0.0;
uint64_t WindowEndAddress =
computeWindowEndAddress(*Window.begin(), Offset, Layout);
MCPFRange FullWindowFirstPart; // will hold all the fragments that are in the
// same window as the fragments in the given
// window but their penalty weight should not
// be added
for (const MCFragment *Fragment = (*Window.begin())->getPrevNode();
Fragment != nullptr; Fragment = Fragment->getPrevNode()) {
const MCPaddingFragment *PaddingNopFragment =
dyn_cast<MCPaddingFragment>(Fragment);
if (PaddingNopFragment == nullptr ||
!PaddingNopFragment->hasPaddingPolicy(getKindMask()))
continue;
if (WindowEndAddress !=
computeWindowEndAddress(PaddingNopFragment, Offset, Layout))
break;
FullWindowFirstPart.push_back(PaddingNopFragment);
}
std::reverse(FullWindowFirstPart.begin(), FullWindowFirstPart.end());
double FullWindowFirstPartWeight =
computeWindowPenaltyWeight(FullWindowFirstPart, Offset, Layout);
MCPFRange FullWindow(
FullWindowFirstPart); // will hold all the fragments that are in the
// same window as the fragments in the given
// window, whether their weight should be added
// or not
FullWindow.append(Window.begin(), Window.end());
double FullWindowWeight =
computeWindowPenaltyWeight(FullWindow, Offset, Layout);
assert(FullWindowWeight >= FullWindowFirstPartWeight &&
"More fragments necessarily means bigger weight");
return FullWindowWeight - FullWindowFirstPartWeight;
}
Reference in New Issue View Git Blame Copy Permalink