/* * Copyright 2012-2013 Ecole Normale Superieure * Copyright 2022 Cerebras Systems * * Use of this software is governed by the MIT license * * Written by Sven Verdoolaege, * Ecole Normale Superieure, 45 rue d’Ulm, 75230 Paris, France * and Cerebras Systems, 1237 E Arques Ave, Sunnyvale, CA, USA */ #include <string.h> #include <isl/id.h> #include <isl/stream.h> #include <isl/val.h> #include <isl_ast_private.h> #undef EL_BASE #define EL_BASE … #include <isl_list_templ.c> #undef EL_BASE #define EL_BASE … #include <isl_list_templ.c> isl_ctx *isl_ast_print_options_get_ctx( __isl_keep isl_ast_print_options *options) { … } __isl_give isl_ast_print_options *isl_ast_print_options_alloc(isl_ctx *ctx) { … } __isl_give isl_ast_print_options *isl_ast_print_options_dup( __isl_keep isl_ast_print_options *options) { … } __isl_give isl_ast_print_options *isl_ast_print_options_cow( __isl_take isl_ast_print_options *options) { … } __isl_give isl_ast_print_options *isl_ast_print_options_copy( __isl_keep isl_ast_print_options *options) { … } __isl_null isl_ast_print_options *isl_ast_print_options_free( __isl_take isl_ast_print_options *options) { … } /* Set the print_user callback of "options" to "print_user". * * If this callback is set, then it is used to print user nodes in the AST. * Otherwise, the expression associated to the user node is printed. */ __isl_give isl_ast_print_options *isl_ast_print_options_set_print_user( __isl_take isl_ast_print_options *options, __isl_give isl_printer *(*print_user)(__isl_take isl_printer *p, __isl_take isl_ast_print_options *options, __isl_keep isl_ast_node *node, void *user), void *user) { … } /* Set the print_for callback of "options" to "print_for". * * If this callback is set, then it used to print for nodes in the AST. */ __isl_give isl_ast_print_options *isl_ast_print_options_set_print_for( __isl_take isl_ast_print_options *options, __isl_give isl_printer *(*print_for)(__isl_take isl_printer *p, __isl_take isl_ast_print_options *options, __isl_keep isl_ast_node *node, void *user), void *user) { … } /* Create a new operation expression of operation type "op", * with arguments "args". */ static __isl_give isl_ast_expr *alloc_op(enum isl_ast_expr_op_type op, __isl_take isl_ast_expr_list *args) { … } /* Create a new operation expression of operation type "op", * which will end up having "n_arg" arguments. * The caller still needs to add those arguments. */ __isl_give isl_ast_expr *isl_ast_expr_alloc_op(isl_ctx *ctx, enum isl_ast_expr_op_type op, int n_arg) { … } __isl_give isl_ast_expr *isl_ast_expr_copy(__isl_keep isl_ast_expr *expr) { … } __isl_give isl_ast_expr *isl_ast_expr_dup(__isl_keep isl_ast_expr *expr) { … } __isl_give isl_ast_expr *isl_ast_expr_cow(__isl_take isl_ast_expr *expr) { … } __isl_null isl_ast_expr *isl_ast_expr_free(__isl_take isl_ast_expr *expr) { … } isl_ctx *isl_ast_expr_get_ctx(__isl_keep isl_ast_expr *expr) { … } enum isl_ast_expr_type isl_ast_expr_get_type(__isl_keep isl_ast_expr *expr) { … } /* Return the integer value represented by "expr". */ __isl_give isl_val *isl_ast_expr_int_get_val(__isl_keep isl_ast_expr *expr) { … } /* This is an alternative name for the function above. */ __isl_give isl_val *isl_ast_expr_get_val(__isl_keep isl_ast_expr *expr) { … } __isl_give isl_id *isl_ast_expr_id_get_id(__isl_keep isl_ast_expr *expr) { … } /* This is an alternative name for the function above. */ __isl_give isl_id *isl_ast_expr_get_id(__isl_keep isl_ast_expr *expr) { … } /* Check that "expr" is of type isl_ast_expr_op. */ static isl_stat isl_ast_expr_check_op(__isl_keep isl_ast_expr *expr) { … } /* Return the type of operation represented by "expr". */ enum isl_ast_expr_op_type isl_ast_expr_op_get_type( __isl_keep isl_ast_expr *expr) { … } /* This is an alternative name for the function above. */ enum isl_ast_expr_op_type isl_ast_expr_get_op_type( __isl_keep isl_ast_expr *expr) { … } /* Return the number of arguments of the operation represented by "expr". */ isl_size isl_ast_expr_op_get_n_arg(__isl_keep isl_ast_expr *expr) { … } /* This is an alternative name for the function above. */ isl_size isl_ast_expr_get_op_n_arg(__isl_keep isl_ast_expr *expr) { … } /* Return the argument at position "pos" of the operation represented by "expr". */ __isl_give isl_ast_expr *isl_ast_expr_op_get_arg(__isl_keep isl_ast_expr *expr, int pos) { … } /* This is an alternative name for the function above. */ __isl_give isl_ast_expr *isl_ast_expr_get_op_arg(__isl_keep isl_ast_expr *expr, int pos) { … } /* Return a copy of the arguments of the operation represented by "expr". */ static __isl_give isl_ast_expr_list *isl_ast_expr_op_get_args( __isl_keep isl_ast_expr *expr) { … } /* Return the arguments of the operation expression "expr". * This may be either a copy or the arguments themselves * if there is only one reference to "expr". * This allows the arguments to be modified inplace * if both "expr" and its arguments have only a single reference. * The caller is not allowed to modify "expr" between this call and * the subsequent call to isl_ast_expr_op_restore_args. * The only exception is that isl_ast_expr_free can be called instead. */ static __isl_give isl_ast_expr_list *isl_ast_expr_op_take_args( __isl_keep isl_ast_expr *expr) { … } /* Set the arguments of the operation expression "expr" to "args", * where the arguments of "args" may be missing * due to a preceding call to isl_ast_expr_op_take_args. * However, in this case, "expr" only has a single reference and * then the call to isl_ast_expr_cow has no effect. */ static __isl_give isl_ast_expr *isl_ast_expr_op_restore_args( __isl_take isl_ast_expr *expr, __isl_take isl_ast_expr_list *args) { … } /* Add "arg" to the arguments of the operation expression "expr". */ __isl_give isl_ast_expr *isl_ast_expr_op_add_arg(__isl_take isl_ast_expr *expr, __isl_take isl_ast_expr *arg) { … } /* Replace the argument at position "pos" of "expr" by "arg". */ __isl_give isl_ast_expr *isl_ast_expr_set_op_arg(__isl_take isl_ast_expr *expr, int pos, __isl_take isl_ast_expr *arg) { … } /* Are the lists of AST expressions "list1" and "list2" the same? */ static isl_bool isl_ast_expr_list_is_equal(__isl_keep isl_ast_expr_list *list1, __isl_keep isl_ast_expr_list *list2) { … } /* Is "expr1" equal to "expr2"? */ isl_bool isl_ast_expr_is_equal(__isl_keep isl_ast_expr *expr1, __isl_keep isl_ast_expr *expr2) { … } /* Create a new id expression representing "id". */ __isl_give isl_ast_expr *isl_ast_expr_from_id(__isl_take isl_id *id) { … } /* Create a new integer expression representing "i". */ __isl_give isl_ast_expr *isl_ast_expr_alloc_int_si(isl_ctx *ctx, int i) { … } /* Create a new integer expression representing "v". */ __isl_give isl_ast_expr *isl_ast_expr_from_val(__isl_take isl_val *v) { … } /* Create an expression representing the unary operation "type" applied to * "arg". */ __isl_give isl_ast_expr *isl_ast_expr_alloc_unary( enum isl_ast_expr_op_type type, __isl_take isl_ast_expr *arg) { … } /* Create an expression representing the negation of "arg". */ __isl_give isl_ast_expr *isl_ast_expr_neg(__isl_take isl_ast_expr *arg) { … } /* Create an expression representing the address of "expr". */ __isl_give isl_ast_expr *isl_ast_expr_address_of(__isl_take isl_ast_expr *expr) { … } /* Create an expression representing the binary operation "type" * applied to "expr1" and "expr2". */ __isl_give isl_ast_expr *isl_ast_expr_alloc_binary( enum isl_ast_expr_op_type type, __isl_take isl_ast_expr *expr1, __isl_take isl_ast_expr *expr2) { … } /* Create an expression representing the sum of "expr1" and "expr2". */ __isl_give isl_ast_expr *isl_ast_expr_add(__isl_take isl_ast_expr *expr1, __isl_take isl_ast_expr *expr2) { … } /* Create an expression representing the difference of "expr1" and "expr2". */ __isl_give isl_ast_expr *isl_ast_expr_sub(__isl_take isl_ast_expr *expr1, __isl_take isl_ast_expr *expr2) { … } /* Create an expression representing the product of "expr1" and "expr2". */ __isl_give isl_ast_expr *isl_ast_expr_mul(__isl_take isl_ast_expr *expr1, __isl_take isl_ast_expr *expr2) { … } /* Create an expression representing the quotient of "expr1" and "expr2". */ __isl_give isl_ast_expr *isl_ast_expr_div(__isl_take isl_ast_expr *expr1, __isl_take isl_ast_expr *expr2) { … } /* Create an expression representing the quotient of the integer * division of "expr1" by "expr2", where "expr1" is known to be * non-negative. */ __isl_give isl_ast_expr *isl_ast_expr_pdiv_q(__isl_take isl_ast_expr *expr1, __isl_take isl_ast_expr *expr2) { … } /* Create an expression representing the remainder of the integer * division of "expr1" by "expr2", where "expr1" is known to be * non-negative. */ __isl_give isl_ast_expr *isl_ast_expr_pdiv_r(__isl_take isl_ast_expr *expr1, __isl_take isl_ast_expr *expr2) { … } /* Create an expression representing the conjunction of "expr1" and "expr2". */ __isl_give isl_ast_expr *isl_ast_expr_and(__isl_take isl_ast_expr *expr1, __isl_take isl_ast_expr *expr2) { … } /* Create an expression representing the conjunction of "expr1" and "expr2", * where "expr2" is evaluated only if "expr1" is evaluated to true. */ __isl_give isl_ast_expr *isl_ast_expr_and_then(__isl_take isl_ast_expr *expr1, __isl_take isl_ast_expr *expr2) { … } /* Create an expression representing the disjunction of "expr1" and "expr2". */ __isl_give isl_ast_expr *isl_ast_expr_or(__isl_take isl_ast_expr *expr1, __isl_take isl_ast_expr *expr2) { … } /* Create an expression representing the disjunction of "expr1" and "expr2", * where "expr2" is evaluated only if "expr1" is evaluated to false. */ __isl_give isl_ast_expr *isl_ast_expr_or_else(__isl_take isl_ast_expr *expr1, __isl_take isl_ast_expr *expr2) { … } /* Create an expression representing "expr1" less than or equal to "expr2". */ __isl_give isl_ast_expr *isl_ast_expr_le(__isl_take isl_ast_expr *expr1, __isl_take isl_ast_expr *expr2) { … } /* Create an expression representing "expr1" less than "expr2". */ __isl_give isl_ast_expr *isl_ast_expr_lt(__isl_take isl_ast_expr *expr1, __isl_take isl_ast_expr *expr2) { … } /* Create an expression representing "expr1" greater than or equal to "expr2". */ __isl_give isl_ast_expr *isl_ast_expr_ge(__isl_take isl_ast_expr *expr1, __isl_take isl_ast_expr *expr2) { … } /* Create an expression representing "expr1" greater than "expr2". */ __isl_give isl_ast_expr *isl_ast_expr_gt(__isl_take isl_ast_expr *expr1, __isl_take isl_ast_expr *expr2) { … } /* Create an expression representing "expr1" equal to "expr2". */ __isl_give isl_ast_expr *isl_ast_expr_eq(__isl_take isl_ast_expr *expr1, __isl_take isl_ast_expr *expr2) { … } /* Create an expression of type "type" with as arguments "arg0" followed * by "arguments". */ static __isl_give isl_ast_expr *ast_expr_with_arguments( enum isl_ast_expr_op_type type, __isl_take isl_ast_expr *arg0, __isl_take isl_ast_expr_list *arguments) { … } /* Create an expression representing an access to "array" with index * expressions "indices". */ __isl_give isl_ast_expr *isl_ast_expr_access(__isl_take isl_ast_expr *array, __isl_take isl_ast_expr_list *indices) { … } /* Create an expression representing a call to "function" with argument * expressions "arguments". */ __isl_give isl_ast_expr *isl_ast_expr_call(__isl_take isl_ast_expr *function, __isl_take isl_ast_expr_list *arguments) { … } /* Wrapper around isl_ast_expr_substitute_ids for use * as an isl_ast_expr_list_map callback. */ static __isl_give isl_ast_expr *substitute_ids(__isl_take isl_ast_expr *expr, void *user) { … } /* For each subexpression of "expr" of type isl_ast_expr_id, * if it appears in "id2expr", then replace it by the corresponding * expression. */ __isl_give isl_ast_expr *isl_ast_expr_substitute_ids( __isl_take isl_ast_expr *expr, __isl_take isl_id_to_ast_expr *id2expr) { … } isl_ctx *isl_ast_node_get_ctx(__isl_keep isl_ast_node *node) { … } enum isl_ast_node_type isl_ast_node_get_type(__isl_keep isl_ast_node *node) { … } __isl_give isl_ast_node *isl_ast_node_alloc(isl_ctx *ctx, enum isl_ast_node_type type) { … } /* Create an if node with the given guard. * * The then body needs to be filled in later. */ __isl_give isl_ast_node *isl_ast_node_alloc_if(__isl_take isl_ast_expr *guard) { … } /* Create a for node with the given iterator. * * The remaining fields need to be filled in later. */ __isl_give isl_ast_node *isl_ast_node_alloc_for(__isl_take isl_id *id) { … } /* Create a mark node, marking "node" with "id". */ __isl_give isl_ast_node *isl_ast_node_alloc_mark(__isl_take isl_id *id, __isl_take isl_ast_node *node) { … } /* Create a user node evaluating "expr". */ __isl_give isl_ast_node *isl_ast_node_user_from_expr( __isl_take isl_ast_expr *expr) { … } /* This is an alternative name for the function above. */ __isl_give isl_ast_node *isl_ast_node_alloc_user(__isl_take isl_ast_expr *expr) { … } /* Create a block node with the given children. */ __isl_give isl_ast_node *isl_ast_node_block_from_children( __isl_take isl_ast_node_list *list) { … } /* This is an alternative name for the function above. */ __isl_give isl_ast_node *isl_ast_node_alloc_block( __isl_take isl_ast_node_list *list) { … } /* Represent the given list of nodes as a single node, either by * extract the node from a single element list or by creating * a block node with the list of nodes as children. */ __isl_give isl_ast_node *isl_ast_node_from_ast_node_list( __isl_take isl_ast_node_list *list) { … } __isl_give isl_ast_node *isl_ast_node_copy(__isl_keep isl_ast_node *node) { … } /* Return a fresh copy of "node". * * In the case of a degenerate for node, take into account * that "cond" and "inc" are NULL. */ __isl_give isl_ast_node *isl_ast_node_dup(__isl_keep isl_ast_node *node) { … } __isl_give isl_ast_node *isl_ast_node_cow(__isl_take isl_ast_node *node) { … } __isl_null isl_ast_node *isl_ast_node_free(__isl_take isl_ast_node *node) { … } /* Check that "node" is of type "type", printing "msg" if not. */ static isl_stat isl_ast_node_check_type(__isl_keep isl_ast_node *node, enum isl_ast_node_type type, const char *msg) { … } /* Check that "node" is of type isl_ast_node_block. */ static isl_stat isl_ast_node_check_block(__isl_keep isl_ast_node *node) { … } /* Check that "node" is of type isl_ast_node_if. */ static isl_stat isl_ast_node_check_if(__isl_keep isl_ast_node *node) { … } /* Check that "node" is of type isl_ast_node_for. */ static isl_stat isl_ast_node_check_for(__isl_keep isl_ast_node *node) { … } /* Check that "node" is of type isl_ast_node_mark. */ static isl_stat isl_ast_node_check_mark(__isl_keep isl_ast_node *node) { … } /* Check that "node" is of type isl_ast_node_user. */ static isl_stat isl_ast_node_check_user(__isl_keep isl_ast_node *node) { … } #undef NODE_TYPE #define NODE_TYPE … #undef FIELD_NAME #define FIELD_NAME … #undef FIELD_TYPE #define FIELD_TYPE … #undef FIELD #define FIELD … #include "isl_ast_node_set_field_templ.c" #undef NODE_TYPE #define NODE_TYPE … #undef FIELD_NAME #define FIELD_NAME … #undef FIELD_TYPE #define FIELD_TYPE … #undef FIELD #define FIELD … #include "isl_ast_node_set_field_templ.c" #undef NODE_TYPE #define NODE_TYPE … #undef FIELD_NAME #define FIELD_NAME … #undef FIELD_TYPE #define FIELD_TYPE … #undef FIELD #define FIELD … #include "isl_ast_node_set_field_templ.c" #undef NODE_TYPE #define NODE_TYPE … #undef FIELD_NAME #define FIELD_NAME … #undef FIELD_TYPE #define FIELD_TYPE … #undef FIELD #define FIELD … #include "isl_ast_node_set_field_templ.c" /* Return the body of the for-node "node", * This may be either a copy or the body itself * if there is only one reference to "node". * This allows the body to be modified inplace * if both "node" and its body have only a single reference. * The caller is not allowed to modify "node" between this call and * the subsequent call to isl_ast_node_for_restore_body. * The only exception is that isl_ast_node_free can be called instead. */ static __isl_give isl_ast_node *isl_ast_node_for_take_body( __isl_keep isl_ast_node *node) { … } /* Set the body of the for-node "node" to "body", * where the body of "node" may be missing * due to a preceding call to isl_ast_node_for_take_body. * However, in this case, "node" only has a single reference. */ static __isl_give isl_ast_node *isl_ast_node_for_restore_body( __isl_take isl_ast_node *node, __isl_take isl_ast_node *body) { … } __isl_give isl_ast_node *isl_ast_node_for_get_body( __isl_keep isl_ast_node *node) { … } /* Mark the given for node as being degenerate. */ __isl_give isl_ast_node *isl_ast_node_for_mark_degenerate( __isl_take isl_ast_node *node) { … } isl_bool isl_ast_node_for_is_degenerate(__isl_keep isl_ast_node *node) { … } __isl_give isl_ast_expr *isl_ast_node_for_get_iterator( __isl_keep isl_ast_node *node) { … } __isl_give isl_ast_expr *isl_ast_node_for_get_init( __isl_keep isl_ast_node *node) { … } /* Return the condition expression of the given for node. * * If the for node is degenerate, then the condition is not explicitly * stored in the node. Instead, it is constructed as * * iterator <= init */ __isl_give isl_ast_expr *isl_ast_node_for_get_cond( __isl_keep isl_ast_node *node) { … } /* Return the increment of the given for node. * * If the for node is degenerate, then the increment is not explicitly * stored in the node. We simply return "1". */ __isl_give isl_ast_expr *isl_ast_node_for_get_inc( __isl_keep isl_ast_node *node) { … } #undef NODE_TYPE #define NODE_TYPE … #undef FIELD_NAME #define FIELD_NAME … #undef FIELD_TYPE #define FIELD_TYPE … #undef FIELD #define FIELD … #include "isl_ast_node_set_field_templ.c" /* Return the then-branch of the if-node "node", * This may be either a copy or the branch itself * if there is only one reference to "node". * This allows the branch to be modified inplace * if both "node" and its then-branch have only a single reference. * The caller is not allowed to modify "node" between this call and * the subsequent call to isl_ast_node_if_restore_then_node. * The only exception is that isl_ast_node_free can be called instead. */ static __isl_give isl_ast_node *isl_ast_node_if_take_then_node( __isl_keep isl_ast_node *node) { … } /* Set the then-branch of the if-node "node" to "child", * where the then-branch of "node" may be missing * due to a preceding call to isl_ast_node_if_take_then_node. * However, in this case, "node" only has a single reference. */ static __isl_give isl_ast_node *isl_ast_node_if_restore_then_node( __isl_take isl_ast_node *node, __isl_take isl_ast_node *child) { … } /* Return the then-node of the given if-node. */ __isl_give isl_ast_node *isl_ast_node_if_get_then_node( __isl_keep isl_ast_node *node) { … } /* This is an alternative name for the function above. */ __isl_give isl_ast_node *isl_ast_node_if_get_then( __isl_keep isl_ast_node *node) { … } /* Does the given if-node have an else-node? */ isl_bool isl_ast_node_if_has_else_node(__isl_keep isl_ast_node *node) { … } /* This is an alternative name for the function above. */ isl_bool isl_ast_node_if_has_else(__isl_keep isl_ast_node *node) { … } /* Return the else-node of the given if-node, * assuming there is one. */ __isl_give isl_ast_node *isl_ast_node_if_get_else_node( __isl_keep isl_ast_node *node) { … } /* This is an alternative name for the function above. */ __isl_give isl_ast_node *isl_ast_node_if_get_else( __isl_keep isl_ast_node *node) { … } #undef NODE_TYPE #define NODE_TYPE … #undef FIELD_NAME #define FIELD_NAME … #undef FIELD_TYPE #define FIELD_TYPE … #undef FIELD #define FIELD … static #include "isl_ast_node_set_field_templ.c" /* Return the else-branch of the if-node "node", * This may be either a copy or the branch itself * if there is only one reference to "node". * This allows the branch to be modified inplace * if both "node" and its else-branch have only a single reference. * The caller is not allowed to modify "node" between this call and * the subsequent call to isl_ast_node_if_restore_else_node. * The only exception is that isl_ast_node_free can be called instead. */ static __isl_give isl_ast_node *isl_ast_node_if_take_else_node( __isl_keep isl_ast_node *node) { … } /* Set the else-branch of the if-node "node" to "child", * where the else-branch of "node" may be missing * due to a preceding call to isl_ast_node_if_take_else_node. * However, in this case, "node" only has a single reference. */ static __isl_give isl_ast_node *isl_ast_node_if_restore_else_node( __isl_take isl_ast_node *node, __isl_take isl_ast_node *child) { … } __isl_give isl_ast_expr *isl_ast_node_if_get_cond( __isl_keep isl_ast_node *node) { … } __isl_give isl_ast_node_list *isl_ast_node_block_get_children( __isl_keep isl_ast_node *node) { … } #undef NODE_TYPE #define NODE_TYPE … #undef FIELD_NAME #define FIELD_NAME … #undef FIELD_TYPE #define FIELD_TYPE … #undef FIELD #define FIELD … static #include "isl_ast_node_set_field_templ.c" /* Return the children of the block-node "node", * This may be either a copy or the children themselves * if there is only one reference to "node". * This allows the children to be modified inplace * if both "node" and its children have only a single reference. * The caller is not allowed to modify "node" between this call and * the subsequent call to isl_ast_node_block_restore_children. * The only exception is that isl_ast_node_free can be called instead. */ static __isl_give isl_ast_node_list *isl_ast_node_block_take_children( __isl_keep isl_ast_node *node) { … } /* Set the children of the block-node "node" to "children", * where the children of "node" may be missing * due to a preceding call to isl_ast_node_block_take_children. * However, in this case, "node" only has a single reference. */ static __isl_give isl_ast_node *isl_ast_node_block_restore_children( __isl_take isl_ast_node *node, __isl_take isl_ast_node_list *children) { … } __isl_give isl_ast_expr *isl_ast_node_user_get_expr( __isl_keep isl_ast_node *node) { … } /* Return the mark identifier of the mark node "node". */ __isl_give isl_id *isl_ast_node_mark_get_id(__isl_keep isl_ast_node *node) { … } /* Return the node marked by mark node "node". */ __isl_give isl_ast_node *isl_ast_node_mark_get_node( __isl_keep isl_ast_node *node) { … } #undef NODE_TYPE #define NODE_TYPE … #undef FIELD_NAME #define FIELD_NAME … #undef FIELD_TYPE #define FIELD_TYPE … #undef FIELD #define FIELD … static #include "isl_ast_node_set_field_templ.c" /* Return the child of the mark-node "node", * This may be either a copy or the child itself * if there is only one reference to "node". * This allows the child to be modified inplace * if both "node" and its child have only a single reference. * The caller is not allowed to modify "node" between this call and * the subsequent call to isl_ast_node_mark_restore_node. * The only exception is that isl_ast_node_free can be called instead. */ static __isl_give isl_ast_node *isl_ast_node_mark_take_node( __isl_keep isl_ast_node *node) { … } /* Set the child of the mark-node "node" to "child", * where the child of "node" may be missing * due to a preceding call to isl_ast_node_mark_take_node. * However, in this case, "node" only has a single reference. */ static __isl_give isl_ast_node *isl_ast_node_mark_restore_node( __isl_take isl_ast_node *node, __isl_take isl_ast_node *child) { … } __isl_give isl_id *isl_ast_node_get_annotation(__isl_keep isl_ast_node *node) { … } /* Check that "node" is of any type. * That is, simply check that it is a valid node. */ static isl_stat isl_ast_node_check_any(__isl_keep isl_ast_node *node) { … } #undef NODE_TYPE #define NODE_TYPE … #undef FIELD_NAME #define FIELD_NAME … #undef FIELD_TYPE #define FIELD_TYPE … #undef FIELD #define FIELD … static #include "isl_ast_node_set_field_templ.c" /* Replace node->annotation by "annotation". */ __isl_give isl_ast_node *isl_ast_node_set_annotation( __isl_take isl_ast_node *node, __isl_take isl_id *annotation) { … } static __isl_give isl_ast_node *traverse(__isl_take isl_ast_node *node, __isl_give isl_ast_node *(*enter)(__isl_take isl_ast_node *node, int *more, void *user), __isl_give isl_ast_node *(*leave)(__isl_take isl_ast_node *node, void *user), void *user); /* Traverse the elements of "list" and all their descendants * in depth first preorder. Call "enter" whenever a node is entered and "leave" * whenever a node is left. * * Return the updated node. */ static __isl_give isl_ast_node_list *traverse_list( __isl_take isl_ast_node_list *list, __isl_give isl_ast_node *(*enter)(__isl_take isl_ast_node *node, int *more, void *user), __isl_give isl_ast_node *(*leave)(__isl_take isl_ast_node *node, void *user), void *user) { … } /* Traverse the descendants of "node" (including the node itself) * in depth first preorder. Call "enter" whenever a node is entered and "leave" * whenever a node is left. * * If "enter" sets the "more" argument to zero, then the subtree rooted * at the given node is skipped. * * Return the updated node. */ static __isl_give isl_ast_node *traverse(__isl_take isl_ast_node *node, __isl_give isl_ast_node *(*enter)(__isl_take isl_ast_node *node, int *more, void *user), __isl_give isl_ast_node *(*leave)(__isl_take isl_ast_node *node, void *user), void *user) { … } /* Internal data structure storing the arguments of * isl_ast_node_foreach_descendant_top_down. */ struct isl_ast_node_preorder_data { … }; /* Enter "node" and set *more to continue traversing its descendants. * * In the case of a depth first preorder traversal, call data->fn and * let it decide whether to continue. */ static __isl_give isl_ast_node *preorder_enter(__isl_take isl_ast_node *node, int *more, void *user) { … } /* Leave "node". * * In the case of a depth first preorder traversal, nothing needs to be done. */ static __isl_give isl_ast_node *preorder_leave(__isl_take isl_ast_node *node, void *user) { … } /* Traverse the descendants of "node" (including the node itself) * in depth first preorder. * * If "fn" returns isl_bool_error on any of the nodes, then the traversal * is aborted. * If "fn" returns isl_bool_false on any of the nodes, then the subtree rooted * at that node is skipped. * * Return isl_stat_ok on success and isl_stat_error on failure. */ isl_stat isl_ast_node_foreach_descendant_top_down( __isl_keep isl_ast_node *node, isl_bool (*fn)(__isl_keep isl_ast_node *node, void *user), void *user) { … } /* Internal data structure storing the arguments of * isl_ast_node_map_descendant_bottom_up. */ struct isl_ast_node_postorder_data { … }; /* Enter "node" and set *more to continue traversing its descendants. * * In the case of a depth-first post-order traversal, * nothing needs to be done and traversal always continues. */ static __isl_give isl_ast_node *postorder_enter(__isl_take isl_ast_node *node, int *more, void *user) { … } /* Leave "node". * * In the case of a depth-first post-order traversal, call data->fn. */ static __isl_give isl_ast_node *postorder_leave(__isl_take isl_ast_node *node, void *user) { … } /* Traverse the descendants of "node" (including the node itself) * in depth-first post-order, where the user callback is allowed to modify the * visited node. * * Return the updated node. */ __isl_give isl_ast_node *isl_ast_node_map_descendant_bottom_up( __isl_take isl_ast_node *node, __isl_give isl_ast_node *(*fn)(__isl_take isl_ast_node *node, void *user), void *user) { … } /* Textual C representation of the various operators. */ static char *op_str_c[] = …; /* Precedence in C of the various operators. * Based on http://en.wikipedia.org/wiki/Operators_in_C_and_C++ * Lowest value means highest precedence. */ static int op_prec[] = …; /* Is the operator left-to-right associative? */ static int op_left[] = …; static int is_and(enum isl_ast_expr_op_type op) { … } static int is_or(enum isl_ast_expr_op_type op) { … } static int is_add_sub(enum isl_ast_expr_op_type op) { … } static int is_div_mod(enum isl_ast_expr_op_type op) { … } static __isl_give isl_printer *print_ast_expr_c(__isl_take isl_printer *p, __isl_keep isl_ast_expr *expr); /* Do we need/want parentheses around "expr" as a subexpression of * an "op" operation? If "left" is set, then "expr" is the left-most * operand. * * We only need parentheses if "expr" represents an operation. * * If op has a higher precedence than expr->u.op.op, then we need * parentheses. * If op and expr->u.op.op have the same precedence, but the operations * are performed in an order that is different from the associativity, * then we need parentheses. * * An and inside an or technically does not require parentheses, * but some compilers complain about that, so we add them anyway. * * Computations such as "a / b * c" and "a % b + c" can be somewhat * difficult to read, so we add parentheses for those as well. */ static int sub_expr_need_parens(enum isl_ast_expr_op_type op, __isl_keep isl_ast_expr *expr, int left) { … } /* Print the subexpression at position "pos" of operation expression "expr" * in C format. * If "left" is set, then "expr" is the left-most operand. */ static __isl_give isl_printer *print_sub_expr_c(__isl_take isl_printer *p, __isl_keep isl_ast_expr *expr, int pos, int left) { … } #define isl_ast_expr_op_last … /* Data structure that holds the user-specified textual * representations for the operators in C format. * The entries are either NULL or copies of strings. * A NULL entry means that the default name should be used. */ struct isl_ast_expr_op_names { … }; /* Create an empty struct isl_ast_expr_op_names. */ static void *create_names(isl_ctx *ctx) { … } /* Free a struct isl_ast_expr_op_names along with all memory * owned by the struct. */ static void free_names(void *user) { … } /* Create an identifier that is used to store * an isl_ast_expr_op_names note. */ static __isl_give isl_id *names_id(isl_ctx *ctx) { … } /* Ensure that "p" has a note identified by "id". * If there is no such note yet, then it is created by "note_create" and * scheduled do be freed by "note_free". */ static __isl_give isl_printer *alloc_note(__isl_take isl_printer *p, __isl_keep isl_id *id, void *(*note_create)(isl_ctx *), void (*note_free)(void *)) { … } /* Ensure that "p" has an isl_ast_expr_op_names note identified by "id". */ static __isl_give isl_printer *alloc_names(__isl_take isl_printer *p, __isl_keep isl_id *id) { … } /* Retrieve the note identified by "id" from "p". * The note is assumed to exist. */ static void *get_note(__isl_keep isl_printer *p, __isl_keep isl_id *id) { … } /* Use "name" to print operations of type "type" to "p". * * Store the name in an isl_ast_expr_op_names note attached to "p", such that * it can be retrieved by get_op_str. */ __isl_give isl_printer *isl_ast_expr_op_type_set_print_name( __isl_take isl_printer *p, enum isl_ast_expr_op_type type, __isl_keep const char *name) { … } /* This is an alternative name for the function above. */ __isl_give isl_printer *isl_ast_op_type_set_print_name( __isl_take isl_printer *p, enum isl_ast_expr_op_type type, __isl_keep const char *name) { … } /* Return the textual representation of "type" in C format. * * If there is a user-specified name in an isl_ast_expr_op_names note * associated to "p", then return that. * Otherwise, return the default name in op_str_c. */ static const char *get_op_str_c(__isl_keep isl_printer *p, enum isl_ast_expr_op_type type) { … } /* Print the expression at position "pos" in "list" in C format. */ static __isl_give isl_printer *print_at_c(__isl_take isl_printer *p, __isl_keep isl_ast_expr_list *list, int pos) { … } /* Print a min or max reduction "expr" in C format. */ static __isl_give isl_printer *print_min_max_c(__isl_take isl_printer *p, __isl_keep isl_ast_expr *expr) { … } /* Print a function call "expr" in C format. * * The first argument represents the function to be called. */ static __isl_give isl_printer *print_call_c(__isl_take isl_printer *p, __isl_keep isl_ast_expr *expr) { … } /* Print an array access "expr" in C format. * * The first argument represents the array being accessed. */ static __isl_give isl_printer *print_access_c(__isl_take isl_printer *p, __isl_keep isl_ast_expr *expr) { … } /* Print "expr" to "p" in C format. */ static __isl_give isl_printer *print_ast_expr_c(__isl_take isl_printer *p, __isl_keep isl_ast_expr *expr) { … } /* Textual representation of the isl_ast_expr_op_type elements * for use in a YAML representation of an isl_ast_expr. */ static char *op_str[] = …; static __isl_give isl_printer *print_ast_expr_isl(__isl_take isl_printer *p, __isl_keep isl_ast_expr *expr); /* Print the arguments of "expr" to "p" in isl format. * * If there are no arguments, then nothing needs to be printed. * Otherwise add an "args" key to the current mapping with as value * the list of arguments of "expr". */ static __isl_give isl_printer *print_arguments(__isl_take isl_printer *p, __isl_keep isl_ast_expr *expr) { … } /* Textual representations of the YAML keys for an isl_ast_expr object. */ static char *expr_str[] = …; /* Print "expr" to "p" in isl format. * * In particular, print the isl_ast_expr as a YAML document. */ static __isl_give isl_printer *print_ast_expr_isl(__isl_take isl_printer *p, __isl_keep isl_ast_expr *expr) { … } /* Print "expr" to "p". * * Only an isl and a C format are supported. */ __isl_give isl_printer *isl_printer_print_ast_expr(__isl_take isl_printer *p, __isl_keep isl_ast_expr *expr) { … } #undef KEY #define KEY … #undef KEY_ERROR #define KEY_ERROR … #undef KEY_END #define KEY_END … #undef KEY_STR #define KEY_STR … #undef KEY_EXTRACT #define KEY_EXTRACT … #undef KEY_GET #define KEY_GET … #include "extract_key.c" /* Return the next token, which is assumed to be a key in a YAML mapping, * from "s" as a string. */ static __isl_give char *next_key(__isl_keep isl_stream *s) { … } /* Remove the next token, which is assumed to be the key "expected" * in a YAML mapping, from "s" and move to the corresponding value. */ static isl_stat eat_key(__isl_keep isl_stream *s, const char *expected) { … } #undef EL_BASE #define EL_BASE … #include <isl_list_read_yaml_templ.c> /* Read an isl_ast_expr object of type isl_ast_expr_op from "s", * where the "op" key has already been read by the caller. * * Read the operation type and the arguments and * return the corresponding isl_ast_expr object. */ static __isl_give isl_ast_expr *read_op(__isl_keep isl_stream *s) { … } /* Read an isl_ast_expr object of type isl_ast_expr_id from "s", * where the "id" key has already been read by the caller. */ static __isl_give isl_ast_expr *read_id(__isl_keep isl_stream *s) { … } /* Read an isl_ast_expr object of type isl_ast_expr_int from "s", * where the "val" key has already been read by the caller. */ static __isl_give isl_ast_expr *read_int(__isl_keep isl_stream *s) { … } #undef KEY #define KEY … #undef KEY_ERROR #define KEY_ERROR … #undef KEY_END #define KEY_END … #undef KEY_STR #define KEY_STR … #undef KEY_EXTRACT #define KEY_EXTRACT … #undef KEY_GET #define KEY_GET … #include "extract_key.c" /* Read an isl_ast_expr object from "s". * * The keys in the YAML mapping are assumed to appear * in the same order as the one in which they are printed * by print_ast_expr_isl. * In particular, the isl_ast_expr_op type, which is the only one * with more than one element, is identified by the "op" key and * not by the "args" key. */ __isl_give isl_ast_expr *isl_stream_read_ast_expr(__isl_keep isl_stream *s) { … } static __isl_give isl_printer *print_ast_node_isl(__isl_take isl_printer *p, __isl_keep isl_ast_node *node); /* Print a YAML sequence containing the entries in "list" to "p". */ static __isl_give isl_printer *print_ast_node_list(__isl_take isl_printer *p, __isl_keep isl_ast_node_list *list) { … } /* Print "node" to "p" in "isl format". * * In particular, print the isl_ast_node as a YAML document. */ static __isl_give isl_printer *print_ast_node_isl(__isl_take isl_printer *p, __isl_keep isl_ast_node *node) { … } /* Do we need to print a block around the body "node" of a for or if node? * * If the node is a block, then we need to print a block. * Also if the node is a degenerate for then we will print it as * an assignment followed by the body of the for loop, so we need a block * as well. * If the node is an if node with an else, then we print a block * to avoid spurious dangling else warnings emitted by some compilers. * If the node is a mark, then in principle, we would have to check * the child of the mark node. However, even if the child would not * require us to print a block, for readability it is probably best * to print a block anyway. * If the ast_always_print_block option has been set, then we print a block. */ static int need_block(__isl_keep isl_ast_node *node) { … } static __isl_give isl_printer *print_ast_node_c(__isl_take isl_printer *p, __isl_keep isl_ast_node *node, __isl_keep isl_ast_print_options *options, int in_block, int in_list); static __isl_give isl_printer *print_if_c(__isl_take isl_printer *p, __isl_keep isl_ast_node *node, __isl_keep isl_ast_print_options *options, int new_line, int force_block); /* Print the body "node" of a for or if node. * If "else_node" is set, then it is printed as well. * If "force_block" is set, then print out the body as a block. * * We first check if we need to print out a block. * We always print out a block if there is an else node to make * sure that the else node is matched to the correct if node. * For consistency, the corresponding else node is also printed as a block. * * If the else node is itself an if, then we print it as * * } else if (..) { * } * * Otherwise the else node is printed as * * } else { * node * } */ static __isl_give isl_printer *print_body_c(__isl_take isl_printer *p, __isl_keep isl_ast_node *node, __isl_keep isl_ast_node *else_node, __isl_keep isl_ast_print_options *options, int force_block) { … } /* Print the start of a compound statement. */ static __isl_give isl_printer *start_block(__isl_take isl_printer *p) { … } /* Print the end of a compound statement. */ static __isl_give isl_printer *end_block(__isl_take isl_printer *p) { … } /* Print the for node "node". * * If the for node is degenerate, it is printed as * * type iterator = init; * body * * Otherwise, it is printed as * * for (type iterator = init; cond; iterator += inc) * body * * "in_block" is set if we are currently inside a block. * "in_list" is set if the current node is not alone in the block. * If we are not in a block or if the current not is not alone in the block * then we print a block around a degenerate for loop such that the variable * declaration will not conflict with any potential other declaration * of the same variable. */ static __isl_give isl_printer *print_for_c(__isl_take isl_printer *p, __isl_keep isl_ast_node *node, __isl_keep isl_ast_print_options *options, int in_block, int in_list) { … } /* Print the if node "node". * If "new_line" is set then the if node should be printed on a new line. * If "force_block" is set, then print out the body as a block. */ static __isl_give isl_printer *print_if_c(__isl_take isl_printer *p, __isl_keep isl_ast_node *node, __isl_keep isl_ast_print_options *options, int new_line, int force_block) { … } /* Print the "node" to "p". * * "in_block" is set if we are currently inside a block. * If so, we do not print a block around the children of a block node. * We do this to avoid an extra block around the body of a degenerate * for node. * * "in_list" is set if the current node is not alone in the block. */ static __isl_give isl_printer *print_ast_node_c(__isl_take isl_printer *p, __isl_keep isl_ast_node *node, __isl_keep isl_ast_print_options *options, int in_block, int in_list) { … } /* Print the for node "node" to "p". */ __isl_give isl_printer *isl_ast_node_for_print(__isl_keep isl_ast_node *node, __isl_take isl_printer *p, __isl_take isl_ast_print_options *options) { … } /* Print the if node "node" to "p". */ __isl_give isl_printer *isl_ast_node_if_print(__isl_keep isl_ast_node *node, __isl_take isl_printer *p, __isl_take isl_ast_print_options *options) { … } /* Print "node" to "p". * * "node" is assumed to be either the outermost node in an AST or * a node that is known not to be a block. * If "node" is a block (and is therefore outermost) and * if the ast_print_outermost_block options is not set, * then act as if the printing occurs inside a block, such * that no "extra" block will get printed. */ __isl_give isl_printer *isl_ast_node_print(__isl_keep isl_ast_node *node, __isl_take isl_printer *p, __isl_take isl_ast_print_options *options) { … } /* Print "node" to "p". */ __isl_give isl_printer *isl_printer_print_ast_node(__isl_take isl_printer *p, __isl_keep isl_ast_node *node) { … } /* Print the list of nodes "list" to "p". */ __isl_give isl_printer *isl_ast_node_list_print( __isl_keep isl_ast_node_list *list, __isl_take isl_printer *p, __isl_keep isl_ast_print_options *options) { … } /* Is the next token on "s" the start of a YAML sequence * (rather than a YAML mapping)? * * A YAML sequence starts with either a '[' or a '-', depending on the format. */ static isl_bool next_is_sequence(__isl_keep isl_stream *s) { … } #undef EL_BASE #define EL_BASE … #include <isl_list_read_yaml_templ.c> /* Read an isl_ast_node object of type isl_ast_node_block from "s". */ static __isl_give isl_ast_node *read_block(__isl_keep isl_stream *s) { … } /* Textual representation of the first YAML key used * while printing an isl_ast_node of a given type. * * An isl_ast_node of type isl_ast_node_block is not printed * as a YAML mapping and is therefore assigned a dummy key. */ static char *node_first_str[] = …; #undef KEY #define KEY … #undef KEY_ERROR #define KEY_ERROR … #undef KEY_END #define KEY_END … #undef KEY_STR #define KEY_STR … #undef KEY_EXTRACT #define KEY_EXTRACT … #undef KEY_GET #define KEY_GET … #include "extract_key.c" static __isl_give isl_ast_node *read_body(__isl_keep isl_stream *s, __isl_take isl_ast_node *node) { … } /* Read an isl_ast_node object of type isl_ast_node_for from "s", * where the initial "iterator" key has already been read by the caller. * * If the initial value is printed as the value of the key "value", * then the for-loop is degenerate and can at most have * a further "body" element. * Otherwise, the for-loop also has "cond" and "inc" elements. */ static __isl_give isl_ast_node *read_for(__isl_keep isl_stream *s) { … } /* Read an isl_ast_node object of type isl_ast_node_mark from "s", * where the initial "mark" key has already been read by the caller. */ static __isl_give isl_ast_node *read_mark(__isl_keep isl_stream *s) { … } /* Read an isl_ast_node object of type isl_ast_node_user from "s", * where the "user" key has already been read by the caller. */ static __isl_give isl_ast_node *read_user(__isl_keep isl_stream *s) { … } /* Read an isl_ast_node object of type isl_ast_node_if from "s", * where the initial "guard" key has already been read by the caller. */ static __isl_give isl_ast_node *read_if(__isl_keep isl_stream *s) { … } /* Read an isl_ast_node object from "s". * * A block node is printed as a YAML sequence by print_ast_node_isl. * Every other node type is printed as a YAML mapping. * * First check if the next element is a sequence and if so, * read a block node. * Otherwise, read a node based on the first mapping key * that is used to print a node type. * Note that the keys in the YAML mapping are assumed to appear * in the same order as the one in which they are printed * by print_ast_node_isl. */ __isl_give isl_ast_node *isl_stream_read_ast_node(__isl_keep isl_stream *s) { … } #define ISL_AST_MACRO_FDIV_Q … #define ISL_AST_MACRO_MIN … #define ISL_AST_MACRO_MAX … #define ISL_AST_MACRO_ALL … static int ast_expr_required_macros(__isl_keep isl_ast_expr *expr, int macros); /* Wrapper around ast_expr_required_macros for use * as an isl_ast_expr_list_foreach callback. */ static isl_stat entry_required_macros(__isl_take isl_ast_expr *expr, void *user) { … } /* If "expr" contains an isl_ast_expr_op_min, isl_ast_expr_op_max or * isl_ast_expr_op_fdiv_q then set the corresponding bit in "macros". */ static int ast_expr_required_macros(__isl_keep isl_ast_expr *expr, int macros) { … } static int ast_node_list_required_macros(__isl_keep isl_ast_node_list *list, int macros); /* If "node" contains an isl_ast_expr_op_min, isl_ast_expr_op_max or * isl_ast_expr_op_fdiv_q then set the corresponding bit in "macros". */ static int ast_node_required_macros(__isl_keep isl_ast_node *node, int macros) { … } /* If "list" contains an isl_ast_expr_op_min, isl_ast_expr_op_max or * isl_ast_expr_op_fdiv_q then set the corresponding bit in "macros". */ static int ast_node_list_required_macros(__isl_keep isl_ast_node_list *list, int macros) { … } /* Data structure for keeping track of whether a macro definition * for a given type has already been printed. * The value is zero if no definition has been printed and non-zero otherwise. */ struct isl_ast_expr_op_printed { … }; /* Create an empty struct isl_ast_expr_op_printed. */ static void *create_printed(isl_ctx *ctx) { … } /* Free a struct isl_ast_expr_op_printed. */ static void free_printed(void *user) { … } /* Ensure that "p" has an isl_ast_expr_op_printed note identified by "id". */ static __isl_give isl_printer *alloc_printed(__isl_take isl_printer *p, __isl_keep isl_id *id) { … } /* Create an identifier that is used to store * an isl_ast_expr_op_printed note. */ static __isl_give isl_id *printed_id(isl_ctx *ctx) { … } /* Did the user specify that a macro definition should only be * printed once and has a macro definition for "type" already * been printed to "p"? * If definitions should only be printed once, but a definition * for "p" has not yet been printed, then mark it as having been * printed so that it will not printed again. * The actual printing is taken care of by the caller. */ static isl_bool already_printed_once(__isl_keep isl_printer *p, enum isl_ast_expr_op_type type) { … } /* Print a macro definition for the operator "type". * * If the user has specified that a macro definition should * only be printed once to any given printer and if the macro definition * has already been printed to "p", then do not print the definition. */ __isl_give isl_printer *isl_ast_expr_op_type_print_macro( enum isl_ast_expr_op_type type, __isl_take isl_printer *p) { … } /* This is an alternative name for the function above. */ __isl_give isl_printer *isl_ast_op_type_print_macro( enum isl_ast_expr_op_type type, __isl_take isl_printer *p) { … } /* Call "fn" for each type of operation represented in the "macros" * bit vector. */ static isl_stat foreach_ast_expr_op_type(int macros, isl_stat (*fn)(enum isl_ast_expr_op_type type, void *user), void *user) { … } /* Call "fn" for each type of operation that appears in "expr" * and that requires a macro definition. */ isl_stat isl_ast_expr_foreach_ast_expr_op_type(__isl_keep isl_ast_expr *expr, isl_stat (*fn)(enum isl_ast_expr_op_type type, void *user), void *user) { … } /* This is an alternative name for the function above. */ isl_stat isl_ast_expr_foreach_ast_op_type(__isl_keep isl_ast_expr *expr, isl_stat (*fn)(enum isl_ast_expr_op_type type, void *user), void *user) { … } /* Call "fn" for each type of operation that appears in "node" * and that requires a macro definition. */ isl_stat isl_ast_node_foreach_ast_expr_op_type(__isl_keep isl_ast_node *node, isl_stat (*fn)(enum isl_ast_expr_op_type type, void *user), void *user) { … } /* This is an alternative name for the function above. */ isl_stat isl_ast_node_foreach_ast_op_type(__isl_keep isl_ast_node *node, isl_stat (*fn)(enum isl_ast_expr_op_type type, void *user), void *user) { … } static isl_stat ast_op_type_print_macro(enum isl_ast_expr_op_type type, void *user) { … } /* Print macro definitions for all the macros used in the result * of printing "expr". */ __isl_give isl_printer *isl_ast_expr_print_macros( __isl_keep isl_ast_expr *expr, __isl_take isl_printer *p) { … } /* Print macro definitions for all the macros used in the result * of printing "node". */ __isl_give isl_printer *isl_ast_node_print_macros( __isl_keep isl_ast_node *node, __isl_take isl_printer *p) { … } /* Return a string containing C code representing this isl_ast_expr. */ __isl_give char *isl_ast_expr_to_C_str(__isl_keep isl_ast_expr *expr) { … } /* Return a string containing C code representing this isl_ast_node. */ __isl_give char *isl_ast_node_to_C_str(__isl_keep isl_ast_node *node) { … }
Codebase Browser
llvm