Pedagogical phases in PIPS

Simple phases to show how to add stuff to a module: a comment, a call,... More...

Functions
bool	prepend_comment (char *module_name)
	Add a comment at the begin of a module code. More...
bool	prepend_call (string mn)
	This function adds a call to ficticious global function "MY_TRACK" as first executabble statement of module "mn" in C89 style. More...
static void	do_add_pragma (statement s, statement p)
bool	add_pragma (const string mn)

Detailed Description

Simple phases to show how to add stuff to a module: a comment, a call,...

Pedagogical, but also useful for RK for a project...

Ronan.nosp@m..Ker.nosp@m.yell@.nosp@m.hpc-.nosp@m.proje.nosp@m.ct.c.nosp@m.om François Irigoin

This module introduces some pedagogical minimal phases to dive into PIPS development, with some examples of programming and documentation style (such as this module itself!)

Function Documentation

add_pragma()

bool add_pragma

(

const string

mn

)

a bit more complex: the directive must be added just before any return statement, if any

Definition at line 110 of file add_stuff_to_module.c.

                                 {
  const char* pragma_name = get_string_property("PRAGMA_NAME");
  bool prepend = get_bool_property("PRAGMA_PREPEND");
  statement pragma_s = make_empty_statement();
  add_pragma_str_to_statement(pragma_s, pragma_name, true);
  statement module_statement = PIPS_PHASE_PRELUDE(mn, "ADD_PRAGMA_DEBUG_LEVEL");
  insert_statement(module_statement, pragma_s, prepend);
  if(!prepend) /* a bit more complex: the directive must be added just before any return statement, if any */ {
      gen_context_recurse(module_statement, pragma_s, statement_domain, gen_true2, do_add_pragma);
  }
  PIPS_PHASE_POSTLUDE(module_statement);
}

References add_pragma_str_to_statement(), do_add_pragma(), gen_context_recurse, gen_true2(), get_bool_property(), get_string_property(), insert_statement(), make_empty_statement, module_statement, PIPS_PHASE_POSTLUDE, PIPS_PHASE_PRELUDE, and statement_domain.

Here is the call graph for this function:

do_add_pragma()

static void do_add_pragma ( statement  s, statement  p  )

static

Definition at line 104 of file add_stuff_to_module.c.

                                                    {
    if(return_statement_p(s)){
        insert_statement(s,copy_statement(p),true);
    }
}

References copy_statement(), insert_statement(), and return_statement_p().

Referenced by add_pragma().

Here is the call graph for this function:

Here is the caller graph for this function:

prepend_call()

bool prepend_call

(

string

mn

)

This function adds a call to ficticious global function "MY_TRACK" as first executabble statement of module "mn" in C89 style.

It is not supposed to be of any use beyond training new comers to PIPS.

Function "MY_TRACK" is assumed to take no arguments and to return no results. No source code is available for it.

It is written to show how to use Newgen primitives in PIPS PPoPP 2010 tutorial, not to be used. See make_empty_subroutine() in ri-util/entity.c for a similar function which might be moved into ri-util/module.c.

Parameters

mn	is the name of the module to apply this phase on.

Returns

true as we assume it always works, although repetitive calls to make_entity() with the same global name might fail:-). Not tested on Fortran code. No non-regression tests for it either.

This works only once. So use FindOrCreateEntity() instead... or rely on functions in library ri-util.

Definition at line 77 of file add_stuff_to_module.c.

                             {
  type rt = make_type_void(NIL);
  functional ft = make_functional(NIL, rt);
  type t = make_type_functional(ft);
  storage st = make_storage_rom();
  code co = make_code(NIL, strdup(""), make_sequence(NIL),NIL,
                      make_language_c());
  value v = make_value_code(co);
  const char* name = get_string_property("PREPEND_CALL");
  string ffn = strdup(concatenate(TOP_LEVEL_MODULE_NAME,
                                  MODULE_SEP_STRING,
                                  name,
                                  NULL)); 
  /* This works only once. So use FindOrCreateEntity() instead... or
     rely on functions in library ri-util. */
  entity f = make_entity(ffn, t, st, v);
  call ca = make_call(f, NIL);
  instruction i = make_instruction_call(ca);
  statement ns = instruction_to_statement(i);
  statement module_statement = PIPS_PHASE_PRELUDE(mn,
                                                  "PREPEND_CALL_DEBUG_LEVEL");
  pips_assert("f really is an entity", check_entity(f));
  insert_statement(module_statement, ns, true);
  DB_PUT_MEMORY_RESOURCE(DBR_CALLEES, mn, compute_callees(module_statement));
  PIPS_PHASE_POSTLUDE(module_statement);
}

References check_entity(), compute_callees(), concatenate(), DB_PUT_MEMORY_RESOURCE, f(), get_string_property(), insert_statement(), instruction_to_statement(), make_call(), make_code(), make_entity, make_functional(), make_instruction_call(), make_language_c(), make_sequence(), make_storage_rom(), make_type_functional(), make_type_void(), make_value_code(), MODULE_SEP_STRING, module_statement, NIL, pips_assert, PIPS_PHASE_POSTLUDE, PIPS_PHASE_PRELUDE, strdup(), and TOP_LEVEL_MODULE_NAME.

Here is the call graph for this function:

prepend_comment()

bool prepend_comment

(

char *

module_name

)

Add a comment at the begin of a module code.

It is a pedagogical phase but is also used for CUDA generation.

Parameters

module_name

is the name of the module to apply this phase on.

Returns

a bool which is true if it works. Well, indeed this phase assumes to always work...

Use this module name and this environment variable to set

Put back the new statement for the module

Definition at line 42 of file add_stuff_to_module.c.

                                         {
  /* Use this module name and this environment variable to set */
 
  statement module_statement = PIPS_PHASE_PRELUDE(module_name,
                                                  "PREPEND_COMMENT_DEBUG_LEVEL");
 
  // Get the value of the property containing the comment to be prepended
  const char* comment = get_string_property("PREPEND_COMMENT");
 
  insert_comments_to_statement(module_statement, comment);
 
  /* Put back the new statement for the module */
  PIPS_PHASE_POSTLUDE(module_statement);
}

References comment(), get_string_property(), insert_comments_to_statement(), module_name(), module_statement, PIPS_PHASE_POSTLUDE, and PIPS_PHASE_PRELUDE.

Here is the call graph for this function: