unroll.c File Reference

#include "genC.h"
#include "linear.h"
#include "ri.h"
#include "effects.h"
#include "resources.h"
#include "misc.h"
#include "ri-util.h"
#include "effects-util.h"
#include "pipsdbm.h"
#include "effects-generic.h"
#include "transformations.h"
#include "control.h"
#include "sac.h"
#include "hyperplane.h"
#include "properties.h"
#include <limits.h>

Include dependency graph for unroll.c:

Go to the source code of this file.

Data Structures
struct	MinMaxVar

Functions
static bool	should_unroll_p (instruction i)
static void	compute_variable_size (statement s, MinMaxVar *varwidth)
static void	simd_loop_unroll (statement loop_statement, intptr_t rate)
static int	simple_simd_unroll_rate (loop l)
static bool	simple_simd_unroll_loop_filter (statement s)
static void	compute_parallelism_factor (statement s, MinMaxVar *factor)
static bool	full_simd_unroll_loop_filter (statement s)
static void	simd_unroll_as_needed (statement module_stmt)
bool	loop_auto_unroll (const char *mod_name)
	unroll.c More...
bool	simdizer_auto_unroll (char *mod_name)
static void	gather_local_indices (reference r, set s)
static void	keep_loop_indices (statement s, list *L)
static list	do_simdizer_auto_tile_int_to_list (int maxdepth, int path, loop l)
static statement	do_simdizer_auto_tile_generate_all_tests (statement root, int maxdepth, int path, expression *tests)
static statement	simdizer_auto_tile_generate_all_tests (statement root, int maxdepth, expression tests[1+maxdepth])
static void	stmt_rm_labels (statement s)
bool	simdizer_auto_tile (const char *module_name)

Function Documentation

compute_parallelism_factor()

static void compute_parallelism_factor ( statement  s, MinMaxVar *  factor  )

static

see if the statement can be SIMDized

and if so, to what extent it may benefit from unrolling

Definition at line 197 of file unroll.c.

{
    int varwidth = effective_variables_width(statement_instruction(s));
 
    /* see if the statement can be SIMDized */
    FOREACH(MATCH, m,match_statement(s))
    {
        /* and if so, to what extent it may benefit from unrolling */
        FOREACH(OPCODE, o,opcodeClass_opcodes(match_type(m)))
        {
            if (get_subwordSize_from_opcode(o, 0) >= varwidth) //opcode may be used
            {
                if (opcode_vectorSize(o) > factor->max)
                    factor->max = opcode_vectorSize(o);
                if (opcode_vectorSize(o) < factor->min)
                    factor->min = opcode_vectorSize(o);
            }
        }
    }
}

References effective_variables_width(), FOREACH, get_subwordSize_from_opcode(), MATCH, match_statement(), match_type, MinMaxVar::max, MinMaxVar::min, OPCODE, opcode_vectorSize, opcodeClass_opcodes, and statement_instruction.

Referenced by full_simd_unroll_loop_filter().

Here is the call graph for this function:

Here is the caller graph for this function:

compute_variable_size()

static void compute_variable_size ( statement  s, MinMaxVar *  varwidth  )

static

Definition at line 90 of file unroll.c.

{
    int width = effective_variables_width(statement_instruction(s));
 
    if (width > varwidth->max)
        varwidth->max = width;
 
    if (width < varwidth->min)
        varwidth->min = width;
}

References effective_variables_width(), MinMaxVar::max, min, MinMaxVar::min, and statement_instruction.

Referenced by simple_simd_unroll_rate().

Here is the call graph for this function:

Here is the caller graph for this function:

do_simdizer_auto_tile_generate_all_tests()

static statement do_simdizer_auto_tile_generate_all_tests ( statement  root, int  maxdepth, int  path, expression *  tests  )

static

duplicate effects for the copied statement

Definition at line 365 of file unroll.c.

                                                                                                                      {
    if(expression_undefined_p(*tests)) {
        clone_context cc = make_clone_context(get_current_module_entity(),get_current_module_entity(),NIL,get_current_module_statement());
        statement cp = clone_statement(root, cc);
        /* duplicate effects for the copied statement */
        store_cumulated_rw_effects(cp,copy_effects(load_cumulated_rw_effects(root)));
        list l = do_simdizer_auto_tile_int_to_list(maxdepth, path,statement_loop(root));
        do_symbolic_tiling(cp,l);
        statement siter = cp;
        FOREACH(LOOP,li,l)
            siter = loop_body(statement_loop(siter));
        free_clone_context(cc);
        return cp;
    }
    else {
        int npath = path << 1 ;
        return do_simdizer_auto_tile_generate_all_tests(root, maxdepth, npath+1, tests+1);
        /*
        int npath = path << 1 ;
        statement trueb = do_simdizer_auto_tile_generate_all_tests(root, maxdepth, npath+1, tests+1);
        statement falseb = do_simdizer_auto_tile_generate_all_tests(root, maxdepth, npath,  tests+1);
        return
        instruction_to_statement(
                make_instruction_test(
                    make_test(
                        *tests,
                        trueb,
                        falseb
                        )
                    )
                );
                */
    }
}

References clone_statement(), copy_effects(), cp, do_simdizer_auto_tile_int_to_list(), do_symbolic_tiling(), expression_undefined_p, FOREACH, free_clone_context(), get_current_module_entity(), get_current_module_statement(), load_cumulated_rw_effects(), LOOP, loop_body, make_clone_context(), NIL, statement_loop(), and store_cumulated_rw_effects().

Referenced by simdizer_auto_tile_generate_all_tests().

Here is the call graph for this function:

Here is the caller graph for this function:

do_simdizer_auto_tile_int_to_list()

static list do_simdizer_auto_tile_int_to_list ( int  maxdepth, int  path, loop  l  )

static

Definition at line 354 of file unroll.c.

                                                                             {
    list out = NIL;
    int rw = simple_simd_unroll_rate(l);
    while(maxdepth--) {
        int a = 1;
        if(path & 1) a=rw;
        out=CONS(EXPRESSION,int_to_expression(a),out);
    }
    return out;
}

References CONS, EXPRESSION, int_to_expression(), NIL, out, and simple_simd_unroll_rate().

Referenced by do_simdizer_auto_tile_generate_all_tests().

Here is the call graph for this function:

Here is the caller graph for this function:

full_simd_unroll_loop_filter()

static bool full_simd_unroll_loop_filter ( statement  s )

static

If this is not a loop, keep on recursing

Can only simdize certain loops

can't do anything

look at each of the statements in the body

Decide between min and max unroll factor, and unroll

Do not recursively analyse the loop

Definition at line 218 of file unroll.c.

{
    MinMaxVar factor;
    instruction i;
    loop l;
    instruction iBody;
 
    /* If this is not a loop, keep on recursing */
    i = statement_instruction(s);
    if (!instruction_loop_p(i))
        return true;
    l = instruction_loop(i);
 
    /* Can only simdize certain loops */
    iBody = statement_instruction(loop_body(l));
    if (!should_unroll_p(iBody))
        return true;  /* can't do anything */
 
    /* look at each of the statements in the body */
    factor.min = INT_MAX;
    factor.max = 1;
    gen_context_recurse(loop_body(l), &factor, statement_domain, gen_true2, compute_parallelism_factor);
    factor.min = factor.min > factor.max ? factor.max : factor.min;
 
 
    /* Decide between min and max unroll factor, and unroll */
    int unroll_rate = get_bool_property("SIMDIZER_AUTO_UNROLL_MINIMIZE_UNROLL") ? factor.min : factor.max;
    simd_loop_unroll(s, unroll_rate);
 
    /* Do not recursively analyse the loop */
    return false;
}

References compute_parallelism_factor(), gen_context_recurse, gen_true2(), get_bool_property(), instruction_loop, instruction_loop_p, loop_body, MinMaxVar::max, MinMaxVar::min, should_unroll_p(), simd_loop_unroll(), statement_domain, and statement_instruction.

Referenced by simd_unroll_as_needed().

Here is the call graph for this function:

Here is the caller graph for this function:

gather_local_indices()

static void gather_local_indices ( reference  r, set  s  )

static

Definition at line 339 of file unroll.c.

                                                     {
    list indices = reference_indices(r);
    if(!ENDP(indices)) {
        expression x = EXPRESSION(CAR(gen_last(indices)));
        set xs = get_referenced_entities(x);
        set_union(s,s,xs);
        set_free(xs);
    }
}

References CAR, ENDP, EXPRESSION, gen_last(), get_referenced_entities(), indices, reference_indices, set_free(), set_union(), and x.

Referenced by simdizer_auto_tile().

Here is the call graph for this function:

Here is the caller graph for this function:

keep_loop_indices()

static void keep_loop_indices ( statement  s, list *  L  )

static

Definition at line 349 of file unroll.c.

                                                    {
        if(statement_loop_p(s))
                *L=CONS(STATEMENT,s,*L);
}

References CONS, STATEMENT, and statement_loop_p().

Referenced by simdizer_auto_tile().

Here is the call graph for this function:

Here is the caller graph for this function:

loop_auto_unroll()

bool loop_auto_unroll

(

const char *

mod_name

)

unroll.c

do the job

Parameters

mod_name

od_name

Definition at line 270 of file unroll.c.

                                            {
    // get the resources
    statement mod_stmt = (statement)
        db_get_memory_resource(DBR_CODE, mod_name, true);
 
    set_current_module_statement(mod_stmt);
    set_current_module_entity(module_name_to_entity(mod_name));
 
    debug_on("SIMDIZER_DEBUG_LEVEL");
 
    /* do the job */
    const char* slabel = get_string_property_or_ask("LOOP_LABEL","enter the label of a loop !");
    entity elabel = find_label_entity(mod_name,slabel);
 
    if(entity_undefined_p(elabel)) {
        pips_user_error("label %s does not exist !\n", slabel);
    }
    else {
        statement theloopstatement = find_loop_from_label(get_current_module_statement(),elabel);
        if(!statement_undefined_p(theloopstatement)) {
            simple_simd_unroll_loop_filter(theloopstatement);
        }
    }
 
    pips_assert("Statement is consistent after SIMDIZER_AUTO_UNROLL", 
            statement_consistent_p(mod_stmt));
 
    // Reorder the module, because new statements have been added
    module_reorder(mod_stmt);
    DB_PUT_MEMORY_RESOURCE(DBR_CODE, mod_name, mod_stmt);
 
    // update/release resources
    reset_current_module_statement();
    reset_current_module_entity();
 
    debug_off();
 
    return true;
}

References db_get_memory_resource(), DB_PUT_MEMORY_RESOURCE, debug_off, debug_on, entity_undefined_p, find_label_entity(), find_loop_from_label(), get_current_module_statement(), get_string_property_or_ask(), module_name_to_entity(), module_reorder(), pips_assert, pips_user_error, reset_current_module_entity(), reset_current_module_statement(), set_current_module_entity(), set_current_module_statement(), simple_simd_unroll_loop_filter(), statement_consistent_p(), and statement_undefined_p.

Here is the call graph for this function:

should_unroll_p()

static bool should_unroll_p ( instruction  i )

static

Definition at line 53 of file unroll.c.

{
    switch(instruction_tag(i))
    {
        case is_instruction_call:
            return true;
 
        case is_instruction_sequence:
            {
                cons * j;
 
                for( j = sequence_statements(instruction_sequence(i));
                        j != NIL;
                        j = CDR(j) )
                {
                    statement s = STATEMENT(CAR(j));
                    if (!should_unroll_p(statement_instruction(s)))
                        return false;
                }
                return true;
            }
 
        case is_instruction_test:
        case is_instruction_loop:
        case is_instruction_whileloop:
        case is_instruction_goto:
        case is_instruction_unstructured:
        default:
            return false;
    }
}

References CAR, CDR, instruction_sequence, instruction_tag, is_instruction_call, is_instruction_goto, is_instruction_loop, is_instruction_sequence, is_instruction_test, is_instruction_unstructured, is_instruction_whileloop, NIL, sequence_statements, STATEMENT, and statement_instruction.

Referenced by full_simd_unroll_loop_filter(), and simple_simd_unroll_loop_filter().

Here is the caller graph for this function:

simd_loop_unroll()

static void simd_loop_unroll ( statement  loop_statement, intptr_t  rate  )

static

Definition at line 101 of file unroll.c.

{
  range r = loop_range(statement_loop(loop_statement));
  expression erange = range_to_expression(r,range_to_nbiter);
  intptr_t irange;
  if(expression_integer_value(erange,&irange) && irange <=rate) {
      bool saved[] = {
          get_bool_property("LOOP_NORMALIZE_ONE_INCREMENT"),
          get_bool_property("LOOP_NORMALIZE_SKIP_INDEX_SIDE_EFFECT")
      };
      set_bool_property("LOOP_NORMALIZE_ONE_INCREMENT",true);
      set_bool_property("LOOP_NORMALIZE_SKIP_INDEX_SIDE_EFFECT",true);
      loop_normalize_statement(loop_statement);
      range r = loop_range(statement_loop(loop_statement));
      simplify_expression(&range_upper(r));
      simplify_expression(&range_lower(r));
      set_bool_property("LOOP_NORMALIZE_ONE_INCREMENT",saved[0]);
      set_bool_property("LOOP_NORMALIZE_SKIP_INDEX_SIDE_EFFECT",saved[1]);
      full_loop_unroll(loop_statement);
  }
  else
  {  
          expression lower = range_lower(r);
          NORMALIZE_EXPRESSION(lower);
          entity new = entity_undefined;
          if (normalized_complex_p(expression_normalized(lower))){
                        new = make_new_index_entity(loop_index(statement_loop(loop_statement)),"i");
                        AddEntityToCurrentModule(new);
                        range_lower(r) = entity_to_expression(new);
          }       
          do_loop_unroll(loop_statement,rate,NULL);
          if (! entity_undefined_p(new)){
                        insert_statement(loop_statement,
                                        make_assign_statement(entity_to_expression(new),lower),
                                        true);
          } 
  }
  free_expression(erange);
}

References AddEntityToCurrentModule(), do_loop_unroll(), entity_to_expression(), entity_undefined, entity_undefined_p, expression_integer_value(), expression_normalized, free_expression(), full_loop_unroll(), get_bool_property(), insert_statement(), intptr_t, loop_index, loop_normalize_statement(), loop_range, make_assign_statement(), make_new_index_entity(), NORMALIZE_EXPRESSION, normalized_complex_p, range_lower, range_to_expression(), range_to_nbiter, range_upper, set_bool_property(), simplify_expression(), and statement_loop().

Referenced by full_simd_unroll_loop_filter(), and simple_simd_unroll_loop_filter().

Here is the call graph for this function:

Here is the caller graph for this function:

simd_unroll_as_needed()

static void simd_unroll_as_needed ( statement  module_stmt )

static

Choose algorithm to use, and use it

Definition at line 251 of file unroll.c.

{
    /* Choose algorithm to use, and use it */
    if (get_bool_property("SIMDIZER_AUTO_UNROLL_SIMPLE_CALCULATION"))
    {
        gen_recurse(module_stmt, statement_domain, 
                simple_simd_unroll_loop_filter, gen_null);
    }
    else
    {
        set_simd_treematch((matchTree)db_get_memory_resource(DBR_SIMD_TREEMATCH,"",true));
        set_simd_operator_mappings(db_get_memory_resource(DBR_SIMD_OPERATOR_MAPPINGS,"",true));
 
        gen_recurse(module_stmt, statement_domain, 
                full_simd_unroll_loop_filter, gen_null);
        reset_simd_treematch();
        reset_simd_operator_mappings();
    }
}

References db_get_memory_resource(), full_simd_unroll_loop_filter(), gen_null(), gen_recurse, get_bool_property(), reset_simd_operator_mappings(), reset_simd_treematch(), set_simd_operator_mappings(), set_simd_treematch(), simple_simd_unroll_loop_filter(), and statement_domain.

Referenced by simdizer_auto_unroll().

Here is the call graph for this function:

Here is the caller graph for this function:

simdizer_auto_tile()

bool simdizer_auto_tile

(

const char *

module_name

)

do the job

retrieve loop indices that are referenced as last element

build tests

iterate over all possible combination of tests

create the if's recursively

validate

Parameters

module_name

odule_name

Definition at line 409 of file unroll.c.

                                                  {
    bool success = false;
    set_current_module_entity(module_name_to_entity( module_name ));
    set_current_module_statement((statement) db_get_memory_resource(DBR_CODE, module_name, true) );
    set_cumulated_rw_effects((statement_effects)db_get_memory_resource(DBR_CUMULATED_EFFECTS, module_name, true));
 
    /* do the job */
    const char* slabel = get_string_property_or_ask("LOOP_LABEL","enter the label of a loop !");
    entity elabel = find_label_entity(module_name,slabel);
 
    if(entity_undefined_p(elabel)) {
        pips_user_error("label %s does not exist !\n", slabel);
    }
    else {
        statement theloopstatement = find_loop_from_label(get_current_module_statement(),elabel);
        if(!statement_undefined_p(theloopstatement)) {
            if(perfectly_nested_loop_p(theloopstatement)) {
                /* retrieve loop indices that are referenced as last element */
                set indices = set_make(set_pointer);
                gen_context_recurse(theloopstatement,indices,reference_domain,gen_true2,gather_local_indices);
                list tloops = NIL;
                gen_context_recurse(theloopstatement,&tloops, statement_domain,gen_true2,keep_loop_indices);
                list allloops =gen_copy_seq(tloops);
                FOREACH(STATEMENT,l,allloops) {
                    if(!set_belong_p(indices,loop_index(statement_loop(l))))
                        gen_remove_once(&tloops,l);
                }
                                theloopstatement=STATEMENT(CAR((tloops)));
                                //allloops=gen_nreverse(allloops);
                                while(theloopstatement!=STATEMENT(CAR(allloops))) POP(allloops);
                set_free(indices);
                set loops = set_make(set_pointer);set_assign_list(loops,tloops);gen_free_list(tloops);
 
                /* build tests */
                int max_unroll_rate = simple_simd_unroll_rate(statement_loop(theloopstatement));
                int nloops=gen_length(allloops);
                /* iterate over all possible combination of tests */
                expression alltests[1+nloops];
                alltests[nloops] = expression_undefined ;
                int j=0;
                FOREACH(STATEMENT,sl,allloops) {
                    alltests[j++]=MakeBinaryCall(
                            entity_intrinsic(GREATER_THAN_OPERATOR_NAME),
                            range_to_expression(loop_range(statement_loop(sl)),range_to_nbiter),
                            int_to_expression(2*max_unroll_rate)
                            );
                }
                /* create the if's recursively */
                statement root =
                    simdizer_auto_tile_generate_all_tests(
                        theloopstatement,
                        nloops,
                        alltests);
                gen_recurse(root, statement_domain, gen_true, stmt_rm_labels);
                *theloopstatement=*root;
                loop_label(statement_loop(theloopstatement))=elabel;
                success=true;
 
                /* validate */
                module_reorder(get_current_module_statement());
                DB_PUT_MEMORY_RESOURCE(DBR_CODE, module_name,get_current_module_statement());
            }
            else pips_user_error("loop is not perfectly nested !\n");
        }
        else pips_user_error("label is not on a loop!\n");
    }
 
    reset_cumulated_rw_effects();
    reset_current_module_statement();
    reset_current_module_entity();
    return success;
}

References CAR, db_get_memory_resource(), DB_PUT_MEMORY_RESOURCE, entity_intrinsic(), entity_undefined_p, expression_undefined, find_label_entity(), find_loop_from_label(), FOREACH, gather_local_indices(), gen_context_recurse, gen_copy_seq(), gen_free_list(), gen_length(), gen_recurse, gen_remove_once(), gen_true(), gen_true2(), get_current_module_statement(), get_string_property_or_ask(), GREATER_THAN_OPERATOR_NAME, indices, int_to_expression(), keep_loop_indices(), loop_index, loop_label, loop_range, loops, MakeBinaryCall(), module_name(), module_name_to_entity(), module_reorder(), NIL, perfectly_nested_loop_p(), pips_user_error, POP, range_to_expression(), range_to_nbiter, reference_domain, reset_cumulated_rw_effects(), reset_current_module_entity(), reset_current_module_statement(), set_assign_list(), set_belong_p(), set_cumulated_rw_effects(), set_current_module_entity(), set_current_module_statement(), set_free(), set_make(), set_pointer, simdizer_auto_tile_generate_all_tests(), simple_simd_unroll_rate(), STATEMENT, statement_domain, statement_loop(), statement_undefined_p, and stmt_rm_labels().

Here is the call graph for this function:

simdizer_auto_tile_generate_all_tests()

static statement simdizer_auto_tile_generate_all_tests ( statement  root, int  maxdepth, expression  tests[1+maxdepth]  )

static

Definition at line 400 of file unroll.c.

                                                                                                                   {
    return do_simdizer_auto_tile_generate_all_tests(root,maxdepth,0,&tests[0]);
}

References do_simdizer_auto_tile_generate_all_tests().

Referenced by simdizer_auto_tile().

Here is the call graph for this function:

Here is the caller graph for this function:

simdizer_auto_unroll()

bool simdizer_auto_unroll

(

char *

mod_name

)

Parameters

mod_name

od_name

Definition at line 310 of file unroll.c.

{
    // get the resources
    statement mod_stmt = (statement)
        db_get_memory_resource(DBR_CODE, mod_name, true);
 
    set_current_module_statement(mod_stmt);
    set_current_module_entity(module_name_to_entity(mod_name));
 
    debug_on("SIMDIZER_DEBUG_LEVEL");
 
    simd_unroll_as_needed(mod_stmt);
 
    pips_assert("Statement is consistent after SIMDIZER_AUTO_UNROLL", 
            statement_consistent_p(mod_stmt));
 
    // Reorder the module, because new statements have been added
    module_reorder(mod_stmt);
    DB_PUT_MEMORY_RESOURCE(DBR_CODE, mod_name, mod_stmt);
 
    // update/release resources
    reset_current_module_statement();
    reset_current_module_entity();
 
    debug_off();
 
    return true;
}

References db_get_memory_resource(), DB_PUT_MEMORY_RESOURCE, debug_off, debug_on, module_name_to_entity(), module_reorder(), pips_assert, reset_current_module_entity(), reset_current_module_statement(), set_current_module_entity(), set_current_module_statement(), simd_unroll_as_needed(), and statement_consistent_p().

Here is the call graph for this function:

simple_simd_unroll_loop_filter()

static bool simple_simd_unroll_loop_filter ( statement  s )

static

If this is not a loop, keep on recursing

Can only simdize certain loops

can't do anything

Unroll as many times as needed by the variables width

Do not recursively analyse the loop

Definition at line 173 of file unroll.c.

{
    instruction i;
    loop l;
    instruction iBody;
 
    /* If this is not a loop, keep on recursing */
    i = statement_instruction(s);
    if (!instruction_loop_p(i))
        return true;
    l = instruction_loop(i);
 
    /* Can only simdize certain loops */
    iBody = statement_instruction(loop_body(l));
    if (!should_unroll_p(iBody))
        return true;  /* can't do anything */
 
    /* Unroll as many times as needed by the variables width */
    simd_loop_unroll(s, simple_simd_unroll_rate(l) );
 
    /* Do not recursively analyse the loop */
    return false;
}

References instruction_loop, instruction_loop_p, loop_body, should_unroll_p(), simd_loop_unroll(), simple_simd_unroll_rate(), and statement_instruction.

Referenced by loop_auto_unroll(), and simd_unroll_as_needed().

Here is the call graph for this function:

Here is the caller graph for this function:

simple_simd_unroll_rate()

static int simple_simd_unroll_rate ( loop  l )

static

Compute variable size

Decide between min and max unroll factor

Round up varwidth to a power of 2

Unroll as many times as needed by the variables width

Definition at line 141 of file unroll.c.

                                           {
    /* Compute variable size */
    MinMaxVar varwidths = { INT_MAX , 0 };
    int varwidth;
    gen_context_recurse(loop_body(l), &varwidths,
      statement_domain, gen_true2, compute_variable_size);
 
    /* Decide between min and max unroll factor */
    if (get_bool_property("SIMDIZER_AUTO_UNROLL_MINIMIZE_UNROLL"))
        varwidth = varwidths.max;
    else
        varwidth = varwidths.min;
 
    /* Round up varwidth to a power of 2 */
    int regWidth = get_int_property("SAC_SIMD_REGISTER_WIDTH");
 
    if ((varwidth > regWidth/2) || (varwidth <= 0)) 
        return 1;
 
    for(int j = 8; j <= regWidth/2; j*=2)
    {
        if (varwidth <= j)
        {
            varwidth = j; 
            break;
        }
    }
 
    /* Unroll as many times as needed by the variables width */
    return regWidth / varwidth;
}

References compute_variable_size(), gen_context_recurse, gen_true2(), get_bool_property(), get_int_property(), loop_body, MinMaxVar::max, MinMaxVar::min, and statement_domain.

Referenced by do_simdizer_auto_tile_int_to_list(), simdizer_auto_tile(), and simple_simd_unroll_loop_filter().

Here is the call graph for this function:

Here is the caller graph for this function:

stmt_rm_labels()

static void stmt_rm_labels ( statement  s )

static

Definition at line 404 of file unroll.c.

{
  (void) statement_remove_useless_label(s, false);
}

References statement_remove_useless_label().

Referenced by simdizer_auto_tile().

Here is the call graph for this function:

Here is the caller graph for this function: