tseeker-pub/demotool
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
demotool/c-opopt.cc

1783 lines
45 KiB
C++
Raw Blame History

#include "externals.hh"
#include "c-opopt.hh"
#include "c-ops.hh"
#include "c-sync.hh"
using namespace ebcl;
using namespace opast;
using namespace opopt;
/*= T_OptData ================================================================*/
#define M_LOGSTR_( S , L ) \
logger( [](){ return T_StringBuilder{ S }; } , L )
uint32_t opopt::ComputeHash(
T_OptData::T_VarId const& id ) noexcept
{
const uint32_t nh{ ComputeHash( id.name ) };
const uint32_t oh{ id.type != T_OptData::E_UDVarType::GLOBAL
? ComputeHash( id.name )
: 0
};
return ( uint32_t( id.type ) << 8 )
^ nh
^ ( ( oh << 29 ) | ( oh >> 3 ) );
}
T_StringBuilder& opopt::operator<<(
T_StringBuilder& obj ,
T_OptData::T_CtrlFlowEdge const& value ) noexcept
{
obj << value.target;
switch ( value.type ) {
case T_OptData::T_CtrlFlowEdge::CALL:
obj << "{c}";
break;
case T_OptData::T_CtrlFlowEdge::RET:
obj << "{r}";
break;
case T_OptData::T_CtrlFlowEdge::BYPASS:
obj << "{b}";
break;
case T_OptData::T_CtrlFlowEdge::FLOW:
break;
}
return obj;
}
constexpr uint32_t T_OptData::CFG_ENTER;
constexpr uint32_t T_OptData::CFG_MAINLOOP;
constexpr uint32_t T_OptData::CFG_END;
/*= T_OptData - INPUT DECLARATIONS ===========================================*/
void T_OptData::findInputDecls(
T_OpsParserOutput& program ) noexcept
{
if ( state & E_StateItem::INPUTS ) {
return;
}
inputDecls.clear( );
visitor.visit( program.root , [this]( A_Node& node , const bool exit ) {
if ( exit && node.type( ) == A_Node::OP_INPUT ) {
auto& input{ (T_InputInstrNode&) node };
auto* da{ inputDecls->get( input.id( ) ) };
if ( !da ) {
inputDecls->add( input.id( ) , T_Array< T_InputDecl >{ } );
da = inputDecls->get( input.id( ) );
}
da->add( T_InputDecl{ input.location( ) , input.defValue( ) } );
}
return true;
} );
state = state | E_StateItem::INPUTS;
}
/*= T_OptData - INSTRUCTION NUMBERING ========================================*/
namespace {
bool ODNIVisitor_(
A_Node& node ,
const bool exit ,
T_OptData& oData ,
const uint32_t fnIndex ) noexcept
{
if ( dynamic_cast< A_ExpressionNode* >( &node ) ) {
return false;
}
auto* const iptr{
dynamic_cast< A_InstructionNode* >( &node ) };
if ( iptr && !exit ) {
auto const& il{ dynamic_cast< T_InstrListNode& >( iptr->parent( ) ) };
const auto hash{ ebcl::ComputeHash( (uint64_t)iptr ) };
oData.instrIndex.add( hash );
oData.instructions.add( T_OptData::T_InstrPos{
oData.instructions.size( ) , iptr ,
iptr == &il.node( il.size( ) - 1 ) ,
fnIndex } );
}
return true;
}
} // namespace <anon>
void T_OptData::numberInstructions(
T_OpsParserOutput& program ) noexcept
{
if ( state & E_StateItem::NUMBERING ) {
return;
}
instructions.clear( );
instrIndex.clear( );
const auto nf{ program.root.nFunctions( ) };
for ( auto i = 0u ; i < nf ; i ++ ) {
visitor.visit( program.root.function( i ) ,
[&]( A_Node& node , const bool exit ) {
return ODNIVisitor_( node , exit , *this , i );
} );
}
state = state | E_StateItem::NUMBERING;
}
uint32_t T_OptData::indexOf(
opast::A_InstructionNode const& instr ) noexcept
{
const auto hash{ ebcl::ComputeHash( (uint64_t)&instr ) };
uint32_t existing{ instrIndex.first( hash ) };
while ( existing != T_HashIndex::INVALID_INDEX ) {
if ( &instr == instructions[ existing ].node ) {
break;
}
existing = instrIndex.next( existing );
}
assert( existing != T_HashIndex::INVALID_INDEX );
return existing;
}
/*= T_OptData - CONTROL FLOW GRAPH CONSTRUCTION ==============================*/
namespace {
// CFG type shortcuts
using T_CFN_ = T_OptData::T_CtrlFlowNode;
using P_CFN_ = T_OptData::P_CtrlFlowNode;
// Helpers to create or re-use CFG nodes
T_OptData::P_CtrlFlowNode BCFGNewNode_(
T_Array< P_CFN_ >& pool ) noexcept
{
if ( pool.empty( ) ) {
return NewOwned< T_CFN_ >( );
}
auto r{ std::move( pool.last( ) ) };
pool.removeLast( );
r->instructions.clear( );
r->inbound.clear( );
r->outbound.clear( );
return r;
}
#define M_NEWNODE_() BCFGNewNode_( old )
#define M_ADDNEW_() \
ctrlFlowGraph.add( M_NEWNODE_( ) )
#define M_NODE_(i) \
ctrlFlowGraph[i]
/*----------------------------------------------------------------------------*/
using T_BCFGFunctions_ = T_KeyValueTable< T_String , T_OptData::T_BasicBlock >;
inline void BCFGFuncEnter_(
A_Node& node ,
T_Optional< uint32_t >& cNode ,
T_Array< T_OptData::P_CtrlFlowNode >& ctrlFlowGraph ,
T_Array< T_OptData::P_CtrlFlowNode >& old ,
T_BCFGFunctions_& cfgFunctions ,
F_OPLogger const& logger
) noexcept
{
auto& n{ dynamic_cast< A_FuncNode& >( node ) };
auto const& fn{ n.name( ) };
logger( [&](){
T_StringBuilder sb;
sb << "Starting function '" << fn << "' at "
<< ctrlFlowGraph.size( );
return sb;
} , 5 );
cfgFunctions.add( fn , T_OptData::T_BasicBlock{
ctrlFlowGraph.size( ) } );
cNode = M_ADDNEW_( );
}
inline void BCFGFuncExit_(
A_Node& node ,
T_Optional< uint32_t >& cNode ,
T_Array< T_OptData::P_CtrlFlowNode >& ctrlFlowGraph ,
T_BCFGFunctions_& cfgFunctions ,
F_OPLogger const& logger
) noexcept
{
auto& n{ dynamic_cast< A_FuncNode& >( node ) };
auto const& fn{ n.name( ) };
logger( [&](){
T_StringBuilder sb;
sb << "Function ended; last block had "
<< ( M_NODE_( *cNode )->instructions
? M_NODE_( *cNode )->instructions->count
: 0 )
<< " instructions";
return sb;
} , 5 );
auto* frec{ cfgFunctions.get( fn ) };
assert( frec );
frec->count = ctrlFlowGraph.size( ) - frec->first;
cNode.clear( );
}
/*----------------------------------------------------------------------------*/
// Data structure to handle conditionals
struct T_BCFGStackEntry_ {
uint32_t condBlock;
bool hasDefault{ false };
T_AutoArray< uint32_t , 8 > caseBlocks;
};
using T_BCFGStack_ = T_AutoArray< T_BCFGStackEntry_ , 8 >;
inline void BCFGCondEnter_(
T_BCFGStack_& stack ,
T_Optional< uint32_t >& cNode ,
T_Array< T_OptData::P_CtrlFlowNode >& ctrlFlowGraph ,
F_OPLogger const& logger ) noexcept
{
auto& se{ stack.addNew( ) };
se.condBlock = *cNode;
cNode.clear( );
logger( [&](){
T_StringBuilder sb;
sb << "Entering conditional instruction, stack size "
<< stack.size( )
<< ", block had "
<< ( M_NODE_( se.condBlock )->instructions
? M_NODE_( se.condBlock )->instructions->count
: 0 )
<< " instructions";
return sb;
} , 6 );
}
inline void BCFGCondExit_(
T_BCFGStack_& stack ,
T_Optional< uint32_t >& cNode ,
T_Array< T_OptData::P_CtrlFlowNode >& ctrlFlowGraph ,
T_Array< T_OptData::P_CtrlFlowNode >& old ,
F_OPLogger const& logger ) noexcept
{
auto& se{ stack.last( ) };
cNode = M_ADDNEW_( );
// Connect each case block to both the condition
// and the next block
const auto ncb{ se.caseBlocks.size( ) };
for ( auto i = 0u ; i < ncb ; i ++ ) {
auto& cbi{ se.caseBlocks[ i ] };
auto& cb{ *M_NODE_( cbi ) };
cb.inbound.add( se.condBlock );
M_NODE_( se.condBlock )->outbound.add( cbi );
cb.outbound.add( *cNode );
M_NODE_( *cNode )->inbound.add( cbi );
}
if ( !se.hasDefault ) {
M_NODE_( *cNode )->inbound.add( se.condBlock );
M_NODE_( se.condBlock )->outbound.add( *cNode );
}
stack.removeLast( );
logger( [&](){
T_StringBuilder sb;
sb << "Exiting conditional instruction, stack size "
<< stack.size( );
return sb;
} , 6 );
}
/*----------------------------------------------------------------------------*/
inline bool BCFGVisitor_(
A_Node& node ,
const bool exit ,
T_OptData& data ,
T_BCFGStack_& stack ,
T_Optional< uint32_t >& cNode ,
T_Array< T_OptData::P_CtrlFlowNode >& old
) noexcept
{
const auto nt{ node.type( ) };
// Handle start/end of functions
if ( nt == A_Node::DECL_FN || nt == A_Node::DECL_INIT
|| nt == A_Node::DECL_FRAME ) {
if ( exit ) {
assert( stack.empty( ) );
BCFGFuncExit_( node , cNode , data.ctrlFlowGraph ,
data.cfgFunctions , data.logger );
} else {
BCFGFuncEnter_( node , cNode , data.ctrlFlowGraph ,
old , data.cfgFunctions ,
data.logger );
}
return true;
}
// All instructions: continue the current basic block
auto* const iptr{ dynamic_cast< A_InstructionNode* >( &node ) };
if ( iptr && !exit ) {
assert( cNode );
auto& n{ *data.ctrlFlowGraph[ *cNode ] };
if ( n.instructions ) {
n.instructions->count ++;
} else {
n.instructions = T_OptData::T_BasicBlock{
data.indexOf( *iptr ) };
}
}
// Handle conditionals
if ( nt == A_Node::OP_COND ) {
if ( exit ) {
BCFGCondExit_( stack , cNode , data.ctrlFlowGraph ,
old , data.logger );
} else {
BCFGCondEnter_( stack , cNode , data.ctrlFlowGraph ,
data.logger );
}
return true;
}
// Calls also break the flow
if ( nt == A_Node::OP_CALL && !exit ) {
T_CallInstrNode& ci{ *dynamic_cast< T_CallInstrNode* >( iptr ) };
data.logger( [&](){
T_StringBuilder sb;
auto const& node{ *data.ctrlFlowGraph[ *cNode ] };
sb << "Call to " << ci.id( ) << ", block had "
<< ( node.instructions
? node.instructions->count
: 0 )
<< " instructions";
return sb;
} , 6 );
auto& cs{ data.callSites.addNew( ) };
cs.name = ci.id( );
cs.callBlock = *cNode;
cNode = cs.retBlock = data.ctrlFlowGraph.add( M_NEWNODE_( ) );
return true;
}
// Condition case nodes: create new basic block, add to stack's list
if ( nt == A_Node::TN_CASE || nt == A_Node::TN_DEFAULT ) {
if ( exit ) {
data.logger( [&](){
T_StringBuilder sb;
auto const& node{ *data.ctrlFlowGraph[ *cNode ] };
sb << "Case block added ("
<< ( node.instructions
? node.instructions->count
: 0 )
<< " instructions)";
return sb;
} , 6 );
cNode.clear( );
} else {
stack.last( ).hasDefault = stack.last( ).hasDefault
|| ( nt == A_Node::TN_DEFAULT );
cNode = data.ctrlFlowGraph.add( M_NEWNODE_( ) );
stack.last( ).caseBlocks.add( *cNode );
}
}
return !dynamic_cast< A_ExpressionNode* >( &node );
}
/*----------------------------------------------------------------------------*/
inline void BCFGHandleCalls_(
T_OptData& data ) noexcept
{
// Add fake call sites for *init* and *frame*
{
auto& cs{ data.callSites.addNew( ) };
cs.callBlock = T_OptData::CFG_ENTER;
cs.retBlock = T_OptData::CFG_MAINLOOP;
cs.name = "*init*";
}
{
auto& cs{ data.callSites.addNew( ) };
cs.callBlock = T_OptData::CFG_MAINLOOP;
cs.retBlock = T_OptData::CFG_MAINLOOP;
cs.name = "*frame*";
}
// Handle calls
constexpr auto tCall{ T_OptData::T_CtrlFlowEdge::CALL };
constexpr auto tRet{ T_OptData::T_CtrlFlowEdge::RET };
constexpr auto tBypass{ T_OptData::T_CtrlFlowEdge::BYPASS };
for ( auto const& cs : data.callSites ) {
auto const* frec{ data.cfgFunctions.get( cs.name ) };
assert( frec );
const auto nExit{ frec->first + frec->count - 1 };
auto& bCall{ *data.ctrlFlowGraph[ cs.callBlock ] };
auto& bRet{ *data.ctrlFlowGraph[ cs.retBlock ] };
auto& bEntry{ *data.ctrlFlowGraph[ frec->first ] };
auto& bExit{ *data.ctrlFlowGraph[ nExit ] };
// Call
bEntry.inbound.addNew( cs.callBlock , tCall );
bCall.outbound.addNew( frec->first , tCall );
// Return
bExit.outbound.addNew( cs.retBlock , tRet );
bRet.inbound.addNew( nExit , tRet );
// Call bypass
bCall.outbound.addNew( cs.retBlock , tBypass );
bRet.inbound.addNew( cs.callBlock , tBypass );
}
}
/*----------------------------------------------------------------------------*/
inline T_StringBuilder BCFGDumpAll_(
T_OptData const& data ) noexcept
{
T_StringBuilder dump;
int i{ 0 };
dump << "Control flow graph dump\n";
for ( auto const& p : data.ctrlFlowGraph ) {
auto const& e{ *p };
dump << "\nNode " << i++ << "\n\t";
if ( e.instructions ) {
dump << e.instructions->count
<< " instruction(s) at index "
<< e.instructions->first;
} else {
dump << "No instructions";
}
dump << "\n\tInbound:";
{
const auto ni{ e.inbound.size( ) };
if ( ni == 0 ) {
dump << " NONE";
}
for ( auto idx = 0u ; idx < ni ; idx ++ ) {
dump << ' ' << e.inbound[ idx ];
}
}
dump << "\n\tOutbound:";
{
const auto no{ e.outbound.size( ) };
if ( no == 0 ) {
dump << " NONE";
}
for ( auto idx = 0u ; idx < no ; idx ++ ) {
dump << ' ' << e.outbound[ idx ];
}
}
dump << '\n';
}
dump << '\n';
return dump;
}
} // namespace <anon>
/*----------------------------------------------------------------------------*/
void T_OptData::buildControlFlowGraph(
T_OpsParserOutput& program ) noexcept
{
if ( state & E_StateItem::CFG ) {
return;
}
numberInstructions( program );
M_LOGSTR_( "Building control flow graph" , 4 );
// Keep the old array, we'll reuse its contents
T_Array< P_CtrlFlowNode > old{ std::move( ctrlFlowGraph ) };
callSites.clear( );
cfgFunctions.clear( );
// Create special nodes
M_ADDNEW_( );
M_ADDNEW_( );
M_ADDNEW_( );
M_NODE_( CFG_MAINLOOP )->outbound.add( CFG_END );
M_NODE_( CFG_END )->inbound.add( CFG_MAINLOOP );
// Generate control flow graph for each function
T_BCFGStack_ stack;
T_Optional< uint32_t > cNode{ };
visitor.visit( program.root , [&]( A_Node& node , const bool exit ) {
return BCFGVisitor_( node , exit , *this ,
stack , cNode , old );
} );
assert( cfgFunctions.contains( "*init*" )
&& cfgFunctions.contains( "*frame*" ) );
BCFGHandleCalls_( *this );
logger( [this](){
return BCFGDumpAll_( *this );
} , 6 );
state = state | E_StateItem::CFG;
}
#undef M_ADDNEW_
#undef M_NEWNODE_
#undef M_NODE_
/*= T_OptData - USE/DEFINE CHAINS ============================================*/
namespace {
void BUDCAddRecord_(
A_Node& n ,
T_String const& id ,
const bool use ,
T_OptData& od ,
T_RootNode& root ,
T_OptData::T_VarId const* extVarId = nullptr ) noexcept
{
// Find instruction and function index
A_FuncNode* func{ nullptr };
T_Optional< uint32_t > instrId;
A_Node* pn{ &n };
while ( pn ) {
auto* const asInstr{ dynamic_cast< A_InstructionNode* >( pn ) };
func = dynamic_cast< A_FuncNode* >( pn );
if ( !instrId && asInstr ) {
instrId = od.indexOf( *asInstr );
} else if ( func ) {
break;
}
pn = &pn->parent( );
}
assert( func && instrId );
// Generate the identifier
const T_OptData::T_VarId varId{ extVarId ? *extVarId : [&]() {
auto const& n{ id };
if ( func->hasLocal( id ) ) {
return T_OptData::T_VarId{ n , func->name( ) ,
func->isArgument( id ) };
}
return T_OptData::T_VarId{ n };
} () };
// Access or create the record
auto* const varRec{ [&]() {
auto* const x{ od.varUDChains.get( varId ) };
if ( x ) {
return x;
}
od.varUDChains.add( T_OptData::T_VarUseDefine{ varId } );
return od.varUDChains.get( varId );
} () };
assert( varRec );
// Add use/define record
auto& udRec{ use ? varRec->uses.addNew( ) : varRec->defines.addNew( ) };
udRec.node = *instrId;
udRec.fnIndex = root.functionIndex( func->name( ) );
od.logger( [&](){
T_StringBuilder sb;
sb << ( use ? "use " : "def " ) << varId.name << "(#"
<< ( use ? varRec->uses.size( ) : varRec->defines.size( ) ) - 1
<< ") at " << n.location( ) << " (";
if ( varId.type == T_OptData::E_UDVarType::GLOBAL ) {
sb << "global";
} else {
if ( varId.type == T_OptData::E_UDVarType::LOCAL ) {
sb << "local";
} else {
sb << "argument";
}
sb << " of " << varId.owner;
}
sb << "), instr #" << *instrId;
return sb;
} , 6 );
}
void BUDCVisitor_(
T_RootNode& root ,
T_OptData& od ,
A_Node& n )
{
switch ( n.type( ) ) {
default: break;
case A_Node::EXPR_ID: {
auto const& id{ dynamic_cast< T_IdentifierExprNode& >( n ).id( ) };
if ( id != "width" && id != "height" && id != "time" ) {
BUDCAddRecord_( n , id , true , od , root );
}
break;
}
case A_Node::OP_UNIFORMS:
BUDCAddRecord_( n ,
dynamic_cast< T_UniformsInstrNode& >( n ).progId( ) ,
true , od , root );
break;
case A_Node::OP_USE_TEXTURE:
BUDCAddRecord_( n ,
dynamic_cast< T_UseTextureInstrNode& >( n ).samplerId( ) ,
true , od , root );
// fallthrough
case A_Node::OP_USE_PROGRAM:
case A_Node::OP_USE_PIPELINE:
case A_Node::OP_USE_FRAMEBUFFER:
BUDCAddRecord_( n ,
dynamic_cast< T_UseInstrNode& >( n ).id( ) ,
true , od , root );
break;
case A_Node::OP_PIPELINE: {
auto& pln{ dynamic_cast< T_PipelineInstrNode& >( n ) };
BUDCAddRecord_( n , pln.id( ) , false , od , root );
const auto np{ pln.size( ) };
for ( auto i = 0u ; i < np ; i ++ ) {
BUDCAddRecord_( n , pln.program( i ) ,
true , od , root );
}
break;
}
case A_Node::TN_FBATT:
BUDCAddRecord_( n , dynamic_cast< T_FramebufferInstrNode::T_Attachment& >( n ).id( ) ,
true , od , root );
break;
case A_Node::OP_FRAMEBUFFER:
case A_Node::OP_TEXTURE:
case A_Node::OP_SAMPLER:
case A_Node::OP_PROGRAM:
BUDCAddRecord_( n , dynamic_cast< A_ResourceDefInstrNode& >( n ).id( ) ,
false , od , root );
break;
case A_Node::OP_SET:
BUDCAddRecord_( n , dynamic_cast< T_SetInstrNode& >( n ).id( ) ,
false , od , root );
break;
case A_Node::OP_CALL: {
auto& cn{ dynamic_cast< T_CallInstrNode& >( n ) };
auto& callee{ root.function(
root.functionIndex( cn.id( ) ) ) };
const auto nlocs{ callee.locals( ) };
for ( auto i = 0u ; i < nlocs ; i ++ ) {
auto const& name{ callee.getLocalName( i ) };
if ( !callee.isArgument( name ) ) {
continue;
}
const T_OptData::T_VarId vid{ name , callee.name( ) , true };
BUDCAddRecord_( n , name , false , od ,
root , &vid );
}
break;
}
}
}
/*----------------------------------------------------------------------------*/
struct T_UDEntry_
{
uint32_t entry;
bool isUse;
uint32_t index;
};
using T_UDEPerInstr_ = T_KeyValueTable< uint32_t , T_AutoArray< T_UDEntry_ , 8 > >;
template< uint32_t S >
void BUDCAddEntries_(
T_UDEPerInstr_& out ,
const uint32_t mainEntry ,
const bool isUse ,
T_AutoArray< T_OptData::T_VarUDRecord , S > const& entries ) noexcept
{
const auto na{ entries.size( ) };
for ( auto j = 0u ; j < na ; j ++ ) {
auto const& use{ entries[ j ] };
auto* rec{ out.get( use.node ) };
if ( !rec ) {
out.add( use.node , T_AutoArray< T_UDEntry_ , 8 >{ } );
rec = out.get( use.node );
}
assert( rec );
auto& ne{ rec->addNew( ) };
ne.entry = mainEntry;
ne.isUse = isUse;
ne.index = j;
}
}
/*----------------------------------------------------------------------------*/
void BUDCLink_(
T_OptData::T_VarUseDefine& var ,
const uint32_t def ,
const uint32_t use ,
F_OPLogger const& logger
) noexcept
{
var.uses[ use ].refs.add( def );
if ( def != T_HashIndex::INVALID_INDEX ) {
var.defines[ def ].refs.add( use );
}
logger( [&](){
T_StringBuilder sb;
sb << var.var.name << " (";
switch ( var.var.type ) {
case T_OptData::E_UDVarType::GLOBAL:
sb << "global";
break;
case T_OptData::E_UDVarType::ARGUMENT:
sb << "argument of " << var.var.owner;
break;
case T_OptData::E_UDVarType::LOCAL:
sb << "local variable of " << var.var.owner;
break;
}
sb << ") ";
if ( def == T_HashIndex::INVALID_INDEX ) {
sb << "UNDEFINED";
} else {
sb << "DEF " << def;
}
sb << " USE " << use;
return sb;
} , 6 );
}
/*----------------------------------------------------------------------------*/
struct T_BUDCDefSet_
{
T_Set< uint32_t > set{ UseTag< ArrayBacked< 4 > >( ) };
T_AutoArray< uint8_t , 1 > bitmap;
explicit T_BUDCDefSet_( const uint32_t max ) noexcept
{
const auto nBytesRaw{ max >> 3 };
const auto nBytes{ nBytesRaw + ( ( max & 7 ) != 0 ? 1 : 0 ) };
for ( auto i = 0u ; i < nBytes ; i ++ ) {
bitmap.add( 0 );
}
}
void clear( ) noexcept
{
set.clear( );
for ( auto i = 0u ; i < bitmap.size( ) ; i ++ ) {
bitmap[ i ] = 0;
}
}
void add( const uint32_t item ) noexcept
{
const auto byte{ item >> 3 };
const auto bit{ item & 7 };
const auto mask{ 1 << bit };
if ( ( bitmap[ byte ] & mask ) == 0 ) {
bitmap[ byte ] |= mask;
set.add( item );
}
}
bool operator ==( T_BUDCDefSet_ const& other ) noexcept
{
if ( bitmap.size( ) != other.bitmap.size( ) ) {
return false;
}
for ( auto i = 0u ; i < bitmap.size( ) ; i ++ ) {
if ( bitmap[ i ] != other.bitmap[ i ] ) {
return false;
}
}
return true;
}
};
void BUDCWalkGraph_(
T_OptData& data ,
T_OptData::T_VarUseDefine& var ,
T_UDEPerInstr_& udPerInstr ,
T_Optional< uint32_t > fnIndex
) noexcept
{
T_Set< uint32_t > changed{ UseTag< ArrayBacked< 16 > >( ) }; // FIXME alloc
T_Array< T_BUDCDefSet_ > defines; // FIXME alloc
defines.resize( data.ctrlFlowGraph.size( ) , T_BUDCDefSet_{ 0 } );
data.logger( [&]() {
T_StringBuilder sb;
sb << "Walking graph for " << var.var.name << " (";
switch ( var.var.type ) {
case T_OptData::E_UDVarType::GLOBAL:
sb << "global";
break;
case T_OptData::E_UDVarType::ARGUMENT:
sb << "argument of " << var.var.owner;
break;
case T_OptData::E_UDVarType::LOCAL:
sb << "local variable of " << var.var.owner;
break;
}
sb << ')';
return sb;
} , 5 );
auto const* const fn{ fnIndex
? &data.cfgFunctions[ *fnIndex ]
: nullptr };
auto const nFirst{ fn ? fn->first : 0u };
auto const nEnd{ fn ? ( fn->first + fn->count )
: data.ctrlFlowGraph.size( ) };
data.logger( [=](){
T_StringBuilder sb{ "Nodes " };
sb << nFirst << " ... " << ( nEnd - 1 );;
return sb;
} , 8 );
changed.add( nFirst );
for ( auto i = nEnd ; i > nFirst + 1 ; i -- ) {
changed.add( i - 1 );
}
while ( changed.size( ) ) {
const auto node{ changed[ 0 ] };
data.logger( [=](){
T_StringBuilder sb{ "Checking node " };
sb << node;
return sb;
} , 8 );
assert( node >= nFirst && node < nEnd );
auto const& cn{ *data.ctrlFlowGraph[ node ] };
changed.remove( node );
// Assemble the set of possible definitions at the start of
// the block.
T_BUDCDefSet_ sInput{ var.defines.size( ) };
const auto nIn{ cn.inbound.size( ) };
for ( auto i = 0u ; i < nIn ; i ++ ) {
auto const& ib{ cn.inbound[ i ] };
// Make sure the inbound link type is right (FLOW always
// is, BYPASS works in functions, CALL/RET at the global
// level)
if ( ib.type != ib.FLOW && (
( fnIndex && ib.type != ib.BYPASS )
|| ( !fnIndex && ib.type == ib.BYPASS ) ) ) {
continue;
}
// Get defines from node
auto const& sNode{ defines[ ib.target ] };
const auto nIbIn{ sNode.set.size( ) };
for ( auto j = 0u ; j < nIbIn ; j ++ ) {
sInput.add( sNode.set[ j ] );
}
}
if ( cn.instructions ) {
// Check for defines in the instructions
const auto is{ cn.instructions->first };
const auto ie{ is + cn.instructions->count };
for ( auto ii = is ; ii < ie ; ii ++ ) {
auto const* const irec{ udPerInstr.get( ii ) };
if ( !irec ) {
continue;
}
const auto nrec{ irec->size( ) };
for ( auto j = 0u ; j < nrec ; j ++ ) {
auto const& rec{ (*irec)[ j ] };
if ( rec.isUse || data.varUDChains[ rec.entry ].var != var.var ) {
continue;
}
sInput.clear( );
sInput.add( rec.index );
}
}
}
auto& sOut{ defines[ node ] };
if ( sOut == sInput ) {
continue;
}
data.logger( [&](){
T_StringBuilder sb;
sb << "Node " << node << ", setting output to {";
for ( auto i = 0u ; i < sInput.set.size( ) ; i ++ ) {
if ( i ) {
sb << " ,";
}
sb << ' ' << sInput.set[ i ];
}
sb << " }";
return sb;
} , 7 );
sOut = sInput;
// Add the node's successors into the changed set
const auto nOut{ cn.outbound.size( ) };
for ( auto i = 0u ; i < nOut ; i ++ ) {
auto const& ob{ cn.outbound[ i ] };
// Make sure the outbound link type is right (FLOW
// always is, BYPASS works in functions, CALL/RET at
// the global level)
if ( ob.type != ob.FLOW && (
( fnIndex && ob.type != ob.BYPASS )
|| ( !fnIndex && ob.type == ob.BYPASS ) ) ) {
continue;
}
changed.add( ob.target );
}
}
// Now we need to identify the blocks which contain var uses
T_Set< uint32_t > blocks{ UseTag< ArrayBacked< 16 > >( ) }; // FIXME alloc
for ( auto i = 0u ; i < var.uses.size( ) ; i ++ ) {
const auto useInstr{ var.uses[ i ].node };
for ( auto j = nFirst ; j < nEnd ; j ++ ) {
auto const& block{ *data.ctrlFlowGraph[ j ] };
if ( !block.instructions ) {
continue;
}
const auto f{ block.instructions->first };
const auto e{ block.instructions->count + f - 1 };
if ( f <= useInstr && e >= useInstr ) {
blocks.add( j );
break;
}
}
}
// Now go through all the blocks instruction by instruction, updating
// the active definition set if a definition is found, and associating
// defines to uses.
for ( auto i = 0u ; i < blocks.size( ) ; i ++ ) {
const auto bid{ blocks[ i ] };
auto const& cb{ *data.ctrlFlowGraph[ bid ] };
T_BUDCDefSet_ defs{ defines[ bid ] };
assert( cb.instructions );
const auto is{ cb.instructions->first };
const auto ie{ is + cb.instructions->count };
for ( auto ii = is ; ii < ie ; ii ++ ) {
auto const* const irec{ udPerInstr.get( ii ) };
if ( !irec ) {
continue;
}
const auto nrec{ irec->size( ) };
// Handle uses first
for ( auto j = 0u ; j < nrec ; j ++ ) {
auto const& rec{ (*irec)[ j ] };
auto const& ud{ data.varUDChains[ rec.entry ] };
if ( !rec.isUse || ud.var != var.var ) {
continue;
}
for ( auto di = 0u ; di < defs.set.size( ) ; di ++ ) {
BUDCLink_( var , defs.set[ di ] ,
rec.index , data.logger );
}
if ( !defs.set.size( ) ) {
// FIXME: add warning
BUDCLink_( var , T_HashIndex::INVALID_INDEX ,
rec.index , data.logger );
}
}
// Update the set
for ( auto j = 0u ; j < nrec ; j ++ ) {
auto const& rec{ (*irec)[ j ] };
auto const& ud{ data.varUDChains[ rec.entry ] };
if ( rec.isUse || ud.var != var.var ) {
continue;
}
defs.clear( );
defs.add( rec.index );
break;
}
}
}
}
} // namespace <anon>
/*----------------------------------------------------------------------------*/
void T_OptData::buildUseDefineChains(
T_OpsParserOutput& program ) noexcept
{
if ( state & E_StateItem::UDCHAINS ) {
return;
}
buildControlFlowGraph( program );
M_LOGSTR_( "Building use/define chains" , 4 );
varUDChains.clear( );
// Find all definitions and uses, add them to the table
visitor.visit( program.root , [&]( auto& n , const bool exit ) {
if ( !exit ) {
BUDCVisitor_( program.root , *this , n );
}
return true;
} );
// Build a per-instruction table of all variable uses/defines that were
// identified
T_UDEPerInstr_ udPerInstr;
auto const& udcEntries{ varUDChains.values( ) };
const auto n{ udcEntries.size( ) };
for ( auto i = 0u ; i < n ; i ++ ) {
auto const& r{ udcEntries[ i ] };
BUDCAddEntries_( udPerInstr , i , true , r.uses );
BUDCAddEntries_( udPerInstr , i , false , r.defines );
}
// Proceed for each symbol
for ( auto& sym : varUDChains.values( ) ) {
switch ( sym.var.type ) {
case T_OptData::E_UDVarType::GLOBAL:
BUDCWalkGraph_( *this , sym , udPerInstr , {} );
break;
case T_OptData::E_UDVarType::ARGUMENT: {
const auto nDefs{ sym.defines.size( ) };
const auto nUses{ sym.uses.size( ) };
for ( auto i = 0u ; i < nDefs ; i ++ ) {
for ( auto j = 0u ; j < nUses ; j ++ ) {
BUDCLink_( sym , i , j , logger );
}
}
break;
}
case T_OptData::E_UDVarType::LOCAL: {
assert( cfgFunctions.contains( sym.var.owner ) );
BUDCWalkGraph_( *this , sym , udPerInstr ,
cfgFunctions.indexOf( sym.var.owner ) );
break;
}
}
}
state = state | E_StateItem::UDCHAINS;
}
/*============================================================================*/
#undef M_LOGSTR_
#define M_LOGSTR_( S , L ) \
oData.logger( [](){ return T_StringBuilder{ S }; } , L )
/*= CONSTANT FOLDING =========================================================*/
namespace {
struct T_ConstantFolder_
{
T_ConstantFolder_( T_OptData& data ) noexcept
: oData{ data }
{}
// Result
bool didFold{ false };
bool operator()( A_Node& node , bool exit ) noexcept;
private:
T_OptData& oData;
template<
typename T
> void handleParentNode(
A_Node& node ,
std::function< A_ExpressionNode&( T& ) > get ,
std::function< void( T& , P_ExpressionNode ) > set ) noexcept;
P_ExpressionNode checkExpression(
A_ExpressionNode& node ) noexcept;
// Handle identifiers. If the size is fixed and the identifier is
// either width or height, replace it with the appropriate value.
P_ExpressionNode doIdExpr(
T_IdentifierExprNode& node ) noexcept;
// Handle reads from inputs. If there's a curve and it is a constant,
// or if there's no curve and only one default value, then the
// expression is constant.
P_ExpressionNode doInputExpr(
T_InputExprNode& node ) noexcept;
// Transform an unary operator applied to a constant into a constant.
P_ExpressionNode doUnaryOp(
T_UnaryOperatorNode& node ,
double value ) const noexcept;
// Transform a binary operator applied to a constant into a constant.
P_ExpressionNode doBinaryOp(
T_BinaryOperatorNode& node ,
double left ,
double right ) const noexcept;
};
/*----------------------------------------------------------------------------*/
bool T_ConstantFolder_::operator()(
A_Node& node ,
const bool exit ) noexcept
{
if ( exit ) {
return true;
}
switch ( node.type( ) ) {
case A_Node::TN_ARG:
handleParentNode< T_ArgumentNode >(
node ,
[]( auto& n ) -> A_ExpressionNode& { return n.expression( ); } ,
[]( auto& n , P_ExpressionNode e ) { n.expression( std::move( e ) ); }
);
return false;
case A_Node::TN_CONDITION:
handleParentNode< T_CondInstrNode::T_Expression >( node ,
[]( auto& n ) -> A_ExpressionNode& { return n.expression( ); } ,
[]( auto& n , P_ExpressionNode e ) { n.expression( std::move( e ) ); }
);
return false;
case A_Node::OP_SET:
handleParentNode< T_SetInstrNode >( node ,
[]( auto& n ) -> A_ExpressionNode& { return n.expression( ); } ,
[]( auto& n , P_ExpressionNode e ) { n.setExpression( std::move( e ) ); } );
return false;
default:
return true;
}
}
/*----------------------------------------------------------------------------*/
template<
typename T
> void T_ConstantFolder_::handleParentNode(
A_Node& n ,
std::function< A_ExpressionNode&( T& ) > get ,
std::function< void( T& , P_ExpressionNode ) > set ) noexcept
{
auto& node{ (T&) n };
auto& child{ get( node ) };
auto r{ checkExpression( child ) };
if ( r ) {
oData.logger( [&]() {
T_StringBuilder sb;
sb << "substituting node at " << child.location( );
return sb;
} , 3 );
r->location( ) = node.location( );
set( node , std::move( r ) );
didFold = true;
}
}
P_ExpressionNode T_ConstantFolder_::checkExpression(
A_ExpressionNode& node ) noexcept
{
// Already a constant
if ( node.type( ) == A_Node::EXPR_CONST ) {
return {};
}
// Replace $width/$height with value if fixedSize
if ( node.type( ) == A_Node::EXPR_ID ) {
return doIdExpr( (T_IdentifierExprNode&) node );
}
// Replace inputs with value if no curve/constant curve
if ( node.type( ) == A_Node::EXPR_INPUT ) {
return doInputExpr( (T_InputExprNode&) node );
}
// Replace UnOp( Cnst ) with result
auto* const asUnary{ dynamic_cast< T_UnaryOperatorNode* >( &node ) };
if ( asUnary ) {
handleParentNode< T_UnaryOperatorNode >( *asUnary ,
[]( auto& n ) -> A_ExpressionNode& { return n.argument( ); } ,
[]( auto& n , P_ExpressionNode e ) { n.setArgument( std::move( e ) ); } );
if ( asUnary->argument( ).type( ) == A_Node::EXPR_CONST ) {
auto const& cn{ (T_ConstantExprNode const&) asUnary->argument( ) };
return doUnaryOp( *asUnary , cn.floatValue( ) );
}
return {};
}
// Replace BinOp( Cnst , Cnst ) with result
auto* const asBinary{ dynamic_cast< T_BinaryOperatorNode* >( &node ) };
assert( asBinary && "Missing support for some expr subtype" );
handleParentNode< T_BinaryOperatorNode >( *asBinary ,
[]( auto& n ) -> A_ExpressionNode& { return n.left( ); } ,
[]( auto& n , P_ExpressionNode e ) { n.setLeft( std::move( e ) ); } );
handleParentNode< T_BinaryOperatorNode >( *asBinary ,
[]( auto& n ) -> A_ExpressionNode& { return n.right( ); } ,
[]( auto& n , P_ExpressionNode e ) { n.setRight( std::move( e ) ); } );
if ( asBinary->left( ).type( ) == A_Node::EXPR_CONST
&& asBinary->right( ).type( ) == A_Node::EXPR_CONST ) {
auto const& l{ (T_ConstantExprNode const&) asBinary->left( ) };
auto const& r{ (T_ConstantExprNode const&) asBinary->right( ) };
return doBinaryOp( *asBinary , l.floatValue( ) , r.floatValue( ) );
}
return {};
}
/*----------------------------------------------------------------------------*/
P_ExpressionNode T_ConstantFolder_::doInputExpr(
T_InputExprNode& node ) noexcept
{
if ( !oData.curves ) {
return {};
}
auto const* const curve{ oData.curves->curves.get( node.id( ) ) };
if ( curve ) {
// Curve present, check if it's constant
const auto cval{ curve->isConstant( ) };
if ( !cval ) {
return {};
}
return NewOwned< T_ConstantExprNode >( node.parent( ) , *cval );
}
assert( oData.inputDecls );
auto const* const dva{ oData.inputDecls->get( node.id( ) ) };
assert( dva );
if ( dva->size( ) == 1 ) {
// If there's only one default value, that's a constant.
return NewOwned< T_ConstantExprNode >( node.parent( ) ,
(*dva)[ 0 ].value );
}
return {};
}
P_ExpressionNode T_ConstantFolder_::doIdExpr(
T_IdentifierExprNode& node ) noexcept
{
if ( !oData.fixedSize ) {
return {};
}
if ( node.id( ) == "width" ) {
M_LOGSTR_( "replacing $width with fixed width" , 3 );
return NewOwned< T_ConstantExprNode >( node.parent( ) ,
double( oData.fixedSize->first ) );
}
if ( node.id( ) == "height" ) {
M_LOGSTR_( "replacing $height with fixed height" , 3 );
return NewOwned< T_ConstantExprNode >( node.parent( ) ,
float( oData.fixedSize->second ) );
}
return {};
}
P_ExpressionNode T_ConstantFolder_::doUnaryOp(
T_UnaryOperatorNode& node ,
const double value ) const noexcept
{
const double rVal{ [this]( auto& node , const auto value ) {
switch ( node.op( ) ) {
case T_UnaryOperatorNode::NEG:
return -value;
case T_UnaryOperatorNode::NOT:
return value ? 0. : 1.;
case T_UnaryOperatorNode::INV:
if ( value == 0 ) {
oData.errors.addNew( "math - 1/x, x=0" , node.location( ) );
return 0.;
}
return 1. / value;
case T_UnaryOperatorNode::COS:
return cos( value );
case T_UnaryOperatorNode::SIN:
return sin( value );
case T_UnaryOperatorNode::TAN:
if ( fabs( value - M_PI / 2 ) <= 1e-6 ) {
oData.errors.addNew( "math - tan(x), x=~PI/2" ,
node.location( ) , E_SRDErrorType::WARNING );
}
return tan( value );
case T_UnaryOperatorNode::SQRT:
if ( value < 0 ) {
oData.errors.addNew( "math - sqrt(x), x<0" , node.location( ) );
return 0.;
}
return sqrt( value );
case T_UnaryOperatorNode::LN:
if ( value <= 0 ) {
oData.errors.addNew( "math - ln(x), x<=0" , node.location( ) );
return 0.;
}
return log( value );
case T_UnaryOperatorNode::EXP:
return exp( value );
}
fprintf( stderr , "invalid operator %d\n" , int( node.op( ) ) );
std::abort( );
}( node , value ) };
return NewOwned< T_ConstantExprNode >( node.parent( ) , rVal );
}
P_ExpressionNode T_ConstantFolder_::doBinaryOp(
T_BinaryOperatorNode& node ,
const double left ,
const double right ) const noexcept
{
const double rVal{ [this]( auto& node , const auto l , const auto r ) {
switch ( node.op( ) ) {
case T_BinaryOperatorNode::ADD:
return l + r;
case T_BinaryOperatorNode::SUB:
return l - r;
case T_BinaryOperatorNode::MUL:
return l * r;
case T_BinaryOperatorNode::DIV:
if ( r == 0 ) {
oData.errors.addNew( "math - l/r, r=0" , node.location( ) );
return 0.;
}
return l / r;
case T_BinaryOperatorNode::POW:
if ( l == 0 && r == 0 ) {
oData.errors.addNew( "math - l^r, l=r=0" , node.location( ) );
return 0.;
}
if ( l == 0 && r < 0 ) {
oData.errors.addNew( "math - l^r, l=0, r<0" , node.location( ) );
return 0.;
}
if ( l < 0 && fmod( r , 1. ) != 0. ) {
oData.errors.addNew( "math - l^r, l<0, r not integer" , node.location( ) );
return 0.;
}
return pow( l , r );
case T_BinaryOperatorNode::CMP_EQ: return ( l == r ) ? 1. : 0.;
case T_BinaryOperatorNode::CMP_NE: return ( l != r ) ? 1. : 0.;
case T_BinaryOperatorNode::CMP_GT: return ( l > r ) ? 1. : 0.;
case T_BinaryOperatorNode::CMP_GE: return ( l >= r ) ? 1. : 0.;
case T_BinaryOperatorNode::CMP_LT: return ( l < r ) ? 1. : 0.;
case T_BinaryOperatorNode::CMP_LE: return ( l <= r ) ? 1. : 0.;
}
fprintf( stderr , "invalid operator %d\n" , int( node.op( ) ) );
std::abort( );
}( node , left , right ) };
return NewOwned< T_ConstantExprNode >( node.parent( ) , rVal );
}
} // namespace <anon>
/*----------------------------------------------------------------------------*/
bool opopt::FoldConstants(
T_OpsParserOutput& program ,
T_OptData& oData ) noexcept
{
T_ConstantFolder_ folder{ oData };
M_LOGSTR_( "... Folding constants" , 2 );
if ( oData.curves ) {
oData.findInputDecls( program );
}
oData.visitor.visit( program.root , [&]( auto& n , auto x ) {
return folder( n , x );
} );
oData.logger( [&]() {
T_StringBuilder sb{ "...... " };
sb << ( folder.didFold
? "Some constants were folded"
: "No constants were folded" );
return sb;
} , 2 );
return folder.didFold;
}
/*= CONSTANT PROPAGATION =====================================================*/
namespace {
void CPReplaceWithConstant_(
A_InstructionNode& instruction ,
T_OptData::T_VarId const& var ,
const double value ,
T_OptData& oData
) noexcept
{
oData.visitor.visit( instruction , [&]( A_Node& node , const bool exit ) {
if ( !exit || node.type( ) != A_Node::EXPR_ID ) {
return node.type( ) != A_Node::ILIST;
}
auto& eid{ (T_IdentifierExprNode&) node };
if ( eid.id( ) != var.name ) {
return true;
}
auto& p{ eid.parent( ) };
T_OwnPtr< A_Node > replacement{
NewOwned< T_ConstantExprNode >( p , value )
};
replacement->location( ) = eid.location( );
p.replace( eid , replacement );
oData.logger( [&]() {
T_StringBuilder sb;
sb << "...... Propagated constant from " << var.name
<< " at " << instruction.location( )
<< " (value " << value << ")";
return sb;
} , 3 );
return true;
} );
}
} // namespace <anon>
bool opopt::PropagateConstants(
T_OpsParserOutput& program ,
T_OptData& oData ) noexcept
{
oData.buildUseDefineChains( program );
M_LOGSTR_( "... Propagating constants" , 2 );
T_Set< uint32_t > cDefs{ UseTag< ArrayBacked< 16 > >( ) };
T_AutoArray< double , 16 > cValues;
bool changesMade{ false };
for ( auto& udc : oData.varUDChains.values( ) ) {
cDefs.clear( );
cValues.clear( );
// Find all constant definitions
const auto nDefs{ udc.defines.size( ) };
for ( auto i = 0u ; i < nDefs ; i ++ ) {
auto const& def{ udc.defines[ i ] };
auto const* const ri{ oData.instructions[ def.node ].node };
if ( ri->type( ) == A_Node::OP_SET ) {
auto const* const si{
dynamic_cast< T_SetInstrNode const* >( ri ) };
if ( si->expression( ).type( ) == A_Node::EXPR_CONST ) {
cDefs.add( i );
cValues.add( ( (T_ConstantExprNode&) si->expression( ) ).floatValue( ) );
}
} else {
// Instruction is not supported, exit
assert( cDefs.size( ) == 0 );
break;
}
}
assert( cValues.size( ) == cDefs.size( ) );
if ( cValues.empty( ) ) {
continue;
}
for ( auto i = 0u ; i < udc.uses.size( ) ; ) {
auto const& use{ udc.uses[ i ] };
const auto nRefs{ use.refs.size( ) };
T_Optional< double > repVal{ };
for ( auto j = 0u ; j < nRefs ; j ++ ) {
const auto dIdx{ cDefs.indexOf( use.refs[ j ] ) };
if ( dIdx == -1 ) {
repVal.clear( );
break;
}
if ( !repVal ) {
repVal = cValues[ dIdx ];
} else if ( *repVal != cValues[ dIdx ] ) {
repVal.clear( );
break;
}
}
if ( !repVal ) {
i ++;
continue;
}
CPReplaceWithConstant_( *oData.instructions[ use.node ].node ,
udc.var , *repVal , oData );
for ( auto j = 0u ; j < nRefs ; j ++ ) {
auto& def{ udc.defines[ use.refs[ j ] ] };
def.refs.remove( def.refs.indexOf( i ) );
for ( auto k = 0u ; k < def.refs.size( ) ; k ++ ) {
if ( def.refs[ k ] > i ) {
def.refs[ k ] --;
}
}
}
udc.uses.removeSwap( i );
changesMade = true;
}
}
return changesMade;
}
/*= DEAD CODE REMOVAL ========================================================*/
namespace {
struct T_RDCConstCond_
{
T_CondInstrNode* node;
int64_t value;
};
using T_RDCConstCondList_ = T_AutoArray< T_RDCConstCond_ , 16 >;
bool RDCFindConditionals_(
A_Node& node ,
const bool exit ,
T_RDCConstCondList_& constConds
) noexcept
{
if ( exit || node.type( ) != A_Node::OP_COND ) {
return !dynamic_cast< A_ExpressionNode* >( &node );
}
auto& cn{ dynamic_cast< T_CondInstrNode& >( node ) };
auto const& ce{ cn.expression( ).expression( ) };
if ( ce.type( ) == A_Node::EXPR_CONST ) {
const int64_t ccv{ ( (T_ConstantExprNode const&) ce ).intValue( ) };
constConds.add( T_RDCConstCond_{ &cn , ccv } );
return false;
}
return true;
}
bool RDCConditionals_(
T_OpsParserOutput& program ,
T_OptData& oData
) noexcept
{
M_LOGSTR_( "...... Checking conditional instructions" , 3 );
T_RDCConstCondList_ constConds;
oData.visitor.visit( program.root , [&]( A_Node& node , const bool exit ) {
return RDCFindConditionals_( node , exit , constConds );
} );
if ( !constConds.size( ) ) {
return false;
}
const auto ncc{ constConds.size( ) };
for ( auto i = 0u ; i < ncc ; i ++ ) {
auto const& cc{ constConds[ i ] };
auto& cn{ *cc.node };
T_InstrListNode* replacement;
oData.logger( [&](){
T_StringBuilder sb;
sb << "......... Conditional with constant argument at "
<< cn.location( );
return sb;
} , 4 );
if ( cn.hasCase( cc.value ) ) {
replacement = &cn.getCase( cc.value ).instructions( );
oData.logger( [&](){
T_StringBuilder sb;
sb << "Will replace with case for value "
<< cc.value << " ("
<< replacement->location( ) << ")";
return sb;
} , 5 );
} else if ( cn.hasDefaultCase( ) ) {
replacement = &cn.defaultCase( ).instructions( );
oData.logger( [&](){
T_StringBuilder sb;
sb << "Will replace with default case ("
<< replacement->location( ) << ")";
return sb;
} , 5 );
} else {
M_LOGSTR_( "Will delete whole instruction" , 5 );
replacement = nullptr;
}
( (T_InstrListNode&) cn.parent( ) ).replaceMultiple( cn , replacement );
}
oData.state = {};
return true;
}
/*----------------------------------------------------------------------------*/
bool RDCDeadStores_(
T_OpsParserOutput& program ,
T_OptData& oData
) noexcept
{
M_LOGSTR_( "...... Removing dead stores" , 3 );
oData.buildUseDefineChains( program );
T_AutoArray< A_InstructionNode* , 32 > deadSets;
for ( auto& udc : oData.varUDChains.values( ) ) {
const auto nDefs{ udc.defines.size( ) };
for ( auto i = 0u ; i < nDefs ; i ++ ) {
auto const& def{ udc.defines[ i ] };
if ( !def.refs.size( ) ) {
deadSets.add( oData.instructions[ def.node ].node );
}
}
}
if ( deadSets.empty( ) ) {
return false;
}
oData.logger( [&](){
T_StringBuilder sb;
sb << "Found " << deadSets.size( ) << " dead store candidates";
return sb;
} , 5 );
const auto nds{ deadSets.size( ) };
bool changesMade{ false };
for ( auto i = 0u ; i < nds ; i ++ ) {
auto* const instr{ deadSets[ i ] };
if ( instr->type( ) != A_Node::OP_CALL ) {
oData.logger( [&](){
T_StringBuilder sb;
sb << "Removing dead store at "
<< instr->location( );
return sb;
} , 4 );
( (T_InstrListNode&) instr->parent( ) ).replaceMultiple(
*instr , nullptr );
changesMade = true;
}
}
if ( changesMade ) {
oData.state = {};
}
return changesMade;
}
/*----------------------------------------------------------------------------*/
bool RDCUnusedLocals_(
T_OpsParserOutput& program ,
T_OptData& oData
) noexcept
{
M_LOGSTR_( "...... Removing unused locals" , 3 );
oData.buildUseDefineChains( program );
const auto nf{ program.root.nFunctions( ) };
bool changed{ false };
for ( auto f = 0u ; f < nf ; f ++ ) {
auto& func{ program.root.function( f ) };
bool restart{ false };
for ( auto l = 0u ; l < func.locals( ) ;
restart ? ( restart = false , l = 0 ) : l ++ ) {
auto const& ln{ func.getLocalName( l ) };
if ( func.isArgument( ln ) ) {
// TODO
continue;
}
const T_OptData::T_VarId vid{
ln , func.name( ) , false
};
if ( oData.varUDChains.contains( vid ) ) {
continue;
}
oData.logger( [&](){
T_StringBuilder sb;
sb << "Removing used local variable "
<< ln << " at "
<< func.getLocalLocation( l );
return sb;
} , 4 );
func.removeLocal( ln );
restart = true;
changed = true;
}
}
return changed;
}
} // namespace <anon>
/*----------------------------------------------------------------------------*/
bool opopt::RemoveDeadCode(
T_OpsParserOutput& program ,
T_OptData& oData ) noexcept
{
M_LOGSTR_( "... Eliminating dead code" , 2 );
bool didStuff{ false };
bool tryDeadStoresFirst{ oData.state & T_OptData::E_StateItem::UDCHAINS };
bool didStuffThisTime;
do {
if ( tryDeadStoresFirst ) {
tryDeadStoresFirst = false;
didStuff = RDCDeadStores_( program , oData );
didStuffThisTime = true;
continue;
}
didStuffThisTime = RDCConditionals_( program , oData )
|| RDCDeadStores_( program , oData )
|| RDCUnusedLocals_( program , oData );
didStuff = didStuff || didStuffThisTime;
} while ( didStuffThisTime );
if ( didStuff ) {
M_LOGSTR_( "...... Dead code removed" , 3 );
} else {
M_LOGSTR_( "...... No dead code found" , 3 );
}
return didStuff;
}
Reference in a new issue View git blame Copy permalink