ClientWrap::ClientWrap( int compileGuarded )
: m_mutex("Node.js ClientWrap")
{
std::vector<std::string> pluginPaths;
Plug::AppendUserPaths( pluginPaths );
Plug::AppendGlobalPaths( pluginPaths );
CG::CompileOptions compileOptions;
if ( compileGuarded > -1 )
compileOptions.setGuarded( compileGuarded );
else
compileOptions.setGuarded( false );
RC::Handle<IO::Manager> ioManager = IOManager::Create( &ClientWrap::ScheduleAsyncUserCallback, this );
RC::Handle<DG::Context> dgContext = DG::Context::Create( ioManager, pluginPaths, compileOptions, true );
#if defined(FABRIC_MODULE_OPENCL)
OCL::registerTypes( dgContext->getRTManager() );
#endif
Plug::Manager::Instance()->loadBuiltInPlugins( pluginPaths, dgContext->getCGManager(), DG::Context::GetCallbackStruct() );
m_client = Client::Create( dgContext, this );
m_mainThreadTLS = true;
uv_async_init( uv_default_loop(), &m_uvAsync, &ClientWrap::AsyncCallback );
m_uvAsync.data = this;
//// uv_timer_init adds a loop reference. (That is, it calls uv_ref.) This
//// is not the behavior we want in Node. Timers should not increase the
//// ref count of the loop except when active.
//uv_unref( uv_default_loop() );
}
void ArrayProducerAdapter::llvmRelease( CG::BasicBlockBuilder &basicBlockBuilder, llvm::Value *rValue ) const
{
RC::Handle<Context> context = basicBlockBuilder.getContext();
std::vector<llvm::Type *> argTypes;
argTypes.push_back( llvmRType( context ) );
llvm::FunctionType *funcType = llvm::FunctionType::get( llvm::Type::getVoidTy( context->getLLVMContext() ), argTypes, false );
llvm::Constant *func = basicBlockBuilder.getModuleBuilder()->getOrInsertFunction( "__"+getCodeName()+"__Release", funcType );
basicBlockBuilder->CreateCall( func, rValue );
}
void ThreadPool::executeOneTaskIfPossible_CRITICAL_SECTION()
{
if ( m_tasks.empty() && m_idleTasks.empty() && (!m_isMainThread.get() || m_mainThreadTasks.empty()) )
m_stateCond.wait( m_stateMutex );
else
{
std::vector<Task *> *taskQueue;
if ( m_isMainThread.get() && !m_mainThreadTasks.empty() )
taskQueue = &m_mainThreadTasks;
else if ( !m_tasks.empty() )
taskQueue = &m_tasks;
else taskQueue = &m_idleTasks;
Task *task = taskQueue->back();
size_t index;
bool keep;
task->preExecute_CRITICAL_SECTION( index, keep );
if ( !keep )
taskQueue->pop_back();
m_stateMutex.release();
try
{
task->execute( index );
}
catch ( Exception e )
{
Util::SimpleString prefixedException = "Exception: " + e.getDesc();
RC::Handle<LogCollector> logCollector = task->getLogCollector();
if ( logCollector )
logCollector->add( prefixedException.data(), prefixedException.length() );
}
catch ( ... )
{
static Util::SimpleString const genericException = "Exception (unknown)";
RC::Handle<LogCollector> logCollector = task->getLogCollector();
if ( logCollector )
logCollector->add( genericException.data(), genericException.length() );
}
m_stateMutex.acquire();
task->postExecute_CRITICAL_SECTION();
if ( task->completed_CRITICAL_SECTION() )
{
void (*finishedCallback)( void * ) = task->getFinishedCallback();
if ( finishedCallback )
finishedCallback( task->getFinishedUserdata() );
task->dispose();
// [pzion 20101108] Must wake waiter because they might be
// waiting on the task completion
m_stateCond.broadcast();
}
}
}
void ValueProducerWrapper::JSONExecProduceAsyncFinishedCallback( void *userdata )
{
JSONProduceAsyncUserdata *jsonProduceAsyncUserdata = static_cast<JSONProduceAsyncUserdata *>( userdata );
RC::Handle<ValueProducerWrapper> valueProducerWrapper = jsonProduceAsyncUserdata->valueProducerWrapper;
Util::SimpleString *notifyJSONArg = jsonProduceAsyncUserdata->notifyJSONArg;
delete jsonProduceAsyncUserdata;
valueProducerWrapper->jsonNotify( "produceAsyncFinished", 20, notifyJSONArg );
delete notifyJSONArg;
}
void ArrayProducerAdapter::llvmDefaultAssign( BasicBlockBuilder &basicBlockBuilder, llvm::Value *dstLValue, llvm::Value *srcRValue ) const
{
RC::Handle<Context> context = basicBlockBuilder.getContext();
std::vector<llvm::Type *> argTypes;
argTypes.push_back( llvmRType( context ) );
argTypes.push_back( llvmLType( context ) );
llvm::FunctionType *funcType = llvm::FunctionType::get( llvm::Type::getVoidTy( context->getLLVMContext() ), argTypes, false );
llvm::Constant *func = basicBlockBuilder.getModuleBuilder()->getOrInsertFunction( "__"+getCodeName()+"__DefaultAssign", funcType );
basicBlockBuilder->CreateCall2( func, srcRValue, dstLValue );
}
void ArrayProducerAdapter::Produce0( void const *_adapter, void const *arrayProducerRValue, void *dstLValue )
{
MR::ArrayProducer *arrayProducer = *static_cast<MR::ArrayProducer * const *>( arrayProducerRValue );
if ( arrayProducer )
{
RC::Handle<MR::ArrayProducer::ComputeState> computeState = arrayProducer->createComputeState();
size_t count = computeState->getCount();
RC::ConstHandle<RT::VariableArrayDesc> elementVariableArrayDesc = RC::ConstHandle<RT::VariableArrayDesc>::StaticCast( static_cast<ArrayProducerAdapter const *>( _adapter )->m_elementVariableArrayAdapter->getDesc() );
elementVariableArrayDesc->setNumMembers( dstLValue, count );
void *firstMemberData = elementVariableArrayDesc->getMutableMemberData( dstLValue, 0 );
computeState->produce( 0, count, firstMemberData );
}
}
RC::Handle<ResourceLoadNode> ResourceLoadNode::Create( std::string const &name, RC::Handle<Context> const &context )
{
RC::Handle<ResourceLoadNode> resourceLoadNode = new ResourceLoadNode( name, context );
Util::SimpleString json;
{
JSON::Encoder jg( &json );
resourceLoadNode->jsonDesc( jg );
}
resourceLoadNode->jsonNotifyDelta( json );
return resourceLoadNode;
}
ArrayOutputOperator::ArrayOutputOperator(
RC::ConstHandle<Executable> const &executable,
RC::ConstHandle<AST::Operator> const &astOperator,
void (*functionPtr)(...)
)
: m_executable( executable )
{
if ( astOperator )
{
RC::Handle<CG::Manager> cgManager = executable->getCGManager();
RC::ConstHandle<AST::ParamVector> params = astOperator->getParams( cgManager );
size_t numParams = params->size();
if ( numParams < 1 || numParams > 4 )
throw GetPrototypeException();
RC::ConstHandle<AST::Param> valueParam = params->get(0);
if ( valueParam->getUsage() != CG::USAGE_LVALUE )
throw GetPrototypeException();
RC::ConstHandle<RT::Desc> valueDesc = valueParam->getAdapter( cgManager )->getDesc();
RC::ConstHandle<RT::Desc> sharedDesc;
if ( numParams >= 2 )
{
RC::ConstHandle<AST::Param> indexParam = params->get(1);
if ( indexParam->getUsage() != CG::USAGE_RVALUE
|| !indexParam->getAdapter( cgManager )->isEquivalentTo( cgManager->getSizeAdapter() )
)
throw GetPrototypeException();
if ( numParams >= 3 )
{
RC::ConstHandle<AST::Param> countParam = params->get(2);
if ( countParam->getUsage() != CG::USAGE_RVALUE
|| !countParam->getAdapter( cgManager )->isEquivalentTo( cgManager->getSizeAdapter() )
)
throw GetPrototypeException();
if ( numParams >= 4 )
{
RC::ConstHandle<AST::Param> sharedParam = params->get(3);
if ( sharedParam->getUsage() != CG::USAGE_RVALUE )
throw GetPrototypeException();
sharedDesc = sharedParam->getAdapter( cgManager )->getDesc();
}
}
}
init( functionPtr, numParams, valueDesc, sharedDesc );
}
}
CG::ExprValue CreateConstValue::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" );
CG::ExprType childExprType = m_child->getExprType( basicBlockBuilder );
RC::ConstHandle<CG::ValueProducerAdapter> valueProducerAdapter = basicBlockBuilder.getManager()->getValueProducerOf( childExprType.getAdapter() );
RC::Handle<CG::Context> context = basicBlockBuilder.getContext();
llvm::LLVMContext &llvmContext = context->getLLVMContext();
std::vector<llvm::Type const *> argTypes;
argTypes.push_back( llvm::Type::getInt8PtrTy( llvmContext ) );
argTypes.push_back( llvm::Type::getInt8PtrTy( llvmContext ) );
argTypes.push_back( valueProducerAdapter->llvmLType( context ) );
llvm::FunctionType const *funcType = llvm::FunctionType::get( llvm::Type::getVoidTy( llvmContext ), argTypes, false );
llvm::Constant *func = basicBlockBuilder.getModuleBuilder()->getOrInsertFunction( "__MR_CreateConstValue", funcType );
CG::ExprValue childExprRValue = m_child->buildExprValue( basicBlockBuilder, CG::USAGE_RVALUE, lValueErrorDesc );
llvm::Value *childExprLValue = childExprType.getAdapter()->llvmRValueToLValue( basicBlockBuilder, childExprRValue.getValue() );
llvm::Value *resultLValue = valueProducerAdapter->llvmAlloca( basicBlockBuilder, "result" );
valueProducerAdapter->llvmInit( basicBlockBuilder, resultLValue );
basicBlockBuilder.getScope().put(
CG::VariableSymbol::Create(
CG::ExprValue(
valueProducerAdapter,
CG::USAGE_LVALUE,
context,
resultLValue
)
)
);
basicBlockBuilder->CreateCall3(
func,
valueProducerAdapter->llvmAdapterPtr( basicBlockBuilder ),
basicBlockBuilder->CreatePointerCast(
childExprLValue,
llvm::Type::getInt8PtrTy( llvmContext )
),
resultLValue
);
return CG::ExprValue(
valueProducerAdapter,
CG::USAGE_RVALUE,
context,
valueProducerAdapter->llvmLValueToRValue( basicBlockBuilder, resultLValue )
);
}
void ArrayProducerAdapter::llvmProduce0(
CG::BasicBlockBuilder &basicBlockBuilder,
llvm::Value *arrayProducerRValue,
llvm::Value *dstLValue
) const
{
RC::Handle<Context> context = basicBlockBuilder.getContext();
std::vector<llvm::Type *> argTypes;
argTypes.push_back( basicBlockBuilder->getInt8PtrTy() );
argTypes.push_back( llvmRType( context ) );
argTypes.push_back( m_elementVariableArrayAdapter->llvmLType( context ) );
llvm::FunctionType *funcType = llvm::FunctionType::get( llvm::Type::getVoidTy( context->getLLVMContext() ), argTypes, false );
llvm::Constant *func = basicBlockBuilder.getModuleBuilder()->getOrInsertFunction( "__"+getCodeName()+"__Produce0", funcType );
basicBlockBuilder->CreateCall3( func, llvmAdapterPtr( basicBlockBuilder ), arrayProducerRValue, dstLValue );
}
void ConstString::registerTypes( RC::Handle<CG::Manager> const &cgManager, CG::Diagnostics &diagnostics ) const
{
std::string unquotedValue;
try
{
unquotedValue = Util::parseQuotedString( m_value );
}
catch ( Exception e )
{
throw CG::Error( getLocation(), e.getDesc() + "(" + m_value + ")" );
}
cgManager->getConstStringAdapter();
cgManager->getStringAdapter();
}
CG::ExprValue CreateValueCache::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();
CG::ExprType inputExprType = m_input->getExprType( basicBlockBuilder );
if ( !RT::isValueProducer( inputExprType.getAdapter()->getType() ) )
throw CG::Error( getLocation(), "input must be a value producer" );
RC::ConstHandle<CG::ValueProducerAdapter> valueProducerAdapter = RC::ConstHandle<CG::ValueProducerAdapter>::StaticCast( inputExprType.getAdapter() );
RC::ConstHandle<CG::Adapter> valueAdapter = valueProducerAdapter->getValueAdapter();
CG::ExprValue inputExprRValue = m_input->buildExprValue( basicBlockBuilder, CG::USAGE_RVALUE, lValueErrorDesc );
llvm::Value *resultLValue = valueProducerAdapter->llvmAlloca( basicBlockBuilder, "result" );
valueProducerAdapter->llvmInit( basicBlockBuilder, resultLValue );
basicBlockBuilder.getScope().put(
CG::VariableSymbol::Create(
CG::ExprValue(
valueProducerAdapter,
CG::USAGE_LVALUE,
context,
resultLValue
)
)
);
std::vector<llvm::Type const *> argTypes;
argTypes.push_back( valueProducerAdapter->llvmLType( context ) );
argTypes.push_back( valueProducerAdapter->llvmLType( context ) );
llvm::FunctionType const *funcType = llvm::FunctionType::get( llvm::Type::getVoidTy( llvmContext ), argTypes, false );
llvm::Constant *func = basicBlockBuilder.getModuleBuilder()->getOrInsertFunction( "__MR_CreateValueCache", funcType );
basicBlockBuilder->CreateCall2(
func,
inputExprRValue.getValue(),
resultLValue
);
return CG::ExprValue(
valueProducerAdapter,
CG::USAGE_RVALUE,
context,
valueProducerAdapter->llvmLValueToRValue( basicBlockBuilder, resultLValue )
);
}
ResourceLoadNode::ResourceLoadNode( std::string const &name, RC::Handle<Context> const &context )
: Node( name, context )
, m_fabricResourceStreamData( context->getRTManager() )
, m_firstEvalAfterLoad( false )
, m_keepMemoryCache( false )
, m_asFile( false )
, m_inProgress( false )
, m_streamGeneration( 0 )
, m_resourceManagerWeak( context->getIOManager()->getResourceManager() )
{
RC::ConstHandle<RT::StringDesc> stringDesc = context->getRTManager()->getStringDesc();
RC::ConstHandle<RT::BooleanDesc> booleanDesc = context->getRTManager()->getBooleanDesc();
addMember( "url", stringDesc, stringDesc->getDefaultData() );
addMember( "resource", m_fabricResourceStreamData.getDesc(), m_fabricResourceStreamData.getDesc()->getDefaultData() );
addMember( "keepMemoryCache", booleanDesc, booleanDesc->getDefaultData() );
addMember( "storeDataAsFile", booleanDesc, booleanDesc->getDefaultData() );
}
void RegisterFabricResourceType( RC::Handle<RT::Manager> const &rtManager )
{
RT::StructMemberInfoVector memberInfos;
RC::ConstHandle<RT::StringDesc> stringDesc = rtManager->getStringDesc();
memberInfos.resize(NB_FABRIC_RESOURCE_MEMBERS);
memberInfos[FABRIC_RESOURCE_DATA_MEMBER_INDEX].name = "data";
memberInfos[FABRIC_RESOURCE_DATA_MEMBER_INDEX].desc = rtManager->getVariableArrayOf( rtManager->getByteDesc() );
memberInfos[FABRIC_RESOURCE_MIMETYPE_MEMBER_INDEX].name = "mimeType";
memberInfos[FABRIC_RESOURCE_MIMETYPE_MEMBER_INDEX].desc = stringDesc;
memberInfos[FABRIC_RESOURCE_EXTENSION_MEMBER_INDEX].name = "extension";
memberInfos[FABRIC_RESOURCE_EXTENSION_MEMBER_INDEX].desc = stringDesc;
memberInfos[FABRIC_RESOURCE_URL_MEMBER_INDEX].name = "url";
memberInfos[FABRIC_RESOURCE_URL_MEMBER_INDEX].desc = stringDesc;
memberInfos[FABRIC_RESOURCE_DATAEXTERNALLOCATION_MEMBER_INDEX].name = "dataExternalLocation";
memberInfos[FABRIC_RESOURCE_DATAEXTERNALLOCATION_MEMBER_INDEX].desc = stringDesc;
rtManager->registerStruct( "FabricResource", memberInfos, 0 );
}
void MemberDecl::registerTypes( RC::Handle<CG::Manager> const &cgManager, CG::Diagnostics &diagnostics ) const
{
try
{
cgManager->getAdapter( m_type );
}
catch ( Exception e )
{
addError( diagnostics, e );
}
}
void IOManager::setContext( RC::Handle<Context> const &context )
{
m_context = context.ptr();
}
std::string AssignOpImpl::getPencilKey( RC::Handle<CG::Manager> const &cgManager ) const
{
RC::ConstHandle<CG::Adapter> thisAdapter = cgManager->getAdapter( m_thisTypeName );
return CG::AssignOpPencilKey( thisAdapter, m_assignOpType );
}
std::string AssignOpImpl::getDesc( RC::Handle<CG::Manager> const &cgManager ) const
{
RC::ConstHandle<CG::Adapter> thisAdapter = cgManager->getAdapter( m_thisTypeName );
RC::ConstHandle<CG::Adapter> thatAdapter = cgManager->getAdapter( m_rhs->getType() );
return CG::AssignOpFullDesc( thisAdapter, m_assignOpType, thatAdapter );
}
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 )
);
}
void ConstFloat::registerTypes( RC::Handle<CG::Manager> const &cgManager, CG::Diagnostics &diagnostics ) const
{
cgManager->getFloat64Adapter();
}