0823efedd0
Merge from cxx-conversion branch (http://gcc.gnu.org/wiki/cxx-conversion). As described in http://gcc.gnu.org/ml/gcc/2012-08/msg00015.html, this patch changes the default bootstrap process so that stage 1 always builds with a C++ compiler. Other than the bootstrap change, the patch makes no functional changes to the compiler. Everything should build as it does now in trunk. The main changes in this patch are: 1- Configuration changes. 2- Re-write of VEC. 3- Re-write of gengtype to support C++ templates and user-provided marking functions. 4- New hash table class. 5- Re-write double_int. 6- Implement tree macros as inline functions so they can be called from gdb. As discussed before, several of these changes do not fully change the call sites to use the new APIs. The bootstrap changes have already been tested on a wide range of targets (http://gcc.gnu.org/wiki/CppBuildStatus). Additionally, I have tested the merged trunk on: x86_64-unknown-linux-gnu, mips64el-unknown-linux-gnu, powerpc64-unknown-linux-gnu, i686-pc-linux-gnu, and ia64-unknown-linux-gnu. ChangeLog 2012-08-14 Diego Novillo <dnovillo@google.com> Merge from cxx-conversion branch. * Makefile.tpl (STAGE[+id+]_CXXFLAGS): Remove POSTSTAGE1_CONFIGURE_FLAGS. * Makefile.in: Regenerate. * configure.ac (ENABLE_BUILD_WITH_CXX): Remove. Update all users. Force C++ when bootstrapping. * configure: Regenerate. libcpp/ChangeLog 2012-08-14 Diego Novillo <dnovillo@google.com> Merge from cxx-conversion branch. Configury. * Makefile.in: Remove all handlers of ENABLE_BUILD_WITH_CXX. * configure.ac: Likewise. * configure: Regenerate. 2012-08-14 Lawrence Crowl <crowl@google.com> Merge from cxx-conversion branch. New C++ hash table. * include/symtab.h (typedef struct ht hash_table): Change the typedef name to cpp_hash_table. Update all users of the typedef. gcc/ChangeLog 2012-08-14 Diego Novillo <dnovillo@google.com> Merge from cxx-conversion branch. Configury. * configure.ac (CXX_FOR_BUILD): Define and substitute. (BUILD_CXXFLAGS): Define. Remove all handlers of ENABLE_BUILD_WITH_CXX. Force all build to be with C++. * Makefile.in (BUILD_CXXFLAGS): Use it. Remove all handlers of ENABLE_BUILD_WITH_CXX. * configure: Regenerate. * config.in: Regenerate. * doc/install.texi: Remove documentation for --enable-build-with-cxx and --enable-build-poststage1-with-cxx. 2012-08-14 Diego Novillo <dnovillo@google.com> Merge from cxx-conversion branch. Re-implement VEC in C++. * vec.c (vec_heap_free): Convert into a template function. (vec_gc_o_reserve_1): Make extern. (vec_gc_p_reserve): Remove. (vec_gc_p_reserve_exact): Remove. (vec_gc_o_reserve): Remove. (vec_gc_o_reserve_exact): Remove. (vec_heap_o_reserve_1): Make extern. (vec_heap_p_reserve): Remove. (vec_heap_p_reserve_exact): Remove. (vec_heap_o_reserve): Remove. (vec_heap_o_reserve_exact): Remove. (vec_stack_p_reserve): Remove. (vec_stack_p_reserve_exact): Remove. * vec.h (VEC_CHECK_INFO, VEC_CHECK_DECL, VEC_CHECK_PASS, VEC_ASSERT, VEC_ASSERT_FAIL, vec_assert_fail): Move earlier in the file. (VEC): Define to vec_t<T>. (vec_allocation_t): Define. (struct vec_prefix): Move earlier in the file. (vec_t<T>): New template. (DEF_VEC_I, DEF_VECL_ALLOC_I, DEF_VEC_P, DEF_VEC_ALLOC_P, DEF_VEC_O, DEF_VEC_ALLOC_P, DEF_VEC_O, DEF_VEC_ALLOC_O, DEF_VEC_ALLOC_P_STACK, DEF_VEC_ALLOC_O_STACK, DEF_VEC_ALLOC_I_STACK): Expand to 'struct vec_swallow_trailing_semi'. (DEF_VEC_A): Provide template instantiations for GC/PCH markers that do not traverse the vector. (vec_stack_p_reserve): Remove. (vec_stack_p_reserve_exact): Remove. (vec_stack_p_reserve_exact_1): Remove. (vec_stack_o_reserve): Remove. (vec_stack_o_reserve_exact): Remove. (vec_stack_free): Re-write as a template function. (vec_reserve): New template function. (vec_reserve_exact): New template function. (vec_heap_free): New template function if GATHER_STATISTICS is defined. Otherwise, macro that expands to free(). (VEC_length_1): New template function. (VEC_length): Call it. (VEC_empty_1): New template function. (VEC_empty): Call it. (VEC_address_1): New template function. (VEC_address): Call it. (VEC_last_1): New template function. (VEC_last): Call it. Change return type to T&. Change all users that used VEC_Os. (VEC_index_1): New template function. (VEC_index): Call it. Return a T& instead of a T*. Update all callers that were using VEC_O before. (VEC_iterate_1): New template function. (VEC_iterate): Call it. (VEC_embedded_size_1): New template function. (VEC_embedded_size): Call it. (VEC_embedded_init_1): New template function. (VEC_embedded_init): Call it. (VEC_alloc_1): New template function. (VEC_alloc): Call it. If A is 'stack', call XALLOCAVAR to do the allocation. (VEC_free_1): New template function. (VEC_free): Call it. (VEC_copy_1): New template function. (VEC_copy): Call it. (VEC_space_1): New template function (VEC_space): Call it. (VEC_reserve_1): New template function. (VEC_reserve): Call it. (VEC_reserve_exact_1): New template function. (VEC_reserve_exact): Call it. (VEC_splice_1): New template function. (VEC_splice): Call it. (VEC_safe_splice_1): New template function. (VEC_safe_splice): Call it. (VEC_quick_push_1): New template function. Create two overloads, one accepting T, the other accepting T *. Update all callers where T and T * are ambiguous. (VEC_quick_push): Call it. (VEC_safe_push_1): New template function. Create two overloads, one accepting T, the other accepting T *. Update all callers where T and T * are ambiguous. (VEC_safe_push): Call it. (VEC_pop_1): New template function. (VEC_pop): Call it. (VEC_truncate_1): New template function. (VEC_truncate): Call it. (VEC_safe_grow_1): New template function. (VEC_safe_grow): Call it. (VEC_safe_grow_cleared_1): New template function. (VEC_safe_grow_cleared): Call it. (VEC_replace_1): New template function. (VEC_replace): Call it. Always accept T instead of T*. Update all callers that used VEC_Os. (VEC_quick_insert_1): New template function. (VEC_quick_insert): Call it. (VEC_safe_insert_1): New template function. (VEC_safe_insert): Call it. (VEC_ordered_remove_1): New template function. (VEC_ordered_remove): Call it. (VEC_unordered_remove_1): New template function. (VEC_unordered_remove): Call it. (VEC_block_remove_1): New template function. (VEC_block_remove): Call it. (VEC_lower_bound_1): New template function. (VEC_lower_bound): Call it. (VEC_OP): Remove. (DEF_VEC_FUNC_P): Remove. (DEF_VEC_ALLOC_FUNC_P): Remove. (DEF_VEC_NONALLOC_FUNCS_P): Remove. (DEF_VEC_FUNC_O): Remove. (DEF_VEC_ALLOC_FUNC_O): Remove. (DEF_VEC_NONALLOC_FUNCS_O): Remove. (DEF_VEC_ALLOC_FUNC_I): Remove. (DEF_VEC_NONALLOC_FUNCS_I): Remove. (DEF_VEC_ALLOC_FUNC_P_STACK): Remove. (DEF_VEC_ALLOC_FUNC_O_STACK): Remove. (DEF_VEC_ALLOC_FUNC_I_STACK): Remove. (vec_reserve_exact): New template function. * gengtype-lex.l (DEF_VEC_ALLOC_[IOP]/{EOID}): Remove. * gengtype-parse.c (token_names): Remove DEF_VEC_ALLOC_[IOP]. (typedef_name): Emit vec_t<C1> instead of VEC_C1_C2. (def_vec_alloc): Remove. Update all callers. * gengtype.c (filter_type_name): New. (output_mangled_typename): Call it. (write_func_for_structure): Likewise. (write_types): Likewise. (write_root): Likewise. (write_typed_alloc_def): Likewise. (note_def_vec): Emit vec_t<TYPE_NAME> instead of VEC_TYPE_NAME_base. (note_def_vec_alloc): Remove. * gengtype.h (note_def_vec_alloc): Remove. (DEFVEC_ALLOC): Remove token code. * df-scan.c (df_bb_verify): Remove call to df_free_collection_rec inside the insn traversal loop. * gimplify.c (gimplify_compound_lval): Rename STACK to EXPR_STACK. * ipa-inline.c (inline_small_functions): Rename HEAP to EDGE_HEAP. * reg-stack.c (stack): Rename to STACK_PTR. Update all users. * tree-vrp.c (stack): Rename to EQUIV_STACK. Update all users. * config/bfin/bfin.c (hwloop_optimize): Update some calls to VEC_* for vectors of non-pointers. * config/c6x/c6x.c (try_rename_operands): Likewise. (reshuffle_units): Likewise. * config/mips/mips.c (mips_multi_start): Likewise. (mips_multi_add): Likewise. (mips_multi_copy_insn): Likewise. (mips_multi_set_operand): Likewise. * hw-doloop.c (discover_loop): Likewise. (discover_loops): Likewise. (reorg_loops): Likewise. 2012-08-14 Diego Novillo <dnovillo@google.com> Merge from cxx-conversion branch. C++ support in gengtype. * coretypes.h (gt_pointer_operator): Move from ... * ggc.h: ... here. * doc/gty.texi: Document support for C++ templates and user-provided markers. * gcc/gengtype-lex.l: Update copyright year. Remove support for recognizing DEF_VEC_O, DEF_VEC_P and DEFVEC_I. * gengtype-parse.c: Update copyright year. (token_names): Remove DEF_VEC_O, DEF_VEC_P and DEF_VEC_I. (require_template_declaration): New. (typedef_name): Call it. (type): Replace IS_UNION with KIND. Replace all users. (def_vec): Remove. Update all users. * gengtype-state.c (type_lineloc): Handle TYPE_USER_STRUCT. (write_state_user_struct_type): New. (write_state_type): Call it. (read_state_user_struct_type): New. (read_state_type): Call it. * gengtype.c: Update copyright year. (dump_pair): Move declaration to the top. (dump_type): Likewise. (dump_type_list): Likewise. (dbgprint_count_type_at): Handle TYPE_USER_STRUCT. (create_user_defined_type): New. (resolve_typedef): Call it. (new_structure): Replace argument ISUNION with KIND. Change users to refer to KIND directly. Update all callers. (find_structure): Likewise. (set_gc_used_type): Handle TYPE_USER_STRUCT. (create_file): Update HDR to include new copyright year. (struct walk_type_data): Add field IN_PTR_FIELD. (output_mangled_typename): Handle TYPE_USER_STRUCT. (walk_type): Set D->IN_PTR_FIELD when walking a TYPE_POINTER. Clear it afterwards. Handle TYPE_USER_STRUCT. (write_types_process_field): Handle TYPE_USER_STRUCT. (get_type_specifier): Move earlier in the file. (write_type_decl): New. (write_marker_function_name): New. (write_user_func_for_structure_ptr): New. (write_user_func_for_structure_body): New. (write_user_marking_functions): New. (write_func_for_structure): Call write_marker_function_name and write_type_decl. Do not call walk_type for TYPE_USER_STRUCT. Emit a call to the user function directly. Call write_user_marking_functions on TYPE_USER_STRUCTs. (write_types_local_user_process_field): New. (write_pch_user_walking_for_structure_body): New. (write_pch_user_walking_functions): New. (write_types_local_process_field): Handle TYPE_USER_STRUCT. (write_local_func_for_structure): Do not call walk_type for TYPE_USER_STRUCT. Instead, emit the call to gt_pch_nx directly. Call write_pch_user_walking_functions for TYPE_USER_STRUCTs. (write_root): Handle TYPE_USER_STRUCT. (vec_prefix_type): Remove. Update all users. (note_def_vec): Remove. Update all users. (dump_typekind): Handle TYPE_USER_STRUCT. (dump_type): Initialize SEEN_TYPES, if needed. Handle TYPE_USER_STRUCT. (dump_everything): Do not initialize SEEN_TYPES. * gengtype.h: Update copyright year. (enum typekind): Add TYPE_USER_STRUCT. (union_or_struct_p): Rename from UNION_OR_STRUCT_P. Convert into function. Add an overload taking const_type_p. Update all callers. (new_structure): Change second field to type enum typekind. Update all users. (find_structure): Likewise. (note_def_vec): Remove. (DEFVEC_OP): Remove. (DEFVEC_I): Remove. * ggc-page.c (gt_ggc_mx): Add entry points for marking 'const char *&', 'unsigned char *&' and 'unsigned char&'. * ggc-zone.c (gt_ggc_mx): Add entry points for marking 'const char *&' and 'unsigned char *&'. * stringpool.c (gt_pch_nx): Add entry points for marking 'const char *&', 'unsigned char *&' and 'unsigned char&'. Add an entry point for the overload taking arguments 'unsigned char *', 'gt_pointer_operator' and 'void *'. * vec.h (struct vec_prefix): Remove GTY marker. (struct vec_t): Remove GTY((length)) attribute from field 'vec'. (gt_ggc_mx (vec_t<T> *)): New template function. (gt_pch_nx (vec_t<T> *)): New template function. (gt_pch_nx (vec_t<T *> *, gt_pointer_operator, void *)): New template function. (gt_pch_nx (vec_t<T> *, gt_pointer_operator, void *)): New template function. * basic-block.h (struct edge_def): Mark GTY((user)). Remove all GTY markers from fields. (gt_ggc_mx): Declare. (gt_pch_nx): Declare. * tree-cfg.c (gt_ggc_mx): New. (gt_pch_nx): New. * gengtype-lex.l (USER_GTY): Add pattern for "user". * gengtype-parse.c (option): Handle USER_GTY. (opts_have): New. (type): Call it. If the keyword 'user' is used, do not walk the fields of the structure. * gengtype.h (USER_GTY): Add. * doc/gty.texi: Update. 2012-08-14 Lawrence Crowl <crowl@google.com> Merge cxx-conversion branch. Implement C++ hash table. * hash-table.h: New. Implementation borrowed from libiberty/hashtab.c. * hash-table.c: Likewise. * tree-ssa-tail-merge.c: Include hash-table.h instead of hashtab.h. (static htab_t same_succ_htab): Change type to hash_table; move specification of helper functions from create call to declaration. Change users to invoke member functions. (same_succ_print_traverse): Make extern ssa_.... Change callers. Remove void* casting. (same_succ_hash): Likewise. (same_succ_equal): Likewise. (same_succ_delete): Likewise. * tree-ssa-threadupdate.c: Include hash-table.h. (struct local_info): Rename to ssa_local_info_t to avoid overloading the type name local_info with the variable name local_info. (static htab_t redirection_data): Change type to hash_table. Move specification of helper functions from create call to declaration. Change users to invoke member functions. (redirection_data_hash): Make extern ssa_.... Change callers. Remove void* casting. (redirection_data_eq): Likewise. (fix_duplicate_block_edges): Likewise. (create_duplicates): Likewise. (fixup_template_block): Likewise. (redirect_edges): Likewise. (lookup_redirection_data): Change types associated with the hash table from void* to their actual type. Remove unnecessary casts. * tree-ssa-ccp.c: Include hash-table.h. (typedef gimple_htab): New. Uses hash_table. Replace specific uses of htab_t with gimple_htab. Change users to invoke member functions. Move specification of helper functions from create call to declaration. * tree-ssa-coalesce.c: Include hash-table.h instead of hashtab.h. (hash_ssa_name_by_var): Make extern. Remove void* casting. (eq_ssa_name_by_var): Likewise. (coalesce_ssa_name): Change type of local static htab_t ssa_name_hash to hash_table. Change users to invoke member functions. Move specification of helper functions from create call to declaration. * coverage.c: Include hash-table.h instead of hashtab.h. (static htab_t counts_hash): Change type to hash_table; move specification of helper functions from create call to declaration. Change users to invoke member functions. (htab_counts_entry_hash): Make extern. Rename with coverage_... instead of htab_... Remove void* casting. (htab_counts_entry_eq): Likewise. (htab_counts_entry_del): Likewise. * tree-ssa-pre.c: Include hash-table.h instead of hashtab.h. (static htab_t expression_to_id): Change type to hash_table. Move specification of helper functions from create call to declaration. Change users to invoke member functions. (static htab_t phi_translate_table): Likewise. (pre_expr_eq): Make extern ssa_.... Change callers. Remove void* casting. (pre_expr_hash): Likewise. (expr_pred_trans_hash): Likewise. (expr_pred_trans_eq): Likewise. (alloc_expression_id): Change types associated with the hash table from void* to their actual type. Remove unnecessary casts. (lookup_expression_id): Likewise. (phi_trans_lookup): Likewise. (phi_trans_add): Likewise. * stringpool.c: Rename uses of libcpp typedef hash_table to cpp_hash_table. * Makefile.in: Add hash-table.o to OBJS-libcommon-target. Add $(HASH_TABLE_H). Add new dependences on $(HASH_TABLE_H). 2012-08-14 Lawrence Crowl <crowl@google.com> Merge from cxx-conversion branch. Re-write double_int in C++. * hash-table.h (typedef double_int): Change to struct (POD). (double_int::make): New overloads for int to double-int conversion. (double_int::mask): New. (double_int::max_value): New. (double_int::min_value): New. (double_int::operator ++): New. (double_int::operator --): New. (double_int::operator *=): New. (double_int::operator +=): New. (double_int::operator -=): New. (double_int::to_signed): New. (double_int::to_unsigned): New. (double_int::fits_unsigned): New. (double_int::fits_signed): New. (double_int::fits): New. (double_int::trailing_zeros): New. (double_int::popcount): New. (double_int::multiple_of): New. (double_int::set_bit): New. (double_int::mul_with_sign): New. (double_int::operator * (binary)): New. (double_int::operator + (binary)): New. (double_int::operator - (binary)): New. (double_int::operator - (unary)): New. (double_int::operator ~ (unary)): New. (double_int::operator & (binary)): New. (double_int::operator | (binary)): New. (double_int::operator ^ (binary)): New. (double_int::and_not): New. (double_int::lshift): New. (double_int::rshift): New. (double_int::alshift): New. (double_int::arshift): New. (double_int::llshift): New. (double_int::lrshift): New. (double_int::lrotate): New. (double_int::rrotate): New. (double_int::div): New. (double_int::sdiv): New. (double_int::udiv): New. (double_int::mod): New. (double_int::smod): New. (double_int::umod): New. (double_int::divmod): New. (double_int::sdivmod): New. (double_int::udivmod): New. (double_int::ext): New. (double_int::zext): New. (double_int::sext): New. (double_int::is_zero): New. (double_int::is_one): New. (double_int::is_minus_one): New. (double_int::is_negative): New. (double_int::cmp): New. (double_int::ucmp): New. (double_int::scmp): New. (double_int::ult): New. (double_int::ugt): New. (double_int::slt): New. (double_int::sgt): New. (double_int::max): New. (double_int::smax): New. (double_int::umax): New. (double_int::min): New. (double_int::smin): New. (double_int::umin): New. (double_int::operator ==): New. (double_int::operator !=): New. (shwi_to_double_int): Change implementation to use member function. (double_int_minus_one): Likewise. (double_int_zero): Likewise. (double_int_one): Likewise. (double_int_two): Likewise. (double_int_ten): Likewise. (uhwi_to_double_int): Likewise. (double_int_to_shwi): Likewise. (double_int_to_uhwi): Likewise. (double_int_fits_in_uhwi_p): Likewise. (double_int_fits_in_shwi_p): Likewise. (double_int_fits_in_hwi_p): Likewise. (double_int_mul): Likewise. (double_int_mul_with_sign): Likewise. (double_int_add): Likewise. (double_int_sub): Likewise. (double_int_neg): Likewise. (double_int_div): Likewise. (double_int_sdiv): Likewise. (double_int_udiv): Likewise. (double_int_mod): Likewise. (double_int_smod): Likewise. (double_int_umod): Likewise. (double_int_divmod): Likewise. (double_int_sdivmod): Likewise. (double_int_udivmod): Likewise. (double_int_multiple_of): Likewise. (double_int_setbit): Likewise. (double_int_ctz): Likewise. (double_int_not): Likewise. (double_int_ior): Likewise. (double_int_and): Likewise. (double_int_and_not): Likewise. (double_int_xor): Likewise. (double_int_lshift): Likewise. (double_int_rshift): Likewise. (double_int_lrotate): Likewise. (double_int_rrotate): Likewise. (double_int_cmp): Likewise. (double_int_scmp): Likewise. (double_int_ucmp): Likewise. (double_int_max): Likewise. (double_int_smax): Likewise. (double_int_umax): Likewise. (double_int_min): Likewise. (double_int_smin): Likewise. (double_int_umin): Likewise. (double_int_ext): Likewise. (double_int_sext): Likewise. (double_int_zext): Likewise. (double_int_mask): Likewise. (double_int_max_value): Likewise. (double_int_min_value): Likewise. (double_int_zero_p): Likewise. (double_int_one_p): Likewise. (double_int_minus_one_p): Likewise. (double_int_equal_p): Likewise. (double_int_popcount): Likewise. * hash-table.c (double_int_mask): Reuse implementation for double_int::mask. (double_int_max_value): Likewise. (double_int_min_value): Likewise. (double_int_ext): Likewise. (double_int_zext): Likewise. (double_int_sext): Likewise. (double_int_mul_with_sign): Likewise. (double_int_divmod): Likewise. (double_int_sdivmod): Likewise. (double_int_udivmod): Likewise. (double_int_div): Likewise. (double_int_sdiv): Likewise. (double_int_udiv): Likewise. (double_int_mod): Likewise. (double_int_smod): Likewise. (double_int_umod): Likewise. (double_int_multiple_of): Likewise. (double_int_lshift): Likewise. (double_int_rshift): Likewise. (double_int_lrotate): Likewise. (double_int_rrotate): Likewise. (double_int_cmp): Likewise. (double_int_ucmp): Likewise. (double_int_scmp): Likewise. (double_int_max): Likewise. (double_int_smax): Likewise. (double_int_umax): Likewise. (double_int_min): Likewise. (double_int_smin): Likewise. (double_int_umin): Likewise. (double_int_min): Likewise. (double_int_min): Likewise. (double_int_min): Likewise. (double_int_min): Likewise. (double_int_min): Likewise. (double_int_min): Likewise. (double_int::alshift): New. (double_int::arshift): New. (double_int::llshift): New. (double_int::lrshift): New. (double_int::ult): New. (double_int::ugt): New. (double_int::slt): New. (double_int::sgt): New. (double_int_setbit): Reuse implementation for double_int::set_bit, which avoids a name conflict with a macro. (double_int_double_int_ctz): Reuse implementation for double_int::trailing_zeros. (double_int_fits_in_shwi_p): Reuse implementation for double_int::fits_signed. (double_int_fits_in_hwi_p): Reuse implementation for double_int::fits. (double_int_mul): Reuse implementation for binary double_int::operator *. (double_int_add): Likewise. (double_int_sub): Likewise. (double_int_neg): Reuse implementation for unary double_int::operator -. (double_int_max_value): Likewise. * fixed-value.c: Change to use member functions introduced above. 2012-08-14 Lawrence Crowl <crowl@google.com> Merge cxx-conversion branch. Support tree macro calling from gdb. * tree.h (tree_check): New. (TREE_CHECK): Use inline function above instead of __extension__. (tree_not_check): New. (TREE_NOT_CHECK): Use inline function above instead of __extension__. (tree_check2): New. (TREE_CHECK2): Use inline function above instead of __extension__. (tree_not_check2): New. (TREE_NOT_CHECK2): Use inline function above instead of __extension__. (tree_check3): New. (TREE_CHECK3): Use inline function above instead of __extension__. (tree_not_check3): New. (TREE_NOT_CHECK3): Use inline function above instead of __extension__. (tree_check4): New. (TREE_CHECK4): Use inline function above instead of __extension__. (tree_not_check4): New. (TREE_NOT_CHECK4): Use inline function above instead of __extension__. (tree_check5): New. (TREE_CHECK5): Use inline function above instead of __extension__. (tree_not_check5): New. (TREE_NOT_CHECK5): Use inline function above instead of __extension__. (contains_struct_check): New. (CONTAINS_STRUCT_CHECK): Use inline function above instead of __extension__. (tree_class_check): New. (TREE_CLASS_CHECK): Use inline function above instead of __extension__. (tree_range_check): New. (TREE_RANGE_CHECK): Use inline function above instead of __extension__. (omp_clause_subcode_check): New. (OMP_CLAUSE_SUBCODE_CHECK): Use inline function above instead of __extension__. (omp_clause_range_check): New. (OMP_CLAUSE_RANGE_CHECK): Use inline function above instead of __extension__. (expr_check): New. (EXPR_CHECK): Use inline function above instead of __extension__. (non_type_check): New. (NON_TYPE_CHECK): Use inline function above instead of __extension__. (tree_vec_elt_check): New. (TREE_VEC_ELT_CHECK): Use inline function above instead of __extension__. (omp_clause_elt_check): New. (OMP_CLAUSE_ELT_CHECK): Use inline function above instead of __extension__. (tree_operand_check): New. (TREE_OPERAND_CHECK): Use inline function above instead of __extension__. (tree_operand_check_code): New. (TREE_OPERAND_CHECK_CODE): Use inline function above instead of __extension__. (TREE_CHAIN): Simplify implementation. (TREE_TYPE): Simplify implementation. (tree_operand_length): Move for compilation dependences. * gdbinit.in: (macro define __FILE__): New. (macro define __LINE__): New. (skip "tree.h"): New. gcc/cp/ChangeLog 2012-08-14 Diego Novillo <dnovillo@google.com> Merge from cxx-conversion branch. Re-write VEC in C++. * call.c (add_function_candidate): Remove const qualifier from call to VEC_index. 2012-08-14 Diego Novillo <dnovillo@google.com> Merge from cxx-conversion branch. Configury. * go-c.h: Remove all handlers of ENABLE_BUILD_WITH_CXX. * go-gcc.cc: Likewise. * go-system.h: Likewise. From-SVN: r190402
672 lines
18 KiB
C
672 lines
18 KiB
C
/* Code to analyze doloop loops in order for targets to perform late
|
|
optimizations converting doloops to other forms of hardware loops.
|
|
Copyright (C) 2011 Free Software Foundation, Inc.
|
|
|
|
This file is part of GCC.
|
|
|
|
GCC is free software; you can redistribute it and/or modify it under
|
|
the terms of the GNU General Public License as published by the Free
|
|
Software Foundation; either version 3, or (at your option) any later
|
|
version.
|
|
|
|
GCC is distributed in the hope that it will be useful, but WITHOUT ANY
|
|
WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
|
for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with GCC; see the file COPYING3. If not see
|
|
<http://www.gnu.org/licenses/>. */
|
|
|
|
#include "config.h"
|
|
#include "system.h"
|
|
#include "coretypes.h"
|
|
#include "tm.h"
|
|
#include "rtl.h"
|
|
#include "flags.h"
|
|
#include "expr.h"
|
|
#include "hard-reg-set.h"
|
|
#include "regs.h"
|
|
#include "basic-block.h"
|
|
#include "tm_p.h"
|
|
#include "df.h"
|
|
#include "cfgloop.h"
|
|
#include "recog.h"
|
|
#include "target.h"
|
|
#include "hw-doloop.h"
|
|
#include "dumpfile.h"
|
|
|
|
#ifdef HAVE_doloop_end
|
|
|
|
/* Dump information collected in LOOPS. */
|
|
static void
|
|
dump_hwloops (hwloop_info loops)
|
|
{
|
|
hwloop_info loop;
|
|
|
|
for (loop = loops; loop; loop = loop->next)
|
|
{
|
|
hwloop_info i;
|
|
basic_block b;
|
|
unsigned ix;
|
|
|
|
fprintf (dump_file, ";; loop %d: ", loop->loop_no);
|
|
if (loop->bad)
|
|
fprintf (dump_file, "(bad) ");
|
|
fprintf (dump_file, "{head:%d, depth:%d, reg:%u}",
|
|
loop->head == NULL ? -1 : loop->head->index,
|
|
loop->depth, REGNO (loop->iter_reg));
|
|
|
|
fprintf (dump_file, " blocks: [ ");
|
|
for (ix = 0; VEC_iterate (basic_block, loop->blocks, ix, b); ix++)
|
|
fprintf (dump_file, "%d ", b->index);
|
|
fprintf (dump_file, "] ");
|
|
|
|
fprintf (dump_file, " inner loops: [ ");
|
|
for (ix = 0; VEC_iterate (hwloop_info, loop->loops, ix, i); ix++)
|
|
fprintf (dump_file, "%d ", i->loop_no);
|
|
fprintf (dump_file, "]\n");
|
|
}
|
|
fprintf (dump_file, "\n");
|
|
}
|
|
|
|
/* Return true if BB is part of LOOP. */
|
|
static bool
|
|
bb_in_loop_p (hwloop_info loop, basic_block bb)
|
|
{
|
|
return bitmap_bit_p (loop->block_bitmap, bb->index);
|
|
}
|
|
|
|
/* Scan the blocks of LOOP (and its inferiors), and record things such as
|
|
hard registers set, jumps out of and within the loop. */
|
|
static void
|
|
scan_loop (hwloop_info loop)
|
|
{
|
|
unsigned ix;
|
|
basic_block bb;
|
|
|
|
if (loop->bad)
|
|
return;
|
|
|
|
if (REGNO_REG_SET_P (df_get_live_in (loop->successor),
|
|
REGNO (loop->iter_reg)))
|
|
loop->iter_reg_used_outside = true;
|
|
|
|
for (ix = 0; VEC_iterate (basic_block, loop->blocks, ix, bb); ix++)
|
|
{
|
|
rtx insn;
|
|
edge e;
|
|
edge_iterator ei;
|
|
|
|
if (bb != loop->tail)
|
|
FOR_EACH_EDGE (e, ei, bb->succs)
|
|
{
|
|
if (bb_in_loop_p (loop, e->dest))
|
|
{
|
|
if (!(e->flags & EDGE_FALLTHRU))
|
|
loop->jumps_within = true;
|
|
}
|
|
else
|
|
{
|
|
loop->jumps_outof = true;
|
|
if (!loop->bad)
|
|
gcc_assert (!REGNO_REG_SET_P (df_get_live_in (e->dest),
|
|
REGNO (loop->iter_reg)));
|
|
}
|
|
}
|
|
|
|
for (insn = BB_HEAD (bb);
|
|
insn != NEXT_INSN (BB_END (bb));
|
|
insn = NEXT_INSN (insn))
|
|
{
|
|
df_ref *def_rec;
|
|
HARD_REG_SET set_this_insn;
|
|
|
|
if (!NONDEBUG_INSN_P (insn))
|
|
continue;
|
|
|
|
if (recog_memoized (insn) < 0
|
|
&& (GET_CODE (PATTERN (insn)) == ASM_INPUT
|
|
|| asm_noperands (PATTERN (insn)) >= 0))
|
|
loop->has_asm = true;
|
|
|
|
CLEAR_HARD_REG_SET (set_this_insn);
|
|
for (def_rec = DF_INSN_DEFS (insn); *def_rec; def_rec++)
|
|
{
|
|
rtx dreg = DF_REF_REG (*def_rec);
|
|
|
|
if (!REG_P (dreg))
|
|
continue;
|
|
|
|
add_to_hard_reg_set (&set_this_insn, GET_MODE (dreg),
|
|
REGNO (dreg));
|
|
}
|
|
|
|
if (insn == loop->loop_end)
|
|
CLEAR_HARD_REG_BIT (set_this_insn, REGNO (loop->iter_reg));
|
|
else if (reg_mentioned_p (loop->iter_reg, PATTERN (insn)))
|
|
loop->iter_reg_used = true;
|
|
IOR_HARD_REG_SET (loop->regs_set_in_loop, set_this_insn);
|
|
}
|
|
}
|
|
}
|
|
|
|
/* Compute the incoming_dest and incoming_src members of LOOP by
|
|
identifying the edges that jump into the loop. If there is more
|
|
than one block that jumps into the loop, incoming_src will be set
|
|
to NULL; likewise, if there is more than one block in the loop that
|
|
is the destination of an incoming edge, incoming_dest will be NULL.
|
|
|
|
Return true if either of these two fields is nonnull, false
|
|
otherwise. */
|
|
static bool
|
|
process_incoming_edges (hwloop_info loop)
|
|
{
|
|
edge e;
|
|
edge_iterator ei;
|
|
bool first = true;
|
|
|
|
FOR_EACH_EDGE (e, ei, loop->incoming)
|
|
{
|
|
if (first)
|
|
{
|
|
loop->incoming_src = e->src;
|
|
loop->incoming_dest = e->dest;
|
|
first = false;
|
|
}
|
|
else
|
|
{
|
|
if (e->dest != loop->incoming_dest)
|
|
loop->incoming_dest = NULL;
|
|
if (e->src != loop->incoming_src)
|
|
loop->incoming_src = NULL;
|
|
}
|
|
}
|
|
if (loop->incoming_src == NULL && loop->incoming_dest == NULL)
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
/* Try to identify a forwarder block that jump into LOOP, and add it to
|
|
the set of blocks in the loop, updating the vector of incoming blocks as
|
|
well. This transformation gives a second chance to loops we couldn't
|
|
otherwise handle by increasing the chance that we'll end up with one
|
|
incoming_src block.
|
|
Return true if we made a change, false otherwise. */
|
|
static bool
|
|
add_forwarder_blocks (hwloop_info loop)
|
|
{
|
|
edge e;
|
|
edge_iterator ei;
|
|
|
|
FOR_EACH_EDGE (e, ei, loop->incoming)
|
|
{
|
|
if (forwarder_block_p (e->src))
|
|
{
|
|
edge e2;
|
|
edge_iterator ei2;
|
|
|
|
if (dump_file)
|
|
fprintf (dump_file,
|
|
";; Adding forwarder block %d to loop %d and retrying\n",
|
|
e->src->index, loop->loop_no);
|
|
VEC_safe_push (basic_block, heap, loop->blocks, e->src);
|
|
bitmap_set_bit (loop->block_bitmap, e->src->index);
|
|
FOR_EACH_EDGE (e2, ei2, e->src->preds)
|
|
VEC_safe_push (edge, gc, loop->incoming, e2);
|
|
VEC_unordered_remove (edge, loop->incoming, ei.index);
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/* Called from reorg_loops when a potential loop end is found. LOOP is
|
|
a newly set up structure describing the loop, it is this function's
|
|
responsibility to fill most of it. TAIL_BB and TAIL_INSN point to the
|
|
loop_end insn and its enclosing basic block. REG is the loop counter
|
|
register.
|
|
For our purposes, a loop is defined by the set of blocks reachable from
|
|
the loop head in which the loop counter register is live. This matches
|
|
the expected use; targets that call into this code usually replace the
|
|
loop counter with a different special register. */
|
|
static void
|
|
discover_loop (hwloop_info loop, basic_block tail_bb, rtx tail_insn, rtx reg)
|
|
{
|
|
bool found_tail;
|
|
unsigned dwork = 0;
|
|
basic_block bb;
|
|
VEC (basic_block,heap) *works;
|
|
|
|
loop->tail = tail_bb;
|
|
loop->loop_end = tail_insn;
|
|
loop->iter_reg = reg;
|
|
loop->incoming = VEC_alloc (edge, gc, 2);
|
|
loop->start_label = JUMP_LABEL (tail_insn);
|
|
|
|
if (EDGE_COUNT (tail_bb->succs) != 2)
|
|
{
|
|
loop->bad = true;
|
|
return;
|
|
}
|
|
loop->head = BRANCH_EDGE (tail_bb)->dest;
|
|
loop->successor = FALLTHRU_EDGE (tail_bb)->dest;
|
|
|
|
works = VEC_alloc (basic_block, heap, 20);
|
|
VEC_safe_push (basic_block, heap, works, loop->head);
|
|
|
|
found_tail = false;
|
|
for (dwork = 0; VEC_iterate (basic_block, works, dwork, bb); dwork++)
|
|
{
|
|
edge e;
|
|
edge_iterator ei;
|
|
if (bb == EXIT_BLOCK_PTR)
|
|
{
|
|
/* We've reached the exit block. The loop must be bad. */
|
|
if (dump_file)
|
|
fprintf (dump_file,
|
|
";; Loop is bad - reached exit block while scanning\n");
|
|
loop->bad = true;
|
|
break;
|
|
}
|
|
|
|
if (bitmap_bit_p (loop->block_bitmap, bb->index))
|
|
continue;
|
|
|
|
/* We've not seen this block before. Add it to the loop's
|
|
list and then add each successor to the work list. */
|
|
|
|
VEC_safe_push (basic_block, heap, loop->blocks, bb);
|
|
bitmap_set_bit (loop->block_bitmap, bb->index);
|
|
|
|
if (bb == tail_bb)
|
|
found_tail = true;
|
|
else
|
|
{
|
|
FOR_EACH_EDGE (e, ei, bb->succs)
|
|
{
|
|
basic_block succ = EDGE_SUCC (bb, ei.index)->dest;
|
|
if (REGNO_REG_SET_P (df_get_live_in (succ),
|
|
REGNO (loop->iter_reg)))
|
|
VEC_safe_push (basic_block, heap, works, succ);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!found_tail)
|
|
loop->bad = true;
|
|
|
|
/* Find the predecessor, and make sure nothing else jumps into this loop. */
|
|
if (!loop->bad)
|
|
{
|
|
FOR_EACH_VEC_ELT (basic_block, loop->blocks, dwork, bb)
|
|
{
|
|
edge e;
|
|
edge_iterator ei;
|
|
FOR_EACH_EDGE (e, ei, bb->preds)
|
|
{
|
|
basic_block pred = e->src;
|
|
|
|
if (!bb_in_loop_p (loop, pred))
|
|
{
|
|
if (dump_file)
|
|
fprintf (dump_file, ";; Loop %d: incoming edge %d -> %d\n",
|
|
loop->loop_no, pred->index,
|
|
e->dest->index);
|
|
VEC_safe_push (edge, gc, loop->incoming, e);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!process_incoming_edges (loop))
|
|
{
|
|
if (dump_file)
|
|
fprintf (dump_file,
|
|
";; retrying loop %d with forwarder blocks\n",
|
|
loop->loop_no);
|
|
if (!add_forwarder_blocks (loop))
|
|
{
|
|
if (dump_file)
|
|
fprintf (dump_file, ";; No forwarder blocks found\n");
|
|
loop->bad = true;
|
|
}
|
|
else if (!process_incoming_edges (loop))
|
|
{
|
|
if (dump_file)
|
|
fprintf (dump_file,
|
|
";; can't find suitable entry for loop %d\n",
|
|
loop->loop_no);
|
|
}
|
|
}
|
|
}
|
|
|
|
VEC_free (basic_block, heap, works);
|
|
}
|
|
|
|
/* Analyze the structure of the loops in the current function. Use
|
|
LOOP_STACK for bitmap allocations. Returns all the valid candidates for
|
|
hardware loops found in this function. HOOKS is the argument
|
|
passed to reorg_loops, used here to find the iteration registers
|
|
from a loop_end pattern. */
|
|
static hwloop_info
|
|
discover_loops (bitmap_obstack *loop_stack, struct hw_doloop_hooks *hooks)
|
|
{
|
|
hwloop_info loops = NULL;
|
|
hwloop_info loop;
|
|
basic_block bb;
|
|
int nloops = 0;
|
|
|
|
/* Find all the possible loop tails. This means searching for every
|
|
loop_end instruction. For each one found, create a hwloop_info
|
|
structure and add the head block to the work list. */
|
|
FOR_EACH_BB (bb)
|
|
{
|
|
rtx tail = BB_END (bb);
|
|
rtx insn, reg;
|
|
|
|
while (tail && GET_CODE (tail) == NOTE && tail != BB_HEAD (bb))
|
|
tail = PREV_INSN (tail);
|
|
|
|
if (tail == NULL_RTX)
|
|
continue;
|
|
|
|
if (!JUMP_P (tail))
|
|
continue;
|
|
reg = hooks->end_pattern_reg (tail);
|
|
if (reg == NULL_RTX)
|
|
continue;
|
|
|
|
/* A possible loop end */
|
|
|
|
/* There's a degenerate case we can handle - an empty loop consisting
|
|
of only a back branch. Handle that by deleting the branch. */
|
|
insn = JUMP_LABEL (tail);
|
|
while (insn && !NONDEBUG_INSN_P (insn))
|
|
insn = NEXT_INSN (insn);
|
|
if (insn == tail)
|
|
{
|
|
basic_block succ = FALLTHRU_EDGE (bb)->dest;
|
|
if (dump_file)
|
|
{
|
|
fprintf (dump_file, ";; degenerate loop ending at\n");
|
|
print_rtl_single (dump_file, tail);
|
|
}
|
|
if (!REGNO_REG_SET_P (df_get_live_in (succ), REGNO (reg)))
|
|
{
|
|
if (dump_file)
|
|
fprintf (dump_file, ";; deleting it\n");
|
|
delete_insn_and_edges (tail);
|
|
continue;
|
|
}
|
|
}
|
|
|
|
loop = XCNEW (struct hwloop_info_d);
|
|
loop->next = loops;
|
|
loops = loop;
|
|
loop->loop_no = nloops++;
|
|
loop->blocks = VEC_alloc (basic_block, heap, 20);
|
|
loop->block_bitmap = BITMAP_ALLOC (loop_stack);
|
|
|
|
if (dump_file)
|
|
{
|
|
fprintf (dump_file, ";; potential loop %d ending at\n",
|
|
loop->loop_no);
|
|
print_rtl_single (dump_file, tail);
|
|
}
|
|
|
|
discover_loop (loop, bb, tail, reg);
|
|
}
|
|
|
|
/* Compute loop nestings. Given two loops A and B, either the sets
|
|
of their blocks don't intersect at all, or one is the subset of
|
|
the other, or the blocks don't form a good nesting structure. */
|
|
for (loop = loops; loop; loop = loop->next)
|
|
{
|
|
hwloop_info other;
|
|
|
|
if (loop->bad)
|
|
continue;
|
|
|
|
for (other = loops; other; other = other->next)
|
|
{
|
|
if (other->bad)
|
|
continue;
|
|
|
|
if (!bitmap_intersect_p (other->block_bitmap, loop->block_bitmap))
|
|
continue;
|
|
if (!bitmap_intersect_compl_p (other->block_bitmap,
|
|
loop->block_bitmap))
|
|
VEC_safe_push (hwloop_info, heap, loop->loops, other);
|
|
else if (!bitmap_intersect_compl_p (loop->block_bitmap,
|
|
other->block_bitmap))
|
|
VEC_safe_push (hwloop_info, heap, other->loops, loop);
|
|
else
|
|
{
|
|
if (dump_file)
|
|
fprintf (dump_file,
|
|
";; can't find suitable nesting for loops %d and %d\n",
|
|
loop->loop_no, other->loop_no);
|
|
loop->bad = other->bad = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (dump_file)
|
|
dump_hwloops (loops);
|
|
|
|
return loops;
|
|
}
|
|
|
|
/* Free up the loop structures in LOOPS. */
|
|
static void
|
|
free_loops (hwloop_info loops)
|
|
{
|
|
while (loops)
|
|
{
|
|
hwloop_info loop = loops;
|
|
loops = loop->next;
|
|
VEC_free (hwloop_info, heap, loop->loops);
|
|
VEC_free (basic_block, heap, loop->blocks);
|
|
BITMAP_FREE (loop->block_bitmap);
|
|
XDELETE (loop);
|
|
}
|
|
}
|
|
|
|
#define BB_AUX_INDEX(BB) ((intptr_t) (BB)->aux)
|
|
|
|
/* Initialize the aux fields to give ascending indices to basic blocks. */
|
|
static void
|
|
set_bb_indices (void)
|
|
{
|
|
basic_block bb;
|
|
intptr_t index;
|
|
|
|
index = 0;
|
|
FOR_EACH_BB (bb)
|
|
bb->aux = (void *) index++;
|
|
}
|
|
|
|
/* The taken-branch edge from the loop end can actually go forward.
|
|
If the target's hardware loop support requires that the loop end be
|
|
after the loop start, try to reorder a loop's basic blocks when we
|
|
find such a case.
|
|
This is not very aggressive; it only moves at most one block. It
|
|
does not introduce new branches into loops; it may remove them, or
|
|
it may switch fallthru/jump edges. */
|
|
static void
|
|
reorder_loops (hwloop_info loops)
|
|
{
|
|
basic_block bb;
|
|
hwloop_info loop;
|
|
|
|
cfg_layout_initialize (0);
|
|
|
|
set_bb_indices ();
|
|
|
|
for (loop = loops; loop; loop = loop->next)
|
|
{
|
|
edge e;
|
|
edge_iterator ei;
|
|
|
|
if (loop->bad)
|
|
continue;
|
|
|
|
if (BB_AUX_INDEX (loop->head) <= BB_AUX_INDEX (loop->tail))
|
|
continue;
|
|
|
|
FOR_EACH_EDGE (e, ei, loop->head->succs)
|
|
{
|
|
if (bitmap_bit_p (loop->block_bitmap, e->dest->index)
|
|
&& BB_AUX_INDEX (e->dest) < BB_AUX_INDEX (loop->tail))
|
|
{
|
|
basic_block start_bb = e->dest;
|
|
basic_block start_prev_bb = start_bb->prev_bb;
|
|
|
|
if (dump_file)
|
|
fprintf (dump_file, ";; Moving block %d before block %d\n",
|
|
loop->head->index, start_bb->index);
|
|
loop->head->prev_bb->next_bb = loop->head->next_bb;
|
|
loop->head->next_bb->prev_bb = loop->head->prev_bb;
|
|
|
|
loop->head->prev_bb = start_prev_bb;
|
|
loop->head->next_bb = start_bb;
|
|
start_prev_bb->next_bb = start_bb->prev_bb = loop->head;
|
|
|
|
set_bb_indices ();
|
|
break;
|
|
}
|
|
}
|
|
loops = loops->next;
|
|
}
|
|
|
|
FOR_EACH_BB (bb)
|
|
{
|
|
if (bb->next_bb != EXIT_BLOCK_PTR)
|
|
bb->aux = bb->next_bb;
|
|
else
|
|
bb->aux = NULL;
|
|
}
|
|
cfg_layout_finalize ();
|
|
clear_aux_for_blocks ();
|
|
df_analyze ();
|
|
}
|
|
|
|
/* Call the OPT function for LOOP and all of its sub-loops. This is
|
|
done in a depth-first search; innermost loops are visited first.
|
|
OPTIMIZE and FAIL are the functions passed to reorg_loops by the
|
|
target's reorg pass. */
|
|
static void
|
|
optimize_loop (hwloop_info loop, struct hw_doloop_hooks *hooks)
|
|
{
|
|
int ix;
|
|
hwloop_info inner;
|
|
int inner_depth = 0;
|
|
|
|
if (loop->visited)
|
|
return;
|
|
|
|
loop->visited = 1;
|
|
|
|
if (loop->bad)
|
|
{
|
|
if (dump_file)
|
|
fprintf (dump_file, ";; loop %d bad when found\n", loop->loop_no);
|
|
goto bad_loop;
|
|
}
|
|
|
|
/* Every loop contains in its list of inner loops every loop nested inside
|
|
it, even if there are intermediate loops. This works because we're doing
|
|
a depth-first search here and never visit a loop more than once.
|
|
Recursion depth is effectively limited by the number of available
|
|
hardware registers. */
|
|
for (ix = 0; VEC_iterate (hwloop_info, loop->loops, ix, inner); ix++)
|
|
{
|
|
optimize_loop (inner, hooks);
|
|
|
|
if (!inner->bad && inner_depth < inner->depth)
|
|
inner_depth = inner->depth;
|
|
/* The set of registers may be changed while optimizing the inner
|
|
loop. */
|
|
IOR_HARD_REG_SET (loop->regs_set_in_loop, inner->regs_set_in_loop);
|
|
}
|
|
|
|
loop->depth = inner_depth + 1;
|
|
|
|
if (hooks->opt (loop))
|
|
return;
|
|
|
|
bad_loop:
|
|
if (dump_file)
|
|
fprintf (dump_file, ";; loop %d is bad\n", loop->loop_no);
|
|
|
|
loop->bad = true;
|
|
hooks->fail (loop);
|
|
}
|
|
|
|
/* This function can be used from a port's machine_dependent_reorg to
|
|
find and analyze loops that end in loop_end instructions. It uses
|
|
a set of function pointers in HOOKS to call back into the
|
|
target-specific functions to perform the actual machine-specific
|
|
transformations.
|
|
|
|
Such transformations typically involve additional set-up
|
|
instructions before the loop, to define loop bounds or set up a
|
|
special loop counter register.
|
|
|
|
DO_REORDER should be set to true if we should try to use the
|
|
reorder_loops function to ensure the loop end occurs after the loop
|
|
start. This is for use by targets where the loop hardware requires
|
|
this condition.
|
|
|
|
HOOKS is used to pass in target specific hooks; see
|
|
hw-doloop.h. */
|
|
void
|
|
reorg_loops (bool do_reorder, struct hw_doloop_hooks *hooks)
|
|
{
|
|
hwloop_info loops = NULL;
|
|
hwloop_info loop;
|
|
bitmap_obstack loop_stack;
|
|
|
|
df_live_add_problem ();
|
|
df_live_set_all_dirty ();
|
|
df_analyze ();
|
|
|
|
bitmap_obstack_initialize (&loop_stack);
|
|
|
|
if (dump_file)
|
|
fprintf (dump_file, ";; Find loops, first pass\n\n");
|
|
|
|
loops = discover_loops (&loop_stack, hooks);
|
|
|
|
if (do_reorder)
|
|
{
|
|
reorder_loops (loops);
|
|
free_loops (loops);
|
|
|
|
if (dump_file)
|
|
fprintf (dump_file, ";; Find loops, second pass\n\n");
|
|
|
|
loops = discover_loops (&loop_stack, hooks);
|
|
}
|
|
|
|
for (loop = loops; loop; loop = loop->next)
|
|
scan_loop (loop);
|
|
|
|
/* Now apply the optimizations. */
|
|
for (loop = loops; loop; loop = loop->next)
|
|
optimize_loop (loop, hooks);
|
|
|
|
if (dump_file)
|
|
{
|
|
fprintf (dump_file, ";; After hardware loops optimization:\n\n");
|
|
dump_hwloops (loops);
|
|
}
|
|
|
|
free_loops (loops);
|
|
|
|
if (dump_file)
|
|
print_rtl (dump_file, get_insns ());
|
|
}
|
|
#endif
|