template <typename T = Assembler> T *getAssembler() const {
return llvm::dyn_cast<T>(TargetAssembler.get());
}
- Assembler *releaseAssembler() { return TargetAssembler.release(); }
+ std::unique_ptr<Assembler> releaseAssembler() {
+ return std::move(TargetAssembler);
+ }
bool hasComputedFrame() const;
bool getFocusedTiming() const { return FocusedTiming; }
void setFocusedTiming() { FocusedTiming = true; }
}
Func->translate();
- EmitterWorkItem *Item = nullptr;
+ std::unique_ptr<EmitterWorkItem> Item;
if (Func->hasError()) {
getErrorStatus()->assign(EC_Translation);
OstreamLocker L(this);
getStrError() << "ICE translation error: " << Func->getFunctionName()
<< ": " << Func->getError() << ": "
<< Func->getFunctionNameAndSize() << "\n";
- Item = new EmitterWorkItem(Func->getSequenceNumber());
+ Item = makeUnique<EmitterWorkItem>(Func->getSequenceNumber());
} else {
Func->getAssembler<>()->setInternal(Func->getInternal());
switch (getFlags().getOutFileType()) {
// stats have been fully collected into this thread's TLS.
// Dump them before TLS is reset for the next Cfg.
dumpStats(Func->getFunctionNameAndSize());
- Assembler *Asm = Func->releaseAssembler();
+ auto Asm = Func->releaseAssembler();
// Copy relevant fields into Asm before Func is deleted.
Asm->setFunctionName(Func->getFunctionName());
- Item = new EmitterWorkItem(Func->getSequenceNumber(), Asm);
+ Item = makeUnique<EmitterWorkItem>(Func->getSequenceNumber(),
+ std::move(Asm));
Item->setGlobalInits(Func->getGlobalInits());
} break;
case FT_Asm:
// to be dumped.
std::unique_ptr<VariableDeclarationList> GlobalInits =
Func->getGlobalInits();
- Item = new EmitterWorkItem(Func->getSequenceNumber(), Func.release());
+ Item = makeUnique<EmitterWorkItem>(Func->getSequenceNumber(),
+ std::move(Func));
Item->setGlobalInits(std::move(GlobalInits));
break;
}
}
- assert(Item);
- emitQueueBlockingPush(Item);
+ assert(Item != nullptr);
+ emitQueueBlockingPush(std::move(Item));
// The Cfg now gets deleted as Func goes out of scope.
}
}
namespace {
// Ensure Pending is large enough that Pending[Index] is valid.
-void resizePending(std::vector<EmitterWorkItem *> &Pending, uint32_t Index) {
- if (Index >= Pending.size())
- Utils::reserveAndResize(Pending, Index + 1);
+void resizePending(std::vector<std::unique_ptr<EmitterWorkItem>> *Pending,
+ uint32_t Index) {
+ if (Index >= Pending->size())
+ Utils::reserveAndResize(*Pending, Index + 1);
}
} // end of anonymous namespace
// the work queue, and if it's not the item we're waiting for, we
// insert it into Pending and repeat. The work item is deleted
// after it is processed.
- std::vector<EmitterWorkItem *> Pending;
+ std::vector<std::unique_ptr<EmitterWorkItem>> Pending;
uint32_t DesiredSequenceNumber = getFirstSequenceNumber();
uint32_t ShuffleStartIndex = DesiredSequenceNumber;
uint32_t ShuffleEndIndex = DesiredSequenceNumber;
RandomNumberGenerator RNG(getFlags().getRandomSeed(), RPE_FunctionReordering);
while (!EmitQueueEmpty) {
- resizePending(Pending, DesiredSequenceNumber);
+ resizePending(&Pending, DesiredSequenceNumber);
// See if Pending contains DesiredSequenceNumber.
- EmitterWorkItem *RawItem = Pending[DesiredSequenceNumber];
- if (RawItem == nullptr) {
+ if (Pending[DesiredSequenceNumber] == nullptr) {
// We need to fetch an EmitterWorkItem from the queue.
- RawItem = emitQueueBlockingPop();
+ auto RawItem = emitQueueBlockingPop();
if (RawItem == nullptr) {
// This is the notifier for an empty queue.
EmitQueueEmpty = true;
if (Threaded && ItemSeq != DesiredSequenceNumber) {
// Not the desired one, add it to Pending but do not increase
// DesiredSequenceNumber. Continue the loop, do not emit the item.
- resizePending(Pending, ItemSeq);
- Pending[ItemSeq] = RawItem;
+ resizePending(&Pending, ItemSeq);
+ Pending[ItemSeq] = std::move(RawItem);
continue;
}
// ItemSeq == DesiredSequenceNumber, we need to check if we should
// emit it or not. If !Threaded, we're OK with ItemSeq !=
// DesiredSequenceNumber.
- Pending[DesiredSequenceNumber] = RawItem;
+ Pending[DesiredSequenceNumber] = std::move(RawItem);
}
}
+ const auto *CurrentWorkItem = Pending[DesiredSequenceNumber].get();
+
// We have the desired EmitterWorkItem or nullptr as the end notifier.
// If the emitter queue is not empty, increase DesiredSequenceNumber and
// ShuffleEndIndex.
// holding an arbitrarily large GlobalDeclarationList.
if (!EmitQueueEmpty &&
ShuffleEndIndex - ShuffleStartIndex < ShuffleWindowSize &&
- RawItem->getKind() != EmitterWorkItem::WI_GlobalInits)
+ CurrentWorkItem->getKind() != EmitterWorkItem::WI_GlobalInits)
continue;
// Emit the EmitterWorkItem between Pending[ShuffleStartIndex] to
// Emit the item from ShuffleStartIndex to ShuffleEndIndex.
for (uint32_t I = ShuffleStartIndex; I < ShuffleEndIndex; I++) {
- std::unique_ptr<EmitterWorkItem> Item(Pending[I]);
+ std::unique_ptr<EmitterWorkItem> Item = std::move(Pending[I]);
switch (Item->getKind()) {
case EmitterWorkItem::WI_Nop:
assert(Func);
{
TimerMarker _(TimerStack::TT_qTransPush, this);
- OptQ.blockingPush(Func.release());
+ OptQ.blockingPush(std::move(Func));
}
if (getFlags().isSequential())
translateFunctions();
return std::unique_ptr<Cfg>(OptQ.blockingPop());
}
-void GlobalContext::emitQueueBlockingPush(EmitterWorkItem *Item) {
+void GlobalContext::emitQueueBlockingPush(
+ std::unique_ptr<EmitterWorkItem> Item) {
assert(Item);
{
TimerMarker _(TimerStack::TT_qEmitPush, this);
- EmitQ.blockingPush(Item);
+ EmitQ.blockingPush(std::move(Item));
}
if (getFlags().isSequential())
emitItems();
}
-EmitterWorkItem *GlobalContext::emitQueueBlockingPop() {
+std::unique_ptr<EmitterWorkItem> GlobalContext::emitQueueBlockingPop() {
TimerMarker _(TimerStack::TT_qEmitPop, this);
return EmitQ.blockingPop();
}
#include <array>
#include <functional>
+#include <memory>
#include <mutex>
#include <thread>
#include <type_traits>
+#include <utility>
#include <vector>
namespace Ice {
void lowerJumpTables();
- void emitQueueBlockingPush(EmitterWorkItem *Item);
- EmitterWorkItem *emitQueueBlockingPop();
+ void emitQueueBlockingPush(std::unique_ptr<EmitterWorkItem> Item);
+ std::unique_ptr<EmitterWorkItem> emitQueueBlockingPop();
void emitQueueNotifyEnd() { EmitQ.notifyEnd(); }
void initParserThread() {
EmitterWorkItem::EmitterWorkItem(uint32_t Seq)
: Sequence(Seq), Kind(WI_Nop), GlobalInits(nullptr), Function(nullptr),
RawFunc(nullptr) {}
-EmitterWorkItem::EmitterWorkItem(uint32_t Seq, VariableDeclarationList *D)
- : Sequence(Seq), Kind(WI_GlobalInits), GlobalInits(D), Function(nullptr),
+EmitterWorkItem::EmitterWorkItem(uint32_t Seq,
+ std::unique_ptr<VariableDeclarationList> D)
+ : Sequence(Seq), Kind(WI_GlobalInits), GlobalInits(std::move(D)),
+ Function(nullptr), RawFunc(nullptr) {}
+EmitterWorkItem::EmitterWorkItem(uint32_t Seq, std::unique_ptr<Assembler> A)
+ : Sequence(Seq), Kind(WI_Asm), GlobalInits(nullptr), Function(std::move(A)),
RawFunc(nullptr) {}
-EmitterWorkItem::EmitterWorkItem(uint32_t Seq, Assembler *A)
- : Sequence(Seq), Kind(WI_Asm), GlobalInits(nullptr), Function(A),
- RawFunc(nullptr) {}
-EmitterWorkItem::EmitterWorkItem(uint32_t Seq, Cfg *F)
+EmitterWorkItem::EmitterWorkItem(uint32_t Seq, std::unique_ptr<Cfg> F)
: Sequence(Seq), Kind(WI_Cfg), GlobalInits(nullptr), Function(nullptr),
- RawFunc(F) {}
+ RawFunc(std::move(F)) {}
void EmitterWorkItem::setGlobalInits(
std::unique_ptr<VariableDeclarationList> GloblInits) {
#include "IceDefs.h"
#include <condition_variable>
+#include <memory>
#include <mutex>
+#include <utility>
namespace Ice {
public:
BoundedProducerConsumerQueue(bool Sequential, size_t MaxSize = MaxStaticSize)
: MaxSize(std::min(MaxSize, MaxStaticSize)), Sequential(Sequential) {}
- void blockingPush(T *Item) {
+ void blockingPush(std::unique_ptr<T> Item) {
{
std::unique_lock<GlobalLockType> L(Lock);
// If the work queue is already "full", wait for a consumer to grab an
// element and shrink the queue.
Shrunk.wait(L, [this] { return size() < MaxSize || Sequential; });
- push(Item);
+ push(std::move(Item));
}
GrewOrEnded.notify_one();
}
- T *blockingPop() {
- T *Item = nullptr;
+ std::unique_ptr<T> blockingPop() {
+ std::unique_ptr<T> Item;
bool ShouldNotifyProducer = false;
{
std::unique_lock<GlobalLockType> L(Lock);
ICE_CACHELINE_BOUNDARY;
/// WorkItems and Lock are read/written by all.
- T *WorkItems[MaxStaticSize];
+ std::unique_ptr<T> WorkItems[MaxStaticSize];
ICE_CACHELINE_BOUNDARY;
/// Lock guards access to WorkItems, Front, Back, and IsEnded.
GlobalLockType Lock;
/// The lock must be held when the following methods are called.
bool empty() const { return Front == Back; }
size_t size() const { return Back - Front; }
- void push(T *Item) {
- WorkItems[Back++ & MaxStaticSizeMask] = Item;
+ void push(std::unique_ptr<T> Item) {
+ WorkItems[Back++ & MaxStaticSizeMask] = std::move(Item);
assert(size() <= MaxStaticSize);
}
- T *pop() {
+ std::unique_ptr<T> pop() {
assert(!empty());
- return WorkItems[Front++ & MaxStaticSizeMask];
+ return std::move(WorkItems[Front++ & MaxStaticSizeMask]);
}
};
/// Constructor for a WI_Nop work item.
explicit EmitterWorkItem(uint32_t Seq);
/// Constructor for a WI_GlobalInits work item.
- EmitterWorkItem(uint32_t Seq, VariableDeclarationList *D);
+ EmitterWorkItem(uint32_t Seq, std::unique_ptr<VariableDeclarationList> D);
/// Constructor for a WI_Asm work item.
- EmitterWorkItem(uint32_t Seq, Assembler *A);
+ EmitterWorkItem(uint32_t Seq, std::unique_ptr<Assembler> A);
/// Constructor for a WI_Cfg work item.
- EmitterWorkItem(uint32_t Seq, Cfg *F);
+ EmitterWorkItem(uint32_t Seq, std::unique_ptr<Cfg> F);
uint32_t getSequenceNumber() const { return Sequence; }
ItemKind getKind() const { return Kind; }
void setGlobalInits(std::unique_ptr<VariableDeclarationList> GloblInits);
#include "IceTranslator.h"
+#include "IceDefs.h"
#include "IceCfg.h"
#include "IceClFlags.h"
-#include "IceDefs.h"
#include "IceGlobalInits.h"
#include "IceTargetLowering.h"
-using namespace Ice;
+#include <utility>
+
+namespace Ice {
Translator::Translator(GlobalContext *Ctx)
: Ctx(Ctx), NextSequenceNumber(GlobalContext::getFirstSequenceNumber()),
void Translator::lowerGlobals(
std::unique_ptr<VariableDeclarationList> VariableDeclarations) {
- EmitterWorkItem *Item = new EmitterWorkItem(getNextSequenceNumber(),
- VariableDeclarations.release());
- Ctx->emitQueueBlockingPush(Item);
+ Ctx->emitQueueBlockingPush(makeUnique<EmitterWorkItem>(
+ getNextSequenceNumber(), std::move(VariableDeclarations)));
}
+
+} // end of namespace Ice
#include "IceDefs.h"
#include "IceGlobalContext.h"
+#include <memory>
+
namespace llvm {
class Module;
} // end of namespace llvm
const ClFlags &getFlags() const { return Ctx->getFlags(); }
- /// Translates the constructed ICE function Fcn to machine code. Takes
- /// ownership of Func.
+ /// Translates the constructed ICE function Func to machine code.
void translateFcn(std::unique_ptr<Cfg> Func);
/// Lowers the given list of global addresses to target. Generates list of
OSDN Git Service
