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 )
);
}
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 )
);
}
void ArrayAdapter::llvmThrowOutOfRangeException(
BasicBlockBuilder &basicBlockBuilder,
llvm::Value *itemDescRValue,
llvm::Value *indexRValue,
llvm::Value *sizeRValue,
llvm::Value *errorDescRValue
) const
{
RC::Handle<Context> context = basicBlockBuilder.getContext();
RC::ConstHandle<SizeAdapter> sizeAdapter = basicBlockBuilder.getManager()->getSizeAdapter();
RC::ConstHandle<StringAdapter> stringAdapter = basicBlockBuilder.getManager()->getStringAdapter();
RC::ConstHandle<ConstStringAdapter> constStringAdapter = basicBlockBuilder.getManager()->getConstStringAdapter();
std::vector<llvm::Type const *> argTypes;
argTypes.push_back( constStringAdapter->llvmRType( context ) );
argTypes.push_back( sizeAdapter->llvmRType( context ) );
argTypes.push_back( sizeAdapter->llvmRType( context ) );
argTypes.push_back( constStringAdapter->llvmRType( context ) );
llvm::FunctionType const *funcType = llvm::FunctionType::get( basicBlockBuilder->getVoidTy(), argTypes, false );
llvm::AttributeWithIndex AWI[1];
AWI[0] = llvm::AttributeWithIndex::get( ~0u, 0 /*llvm::Attribute::InlineHint | llvm::Attribute::NoUnwind*/ );
llvm::AttrListPtr attrListPtr = llvm::AttrListPtr::get( AWI, 1 );
std::string name = "__ThrowOutOfRangeException";
llvm::Function *func = llvm::cast<llvm::Function>( basicBlockBuilder.getModuleBuilder()->getFunction( name ) );
if ( !func )
{
ModuleBuilder &mb = basicBlockBuilder.getModuleBuilder();
func = llvm::cast<llvm::Function>( mb->getOrInsertFunction( name, funcType, attrListPtr ) );
func->setLinkage( llvm::GlobalValue::PrivateLinkage );
FunctionBuilder fb( mb, funcType, func );
llvm::Argument *itemRValue = fb[0];
itemRValue->setName( "itemRValue" );
itemRValue->addAttr( llvm::Attribute::NoCapture );
llvm::Argument *indexRValue = fb[1];
indexRValue->setName( "indexRValue" );
llvm::Argument *sizeRValue = fb[2];
sizeRValue->setName( "sizeRValue" );
llvm::Argument *errorDescRValue = fb[3];
errorDescRValue->setName( "errorDescRValue" );
errorDescRValue->addAttr( llvm::Attribute::NoCapture );
BasicBlockBuilder bbb( fb );
llvm::BasicBlock *entryBB = fb.createBasicBlock( "entry" );
bbb->SetInsertPoint( entryBB );
llvm::Value *errorMsg1PlusIndexPlusErrorMsg2PlusSizePlusErrorMsg3LValue;
{
Scope subScope( bbb.getScope() );
BasicBlockBuilder subBasicBlockBuilder( bbb, subScope );
llvm::BasicBlock *haveErrorDescBB = fb.createBasicBlock( "haveErrorDescBB" );
llvm::BasicBlock *noErrorDescBB = fb.createBasicBlock( "noErrorDescBB" );
llvm::BasicBlock *goBB = fb.createBasicBlock( "goBB" );
subBasicBlockBuilder->CreateCondBr(
subBasicBlockBuilder->CreateIsNotNull( errorDescRValue ),
haveErrorDescBB,
noErrorDescBB
);
subBasicBlockBuilder->SetInsertPoint( haveErrorDescBB );
llvm::Value *haveErrorDescConstStringRValue = errorDescRValue;
subBasicBlockBuilder->CreateBr( goBB );
subBasicBlockBuilder->SetInsertPoint( noErrorDescBB );
llvm::Value *noErrorDescConstStringRValue = constStringAdapter->llvmConst( subBasicBlockBuilder, "KL" );
subBasicBlockBuilder->CreateBr( goBB );
subBasicBlockBuilder->SetInsertPoint( goBB );
llvm::PHINode *errorDescConstStringRValue = subBasicBlockBuilder->CreatePHI( haveErrorDescConstStringRValue->getType(), "errorDescConstStringRValue" );
errorDescConstStringRValue->addIncoming( haveErrorDescConstStringRValue, haveErrorDescBB );
errorDescConstStringRValue->addIncoming( noErrorDescConstStringRValue, noErrorDescBB );
llvm::Value *errorMsg0RValue = stringAdapter->llvmCast(
subBasicBlockBuilder,
ExprValue( constStringAdapter, USAGE_RVALUE, context, errorDescConstStringRValue )
);
llvm::Value *errorMsgARValue = stringAdapter->llvmCast( subBasicBlockBuilder,
ExprValue( constStringAdapter, USAGE_RVALUE, context, constStringAdapter->llvmConst( subBasicBlockBuilder, ": " ) )
);
llvm::Value *errorMsgALValue = stringAdapter->llvmAlloca( subBasicBlockBuilder, "errorMsgA" );
stringAdapter->llvmInit( subBasicBlockBuilder, errorMsgALValue );
stringAdapter->llvmCallConcat(
subBasicBlockBuilder,
errorMsg0RValue,
errorMsgARValue,
errorMsgALValue
);
llvm::Value *errorMsgBRValue = stringAdapter->llvmCast( subBasicBlockBuilder,
ExprValue( constStringAdapter, USAGE_RVALUE, context, itemRValue )
);
llvm::Value *errorMsgBLValue = stringAdapter->llvmAlloca( subBasicBlockBuilder, "errorMsgB" );
stringAdapter->llvmInit( subBasicBlockBuilder, errorMsgBLValue );
stringAdapter->llvmCallConcat(
subBasicBlockBuilder,
stringAdapter->llvmLValueToRValue( subBasicBlockBuilder, errorMsgALValue ),
errorMsgBRValue,
errorMsgBLValue
);
stringAdapter->llvmDispose( subBasicBlockBuilder, errorMsgALValue );
llvm::Value *errorMsgCRValue = stringAdapter->llvmCast( subBasicBlockBuilder,
ExprValue( constStringAdapter, USAGE_RVALUE, context, constStringAdapter->llvmConst( subBasicBlockBuilder, " (" ) )
);
llvm::Value *errorMsgCLValue = stringAdapter->llvmAlloca( subBasicBlockBuilder, "errorMsgC" );
stringAdapter->llvmInit( subBasicBlockBuilder, errorMsgCLValue );
stringAdapter->llvmCallConcat(
subBasicBlockBuilder,
stringAdapter->llvmLValueToRValue( subBasicBlockBuilder, errorMsgBLValue ),
errorMsgCRValue,
errorMsgCLValue
);
stringAdapter->llvmDispose( subBasicBlockBuilder, errorMsgBLValue );
llvm::Value *indexStringRValue = stringAdapter->llvmCast(
subBasicBlockBuilder,
ExprValue( sizeAdapter, USAGE_RVALUE, context, indexRValue )
);
llvm::Value *errorMsg1PlusIndexLValue = stringAdapter->llvmAlloca( subBasicBlockBuilder, "errorMsg1PlusIndex" );
stringAdapter->llvmInit( subBasicBlockBuilder, errorMsg1PlusIndexLValue );
stringAdapter->llvmCallConcat(
subBasicBlockBuilder,
stringAdapter->llvmLValueToRValue( subBasicBlockBuilder, errorMsgCLValue ),
indexStringRValue,
errorMsg1PlusIndexLValue
);
stringAdapter->llvmDispose( subBasicBlockBuilder, errorMsgCLValue );
llvm::Value *errorMsg2RValue = stringAdapter->llvmCast(
subBasicBlockBuilder,
ExprValue( constStringAdapter, USAGE_RVALUE, context, constStringAdapter->llvmConst( subBasicBlockBuilder, ") out of range (" ) )
);
llvm::Value *errorMsg1PlusIndexPlusErrorMsg2LValue = stringAdapter->llvmAlloca( subBasicBlockBuilder, "errorMsg1PlusIndexPlusErrorMsg2" );
stringAdapter->llvmInit( subBasicBlockBuilder, errorMsg1PlusIndexPlusErrorMsg2LValue );
stringAdapter->llvmCallConcat(
subBasicBlockBuilder,
stringAdapter->llvmLValueToRValue( subBasicBlockBuilder, errorMsg1PlusIndexLValue ),
errorMsg2RValue,
errorMsg1PlusIndexPlusErrorMsg2LValue
);
stringAdapter->llvmDispose( subBasicBlockBuilder, errorMsg1PlusIndexLValue );
llvm::Value *sizeStringRValue = stringAdapter->llvmCast(
subBasicBlockBuilder,
ExprValue( sizeAdapter, USAGE_RVALUE, context, sizeRValue )
);
llvm::Value *errorMsg1PlusIndexPlusErrorMsg2PlusSizeLValue = stringAdapter->llvmAlloca( subBasicBlockBuilder, "errorMsg1PlusIndexPlusErrorMsg2PlusSize" );
stringAdapter->llvmInit( subBasicBlockBuilder, errorMsg1PlusIndexPlusErrorMsg2PlusSizeLValue );
stringAdapter->llvmCallConcat(
subBasicBlockBuilder,
stringAdapter->llvmLValueToRValue( subBasicBlockBuilder, errorMsg1PlusIndexPlusErrorMsg2LValue ),
sizeStringRValue,
errorMsg1PlusIndexPlusErrorMsg2PlusSizeLValue
);
stringAdapter->llvmDispose( subBasicBlockBuilder, errorMsg1PlusIndexPlusErrorMsg2LValue );
llvm::Value *errorMsg3RValue = stringAdapter->llvmCast(
subBasicBlockBuilder,
ExprValue( constStringAdapter, USAGE_RVALUE, context, constStringAdapter->llvmConst( subBasicBlockBuilder, ")" ) )
);
errorMsg1PlusIndexPlusErrorMsg2PlusSizePlusErrorMsg3LValue = stringAdapter->llvmAlloca( subBasicBlockBuilder, "errorMsg1PlusIndexPlusErrorMsg2PlusSizePlusErrorMsg3" );
stringAdapter->llvmInit( subBasicBlockBuilder, errorMsg1PlusIndexPlusErrorMsg2PlusSizePlusErrorMsg3LValue );
stringAdapter->llvmCallConcat(
subBasicBlockBuilder,
stringAdapter->llvmLValueToRValue( subBasicBlockBuilder, errorMsg1PlusIndexPlusErrorMsg2PlusSizeLValue ),
errorMsg3RValue,
errorMsg1PlusIndexPlusErrorMsg2PlusSizePlusErrorMsg3LValue
);
stringAdapter->llvmDispose( subBasicBlockBuilder, errorMsg1PlusIndexPlusErrorMsg2PlusSizeLValue );
subScope.llvmUnwind( subBasicBlockBuilder );
}
llvmThrowException( bbb, errorMsg1PlusIndexPlusErrorMsg2PlusSizePlusErrorMsg3LValue );
bbb->CreateRetVoid();
}
std::vector<llvm::Value *> args;
args.push_back( itemDescRValue );
args.push_back( indexRValue );
args.push_back( sizeRValue );
args.push_back( errorDescRValue );
basicBlockBuilder->CreateCall( func, args.begin(), args.end() );
}
ExprValue Function::llvmCreateCall( BasicBlockBuilder &basicBlockBuilder, std::vector<ExprValue> &args ) const
{
RC::Handle<Context> context = basicBlockBuilder.getContext();
if ( m_params.size() != args.size() )
throw Exception( "incorrect number of arguments (expected %u, actual %u)", (unsigned)m_params.size(), (unsigned)args.size() );
for ( size_t i=0; i<args.size(); ++i )
{
FunctionParam const ¶m = m_params[i];
ExprValue &arg = args[i];
if( !arg.isValid() )
throw Exception( "expression is invalid" );
try
{
arg.castTo( basicBlockBuilder, param.getExprType() );
}
catch ( Exception e )
{
throw Exception( "argument %u ('%s'): %s", (unsigned)(i + 1), param.getName().c_str(), (const char*)e.getDesc() );
}
}
llvm::Value *returnValue = 0;
if ( m_returnInfo.usesReturnLValue() )
{
RC::ConstHandle<Adapter> returnAdapter = m_returnInfo.getAdapter();
returnValue = returnAdapter->llvmAlloca( basicBlockBuilder, "resultLValue" );
returnAdapter->llvmInit( basicBlockBuilder, returnValue );
args.resize( args.size() + 1, ExprValue(context) );
for ( size_t i=1; i<args.size(); ++i )
args[args.size()-i] = args[args.size()-i-1];
args[0] = ExprValue( returnAdapter, USAGE_LVALUE, context, returnValue );
basicBlockBuilder.getScope().put( CG::VariableSymbol::Create( args[0] ) );
}
std::vector<llvm::Value *> argValues;
for ( size_t i=0; i<args.size(); ++i )
argValues.push_back( args[i].getValue() );
/*
llvm::BasicBlock *lpbb = basicBlockBuilder.getFunctionBuilder()->createBasicBlock( "lpbb" );
llvm::BasicBlock *normalbb = basicBlockBuilder.getFunctionBuilder()->createBasicBlock( "normalbb" );
llvm::Value *resultValue = basicBlockBuilder->CreateInvoke( m_llvmFunction, normalbb, lpbb, argValues );
if( !m_returnInfo.usesReturnLValue() )
returnValue = resultValue;
basicBlockBuilder->SetInsertPoint( lpbb );
basicBlockBuilder->CreateLandingPad();
basicBlockBuilder->CreateBr( normalbb );
basicBlockBuilder->SetInsertPoint( normalbb );
*/
llvm::Value *resultValue = basicBlockBuilder->CreateCall( m_llvmFunction, argValues );
if( !m_returnInfo.usesReturnLValue() )
returnValue = resultValue;
return CG::ExprValue( m_returnInfo.getExprType(), context, returnValue );
}
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 )
);
}