This corresponds to: [PATCH 23/89] Introduce gimple_asm https://gcc.gnu.org/ml/gcc-patches/2014-04/msg01234.html from the original 89-patch kit
That earlier patch was approved by Jeff: > OK after fixing up the naming/const stuff as discussed for prior > patches. > That applies to 22-30. Make sure to take care of > the pretty printers per Trevor's comments as well. He indicated those > were missing in a couple of those patches. in https://gcc.gnu.org/ml/gcc-patches/2014-05/msg00628.html gcc/ * coretypes.h (gimple_asm): New typedef. (const_gimple_asm): New typedef. * gimple.h (gimple_build_asm_vec): Return a gimple_asm rather than just a gimple. (gimple_asm_clobbers_memory_p): Require a const_gimple_asm rather than just a const_gimple. (gimple_asm_ninputs): Likewise. (gimple_asm_noutputs): Likewise. (gimple_asm_nclobbers): Likewise. (gimple_asm_nlabels): Likewise. (gimple_asm_input_op): Likewise. (gimple_asm_input_op_ptr): Likewise. (gimple_asm_output_op): Likewise. (gimple_asm_output_op_ptr): Likewise. (gimple_asm_clobber_op): Likewise. (gimple_asm_label_op): Likewise. (gimple_asm_string): Likewise. (gimple_asm_volatile_p): Likewise. (gimple_asm_input_p): Likewise. (gimple_asm_set_input_op): Require a gimple_asm rather than a plain gimple. (gimple_asm_set_output_op): Likewise. (gimple_asm_set_clobber_op): Likewise. (gimple_asm_set_label_op): Likewise. (gimple_asm_set_volatile): Likewise. (gimple_asm_set_input): Likewise. * cfgexpand.c (expand_asm_stmt): Require a gimple_asm rather than a plain gimple. (expand_gimple_stmt_1): Add checked cast to gimple_asm within GIMPLE_ASM case of switch statement. * gimple-fold.c (fold_stmt_1): Add new local from checked cast to gimple_asm within case GIMPLE_ASM. * gimple-pretty-print.c (dump_gimple_asm): Require a gimple_asm rather than a plain gimple. (pp_gimple_stmt_1): Add checked cast to gimple_asm within GIMPLE_ASM case of switch statement. * gimple-streamer-in.c (input_gimple_stmt): Rework existing checked cast to gimple_asm; add a new one. * gimple-streamer-out.c (output_gimple_stmt): Add new local from checked cast to gimple_asm within case GIMPLE_ASM. * gimple-walk.c (walk_gimple_asm): Require a gimple_asm rather than a plain gimple. (walk_gimple_op): Add checked cast to gimple_asm within GIMPLE_ASM case of switch statement. (walk_stmt_load_store_addr_ops): Use dyn_cast<gimple_asm> in place of a code check against GIMPLE_ASM to introduce a new gimple_asm local. * gimple.c (gimple_build_asm_1): Return a gimple_asm rather than a plain gimple. (gimple_build_asm_vec): Likewise. (gimple_has_side_effects): Add a checked cast to gimple_asm. (gimple_could_trap_p_1): Likewise. (gimple_call_builtin_p): Require a const_gimple_asm rather then a const_gimple. * gimplify-me.c (gimple_regimplify_operands): Add a checked cast and a new local of type gimple_asm within GIMPLE_ASM case. * gimplify.c (gimplify_asm_expr): Convert a local from gimple to gimple_asm. * ipa-pure-const.c (check_stmt): Add checked casts within GIMPLE_ASM case. * ssa-iterators.h (op_iter_init): Likewise. * tree-cfg.c (make_goto_expr_edges): Convert a local from gimple to gimple_asm. (cleanup_dead_labels): Add a checked cast and a new local of type gimple_asm within GIMPLE_ASM case. (gimple_redirect_edge_and_branch): Likewise. (is_ctrl_altering_stmt): Add a checked cast. (need_fake_edge_p): Replace a code check against GIMPLE_ASM with a dyn_cast<gimple_asm>. * tree-complex.c (expand_complex_comparison): Convert a local from gimple to gimple_asm. * tree-data-ref.c (get_references_in_stmt): Add a checked cast to gimple_asm. * tree-eh.c (stmt_could_throw_p): Likewise. * tree-inline.c (estimate_num_insns): Likewise. * tree-sra.c (scan_function): Add a checked cast and a new local of type gimple_asm within GIMPLE_ASM case. (sra_modify_function_body): Likewise. (ipa_sra_modify_function_body): Likewise. * tree-ssa-coalesce.c (create_outofssa_var_map): Likewise. * tree-ssa-dce.c (propagate_necessity): Replace a code check against GIMPLE_ASM with a dyn_cast<gimple_asm>. * tree-ssa-operands.c (maybe_add_call_vops): Require a gimple_asm rather than a plain gimple. (parse_ssa_operands): Add a checked cast to gimple_asm. * tree-ssa-structalias.c (find_func_aliases): Replace a check for GIMPLE_ASM with a dyn_cast<gimple_asm>, introducing a new local "asm_stmt", using it in place of "t" for typesafety. * tree-ssa-threadedge.c (record_temporary_equivalences_from_stmts_at_dest): Add a checked cast to gimple_asm. * tree-ssa.c (execute_update_addresses_taken): Add checked casts and new locals of type gimple_asm within clauses guarded by code check. --- gcc/ChangeLog.gimple-classes | 123 ++++++++++++++++++++++++++++++++++++ gcc/cfgexpand.c | 4 +- gcc/coretypes.h | 4 ++ gcc/gimple-fold.c | 20 +++--- gcc/gimple-pretty-print.c | 4 +- gcc/gimple-streamer-in.c | 5 +- gcc/gimple-streamer-out.c | 15 +++-- gcc/gimple-walk.c | 16 ++--- gcc/gimple.c | 14 ++--- gcc/gimple.h | 146 +++++++++++++++++-------------------------- gcc/gimplify-me.c | 9 +-- gcc/gimplify.c | 2 +- gcc/ipa-pure-const.c | 4 +- gcc/ssa-iterators.h | 2 +- gcc/tree-cfg.c | 20 +++--- gcc/tree-complex.c | 2 +- gcc/tree-data-ref.c | 3 +- gcc/tree-eh.c | 2 +- gcc/tree-inline.c | 3 +- gcc/tree-sra.c | 77 +++++++++++++---------- gcc/tree-ssa-coalesce.c | 9 +-- gcc/tree-ssa-dce.c | 6 +- gcc/tree-ssa-operands.c | 4 +- gcc/tree-ssa-structalias.c | 10 +-- gcc/tree-ssa-threadedge.c | 3 +- gcc/tree-ssa.c | 18 +++--- 26 files changed, 323 insertions(+), 202 deletions(-) diff --git a/gcc/ChangeLog.gimple-classes b/gcc/ChangeLog.gimple-classes index bba6c7d..bd88371 100644 --- a/gcc/ChangeLog.gimple-classes +++ b/gcc/ChangeLog.gimple-classes @@ -1,5 +1,128 @@ 2014-10-24 David Malcolm <dmalc...@redhat.com> + Introduce gimple_asm + + * coretypes.h (gimple_asm): New typedef. + (const_gimple_asm): New typedef. + + * gimple.h (gimple_build_asm_vec): Return a gimple_asm rather than + just a gimple. + (gimple_asm_clobbers_memory_p): Require a const_gimple_asm rather + than just a const_gimple. + (gimple_asm_ninputs): Likewise. + (gimple_asm_noutputs): Likewise. + (gimple_asm_nclobbers): Likewise. + (gimple_asm_nlabels): Likewise. + (gimple_asm_input_op): Likewise. + (gimple_asm_input_op_ptr): Likewise. + (gimple_asm_output_op): Likewise. + (gimple_asm_output_op_ptr): Likewise. + (gimple_asm_clobber_op): Likewise. + (gimple_asm_label_op): Likewise. + (gimple_asm_string): Likewise. + (gimple_asm_volatile_p): Likewise. + (gimple_asm_input_p): Likewise. + (gimple_asm_set_input_op): Require a gimple_asm rather than a plain + gimple. + (gimple_asm_set_output_op): Likewise. + (gimple_asm_set_clobber_op): Likewise. + (gimple_asm_set_label_op): Likewise. + (gimple_asm_set_volatile): Likewise. + (gimple_asm_set_input): Likewise. + + * cfgexpand.c (expand_asm_stmt): Require a gimple_asm rather than + a plain gimple. + (expand_gimple_stmt_1): Add checked cast to gimple_asm within + GIMPLE_ASM case of switch statement. + + * gimple-fold.c (fold_stmt_1): Add new local from checked cast to + gimple_asm within case GIMPLE_ASM. + + * gimple-pretty-print.c (dump_gimple_asm): Require a gimple_asm + rather than a plain gimple. + (pp_gimple_stmt_1): Add checked cast to gimple_asm within + GIMPLE_ASM case of switch statement. + + * gimple-streamer-in.c (input_gimple_stmt): Rework existing + checked cast to gimple_asm; add a new one. + + * gimple-streamer-out.c (output_gimple_stmt): Add new local from + checked cast to gimple_asm within case GIMPLE_ASM. + + * gimple-walk.c (walk_gimple_asm): Require a gimple_asm rather + than a plain gimple. + (walk_gimple_op): Add checked cast to gimple_asm within GIMPLE_ASM + case of switch statement. + (walk_stmt_load_store_addr_ops): Use dyn_cast<gimple_asm> in place + of a code check against GIMPLE_ASM to introduce a new gimple_asm + local. + + * gimple.c (gimple_build_asm_1): Return a gimple_asm rather than + a plain gimple. + (gimple_build_asm_vec): Likewise. + (gimple_has_side_effects): Add a checked cast to gimple_asm. + (gimple_could_trap_p_1): Likewise. + (gimple_call_builtin_p): Require a const_gimple_asm rather then + a const_gimple. + + * gimplify-me.c (gimple_regimplify_operands): Add a checked cast + and a new local of type gimple_asm within GIMPLE_ASM case. + + * gimplify.c (gimplify_asm_expr): Convert a local from gimple to + gimple_asm. + + * ipa-pure-const.c (check_stmt): Add checked casts within + GIMPLE_ASM case. + + * ssa-iterators.h (op_iter_init): Likewise. + + * tree-cfg.c (make_goto_expr_edges): Convert a local from gimple + to gimple_asm. + (cleanup_dead_labels): Add a checked cast and a new local of type + gimple_asm within GIMPLE_ASM case. + (gimple_redirect_edge_and_branch): Likewise. + (is_ctrl_altering_stmt): Add a checked cast. + (need_fake_edge_p): Replace a code check against GIMPLE_ASM with a + dyn_cast<gimple_asm>. + + * tree-complex.c (expand_complex_comparison): Convert a local from + gimple to gimple_asm. + + * tree-data-ref.c (get_references_in_stmt): Add a checked cast to + gimple_asm. + + * tree-eh.c (stmt_could_throw_p): Likewise. + + * tree-inline.c (estimate_num_insns): Likewise. + + * tree-sra.c (scan_function): Add a checked cast and a new local + of type gimple_asm within GIMPLE_ASM case. + (sra_modify_function_body): Likewise. + (ipa_sra_modify_function_body): Likewise. + + * tree-ssa-coalesce.c (create_outofssa_var_map): Likewise. + + * tree-ssa-dce.c (propagate_necessity): Replace a code check + against GIMPLE_ASM with a dyn_cast<gimple_asm>. + + * tree-ssa-operands.c (maybe_add_call_vops): Require a gimple_asm + rather than a plain gimple. + (parse_ssa_operands): Add a checked cast to gimple_asm. + + * tree-ssa-structalias.c (find_func_aliases): Replace a check for + GIMPLE_ASM with a dyn_cast<gimple_asm>, introducing a new local + "asm_stmt", using it in place of "t" for typesafety. + + * tree-ssa-threadedge.c + (record_temporary_equivalences_from_stmts_at_dest): Add a checked + cast to gimple_asm. + + * tree-ssa.c (execute_update_addresses_taken): Add checked casts + and new locals of type gimple_asm within clauses guarded by code + check. + +2014-10-24 David Malcolm <dmalc...@redhat.com> + Introduce gimple_goto * coretypes.h (gimple_goto): New typedef. diff --git a/gcc/cfgexpand.c b/gcc/cfgexpand.c index e656ed5..d93c888 100644 --- a/gcc/cfgexpand.c +++ b/gcc/cfgexpand.c @@ -2927,7 +2927,7 @@ expand_asm_operands (tree string, tree outputs, tree inputs, static void -expand_asm_stmt (gimple stmt) +expand_asm_stmt (gimple_asm stmt) { int noutputs; tree outputs, tail, t; @@ -3212,7 +3212,7 @@ expand_gimple_stmt_1 (gimple stmt) expand_case (as_a <gimple_switch> (stmt)); break; case GIMPLE_ASM: - expand_asm_stmt (stmt); + expand_asm_stmt (as_a <gimple_asm> (stmt)); break; case GIMPLE_CALL: expand_call_stmt (as_a <gimple_call> (stmt)); diff --git a/gcc/coretypes.h b/gcc/coretypes.h index 653343a..98636bb 100644 --- a/gcc/coretypes.h +++ b/gcc/coretypes.h @@ -114,6 +114,10 @@ struct gimple_statement_assign; typedef struct gimple_statement_assign *gimple_assign; typedef const struct gimple_statement_assign *const_gimple_assign; +struct gimple_statement_asm; +typedef struct gimple_statement_asm *gimple_asm; +typedef const struct gimple_statement_asm *const_gimple_asm; + struct gimple_statement_call; typedef struct gimple_statement_call *gimple_call; typedef const struct gimple_statement_call *const_gimple_call; diff --git a/gcc/gimple-fold.c b/gcc/gimple-fold.c index 56b1e5b..c6ba019 100644 --- a/gcc/gimple-fold.c +++ b/gcc/gimple-fold.c @@ -2855,17 +2855,18 @@ fold_stmt_1 (gimple_stmt_iterator *gsi, bool inplace) } case GIMPLE_ASM: { - for (i = 0; i < gimple_asm_noutputs (stmt); ++i) + gimple_asm asm_stmt = as_a <gimple_asm> (stmt); + for (i = 0; i < gimple_asm_noutputs (asm_stmt); ++i) { - tree link = gimple_asm_output_op (stmt, i); + tree link = gimple_asm_output_op (asm_stmt, i); tree op = TREE_VALUE (link); if (REFERENCE_CLASS_P (op) && maybe_canonicalize_mem_ref_addr (&TREE_VALUE (link))) changed = true; } - for (i = 0; i < gimple_asm_ninputs (stmt); ++i) + for (i = 0; i < gimple_asm_ninputs (asm_stmt); ++i) { - tree link = gimple_asm_input_op (stmt, i); + tree link = gimple_asm_input_op (asm_stmt, i); tree op = TREE_VALUE (link); if ((REFERENCE_CLASS_P (op) || TREE_CODE (op) == ADDR_EXPR) @@ -2935,17 +2936,18 @@ fold_stmt_1 (gimple_stmt_iterator *gsi, bool inplace) case GIMPLE_ASM: /* Fold *& in asm operands. */ { + gimple_asm asm_stmt = as_a <gimple_asm> (stmt); size_t noutputs; const char **oconstraints; const char *constraint; bool allows_mem, allows_reg; - noutputs = gimple_asm_noutputs (stmt); + noutputs = gimple_asm_noutputs (asm_stmt); oconstraints = XALLOCAVEC (const char *, noutputs); - for (i = 0; i < gimple_asm_noutputs (stmt); ++i) + for (i = 0; i < gimple_asm_noutputs (asm_stmt); ++i) { - tree link = gimple_asm_output_op (stmt, i); + tree link = gimple_asm_output_op (asm_stmt, i); tree op = TREE_VALUE (link); oconstraints[i] = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (link))); @@ -2956,9 +2958,9 @@ fold_stmt_1 (gimple_stmt_iterator *gsi, bool inplace) changed = true; } } - for (i = 0; i < gimple_asm_ninputs (stmt); ++i) + for (i = 0; i < gimple_asm_ninputs (asm_stmt); ++i) { - tree link = gimple_asm_input_op (stmt, i); + tree link = gimple_asm_input_op (asm_stmt, i); tree op = TREE_VALUE (link); constraint = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (link))); diff --git a/gcc/gimple-pretty-print.c b/gcc/gimple-pretty-print.c index 47772d6..d8d7703 100644 --- a/gcc/gimple-pretty-print.c +++ b/gcc/gimple-pretty-print.c @@ -1606,7 +1606,7 @@ dump_gimple_transaction (pretty_printer *buffer, gimple gs, int spc, int flags) dumpfile.h). */ static void -dump_gimple_asm (pretty_printer *buffer, gimple gs, int spc, int flags) +dump_gimple_asm (pretty_printer *buffer, gimple_asm gs, int spc, int flags) { unsigned int i, n, f, fields; @@ -2085,7 +2085,7 @@ pp_gimple_stmt_1 (pretty_printer *buffer, gimple gs, int spc, int flags) switch (gimple_code (gs)) { case GIMPLE_ASM: - dump_gimple_asm (buffer, gs, spc, flags); + dump_gimple_asm (buffer, as_a <gimple_asm> (gs), spc, flags); break; case GIMPLE_ASSIGN: diff --git a/gcc/gimple-streamer-in.c b/gcc/gimple-streamer-in.c index 2741ea7..c297ec3 100644 --- a/gcc/gimple-streamer-in.c +++ b/gcc/gimple-streamer-in.c @@ -218,11 +218,12 @@ input_gimple_stmt (struct lto_input_block *ib, struct data_in *data_in, } else if (code == GIMPLE_ASM) { + gimple_asm asm_stmt = as_a <gimple_asm> (stmt); unsigned i; - for (i = 0; i < gimple_asm_noutputs (stmt); i++) + for (i = 0; i < gimple_asm_noutputs (asm_stmt); i++) { - tree op = TREE_VALUE (gimple_asm_output_op (stmt, i)); + tree op = TREE_VALUE (gimple_asm_output_op (asm_stmt, i)); if (TREE_CODE (op) == SSA_NAME) SSA_NAME_DEF_STMT (op) = stmt; } diff --git a/gcc/gimple-streamer-out.c b/gcc/gimple-streamer-out.c index 85a7966..77fc3fa 100644 --- a/gcc/gimple-streamer-out.c +++ b/gcc/gimple-streamer-out.c @@ -109,12 +109,15 @@ output_gimple_stmt (struct output_block *ob, gimple stmt) break; case GIMPLE_ASM: - streamer_write_uhwi (ob, gimple_asm_ninputs (stmt)); - streamer_write_uhwi (ob, gimple_asm_noutputs (stmt)); - streamer_write_uhwi (ob, gimple_asm_nclobbers (stmt)); - streamer_write_uhwi (ob, gimple_asm_nlabels (stmt)); - streamer_write_string (ob, ob->main_stream, gimple_asm_string (stmt), - true); + { + gimple_asm asm_stmt = as_a <gimple_asm> (stmt); + streamer_write_uhwi (ob, gimple_asm_ninputs (asm_stmt)); + streamer_write_uhwi (ob, gimple_asm_noutputs (asm_stmt)); + streamer_write_uhwi (ob, gimple_asm_nclobbers (asm_stmt)); + streamer_write_uhwi (ob, gimple_asm_nlabels (asm_stmt)); + streamer_write_string (ob, ob->main_stream, + gimple_asm_string (asm_stmt), true); + } /* Fallthru */ case GIMPLE_ASSIGN: diff --git a/gcc/gimple-walk.c b/gcc/gimple-walk.c index 661a69e..40d2145 100644 --- a/gcc/gimple-walk.c +++ b/gcc/gimple-walk.c @@ -94,7 +94,7 @@ walk_gimple_seq (gimple_seq seq, walk_stmt_fn callback_stmt, /* Helper function for walk_gimple_stmt. Walk operands of a GIMPLE_ASM. */ static tree -walk_gimple_asm (gimple stmt, walk_tree_fn callback_op, +walk_gimple_asm (gimple_asm stmt, walk_tree_fn callback_op, struct walk_stmt_info *wi) { tree ret, op; @@ -292,7 +292,7 @@ walk_gimple_op (gimple stmt, walk_tree_fn callback_op, break; case GIMPLE_ASM: - ret = walk_gimple_asm (stmt, callback_op, wi); + ret = walk_gimple_asm (as_a <gimple_asm> (stmt), callback_op, wi); if (ret) return ret; break; @@ -779,18 +779,18 @@ walk_stmt_load_store_addr_ops (gimple stmt, void *data, ret |= visit_addr (stmt, gimple_call_lhs (stmt), gimple_call_lhs (stmt), data); } - else if (gimple_code (stmt) == GIMPLE_ASM) + else if (gimple_asm asm_stmt = dyn_cast <gimple_asm> (stmt)) { unsigned noutputs; const char *constraint; const char **oconstraints; bool allows_mem, allows_reg, is_inout; - noutputs = gimple_asm_noutputs (stmt); + noutputs = gimple_asm_noutputs (asm_stmt); oconstraints = XALLOCAVEC (const char *, noutputs); if (visit_store || visit_addr) - for (i = 0; i < gimple_asm_noutputs (stmt); ++i) + for (i = 0; i < gimple_asm_noutputs (asm_stmt); ++i) { - tree link = gimple_asm_output_op (stmt, i); + tree link = gimple_asm_output_op (asm_stmt, i); tree op = get_base_loadstore (TREE_VALUE (link)); if (op && visit_store) ret |= visit_store (stmt, op, TREE_VALUE (link), data); @@ -806,9 +806,9 @@ walk_stmt_load_store_addr_ops (gimple stmt, void *data, } } if (visit_load || visit_addr) - for (i = 0; i < gimple_asm_ninputs (stmt); ++i) + for (i = 0; i < gimple_asm_ninputs (asm_stmt); ++i) { - tree link = gimple_asm_input_op (stmt, i); + tree link = gimple_asm_input_op (asm_stmt, i); tree op = TREE_VALUE (link); if (visit_addr && TREE_CODE (op) == ADDR_EXPR) diff --git a/gcc/gimple.c b/gcc/gimple.c index 0e5e473..2d86191 100644 --- a/gcc/gimple.c +++ b/gcc/gimple.c @@ -542,11 +542,11 @@ gimple_build_bind (tree vars, gimple_seq body, tree block) NCLOBBERS is the number of clobbered registers. */ -static inline gimple +static inline gimple_asm gimple_build_asm_1 (const char *string, unsigned ninputs, unsigned noutputs, unsigned nclobbers, unsigned nlabels) { - gimple_statement_asm *p; + gimple_asm p; int size = strlen (string); /* ASMs with labels cannot have outputs. This should have been @@ -580,12 +580,12 @@ gimple_build_asm_1 (const char *string, unsigned ninputs, unsigned noutputs, CLOBBERS is a vector of the clobbered register parameters. LABELS is a vector of destination labels. */ -gimple +gimple_asm gimple_build_asm_vec (const char *string, vec<tree, va_gc> *inputs, vec<tree, va_gc> *outputs, vec<tree, va_gc> *clobbers, vec<tree, va_gc> *labels) { - gimple p; + gimple_asm p; unsigned i; p = gimple_build_asm_1 (string, @@ -1821,7 +1821,7 @@ gimple_has_side_effects (const_gimple s) return true; if (gimple_code (s) == GIMPLE_ASM - && gimple_asm_volatile_p (s)) + && gimple_asm_volatile_p (as_a <const_gimple_asm> (s))) return true; if (is_gimple_call (s)) @@ -1862,7 +1862,7 @@ gimple_could_trap_p_1 (gimple s, bool include_mem, bool include_stores) switch (gimple_code (s)) { case GIMPLE_ASM: - return gimple_asm_volatile_p (s); + return gimple_asm_volatile_p (as_a <gimple_asm> (s)); case GIMPLE_CALL: t = gimple_call_fndecl (s); @@ -2477,7 +2477,7 @@ gimple_call_builtin_p (const_gimple stmt, enum built_in_function code) GIMPLE_ASM. */ bool -gimple_asm_clobbers_memory_p (const_gimple stmt) +gimple_asm_clobbers_memory_p (const_gimple_asm stmt) { unsigned i; diff --git a/gcc/gimple.h b/gcc/gimple.h index 128baf5..d2dc7ce 100644 --- a/gcc/gimple.h +++ b/gcc/gimple.h @@ -1322,9 +1322,9 @@ gimple_label gimple_build_label (tree label); gimple_goto gimple_build_goto (tree dest); gimple gimple_build_nop (void); gimple_bind gimple_build_bind (tree, gimple_seq, tree); -gimple gimple_build_asm_vec (const char *, vec<tree, va_gc> *, - vec<tree, va_gc> *, vec<tree, va_gc> *, - vec<tree, va_gc> *); +gimple_asm gimple_build_asm_vec (const char *, vec<tree, va_gc> *, + vec<tree, va_gc> *, vec<tree, va_gc> *, + vec<tree, va_gc> *); gimple gimple_build_catch (tree, gimple_seq); gimple gimple_build_eh_filter (tree, gimple_seq); gimple gimple_build_eh_must_not_throw (tree); @@ -1401,7 +1401,7 @@ extern bool gimple_builtin_call_types_compatible_p (const_gimple, tree); extern bool gimple_call_builtin_p (const_gimple); extern bool gimple_call_builtin_p (const_gimple, enum built_in_class); extern bool gimple_call_builtin_p (const_gimple, enum built_in_function); -extern bool gimple_asm_clobbers_memory_p (const_gimple); +extern bool gimple_asm_clobbers_memory_p (const_gimple_asm); extern void dump_decl_set (FILE *, bitmap); extern bool nonfreeing_call_p (gimple); extern bool infer_nonnull_range (gimple, tree, bool, bool); @@ -3339,218 +3339,188 @@ gimple_bind_set_block (gimple_bind bind_stmt, tree block) } -/* Return the number of input operands for GIMPLE_ASM GS. */ +/* Return the number of input operands for GIMPLE_ASM ASM_STMT. */ static inline unsigned -gimple_asm_ninputs (const_gimple gs) +gimple_asm_ninputs (const_gimple_asm asm_stmt) { - const gimple_statement_asm *asm_stmt = - as_a <const gimple_statement_asm *> (gs); return asm_stmt->ni; } -/* Return the number of output operands for GIMPLE_ASM GS. */ +/* Return the number of output operands for GIMPLE_ASM ASM_STMT. */ static inline unsigned -gimple_asm_noutputs (const_gimple gs) +gimple_asm_noutputs (const_gimple_asm asm_stmt) { - const gimple_statement_asm *asm_stmt = - as_a <const gimple_statement_asm *> (gs); return asm_stmt->no; } -/* Return the number of clobber operands for GIMPLE_ASM GS. */ +/* Return the number of clobber operands for GIMPLE_ASM ASM_STMT. */ static inline unsigned -gimple_asm_nclobbers (const_gimple gs) +gimple_asm_nclobbers (const_gimple_asm asm_stmt) { - const gimple_statement_asm *asm_stmt = - as_a <const gimple_statement_asm *> (gs); return asm_stmt->nc; } -/* Return the number of label operands for GIMPLE_ASM GS. */ +/* Return the number of label operands for GIMPLE_ASM ASM_STMT. */ static inline unsigned -gimple_asm_nlabels (const_gimple gs) +gimple_asm_nlabels (const_gimple_asm asm_stmt) { - const gimple_statement_asm *asm_stmt = - as_a <const gimple_statement_asm *> (gs); return asm_stmt->nl; } -/* Return input operand INDEX of GIMPLE_ASM GS. */ +/* Return input operand INDEX of GIMPLE_ASM ASM_STMT. */ static inline tree -gimple_asm_input_op (const_gimple gs, unsigned index) +gimple_asm_input_op (const_gimple_asm asm_stmt, unsigned index) { - const gimple_statement_asm *asm_stmt = - as_a <const gimple_statement_asm *> (gs); gcc_gimple_checking_assert (index < asm_stmt->ni); - return gimple_op (gs, index + asm_stmt->no); + return gimple_op (asm_stmt, index + asm_stmt->no); } -/* Return a pointer to input operand INDEX of GIMPLE_ASM GS. */ +/* Return a pointer to input operand INDEX of GIMPLE_ASM ASM_STMT. */ static inline tree * -gimple_asm_input_op_ptr (const_gimple gs, unsigned index) +gimple_asm_input_op_ptr (const_gimple_asm asm_stmt, unsigned index) { - const gimple_statement_asm *asm_stmt = - as_a <const gimple_statement_asm *> (gs); gcc_gimple_checking_assert (index < asm_stmt->ni); - return gimple_op_ptr (gs, index + asm_stmt->no); + return gimple_op_ptr (asm_stmt, index + asm_stmt->no); } -/* Set IN_OP to be input operand INDEX in GIMPLE_ASM GS. */ +/* Set IN_OP to be input operand INDEX in GIMPLE_ASM ASM_STMT. */ static inline void -gimple_asm_set_input_op (gimple gs, unsigned index, tree in_op) +gimple_asm_set_input_op (gimple_asm asm_stmt, unsigned index, tree in_op) { - gimple_statement_asm *asm_stmt = as_a <gimple_statement_asm *> (gs); gcc_gimple_checking_assert (index < asm_stmt->ni && TREE_CODE (in_op) == TREE_LIST); - gimple_set_op (gs, index + asm_stmt->no, in_op); + gimple_set_op (asm_stmt, index + asm_stmt->no, in_op); } -/* Return output operand INDEX of GIMPLE_ASM GS. */ +/* Return output operand INDEX of GIMPLE_ASM ASM_STMT. */ static inline tree -gimple_asm_output_op (const_gimple gs, unsigned index) +gimple_asm_output_op (const_gimple_asm asm_stmt, unsigned index) { - const gimple_statement_asm *asm_stmt = - as_a <const gimple_statement_asm *> (gs); gcc_gimple_checking_assert (index < asm_stmt->no); - return gimple_op (gs, index); + return gimple_op (asm_stmt, index); } -/* Return a pointer to output operand INDEX of GIMPLE_ASM GS. */ +/* Return a pointer to output operand INDEX of GIMPLE_ASM ASM_STMT. */ static inline tree * -gimple_asm_output_op_ptr (const_gimple gs, unsigned index) +gimple_asm_output_op_ptr (const_gimple_asm asm_stmt, unsigned index) { - const gimple_statement_asm *asm_stmt = - as_a <const gimple_statement_asm *> (gs); gcc_gimple_checking_assert (index < asm_stmt->no); - return gimple_op_ptr (gs, index); + return gimple_op_ptr (asm_stmt, index); } -/* Set OUT_OP to be output operand INDEX in GIMPLE_ASM GS. */ +/* Set OUT_OP to be output operand INDEX in GIMPLE_ASM ASM_STMT. */ static inline void -gimple_asm_set_output_op (gimple gs, unsigned index, tree out_op) +gimple_asm_set_output_op (gimple_asm asm_stmt, unsigned index, tree out_op) { - gimple_statement_asm *asm_stmt = as_a <gimple_statement_asm *> (gs); gcc_gimple_checking_assert (index < asm_stmt->no && TREE_CODE (out_op) == TREE_LIST); - gimple_set_op (gs, index, out_op); + gimple_set_op (asm_stmt, index, out_op); } -/* Return clobber operand INDEX of GIMPLE_ASM GS. */ +/* Return clobber operand INDEX of GIMPLE_ASM ASM_STMT. */ static inline tree -gimple_asm_clobber_op (const_gimple gs, unsigned index) +gimple_asm_clobber_op (const_gimple_asm asm_stmt, unsigned index) { - const gimple_statement_asm *asm_stmt = - as_a <const gimple_statement_asm *> (gs); gcc_gimple_checking_assert (index < asm_stmt->nc); - return gimple_op (gs, index + asm_stmt->ni + asm_stmt->no); + return gimple_op (asm_stmt, index + asm_stmt->ni + asm_stmt->no); } -/* Set CLOBBER_OP to be clobber operand INDEX in GIMPLE_ASM GS. */ +/* Set CLOBBER_OP to be clobber operand INDEX in GIMPLE_ASM ASM_STMT. */ static inline void -gimple_asm_set_clobber_op (gimple gs, unsigned index, tree clobber_op) +gimple_asm_set_clobber_op (gimple_asm asm_stmt, unsigned index, tree clobber_op) { - gimple_statement_asm *asm_stmt = as_a <gimple_statement_asm *> (gs); gcc_gimple_checking_assert (index < asm_stmt->nc && TREE_CODE (clobber_op) == TREE_LIST); - gimple_set_op (gs, index + asm_stmt->ni + asm_stmt->no, clobber_op); + gimple_set_op (asm_stmt, index + asm_stmt->ni + asm_stmt->no, clobber_op); } -/* Return label operand INDEX of GIMPLE_ASM GS. */ +/* Return label operand INDEX of GIMPLE_ASM ASM_STMT. */ static inline tree -gimple_asm_label_op (const_gimple gs, unsigned index) +gimple_asm_label_op (const_gimple_asm asm_stmt, unsigned index) { - const gimple_statement_asm *asm_stmt = - as_a <const gimple_statement_asm *> (gs); gcc_gimple_checking_assert (index < asm_stmt->nl); - return gimple_op (gs, index + asm_stmt->ni + asm_stmt->nc); + return gimple_op (asm_stmt, index + asm_stmt->ni + asm_stmt->nc); } -/* Set LABEL_OP to be label operand INDEX in GIMPLE_ASM GS. */ +/* Set LABEL_OP to be label operand INDEX in GIMPLE_ASM ASM_STMT. */ static inline void -gimple_asm_set_label_op (gimple gs, unsigned index, tree label_op) +gimple_asm_set_label_op (gimple_asm asm_stmt, unsigned index, tree label_op) { - gimple_statement_asm *asm_stmt = as_a <gimple_statement_asm *> (gs); gcc_gimple_checking_assert (index < asm_stmt->nl && TREE_CODE (label_op) == TREE_LIST); - gimple_set_op (gs, index + asm_stmt->ni + asm_stmt->nc, label_op); + gimple_set_op (asm_stmt, index + asm_stmt->ni + asm_stmt->nc, label_op); } /* Return the string representing the assembly instruction in - GIMPLE_ASM GS. */ + GIMPLE_ASM ASM_STMT. */ static inline const char * -gimple_asm_string (const_gimple gs) +gimple_asm_string (const_gimple_asm asm_stmt) { - const gimple_statement_asm *asm_stmt = - as_a <const gimple_statement_asm *> (gs); return asm_stmt->string; } -/* Return true if GS is an asm statement marked volatile. */ +/* Return true ASM_STMT ASM_STMT is an asm statement marked volatile. */ static inline bool -gimple_asm_volatile_p (const_gimple gs) +gimple_asm_volatile_p (const_gimple_asm asm_stmt) { - GIMPLE_CHECK (gs, GIMPLE_ASM); - return (gs->subcode & GF_ASM_VOLATILE) != 0; + return (asm_stmt->subcode & GF_ASM_VOLATILE) != 0; } -/* If VOLATLE_P is true, mark asm statement GS as volatile. */ +/* If VOLATLE_P is true, mark asm statement ASM_STMT as volatile. */ static inline void -gimple_asm_set_volatile (gimple gs, bool volatile_p) +gimple_asm_set_volatile (gimple_asm asm_stmt, bool volatile_p) { - GIMPLE_CHECK (gs, GIMPLE_ASM); if (volatile_p) - gs->subcode |= GF_ASM_VOLATILE; + asm_stmt->subcode |= GF_ASM_VOLATILE; else - gs->subcode &= ~GF_ASM_VOLATILE; + asm_stmt->subcode &= ~GF_ASM_VOLATILE; } -/* If INPUT_P is true, mark asm GS as an ASM_INPUT. */ +/* If INPUT_P is true, mark asm ASM_STMT as an ASM_INPUT. */ static inline void -gimple_asm_set_input (gimple gs, bool input_p) +gimple_asm_set_input (gimple_asm asm_stmt, bool input_p) { - GIMPLE_CHECK (gs, GIMPLE_ASM); if (input_p) - gs->subcode |= GF_ASM_INPUT; + asm_stmt->subcode |= GF_ASM_INPUT; else - gs->subcode &= ~GF_ASM_INPUT; + asm_stmt->subcode &= ~GF_ASM_INPUT; } -/* Return true if asm GS is an ASM_INPUT. */ +/* Return true if asm ASM_STMT is an ASM_INPUT. */ static inline bool -gimple_asm_input_p (const_gimple gs) +gimple_asm_input_p (const_gimple_asm asm_stmt) { - GIMPLE_CHECK (gs, GIMPLE_ASM); - return (gs->subcode & GF_ASM_INPUT) != 0; + return (asm_stmt->subcode & GF_ASM_INPUT) != 0; } diff --git a/gcc/gimplify-me.c b/gcc/gimplify-me.c index 05e986a..08d2b9c 100644 --- a/gcc/gimplify-me.c +++ b/gcc/gimplify-me.c @@ -183,7 +183,8 @@ gimple_regimplify_operands (gimple stmt, gimple_stmt_iterator *gsi_p) break; case GIMPLE_ASM: { - size_t i, noutputs = gimple_asm_noutputs (stmt); + gimple_asm asm_stmt = as_a <gimple_asm> (stmt); + size_t i, noutputs = gimple_asm_noutputs (asm_stmt); const char *constraint, **oconstraints; bool allows_mem, allows_reg, is_inout; @@ -191,7 +192,7 @@ gimple_regimplify_operands (gimple stmt, gimple_stmt_iterator *gsi_p) = (const char **) alloca ((noutputs) * sizeof (const char *)); for (i = 0; i < noutputs; i++) { - tree op = gimple_asm_output_op (stmt, i); + tree op = gimple_asm_output_op (asm_stmt, i); constraint = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (op))); oconstraints[i] = constraint; parse_output_constraint (&constraint, i, 0, 0, &allows_mem, @@ -200,9 +201,9 @@ gimple_regimplify_operands (gimple stmt, gimple_stmt_iterator *gsi_p) is_inout ? is_gimple_min_lval : is_gimple_lvalue, fb_lvalue | fb_mayfail); } - for (i = 0; i < gimple_asm_ninputs (stmt); i++) + for (i = 0; i < gimple_asm_ninputs (asm_stmt); i++) { - tree op = gimple_asm_input_op (stmt, i); + tree op = gimple_asm_input_op (asm_stmt, i); constraint = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (op))); parse_input_constraint (&constraint, 0, 0, noutputs, 0, oconstraints, &allows_mem, &allows_reg); diff --git a/gcc/gimplify.c b/gcc/gimplify.c index af64e45..bed3606 100644 --- a/gcc/gimplify.c +++ b/gcc/gimplify.c @@ -4918,7 +4918,7 @@ gimplify_asm_expr (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p) const char *constraint; bool allows_mem, allows_reg, is_inout; enum gimplify_status ret, tret; - gimple stmt; + gimple_asm stmt; vec<tree, va_gc> *inputs; vec<tree, va_gc> *outputs; vec<tree, va_gc> *clobbers; diff --git a/gcc/ipa-pure-const.c b/gcc/ipa-pure-const.c index 6beca09..8375381 100644 --- a/gcc/ipa-pure-const.c +++ b/gcc/ipa-pure-const.c @@ -698,14 +698,14 @@ check_stmt (gimple_stmt_iterator *gsip, funct_state local, bool ipa) } break; case GIMPLE_ASM: - if (gimple_asm_clobbers_memory_p (stmt)) + if (gimple_asm_clobbers_memory_p (as_a <gimple_asm> (stmt))) { if (dump_file) fprintf (dump_file, " memory asm clobber is not const/pure\n"); /* Abandon all hope, ye who enter here. */ local->pure_const_state = IPA_NEITHER; } - if (gimple_asm_volatile_p (stmt)) + if (gimple_asm_volatile_p (as_a <gimple_asm> (stmt))) { if (dump_file) fprintf (dump_file, " volatile is not const/pure\n"); diff --git a/gcc/ssa-iterators.h b/gcc/ssa-iterators.h index 2c75e4a..f332b7c 100644 --- a/gcc/ssa-iterators.h +++ b/gcc/ssa-iterators.h @@ -610,7 +610,7 @@ op_iter_init (ssa_op_iter *ptr, gimple stmt, int flags) ptr->numops = 1; break; case GIMPLE_ASM: - ptr->numops = gimple_asm_noutputs (stmt); + ptr->numops = gimple_asm_noutputs (as_a <gimple_asm> (stmt)); break; default: ptr->numops = 0; diff --git a/gcc/tree-cfg.c b/gcc/tree-cfg.c index 1652075..8e9262f 100644 --- a/gcc/tree-cfg.c +++ b/gcc/tree-cfg.c @@ -1247,7 +1247,7 @@ make_goto_expr_edges (basic_block bb) static void make_gimple_asm_edges (basic_block bb) { - gimple stmt = last_stmt (bb); + gimple_asm stmt = as_a <gimple_asm> (last_stmt (bb)); int i, n = gimple_asm_nlabels (stmt); for (i = 0; i < n; ++i) @@ -1447,11 +1447,12 @@ cleanup_dead_labels (void) case GIMPLE_ASM: { - int i, n = gimple_asm_nlabels (stmt); + gimple_asm asm_stmt = as_a <gimple_asm> (stmt); + int i, n = gimple_asm_nlabels (asm_stmt); for (i = 0; i < n; ++i) { - tree cons = gimple_asm_label_op (stmt, i); + tree cons = gimple_asm_label_op (asm_stmt, i); tree label = main_block_label (TREE_VALUE (cons)); TREE_VALUE (cons) = label; } @@ -2414,7 +2415,7 @@ is_ctrl_altering_stmt (gimple t) return true; case GIMPLE_ASM: - if (gimple_asm_nlabels (t) > 0) + if (gimple_asm_nlabels (as_a <gimple_asm> (t)) > 0) return true; break; @@ -5535,12 +5536,13 @@ gimple_redirect_edge_and_branch (edge e, basic_block dest) case GIMPLE_ASM: { - int i, n = gimple_asm_nlabels (stmt); + gimple_asm asm_stmt = as_a <gimple_asm> (stmt); + int i, n = gimple_asm_nlabels (asm_stmt); tree label = NULL; for (i = 0; i < n; ++i) { - tree cons = gimple_asm_label_op (stmt, i); + tree cons = gimple_asm_label_op (asm_stmt, i); if (label_to_block (TREE_VALUE (cons)) == e->dest) { if (!label) @@ -7567,9 +7569,9 @@ need_fake_edge_p (gimple t) return true; } - if (gimple_code (t) == GIMPLE_ASM - && (gimple_asm_volatile_p (t) || gimple_asm_input_p (t))) - return true; + if (gimple_asm asm_stmt = dyn_cast <gimple_asm> (t)) + if (gimple_asm_volatile_p (asm_stmt) || gimple_asm_input_p (asm_stmt)) + return true; return false; } diff --git a/gcc/tree-complex.c b/gcc/tree-complex.c index c259504..d2b4f01 100644 --- a/gcc/tree-complex.c +++ b/gcc/tree-complex.c @@ -1419,7 +1419,7 @@ expand_complex_comparison (gimple_stmt_iterator *gsi, tree ar, tree ai, static void expand_complex_asm (gimple_stmt_iterator *gsi) { - gimple stmt = gsi_stmt (*gsi); + gimple_asm stmt = as_a <gimple_asm> (gsi_stmt (*gsi)); unsigned int i; for (i = 0; i < gimple_asm_noutputs (stmt); ++i) diff --git a/gcc/tree-data-ref.c b/gcc/tree-data-ref.c index 89aeb30..9bd3c17 100644 --- a/gcc/tree-data-ref.c +++ b/gcc/tree-data-ref.c @@ -4388,7 +4388,8 @@ get_references_in_stmt (gimple stmt, vec<data_ref_loc, va_heap> *references) clobbers_memory = true; } else if (stmt_code == GIMPLE_ASM - && (gimple_asm_volatile_p (stmt) || gimple_vuse (stmt))) + && (gimple_asm_volatile_p (as_a <gimple_asm> (stmt)) + || gimple_vuse (stmt))) clobbers_memory = true; if (!gimple_vuse (stmt)) diff --git a/gcc/tree-eh.c b/gcc/tree-eh.c index df3f613..9769225 100644 --- a/gcc/tree-eh.c +++ b/gcc/tree-eh.c @@ -2773,7 +2773,7 @@ stmt_could_throw_p (gimple stmt) case GIMPLE_ASM: if (!cfun->can_throw_non_call_exceptions) return false; - return gimple_asm_volatile_p (stmt); + return gimple_asm_volatile_p (as_a <gimple_asm> (stmt)); default: return false; diff --git a/gcc/tree-inline.c b/gcc/tree-inline.c index 15b2cdd..2c7d6b7 100644 --- a/gcc/tree-inline.c +++ b/gcc/tree-inline.c @@ -3944,7 +3944,8 @@ estimate_num_insns (gimple stmt, eni_weights *weights) case GIMPLE_ASM: { - int count = asm_str_count (gimple_asm_string (stmt)); + int count = + asm_str_count (gimple_asm_string (as_a <gimple_asm> (stmt))); /* 1000 means infinity. This avoids overflows later with very long asm statements. */ if (count > 1000) diff --git a/gcc/tree-sra.c b/gcc/tree-sra.c index fb24114..67c4247 100644 --- a/gcc/tree-sra.c +++ b/gcc/tree-sra.c @@ -1325,21 +1325,24 @@ scan_function (void) break; case GIMPLE_ASM: - walk_stmt_load_store_addr_ops (stmt, NULL, NULL, NULL, - asm_visit_addr); - if (final_bbs) - bitmap_set_bit (final_bbs, bb->index); + { + gimple_asm asm_stmt = as_a <gimple_asm> (stmt); + walk_stmt_load_store_addr_ops (asm_stmt, NULL, NULL, NULL, + asm_visit_addr); + if (final_bbs) + bitmap_set_bit (final_bbs, bb->index); - for (i = 0; i < gimple_asm_ninputs (stmt); i++) - { - t = TREE_VALUE (gimple_asm_input_op (stmt, i)); - ret |= build_access_from_expr (t, stmt, false); - } - for (i = 0; i < gimple_asm_noutputs (stmt); i++) - { - t = TREE_VALUE (gimple_asm_output_op (stmt, i)); - ret |= build_access_from_expr (t, stmt, true); - } + for (i = 0; i < gimple_asm_ninputs (asm_stmt); i++) + { + t = TREE_VALUE (gimple_asm_input_op (asm_stmt, i)); + ret |= build_access_from_expr (t, asm_stmt, false); + } + for (i = 0; i < gimple_asm_noutputs (asm_stmt); i++) + { + t = TREE_VALUE (gimple_asm_output_op (asm_stmt, i)); + ret |= build_access_from_expr (t, asm_stmt, true); + } + } break; default: @@ -3411,16 +3414,19 @@ sra_modify_function_body (void) break; case GIMPLE_ASM: - for (i = 0; i < gimple_asm_ninputs (stmt); i++) - { - t = &TREE_VALUE (gimple_asm_input_op (stmt, i)); - modified |= sra_modify_expr (t, &gsi, false); - } - for (i = 0; i < gimple_asm_noutputs (stmt); i++) - { - t = &TREE_VALUE (gimple_asm_output_op (stmt, i)); - modified |= sra_modify_expr (t, &gsi, true); - } + { + gimple_asm asm_stmt = as_a <gimple_asm> (stmt); + for (i = 0; i < gimple_asm_ninputs (asm_stmt); i++) + { + t = &TREE_VALUE (gimple_asm_input_op (asm_stmt, i)); + modified |= sra_modify_expr (t, &gsi, false); + } + for (i = 0; i < gimple_asm_noutputs (asm_stmt); i++) + { + t = &TREE_VALUE (gimple_asm_output_op (asm_stmt, i)); + modified |= sra_modify_expr (t, &gsi, true); + } + } break; default: @@ -4672,16 +4678,19 @@ ipa_sra_modify_function_body (ipa_parm_adjustment_vec adjustments) break; case GIMPLE_ASM: - for (i = 0; i < gimple_asm_ninputs (stmt); i++) - { - t = &TREE_VALUE (gimple_asm_input_op (stmt, i)); - modified |= ipa_modify_expr (t, true, adjustments); - } - for (i = 0; i < gimple_asm_noutputs (stmt); i++) - { - t = &TREE_VALUE (gimple_asm_output_op (stmt, i)); - modified |= ipa_modify_expr (t, false, adjustments); - } + { + gimple_asm asm_stmt = as_a <gimple_asm> (stmt); + for (i = 0; i < gimple_asm_ninputs (asm_stmt); i++) + { + t = &TREE_VALUE (gimple_asm_input_op (asm_stmt, i)); + modified |= ipa_modify_expr (t, true, adjustments); + } + for (i = 0; i < gimple_asm_noutputs (asm_stmt); i++) + { + t = &TREE_VALUE (gimple_asm_output_op (asm_stmt, i)); + modified |= ipa_modify_expr (t, false, adjustments); + } + } break; default: diff --git a/gcc/tree-ssa-coalesce.c b/gcc/tree-ssa-coalesce.c index e4e2201..f043096 100644 --- a/gcc/tree-ssa-coalesce.c +++ b/gcc/tree-ssa-coalesce.c @@ -1008,15 +1008,16 @@ create_outofssa_var_map (coalesce_list_p cl, bitmap used_in_copy) case GIMPLE_ASM: { + gimple_asm asm_stmt = as_a <gimple_asm> (stmt); unsigned long noutputs, i; unsigned long ninputs; tree *outputs, link; - noutputs = gimple_asm_noutputs (stmt); - ninputs = gimple_asm_ninputs (stmt); + noutputs = gimple_asm_noutputs (asm_stmt); + ninputs = gimple_asm_ninputs (asm_stmt); outputs = (tree *) alloca (noutputs * sizeof (tree)); for (i = 0; i < noutputs; ++i) { - link = gimple_asm_output_op (stmt, i); + link = gimple_asm_output_op (asm_stmt, i); outputs[i] = TREE_VALUE (link); } @@ -1027,7 +1028,7 @@ create_outofssa_var_map (coalesce_list_p cl, bitmap used_in_copy) char *end; unsigned long match; - link = gimple_asm_input_op (stmt, i); + link = gimple_asm_input_op (asm_stmt, i); constraint = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (link))); input = TREE_VALUE (link); diff --git a/gcc/tree-ssa-dce.c b/gcc/tree-ssa-dce.c index f95c0ea..8e8cd57 100644 --- a/gcc/tree-ssa-dce.c +++ b/gcc/tree-ssa-dce.c @@ -882,14 +882,14 @@ propagate_necessity (bool aggressive) mark_all_reaching_defs_necessary (stmt); } } - else if (gimple_code (stmt) == GIMPLE_ASM) + else if (gimple_asm asm_stmt = dyn_cast <gimple_asm> (stmt)) { unsigned i; mark_all_reaching_defs_necessary (stmt); /* Inputs may perform loads. */ - for (i = 0; i < gimple_asm_ninputs (stmt); ++i) + for (i = 0; i < gimple_asm_ninputs (asm_stmt); ++i) { - tree op = TREE_VALUE (gimple_asm_input_op (stmt, i)); + tree op = TREE_VALUE (gimple_asm_input_op (asm_stmt, i)); if (TREE_CODE (op) != SSA_NAME && !is_gimple_min_invariant (op) && TREE_CODE (op) != CONSTRUCTOR diff --git a/gcc/tree-ssa-operands.c b/gcc/tree-ssa-operands.c index 1e59b76..5f20c66 100644 --- a/gcc/tree-ssa-operands.c +++ b/gcc/tree-ssa-operands.c @@ -655,7 +655,7 @@ maybe_add_call_vops (struct function *fn, gimple_call stmt) /* Scan operands in the ASM_EXPR stmt referred to in INFO. */ static void -get_asm_stmt_operands (struct function *fn, gimple stmt) +get_asm_stmt_operands (struct function *fn, gimple_asm stmt) { size_t i, noutputs; const char **oconstraints; @@ -909,7 +909,7 @@ parse_ssa_operands (struct function *fn, gimple stmt) switch (code) { case GIMPLE_ASM: - get_asm_stmt_operands (fn, stmt); + get_asm_stmt_operands (fn, as_a <gimple_asm> (stmt)); break; case GIMPLE_TRANSACTION: diff --git a/gcc/tree-ssa-structalias.c b/gcc/tree-ssa-structalias.c index 4bde124..a130268 100644 --- a/gcc/tree-ssa-structalias.c +++ b/gcc/tree-ssa-structalias.c @@ -4752,19 +4752,19 @@ find_func_aliases (struct function *fn, gimple origt) } } /* Handle asms conservatively by adding escape constraints to everything. */ - else if (gimple_code (t) == GIMPLE_ASM) + else if (gimple_asm asm_stmt = dyn_cast <gimple_asm> (t)) { unsigned i, noutputs; const char **oconstraints; const char *constraint; bool allows_mem, allows_reg, is_inout; - noutputs = gimple_asm_noutputs (t); + noutputs = gimple_asm_noutputs (asm_stmt); oconstraints = XALLOCAVEC (const char *, noutputs); for (i = 0; i < noutputs; ++i) { - tree link = gimple_asm_output_op (t, i); + tree link = gimple_asm_output_op (asm_stmt, i); tree op = TREE_VALUE (link); constraint = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (link))); @@ -4791,9 +4791,9 @@ find_func_aliases (struct function *fn, gimple origt) process_constraint (new_constraint (*lhsp, rhsc)); } } - for (i = 0; i < gimple_asm_ninputs (t); ++i) + for (i = 0; i < gimple_asm_ninputs (asm_stmt); ++i) { - tree link = gimple_asm_input_op (t, i); + tree link = gimple_asm_input_op (asm_stmt, i); tree op = TREE_VALUE (link); constraint = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (link))); diff --git a/gcc/tree-ssa-threadedge.c b/gcc/tree-ssa-threadedge.c index 45083df..50cc729 100644 --- a/gcc/tree-ssa-threadedge.c +++ b/gcc/tree-ssa-threadedge.c @@ -345,7 +345,8 @@ record_temporary_equivalences_from_stmts_at_dest (edge e, /* If the statement has volatile operands, then we assume we can not thread through this block. This is overly conservative in some ways. */ - if (gimple_code (stmt) == GIMPLE_ASM && gimple_asm_volatile_p (stmt)) + if (gimple_code (stmt) == GIMPLE_ASM + && gimple_asm_volatile_p (as_a <gimple_asm> (stmt))) return NULL; /* If duplicating this block is going to cause too much code diff --git a/gcc/tree-ssa.c b/gcc/tree-ssa.c index a907426..6babaee 100644 --- a/gcc/tree-ssa.c +++ b/gcc/tree-ssa.c @@ -1454,9 +1454,10 @@ execute_update_addresses_taken (void) else if (code == GIMPLE_ASM) { - for (i = 0; i < gimple_asm_noutputs (stmt); ++i) + gimple_asm asm_stmt = as_a <gimple_asm> (stmt); + for (i = 0; i < gimple_asm_noutputs (asm_stmt); ++i) { - tree link = gimple_asm_output_op (stmt, i); + tree link = gimple_asm_output_op (asm_stmt, i); tree lhs = TREE_VALUE (link); if (TREE_CODE (lhs) != SSA_NAME) { @@ -1471,9 +1472,9 @@ execute_update_addresses_taken (void) bitmap_set_bit (not_reg_needs, DECL_UID (decl)); } } - for (i = 0; i < gimple_asm_ninputs (stmt); ++i) + for (i = 0; i < gimple_asm_ninputs (asm_stmt); ++i) { - tree link = gimple_asm_input_op (stmt, i); + tree link = gimple_asm_input_op (asm_stmt, i); if ((decl = non_rewritable_mem_ref_base (TREE_VALUE (link)))) bitmap_set_bit (not_reg_needs, DECL_UID (decl)); } @@ -1584,16 +1585,17 @@ execute_update_addresses_taken (void) else if (gimple_code (stmt) == GIMPLE_ASM) { + gimple_asm asm_stmt = as_a <gimple_asm> (stmt); unsigned i; - for (i = 0; i < gimple_asm_noutputs (stmt); ++i) + for (i = 0; i < gimple_asm_noutputs (asm_stmt); ++i) { - tree link = gimple_asm_output_op (stmt, i); + tree link = gimple_asm_output_op (asm_stmt, i); maybe_rewrite_mem_ref_base (&TREE_VALUE (link), suitable_for_renaming); } - for (i = 0; i < gimple_asm_ninputs (stmt); ++i) + for (i = 0; i < gimple_asm_ninputs (asm_stmt); ++i) { - tree link = gimple_asm_input_op (stmt, i); + tree link = gimple_asm_input_op (asm_stmt, i); maybe_rewrite_mem_ref_base (&TREE_VALUE (link), suitable_for_renaming); } -- 1.8.5.3
