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(); }