ValueGenerator::ValueGenerator(
RC::ConstHandle<ValueOutputOperator> const &operator_,
RC::ConstHandle<ValueProducer> const &shared
)
: m_operator( operator_ )
, m_shared( shared )
{
RC::ConstHandle<RT::Desc> operatorValueDesc = m_operator->getValueDesc();
if ( !operatorValueDesc )
throw Exception("operator is invalid");
m_valueDesc = operatorValueDesc;
RC::ConstHandle<RT::Desc> operatorSharedDesc = m_operator->getSharedDesc();
if ( operatorSharedDesc )
{
RC::ConstHandle<RT::Desc> sharedValueDesc = m_shared? m_shared->getValueDesc(): RC::ConstHandle<RT::Desc>();
if ( !sharedValueDesc )
throw Exception( "operator requires a shared value but no shared value producer is provided" );
if ( !sharedValueDesc->isEquivalentTo( operatorSharedDesc ) )
throw Exception(
"shared value type ("
+ _(sharedValueDesc->getUserName())
+ ") is not equivalent to operator shared type ("
+ _(operatorSharedDesc->getUserName()) + ")"
);
}
}
std::string BinOpFullDesc(
RC::ConstHandle<Adapter> const &returnAdapter,
BinOpType type,
RC::ConstHandle<CG::Adapter> const &lhsAdapter,
RC::ConstHandle<CG::Adapter> const &rhsAdapter
)
{
std::string result = "function ";
if ( returnAdapter )
result += returnAdapter->getUserName() + " ";
result += binOpUserName( type ) + "(" + lhsAdapter->getUserName() + ", " + rhsAdapter->getUserName() + ")";
return result;
}
std::string ConstructorQueryDesc(
RC::ConstHandle<CG::Adapter> const &thisAdapter,
AdapterVector const ¶mAdapters
)
{
return "constructor " + thisAdapter->getUserName() + DescParams( paramAdapters );
}
std::string BinOpQueryDesc(
BinOpType type,
RC::ConstHandle<CG::Adapter> const &lhsAdapter,
RC::ConstHandle<CG::Adapter> const &rhsAdapter
)
{
return "binary operation " + lhsAdapter->getUserName() + " " + binOpUserName( type ) + " " + rhsAdapter->getUserName();
}
std::string AssignOpQueryDesc(
RC::ConstHandle<CG::Adapter> const &thisAdapter,
AssignOpType type,
RC::ConstHandle<CG::Adapter> const &thatAdapter
)
{
return "assignment operator " + thisAdapter->getUserName() + " " + assignOpUserName( type ) + " " + thatAdapter->getUserName();
}
std::string AssignOpFullDesc(
RC::ConstHandle<CG::Adapter> const &thisAdapter,
AssignOpType type,
RC::ConstHandle<CG::Adapter> const &thatAdapter
)
{
return "function " + thisAdapter->getUserName() + "." + assignOpUserName( type ) + "(" + thatAdapter->getUserName() + ")";
}
std::string FunctionFullDesc(
RC::ConstHandle<Adapter> const &returnAdapter,
std::string const &functionName,
ExprTypeVector const ¶mTypes
)
{
std::string result = "function ";
if ( returnAdapter )
result += returnAdapter->getUserName() + " ";
result += functionName + DescParams( paramTypes );
return result;
}
std::string UniOpFullDesc(
RC::ConstHandle<Adapter> const &returnAdapter,
UniOpType type,
ExprType const &thisExprType
)
{
std::string result = "function ";
if ( returnAdapter )
result += returnAdapter->getUserName() + " ";
result += uniOpUserName( type ) + DescParams( ExprTypeVector( thisExprType ) );
return result;
}
std::string MethodFullDesc(
RC::ConstHandle<Adapter> const &returnAdapter,
CG::ExprType const &thisType,
std::string const &methodName,
CG::ExprTypeVector const ¶mTypes
)
{
std::string result = "function ";
if ( returnAdapter )
result += returnAdapter->getUserName() + " ";
result += thisType.getUserName() + "." + methodName + DescParams( paramTypes );
return result;
}
ValueMap::ValueMap(
RC::ConstHandle<ValueProducer> const &input,
RC::ConstHandle<ValueIOOperator> const &operator_,
RC::ConstHandle<ValueProducer> const &shared
)
: m_input( input )
, m_operator( operator_ )
, m_shared( shared )
{
RC::ConstHandle<RT::Desc> inputValueDesc = input->getValueDesc();
if ( !inputValueDesc )
throw Exception("input is invalid");
RC::ConstHandle<RT::Desc> operatorInputDesc = operator_->getInputDesc();
if ( !operatorInputDesc )
throw Exception("operator is invalid");
if ( !operatorInputDesc->isEquivalentTo( inputValueDesc ) )
throw Exception(
"input value type ("
+ _(inputValueDesc->getUserName())
+ ") is not equivalent to value map operator input type ("
+ _(operatorInputDesc->getUserName()) + ")"
);
RC::ConstHandle<RT::Desc> operatorSharedDesc = operator_->getSharedDesc();
if ( operatorSharedDesc )
{
RC::ConstHandle<RT::Desc> sharedValueDesc = shared->getValueDesc();
if ( !sharedValueDesc )
throw Exception( "operator requires a shared value but no shared value producer is provided" );
if ( !sharedValueDesc->isEquivalentTo( operatorSharedDesc ) )
throw Exception(
"shared value type ("
+ _(sharedValueDesc->getUserName())
+ ") is not equivalent to value map operator shared type ("
+ _(operatorSharedDesc->getUserName()) + ")"
);
}
}
std::string DestructorDesc( RC::ConstHandle<CG::Adapter> const &thisAdapter )
{
return "function ~" + thisAdapter->getUserName();
}
CG::ExprValue CreateArrayGenerator::buildExprValue( CG::BasicBlockBuilder &basicBlockBuilder, CG::Usage usage, std::string const &lValueErrorDesc ) const
{
if ( usage == CG::USAGE_LVALUE )
throw Exception( "cannot be used as l-values" );
RC::Handle<CG::Context> context = basicBlockBuilder.getContext();
llvm::LLVMContext &llvmContext = context->getLLVMContext();
RC::ConstHandle<CG::SizeAdapter> sizeAdapter = basicBlockBuilder.getManager()->getSizeAdapter();
RC::ConstHandle<CG::Symbol> operatorSymbol = basicBlockBuilder.getScope().get( m_operatorName );
if ( !operatorSymbol )
throw CG::Error( getLocation(), _(m_operatorName) + ": operator not found" );
if ( !operatorSymbol->isPencil() )
throw CG::Error( getLocation(), _(m_operatorName) + ": not an operator" );
RC::ConstHandle<CG::PencilSymbol> pencil = RC::ConstHandle<CG::PencilSymbol>::StaticCast( operatorSymbol );
CG::Function const *function = pencil->getUniqueFunction( getLocation(), "operator " + _(m_operatorName) );
std::vector<CG::FunctionParam> const &operatorParams = function->getParams();
if ( operatorParams.size() < 1 )
throw MR::ArrayGeneratorOperator::GetPrototypeException();
CG::ExprType countExprType = m_count->getExprType( basicBlockBuilder );
if ( !RT::isValueProducer( countExprType.getAdapter()->getType() ) )
throw CG::Error( getLocation(), "count must be a value producer" );
RC::ConstHandle<CG::ValueProducerAdapter> countValueProducerAdapter = RC::ConstHandle<CG::ValueProducerAdapter>::StaticCast( countExprType.getAdapter() );
RC::ConstHandle<CG::Adapter> countAdapter = countValueProducerAdapter->getValueAdapter();
if ( countAdapter != sizeAdapter )
throw CG::Error( getLocation(), "count value type must be 'Size'" );
CG::ExprValue countValueProducerExprValue = m_count->buildExprValue( basicBlockBuilder, CG::USAGE_RVALUE, lValueErrorDesc );
if ( operatorParams[0].getUsage() != CG::USAGE_LVALUE )
throw CG::Error( getLocation(), "operator value parameter must be an 'io' parameter" );
RC::ConstHandle<CG::Adapter> outputAdapter = operatorParams[0].getAdapter();
RC::ConstHandle<CG::ArrayProducerAdapter> outputArrayProducerAdapter = basicBlockBuilder.getManager()->getArrayProducerOf( outputAdapter );
llvm::Value *resultLValue = outputArrayProducerAdapter->llvmAlloca( basicBlockBuilder, "result" );
outputArrayProducerAdapter->llvmInit( basicBlockBuilder, resultLValue );
basicBlockBuilder.getScope().put(
CG::VariableSymbol::Create(
CG::ExprValue(
outputArrayProducerAdapter,
CG::USAGE_LVALUE,
context,
resultLValue
)
)
);
bool needCall = true;
if ( operatorParams.size() >= 2 )
{
if ( operatorParams[1].getAdapter() != sizeAdapter )
throw CG::Error( getLocation(), "operator index parameter type (" + operatorParams[1].getAdapter()->getUserName() + ") must be 'Size'" );
if ( operatorParams[1].getUsage() != CG::USAGE_RVALUE )
throw CG::Error( getLocation(), "operator index parameter must be an 'in' parameter" );
if ( operatorParams.size() >= 3 )
{
if ( operatorParams[2].getAdapter() != sizeAdapter )
throw CG::Error( getLocation(), "operator index parameter type (" + operatorParams[2].getAdapter()->getUserName() + ") must be 'Size'" );
if ( operatorParams[2].getUsage() != CG::USAGE_RVALUE )
throw CG::Error( getLocation(), "operator index parameter must be an 'in' parameter" );
if ( operatorParams.size() >= 4 )
{
if ( operatorParams.size() > 4 )
throw MR::ArrayGeneratorOperator::GetPrototypeException();
if ( !m_shared )
throw CG::Error( getLocation(), "operator takes a shared value but no shared value is provided" );
CG::ExprType sharedExprType = m_shared->getExprType( basicBlockBuilder );
if ( !RT::isValueProducer( sharedExprType.getAdapter()->getType() ) )
throw CG::Error( getLocation(), "shared value must be a value producer" );
RC::ConstHandle<CG::ValueProducerAdapter> sharedValueProducerAdapter = RC::ConstHandle<CG::ValueProducerAdapter>::StaticCast( sharedExprType.getAdapter() );
RC::ConstHandle<CG::Adapter> sharedAdapter = sharedValueProducerAdapter->getValueAdapter();
if ( operatorParams[3].getAdapter() != sharedAdapter )
throw CG::Error( getLocation(), "operator shared value parameter type (" + operatorParams[3].getAdapter()->getUserName() + ") does not match shared value type (" + sharedAdapter->getUserName() + ")" );
if ( operatorParams[3].getUsage() != CG::USAGE_RVALUE )
throw CG::Error( getLocation(), "operator shared value parameter must be an 'in' parameter" );
CG::ExprValue sharedExprRValue = m_shared->buildExprValue( basicBlockBuilder, CG::USAGE_RVALUE, lValueErrorDesc );
std::vector<llvm::Type const *> argTypes;
argTypes.push_back( llvm::Type::getInt8PtrTy( llvmContext ) ); // function
argTypes.push_back( sizeAdapter->llvmRType( context ) ); // numParams
argTypes.push_back( countValueProducerAdapter->llvmLType( context ) ); // count value producer
argTypes.push_back( sharedValueProducerAdapter->llvmLType( context ) ); // shared value producer
argTypes.push_back( llvm::Type::getInt8PtrTy( llvmContext ) ); // output array producer adapter
argTypes.push_back( outputArrayProducerAdapter->llvmLType( context ) ); // output array producer
llvm::FunctionType const *funcType = llvm::FunctionType::get( llvm::Type::getVoidTy( llvmContext ), argTypes, false );
llvm::Constant *func = basicBlockBuilder.getModuleBuilder()->getOrInsertFunction( "__MR_CreateArrayGenerator_4", funcType );
std::vector<llvm::Value *> args;
args.push_back( basicBlockBuilder->CreateBitCast(
function->getLLVMFunction(),
llvm::Type::getInt8PtrTy( llvmContext )
) );
args.push_back( sizeAdapter->llvmConst( context, operatorParams.size() ) );
args.push_back( countValueProducerExprValue.getValue() );
args.push_back( sharedExprRValue.getValue() );
args.push_back( outputArrayProducerAdapter->llvmAdapterPtr( basicBlockBuilder ) );
args.push_back( resultLValue );
basicBlockBuilder->CreateCall( func, args.begin(), args.end() );
needCall = false;
}
}
}
if ( needCall )
{
std::vector<llvm::Type const *> argTypes;
argTypes.push_back( llvm::Type::getInt8PtrTy( llvmContext ) ); // function
argTypes.push_back( sizeAdapter->llvmRType( context ) ); // numParams
argTypes.push_back( countValueProducerAdapter->llvmLType( context ) ); // count value producer
argTypes.push_back( llvm::Type::getInt8PtrTy( llvmContext ) ); // output array producer adapter
argTypes.push_back( outputArrayProducerAdapter->llvmLType( context ) ); // output array producer
llvm::FunctionType const *funcType = llvm::FunctionType::get( llvm::Type::getVoidTy( llvmContext ), argTypes, false );
llvm::Constant *func = basicBlockBuilder.getModuleBuilder()->getOrInsertFunction( "__MR_CreateArrayGenerator_3", funcType );
std::vector<llvm::Value *> args;
args.push_back( basicBlockBuilder->CreateBitCast(
function->getLLVMFunction(),
llvm::Type::getInt8PtrTy( llvmContext )
) );
args.push_back( sizeAdapter->llvmConst( context, operatorParams.size() ) );
args.push_back( countValueProducerExprValue.getValue() );
args.push_back( outputArrayProducerAdapter->llvmAdapterPtr( basicBlockBuilder ) );
args.push_back( resultLValue );
basicBlockBuilder->CreateCall( func, args.begin(), args.end() );
}
return CG::ExprValue(
outputArrayProducerAdapter,
CG::USAGE_RVALUE,
context,
outputArrayProducerAdapter->llvmLValueToRValue( basicBlockBuilder, resultLValue )
);
}
