sac.h File Reference

#include "sac_private.h"
#include "dg.h"
#include "graph.h"

Include dependency graph for sac.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Macros
#define	FUNC_TO_ATOMIZE_P(call)
#define	IF_TO_CONVERT   "PIPS IF_TO_CONVERT"
	if conversion More...
#define	IF_CONV_TO_COMPACT   "PIPS IF_CONV_TO_COMPACT"
#define	ENTITY_FUNCTION_P(f)
#define	SIMD_MASKED_SUFFIX   "_MASKED"
	simd_loop_const_elim.c More...
#define	SIMD_GENERIC_SUFFIX   "_GENERIC"
#define	SIMD_CONSTANT_SUFFIX   "_CONSTANT"
#define	SIMD_BROADCAST_SUFFIX   "_BROADCAST"
#define	SAC_PADDING_ENTITY_NAME   "PADDING_VALUE"
#define	STATEMENT_INFO_NEWGEN_DOMAIN   SIMDSTATEMENTINFO_NEWGEN_DOMAIN
#define	gen_STATEMENT_INFO_cons   gen_SIMDSTATEMENTINFO_cons
#define	CHECK_VECTORELEMENT(ve)

Typedefs
typedef hash_table	operator_id_sons
	Warning! Do not modify this file that is automatically generated! More...
typedef dg_arc_label	arc_label
typedef dg_vertex_label	vertex_label

Functions
int	patterns_yyparse ()
int	patterns_yylex ()
void	patterns_yyerror (const char *)
bool	if_conversion_compact (char *)
	cproto-generated files More...
bool	if_conversion_init (char *)
	if_conversion_init.c More...
match	get_statement_match_of_kind (statement, opcodeClass)
	simdizer.c More...
string	sac_commenter (entity)
bool	simdizer (char *)
bool	simdizer_init (const char *)
int	effective_variables_width (instruction)
	varwidth.c More...
void	init_vector_to_expressions (void)
	codegen.c More...
void	reset_vector_to_expressions (void)
void	invalidate_expressions_in_statement (statement)
bool	expression_reference_or_field_p (expression)
bool	simd_vector_entity_p (entity)
int	get_subwordSize_from_opcode (opcode, int)
opcode	generate_opcode (string, list, float)
	auto-guess vector size More...
expression	distance_between_expression (const expression, const expression)
	computes the distance betwwen two expression More...
bool	sac_aligned_entity_p (entity)
statement	make_shuffle_statement (entity *, list, int *)
simdstatement	make_simd_statements (set, list)
list	generate_simd_code (simdstatement, float *)
bool	loop_auto_unroll (const char *)
	unroll.c More...
bool	simdizer_auto_unroll (char *)
bool	simdizer_auto_tile (const char *)
void	set_simd_operator_mappings (void *)
	operatorid.c More...
void	reset_simd_operator_mappings (void)
int	get_operator_id (entity)
bool	simd_operator_mappings (const string)
void	set_simd_treematch (matchTree)
	treematch.c More...
void	reset_simd_treematch (void)
void	simd_reset_finalArgType (void)
void	simd_fill_finalArgType (statement)
void	simd_fill_curArgType (statement)
bool	simd_check_argType (void)
list	match_statement (statement)
	return a list of matching statements More...
void	insert_opcodeClass (char *, int, list)
void	insert_pattern (char *, list, list)
bool	simd_treematcher (const string)
statement	simd_atomize_this_expression (entity(*)(entity, basic), expression)
	atomizer.c More...
bool	simd_atomizer (char *)
bool	reduction_atomization (const char *)
void	insert_transformation (char *, int, int, int, int, int, list)
	vectransform.c More...
bool	sac_expression_reduction_p (expression)
	reductions.c More...
bool	simd_remove_reductions (char *)
	remove reductions by expanding reduced scalar to an array More...
bool	redundant_load_store_elimination (char *)
bool	scalar_renaming (char *)
	singleass.c More...
bool	deatomizer (char *)
	deatomizer.c More...
bool	if_conversion (char *)
	if_conversion.c More...
bool	loop_nest_unswitching (const char *)
bool	simd_memory_packing (char *)
	simd_memory_packing.c More...
int	patterns_yywrap (void)
void	patterns_yyrestart (FILE *)
void	patterns_yypop_buffer_state (void)
int	patterns_yyget_lineno (void)
FILE *	patterns_yyget_in (void)
FILE *	patterns_yyget_out (void)
int	patterns_yyget_leng (void)
char *	patterns_yyget_text (void)
void	patterns_yyset_lineno (int)
void	patterns_yyset_in (FILE *)
void	patterns_yyset_out (FILE *)
int	patterns_yyget_debug (void)
void	patterns_yyset_debug (int)
int	patterns_yylex_destroy (void)
void *	patterns_yyalloc (yy_size_t)
void *	patterns_yyrealloc (void *, yy_size_t)
void	patterns_yyfree (void *)

Variables
FILE *	patterns_yyin
	symbols exported by the parser More...
size_t	sac_lineno
	patterns.c More...
statement	sac_current_block
instruction	sac_real_current_instruction
int	patterns_yychar
int	patterns_yynerrs
int	patterns_yyleng
	lexer.c More...
FILE *	patterns_yyout
int	patterns_yylineno
int	patterns_yy_flex_debug
char *	patterns_yytext

Macro Definition Documentation

CHECK_VECTORELEMENT

#define CHECK_VECTORELEMENT

(

ve

)

Value:

    do {\
    pips_assert("vector Index seems legal",vectorElement_vectorIndex(ve) >= 0 && vectorElement_vectorIndex(ve) < simdStatementInfo_nbArgs(vectorElement_statement(ve)));\
    } while(0)

Definition at line 70 of file sac.h.

ENTITY_FUNCTION_P

#define ENTITY_FUNCTION_P

(

f

)

Value:

                            (type_functional_p(entity_type(f)) && \
                            (gen_length(module_functional_parameters(f)) != 0))

Definition at line 55 of file sac.h.

FUNC_TO_ATOMIZE_P

#define FUNC_TO_ATOMIZE_P

(

call

)

Value:

        (\
        type_functional_p(entity_type(call_function(call))) && \
            (gen_length(module_functional_parameters(call_function(call))) != 0) && \
        (!ENTITY_DEREFERENCING_P(call_function(call))) && \
        (!ENTITY_POINT_TO_P(call_function(call))) && \
        (!ENTITY_FIELD_P(call_function(call)))\
        )

Definition at line 42 of file sac.h.

gen_STATEMENT_INFO_cons

#define gen_STATEMENT_INFO_cons   gen_SIMDSTATEMENTINFO_cons

Definition at line 67 of file sac.h.

IF_CONV_TO_COMPACT

#define IF_CONV_TO_COMPACT   "PIPS IF_CONV_TO_COMPACT"

Definition at line 52 of file sac.h.

IF_TO_CONVERT

#define IF_TO_CONVERT   "PIPS IF_TO_CONVERT"

if conversion

Definition at line 51 of file sac.h.

SAC_PADDING_ENTITY_NAME

#define SAC_PADDING_ENTITY_NAME   "PADDING_VALUE"

Definition at line 64 of file sac.h.

SIMD_BROADCAST_SUFFIX

#define SIMD_BROADCAST_SUFFIX   "_BROADCAST"

Definition at line 63 of file sac.h.

SIMD_CONSTANT_SUFFIX

#define SIMD_CONSTANT_SUFFIX   "_CONSTANT"

Definition at line 62 of file sac.h.

SIMD_GENERIC_SUFFIX

#define SIMD_GENERIC_SUFFIX   "_GENERIC"

Definition at line 61 of file sac.h.

SIMD_MASKED_SUFFIX

#define SIMD_MASKED_SUFFIX   "_MASKED"

simd_loop_const_elim.c

Definition at line 60 of file sac.h.

STATEMENT_INFO_NEWGEN_DOMAIN

#define STATEMENT_INFO_NEWGEN_DOMAIN   SIMDSTATEMENTINFO_NEWGEN_DOMAIN

Definition at line 66 of file sac.h.

Typedef Documentation

arc_label

typedef dg_arc_label arc_label

Definition at line 36 of file sac.h.

operator_id_sons

typedef hash_table operator_id_sons

Warning! Do not modify this file that is automatically generated!

Modify src/Libs/sac/sac-local.h instead, to add your own modifications. header file built by cproto sac-local.h

Definition at line 32 of file sac.h.

vertex_label

typedef dg_vertex_label vertex_label

Definition at line 37 of file sac.h.

Function Documentation

deatomizer()

bool deatomizer

(

char *

mod_name

)

deatomizer.c

get the resources

Now do the job

Reorder the module, because new statements have been added

update/release resources

Parameters

mod_name

od_name

Definition at line 726 of file deatomizer.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));
        set_ordering_to_statement(mod_stmt);
 
    dep_graph = (graph) db_get_memory_resource(DBR_DG, mod_name, true);
 
    set_proper_rw_effects((statement_effects) 
            db_get_memory_resource(DBR_PROPER_EFFECTS, mod_name, true));
 
    debug_on("DEATOMIZER");
 
    /* Now do the job */
 
    // To prevent some warnings
    hash_dont_warn_on_redefinition();
 
    gen_recurse(mod_stmt, statement_domain,
            da_simple_sequence_filter, da_simple_statements);
 
    // Restore the warning
    hash_warn_on_redefinition();
 
    pips_assert("Statement is consistent after DEATOMIZER", 
            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_ordering_to_statement();
    reset_current_module_statement();
    reset_current_module_entity();
    reset_proper_rw_effects();
 
    debug_off();
 
    return true;
}

References da_simple_sequence_filter(), da_simple_statements(), db_get_memory_resource(), DB_PUT_MEMORY_RESOURCE, debug_off, debug_on, dep_graph, gen_recurse, hash_dont_warn_on_redefinition(), hash_warn_on_redefinition(), module_name_to_entity(), module_reorder(), pips_assert, reset_current_module_entity(), reset_current_module_statement(), reset_ordering_to_statement(), reset_proper_rw_effects(), set_current_module_entity(), set_current_module_statement(), set_ordering_to_statement(), set_proper_rw_effects(), statement_consistent_p(), and statement_domain.

Here is the call graph for this function:

distance_between_expression()

expression distance_between_expression	(	const expression	exp0,
		const expression	exp1
	)

computes the distance betwwen two expression

Returns

expression_undefined if not comparable, an expression of the distance otherwise

reference with different variables have an infinite distance

Parameters

exp0	xp0
exp1	xp1

Definition at line 419 of file codegen.c.

{
    bool eval_sizeof = get_bool_property("EVAL_SIZEOF");
    set_bool_property("EVAL_SIZEOF",true);
    expression result = expression_undefined;
    if( expression_reference_p(exp0) && expression_reference_p(exp1))
    {
        reference r0 = expression_reference(exp0),
                  r1 = expression_reference(exp1);
 
        /* reference with different variables have an infinite distance */
        entity e0 = reference_variable(r0),
               e1 = reference_variable(r1);
        expression edistance = distance_between_entity(e0,e1);
        if(!expression_undefined_p(edistance))
        {
            basic b = basic_of_reference(r0);
            expression offset0 = sreference_offset(r0),
                       offset1 = sreference_offset(r1);
            expression distance =  make_op_exp(MINUS_OPERATOR_NAME,offset1,offset0);
            distance = make_op_exp(MULTIPLY_OPERATOR_NAME,
                    distance,int_to_expression(SizeOfElements(b)));
            free_basic(b);
            result= make_op_exp(PLUS_OPERATOR_NAME,distance,edistance);
        }
    }
    else if (expression_field_p(exp0) && expression_field_p(exp1))
    {
        expression str0 = binary_call_lhs(expression_call(exp0)),
                   str1 = binary_call_lhs(expression_call(exp1));
        expression lhs_distance = distance_between_expression(str0,str1);
        expression rhs_distance = distance_between_expression(binary_call_rhs(expression_call(exp1)),binary_call_rhs(expression_call(exp0)));
        if(!expression_undefined_p(lhs_distance) && !expression_undefined_p(rhs_distance))
            result = make_op_exp(MINUS_OPERATOR_NAME,lhs_distance,rhs_distance);
    }
    set_bool_property("EVAL_SIZEOF",eval_sizeof);
    //maxima_simplify(&result);
    simplify_expression(&result);
    return result;
}

References basic_of_reference(), binary_call_lhs, binary_call_rhs, distance_between_entity(), expression_call(), expression_field_p(), expression_reference(), expression_reference_p(), expression_undefined, expression_undefined_p, free_basic(), get_bool_property(), int_to_expression(), make_op_exp(), MINUS_OPERATOR_NAME, MULTIPLY_OPERATOR_NAME, PLUS_OPERATOR_NAME, reference_variable, set_bool_property(), simplify_expression(), SizeOfElements(), and sreference_offset().

Referenced by comparable_statements_on_distance_p(), compare_statements_on_distance_to_origin(), conflict_is_a_real_conflict_p(), consecutive_expression_p(), and do_simdizer_init().

Here is the call graph for this function:

Here is the caller graph for this function:

effective_variables_width()

int effective_variables_width

(

instruction

i

)

varwidth.c

Definition at line 85 of file varwidth.c.

{
   int g_varwidth = 0;
 
   gen_context_recurse(i, &g_varwidth,reference_domain, variables_width_filter, gen_null2);
 
   return g_varwidth;
}

References gen_context_recurse, gen_null2(), reference_domain, and variables_width_filter().

Referenced by compute_parallelism_factor(), and compute_variable_size().

Here is the call graph for this function:

Here is the caller graph for this function:

expression_reference_or_field_p()

bool expression_reference_or_field_p

(

expression

e

)

Definition at line 192 of file codegen.c.

{
    return expression_reference_p(e) || expression_field_p(e);
}

References expression_field_p(), and expression_reference_p().

Referenced by do_simdizer_init(), get_optimal_opcode(), and sac_statement_to_expressions_gather().

Here is the call graph for this function:

Here is the caller graph for this function:

generate_opcode()

opcode generate_opcode	(	string	name,
		list	types,
		float	cost
	)

auto-guess vector size

Parameters

name	ame
types	ypes
cost	ost

Definition at line 276 of file codegen.c.

{
    intptr_t elem_size=0,vector_size = get_int_property("SAC_SIMD_REGISTER_WIDTH");
    opcode oc =  make_opcode(name,vector_size,types,cost);
    int n = gen_length(types);
    for(int i=0; i<n;i++)
    {
        int curr = get_subwordSize_from_opcode(oc,i);
        if(curr > elem_size) elem_size=curr;
    }
    opcode_vectorSize(oc)/=elem_size;
    if( opcode_vectorSize(oc) * elem_size !=get_int_property("SAC_SIMD_REGISTER_WIDTH"))
        pips_user_warning("SAC_SIMD_REGISTER_WIDTH and description of %s leads "
            "to partially filled register\n", name);
    return oc;
}

References gen_length(), get_int_property(), get_subwordSize_from_opcode(), intptr_t, make_opcode(), opcode_vectorSize, and pips_user_warning.

Here is the call graph for this function:

generate_simd_code()

list generate_simd_code	(	simdstatement	ssi,
		float *	simdCost
	)

this is the classical generation process: several load, an exec and a store

the order is reversed, but we use it

Parameters

ssi	si
simdCost	imdCost

Definition at line 1325 of file codegen.c.

{
    gSimdCost = 0;
 
    pips_debug(3,"generate_simd_code 1\n");
 
    /* this is the classical generation process:
     * several load, an exec and a store
     */
    //First, the load statement(s)
    list loads=NIL;
    for(int i = 0; i < simdstatement_nbArgs(ssi)-1; i++)
    {
        statement s = generate_load_statement(ssi, i);
        if (! statement_undefined_p(s))
            loads = CONS(STATEMENT, s, loads);
    }
 
    //Then, the exec statement
    statement exec= generate_exec_statement(ssi);
 
    //Finally, the save statement (always generated. It is up to 
    //latter phases (USE-DEF elimination....) to remove it, if needed
    statement save = generate_save_statement(ssi);
 
    list out = NIL;
        out=CONS(STATEMENT,save,CONS(STATEMENT,exec,loads));
    *simdCost += gSimdCost;
    pips_debug(3,"generate_simd_code 2 that costs %lf\n",gSimdCost);
    /* the order is reversed, but we use it */
    return out;
}

References CONS, generate_exec_statement(), generate_load_statement(), generate_save_statement(), gSimdCost, NIL, out, pips_debug, save, simdstatement_nbArgs, STATEMENT, and statement_undefined_p.

Referenced by simdize_simple_statements_pass2().

Here is the call graph for this function:

Here is the caller graph for this function:

get_operator_id()

int get_operator_id

(

entity

e

)

retry with uppercase version, cos -> COS :)

Definition at line 161 of file operatorid.c.

{
    const char* ename = entity_local_name(e);
    int res = do_get_operator_id(ename);
    if(res == UNKNOWN_TOK )
    {
        /* retry with uppercase version, cos -> COS :) */
        ename = strupper(strdup(ename),ename);
        res = do_get_operator_id(ename);
    }
    return res;
}

References do_get_operator_id(), entity_local_name(), strdup(), strupper(), and UNKNOWN_TOK.

Referenced by match_call().

Here is the call graph for this function:

Here is the caller graph for this function:

get_statement_match_of_kind()

match get_statement_match_of_kind	(	statement	s,
		opcodeClass	kind
	)

simdizer.c

Parameters

kind

ind

Definition at line 101 of file simdizer.c.

{
    list l = get_statement_matches(s);
 
    for( ; l!=NIL; l=CDR(l))
    {
        match m = MATCH(CAR(l));
        if (match_type(m) == kind)
            return m;
    }
 
    return match_undefined;
}

References CAR, CDR, get_statement_matches(), MATCH, match_type, match_undefined, and NIL.

Referenced by make_simd_statements().

Here is the call graph for this function:

Here is the caller graph for this function:

get_subwordSize_from_opcode()

int get_subwordSize_from_opcode	(	opcode	oc,
		int	argNum
	)

Parameters

oc	c
argNum	rgNum

Definition at line 246 of file codegen.c.

{
    int type = INT(gen_nth(argNum, opcode_argType(oc)));
 
    switch(type)
    {
        case QI_REF_TOK:
            return 8;
        case HI_REF_TOK:
            return 16;
        case SI_REF_TOK:
            return 32;
        case DI_REF_TOK:
            return 64;
        case SF_REF_TOK:
            return 32;
        case DF_REF_TOK:
            return 64;
        case SC_REF_TOK:
            return 64;
        case DC_REF_TOK:
            return 128;
        default:
            pips_internal_error("subword size unknown.");
    }
 
    return 8;
}

References DC_REF_TOK, DF_REF_TOK, DI_REF_TOK, gen_nth(), HI_REF_TOK, INT, opcode_argType, pips_internal_error, QI_REF_TOK, SC_REF_TOK, SF_REF_TOK, and SI_REF_TOK.

Referenced by compute_parallelism_factor(), generate_opcode(), get_optimal_opcode(), and make_simd_statement().

Here is the call graph for this function:

Here is the caller graph for this function:

if_conversion()

bool if_conversion

(

char *

mod_name

)

if_conversion.c

Parameters

mod_name

od_name

Definition at line 281 of file if_conversion.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("IF_CONVERSION_DEBUG_LEVEL");
    // Now do the job
 
    gen_recurse(mod_stmt, statement_domain, gen_true, if_conv_statement);
 
    // Reorder the module, because new statements have been added 
    module_reorder(mod_stmt);
    DB_PUT_MEMORY_RESOURCE(DBR_CODE, mod_name, mod_stmt);
    DB_PUT_MEMORY_RESOURCE(DBR_CALLEES, mod_name, 
            compute_callees(mod_stmt));
 
    // update/release resources
    reset_current_module_statement();
    reset_current_module_entity();
 
    debug_off();
 
    return true;
}

References compute_callees(), db_get_memory_resource(), DB_PUT_MEMORY_RESOURCE, debug_off, debug_on, gen_recurse, gen_true(), if_conv_statement(), module_name_to_entity(), module_reorder(), reset_current_module_entity(), reset_current_module_statement(), set_current_module_entity(), set_current_module_statement(), and statement_domain.

Here is the call graph for this function:

if_conversion_compact()

bool if_conversion_compact

(

char *

mod_name

)

cproto-generated files

if_conversion_compact.c

Parameters

mod_name

od_name

Definition at line 252 of file if_conversion_compact.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));
        set_ordering_to_statement(mod_stmt);
 
    graph dg = (graph) db_get_memory_resource(DBR_DG, mod_name, true);
 
    set_proper_rw_effects((statement_effects) 
            db_get_memory_resource(DBR_PROPER_EFFECTS, mod_name, true));
 
    debug_on("IF_CONVERSION_COMPACT_DEBUG_LEVEL");
    // Now do the job
 
    gen_context_recurse(mod_stmt, dg, statement_domain, gen_true2, if_conversion_compact_stats);
 
    // 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_ordering_to_statement();
    reset_current_module_statement();
    reset_current_module_entity();
    reset_proper_rw_effects();
 
    debug_off();
 
    return true;
}

References db_get_memory_resource(), DB_PUT_MEMORY_RESOURCE, debug_off, debug_on, dg, gen_context_recurse, gen_true2(), if_conversion_compact_stats(), module_name_to_entity(), module_reorder(), reset_current_module_entity(), reset_current_module_statement(), reset_ordering_to_statement(), reset_proper_rw_effects(), set_current_module_entity(), set_current_module_statement(), set_ordering_to_statement(), set_proper_rw_effects(), and statement_domain.

Here is the call graph for this function:

if_conversion_init()

bool if_conversion_init

(

char *

mod_name

)

if_conversion_init.c

Parameters

mod_name

od_name

Definition at line 337 of file if_conversion_init.c.

{
    // get the resources
    set_current_module_entity(module_name_to_entity(mod_name));
    statement root = (statement) db_get_memory_resource(DBR_CODE, mod_name, true);
    statement fake = make_empty_block_statement();
 
    set_current_module_statement(fake);// to prevent a complex bug with gen_recurse and AddEntityToCurrentModule
    set_complexity_map( (statement_mapping) db_get_memory_resource(DBR_COMPLEXITIES, mod_name, true));
 
    debug_on("IF_CONVERSION_INIT_DEBUG_LEVEL");
 
    ifdebug(1) {
      pips_debug(1, "Code before if_conversion_init:\n");
      print_statement(root);
    }
 
    // Now do the job
    gen_recurse(root, statement_domain, gen_true, if_conv_init_statement);
 
    ifdebug(1) {
      pips_debug(1, "Code after if_conv_init_statement:\n");
      print_statement(root);
    }
 
    // and share decl
    FOREACH(STATEMENT,s,statement_block(fake))
        insert_statement_no_matter_what(root,copy_statement(s),true);
    free_statement(fake);
 
    ifdebug(1) {
      pips_debug(1, "Code after copying from fake statement:\n");
      print_statement(root);
    }
 
    // Reorder the module, because new statements have been added
    module_reorder(root);
    DB_PUT_MEMORY_RESOURCE(DBR_CODE, mod_name, root);
 
    // update/release resources
    reset_complexity_map();
    reset_current_module_statement();
    reset_current_module_entity();
 
    debug_off();
 
    return true;
}

References copy_statement(), db_get_memory_resource(), DB_PUT_MEMORY_RESOURCE, debug_off, debug_on, FOREACH, free_statement(), gen_recurse, gen_true(), if_conv_init_statement(), ifdebug, insert_statement_no_matter_what(), make_empty_block_statement(), module_name_to_entity(), module_reorder(), pips_debug, print_statement(), reset_complexity_map(), reset_current_module_entity(), reset_current_module_statement(), set_complexity_map(), set_current_module_entity(), set_current_module_statement(), STATEMENT, statement_block(), and statement_domain.

Here is the call graph for this function:

init_vector_to_expressions()

void init_vector_to_expressions

(

void

)

codegen.c

Definition at line 59 of file codegen.c.

{
    pips_assert("reset was called",hash_table_undefined_p(vector_to_expressions));
    vector_to_expressions=hash_table_make(hash_pointer,HASH_DEFAULT_SIZE);
}

References HASH_DEFAULT_SIZE, hash_pointer, hash_table_make(), hash_table_undefined_p, pips_assert, and vector_to_expressions.

Referenced by simdize_simple_statements_pass2().

Here is the call graph for this function:

Here is the caller graph for this function:

insert_opcodeClass()

void insert_opcodeClass	(	char *	s,
		int	nbArgs,
		list	opcodes
	)

Parameters

nbArgs	bArgs
opcodes	pcodes

Definition at line 267 of file treematch.c.

{
    //Add the class and name in the map
    make_opcodeClass(s, nbArgs, opcodes);
}

References make_opcodeClass().

Here is the call graph for this function:

insert_pattern()

void insert_pattern	(	char *	s,
		list	tokens,
		list	args
	)

no such branch -> create a new branch

Parameters

tokens	okens
args	rgs

Definition at line 278 of file treematch.c.

{
    opcodeClass c = get_opcodeClass(s);
    patternx p;
    matchTree m = patterns_tree;
 
    if (c == opcodeClass_undefined)
    {
        pips_user_warning("defining pattern for an undefined opcodeClass (%s).",s);
        return;
    }
 
    p = make_patternx(c, args);
 
    for( ; tokens != NIL; tokens = CDR(tokens) )
    {
        int token = INT(CAR(tokens));
        matchTree next = select_tree_branch(m, token);
 
        if (next == matchTree_undefined)
        {
            /* no such branch -> create a new branch */
            next = make_tree();
            insert_tree_branch(m, token, next);
        }
 
        m = next;
    }
 
    matchTree_patterns(m) = CONS(PATTERNX, p, matchTree_patterns(m));
}

References CAR, CDR, CONS, get_opcodeClass(), insert_tree_branch(), INT, make_patternx(), make_tree(), matchTree_patterns, matchTree_undefined, NIL, opcodeClass_undefined, patterns_tree, PATTERNX, pips_user_warning, and select_tree_branch().

Here is the call graph for this function:

insert_transformation()

void insert_transformation	(	char *	name,
		int	vectorLengthOut,
		int	subwordSizeOut,
		int	vectorLengthIn,
		int	subwordSizeIn,
		int	nbArgs,
		list	mapping
	)

vectransform.c

Parameters

name	ame
vectorLengthOut	ectorLengthOut
subwordSizeOut	ubwordSizeOut
vectorLengthIn	ectorLengthIn
subwordSizeIn	ubwordSizeIn
nbArgs	bArgs
mapping	apping

Definition at line 43 of file vectransform.c.

{
    int i;
    list l;
    transformation t = make_transformation(strdup(name),
            vectorLengthOut,
            subwordSizeOut,
            vectorLengthIn,
            subwordSizeIn,
            nbArgs,
            (int*)malloc(sizeof(int)*vectorLengthOut));
 
    for(i = vectorLengthOut-1, l=mapping; (i>=0) && (l!=NIL); i--, l=CDR(l))
        transformation_mapping(t)[i] = INT(CAR(l));
 
    transformations = CONS(TRANSFORMATION, t, transformations);
}

References CAR, CDR, CONS, INT, make_transformation(), malloc(), NIL, strdup(), TRANSFORMATION, transformation_mapping, and transformations.

Here is the call graph for this function:

invalidate_expressions_in_statement()

void invalidate_expressions_in_statement

(

statement

s

)

Definition at line 162 of file codegen.c.

{
    list effects = load_proper_rw_effects_list( s );
    void * hiter = NULL;
    entity key;
    list value;
    list purge = NIL;
    while( (hiter = hash_table_scan(vector_to_expressions,hiter,(void**)&key,(void**)&value) ))
    {
        bool invalidate=false;
        FOREACH(EXPRESSION,v,value)
        {
            if(!expression_undefined_p(v) && expression_reference_p(v))
            {
                FOREACH(EFFECT,eff,effects)
                    if((invalidate=references_may_conflict_p(expression_reference(v),effect_any_reference(eff))))
                    {
                        gen_full_free_list(value);
                        break;
                    }
            }
            if(invalidate) break;
        }
        if(invalidate) purge=CONS(ENTITY,key,purge);
    }
    FOREACH(ENTITY,e,purge)
        hash_del(vector_to_expressions,e);
    gen_free_list(purge);
}

References CONS, EFFECT, effect_any_reference, ENTITY, EXPRESSION, expression_reference(), expression_reference_p(), expression_undefined_p, FOREACH, gen_free_list(), gen_full_free_list(), hash_del(), hash_table_scan(), load_proper_rw_effects_list(), NIL, references_may_conflict_p(), and vector_to_expressions.

Referenced by simdize_simple_statements_pass2().

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:

loop_nest_unswitching()

bool loop_nest_unswitching

(

const char *

module_name

)

Parameters

module_name

odule_name

Definition at line 391 of file if_conversion.c.

                                                    {
    set_current_module_statement((statement)db_get_memory_resource(DBR_CODE, module_name,true));
    set_current_module_entity(module_name_to_entity(module_name));
 
    list l=NIL;
    gen_context_recurse(get_current_module_statement(), &l,
            statement_domain, gen_true2, do_loop_nest_unswitching);
    pips_assert("everything went well\n",ENDP(l));
 
 
    // Reorder the module, because new statements have been added 
    module_reorder(get_current_module_statement());
    DB_PUT_MEMORY_RESOURCE(DBR_CODE, module_name, get_current_module_statement());
 
    reset_current_module_statement();
    reset_current_module_entity();
    return true;
}

References db_get_memory_resource(), DB_PUT_MEMORY_RESOURCE, do_loop_nest_unswitching(), ENDP, gen_context_recurse, gen_true2(), get_current_module_statement(), module_name(), module_name_to_entity(), module_reorder(), NIL, pips_assert, reset_current_module_entity(), reset_current_module_statement(), set_current_module_entity(), set_current_module_statement(), and statement_domain.

Here is the call graph for this function:

make_shuffle_statement()

statement make_shuffle_statement	(	entity *	from,
		list	expressions,
		int *	perms
	)

If the permutation indexes are equivalent to an invertion, generate an SIMD_INVERT function (useful for some MIS).

Parameters

from	rom
expressions	xpressions
perms	erms

Definition at line 1068 of file codegen.c.

                                                                           {
        list shuffle=NIL;
    FOREACH(EXPRESSION,_,expressions)
                shuffle=CONS(EXPRESSION,int_to_expression(*perms++),shuffle);
        shuffle=gen_nreverse(shuffle);
        entity out = make_entity_copy(*from);
        AddEntityToCurrentModule(out);
        string sshuffle;
        statement outs;
        /* If the permutation indexes are equivalent to an invertion,
         * generate an SIMD_INVERT function (useful for some MIS). */
        if (perms[0] == 4 && perms[1] == 3 && perms[2] == 2 && perms[3] == 1) {
                asprintf(&sshuffle,"SIMD_INVERT_%s",
                                get_vect_name_from_data(gen_length(expressions),expressions));
                list args = NIL;
                args = CONS(EXPRESSION,entity_to_expression(*from),args);
                args = CONS(EXPRESSION,entity_to_expression(out),args);
 
                outs =  instruction_to_statement(
                                make_instruction_call(
                                        make_call(
                                                module_name_to_runtime_entity(sshuffle),
                                                args)
                                        )
                                );
        }
        else {
                asprintf(&sshuffle,"SIMD_SHUFFLE_%s",
                                get_vect_name_from_data(gen_length(expressions),expressions));
 
                outs =  instruction_to_statement(
                                make_instruction_call(
                                        make_call(
                                                module_name_to_runtime_entity(sshuffle),
                                                CONS(EXPRESSION,entity_to_expression(out),
                                                        CONS(EXPRESSION,entity_to_expression(*from), shuffle)))
                                        )
                                );
        }
        *from=out;
        return outs;
}

References _, AddEntityToCurrentModule(), asprintf, CONS, entity_to_expression(), EXPRESSION, FOREACH, gen_length(), gen_nreverse(), get_vect_name_from_data(), instruction_to_statement(), int_to_expression(), make_call(), make_entity_copy(), make_instruction_call(), module_name_to_runtime_entity(), NIL, out, and shuffle().

Referenced by try_all_permutations().

Here is the call graph for this function:

Here is the caller graph for this function:

make_simd_statements()

simdstatement make_simd_statements	(	set	opkinds,
		list	statements
	)

there should be a better order than this

get the variables

compute the opcode to use

update the pointer to the next statement to be processed

generate the statement information

Parameters

opkinds	pkinds
statements	tatements

Definition at line 1193 of file codegen.c.

{
    list args[MAX_PACK];
    /* there should be a better order than this */
    list first = statements;
    list last = gen_last(first);
    list kinds = set_to_list(opkinds);
 
    pips_debug(3,"make_simd_statements 1\n");
 
    if (first == last)
        return simdstatement_undefined;
 
    pips_debug(3,"make_simd_statements 2\n");
 
    list i = first;
    simdstatement instr = simdstatement_undefined;
 
    opcodeClass type = OPCODECLASS(CAR(kinds));
    {
        int index;
        opcode oc;
        list j;
 
        /* get the variables */
        for( index = 0, j = i;
                (index < MAX_PACK) && (j != CDR(last));
                index++, j = CDR(j) )
        {
            match m = get_statement_match_of_kind(STATEMENT(CAR(j)), type);
            args[index] = match_args(m);
        }
 
        /* compute the opcode to use */
        oc = get_optimal_opcode(type, index, args);
 
        if (!opcode_undefined_p(oc))
        {
            /* update the pointer to the next statement to be processed */
            for(index = 0; 
                    (index<opcode_vectorSize(oc)) && (i!=CDR(last)); 
                    index++)
            {
                i = CDR(i);
            }
 
            /* generate the statement information */
            pips_debug(3,"make_simd_statements : simd\n");
            instr =  make_simd_statement(type, oc, args);
        }
    }
 
    pips_debug(3,"make_simd_statements 3\n");
    return instr;
}

References CAR, CDR, gen_last(), get_optimal_opcode(), get_statement_match_of_kind(), make_simd_statement(), match_args, MAX_PACK, opcode_undefined_p, opcode_vectorSize, OPCODECLASS, pips_debug, set_to_list(), simdstatement_undefined, and STATEMENT.

Referenced by simdize_simple_statements_pass2().

Here is the call graph for this function:

Here is the caller graph for this function:

match_statement()

list match_statement

(

statement

s

)

return a list of matching statements

find the matching patterns

build the matches

Definition at line 237 of file treematch.c.

{
    list matches = NIL;
 
    if (statement_call_p(s))
    {
 
        /* find the matching patterns */
        list args = NIL;
        matchTree t = match_call(statement_call(s), patterns_tree, &args);
        if (matchTree_undefined_p(t))
        {
            gen_free_list(args);
            return NIL;
        }
 
        /* build the matches */
        FOREACH(PATTERNX, p ,matchTree_patterns(t))
        {
            match m = make_match(
                    patternx_class(p),
                    merge_lists(args, patternx_args(p))
                    );
            matches = CONS(MATCH, m, matches);
        }
    }
 
    return matches;
}

References CONS, FOREACH, gen_free_list(), make_match(), MATCH, match_call(), matches, matchTree_patterns, matchTree_undefined_p, merge_lists(), NIL, patterns_tree, PATTERNX, patternx_args, patternx_class, statement_call(), and statement_call_p().

Referenced by compute_parallelism_factor(), and init_statement_matches_map().

Here is the call graph for this function:

Here is the caller graph for this function:

patterns_yyalloc()

void* patterns_yyalloc

(

yy_size_t

)

patterns_yyerror()

void patterns_yyerror

(

const char *

s

)

Definition at line 1863 of file patterns.c.

{
   pips_internal_error("patterns parser:%zd: %s\n",sac_lineno, s);
}

References pips_internal_error, and sac_lineno.

patterns_yyfree()

void patterns_yyfree

(

void *

)

patterns_yyget_debug()

int patterns_yyget_debug

(

void

)

patterns_yyget_in()

FILE* patterns_yyget_in

(

void

)

patterns_yyget_leng()

int patterns_yyget_leng

(

void

)

patterns_yyget_lineno()

int patterns_yyget_lineno

(

void

)

patterns_yyget_out()

FILE* patterns_yyget_out

(

void

)

patterns_yyget_text()

char* patterns_yyget_text

(

void

)

patterns_yylex()

int patterns_yylex

(

)

patterns_yylex_destroy()

int patterns_yylex_destroy

(

void

)

patterns_yyparse()

int patterns_yyparse

(

)

patterns_yypop_buffer_state()

void patterns_yypop_buffer_state

(

void

)

patterns_yyrealloc()

void* patterns_yyrealloc	(	void *	,
		yy_size_t
	)

patterns_yyrestart()

void patterns_yyrestart

(

FILE *

)

patterns_yyset_debug()

void patterns_yyset_debug

(

int

)

patterns_yyset_in()

void patterns_yyset_in

(

FILE *

)

patterns_yyset_lineno()

void patterns_yyset_lineno

(

int

)

patterns_yyset_out()

void patterns_yyset_out

(

FILE *

)

patterns_yywrap()

int patterns_yywrap

(

void

)

Definition at line 1858 of file patterns.c.

{
   return 1;
}

reduction_atomization()

bool reduction_atomization

(

const char *

module_name

)

prelude

do the job

postlude

Parameters

module_name

odule_name

Definition at line 459 of file atomizer.c.

                                                     {
    /* prelude */
    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_reductions((pstatement_reductions) db_get_memory_resource(DBR_CUMULATED_REDUCTIONS, module_name, true));
 
    /* do the job */
    gen_recurse(get_current_module_statement(),statement_domain,do_reduction_atomization,gen_null);
    module_reorder(get_current_module_statement());
    DB_PUT_MEMORY_RESOURCE(DBR_CODE, get_current_module_name(), get_current_module_statement());
 
    /* postlude */
    reset_cumulated_reductions();
    reset_current_module_statement();
    reset_current_module_entity();
    return true;
}

References db_get_memory_resource(), DB_PUT_MEMORY_RESOURCE, do_reduction_atomization(), gen_null(), gen_recurse, get_current_module_name(), get_current_module_statement(), module_name(), module_name_to_entity(), module_reorder(), reset_cumulated_reductions(), reset_current_module_entity(), reset_current_module_statement(), set_cumulated_reductions(), set_current_module_entity(), set_current_module_statement(), and statement_domain.

Here is the call graph for this function:

redundant_load_store_elimination()

bool redundant_load_store_elimination

(

char *

module_name

)

Get the code of the module.

Parameters

module_name

odule_name

Definition at line 788 of file reductions.c.

{
    /* Get the code of the module. */
    entity module = module_name_to_entity(module_name);
    statement module_stat = (statement)db_get_memory_resource(DBR_CODE, module_name, true);
        set_ordering_to_statement(module_stat);
    set_current_module_entity( module);
    set_current_module_statement( module_stat);
    set_proper_rw_effects((statement_effects) db_get_memory_resource(DBR_REGIONS, module_name, true));
    set_cumulated_rw_effects((statement_effects)db_get_memory_resource(DBR_OUT_REGIONS, module_name, true));
 
    graph dependence_graph = (graph) db_get_memory_resource(DBR_CHAINS, module_name, true);
 
    // buggy and incomplete
    //do_sac_reduction_optimizations(dependence_graph);
    do_redundant_load_store_elimination(dependence_graph);
 
    unnormalize_expression(module_stat);
    module_reorder(module_stat);
    DB_PUT_MEMORY_RESOURCE(DBR_CODE, module_name, module_stat);
    DB_PUT_MEMORY_RESOURCE(DBR_CALLEES, module_name, compute_callees(get_current_module_statement()));
 
 
    reset_current_module_entity();
        reset_ordering_to_statement();
    reset_current_module_statement();
    reset_proper_rw_effects();
    reset_cumulated_rw_effects();
 
    return true;
}

References compute_callees(), db_get_memory_resource(), DB_PUT_MEMORY_RESOURCE, dependence_graph, do_redundant_load_store_elimination(), get_current_module_statement(), module, module_name(), module_name_to_entity(), module_reorder(), reset_cumulated_rw_effects(), reset_current_module_entity(), reset_current_module_statement(), reset_ordering_to_statement(), reset_proper_rw_effects(), set_cumulated_rw_effects(), set_current_module_entity(), set_current_module_statement(), set_ordering_to_statement(), set_proper_rw_effects(), and unnormalize_expression().

Here is the call graph for this function:

reset_simd_operator_mappings()

void reset_simd_operator_mappings

(

void

)

Definition at line 48 of file operatorid.c.

{
    pips_assert("already set",mappings);
    mappings=NULL;
}

References mappings, and pips_assert.

Referenced by simd_operator_mappings(), simd_unroll_as_needed(), and simdizer().

Here is the caller graph for this function:

reset_simd_treematch()

void reset_simd_treematch

(

void

)

Definition at line 52 of file treematch.c.

{
    pips_assert("tree match already set",patterns_tree!=NULL);
    patterns_tree=NULL;
}

References patterns_tree, and pips_assert.

Referenced by simd_treematcher(), simd_unroll_as_needed(), and simdizer().

Here is the caller graph for this function:

reset_vector_to_expressions()

void reset_vector_to_expressions

(

void

)

Definition at line 64 of file codegen.c.

{
    pips_assert("init was called",!hash_table_undefined_p(vector_to_expressions));
    hash_table_free(vector_to_expressions);
    vector_to_expressions=hash_table_undefined;
}

References hash_table_free(), hash_table_undefined, hash_table_undefined_p, pips_assert, and vector_to_expressions.

Referenced by simdize_simple_statements_pass2().

Here is the call graph for this function:

Here is the caller graph for this function:

sac_aligned_entity_p()

bool sac_aligned_entity_p

(

entity

e

)

Definition at line 646 of file codegen.c.

{
    return same_stringn_p(entity_user_name(e),SAC_ALIGNED_VECTOR_NAME,sizeof(SAC_ALIGNED_VECTOR_NAME)-1);
}

References entity_user_name(), SAC_ALIGNED_VECTOR_NAME, and same_stringn_p.

Referenced by sac_aligned_expression_p(), and sac_commenter().

Here is the call graph for this function:

Here is the caller graph for this function:

sac_commenter()

string sac_commenter

(

entity

e

)

Definition at line 821 of file simdizer.c.

{
    if(sac_aligned_entity_p(e))
    {
        return strdup("SAC generated temporary array");
    }
    else if(simd_vector_entity_p(e))
    {
        string s,g = basic_to_string(entity_basic(e));
        asprintf(&s,"PIPS:SAC generated %s vector(s)", g);
        free(g);
        return s;
    }
    else
        return strdup("PIPS:SAC generated variable");
}

References asprintf, basic_to_string(), entity_basic(), free(), sac_aligned_entity_p(), simd_vector_entity_p(), and strdup().

Referenced by simdizer().

Here is the call graph for this function:

Here is the caller graph for this function:

sac_expression_reduction_p()

bool sac_expression_reduction_p

(

expression

e

)

reductions.c

Definition at line 55 of file reductions.c.

                                             {
    if(expression_reference_p(e)) {
        const char* refname = entity_user_name(reference_variable(expression_reference(e)));
        if(refname==strstr(refname,get_string_property("SIMD_REMOVE_REDUCTIONS_PREFIX")))
            return true;
    }
    return false;
}

References entity_user_name(), expression_reference(), expression_reference_p(), get_string_property(), and reference_variable.

Here is the call graph for this function:

scalar_renaming()

bool scalar_renaming

(

char *

mod_name

)

singleass.c

singleass.c

Get the resources

needed for vertex_to_statement

prune graph

Now do the job

Reorder the module, because new statements have been added

update/release resources

Parameters

mod_name

od_name

Definition at line 300 of file singleass.c.

{
    /* Get the resources */
    statement mod_stmt = (statement)
        db_get_memory_resource(DBR_CODE, mod_name, true);
    graph dg = (graph) db_get_memory_resource(DBR_DG, mod_name, true);
 
    set_current_module_statement(mod_stmt);
    set_current_module_entity(module_name_to_entity(mod_name));
    set_ordering_to_statement(mod_stmt); /* needed for vertex_to_statement */
 
    set_proper_rw_effects((statement_effects)
                    db_get_memory_resource(DBR_PROPER_EFFECTS, mod_name, true));
 
    debug_on("SCALAR_RENAMING_DEBUG_LEVEL");
 
    /* prune graph */
    simplify_dg(get_current_module_entity(),dg);
 
    /* Now do the job */
    do_scalar_renaming(get_current_module_entity(),get_current_module_statement(),dg);
 
    pips_assert("Statement is consistent after SCALAR_RENAMING",
            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();
    reset_proper_rw_effects();
        reset_ordering_to_statement();
 
    debug_off();
 
    return true;
}

References db_get_memory_resource(), DB_PUT_MEMORY_RESOURCE, debug_off, debug_on, dg, do_scalar_renaming(), get_current_module_entity(), get_current_module_statement(), module_name_to_entity(), module_reorder(), pips_assert, reset_current_module_entity(), reset_current_module_statement(), reset_ordering_to_statement(), reset_proper_rw_effects(), set_current_module_entity(), set_current_module_statement(), set_ordering_to_statement(), set_proper_rw_effects(), simplify_dg(), and statement_consistent_p().

Here is the call graph for this function:

set_simd_operator_mappings()

void set_simd_operator_mappings

(

void *

m

)

operatorid.c

Definition at line 43 of file operatorid.c.

{
    pips_assert("not already set",mappings==NULL);
    mappings=m;
}

References mappings, and pips_assert.

Referenced by simd_operator_mappings(), simd_unroll_as_needed(), and simdizer().

Here is the caller graph for this function:

set_simd_treematch()

void set_simd_treematch

(

matchTree

t

)

treematch.c

Definition at line 46 of file treematch.c.

{
    pips_assert("tree match not already set",patterns_tree==NULL);
    patterns_tree=t;
}

References patterns_tree, and pips_assert.

Referenced by simd_treematcher(), simd_unroll_as_needed(), and simdizer().

Here is the caller graph for this function:

simd_atomize_this_expression()

statement simd_atomize_this_expression	(	entity(*)(entity, basic)	create,
		expression	e
	)

atomizer.c

atomizer.c

it does not make sense to atomize a range...

SG: in case of expression similar to (a+2), if a is a short (or a char ...), the user may expect the result is a short too the C syntax expect 2 is an int set the property to false if you want to override this behavior

force all integer to char, then compute the basic validate only if we can guess the size from something not a constant integer

Definition at line 87 of file atomizer.c.

{
    basic bofe = basic_undefined;
 
    /* it does not make sense to atomize a range...
    */
    if (syntax_range_p(expression_syntax(e))) return NULL;
 
    /* SG: in case of expression similar to (a+2), if a is a short (or a char ...),
     * the user may expect the result is a short too 
     * the C syntax expect 2 is an int
     * set the property to false if you want to override this behavior
     */
    if( get_bool_property("SIMD_OVERRIDE_CONSTANT_TYPE_INFERENCE") )
    {
        expression etemp = copy_expression(e);
        bool patch_all=true;
        /* force all integer to char, then compute the basic
         * validate only if we can guess the size from something not a constant integer
         */
        gen_context_recurse(etemp, &patch_all, syntax_domain, gen_true2, patch_constant_size);
        if( !patch_all )
            bofe=basic_of_expression(etemp);
        free_expression(etemp);
    }
 
    if(basic_undefined_p(bofe) )
        bofe = basic_of_expression(e);
 
    if(!basic_undefined_p(bofe)) {
        if (!basic_overloaded_p(bofe))
        {
            entity newvar = (*create)(get_current_module_entity(), bofe);
            AddEntityToCurrentModule(newvar);
            expression rhs = make_expression(expression_syntax(e), normalized_undefined);
            normalize_all_expressions_of(rhs);
            statement assign = make_assign_statement(entity_to_expression(newvar),rhs);
            expression_syntax(e) = make_syntax_reference( make_reference(newvar, NIL));
 
            return assign;
        }
 
        free_basic(bofe);
    }
    return NULL;
}

References AddEntityToCurrentModule(), basic_of_expression(), basic_overloaded_p, basic_undefined, basic_undefined_p, copy_expression(), entity_to_expression(), expression_syntax, free_basic(), free_expression(), gen_context_recurse, gen_true2(), get_bool_property(), get_current_module_entity(), make_assign_statement(), make_expression(), make_reference(), make_syntax_reference(), NIL, normalize_all_expressions_of(), normalized_undefined, patch_constant_size(), syntax_domain, and syntax_range_p.

Referenced by atomize_condition(), and simd_do_atomize().

Here is the call graph for this function:

Here is the caller graph for this function:

simd_atomizer()

bool simd_atomizer

(

char *

mod_name

)

get the resources

Now do the job

Reorder the module, because new statements have been added

update/release resources

Parameters

mod_name

od_name

Definition at line 361 of file atomizer.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("SIMD_ATOMIZER_DEBUG_LEVEL");
 
 
    /* Now do the job */
    gen_recurse(mod_stmt, statement_domain, gen_true, atomize_statements);
 
    /* 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 atomize_statements(), db_get_memory_resource(), DB_PUT_MEMORY_RESOURCE, debug_off, debug_on, gen_recurse, gen_true(), module_name_to_entity(), module_reorder(), reset_current_module_entity(), reset_current_module_statement(), set_current_module_entity(), set_current_module_statement(), and statement_domain.

Here is the call graph for this function:

simd_check_argType()

bool simd_check_argType

(

void

)

Definition at line 87 of file treematch.c.

{
    list pCurBas = curArgType;
 
    FOREACH(BASIC, finBas, finalArgType)
        {
                if(ENDP(pCurBas) )
                        return false;
                basic curBas = BASIC(CAR(pCurBas));
                if(!basic_equal_p(curBas, finBas))
                        return false;
                pCurBas = CDR(pCurBas);
        }
 
    gen_full_free_list(curArgType);
    curArgType = NIL;
 
    return true;
}

References BASIC, basic_equal_p(), CAR, CDR, curArgType, ENDP, finalArgType, FOREACH, gen_full_free_list(), and NIL.

Referenced by extract_matching_statements().

Here is the call graph for this function:

Here is the caller graph for this function:

simd_fill_curArgType()

void simd_fill_curArgType

(

statement

stat

)

Parameters

stat

tat

Definition at line 82 of file treematch.c.

{
    curArgType=simd_fill_curArgType_call(statement_call(stat));
}

References curArgType, simd_fill_curArgType_call(), and statement_call().

Referenced by extract_matching_statements().

Here is the call graph for this function:

Here is the caller graph for this function:

simd_fill_finalArgType()

void simd_fill_finalArgType

(

statement

stat

)

Parameters

stat

tat

Definition at line 77 of file treematch.c.

{
    finalArgType=simd_fill_curArgType_call(statement_call(stat));
}

References finalArgType, simd_fill_curArgType_call(), and statement_call().

Referenced by simdize_simple_statements_pass2().

Here is the call graph for this function:

Here is the caller graph for this function:

simd_memory_packing()

bool simd_memory_packing

(

char *

mod_name

)

simd_memory_packing.c

simd_memory_packing.c

Parameters

mod_name

name of the module to convert

Returns

false if something went wrong

get the resources

first step : create a vector <> array table

second step : look for any array `‘vectorized’' in the parameter and modify their type to fit the real array size

update/release resources

Parameters

mod_name

od_name

Definition at line 151 of file simd_memory_packing.c.

{
    bool failed = false;
        /* 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));
 
        /* first step : create a vector <> array table */
        hash_table array_to_vector = hash_table_make(hash_pointer,0);
        gen_context_recurse(mod_stmt, array_to_vector, statement_domain, gen_true2, simd_trace_call);
        if(( failed=hash_table_empty_p(array_to_vector)) )
        {
            pips_user_warning("I did not find any simd load / store operation :'(\n");
            goto simd_memory_packing_end;
        }
 
        /* second step : look for any array ``vectorized'' in the parameter
         * and modify their type to fit the real array size
         */
        {
            bool replaced_something = simd_replace_parameters(array_to_vector);
            if( ( failed = !replaced_something ) )
            {
                pips_user_warning("I did not find any vectorized array in module parameters :'(\n");
                goto simd_memory_packing_end;
            }
            text t = text_module(get_current_module_entity(),get_current_module_statement());
            add_new_module_from_text( mod_name,
                    t,
                    fortran_module_p(get_current_module_entity()),compilation_unit_of_module(get_current_module_name())
                    );
            free_text(t);
            /* update/release resources */
            hash_table_free(array_to_vector);
 
            reset_current_module_statement();
            reset_current_module_entity();
        }
 
simd_memory_packing_end:
    return !failed;
}

References add_new_module_from_text(), compilation_unit_of_module(), db_get_memory_resource(), fortran_module_p(), free_text(), gen_context_recurse, gen_true2(), get_current_module_entity(), get_current_module_name(), get_current_module_statement(), hash_pointer, hash_table_empty_p, hash_table_free(), hash_table_make(), module_name_to_entity(), pips_user_warning, reset_current_module_entity(), reset_current_module_statement(), set_current_module_entity(), set_current_module_statement(), simd_replace_parameters(), simd_trace_call(), statement_domain, and text_module().

Here is the call graph for this function:

simd_operator_mappings()

bool simd_operator_mappings

(

const

string

)

create a new operator id

put it in pipsdbm

Parameters

string

odule_name

Definition at line 174 of file operatorid.c.

{
  pips_assert("true", module_name==module_name);
    /* create a new operator id */
    operator_id_tree m= make_operator_id_tree(UNKNOWN_TOK,hash_table_make(hash_int,HASH_DEFAULT_SIZE));
    set_simd_operator_mappings(m);
 
    for(size_t i=0; operators[i].name != NULL; i++)
        insert_mapping(&operators[i]);
 
    /* put it in pipsdbm */
    DB_PUT_MEMORY_RESOURCE(DBR_SIMD_OPERATOR_MAPPINGS,"",m);
 
    reset_simd_operator_mappings();
    return true;
}

References DB_PUT_MEMORY_RESOURCE, HASH_DEFAULT_SIZE, hash_int, hash_table_make(), insert_mapping(), make_operator_id_tree(), module_name(), oper_id_mapping::name, operators, pips_assert, reset_simd_operator_mappings(), set_simd_operator_mappings(), and UNKNOWN_TOK.

Here is the call graph for this function:

simd_remove_reductions()

bool simd_remove_reductions

(

char *

mod_name

)

remove reductions by expanding reduced scalar to an array

Parameters

mod_name

module to remove reductions from

Returns

true

get the resources

Now do the job

Reorder the module, because new statements have been added

update/release resources

Parameters

mod_name

od_name

Definition at line 571 of file reductions.c.

{
 
    /* get the resources */
    set_current_module_statement((statement)db_get_memory_resource(DBR_CODE, mod_name,true));
    set_current_module_entity(module_name_to_entity(mod_name));
    set_cumulated_reductions((pstatement_reductions) db_get_memory_resource(DBR_CUMULATED_REDUCTIONS, mod_name, true));
 
    debug_on("SIMDREDUCTION_DEBUG_LEVEL");
 
    /* Now do the job */
    set skip = set_make(set_pointer);
    gen_context_recurse(get_current_module_statement(),skip, statement_domain, reduction_rewrite_filter, reductions_rewrite);
    set_free(skip);
 
    pips_assert("Statement is consistent after remove reductions", statement_consistent_p(get_current_module_statement()));
 
    /* Reorder the module, because new statements have been added */  
    clean_up_sequences(get_current_module_statement());
    module_reorder(get_current_module_statement());
    DB_PUT_MEMORY_RESOURCE(DBR_CODE, mod_name, get_current_module_statement());
    DB_PUT_MEMORY_RESOURCE(DBR_CALLEES, mod_name, compute_callees(get_current_module_statement()));
 
    /* update/release resources */
    reset_cumulated_reductions();
    reset_current_module_statement();
    reset_current_module_entity();
 
    debug_off();
 
    return true;
}

References clean_up_sequences(), compute_callees(), db_get_memory_resource(), DB_PUT_MEMORY_RESOURCE, debug_off, debug_on, gen_context_recurse, get_current_module_statement(), module_name_to_entity(), module_reorder(), pips_assert, reduction_rewrite_filter(), reductions_rewrite(), reset_cumulated_reductions(), reset_current_module_entity(), reset_current_module_statement(), set_cumulated_reductions(), set_current_module_entity(), set_current_module_statement(), set_free(), set_make(), set_pointer, statement_consistent_p(), and statement_domain.

Here is the call graph for this function:

simd_reset_finalArgType()

void simd_reset_finalArgType

(

void

)

Definition at line 61 of file treematch.c.

{
    gen_free_list(finalArgType);
    finalArgType = NIL;
 
    gen_free_list(curArgType);
    curArgType = NIL;
}

References curArgType, finalArgType, gen_free_list(), and NIL.

Referenced by simdize_simple_statements_pass2().

Here is the call graph for this function:

Here is the caller graph for this function:

simd_treematcher()

bool simd_treematcher

(

const

string

)

create a new tree match

fill it

put it in pipsdbm

clean up

Parameters

string

odule_name

Definition at line 310 of file treematch.c.

{
  pips_assert("true", module_name==module_name);
    /* create a new tree match */
    matchTree treematch = make_tree();
    set_simd_treematch(treematch);
 
    /* fill it */
    sac_lineno=0;
    patterns_yyin=fopen_config("patterns.def","SIMD_PATTERN_FILE",NULL);
    patterns_yyparse();
    fclose(patterns_yyin);
 
    /* put it in pipsdbm */
    DB_PUT_MEMORY_RESOURCE(DBR_SIMD_TREEMATCH,"",treematch);
 
    /* clean up */
    reset_simd_treematch();
    return true;
}

References DB_PUT_MEMORY_RESOURCE, fopen_config(), make_tree(), module_name(), patterns_yyin, patterns_yyparse(), pips_assert, reset_simd_treematch(), sac_lineno, and set_simd_treematch().

Here is the call graph for this function:

simd_vector_entity_p()

bool simd_vector_entity_p

(

entity

e

)

Definition at line 197 of file codegen.c.

{
    return 
        strstr(entity_user_name(e),VECTOR_POSTFIX)
        && type_variable_p(entity_type(e))
        && !entity_scalar_p(e);
    ;
}

References entity_scalar_p(), entity_type, entity_user_name(), type_variable_p, and VECTOR_POSTFIX.

Referenced by get_basic_from_opcode(), and sac_commenter().

Here is the call graph for this function:

Here is the caller graph for this function:

simdizer()

bool simdizer

(

char *

mod_name

)

get the resources

Now do the job

Reorder the module, because new statements have been added

update/release resources

Parameters

mod_name

od_name

Definition at line 854 of file simdizer.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));
    set_ordering_to_statement(mod_stmt);
    simdizer_context sc = { .dg = (graph) db_get_memory_resource(DBR_DG, mod_name, true),
        .nb_enclosing_loops = 0,
                            .result = false };
    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));
    statement_effects se = (statement_effects)db_get_memory_resource(DBR_PROPER_EFFECTS,mod_name,true);
    remove_preferences(se);
    set_proper_rw_effects(se);
    push_generated_variable_commenter(sac_commenter);
    set_conflict_testing_properties();
 
    debug_on("SIMDIZER_DEBUG_LEVEL");
 
    /* Now do the job */
    gen_context_multi_recurse(mod_stmt, &sc, statement_domain,
            simd_simple_sequence_filter, simdize_simple_statements,
            loop_domain, incr_counter,decr_counter,
            NULL);
 
    pips_assert("Statement is consistent after SIMDIZER", 
            statement_consistent_p(mod_stmt));
 
    /* Reorder the module, because new statements have been added */  
    clean_up_sequences(mod_stmt);
    module_reorder(mod_stmt);
    DB_PUT_MEMORY_RESOURCE(DBR_CODE, mod_name, mod_stmt);
    DB_PUT_MEMORY_RESOURCE(DBR_CALLEES, mod_name, compute_callees(mod_stmt));
    //DB_PUT_MEMORY_RESOURCE(DBR_DG, mod_name, dependence_graph);
 
    /* update/release resources */
    reset_proper_rw_effects();
    reset_simd_operator_mappings();
    reset_simd_treematch();
        reset_ordering_to_statement();
    reset_current_module_statement();
    reset_current_module_entity();
    pop_generated_variable_commenter();
 
    debug_off();
 
    return sc.result;
}

References clean_up_sequences(), compute_callees(), db_get_memory_resource(), DB_PUT_MEMORY_RESOURCE, debug_off, debug_on, decr_counter(), simdizer_context::dg, gen_context_multi_recurse(), incr_counter(), loop_domain, module_name_to_entity(), module_reorder(), pips_assert, pop_generated_variable_commenter(), push_generated_variable_commenter(), remove_preferences(), reset_current_module_entity(), reset_current_module_statement(), reset_ordering_to_statement(), reset_proper_rw_effects(), reset_simd_operator_mappings(), reset_simd_treematch(), simdizer_context::result, sac_commenter(), set_conflict_testing_properties(), set_current_module_entity(), set_current_module_statement(), set_ordering_to_statement(), set_proper_rw_effects(), set_simd_operator_mappings(), set_simd_treematch(), simd_simple_sequence_filter(), simdize_simple_statements(), statement_consistent_p(), and statement_domain.

Here is the call 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_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:

simdizer_init()

bool simdizer_init

(

const char *

module_name

)

get the resources

normalize blocks

then split blocks containing declarations statement

then split blocks containing labeled statement

sort commutative operators

reset

Parameters

module_name

odule_name

Definition at line 1023 of file simdizer.c.

{
    /* get the resources */
    set_current_module_statement((statement)db_get_memory_resource(DBR_CODE, module_name, true));
    set_current_module_entity(module_name_to_entity(module_name));
 
    /* normalize blocks */
    clean_up_sequences(get_current_module_statement());
 
    /* then split blocks containing declarations statement */
    gen_recurse(get_current_module_statement(), statement_domain, gen_true, do_split_decl_block_statements);
 
    /* then split blocks containing labeled statement */
    gen_recurse(get_current_module_statement(), statement_domain, gen_true, do_split_block_statements);
 
    /* sort commutative operators */
    gen_recurse(get_current_module_statement(),call_domain,gen_true,do_simdizer_init);
 
    module_reorder(get_current_module_statement());
    DB_PUT_MEMORY_RESOURCE(DBR_CODE, module_name, get_current_module_statement());
 
    /* reset */
    reset_current_module_statement();
    reset_current_module_entity();
 
    return true;
 
}

References call_domain, clean_up_sequences(), db_get_memory_resource(), DB_PUT_MEMORY_RESOURCE, do_simdizer_init(), do_split_block_statements(), do_split_decl_block_statements(), gen_recurse, gen_true(), get_current_module_statement(), module_name(), module_name_to_entity(), module_reorder(), reset_current_module_entity(), reset_current_module_statement(), set_current_module_entity(), set_current_module_statement(), and statement_domain.

Here is the call graph for this function:

Variable Documentation

patterns_yy_flex_debug

int patterns_yy_flex_debug

extern

patterns_yychar

int patterns_yychar

extern

patterns_yyin

FILE* patterns_yyin

extern

symbols exported by the parser

Definition at line 157 of file sac.h.

patterns_yyleng

int patterns_yyleng

extern

lexer.c

patterns_yylineno

int patterns_yylineno

extern

patterns_yynerrs

int patterns_yynerrs

extern

patterns_yyout

FILE* patterns_yyout

extern

patterns_yytext

char* patterns_yytext

extern

sac_current_block

statement sac_current_block

extern

Definition at line 722 of file simdizer.c.

Referenced by make_new_simd_vector_with_prefix(), and simdize_simple_statements().

sac_lineno

size_t sac_lineno

extern

patterns.c

Definition at line 149 of file sac.h.

Referenced by patterns_yyerror(), and simd_treematcher().

sac_real_current_instruction

instruction sac_real_current_instruction

extern

Definition at line 723 of file simdizer.c.

Referenced by make_loadsave_statement(), and simdize_simple_statements().