blob: 73b23f6e93fd051ffe27d76d81d6ddb2f16e7e5b [file] [log] [blame] [edit]
// Copyright 2016 The SwiftShader Authors. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
#ifndef rr_Nucleus_hpp
#define rr_Nucleus_hpp
#include <atomic>
#include <cassert>
#include <cstdarg>
#include <cstdint>
#include <functional>
#include <memory>
#include <string>
#include <vector>
#ifdef None
# undef None // TODO(b/127920555)
#endif
static_assert(sizeof(short) == 2, "Reactor's 'Short' type is 16-bit, and requires the C++ 'short' to match that.");
static_assert(sizeof(int) == 4, "Reactor's 'Int' type is 32-bit, and requires the C++ 'int' to match that.");
namespace rr {
class Type;
class Value;
class SwitchCases;
class BasicBlock;
class Routine;
// Optimization holds the optimization settings for code generation.
class Optimization
{
public:
enum class Level
{
None,
Less,
Default,
Aggressive,
};
enum class Pass
{
Disabled,
InstructionCombining,
CFGSimplification,
LICM,
AggressiveDCE,
GVN,
Reassociate,
DeadStoreElimination,
SCCP,
ScalarReplAggregates,
EarlyCSEPass,
Count,
};
using Passes = std::vector<Pass>;
Optimization(Level level = Level::Default, const Passes &passes = {})
: level(level)
, passes(passes)
{
#if defined(REACTOR_DEFAULT_OPT_LEVEL)
{
this->level = Level::REACTOR_DEFAULT_OPT_LEVEL;
}
#endif
}
Level getLevel() const { return level; }
const Passes &getPasses() const { return passes; }
private:
Level level = Level::Default;
Passes passes;
};
// Config holds the Reactor configuration settings.
class Config
{
public:
// Edit holds a number of modifications to a config, that can be applied
// on an existing Config to produce a new Config with the specified
// changes.
class Edit
{
public:
Edit &set(Optimization::Level level)
{
optLevel = level;
optLevelChanged = true;
return *this;
}
Edit &add(Optimization::Pass pass)
{
optPassEdits.push_back({ ListEdit::Add, pass });
return *this;
}
Edit &remove(Optimization::Pass pass)
{
optPassEdits.push_back({ ListEdit::Remove, pass });
return *this;
}
Edit &clearOptimizationPasses()
{
optPassEdits.push_back({ ListEdit::Clear, Optimization::Pass::Disabled });
return *this;
}
Config apply(const Config &cfg) const;
private:
enum class ListEdit
{
Add,
Remove,
Clear
};
using OptPassesEdit = std::pair<ListEdit, Optimization::Pass>;
template<typename T>
void apply(const std::vector<std::pair<ListEdit, T>> &edits, std::vector<T> &list) const;
Optimization::Level optLevel;
bool optLevelChanged = false;
std::vector<OptPassesEdit> optPassEdits;
};
Config() = default;
Config(const Optimization &optimization)
: optimization(optimization)
{}
const Optimization &getOptimization() const { return optimization; }
private:
Optimization optimization;
};
class Nucleus
{
public:
Nucleus();
virtual ~Nucleus();
// Default configuration to use when no other configuration is specified.
// The new configuration will be applied to subsequent reactor calls.
static void setDefaultConfig(const Config &cfg);
static void adjustDefaultConfig(const Config::Edit &cfgEdit);
static Config getDefaultConfig();
std::shared_ptr<Routine> acquireRoutine(const char *name, const Config::Edit *cfgEdit = nullptr);
static Value *allocateStackVariable(Type *type, int arraySize = 0);
static BasicBlock *createBasicBlock();
static BasicBlock *getInsertBlock();
static void setInsertBlock(BasicBlock *basicBlock);
static void createFunction(Type *returnType, const std::vector<Type *> &paramTypes);
static Value *getArgument(unsigned int index);
// Coroutines
using CoroutineHandle = void *;
template<typename... ARGS>
using CoroutineBegin = CoroutineHandle(ARGS...);
using CoroutineAwait = bool(CoroutineHandle, void *yieldValue);
using CoroutineDestroy = void(CoroutineHandle);
enum CoroutineEntries
{
CoroutineEntryBegin = 0,
CoroutineEntryAwait,
CoroutineEntryDestroy,
CoroutineEntryCount
};
// Begins the generation of the three coroutine functions: CoroutineBegin, CoroutineAwait, and CoroutineDestroy,
// which will be returned by Routine::getEntry() with arg CoroutineEntryBegin, CoroutineEntryAwait, and CoroutineEntryDestroy
// respectively. Called by Coroutine constructor.
// Params are used to generate the params to CoroutineBegin, while ReturnType is used as the YieldType for the coroutine,
// returned via CoroutineAwait..
static void createCoroutine(Type *returnType, const std::vector<Type *> &params);
// Generates code to store the passed in value, and to suspend execution of the coroutine, such that the next call to
// CoroutineAwait can set the output yieldValue and resume execution of the coroutine.
static void yield(Value *val);
// Called to finalize coroutine creation. After this call, Routine::getEntry can be called to retrieve the entry point to any
// of the three coroutine functions. Called by Coroutine::finalize.
std::shared_ptr<Routine> acquireCoroutine(const char *name, const Config::Edit *cfg = nullptr);
// Called by Coroutine::operator() to execute CoroutineEntryBegin wrapped up in func. This is needed in case
// the call must be run on a separate thread of execution (e.g. on a fiber).
static CoroutineHandle invokeCoroutineBegin(Routine &routine, std::function<CoroutineHandle()> func);
// Terminators
static void createRetVoid();
static void createRet(Value *V);
static void createBr(BasicBlock *dest);
static void createCondBr(Value *cond, BasicBlock *ifTrue, BasicBlock *ifFalse);
// Binary operators
static Value *createAdd(Value *lhs, Value *rhs);
static Value *createSub(Value *lhs, Value *rhs);
static Value *createMul(Value *lhs, Value *rhs);
static Value *createUDiv(Value *lhs, Value *rhs);
static Value *createSDiv(Value *lhs, Value *rhs);
static Value *createFAdd(Value *lhs, Value *rhs);
static Value *createFSub(Value *lhs, Value *rhs);
static Value *createFMul(Value *lhs, Value *rhs);
static Value *createFDiv(Value *lhs, Value *rhs);
static Value *createURem(Value *lhs, Value *rhs);
static Value *createSRem(Value *lhs, Value *rhs);
static Value *createFRem(Value *lhs, Value *rhs);
static Value *createShl(Value *lhs, Value *rhs);
static Value *createLShr(Value *lhs, Value *rhs);
static Value *createAShr(Value *lhs, Value *rhs);
static Value *createAnd(Value *lhs, Value *rhs);
static Value *createOr(Value *lhs, Value *rhs);
static Value *createXor(Value *lhs, Value *rhs);
// Unary operators
static Value *createNeg(Value *V);
static Value *createFNeg(Value *V);
static Value *createNot(Value *V);
// Memory instructions
static Value *createLoad(Value *ptr, Type *type, bool isVolatile = false, unsigned int alignment = 0, bool atomic = false, std::memory_order memoryOrder = std::memory_order_relaxed);
static Value *createStore(Value *value, Value *ptr, Type *type, bool isVolatile = false, unsigned int aligment = 0, bool atomic = false, std::memory_order memoryOrder = std::memory_order_relaxed);
static Value *createGEP(Value *ptr, Type *type, Value *index, bool unsignedIndex);
// Masked Load / Store instructions
static Value *createMaskedLoad(Value *base, Type *elementType, Value *mask, unsigned int alignment, bool zeroMaskedLanes);
static void createMaskedStore(Value *base, Value *value, Value *mask, unsigned int alignment);
// Barrier instructions
static void createFence(std::memory_order memoryOrder);
// Atomic instructions
static Value *createAtomicAdd(Value *ptr, Value *value, std::memory_order memoryOrder = std::memory_order_relaxed);
static Value *createAtomicSub(Value *ptr, Value *value, std::memory_order memoryOrder = std::memory_order_relaxed);
static Value *createAtomicAnd(Value *ptr, Value *value, std::memory_order memoryOrder = std::memory_order_relaxed);
static Value *createAtomicOr(Value *ptr, Value *value, std::memory_order memoryOrder = std::memory_order_relaxed);
static Value *createAtomicXor(Value *ptr, Value *value, std::memory_order memoryOrder = std::memory_order_relaxed);
static Value *createAtomicMin(Value *ptr, Value *value, std::memory_order memoryOrder = std::memory_order_relaxed);
static Value *createAtomicMax(Value *ptr, Value *value, std::memory_order memoryOrder = std::memory_order_relaxed);
static Value *createAtomicUMin(Value *ptr, Value *value, std::memory_order memoryOrder = std::memory_order_relaxed);
static Value *createAtomicUMax(Value *ptr, Value *value, std::memory_order memoryOrder = std::memory_order_relaxed);
static Value *createAtomicExchange(Value *ptr, Value *value, std::memory_order memoryOrder = std::memory_order_relaxed);
static Value *createAtomicCompareExchange(Value *ptr, Value *value, Value *compare, std::memory_order memoryOrderEqual, std::memory_order memoryOrderUnequal);
// Cast/Conversion Operators
static Value *createTrunc(Value *V, Type *destType);
static Value *createZExt(Value *V, Type *destType);
static Value *createSExt(Value *V, Type *destType);
static Value *createFPToUI(Value *V, Type *destType);
static Value *createFPToSI(Value *V, Type *destType);
static Value *createSIToFP(Value *V, Type *destType);
static Value *createFPTrunc(Value *V, Type *destType);
static Value *createFPExt(Value *V, Type *destType);
static Value *createBitCast(Value *V, Type *destType);
// Compare instructions
static Value *createICmpEQ(Value *lhs, Value *rhs);
static Value *createICmpNE(Value *lhs, Value *rhs);
static Value *createICmpUGT(Value *lhs, Value *rhs);
static Value *createICmpUGE(Value *lhs, Value *rhs);
static Value *createICmpULT(Value *lhs, Value *rhs);
static Value *createICmpULE(Value *lhs, Value *rhs);
static Value *createICmpSGT(Value *lhs, Value *rhs);
static Value *createICmpSGE(Value *lhs, Value *rhs);
static Value *createICmpSLT(Value *lhs, Value *rhs);
static Value *createICmpSLE(Value *lhs, Value *rhs);
static Value *createFCmpOEQ(Value *lhs, Value *rhs);
static Value *createFCmpOGT(Value *lhs, Value *rhs);
static Value *createFCmpOGE(Value *lhs, Value *rhs);
static Value *createFCmpOLT(Value *lhs, Value *rhs);
static Value *createFCmpOLE(Value *lhs, Value *rhs);
static Value *createFCmpONE(Value *lhs, Value *rhs);
static Value *createFCmpORD(Value *lhs, Value *rhs);
static Value *createFCmpUNO(Value *lhs, Value *rhs);
static Value *createFCmpUEQ(Value *lhs, Value *rhs);
static Value *createFCmpUGT(Value *lhs, Value *rhs);
static Value *createFCmpUGE(Value *lhs, Value *rhs);
static Value *createFCmpULT(Value *lhs, Value *rhs);
static Value *createFCmpULE(Value *lhs, Value *rhs);
static Value *createFCmpUNE(Value *lhs, Value *rhs);
// Vector instructions
static Value *createExtractElement(Value *vector, Type *type, int index);
static Value *createInsertElement(Value *vector, Value *element, int index);
static Value *createShuffleVector(Value *V1, Value *V2, const int *select);
// Other instructions
static Value *createSelect(Value *C, Value *ifTrue, Value *ifFalse);
static SwitchCases *createSwitch(Value *control, BasicBlock *defaultBranch, unsigned numCases);
static void addSwitchCase(SwitchCases *switchCases, int label, BasicBlock *branch);
static void createUnreachable();
// Constant values
static Value *createNullValue(Type *type);
static Value *createConstantLong(int64_t i);
static Value *createConstantInt(int i);
static Value *createConstantInt(unsigned int i);
static Value *createConstantBool(bool b);
static Value *createConstantByte(signed char i);
static Value *createConstantByte(unsigned char i);
static Value *createConstantShort(short i);
static Value *createConstantShort(unsigned short i);
static Value *createConstantFloat(float x);
static Value *createNullPointer(Type *type);
static Value *createConstantVector(const int64_t *constants, Type *type);
static Value *createConstantVector(const double *constants, Type *type);
static Value *createConstantString(const char *v);
static Value *createConstantString(const std::string &v) { return createConstantString(v.c_str()); }
static Type *getType(Value *value);
static Type *getContainedType(Type *vectorType);
static Type *getPointerType(Type *elementType);
static Type *getPrintfStorageType(Type *valueType);
// Diagnostic utilities
struct OptimizerReport
{
int allocas = 0;
int loads = 0;
int stores = 0;
};
using OptimizerCallback = void(const OptimizerReport *report);
// Sets the callback to be used by the next optimizer invocation (during acquireRoutine),
// for reporting stats about the resulting IR code. For testing only.
static void setOptimizerCallback(OptimizerCallback *callback);
};
} // namespace rr
#endif // rr_Nucleus_hpp