// We redefine the visitor of Nodecl::FunctionCode because we need to
// visit first the internal functions and later the statements
void LoweringVisitor::visit(const Nodecl::FunctionCode& function_code)
{
Nodecl::List stmts = function_code.get_statements().as<Nodecl::List>();
// First, traverse nested functions
for (Nodecl::List::iterator it = stmts.begin();
it != stmts.end();
it++)
{
if (it->is<Nodecl::FunctionCode>())
{
walk(*it);
}
}
// Second, remaining statements
for (Nodecl::List::iterator it = stmts.begin();
it != stmts.end();
it++)
{
if (!it->is<Nodecl::FunctionCode>())
{
walk(*it);
}
}
}
void NeonVectorBackend::visit(const Nodecl::FunctionCode& n)
{
bool contains_vector_nodes = TL::Vectorization::Utils::contains_vector_nodes(n);
if (contains_vector_nodes)
{
// Initialize analisys
TL::Optimizations::canonicalize_and_fold(
n, /*_fast_math_enabled*/ false);
walk(n.get_statements());
}
}
void VectorizerVisitorFunction::visit(const Nodecl::FunctionCode& function_code)
{
// Set up enviroment
_environment._external_scope =
function_code.retrieve_context();
_environment._local_scope_list.push_back(
function_code.get_statements().retrieve_context());
// Get analysis info
Vectorizer::initialize_analysis(function_code);
// Push FunctionCode as scope for analysis
_environment._analysis_scopes.push_back(function_code);
//Vectorize function type and parameters
TL::Symbol vect_func_sym = function_code.get_symbol();
TL::Type func_type = vect_func_sym.get_type();
TL::ObjectList<TL::Symbol> parameters = vect_func_sym.get_function_parameters();
TL::ObjectList<TL::Type> parameters_type = func_type.parameters();
TL::ObjectList<TL::Type> parameters_vector_type;
TL::ObjectList<TL::Type>::iterator it_type;
TL::ObjectList<TL::Symbol>::iterator it_param_sym;
for(it_param_sym = parameters.begin(), it_type = parameters_type.begin();
it_type != parameters_type.end();
it_param_sym++, it_type++)
{
TL::Type sym_type = get_qualified_vector_to((*it_type), _environment._vector_length);
// Set type to parameter TL::Symbol
(*it_param_sym).set_type(sym_type);
parameters_vector_type.append(sym_type);
}
if(_masked_version)
{
TL::Scope scope = vect_func_sym.get_related_scope();
// Create mask parameter
TL::Symbol mask_sym = scope.new_symbol("__mask_param");
mask_sym.get_internal_symbol()->kind = SK_VARIABLE;
mask_sym.get_internal_symbol()->entity_specs.is_user_declared = 1;
mask_sym.set_type(TL::Type::get_mask_type(_environment._mask_size));
symbol_set_as_parameter_of_function(mask_sym.get_internal_symbol(),
vect_func_sym.get_internal_symbol(),
parameters.size());
// Add mask symbol and type to parameters
parameters.append(mask_sym);
parameters_vector_type.append(mask_sym.get_type());
vect_func_sym.set_related_symbols(parameters);
// Take care of default_argument_info_t*
//TODO: Move this into a function
{
int num_parameters =
vect_func_sym.get_internal_symbol()->entity_specs.num_parameters;
default_argument_info_t** default_argument_info =
vect_func_sym.get_internal_symbol()->entity_specs.default_argument_info;
num_parameters++;
default_argument_info = (default_argument_info_t**)xrealloc(default_argument_info,
num_parameters * sizeof(*default_argument_info));
default_argument_info[num_parameters-1] = NULL;
vect_func_sym.get_internal_symbol()->entity_specs.default_argument_info = default_argument_info;
vect_func_sym.get_internal_symbol()->entity_specs.num_parameters = num_parameters;
}
Nodecl::Symbol mask_nodecl_sym =
mask_sym.make_nodecl(true, function_code.get_locus());
_environment._mask_list.push_back(mask_nodecl_sym);
}
else // Add MaskLiteral to mask_list
{
Nodecl::MaskLiteral all_one_mask =
Nodecl::MaskLiteral::make(
TL::Type::get_mask_type(_environment._mask_size),
const_value_get_minus_one(_environment._mask_size, 1),
make_locus("", 0, 0));
_environment._mask_list.push_back(all_one_mask);
}
vect_func_sym.set_type(get_qualified_vector_to(func_type.returns(),
_environment._vector_length).get_function_returning(parameters_vector_type));
// Vectorize function statements
VectorizerVisitorStatement visitor_stmt(_environment);
visitor_stmt.walk(function_code.get_statements());
// Add final return if multi-return function
if (_environment._function_return.is_valid())
{
// Return value
Nodecl::Symbol return_value= _environment._function_return.make_nodecl(
false, function_code.get_locus());
// VectorizerVisitorExpression visitor_sym(_environment);
// visitor_sym.walk(return_value);
// Return value at the end of the Compound Statement
Nodecl::ReturnStatement return_stmt =
Nodecl::ReturnStatement::make(return_value, function_code.get_locus());
function_code.get_statements().as<Nodecl::Context>().get_in_context().as<Nodecl::List>()
.front().as<Nodecl::CompoundStatement>().get_statements()
.as<Nodecl::List>().append(return_stmt);
}
_environment._analysis_scopes.pop_back();
_environment._mask_list.pop_back();
// Analysis in functions won't be reused anywhere so it must be freed
Vectorizer::finalize_analysis();
}
