+2014-04-23 David Malcolm <dmalcolm@redhat.com>
+
+ * is-a.h: Update comments to reflect the following changes to the
+ "pointerness" of the API, making the template parameter match the
+ return type, allowing use of is-a.h with typedefs of pointers.
+ (is_a_helper::cast): Return a T rather then a pointer to a T, so
+ that the return type matches the parameter to the is_a_helper.
+ (as_a): Likewise.
+ (dyn_cast): Likewise.
+
+ * cgraph.c (cgraph_node_for_asm): Update for removal of implicit
+ pointer from the is-a.h API.
+
+ * cgraph.h (is_a_helper <cgraph_node>::test): Convert to...
+ (is_a_helper <cgraph_node *>::test): ...this, matching change to
+ is-a.h API.
+ (is_a_helper <varpool_node>::test): Likewise, convert to...
+ (is_a_helper <varpool_node *>::test): ...this.
+
+ (varpool_first_variable): Update for removal of implicit pointer
+ from the is-a.h API.
+ (varpool_next_variable): Likewise.
+ (varpool_first_static_initializer): Likewise.
+ (varpool_next_static_initializer): Likewise.
+ (varpool_first_defined_variable): Likewise.
+ (varpool_next_defined_variable): Likewise.
+ (cgraph_first_defined_function): Likewise.
+ (cgraph_next_defined_function): Likewise.
+ (cgraph_first_function): Likewise.
+ (cgraph_next_function): Likewise.
+ (cgraph_first_function_with_gimple_body): Likewise.
+ (cgraph_next_function_with_gimple_body): Likewise.
+ (cgraph_alias_target): Likewise.
+ (varpool_alias_target): Likewise.
+ (cgraph_function_or_thunk_node): Likewise.
+ (varpool_variable_node): Likewise.
+ (symtab_real_symbol_p): Likewise.
+ * cgraphunit.c (referred_to_p): Likewise.
+ (analyze_functions): Likewise.
+ (handle_alias_pairs): Likewise.
+ * gimple-fold.c (can_refer_decl_in_current_unit_p): Likewise.
+ * gimple-ssa.h (gimple_vuse_op): Likewise.
+ (gimple_vdef_op): Likewise.
+ * gimple-streamer-in.c (input_gimple_stmt): Likewise.
+ * gimple.c (gimple_build_asm_1): Likewise.
+ (gimple_build_try): Likewise.
+ (gimple_build_resx): Likewise.
+ (gimple_build_eh_dispatch): Likewise.
+ (gimple_build_omp_for): Likewise.
+ (gimple_omp_for_set_clauses): Likewise.
+
+ * gimple.h (is_a_helper <gimple_statement_asm>::test): Convert to...
+ (is_a_helper <gimple_statement_asm *>::test): ...this.
+ (is_a_helper <gimple_statement_bind>::test): Convert to...
+ (is_a_helper <gimple_statement_bind *>::test): ...this.
+ (is_a_helper <gimple_statement_call>::test): Convert to...
+ (is_a_helper <gimple_statement_call *>::test): ...this.
+ (is_a_helper <gimple_statement_catch>::test): Convert to...
+ (is_a_helper <gimple_statement_catch *>::test): ...this.
+ (is_a_helper <gimple_statement_resx>::test): Convert to...
+ (is_a_helper <gimple_statement_resx *>::test): ...this.
+ (is_a_helper <gimple_statement_eh_dispatch>::test): Convert to...
+ (is_a_helper <gimple_statement_eh_dispatch *>::test): ...this.
+ (is_a_helper <gimple_statement_eh_else>::test): Convert to...
+ (is_a_helper <gimple_statement_eh_else *>::test): ...this.
+ (is_a_helper <gimple_statement_eh_filter>::test): Convert to...
+ (is_a_helper <gimple_statement_eh_filter *>::test): ...this.
+ (is_a_helper <gimple_statement_eh_mnt>::test): Convert to...
+ (is_a_helper <gimple_statement_eh_mnt *>::test): ...this.
+ (is_a_helper <gimple_statement_omp_atomic_load>::test): Convert to...
+ (is_a_helper <gimple_statement_omp_atomic_load *>::test): ...this.
+ (is_a_helper <gimple_statement_omp_atomic_store>::test): Convert to...
+ (is_a_helper <gimple_statement_omp_atomic_store *>::test): ...this.
+ (is_a_helper <gimple_statement_omp_return>::test): Convert to...
+ (is_a_helper <gimple_statement_omp_return *>::test): ...this.
+ (is_a_helper <gimple_statement_omp_continue>::test): Convert to...
+ (is_a_helper <gimple_statement_omp_continue *>::test): ...this.
+ (is_a_helper <gimple_statement_omp_critical>::test): Convert to...
+ (is_a_helper <gimple_statement_omp_critical *>::test): ...this.
+ (is_a_helper <gimple_statement_omp_for>::test): Convert to...
+ (is_a_helper <gimple_statement_omp_for *>::test): ...this.
+ (is_a_helper <gimple_statement_omp_taskreg>::test): Convert to...
+ (is_a_helper <gimple_statement_omp_taskreg *>::test): ...this.
+ (is_a_helper <gimple_statement_omp_parallel>::test): Convert to...
+ (is_a_helper <gimple_statement_omp_parallel *>::test): ...this.
+ (is_a_helper <gimple_statement_omp_target>::test): Convert to...
+ (is_a_helper <gimple_statement_omp_target *>::test): ...this.
+ (is_a_helper <gimple_statement_omp_sections>::test): Convert to...
+ (is_a_helper <gimple_statement_omp_sections *>::test): ...this.
+ (is_a_helper <gimple_statement_omp_single>::test): Convert to...
+ (is_a_helper <gimple_statement_omp_single *>::test): ...this.
+ (is_a_helper <gimple_statement_omp_teams>::test): Convert to...
+ (is_a_helper <gimple_statement_omp_teams *>::test): ...this.
+ (is_a_helper <gimple_statement_omp_task>::test): Convert to...
+ (is_a_helper <gimple_statement_omp_task *>::test): ...this.
+ (is_a_helper <gimple_statement_phi>::test): Convert to...
+ (is_a_helper <gimple_statement_phi *>::test): ...this.
+ (is_a_helper <gimple_statement_transaction>::test): Convert to...
+ (is_a_helper <gimple_statement_transaction *>::test): ...this.
+ (is_a_helper <gimple_statement_try>::test): Convert to...
+ (is_a_helper <gimple_statement_try *>::test): ...this.
+ (is_a_helper <gimple_statement_wce>::test): Convert to...
+ (is_a_helper <gimple_statement_wce *>::test): ...this.
+ (is_a_helper <const gimple_statement_asm>::test): Convert to...
+ (is_a_helper <const gimple_statement_asm *>::test): ...this.
+ (is_a_helper <const gimple_statement_bind>::test): Convert to...
+ (is_a_helper <const gimple_statement_bind *>::test): ...this.
+ (is_a_helper <const gimple_statement_call>::test): Convert to...
+ (is_a_helper <const gimple_statement_call *>::test): ...this.
+ (is_a_helper <const gimple_statement_catch>::test): Convert to...
+ (is_a_helper <const gimple_statement_catch *>::test): ...this.
+ (is_a_helper <const gimple_statement_resx>::test): Convert to...
+ (is_a_helper <const gimple_statement_resx *>::test): ...this.
+ (is_a_helper <const gimple_statement_eh_dispatch>::test):
+ Convert to...
+ (is_a_helper <const gimple_statement_eh_dispatch *>::test):
+ ...this.
+ (is_a_helper <const gimple_statement_eh_filter>::test): Convert
+ to...
+ (is_a_helper <const gimple_statement_eh_filter *>::test): ...this.
+ (is_a_helper <const gimple_statement_omp_atomic_load>::test):
+ Convert to...
+ (is_a_helper <const gimple_statement_omp_atomic_load *>::test):
+ ...this.
+ (is_a_helper <const gimple_statement_omp_atomic_store>::test):
+ Convert to...
+ (is_a_helper <const gimple_statement_omp_atomic_store *>::test):
+ ...this.
+ (is_a_helper <const gimple_statement_omp_return>::test): Convert
+ to...
+ (is_a_helper <const gimple_statement_omp_return *>::test): ...this.
+ (is_a_helper <const gimple_statement_omp_continue>::test): Convert
+ to...
+ (is_a_helper <const gimple_statement_omp_continue *>::test): ...this.
+ (is_a_helper <const gimple_statement_omp_critical>::test): Convert
+ to...
+ (is_a_helper <const gimple_statement_omp_critical *>::test): ...this.
+ (is_a_helper <const gimple_statement_omp_for>::test): Convert to...
+ (is_a_helper <const gimple_statement_omp_for *>::test): ...this.
+ (is_a_helper <const gimple_statement_omp_taskreg>::test): Convert
+ to...
+ (is_a_helper <const gimple_statement_omp_taskreg *>::test): ...this.
+ (is_a_helper <const gimple_statement_omp_parallel>::test): Convert
+ to...
+ (is_a_helper <const gimple_statement_omp_parallel *>::test): ...this.
+ (is_a_helper <const gimple_statement_omp_target>::test): Convert
+ to...
+ (is_a_helper <const gimple_statement_omp_target *>::test): ...this.
+ (is_a_helper <const gimple_statement_omp_sections>::test): Convert
+ to...
+ (is_a_helper <const gimple_statement_omp_sections *>::test): ...this.
+ (is_a_helper <const gimple_statement_omp_single>::test): Convert
+ to...
+ (is_a_helper <const gimple_statement_omp_single *>::test): ...this.
+ (is_a_helper <const gimple_statement_omp_teams>::test): Convert
+ to...
+ (is_a_helper <const gimple_statement_omp_teams *>::test): ...this.
+ (is_a_helper <const gimple_statement_omp_task>::test): Convert
+ to...
+ (is_a_helper <const gimple_statement_omp_task *>::test): ...this.
+ (is_a_helper <const gimple_statement_phi>::test): Convert to...
+ (is_a_helper <const gimple_statement_phi *>::test): ...this.
+ (is_a_helper <const gimple_statement_transaction>::test): Convert
+ to...
+ (is_a_helper <const gimple_statement_transaction *>::test): ...this.
+ (is_a_helper <const gimple_statement_with_ops>::test): Convert
+ to...
+ (is_a_helper <const gimple_statement_with_ops *>::test): ...this.
+ (is_a_helper <gimple_statement_with_ops>::test): Convert to...
+ (is_a_helper <gimple_statement_with_ops *>::test): ...this.
+ (is_a_helper <const gimple_statement_with_memory_ops>::test):
+ Convert to...
+ (is_a_helper <const gimple_statement_with_memory_ops *>::test):
+ ...this.
+ (is_a_helper <gimple_statement_with_memory_ops>::test): Convert
+ to...
+ (is_a_helper <gimple_statement_with_memory_ops *>::test): ...this.
+
+ (gimple_use_ops): Update for removal of implicit pointer from the
+ is-a.h API.
+ (gimple_set_use_ops): Likewise.
+ (gimple_vuse): Likewise.
+ (gimple_vdef): Likewise.
+ (gimple_vuse_ptr): Likewise.
+ (gimple_vdef_ptr): Likewise.
+ (gimple_set_vuse): Likewise.
+ (gimple_set_vdef): Likewise.
+ (gimple_omp_return_set_lhs): Likewise.
+ (gimple_omp_return_lhs): Likewise.
+ (gimple_omp_return_lhs_ptr): Likewise.
+ (gimple_call_fntype): Likewise.
+ (gimple_call_set_fntype): Likewise.
+ (gimple_call_set_internal_fn): Likewise.
+ (gimple_call_use_set): Likewise.
+ (gimple_call_clobber_set): Likewise.
+ (gimple_bind_vars): Likewise.
+ (gimple_bind_set_vars): Likewise.
+ (gimple_bind_body_ptr): Likewise.
+ (gimple_bind_set_body): Likewise.
+ (gimple_bind_add_stmt): Likewise.
+ (gimple_bind_block): Likewise.
+ (gimple_bind_set_block): Likewise.
+ (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_set_output_op): Likewise.
+ (gimple_asm_clobber_op): Likewise.
+ (gimple_asm_set_clobber_op): Likewise.
+ (gimple_asm_label_op): Likewise.
+ (gimple_asm_set_label_op): Likewise.
+ (gimple_asm_string): Likewise.
+ (gimple_catch_types): Likewise.
+ (gimple_catch_types_ptr): Likewise.
+ (gimple_catch_handler_ptr): Likewise.
+ (gimple_catch_set_types): Likewise.
+ (gimple_catch_set_handler): Likewise.
+ (gimple_eh_filter_types): Likewise.
+ (gimple_eh_filter_types_ptr): Likewise.
+ (gimple_eh_filter_failure_ptr): Likewise.
+ (gimple_eh_filter_set_types): Likewise.
+ (gimple_eh_filter_set_failure): Likewise.
+ (gimple_eh_must_not_throw_fndecl): Likewise.
+ (gimple_eh_must_not_throw_set_fndecl): Likewise.
+ (gimple_eh_else_n_body_ptr): Likewise.
+ (gimple_eh_else_e_body_ptr): Likewise.
+ (gimple_eh_else_set_n_body): Likewise.
+ (gimple_eh_else_set_e_body): Likewise.
+ (gimple_try_eval_ptr): Likewise.
+ (gimple_try_cleanup_ptr): Likewise.
+ (gimple_try_set_eval): Likewise.
+ (gimple_try_set_cleanup): Likewise.
+ (gimple_wce_cleanup_ptr): Likewise.
+ (gimple_wce_set_cleanup): Likewise.
+ (gimple_phi_capacity): Likewise.
+ (gimple_phi_num_args): Likewise.
+ (gimple_phi_result): Likewise.
+ (gimple_phi_result_ptr): Likewise.
+ (gimple_phi_set_result): Likewise.
+ (gimple_phi_arg): Likewise.
+ (gimple_phi_set_arg): Likewise.
+ (gimple_resx_region): Likewise.
+ (gimple_resx_set_region): Likewise.
+ (gimple_eh_dispatch_region): Likewise.
+ (gimple_eh_dispatch_set_region): Likewise.
+ (gimple_omp_critical_name): Likewise.
+ (gimple_omp_critical_name_ptr): Likewise.
+ (gimple_omp_critical_set_name): Likewise.
+ (gimple_omp_for_clauses): Likewise.
+ (gimple_omp_for_clauses_ptr): Likewise.
+ (gimple_omp_for_set_clauses): Likewise.
+ (gimple_omp_for_collapse): Likewise.
+ (gimple_omp_for_index): Likewise.
+ (gimple_omp_for_index_ptr): Likewise.
+ (gimple_omp_for_set_index): Likewise.
+ (gimple_omp_for_initial): Likewise.
+ (gimple_omp_for_initial_ptr): Likewise.
+ (gimple_omp_for_set_initial): Likewise.
+ (gimple_omp_for_final): Likewise.
+ (gimple_omp_for_final_ptr): Likewise.
+ (gimple_omp_for_set_final): Likewise.
+ (gimple_omp_for_incr): Likewise.
+ (gimple_omp_for_incr_ptr): Likewise.
+ (gimple_omp_for_set_incr): Likewise.
+ (gimple_omp_for_pre_body_ptr): Likewise.
+ (gimple_omp_for_set_pre_body): Likewise.
+ (gimple_omp_parallel_clauses): Likewise.
+ (gimple_omp_parallel_clauses_ptr): Likewise.
+ (gimple_omp_parallel_set_clauses): Likewise.
+ (gimple_omp_parallel_child_fn): Likewise.
+ (gimple_omp_parallel_child_fn_ptr): Likewise.
+ (gimple_omp_parallel_set_child_fn): Likewise.
+ (gimple_omp_parallel_data_arg): Likewise.
+ (gimple_omp_parallel_data_arg_ptr): Likewise.
+ (gimple_omp_parallel_set_data_arg): Likewise.
+ (gimple_omp_task_clauses): Likewise.
+ (gimple_omp_task_clauses_ptr): Likewise.
+ (gimple_omp_task_set_clauses): Likewise.
+ (gimple_omp_task_child_fn): Likewise.
+ (gimple_omp_task_child_fn_ptr): Likewise.
+ (gimple_omp_task_set_child_fn): Likewise.
+ (gimple_omp_task_data_arg): Likewise.
+ (gimple_omp_task_data_arg_ptr): Likewise.
+ (gimple_omp_task_set_data_arg): Likewise.
+ (gimple_omp_taskreg_clauses): Likewise.
+ (gimple_omp_taskreg_clauses_ptr): Likewise.
+ (gimple_omp_taskreg_set_clauses): Likewise.
+ (gimple_omp_taskreg_child_fn): Likewise.
+ (gimple_omp_taskreg_child_fn_ptr): Likewise.
+ (gimple_omp_taskreg_set_child_fn): Likewise.
+ (gimple_omp_taskreg_data_arg): Likewise.
+ (gimple_omp_taskreg_data_arg_ptr): Likewise.
+ (gimple_omp_taskreg_set_data_arg): Likewise.
+ (gimple_omp_task_copy_fn): Likewise.
+ (gimple_omp_task_copy_fn_ptr): Likewise.
+ (gimple_omp_task_set_copy_fn): Likewise.
+ (gimple_omp_task_arg_size): Likewise.
+ (gimple_omp_task_arg_size_ptr): Likewise.
+ (gimple_omp_task_set_arg_size): Likewise.
+ (gimple_omp_task_arg_align): Likewise.
+ (gimple_omp_task_arg_align_ptr): Likewise.
+ (gimple_omp_task_set_arg_align): Likewise.
+ (gimple_omp_single_clauses): Likewise.
+ (gimple_omp_single_clauses_ptr): Likewise.
+ (gimple_omp_single_set_clauses): Likewise.
+ (gimple_omp_target_clauses): Likewise.
+ (gimple_omp_target_clauses_ptr): Likewise.
+ (gimple_omp_target_set_clauses): Likewise.
+ (gimple_omp_target_child_fn): Likewise.
+ (gimple_omp_target_child_fn_ptr): Likewise.
+ (gimple_omp_target_set_child_fn): Likewise.
+ (gimple_omp_target_data_arg): Likewise.
+ (gimple_omp_target_data_arg_ptr): Likewise.
+ (gimple_omp_target_set_data_arg): Likewise.
+ (gimple_omp_teams_clauses): Likewise.
+ (gimple_omp_teams_clauses_ptr): Likewise.
+ (gimple_omp_teams_set_clauses): Likewise.
+ (gimple_omp_sections_clauses): Likewise.
+ (gimple_omp_sections_clauses_ptr): Likewise.
+ (gimple_omp_sections_set_clauses): Likewise.
+ (gimple_omp_sections_control): Likewise.
+ (gimple_omp_sections_control_ptr): Likewise.
+ (gimple_omp_sections_set_control): Likewise.
+ (gimple_omp_for_set_cond): Likewise.
+ (gimple_omp_for_cond): Likewise.
+ (gimple_omp_atomic_store_set_val): Likewise.
+ (gimple_omp_atomic_store_val): Likewise.
+ (gimple_omp_atomic_store_val_ptr): Likewise.
+ (gimple_omp_atomic_load_set_lhs): Likewise.
+ (gimple_omp_atomic_load_lhs): Likewise.
+ (gimple_omp_atomic_load_lhs_ptr): Likewise.
+ (gimple_omp_atomic_load_set_rhs): Likewise.
+ (gimple_omp_atomic_load_rhs): Likewise.
+ (gimple_omp_atomic_load_rhs_ptr): Likewise.
+ (gimple_omp_continue_control_def): Likewise.
+ (gimple_omp_continue_control_def_ptr): Likewise.
+ (gimple_omp_continue_set_control_def): Likewise.
+ (gimple_omp_continue_control_use): Likewise.
+ (gimple_omp_continue_control_use_ptr): Likewise.
+ (gimple_omp_continue_set_control_use): Likewise.
+ (gimple_transaction_body_ptr): Likewise.
+ (gimple_transaction_label): Likewise.
+ (gimple_transaction_label_ptr): Likewise.
+ (gimple_transaction_set_body): Likewise.
+ (gimple_transaction_set_label): Likewise.
+
+ * ipa-devirt.c (build_type_inheritance_graph): Likewise.
+ * ipa-inline-analysis.c (inline_write_summary): Likewise.
+ * ipa-ref.c (ipa_record_reference): Likewise.
+ * ipa-reference.c (analyze_function): Likewise.
+ (ipa_reference_write_optimization_summary): Likewise.
+ * ipa.c (symtab_remove_unreachable_nodes): Likewise.
+ (address_taken_from_non_vtable_p): Likewise.
+ (comdat_can_be_unshared_p_1): Likewise.
+ * lto-cgraph.c (lto_output_ref): Likewise.
+ (add_references): Likewise.
+ (compute_ltrans_boundary): Likewise.
+ (output_symtab): Likewise.
+ (input_ref): Likewise.
+ (input_cgraph_1): Likewise.
+ (output_cgraph_opt_summary): Likewise.
+ * lto-streamer-out.c (lto_output): Likewise.
+ (output_symbol_p): Likewise.
+ * lto-streamer.h (lsei_next_function_in_partition): Likewise.
+ (lsei_start_function_in_partition): Likewise.
+ (lsei_next_variable_in_partition): Likewise.
+ (lsei_start_variable_in_partition): Likewise.
+ * symtab.c (insert_to_assembler_name_hash): Likewise.
+ (unlink_from_assembler_name_hash): Likewise.
+ (symtab_unregister_node): Likewise.
+ (symtab_remove_node): Likewise.
+ (dump_symtab_node): Likewise.
+ (verify_symtab_base): Likewise.
+ (verify_symtab_node): Likewise.
+ (symtab_make_decl_local): Likewise.
+ (symtab_alias_ultimate_target): Likewise.
+ (symtab_resolve_alias): Likewise.
+ (symtab_get_symbol_partitioning_class): Likewise.
+ * tree-phinodes.c (allocate_phi_node): Likewise.
+ (reserve_phi_args_for_new_edge): Likewise.
+ (remove_phi_args): Likewise.
+ * varpool.c (varpool_node_for_asm): Likewise.
+ (varpool_remove_unreferenced_decls): Likewise.
+
2014-04-23 Jeff Law <law@redhat.com>
PR tree-optimization/60902
template <>
template <>
inline bool
-is_a_helper <gimple_statement_asm>::test (gimple gs)
+is_a_helper <gimple_statement_asm *>::test (gimple gs)
{
return gs->code == GIMPLE_ASM;
}
template <>
template <>
inline bool
-is_a_helper <gimple_statement_bind>::test (gimple gs)
+is_a_helper <gimple_statement_bind *>::test (gimple gs)
{
return gs->code == GIMPLE_BIND;
}
template <>
template <>
inline bool
-is_a_helper <gimple_statement_call>::test (gimple gs)
+is_a_helper <gimple_statement_call *>::test (gimple gs)
{
return gs->code == GIMPLE_CALL;
}
template <>
template <>
inline bool
-is_a_helper <gimple_statement_catch>::test (gimple gs)
+is_a_helper <gimple_statement_catch *>::test (gimple gs)
{
return gs->code == GIMPLE_CATCH;
}
template <>
template <>
inline bool
-is_a_helper <gimple_statement_resx>::test (gimple gs)
+is_a_helper <gimple_statement_resx *>::test (gimple gs)
{
return gs->code == GIMPLE_RESX;
}
template <>
template <>
inline bool
-is_a_helper <gimple_statement_eh_dispatch>::test (gimple gs)
+is_a_helper <gimple_statement_eh_dispatch *>::test (gimple gs)
{
return gs->code == GIMPLE_EH_DISPATCH;
}
template <>
template <>
inline bool
-is_a_helper <gimple_statement_eh_else>::test (gimple gs)
+is_a_helper <gimple_statement_eh_else *>::test (gimple gs)
{
return gs->code == GIMPLE_EH_ELSE;
}
template <>
template <>
inline bool
-is_a_helper <gimple_statement_eh_filter>::test (gimple gs)
+is_a_helper <gimple_statement_eh_filter *>::test (gimple gs)
{
return gs->code == GIMPLE_EH_FILTER;
}
template <>
template <>
inline bool
-is_a_helper <gimple_statement_eh_mnt>::test (gimple gs)
+is_a_helper <gimple_statement_eh_mnt *>::test (gimple gs)
{
return gs->code == GIMPLE_EH_MUST_NOT_THROW;
}
template <>
template <>
inline bool
-is_a_helper <gimple_statement_omp_atomic_load>::test (gimple gs)
+is_a_helper <gimple_statement_omp_atomic_load *>::test (gimple gs)
{
return gs->code == GIMPLE_OMP_ATOMIC_LOAD;
}
template <>
template <>
inline bool
-is_a_helper <gimple_statement_omp_atomic_store>::test (gimple gs)
+is_a_helper <gimple_statement_omp_atomic_store *>::test (gimple gs)
{
return gs->code == GIMPLE_OMP_ATOMIC_STORE;
}
template <>
template <>
inline bool
-is_a_helper <gimple_statement_omp_return>::test (gimple gs)
+is_a_helper <gimple_statement_omp_return *>::test (gimple gs)
{
return gs->code == GIMPLE_OMP_RETURN;
}
template <>
template <>
inline bool
-is_a_helper <gimple_statement_omp_continue>::test (gimple gs)
+is_a_helper <gimple_statement_omp_continue *>::test (gimple gs)
{
return gs->code == GIMPLE_OMP_CONTINUE;
}
template <>
template <>
inline bool
-is_a_helper <gimple_statement_omp_critical>::test (gimple gs)
+is_a_helper <gimple_statement_omp_critical *>::test (gimple gs)
{
return gs->code == GIMPLE_OMP_CRITICAL;
}
template <>
template <>
inline bool
-is_a_helper <gimple_statement_omp_for>::test (gimple gs)
+is_a_helper <gimple_statement_omp_for *>::test (gimple gs)
{
return gs->code == GIMPLE_OMP_FOR;
}
template <>
template <>
inline bool
-is_a_helper <gimple_statement_omp_taskreg>::test (gimple gs)
+is_a_helper <gimple_statement_omp_taskreg *>::test (gimple gs)
{
return gs->code == GIMPLE_OMP_PARALLEL || gs->code == GIMPLE_OMP_TASK;
}
template <>
template <>
inline bool
-is_a_helper <gimple_statement_omp_parallel>::test (gimple gs)
+is_a_helper <gimple_statement_omp_parallel *>::test (gimple gs)
{
return gs->code == GIMPLE_OMP_PARALLEL;
}
template <>
template <>
inline bool
-is_a_helper <gimple_statement_omp_target>::test (gimple gs)
+is_a_helper <gimple_statement_omp_target *>::test (gimple gs)
{
return gs->code == GIMPLE_OMP_TARGET;
}
template <>
template <>
inline bool
-is_a_helper <gimple_statement_omp_sections>::test (gimple gs)
+is_a_helper <gimple_statement_omp_sections *>::test (gimple gs)
{
return gs->code == GIMPLE_OMP_SECTIONS;
}
template <>
template <>
inline bool
-is_a_helper <gimple_statement_omp_single>::test (gimple gs)
+is_a_helper <gimple_statement_omp_single *>::test (gimple gs)
{
return gs->code == GIMPLE_OMP_SINGLE;
}
template <>
template <>
inline bool
-is_a_helper <gimple_statement_omp_teams>::test (gimple gs)
+is_a_helper <gimple_statement_omp_teams *>::test (gimple gs)
{
return gs->code == GIMPLE_OMP_TEAMS;
}
template <>
template <>
inline bool
-is_a_helper <gimple_statement_omp_task>::test (gimple gs)
+is_a_helper <gimple_statement_omp_task *>::test (gimple gs)
{
return gs->code == GIMPLE_OMP_TASK;
}
template <>
template <>
inline bool
-is_a_helper <gimple_statement_phi>::test (gimple gs)
+is_a_helper <gimple_statement_phi *>::test (gimple gs)
{
return gs->code == GIMPLE_PHI;
}
template <>
template <>
inline bool
-is_a_helper <gimple_statement_transaction>::test (gimple gs)
+is_a_helper <gimple_statement_transaction *>::test (gimple gs)
{
return gs->code == GIMPLE_TRANSACTION;
}
template <>
template <>
inline bool
-is_a_helper <gimple_statement_try>::test (gimple gs)
+is_a_helper <gimple_statement_try *>::test (gimple gs)
{
return gs->code == GIMPLE_TRY;
}
template <>
template <>
inline bool
-is_a_helper <gimple_statement_wce>::test (gimple gs)
+is_a_helper <gimple_statement_wce *>::test (gimple gs)
{
return gs->code == GIMPLE_WITH_CLEANUP_EXPR;
}
template <>
template <>
inline bool
-is_a_helper <const gimple_statement_asm>::test (const_gimple gs)
+is_a_helper <const gimple_statement_asm *>::test (const_gimple gs)
{
return gs->code == GIMPLE_ASM;
}
template <>
template <>
inline bool
-is_a_helper <const gimple_statement_bind>::test (const_gimple gs)
+is_a_helper <const gimple_statement_bind *>::test (const_gimple gs)
{
return gs->code == GIMPLE_BIND;
}
template <>
template <>
inline bool
-is_a_helper <const gimple_statement_call>::test (const_gimple gs)
+is_a_helper <const gimple_statement_call *>::test (const_gimple gs)
{
return gs->code == GIMPLE_CALL;
}
template <>
template <>
inline bool
-is_a_helper <const gimple_statement_catch>::test (const_gimple gs)
+is_a_helper <const gimple_statement_catch *>::test (const_gimple gs)
{
return gs->code == GIMPLE_CATCH;
}
template <>
template <>
inline bool
-is_a_helper <const gimple_statement_resx>::test (const_gimple gs)
+is_a_helper <const gimple_statement_resx *>::test (const_gimple gs)
{
return gs->code == GIMPLE_RESX;
}
template <>
template <>
inline bool
-is_a_helper <const gimple_statement_eh_dispatch>::test (const_gimple gs)
+is_a_helper <const gimple_statement_eh_dispatch *>::test (const_gimple gs)
{
return gs->code == GIMPLE_EH_DISPATCH;
}
template <>
template <>
inline bool
-is_a_helper <const gimple_statement_eh_filter>::test (const_gimple gs)
+is_a_helper <const gimple_statement_eh_filter *>::test (const_gimple gs)
{
return gs->code == GIMPLE_EH_FILTER;
}
template <>
template <>
inline bool
-is_a_helper <const gimple_statement_omp_atomic_load>::test (const_gimple gs)
+is_a_helper <const gimple_statement_omp_atomic_load *>::test (const_gimple gs)
{
return gs->code == GIMPLE_OMP_ATOMIC_LOAD;
}
template <>
template <>
inline bool
-is_a_helper <const gimple_statement_omp_atomic_store>::test (const_gimple gs)
+is_a_helper <const gimple_statement_omp_atomic_store *>::test (const_gimple gs)
{
return gs->code == GIMPLE_OMP_ATOMIC_STORE;
}
template <>
template <>
inline bool
-is_a_helper <const gimple_statement_omp_return>::test (const_gimple gs)
+is_a_helper <const gimple_statement_omp_return *>::test (const_gimple gs)
{
return gs->code == GIMPLE_OMP_RETURN;
}
template <>
template <>
inline bool
-is_a_helper <const gimple_statement_omp_continue>::test (const_gimple gs)
+is_a_helper <const gimple_statement_omp_continue *>::test (const_gimple gs)
{
return gs->code == GIMPLE_OMP_CONTINUE;
}
template <>
template <>
inline bool
-is_a_helper <const gimple_statement_omp_critical>::test (const_gimple gs)
+is_a_helper <const gimple_statement_omp_critical *>::test (const_gimple gs)
{
return gs->code == GIMPLE_OMP_CRITICAL;
}
template <>
template <>
inline bool
-is_a_helper <const gimple_statement_omp_for>::test (const_gimple gs)
+is_a_helper <const gimple_statement_omp_for *>::test (const_gimple gs)
{
return gs->code == GIMPLE_OMP_FOR;
}
template <>
template <>
inline bool
-is_a_helper <const gimple_statement_omp_taskreg>::test (const_gimple gs)
+is_a_helper <const gimple_statement_omp_taskreg *>::test (const_gimple gs)
{
return gs->code == GIMPLE_OMP_PARALLEL || gs->code == GIMPLE_OMP_TASK;
}
template <>
template <>
inline bool
-is_a_helper <const gimple_statement_omp_parallel>::test (const_gimple gs)
+is_a_helper <const gimple_statement_omp_parallel *>::test (const_gimple gs)
{
return gs->code == GIMPLE_OMP_PARALLEL;
}
template <>
template <>
inline bool
-is_a_helper <const gimple_statement_omp_target>::test (const_gimple gs)
+is_a_helper <const gimple_statement_omp_target *>::test (const_gimple gs)
{
return gs->code == GIMPLE_OMP_TARGET;
}
template <>
template <>
inline bool
-is_a_helper <const gimple_statement_omp_sections>::test (const_gimple gs)
+is_a_helper <const gimple_statement_omp_sections *>::test (const_gimple gs)
{
return gs->code == GIMPLE_OMP_SECTIONS;
}
template <>
template <>
inline bool
-is_a_helper <const gimple_statement_omp_single>::test (const_gimple gs)
+is_a_helper <const gimple_statement_omp_single *>::test (const_gimple gs)
{
return gs->code == GIMPLE_OMP_SINGLE;
}
template <>
template <>
inline bool
-is_a_helper <const gimple_statement_omp_teams>::test (const_gimple gs)
+is_a_helper <const gimple_statement_omp_teams *>::test (const_gimple gs)
{
return gs->code == GIMPLE_OMP_TEAMS;
}
template <>
template <>
inline bool
-is_a_helper <const gimple_statement_omp_task>::test (const_gimple gs)
+is_a_helper <const gimple_statement_omp_task *>::test (const_gimple gs)
{
return gs->code == GIMPLE_OMP_TASK;
}
template <>
template <>
inline bool
-is_a_helper <const gimple_statement_phi>::test (const_gimple gs)
+is_a_helper <const gimple_statement_phi *>::test (const_gimple gs)
{
return gs->code == GIMPLE_PHI;
}
template <>
template <>
inline bool
-is_a_helper <const gimple_statement_transaction>::test (const_gimple gs)
+is_a_helper <const gimple_statement_transaction *>::test (const_gimple gs)
{
return gs->code == GIMPLE_TRANSACTION;
}
template <>
template <>
inline bool
-is_a_helper <const gimple_statement_with_ops>::test (const_gimple gs)
+is_a_helper <const gimple_statement_with_ops *>::test (const_gimple gs)
{
return gimple_has_ops (gs);
}
template <>
template <>
inline bool
-is_a_helper <gimple_statement_with_ops>::test (gimple gs)
+is_a_helper <gimple_statement_with_ops *>::test (gimple gs)
{
return gimple_has_ops (gs);
}
template <>
template <>
inline bool
-is_a_helper <const gimple_statement_with_memory_ops>::test (const_gimple gs)
+is_a_helper <const gimple_statement_with_memory_ops *>::test (const_gimple gs)
{
return gimple_has_mem_ops (gs);
}
template <>
template <>
inline bool
-is_a_helper <gimple_statement_with_memory_ops>::test (gimple gs)
+is_a_helper <gimple_statement_with_memory_ops *>::test (gimple gs)
{
return gimple_has_mem_ops (gs);
}
gimple_use_ops (const_gimple g)
{
const gimple_statement_with_ops *ops_stmt =
- dyn_cast <const gimple_statement_with_ops> (g);
+ dyn_cast <const gimple_statement_with_ops *> (g);
if (!ops_stmt)
return NULL;
return ops_stmt->use_ops;
gimple_set_use_ops (gimple g, struct use_optype_d *use)
{
gimple_statement_with_ops *ops_stmt =
- as_a <gimple_statement_with_ops> (g);
+ as_a <gimple_statement_with_ops *> (g);
ops_stmt->use_ops = use;
}
gimple_vuse (const_gimple g)
{
const gimple_statement_with_memory_ops *mem_ops_stmt =
- dyn_cast <const gimple_statement_with_memory_ops> (g);
+ dyn_cast <const gimple_statement_with_memory_ops *> (g);
if (!mem_ops_stmt)
return NULL_TREE;
return mem_ops_stmt->vuse;
gimple_vdef (const_gimple g)
{
const gimple_statement_with_memory_ops *mem_ops_stmt =
- dyn_cast <const gimple_statement_with_memory_ops> (g);
+ dyn_cast <const gimple_statement_with_memory_ops *> (g);
if (!mem_ops_stmt)
return NULL_TREE;
return mem_ops_stmt->vdef;
gimple_vuse_ptr (gimple g)
{
gimple_statement_with_memory_ops *mem_ops_stmt =
- dyn_cast <gimple_statement_with_memory_ops> (g);
+ dyn_cast <gimple_statement_with_memory_ops *> (g);
if (!mem_ops_stmt)
return NULL;
return &mem_ops_stmt->vuse;
gimple_vdef_ptr (gimple g)
{
gimple_statement_with_memory_ops *mem_ops_stmt =
- dyn_cast <gimple_statement_with_memory_ops> (g);
+ dyn_cast <gimple_statement_with_memory_ops *> (g);
if (!mem_ops_stmt)
return NULL;
return &mem_ops_stmt->vdef;
gimple_set_vuse (gimple g, tree vuse)
{
gimple_statement_with_memory_ops *mem_ops_stmt =
- as_a <gimple_statement_with_memory_ops> (g);
+ as_a <gimple_statement_with_memory_ops *> (g);
mem_ops_stmt->vuse = vuse;
}
gimple_set_vdef (gimple g, tree vdef)
{
gimple_statement_with_memory_ops *mem_ops_stmt =
- as_a <gimple_statement_with_memory_ops> (g);
+ as_a <gimple_statement_with_memory_ops *> (g);
mem_ops_stmt->vdef = vdef;
}
gimple_omp_return_set_lhs (gimple g, tree lhs)
{
gimple_statement_omp_return *omp_return_stmt =
- as_a <gimple_statement_omp_return> (g);
+ as_a <gimple_statement_omp_return *> (g);
omp_return_stmt->val = lhs;
}
gimple_omp_return_lhs (const_gimple g)
{
const gimple_statement_omp_return *omp_return_stmt =
- as_a <const gimple_statement_omp_return> (g);
+ as_a <const gimple_statement_omp_return *> (g);
return omp_return_stmt->val;
}
gimple_omp_return_lhs_ptr (gimple g)
{
gimple_statement_omp_return *omp_return_stmt =
- as_a <gimple_statement_omp_return> (g);
+ as_a <gimple_statement_omp_return *> (g);
return &omp_return_stmt->val;
}
gimple_call_fntype (const_gimple gs)
{
const gimple_statement_call *call_stmt =
- as_a <const gimple_statement_call> (gs);
+ as_a <const gimple_statement_call *> (gs);
if (gimple_call_internal_p (gs))
return NULL_TREE;
return call_stmt->u.fntype;
static inline void
gimple_call_set_fntype (gimple gs, tree fntype)
{
- gimple_statement_call *call_stmt = as_a <gimple_statement_call> (gs);
+ gimple_statement_call *call_stmt = as_a <gimple_statement_call *> (gs);
gcc_gimple_checking_assert (!gimple_call_internal_p (gs));
call_stmt->u.fntype = fntype;
}
static inline void
gimple_call_set_internal_fn (gimple gs, enum internal_fn fn)
{
- gimple_statement_call *call_stmt = as_a <gimple_statement_call> (gs);
+ gimple_statement_call *call_stmt = as_a <gimple_statement_call *> (gs);
gcc_gimple_checking_assert (gimple_call_internal_p (gs));
call_stmt->u.internal_fn = fn;
}
static inline struct pt_solution *
gimple_call_use_set (gimple call)
{
- gimple_statement_call *call_stmt = as_a <gimple_statement_call> (call);
+ gimple_statement_call *call_stmt = as_a <gimple_statement_call *> (call);
return &call_stmt->call_used;
}
static inline struct pt_solution *
gimple_call_clobber_set (gimple call)
{
- gimple_statement_call *call_stmt = as_a <gimple_statement_call> (call);
+ gimple_statement_call *call_stmt = as_a <gimple_statement_call *> (call);
return &call_stmt->call_clobbered;
}
gimple_bind_vars (const_gimple gs)
{
const gimple_statement_bind *bind_stmt =
- as_a <const gimple_statement_bind> (gs);
+ as_a <const gimple_statement_bind *> (gs);
return bind_stmt->vars;
}
static inline void
gimple_bind_set_vars (gimple gs, tree vars)
{
- gimple_statement_bind *bind_stmt = as_a <gimple_statement_bind> (gs);
+ gimple_statement_bind *bind_stmt = as_a <gimple_statement_bind *> (gs);
bind_stmt->vars = vars;
}
static inline void
gimple_bind_append_vars (gimple gs, tree vars)
{
- gimple_statement_bind *bind_stmt = as_a <gimple_statement_bind> (gs);
+ gimple_statement_bind *bind_stmt = as_a <gimple_statement_bind *> (gs);
bind_stmt->vars = chainon (bind_stmt->vars, vars);
}
static inline gimple_seq *
gimple_bind_body_ptr (gimple gs)
{
- gimple_statement_bind *bind_stmt = as_a <gimple_statement_bind> (gs);
+ gimple_statement_bind *bind_stmt = as_a <gimple_statement_bind *> (gs);
return &bind_stmt->body;
}
static inline void
gimple_bind_set_body (gimple gs, gimple_seq seq)
{
- gimple_statement_bind *bind_stmt = as_a <gimple_statement_bind> (gs);
+ gimple_statement_bind *bind_stmt = as_a <gimple_statement_bind *> (gs);
bind_stmt->body = seq;
}
static inline void
gimple_bind_add_stmt (gimple gs, gimple stmt)
{
- gimple_statement_bind *bind_stmt = as_a <gimple_statement_bind> (gs);
+ gimple_statement_bind *bind_stmt = as_a <gimple_statement_bind *> (gs);
gimple_seq_add_stmt (&bind_stmt->body, stmt);
}
static inline void
gimple_bind_add_seq (gimple gs, gimple_seq seq)
{
- gimple_statement_bind *bind_stmt = as_a <gimple_statement_bind> (gs);
+ gimple_statement_bind *bind_stmt = as_a <gimple_statement_bind *> (gs);
gimple_seq_add_seq (&bind_stmt->body, seq);
}
gimple_bind_block (const_gimple gs)
{
const gimple_statement_bind *bind_stmt =
- as_a <const gimple_statement_bind> (gs);
+ as_a <const gimple_statement_bind *> (gs);
return bind_stmt->block;
}
static inline void
gimple_bind_set_block (gimple gs, tree block)
{
- gimple_statement_bind *bind_stmt = as_a <gimple_statement_bind> (gs);
+ gimple_statement_bind *bind_stmt = as_a <gimple_statement_bind *> (gs);
gcc_gimple_checking_assert (block == NULL_TREE
|| TREE_CODE (block) == BLOCK);
bind_stmt->block = block;
gimple_asm_ninputs (const_gimple gs)
{
const gimple_statement_asm *asm_stmt =
- as_a <const gimple_statement_asm> (gs);
+ as_a <const gimple_statement_asm *> (gs);
return asm_stmt->ni;
}
gimple_asm_noutputs (const_gimple gs)
{
const gimple_statement_asm *asm_stmt =
- as_a <const gimple_statement_asm> (gs);
+ as_a <const gimple_statement_asm *> (gs);
return asm_stmt->no;
}
gimple_asm_nclobbers (const_gimple gs)
{
const gimple_statement_asm *asm_stmt =
- as_a <const gimple_statement_asm> (gs);
+ as_a <const gimple_statement_asm *> (gs);
return asm_stmt->nc;
}
gimple_asm_nlabels (const_gimple gs)
{
const gimple_statement_asm *asm_stmt =
- as_a <const gimple_statement_asm> (gs);
+ as_a <const gimple_statement_asm *> (gs);
return asm_stmt->nl;
}
gimple_asm_input_op (const_gimple gs, unsigned index)
{
const gimple_statement_asm *asm_stmt =
- as_a <const gimple_statement_asm> (gs);
+ as_a <const gimple_statement_asm *> (gs);
gcc_gimple_checking_assert (index < asm_stmt->ni);
return gimple_op (gs, index + asm_stmt->no);
}
gimple_asm_input_op_ptr (const_gimple gs, unsigned index)
{
const gimple_statement_asm *asm_stmt =
- as_a <const gimple_statement_asm> (gs);
+ as_a <const gimple_statement_asm *> (gs);
gcc_gimple_checking_assert (index < asm_stmt->ni);
return gimple_op_ptr (gs, index + asm_stmt->no);
}
static inline void
gimple_asm_set_input_op (gimple gs, unsigned index, tree in_op)
{
- gimple_statement_asm *asm_stmt = as_a <gimple_statement_asm> (gs);
+ 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_asm_output_op (const_gimple gs, unsigned index)
{
const gimple_statement_asm *asm_stmt =
- as_a <const gimple_statement_asm> (gs);
+ as_a <const gimple_statement_asm *> (gs);
gcc_gimple_checking_assert (index < asm_stmt->no);
return gimple_op (gs, index);
}
gimple_asm_output_op_ptr (const_gimple gs, unsigned index)
{
const gimple_statement_asm *asm_stmt =
- as_a <const gimple_statement_asm> (gs);
+ as_a <const gimple_statement_asm *> (gs);
gcc_gimple_checking_assert (index < asm_stmt->no);
return gimple_op_ptr (gs, index);
}
static inline void
gimple_asm_set_output_op (gimple gs, unsigned index, tree out_op)
{
- gimple_statement_asm *asm_stmt = as_a <gimple_statement_asm> (gs);
+ 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_asm_clobber_op (const_gimple gs, unsigned index)
{
const gimple_statement_asm *asm_stmt =
- as_a <const gimple_statement_asm> (gs);
+ 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);
}
static inline void
gimple_asm_set_clobber_op (gimple gs, unsigned index, tree clobber_op)
{
- gimple_statement_asm *asm_stmt = as_a <gimple_statement_asm> (gs);
+ 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_asm_label_op (const_gimple gs, unsigned index)
{
const gimple_statement_asm *asm_stmt =
- as_a <const gimple_statement_asm> (gs);
+ 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);
}
static inline void
gimple_asm_set_label_op (gimple gs, unsigned index, tree label_op)
{
- gimple_statement_asm *asm_stmt = as_a <gimple_statement_asm> (gs);
+ 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_asm_string (const_gimple gs)
{
const gimple_statement_asm *asm_stmt =
- as_a <const gimple_statement_asm> (gs);
+ as_a <const gimple_statement_asm *> (gs);
return asm_stmt->string;
}
gimple_catch_types (const_gimple gs)
{
const gimple_statement_catch *catch_stmt =
- as_a <const gimple_statement_catch> (gs);
+ as_a <const gimple_statement_catch *> (gs);
return catch_stmt->types;
}
static inline tree *
gimple_catch_types_ptr (gimple gs)
{
- gimple_statement_catch *catch_stmt = as_a <gimple_statement_catch> (gs);
+ gimple_statement_catch *catch_stmt = as_a <gimple_statement_catch *> (gs);
return &catch_stmt->types;
}
static inline gimple_seq *
gimple_catch_handler_ptr (gimple gs)
{
- gimple_statement_catch *catch_stmt = as_a <gimple_statement_catch> (gs);
+ gimple_statement_catch *catch_stmt = as_a <gimple_statement_catch *> (gs);
return &catch_stmt->handler;
}
static inline void
gimple_catch_set_types (gimple gs, tree t)
{
- gimple_statement_catch *catch_stmt = as_a <gimple_statement_catch> (gs);
+ gimple_statement_catch *catch_stmt = as_a <gimple_statement_catch *> (gs);
catch_stmt->types = t;
}
static inline void
gimple_catch_set_handler (gimple gs, gimple_seq handler)
{
- gimple_statement_catch *catch_stmt = as_a <gimple_statement_catch> (gs);
+ gimple_statement_catch *catch_stmt = as_a <gimple_statement_catch *> (gs);
catch_stmt->handler = handler;
}
gimple_eh_filter_types (const_gimple gs)
{
const gimple_statement_eh_filter *eh_filter_stmt =
- as_a <const gimple_statement_eh_filter> (gs);
+ as_a <const gimple_statement_eh_filter *> (gs);
return eh_filter_stmt->types;
}
gimple_eh_filter_types_ptr (gimple gs)
{
gimple_statement_eh_filter *eh_filter_stmt =
- as_a <gimple_statement_eh_filter> (gs);
+ as_a <gimple_statement_eh_filter *> (gs);
return &eh_filter_stmt->types;
}
gimple_eh_filter_failure_ptr (gimple gs)
{
gimple_statement_eh_filter *eh_filter_stmt =
- as_a <gimple_statement_eh_filter> (gs);
+ as_a <gimple_statement_eh_filter *> (gs);
return &eh_filter_stmt->failure;
}
gimple_eh_filter_set_types (gimple gs, tree types)
{
gimple_statement_eh_filter *eh_filter_stmt =
- as_a <gimple_statement_eh_filter> (gs);
+ as_a <gimple_statement_eh_filter *> (gs);
eh_filter_stmt->types = types;
}
gimple_eh_filter_set_failure (gimple gs, gimple_seq failure)
{
gimple_statement_eh_filter *eh_filter_stmt =
- as_a <gimple_statement_eh_filter> (gs);
+ as_a <gimple_statement_eh_filter *> (gs);
eh_filter_stmt->failure = failure;
}
static inline tree
gimple_eh_must_not_throw_fndecl (gimple gs)
{
- gimple_statement_eh_mnt *eh_mnt_stmt = as_a <gimple_statement_eh_mnt> (gs);
+ gimple_statement_eh_mnt *eh_mnt_stmt = as_a <gimple_statement_eh_mnt *> (gs);
return eh_mnt_stmt->fndecl;
}
static inline void
gimple_eh_must_not_throw_set_fndecl (gimple gs, tree decl)
{
- gimple_statement_eh_mnt *eh_mnt_stmt = as_a <gimple_statement_eh_mnt> (gs);
+ gimple_statement_eh_mnt *eh_mnt_stmt = as_a <gimple_statement_eh_mnt *> (gs);
eh_mnt_stmt->fndecl = decl;
}
gimple_eh_else_n_body_ptr (gimple gs)
{
gimple_statement_eh_else *eh_else_stmt =
- as_a <gimple_statement_eh_else> (gs);
+ as_a <gimple_statement_eh_else *> (gs);
return &eh_else_stmt->n_body;
}
gimple_eh_else_e_body_ptr (gimple gs)
{
gimple_statement_eh_else *eh_else_stmt =
- as_a <gimple_statement_eh_else> (gs);
+ as_a <gimple_statement_eh_else *> (gs);
return &eh_else_stmt->e_body;
}
gimple_eh_else_set_n_body (gimple gs, gimple_seq seq)
{
gimple_statement_eh_else *eh_else_stmt =
- as_a <gimple_statement_eh_else> (gs);
+ as_a <gimple_statement_eh_else *> (gs);
eh_else_stmt->n_body = seq;
}
gimple_eh_else_set_e_body (gimple gs, gimple_seq seq)
{
gimple_statement_eh_else *eh_else_stmt =
- as_a <gimple_statement_eh_else> (gs);
+ as_a <gimple_statement_eh_else *> (gs);
eh_else_stmt->e_body = seq;
}
static inline gimple_seq *
gimple_try_eval_ptr (gimple gs)
{
- gimple_statement_try *try_stmt = as_a <gimple_statement_try> (gs);
+ gimple_statement_try *try_stmt = as_a <gimple_statement_try *> (gs);
return &try_stmt->eval;
}
static inline gimple_seq *
gimple_try_cleanup_ptr (gimple gs)
{
- gimple_statement_try *try_stmt = as_a <gimple_statement_try> (gs);
+ gimple_statement_try *try_stmt = as_a <gimple_statement_try *> (gs);
return &try_stmt->cleanup;
}
static inline void
gimple_try_set_eval (gimple gs, gimple_seq eval)
{
- gimple_statement_try *try_stmt = as_a <gimple_statement_try> (gs);
+ gimple_statement_try *try_stmt = as_a <gimple_statement_try *> (gs);
try_stmt->eval = eval;
}
static inline void
gimple_try_set_cleanup (gimple gs, gimple_seq cleanup)
{
- gimple_statement_try *try_stmt = as_a <gimple_statement_try> (gs);
+ gimple_statement_try *try_stmt = as_a <gimple_statement_try *> (gs);
try_stmt->cleanup = cleanup;
}
static inline gimple_seq *
gimple_wce_cleanup_ptr (gimple gs)
{
- gimple_statement_wce *wce_stmt = as_a <gimple_statement_wce> (gs);
+ gimple_statement_wce *wce_stmt = as_a <gimple_statement_wce *> (gs);
return &wce_stmt->cleanup;
}
static inline void
gimple_wce_set_cleanup (gimple gs, gimple_seq cleanup)
{
- gimple_statement_wce *wce_stmt = as_a <gimple_statement_wce> (gs);
+ gimple_statement_wce *wce_stmt = as_a <gimple_statement_wce *> (gs);
wce_stmt->cleanup = cleanup;
}
gimple_phi_capacity (const_gimple gs)
{
const gimple_statement_phi *phi_stmt =
- as_a <const gimple_statement_phi> (gs);
+ as_a <const gimple_statement_phi *> (gs);
return phi_stmt->capacity;
}
gimple_phi_num_args (const_gimple gs)
{
const gimple_statement_phi *phi_stmt =
- as_a <const gimple_statement_phi> (gs);
+ as_a <const gimple_statement_phi *> (gs);
return phi_stmt->nargs;
}
gimple_phi_result (const_gimple gs)
{
const gimple_statement_phi *phi_stmt =
- as_a <const gimple_statement_phi> (gs);
+ as_a <const gimple_statement_phi *> (gs);
return phi_stmt->result;
}
static inline tree *
gimple_phi_result_ptr (gimple gs)
{
- gimple_statement_phi *phi_stmt = as_a <gimple_statement_phi> (gs);
+ gimple_statement_phi *phi_stmt = as_a <gimple_statement_phi *> (gs);
return &phi_stmt->result;
}
static inline void
gimple_phi_set_result (gimple gs, tree result)
{
- gimple_statement_phi *phi_stmt = as_a <gimple_statement_phi> (gs);
+ gimple_statement_phi *phi_stmt = as_a <gimple_statement_phi *> (gs);
phi_stmt->result = result;
if (result && TREE_CODE (result) == SSA_NAME)
SSA_NAME_DEF_STMT (result) = gs;
static inline struct phi_arg_d *
gimple_phi_arg (gimple gs, unsigned index)
{
- gimple_statement_phi *phi_stmt = as_a <gimple_statement_phi> (gs);
+ gimple_statement_phi *phi_stmt = as_a <gimple_statement_phi *> (gs);
gcc_gimple_checking_assert (index <= phi_stmt->capacity);
return &(phi_stmt->args[index]);
}
static inline void
gimple_phi_set_arg (gimple gs, unsigned index, struct phi_arg_d * phiarg)
{
- gimple_statement_phi *phi_stmt = as_a <gimple_statement_phi> (gs);
+ gimple_statement_phi *phi_stmt = as_a <gimple_statement_phi *> (gs);
gcc_gimple_checking_assert (index <= phi_stmt->nargs);
phi_stmt->args[index] = *phiarg;
}
gimple_resx_region (const_gimple gs)
{
const gimple_statement_resx *resx_stmt =
- as_a <const gimple_statement_resx> (gs);
+ as_a <const gimple_statement_resx *> (gs);
return resx_stmt->region;
}
static inline void
gimple_resx_set_region (gimple gs, int region)
{
- gimple_statement_resx *resx_stmt = as_a <gimple_statement_resx> (gs);
+ gimple_statement_resx *resx_stmt = as_a <gimple_statement_resx *> (gs);
resx_stmt->region = region;
}
gimple_eh_dispatch_region (const_gimple gs)
{
const gimple_statement_eh_dispatch *eh_dispatch_stmt =
- as_a <const gimple_statement_eh_dispatch> (gs);
+ as_a <const gimple_statement_eh_dispatch *> (gs);
return eh_dispatch_stmt->region;
}
gimple_eh_dispatch_set_region (gimple gs, int region)
{
gimple_statement_eh_dispatch *eh_dispatch_stmt =
- as_a <gimple_statement_eh_dispatch> (gs);
+ as_a <gimple_statement_eh_dispatch *> (gs);
eh_dispatch_stmt->region = region;
}
gimple_omp_critical_name (const_gimple gs)
{
const gimple_statement_omp_critical *omp_critical_stmt =
- as_a <const gimple_statement_omp_critical> (gs);
+ as_a <const gimple_statement_omp_critical *> (gs);
return omp_critical_stmt->name;
}
gimple_omp_critical_name_ptr (gimple gs)
{
gimple_statement_omp_critical *omp_critical_stmt =
- as_a <gimple_statement_omp_critical> (gs);
+ as_a <gimple_statement_omp_critical *> (gs);
return &omp_critical_stmt->name;
}
gimple_omp_critical_set_name (gimple gs, tree name)
{
gimple_statement_omp_critical *omp_critical_stmt =
- as_a <gimple_statement_omp_critical> (gs);
+ as_a <gimple_statement_omp_critical *> (gs);
omp_critical_stmt->name = name;
}
gimple_omp_for_clauses (const_gimple gs)
{
const gimple_statement_omp_for *omp_for_stmt =
- as_a <const gimple_statement_omp_for> (gs);
+ as_a <const gimple_statement_omp_for *> (gs);
return omp_for_stmt->clauses;
}
gimple_omp_for_clauses_ptr (gimple gs)
{
gimple_statement_omp_for *omp_for_stmt =
- as_a <gimple_statement_omp_for> (gs);
+ as_a <gimple_statement_omp_for *> (gs);
return &omp_for_stmt->clauses;
}
gimple_omp_for_set_clauses (gimple gs, tree clauses)
{
gimple_statement_omp_for *omp_for_stmt =
- as_a <gimple_statement_omp_for> (gs);
+ as_a <gimple_statement_omp_for *> (gs);
omp_for_stmt->clauses = clauses;
}
gimple_omp_for_collapse (gimple gs)
{
gimple_statement_omp_for *omp_for_stmt =
- as_a <gimple_statement_omp_for> (gs);
+ as_a <gimple_statement_omp_for *> (gs);
return omp_for_stmt->collapse;
}
gimple_omp_for_index (const_gimple gs, size_t i)
{
const gimple_statement_omp_for *omp_for_stmt =
- as_a <const gimple_statement_omp_for> (gs);
+ as_a <const gimple_statement_omp_for *> (gs);
gcc_gimple_checking_assert (i < omp_for_stmt->collapse);
return omp_for_stmt->iter[i].index;
}
gimple_omp_for_index_ptr (gimple gs, size_t i)
{
gimple_statement_omp_for *omp_for_stmt =
- as_a <gimple_statement_omp_for> (gs);
+ as_a <gimple_statement_omp_for *> (gs);
gcc_gimple_checking_assert (i < omp_for_stmt->collapse);
return &omp_for_stmt->iter[i].index;
}
gimple_omp_for_set_index (gimple gs, size_t i, tree index)
{
gimple_statement_omp_for *omp_for_stmt =
- as_a <gimple_statement_omp_for> (gs);
+ as_a <gimple_statement_omp_for *> (gs);
gcc_gimple_checking_assert (i < omp_for_stmt->collapse);
omp_for_stmt->iter[i].index = index;
}
gimple_omp_for_initial (const_gimple gs, size_t i)
{
const gimple_statement_omp_for *omp_for_stmt =
- as_a <const gimple_statement_omp_for> (gs);
+ as_a <const gimple_statement_omp_for *> (gs);
gcc_gimple_checking_assert (i < omp_for_stmt->collapse);
return omp_for_stmt->iter[i].initial;
}
gimple_omp_for_initial_ptr (gimple gs, size_t i)
{
gimple_statement_omp_for *omp_for_stmt =
- as_a <gimple_statement_omp_for> (gs);
+ as_a <gimple_statement_omp_for *> (gs);
gcc_gimple_checking_assert (i < omp_for_stmt->collapse);
return &omp_for_stmt->iter[i].initial;
}
gimple_omp_for_set_initial (gimple gs, size_t i, tree initial)
{
gimple_statement_omp_for *omp_for_stmt =
- as_a <gimple_statement_omp_for> (gs);
+ as_a <gimple_statement_omp_for *> (gs);
gcc_gimple_checking_assert (i < omp_for_stmt->collapse);
omp_for_stmt->iter[i].initial = initial;
}
gimple_omp_for_final (const_gimple gs, size_t i)
{
const gimple_statement_omp_for *omp_for_stmt =
- as_a <const gimple_statement_omp_for> (gs);
+ as_a <const gimple_statement_omp_for *> (gs);
gcc_gimple_checking_assert (i < omp_for_stmt->collapse);
return omp_for_stmt->iter[i].final;
}
gimple_omp_for_final_ptr (gimple gs, size_t i)
{
gimple_statement_omp_for *omp_for_stmt =
- as_a <gimple_statement_omp_for> (gs);
+ as_a <gimple_statement_omp_for *> (gs);
gcc_gimple_checking_assert (i < omp_for_stmt->collapse);
return &omp_for_stmt->iter[i].final;
}
gimple_omp_for_set_final (gimple gs, size_t i, tree final)
{
gimple_statement_omp_for *omp_for_stmt =
- as_a <gimple_statement_omp_for> (gs);
+ as_a <gimple_statement_omp_for *> (gs);
gcc_gimple_checking_assert (i < omp_for_stmt->collapse);
omp_for_stmt->iter[i].final = final;
}
gimple_omp_for_incr (const_gimple gs, size_t i)
{
const gimple_statement_omp_for *omp_for_stmt =
- as_a <const gimple_statement_omp_for> (gs);
+ as_a <const gimple_statement_omp_for *> (gs);
gcc_gimple_checking_assert (i < omp_for_stmt->collapse);
return omp_for_stmt->iter[i].incr;
}
gimple_omp_for_incr_ptr (gimple gs, size_t i)
{
gimple_statement_omp_for *omp_for_stmt =
- as_a <gimple_statement_omp_for> (gs);
+ as_a <gimple_statement_omp_for *> (gs);
gcc_gimple_checking_assert (i < omp_for_stmt->collapse);
return &omp_for_stmt->iter[i].incr;
}
gimple_omp_for_set_incr (gimple gs, size_t i, tree incr)
{
gimple_statement_omp_for *omp_for_stmt =
- as_a <gimple_statement_omp_for> (gs);
+ as_a <gimple_statement_omp_for *> (gs);
gcc_gimple_checking_assert (i < omp_for_stmt->collapse);
omp_for_stmt->iter[i].incr = incr;
}
gimple_omp_for_pre_body_ptr (gimple gs)
{
gimple_statement_omp_for *omp_for_stmt =
- as_a <gimple_statement_omp_for> (gs);
+ as_a <gimple_statement_omp_for *> (gs);
return &omp_for_stmt->pre_body;
}
gimple_omp_for_set_pre_body (gimple gs, gimple_seq pre_body)
{
gimple_statement_omp_for *omp_for_stmt =
- as_a <gimple_statement_omp_for> (gs);
+ as_a <gimple_statement_omp_for *> (gs);
omp_for_stmt->pre_body = pre_body;
}
gimple_omp_parallel_clauses (const_gimple gs)
{
const gimple_statement_omp_parallel *omp_parallel_stmt =
- as_a <const gimple_statement_omp_parallel> (gs);
+ as_a <const gimple_statement_omp_parallel *> (gs);
return omp_parallel_stmt->clauses;
}
gimple_omp_parallel_clauses_ptr (gimple gs)
{
gimple_statement_omp_parallel *omp_parallel_stmt =
- as_a <gimple_statement_omp_parallel> (gs);
+ as_a <gimple_statement_omp_parallel *> (gs);
return &omp_parallel_stmt->clauses;
}
gimple_omp_parallel_set_clauses (gimple gs, tree clauses)
{
gimple_statement_omp_parallel *omp_parallel_stmt =
- as_a <gimple_statement_omp_parallel> (gs);
+ as_a <gimple_statement_omp_parallel *> (gs);
omp_parallel_stmt->clauses = clauses;
}
gimple_omp_parallel_child_fn (const_gimple gs)
{
const gimple_statement_omp_parallel *omp_parallel_stmt =
- as_a <const gimple_statement_omp_parallel> (gs);
+ as_a <const gimple_statement_omp_parallel *> (gs);
return omp_parallel_stmt->child_fn;
}
gimple_omp_parallel_child_fn_ptr (gimple gs)
{
gimple_statement_omp_parallel *omp_parallel_stmt =
- as_a <gimple_statement_omp_parallel> (gs);
+ as_a <gimple_statement_omp_parallel *> (gs);
return &omp_parallel_stmt->child_fn;
}
gimple_omp_parallel_set_child_fn (gimple gs, tree child_fn)
{
gimple_statement_omp_parallel *omp_parallel_stmt =
- as_a <gimple_statement_omp_parallel> (gs);
+ as_a <gimple_statement_omp_parallel *> (gs);
omp_parallel_stmt->child_fn = child_fn;
}
gimple_omp_parallel_data_arg (const_gimple gs)
{
const gimple_statement_omp_parallel *omp_parallel_stmt =
- as_a <const gimple_statement_omp_parallel> (gs);
+ as_a <const gimple_statement_omp_parallel *> (gs);
return omp_parallel_stmt->data_arg;
}
gimple_omp_parallel_data_arg_ptr (gimple gs)
{
gimple_statement_omp_parallel *omp_parallel_stmt =
- as_a <gimple_statement_omp_parallel> (gs);
+ as_a <gimple_statement_omp_parallel *> (gs);
return &omp_parallel_stmt->data_arg;
}
gimple_omp_parallel_set_data_arg (gimple gs, tree data_arg)
{
gimple_statement_omp_parallel *omp_parallel_stmt =
- as_a <gimple_statement_omp_parallel> (gs);
+ as_a <gimple_statement_omp_parallel *> (gs);
omp_parallel_stmt->data_arg = data_arg;
}
gimple_omp_task_clauses (const_gimple gs)
{
const gimple_statement_omp_task *omp_task_stmt =
- as_a <const gimple_statement_omp_task> (gs);
+ as_a <const gimple_statement_omp_task *> (gs);
return omp_task_stmt->clauses;
}
gimple_omp_task_clauses_ptr (gimple gs)
{
gimple_statement_omp_task *omp_task_stmt =
- as_a <gimple_statement_omp_task> (gs);
+ as_a <gimple_statement_omp_task *> (gs);
return &omp_task_stmt->clauses;
}
gimple_omp_task_set_clauses (gimple gs, tree clauses)
{
gimple_statement_omp_task *omp_task_stmt =
- as_a <gimple_statement_omp_task> (gs);
+ as_a <gimple_statement_omp_task *> (gs);
omp_task_stmt->clauses = clauses;
}
gimple_omp_task_child_fn (const_gimple gs)
{
const gimple_statement_omp_task *omp_task_stmt =
- as_a <const gimple_statement_omp_task> (gs);
+ as_a <const gimple_statement_omp_task *> (gs);
return omp_task_stmt->child_fn;
}
gimple_omp_task_child_fn_ptr (gimple gs)
{
gimple_statement_omp_task *omp_task_stmt =
- as_a <gimple_statement_omp_task> (gs);
+ as_a <gimple_statement_omp_task *> (gs);
return &omp_task_stmt->child_fn;
}
gimple_omp_task_set_child_fn (gimple gs, tree child_fn)
{
gimple_statement_omp_task *omp_task_stmt =
- as_a <gimple_statement_omp_task> (gs);
+ as_a <gimple_statement_omp_task *> (gs);
omp_task_stmt->child_fn = child_fn;
}
gimple_omp_task_data_arg (const_gimple gs)
{
const gimple_statement_omp_task *omp_task_stmt =
- as_a <const gimple_statement_omp_task> (gs);
+ as_a <const gimple_statement_omp_task *> (gs);
return omp_task_stmt->data_arg;
}
gimple_omp_task_data_arg_ptr (gimple gs)
{
gimple_statement_omp_task *omp_task_stmt =
- as_a <gimple_statement_omp_task> (gs);
+ as_a <gimple_statement_omp_task *> (gs);
return &omp_task_stmt->data_arg;
}
gimple_omp_task_set_data_arg (gimple gs, tree data_arg)
{
gimple_statement_omp_task *omp_task_stmt =
- as_a <gimple_statement_omp_task> (gs);
+ as_a <gimple_statement_omp_task *> (gs);
omp_task_stmt->data_arg = data_arg;
}
gimple_omp_taskreg_clauses (const_gimple gs)
{
const gimple_statement_omp_taskreg *omp_taskreg_stmt =
- as_a <const gimple_statement_omp_taskreg> (gs);
+ as_a <const gimple_statement_omp_taskreg *> (gs);
return omp_taskreg_stmt->clauses;
}
gimple_omp_taskreg_clauses_ptr (gimple gs)
{
gimple_statement_omp_taskreg *omp_taskreg_stmt =
- as_a <gimple_statement_omp_taskreg> (gs);
+ as_a <gimple_statement_omp_taskreg *> (gs);
return &omp_taskreg_stmt->clauses;
}
gimple_omp_taskreg_set_clauses (gimple gs, tree clauses)
{
gimple_statement_omp_taskreg *omp_taskreg_stmt =
- as_a <gimple_statement_omp_taskreg> (gs);
+ as_a <gimple_statement_omp_taskreg *> (gs);
omp_taskreg_stmt->clauses = clauses;
}
gimple_omp_taskreg_child_fn (const_gimple gs)
{
const gimple_statement_omp_taskreg *omp_taskreg_stmt =
- as_a <const gimple_statement_omp_taskreg> (gs);
+ as_a <const gimple_statement_omp_taskreg *> (gs);
return omp_taskreg_stmt->child_fn;
}
gimple_omp_taskreg_child_fn_ptr (gimple gs)
{
gimple_statement_omp_taskreg *omp_taskreg_stmt =
- as_a <gimple_statement_omp_taskreg> (gs);
+ as_a <gimple_statement_omp_taskreg *> (gs);
return &omp_taskreg_stmt->child_fn;
}
gimple_omp_taskreg_set_child_fn (gimple gs, tree child_fn)
{
gimple_statement_omp_taskreg *omp_taskreg_stmt =
- as_a <gimple_statement_omp_taskreg> (gs);
+ as_a <gimple_statement_omp_taskreg *> (gs);
omp_taskreg_stmt->child_fn = child_fn;
}
gimple_omp_taskreg_data_arg (const_gimple gs)
{
const gimple_statement_omp_taskreg *omp_taskreg_stmt =
- as_a <const gimple_statement_omp_taskreg> (gs);
+ as_a <const gimple_statement_omp_taskreg *> (gs);
return omp_taskreg_stmt->data_arg;
}
gimple_omp_taskreg_data_arg_ptr (gimple gs)
{
gimple_statement_omp_taskreg *omp_taskreg_stmt =
- as_a <gimple_statement_omp_taskreg> (gs);
+ as_a <gimple_statement_omp_taskreg *> (gs);
return &omp_taskreg_stmt->data_arg;
}
gimple_omp_taskreg_set_data_arg (gimple gs, tree data_arg)
{
gimple_statement_omp_taskreg *omp_taskreg_stmt =
- as_a <gimple_statement_omp_taskreg> (gs);
+ as_a <gimple_statement_omp_taskreg *> (gs);
omp_taskreg_stmt->data_arg = data_arg;
}
gimple_omp_task_copy_fn (const_gimple gs)
{
const gimple_statement_omp_task *omp_task_stmt =
- as_a <const gimple_statement_omp_task> (gs);
+ as_a <const gimple_statement_omp_task *> (gs);
return omp_task_stmt->copy_fn;
}
gimple_omp_task_copy_fn_ptr (gimple gs)
{
gimple_statement_omp_task *omp_task_stmt =
- as_a <gimple_statement_omp_task> (gs);
+ as_a <gimple_statement_omp_task *> (gs);
return &omp_task_stmt->copy_fn;
}
gimple_omp_task_set_copy_fn (gimple gs, tree copy_fn)
{
gimple_statement_omp_task *omp_task_stmt =
- as_a <gimple_statement_omp_task> (gs);
+ as_a <gimple_statement_omp_task *> (gs);
omp_task_stmt->copy_fn = copy_fn;
}
gimple_omp_task_arg_size (const_gimple gs)
{
const gimple_statement_omp_task *omp_task_stmt =
- as_a <const gimple_statement_omp_task> (gs);
+ as_a <const gimple_statement_omp_task *> (gs);
return omp_task_stmt->arg_size;
}
gimple_omp_task_arg_size_ptr (gimple gs)
{
gimple_statement_omp_task *omp_task_stmt =
- as_a <gimple_statement_omp_task> (gs);
+ as_a <gimple_statement_omp_task *> (gs);
return &omp_task_stmt->arg_size;
}
gimple_omp_task_set_arg_size (gimple gs, tree arg_size)
{
gimple_statement_omp_task *omp_task_stmt =
- as_a <gimple_statement_omp_task> (gs);
+ as_a <gimple_statement_omp_task *> (gs);
omp_task_stmt->arg_size = arg_size;
}
gimple_omp_task_arg_align (const_gimple gs)
{
const gimple_statement_omp_task *omp_task_stmt =
- as_a <const gimple_statement_omp_task> (gs);
+ as_a <const gimple_statement_omp_task *> (gs);
return omp_task_stmt->arg_align;
}
gimple_omp_task_arg_align_ptr (gimple gs)
{
gimple_statement_omp_task *omp_task_stmt =
- as_a <gimple_statement_omp_task> (gs);
+ as_a <gimple_statement_omp_task *> (gs);
return &omp_task_stmt->arg_align;
}
gimple_omp_task_set_arg_align (gimple gs, tree arg_align)
{
gimple_statement_omp_task *omp_task_stmt =
- as_a <gimple_statement_omp_task> (gs);
+ as_a <gimple_statement_omp_task *> (gs);
omp_task_stmt->arg_align = arg_align;
}
gimple_omp_single_clauses (const_gimple gs)
{
const gimple_statement_omp_single *omp_single_stmt =
- as_a <const gimple_statement_omp_single> (gs);
+ as_a <const gimple_statement_omp_single *> (gs);
return omp_single_stmt->clauses;
}
gimple_omp_single_clauses_ptr (gimple gs)
{
gimple_statement_omp_single *omp_single_stmt =
- as_a <gimple_statement_omp_single> (gs);
+ as_a <gimple_statement_omp_single *> (gs);
return &omp_single_stmt->clauses;
}
gimple_omp_single_set_clauses (gimple gs, tree clauses)
{
gimple_statement_omp_single *omp_single_stmt =
- as_a <gimple_statement_omp_single> (gs);
+ as_a <gimple_statement_omp_single *> (gs);
omp_single_stmt->clauses = clauses;
}
gimple_omp_target_clauses (const_gimple gs)
{
const gimple_statement_omp_target *omp_target_stmt =
- as_a <const gimple_statement_omp_target> (gs);
+ as_a <const gimple_statement_omp_target *> (gs);
return omp_target_stmt->clauses;
}
gimple_omp_target_clauses_ptr (gimple gs)
{
gimple_statement_omp_target *omp_target_stmt =
- as_a <gimple_statement_omp_target> (gs);
+ as_a <gimple_statement_omp_target *> (gs);
return &omp_target_stmt->clauses;
}
gimple_omp_target_set_clauses (gimple gs, tree clauses)
{
gimple_statement_omp_target *omp_target_stmt =
- as_a <gimple_statement_omp_target> (gs);
+ as_a <gimple_statement_omp_target *> (gs);
omp_target_stmt->clauses = clauses;
}
gimple_omp_target_child_fn (const_gimple gs)
{
const gimple_statement_omp_target *omp_target_stmt =
- as_a <const gimple_statement_omp_target> (gs);
+ as_a <const gimple_statement_omp_target *> (gs);
return omp_target_stmt->child_fn;
}
gimple_omp_target_child_fn_ptr (gimple gs)
{
gimple_statement_omp_target *omp_target_stmt =
- as_a <gimple_statement_omp_target> (gs);
+ as_a <gimple_statement_omp_target *> (gs);
return &omp_target_stmt->child_fn;
}
gimple_omp_target_set_child_fn (gimple gs, tree child_fn)
{
gimple_statement_omp_target *omp_target_stmt =
- as_a <gimple_statement_omp_target> (gs);
+ as_a <gimple_statement_omp_target *> (gs);
omp_target_stmt->child_fn = child_fn;
}
gimple_omp_target_data_arg (const_gimple gs)
{
const gimple_statement_omp_target *omp_target_stmt =
- as_a <const gimple_statement_omp_target> (gs);
+ as_a <const gimple_statement_omp_target *> (gs);
return omp_target_stmt->data_arg;
}
gimple_omp_target_data_arg_ptr (gimple gs)
{
gimple_statement_omp_target *omp_target_stmt =
- as_a <gimple_statement_omp_target> (gs);
+ as_a <gimple_statement_omp_target *> (gs);
return &omp_target_stmt->data_arg;
}
gimple_omp_target_set_data_arg (gimple gs, tree data_arg)
{
gimple_statement_omp_target *omp_target_stmt =
- as_a <gimple_statement_omp_target> (gs);
+ as_a <gimple_statement_omp_target *> (gs);
omp_target_stmt->data_arg = data_arg;
}
gimple_omp_teams_clauses (const_gimple gs)
{
const gimple_statement_omp_teams *omp_teams_stmt =
- as_a <const gimple_statement_omp_teams> (gs);
+ as_a <const gimple_statement_omp_teams *> (gs);
return omp_teams_stmt->clauses;
}
gimple_omp_teams_clauses_ptr (gimple gs)
{
gimple_statement_omp_teams *omp_teams_stmt =
- as_a <gimple_statement_omp_teams> (gs);
+ as_a <gimple_statement_omp_teams *> (gs);
return &omp_teams_stmt->clauses;
}
gimple_omp_teams_set_clauses (gimple gs, tree clauses)
{
gimple_statement_omp_teams *omp_teams_stmt =
- as_a <gimple_statement_omp_teams> (gs);
+ as_a <gimple_statement_omp_teams *> (gs);
omp_teams_stmt->clauses = clauses;
}
gimple_omp_sections_clauses (const_gimple gs)
{
const gimple_statement_omp_sections *omp_sections_stmt =
- as_a <const gimple_statement_omp_sections> (gs);
+ as_a <const gimple_statement_omp_sections *> (gs);
return omp_sections_stmt->clauses;
}
gimple_omp_sections_clauses_ptr (gimple gs)
{
gimple_statement_omp_sections *omp_sections_stmt =
- as_a <gimple_statement_omp_sections> (gs);
+ as_a <gimple_statement_omp_sections *> (gs);
return &omp_sections_stmt->clauses;
}
gimple_omp_sections_set_clauses (gimple gs, tree clauses)
{
gimple_statement_omp_sections *omp_sections_stmt =
- as_a <gimple_statement_omp_sections> (gs);
+ as_a <gimple_statement_omp_sections *> (gs);
omp_sections_stmt->clauses = clauses;
}
gimple_omp_sections_control (const_gimple gs)
{
const gimple_statement_omp_sections *omp_sections_stmt =
- as_a <const gimple_statement_omp_sections> (gs);
+ as_a <const gimple_statement_omp_sections *> (gs);
return omp_sections_stmt->control;
}
gimple_omp_sections_control_ptr (gimple gs)
{
gimple_statement_omp_sections *omp_sections_stmt =
- as_a <gimple_statement_omp_sections> (gs);
+ as_a <gimple_statement_omp_sections *> (gs);
return &omp_sections_stmt->control;
}
gimple_omp_sections_set_control (gimple gs, tree control)
{
gimple_statement_omp_sections *omp_sections_stmt =
- as_a <gimple_statement_omp_sections> (gs);
+ as_a <gimple_statement_omp_sections *> (gs);
omp_sections_stmt->control = control;
}
gimple_omp_for_set_cond (gimple gs, size_t i, enum tree_code cond)
{
gimple_statement_omp_for *omp_for_stmt =
- as_a <gimple_statement_omp_for> (gs);
+ as_a <gimple_statement_omp_for *> (gs);
gcc_gimple_checking_assert (TREE_CODE_CLASS (cond) == tcc_comparison
&& i < omp_for_stmt->collapse);
omp_for_stmt->iter[i].cond = cond;
gimple_omp_for_cond (const_gimple gs, size_t i)
{
const gimple_statement_omp_for *omp_for_stmt =
- as_a <const gimple_statement_omp_for> (gs);
+ as_a <const gimple_statement_omp_for *> (gs);
gcc_gimple_checking_assert (i < omp_for_stmt->collapse);
return omp_for_stmt->iter[i].cond;
}
gimple_omp_atomic_store_set_val (gimple g, tree val)
{
gimple_statement_omp_atomic_store *omp_atomic_store_stmt =
- as_a <gimple_statement_omp_atomic_store> (g);
+ as_a <gimple_statement_omp_atomic_store *> (g);
omp_atomic_store_stmt->val = val;
}
gimple_omp_atomic_store_val (const_gimple g)
{
const gimple_statement_omp_atomic_store *omp_atomic_store_stmt =
- as_a <const gimple_statement_omp_atomic_store> (g);
+ as_a <const gimple_statement_omp_atomic_store *> (g);
return omp_atomic_store_stmt->val;
}
gimple_omp_atomic_store_val_ptr (gimple g)
{
gimple_statement_omp_atomic_store *omp_atomic_store_stmt =
- as_a <gimple_statement_omp_atomic_store> (g);
+ as_a <gimple_statement_omp_atomic_store *> (g);
return &omp_atomic_store_stmt->val;
}
gimple_omp_atomic_load_set_lhs (gimple g, tree lhs)
{
gimple_statement_omp_atomic_load *omp_atomic_load_stmt =
- as_a <gimple_statement_omp_atomic_load> (g);
+ as_a <gimple_statement_omp_atomic_load *> (g);
omp_atomic_load_stmt->lhs = lhs;
}
gimple_omp_atomic_load_lhs (const_gimple g)
{
const gimple_statement_omp_atomic_load *omp_atomic_load_stmt =
- as_a <const gimple_statement_omp_atomic_load> (g);
+ as_a <const gimple_statement_omp_atomic_load *> (g);
return omp_atomic_load_stmt->lhs;
}
gimple_omp_atomic_load_lhs_ptr (gimple g)
{
gimple_statement_omp_atomic_load *omp_atomic_load_stmt =
- as_a <gimple_statement_omp_atomic_load> (g);
+ as_a <gimple_statement_omp_atomic_load *> (g);
return &omp_atomic_load_stmt->lhs;
}
gimple_omp_atomic_load_set_rhs (gimple g, tree rhs)
{
gimple_statement_omp_atomic_load *omp_atomic_load_stmt =
- as_a <gimple_statement_omp_atomic_load> (g);
+ as_a <gimple_statement_omp_atomic_load *> (g);
omp_atomic_load_stmt->rhs = rhs;
}
gimple_omp_atomic_load_rhs (const_gimple g)
{
const gimple_statement_omp_atomic_load *omp_atomic_load_stmt =
- as_a <const gimple_statement_omp_atomic_load> (g);
+ as_a <const gimple_statement_omp_atomic_load *> (g);
return omp_atomic_load_stmt->rhs;
}
gimple_omp_atomic_load_rhs_ptr (gimple g)
{
gimple_statement_omp_atomic_load *omp_atomic_load_stmt =
- as_a <gimple_statement_omp_atomic_load> (g);
+ as_a <gimple_statement_omp_atomic_load *> (g);
return &omp_atomic_load_stmt->rhs;
}
gimple_omp_continue_control_def (const_gimple g)
{
const gimple_statement_omp_continue *omp_continue_stmt =
- as_a <const gimple_statement_omp_continue> (g);
+ as_a <const gimple_statement_omp_continue *> (g);
return omp_continue_stmt->control_def;
}
gimple_omp_continue_control_def_ptr (gimple g)
{
gimple_statement_omp_continue *omp_continue_stmt =
- as_a <gimple_statement_omp_continue> (g);
+ as_a <gimple_statement_omp_continue *> (g);
return &omp_continue_stmt->control_def;
}
gimple_omp_continue_set_control_def (gimple g, tree def)
{
gimple_statement_omp_continue *omp_continue_stmt =
- as_a <gimple_statement_omp_continue> (g);
+ as_a <gimple_statement_omp_continue *> (g);
omp_continue_stmt->control_def = def;
}
gimple_omp_continue_control_use (const_gimple g)
{
const gimple_statement_omp_continue *omp_continue_stmt =
- as_a <const gimple_statement_omp_continue> (g);
+ as_a <const gimple_statement_omp_continue *> (g);
return omp_continue_stmt->control_use;
}
gimple_omp_continue_control_use_ptr (gimple g)
{
gimple_statement_omp_continue *omp_continue_stmt =
- as_a <gimple_statement_omp_continue> (g);
+ as_a <gimple_statement_omp_continue *> (g);
return &omp_continue_stmt->control_use;
}
gimple_omp_continue_set_control_use (gimple g, tree use)
{
gimple_statement_omp_continue *omp_continue_stmt =
- as_a <gimple_statement_omp_continue> (g);
+ as_a <gimple_statement_omp_continue *> (g);
omp_continue_stmt->control_use = use;
}
gimple_transaction_body_ptr (gimple gs)
{
gimple_statement_transaction *transaction_stmt =
- as_a <gimple_statement_transaction> (gs);
+ as_a <gimple_statement_transaction *> (gs);
return &transaction_stmt->body;
}
gimple_transaction_label (const_gimple gs)
{
const gimple_statement_transaction *transaction_stmt =
- as_a <const gimple_statement_transaction> (gs);
+ as_a <const gimple_statement_transaction *> (gs);
return transaction_stmt->label;
}
gimple_transaction_label_ptr (gimple gs)
{
gimple_statement_transaction *transaction_stmt =
- as_a <gimple_statement_transaction> (gs);
+ as_a <gimple_statement_transaction *> (gs);
return &transaction_stmt->label;
}
gimple_transaction_set_body (gimple gs, gimple_seq body)
{
gimple_statement_transaction *transaction_stmt =
- as_a <gimple_statement_transaction> (gs);
+ as_a <gimple_statement_transaction *> (gs);
transaction_stmt->body = body;
}
gimple_transaction_set_label (gimple gs, tree label)
{
gimple_statement_transaction *transaction_stmt =
- as_a <gimple_statement_transaction> (gs);
+ as_a <gimple_statement_transaction *> (gs);
transaction_stmt->label = label;
}
projects / thirdparty / gcc.git / commitdiff
