25 #include "pips_config.h"
126 bool call_s_p =
false;
147 bool call_s_p =
false;
286 string instrstring = NULL;
291 instrstring=
"DO LOOP";
294 instrstring=
"WHILE LOOP";
304 instrstring=
"CONTINUE";
306 instrstring=
"RETURN";
310 instrstring=
"FORMAT";
312 instrstring=
"ASSIGN";
322 instrstring=
"UNSTRUCTURED";
325 instrstring=
"FOR LOOP";
328 instrstring=
"EXPRESSION";
341 instrstring =
"UNDEFINED INSTRUCTION";
call make_call(entity a1, list a2)
instruction make_instruction_sequence(sequence _field_)
instruction make_instruction(enum instruction_utype tag, void *val)
sequence make_sequence(list a)
instruction make_instruction_block(list statements)
Build an instruction block from a list of statements.
instruction make_continue_instruction()
Creates a CONTINUE instruction, that is the FORTRAN nop, the ";" in C or the "pass" in Python for exa...
instruction make_assign_instruction(expression l, expression r)
instruction make_call_instruction(entity e, list l)
Build an instruction that call a function entity with an argument list.
instruction MakeUnaryCallInst(entity f, expression e)
Creates a call instruction to a function with one argument.
instruction MakeNullaryCallInst(entity f)
Creates a call instruction to a function with no argument.
bool instruction_assign_p(instruction i)
Test if an instruction is an assignment.
bool instruction_stop_p(instruction i)
Test if an instruction is a Fortran STOP.
bool assignment_block_p(instruction i)
Checks if an instruction block is a list of assignments, possibly followed by a continue.
bool exit_instruction_p(instruction i)
bool abort_instruction_p(instruction i)
bool instruction_format_p(instruction i)
Test if an instruction is a Fortran FORMAT.
bool native_instruction_p(instruction i, string op_name)
Test if an instruction is a native instruction of the language.
bool instruction_continue_p(instruction i)
Test if an instruction is a CONTINUE, that is the FORTRAN nop, the ";" in C or the "pass" in Python....
bool return_instruction_p(instruction i)
Test if an instruction is a C or Fortran "return".
bool C_return_instruction_p(instruction i)
bool native_call_p(call c, string op_name)
Test if a call is a native instruction of the language.
bool fortran_return_instruction_p(instruction i)
#define ENDP(l)
Test if a list is empty.
#define NIL
The empty list (nil in Lisp)
#define CONS(_t_, _i_, _l_)
List element cell constructor (insert an element at the beginning of a list)
list gen_nconc(list cp1, list cp2)
physically concatenates CP1 and CP2 but do not duplicates the elements
#define CAR(pcons)
Get the value of the first element of a list.
void gen_free_list(list l)
free the spine of the list
#define FOREACH(_fe_CASTER, _fe_item, _fe_list)
Apply/map an instruction block on all the elements of a list.
#define CDR(pcons)
Get the list less its first element.
#define MAPL(_map_list_cp, _code, _l)
Apply some code on the addresses of all the elements of a list.
bool continue_statement_p(statement)
Test if a statement is a CONTINUE, that is the FORTRAN nop, the ";" in C or the "pass" in Python....
bool assignment_statement_p(statement)
Test if a statement is an assignment.
string safe_instruction_identification(instruction i)
void flatten_block_if_necessary(instruction i)
Flatten an instruction block if necessary.
string instruction_identification(instruction i)
Return a constant string representing symbolically the instruction type.
#define pips_internal_error
int f(int off1, int off2, int n, float r[n], float a[n], float b[n])
#define instruction_block_p(i)
#define RETURN_FUNCTION_NAME
#define ABORT_FUNCTION_NAME
#define C_RETURN_FUNCTION_NAME
#define is_instruction_block
soft block->sequence transition
#define CONTINUE_FUNCTION_NAME
#define STOP_FUNCTION_NAME
#define EXIT_FUNCTION_NAME
#define instruction_block(i)
#define FORMAT_FUNCTION_NAME
#define ASSIGN_OPERATOR_NAME
const char * entity_user_name(entity e)
Since entity_local_name may contain PIPS special characters such as prefixes (label,...
entity entity_intrinsic(const char *name)
FI: I do not understand this function name (see next one!).
#define instruction_undefined_p(x)
#define EXPRESSION(x)
EXPRESSION.
#define instruction_undefined
@ is_instruction_unstructured
@ is_instruction_whileloop
@ is_instruction_expression
#define instruction_tag(x)
#define instruction_call_p(x)
#define instruction_expression(x)
#define statement_instruction(x)
#define instruction_call(x)
#define expression_syntax(x)
#define instruction_expression_p(x)
#define STATEMENT(x)
STATEMENT.
The structure used to build lists in NewGen.