clone_statement.c File Reference

#include "linear.h"
#include "genC.h"
#include "misc.h"
#include "ri.h"
#include "cloning.h"
#include "ri-util.h"

Include dependency graph for clone_statement.c:

Go to the source code of this file.

Functions
static expression	do_clone_expression (expression e, clone_context cc, hash_table ht)
	forward declarations More...
static call	do_clone_call (call c, clone_context cc, hash_table ht)
static statement	do_clone_statement (statement s, clone_context cc, hash_table ht)
static entity	do_clone_label (entity l, clone_context cc)
static gen_chunk *	do_clone_reference (reference r, clone_context cc, hash_table ht)
	nd formard declarations More...
static range	do_clone_range (range r, clone_context cc, hash_table ht)
static cast	do_clone_cast (cast c, clone_context cc, hash_table ht)
static sizeofexpression	do_clone_sizeofexpression (sizeofexpression s, clone_context cc, hash_table ht)
static subscript	do_clone_subscript (subscript s, clone_context cc, hash_table ht)
static application	do_clone_application (application a, clone_context cc, hash_table ht)
static syntax	do_clone_syntax (syntax s, clone_context cc, hash_table ht)
static entity	do_clone_entity (entity e, clone_context cc, hash_table ht)
static sequence	do_clone_sequence (sequence s, clone_context cc, hash_table ht)
static test	do_clone_test (test t, clone_context cc, hash_table ht)
static loop	do_clone_loop (loop l, clone_context cc, hash_table ht)
static whileloop	do_clone_whileloop (whileloop w, clone_context cc, hash_table ht)
static multitest	do_clone_multitest (multitest m, clone_context cc, hash_table ht)
static forloop	do_clone_forloop (forloop f, clone_context cc, hash_table ht)
static instruction	do_clone_instruction (instruction i, clone_context cc, hash_table ht)
statement	clone_statement (statement s, clone_context cc)
	clone_statement.c More...

Function Documentation

clone_statement()

statement clone_statement	(	statement	s,
		clone_context	cc
	)

clone_statement.c

Parameters

cc

c

Definition at line 437 of file clone_statement.c.

{
    hash_table ht = hash_table_make(hash_string,0);
    statement sout = do_clone_statement(s,cc,ht);
    hash_table_free(ht);
    return sout;
}

References do_clone_statement(), hash_string, hash_table_free(), and hash_table_make().

Referenced by do_loop_expansion_init(), do_loop_nest_unswitching_purge(), do_loop_unroll_with_epilogue(), do_loop_unroll_with_prologue(), do_simdizer_auto_tile_generate_all_tests(), dowhile_to_while_walker(), full_loop_unroll(), and make_new_loop_statement().

Here is the call graph for this function:

Here is the caller graph for this function:

do_clone_application()

static application do_clone_application ( application  a, clone_context  cc, hash_table  ht  )

static

Definition at line 102 of file clone_statement.c.

{
    list new_arguments = NIL;
    FOREACH(EXPRESSION,e,application_arguments(a))
        new_arguments=CONS(EXPRESSION,do_clone_expression(e,cc, ht),new_arguments);
    return make_application(do_clone_expression(application_function(a),cc, ht),gen_nreverse(new_arguments));
}

References application_arguments, application_function, CONS, do_clone_expression(), EXPRESSION, FOREACH, gen_nreverse(), make_application(), and NIL.

Referenced by do_clone_syntax().

Here is the call graph for this function:

Here is the caller graph for this function:

do_clone_call()

static call do_clone_call ( call  c, clone_context  cc, hash_table  ht  )

static

Definition at line 331 of file clone_statement.c.

{
    list new_arguments = NIL;
    FOREACH(EXPRESSION,e,call_arguments(c))
    {
        new_arguments=CONS(EXPRESSION,do_clone_expression(e,cc, ht),new_arguments);
    }
    return make_call(
            call_function(c),
            gen_nreverse(new_arguments));
}

References call_arguments, call_function, CONS, do_clone_expression(), EXPRESSION, FOREACH, gen_nreverse(), make_call(), and NIL.

Referenced by do_clone_instruction(), and do_clone_syntax().

Here is the call graph for this function:

Here is the caller graph for this function:

do_clone_cast()

static cast do_clone_cast ( cast  c, clone_context  cc, hash_table  ht  )

static

Definition at line 72 of file clone_statement.c.

{
    return make_cast(
            copy_type(cast_type(c)),
            do_clone_expression(cast_expression(c),cc, ht));
}

References cast_expression, cast_type, copy_type(), do_clone_expression(), and make_cast().

Referenced by do_clone_syntax().

Here is the call graph for this function:

Here is the caller graph for this function:

do_clone_entity()

static entity do_clone_entity ( entity  e, clone_context  cc, hash_table  ht  )

static

There is no reason to replicate such an entity when cloning since they are left unchanged, except maybe if they contain dependent types...

The entity can be a typedef instead of a variable...

The type of the entity can be a typedef that has been renamed...

FI: I am adding this for loop_unroll, but I believe 1) that typedef variables should not be renamed since only non-dependent types are supported, and 2) that loop unroll should be implemented in a simpler way and complemented by flatten_code

For dependent types, the variables used in dimension might have been renamed, but the cloning is not compatible with dependent types because declarations are moved...

Definition at line 166 of file clone_statement.c.

{
    pips_assert("entity is fine",entity_consistent_p(e));
    entity new_entity = entity_undefined;
    if( (new_entity=hash_get(ht,entity_name(e))) == HASH_UNDEFINED_VALUE)
    {
      //string ln = entity_user_name(e);
      string en = entity_name(e);
      string ms = strrchr(en, BLOCK_SEP_CHAR);
      if(ms==NULL)
        ms = strchr(en, MODULE_SEP);
      string ln = ms+1;
 
        if(entity_scalar_p(e))
            new_entity = make_new_scalar_variable_with_prefix(
                    //entity_user_name(e),
                    ln,
                    clone_context_new_module(cc),
                    copy_basic(entity_basic(e))
                    );
        else if(entity_array_p(e))
            new_entity = make_new_array_variable_with_prefix(
                    //entity_user_name(e),
                    ln,
                    clone_context_new_module(cc),
                    copy_basic(entity_basic(e)),
                    gen_full_copy_list(variable_dimensions(type_variable(entity_type(e))))
                    );
        else if(entity_struct_p(e) || entity_union_p(e) || entity_enum_p(e)) {
          /* There is no reason to replicate such an entity when
             cloning since they are left unchanged, except maybe if
             they contain dependent types... */
            new_entity = make_new_derived_entity_with_prefix(
                    ln,
                    clone_context_new_module(cc),
                    entity_type(e)
                    );
        }
        else {
          pips_internal_error("Unexpected case\n");
        }
 
        /* The entity can be a typedef instead of a
           variable... */
        if(typedef_entity_p(e)) {
          storage s = entity_storage(new_entity);
          free_storage(s);
          s = make_storage_rom();
          entity_storage(new_entity) = s;
        }
 
        /* The type of the entity can be a typedef that has been renamed... */
        /* FI: I am adding this for loop_unroll, but I believe 1) that
           typedef variables should not be renamed since only
           non-dependent types are supported, and 2) that loop unroll
           should be implemented in a simpler way and complemented by
           flatten_code */
        type nt = entity_type(new_entity);
        if(type_variable_p(nt)) {
          variable nv = type_variable(nt);
          /* For dependent types, the variables used in dimension
             might have been renamed, but the cloning is not
             compatible with dependent types because declarations are
             moved... */
          basic nb = variable_basic(nv);
          if(basic_typedef_p(nb)) {
            entity otd = basic_typedef(nb);
            entity ntd = hash_get(ht,entity_name(otd));
            if(ntd != HASH_UNDEFINED_VALUE)
              basic_typedef(nb) = ntd;
          }
          else if(basic_derived_p(nb)) {
            entity de = basic_derived(nb);
            entity nde = hash_get(ht,entity_name(de));
            if(nde != HASH_UNDEFINED_VALUE)
              basic_derived(nb) = nde;
          }
        }
 
        AddLocalEntityToDeclarations(new_entity,clone_context_new_module(cc),clone_context_new_module_statement(cc));
        hash_put(ht,entity_name(e),new_entity);
    }
    return new_entity;
}

References AddLocalEntityToDeclarations(), basic_derived, basic_derived_p, basic_typedef, basic_typedef_p, BLOCK_SEP_CHAR, clone_context_new_module, clone_context_new_module_statement, copy_basic(), entity_array_p(), entity_basic(), entity_consistent_p(), entity_enum_p(), entity_name, entity_scalar_p(), entity_storage, entity_struct_p(), entity_type, entity_undefined, entity_union_p(), free_storage(), gen_full_copy_list(), hash_get(), hash_put(), HASH_UNDEFINED_VALUE, make_new_array_variable_with_prefix(), make_new_derived_entity_with_prefix(), make_new_scalar_variable_with_prefix(), make_storage_rom(), MODULE_SEP, pips_assert, pips_internal_error, type_variable, type_variable_p, typedef_entity_p(), variable_basic, and variable_dimensions.

Referenced by do_clone_loop(), and do_clone_statement().

Here is the call graph for this function:

Here is the caller graph for this function:

do_clone_expression()

static expression do_clone_expression ( expression  e, clone_context  cc, hash_table  ht  )

static

forward declarations

Definition at line 157 of file clone_statement.c.

{
    return make_expression(
            do_clone_syntax(expression_syntax(e),cc, ht),
            normalized_undefined);
}

References do_clone_syntax(), expression_syntax, make_expression(), and normalized_undefined.

Referenced by do_clone_application(), do_clone_call(), do_clone_cast(), do_clone_forloop(), do_clone_instruction(), do_clone_multitest(), do_clone_range(), do_clone_reference(), do_clone_sizeofexpression(), do_clone_statement(), do_clone_subscript(), do_clone_test(), and do_clone_whileloop().

Here is the call graph for this function:

Here is the caller graph for this function:

do_clone_forloop()

static forloop do_clone_forloop ( forloop  f, clone_context  cc, hash_table  ht  )

static

Definition at line 352 of file clone_statement.c.

{
    return make_forloop(
            do_clone_expression(forloop_initialization(f),cc, ht),
            do_clone_expression(forloop_condition(f),cc, ht),
            do_clone_expression(forloop_increment(f),cc, ht),
            do_clone_statement(forloop_body(f),cc, ht));
}

References do_clone_expression(), do_clone_statement(), f(), forloop_body, forloop_condition, forloop_increment, forloop_initialization, and make_forloop().

Referenced by do_clone_instruction().

Here is the call graph for this function:

Here is the caller graph for this function:

do_clone_instruction()

static instruction do_clone_instruction ( instruction  i, clone_context  cc, hash_table  ht  )

static

Definition at line 362 of file clone_statement.c.

{
    if(instruction_undefined_p(i)) return i;
 
    switch(instruction_tag(i))
    {
        case is_instruction_sequence:
            return make_instruction_sequence(do_clone_sequence(instruction_sequence(i),cc, ht));
        case is_instruction_test:
            return make_instruction_test(do_clone_test(instruction_test(i),cc, ht));
        case is_instruction_loop:
            return make_instruction_loop(do_clone_loop(instruction_loop(i),cc, ht));
        case is_instruction_whileloop:
            return make_instruction_whileloop(do_clone_whileloop(instruction_whileloop(i),cc, ht));
        case is_instruction_goto:
            pips_user_error("don't know how to clone a goto");
        case is_instruction_call:
            return make_instruction_call(do_clone_call(instruction_call(i),cc, ht));
        case is_instruction_unstructured:
            pips_user_error("don't know how to clone an unstructured");
        case is_instruction_multitest:
            return make_instruction_multitest(do_clone_multitest(instruction_multitest(i),cc, ht));
        case is_instruction_forloop:
            return make_instruction_forloop(do_clone_forloop(instruction_forloop(i),cc, ht));
        case is_instruction_expression:
            return make_instruction_expression(do_clone_expression(instruction_expression(i),cc, ht));
    };
    return instruction_undefined;
}

References do_clone_call(), do_clone_expression(), do_clone_forloop(), do_clone_loop(), do_clone_multitest(), do_clone_sequence(), do_clone_test(), do_clone_whileloop(), instruction_call, instruction_expression, instruction_forloop, instruction_loop, instruction_multitest, instruction_sequence, instruction_tag, instruction_test, instruction_undefined, instruction_undefined_p, instruction_whileloop, is_instruction_call, is_instruction_expression, is_instruction_forloop, is_instruction_goto, is_instruction_loop, is_instruction_multitest, is_instruction_sequence, is_instruction_test, is_instruction_unstructured, is_instruction_whileloop, make_instruction_call(), make_instruction_expression(), make_instruction_forloop(), make_instruction_loop(), make_instruction_multitest(), make_instruction_sequence(), make_instruction_test(), make_instruction_whileloop(), and pips_user_error.

Referenced by do_clone_statement().

Here is the call graph for this function:

Here is the caller graph for this function:

do_clone_label()

static entity do_clone_label ( entity  l, clone_context  cc  )

static

if the label was cloned in the past, we get the same clone this function returned before instead of creating a new one

Checking if the entity is in the list of cloned labels

Insert those two values at beginning of the list (reverse inserting order as it's insterting before instead of inserting at the end)

Parameters

cc	hash_table ht

Definition at line 291 of file clone_statement.c.

{
    if(entity_empty_label_p(l)) return entity_empty_label();
 
    /* if the label was cloned in the past, we get the same clone this function
       returned before instead of creating a new one */
    entity replacement = entity_undefined;
 
    /* Checking if the entity is in the list of cloned labels */
    for (list iter = clone_context_labels(cc); !ENDP(iter); POP(iter)) {
        if (same_entity_p(ENTITY(CAR(iter)), l)) {
            POP(iter);
            replacement = ENTITY(CAR(iter));
        } else {
            POP(iter);
        }
    }
 
    if(entity_undefined_p(replacement)) {
        replacement=make_new_label(clone_context_new_module(cc));
        /* Insert those two values at beginning of the list (reverse inserting order
           as it's insterting before instead of inserting at the end) */
        clone_context_labels(cc) = CONS(ENTITY, replacement, clone_context_labels(cc));
        clone_context_labels(cc) = CONS(ENTITY, l, clone_context_labels(cc));
    }
 
    return replacement;
}

References CAR, clone_context_labels, clone_context_new_module, CONS, ENDP, ENTITY, entity_empty_label(), entity_empty_label_p(), entity_undefined, entity_undefined_p, make_new_label(), POP, and same_entity_p().

Referenced by do_clone_loop(), do_clone_statement(), and do_clone_whileloop().

Here is the call graph for this function:

Here is the caller graph for this function:

do_clone_loop()

static loop do_clone_loop ( loop  l, clone_context  cc, hash_table  ht  )

static

ht

unsure ...

Definition at line 275 of file clone_statement.c.

{
    entity new_entity = 
         gen_chunk_undefined_p(gen_find_eq(loop_index(l),loop_locals(l))) ?
            do_clone_entity(loop_index(l),cc, ht):
            loop_index(l);
    return make_loop(
            new_entity,
            do_clone_range(loop_range(l),cc, ht),
            do_clone_statement(loop_body(l),cc, ht),
            do_clone_label(loop_label(l),cc/*, ht*/),
            make_execution_sequential(),
            NIL /* unsure ...*/);
}

References do_clone_entity(), do_clone_label(), do_clone_range(), do_clone_statement(), gen_chunk_undefined_p, gen_find_eq(), loop_body, loop_index, loop_label, loop_locals, loop_range, make_execution_sequential(), make_loop(), and NIL.

Referenced by do_clone_instruction().

Here is the call graph for this function:

Here is the caller graph for this function:

do_clone_multitest()

static multitest do_clone_multitest ( multitest  m, clone_context  cc, hash_table  ht  )

static

Definition at line 344 of file clone_statement.c.

{
    return make_multitest(
            do_clone_expression(multitest_controller(m),cc, ht),
            do_clone_statement(multitest_body(m),cc, ht));
}

References do_clone_expression(), do_clone_statement(), make_multitest(), multitest_body, and multitest_controller.

Referenced by do_clone_instruction().

Here is the call graph for this function:

Here is the caller graph for this function:

do_clone_range()

static range do_clone_range ( range  r, clone_context  cc, hash_table  ht  )

static

Definition at line 64 of file clone_statement.c.

{
    return make_range(
            do_clone_expression(range_lower(r),cc, ht),
            do_clone_expression(range_upper(r),cc, ht),
            do_clone_expression(range_increment(r),cc, ht));
}

References do_clone_expression(), make_range(), range_increment, range_lower, and range_upper.

Referenced by do_clone_loop(), and do_clone_syntax().

Here is the call graph for this function:

Here is the caller graph for this function:

do_clone_reference()

static gen_chunk* do_clone_reference ( reference  r, clone_context  cc, hash_table  ht  )

static

nd formard declarations

Definition at line 46 of file clone_statement.c.

{
    entity new_entity = entity_undefined;
    if( (new_entity = hash_get(ht,entity_name(reference_variable(r)))) == HASH_UNDEFINED_VALUE )
    {
        new_entity = reference_variable(r);
        if( entity_constant_p(new_entity) )
        {
            return (gen_chunk*)make_call(new_entity,NIL);
        }
    }
    list new_indices = NIL;
    FOREACH(EXPRESSION,e,reference_indices(r))
        new_indices=CONS(EXPRESSION,do_clone_expression(e,cc, ht),new_indices);
    return (gen_chunk*)make_reference(new_entity,gen_nreverse(new_indices));
}

References CONS, do_clone_expression(), entity_constant_p, entity_name, entity_undefined, EXPRESSION, FOREACH, gen_nreverse(), hash_get(), HASH_UNDEFINED_VALUE, make_call(), make_reference(), NIL, reference_indices, and reference_variable.

Referenced by do_clone_syntax().

Here is the call graph for this function:

Here is the caller graph for this function:

do_clone_sequence()

static sequence do_clone_sequence ( sequence  s, clone_context  cc, hash_table  ht  )

static

Definition at line 252 of file clone_statement.c.

{
    list new_statements = NIL;
    FOREACH(STATEMENT,st,sequence_statements(s))
    {
        new_statements=CONS(STATEMENT,do_clone_statement(st,cc, ht),new_statements);
    }
    new_statements=gen_nreverse(new_statements);
    return make_sequence(new_statements);
}

References CONS, do_clone_statement(), FOREACH, gen_nreverse(), make_sequence(), new_statements, NIL, sequence_statements, and STATEMENT.

Referenced by do_clone_instruction().

Here is the call graph for this function:

Here is the caller graph for this function:

do_clone_sizeofexpression()

static sizeofexpression do_clone_sizeofexpression ( sizeofexpression  s, clone_context  cc, hash_table  ht  )

static

Definition at line 80 of file clone_statement.c.

{
    switch(sizeofexpression_tag(s))
    {
        case is_sizeofexpression_type:
            return copy_sizeofexpression(s);
        case is_sizeofexpression_expression:
            return make_sizeofexpression_expression(do_clone_expression(sizeofexpression_expression(s),cc, ht));
    };
    return sizeofexpression_undefined;
}

References copy_sizeofexpression(), do_clone_expression(), is_sizeofexpression_expression, is_sizeofexpression_type, make_sizeofexpression_expression(), sizeofexpression_expression, sizeofexpression_tag, and sizeofexpression_undefined.

Referenced by do_clone_syntax().

Here is the call graph for this function:

Here is the caller graph for this function:

do_clone_statement()

static statement do_clone_statement ( statement  s, clone_context  cc, hash_table  ht  )

static

ht

add new declarations to top level statement this prevents difficult scope renaming in C

Definition at line 393 of file clone_statement.c.

{
    if (statement_undefined_p(s)) return s;
 
    entity new_label = do_clone_label(statement_label(s),cc/*, ht*/);
    /* add new declarations to top level statement
     * this prevents difficult scope renaming in C
     */
    list new_declarations_initialization = NIL;
    FOREACH(ENTITY, e, statement_declarations(s))
    {
        entity new_entity = do_clone_entity(e,cc, ht);
        if( !value_unknown_p(entity_initial(e)) &&
            value_expression_p(entity_initial(e)) &&
            !expression_undefined_p( value_expression(entity_initial(e)) ) )
        {
            statement ns = make_assign_statement(
                    entity_to_expression(new_entity),
                    do_clone_expression(value_expression(entity_initial(e)),cc, ht) );
            new_declarations_initialization=CONS(STATEMENT,ns,new_declarations_initialization);
        }
    }
    instruction new_instruction = do_clone_instruction(statement_instruction(s),cc, ht);
    instruction new_instruction_with_decl = ENDP(new_declarations_initialization)?
        new_instruction:
        make_instruction_sequence(
            make_sequence(
                gen_nconc(
                    gen_nreverse(new_declarations_initialization),
                    CONS(STATEMENT,instruction_to_statement(new_instruction),NIL))
                ));
 
    return make_statement(
            new_label,
            STATEMENT_NUMBER_UNDEFINED,
            STATEMENT_ORDERING_UNDEFINED,
            empty_comments,
            new_instruction_with_decl,
            NIL,
            NULL,
            empty_extensions (), make_synchronization_none());
 
}

References CONS, do_clone_entity(), do_clone_expression(), do_clone_instruction(), do_clone_label(), empty_comments, empty_extensions(), ENDP, ENTITY, entity_initial, entity_to_expression(), expression_undefined_p, FOREACH, gen_nconc(), gen_nreverse(), instruction_to_statement(), make_assign_statement(), make_instruction_sequence(), make_sequence(), make_statement(), make_synchronization_none(), NIL, STATEMENT, statement_declarations, statement_instruction, statement_label, STATEMENT_NUMBER_UNDEFINED, STATEMENT_ORDERING_UNDEFINED, statement_undefined_p, value_expression, value_expression_p, and value_unknown_p.

Referenced by clone_statement(), do_clone_forloop(), do_clone_loop(), do_clone_multitest(), do_clone_sequence(), do_clone_test(), and do_clone_whileloop().

Here is the call graph for this function:

Here is the caller graph for this function:

do_clone_subscript()

static subscript do_clone_subscript ( subscript  s, clone_context  cc, hash_table  ht  )

static

Definition at line 93 of file clone_statement.c.

{
    list new_indices = NIL;
    FOREACH(EXPRESSION,e,subscript_indices(s))
        new_indices=CONS(EXPRESSION,do_clone_expression(e,cc, ht),new_indices);
    return make_subscript(do_clone_expression(subscript_array(s),cc, ht),gen_nreverse(new_indices));
}

References CONS, do_clone_expression(), EXPRESSION, FOREACH, gen_nreverse(), make_subscript(), NIL, subscript_array, and subscript_indices.

Referenced by do_clone_syntax().

Here is the call graph for this function:

Here is the caller graph for this function:

do_clone_syntax()

static syntax do_clone_syntax ( syntax  s, clone_context  cc, hash_table  ht  )

static

Definition at line 111 of file clone_statement.c.

{
    switch(syntax_tag(s))
    {
        case is_syntax_reference:
            {
                gen_chunk* chunk = do_clone_reference(syntax_reference(s),cc, ht);
                if(INSTANCE_OF(reference,chunk))
                {
                    pips_assert("result of cloning is a reference", check_reference((reference)chunk));
                    return make_syntax_reference((reference)chunk);
                }
                else if(INSTANCE_OF(call,chunk))
                {
                    pips_assert("result of cloning is a call", check_call((call)chunk));
                    return make_syntax_call((call)chunk);
                }
                else
                    pips_internal_error("expecting a call or a reference as result of cloning");
            }
        case is_syntax_range:
            return make_syntax_range(do_clone_range(syntax_range(s),cc, ht));
        case is_syntax_call:
            return make_syntax_call(do_clone_call(syntax_call(s),cc, ht));
        case is_syntax_cast:
            return make_syntax_cast(do_clone_cast(syntax_cast(s),cc, ht));
        case is_syntax_sizeofexpression:
            return make_syntax_sizeofexpression(do_clone_sizeofexpression(syntax_sizeofexpression(s),cc, ht));
        case is_syntax_subscript:
            return make_syntax_subscript(do_clone_subscript(syntax_subscript(s),cc, ht));
        case is_syntax_application:
            return make_syntax_application(do_clone_application(syntax_application(s),cc, ht));
        case is_syntax_va_arg:
            {
                list new_va_args = NIL;
                FOREACH(SIZEOFEXPRESSION,soe,syntax_va_arg(s))
                    new_va_args=CONS(SIZEOFEXPRESSION,do_clone_sizeofexpression(soe,cc, ht),new_va_args);
                return make_syntax_va_arg(gen_nreverse(new_va_args));
            }
 
    };
    return syntax_undefined;
}

References check_call(), check_reference(), CONS, do_clone_application(), do_clone_call(), do_clone_cast(), do_clone_range(), do_clone_reference(), do_clone_sizeofexpression(), do_clone_subscript(), FOREACH, gen_nreverse(), INSTANCE_OF, is_syntax_application, is_syntax_call, is_syntax_cast, is_syntax_range, is_syntax_reference, is_syntax_sizeofexpression, is_syntax_subscript, is_syntax_va_arg, make_syntax_application(), make_syntax_call(), make_syntax_cast(), make_syntax_range(), make_syntax_reference(), make_syntax_sizeofexpression(), make_syntax_subscript(), make_syntax_va_arg(), NIL, pips_assert, pips_internal_error, SIZEOFEXPRESSION, syntax_application, syntax_call, syntax_cast, syntax_range, syntax_reference, syntax_sizeofexpression, syntax_subscript, syntax_tag, syntax_undefined, and syntax_va_arg.

Referenced by do_clone_expression().

Here is the call graph for this function:

Here is the caller graph for this function:

do_clone_test()

static test do_clone_test ( test  t, clone_context  cc, hash_table  ht  )

static

Definition at line 264 of file clone_statement.c.

{
    if(test_undefined_p(t)) return t;
    return make_test(
            do_clone_expression(test_condition(t),cc, ht),
            do_clone_statement(test_true(t),cc, ht),
            do_clone_statement(test_false(t),cc, ht));
 
}

References do_clone_expression(), do_clone_statement(), make_test(), test_condition, test_false, test_true, and test_undefined_p.

Referenced by do_clone_instruction().

Here is the call graph for this function:

Here is the caller graph for this function:

do_clone_whileloop()

static whileloop do_clone_whileloop ( whileloop  w, clone_context  cc, hash_table  ht  )

static

ht

Definition at line 321 of file clone_statement.c.

{
    return make_whileloop(
            do_clone_expression(whileloop_condition(w),cc, ht),
            do_clone_statement(whileloop_body(w),cc, ht),
            do_clone_label(whileloop_label(w),cc/*, ht*/),
            copy_evaluation(whileloop_evaluation(w)));
}

References copy_evaluation(), do_clone_expression(), do_clone_label(), do_clone_statement(), make_whileloop(), whileloop_body, whileloop_condition, whileloop_evaluation, and whileloop_label.

Referenced by do_clone_instruction().

Here is the call graph for this function:

Here is the caller graph for this function: