directives.c File Reference

#include "defines-local.h"
#include "resources.h"
#include "control.h"

Include dependency graph for directives.c:

Go to the source code of this file.

Data Structures
struct	DirectiveHandler
	finds the handler for a given entity. More...

Macros
#define	HANDLER(name)   handle_##name##_directive
	each directive is handled by a function here. More...

Functions
static void	clean_statement (statement s)
	the directive is freed and replaced by a continue call or a copy loop nest, depending on the renamings. More...
static void	add_statement_to_clean (statement s)
void	add_a_dynamic (entity c)
	local primary dynamics More...
void	hpfc_directives_error_handler ()
	the local stack is used to retrieve the current statement while scanning the AST with gen_recurse. More...
static void	switch_basic_type_to_overloaded (entity e)
	management of PROCESSORS and TEMPLATE directives. More...
static void	new_processor (expression e)
static void	new_template (expression e)
static void	new_dynamic (expression e)
static void	new_io_function (expression e)
static void	new_fake_function (expression e)
static void	new_pure_function (expression e)
static void	array_as_template (entity array)
	array is to be seen as a template. More...
static bool	alignment_p (list align_src, expression subscript, int *padim, Value *prate, Value *pshift)
	one simple ALIGN directive is handled. More...
static align	extract_the_align (reference alignee, reference temp, list lopt)
	builds an align from the alignee and template references. More...
static void	initial_alignment (statement s)
	handle s as the initial alignment... More...
static void	one_align_directive (reference alignee, reference temp, list lopt, bool dynamic)
	handle a simple (re)align directive. More...
static bool	align_indices_p (entity f)
	hack, the common indices of a free form align is stored in a BLOCK() More...
static void	handle_align_and_realign_directive (_UNUSED_ entity f, list args, bool dynamic)
	handle a full (re)align directive. More...
static tag	distribution_format (expression e, list *pl)
	one DISTRIBUTE directive management More...
static distribute	extract_the_distribute (reference distributee, reference proc)
	builds the distribute from the distributee and processor references. More...
static void	one_distribute_directive (reference distributee, reference proc, bool dynamic)
	handles a simple (one template) distribute or redistribute directive. More...
static void	handle_distribute_and_redistribute_directive (_UNUSED_ entity f, list args, bool dynamic)
	handles a full distribute or redistribute directive. More...
static void	handle_unexpected_directive (_UNUSED_ entity f, _UNUSED_ list args)
static void	handle_processors_directive (_UNUSED_ entity f, list args)
static void	handle_template_directive (_UNUSED_ entity f, list args)
static void	handle_align_directive (entity f, list args)
static void	handle_distribute_directive (entity f, list args)
static void	handle_reduction_directive (_UNUSED_ entity f, list args)
	I chose not to modify the ri to add reductions as private variables. More...
static void	handle_independent_directive (_UNUSED_ entity f, list args)
	??? I wait for the next statements in a particular order, what should not be necessary. More...
static void	handle_new_directive (_UNUSED_ entity f, _UNUSED_ list args)
	??? not implemented and not used. More...
static void	handle_dynamic_directive (_UNUSED_ entity f, list args)
static void	handle_pure_directive (_UNUSED_ entity f, list args)
	may be used to declare functions as pure. More...
static void	handle_io_directive (_UNUSED_ entity f, list args)
static void	handle_fake_directive (_UNUSED_ entity f, list args)
static void	handle_realign_directive (entity f, list args)
static void	handle_redistribute_directive (entity f, list args)
static void	handle_synchro_directive (_UNUSED_ entity f, _UNUSED_ list args)
static void	handle_time_directive (_UNUSED_ entity f, _UNUSED_ list args)
	for both timeon and timeoff More...
static void	handle_host_section_directive (_UNUSED_ entity f, _UNUSED_ list args)
static void	handle_set_directive (entity f, list args)
	for both setbool and setint ??? looks like a hack:-) More...
static void	handle_prescriptive_directive (_UNUSED_ entity f, list args)
	prescriptive mappings before a call. More...
static void	handle_kill_directive (_UNUSED_ entity f, _UNUSED_ list args)
	tells the compiler that the array values are dead from now on. More...
static void	handle_nothing_directive (entity f, _UNUSED_ list args)
static bool	directive_managed_now_p (const char *name)
static bool	directive_filter (call c)
	newgen recursion thru the IR. More...
static bool	prescription_filter (call c)
void	handle_hpf_directives (statement s, bool dyn)
	void handle_hpf_directives(s) statement s; More...

Variables
static int	analysis_phase = 0
	HPFC module by Fabien COELHO. More...
static list	to_be_cleaned = NIL
	list of statements to be cleaned. More...
static struct DirectiveHandler	handlers []
static void(*)(entity, list)	directive_handler (const char *name)
	returns the handler for directive name. More...

Macro Definition Documentation

HANDLER

#define HANDLER

(

name

)

handle_##name##_directive

each directive is handled by a function here.

these handlers may use the statement stack to proceed. I may add some handlers for private directives?

Definition at line 650 of file directives.c.

Function Documentation

add_a_dynamic()

void add_a_dynamic

(

entity

c

)

local primary dynamics

Definition at line 99 of file directives.c.

{
  the_dynamics_object = gen_once(c, the_dynamics_object);
}

References gen_once().

Referenced by hpfc_translate_call_with_distributed_args(), and new_dynamic().

Here is the call graph for this function:

Here is the caller graph for this function:

add_statement_to_clean()

static void add_statement_to_clean ( statement  s )

static

Definition at line 90 of file directives.c.

{
  to_be_cleaned = CONS(STATEMENT, s, to_be_cleaned);
}

References CONS, STATEMENT, and to_be_cleaned.

Referenced by directive_filter(), handle_set_directive(), handle_synchro_directive(), and handle_time_directive().

Here is the caller graph for this function:

align_indices_p()

static bool align_indices_p ( entity  f )

static

hack, the common indices of a free form align is stored in a BLOCK()

Definition at line 406 of file directives.c.

{
    return same_string_p(entity_local_name(f), HPF_PREFIX BLOCK_SUFFIX);
}

References BLOCK_SUFFIX, entity_local_name(), f(), HPF_PREFIX, and same_string_p.

Referenced by handle_align_and_realign_directive().

Here is the call graph for this function:

Here is the caller graph for this function:

alignment_p()

static bool alignment_p ( list  align_src, expression  subscript, int *  padim, Value *  prate, Value *  pshift  )

static

one simple ALIGN directive is handled.

retrieve the alignment from references array and template true if the template dimension subscript is an alignment. false if the dimension is replicated.

else the subscript is affine

the alignment should be a simple affine expression

constant alignment case

affine alignment case

alignment ok

matching array dimension not found, replicated!

Parameters

align_src

of expressions

Definition at line 193 of file directives.c.

{
    normalized n = expression_normalized(subscript);
    Pvecteur v, v_src;
    int size, array_dim;
 
    if (normalized_complex_p(n)) return false;
 
    /*  else the subscript is affine
     */
    v = normalized_linear(n);
    size = vect_size(v);
    *pshift = vect_coeff(TCST, v);
 
    /*  the alignment should be a simple affine expression
     */
    pips_user_assert("affine align subscript", *pshift==0 ? size<=1 : size<=2);
 
    /*   constant alignment case
     */
    if (size==0 || (*pshift!=0 && size==1))
    {
        *padim = 0, *prate = 0;
        return true;
    }
 
    /*   affine alignment case
     */
    for(array_dim = 1; !ENDP(align_src); POP(align_src), array_dim++)
    {
        n = expression_normalized(EXPRESSION(CAR(align_src)));
        if (normalized_linear_p(n))
        {
            v_src = normalized_linear(n);
 
            pips_user_assert("simple index",
                             vect_size(v_src)==1 && var_of(v_src)!=TCST);
 
            *prate = vect_coeff(var_of(v_src), v);
 
            if (*prate!=0)
            {
                *padim = array_dim;
                return true;   /* alignment ok */
            }
        }
    }
 
    /*   matching array dimension not found, replicated!
     */
    *padim = 0, *prate = 0;
    return false;
}

References CAR, ENDP, EXPRESSION, expression_normalized, normalized_complex_p, normalized_linear, normalized_linear_p, pips_user_assert, POP, TCST, var_of, vect_coeff(), and vect_size().

Referenced by extract_the_align().

Here is the call graph for this function:

Here is the caller graph for this function:

array_as_template()

static void array_as_template ( entity  array )

static

array is to be seen as a template.

aligned to itself...

of alignment

Definition at line 170 of file directives.c.

{
    int ndim = NumberOfDimension(array);
    list /* of alignment */ l = NIL;
 
    set_array_as_distributed(array);
    set_template(array);
 
    for(; ndim>0; ndim--)
        l = CONS(ALIGNMENT, make_alignment(ndim, ndim,
                                           int_to_expression(1),
                                           int_to_expression(0)), l);
 
    store_hpf_alignment(array, make_align(l, array));
}

References ALIGNMENT, array, CONS, int_to_expression(), make_align(), make_alignment(), NIL, NumberOfDimension(), set_array_as_distributed(), set_template(), and store_hpf_alignment().

Referenced by extract_the_align(), extract_the_distribute(), and one_distribute_directive().

Here is the call graph for this function:

Here is the caller graph for this function:

clean_statement()

static void clean_statement ( statement  s )

static

the directive is freed and replaced by a continue call or a copy loop nest, depending on the renamings.

of renamings

of statements

Do not forget to move forbidden information associated with block:

Definition at line 56 of file directives.c.

{
    instruction i = statement_instruction(s);
 
    pips_assert("call", instruction_call_p(i));
 
    free_call(instruction_call(i));
    instruction_call(i) = call_undefined;
 
    if (bound_renamings_p(s))
    {
        list /* of renamings */  lr = load_renamings(s),
             /* of statements */ block = NIL;
 
        MAP(RENAMING, r,
        {
            entity o = renaming_old(r);
            entity n = renaming_new(r);
 
            block = CONS(STATEMENT, generate_copy_loop_nest(o, n), block);
        },
            lr);
 
        free_instruction(i);
        statement_instruction(s) = make_instruction_block(block);
        /* Do not forget to move forbidden information associated with
           block: */
        fix_sequence_statement_attributes(s);
    }
    else
      instruction_call(i) =
        make_call(entity_intrinsic(CONTINUE_FUNCTION_NAME), NIL);
}

References bound_renamings_p(), call_undefined, CONS, CONTINUE_FUNCTION_NAME, entity_intrinsic(), fix_sequence_statement_attributes(), free_call(), free_instruction(), generate_copy_loop_nest(), instruction_call, instruction_call_p, load_renamings(), make_call(), make_instruction_block(), MAP, NIL, pips_assert, RENAMING, renaming_new, renaming_old, STATEMENT, and statement_instruction.

Referenced by handle_hpf_directives().

Here is the call graph for this function:

Here is the caller graph for this function:

directive_filter()

static bool directive_filter ( call  c )

static

newgen recursion thru the IR.

Definition at line 1017 of file directives.c.

{
  entity f = call_function(c);
 
  // DIRECTIVES
  if (hpf_directive_entity_p(f))
  {
    const char* name = entity_local_name(f);
    pips_debug(8, "hpfc entity is %s\n", entity_name(f));
 
    // call the appropriate handler for the directive.
    (directive_handler(name))(f, call_arguments(c));
 
    // the current statement will have to be cleaned.
    if (directive_managed_now_p(name) && !keep_directive_in_code_p(name))
      add_statement_to_clean(current_stmt_head());
  }
 
  return false; // no instructions within a call!
}

References add_statement_to_clean(), call_arguments, call_function, current_stmt_head, directive_handler, directive_managed_now_p(), entity_local_name(), entity_name, f(), hpf_directive_entity_p(), keep_directive_in_code_p(), and pips_debug.

Referenced by handle_hpf_directives().

Here is the call graph for this function:

Here is the caller graph for this function:

directive_managed_now_p()

static bool directive_managed_now_p ( const char *  name )

static

Definition at line 1010 of file directives.c.

{
    return directive_handler(name)!=HANDLER(nothing);
}

References directive_handler, and HANDLER.

Referenced by directive_filter().

Here is the caller graph for this function:

distribution_format()

static tag distribution_format ( expression  e, list *  pl  )

static

one DISTRIBUTE directive management

returns the expected style tag for the given distribution format, plus a pointer to the list of arguments.

BLOCK()

CYCLIC()

just to avoid a gcc warning

Parameters

pl	of expressions

Definition at line 451 of file directives.c.

{
    syntax s = expression_syntax(e);
    entity function;
    const char* name;
    call c;
 
    pips_assert("valid distribution format", syntax_call_p(s));
 
    c = syntax_call(s);
    function = call_function(c);
    *pl = call_arguments(c);
 
    pips_assert("valid distribution format", hpf_directive_entity_p(function));
 
    name = entity_local_name(function);
    
    if (same_string_p(name, HPF_PREFIX BLOCK_SUFFIX))  /* BLOCK() */
        return is_style_block;
    else 
    if (same_string_p(name, HPF_PREFIX CYCLIC_SUFFIX)) /* CYCLIC() */
        return is_style_cyclic;
    else
    if (same_string_p(name, HPF_PREFIX STAR_SUFFIX))   /* * [star] */
        return is_style_none;
    else
        pips_user_error("invalid distribution format");
 
    return 0; /* just to avoid a gcc warning */
}

References BLOCK_SUFFIX, call_arguments, call_function, CYCLIC_SUFFIX, entity_local_name(), expression_syntax, hpf_directive_entity_p(), HPF_PREFIX, is_style_block, is_style_cyclic, is_style_none, pips_assert, pips_user_error, pl, same_string_p, STAR_SUFFIX, syntax_call, and syntax_call_p.

Referenced by extract_the_distribute().

Here is the call graph for this function:

Here is the caller graph for this function:

extract_the_align()

static align extract_the_align ( reference  alignee, reference  temp, list  lopt  )

static

builds an align from the alignee and template references.

used by both align and realign management.

of alignments

of expressions

each array dimension is looked for a possible alignment

align A with T - implicit alignment

explicit alignment

for an alignment tree I should check here whether template is aligned to sg, and update accordingly. Also backtracking already built alignments when a "template" happens to be aligned would be useful. Some day...

built align is returned. should be normalized?

Parameters

lopt	of expression

Definition at line 253 of file directives.c.

{
    list/* of alignments  */ aligns    = NIL,
        /* of expressions */ align_src = reference_indices(alignee),
                             align_sub = reference_indices(temp);
    entity template = reference_variable(temp),
           array = reference_variable(alignee);
    int array_dim, template_dim, tndim, andim;
    Value rate, shift;
 
    if (!entity_template_p(template))
        array_as_template(template);
 
    pips_user_assert("align with a template", entity_template_p(template));
    pips_user_assert("one set of indices", !(lopt && align_src));
 
    if (lopt) align_src = lopt;
 
    tndim = NumberOfDimension(template);
    andim = NumberOfDimension(array);
 
    /*  each array dimension is looked for a possible alignment
     */
 
    if (ENDP(align_src)) /* align A with T - implicit alignment */
    {
        int dim, ndim, tlower, alower, unused;
 
        pips_user_assert("no template subscripts", ENDP(align_sub));
        ndim=MIN(andim, tndim);
 
        for (dim=1; dim<=ndim; dim++)
        {
            get_entity_dimensions(template, dim, &tlower, &unused);
            get_entity_dimensions(array, dim, &alower, &unused);
 
            aligns = CONS(ALIGNMENT,
                          make_alignment(dim, dim,
                                         int_to_expression(1),
                                         int_to_expression(-alower+tlower)),
                          aligns);
        }
    }
    else /* explicit alignment */
    {
        pips_user_assert("align-source-list length = rank",
                   (int)gen_length(align_src) == andim);
        pips_user_assert("align-subscript-list length = rank",
                   (int)gen_length(align_sub) == tndim);
 
        for(template_dim=1; !ENDP(align_sub); POP(align_sub), template_dim++)
        {
            if (alignment_p(align_src, EXPRESSION(CAR(align_sub)),
                            &array_dim, &rate, &shift))
                aligns = CONS(ALIGNMENT,
                              make_alignment(array_dim,
                                             template_dim,
                                             Value_to_expression(rate),
                                             Value_to_expression(shift)),
                              aligns);
        }
    }
 
    /* for an alignment tree I should check here whether template is
     * aligned to sg, and update accordingly. Also backtracking already
     * built alignments when a "template" happens to be aligned would be
     * useful. Some day...
     */
    /* built align is returned. should be normalized?
     */
    return make_align(aligns, template);
}

References ALIGNMENT, alignment_p(), array, array_as_template(), CAR, CONS, ENDP, entity_template_p(), EXPRESSION, gen_length(), get_entity_dimensions(), int_to_expression(), make_align(), make_alignment(), MIN, NIL, NumberOfDimension(), pips_user_assert, POP, reference_indices, reference_variable, and Value_to_expression().

Referenced by one_align_directive().

Here is the call graph for this function:

Here is the caller graph for this function:

extract_the_distribute()

static distribute extract_the_distribute ( reference  distributee, reference  proc  )

static

builds the distribute from the distributee and processor references.

of expressions

keep the non empty one

of distributions

the template arguments are scanned to build the distribution

distribute T onto P - implicit

explicit distribution

implicit size

explicit size

Definition at line 486 of file directives.c.

{
    expression parameter = expression_undefined;
    entity processor = reference_variable(proc),
           template = reference_variable(distributee);
    list/* of expressions */   largs,
        lformat = reference_indices(distributee)? /* keep the non empty one */
            reference_indices(distributee): reference_indices(proc),
        /* of distributions */ ldist = NIL;
    int npdim, ntdim;
    tag format;
 
    if (!entity_template_p(template))
        array_as_template(template);
 
    ntdim = NumberOfDimension(template);
    npdim = NumberOfDimension(processor);
 
    pips_user_assert("more template dimensions than processor dimensions",
                     ntdim>=npdim);
 
    /* the template arguments are scanned to build the distribution
     */
    if (ENDP(lformat)) /* distribute T onto P - implicit */
    {
        int dim;
        for (dim=1; dim<=npdim; dim++)
            ldist = CONS(DISTRIBUTION,
                         make_distribution(make_style(is_style_block, UU),
                                           expression_undefined),
                         ldist);
    }
    else /* explicit distribution */
    {
        for(; !ENDP(lformat); POP(lformat))
        {
            format = distribution_format(EXPRESSION(CAR(lformat)), &largs);
            
            switch (format)
            {
            case is_style_block:
            case is_style_cyclic:
                pips_assert("valid distribution", gen_length(largs)<=1);
                
                parameter = ENDP(largs) ? 
                    expression_undefined :                /* implicit size */
                 copy_expression(EXPRESSION(CAR(largs))); /* explicit size */
                
                break;
            case is_style_none:
                parameter = expression_undefined;
                break;
            default:
                pips_internal_error("unexpected style tag (%d)", format);
            }
            
            ldist = CONS(DISTRIBUTION, 
                         make_distribution(make_style(format, UU), parameter),
                         ldist);
        }
    }
    
    return make_distribute(gen_nreverse(ldist), processor);
}

References array_as_template(), CAR, CONS, copy_expression(), DISTRIBUTION, distribution_format(), ENDP, entity_template_p(), EXPRESSION, expression_undefined, gen_length(), gen_nreverse(), is_style_block, is_style_cyclic, is_style_none, make_distribute(), make_distribution(), make_style(), NIL, NumberOfDimension(), pips_assert, pips_internal_error, pips_user_assert, POP, reference_indices, reference_variable, and UU.

Referenced by one_distribute_directive().

Here is the call graph for this function:

Here is the caller graph for this function:

handle_align_and_realign_directive()

static void handle_align_and_realign_directive ( _UNUSED_ entity  f, list  args, bool  dynamic  )

static

handle a full (re)align directive.

just decompose into simple alignments...

of expression

last points to the last item of args, which should be the template

Parameters

args	of expressions

Definition at line 415 of file directives.c.

{
    list /* of expression */ last = gen_last(args), lopt=NIL;
    reference template;
    expression first;
 
    /* last points to the last item of args, which should be the template
     */
    pips_user_assert("align sg with sg", gen_length(args)>=2);
    template = expression_to_reference(EXPRESSION(CAR(last)));
 
    gen_map((gen_iter_func_t)normalize_all_expressions_of, args);
 
    if (dynamic) store_renamings(current_stmt_head(), NIL);
 
    first = EXPRESSION(CAR(args));
    if (align_indices_p(expression_to_entity(first)))
    {
        pips_debug(5, "external align indices\n");
        lopt = call_arguments(syntax_call(expression_syntax(first)));
        POP(args);
    }
 
    for(; args!=last; POP(args))
      one_align_directive(expression_to_reference(EXPRESSION(CAR(args))),
                          template, lopt, dynamic);
}

References align_indices_p(), call_arguments, CAR, current_stmt_head, EXPRESSION, expression_syntax, expression_to_entity(), expression_to_reference(), gen_last(), gen_length(), gen_map(), NIL, normalize_all_expressions_of(), one_align_directive(), pips_debug, pips_user_assert, POP, store_renamings(), and syntax_call.

Referenced by handle_align_directive(), and handle_realign_directive().

Here is the call graph for this function:

Here is the caller graph for this function:

handle_align_directive()

static void handle_align_directive ( entity  f, list  args  )

static

Definition at line 672 of file directives.c.

{
    handle_align_and_realign_directive(f, args, false);
}

References f(), and handle_align_and_realign_directive().

Here is the call graph for this function:

handle_distribute_and_redistribute_directive()

static void handle_distribute_and_redistribute_directive ( _UNUSED_ entity  f, list  args, bool  dynamic  )

static

handles a full distribute or redistribute directive.

of expression

last points to the last item of args, which should be the processors

calls the simple case handler.

Definition at line 619 of file directives.c.

{
    list /* of expression */ last = gen_last(args);
    reference proc;
 
    if (dynamic) store_renamings(current_stmt_head(), NIL);
 
    /* last points to the last item of args, which should be the processors
     */
    pips_user_assert("distribute sg with sg", gen_length(args)>=2);
    proc = expression_to_reference(EXPRESSION(CAR(last)));
    gen_map((gen_iter_func_t)normalize_all_expressions_of, args);
 
    /*  calls the simple case handler.
     */
    for(; args!=last; POP(args))
       one_distribute_directive(expression_to_reference(EXPRESSION(CAR(args))),
                                proc, dynamic);
}

References CAR, current_stmt_head, EXPRESSION, expression_to_reference(), gen_last(), gen_length(), gen_map(), NIL, normalize_all_expressions_of(), one_distribute_directive(), pips_user_assert, POP, and store_renamings().

Referenced by handle_distribute_directive(), and handle_redistribute_directive().

Here is the call graph for this function:

Here is the caller graph for this function:

handle_distribute_directive()

static void handle_distribute_directive ( entity  f, list  args  )

static

Definition at line 678 of file directives.c.

{
    handle_distribute_and_redistribute_directive(f, args, false);
}

References f(), and handle_distribute_and_redistribute_directive().

Here is the call graph for this function:

handle_dynamic_directive()

static void handle_dynamic_directive ( _UNUSED_ entity  f, list  args  )

static

see new_dynamic

Definition at line 783 of file directives.c.

{
    gen_map((gen_iter_func_t)new_dynamic, args); /* see new_dynamic */
}

References gen_map(), and new_dynamic().

Here is the call graph for this function:

handle_fake_directive()

static void handle_fake_directive ( _UNUSED_ entity  f, list  args  )

static

Definition at line 814 of file directives.c.

{
    entity module = get_current_module_entity();
    if (ENDP(args))
        add_a_fake_function(module);
    else
        gen_map((gen_iter_func_t)new_fake_function, args);
}

References add_a_fake_function(), ENDP, gen_map(), get_current_module_entity(), module, and new_fake_function().

Here is the call graph for this function:

handle_host_section_directive()

static void handle_host_section_directive ( _UNUSED_ entity  f, _UNUSED_ list  args  )

static

Definition at line 854 of file directives.c.

{
    pips_debug(8, "host section\n");
    return;
}

References pips_debug.

handle_hpf_directives()

void handle_hpf_directives	(	statement	s,
		bool	dyn
	)

void handle_hpf_directives(s) statement s;

what: handles the HPF directives in statement s. how: recurses thru the AST, looking for special "directive calls". when found, a special handler is called for the given directive. input: the code statement s output: none side effects: (many)

• the hpfc data structures are set/updated to store the hpf mapping.
• parallel loops are tagged parallel.
• a static stack is used to retrieve the current statement.
• the ctrl_graph travelling is used, so should be initialized.
• the special calls are freed and replaced by continues. bugs or features:
• the "new" directive is not used to tag private variables.
• a non hpf "pure" directive is parsed.

INITIALIZE needed static stuff

PHASE 1

PHASE 2

PHASE 3

OPTIMIZATION

CLEAN

Parameters

dyn

yn

Definition at line 1069 of file directives.c.

{
    /* INITIALIZE needed static stuff
     */
    make_current_stmt_stack();
    to_be_cleaned = NIL;
 
    if (!dyn)
    {
    /* PHASE 1
     */
    pips_debug(1, "starting phase 1\n");
    analysis_phase = 1;
    gen_multi_recurse(s,
        statement_domain,  current_stmt_filter, current_stmt_rewrite,
        expression_domain, gen_false,           gen_null,
        call_domain,       directive_filter,    gen_null,
                      NULL);
    }
    else
    {
    /* PHASE 2
     */
    init_dynamic_locals();
    init_the_dynamics();
    store_renamings(s, NIL);
 
    pips_debug(1, "starting phase 2\n");
    analysis_phase = 2;
    gen_multi_recurse(s,
        statement_domain,  current_stmt_filter, current_stmt_rewrite, 
        call_domain,       prescription_filter, gen_null,
                      NULL);
 
    DEBUG_STAT(7, "between phase 2 and 3", s);
 
 
    /* PHASE 3
     */
    pips_debug(1, "starting phase 3\n");
    analysis_phase = 3;
    build_full_ctrl_graph(s);
    gen_multi_recurse(s,
        statement_domain,  current_stmt_filter, current_stmt_rewrite, 
        expression_domain, gen_false,           gen_null,
        call_domain,       directive_filter,    gen_null,
                      NULL);
 
    initial_alignment(s);
 
    ifdebug(7) dump_current_remapping_graph("after phase 3");
    DEBUG_STAT(7, "after phase 3", s);
 
    /* OPTIMIZATION
     */
    if (get_bool_property("HPFC_OPTIMIZE_REMAPPINGS"))
    {
        pips_debug(1, "starting optimization phase\n");
        simplify_remapping_graph();
    }
 
    clean_ctrl_graph();
 
    hpfc_check_for_similarities(get_the_dynamics());
 
    close_dynamic_locals();
    close_the_dynamics();
 
    DEBUG_STAT(7, "after optimization phase", s);
    }
 
    /* CLEAN
     */
    gen_map((gen_iter_func_t)clean_statement, to_be_cleaned);
    pips_assert("empty stack", current_stmt_empty_p());
    gen_free_list(to_be_cleaned), to_be_cleaned=NIL;
    free_current_stmt_stack();
 
    DEBUG_CODE(5, "resulting code", get_current_module_entity(), s);
}

References analysis_phase, build_full_ctrl_graph(), call_domain, clean_ctrl_graph(), clean_statement(), close_dynamic_locals(), close_the_dynamics(), DEBUG_CODE, DEBUG_STAT, directive_filter(), dump_current_remapping_graph(), expression_domain, gen_false(), gen_free_list(), gen_map(), gen_multi_recurse(), gen_null(), get_bool_property(), get_current_module_entity(), get_the_dynamics(), hpfc_check_for_similarities(), ifdebug, init_dynamic_locals(), init_the_dynamics(), initial_alignment(), NIL, pips_assert, pips_debug, prescription_filter(), simplify_remapping_graph(), statement_domain, store_renamings(), and to_be_cleaned.

Referenced by hpfc_directives_handler().

Here is the call graph for this function:

Here is the caller graph for this function:

handle_independent_directive()

static void handle_independent_directive ( _UNUSED_ entity  f, list  args  )

static

??? I wait for the next statements in a particular order, what should not be necessary.

Means I should deal with independent directives on the PARSED_CODE rather than after the CONTROLIZED.

of entities

travels thru the full control graph to find the loops and tag them as parallel.

what we're looking for

simple independent case, first loop is tagged //

else general independent case (with a list of indexes)

the end

Definition at line 721 of file directives.c.

{
    list /* of entities */ l = expressions_to_entities(args);
    statement s;
 
    pips_debug(2, "%zd index(es)\n", gen_length(l));
 
    /*  travels thru the full control graph to find the loops
     *  and tag them as parallel.
     */
    init_ctrl_graph_travel(current_stmt_head(), (bool(*)(statement))gen_true);
 
    while(next_ctrl_graph_travel(&s))
    {
        instruction i = statement_instruction(s);
 
        if (instruction_loop_p(i))  /* what we're looking for */
        {
            loop o = instruction_loop(i);
            entity index = loop_index(o);
 
            if (ENDP(l)) /* simple independent case, first loop is tagged // */
            {
                pips_debug(3, "parallel loop\n");
 
                execution_tag(loop_execution(o)) = is_execution_parallel;
                close_ctrl_graph_travel();
                return;
            }
            /*  else general independent case (with a list of indexes)
             */
            if (gen_in_list_p(index, l))
            {
                pips_debug(3, "parallel loop (%s)\n", entity_name(index));
 
                execution_tag(loop_execution(o)) = is_execution_parallel;
                gen_remove(&l, index);
 
                if (ENDP(l)) /* the end */
                {
                    close_ctrl_graph_travel();
                    return;
                }
            }
        }
    }
 
    close_ctrl_graph_travel();
    pips_user_error("some loop not found!\n");
}

References close_ctrl_graph_travel(), current_stmt_head, ENDP, entity_name, execution_tag, expressions_to_entities(), gen_in_list_p(), gen_length(), gen_remove(), gen_true(), init_ctrl_graph_travel(), instruction_loop, instruction_loop_p, is_execution_parallel, loop_execution, loop_index, next_ctrl_graph_travel(), pips_debug, pips_user_error, and statement_instruction.

Here is the call graph for this function:

handle_io_directive()

static void handle_io_directive ( _UNUSED_ entity  f, list  args  )

static

Definition at line 804 of file directives.c.

{
    entity module = get_current_module_entity();
    if (ENDP(args))
        add_an_io_function(module);
    else
        gen_map((gen_iter_func_t)new_io_function, args);
}

References add_an_io_function(), ENDP, gen_map(), get_current_module_entity(), module, and new_io_function().

Here is the call graph for this function:

handle_kill_directive()

static void handle_kill_directive ( _UNUSED_ entity  f, _UNUSED_ list  args  )

static

tells the compiler that the array values are dead from now on.

can be used by the propagation to stop the process... and mark at this point all copies as live! pretty simple handling! I let the call as a marker for itself, and it will be removed later on at the compilation stage only...

Definition at line 929 of file directives.c.

{
    pips_debug(4, "dead directive encountered");
}

References pips_debug.

handle_new_directive()

static void handle_new_directive ( _UNUSED_ entity  f, _UNUSED_ list  args  )

static

??? not implemented and not used.

The independent directive is trusted by the compiler to apply its optimizations...

(that's indeed a first implementation:-)

Definition at line 776 of file directives.c.

{
    hpfc_warning("not implemented\n");
    return; /* (that's indeed a first implementation:-) */
}

References hpfc_warning.

handle_nothing_directive()

static void handle_nothing_directive ( entity  f, _UNUSED_ list  args  )

static

Definition at line 935 of file directives.c.

{
    pips_debug(4, "skipping entity %s\n", entity_name(f));
}

References entity_name, f(), and pips_debug.

Here is the call graph for this function:

handle_prescriptive_directive()

static void handle_prescriptive_directive ( _UNUSED_ entity  f, list  args  )

static

prescriptive mappings before a call.

another kind of remapping, as realign and redistribute.

only one renaming per rename directive!

Definition at line 905 of file directives.c.

{
    statement current = current_stmt_head();
    entity array, new_array;
 
    array = expression_to_entity(EXPRESSION(CAR(args)));
    new_array = expression_to_entity(EXPRESSION(CAR(CDR(args))));
 
    propagate_synonym(current, array, new_array, true);
 
    /* only one renaming per rename directive!
     */
    store_renamings(current, 
                    CONS(RENAMING, make_renaming(array, new_array), NIL));
 
}

References array, CAR, CDR, CONS, current, current_stmt_head, EXPRESSION, expression_to_entity(), make_renaming(), NIL, propagate_synonym(), RENAMING, and store_renamings().

Here is the call graph for this function:

handle_processors_directive()

static void handle_processors_directive ( _UNUSED_ entity  f, list  args  )

static

see new_processor

Definition at line 660 of file directives.c.

{
    gen_map((gen_iter_func_t)new_processor, args); /* see new_processor */
}

References gen_map(), and new_processor().

Here is the call graph for this function:

handle_pure_directive()

static void handle_pure_directive ( _UNUSED_ entity  f, list  args  )

static

may be used to declare functions as pure.

??? it is not a directive in HPF, but I put it this way in F77. ??? pure declarations are not yet used by HPFC.

Definition at line 793 of file directives.c.

{
    entity module = get_current_module_entity();
 
    if (ENDP(args))
        add_a_pure(module);
    else
        gen_map((gen_iter_func_t)new_pure_function, args);
}

References add_a_pure(), ENDP, gen_map(), get_current_module_entity(), module, and new_pure_function().

Here is the call graph for this function:

handle_realign_directive()

static void handle_realign_directive ( entity  f, list  args  )

static

Definition at line 824 of file directives.c.

{
    handle_align_and_realign_directive(f, args, true);
}

References f(), and handle_align_and_realign_directive().

Here is the call graph for this function:

handle_redistribute_directive()

static void handle_redistribute_directive ( entity  f, list  args  )

static

Definition at line 830 of file directives.c.

{
    handle_distribute_and_redistribute_directive(f, args, true);
}

References f(), and handle_distribute_and_redistribute_directive().

Here is the call graph for this function:

handle_reduction_directive()

static void handle_reduction_directive ( _UNUSED_ entity  f, list  args  )

static

I chose not to modify the ri to add reductions as private variables.

the reason is the following: locals are not well placed (they should be attached to statements?), I won't add one more misplaced sg. Also I would have to update all make_loop() within PIPS...

of entity

Definition at line 689 of file directives.c.

{
    list /* of entity */ l = expressions_to_entities(args);
    statement s;
 
    init_ctrl_graph_travel(current_stmt_head(), (bool(*)(statement))gen_true);
 
    while(next_ctrl_graph_travel(&s))
    {
        if (instruction_loop_p(statement_instruction(s)))
        {
            if (!bound_hpf_reductions_p(s))
                store_hpf_reductions(s, make_entities(l));
            else
            {
                entities e = load_hpf_reductions(s);
                entities_list(e) = gen_nconc(entities_list(e), l);
            }
            close_ctrl_graph_travel();
            return;
        }
    }
 
    close_ctrl_graph_travel();
    pips_user_error("some loop not found!\n");
}

References bound_hpf_reductions_p(), close_ctrl_graph_travel(), current_stmt_head, entities_list, expressions_to_entities(), gen_nconc(), gen_true(), init_ctrl_graph_travel(), instruction_loop_p, load_hpf_reductions(), make_entities(), next_ctrl_graph_travel(), pips_user_error, statement_instruction, and store_hpf_reductions().

Here is the call graph for this function:

handle_set_directive()

static void handle_set_directive ( entity  f, list  args  )

static

for both setbool and setint ??? looks like a hack:-)

property name. ??? moved to uppers because hpfc_directives put lowers. ??? plus having to deal with quotes that are put in the name!

Definition at line 864 of file directives.c.

{
    if (!get_bool_property(FCD_IGNORE_PREFIX "SET"))
    {
        expression arg1, arg2;
        string property;
        int val, i;
 
        pips_user_assert("two args", gen_length(args)==2);
        arg1 = EXPRESSION(CAR(args));
        arg2 = EXPRESSION(CAR(CDR(args)));
        pips_user_assert("constant args",
                    expression_is_constant_p(arg1) &&
                    expression_is_constant_p(arg2));
 
        /* property name.
         * ??? moved to uppers because hpfc_directives put lowers.
         * ??? plus having to deal with quotes that are put in the name!
         */
        property = strdup(entity_local_name
            (call_function(syntax_call(expression_syntax(arg1)))));
        for (i=0; property[i]; i++) property[i]=toupper(property[i]);
        property[i-1]='\0';
 
        val = HpfcExpressionToInt(arg2);
 
        if (same_string_p(entity_local_name(f), HPF_PREFIX SETBOOL_SUFFIX))
            set_bool_property(property+1, val);
        else
            set_int_property(property+1, val);
 
        free(property);
    }
 
    add_statement_to_clean(current_stmt_head());
}

References add_statement_to_clean(), call_function, CAR, CDR, current_stmt_head, entity_local_name(), EXPRESSION, expression_is_constant_p(), expression_syntax, f(), FCD_IGNORE_PREFIX, free(), gen_length(), get_bool_property(), HPF_PREFIX, HpfcExpressionToInt(), pips_user_assert, same_string_p, set_bool_property(), set_int_property(), SETBOOL_SUFFIX, strdup(), and syntax_call.

Here is the call graph for this function:

handle_synchro_directive()

static void handle_synchro_directive ( _UNUSED_ entity  f, _UNUSED_ list  args  )

static

Definition at line 838 of file directives.c.

{
  if (get_bool_property(FCD_IGNORE_PREFIX "SYNCHRO"))
    add_statement_to_clean(current_stmt_head());
}

References add_statement_to_clean(), current_stmt_head, FCD_IGNORE_PREFIX, and get_bool_property().

Here is the call graph for this function:

handle_template_directive()

static void handle_template_directive ( _UNUSED_ entity  f, list  args  )

static

see new_template

Definition at line 666 of file directives.c.

{
    gen_map((gen_iter_func_t)new_template, args); /* see new_template */
}

References gen_map(), and new_template().

Here is the call graph for this function:

handle_time_directive()

static void handle_time_directive ( _UNUSED_ entity  f, _UNUSED_ list  args  )

static

for both timeon and timeoff

Definition at line 847 of file directives.c.

{
  if (get_bool_property(FCD_IGNORE_PREFIX "TIME"))
    add_statement_to_clean(current_stmt_head());
}

References add_statement_to_clean(), current_stmt_head, FCD_IGNORE_PREFIX, and get_bool_property().

Here is the call graph for this function:

handle_unexpected_directive()

static void handle_unexpected_directive ( _UNUSED_ entity  f, _UNUSED_ list  args  )

static

Definition at line 654 of file directives.c.

{
    pips_user_error("unexpected hpf directive\n");
}

References pips_user_error.

hpfc_directives_error_handler()

void hpfc_directives_error_handler

(

void

)

the local stack is used to retrieve the current statement while scanning the AST with gen_recurse.

Definition at line 109 of file directives.c.

{
  error_reset_current_stmt_stack();
}

Referenced by hpfc_error_handler().

Here is the caller graph for this function:

initial_alignment()

static void initial_alignment ( statement  s )

static

handle s as the initial alignment...

to be called after the dynamics arrays...

a formal is considered as used to force the remapping

Definition at line 332 of file directives.c.

{
    MAP(ENTITY, array,
    {
        if (array_distributed_p(array))
        {
            propagate_synonym(s, array, array, true);
            update_renamings(s, CONS(RENAMING, make_renaming(array, array),
                                     load_renamings(s)));
 
            if (storage_formal_p(entity_storage(array)))
                /* a formal is considered as used to force the remapping
                 */
                add_as_a_used_dynamic_to_statement(s, array);
        }
    },
        get_the_dynamics());
}

References add_as_a_used_dynamic_to_statement(), array, array_distributed_p(), CONS, ENTITY, entity_storage, get_the_dynamics(), load_renamings(), make_renaming(), MAP, propagate_synonym(), RENAMING, storage_formal_p, and update_renamings().

Referenced by handle_hpf_directives().

Here is the call graph for this function:

Here is the caller graph for this function:

new_dynamic()

static void new_dynamic ( expression  e )

static

Definition at line 144 of file directives.c.

{
    entity a = expression_to_entity(e);
    set_entity_as_dynamic(a);
    add_a_dynamic(a);
 
    pips_debug(3, "entity is %s\n", entity_name(a));
}

References add_a_dynamic(), entity_name, expression_to_entity(), pips_debug, and set_entity_as_dynamic().

Referenced by handle_dynamic_directive().

Here is the call graph for this function:

Here is the caller graph for this function:

new_fake_function()

static void new_fake_function ( expression  e )

static

Definition at line 158 of file directives.c.

{
  add_a_fake_function(expression_to_entity(e));
}

References add_a_fake_function(), and expression_to_entity().

Referenced by handle_fake_directive().

Here is the call graph for this function:

Here is the caller graph for this function:

new_io_function()

static void new_io_function ( expression  e )

static

Definition at line 153 of file directives.c.

{
  add_an_io_function(expression_to_entity(e));
}

References add_an_io_function(), and expression_to_entity().

Referenced by handle_io_directive().

Here is the call graph for this function:

Here is the caller graph for this function:

new_processor()

static void new_processor ( expression  e )

static

Definition at line 126 of file directives.c.

{
    entity p = expression_to_entity(e);
    switch_basic_type_to_overloaded(p);
    set_processor(p);
 
    pips_debug(3, "entity is %s\n", entity_name(p));
}

References entity_name, expression_to_entity(), pips_debug, set_processor(), and switch_basic_type_to_overloaded().

Referenced by handle_processors_directive().

Here is the call graph for this function:

Here is the caller graph for this function:

new_pure_function()

static void new_pure_function ( expression  e )

static

Definition at line 163 of file directives.c.

{
  add_a_pure(expression_to_entity(e));
}

References add_a_pure(), and expression_to_entity().

Referenced by handle_pure_directive().

Here is the call graph for this function:

Here is the caller graph for this function:

new_template()

static void new_template ( expression  e )

static

Definition at line 135 of file directives.c.

{
    entity t = expression_to_entity(e);
    switch_basic_type_to_overloaded(t);
    set_template(t);
 
    pips_debug(3, "entity is %s\n", entity_name(t));
}

References entity_name, expression_to_entity(), pips_debug, set_template(), and switch_basic_type_to_overloaded().

Referenced by handle_template_directive().

Here is the call graph for this function:

Here is the caller graph for this function:

one_align_directive()

static void one_align_directive ( reference  alignee, reference  temp, list  lopt, bool  dynamic  )

static

handle a simple (re)align directive.

store the mappings in internal data structures. realign or align

a variable in a common can be declared several alignments that MUST be the same...

Parameters

temp	the array
lopt	the template of expressions

Definition at line 355 of file directives.c.

{
    entity template = reference_variable(temp),
           array    = reference_variable(alignee);
    align a;
 
    pips_debug(3, "%s %saligned with %s\n", entity_name(array),
               dynamic ? "re" : "", entity_name(template));
 
    a = extract_the_align(alignee, temp, lopt);
    normalize_align(array, a);
 
    ifdebug(8) print_align(a);
 
    if (dynamic)
    {
        statement current = current_stmt_head();
        entity new_array;
 
        pips_user_assert("dynamic array realignment",
            array_distributed_p(array) && dynamic_entity_p(array));
 
        new_array = array_synonym_aligned_as(array, a);
        propagate_synonym(current, array, new_array, true);
        update_renamings(current,
                         CONS(RENAMING, make_renaming(array, new_array),
                              load_renamings(current)));
    }
    else
    {
        if (!array_distributed_p(array))
        {
            set_array_as_distributed(array);
            store_hpf_alignment(array, a);
        }
        else
        {
            /* a variable in a common can be declared several alignments
             * that MUST be the same...
             */
            pips_assert("some alignment", bound_hpf_alignment_p(array));
        }
    }
}

References array, array_distributed_p(), array_synonym_aligned_as(), bound_hpf_alignment_p(), CONS, current, current_stmt_head, dynamic_entity_p, entity_name, extract_the_align(), ifdebug, load_renamings(), make_renaming(), normalize_align(), pips_assert, pips_debug, pips_user_assert, print_align(), propagate_synonym(), reference_variable, RENAMING, set_array_as_distributed(), store_hpf_alignment(), and update_renamings().

Referenced by handle_align_and_realign_directive().

Here is the call graph for this function:

Here is the caller graph for this function:

one_distribute_directive()

static void one_distribute_directive ( reference  distributee, reference  proc, bool  dynamic  )

static

handles a simple (one template) distribute or redistribute directive.

redistribute or distribute

the new template may be an array, thus auto-aligned

all arrays aligned to template are propagated in turn.

Parameters

proc	the template
dynamic	the processor arrangement

Definition at line 554 of file directives.c.

{
    entity processor = reference_variable(proc),
           template  = reference_variable(distributee);
    distribute d = extract_the_distribute(distributee, proc);
 
    pips_user_assert("no indices to processor or :: syntax", 
      ENDP(reference_indices(proc)) || ENDP(reference_indices(distributee)));
    
    normalize_distribute(template, d);
 
    pips_debug(3, "%s %sdistributed onto %s\n", entity_name(template), 
               dynamic ? "re" : "", entity_name(processor));
 
    if (dynamic)
    {
        statement current = current_stmt_head();
        entity new_t;
 
        pips_user_assert("dynamic template redistribution",
                  entity_template_p(template) && dynamic_entity_p(template));
 
        new_t = template_synonym_distributed_as(template, d);
        propagate_synonym(current, template, new_t, false);
 
        /* the new template may be an array, thus auto-aligned 
         */
        if (array_distributed_p(template) && !bound_hpf_alignment_p(new_t))
            array_as_template(new_t);
 
        /*  all arrays aligned to template are propagated in turn.
         */
        MAP(ENTITY, array,
        {
            align a;
            entity new_array;
 
            pips_debug(7, "array 0x%p\n", array);
            pips_debug(7, "alive array %s\n", entity_name(array));
            
            a = new_align_with_template(load_hpf_alignment(array), new_t);
            new_array = array_synonym_aligned_as(array, a);
            
            propagate_synonym(current, array, new_array, true);
            update_renamings(current, 
                             CONS(RENAMING, make_renaming(array, new_array),
                                  load_renamings(current)));
 
            pips_debug(9, "done with %s->%s\n", 
                       entity_name(array), entity_name(new_array));
         },
            alive_arrays(current, template));
    }
    else
        store_hpf_distribution(template, d);
 
    pips_debug(4, "out\n");
}

References alive_arrays(), array, array_as_template(), array_distributed_p(), array_synonym_aligned_as(), bound_hpf_alignment_p(), CONS, current, current_stmt_head, dynamic_entity_p, ENDP, ENTITY, entity_name, entity_template_p(), extract_the_distribute(), load_hpf_alignment(), load_renamings(), make_renaming(), MAP, new_align_with_template(), normalize_distribute(), pips_debug, pips_user_assert, propagate_synonym(), reference_indices, reference_variable, RENAMING, store_hpf_distribution(), template_synonym_distributed_as(), and update_renamings().

Referenced by handle_distribute_and_redistribute_directive().

Here is the call graph for this function:

Here is the caller graph for this function:

prescription_filter()

static bool prescription_filter ( call  c )

static

Definition at line 1038 of file directives.c.

{
    entity f = call_function(c);
 
    if (hpfc_call_with_distributed_args_p(c))
    {
        pips_debug(5, "distributed call to %s\n", entity_name(f));
        hpfc_translate_call_with_distributed_args(current_stmt_head(), c);
    }
 
    return false;
}

References call_function, current_stmt_head, entity_name, f(), hpfc_call_with_distributed_args_p(), hpfc_translate_call_with_distributed_args(), and pips_debug.

Referenced by handle_hpf_directives().

Here is the call graph for this function:

Here is the caller graph for this function:

switch_basic_type_to_overloaded()

static void switch_basic_type_to_overloaded ( entity  e )

static

management of PROCESSORS and TEMPLATE directives.

just changes the basic type to overloaded and stores the entity as a processor or a template.

Definition at line 119 of file directives.c.

{
  basic b = entity_basic(e);
  pips_assert("basic defined", b!=basic_undefined);
  basic_tag(b)=is_basic_overloaded;
}

References basic_tag, basic_undefined, entity_basic(), is_basic_overloaded, and pips_assert.

Referenced by new_processor(), and new_template().

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

analysis_phase

int analysis_phase = 0

static

HPFC module by Fabien COELHO.

These functions deal with HPF directives. (just a big hack, but few lines of code and neither lex nor yacc:-) I'm definitely happy with this. FC. several phases are used to analyze the directives. 1: static directives 2: special management of prescriptive mappings 3: dynamic mappings

Definition at line 44 of file directives.c.

Referenced by handle_hpf_directives().

directive_handler

void(*)(entity, list) directive_handler(const char *name) ( const char *  name )

static

returns the handler for directive name.

assumes that name should point to a directive.

Definition at line 1002 of file directives.c.

{
    struct DirectiveHandler *x=handlers;
    while (x->name && strcmp(name, x->name)) x++;
    return (!x->phase || x->phase==analysis_phase)?
        x->handler: HANDLER(nothing);
}

Referenced by directive_filter(), and directive_managed_now_p().

handlers

struct DirectiveHandler handlers[]

static

Definition at line 935 of file directives.c.

to_be_cleaned

list to_be_cleaned = NIL

static

list of statements to be cleaned.

the operation is delayed because the directives are needed in place to stop the dynamic updates. of statements

Definition at line 51 of file directives.c.

Referenced by add_statement_to_clean(), and handle_hpf_directives().