From e53b6e564aab615703ff2f9e8406a3953f0a3785 Mon Sep 17 00:00:00 2001 From: Martin Liska Date: Fri, 14 Jan 2022 16:57:02 +0100 Subject: Change references of .c files to .cc files ChangeLog: * MAINTAINERS: Rename .c names to .cc. contrib/ChangeLog: * filter-clang-warnings.py: Rename .c names to .cc. * gcc_update: Likewise. * paranoia.cc: Likewise. contrib/header-tools/ChangeLog: * README: Rename .c names to .cc. gcc/ChangeLog: * Makefile.in: Rename .c names to .cc. * alias.h: Likewise. * asan.cc: Likewise. * auto-profile.h: Likewise. * basic-block.h (struct basic_block_d): Likewise. * btfout.cc: Likewise. * builtins.cc (expand_builtin_longjmp): Likewise. (validate_arg): Likewise. (access_ref::offset_bounded): Likewise. * caller-save.cc (reg_restore_code): Likewise. (setup_save_areas): Likewise. * calls.cc (initialize_argument_information): Likewise. (expand_call): Likewise. (emit_library_call_value_1): Likewise. * cfg-flags.def (RTL): Likewise. (SIBCALL): Likewise. (CAN_FALLTHRU): Likewise. * cfganal.cc (post_order_compute): Likewise. * cfgcleanup.cc (try_simplify_condjump): Likewise. (merge_blocks_move_predecessor_nojumps): Likewise. (merge_blocks_move_successor_nojumps): Likewise. (merge_blocks_move): Likewise. (old_insns_match_p): Likewise. (try_crossjump_bb): Likewise. * cfgexpand.cc (expand_gimple_stmt): Likewise. * cfghooks.cc (split_block_before_cond_jump): Likewise. (profile_record_check_consistency): Likewise. * cfghooks.h: Likewise. * cfgrtl.cc (pass_free_cfg::execute): Likewise. (rtl_can_merge_blocks): Likewise. (try_redirect_by_replacing_jump): Likewise. (make_pass_outof_cfg_layout_mode): Likewise. (cfg_layout_can_merge_blocks_p): Likewise. * cgraph.cc (release_function_body): Likewise. (cgraph_node::get_fun): Likewise. * cgraph.h (struct cgraph_node): Likewise. (asmname_hasher::equal): Likewise. (cgraph_inline_failed_type): Likewise. (thunk_adjust): Likewise. (dump_callgraph_transformation): Likewise. (record_references_in_initializer): Likewise. (ipa_discover_variable_flags): Likewise. * cgraphclones.cc (GTY): Likewise. * cgraphunit.cc (symbol_table::finalize_compilation_unit): Likewise. * collect-utils.h (GCC_COLLECT_UTILS_H): Likewise. * collect2-aix.h (GCC_COLLECT2_AIX_H): Likewise. * collect2.cc (maybe_run_lto_and_relink): Likewise. * combine-stack-adj.cc: Likewise. * combine.cc (setup_incoming_promotions): Likewise. (combine_simplify_rtx): Likewise. (count_rtxs): Likewise. * common.opt: Likewise. * common/config/aarch64/aarch64-common.cc: Likewise. * common/config/arm/arm-common.cc (arm_asm_auto_mfpu): Likewise. * common/config/avr/avr-common.cc: Likewise. * common/config/i386/i386-isas.h (struct _isa_names_table): Likewise. * conditions.h: Likewise. * config.gcc: Likewise. * config/aarch64/aarch64-builtins.cc (aarch64_resolve_overloaded_memtag): Likewise. * config/aarch64/aarch64-protos.h (aarch64_classify_address): Likewise. (aarch64_get_extension_string_for_isa_flags): Likewise. * config/aarch64/aarch64-sve-builtins.cc (function_builder::add_function): Likewise. * config/aarch64/aarch64.cc (aarch64_regmode_natural_size): Likewise. (aarch64_sched_first_cycle_multipass_dfa_lookahead): Likewise. (aarch64_option_valid_attribute_p): Likewise. (aarch64_short_vector_p): Likewise. (aarch64_float_const_representable_p): Likewise. * config/aarch64/aarch64.h (DBX_REGISTER_NUMBER): Likewise. (ASM_OUTPUT_POOL_EPILOGUE): Likewise. (GTY): Likewise. * config/aarch64/cortex-a57-fma-steering.cc: Likewise. * config/aarch64/driver-aarch64.cc (contains_core_p): Likewise. * config/aarch64/t-aarch64: Likewise. * config/aarch64/x-aarch64: Likewise. * config/aarch64/x-darwin: Likewise. * config/alpha/alpha-protos.h: Likewise. * config/alpha/alpha.cc (alpha_scalar_mode_supported_p): Likewise. * config/alpha/alpha.h (LONG_DOUBLE_TYPE_SIZE): Likewise. (enum reg_class): Likewise. * config/alpha/alpha.md: Likewise. * config/alpha/driver-alpha.cc (AMASK_LOCKPFTCHOK): Likewise. * config/alpha/x-alpha: Likewise. * config/arc/arc-protos.h (arc_eh_uses): Likewise. * config/arc/arc.cc (ARC_OPT): Likewise. (arc_ccfsm_advance): Likewise. (arc_arg_partial_bytes): Likewise. (conditionalize_nonjump): Likewise. * config/arc/arc.md: Likewise. * config/arc/builtins.def: Likewise. * config/arc/t-arc: Likewise. * config/arm/arm-c.cc (arm_resolve_overloaded_builtin): Likewise. (arm_pragma_target_parse): Likewise. * config/arm/arm-protos.h (save_restore_target_globals): Likewise. (arm_cpu_cpp_builtins): Likewise. * config/arm/arm.cc (vfp3_const_double_index): Likewise. (shift_op): Likewise. (thumb2_final_prescan_insn): Likewise. (arm_final_prescan_insn): Likewise. (arm_asm_output_labelref): Likewise. (arm_small_register_classes_for_mode_p): Likewise. * config/arm/arm.h: Likewise. * config/arm/arm.md: Likewise. * config/arm/driver-arm.cc: Likewise. * config/arm/symbian.h: Likewise. * config/arm/t-arm: Likewise. * config/arm/thumb1.md: Likewise. * config/arm/x-arm: Likewise. * config/avr/avr-c.cc (avr_register_target_pragmas): Likewise. * config/avr/avr-fixed.md: Likewise. * config/avr/avr-log.cc (avr_log_vadump): Likewise. * config/avr/avr-mcus.def: Likewise. * config/avr/avr-modes.def (FRACTIONAL_INT_MODE): Likewise. * config/avr/avr-passes.def (INSERT_PASS_BEFORE): Likewise. * config/avr/avr-protos.h (make_avr_pass_casesi): Likewise. * config/avr/avr.cc (avr_option_override): Likewise. (avr_build_builtin_va_list): Likewise. (avr_mode_dependent_address_p): Likewise. (avr_function_arg_advance): Likewise. (avr_asm_output_aligned_decl_common): Likewise. * config/avr/avr.h (RETURN_ADDR_RTX): Likewise. (SUPPORTS_INIT_PRIORITY): Likewise. * config/avr/avr.md: Likewise. * config/avr/builtins.def: Likewise. * config/avr/gen-avr-mmcu-specs.cc (IN_GEN_AVR_MMCU_TEXI): Likewise. * config/avr/gen-avr-mmcu-texi.cc (IN_GEN_AVR_MMCU_TEXI): Likewise. (main): Likewise. * config/avr/t-avr: Likewise. * config/bfin/bfin.cc (frame_related_constant_load): Likewise. * config/bpf/bpf-protos.h (GCC_BPF_PROTOS_H): Likewise. * config/bpf/bpf.h (enum reg_class): Likewise. * config/bpf/t-bpf: Likewise. * config/c6x/c6x-protos.h (GCC_C6X_PROTOS_H): Likewise. * config/cr16/cr16-protos.h: Likewise. * config/cris/cris.cc (cris_address_cost): Likewise. (cris_side_effect_mode_ok): Likewise. (cris_init_machine_status): Likewise. (cris_emit_movem_store): Likewise. * config/cris/cris.h (INDEX_REG_CLASS): Likewise. (enum reg_class): Likewise. (struct cum_args): Likewise. * config/cris/cris.opt: Likewise. * config/cris/sync.md: Likewise. * config/csky/csky.cc (csky_expand_prologue): Likewise. * config/darwin-c.cc: Likewise. * config/darwin-f.cc: Likewise. * config/darwin-sections.def (zobj_const_section): Likewise. * config/darwin.cc (output_objc_section_asm_op): Likewise. (fprintf): Likewise. * config/darwin.h (GTY): Likewise. * config/elfos.h: Likewise. * config/epiphany/epiphany-sched.md: Likewise. * config/epiphany/epiphany.cc (epiphany_function_value): Likewise. * config/epiphany/epiphany.h (GTY): Likewise. (NO_FUNCTION_CSE): Likewise. * config/epiphany/mode-switch-use.cc: Likewise. * config/epiphany/predicates.md: Likewise. * config/epiphany/t-epiphany: Likewise. * config/fr30/fr30-protos.h: Likewise. * config/frv/frv-protos.h: Likewise. * config/frv/frv.cc (TLS_BIAS): Likewise. * config/frv/frv.h (ASM_OUTPUT_ALIGNED_LOCAL): Likewise. * config/ft32/ft32-protos.h: Likewise. * config/gcn/gcn-hsa.h (ASM_APP_OFF): Likewise. * config/gcn/gcn.cc (gcn_init_libfuncs): Likewise. * config/gcn/mkoffload.cc (copy_early_debug_info): Likewise. * config/gcn/t-gcn-hsa: Likewise. * config/gcn/t-omp-device: Likewise. * config/h8300/h8300-protos.h (GCC_H8300_PROTOS_H): Likewise. (same_cmp_following_p): Likewise. * config/h8300/h8300.cc (F): Likewise. * config/h8300/h8300.h (struct cum_arg): Likewise. (BRANCH_COST): Likewise. * config/i386/cygming.h (DEFAULT_PCC_STRUCT_RETURN): Likewise. * config/i386/djgpp.h (TARGET_ASM_LTO_END): Likewise. * config/i386/dragonfly.h (NO_PROFILE_COUNTERS): Likewise. * config/i386/driver-i386.cc (detect_caches_intel): Likewise. * config/i386/freebsd.h (NO_PROFILE_COUNTERS): Likewise. * config/i386/i386-c.cc (ix86_target_macros): Likewise. * config/i386/i386-expand.cc (get_mode_wider_vector): Likewise. * config/i386/i386-options.cc (ix86_set_func_type): Likewise. * config/i386/i386-protos.h (ix86_extract_perm_from_pool_constant): Likewise. (ix86_register_pragmas): Likewise. (ix86_d_has_stdcall_convention): Likewise. (i386_pe_seh_init_sections): Likewise. * config/i386/i386.cc (ix86_function_arg_regno_p): Likewise. (ix86_function_value_regno_p): Likewise. (ix86_compute_frame_layout): Likewise. (legitimize_pe_coff_symbol): Likewise. (output_pic_addr_const): Likewise. * config/i386/i386.h (defined): Likewise. (host_detect_local_cpu): Likewise. (CONSTANT_ADDRESS_P): Likewise. (DEFAULT_LARGE_SECTION_THRESHOLD): Likewise. (struct machine_frame_state): Likewise. * config/i386/i386.md: Likewise. * config/i386/lynx.h (ASM_OUTPUT_ALIGN): Likewise. * config/i386/mmx.md: Likewise. * config/i386/sse.md: Likewise. * config/i386/t-cygming: Likewise. * config/i386/t-djgpp: Likewise. * config/i386/t-gnu-property: Likewise. * config/i386/t-i386: Likewise. * config/i386/t-intelmic: Likewise. * config/i386/t-omp-device: Likewise. * config/i386/winnt-cxx.cc (i386_pe_type_dllimport_p): Likewise. (i386_pe_adjust_class_at_definition): Likewise. * config/i386/winnt.cc (gen_stdcall_or_fastcall_suffix): Likewise. (i386_pe_mangle_decl_assembler_name): Likewise. (i386_pe_encode_section_info): Likewise. * config/i386/x-cygwin: Likewise. * config/i386/x-darwin: Likewise. * config/i386/x-i386: Likewise. * config/i386/x-mingw32: Likewise. * config/i386/x86-tune-sched-core.cc: Likewise. * config/i386/x86-tune.def: Likewise. * config/i386/xm-djgpp.h (STANDARD_STARTFILE_PREFIX_1): Likewise. * config/ia64/freebsd.h: Likewise. * config/ia64/hpux.h (REGISTER_TARGET_PRAGMAS): Likewise. * config/ia64/ia64-protos.h (ia64_except_unwind_info): Likewise. * config/ia64/ia64.cc (ia64_function_value_regno_p): Likewise. (ia64_secondary_reload_class): Likewise. (bundling): Likewise. * config/ia64/ia64.h: Likewise. * config/ia64/ia64.md: Likewise. * config/ia64/predicates.md: Likewise. * config/ia64/sysv4.h: Likewise. * config/ia64/t-ia64: Likewise. * config/iq2000/iq2000.h (FUNCTION_MODE): Likewise. * config/iq2000/iq2000.md: Likewise. * config/linux.h (TARGET_HAS_BIONIC): Likewise. (if): Likewise. * config/m32c/m32c.cc (m32c_function_needs_enter): Likewise. * config/m32c/m32c.h (MAX_REGS_PER_ADDRESS): Likewise. * config/m32c/t-m32c: Likewise. * config/m32r/m32r-protos.h: Likewise. * config/m32r/m32r.cc (m32r_print_operand): Likewise. * config/m32r/m32r.h: Likewise. * config/m32r/m32r.md: Likewise. * config/m68k/m68k-isas.def: Likewise. * config/m68k/m68k-microarchs.def: Likewise. * config/m68k/m68k-protos.h (strict_low_part_peephole_ok): Likewise. (m68k_epilogue_uses): Likewise. * config/m68k/m68k.cc (m68k_call_tls_get_addr): Likewise. (m68k_sched_adjust_cost): Likewise. (m68k_sched_md_init): Likewise. * config/m68k/m68k.h (__transfer_from_trampoline): Likewise. (enum m68k_function_kind): Likewise. * config/m68k/m68k.md: Likewise. * config/m68k/m68kemb.h: Likewise. * config/m68k/uclinux.h (ENDFILE_SPEC): Likewise. * config/mcore/mcore-protos.h: Likewise. * config/mcore/mcore.cc (mcore_expand_insv): Likewise. (mcore_expand_prolog): Likewise. * config/mcore/mcore.h (TARGET_MCORE): Likewise. * config/mcore/mcore.md: Likewise. * config/microblaze/microblaze-protos.h: Likewise. * config/microblaze/microblaze.cc (microblaze_legitimate_pic_operand): Likewise. (microblaze_function_prologue): Likewise. (microblaze_function_epilogue): Likewise. (microblaze_select_section): Likewise. (microblaze_asm_output_mi_thunk): Likewise. (microblaze_eh_return): Likewise. * config/microblaze/microblaze.h: Likewise. * config/microblaze/microblaze.md: Likewise. * config/microblaze/t-microblaze: Likewise. * config/mips/driver-native.cc: Likewise. * config/mips/loongson2ef.md: Likewise. * config/mips/mips-protos.h (mips_expand_vec_cmp_expr): Likewise. * config/mips/mips.cc (mips_rtx_costs): Likewise. (mips_output_filename): Likewise. (mips_output_function_prologue): Likewise. (mips_output_function_epilogue): Likewise. (mips_output_mi_thunk): Likewise. * config/mips/mips.h: Likewise. * config/mips/mips.md: Likewise. * config/mips/t-mips: Likewise. * config/mips/x-native: Likewise. * config/mmix/mmix-protos.h: Likewise. * config/mmix/mmix.cc (mmix_option_override): Likewise. (mmix_dbx_register_number): Likewise. (mmix_expand_prologue): Likewise. * config/mmix/mmix.h: Likewise. * config/mmix/mmix.md: Likewise. * config/mmix/predicates.md: Likewise. * config/mn10300/mn10300.cc (mn10300_symbolic_operand): Likewise. (mn10300_legitimate_pic_operand_p): Likewise. * config/mn10300/mn10300.h (enum reg_class): Likewise. (NO_FUNCTION_CSE): Likewise. * config/moxie/moxie-protos.h: Likewise. * config/moxie/uclinux.h (TARGET_LIBC_HAS_FUNCTION): Likewise. * config/msp430/msp430-devices.cc (extract_devices_dir_from_exec_prefix): Likewise. * config/msp430/msp430.cc (msp430_gimplify_va_arg_expr): Likewise. (msp430_incoming_return_addr_rtx): Likewise. * config/msp430/msp430.h (msp430_get_linker_devices_include_path): Likewise. * config/msp430/t-msp430: Likewise. * config/nds32/nds32-cost.cc (nds32_rtx_costs_speed_prefer): Likewise. (nds32_rtx_costs_size_prefer): Likewise. (nds32_init_rtx_costs): Likewise. * config/nds32/nds32-doubleword.md: Likewise. * config/nds32/nds32.cc (nds32_memory_move_cost): Likewise. (nds32_builtin_decl): Likewise. * config/nds32/nds32.h (enum nds32_16bit_address_type): Likewise. (enum nds32_isr_nested_type): Likewise. (enum reg_class): Likewise. * config/nds32/predicates.md: Likewise. * config/nds32/t-nds32: Likewise. * config/nios2/nios2.cc (nios2_pragma_target_parse): Likewise. * config/nvptx/nvptx-protos.h: Likewise. * config/nvptx/nvptx.cc (nvptx_goacc_expand_var_decl): Likewise. * config/nvptx/nvptx.h (TARGET_CPU_CPP_BUILTINS): Likewise. * config/nvptx/t-nvptx: Likewise. * config/nvptx/t-omp-device: Likewise. * config/pa/elf.h: Likewise. * config/pa/pa-linux.h (GLOBAL_ASM_OP): Likewise. * config/pa/pa-netbsd.h (GLOBAL_ASM_OP): Likewise. * config/pa/pa-openbsd.h (TARGET_ASM_GLOBALIZE_LABEL): Likewise. * config/pa/pa-protos.h (pa_eh_return_handler_rtx): Likewise. (pa_legitimize_reload_address): Likewise. (pa_can_use_return_insn): Likewise. * config/pa/pa.cc (mem_shadd_or_shadd_rtx_p): Likewise. (som_output_text_section_asm_op): Likewise. * config/pa/pa.h (PROFILE_BEFORE_PROLOGUE): Likewise. * config/pa/pa.md: Likewise. * config/pa/som.h: Likewise. * config/pa/t-pa: Likewise. * config/pdp11/pdp11.cc (decode_pdp11_d): Likewise. * config/pdp11/pdp11.h: Likewise. * config/pdp11/pdp11.md: Likewise. * config/pdp11/t-pdp11: Likewise. * config/pru/pru.md: Likewise. * config/pru/t-pru: Likewise. * config/riscv/riscv-protos.h (NUM_SYMBOL_TYPES): Likewise. (riscv_gpr_save_operation_p): Likewise. (riscv_d_register_target_info): Likewise. (riscv_init_builtins): Likewise. * config/riscv/riscv.cc (riscv_output_mi_thunk): Likewise. * config/riscv/riscv.h (CSW_MAX_OFFSET): Likewise. * config/riscv/t-riscv: Likewise. * config/rl78/rl78.cc (rl78_asm_ctor_dtor): Likewise. * config/rl78/t-rl78: Likewise. * config/rs6000/aix.h: Likewise. * config/rs6000/aix71.h (ASM_SPEC_COMMON): Likewise. * config/rs6000/aix72.h (ASM_SPEC_COMMON): Likewise. * config/rs6000/aix73.h (ASM_SPEC_COMMON): Likewise. * config/rs6000/darwin.h (TARGET_ASM_GLOBALIZE_LABEL): Likewise. * config/rs6000/driver-rs6000.cc: Likewise. * config/rs6000/freebsd.h: Likewise. * config/rs6000/freebsd64.h: Likewise. * config/rs6000/lynx.h (ASM_OUTPUT_ALIGN): Likewise. * config/rs6000/rbtree.cc: Likewise. * config/rs6000/rbtree.h: Likewise. * config/rs6000/rs6000-c.cc (rs6000_target_modify_macros): Likewise. * config/rs6000/rs6000-call.cc (rs6000_invalid_builtin): Likewise. (rs6000_expand_builtin): Likewise. (rs6000_init_builtins): Likewise. * config/rs6000/rs6000-cpus.def: Likewise. * config/rs6000/rs6000-gen-builtins.cc (write_init_ovld_table): Likewise. * config/rs6000/rs6000-internal.h (ALTIVEC_REG_BIT): Likewise. (quad_address_offset_p): Likewise. * config/rs6000/rs6000-logue.cc (interesting_frame_related_regno): Likewise. (rs6000_emit_epilogue): Likewise. * config/rs6000/rs6000-overload.def: Likewise. * config/rs6000/rs6000-p8swap.cc: Likewise. * config/rs6000/rs6000-protos.h (GCC_RS6000_PROTOS_H): Likewise. (rs6000_const_f32_to_i32): Likewise. * config/rs6000/rs6000.cc (legitimate_lo_sum_address_p): Likewise. (rs6000_debug_legitimize_address): Likewise. (rs6000_mode_dependent_address): Likewise. (rs6000_adjust_priority): Likewise. (rs6000_c_mode_for_suffix): Likewise. * config/rs6000/rs6000.h (defined): Likewise. (LONG_DOUBLE_TYPE_SIZE): Likewise. * config/rs6000/rs6000.md: Likewise. * config/rs6000/sysv4.h: Likewise. * config/rs6000/t-linux: Likewise. * config/rs6000/t-linux64: Likewise. * config/rs6000/t-rs6000: Likewise. * config/rs6000/x-darwin: Likewise. * config/rs6000/x-darwin64: Likewise. * config/rs6000/x-rs6000: Likewise. * config/rs6000/xcoff.h (ASM_OUTPUT_LABELREF): Likewise. * config/rx/rx.cc (rx_expand_builtin): Likewise. * config/s390/constraints.md: Likewise. * config/s390/driver-native.cc: Likewise. * config/s390/htmxlintrin.h: Likewise. * config/s390/s390-builtins.def (B_DEF): Likewise. (OB_DEF_VAR): Likewise. * config/s390/s390-builtins.h: Likewise. * config/s390/s390-c.cc: Likewise. * config/s390/s390-opts.h: Likewise. * config/s390/s390-protos.h (s390_check_symref_alignment): Likewise. (s390_register_target_pragmas): Likewise. * config/s390/s390.cc (s390_init_builtins): Likewise. (s390_expand_plus_operand): Likewise. (s390_expand_atomic): Likewise. (s390_valid_target_attribute_inner_p): Likewise. * config/s390/s390.h (LONG_DOUBLE_TYPE_SIZE): Likewise. * config/s390/s390.md: Likewise. * config/s390/t-s390: Likewise. * config/s390/vx-builtins.md: Likewise. * config/s390/x-native: Likewise. * config/sh/divtab-sh4-300.cc (main): Likewise. * config/sh/divtab-sh4.cc (main): Likewise. * config/sh/divtab.cc (main): Likewise. * config/sh/elf.h: Likewise. * config/sh/sh-protos.h (sh_fsca_int2sf): Likewise. * config/sh/sh.cc (SYMBOL_FLAG_FUNCVEC_FUNCTION): Likewise. (sh_struct_value_rtx): Likewise. (sh_remove_reg_dead_or_unused_notes): Likewise. * config/sh/sh.h (MIN_UNITS_PER_WORD): Likewise. * config/sh/t-sh: Likewise. * config/sol2-protos.h (solaris_override_options): Likewise. * config/sol2.h: Likewise. * config/sparc/driver-sparc.cc: Likewise. * config/sparc/freebsd.h: Likewise. * config/sparc/sparc-protos.h (make_pass_work_around_errata): Likewise. * config/sparc/sparc.cc (sparc_output_mi_thunk): Likewise. (sparc_asan_shadow_offset): Likewise. * config/sparc/sparc.h: Likewise. * config/sparc/sparc.md: Likewise. * config/sparc/t-sparc: Likewise. * config/sparc/x-sparc: Likewise. * config/stormy16/stormy16.cc (xstormy16_mode_dependent_address_p): Likewise. * config/t-darwin: Likewise. * config/t-dragonfly: Likewise. * config/t-freebsd: Likewise. * config/t-glibc: Likewise. * config/t-linux: Likewise. * config/t-netbsd: Likewise. * config/t-openbsd: Likewise. * config/t-pnt16-warn: Likewise. * config/t-sol2: Likewise. * config/t-vxworks: Likewise. * config/t-winnt: Likewise. * config/tilegx/t-tilegx: Likewise. * config/tilegx/tilegx-c.cc: Likewise. * config/tilegx/tilegx-protos.h (tilegx_function_profiler): Likewise. * config/tilegx/tilegx.md: Likewise. * config/tilepro/t-tilepro: Likewise. * config/tilepro/tilepro-c.cc: Likewise. * config/v850/t-v850: Likewise. * config/v850/v850-protos.h: Likewise. * config/v850/v850.cc (F): Likewise. * config/v850/v850.h (enum reg_class): Likewise. (SLOW_BYTE_ACCESS): Likewise. * config/vax/vax.cc (vax_mode_dependent_address_p): Likewise. * config/vax/vax.h (enum reg_class): Likewise. * config/vax/vax.md: Likewise. * config/visium/visium.cc (visium_legitimate_address_p): Likewise. * config/visium/visium.h: Likewise. * config/vms/t-vms: Likewise. * config/vms/vms-crtlmap.map: Likewise. * config/vms/vms-protos.h (vms_c_get_vms_ver): Likewise. * config/vx-common.h: Likewise. * config/x-darwin: Likewise. * config/x-hpux: Likewise. * config/x-linux: Likewise. * config/x-netbsd: Likewise. * config/x-openbsd: Likewise. * config/x-solaris: Likewise. * config/xtensa/xtensa-protos.h (xtensa_mem_offset): Likewise. * config/xtensa/xtensa.cc (xtensa_option_override): Likewise. * config/xtensa/xtensa.h: Likewise. * configure.ac: Likewise. * context.cc: Likewise. * convert.h: Likewise. * coretypes.h: Likewise. * coverage.cc: Likewise. * coverage.h: Likewise. * cppdefault.h (struct default_include): Likewise. * cprop.cc (local_cprop_pass): Likewise. (one_cprop_pass): Likewise. * cse.cc (hash_rtx_cb): Likewise. (fold_rtx): Likewise. * ctfc.h (ctfc_get_num_vlen_bytes): Likewise. * data-streamer.h (bp_unpack_var_len_int): Likewise. (streamer_write_widest_int): Likewise. * dbgcnt.def: Likewise. * dbxout.cc (dbxout_early_global_decl): Likewise. (dbxout_common_check): Likewise. * dbxout.h: Likewise. * debug.h (struct gcc_debug_hooks): Likewise. (dump_go_spec_init): Likewise. * df-core.cc: Likewise. * df-scan.cc (df_insn_info_delete): Likewise. (df_insn_delete): Likewise. * df.h (debug_df_chain): Likewise. (can_move_insns_across): Likewise. * dfp.cc (decimal_from_binary): Likewise. * diagnostic-color.cc: Likewise. * diagnostic-event-id.h: Likewise. * diagnostic-show-locus.cc (test_one_liner_labels): Likewise. * diagnostic.cc (bt_callback): Likewise. (num_digits): Likewise. * doc/avr-mmcu.texi: Likewise. * doc/cfg.texi: Likewise. * doc/contrib.texi: Likewise. * doc/cppinternals.texi: Likewise. * doc/extend.texi: Likewise. * doc/generic.texi: Likewise. * doc/gimple.texi: Likewise. * doc/gty.texi: Likewise. * doc/invoke.texi: Likewise. * doc/loop.texi: Likewise. * doc/lto.texi: Likewise. * doc/match-and-simplify.texi: Likewise. * doc/md.texi: Likewise. * doc/optinfo.texi: Likewise. * doc/options.texi: Likewise. * doc/passes.texi: Likewise. * doc/plugins.texi: Likewise. * doc/rtl.texi: Likewise. * doc/sourcebuild.texi: Likewise. * doc/tm.texi: Likewise. * doc/tm.texi.in: Likewise. * doc/tree-ssa.texi: Likewise. * dojump.cc (do_jump): Likewise. * dojump.h: Likewise. * dumpfile.cc (test_impl_location): Likewise. (test_capture_of_dump_calls): Likewise. * dumpfile.h (enum dump_kind): Likewise. (class dump_location_t): Likewise. (dump_enabled_p): Likewise. (enable_rtl_dump_file): Likewise. (dump_combine_total_stats): Likewise. * dwarf2asm.cc (dw2_asm_output_delta_uleb128): Likewise. * dwarf2ctf.h (ctf_debug_finish): Likewise. * dwarf2out.cc (dwarf2out_begin_prologue): Likewise. (struct loc_descr_context): Likewise. (rtl_for_decl_location): Likewise. (gen_subprogram_die): Likewise. (gen_label_die): Likewise. (is_trivial_indirect_ref): Likewise. (dwarf2out_late_global_decl): Likewise. (dwarf_file_hasher::hash): Likewise. (dwarf2out_end_source_file): Likewise. (dwarf2out_define): Likewise. (dwarf2out_early_finish): Likewise. * dwarf2out.h (struct dw_fde_node): Likewise. (struct dw_discr_list_node): Likewise. (output_loc_sequence_raw): Likewise. * emit-rtl.cc (gen_raw_REG): Likewise. (maybe_set_max_label_num): Likewise. * emit-rtl.h (struct rtl_data): Likewise. * errors.cc (internal_error): Likewise. (trim_filename): Likewise. * et-forest.cc: Likewise. * except.cc (init_eh_for_function): Likewise. * explow.cc (promote_ssa_mode): Likewise. (get_dynamic_stack_size): Likewise. * explow.h: Likewise. * expmed.h: Likewise. * expr.cc (safe_from_p): Likewise. (expand_expr_real_2): Likewise. (expand_expr_real_1): Likewise. * file-prefix-map.cc (remap_filename): Likewise. * final.cc (app_enable): Likewise. (make_pass_compute_alignments): Likewise. (final_scan_insn_1): Likewise. (final_scan_insn): Likewise. * fixed-value.h (fixed_from_string): Likewise. * flag-types.h (NO_DEBUG): Likewise. (DWARF2_DEBUG): Likewise. (VMS_DEBUG): Likewise. (BTF_DEBUG): Likewise. (enum ctf_debug_info_levels): Likewise. * fold-const.cc (const_binop): Likewise. (fold_binary_loc): Likewise. (fold_checksum_tree): Likewise. * fp-test.cc: Likewise. * function.cc (expand_function_end): Likewise. * function.h (struct function): Likewise. * fwprop.cc (should_replace_address): Likewise. * gcc-main.cc: Likewise. * gcc-rich-location.h (class gcc_rich_location): Likewise. * gcc-symtab.h: Likewise. * gcc.cc (MIN_FATAL_STATUS): Likewise. (driver_handle_option): Likewise. (quote_spec_arg): Likewise. (driver::finalize): Likewise. * gcc.h (set_input): Likewise. * gcov-dump.cc: Likewise. * gcov.cc (solve_flow_graph): Likewise. * gcse-common.cc: Likewise. * gcse.cc (make_pass_rtl_hoist): Likewise. * genattr-common.cc: Likewise. * genattrtab.cc (min_fn): Likewise. (write_const_num_delay_slots): Likewise. * genautomata.cc: Likewise. * genconditions.cc (write_one_condition): Likewise. * genconstants.cc: Likewise. * genemit.cc (gen_exp): Likewise. * generic-match-head.cc: Likewise. * genextract.cc: Likewise. * gengenrtl.cc (always_void_p): Likewise. * gengtype-parse.cc (gtymarker_opt): Likewise. * gengtype-state.cc (state_writer::state_writer): Likewise. (write_state_trailer): Likewise. (equals_type_number): Likewise. (read_state): Likewise. * gengtype.cc (open_base_files): Likewise. (struct file_rule_st): Likewise. (header_dot_h_frul): Likewise. * gengtype.h: Likewise. * genmatch.cc (main): Likewise. * genmddeps.cc: Likewise. * genmodes.cc (emit_mode_inner): Likewise. (emit_mode_unit_size): Likewise. * genpeep.cc (gen_peephole): Likewise. * genpreds.cc (write_tm_preds_h): Likewise. * genrecog.cc (validate_pattern): Likewise. (write_header): Likewise. (main): Likewise. * gensupport.cc (change_subst_attribute): Likewise. (traverse_c_tests): Likewise. (add_predicate): Likewise. (init_predicate_table): Likewise. * gensupport.h (struct optab_pattern): Likewise. (get_num_insn_codes): Likewise. (maybe_eval_c_test): Likewise. (struct pred_data): Likewise. * ggc-internal.h: Likewise. * gimple-fold.cc (maybe_fold_reference): Likewise. (get_range_strlen_tree): Likewise. * gimple-fold.h (gimple_stmt_integer_valued_real_p): Likewise. * gimple-low.cc: Likewise. * gimple-match-head.cc (directly_supported_p): Likewise. * gimple-pretty-print.h: Likewise. * gimple-ssa-sprintf.cc (format_percent): Likewise. (adjust_range_for_overflow): Likewise. * gimple-streamer.h: Likewise. * gimple.h (struct GTY): Likewise. (is_gimple_resx): Likewise. * gimplify.cc (gimplify_expr): Likewise. (gimplify_init_constructor): Likewise. (omp_construct_selector_matches): Likewise. (gimplify_omp_target_update): Likewise. (gimplify_omp_ordered): Likewise. (gimplify_va_arg_expr): Likewise. * graphite-isl-ast-to-gimple.cc (should_copy_to_new_region): Likewise. * haifa-sched.cc (increase_insn_priority): Likewise. (try_ready): Likewise. (sched_create_recovery_edges): Likewise. * ifcvt.cc (find_if_case_1): Likewise. (find_if_case_2): Likewise. * inchash.h: Likewise. * incpath.cc (add_env_var_paths): Likewise. * input.cc (dump_location_info): Likewise. (assert_loceq): Likewise. (test_lexer_string_locations_concatenation_1): Likewise. (test_lexer_string_locations_concatenation_2): Likewise. (test_lexer_string_locations_concatenation_3): Likewise. * input.h (BUILTINS_LOCATION): Likewise. (class string_concat_db): Likewise. * internal-fn.cc (expand_MUL_OVERFLOW): Likewise. (expand_LOOP_VECTORIZED): Likewise. * ipa-cp.cc (make_pass_ipa_cp): Likewise. * ipa-fnsummary.cc (remap_freqcounting_preds_after_dup): Likewise. (ipa_fn_summary_t::duplicate): Likewise. (make_pass_ipa_fn_summary): Likewise. * ipa-fnsummary.h (enum ipa_hints_vals): Likewise. * ipa-free-lang-data.cc (fld_simplified_type): Likewise. (free_lang_data_in_decl): Likewise. * ipa-inline.cc (compute_inlined_call_time): Likewise. (inline_always_inline_functions): Likewise. * ipa-inline.h (free_growth_caches): Likewise. (inline_account_function_p): Likewise. * ipa-modref.cc (modref_access_analysis::analyze_stmt): Likewise. (modref_eaf_analysis::analyze_ssa_name): Likewise. * ipa-param-manipulation.cc (ipa_param_body_adjustments::mark_dead_statements): Likewise. (ipa_param_body_adjustments::remap_with_debug_expressions): Likewise. * ipa-prop.cc (ipa_set_node_agg_value_chain): Likewise. * ipa-prop.h (IPA_UNDESCRIBED_USE): Likewise. (unadjusted_ptr_and_unit_offset): Likewise. * ipa-reference.cc (make_pass_ipa_reference): Likewise. * ipa-reference.h (GCC_IPA_REFERENCE_H): Likewise. * ipa-split.cc (consider_split): Likewise. * ipa-sra.cc (isra_read_node_info): Likewise. * ipa-utils.h (struct ipa_dfs_info): Likewise. (recursive_call_p): Likewise. (ipa_make_function_pure): Likewise. * ira-build.cc (ira_create_allocno): Likewise. (ira_flattening): Likewise. * ira-color.cc (do_coloring): Likewise. (update_curr_costs): Likewise. * ira-conflicts.cc (process_regs_for_copy): Likewise. * ira-int.h (struct ira_emit_data): Likewise. (ira_prohibited_mode_move_regs): Likewise. (ira_get_dup_out_num): Likewise. (ira_destroy): Likewise. (ira_tune_allocno_costs): Likewise. (ira_implicitly_set_insn_hard_regs): Likewise. (ira_build_conflicts): Likewise. (ira_color): Likewise. * ira-lives.cc (process_bb_node_lives): Likewise. * ira.cc (class ira_spilled_reg_stack_slot): Likewise. (setup_uniform_class_p): Likewise. (def_dominates_uses): Likewise. * ira.h (ira_nullify_asm_goto): Likewise. * langhooks.cc (lhd_post_options): Likewise. * langhooks.h (class substring_loc): Likewise. (struct lang_hooks_for_tree_inlining): Likewise. (struct lang_hooks_for_types): Likewise. (struct lang_hooks): Likewise. * libfuncs.h (synchronize_libfunc): Likewise. * loop-doloop.cc (doloop_condition_get): Likewise. * loop-init.cc (fix_loop_structure): Likewise. * loop-invariant.cc: Likewise. * lower-subreg.h: Likewise. * lra-constraints.cc (curr_insn_transform): Likewise. * lra-int.h (struct lra_insn_reg): Likewise. (lra_undo_inheritance): Likewise. (lra_setup_reload_pseudo_preferenced_hard_reg): Likewise. (lra_split_hard_reg_for): Likewise. (lra_coalesce): Likewise. (lra_final_code_change): Likewise. * lra-spills.cc (lra_final_code_change): Likewise. * lra.cc (lra_process_new_insns): Likewise. * lto-compress.h (struct lto_compression_stream): Likewise. * lto-streamer-out.cc (DFS::DFS_write_tree_body): Likewise. (write_symbol): Likewise. * lto-streamer.h (enum LTO_tags): Likewise. (lto_value_range_error): Likewise. (lto_append_block): Likewise. (lto_streamer_hooks_init): Likewise. (stream_read_tree_ref): Likewise. (lto_prepare_function_for_streaming): Likewise. (select_what_to_stream): Likewise. (omp_lto_input_declare_variant_alt): Likewise. (cl_optimization_stream_in): Likewise. * lto-wrapper.cc (append_compiler_options): Likewise. * machmode.def: Likewise. * machmode.h (struct int_n_data_t): Likewise. * main.cc (main): Likewise. * match.pd: Likewise. * omp-builtins.def (BUILT_IN_GOMP_CRITICAL_NAME_END): Likewise. (BUILT_IN_GOMP_LOOP_ULL_ORDERED_RUNTIME_NEXT): Likewise. * omp-expand.cc (expand_omp_atomic_fetch_op): Likewise. (make_pass_expand_omp_ssa): Likewise. * omp-low.cc (struct omp_context): Likewise. (struct omp_taskcopy_context): Likewise. (lower_omp): Likewise. * omp-oacc-neuter-broadcast.cc (omp_sese_active_worker_call): Likewise. (mask_name): Likewise. (omp_sese_dump_pars): Likewise. (worker_single_simple): Likewise. * omp-offload.cc (omp_finish_file): Likewise. (execute_oacc_loop_designation): Likewise. * optabs-query.cc (lshift_cheap_p): Likewise. * optc-gen.awk: Likewise. * optc-save-gen.awk: Likewise. * optinfo-emit-json.cc (optrecord_json_writer::optrecord_json_writer): Likewise. * opts-common.cc: Likewise. * output.h (app_enable): Likewise. (output_operand_lossage): Likewise. (insn_current_reference_address): Likewise. (get_insn_template): Likewise. (output_quoted_string): Likewise. * pass_manager.h (struct register_pass_info): Likewise. * plugin.cc: Likewise. * plugin.def (PLUGIN_ANALYZER_INIT): Likewise. * plugin.h (invoke_plugin_callbacks): Likewise. * pointer-query.cc (handle_mem_ref): Likewise. * postreload-gcse.cc (alloc_mem): Likewise. * predict.h (enum prediction): Likewise. (add_reg_br_prob_note): Likewise. * prefix.h: Likewise. * profile.h (get_working_sets): Likewise. * read-md.cc: Likewise. * read-md.h (struct mapping): Likewise. (class md_reader): Likewise. (class noop_reader): Likewise. * read-rtl-function.cc (function_reader::create_function): Likewise. (function_reader::extra_parsing_for_operand_code_0): Likewise. * read-rtl.cc (initialize_iterators): Likewise. * real.cc: Likewise. * real.h (struct real_value): Likewise. (format_helper::format_helper): Likewise. (real_hash): Likewise. (real_can_shorten_arithmetic): Likewise. * recog.cc (struct target_recog): Likewise. (offsettable_nonstrict_memref_p): Likewise. (constrain_operands): Likewise. * recog.h (MAX_RECOG_ALTERNATIVES): Likewise. (which_op_alt): Likewise. (struct insn_gen_fn): Likewise. * reg-notes.def (REG_NOTE): Likewise. * reg-stack.cc: Likewise. * regs.h (reg_is_parm_p): Likewise. * regset.h: Likewise. * reload.cc (push_reload): Likewise. (find_reloads): Likewise. (find_reloads_address_1): Likewise. (find_replacement): Likewise. (refers_to_regno_for_reload_p): Likewise. (refers_to_mem_for_reload_p): Likewise. * reload.h (push_reload): Likewise. (deallocate_reload_reg): Likewise. * reload1.cc (emit_input_reload_insns): Likewise. * reorg.cc (relax_delay_slots): Likewise. * rtl.def (UNKNOWN): Likewise. (SEQUENCE): Likewise. (BARRIER): Likewise. (ASM_OPERANDS): Likewise. (EQ_ATTR_ALT): Likewise. * rtl.h (struct GTY): Likewise. (LABEL_NAME): Likewise. (LABEL_ALT_ENTRY_P): Likewise. (SUBREG_BYTE): Likewise. (get_stack_check_protect): Likewise. (dump_rtx_statistics): Likewise. (unwrap_const_vec_duplicate): Likewise. (subreg_promoted_mode): Likewise. (gen_lowpart_common): Likewise. (operand_subword): Likewise. (immed_wide_int_const): Likewise. (decide_function_section): Likewise. (active_insn_p): Likewise. (delete_related_insns): Likewise. (try_split): Likewise. (val_signbit_known_clear_p): Likewise. (simplifiable_subregs): Likewise. (set_insn_deleted): Likewise. (subreg_get_info): Likewise. (remove_free_EXPR_LIST_node): Likewise. (finish_subregs_of_mode): Likewise. (get_mem_attrs): Likewise. (lookup_constant_def): Likewise. (rtx_to_tree_code): Likewise. (hash_rtx): Likewise. (condjump_in_parallel_p): Likewise. (validate_subreg): Likewise. (make_compound_operation): Likewise. (schedule_ebbs): Likewise. (print_inline_rtx): Likewise. (fixup_args_size_notes): Likewise. (expand_dec): Likewise. (prepare_copy_insn): Likewise. (mark_elimination): Likewise. (valid_mode_changes_for_regno): Likewise. (make_debug_expr_from_rtl): Likewise. (delete_vta_debug_insns): Likewise. (simplify_using_condition): Likewise. (set_insn_locations): Likewise. (fatal_insn_not_found): Likewise. (word_register_operation_p): Likewise. * rtlanal.cc (get_call_fndecl): Likewise. (side_effects_p): Likewise. (subreg_nregs): Likewise. (rtx_cost): Likewise. (canonicalize_condition): Likewise. * rtlanal.h (rtx_properties::try_to_add_note): Likewise. * run-rtl-passes.cc (run_rtl_passes): Likewise. * sanitizer.def (BUILT_IN_ASAN_VERSION_MISMATCH_CHECK): Likewise. * sched-deps.cc (add_dependence_1): Likewise. * sched-ebb.cc (begin_move_insn): Likewise. (add_deps_for_risky_insns): Likewise. (advance_target_bb): Likewise. * sched-int.h (reemit_notes): Likewise. (struct _haifa_insn_data): Likewise. (HID): Likewise. (DEP_CANCELLED): Likewise. (debug_ds): Likewise. (number_in_ready): Likewise. (schedule_ebbs_finish): Likewise. (find_modifiable_mems): Likewise. * sched-rgn.cc (debug_rgn_dependencies): Likewise. * sel-sched-dump.cc (dump_lv_set): Likewise. * sel-sched-dump.h: Likewise. * sel-sched-ir.cc (sel_insn_rtx_cost): Likewise. (setup_id_reg_sets): Likewise. (has_dependence_p): Likewise. (sel_num_cfg_preds_gt_1): Likewise. (bb_ends_ebb_p): Likewise. * sel-sched-ir.h (struct _list_node): Likewise. (struct idata_def): Likewise. (bb_next_bb): Likewise. * sel-sched.cc (vinsn_writes_one_of_regs_p): Likewise. (choose_best_pseudo_reg): Likewise. (verify_target_availability): Likewise. (can_speculate_dep_p): Likewise. (sel_rank_for_schedule): Likewise. * selftest-run-tests.cc (selftest::run_tests): Likewise. * selftest.h (class auto_fix_quotes): Likewise. * shrink-wrap.cc (handle_simple_exit): Likewise. * shrink-wrap.h: Likewise. * simplify-rtx.cc (simplify_context::simplify_associative_operation): Likewise. (simplify_context::simplify_gen_vec_select): Likewise. * spellcheck-tree.h: Likewise. * spellcheck.h: Likewise. * statistics.h (struct function): Likewise. * stmt.cc (conditional_probability): Likewise. * stmt.h: Likewise. * stor-layout.h: Likewise. * streamer-hooks.h: Likewise. * stringpool.h: Likewise. * symtab.cc (symbol_table::change_decl_assembler_name): Likewise. * target.def (HOOK_VECTOR_END): Likewise. (type.): Likewise. * target.h (union cumulative_args_t): Likewise. (by_pieces_ninsns): Likewise. (class predefined_function_abi): Likewise. * targhooks.cc (default_translate_mode_attribute): Likewise. * timevar.def: Likewise. * timevar.h (class timer): Likewise. * toplev.h (enable_rtl_dump_file): Likewise. * trans-mem.cc (collect_bb2reg): Likewise. * tree-call-cdce.cc (gen_conditions_for_pow): Likewise. * tree-cfg.cc (remove_bb): Likewise. (verify_gimple_debug): Likewise. (remove_edge_and_dominated_blocks): Likewise. (push_fndecl): Likewise. * tree-cfgcleanup.h (GCC_TREE_CFGCLEANUP_H): Likewise. * tree-complex.cc (expand_complex_multiplication): Likewise. (expand_complex_div_straight): Likewise. * tree-core.h (enum tree_index): Likewise. (enum operand_equal_flag): Likewise. * tree-eh.cc (honor_protect_cleanup_actions): Likewise. * tree-if-conv.cc (if_convertible_gimple_assign_stmt_p): Likewise. * tree-inline.cc (initialize_inlined_parameters): Likewise. * tree-inline.h (force_value_to_type): Likewise. * tree-nested.cc (get_chain_decl): Likewise. (walk_all_functions): Likewise. * tree-object-size.h: Likewise. * tree-outof-ssa.cc: Likewise. * tree-parloops.cc (create_parallel_loop): Likewise. * tree-pretty-print.cc (print_generic_expr_to_str): Likewise. (dump_generic_node): Likewise. * tree-profile.cc (tree_profiling): Likewise. * tree-sra.cc (maybe_add_sra_candidate): Likewise. * tree-ssa-address.cc: Likewise. * tree-ssa-alias.cc: Likewise. * tree-ssa-alias.h (ao_ref::max_size_known_p): Likewise. (dump_alias_stats): Likewise. * tree-ssa-ccp.cc: Likewise. * tree-ssa-coalesce.h: Likewise. * tree-ssa-live.cc (remove_unused_scope_block_p): Likewise. * tree-ssa-loop-manip.cc (copy_phi_node_args): Likewise. * tree-ssa-loop-unswitch.cc: Likewise. * tree-ssa-math-opts.cc: Likewise. * tree-ssa-operands.cc (class operands_scanner): Likewise. * tree-ssa-pre.cc: Likewise. * tree-ssa-reassoc.cc (optimize_ops_list): Likewise. (debug_range_entry): Likewise. * tree-ssa-sccvn.cc (eliminate_dom_walker::eliminate_stmt): Likewise. * tree-ssa-sccvn.h (TREE_SSA_SCCVN_H): Likewise. * tree-ssa-scopedtables.cc (add_expr_commutative): Likewise. (equal_mem_array_ref_p): Likewise. * tree-ssa-strlen.cc (is_strlen_related_p): Likewise. * tree-ssa-strlen.h (get_range_strlen_dynamic): Likewise. * tree-ssa-tail-merge.cc (stmt_local_def): Likewise. * tree-ssa-ter.h: Likewise. * tree-ssa-threadupdate.h (enum bb_dom_status): Likewise. * tree-streamer-in.cc (lto_input_ts_block_tree_pointers): Likewise. * tree-streamer-out.cc (pack_ts_block_value_fields): Likewise. (write_ts_block_tree_pointers): Likewise. * tree-streamer.h (struct streamer_tree_cache_d): Likewise. (streamer_read_tree_bitfields): Likewise. (streamer_write_integer_cst): Likewise. * tree-vect-patterns.cc (apply_binop_and_append_stmt): Likewise. (vect_synth_mult_by_constant): Likewise. * tree-vect-stmts.cc (vectorizable_operation): Likewise. * tree-vectorizer.cc: Likewise. * tree-vectorizer.h (class auto_purge_vect_location): Likewise. (vect_update_inits_of_drs): Likewise. (vect_get_mask_type_for_stmt): Likewise. (vect_rgroup_iv_might_wrap_p): Likewise. (cse_and_gimplify_to_preheader): Likewise. (vect_free_slp_tree): Likewise. (vect_pattern_recog): Likewise. (vect_stmt_dominates_stmt_p): Likewise. * tree.cc (initialize_tree_contains_struct): Likewise. (need_assembler_name_p): Likewise. (type_with_interoperable_signedness): Likewise. * tree.def (SWITCH_EXPR): Likewise. * tree.h (TYPE_SYMTAB_ADDRESS): Likewise. (poly_int_tree_p): Likewise. (inlined_function_outer_scope_p): Likewise. (tree_code_for_canonical_type_merging): Likewise. * value-prof.cc: Likewise. * value-prof.h (get_nth_most_common_value): Likewise. (find_func_by_profile_id): Likewise. * value-range.cc (vrp_operand_equal_p): Likewise. * value-range.h: Likewise. * var-tracking.cc: Likewise. * varasm.cc (default_function_section): Likewise. (function_section_1): Likewise. (assemble_variable): Likewise. (handle_vtv_comdat_section): Likewise. * vec.h (struct vec_prefix): Likewise. * vmsdbgout.cc (full_name): Likewise. * vtable-verify.cc: Likewise. * vtable-verify.h (struct vtv_graph_node): Likewise. * xcoffout.cc: Likewise. * xcoffout.h (DEBUG_SYMS_TEXT): Likewise. gcc/ada/ChangeLog: * Make-generated.in: Rename .c names to .cc. * adaint.c: Likewise. * ctrl_c.c (dummy_handler): Likewise. * gcc-interface/Makefile.in: Likewise. * gcc-interface/config-lang.in: Likewise. * gcc-interface/decl.cc (concat_name): Likewise. (init_gnat_decl): Likewise. * gcc-interface/gigi.h (concat_name): Likewise. (init_gnat_utils): Likewise. (build_call_raise_range): Likewise. (gnat_mark_addressable): Likewise. (gnat_protect_expr): Likewise. (gnat_rewrite_reference): Likewise. * gcc-interface/lang-specs.h (ADA_DUMPS_OPTIONS): Likewise. * gcc-interface/utils.cc (GTY): Likewise. (add_deferred_type_context): Likewise. (init_gnat_utils): Likewise. * gcc-interface/utils2.cc (gnat_stable_expr_p): Likewise. (gnat_protect_expr): Likewise. (gnat_stabilize_reference_1): Likewise. (gnat_rewrite_reference): Likewise. * gsocket.h: Likewise. * init.cc (__gnat_error_handler): Likewise. * libgnarl/s-intman.ads: Likewise. * libgnarl/s-osinte__android.ads: Likewise. * libgnarl/s-osinte__darwin.ads: Likewise. * libgnarl/s-osinte__hpux.ads: Likewise. * libgnarl/s-osinte__linux.ads: Likewise. * libgnarl/s-osinte__qnx.ads: Likewise. * libgnarl/s-taskin.ads: Likewise. * rtfinal.cc: Likewise. * s-oscons-tmplt.c (CND): Likewise. * set_targ.ads: Likewise. gcc/analyzer/ChangeLog: * analyzer.cc (is_special_named_call_p): Rename .c names to .cc. (is_named_call_p): Likewise. * region-model-asm.cc (deterministic_p): Likewise. * region.cc (field_region::get_relative_concrete_offset): Likewise. * sm-malloc.cc (method_p): Likewise. * supergraph.cc (superedge::dump_dot): Likewise. gcc/c-family/ChangeLog: * c-ada-spec.cc: Rename .c names to .cc. * c-ada-spec.h: Likewise. * c-common.cc (c_build_vec_convert): Likewise. (warning_candidate_p): Likewise. * c-common.h (enum rid): Likewise. (build_real_imag_expr): Likewise. (finish_label_address_expr): Likewise. (c_get_substring_location): Likewise. (c_build_bind_expr): Likewise. (conflict_marker_get_final_tok_kind): Likewise. (c_parse_error): Likewise. (check_missing_format_attribute): Likewise. (invalid_array_size_error): Likewise. (warn_for_multistatement_macros): Likewise. (build_attr_access_from_parms): Likewise. * c-cppbuiltin.cc (c_cpp_builtins): Likewise. * c-format.cc: Likewise. * c-gimplify.cc (c_gimplify_expr): Likewise. * c-indentation.h: Likewise. * c-objc.h (objc_prop_attr_kind_for_rid): Likewise. * c-omp.cc (c_omp_predetermined_mapping): Likewise. * c-opts.cc (c_common_post_options): Likewise. (set_std_cxx23): Likewise. * c-pragma.cc (handle_pragma_redefine_extname): Likewise. * c-pretty-print.h: Likewise. gcc/c/ChangeLog: * Make-lang.in: Rename .c names to .cc. * c-convert.cc: Likewise. * c-decl.cc (struct lang_identifier): Likewise. (pop_scope): Likewise. (finish_decl): Likewise. * c-objc-common.h (GCC_C_OBJC_COMMON): Likewise. * c-parser.cc (c_parser_skip_to_end_of_block_or_statement): Likewise. * c-parser.h (GCC_C_PARSER_H): Likewise. * c-tree.h (c_keyword_starts_typename): Likewise. (finish_declspecs): Likewise. (c_get_alias_set): Likewise. (enum c_oracle_request): Likewise. (tag_exists_p): Likewise. (set_c_expr_source_range): Likewise. * c-typeck.cc (c_common_type): Likewise. (c_finish_omp_clauses): Likewise. * config-lang.in: Likewise. gcc/cp/ChangeLog: * Make-lang.in: Rename .c names to .cc. * config-lang.in: Likewise. * constexpr.cc (cxx_eval_constant_expression): Likewise. * coroutines.cc (morph_fn_to_coro): Likewise. * cp-gimplify.cc (cp_gimplify_expr): Likewise. * cp-lang.cc (struct lang_hooks): Likewise. (get_template_argument_pack_elems_folded): Likewise. * cp-objcp-common.cc (cp_tree_size): Likewise. (cp_unit_size_without_reusable_padding): Likewise. (pop_file_scope): Likewise. (cp_pushdecl): Likewise. * cp-objcp-common.h (GCC_CP_OBJCP_COMMON): Likewise. (cxx_simulate_record_decl): Likewise. * cp-tree.h (struct named_label_entry): Likewise. (current_function_return_value): Likewise. (more_aggr_init_expr_args_p): Likewise. (get_function_version_dispatcher): Likewise. (common_enclosing_class): Likewise. (strip_fnptr_conv): Likewise. (current_decl_namespace): Likewise. (do_aggregate_paren_init): Likewise. (cp_check_const_attributes): Likewise. (qualified_name_lookup_error): Likewise. (generic_targs_for): Likewise. (mark_exp_read): Likewise. (is_global_friend): Likewise. (maybe_reject_flexarray_init): Likewise. (module_token_lang): Likewise. (handle_module_option): Likewise. (literal_integer_zerop): Likewise. (build_extra_args): Likewise. (build_if_nonnull): Likewise. (maybe_check_overriding_exception_spec): Likewise. (finish_omp_target_clauses): Likewise. (maybe_warn_zero_as_null_pointer_constant): Likewise. (cxx_print_error_function): Likewise. (decl_in_std_namespace_p): Likewise. (merge_exception_specifiers): Likewise. (mangle_module_global_init): Likewise. (cxx_block_may_fallthru): Likewise. (fold_builtin_source_location): Likewise. (enum cp_oracle_request): Likewise. (subsumes): Likewise. (cp_finish_injected_record_type): Likewise. (vtv_build_vtable_verify_fndecl): Likewise. (cp_tree_c_finish_parsing): Likewise. * cvt.cc (diagnose_ref_binding): Likewise. (convert_to_void): Likewise. (convert_force): Likewise. (type_promotes_to): Likewise. * decl.cc (make_unbound_class_template_raw): Likewise. (cxx_init_decl_processing): Likewise. (check_class_member_definition_namespace): Likewise. (cxx_maybe_build_cleanup): Likewise. * decl2.cc (maybe_emit_vtables): Likewise. * error.cc (dump_function_name): Likewise. * init.cc (is_class_type): Likewise. (build_new_1): Likewise. * lang-specs.h: Likewise. * method.cc (make_alias_for_thunk): Likewise. * module.cc (specialization_add): Likewise. (module_state::read_cluster): Likewise. * name-lookup.cc (check_extern_c_conflict): Likewise. * name-lookup.h (struct cxx_binding): Likewise. * parser.cc (cp_parser_identifier): Likewise. * parser.h (struct cp_parser): Likewise. * pt.cc (has_value_dependent_address): Likewise. (push_tinst_level_loc): Likewise. * semantics.cc (finish_omp_clauses): Likewise. (finish_omp_atomic): Likewise. * tree.cc (cp_save_expr): Likewise. (cp_free_lang_data): Likewise. * typeck.cc (cp_common_type): Likewise. (strip_array_domain): Likewise. (rationalize_conditional_expr): Likewise. (check_return_expr): Likewise. * vtable-class-hierarchy.cc: Likewise. gcc/d/ChangeLog: * d-gimplify.cc: Rename .c names to .cc. * d-incpath.cc: Likewise. * lang-specs.h: Likewise. gcc/fortran/ChangeLog: * check.cc (gfc_check_all_any): Rename .c names to .cc. * class.cc (find_intrinsic_vtab): Likewise. * config-lang.in: Likewise. * cpp.cc (cpp_define_builtins): Likewise. * data.cc (get_array_index): Likewise. * decl.cc (match_clist_expr): Likewise. (get_proc_name): Likewise. (gfc_verify_c_interop_param): Likewise. (gfc_get_pdt_instance): Likewise. (gfc_match_formal_arglist): Likewise. (gfc_get_type_attr_spec): Likewise. * dependency.cc: Likewise. * error.cc (gfc_format_decoder): Likewise. * expr.cc (check_restricted): Likewise. (gfc_build_default_init_expr): Likewise. * f95-lang.cc: Likewise. * gfc-internals.texi: Likewise. * gfortran.h (enum match): Likewise. (enum procedure_type): Likewise. (enum oacc_routine_lop): Likewise. (gfc_get_pdt_instance): Likewise. (gfc_end_source_files): Likewise. (gfc_mpz_set_hwi): Likewise. (gfc_get_option_string): Likewise. (gfc_find_sym_in_expr): Likewise. (gfc_errors_to_warnings): Likewise. (gfc_real_4_kind): Likewise. (gfc_free_finalizer): Likewise. (gfc_sym_get_dummy_args): Likewise. (gfc_check_intrinsic_standard): Likewise. (gfc_free_case_list): Likewise. (gfc_resolve_oacc_routines): Likewise. (gfc_check_vardef_context): Likewise. (gfc_free_association_list): Likewise. (gfc_implicit_pure_function): Likewise. (gfc_ref_dimen_size): Likewise. (gfc_compare_actual_formal): Likewise. (gfc_resolve_wait): Likewise. (gfc_dt_upper_string): Likewise. (gfc_generate_module_code): Likewise. (gfc_delete_bbt): Likewise. (debug): Likewise. (gfc_build_block_ns): Likewise. (gfc_dep_difference): Likewise. (gfc_invalid_null_arg): Likewise. (gfc_is_finalizable): Likewise. (gfc_fix_implicit_pure): Likewise. (gfc_is_size_zero_array): Likewise. (gfc_is_reallocatable_lhs): Likewise. * gfortranspec.cc: Likewise. * interface.cc (compare_actual_expr): Likewise. * intrinsic.cc (add_functions): Likewise. * iresolve.cc (gfc_resolve_matmul): Likewise. (gfc_resolve_alarm_sub): Likewise. * iso-c-binding.def: Likewise. * lang-specs.h: Likewise. * libgfortran.h (GFC_STDERR_UNIT_NUMBER): Likewise. * match.cc (gfc_match_label): Likewise. (gfc_match_symbol): Likewise. (match_derived_type_spec): Likewise. (copy_ts_from_selector_to_associate): Likewise. * match.h (gfc_match_call): Likewise. (gfc_get_common): Likewise. (gfc_match_omp_end_single): Likewise. (gfc_match_volatile): Likewise. (gfc_match_bind_c): Likewise. (gfc_match_literal_constant): Likewise. (gfc_match_init_expr): Likewise. (gfc_match_array_constructor): Likewise. (gfc_match_end_interface): Likewise. (gfc_match_print): Likewise. (gfc_match_expr): Likewise. * matchexp.cc (next_operator): Likewise. * mathbuiltins.def: Likewise. * module.cc (free_true_name): Likewise. * openmp.cc (gfc_resolve_omp_parallel_blocks): Likewise. (gfc_omp_save_and_clear_state): Likewise. * parse.cc (parse_union): Likewise. (set_syms_host_assoc): Likewise. * resolve.cc (resolve_actual_arglist): Likewise. (resolve_elemental_actual): Likewise. (check_host_association): Likewise. (resolve_typebound_function): Likewise. (resolve_typebound_subroutine): Likewise. (gfc_resolve_expr): Likewise. (resolve_assoc_var): Likewise. (resolve_typebound_procedures): Likewise. (resolve_equivalence_derived): Likewise. * simplify.cc (simplify_bound): Likewise. * symbol.cc (gfc_set_default_type): Likewise. (gfc_add_ext_attribute): Likewise. * target-memory.cc (gfc_target_interpret_expr): Likewise. * target-memory.h (gfc_target_interpret_expr): Likewise. * trans-array.cc (gfc_get_cfi_dim_sm): Likewise. (gfc_conv_shift_descriptor_lbound): Likewise. (gfc_could_be_alias): Likewise. (gfc_get_dataptr_offset): Likewise. * trans-const.cc: Likewise. * trans-decl.cc (trans_function_start): Likewise. (gfc_trans_deferred_vars): Likewise. (generate_local_decl): Likewise. (gfc_generate_function_code): Likewise. * trans-expr.cc (gfc_vptr_size_get): Likewise. (gfc_trans_class_array_init_assign): Likewise. (POWI_TABLE_SIZE): Likewise. (gfc_conv_procedure_call): Likewise. (gfc_trans_arrayfunc_assign): Likewise. * trans-intrinsic.cc (gfc_conv_intrinsic_len): Likewise. (gfc_conv_intrinsic_loc): Likewise. (conv_intrinsic_event_query): Likewise. * trans-io.cc (gfc_build_st_parameter): Likewise. * trans-openmp.cc (gfc_omp_check_optional_argument): Likewise. (gfc_omp_unshare_expr_r): Likewise. (gfc_trans_omp_array_section): Likewise. (gfc_trans_omp_clauses): Likewise. * trans-stmt.cc (trans_associate_var): Likewise. (gfc_trans_deallocate): Likewise. * trans-stmt.h (gfc_trans_class_init_assign): Likewise. (gfc_trans_deallocate): Likewise. (gfc_trans_oacc_declare): Likewise. * trans-types.cc: Likewise. * trans-types.h (enum gfc_packed): Likewise. * trans.cc (N_): Likewise. (trans_code): Likewise. * trans.h (gfc_build_compare_string): Likewise. (gfc_conv_expr_type): Likewise. (gfc_trans_deferred_vars): Likewise. (getdecls): Likewise. (gfc_get_array_descr_info): Likewise. (gfc_omp_firstprivatize_type_sizes): Likewise. (GTY): Likewise. gcc/go/ChangeLog: * config-lang.in: Rename .c names to .cc. * go-backend.cc: Likewise. * go-lang.cc: Likewise. * gospec.cc: Likewise. * lang-specs.h: Likewise. gcc/jit/ChangeLog: * config-lang.in: Rename .c names to .cc. * docs/_build/texinfo/libgccjit.texi: Likewise. * docs/internals/index.rst: Likewise. * jit-builtins.cc (builtins_manager::make_builtin_function): Likewise. * jit-playback.cc (fold_const_var): Likewise. (playback::context::~context): Likewise. (new_field): Likewise. (new_bitfield): Likewise. (new_compound_type): Likewise. (playback::compound_type::set_fields): Likewise. (global_set_init_rvalue): Likewise. (load_blob_in_ctor): Likewise. (new_global_initialized): Likewise. (double>): Likewise. (new_string_literal): Likewise. (as_truth_value): Likewise. (build_call): Likewise. (playback::context::build_cast): Likewise. (new_array_access): Likewise. (new_field_access): Likewise. (dereference): Likewise. (postprocess): Likewise. (add_jump): Likewise. (add_switch): Likewise. (build_goto_operands): Likewise. (playback::context::read_dump_file): Likewise. (init_types): Likewise. * jit-recording.cc (recording::context::get_int_type): Likewise. * jit-recording.h: Likewise. * libgccjit.cc (compatible_types): Likewise. (gcc_jit_context_acquire): Likewise. (gcc_jit_context_release): Likewise. (gcc_jit_context_new_child_context): Likewise. (gcc_jit_type_as_object): Likewise. (gcc_jit_context_get_type): Likewise. (gcc_jit_context_get_int_type): Likewise. (gcc_jit_type_get_pointer): Likewise. (gcc_jit_type_get_const): Likewise. (gcc_jit_type_get_volatile): Likewise. (gcc_jit_type_dyncast_array): Likewise. (gcc_jit_type_is_bool): Likewise. (gcc_jit_type_is_pointer): Likewise. (gcc_jit_type_is_integral): Likewise. (gcc_jit_type_dyncast_vector): Likewise. (gcc_jit_type_is_struct): Likewise. (gcc_jit_vector_type_get_num_units): Likewise. (gcc_jit_vector_type_get_element_type): Likewise. (gcc_jit_type_unqualified): Likewise. (gcc_jit_type_dyncast_function_ptr_type): Likewise. (gcc_jit_function_type_get_return_type): Likewise. (gcc_jit_function_type_get_param_count): Likewise. (gcc_jit_function_type_get_param_type): Likewise. (gcc_jit_context_new_array_type): Likewise. (gcc_jit_context_new_field): Likewise. (gcc_jit_field_as_object): Likewise. (gcc_jit_context_new_struct_type): Likewise. (gcc_jit_struct_as_type): Likewise. (gcc_jit_struct_set_fields): Likewise. (gcc_jit_struct_get_field_count): Likewise. (gcc_jit_context_new_union_type): Likewise. (gcc_jit_context_new_function_ptr_type): Likewise. (gcc_jit_param_as_rvalue): Likewise. (gcc_jit_context_new_function): Likewise. (gcc_jit_function_get_return_type): Likewise. (gcc_jit_function_dump_to_dot): Likewise. (gcc_jit_block_get_function): Likewise. (gcc_jit_global_set_initializer_rvalue): Likewise. (gcc_jit_rvalue_get_type): Likewise. (gcc_jit_context_new_rvalue_from_int): Likewise. (gcc_jit_context_one): Likewise. (gcc_jit_context_new_rvalue_from_double): Likewise. (gcc_jit_context_null): Likewise. (gcc_jit_context_new_string_literal): Likewise. (valid_binary_op_p): Likewise. (gcc_jit_context_new_binary_op): Likewise. (gcc_jit_context_new_comparison): Likewise. (gcc_jit_context_new_call): Likewise. (is_valid_cast): Likewise. (gcc_jit_context_new_cast): Likewise. (gcc_jit_object_get_context): Likewise. (gcc_jit_object_get_debug_string): Likewise. (gcc_jit_lvalue_access_field): Likewise. (gcc_jit_rvalue_access_field): Likewise. (gcc_jit_rvalue_dereference_field): Likewise. (gcc_jit_rvalue_dereference): Likewise. (gcc_jit_lvalue_get_address): Likewise. (gcc_jit_lvalue_set_tls_model): Likewise. (gcc_jit_lvalue_set_link_section): Likewise. (gcc_jit_function_new_local): Likewise. (gcc_jit_block_add_eval): Likewise. (gcc_jit_block_add_assignment): Likewise. (is_bool): Likewise. (gcc_jit_block_end_with_conditional): Likewise. (gcc_jit_block_add_comment): Likewise. (gcc_jit_block_end_with_jump): Likewise. (gcc_jit_block_end_with_return): Likewise. (gcc_jit_block_end_with_void_return): Likewise. (case_range_validator::case_range_validator): Likewise. (case_range_validator::validate): Likewise. (case_range_validator::get_wide_int): Likewise. (gcc_jit_block_end_with_switch): Likewise. (gcc_jit_context_set_str_option): Likewise. (gcc_jit_context_set_int_option): Likewise. (gcc_jit_context_set_bool_option): Likewise. (gcc_jit_context_set_bool_allow_unreachable_blocks): Likewise. (gcc_jit_context_set_bool_use_external_driver): Likewise. (gcc_jit_context_add_command_line_option): Likewise. (gcc_jit_context_add_driver_option): Likewise. (gcc_jit_context_enable_dump): Likewise. (gcc_jit_context_compile): Likewise. (gcc_jit_context_compile_to_file): Likewise. (gcc_jit_context_set_logfile): Likewise. (gcc_jit_context_dump_reproducer_to_file): Likewise. (gcc_jit_context_get_first_error): Likewise. (gcc_jit_context_get_last_error): Likewise. (gcc_jit_result_get_code): Likewise. (gcc_jit_result_get_global): Likewise. (gcc_jit_rvalue_set_bool_require_tail_call): Likewise. (gcc_jit_type_get_aligned): Likewise. (gcc_jit_type_get_vector): Likewise. (gcc_jit_function_get_address): Likewise. (gcc_jit_version_patchlevel): Likewise. (gcc_jit_block_add_extended_asm): Likewise. (gcc_jit_extended_asm_as_object): Likewise. (gcc_jit_extended_asm_set_volatile_flag): Likewise. (gcc_jit_extended_asm_set_inline_flag): Likewise. (gcc_jit_extended_asm_add_output_operand): Likewise. (gcc_jit_extended_asm_add_input_operand): Likewise. (gcc_jit_extended_asm_add_clobber): Likewise. * notes.txt: Likewise. gcc/lto/ChangeLog: * config-lang.in: Rename .c names to .cc. * lang-specs.h: Likewise. * lto-common.cc (gimple_register_canonical_type_1): Likewise. * lto-common.h: Likewise. * lto-dump.cc (lto_main): Likewise. * lto-lang.cc (handle_fnspec_attribute): Likewise. (lto_getdecls): Likewise. (lto_init): Likewise. * lto.cc (lto_main): Likewise. * lto.h: Likewise. gcc/objc/ChangeLog: * Make-lang.in: Rename .c names to .cc. * config-lang.in: Likewise. * lang-specs.h: Likewise. * objc-act.cc (objc_build_component_ref): Likewise. (objc_copy_binfo): Likewise. (lookup_method_in_hash_lists): Likewise. (objc_finish_foreach_loop): Likewise. * objc-act.h (objc_common_init_ts): Likewise. * objc-gnu-runtime-abi-01.cc: Likewise. * objc-lang.cc (struct lang_hooks): Likewise. * objc-map.cc: Likewise. * objc-next-runtime-abi-01.cc (generate_objc_symtab_decl): Likewise. * objc-runtime-shared-support.cc: Likewise. * objc-runtime-shared-support.h (build_protocol_initializer): Likewise. gcc/objcp/ChangeLog: * Make-lang.in: Rename .c names to .cc. * config-lang.in: Likewise. * lang-specs.h: Likewise. * objcp-decl.cc (objcp_end_compound_stmt): Likewise. * objcp-lang.cc (struct lang_hooks): Likewise. gcc/po/ChangeLog: * EXCLUDES: Rename .c names to .cc. libcpp/ChangeLog: * Makefile.in: Rename .c names to .cc. * charset.cc (convert_escape): Likewise. * directives.cc (directive_diagnostics): Likewise. (_cpp_handle_directive): Likewise. (lex_macro_node): Likewise. * include/cpplib.h (struct _cpp_file): Likewise. (PURE_ZERO): Likewise. (cpp_defined): Likewise. (cpp_error_at): Likewise. (cpp_forall_identifiers): Likewise. (cpp_compare_macros): Likewise. (cpp_get_converted_source): Likewise. (cpp_read_state): Likewise. (cpp_directive_only_process): Likewise. (struct cpp_decoded_char): Likewise. * include/line-map.h (enum lc_reason): Likewise. (enum location_aspect): Likewise. * include/mkdeps.h: Likewise. * init.cc (cpp_destroy): Likewise. (cpp_finish): Likewise. * internal.h (struct cpp_reader): Likewise. (_cpp_defined_macro_p): Likewise. (_cpp_backup_tokens_direct): Likewise. (_cpp_destroy_hashtable): Likewise. (_cpp_has_header): Likewise. (_cpp_expand_op_stack): Likewise. (_cpp_commit_buff): Likewise. (_cpp_restore_special_builtin): Likewise. (_cpp_bracket_include): Likewise. (_cpp_replacement_text_len): Likewise. (ufputs): Likewise. * line-map.cc (linemap_macro_loc_to_exp_point): Likewise. (linemap_check_files_exited): Likewise. (line_map_new_raw): Likewise. * traditional.cc (enum ls): Likewise. --- MAINTAINERS | 14 +- contrib/filter-clang-warnings.py | 14 +- contrib/gcc_update | 6 +- contrib/header-tools/README | 34 +-- contrib/paranoia.cc | 2 +- gcc/Makefile.in | 284 ++++++++++++------------- gcc/ada/Make-generated.in | 2 +- gcc/ada/adaint.c | 2 +- gcc/ada/ctrl_c.c | 2 +- gcc/ada/gcc-interface/Makefile.in | 52 ++--- gcc/ada/gcc-interface/config-lang.in | 2 +- gcc/ada/gcc-interface/decl.cc | 4 +- gcc/ada/gcc-interface/gigi.h | 16 +- gcc/ada/gcc-interface/lang-specs.h | 2 +- gcc/ada/gcc-interface/utils.cc | 8 +- gcc/ada/gcc-interface/utils2.cc | 8 +- gcc/ada/gsocket.h | 2 +- gcc/ada/init.cc | 4 +- gcc/ada/libgnarl/s-intman.ads | 2 +- gcc/ada/libgnarl/s-osinte__android.ads | 2 +- gcc/ada/libgnarl/s-osinte__darwin.ads | 2 +- gcc/ada/libgnarl/s-osinte__hpux.ads | 2 +- gcc/ada/libgnarl/s-osinte__linux.ads | 2 +- gcc/ada/libgnarl/s-osinte__qnx.ads | 2 +- gcc/ada/libgnarl/s-taskin.ads | 2 +- gcc/ada/rtfinal.cc | 2 +- gcc/ada/s-oscons-tmplt.c | 2 +- gcc/ada/set_targ.ads | 4 +- gcc/alias.h | 2 +- gcc/analyzer/analyzer.cc | 4 +- gcc/analyzer/region-model-asm.cc | 2 +- gcc/analyzer/region.cc | 2 +- gcc/analyzer/sm-malloc.cc | 2 +- gcc/analyzer/supergraph.cc | 2 +- gcc/asan.cc | 2 +- gcc/auto-profile.h | 2 +- gcc/basic-block.h | 2 +- gcc/btfout.cc | 2 +- gcc/builtins.cc | 8 +- gcc/c-family/c-ada-spec.cc | 2 +- gcc/c-family/c-ada-spec.h | 2 +- gcc/c-family/c-common.cc | 4 +- gcc/c-family/c-common.h | 30 +-- gcc/c-family/c-cppbuiltin.cc | 2 +- gcc/c-family/c-format.cc | 2 +- gcc/c-family/c-gimplify.cc | 2 +- gcc/c-family/c-indentation.h | 2 +- gcc/c-family/c-objc.h | 2 +- gcc/c-family/c-omp.cc | 4 +- gcc/c-family/c-opts.cc | 4 +- gcc/c-family/c-pragma.cc | 2 +- gcc/c-family/c-pretty-print.h | 2 +- gcc/c/Make-lang.in | 10 +- gcc/c/c-convert.cc | 10 +- gcc/c/c-decl.cc | 6 +- gcc/c/c-objc-common.h | 2 +- gcc/c/c-parser.cc | 2 +- gcc/c/c-parser.h | 2 +- gcc/c/c-tree.h | 22 +- gcc/c/c-typeck.cc | 4 +- gcc/c/config-lang.in | 2 +- gcc/caller-save.cc | 4 +- gcc/calls.cc | 12 +- gcc/cfg-flags.def | 6 +- gcc/cfganal.cc | 2 +- gcc/cfgcleanup.cc | 12 +- gcc/cfgexpand.cc | 2 +- gcc/cfghooks.cc | 4 +- gcc/cfghooks.h | 4 +- gcc/cfgrtl.cc | 10 +- gcc/cgraph.cc | 4 +- gcc/cgraph.h | 22 +- gcc/cgraphclones.cc | 2 +- gcc/cgraphunit.cc | 2 +- gcc/collect-utils.h | 2 +- gcc/collect2-aix.h | 2 +- gcc/collect2.cc | 2 +- gcc/combine-stack-adj.cc | 2 +- gcc/combine.cc | 6 +- gcc/common.opt | 2 +- gcc/common/config/aarch64/aarch64-common.cc | 2 +- gcc/common/config/arm/arm-common.cc | 2 +- gcc/common/config/avr/avr-common.cc | 2 +- gcc/common/config/i386/i386-isas.h | 4 +- gcc/conditions.h | 2 +- gcc/config.gcc | 40 ++-- gcc/config/aarch64/aarch64-builtins.cc | 2 +- gcc/config/aarch64/aarch64-protos.h | 4 +- gcc/config/aarch64/aarch64-sve-builtins.cc | 2 +- gcc/config/aarch64/aarch64.cc | 12 +- gcc/config/aarch64/aarch64.h | 6 +- gcc/config/aarch64/cortex-a57-fma-steering.cc | 4 +- gcc/config/aarch64/driver-aarch64.cc | 2 +- gcc/config/aarch64/t-aarch64 | 26 +-- gcc/config/aarch64/x-aarch64 | 2 +- gcc/config/aarch64/x-darwin | 2 +- gcc/config/alpha/alpha-protos.h | 2 +- gcc/config/alpha/alpha.cc | 2 +- gcc/config/alpha/alpha.h | 8 +- gcc/config/alpha/alpha.md | 4 +- gcc/config/alpha/driver-alpha.cc | 2 +- gcc/config/alpha/x-alpha | 2 +- gcc/config/arc/arc-protos.h | 2 +- gcc/config/arc/arc.cc | 12 +- gcc/config/arc/arc.md | 8 +- gcc/config/arc/builtins.def | 4 +- gcc/config/arc/t-arc | 6 +- gcc/config/arm/arm-c.cc | 4 +- gcc/config/arm/arm-protos.h | 8 +- gcc/config/arm/arm.cc | 12 +- gcc/config/arm/arm.h | 8 +- gcc/config/arm/arm.md | 2 +- gcc/config/arm/driver-arm.cc | 2 +- gcc/config/arm/symbian.h | 2 +- gcc/config/arm/t-arm | 16 +- gcc/config/arm/thumb1.md | 10 +- gcc/config/arm/x-arm | 2 +- gcc/config/avr/avr-c.cc | 6 +- gcc/config/avr/avr-fixed.md | 2 +- gcc/config/avr/avr-log.cc | 2 +- gcc/config/avr/avr-mcus.def | 2 +- gcc/config/avr/avr-modes.def | 2 +- gcc/config/avr/avr-passes.def | 2 +- gcc/config/avr/avr-protos.h | 4 +- gcc/config/avr/avr.cc | 18 +- gcc/config/avr/avr.h | 4 +- gcc/config/avr/avr.md | 6 +- gcc/config/avr/builtins.def | 4 +- gcc/config/avr/gen-avr-mmcu-specs.cc | 6 +- gcc/config/avr/gen-avr-mmcu-texi.cc | 6 +- gcc/config/avr/t-avr | 16 +- gcc/config/bfin/bfin.cc | 2 +- gcc/config/bpf/bpf-protos.h | 2 +- gcc/config/bpf/bpf.h | 2 +- gcc/config/bpf/t-bpf | 2 +- gcc/config/c6x/c6x-protos.h | 4 +- gcc/config/cr16/cr16-protos.h | 2 +- gcc/config/cris/cris.cc | 8 +- gcc/config/cris/cris.h | 8 +- gcc/config/cris/cris.opt | 2 +- gcc/config/cris/sync.md | 2 +- gcc/config/csky/csky.cc | 2 +- gcc/config/darwin-c.cc | 2 +- gcc/config/darwin-f.cc | 2 +- gcc/config/darwin-sections.def | 8 +- gcc/config/darwin.cc | 10 +- gcc/config/darwin.h | 4 +- gcc/config/elfos.h | 2 +- gcc/config/epiphany/epiphany-sched.md | 2 +- gcc/config/epiphany/epiphany.cc | 2 +- gcc/config/epiphany/epiphany.h | 6 +- gcc/config/epiphany/mode-switch-use.cc | 2 +- gcc/config/epiphany/predicates.md | 2 +- gcc/config/epiphany/t-epiphany | 4 +- gcc/config/fr30/fr30-protos.h | 2 +- gcc/config/frv/frv-protos.h | 2 +- gcc/config/frv/frv.cc | 2 +- gcc/config/frv/frv.h | 2 +- gcc/config/ft32/ft32-protos.h | 2 +- gcc/config/gcn/gcn-hsa.h | 2 +- gcc/config/gcn/gcn.cc | 2 +- gcc/config/gcn/mkoffload.cc | 2 +- gcc/config/gcn/t-gcn-hsa | 8 +- gcc/config/gcn/t-omp-device | 2 +- gcc/config/h8300/h8300-protos.h | 4 +- gcc/config/h8300/h8300.cc | 4 +- gcc/config/h8300/h8300.h | 6 +- gcc/config/i386/cygming.h | 4 +- gcc/config/i386/djgpp.h | 2 +- gcc/config/i386/dragonfly.h | 2 +- gcc/config/i386/driver-i386.cc | 2 +- gcc/config/i386/freebsd.h | 2 +- gcc/config/i386/i386-c.cc | 2 +- gcc/config/i386/i386-expand.cc | 2 +- gcc/config/i386/i386-options.cc | 2 +- gcc/config/i386/i386-protos.h | 12 +- gcc/config/i386/i386.cc | 12 +- gcc/config/i386/i386.h | 16 +- gcc/config/i386/i386.md | 6 +- gcc/config/i386/lynx.h | 2 +- gcc/config/i386/mmx.md | 8 +- gcc/config/i386/sse.md | 10 +- gcc/config/i386/t-cygming | 18 +- gcc/config/i386/t-djgpp | 4 +- gcc/config/i386/t-gnu-property | 2 +- gcc/config/i386/t-i386 | 20 +- gcc/config/i386/t-intelmic | 2 +- gcc/config/i386/t-omp-device | 4 +- gcc/config/i386/winnt-cxx.cc | 4 +- gcc/config/i386/winnt.cc | 8 +- gcc/config/i386/x-cygwin | 4 +- gcc/config/i386/x-darwin | 2 +- gcc/config/i386/x-i386 | 2 +- gcc/config/i386/x-mingw32 | 6 +- gcc/config/i386/x86-tune-sched-core.cc | 2 +- gcc/config/i386/x86-tune.def | 4 +- gcc/config/i386/xm-djgpp.h | 4 +- gcc/config/ia64/freebsd.h | 4 +- gcc/config/ia64/hpux.h | 2 +- gcc/config/ia64/ia64-protos.h | 2 +- gcc/config/ia64/ia64.cc | 6 +- gcc/config/ia64/ia64.h | 2 +- gcc/config/ia64/ia64.md | 4 +- gcc/config/ia64/predicates.md | 2 +- gcc/config/ia64/sysv4.h | 4 +- gcc/config/ia64/t-ia64 | 6 +- gcc/config/iq2000/iq2000.h | 2 +- gcc/config/iq2000/iq2000.md | 4 +- gcc/config/linux.h | 4 +- gcc/config/m32c/m32c.cc | 2 +- gcc/config/m32c/m32c.h | 2 +- gcc/config/m32c/t-m32c | 2 +- gcc/config/m32r/m32r-protos.h | 2 +- gcc/config/m32r/m32r.cc | 2 +- gcc/config/m32r/m32r.h | 4 +- gcc/config/m32r/m32r.md | 2 +- gcc/config/m68k/m68k-isas.def | 2 +- gcc/config/m68k/m68k-microarchs.def | 2 +- gcc/config/m68k/m68k-protos.h | 6 +- gcc/config/m68k/m68k.cc | 10 +- gcc/config/m68k/m68k.h | 4 +- gcc/config/m68k/m68k.md | 4 +- gcc/config/m68k/m68kemb.h | 2 +- gcc/config/m68k/uclinux.h | 2 +- gcc/config/mcore/mcore-protos.h | 2 +- gcc/config/mcore/mcore.cc | 4 +- gcc/config/mcore/mcore.h | 4 +- gcc/config/mcore/mcore.md | 2 +- gcc/config/microblaze/microblaze-protos.h | 2 +- gcc/config/microblaze/microblaze.cc | 12 +- gcc/config/microblaze/microblaze.h | 2 +- gcc/config/microblaze/microblaze.md | 4 +- gcc/config/microblaze/t-microblaze | 4 +- gcc/config/mips/driver-native.cc | 2 +- gcc/config/mips/loongson2ef.md | 2 +- gcc/config/mips/mips-protos.h | 2 +- gcc/config/mips/mips.cc | 10 +- gcc/config/mips/mips.h | 2 +- gcc/config/mips/mips.md | 2 +- gcc/config/mips/t-mips | 4 +- gcc/config/mips/x-native | 2 +- gcc/config/mmix/mmix-protos.h | 2 +- gcc/config/mmix/mmix.cc | 6 +- gcc/config/mmix/mmix.h | 2 +- gcc/config/mmix/mmix.md | 4 +- gcc/config/mmix/predicates.md | 2 +- gcc/config/mn10300/mn10300.cc | 6 +- gcc/config/mn10300/mn10300.h | 6 +- gcc/config/moxie/moxie-protos.h | 2 +- gcc/config/moxie/uclinux.h | 2 +- gcc/config/msp430/msp430-devices.cc | 2 +- gcc/config/msp430/msp430.cc | 4 +- gcc/config/msp430/msp430.h | 4 +- gcc/config/msp430/t-msp430 | 6 +- gcc/config/nds32/nds32-cost.cc | 6 +- gcc/config/nds32/nds32-doubleword.md | 2 +- gcc/config/nds32/nds32.cc | 4 +- gcc/config/nds32/nds32.h | 10 +- gcc/config/nds32/predicates.md | 12 +- gcc/config/nds32/t-nds32 | 40 ++-- gcc/config/nios2/nios2.cc | 2 +- gcc/config/nvptx/nvptx-protos.h | 2 +- gcc/config/nvptx/nvptx.cc | 2 +- gcc/config/nvptx/nvptx.h | 2 +- gcc/config/nvptx/t-nvptx | 4 +- gcc/config/nvptx/t-omp-device | 2 +- gcc/config/pa/elf.h | 2 +- gcc/config/pa/pa-linux.h | 2 +- gcc/config/pa/pa-netbsd.h | 2 +- gcc/config/pa/pa-openbsd.h | 2 +- gcc/config/pa/pa-protos.h | 10 +- gcc/config/pa/pa.cc | 8 +- gcc/config/pa/pa.h | 8 +- gcc/config/pa/pa.md | 8 +- gcc/config/pa/som.h | 2 +- gcc/config/pa/t-pa | 2 +- gcc/config/pdp11/pdp11.cc | 2 +- gcc/config/pdp11/pdp11.h | 2 +- gcc/config/pdp11/pdp11.md | 2 +- gcc/config/pdp11/t-pdp11 | 2 +- gcc/config/pru/pru.md | 2 +- gcc/config/pru/t-pru | 4 +- gcc/config/riscv/riscv-protos.h | 10 +- gcc/config/riscv/riscv.cc | 2 +- gcc/config/riscv/riscv.h | 4 +- gcc/config/riscv/t-riscv | 16 +- gcc/config/rl78/rl78.cc | 2 +- gcc/config/rl78/t-rl78 | 2 +- gcc/config/rs6000/aix.h | 4 +- gcc/config/rs6000/aix71.h | 2 +- gcc/config/rs6000/aix72.h | 2 +- gcc/config/rs6000/aix73.h | 2 +- gcc/config/rs6000/darwin.h | 6 +- gcc/config/rs6000/driver-rs6000.cc | 2 +- gcc/config/rs6000/freebsd.h | 4 +- gcc/config/rs6000/freebsd64.h | 4 +- gcc/config/rs6000/lynx.h | 2 +- gcc/config/rs6000/rbtree.cc | 2 +- gcc/config/rs6000/rbtree.h | 2 +- gcc/config/rs6000/rs6000-c.cc | 2 +- gcc/config/rs6000/rs6000-call.cc | 6 +- gcc/config/rs6000/rs6000-cpus.def | 2 +- gcc/config/rs6000/rs6000-gen-builtins.cc | 2 +- gcc/config/rs6000/rs6000-internal.h | 10 +- gcc/config/rs6000/rs6000-logue.cc | 4 +- gcc/config/rs6000/rs6000-overload.def | 10 +- gcc/config/rs6000/rs6000-p8swap.cc | 4 +- gcc/config/rs6000/rs6000-protos.h | 6 +- gcc/config/rs6000/rs6000.cc | 16 +- gcc/config/rs6000/rs6000.h | 16 +- gcc/config/rs6000/rs6000.md | 2 +- gcc/config/rs6000/sysv4.h | 2 +- gcc/config/rs6000/t-linux | 2 +- gcc/config/rs6000/t-linux64 | 2 +- gcc/config/rs6000/t-rs6000 | 34 +-- gcc/config/rs6000/x-darwin | 2 +- gcc/config/rs6000/x-darwin64 | 2 +- gcc/config/rs6000/x-rs6000 | 2 +- gcc/config/rs6000/xcoff.h | 4 +- gcc/config/rx/rx.cc | 2 +- gcc/config/s390/constraints.md | 8 +- gcc/config/s390/driver-native.cc | 2 +- gcc/config/s390/htmxlintrin.h | 2 +- gcc/config/s390/s390-builtins.def | 8 +- gcc/config/s390/s390-builtins.h | 2 +- gcc/config/s390/s390-c.cc | 2 +- gcc/config/s390/s390-opts.h | 2 +- gcc/config/s390/s390-protos.h | 10 +- gcc/config/s390/s390.cc | 12 +- gcc/config/s390/s390.h | 8 +- gcc/config/s390/s390.md | 8 +- gcc/config/s390/t-s390 | 6 +- gcc/config/s390/vx-builtins.md | 2 +- gcc/config/s390/x-native | 2 +- gcc/config/sh/divtab-sh4-300.cc | 2 +- gcc/config/sh/divtab-sh4.cc | 2 +- gcc/config/sh/divtab.cc | 2 +- gcc/config/sh/elf.h | 2 +- gcc/config/sh/sh-protos.h | 2 +- gcc/config/sh/sh.cc | 6 +- gcc/config/sh/sh.h | 8 +- gcc/config/sh/t-sh | 4 +- gcc/config/sol2-protos.h | 6 +- gcc/config/sol2.h | 4 +- gcc/config/sparc/driver-sparc.cc | 2 +- gcc/config/sparc/freebsd.h | 4 +- gcc/config/sparc/sparc-protos.h | 2 +- gcc/config/sparc/sparc.cc | 6 +- gcc/config/sparc/sparc.h | 6 +- gcc/config/sparc/sparc.md | 4 +- gcc/config/sparc/t-sparc | 4 +- gcc/config/sparc/x-sparc | 2 +- gcc/config/stormy16/stormy16.cc | 2 +- gcc/config/t-darwin | 10 +- gcc/config/t-dragonfly | 2 +- gcc/config/t-freebsd | 2 +- gcc/config/t-glibc | 4 +- gcc/config/t-linux | 2 +- gcc/config/t-netbsd | 4 +- gcc/config/t-openbsd | 2 +- gcc/config/t-pnt16-warn | 2 +- gcc/config/t-sol2 | 10 +- gcc/config/t-vxworks | 4 +- gcc/config/t-winnt | 2 +- gcc/config/tilegx/t-tilegx | 6 +- gcc/config/tilegx/tilegx-c.cc | 2 +- gcc/config/tilegx/tilegx-protos.h | 2 +- gcc/config/tilegx/tilegx.md | 2 +- gcc/config/tilepro/t-tilepro | 6 +- gcc/config/tilepro/tilepro-c.cc | 2 +- gcc/config/v850/t-v850 | 4 +- gcc/config/v850/v850-protos.h | 2 +- gcc/config/v850/v850.cc | 4 +- gcc/config/v850/v850.h | 6 +- gcc/config/vax/vax.cc | 4 +- gcc/config/vax/vax.h | 2 +- gcc/config/vax/vax.md | 2 +- gcc/config/visium/visium.cc | 2 +- gcc/config/visium/visium.h | 6 +- gcc/config/vms/t-vms | 6 +- gcc/config/vms/vms-crtlmap.map | 2 +- gcc/config/vms/vms-protos.h | 4 +- gcc/config/vx-common.h | 2 +- gcc/config/x-darwin | 2 +- gcc/config/x-hpux | 4 +- gcc/config/x-linux | 2 +- gcc/config/x-netbsd | 4 +- gcc/config/x-openbsd | 4 +- gcc/config/x-solaris | 2 +- gcc/config/xtensa/xtensa-protos.h | 2 +- gcc/config/xtensa/xtensa.cc | 4 +- gcc/config/xtensa/xtensa.h | 2 +- gcc/configure.ac | 8 +- gcc/context.cc | 2 +- gcc/convert.h | 2 +- gcc/coretypes.h | 2 +- gcc/coverage.cc | 2 +- gcc/coverage.h | 2 +- gcc/cp/Make-lang.in | 8 +- gcc/cp/config-lang.in | 34 +-- gcc/cp/constexpr.cc | 2 +- gcc/cp/coroutines.cc | 2 +- gcc/cp/cp-gimplify.cc | 4 +- gcc/cp/cp-lang.cc | 4 +- gcc/cp/cp-objcp-common.cc | 8 +- gcc/cp/cp-objcp-common.h | 4 +- gcc/cp/cp-tree.h | 84 ++++---- gcc/cp/cvt.cc | 18 +- gcc/cp/decl.cc | 8 +- gcc/cp/decl2.cc | 2 +- gcc/cp/error.cc | 2 +- gcc/cp/init.cc | 4 +- gcc/cp/lang-specs.h | 2 +- gcc/cp/method.cc | 2 +- gcc/cp/module.cc | 4 +- gcc/cp/name-lookup.cc | 2 +- gcc/cp/name-lookup.h | 2 +- gcc/cp/parser.cc | 4 +- gcc/cp/parser.h | 2 +- gcc/cp/pt.cc | 4 +- gcc/cp/semantics.cc | 6 +- gcc/cp/tree.cc | 4 +- gcc/cp/typeck.cc | 8 +- gcc/cp/vtable-class-hierarchy.cc | 2 +- gcc/cppdefault.h | 2 +- gcc/cprop.cc | 4 +- gcc/cse.cc | 4 +- gcc/ctfc.h | 4 +- gcc/d/d-gimplify.cc | 2 +- gcc/d/d-incpath.cc | 2 +- gcc/d/lang-specs.h | 2 +- gcc/data-streamer.h | 6 +- gcc/dbgcnt.def | 2 +- gcc/dbxout.cc | 4 +- gcc/dbxout.h | 2 +- gcc/debug.h | 8 +- gcc/df-core.cc | 4 +- gcc/df-scan.cc | 4 +- gcc/df.h | 8 +- gcc/dfp.cc | 2 +- gcc/diagnostic-color.cc | 2 +- gcc/diagnostic-event-id.h | 2 +- gcc/diagnostic-show-locus.cc | 2 +- gcc/diagnostic.cc | 8 +- gcc/doc/avr-mmcu.texi | 4 +- gcc/doc/cfg.texi | 2 +- gcc/doc/contrib.texi | 2 +- gcc/doc/cppinternals.texi | 6 +- gcc/doc/extend.texi | 2 +- gcc/doc/generic.texi | 8 +- gcc/doc/gimple.texi | 8 +- gcc/doc/gty.texi | 8 +- gcc/doc/invoke.texi | 6 +- gcc/doc/loop.texi | 2 +- gcc/doc/lto.texi | 40 ++-- gcc/doc/match-and-simplify.texi | 2 +- gcc/doc/md.texi | 6 +- gcc/doc/optinfo.texi | 4 +- gcc/doc/options.texi | 2 +- gcc/doc/passes.texi | 288 +++++++++++++------------- gcc/doc/plugins.texi | 4 +- gcc/doc/rtl.texi | 10 +- gcc/doc/sourcebuild.texi | 6 +- gcc/doc/tm.texi | 46 ++-- gcc/doc/tm.texi.in | 28 +-- gcc/doc/tree-ssa.texi | 6 +- gcc/dojump.cc | 2 +- gcc/dojump.h | 2 +- gcc/dumpfile.cc | 34 +-- gcc/dumpfile.h | 18 +- gcc/dwarf2asm.cc | 2 +- gcc/dwarf2ctf.h | 4 +- gcc/dwarf2out.cc | 24 +-- gcc/dwarf2out.h | 8 +- gcc/emit-rtl.cc | 6 +- gcc/emit-rtl.h | 6 +- gcc/errors.cc | 8 +- gcc/et-forest.cc | 2 +- gcc/except.cc | 18 +- gcc/explow.cc | 4 +- gcc/explow.h | 2 +- gcc/expmed.h | 2 +- gcc/expr.cc | 10 +- gcc/file-prefix-map.cc | 2 +- gcc/final.cc | 10 +- gcc/fixed-value.h | 2 +- gcc/flag-types.h | 20 +- gcc/fold-const.cc | 8 +- gcc/fortran/check.cc | 4 +- gcc/fortran/class.cc | 4 +- gcc/fortran/config-lang.in | 2 +- gcc/fortran/cpp.cc | 4 +- gcc/fortran/data.cc | 8 +- gcc/fortran/decl.cc | 20 +- gcc/fortran/dependency.cc | 2 +- gcc/fortran/error.cc | 2 +- gcc/fortran/expr.cc | 8 +- gcc/fortran/f95-lang.cc | 2 +- gcc/fortran/gfc-internals.texi | 12 +- gcc/fortran/gfortran.h | 86 ++++---- gcc/fortran/gfortranspec.cc | 4 +- gcc/fortran/interface.cc | 2 +- gcc/fortran/intrinsic.cc | 4 +- gcc/fortran/iresolve.cc | 4 +- gcc/fortran/iso-c-binding.def | 2 +- gcc/fortran/lang-specs.h | 4 +- gcc/fortran/libgfortran.h | 2 +- gcc/fortran/match.cc | 16 +- gcc/fortran/match.h | 28 +-- gcc/fortran/matchexp.cc | 2 +- gcc/fortran/mathbuiltins.def | 2 +- gcc/fortran/module.cc | 2 +- gcc/fortran/openmp.cc | 4 +- gcc/fortran/parse.cc | 6 +- gcc/fortran/resolve.cc | 22 +- gcc/fortran/simplify.cc | 2 +- gcc/fortran/symbol.cc | 4 +- gcc/fortran/target-memory.cc | 2 +- gcc/fortran/target-memory.h | 2 +- gcc/fortran/trans-array.cc | 12 +- gcc/fortran/trans-const.cc | 2 +- gcc/fortran/trans-decl.cc | 12 +- gcc/fortran/trans-expr.cc | 16 +- gcc/fortran/trans-intrinsic.cc | 8 +- gcc/fortran/trans-io.cc | 2 +- gcc/fortran/trans-openmp.cc | 8 +- gcc/fortran/trans-stmt.cc | 4 +- gcc/fortran/trans-stmt.h | 8 +- gcc/fortran/trans-types.cc | 2 +- gcc/fortran/trans-types.h | 2 +- gcc/fortran/trans.cc | 4 +- gcc/fortran/trans.h | 14 +- gcc/fp-test.cc | 2 +- gcc/function.cc | 4 +- gcc/function.h | 2 +- gcc/fwprop.cc | 2 +- gcc/gcc-main.cc | 4 +- gcc/gcc-rich-location.h | 2 +- gcc/gcc-symtab.h | 2 +- gcc/gcc.cc | 16 +- gcc/gcc.h | 6 +- gcc/gcov-dump.cc | 2 +- gcc/gcov.cc | 10 +- gcc/gcse-common.cc | 2 +- gcc/gcse.cc | 4 +- gcc/genattr-common.cc | 2 +- gcc/genattrtab.cc | 6 +- gcc/genautomata.cc | 2 +- gcc/genconditions.cc | 2 +- gcc/genconstants.cc | 2 +- gcc/genemit.cc | 4 +- gcc/generic-match-head.cc | 2 +- gcc/genextract.cc | 2 +- gcc/gengenrtl.cc | 2 +- gcc/gengtype-parse.cc | 2 +- gcc/gengtype-state.cc | 8 +- gcc/gengtype.cc | 48 ++--- gcc/gengtype.h | 8 +- gcc/genmatch.cc | 4 +- gcc/genmddeps.cc | 2 +- gcc/genmodes.cc | 4 +- gcc/genpeep.cc | 2 +- gcc/genpreds.cc | 4 +- gcc/genrecog.cc | 18 +- gcc/gensupport.cc | 8 +- gcc/gensupport.h | 12 +- gcc/ggc-internal.h | 2 +- gcc/gimple-fold.cc | 6 +- gcc/gimple-fold.h | 2 +- gcc/gimple-low.cc | 2 +- gcc/gimple-match-head.cc | 4 +- gcc/gimple-pretty-print.h | 2 +- gcc/gimple-ssa-sprintf.cc | 4 +- gcc/gimple-streamer.h | 4 +- gcc/gimple.h | 4 +- gcc/gimplify.cc | 12 +- gcc/go/config-lang.in | 2 +- gcc/go/go-backend.cc | 2 +- gcc/go/go-lang.cc | 2 +- gcc/go/gospec.cc | 2 +- gcc/go/lang-specs.h | 2 +- gcc/graphite-isl-ast-to-gimple.cc | 2 +- gcc/haifa-sched.cc | 20 +- gcc/ifcvt.cc | 4 +- gcc/inchash.h | 2 +- gcc/incpath.cc | 2 +- gcc/input.cc | 18 +- gcc/input.h | 4 +- gcc/internal-fn.cc | 4 +- gcc/ipa-cp.cc | 6 +- gcc/ipa-fnsummary.cc | 6 +- gcc/ipa-fnsummary.h | 6 +- gcc/ipa-free-lang-data.cc | 4 +- gcc/ipa-inline.cc | 4 +- gcc/ipa-inline.h | 6 +- gcc/ipa-modref.cc | 8 +- gcc/ipa-param-manipulation.cc | 4 +- gcc/ipa-prop.cc | 2 +- gcc/ipa-prop.h | 8 +- gcc/ipa-reference.cc | 2 +- gcc/ipa-reference.h | 2 +- gcc/ipa-split.cc | 2 +- gcc/ipa-sra.cc | 2 +- gcc/ipa-utils.h | 8 +- gcc/ira-build.cc | 6 +- gcc/ira-color.cc | 4 +- gcc/ira-conflicts.cc | 2 +- gcc/ira-int.h | 20 +- gcc/ira-lives.cc | 2 +- gcc/ira.cc | 32 +-- gcc/ira.h | 4 +- gcc/jit/config-lang.in | 2 +- gcc/jit/docs/_build/texinfo/libgccjit.texi | 18 +- gcc/jit/docs/internals/index.rst | 12 +- gcc/jit/jit-builtins.cc | 4 +- gcc/jit/jit-playback.cc | 68 +++--- gcc/jit/jit-recording.cc | 2 +- gcc/jit/jit-recording.h | 2 +- gcc/jit/libgccjit.cc | 200 +++++++++--------- gcc/jit/notes.txt | 6 +- gcc/langhooks.cc | 2 +- gcc/langhooks.h | 12 +- gcc/libfuncs.h | 2 +- gcc/loop-doloop.cc | 2 +- gcc/loop-init.cc | 2 +- gcc/loop-invariant.cc | 2 +- gcc/lower-subreg.h | 2 +- gcc/lra-constraints.cc | 2 +- gcc/lra-int.h | 24 +-- gcc/lra-spills.cc | 2 +- gcc/lra.cc | 2 +- gcc/lto-compress.h | 2 +- gcc/lto-streamer-out.cc | 6 +- gcc/lto-streamer.h | 22 +- gcc/lto-wrapper.cc | 2 +- gcc/lto/config-lang.in | 2 +- gcc/lto/lang-specs.h | 2 +- gcc/lto/lto-common.cc | 2 +- gcc/lto/lto-common.h | 2 +- gcc/lto/lto-dump.cc | 2 +- gcc/lto/lto-lang.cc | 6 +- gcc/lto/lto.cc | 2 +- gcc/lto/lto.h | 4 +- gcc/machmode.def | 2 +- gcc/machmode.h | 4 +- gcc/main.cc | 2 +- gcc/match.pd | 16 +- gcc/objc/Make-lang.in | 2 +- gcc/objc/config-lang.in | 2 +- gcc/objc/lang-specs.h | 2 +- gcc/objc/objc-act.cc | 12 +- gcc/objc/objc-act.h | 4 +- gcc/objc/objc-gnu-runtime-abi-01.cc | 2 +- gcc/objc/objc-lang.cc | 2 +- gcc/objc/objc-map.cc | 2 +- gcc/objc/objc-next-runtime-abi-01.cc | 4 +- gcc/objc/objc-runtime-shared-support.cc | 2 +- gcc/objc/objc-runtime-shared-support.h | 2 +- gcc/objcp/Make-lang.in | 16 +- gcc/objcp/config-lang.in | 16 +- gcc/objcp/lang-specs.h | 2 +- gcc/objcp/objcp-decl.cc | 2 +- gcc/objcp/objcp-lang.cc | 2 +- gcc/omp-builtins.def | 4 +- gcc/omp-expand.cc | 4 +- gcc/omp-low.cc | 6 +- gcc/omp-oacc-neuter-broadcast.cc | 12 +- gcc/omp-offload.cc | 6 +- gcc/optabs-query.cc | 2 +- gcc/optc-gen.awk | 2 +- gcc/optc-save-gen.awk | 2 +- gcc/optinfo-emit-json.cc | 4 +- gcc/opts-common.cc | 2 +- gcc/output.h | 16 +- gcc/pass_manager.h | 2 +- gcc/plugin.cc | 2 +- gcc/plugin.def | 2 +- gcc/plugin.h | 2 +- gcc/po/EXCLUDES | 44 ++-- gcc/pointer-query.cc | 2 +- gcc/postreload-gcse.cc | 2 +- gcc/predict.h | 4 +- gcc/prefix.h | 2 +- gcc/profile.h | 2 +- gcc/read-md.cc | 2 +- gcc/read-md.h | 10 +- gcc/read-rtl-function.cc | 8 +- gcc/read-rtl.cc | 2 +- gcc/real.cc | 2 +- gcc/real.h | 8 +- gcc/recog.cc | 10 +- gcc/recog.h | 8 +- gcc/reg-notes.def | 2 +- gcc/reg-stack.cc | 2 +- gcc/regs.h | 2 +- gcc/regset.h | 2 +- gcc/reload.cc | 16 +- gcc/reload.h | 8 +- gcc/reload1.cc | 4 +- gcc/reorg.cc | 12 +- gcc/rtl.def | 12 +- gcc/rtl.h | 146 ++++++------- gcc/rtlanal.cc | 10 +- gcc/rtlanal.h | 4 +- gcc/run-rtl-passes.cc | 4 +- gcc/sanitizer.def | 6 +- gcc/sched-deps.cc | 2 +- gcc/sched-ebb.cc | 6 +- gcc/sched-int.h | 28 +-- gcc/sched-rgn.cc | 2 +- gcc/sel-sched-dump.cc | 2 +- gcc/sel-sched-dump.h | 2 +- gcc/sel-sched-ir.cc | 16 +- gcc/sel-sched-ir.h | 8 +- gcc/sel-sched.cc | 20 +- gcc/selftest-run-tests.cc | 4 +- gcc/selftest.h | 4 +- gcc/shrink-wrap.cc | 2 +- gcc/shrink-wrap.h | 2 +- gcc/simplify-rtx.cc | 8 +- gcc/spellcheck-tree.h | 2 +- gcc/spellcheck.h | 2 +- gcc/statistics.h | 2 +- gcc/stmt.cc | 4 +- gcc/stmt.h | 2 +- gcc/stor-layout.h | 2 +- gcc/streamer-hooks.h | 2 +- gcc/stringpool.h | 2 +- gcc/symtab.cc | 2 +- gcc/target.def | 24 +-- gcc/target.h | 6 +- gcc/targhooks.cc | 2 +- gcc/timevar.def | 2 +- gcc/timevar.h | 2 +- gcc/toplev.h | 10 +- gcc/trans-mem.cc | 4 +- gcc/tree-call-cdce.cc | 2 +- gcc/tree-cfg.cc | 8 +- gcc/tree-cfgcleanup.h | 2 +- gcc/tree-complex.cc | 4 +- gcc/tree-core.h | 6 +- gcc/tree-eh.cc | 2 +- gcc/tree-if-conv.cc | 2 +- gcc/tree-inline.cc | 2 +- gcc/tree-inline.h | 2 +- gcc/tree-nested.cc | 4 +- gcc/tree-object-size.h | 2 +- gcc/tree-outof-ssa.cc | 2 +- gcc/tree-parloops.cc | 2 +- gcc/tree-pretty-print.cc | 6 +- gcc/tree-profile.cc | 4 +- gcc/tree-sra.cc | 2 +- gcc/tree-ssa-address.cc | 2 +- gcc/tree-ssa-alias.cc | 2 +- gcc/tree-ssa-alias.h | 4 +- gcc/tree-ssa-ccp.cc | 2 +- gcc/tree-ssa-coalesce.h | 2 +- gcc/tree-ssa-live.cc | 2 +- gcc/tree-ssa-loop-manip.cc | 2 +- gcc/tree-ssa-loop-unswitch.cc | 2 +- gcc/tree-ssa-math-opts.cc | 2 +- gcc/tree-ssa-operands.cc | 2 +- gcc/tree-ssa-pre.cc | 4 +- gcc/tree-ssa-reassoc.cc | 4 +- gcc/tree-ssa-sccvn.cc | 2 +- gcc/tree-ssa-sccvn.h | 2 +- gcc/tree-ssa-scopedtables.cc | 4 +- gcc/tree-ssa-strlen.cc | 2 +- gcc/tree-ssa-strlen.h | 2 +- gcc/tree-ssa-tail-merge.cc | 2 +- gcc/tree-ssa-ter.h | 2 +- gcc/tree-ssa-threadupdate.h | 2 +- gcc/tree-streamer-in.cc | 2 +- gcc/tree-streamer-out.cc | 4 +- gcc/tree-streamer.h | 6 +- gcc/tree-vect-patterns.cc | 4 +- gcc/tree-vect-stmts.cc | 2 +- gcc/tree-vectorizer.cc | 20 +- gcc/tree-vectorizer.h | 20 +- gcc/tree.cc | 6 +- gcc/tree.def | 2 +- gcc/tree.h | 10 +- gcc/value-prof.cc | 4 +- gcc/value-prof.h | 4 +- gcc/value-range.cc | 2 +- gcc/value-range.h | 2 +- gcc/var-tracking.cc | 2 +- gcc/varasm.cc | 10 +- gcc/vec.h | 2 +- gcc/vmsdbgout.cc | 2 +- gcc/vtable-verify.cc | 2 +- gcc/vtable-verify.h | 2 +- gcc/xcoffout.cc | 4 +- gcc/xcoffout.h | 8 +- libcpp/Makefile.in | 6 +- libcpp/charset.cc | 4 +- libcpp/directives.cc | 6 +- libcpp/include/cpplib.h | 22 +- libcpp/include/line-map.h | 6 +- libcpp/include/mkdeps.h | 2 +- libcpp/init.cc | 6 +- libcpp/internal.h | 32 +-- libcpp/line-map.cc | 6 +- libcpp/traditional.cc | 2 +- 804 files changed, 2695 insertions(+), 2695 deletions(-) diff --git a/MAINTAINERS b/MAINTAINERS index 9b5945c0..399de26 100644 --- a/MAINTAINERS +++ b/MAINTAINERS @@ -192,7 +192,7 @@ scheduler (+ haifa) Jeff Law scheduler (+ haifa) Vladimir Makarov modulo-scheduler Roman Zhuykov reorg Jeff Law -caller-save.c Jeff Law +caller-save.cc Jeff Law callgraph Jan Hubicka debugging code Jim Wilson dwarf debugging code Jason Merrill @@ -206,9 +206,9 @@ fixincludes Bruce Korb *gimpl* Jakub Jelinek *gimpl* Aldy Hernandez *gimpl* Jason Merrill -gcse.c Jeff Law +gcse.cc Jeff Law global opt framework Jeff Law -jump.c David S. Miller +jump.cc David S. Miller web pages Gerald Pfeifer config.sub/config.guess Ben Elliston i18n Philipp Thomas @@ -288,10 +288,10 @@ Fortran Janus Weil Graphite Tobias Grosser Graphite Sebastian Pop libcpp Tom Tromey -libsanitizer, asan.c Jakub Jelinek -libsanitizer, asan.c Dodji Seketeli -libsanitizer, asan.c Kostya Serebryany -libsanitizer, asan.c Dmitry Vyukov +libsanitizer, asan.cc Jakub Jelinek +libsanitizer, asan.cc Dodji Seketeli +libsanitizer, asan.cc Kostya Serebryany +libsanitizer, asan.cc Dmitry Vyukov loop optimizer Zdenek Dvorak LTO Richard Biener LTO plugin Cary Coutant diff --git a/contrib/filter-clang-warnings.py b/contrib/filter-clang-warnings.py index 5b82dad..43557c3 100755 --- a/contrib/filter-clang-warnings.py +++ b/contrib/filter-clang-warnings.py @@ -39,17 +39,17 @@ def skip_warning(filename, message): '-Wignored-attributes', '-Wgnu-zero-variadic-macro-arguments', '-Wformat-security', '-Wundefined-internal', '-Wunknown-warning-option', '-Wc++20-extensions'], - 'insn-modes.c': ['-Wshift-count-overflow'], - 'insn-emit.c': ['-Wtautological-compare'], - 'insn-attrtab.c': ['-Wparentheses-equality'], - 'gimple-match.c': ['-Wunused-', '-Wtautological-compare'], - 'generic-match.c': ['-Wunused-', '-Wtautological-compare'], + 'insn-modes.cc': ['-Wshift-count-overflow'], + 'insn-emit.cc': ['-Wtautological-compare'], + 'insn-attrtab.cc': ['-Wparentheses-equality'], + 'gimple-match.cc': ['-Wunused-', '-Wtautological-compare'], + 'generic-match.cc': ['-Wunused-', '-Wtautological-compare'], 'i386.md': ['-Wparentheses-equality', '-Wtautological-compare', '-Wtautological-overlap-compare'], 'sse.md': ['-Wparentheses-equality', '-Wtautological-compare'], 'mmx.md': ['-Wtautological-compare'], - 'genautomata.c': ['-Wstring-plus-int'], - 'fold-const-call.c': ['-Wreturn-type'], + 'genautomata.cc': ['-Wstring-plus-int'], + 'fold-const-call.cc': ['-Wreturn-type'], 'gfortran.texi': [''], 'libtool': [''] } diff --git a/contrib/gcc_update b/contrib/gcc_update index ce47254..1cf15f9 100755 --- a/contrib/gcc_update +++ b/contrib/gcc_update @@ -90,8 +90,8 @@ gcc/config/m68k/m68k-tables.opt: gcc/config/m68k/m68k-devices.def gcc/config/m68 gcc/config/mips/mips-tables.opt: gcc/config/mips/mips-cpus.def gcc/config/mips/genopt.sh gcc/config/rs6000/rs6000-tables.opt: gcc/config/rs6000/rs6000-cpus.def gcc/config/rs6000/genopt.sh gcc/config/rs6000/fusion.md: gcc/config/rs6000/genfusion.pl -gcc/config/tilegx/mul-tables.c: gcc/config/tilepro/gen-mul-tables.cc -gcc/config/tilepro/mul-tables.c: gcc/config/tilepro/gen-mul-tables.cc +gcc/config/tilegx/mul-tables.cc: gcc/config/tilepro/gen-mul-tables.cc +gcc/config/tilepro/mul-tables.cc: gcc/config/tilepro/gen-mul-tables.cc # And then, language-specific files gcc/cp/cfns.h: gcc/cp/cfns.gperf # testsuite @@ -239,7 +239,7 @@ apply_patch () { } # Check whether this indeed looks like a local tree. -if [ ! -f gcc/reload.c ]; then +if [ ! -f gcc/reload.cc ]; then echo "This does not seem to be a GCC tree!" exit fi diff --git a/contrib/header-tools/README b/contrib/header-tools/README index 592af3a..f4eee32 100644 --- a/contrib/header-tools/README +++ b/contrib/header-tools/README @@ -14,7 +14,7 @@ ie.: tool -lfilename.h target.h containing coretypes.h. Typically that is in gcc/gcc from a source checkout. For these tools to work on files not in this directory, their path needs to be specified on the command line. -ie.: tool c/c-decl.c lto/lto.c +ie.: tool c/c-decl.cc lto/lto.cc - options can be intermixed with filenames anywhere on the command line ie. tool ssa.h rtl.h -a is equivalent to @@ -39,7 +39,7 @@ gcc-order-headers Any files which are changed are output, and the original is saved with a .bak extention. - ex.: gcc-order-headers tree-ssa.c c/c-decl.c + ex.: gcc-order-headers tree-ssa.cc c/c-decl.cc -s will list all of the known headers in their canonical order. It does not show which of those headers include other headers, just the final canonical @@ -67,8 +67,8 @@ show-headers This tool must be run in the core gcc source directory. - ex.: show-headers -sansidecl.h tree-ssa.c - tree-ssa.c + ex.: show-headers -sansidecl.h tree-ssa.cc + tree-ssa.cc config.h auto-host.h ansidecl.h (1) <<------- @@ -124,13 +124,13 @@ included-by check rather than performing the much slower find command. ex: included-by tree-vectorizer.h - config/aarch64/aarch64.c - config/i386/i386.c - config/rs6000/rs6000.c - tree-loop-distribution.c - tree-parloops.c - tree-ssa-loop-ivopts.c - tree-ssa-loop.c + config/aarch64/aarch64.cc + config/i386/i386.cc + config/rs6000/rs6000.cc + tree-loop-distribution.cc + tree-parloops.cc + tree-ssa-loop-ivopts.cc + tree-ssa-loop.cc @@ -219,8 +219,8 @@ reduce-headers reduce-headers -b../../build -t../../targets -falias.h -fexpr.h tree*.c (1) # This will attempt to remove only alias.h and expr.h from tree*.c - reduce-headers -b../../build -t../../targets tree-ssa-live.c - # This will attempt to remove all header files from tree-ssa-live.c + reduce-headers -b../../build -t../../targets tree-ssa-live.cc + # This will attempt to remove all header files from tree-ssa-live.cc the tool will generate a number of log files: @@ -240,14 +240,14 @@ reduce-headers $header.h.log: The same log is put into the relevant header log as well. -a sample output from ira.c.log: +a sample output from ira.cc.log: Compilation failed: for shrink-wrap.h: ============================================ - /gcc/2015-09-09/gcc/gcc/ira.c: In function ‘bool split_live_ranges_for_shrink_wrap()’: - /gcc/2015-09-09/gcc/gcc/ira.c:4839:8: error: ‘SHRINK_WRAPPING_ENABLED’ was not declared in this scope + /gcc/2015-09-09/gcc/gcc/ira.cc: In function ‘bool split_live_ranges_for_shrink_wrap()’: + /gcc/2015-09-09/gcc/gcc/ira.cc:4839:8: error: ‘SHRINK_WRAPPING_ENABLED’ was not declared in this scope if (!SHRINK_WRAPPING_ENABLED) ^ make: *** [ira.o] Error 1 @@ -280,4 +280,4 @@ graph-include-web useful for finding cycles and redundancies, or simply to see what a single file looks like. - ex.: graph-include-web tree.c + ex.: graph-include-web tree.cc diff --git a/contrib/paranoia.cc b/contrib/paranoia.cc index 8e8500e..a7821c4 100644 --- a/contrib/paranoia.cc +++ b/contrib/paranoia.cc @@ -185,7 +185,7 @@ static int verbose_index = 0; /* ====================================================================== */ /* The implementation of the abstract floating point class based on gcc's - real.c. I.e. the object of this exercise. Templated so that we can + real.cc. I.e. the object of this exercise. Templated so that we can all fp sizes. */ class real_c_float diff --git a/gcc/Makefile.in b/gcc/Makefile.in index 37e35dc..e13bf66 100644 --- a/gcc/Makefile.in +++ b/gcc/Makefile.in @@ -889,7 +889,7 @@ PATCHLEVEL_c := \ $(shell echo $(BASEVER_c) | sed -e 's/^[0-9]*\.[0-9]*\.\([0-9]*\)$$/\1/') -# For use in version.c - double quoted strings, with appropriate +# For use in version.cc - double quoted strings, with appropriate # surrounding punctuation and spaces, and with the datestamp and # development phase collapsed to the empty string in release mode # (i.e. if DEVPHASE_c is empty and PATCHLEVEL_c is 0). The space @@ -1771,12 +1771,12 @@ TREECHECKING = @TREECHECKING@ FULL_DRIVER_NAME=$(target_noncanonical)-gcc-$(version)$(exeext) MOSTLYCLEANFILES = insn-flags.h insn-config.h insn-codes.h \ - insn-output.c insn-recog.c insn-emit.c insn-extract.c insn-peep.c \ - insn-attr.h insn-attr-common.h insn-attrtab.c insn-dfatab.c \ - insn-latencytab.c insn-opinit.c insn-opinit.h insn-preds.c insn-constants.h \ - tm-preds.h tm-constrs.h checksum-options gimple-match.c generic-match.c \ - tree-check.h min-insn-modes.c insn-modes.c insn-modes.h insn-modes-inline.h \ - genrtl.h gt-*.h gtype-*.h gtype-desc.c gtyp-input.list \ + insn-output.cc insn-recog.cc insn-emit.cc insn-extract.cc insn-peep.cc \ + insn-attr.h insn-attr-common.h insn-attrtab.cc insn-dfatab.cc \ + insn-latencytab.cc insn-opinit.cc insn-opinit.h insn-preds.cc insn-constants.h \ + tm-preds.h tm-constrs.h checksum-options gimple-match.cc generic-match.cc \ + tree-check.h min-insn-modes.cc insn-modes.cc insn-modes.h insn-modes-inline.h \ + genrtl.h gt-*.h gtype-*.h gtype-desc.cc gtyp-input.list \ case-cfn-macros.h cfn-operators.pd \ xgcc$(exeext) cpp$(exeext) $(FULL_DRIVER_NAME) \ $(EXTRA_PROGRAMS) gcc-cross$(exeext) \ @@ -2214,7 +2214,7 @@ s-mlib: $(srcdir)/genmultilib Makefile srcextra: gcc.srcextra lang.srcextra -gcc.srcextra: gengtype-lex.c +gcc.srcextra: gengtype-lex.cc -cp -p $^ $(srcdir) AR_OBJS = file-find.o @@ -2246,10 +2246,10 @@ CFLAGS-gcc-nm.o += $(DRIVER_DEFINES) \ # ??? the implicit rules dont trigger if the source file has a different name # so copy instead -gcc-ranlib.c: gcc-ar.c +gcc-ranlib.cc: gcc-ar.cc cp $^ $@ -gcc-nm.c: gcc-ar.c +gcc-nm.cc: gcc-ar.cc cp $^ $@ COLLECT2_OBJS = collect2.o collect2-aix.o vec.o ggc-none.o \ @@ -2277,7 +2277,7 @@ CFLAGS-c-family/c-opts.o += @TARGET_SYSTEM_ROOT_DEFINE@ CFLAGS-c-family/c-pch.o += -DHOST_MACHINE=\"$(host)\" \ -DTARGET_MACHINE=\"$(target)\" -default-c.o: config/default-c.c +default-c.o: config/default-c.cc $(COMPILE) $< $(POSTCOMPILE) @@ -2288,7 +2288,7 @@ prefix.o: $(BASEVER) # Files used by the D language front end. -default-d.o: config/default-d.c +default-d.o: config/default-d.cc $(COMPILE) $< $(POSTCOMPILE) @@ -2329,13 +2329,13 @@ s-options: $(ALL_OPT_FILES) Makefile $(srcdir)/opt-gather.awk $(SHELL) $(srcdir)/../move-if-change tmp-optionlist optionlist $(STAMP) s-options -options.c: optionlist $(srcdir)/opt-functions.awk $(srcdir)/opt-read.awk \ +options.cc: optionlist $(srcdir)/opt-functions.awk $(srcdir)/opt-read.awk \ $(srcdir)/optc-gen.awk $(AWK) -f $(srcdir)/opt-functions.awk -f $(srcdir)/opt-read.awk \ -f $(srcdir)/optc-gen.awk \ -v header_name="config.h system.h coretypes.h options.h tm.h" < $< > $@ -options-save.c: optionlist $(srcdir)/opt-functions.awk $(srcdir)/opt-read.awk \ +options-save.cc: optionlist $(srcdir)/opt-functions.awk $(srcdir)/opt-read.awk \ $(srcdir)/optc-save-gen.awk $(AWK) -f $(srcdir)/opt-functions.awk -f $(srcdir)/opt-read.awk \ -f $(srcdir)/optc-save-gen.awk \ @@ -2350,7 +2350,7 @@ s-options-h: optionlist $(srcdir)/opt-functions.awk $(srcdir)/opt-read.awk \ $(SHELL) $(srcdir)/../move-if-change tmp-options.h options.h $(STAMP) $@ -dumpvers: dumpvers.c +dumpvers: dumpvers.cc # lto-compress.o needs $(ZLIBINC) added to the include flags. CFLAGS-lto-compress.o += $(ZLIBINC) $(ZSTD_INC) @@ -2386,9 +2386,9 @@ $(common_out_object_file): $(common_out_file) # and compile them. .PRECIOUS: insn-config.h insn-flags.h insn-codes.h insn-constants.h \ - insn-emit.c insn-recog.c insn-extract.c insn-output.c insn-peep.c \ - insn-attr.h insn-attr-common.h insn-attrtab.c insn-dfatab.c \ - insn-latencytab.c insn-preds.c gimple-match.c generic-match.c \ + insn-emit.cc insn-recog.cc insn-extract.cc insn-output.cc insn-peep.cc \ + insn-attr.h insn-attr-common.h insn-attrtab.cc insn-dfatab.cc \ + insn-latencytab.cc insn-preds.cc gimple-match.cc generic-match.cc \ insn-target-def.h # Dependencies for the md file. The first time through, we just assume @@ -2412,13 +2412,13 @@ s-mddeps: $(md_file) $(MD_INCLUDES) build/genmddeps$(build_exeext) simple_rtl_generated_h = insn-attr.h insn-attr-common.h insn-codes.h \ insn-config.h insn-flags.h insn-target-def.h -simple_rtl_generated_c = insn-automata.c insn-emit.c \ - insn-extract.c insn-output.c \ - insn-peep.c insn-recog.c +simple_rtl_generated_c = insn-automata.cc insn-emit.cc \ + insn-extract.cc insn-output.cc \ + insn-peep.cc insn-recog.cc simple_generated_h = $(simple_rtl_generated_h) insn-constants.h -simple_generated_c = $(simple_rtl_generated_c) insn-enums.c +simple_generated_c = $(simple_rtl_generated_c) insn-enums.cc $(simple_generated_h:insn-%.h=s-%) \ $(simple_generated_c:insn-%.c=s-%): s-%: $(MD_DEPS) @@ -2450,30 +2450,30 @@ s-check : build/gencheck$(build_exeext) $(STAMP) s-check # genattrtab produces three files: tmp-{attrtab.c,dfatab.c,latencytab.c} -insn-attrtab.c insn-dfatab.c insn-latencytab.c: s-attrtab ; @true +insn-attrtab.cc insn-dfatab.cc insn-latencytab.cc: s-attrtab ; @true s-attrtab : $(MD_DEPS) build/genattrtab$(build_exeext) \ insn-conditions.md $(RUN_GEN) build/genattrtab$(build_exeext) $(md_file) insn-conditions.md \ -Atmp-attrtab.c -Dtmp-dfatab.c -Ltmp-latencytab.c - $(SHELL) $(srcdir)/../move-if-change tmp-attrtab.c insn-attrtab.c - $(SHELL) $(srcdir)/../move-if-change tmp-dfatab.c insn-dfatab.c - $(SHELL) $(srcdir)/../move-if-change tmp-latencytab.c insn-latencytab.c + $(SHELL) $(srcdir)/../move-if-change tmp-attrtab.cc insn-attrtab.cc + $(SHELL) $(srcdir)/../move-if-change tmp-dfatab.cc insn-dfatab.cc + $(SHELL) $(srcdir)/../move-if-change tmp-latencytab.cc insn-latencytab.cc $(STAMP) s-attrtab # genopinit produces two files. -insn-opinit.c insn-opinit.h: s-opinit ; @true +insn-opinit.cc insn-opinit.h: s-opinit ; @true s-opinit: $(MD_DEPS) build/genopinit$(build_exeext) insn-conditions.md $(RUN_GEN) build/genopinit$(build_exeext) $(md_file) \ insn-conditions.md -htmp-opinit.h -ctmp-opinit.c $(SHELL) $(srcdir)/../move-if-change tmp-opinit.h insn-opinit.h - $(SHELL) $(srcdir)/../move-if-change tmp-opinit.c insn-opinit.c + $(SHELL) $(srcdir)/../move-if-change tmp-opinit.cc insn-opinit.cc $(STAMP) s-opinit # gencondmd doesn't use the standard naming convention. -build/gencondmd.c: s-conditions; @true +build/gencondmd.cc: s-conditions; @true s-conditions: $(MD_DEPS) build/genconditions$(build_exeext) $(RUN_GEN) build/genconditions$(build_exeext) $(md_file) > tmp-condmd.c - $(SHELL) $(srcdir)/../move-if-change tmp-condmd.c build/gencondmd.c + $(SHELL) $(srcdir)/../move-if-change tmp-condmd.c build/gencondmd.cc $(STAMP) s-conditions insn-conditions.md: s-condmd; @true @@ -2493,14 +2493,14 @@ s-genrtl-h: build/gengenrtl$(build_exeext) $(SHELL) $(srcdir)/../move-if-change tmp-genrtl.h genrtl.h $(STAMP) s-genrtl-h -insn-modes.c: s-modes; @true +insn-modes.cc: s-modes; @true insn-modes.h: s-modes-h; @true insn-modes-inline.h: s-modes-inline-h; @true -min-insn-modes.c: s-modes-m; @true +min-insn-modes.cc: s-modes-m; @true s-modes: build/genmodes$(build_exeext) $(RUN_GEN) build/genmodes$(build_exeext) > tmp-modes.c - $(SHELL) $(srcdir)/../move-if-change tmp-modes.c insn-modes.c + $(SHELL) $(srcdir)/../move-if-change tmp-modes.c insn-modes.cc $(STAMP) s-modes s-modes-h: build/genmodes$(build_exeext) @@ -2516,10 +2516,10 @@ s-modes-inline-h: build/genmodes$(build_exeext) s-modes-m: build/genmodes$(build_exeext) $(RUN_GEN) build/genmodes$(build_exeext) -m > tmp-min-modes.c - $(SHELL) $(srcdir)/../move-if-change tmp-min-modes.c min-insn-modes.c + $(SHELL) $(srcdir)/../move-if-change tmp-min-modes.c min-insn-modes.cc $(STAMP) s-modes-m -insn-preds.c: s-preds; @true +insn-preds.cc: s-preds; @true tm-preds.h: s-preds-h; @true tm-constrs.h: s-constrs-h; @true @@ -2529,7 +2529,7 @@ mddump: $(BUILD_RTL) $(MD_DEPS) build/genmddump$(build_exeext) s-preds: $(MD_DEPS) build/genpreds$(build_exeext) $(RUN_GEN) build/genpreds$(build_exeext) $(md_file) > tmp-preds.c - $(SHELL) $(srcdir)/../move-if-change tmp-preds.c insn-preds.c + $(SHELL) $(srcdir)/../move-if-change tmp-preds.c insn-preds.cc $(STAMP) s-preds s-preds-h: $(MD_DEPS) build/genpreds$(build_exeext) @@ -2631,25 +2631,25 @@ s-tm-texi: build/genhooks$(build_exeext) $(srcdir)/doc/tm.texi.in false; \ fi -gimple-match.c: s-match gimple-match-head.c ; @true -generic-match.c: s-match generic-match-head.c ; @true +gimple-match.cc: s-match gimple-match-head.cc ; @true +generic-match.cc: s-match generic-match-head.cc ; @true s-match: build/genmatch$(build_exeext) $(srcdir)/match.pd cfn-operators.pd $(RUN_GEN) build/genmatch$(build_exeext) --gimple $(srcdir)/match.pd \ - > tmp-gimple-match.c + > tmp-gimple-match.cc $(RUN_GEN) build/genmatch$(build_exeext) --generic $(srcdir)/match.pd \ - > tmp-generic-match.c - $(SHELL) $(srcdir)/../move-if-change tmp-gimple-match.c \ - gimple-match.c - $(SHELL) $(srcdir)/../move-if-change tmp-generic-match.c \ - generic-match.c + > tmp-generic-match.cc + $(SHELL) $(srcdir)/../move-if-change tmp-gimple-match.cc \ + gimple-match.cc + $(SHELL) $(srcdir)/../move-if-change tmp-generic-match.cc \ + generic-match.cc $(STAMP) s-match GTFILES = $(CPPLIB_H) $(srcdir)/input.h $(srcdir)/coretypes.h \ $(host_xm_file_list) \ $(tm_file_list) $(HASHTAB_H) $(SPLAY_TREE_H) $(srcdir)/bitmap.h \ $(srcdir)/wide-int.h $(srcdir)/alias.h \ - $(srcdir)/coverage.c $(srcdir)/rtl.h \ + $(srcdir)/coverage.cc $(srcdir)/rtl.h \ $(srcdir)/optabs.h $(srcdir)/tree.h $(srcdir)/tree-core.h \ $(srcdir)/libfuncs.h $(SYMTAB_H) \ $(srcdir)/real.h $(srcdir)/function.h $(srcdir)/insn-addr.h $(srcdir)/hwint.h \ @@ -2659,70 +2659,70 @@ GTFILES = $(CPPLIB_H) $(srcdir)/input.h $(srcdir)/coretypes.h \ $(srcdir)/cselib.h $(srcdir)/basic-block.h $(srcdir)/ipa-ref.h $(srcdir)/cgraph.h \ $(srcdir)/symtab-thunks.h $(srcdir)/symtab-thunks.cc \ $(srcdir)/symtab-clones.h \ - $(srcdir)/reload.h $(srcdir)/caller-save.c $(srcdir)/symtab.c \ - $(srcdir)/alias.c $(srcdir)/bitmap.c $(srcdir)/cselib.c $(srcdir)/cgraph.c \ - $(srcdir)/ipa-prop.c $(srcdir)/ipa-cp.c $(srcdir)/ipa-utils.h \ - $(srcdir)/ipa-param-manipulation.h $(srcdir)/ipa-sra.c $(srcdir)/dbxout.c \ - $(srcdir)/ipa-modref.h $(srcdir)/ipa-modref.c \ + $(srcdir)/reload.h $(srcdir)/caller-save.cc $(srcdir)/symtab.cc \ + $(srcdir)/alias.cc $(srcdir)/bitmap.cc $(srcdir)/cselib.cc $(srcdir)/cgraph.cc \ + $(srcdir)/ipa-prop.cc $(srcdir)/ipa-cp.cc $(srcdir)/ipa-utils.h \ + $(srcdir)/ipa-param-manipulation.h $(srcdir)/ipa-sra.cc $(srcdir)/dbxout.cc \ + $(srcdir)/ipa-modref.h $(srcdir)/ipa-modref.cc \ $(srcdir)/ipa-modref-tree.h \ $(srcdir)/signop.h \ - $(srcdir)/diagnostic-spec.h $(srcdir)/diagnostic-spec.c \ + $(srcdir)/diagnostic-spec.h $(srcdir)/diagnostic-spec.cc \ $(srcdir)/dwarf2out.h \ - $(srcdir)/dwarf2asm.c \ - $(srcdir)/dwarf2cfi.c \ - $(srcdir)/dwarf2ctf.c \ - $(srcdir)/dwarf2out.c \ + $(srcdir)/dwarf2asm.cc \ + $(srcdir)/dwarf2cfi.cc \ + $(srcdir)/dwarf2ctf.cc \ + $(srcdir)/dwarf2out.cc \ $(srcdir)/ctfc.h \ - $(srcdir)/ctfout.c \ - $(srcdir)/btfout.c \ - $(srcdir)/tree-vect-generic.c \ + $(srcdir)/ctfout.cc \ + $(srcdir)/btfout.cc \ + $(srcdir)/tree-vect-generic.cc \ $(srcdir)/gimple-isel.cc \ - $(srcdir)/dojump.c $(srcdir)/emit-rtl.h \ - $(srcdir)/emit-rtl.c $(srcdir)/except.h $(srcdir)/explow.c $(srcdir)/expr.c \ + $(srcdir)/dojump.cc $(srcdir)/emit-rtl.h \ + $(srcdir)/emit-rtl.cc $(srcdir)/except.h $(srcdir)/explow.cc $(srcdir)/expr.cc \ $(srcdir)/expr.h \ - $(srcdir)/function.c $(srcdir)/except.c \ - $(srcdir)/ggc-tests.c \ - $(srcdir)/gcse.c $(srcdir)/godump.c \ - $(srcdir)/lists.c $(srcdir)/optabs-libfuncs.c \ - $(srcdir)/profile.c $(srcdir)/mcf.c \ - $(srcdir)/reg-stack.c $(srcdir)/cfgrtl.c \ - $(srcdir)/stor-layout.c \ - $(srcdir)/stringpool.c $(srcdir)/tree.c $(srcdir)/varasm.c \ + $(srcdir)/function.cc $(srcdir)/except.cc \ + $(srcdir)/ggc-tests.cc \ + $(srcdir)/gcse.cc $(srcdir)/godump.cc \ + $(srcdir)/lists.cc $(srcdir)/optabs-libfuncs.cc \ + $(srcdir)/profile.cc $(srcdir)/mcf.cc \ + $(srcdir)/reg-stack.cc $(srcdir)/cfgrtl.cc \ + $(srcdir)/stor-layout.cc \ + $(srcdir)/stringpool.cc $(srcdir)/tree.cc $(srcdir)/varasm.cc \ $(srcdir)/gimple.h \ $(srcdir)/gimple-ssa.h \ - $(srcdir)/tree-ssanames.c $(srcdir)/tree-eh.c $(srcdir)/tree-ssa-address.c \ - $(srcdir)/tree-cfg.c $(srcdir)/tree-ssa-loop-ivopts.c \ - $(srcdir)/tree-dfa.c \ - $(srcdir)/tree-iterator.c $(srcdir)/gimple-expr.c \ + $(srcdir)/tree-ssanames.cc $(srcdir)/tree-eh.cc $(srcdir)/tree-ssa-address.cc \ + $(srcdir)/tree-cfg.cc $(srcdir)/tree-ssa-loop-ivopts.cc \ + $(srcdir)/tree-dfa.cc \ + $(srcdir)/tree-iterator.cc $(srcdir)/gimple-expr.cc \ $(srcdir)/tree-chrec.h \ - $(srcdir)/tree-scalar-evolution.c \ + $(srcdir)/tree-scalar-evolution.cc \ $(srcdir)/tree-ssa-operands.h \ - $(srcdir)/tree-profile.c $(srcdir)/tree-nested.c \ + $(srcdir)/tree-profile.cc $(srcdir)/tree-nested.cc \ $(srcdir)/omp-offload.h \ - $(srcdir)/omp-general.c \ - $(srcdir)/omp-low.c \ - $(srcdir)/targhooks.c $(out_file) $(srcdir)/passes.c \ - $(srcdir)/cgraphclones.c \ - $(srcdir)/tree-phinodes.c \ + $(srcdir)/omp-general.cc \ + $(srcdir)/omp-low.cc \ + $(srcdir)/targhooks.cc $(out_file) $(srcdir)/passes.cc \ + $(srcdir)/cgraphclones.cc \ + $(srcdir)/tree-phinodes.cc \ $(srcdir)/tree-ssa-alias.h \ $(srcdir)/tree-ssanames.h \ $(srcdir)/tree-vrp.h \ $(srcdir)/value-range.h \ $(srcdir)/ipa-prop.h \ - $(srcdir)/trans-mem.c \ + $(srcdir)/trans-mem.cc \ $(srcdir)/lto-streamer.h \ $(srcdir)/target-globals.h \ $(srcdir)/ipa-predicate.h \ $(srcdir)/ipa-fnsummary.h \ - $(srcdir)/vtable-verify.c \ - $(srcdir)/asan.c \ - $(srcdir)/ubsan.c \ - $(srcdir)/tsan.c \ - $(srcdir)/sanopt.c \ - $(srcdir)/sancov.c \ - $(srcdir)/ipa-devirt.c \ + $(srcdir)/vtable-verify.cc \ + $(srcdir)/asan.cc \ + $(srcdir)/ubsan.cc \ + $(srcdir)/tsan.cc \ + $(srcdir)/sanopt.cc \ + $(srcdir)/sancov.cc \ + $(srcdir)/ipa-devirt.cc \ $(srcdir)/internal-fn.h \ - $(srcdir)/calls.c \ + $(srcdir)/calls.cc \ $(srcdir)/omp-general.h \ @all_gtfiles@ @@ -2745,7 +2745,7 @@ ALL_GTFILES_H := $(sort $(GTFILES_H) $(GTFILES_LANG_H)) # write it out to a file (taking care not to do that in a way that # overflows a command line!) and then have gengtype read the file in. -$(ALL_GTFILES_H) gtype-desc.c gtype-desc.h gtype.state: s-gtype ; @true +$(ALL_GTFILES_H) gtype-desc.cc gtype-desc.h gtype.state: s-gtype ; @true ### Common flags to gengtype [e.g. -v or -B backupdir] GENGTYPE_FLAGS= @@ -2772,10 +2772,10 @@ generated_files = config.h tm.h $(TM_P_H) $(TM_D_H) $(TM_H) multilib.h \ $(simple_generated_h) specs.h \ tree-check.h genrtl.h insn-modes.h insn-modes-inline.h \ tm-preds.h tm-constrs.h \ - $(ALL_GTFILES_H) gtype-desc.c gtype-desc.h version.h \ + $(ALL_GTFILES_H) gtype-desc.cc gtype-desc.h version.h \ options.h target-hooks-def.h insn-opinit.h \ common/common-target-hooks-def.h pass-instances.def \ - gimple-match.c generic-match.c \ + gimple-match.cc generic-match.cc \ c-family/c-target-hooks-def.h d/d-target-hooks-def.h \ case-cfn-macros.h \ cfn-operators.pd omp-device-properties.h @@ -2789,77 +2789,77 @@ build/%.o : # dependencies provided by explicit rule later # Header dependencies for the programs that generate source code. # These are library modules... -build/errors.o : errors.c $(BCONFIG_H) $(SYSTEM_H) errors.h -build/gensupport.o: gensupport.c $(BCONFIG_H) $(SYSTEM_H) \ +build/errors.o : errors.cc $(BCONFIG_H) $(SYSTEM_H) errors.h +build/gensupport.o: gensupport.cc $(BCONFIG_H) $(SYSTEM_H) \ $(CORETYPES_H) $(GTM_H) $(RTL_BASE_H) $(OBSTACK_H) errors.h \ $(HASHTAB_H) $(READ_MD_H) $(GENSUPPORT_H) $(HASH_TABLE_H) -build/ggc-none.o : ggc-none.c $(BCONFIG_H) $(SYSTEM_H) $(CORETYPES_H) \ +build/ggc-none.o : ggc-none.cc $(BCONFIG_H) $(SYSTEM_H) $(CORETYPES_H) \ $(GGC_H) -build/min-insn-modes.o : min-insn-modes.c $(BCONFIG_H) $(SYSTEM_H) \ +build/min-insn-modes.o : min-insn-modes.cc $(BCONFIG_H) $(SYSTEM_H) \ $(CORETYPES_H) -build/print-rtl.o: print-rtl.c $(BCONFIG_H) $(SYSTEM_H) $(CORETYPES_H) \ +build/print-rtl.o: print-rtl.cc $(BCONFIG_H) $(SYSTEM_H) $(CORETYPES_H) \ $(GTM_H) $(RTL_BASE_H) -build/read-md.o: read-md.c $(BCONFIG_H) $(SYSTEM_H) $(CORETYPES_H) \ +build/read-md.o: read-md.cc $(BCONFIG_H) $(SYSTEM_H) $(CORETYPES_H) \ $(HASHTAB_H) errors.h $(READ_MD_H) -build/read-rtl.o: read-rtl.c $(BCONFIG_H) $(SYSTEM_H) $(CORETYPES_H) \ +build/read-rtl.o: read-rtl.cc $(BCONFIG_H) $(SYSTEM_H) $(CORETYPES_H) \ $(GTM_H) $(RTL_BASE_H) $(OBSTACK_H) $(HASHTAB_H) $(READ_MD_H) \ $(GENSUPPORT_H) -build/rtl.o: rtl.c $(BCONFIG_H) $(CORETYPES_H) $(GTM_H) $(SYSTEM_H) \ +build/rtl.o: rtl.cc $(BCONFIG_H) $(CORETYPES_H) $(GTM_H) $(SYSTEM_H) \ $(RTL_H) $(GGC_H) errors.h -build/vec.o : vec.c $(BCONFIG_H) $(SYSTEM_H) $(CORETYPES_H) $(VEC_H) \ +build/vec.o : vec.cc $(BCONFIG_H) $(SYSTEM_H) $(CORETYPES_H) $(VEC_H) \ $(GGC_H) toplev.h $(DIAGNOSTIC_CORE_H) $(HASH_TABLE_H) -build/hash-table.o : hash-table.c $(BCONFIG_H) $(SYSTEM_H) \ +build/hash-table.o : hash-table.cc $(BCONFIG_H) $(SYSTEM_H) \ $(CORETYPES_H) $(HASH_TABLE_H) $(GGC_H) toplev.h $(DIAGNOSTIC_CORE_H) build/sort.o : sort.cc $(BCONFIG_H) $(SYSTEM_H) -build/inchash.o : inchash.c $(BCONFIG_H) $(SYSTEM_H) $(CORETYPES_H) \ +build/inchash.o : inchash.cc $(BCONFIG_H) $(SYSTEM_H) $(CORETYPES_H) \ $(HASHTAB_H) inchash.h -build/gencondmd.o : build/gencondmd.c $(BCONFIG_H) $(SYSTEM_H) \ +build/gencondmd.o : build/gencondmd.cc $(BCONFIG_H) $(SYSTEM_H) \ $(CORETYPES_H) $(GTM_H) insn-constants.h \ $(filter-out insn-flags.h, $(RTL_H) $(TM_P_H) $(FUNCTION_H) $(REGS_H) \ $(RECOG_H) output.h $(FLAGS_H) $(RESOURCE_H) toplev.h $(DIAGNOSTIC_CORE_H) reload.h \ $(EXCEPT_H) tm-constrs.h) # This pulls in tm-pred.h which contains inline functions wrapping up # predicates from the back-end so those functions must be discarded. -# No big deal since gencondmd.c is a dummy file for non-GCC compilers. +# No big deal since gencondmd.cc is a dummy file for non-GCC compilers. build/gencondmd.o : \ BUILD_CFLAGS := $(filter-out -fkeep-inline-functions, $(BUILD_CFLAGS)) # ...these are the programs themselves. -build/genattr.o : genattr.c $(RTL_BASE_H) $(BCONFIG_H) $(SYSTEM_H) \ +build/genattr.o : genattr.cc $(RTL_BASE_H) $(BCONFIG_H) $(SYSTEM_H) \ $(CORETYPES_H) $(GTM_H) errors.h $(READ_MD_H) $(GENSUPPORT_H) -build/genattr-common.o : genattr-common.c $(RTL_BASE_H) $(BCONFIG_H) \ +build/genattr-common.o : genattr-common.cc $(RTL_BASE_H) $(BCONFIG_H) \ $(SYSTEM_H) $(CORETYPES_H) $(GTM_H) errors.h $(READ_MD_H) $(GENSUPPORT_H) -build/genattrtab.o : genattrtab.c $(RTL_BASE_H) $(OBSTACK_H) \ +build/genattrtab.o : genattrtab.cc $(RTL_BASE_H) $(OBSTACK_H) \ $(BCONFIG_H) $(SYSTEM_H) $(CORETYPES_H) $(GTM_H) errors.h $(GGC_H) \ $(READ_MD_H) $(GENSUPPORT_H) $(FNMATCH_H) -build/genautomata.o : genautomata.c $(RTL_BASE_H) $(OBSTACK_H) \ +build/genautomata.o : genautomata.cc $(RTL_BASE_H) $(OBSTACK_H) \ $(BCONFIG_H) $(SYSTEM_H) $(CORETYPES_H) $(GTM_H) errors.h $(VEC_H) \ $(HASHTAB_H) $(GENSUPPORT_H) $(FNMATCH_H) -build/gencheck.o : gencheck.c all-tree.def $(BCONFIG_H) $(GTM_H) \ +build/gencheck.o : gencheck.cc all-tree.def $(BCONFIG_H) $(GTM_H) \ $(SYSTEM_H) $(CORETYPES_H) tree.def c-family/c-common.def \ $(lang_tree_files) gimple.def -build/genchecksum.o : genchecksum.c $(BCONFIG_H) $(SYSTEM_H) $(MD5_H) -build/gencodes.o : gencodes.c $(RTL_BASE_H) $(BCONFIG_H) $(SYSTEM_H) \ +build/genchecksum.o : genchecksum.cc $(BCONFIG_H) $(SYSTEM_H) $(MD5_H) +build/gencodes.o : gencodes.cc $(RTL_BASE_H) $(BCONFIG_H) $(SYSTEM_H) \ $(CORETYPES_H) $(GTM_H) errors.h $(GENSUPPORT_H) -build/genconditions.o : genconditions.c $(RTL_BASE_H) $(BCONFIG_H) \ +build/genconditions.o : genconditions.cc $(RTL_BASE_H) $(BCONFIG_H) \ $(SYSTEM_H) $(CORETYPES_H) $(GTM_H) errors.h $(HASHTAB_H) \ $(READ_MD_H) $(GENSUPPORT_H) -build/genconfig.o : genconfig.c $(RTL_BASE_H) $(BCONFIG_H) $(SYSTEM_H) \ +build/genconfig.o : genconfig.cc $(RTL_BASE_H) $(BCONFIG_H) $(SYSTEM_H) \ $(CORETYPES_H) $(GTM_H) errors.h $(GENSUPPORT_H) -build/genconstants.o : genconstants.c $(BCONFIG_H) $(SYSTEM_H) \ +build/genconstants.o : genconstants.cc $(BCONFIG_H) $(SYSTEM_H) \ $(CORETYPES_H) errors.h $(READ_MD_H) -build/genemit.o : genemit.c $(RTL_BASE_H) $(BCONFIG_H) $(SYSTEM_H) \ +build/genemit.o : genemit.cc $(RTL_BASE_H) $(BCONFIG_H) $(SYSTEM_H) \ $(CORETYPES_H) $(GTM_H) errors.h $(READ_MD_H) $(GENSUPPORT_H) internal-fn.def -build/genenums.o : genenums.c $(BCONFIG_H) $(SYSTEM_H) \ +build/genenums.o : genenums.cc $(BCONFIG_H) $(SYSTEM_H) \ $(CORETYPES_H) errors.h $(READ_MD_H) -build/genextract.o : genextract.c $(RTL_BASE_H) $(BCONFIG_H) \ +build/genextract.o : genextract.cc $(RTL_BASE_H) $(BCONFIG_H) \ $(SYSTEM_H) $(CORETYPES_H) $(GTM_H) errors.h $(READ_MD_H) $(GENSUPPORT_H) -build/genflags.o : genflags.c $(RTL_BASE_H) $(OBSTACK_H) $(BCONFIG_H) \ +build/genflags.o : genflags.cc $(RTL_BASE_H) $(OBSTACK_H) $(BCONFIG_H) \ $(SYSTEM_H) $(CORETYPES_H) $(GTM_H) errors.h $(READ_MD_H) $(GENSUPPORT_H) -build/gentarget-def.o : gentarget-def.c $(BCONFIG_H) $(SYSTEM_H) \ +build/gentarget-def.o : gentarget-def.cc $(BCONFIG_H) $(SYSTEM_H) \ $(CORETYPES_H) $(GTM_H) $(RTL_BASE_H) errors.h $(READ_MD_H) \ $(GENSUPPORT_H) $(HASH_TABLE_H) target-insns.def -build/gengenrtl.o : gengenrtl.c $(BCONFIG_H) $(SYSTEM_H) rtl.def +build/gengenrtl.o : gengenrtl.cc $(BCONFIG_H) $(SYSTEM_H) rtl.def # The gengtype generator program is special: Two versions are built. # One is for the build machine, and one is for the host to allow @@ -2872,21 +2872,21 @@ build/gengenrtl.o : gengenrtl.c $(BCONFIG_H) $(SYSTEM_H) rtl.def GENGTYPE_OBJS = gengtype.o gengtype-parse.o gengtype-state.o \ gengtype-lex.o errors.o -gengtype-lex.o build/gengtype-lex.o : gengtype-lex.c gengtype.h $(SYSTEM_H) +gengtype-lex.o build/gengtype-lex.o : gengtype-lex.cc gengtype.h $(SYSTEM_H) CFLAGS-gengtype-lex.o += -DHOST_GENERATOR_FILE build/gengtype-lex.o: $(BCONFIG_H) -gengtype-parse.o build/gengtype-parse.o : gengtype-parse.c gengtype.h \ +gengtype-parse.o build/gengtype-parse.o : gengtype-parse.cc gengtype.h \ $(SYSTEM_H) CFLAGS-gengtype-parse.o += -DHOST_GENERATOR_FILE build/gengtype-parse.o: $(BCONFIG_H) -gengtype-state.o build/gengtype-state.o: gengtype-state.c $(SYSTEM_H) \ +gengtype-state.o build/gengtype-state.o: gengtype-state.cc $(SYSTEM_H) \ gengtype.h errors.h version.h $(HASHTAB_H) $(OBSTACK_H) \ $(XREGEX_H) CFLAGS-gengtype-state.o += -DHOST_GENERATOR_FILE build/gengtype-state.o: $(BCONFIG_H) -gengtype.o build/gengtype.o : gengtype.c $(SYSTEM_H) gengtype.h \ +gengtype.o build/gengtype.o : gengtype.cc $(SYSTEM_H) gengtype.h \ rtl.def insn-notes.def errors.h version.h \ $(HASHTAB_H) $(OBSTACK_H) $(XREGEX_H) CFLAGS-gengtype.o += -DHOST_GENERATOR_FILE @@ -2894,30 +2894,30 @@ build/gengtype.o: $(BCONFIG_H) CFLAGS-errors.o += -DHOST_GENERATOR_FILE -build/genmddeps.o: genmddeps.c $(BCONFIG_H) $(SYSTEM_H) $(CORETYPES_H) \ +build/genmddeps.o: genmddeps.cc $(BCONFIG_H) $(SYSTEM_H) $(CORETYPES_H) \ errors.h $(READ_MD_H) -build/genmodes.o : genmodes.c $(BCONFIG_H) $(SYSTEM_H) errors.h \ +build/genmodes.o : genmodes.cc $(BCONFIG_H) $(SYSTEM_H) errors.h \ $(HASHTAB_H) machmode.def $(extra_modes_file) -build/genopinit.o : genopinit.c $(RTL_BASE_H) $(BCONFIG_H) $(SYSTEM_H) \ +build/genopinit.o : genopinit.cc $(RTL_BASE_H) $(BCONFIG_H) $(SYSTEM_H) \ $(CORETYPES_H) $(GTM_H) errors.h $(GENSUPPORT_H) optabs.def -build/genoutput.o : genoutput.c $(RTL_BASE_H) $(BCONFIG_H) $(SYSTEM_H) \ +build/genoutput.o : genoutput.cc $(RTL_BASE_H) $(BCONFIG_H) $(SYSTEM_H) \ $(CORETYPES_H) $(GTM_H) errors.h $(READ_MD_H) $(GENSUPPORT_H) -build/genpeep.o : genpeep.c $(RTL_BASE_H) $(BCONFIG_H) $(SYSTEM_H) \ +build/genpeep.o : genpeep.cc $(RTL_BASE_H) $(BCONFIG_H) $(SYSTEM_H) \ $(CORETYPES_H) $(GTM_H) errors.h $(GENSUPPORT_H) toplev.h \ $(DIAGNOSTIC_CORE_H) -build/genpreds.o : genpreds.c $(RTL_BASE_H) $(BCONFIG_H) $(SYSTEM_H) \ +build/genpreds.o : genpreds.cc $(RTL_BASE_H) $(BCONFIG_H) $(SYSTEM_H) \ $(CORETYPES_H) $(GTM_H) errors.h $(READ_MD_H) $(GENSUPPORT_H) $(OBSTACK_H) -build/genrecog.o : genrecog.c $(RTL_BASE_H) $(BCONFIG_H) $(SYSTEM_H) \ +build/genrecog.o : genrecog.cc $(RTL_BASE_H) $(BCONFIG_H) $(SYSTEM_H) \ $(CORETYPES_H) $(GTM_H) errors.h $(READ_MD_H) $(GENSUPPORT_H) \ $(HASH_TABLE_H) inchash.h -build/genhooks.o : genhooks.c $(TARGET_DEF) $(C_TARGET_DEF) \ +build/genhooks.o : genhooks.cc $(TARGET_DEF) $(C_TARGET_DEF) \ $(COMMON_TARGET_DEF) $(D_TARGET_DEF) $(BCONFIG_H) $(SYSTEM_H) errors.h -build/genmddump.o : genmddump.c $(RTL_BASE_H) $(BCONFIG_H) $(SYSTEM_H) \ +build/genmddump.o : genmddump.cc $(RTL_BASE_H) $(BCONFIG_H) $(SYSTEM_H) \ $(CORETYPES_H) $(GTM_H) errors.h $(READ_MD_H) $(GENSUPPORT_H) -build/genmatch.o : genmatch.c $(BCONFIG_H) $(SYSTEM_H) \ +build/genmatch.o : genmatch.cc $(BCONFIG_H) $(SYSTEM_H) \ $(CORETYPES_H) errors.h $(HASH_TABLE_H) hash-map.h $(GGC_H) is-a.h \ tree.def builtins.def internal-fn.def case-cfn-macros.h $(CPPLIB_H) -build/gencfn-macros.o : gencfn-macros.c $(BCONFIG_H) $(SYSTEM_H) \ +build/gencfn-macros.o : gencfn-macros.cc $(BCONFIG_H) $(SYSTEM_H) \ $(CORETYPES_H) errors.h $(HASH_TABLE_H) hash-set.h builtins.def \ internal-fn.def @@ -3004,7 +3004,7 @@ s-omp-device-properties-h: @omp_device_property_deps@ # Generated source files for gengtype. Prepend inclusion of # config.h/bconfig.h because AIX requires _LARGE_FILES to be defined before # any system header is included. -gengtype-lex.c : gengtype-lex.l +gengtype-lex.cc : gengtype-lex.l -$(FLEX) $(FLEXFLAGS) -o$@ $< && { \ echo '#ifdef HOST_GENERATOR_FILE' > $@.tmp; \ echo '#include "config.h"' >> $@.tmp; \ @@ -3047,13 +3047,13 @@ CFLAGS-cppdefault.o += $(PREPROCESSOR_DEFINES) # Note for the stamp targets, we run the program `true' instead of # having an empty command (nothing following the semicolon). -# genversion.c is run on the build machine to generate version.h +# genversion.cc is run on the build machine to generate version.h CFLAGS-build/genversion.o += -DBASEVER=$(BASEVER_s) -DDATESTAMP=$(DATESTAMP_s) \ -DREVISION=$(REVISION_s) \ -DDEVPHASE=$(DEVPHASE_s) -DPKGVERSION=$(PKGVERSION_s) \ -DBUGURL=$(BUGURL_s) -build/genversion.o: genversion.c $(BCONFIG_H) $(SYSTEM_H) $(srcdir)/DATESTAMP +build/genversion.o: genversion.cc $(BCONFIG_H) $(SYSTEM_H) $(srcdir)/DATESTAMP build/genversion$(build_exeext): build/genversion.o +$(LINKER_FOR_BUILD) $(BUILD_LINKERFLAGS) $(BUILD_LDFLAGS) \ @@ -3078,7 +3078,7 @@ gcov-dump$(exeext): $(GCOV_DUMP_OBJS) $(LIBDEPS) hash-table.o ggc-none.o\ $(LIBS) -o $@ -GCOV_TOOL_DEP_FILES = $(srcdir)/../libgcc/libgcov-util.c gcov-io.c $(GCOV_IO_H) \ +GCOV_TOOL_DEP_FILES = $(srcdir)/../libgcc/libgcov-util.c gcov-io.cc $(GCOV_IO_H) \ $(srcdir)/../libgcc/libgcov-driver.c $(srcdir)/../libgcc/libgcov-driver-system.c \ $(srcdir)/../libgcc/libgcov-merge.c $(srcdir)/../libgcc/libgcov.h \ $(SYSTEM_H) coretypes.h $(TM_H) $(CONFIG_H) version.h intl.h $(DIAGNOSTIC_H) @@ -3513,7 +3513,7 @@ mostlyclean: lang.mostlyclean -rm -f build/* -rm -f mddeps.mk # Delete other built files. - -rm -f specs.h options.c options.h options-save.c + -rm -f specs.h options.cc options.h options-save.cc # Delete the stamp and temporary files. -rm -f s-* tmp-* stamp-* stmp-* -rm -f */stamp-* */tmp-* @@ -3547,7 +3547,7 @@ clean: mostlyclean lang.clean -rm -f libgcc_s* -rm -f libunwind* -rm -f config.h tconfig.h bconfig.h tm_p.h tm.h - -rm -f options.c options.h optionlist + -rm -f options.cc options.h optionlist -rm -f cs-* -rm -f doc/*.dvi -rm -f doc/*.pdf @@ -4313,7 +4313,7 @@ qmtest-gui: ${QMTEST_DIR}/context .PHONY: qmtest-g++ -# Run Paranoia on real.c. +# Run Paranoia on real.cc. paranoia.o: $(srcdir)/../contrib/paranoia.cc $(CONFIG_H) $(SYSTEM_H) $(TREE_H) g++ -c $(ALL_CFLAGS) $(ALL_CPPFLAGS) $< $(OUTPUT_OPTION) diff --git a/gcc/ada/Make-generated.in b/gcc/ada/Make-generated.in index 948fc50..6cdc6b4 100644 --- a/gcc/ada/Make-generated.in +++ b/gcc/ada/Make-generated.in @@ -53,7 +53,7 @@ ada/stamp-snames : ada/snames.ads-tmpl ada/snames.adb-tmpl ada/snames.h-tmpl ada touch ada/stamp-snames ada/sdefault.adb: ada/stamp-sdefault ; @true -ada/stamp-sdefault : $(srcdir)/ada/version.c Makefile +ada/stamp-sdefault : $(srcdir)/ada/version.cc Makefile $(ECHO) "pragma Style_Checks (Off);" >tmp-sdefault.adb $(ECHO) "with Osint; use Osint;" >>tmp-sdefault.adb $(ECHO) "package body Sdefault is" >>tmp-sdefault.adb diff --git a/gcc/ada/adaint.c b/gcc/ada/adaint.c index 591d033..b7b7d74 100644 --- a/gcc/ada/adaint.c +++ b/gcc/ada/adaint.c @@ -172,7 +172,7 @@ extern "C" { #include "mingw32.h" -/* Current code page and CCS encoding to use, set in initialize.c. */ +/* Current code page and CCS encoding to use, set in initialize.cc. */ UINT __gnat_current_codepage; UINT __gnat_current_ccs_encoding; diff --git a/gcc/ada/ctrl_c.c b/gcc/ada/ctrl_c.c index eeec3e6..b32baa0 100644 --- a/gcc/ada/ctrl_c.c +++ b/gcc/ada/ctrl_c.c @@ -61,7 +61,7 @@ void __gnat_uninstall_int_handler (void); void dummy_handler () {} -/* Lives in init.c. */ +/* Lives in init.cc. */ extern void (*__gnat_ctrl_c_handler) (void); #endif diff --git a/gcc/ada/gcc-interface/Makefile.in b/gcc/ada/gcc-interface/Makefile.in index 53d0739..cf645df 100644 --- a/gcc/ada/gcc-interface/Makefile.in +++ b/gcc/ada/gcc-interface/Makefile.in @@ -147,8 +147,8 @@ host_os=@host_os@ target_cpu_default = @target_cpu_default@ xmake_file = @xmake_file@ tmake_file = @tmake_file@ -#version=`sed -e 's/.*\"\([^ \"]*\)[ \"].*/\1/' < $(srcdir)/version.c` -#mainversion=`sed -e 's/.*\"\([0-9]*\.[0-9]*\).*/\1/' < $(srcdir)/version.c` +#version=`sed -e 's/.*\"\([^ \"]*\)[ \"].*/\1/' < $(srcdir)/version.cc` +#mainversion=`sed -e 's/.*\"\([0-9]*\.[0-9]*\).*/\1/' < $(srcdir)/version.cc` # Directory where sources are, from where we are. VPATH = $(srcdir)/ada @@ -222,7 +222,7 @@ endif all.indirect: Makefile ../gnat1$(exeext) # IN_GCC is meant to distinguish between code compiled into GCC itself, i.e. -# for the host, and the rest. But we also use it for the tools (link.c) and +# for the host, and the rest. But we also use it for the tools (link.cc) and # even break the host/target wall by using it for the library (targext.c). # autoconf inserts -DCROSS_DIRECTORY_STRUCTURE if we are building a cross # compiler which does not use the native libraries and headers. @@ -240,7 +240,7 @@ ALL_COMPILERFLAGS = $(ALL_CFLAGS) # This is where we get libiberty.a from. LIBIBERTY = ../../libiberty/libiberty.a -# We need to link against libbacktrace because diagnostic.c in +# We need to link against libbacktrace because diagnostic.cc in # libcommon.a uses it. LIBBACKTRACE = ../../libbacktrace/.libs/libbacktrace.a @@ -303,7 +303,7 @@ ADA_INCLUDES_FOR_SUBDIR = -I. -I$(fsrcdir)/ada $(CC) -c $(ALL_ADAFLAGS) $(ADA_INCLUDES) $< $(OUTPUT_OPTION) # how to regenerate this file -Makefile: ../config.status $(srcdir)/ada/gcc-interface/Makefile.in $(srcdir)/ada/Makefile.in $(srcdir)/ada/version.c +Makefile: ../config.status $(srcdir)/ada/gcc-interface/Makefile.in $(srcdir)/ada/Makefile.in $(srcdir)/ada/version.cc cd ..; \ LANGUAGES="$(CONFIG_LANGUAGES)" \ CONFIG_HEADERS= \ @@ -903,44 +903,44 @@ ADA_RTL_DSO_DIR = $(toolexeclibdir) # need to keep the frame pointer in tracebak.o to pop the stack properly on # some targets. -tracebak.o : tracebak.c +tracebak.o : tracebak.cc $(COMPILER) -c $(ALL_COMPILERFLAGS) $(ADA_CFLAGS) $(ALL_CPPFLAGS) \ $(INCLUDES) $(NO_OMIT_ADAFLAGS) $< $(OUTPUT_OPTION) -adadecode.o : adadecode.c adadecode.h -aux-io.o : aux-io.c -argv.o : argv.c +adadecode.o : adadecode.cc adadecode.h +aux-io.o : aux-io.cc +argv.o : argv.cc cal.o : cal.c deftarg.o : deftarg.c errno.o : errno.c -exit.o : adaint.h exit.c -expect.o : expect.c -final.o : final.c -rtfinal.o : rtfinal.c -rtinit.o : rtinit.c -locales.o : locales.c -mkdir.o : mkdir.c -socket.o : socket.c gsocket.h +exit.o : adaint.h exit.cc +expect.o : expect.cc +final.o : final.cc +rtfinal.o : rtfinal.cc +rtinit.o : rtinit.cc +locales.o : locales.cc +mkdir.o : mkdir.cc +socket.o : socket.cc gsocket.h sysdep.o : sysdep.c -raise.o : raise.c raise.h -sigtramp-armdroid.o : sigtramp-armdroid.c sigtramp.h +raise.o : raise.cc raise.h +sigtramp-armdroid.o : sigtramp-armdroid.cc sigtramp.h sigtramp-armvxworks.o : sigtramp-armvxworks.c sigtramp.h -sigtramp-ios.o : sigtramp-ios.c sigtramp.h -sigtramp-vxworks.o : sigtramp-vxworks.c $(VX_SIGTRAMP_EXTRA_SRCS) +sigtramp-ios.o : sigtramp-ios.cc sigtramp.h +sigtramp-vxworks.o : sigtramp-vxworks.cc $(VX_SIGTRAMP_EXTRA_SRCS) sigtramp-vxworks-vxsim.o : sigtramp-vxworks-vxsim.c $(VX_SIGTRAMP_EXTRA_SRCS) terminals.o : terminals.c -vx_stack_info.o : vx_stack_info.c +vx_stack_info.o : vx_stack_info.cc raise-gcc.o : raise-gcc.c raise.h $(COMPILER) -c $(ALL_COMPILERFLAGS) $(ADA_CFLAGS) \ -iquote $(srcdir) -iquote $(ftop_srcdir)/libgcc \ $(ALL_CPPFLAGS) $(INCLUDES) $< $(OUTPUT_OPTION) -cio.o : cio.c +cio.o : cio.cc $(COMPILER) -c $(ALL_COMPILERFLAGS) $(ADA_CFLAGS) \ $(ALL_CPPFLAGS) $(INCLUDES) $< $(OUTPUT_OPTION) -init.o : init.c adaint.h raise.h +init.o : init.cc adaint.h raise.h $(COMPILER) -c $(ALL_COMPILERFLAGS) $(ADA_CFLAGS) \ $(ALL_CPPFLAGS) $(INCLUDES) $< $(OUTPUT_OPTION) @@ -948,11 +948,11 @@ init-vxsim.o : init-vxsim.c $(COMPILER) -c $(ALL_COMPILERFLAGS) $(ADA_CFLAGS) \ $(ALL_CPPFLAGS) $(INCLUDES) $< $(OUTPUT_OPTION) -initialize.o : initialize.c raise.h +initialize.o : initialize.cc raise.h $(COMPILER) -c $(ALL_COMPILERFLAGS) $(ADA_CFLAGS) \ $(ALL_CPPFLAGS) $(INCLUDES) $< $(OUTPUT_OPTION) -link.o : link.c +link.o : link.cc $(COMPILER) -c $(ALL_COMPILERFLAGS) $(ADA_CFLAGS) \ $(ALL_CPPFLAGS) $(INCLUDES_FOR_SUBDIR) \ $< $(OUTPUT_OPTION) diff --git a/gcc/ada/gcc-interface/config-lang.in b/gcc/ada/gcc-interface/config-lang.in index 8eacf7b..5f72977 100644 --- a/gcc/ada/gcc-interface/config-lang.in +++ b/gcc/ada/gcc-interface/config-lang.in @@ -30,7 +30,7 @@ gcc_subdir="ada/gcc-interface" boot_language=yes compilers="gnat1\$(exeext)" -gtfiles="\$(srcdir)/ada/gcc-interface/ada-tree.h \$(srcdir)/ada/gcc-interface/gigi.h \$(srcdir)/ada/gcc-interface/decl.c \$(srcdir)/ada/gcc-interface/trans.c \$(srcdir)/ada/gcc-interface/utils.c \$(srcdir)/ada/gcc-interface/misc.c" +gtfiles="\$(srcdir)/ada/gcc-interface/ada-tree.h \$(srcdir)/ada/gcc-interface/gigi.h \$(srcdir)/ada/gcc-interface/decl.cc \$(srcdir)/ada/gcc-interface/trans.cc \$(srcdir)/ada/gcc-interface/utils.cc \$(srcdir)/ada/gcc-interface/misc.cc" outputs="ada/gcc-interface/Makefile ada/Makefile" diff --git a/gcc/ada/gcc-interface/decl.cc b/gcc/ada/gcc-interface/decl.cc index 39a9092..1c7a716 100644 --- a/gcc/ada/gcc-interface/decl.cc +++ b/gcc/ada/gcc-interface/decl.cc @@ -10632,7 +10632,7 @@ concat_name (tree gnu_name, const char *suffix) return get_identifier_with_length (new_name, len); } -/* Initialize the data structures of the decl.c module. */ +/* Initialize the data structures of the decl.cc module. */ void init_gnat_decl (void) @@ -10644,7 +10644,7 @@ init_gnat_decl (void) dummy_to_subprog_map = hash_table::create_ggc (512); } -/* Destroy the data structures of the decl.c module. */ +/* Destroy the data structures of the decl.cc module. */ void destroy_gnat_decl (void) diff --git a/gcc/ada/gcc-interface/gigi.h b/gcc/ada/gcc-interface/gigi.h index 4b4a14d..bd559d1 100644 --- a/gcc/ada/gcc-interface/gigi.h +++ b/gcc/ada/gcc-interface/gigi.h @@ -203,10 +203,10 @@ extern tree create_concat_name (Entity_Id gnat_entity, const char *suffix); the name followed by "___" and the specified suffix. */ extern tree concat_name (tree gnu_name, const char *suffix); -/* Initialize data structures of the decl.c module. */ +/* Initialize data structures of the decl.cc module. */ extern void init_gnat_decl (void); -/* Destroy data structures of the decl.c module. */ +/* Destroy data structures of the decl.cc module. */ extern void destroy_gnat_decl (void); /* Highest number in the front-end node table. */ @@ -563,10 +563,10 @@ extern tree convert_to_index_type (tree expr); /* Routines created solely for the tree translator's sake. Their prototypes can be changed as desired. */ -/* Initialize data structures of the utils.c module. */ +/* Initialize data structures of the utils.cc module. */ extern void init_gnat_utils (void); -/* Destroy data structures of the utils.c module. */ +/* Destroy data structures of the utils.cc module. */ extern void destroy_gnat_utils (void); /* GNAT_ENTITY is a GNAT tree node for a defining identifier. @@ -904,7 +904,7 @@ extern tree build_call_raise_range (int msg, Node_Id gnat_node, char kind, tree index, tree first, tree last); /* Return a CONSTRUCTOR of TYPE whose elements are V. This is not the - same as build_constructor in the language-independent tree.c. */ + same as build_constructor in the language-independent tree.cc. */ extern tree gnat_build_constructor (tree type, vec *v); /* Return a COMPONENT_REF to access FIELD in RECORD, or NULL_EXPR and generate @@ -943,7 +943,7 @@ extern tree build_allocator (tree type, tree init, tree result_type, should not be allocated in a register. Returns true if successful. */ extern bool gnat_mark_addressable (tree t); -/* Save EXP for later use or reuse. This is equivalent to save_expr in tree.c +/* Save EXP for later use or reuse. This is equivalent to save_expr in tree.cc but we know how to handle our own nodes. */ extern tree gnat_save_expr (tree exp); @@ -952,7 +952,7 @@ extern tree gnat_save_expr (tree exp); its subsequent reuse(s) except through its potential reevaluation. */ extern tree gnat_protect_expr (tree exp); -/* This is equivalent to stabilize_reference in tree.c but we know how to +/* This is equivalent to stabilize_reference in tree.cc but we know how to handle our own nodes and we take extra arguments. FORCE says whether to force evaluation of everything in REF. INIT is set to the first arm of a COMPOUND_EXPR present in REF, if any. */ @@ -965,7 +965,7 @@ typedef tree (*rewrite_fn) (tree, void *); extern tree gnat_rewrite_reference (tree ref, rewrite_fn func, void *data, tree *init); -/* This is equivalent to get_inner_reference in expr.c but it returns the +/* This is equivalent to get_inner_reference in expr.cc but it returns the ultimate containing object only if the reference (lvalue) is constant, i.e. if it doesn't depend on the context in which it is evaluated. */ extern tree get_inner_constant_reference (tree exp); diff --git a/gcc/ada/gcc-interface/lang-specs.h b/gcc/ada/gcc-interface/lang-specs.h index d26cc8d..db1917b 100644 --- a/gcc/ada/gcc-interface/lang-specs.h +++ b/gcc/ada/gcc-interface/lang-specs.h @@ -27,7 +27,7 @@ extensions to .ada in dump file names. */ #define ADA_DUMPS_OPTIONS DUMPS_OPTIONS ("%{!.adb:%{!.ads:.ada}}") -/* This is the contribution to the `default_compilers' array in gcc.c for +/* This is the contribution to the `default_compilers' array in gcc.cc for GNAT. */ {".ads", "@ada", 0, 0, 0}, diff --git a/gcc/ada/gcc-interface/utils.cc b/gcc/ada/gcc-interface/utils.cc index d5dd04a..049cf74 100644 --- a/gcc/ada/gcc-interface/utils.cc +++ b/gcc/ada/gcc-interface/utils.cc @@ -281,7 +281,7 @@ static GTY(()) vec *builtin_decls; static GTY((deletable)) tree free_block_chain; /* A hash table of packable types. It is modelled on the generic type - hash table in tree.c, which must thus be used as a reference. */ + hash table in tree.cc, which must thus be used as a reference. */ struct GTY((for_user)) packable_type_hash { @@ -304,7 +304,7 @@ struct packable_type_hasher : ggc_cache_ptr_hash static GTY ((cache)) hash_table *packable_type_hash_table; /* A hash table of padded types. It is modelled on the generic type - hash table in tree.c, which must thus be used as a reference. */ + hash table in tree.cc, which must thus be used as a reference. */ struct GTY((for_user)) pad_type_hash { @@ -367,7 +367,7 @@ add_deferred_decl_context (tree decl, Entity_Id gnat_scope, int force_global); static void add_deferred_type_context (struct deferred_decl_context_node *n, tree type); -/* Initialize data structures of the utils.c module. */ +/* Initialize data structures of the utils.cc module. */ void init_gnat_utils (void) @@ -385,7 +385,7 @@ init_gnat_utils (void) pad_type_hash_table = hash_table::create_ggc (512); } -/* Destroy data structures of the utils.c module. */ +/* Destroy data structures of the utils.cc module. */ void destroy_gnat_utils (void) diff --git a/gcc/ada/gcc-interface/utils2.cc b/gcc/ada/gcc-interface/utils2.cc index b651d48..e5cd856 100644 --- a/gcc/ada/gcc-interface/utils2.cc +++ b/gcc/ada/gcc-interface/utils2.cc @@ -2534,7 +2534,7 @@ gnat_stable_expr_p (tree exp) return TREE_CONSTANT (exp) || code == NULL_EXPR || code == SAVE_EXPR; } -/* Save EXP for later use or reuse. This is equivalent to save_expr in tree.c +/* Save EXP for later use or reuse. This is equivalent to save_expr in tree.cc but we know how to handle our own nodes. */ tree @@ -2633,7 +2633,7 @@ gnat_protect_expr (tree exp) save_expr (build_unary_op (ADDR_EXPR, NULL_TREE, exp))); } -/* This is equivalent to stabilize_reference_1 in tree.c but we take an extra +/* This is equivalent to stabilize_reference_1 in tree.cc but we take an extra argument to force evaluation of everything. */ static tree @@ -2703,7 +2703,7 @@ gnat_stabilize_reference_1 (tree e, void *data) return result; } -/* This is equivalent to stabilize_reference in tree.c but we know how to +/* This is equivalent to stabilize_reference in tree.cc but we know how to handle our own nodes and we take extra arguments. FORCE says whether to force evaluation of everything in REF. INIT is set to the first arm of a COMPOUND_EXPR present in REF, if any. */ @@ -2837,7 +2837,7 @@ gnat_rewrite_reference (tree ref, rewrite_fn func, void *data, tree *init) return result; } -/* This is equivalent to get_inner_reference in expr.c but it returns the +/* This is equivalent to get_inner_reference in expr.cc but it returns the ultimate containing object only if the reference (lvalue) is constant, i.e. if it doesn't depend on the context in which it is evaluated. */ diff --git a/gcc/ada/gsocket.h b/gcc/ada/gsocket.h index e7284a1..aaeca95 100644 --- a/gcc/ada/gsocket.h +++ b/gcc/ada/gsocket.h @@ -246,7 +246,7 @@ * mutual exclusion * * See "Handling of gethostbyname, gethostbyaddr, getservbyname and - * getservbyport" in socket.c for details. + * getservbyport" in socket.cc for details. */ #if defined (HAVE_GETxxxBYyyy_R) diff --git a/gcc/ada/init.cc b/gcc/ada/init.cc index 9b15a16..7ee1977 100644 --- a/gcc/ada/init.cc +++ b/gcc/ada/init.cc @@ -542,7 +542,7 @@ __gnat_error_handler (int sig, siginfo_t *si ATTRIBUTE_UNUSED, void *ucontext) before the faulting address is accessible. Unfortunately, Linux seems to have no way of giving us the faulting address. - In old versions of init.c, we had a test of the page before the + In old versions of init.cc, we had a test of the page before the stack pointer: ((volatile char *) @@ -1237,7 +1237,7 @@ __gnat_handle_vms_condition (int *sigargs, void *mechargs) if (__gnat_resignal_p (sigargs [1])) return SS$_RESIGNAL; #ifndef IN_RTS - /* toplev.c handles this for compiler. */ + /* toplev.cc handles this for compiler. */ if (sigargs [1] == SS$_HPARITH) return SS$_RESIGNAL; #endif diff --git a/gcc/ada/libgnarl/s-intman.ads b/gcc/ada/libgnarl/s-intman.ads index aef5a77..4d5ab60 100644 --- a/gcc/ada/libgnarl/s-intman.ads +++ b/gcc/ada/libgnarl/s-intman.ads @@ -105,7 +105,7 @@ private (C, Adjust_Context_For_Raise, "__gnat_adjust_context_for_raise"); -- Target specific hook performing adjustments to the signal's machine -- context, to be called before an exception may be raised from a signal - -- handler. This service is provided by init.c, together with the + -- handler. This service is provided by init.cc, together with the -- non-tasking signal handler. end System.Interrupt_Management; diff --git a/gcc/ada/libgnarl/s-osinte__android.ads b/gcc/ada/libgnarl/s-osinte__android.ads index f4434f6..9ef3e30 100644 --- a/gcc/ada/libgnarl/s-osinte__android.ads +++ b/gcc/ada/libgnarl/s-osinte__android.ads @@ -309,7 +309,7 @@ package System.OS_Interface is -- The alternate signal stack for stack overflows Alternate_Stack_Size : constant := 16 * 1024; - -- This must be in keeping with init.c:__gnat_alternate_stack + -- This must be in keeping with init.cc:__gnat_alternate_stack Stack_Base_Available : constant Boolean := False; -- Indicates whether the stack base is available on this target diff --git a/gcc/ada/libgnarl/s-osinte__darwin.ads b/gcc/ada/libgnarl/s-osinte__darwin.ads index 1856ce9..12bb1aa 100644 --- a/gcc/ada/libgnarl/s-osinte__darwin.ads +++ b/gcc/ada/libgnarl/s-osinte__darwin.ads @@ -288,7 +288,7 @@ package System.OS_Interface is -- The alternate signal stack for stack overflows Alternate_Stack_Size : constant := 32 * 1024; - -- This must be in keeping with init.c:__gnat_alternate_stack + -- This must be in keeping with init.cc:__gnat_alternate_stack Stack_Base_Available : constant Boolean := False; -- Indicates whether the stack base is available on this target. This diff --git a/gcc/ada/libgnarl/s-osinte__hpux.ads b/gcc/ada/libgnarl/s-osinte__hpux.ads index feaedcc..a1cf316 100644 --- a/gcc/ada/libgnarl/s-osinte__hpux.ads +++ b/gcc/ada/libgnarl/s-osinte__hpux.ads @@ -293,7 +293,7 @@ package System.OS_Interface is -- The alternate signal stack for stack overflows Alternate_Stack_Size : constant := 128 * 1024; - -- This must be in keeping with init.c:__gnat_alternate_stack + -- This must be in keeping with init.cc:__gnat_alternate_stack Stack_Base_Available : constant Boolean := False; -- Indicates whether the stack base is available on this target diff --git a/gcc/ada/libgnarl/s-osinte__linux.ads b/gcc/ada/libgnarl/s-osinte__linux.ads index 7c9e7ca..3230f28c 100644 --- a/gcc/ada/libgnarl/s-osinte__linux.ads +++ b/gcc/ada/libgnarl/s-osinte__linux.ads @@ -331,7 +331,7 @@ package System.OS_Interface is pragma Import (C, sigaltstack, "sigaltstack"); Alternate_Stack_Size : constant := 32 * 1024; - -- This must be in keeping with init.c:__gnat_alternate_stack + -- This must be in keeping with init.cc:__gnat_alternate_stack Alternate_Stack : aliased char_array (1 .. Alternate_Stack_Size); pragma Import (C, Alternate_Stack, "__gnat_alternate_stack"); diff --git a/gcc/ada/libgnarl/s-osinte__qnx.ads b/gcc/ada/libgnarl/s-osinte__qnx.ads index c7a887a..af87700 100644 --- a/gcc/ada/libgnarl/s-osinte__qnx.ads +++ b/gcc/ada/libgnarl/s-osinte__qnx.ads @@ -310,7 +310,7 @@ package System.OS_Interface is -- sigaltstack in QNX Alternate_Stack_Size : constant := 0; - -- This must be kept in sync with init.c:__gnat_alternate_stack + -- This must be kept in sync with init.cc:__gnat_alternate_stack Stack_Base_Available : constant Boolean := False; -- Indicates whether the stack base is available on this target diff --git a/gcc/ada/libgnarl/s-taskin.ads b/gcc/ada/libgnarl/s-taskin.ads index 2e6a0bb..c4f42fe 100644 --- a/gcc/ada/libgnarl/s-taskin.ads +++ b/gcc/ada/libgnarl/s-taskin.ads @@ -776,7 +776,7 @@ package System.Tasking is Unspecified_Priority : constant Integer := -1; -- Indicates that a task has an unspecified priority. This is hardcoded as -- -1 rather than System.Priority'First - 1 as the value needs to be used - -- in init.c to specify that the main task has no specified priority. + -- in init.cc to specify that the main task has no specified priority. Priority_Not_Boosted : constant Integer := System.Priority'First - 1; -- Definition of Priority actually has to come from the RTS configuration diff --git a/gcc/ada/rtfinal.cc b/gcc/ada/rtfinal.cc index 543e3a2..ba7c61e 100644 --- a/gcc/ada/rtfinal.cc +++ b/gcc/ada/rtfinal.cc @@ -43,7 +43,7 @@ extern void __gnat_runtime_finalize (void); Note that __gnat_runtime_finalize() is called in adafinal() */ extern int __gnat_rt_init_count; -/* see initialize.c */ +/* see initialize.cc */ #if defined (__MINGW32__) #include "mingw32.h" diff --git a/gcc/ada/s-oscons-tmplt.c b/gcc/ada/s-oscons-tmplt.c index af69190..ea7d256 100644 --- a/gcc/ada/s-oscons-tmplt.c +++ b/gcc/ada/s-oscons-tmplt.c @@ -1976,7 +1976,7 @@ CND(CLOCK_THREAD_CPUTIME_ID, "Thread CPU clock") || defined(__DragonFly__) || defined(__QNX__) /** On these platforms use system provided monotonic clock instead of ** the default CLOCK_REALTIME. We then need to set up cond var attributes - ** appropriately (see thread.c). + ** appropriately (see thread.cc). ** ** Note that AIX 5.2 does not support CLOCK_MONOTONIC timestamps for ** pthread_cond_timedwait (and does not have pthread_condattr_setclock), diff --git a/gcc/ada/set_targ.ads b/gcc/ada/set_targ.ads index 1e57fc9..4cfbdca 100644 --- a/gcc/ada/set_targ.ads +++ b/gcc/ada/set_targ.ads @@ -25,7 +25,7 @@ -- This package handles setting target dependent parameters. If the -gnatet -- switch is not set, then these values are taken from the back end (via the --- routines in Get_Targ, and the enumerate_modes routine in misc.c). If the +-- routines in Get_Targ, and the enumerate_modes routine in misc.cc). If the -- switch is set, then the values are read from the target.atp file in the -- current directory (usually written with the Write_Target_Dependent_Values -- procedure defined in this package). @@ -88,7 +88,7 @@ package Set_Targ is ------------------------------------- -- This table contains the list of modes supported by the back-end as - -- provided by the back end routine enumerate_modes in misc.c. Note that + -- provided by the back end routine enumerate_modes in misc.cc. Note that -- we only store floating-point modes (see Register_Float_Type). type FPT_Mode_Entry is record diff --git a/gcc/alias.h b/gcc/alias.h index 82ce785..b259651 100644 --- a/gcc/alias.h +++ b/gcc/alias.h @@ -1,4 +1,4 @@ -/* Exported functions from alias.c +/* Exported functions from alias.cc Copyright (C) 2004-2022 Free Software Foundation, Inc. This file is part of GCC. diff --git a/gcc/analyzer/analyzer.cc b/gcc/analyzer/analyzer.cc index 0151be2..6784417 100644 --- a/gcc/analyzer/analyzer.cc +++ b/gcc/analyzer/analyzer.cc @@ -241,7 +241,7 @@ is_special_named_call_p (const gcall *call, const char *funcname, /* Helper function for checkers. Is FNDECL an extern fndecl at file scope that has the given FUNCNAME? - Compare with special_function_p in calls.c. */ + Compare with special_function_p in calls.cc. */ bool is_named_call_p (const_tree fndecl, const char *funcname) @@ -271,7 +271,7 @@ is_named_call_p (const_tree fndecl, const char *funcname) } /* Return true if FNDECL is within the namespace "std". - Compare with cp/typeck.c: decl_in_std_namespace_p, but this doesn't + Compare with cp/typeck.cc: decl_in_std_namespace_p, but this doesn't rely on being the C++ FE (or handle inline namespaces inside of std). */ static inline bool diff --git a/gcc/analyzer/region-model-asm.cc b/gcc/analyzer/region-model-asm.cc index 2058bb0..3bf2a02 100644 --- a/gcc/analyzer/region-model-asm.cc +++ b/gcc/analyzer/region-model-asm.cc @@ -126,7 +126,7 @@ deterministic_p (const gasm *asm_stmt) /* Update this model for the asm STMT, using CTXT to report any diagnostics. - Compare with cfgexpand.c: expand_asm_stmt. */ + Compare with cfgexpand.cc: expand_asm_stmt. */ void region_model::on_asm_stmt (const gasm *stmt, region_model_context *ctxt) diff --git a/gcc/analyzer/region.cc b/gcc/analyzer/region.cc index 161e7e1..f5a2a0b 100644 --- a/gcc/analyzer/region.cc +++ b/gcc/analyzer/region.cc @@ -1168,7 +1168,7 @@ field_region::dump_to_pp (pretty_printer *pp, bool simple) const bool field_region::get_relative_concrete_offset (bit_offset_t *out) const { - /* Compare with e.g. gimple-fold.c's + /* Compare with e.g. gimple-fold.cc's fold_nonarray_ctor_reference. */ tree byte_offset = DECL_FIELD_OFFSET (m_field); if (TREE_CODE (byte_offset) != INTEGER_CST) diff --git a/gcc/analyzer/sm-malloc.cc b/gcc/analyzer/sm-malloc.cc index 4718496..2f7a387 100644 --- a/gcc/analyzer/sm-malloc.cc +++ b/gcc/analyzer/sm-malloc.cc @@ -945,7 +945,7 @@ method_p (tree fndecl) } /* Return a 1-based description of ARG_IDX (0-based) of FNDECL. - Compare with %P in the C++ FE (implemented in cp/error.c: parm_to_string + Compare with %P in the C++ FE (implemented in cp/error.cc: parm_to_string as called from cp_printer). */ static label_text diff --git a/gcc/analyzer/supergraph.cc b/gcc/analyzer/supergraph.cc index fc5bdaf..466f924 100644 --- a/gcc/analyzer/supergraph.cc +++ b/gcc/analyzer/supergraph.cc @@ -905,7 +905,7 @@ superedge::dump_dot (graphviz_out *gv, const dump_args_t &) const break; } - /* Adapted from graph.c:draw_cfg_node_succ_edges. */ + /* Adapted from graph.cc:draw_cfg_node_succ_edges. */ if (::edge cfg_edge = get_any_cfg_edge ()) { if (cfg_edge->flags & EDGE_FAKE) diff --git a/gcc/asan.cc b/gcc/asan.cc index 08c622e..b347173 100644 --- a/gcc/asan.cc +++ b/gcc/asan.cc @@ -195,7 +195,7 @@ along with GCC; see the file COPYING3. If not see at the top of the variables of the stack. Note that the real variable layout is done in expand_used_vars in - cfgexpand.c. As far as Address Sanitizer is concerned, it lays out + cfgexpand.cc. As far as Address Sanitizer is concerned, it lays out stack variables as well as the different red zones, emits some prologue code to populate the shadow memory as to poison (mark as non-accessible) the regions of the red zones and mark the regions of diff --git a/gcc/auto-profile.h b/gcc/auto-profile.h index 856eae5..bf3f90f 100644 --- a/gcc/auto-profile.h +++ b/gcc/auto-profile.h @@ -1,4 +1,4 @@ -/* auto-profile.h - Defines data exported from auto-profile.c +/* auto-profile.h - Defines data exported from auto-profile.cc Copyright (C) 2014-2022 Free Software Foundation, Inc. Contributed by Dehao Chen (dehao@google.com) diff --git a/gcc/basic-block.h b/gcc/basic-block.h index b794edb..e3fff1f 100644 --- a/gcc/basic-block.h +++ b/gcc/basic-block.h @@ -146,7 +146,7 @@ struct GTY((chain_next ("%h.next_bb"), chain_prev ("%h.prev_bb"))) basic_block_d /* The index of this block. */ int index; - /* Expected number of executions: calculated in profile.c. */ + /* Expected number of executions: calculated in profile.cc. */ profile_count count; /* The discriminator for this block. The discriminator distinguishes diff --git a/gcc/btfout.cc b/gcc/btfout.cc index 88c4d00..31af505 100644 --- a/gcc/btfout.cc +++ b/gcc/btfout.cc @@ -19,7 +19,7 @@ along with GCC; see the file COPYING3. If not see /* This file contains routines to output the BPF Type Format (BTF). The BTF debug format is very similar to CTF; as a result, the structure of this file - closely resembles that of ctfout.c, and the same CTF container objects are + closely resembles that of ctfout.cc, and the same CTF container objects are used. */ #include "config.h" diff --git a/gcc/builtins.cc b/gcc/builtins.cc index c780340..bf07341 100644 --- a/gcc/builtins.cc +++ b/gcc/builtins.cc @@ -19,7 +19,7 @@ along with GCC; see the file COPYING3. If not see /* Legacy warning! Please add no further builtin simplifications here (apart from pure constant folding) - builtin simplifications should go - to match.pd or gimple-fold.c instead. */ + to match.pd or gimple-fold.cc instead. */ #include "config.h" #include "system.h" @@ -1038,7 +1038,7 @@ expand_builtin_longjmp (rtx buf_addr, rtx value) set_mem_alias_set (stack, setjmp_alias_set); /* Pick up FP, label, and SP from the block and jump. This code is - from expand_goto in stmt.c; see there for detailed comments. */ + from expand_goto in stmt.cc; see there for detailed comments. */ if (targetm.have_nonlocal_goto ()) /* We have to pass a value to the nonlocal_goto pattern that will get copied into the static_chain pointer, but it does not matter @@ -9628,7 +9628,7 @@ validate_arg (const_tree arg, enum tree_code code) VOID_TYPE. This is the GIMPLE version of validate_arglist. Eventually we want to - completely convert builtins.c to work from GIMPLEs and the tree based + completely convert builtins.cc to work from GIMPLEs and the tree based validate_arglist will then be removed. */ bool @@ -10989,7 +10989,7 @@ access_ref::offset_bounded () const } /* If CALLEE has known side effects, fill in INFO and return true. - See tree-ssa-structalias.c:find_func_aliases + See tree-ssa-structalias.cc:find_func_aliases for the list of builtins we might need to handle here. */ attr_fnspec diff --git a/gcc/c-family/c-ada-spec.cc b/gcc/c-family/c-ada-spec.cc index e3025e1..149d336 100644 --- a/gcc/c-family/c-ada-spec.cc +++ b/gcc/c-family/c-ada-spec.cc @@ -1,7 +1,7 @@ /* Print GENERIC declaration (functions, variables, types) trees coming from the C and C++ front-ends as well as macros in Ada syntax. Copyright (C) 2010-2022 Free Software Foundation, Inc. - Adapted from tree-pretty-print.c by Arnaud Charlet + Adapted from tree-pretty-print.cc by Arnaud Charlet This file is part of GCC. diff --git a/gcc/c-family/c-ada-spec.h b/gcc/c-family/c-ada-spec.h index e691b98..d3ba0f4 100644 --- a/gcc/c-family/c-ada-spec.h +++ b/gcc/c-family/c-ada-spec.h @@ -22,7 +22,7 @@ along with GCC; see the file COPYING3. If not see #include "pretty-print.h" -/* In c-ada-spec.c */ +/* In c-ada-spec.cc */ enum cpp_operation { HAS_DEPENDENT_TEMPLATE_ARGS, diff --git a/gcc/c-family/c-common.cc b/gcc/c-family/c-common.cc index a34f32f..d9674ea 100644 --- a/gcc/c-family/c-common.cc +++ b/gcc/c-family/c-common.cc @@ -1324,7 +1324,7 @@ c_build_vec_convert (location_t loc1, tree expr, location_t loc2, tree type, return ret; } -/* Like tree.c:get_narrower, but retain conversion from C++0x scoped enum +/* Like tree.cc:get_narrower, but retain conversion from C++0x scoped enum to integral type. */ tree @@ -1950,7 +1950,7 @@ warning_candidate_p (tree x) if (TREE_CODE (x) == BLOCK) return false; - /* VOID_TYPE_P (TREE_TYPE (x)) is workaround for cp/tree.c + /* VOID_TYPE_P (TREE_TYPE (x)) is workaround for cp/tree.cc (lvalue_p) crash on TRY/CATCH. */ if (TREE_TYPE (x) == NULL_TREE || VOID_TYPE_P (TREE_TYPE (x))) return false; diff --git a/gcc/c-family/c-common.h b/gcc/c-family/c-common.h index 8b7bf35..ee0c4de 100644 --- a/gcc/c-family/c-common.h +++ b/gcc/c-family/c-common.h @@ -1,4 +1,4 @@ -/* Definitions for c-common.c. +/* Definitions for c-common.cc. Copyright (C) 1987-2022 Free Software Foundation, Inc. This file is part of GCC. @@ -249,7 +249,7 @@ enum rid is for __int13. */ /* Note that the range to use is RID_FIRST_INT_N through - RID_FIRST_INT_N + NUM_INT_N_ENTS - 1 and c-parser.c has a list of + RID_FIRST_INT_N + NUM_INT_N_ENTS - 1 and c-parser.cc has a list of all RID_INT_N_* in a case statement. */ RID_INT_N_0, @@ -829,10 +829,10 @@ extern const struct attribute_spec c_common_format_attribute_table[]; extern tree (*make_fname_decl) (location_t, tree, int); -/* In c-decl.c and cp/tree.c. FIXME. */ +/* In c-decl.cc and cp/tree.cc. FIXME. */ extern void c_register_addr_space (const char *str, addr_space_t as); -/* In c-common.c. */ +/* In c-common.cc. */ extern bool in_late_binary_op; extern const char *c_addr_space_name (addr_space_t as); extern tree identifier_global_value (tree); @@ -1006,7 +1006,7 @@ extern tree build_stmt (location_t, enum tree_code, ...); extern tree build_real_imag_expr (location_t, enum tree_code, tree); /* These functions must be defined by each front-end which implements - a variant of the C language. They are used in c-common.c. */ + a variant of the C language. They are used in c-common.cc. */ extern tree build_unary_op (location_t, enum tree_code, tree, bool); extern tree build_binary_op (location_t, enum tree_code, tree, tree, bool); @@ -1044,7 +1044,7 @@ extern tree resolve_overloaded_builtin (location_t, tree, vec *); extern tree finish_label_address_expr (tree, location_t); /* Same function prototype, but the C and C++ front ends have - different implementations. Used in c-common.c. */ + different implementations. Used in c-common.cc. */ extern tree lookup_label (tree); extern tree lookup_name (tree); extern bool lvalue_p (const_tree); @@ -1141,7 +1141,7 @@ class substring_loc; extern const char *c_get_substring_location (const substring_loc &substr_loc, location_t *out_loc); -/* In c-gimplify.c. */ +/* In c-gimplify.cc. */ typedef struct bc_state { tree bc_label[2]; @@ -1154,11 +1154,11 @@ extern void c_genericize (tree); extern int c_gimplify_expr (tree *, gimple_seq *, gimple_seq *); extern tree c_build_bind_expr (location_t, tree, tree); -/* In c-lex.c. */ +/* In c-lex.cc. */ extern enum cpp_ttype conflict_marker_get_final_tok_kind (enum cpp_ttype tok1_kind); -/* In c-pch.c */ +/* In c-pch.cc */ extern void pch_init (void); extern void pch_cpp_save_state (void); extern int c_common_valid_pch (cpp_reader *pfile, const char *name, int fd); @@ -1171,7 +1171,7 @@ extern void c_common_pch_pragma (cpp_reader *pfile, const char *); /* In *-checksum.c */ extern const unsigned char executable_checksum[16]; -/* In c-cppbuiltin.c */ +/* In c-cppbuiltin.cc */ extern void builtin_define_std (const char *macro); extern void builtin_define_with_value (const char *, const char *, int); extern void builtin_define_with_int_value (const char *, HOST_WIDE_INT); @@ -1181,14 +1181,14 @@ extern void fe_file_change (const line_map_ordinary *); extern void c_parse_error (const char *, enum cpp_ttype, tree, unsigned char, rich_location *richloc); -/* In c-ppoutput.c */ +/* In c-ppoutput.cc */ extern void init_pp_output (FILE *); extern void preprocess_file (cpp_reader *); extern void pp_file_change (const line_map_ordinary *); extern void pp_dir_change (cpp_reader *, const char *); extern bool check_missing_format_attribute (tree, tree); -/* In c-omp.c */ +/* In c-omp.cc */ typedef wide_int_bitmask omp_clause_mask; #define OMP_CLAUSE_MASK_1 omp_clause_mask (1) @@ -1400,7 +1400,7 @@ extern bool valid_array_size_p (location_t, const_tree, tree, bool = true); extern void invalid_array_size_error (location_t, cst_size_error, const_tree, const_tree); -/* In c-warn.c. */ +/* In c-warn.cc. */ extern void constant_expression_warning (tree); extern void constant_expression_error (tree); extern void overflow_warning (location_t, tree, tree = NULL_TREE); @@ -1466,7 +1466,7 @@ extern tree do_warn_duplicated_branches_r (tree *, int *, void *); extern void warn_for_multistatement_macros (location_t, location_t, location_t, enum rid); -/* In c-attribs.c. */ +/* In c-attribs.cc. */ extern bool attribute_takes_identifier_p (const_tree); extern tree handle_deprecated_attribute (tree *, tree, tree, int, bool *); extern tree handle_unused_attribute (tree *, tree, tree, int, bool *); @@ -1481,7 +1481,7 @@ extern tree handle_noreturn_attribute (tree *, tree, tree, int, bool *); extern bool has_attribute (location_t, tree, tree, tree (*)(tree)); extern tree build_attr_access_from_parms (tree, bool); -/* In c-format.c. */ +/* In c-format.cc. */ extern bool valid_format_string_type_p (tree); /* A bitmap of flags to positional_argument. */ diff --git a/gcc/c-family/c-cppbuiltin.cc b/gcc/c-family/c-cppbuiltin.cc index 35c0804..528211c 100644 --- a/gcc/c-family/c-cppbuiltin.cc +++ b/gcc/c-family/c-cppbuiltin.cc @@ -938,7 +938,7 @@ c_cpp_builtins (cpp_reader *pfile) cpp_define_formatted (pfile, "__GNUG__=%d", major); } - /* For stddef.h. They require macros defined in c-common.c. */ + /* For stddef.h. They require macros defined in c-common.cc. */ c_stddef_cpp_builtins (); if (c_dialect_cxx ()) diff --git a/gcc/c-family/c-format.cc b/gcc/c-family/c-format.cc index afa7781..d7878b7 100644 --- a/gcc/c-family/c-format.cc +++ b/gcc/c-family/c-format.cc @@ -544,7 +544,7 @@ static const format_length_info strfmon_length_specs[] = }; -/* Length modifiers used by the fortran/error.c routines. */ +/* Length modifiers used by the fortran/error.cc routines. */ static const format_length_info gcc_gfc_length_specs[] = { { "l", FMT_LEN_l, STD_C89, "ll", FMT_LEN_ll, STD_C89, 0 }, diff --git a/gcc/c-family/c-gimplify.cc b/gcc/c-family/c-gimplify.cc index 496895a..a00b0a0 100644 --- a/gcc/c-family/c-gimplify.cc +++ b/gcc/c-family/c-gimplify.cc @@ -705,7 +705,7 @@ c_gimplify_expr (tree *expr_p, gimple_seq *pre_p ATTRIBUTE_UNUSED, } case DECL_EXPR: - /* This is handled mostly by gimplify.c, but we have to deal with + /* This is handled mostly by gimplify.cc, but we have to deal with not warning about int x = x; as it is a GCC extension to turn off this warning but only if warn_init_self is zero. */ if (VAR_P (DECL_EXPR_DECL (*expr_p)) diff --git a/gcc/c-family/c-indentation.h b/gcc/c-family/c-indentation.h index 2d276d8..a344e9d 100644 --- a/gcc/c-family/c-indentation.h +++ b/gcc/c-family/c-indentation.h @@ -1,4 +1,4 @@ -/* Definitions for c-indentation.c. +/* Definitions for c-indentation.cc. Copyright (C) 2015-2022 Free Software Foundation, Inc. This file is part of GCC. diff --git a/gcc/c-family/c-objc.h b/gcc/c-family/c-objc.h index eb0bfac..da0ab3c 100644 --- a/gcc/c-family/c-objc.h +++ b/gcc/c-family/c-objc.h @@ -99,7 +99,7 @@ extern enum objc_property_attribute_kind objc_prop_attr_kind_for_rid (enum rid); /* Objective-C / Objective-C++ entry points. */ /* The following ObjC/ObjC++ functions are called by the C and/or C++ - front-ends; they all must have corresponding stubs in stub-objc.c. */ + front-ends; they all must have corresponding stubs in stub-objc.cc. */ extern void objc_write_global_declarations (void); extern tree objc_is_class_name (tree); extern tree objc_is_object_ptr (tree); diff --git a/gcc/c-family/c-omp.cc b/gcc/c-family/c-omp.cc index 400fd4e..0251aec 100644 --- a/gcc/c-family/c-omp.cc +++ b/gcc/c-family/c-omp.cc @@ -2993,8 +2993,8 @@ c_omp_predetermined_mapping (tree decl) /* For OpenACC, the OMP_CLAUSE_MAP_KIND of an OMP_CLAUSE_MAP is used internally to distinguish clauses as seen by the user. Return the "friendly" clause name for error messages etc., where possible. See also - c/c-parser.c:c_parser_oacc_data_clause and - cp/parser.c:cp_parser_oacc_data_clause. */ + c/c-parser.cc:c_parser_oacc_data_clause and + cp/parser.cc:cp_parser_oacc_data_clause. */ const char * c_omp_map_clause_name (tree clause, bool oacc) diff --git a/gcc/c-family/c-opts.cc b/gcc/c-family/c-opts.cc index aa6801f..21ff22d 100644 --- a/gcc/c-family/c-opts.cc +++ b/gcc/c-family/c-opts.cc @@ -895,7 +895,7 @@ c_common_post_options (const char **pfilename) warn_enum_compare = c_dialect_cxx () ? 1 : 0; /* -Wpacked-bitfield-compat is on by default for the C languages. The - warning is issued in stor-layout.c which is not part of the front-end so + warning is issued in stor-layout.cc which is not part of the front-end so we need to selectively turn it on here. */ if (warn_packed_bitfield_compat == -1) warn_packed_bitfield_compat = 1; @@ -1819,7 +1819,7 @@ set_std_cxx23 (int iso) } /* Args to -d specify what to dump. Silently ignore - unrecognized options; they may be aimed at toplev.c. */ + unrecognized options; they may be aimed at toplev.cc. */ static void handle_OPT_d (const char *arg) { diff --git a/gcc/c-family/c-pragma.cc b/gcc/c-family/c-pragma.cc index 8dde5b8..9004b04 100644 --- a/gcc/c-family/c-pragma.cc +++ b/gcc/c-family/c-pragma.cc @@ -556,7 +556,7 @@ handle_pragma_redefine_extname (cpp_reader * ARG_UNUSED (dummy)) add_to_renaming_pragma_list (oldname, newname); } -/* This is called from here and from ia64-c.c. */ +/* This is called from here and from ia64-c.cc. */ void add_to_renaming_pragma_list (tree oldname, tree newname) { diff --git a/gcc/c-family/c-pretty-print.h b/gcc/c-family/c-pretty-print.h index ae89e14..ba7624d 100644 --- a/gcc/c-family/c-pretty-print.h +++ b/gcc/c-family/c-pretty-print.h @@ -46,7 +46,7 @@ typedef void (*c_pretty_print_fn) (c_pretty_printer *, tree); language using C syntax can derive from this datatype and reuse facilities provided here. A derived pretty-printer can override any function listed in the vtable below. See cp/cxx-pretty-print.h - and cp/cxx-pretty-print.c for an example of derivation. */ + and cp/cxx-pretty-print.cc for an example of derivation. */ class c_pretty_printer : public pretty_printer { public: diff --git a/gcc/c/Make-lang.in b/gcc/c/Make-lang.in index b0e9994..1367a10 100644 --- a/gcc/c/Make-lang.in +++ b/gcc/c/Make-lang.in @@ -71,15 +71,15 @@ endif # compute checksum over all object files and the options # re-use the checksum from the prev-final stage so it passes # the bootstrap comparison and allows comparing of the cc1 binary -cc1-checksum.c : build/genchecksum$(build_exeext) checksum-options \ +cc1-checksum.cc : build/genchecksum$(build_exeext) checksum-options \ $(C_OBJS) $(BACKEND) $(LIBDEPS) if [ -f ../stage_final ] \ && cmp -s ../stage_current ../stage_final; then \ - cp ../prev-gcc/cc1-checksum.c cc1-checksum.c; \ + cp ../prev-gcc/cc1-checksum.cc cc1-checksum.cc; \ else \ build/genchecksum$(build_exeext) $(C_OBJS) $(BACKEND) $(LIBDEPS) \ - checksum-options > cc1-checksum.c.tmp && \ - $(srcdir)/../move-if-change cc1-checksum.c.tmp cc1-checksum.c; \ + checksum-options > cc1-checksum.cc.tmp && \ + $(srcdir)/../move-if-change cc1-checksum.cc.tmp cc1-checksum.cc; \ fi cc1$(exeext): $(C_OBJS) cc1-checksum.o $(BACKEND) $(LIBDEPS) @@ -106,7 +106,7 @@ c.all.cross: c.start.encap: c.rest.encap: c.srcinfo: -c.srcextra: gengtype-lex.c +c.srcextra: gengtype-lex.cc -cp -p $^ $(srcdir) c.tags: force cd $(srcdir)/c; $(ETAGS) -o TAGS.sub *.c *.h; \ diff --git a/gcc/c/c-convert.cc b/gcc/c/c-convert.cc index 5e92759..18083d5 100644 --- a/gcc/c/c-convert.cc +++ b/gcc/c/c-convert.cc @@ -45,12 +45,12 @@ along with GCC; see the file COPYING3. If not see Here is a list of all the functions that assume that widening and narrowing is always done with a NOP_EXPR: - In convert.c, convert_to_integer. - In c-typeck.c, build_binary_op (boolean ops), and + In convert.cc, convert_to_integer. + In c-typeck.cc, build_binary_op (boolean ops), and c_common_truthvalue_conversion. - In expr.c: expand_expr, for operands of a MULT_EXPR. - In fold-const.c: fold. - In tree.c: get_narrower and get_unwidened. */ + In expr.cc: expand_expr, for operands of a MULT_EXPR. + In fold-const.cc: fold. + In tree.cc: get_narrower and get_unwidened. */ /* Subroutines of `convert'. */ diff --git a/gcc/c/c-decl.cc b/gcc/c/c-decl.cc index 29a79eb..c701f07 100644 --- a/gcc/c/c-decl.cc +++ b/gcc/c/c-decl.cc @@ -225,7 +225,7 @@ struct GTY(()) lang_identifier { struct c_binding *label_binding; /* labels */ }; -/* Validate c-lang.c's assumptions. */ +/* Validate c-lang.cc's assumptions. */ extern char C_SIZEOF_STRUCT_LANG_IDENTIFIER_isnt_accurate [(sizeof(struct lang_identifier) == C_SIZEOF_STRUCT_LANG_IDENTIFIER) ? 1 : -1]; @@ -1367,7 +1367,7 @@ pop_scope (void) gcc_fallthrough (); /* Parameters go in DECL_ARGUMENTS, not BLOCK_VARS, and have already been put there by store_parm_decls. Unused- - parameter warnings are handled by function.c. + parameter warnings are handled by function.cc. error_mark_node obviously does not go in BLOCK_VARS and does not get unused-variable warnings. */ case PARM_DECL: @@ -5527,7 +5527,7 @@ finish_decl (tree decl, location_t init_loc, tree init, if (TREE_PUBLIC (decl)) c_determine_visibility (decl); - /* This is a no-op in c-lang.c or something real in objc-act.c. */ + /* This is a no-op in c-lang.cc or something real in objc-act.cc. */ if (c_dialect_objc ()) objc_check_decl (decl); diff --git a/gcc/c/c-objc-common.h b/gcc/c/c-objc-common.h index d23bdea..0b60df9 100644 --- a/gcc/c/c-objc-common.h +++ b/gcc/c/c-objc-common.h @@ -22,7 +22,7 @@ along with GCC; see the file COPYING3. If not see #define GCC_C_OBJC_COMMON /* Lang hooks that are shared between C and ObjC are defined here. Hooks - specific to C or ObjC go in c-lang.c and objc/objc-lang.c, respectively. */ + specific to C or ObjC go in c-lang.cc and objc/objc-lang.cc, respectively. */ #undef LANG_HOOKS_IDENTIFIER_SIZE #define LANG_HOOKS_IDENTIFIER_SIZE C_SIZEOF_STRUCT_LANG_IDENTIFIER diff --git a/gcc/c/c-parser.cc b/gcc/c/c-parser.cc index 20774f7..e9086c5 100644 --- a/gcc/c/c-parser.cc +++ b/gcc/c/c-parser.cc @@ -1413,7 +1413,7 @@ c_parser_skip_to_end_of_block_or_statement (c_parser *parser) parser->error = false; } -/* CPP's options (initialized by c-opts.c). */ +/* CPP's options (initialized by c-opts.cc). */ extern cpp_options *cpp_opts; /* Save the warning flags which are controlled by __extension__. */ diff --git a/gcc/c/c-parser.h b/gcc/c/c-parser.h index 8d5fc30..3d256b6 100644 --- a/gcc/c/c-parser.h +++ b/gcc/c/c-parser.h @@ -23,7 +23,7 @@ along with GCC; see the file COPYING3. If not see #ifndef GCC_C_PARSER_H #define GCC_C_PARSER_H -/* The C lexer intermediates between the lexer in cpplib and c-lex.c +/* The C lexer intermediates between the lexer in cpplib and c-lex.cc and the C parser. Unlike the C++ lexer, the parser structure stores the lexer information instead of using a separate structure. Identifiers are separated into ordinary identifiers, type names, diff --git a/gcc/c/c-tree.h b/gcc/c/c-tree.h index df03fd2..c70f0ba 100644 --- a/gcc/c/c-tree.h +++ b/gcc/c/c-tree.h @@ -23,8 +23,8 @@ along with GCC; see the file COPYING3. If not see #include "c-family/c-common.h" #include "diagnostic.h" -/* struct lang_identifier is private to c-decl.c, but langhooks.c needs to - know how big it is. This is sanity-checked in c-decl.c. */ +/* struct lang_identifier is private to c-decl.cc, but langhooks.cc needs to + know how big it is. This is sanity-checked in c-decl.cc. */ #define C_SIZEOF_STRUCT_LANG_IDENTIFIER \ (sizeof (struct c_common_identifier) + 3 * sizeof (void *)) @@ -538,14 +538,14 @@ enum c_inline_static_type { }; -/* in c-parser.c */ +/* in c-parser.cc */ extern void c_parse_init (void); extern bool c_keyword_starts_typename (enum rid keyword); -/* in c-aux-info.c */ +/* in c-aux-info.cc */ extern void gen_aux_info_record (tree, int, int, int); -/* in c-decl.c */ +/* in c-decl.cc */ struct c_spot_bindings; class c_struct_parse_info; extern struct obstack parser_obstack; @@ -660,7 +660,7 @@ extern struct c_declspecs *declspecs_add_alignas (location_t, struct c_declspecs *, tree); extern struct c_declspecs *finish_declspecs (struct c_declspecs *); -/* in c-objc-common.c */ +/* in c-objc-common.cc */ extern bool c_objc_common_init (void); extern bool c_missing_noreturn_ok_p (tree); extern bool c_warn_unused_global_decl (const_tree); @@ -668,7 +668,7 @@ extern void c_initialize_diagnostics (diagnostic_context *); extern bool c_vla_unspec_p (tree x, tree fn); extern alias_set_type c_get_alias_set (tree); -/* in c-typeck.c */ +/* in c-typeck.cc */ extern int in_alignof; extern int in_sizeof; extern int in_typeof; @@ -783,7 +783,7 @@ extern int current_function_returns_null; extern int current_function_returns_abnormally; -/* In c-decl.c */ +/* In c-decl.cc */ /* Tell the binding oracle what kind of binding we are looking for. */ @@ -798,7 +798,7 @@ enum c_oracle_request create bindings when needed by the C compiler. The oracle is told the name and type of the binding to create. It can call pushdecl or the like to ensure the binding is visible; or do nothing, - leaving the binding untouched. c-decl.c takes note of when the + leaving the binding untouched. c-decl.cc takes note of when the oracle has been called and will not call it again if it fails to create a given binding. */ @@ -816,7 +816,7 @@ extern void c_pushtag (location_t, tree, tree); extern void c_bind (location_t, tree, bool); extern bool tag_exists_p (enum tree_code, tree); -/* In c-errors.c */ +/* In c-errors.cc */ extern bool pedwarn_c90 (location_t, int opt, const char *, ...) ATTRIBUTE_GCC_DIAG(3,4); extern bool pedwarn_c99 (location_t, int opt, const char *, ...) @@ -832,7 +832,7 @@ extern void set_c_expr_source_range (c_expr *expr, source_range src_range); -/* In c-fold.c */ +/* In c-fold.cc */ extern vec incomplete_record_decls; #if CHECKING_P diff --git a/gcc/c/c-typeck.cc b/gcc/c/c-typeck.cc index ac6618e..b06f078 100644 --- a/gcc/c/c-typeck.cc +++ b/gcc/c/c-typeck.cc @@ -1009,7 +1009,7 @@ c_common_type (tree t1, tree t2) return t2; } -/* Wrapper around c_common_type that is used by c-common.c and other +/* Wrapper around c_common_type that is used by c-common.cc and other front end optimizations that remove promotions. ENUMERAL_TYPEs are allowed here and are converted to their compatible integer types. BOOLEAN_TYPEs are allowed here and return either boolean_type_node or @@ -14996,7 +14996,7 @@ c_finish_omp_clauses (tree clauses, enum c_omp_region_type ort) || OMP_CLAUSE_MAP_KIND (c) == GOMP_MAP_DETACH)) /* For attach/detach clauses, set OMP_CLAUSE_SIZE (representing a bias) to zero here, so it is not set erroneously to the pointer - size later on in gimplify.c. */ + size later on in gimplify.cc. */ OMP_CLAUSE_SIZE (c) = size_zero_node; while (TREE_CODE (t) == INDIRECT_REF || TREE_CODE (t) == ARRAY_REF) diff --git a/gcc/c/config-lang.in b/gcc/c/config-lang.in index cb697e8..4526f63 100644 --- a/gcc/c/config-lang.in +++ b/gcc/c/config-lang.in @@ -29,4 +29,4 @@ compilers="cc1\$(exeext)" target_libs= -gtfiles="\$(srcdir)/c/c-lang.c \$(srcdir)/c/c-tree.h \$(srcdir)/c/c-decl.c \$(srcdir)/c-family/c-common.c \$(srcdir)/c-family/c-common.h \$(srcdir)/c-family/c-objc.h \$(srcdir)/c-family/c-cppbuiltin.c \$(srcdir)/c-family/c-pragma.h \$(srcdir)/c-family/c-pragma.c \$(srcdir)/c-family/c-format.c \$(srcdir)/c/c-objc-common.c \$(srcdir)/c/c-parser.h \$(srcdir)/c/c-parser.c \$(srcdir)/c/c-lang.h" +gtfiles="\$(srcdir)/c/c-lang.cc \$(srcdir)/c/c-tree.h \$(srcdir)/c/c-decl.cc \$(srcdir)/c-family/c-common.cc \$(srcdir)/c-family/c-common.h \$(srcdir)/c-family/c-objc.h \$(srcdir)/c-family/c-cppbuiltin.cc \$(srcdir)/c-family/c-pragma.h \$(srcdir)/c-family/c-pragma.cc \$(srcdir)/c-family/c-format.cc \$(srcdir)/c/c-objc-common.cc \$(srcdir)/c/c-parser.h \$(srcdir)/c/c-parser.cc \$(srcdir)/c/c-lang.h" diff --git a/gcc/caller-save.cc b/gcc/caller-save.cc index 5ef1b63..9e28ec3 100644 --- a/gcc/caller-save.cc +++ b/gcc/caller-save.cc @@ -173,7 +173,7 @@ reg_restore_code (int reg, machine_mode mode) /* Initialize for caller-save. Look at all the hard registers that are used by a call and for which - reginfo.c has not already excluded from being used across a call. + reginfo.cc has not already excluded from being used across a call. Ensure that we can find a mode to save the register and that there is a simple insn to save and restore the register. This latter check avoids @@ -520,7 +520,7 @@ setup_save_areas (void) CLEAR_HARD_REG_SET (this_insn_sets); note_stores (insn, mark_set_regs, &this_insn_sets); /* Sibcalls are considered to set the return value, - compare df-scan.c:df_get_call_refs. */ + compare df-scan.cc:df_get_call_refs. */ if (SIBLING_CALL_P (insn) && crtl->return_rtx) mark_set_regs (crtl->return_rtx, NULL_RTX, &this_insn_sets); diff --git a/gcc/calls.cc b/gcc/calls.cc index e0d0101..e64a937 100644 --- a/gcc/calls.cc +++ b/gcc/calls.cc @@ -1351,7 +1351,7 @@ initialize_argument_information (int num_actuals ATTRIBUTE_UNUSED, if args[i].reg is nonzero. These decisions are driven by the FUNCTION_... macros and must agree - with those made by function.c. */ + with those made by function.cc. */ /* See if this argument should be passed by invisible reference. */ function_arg_info arg (type, argpos < n_named_args); @@ -1548,7 +1548,7 @@ initialize_argument_information (int num_actuals ATTRIBUTE_UNUSED, /* ??? Traditionally we've passed TYPE_MODE here, instead of the promoted_mode used for function_arg above. However, the - corresponding handling of incoming arguments in function.c + corresponding handling of incoming arguments in function.cc does pass the promoted mode. */ arg.mode = TYPE_MODE (type); targetm.calls.function_arg_advance (args_so_far, arg); @@ -3669,7 +3669,7 @@ expand_call (tree exp, rtx target, int ignore) } /* For calls to `setjmp', etc., inform - function.c:setjmp_warnings that it should complain if + function.cc:setjmp_warnings that it should complain if nonvolatile values are live. For functions that cannot return, inform flow that control does not fall through. */ @@ -4526,7 +4526,7 @@ emit_library_call_value_1 (int retval, rtx orgfun, rtx value, NO_DEFER_POP; - /* Indicate argument access so that alias.c knows that these + /* Indicate argument access so that alias.cc knows that these values are live. */ if (argblock) use = plus_constant (Pmode, argblock, @@ -4535,7 +4535,7 @@ emit_library_call_value_1 (int retval, rtx orgfun, rtx value, continue; else { - /* When arguments are pushed, trying to tell alias.c where + /* When arguments are pushed, trying to tell alias.cc where exactly this argument is won't work, because the auto-increment causes confusion. So we merely indicate that we access something with a known mode somewhere on @@ -4685,7 +4685,7 @@ emit_library_call_value_1 (int retval, rtx orgfun, rtx value, targetm.calls.end_call_args (); - /* For calls to `setjmp', etc., inform function.c:setjmp_warnings + /* For calls to `setjmp', etc., inform function.cc:setjmp_warnings that it should complain if nonvolatile values are live. For functions that cannot return, inform flow that control does not fall through. */ diff --git a/gcc/cfg-flags.def b/gcc/cfg-flags.def index aced6e6..a2c0676 100644 --- a/gcc/cfg-flags.def +++ b/gcc/cfg-flags.def @@ -74,7 +74,7 @@ DEF_BASIC_BLOCK_FLAG(NON_LOCAL_GOTO_TARGET, 8) DEF_BASIC_BLOCK_FLAG(RTL, 9) /* Set on blocks that are forwarder blocks. - Only used in cfgcleanup.c. */ + Only used in cfgcleanup.cc. */ DEF_BASIC_BLOCK_FLAG(FORWARDER_BLOCK, 10) /* Set on blocks that cannot be threaded through. @@ -163,11 +163,11 @@ DEF_EDGE_FLAG(CROSSING, 11) This flag is only used for the RTL CFG. */ DEF_EDGE_FLAG(SIBCALL, 12) -/* Candidate for straight line flow. Only used in bb-reorder.c. +/* Candidate for straight line flow. Only used in bb-reorder.cc. This flag is only used for the RTL CFG. */ DEF_EDGE_FLAG(CAN_FALLTHRU, 13) -/* Exit of a loop. This is only used in ifcvt.c. +/* Exit of a loop. This is only used in ifcvt.cc. This flag is only used for the RTL CFG. */ DEF_EDGE_FLAG(LOOP_EXIT, 14) diff --git a/gcc/cfganal.cc b/gcc/cfganal.cc index 19307e2..e570d27 100644 --- a/gcc/cfganal.cc +++ b/gcc/cfganal.cc @@ -701,7 +701,7 @@ post_order_compute (int *post_order, bool include_entry_exit, /* Helper routine for inverted_post_order_compute flow_dfs_compute_reverse_execute, and the reverse-CFG - deapth first search in dominance.c. + deapth first search in dominance.cc. BB has to belong to a region of CFG unreachable by inverted traversal from the exit. i.e. there's no control flow path from ENTRY to EXIT diff --git a/gcc/cfgcleanup.cc b/gcc/cfgcleanup.cc index 3d98ddb..335af49 100644 --- a/gcc/cfgcleanup.cc +++ b/gcc/cfgcleanup.cc @@ -147,7 +147,7 @@ try_simplify_condjump (basic_block cbranch_block) be optimizable (or blocks that appear to be mergeable), but which really must be left untouched (they are required to make it safely across partition boundaries). See the comments at the top of - bb-reorder.c:partition_hot_cold_basic_blocks for complete details. */ + bb-reorder.cc:partition_hot_cold_basic_blocks for complete details. */ if (BB_PARTITION (jump_block) != BB_PARTITION (jump_dest_block) || (cbranch_jump_edge->flags & EDGE_CROSSING)) @@ -628,7 +628,7 @@ merge_blocks_move_predecessor_nojumps (basic_block a, basic_block b) be optimizable (or blocks that appear to be mergeable), but which really must be left untouched (they are required to make it safely across partition boundaries). See the comments at the top of - bb-reorder.c:partition_hot_cold_basic_blocks for complete details. */ + bb-reorder.cc:partition_hot_cold_basic_blocks for complete details. */ if (BB_PARTITION (a) != BB_PARTITION (b)) return; @@ -674,7 +674,7 @@ merge_blocks_move_successor_nojumps (basic_block a, basic_block b) be optimizable (or blocks that appear to be mergeable), but which really must be left untouched (they are required to make it safely across partition boundaries). See the comments at the top of - bb-reorder.c:partition_hot_cold_basic_blocks for complete details. */ + bb-reorder.cc:partition_hot_cold_basic_blocks for complete details. */ if (BB_PARTITION (a) != BB_PARTITION (b)) return; @@ -734,7 +734,7 @@ merge_blocks_move (edge e, basic_block b, basic_block c, int mode) be optimizable (or blocks that appear to be mergeable), but which really must be left untouched (they are required to make it safely across partition boundaries). See the comments at the top of - bb-reorder.c:partition_hot_cold_basic_blocks for complete details. */ + bb-reorder.cc:partition_hot_cold_basic_blocks for complete details. */ if (BB_PARTITION (b) != BB_PARTITION (c)) return NULL; @@ -1180,7 +1180,7 @@ old_insns_match_p (int mode ATTRIBUTE_UNUSED, rtx_insn *i1, rtx_insn *i2) /* If this is a CALL_INSN, compare register usage information. If we don't check this on stack register machines, the two - CALL_INSNs might be merged leaving reg-stack.c with mismatching + CALL_INSNs might be merged leaving reg-stack.cc with mismatching numbers of stack registers in the same basic block. If we don't check this on machines with delay slots, a delay slot may be filled that clobbers a parameter expected by the subroutine. @@ -2194,7 +2194,7 @@ try_crossjump_bb (int mode, basic_block bb) be optimizable (or blocks that appear to be mergeable), but which really must be left untouched (they are required to make it safely across partition boundaries). See the comments at the top of - bb-reorder.c:partition_hot_cold_basic_blocks for complete details. */ + bb-reorder.cc:partition_hot_cold_basic_blocks for complete details. */ if (BB_PARTITION (EDGE_PRED (bb, 0)->src) != BB_PARTITION (EDGE_PRED (bb, 1)->src) diff --git a/gcc/cfgexpand.cc b/gcc/cfgexpand.cc index f6de41c..d51af2e 100644 --- a/gcc/cfgexpand.cc +++ b/gcc/cfgexpand.cc @@ -4056,7 +4056,7 @@ expand_gimple_stmt (gimple *stmt) /* A subroutine of expand_gimple_basic_block. Expand one GIMPLE_CALL that has CALL_EXPR_TAILCALL set. Returns non-null if we actually generated a tail call (something that might be denied by the ABI - rules governing the call; see calls.c). + rules governing the call; see calls.cc). Sets CAN_FALLTHRU if we generated a *conditional* tail call, and can still reach the rest of BB. The case here is __builtin_sqrt, diff --git a/gcc/cfghooks.cc b/gcc/cfghooks.cc index dcec51d..e435891 100644 --- a/gcc/cfghooks.cc +++ b/gcc/cfghooks.cc @@ -1455,7 +1455,7 @@ split_block_before_cond_jump (basic_block bb) return cfg_hooks->split_block_before_cond_jump (bb); } -/* Work-horse for passes.c:check_profile_consistency. +/* Work-horse for passes.cc:check_profile_consistency. Do book-keeping of the CFG for the profile consistency checker. Store the counting in RECORD. */ @@ -1539,7 +1539,7 @@ profile_record_check_consistency (profile_record *record) } } -/* Work-horse for passes.c:acount_profile. +/* Work-horse for passes.cc:acount_profile. Do book-keeping of the CFG for the profile accounting. Store the counting in RECORD. */ diff --git a/gcc/cfghooks.h b/gcc/cfghooks.h index 5622007..0982d70 100644 --- a/gcc/cfghooks.h +++ b/gcc/cfghooks.h @@ -25,14 +25,14 @@ along with GCC; see the file COPYING3. If not see /* Structure to gather statistic about profile consistency, per pass. An array of this structure, indexed by pass static number, is allocated - in passes.c. The structure is defined here so that different CFG modes + in passes.cc. The structure is defined here so that different CFG modes can do their book-keeping via CFG hooks. For every field[2], field[0] is the count before the pass runs, and field[1] is the post-pass count. This allows us to monitor the effect of each individual pass on the profile consistency. - This structure is not supposed to be used by anything other than passes.c + This structure is not supposed to be used by anything other than passes.cc and one CFG hook per CFG mode. */ struct profile_record { diff --git a/gcc/cfgrtl.cc b/gcc/cfgrtl.cc index 1261479..9ccc65b 100644 --- a/gcc/cfgrtl.cc +++ b/gcc/cfgrtl.cc @@ -490,7 +490,7 @@ public: unsigned int pass_free_cfg::execute (function *) { - /* The resource.c machinery uses DF but the CFG isn't guaranteed to be + /* The resource.cc machinery uses DF but the CFG isn't guaranteed to be valid at that point so it would be too late to call df_analyze. */ if (DELAY_SLOTS && optimize > 0 && flag_delayed_branch) { @@ -954,7 +954,7 @@ rtl_can_merge_blocks (basic_block a, basic_block b) be optimizable (or blocks that appear to be mergeable), but which really must be left untouched (they are required to make it safely across partition boundaries). See the comments at the top of - bb-reorder.c:partition_hot_cold_basic_blocks for complete details. */ + bb-reorder.cc:partition_hot_cold_basic_blocks for complete details. */ if (BB_PARTITION (a) != BB_PARTITION (b)) return false; @@ -1043,7 +1043,7 @@ try_redirect_by_replacing_jump (edge e, basic_block target, bool in_cfglayout) be optimizable (or blocks that appear to be mergeable), but which really must be left untouched (they are required to make it safely across partition boundaries). See the comments at the top of - bb-reorder.c:partition_hot_cold_basic_blocks for complete details. */ + bb-reorder.cc:partition_hot_cold_basic_blocks for complete details. */ if (BB_PARTITION (src) != BB_PARTITION (target)) return NULL; @@ -3755,7 +3755,7 @@ make_pass_outof_cfg_layout_mode (gcc::context *ctxt) bits are the STAY_IN_CFGLAYOUT_MODE bits. The tracer pass was moved to GIMPLE a long time ago, but it doesn't relink the basic block chain. It could do that (to give better initial RTL) if this function - is made IR-agnostic (and moved to cfganal.c or cfg.c while at it). */ + is made IR-agnostic (and moved to cfganal.cc or cfg.cc while at it). */ void relink_block_chain (bool stay_in_cfglayout_mode) @@ -4744,7 +4744,7 @@ cfg_layout_can_merge_blocks_p (basic_block a, basic_block b) be optimizable (or blocks that appear to be mergeable), but which really must be left untouched (they are required to make it safely across partition boundaries). See the comments at the top of - bb-reorder.c:partition_hot_cold_basic_blocks for complete details. */ + bb-reorder.cc:partition_hot_cold_basic_blocks for complete details. */ if (BB_PARTITION (a) != BB_PARTITION (b)) return false; diff --git a/gcc/cgraph.cc b/gcc/cgraph.cc index 1bbca9d..ea8db2f 100644 --- a/gcc/cgraph.cc +++ b/gcc/cgraph.cc @@ -1821,7 +1821,7 @@ release_function_body (tree decl) /* Release memory used to represent body of function. Use this only for functions that are released before being translated to target code (i.e. RTL). Functions that are compiled to RTL and beyond - are free'd in final.c via free_after_compilation(). + are free'd in final.cc via free_after_compilation(). KEEP_ARGUMENTS are useful only if you want to rebuild body as thunk. */ void @@ -4073,7 +4073,7 @@ cgraph_node::get_fun () const return fun; } -/* Reset all state within cgraph.c so that we can rerun the compiler +/* Reset all state within cgraph.cc so that we can rerun the compiler within the same process. For use by toplev::finalize. */ void diff --git a/gcc/cgraph.h b/gcc/cgraph.h index 0107051..a265107 100644 --- a/gcc/cgraph.h +++ b/gcc/cgraph.h @@ -504,7 +504,7 @@ public: declarations). In this case the assembler names compare via assembler_names_equal_p and weakref is false - aliases that are renamed at a time being output to final file - by varasm.c. For those DECL_ASSEMBLER_NAME have + by varasm.cc. For those DECL_ASSEMBLER_NAME have IDENTIFIER_TRANSPARENT_ALIAS set and thus also their assembler name must be unique. Weakrefs belong to this category when we target assembler without @@ -1106,7 +1106,7 @@ struct GTY((tag ("SYMTAB_FUNCTION"))) cgraph_node : public symtab_node /* Release memory used to represent body of function. Use this only for functions that are released before being translated to target code (i.e. RTL). Functions that are compiled to RTL and beyond - are free'd in final.c via free_after_compilation(). */ + are free'd in final.cc via free_after_compilation(). */ void release_body (bool keep_arguments = false); /* Return the DECL_STRUCT_FUNCTION of the function. */ @@ -1415,7 +1415,7 @@ struct GTY((tag ("SYMTAB_FUNCTION"))) cgraph_node : public symtab_node struct cgraph_rtl_info *rtl; - /* Expected number of executions: calculated in profile.c. */ + /* Expected number of executions: calculated in profile.cc. */ profile_count count; /* How to scale counts at materialization time; used to merge LTO units with different number of profile runs. */ @@ -1883,7 +1883,7 @@ public: /* Return num_speculative_targets of this edge. */ int num_speculative_call_targets_p (void); - /* Expected number of executions: calculated in profile.c. */ + /* Expected number of executions: calculated in profile.cc. */ profile_count count; cgraph_node *caller; cgraph_node *callee; @@ -2567,7 +2567,7 @@ asmname_hasher::equal (symtab_node *n, const_tree t) return symbol_table::decl_assembler_name_equal (n->decl, t); } -/* In cgraph.c */ +/* In cgraph.cc */ void cgraph_c_finalize (void); void release_function_body (tree); cgraph_indirect_call_info *cgraph_allocate_init_indirect_info (void); @@ -2578,7 +2578,7 @@ bool cgraph_function_possibly_inlined_p (tree); const char* cgraph_inline_failed_string (cgraph_inline_failed_t); cgraph_inline_failed_type_t cgraph_inline_failed_type (cgraph_inline_failed_t); -/* In cgraphunit.c */ +/* In cgraphunit.cc */ void cgraphunit_c_finalize (void); int tp_first_run_node_cmp (const void *pa, const void *pb); @@ -2591,7 +2591,7 @@ basic_block init_lowered_empty_function (tree, bool, profile_count); tree thunk_adjust (gimple_stmt_iterator *, tree, bool, HOST_WIDE_INT, tree, HOST_WIDE_INT); -/* In cgraphclones.c */ +/* In cgraphclones.cc */ tree clone_function_name_numbered (const char *name, const char *suffix); tree clone_function_name_numbered (tree decl, const char *suffix); @@ -2608,18 +2608,18 @@ void tree_function_versioning (tree, tree, vec *, void dump_callgraph_transformation (const cgraph_node *original, const cgraph_node *clone, const char *suffix); -/* In cgraphbuild.c */ +/* In cgraphbuild.cc */ int compute_call_stmt_bb_frequency (tree, basic_block bb); void record_references_in_initializer (tree, bool); -/* In ipa.c */ +/* In ipa.cc */ void cgraph_build_static_cdtor (char which, tree body, int priority); bool ipa_discover_variable_flags (void); -/* In varpool.c */ +/* In varpool.cc */ tree ctor_for_folding (tree); -/* In ipa-inline-analysis.c */ +/* In ipa-inline-analysis.cc */ void initialize_inline_failed (struct cgraph_edge *); bool speculation_useful_p (struct cgraph_edge *e, bool anticipate_inlining); diff --git a/gcc/cgraphclones.cc b/gcc/cgraphclones.cc index 9967862..60da1e8 100644 --- a/gcc/cgraphclones.cc +++ b/gcc/cgraphclones.cc @@ -469,7 +469,7 @@ static GTY(()) hash_map *clone_fn_ids; each NAME) unspecified number. If clone numbering is not needed then the two argument clone_function_name should be used instead. Should not be called directly except for by - lto-partition.c:privatize_symbol_name_1. */ + lto-partition.cc:privatize_symbol_name_1. */ tree clone_function_name_numbered (const char *name, const char *suffix) diff --git a/gcc/cgraphunit.cc b/gcc/cgraphunit.cc index 8404ac3..e043f9f 100644 --- a/gcc/cgraphunit.cc +++ b/gcc/cgraphunit.cc @@ -2531,7 +2531,7 @@ symbol_table::finalize_compilation_unit (void) timevar_pop (TV_CGRAPH); } -/* Reset all state within cgraphunit.c so that we can rerun the compiler +/* Reset all state within cgraphunit.cc so that we can rerun the compiler within the same process. For use by toplev::finalize. */ void diff --git a/gcc/collect-utils.h b/gcc/collect-utils.h index 04ba0dd..98cacea 100644 --- a/gcc/collect-utils.h +++ b/gcc/collect-utils.h @@ -20,7 +20,7 @@ along with GCC; see the file COPYING3. If not see #ifndef GCC_COLLECT_UTILS_H #define GCC_COLLECT_UTILS_H -/* Provided in collect-utils.c. */ +/* Provided in collect-utils.cc. */ extern void notice (const char *, ...) __attribute__ ((format (printf, 1, 2))); extern void fatal_signal (int); diff --git a/gcc/collect2-aix.h b/gcc/collect2-aix.h index a804fae..7efbca5 100644 --- a/gcc/collect2-aix.h +++ b/gcc/collect2-aix.h @@ -19,7 +19,7 @@ along with GCC; see the file COPYING3. If not see #ifndef GCC_COLLECT2_AIX_H #define GCC_COLLECT2_AIX_H -/* collect2-aix.c requires mmap support. It should otherwise be +/* collect2-aix.cc requires mmap support. It should otherwise be fairly portable. */ #if defined(CROSS_DIRECTORY_STRUCTURE) \ && defined(TARGET_AIX_VERSION) \ diff --git a/gcc/collect2.cc b/gcc/collect2.cc index dd5022fb..0185b9d 100644 --- a/gcc/collect2.cc +++ b/gcc/collect2.cc @@ -739,7 +739,7 @@ maybe_run_lto_and_relink (char **lto_ld_argv, char **object_lst, else post_ld_pass (false); /* No LTO objects were found, no temp file. */ } -/* Entry point for linker invoation. Called from main in collect2.c. +/* Entry point for linker invoation. Called from main in collect2.cc. LD_ARGV is an array of arguments for the linker. */ static void diff --git a/gcc/combine-stack-adj.cc b/gcc/combine-stack-adj.cc index d360656..e8ba271 100644 --- a/gcc/combine-stack-adj.cc +++ b/gcc/combine-stack-adj.cc @@ -26,7 +26,7 @@ along with GCC; see the file COPYING3. If not see targets that define PREFERRED_STACK_BOUNDARY more aligned than STACK_BOUNDARY (e.g. x86), or if not all registers can be pushed (e.g. x86 fp regs) which would ordinarily have to be implemented - as a sub/mov pair due to restrictions in calls.c. + as a sub/mov pair due to restrictions in calls.cc. Propagation stops when any of the insns that need adjusting are (a) no longer valid because we've exceeded their range, (b) a diff --git a/gcc/combine.cc b/gcc/combine.cc index fb4a27a..2d40635 100644 --- a/gcc/combine.cc +++ b/gcc/combine.cc @@ -1514,7 +1514,7 @@ setup_incoming_promotions (rtx_insn *first) uns3 = TYPE_UNSIGNED (DECL_ARG_TYPE (arg)); /* The mode and signedness of the argument as it is actually passed, - see assign_parm_setup_reg in function.c. */ + see assign_parm_setup_reg in function.cc. */ mode3 = promote_function_mode (TREE_TYPE (arg), mode1, &uns3, TREE_TYPE (cfun->decl), 0); @@ -5907,7 +5907,7 @@ combine_simplify_rtx (rtx x, machine_mode op0_mode, int in_dest, return gen_int_mode (c, mode); } - /* Similarly to what we do in simplify-rtx.c, a truncate of a register + /* Similarly to what we do in simplify-rtx.cc, a truncate of a register whose value is a comparison can be replaced with a subreg if STORE_FLAG_VALUE permits. */ if (HWI_COMPUTABLE_MODE_P (mode) @@ -13043,7 +13043,7 @@ count_rtxs (rtx x) /* Utility function for following routine. Called when X is part of a value being stored into last_set_value. Sets last_set_table_tick - for each register mentioned. Similar to mention_regs in cse.c */ + for each register mentioned. Similar to mention_regs in cse.cc */ static void update_table_tick (rtx x) diff --git a/gcc/common.opt b/gcc/common.opt index c3f6472..fe7bcf6 100644 --- a/gcc/common.opt +++ b/gcc/common.opt @@ -150,7 +150,7 @@ bool flag_stack_usage_info = false ; the generated assembly code (to make it more readable). This option ; is generally only of use to those who actually need to read the ; generated assembly code (perhaps while debugging the compiler itself). -; Currently, this switch is only used by dwarf2out.c; however, it is intended +; Currently, this switch is only used by dwarf2out.cc; however, it is intended ; to be a catchall for printing debug information in the assembler file. Variable int flag_debug_asm diff --git a/gcc/common/config/aarch64/aarch64-common.cc b/gcc/common/config/aarch64/aarch64-common.cc index 140e3e7..dfda5b8 100644 --- a/gcc/common/config/aarch64/aarch64-common.cc +++ b/gcc/common/config/aarch64/aarch64-common.cc @@ -71,7 +71,7 @@ static const struct default_options aarch_option_optimization_table[] = -mcpu=CPU is shorthand for -march=ARCH_FOR_CPU, -mtune=CPU. If either of -march or -mtune is given, they override their respective component of -mcpu. This logic is implemented - in config/aarch64/aarch64.c:aarch64_override_options. */ + in config/aarch64/aarch64.cc:aarch64_override_options. */ bool aarch64_handle_option (struct gcc_options *opts, diff --git a/gcc/common/config/arm/arm-common.cc b/gcc/common/config/arm/arm-common.cc index 2ca640b..c38812f 100644 --- a/gcc/common/config/arm/arm-common.cc +++ b/gcc/common/config/arm/arm-common.cc @@ -1054,7 +1054,7 @@ arm_asm_auto_mfpu (int argc, const char **argv) bitmap_and (fpubits, fpubits, target_isa); /* The logic below is essentially identical to that in - arm.c:arm_identify_fpu_from_isa(), but that only works in the main + arm.cc:arm_identify_fpu_from_isa(), but that only works in the main part of the compiler. */ /* If there are no FPU capability bits, we just pass -mfpu=softvfp. */ diff --git a/gcc/common/config/avr/avr-common.cc b/gcc/common/config/avr/avr-common.cc index bc61ac0..f4e3f55 100644 --- a/gcc/common/config/avr/avr-common.cc +++ b/gcc/common/config/avr/avr-common.cc @@ -70,7 +70,7 @@ static const struct default_options avr_option_optimization_table[] = /* Implement `TARGET_HANDLE_OPTION'. */ -/* This is the same logic that driver-avr.c:avr_double_lib() applies +/* This is the same logic that driver-avr.cc:avr_double_lib() applies during DRIVER_SELF_SPECS, but this time we complain about -mdouble= and -mlong-double= that are not provided by --with-double= resp. --with-long-double= */ diff --git a/gcc/common/config/i386/i386-isas.h b/gcc/common/config/i386/i386-isas.h index e819ed0..2d0646a 100644 --- a/gcc/common/config/i386/i386-isas.h +++ b/gcc/common/config/i386/i386-isas.h @@ -27,9 +27,9 @@ struct _isa_names_table const char *const option; }; -/* NB: isa_names_table is shared by i386-builtins.c, driver-i386.c and +/* NB: isa_names_table is shared by i386-builtins.cc, driver-i386.cc and gcc.target/i386/builtin_target.c. isa_names_table is a static const - array in i386-builtins.c and driver-i386.c. But it is a list of + array in i386-builtins.cc and driver-i386.cc. But it is a list of assert statements in gcc.target/i386/builtin_target.c. */ #ifndef ISA_NAMES_TABLE_START diff --git a/gcc/conditions.h b/gcc/conditions.h index 5e964c8..435d7ad 100644 --- a/gcc/conditions.h +++ b/gcc/conditions.h @@ -1,4 +1,4 @@ -/* Definitions for condition code handling in final.c and output routines. +/* Definitions for condition code handling in final.cc and output routines. Copyright (C) 1987-2022 Free Software Foundation, Inc. This file is part of GCC. diff --git a/gcc/config.gcc b/gcc/config.gcc index f1b8d83..bad51e0 100644 --- a/gcc/config.gcc +++ b/gcc/config.gcc @@ -330,7 +330,7 @@ aarch64*-*-*) cxx_target_objs="aarch64-c.o" d_target_objs="aarch64-d.o" extra_objs="aarch64-builtins.o aarch-common.o aarch64-sve-builtins.o aarch64-sve-builtins-shapes.o aarch64-sve-builtins-base.o aarch64-sve-builtins-sve2.o cortex-a57-fma-steering.o aarch64-speculation.o falkor-tag-collision-avoidance.o aarch64-bti-insert.o aarch64-cc-fusion.o" - target_gtfiles="\$(srcdir)/config/aarch64/aarch64-builtins.c \$(srcdir)/config/aarch64/aarch64-sve-builtins.h \$(srcdir)/config/aarch64/aarch64-sve-builtins.cc" + target_gtfiles="\$(srcdir)/config/aarch64/aarch64-builtins.cc \$(srcdir)/config/aarch64/aarch64-sve-builtins.h \$(srcdir)/config/aarch64/aarch64-sve-builtins.cc" target_has_targetm_common=yes ;; alpha*-*-*) @@ -360,7 +360,7 @@ arm*-*-*) cxx_target_objs="arm-c.o" d_target_objs="arm-d.o" extra_options="${extra_options} arm/arm-tables.opt" - target_gtfiles="\$(srcdir)/config/arm/arm-builtins.c \$(srcdir)/config/arm/arm-mve-builtins.h \$(srcdir)/config/arm/arm-mve-builtins.cc" + target_gtfiles="\$(srcdir)/config/arm/arm-builtins.cc \$(srcdir)/config/arm/arm-mve-builtins.h \$(srcdir)/config/arm/arm-mve-builtins.cc" ;; avr-*-*) cpu_type=avr @@ -393,7 +393,7 @@ i[34567]86-*-* | x86_64-*-*) cxx_target_objs="i386-c.o" d_target_objs="i386-d.o" extra_objs="x86-tune-sched.o x86-tune-sched-bd.o x86-tune-sched-atom.o x86-tune-sched-core.o i386-options.o i386-builtins.o i386-expand.o i386-features.o" - target_gtfiles="\$(srcdir)/config/i386/i386-builtins.c \$(srcdir)/config/i386/i386-expand.c \$(srcdir)/config/i386/i386-options.c" + target_gtfiles="\$(srcdir)/config/i386/i386-builtins.cc \$(srcdir)/config/i386/i386-expand.cc \$(srcdir)/config/i386/i386-options.cc" extra_options="${extra_options} fused-madd.opt" extra_headers="cpuid.h mmintrin.h mm3dnow.h xmmintrin.h emmintrin.h pmmintrin.h tmmintrin.h ammintrin.h smmintrin.h @@ -500,8 +500,8 @@ powerpc*-*-*) ;; esac extra_options="${extra_options} g.opt fused-madd.opt rs6000/rs6000-tables.opt" - target_gtfiles="$target_gtfiles \$(srcdir)/config/rs6000/rs6000-logue.c \$(srcdir)/config/rs6000/rs6000-call.c" - target_gtfiles="$target_gtfiles \$(srcdir)/config/rs6000/rs6000-pcrel-opt.c" + target_gtfiles="$target_gtfiles \$(srcdir)/config/rs6000/rs6000-logue.cc \$(srcdir)/config/rs6000/rs6000-call.cc" + target_gtfiles="$target_gtfiles \$(srcdir)/config/rs6000/rs6000-pcrel-opt.cc" target_gtfiles="$target_gtfiles ./rs6000-builtins.h" ;; pru-*-*) @@ -516,8 +516,8 @@ rs6000*-*-*) extra_options="${extra_options} g.opt fused-madd.opt rs6000/rs6000-tables.opt" extra_objs="rs6000-string.o rs6000-p8swap.o rs6000-logue.o" extra_objs="${extra_objs} rs6000-call.o rs6000-pcrel-opt.o" - target_gtfiles="$target_gtfiles \$(srcdir)/config/rs6000/rs6000-logue.c \$(srcdir)/config/rs6000/rs6000-call.c" - target_gtfiles="$target_gtfiles \$(srcdir)/config/rs6000/rs6000-pcrel-opt.c" + target_gtfiles="$target_gtfiles \$(srcdir)/config/rs6000/rs6000-logue.cc \$(srcdir)/config/rs6000/rs6000-call.cc" + target_gtfiles="$target_gtfiles \$(srcdir)/config/rs6000/rs6000-pcrel-opt.cc" ;; sparc*-*-*) cpu_type=sparc @@ -726,7 +726,7 @@ case ${target} in tm_defines="$tm_defines DEF_LD64=\\\"${def_ld64}\\\"" tm_file="${tm_file} ${cpu_type}/darwin.h" tm_p_file="${tm_p_file} darwin-protos.h" - target_gtfiles="$target_gtfiles \$(srcdir)/config/darwin.c" + target_gtfiles="$target_gtfiles \$(srcdir)/config/darwin.cc" extra_options="${extra_options} rpath.opt darwin.opt" c_target_objs="${c_target_objs} darwin-c.o" cxx_target_objs="${cxx_target_objs} darwin-c.o" @@ -991,7 +991,7 @@ case ${target} in xmake_file=vms/x-vms tmake_file="vms/t-vms t-slibgcc" extra_objs="vms.o" - target_gtfiles="$target_gtfiles \$(srcdir)/config/vms/vms.c" + target_gtfiles="$target_gtfiles \$(srcdir)/config/vms/vms.cc" tm_p_file="${tm_p_file} vms/vms-protos.h" xm_file="vms/xm-vms.h" c_target_objs="vms-c.o" @@ -1542,7 +1542,7 @@ bpf-*-*) extra_headers="bpf-helpers.h" use_gcc_stdint=provide extra_objs="coreout.o" - target_gtfiles="$target_gtfiles \$(srcdir)/config/bpf/coreout.c" + target_gtfiles="$target_gtfiles \$(srcdir)/config/bpf/coreout.cc" ;; cr16-*-elf) tm_file="elfos.h ${tm_file} newlib-stdint.h" @@ -1577,7 +1577,7 @@ csky-*-*) fi tm_file="csky/csky.h" md_file="csky/csky.md" - out_file="csky/csky.c" + out_file="csky/csky.cc" tm_p_file="${tm_p_file} csky/csky-protos.h" extra_options="${extra_options} csky/csky_tables.opt" @@ -2112,7 +2112,7 @@ i[34567]86-*-cygwin*) tm_file="${tm_file} i386/unix.h i386/bsd.h i386/gas.h dbxcoff.h i386/cygming.h i386/cygwin.h i386/cygwin-stdint.h" xm_file=i386/xm-cygwin.h tmake_file="${tmake_file} i386/t-cygming t-slibgcc" - target_gtfiles="$target_gtfiles \$(srcdir)/config/i386/winnt.c" + target_gtfiles="$target_gtfiles \$(srcdir)/config/i386/winnt.cc" extra_options="${extra_options} i386/cygming.opt i386/cygwin.opt" extra_objs="${extra_objs} winnt.o winnt-stubs.o" c_target_objs="${c_target_objs} msformat-c.o" @@ -2130,7 +2130,7 @@ x86_64-*-cygwin*) tm_file="${tm_file} i386/unix.h i386/bsd.h i386/gas.h dbxcoff.h i386/cygming.h i386/cygwin.h i386/cygwin-w64.h i386/cygwin-stdint.h" xm_file=i386/xm-cygwin.h tmake_file="${tmake_file} i386/t-cygming t-slibgcc i386/t-cygwin-w64" - target_gtfiles="$target_gtfiles \$(srcdir)/config/i386/winnt.c" + target_gtfiles="$target_gtfiles \$(srcdir)/config/i386/winnt.cc" extra_options="${extra_options} i386/cygming.opt i386/cygwin.opt" extra_objs="${extra_objs} winnt.o winnt-stubs.o" c_target_objs="${c_target_objs} msformat-c.o" @@ -2202,7 +2202,7 @@ i[34567]86-*-mingw* | x86_64-*-mingw*) ;; esac native_system_header_dir=/mingw/include - target_gtfiles="$target_gtfiles \$(srcdir)/config/i386/winnt.c" + target_gtfiles="$target_gtfiles \$(srcdir)/config/i386/winnt.cc" extra_options="${extra_options} i386/cygming.opt i386/mingw.opt" case ${target} in *-w64-*) @@ -2294,7 +2294,7 @@ ia64-hp-*vms*) ;; iq2000*-*-elf*) tm_file="elfos.h newlib-stdint.h iq2000/iq2000.h" - out_file=iq2000/iq2000.c + out_file=iq2000/iq2000.cc md_file=iq2000/iq2000.md ;; lm32-*-elf*) @@ -3168,7 +3168,7 @@ s390x-*-linux*) cxx_target_objs="${cxx_target_objs} s390-c.o" md_file=s390/s390.md extra_modes=s390/s390-modes.def - out_file=s390/s390.c + out_file=s390/s390.cc tmake_file="${tmake_file} s390/t-linux64 s390/t-s390" ;; s390x-ibm-tpf*) @@ -3178,7 +3178,7 @@ s390x-ibm-tpf*) cxx_target_objs="${cxx_target_objs} s390-c.o" md_file=s390/s390.md extra_modes=s390/s390-modes.def - out_file=s390/s390.c + out_file=s390/s390.cc thread_file='tpf' extra_options="${extra_options} s390/tpf.opt" tmake_file="${tmake_file} s390/t-s390" @@ -3532,7 +3532,7 @@ xstormy16-*-elf) tm_p_file=stormy16/stormy16-protos.h tm_d_file="elfos.h stormy16/stormy16.h" md_file=stormy16/stormy16.md - out_file=stormy16/stormy16.c + out_file=stormy16/stormy16.cc extra_options=stormy16/stormy16.opt tmake_file="stormy16/t-stormy16" ;; @@ -3622,9 +3622,9 @@ fi if [ "$common_out_file" = "" ]; then if [ "$target_has_targetm_common" = "yes" ]; then - common_out_file="$cpu_type/$cpu_type-common.c" + common_out_file="$cpu_type/$cpu_type-common.cc" else - common_out_file="default-common.c" + common_out_file="default-common.cc" fi fi diff --git a/gcc/config/aarch64/aarch64-builtins.cc b/gcc/config/aarch64/aarch64-builtins.cc index 58bcbd9..215de1c 100644 --- a/gcc/config/aarch64/aarch64-builtins.cc +++ b/gcc/config/aarch64/aarch64-builtins.cc @@ -3177,7 +3177,7 @@ aarch64_resolve_overloaded_memtag (location_t loc, return NULL_TREE; } -/* Called at aarch64_resolve_overloaded_builtin in aarch64-c.c. */ +/* Called at aarch64_resolve_overloaded_builtin in aarch64-c.cc. */ tree aarch64_resolve_overloaded_builtin_general (location_t loc, tree function, void *pass_params) diff --git a/gcc/config/aarch64/aarch64-protos.h b/gcc/config/aarch64/aarch64-protos.h index 7a8604b..2636853 100644 --- a/gcc/config/aarch64/aarch64-protos.h +++ b/gcc/config/aarch64/aarch64-protos.h @@ -1012,7 +1012,7 @@ extern bool aarch64_classify_address (struct aarch64_address_info *, rtx, machine_mode, bool, aarch64_addr_query_type = ADDR_QUERY_M); -/* Defined in common/config/aarch64-common.c. */ +/* Defined in common/config/aarch64-common.cc. */ bool aarch64_handle_option (struct gcc_options *, struct gcc_options *, const struct cl_decoded_option *, location_t); const char *aarch64_rewrite_selected_cpu (const char *name); @@ -1022,7 +1022,7 @@ enum aarch64_parse_opt_result aarch64_parse_extension (const char *, void aarch64_get_all_extension_candidates (auto_vec *candidates); std::string aarch64_get_extension_string_for_isa_flags (uint64_t, uint64_t); -/* Defined in aarch64-d.c */ +/* Defined in aarch64-d.cc */ extern void aarch64_d_target_versions (void); extern void aarch64_d_register_target_info (void); diff --git a/gcc/config/aarch64/aarch64-sve-builtins.cc b/gcc/config/aarch64/aarch64-sve-builtins.cc index 6d8f2f0..3381726 100644 --- a/gcc/config/aarch64/aarch64-sve-builtins.cc +++ b/gcc/config/aarch64/aarch64-sve-builtins.cc @@ -1009,7 +1009,7 @@ function_builder::add_function (const function_instance &instance, consistent numbering scheme for function codes between the C and C++ frontends, so that everything ties up in LTO. - Currently, tree-streamer-in.c:unpack_ts_function_decl_value_fields + Currently, tree-streamer-in.cc:unpack_ts_function_decl_value_fields validates that tree nodes returned by TARGET_BUILTIN_DECL are non-NULL and some node other than error_mark_node. This is a holdover from when builtin decls were streamed by code rather than by value. diff --git a/gcc/config/aarch64/aarch64.cc b/gcc/config/aarch64/aarch64.cc index 1bca2a31..fdf0c9b 100644 --- a/gcc/config/aarch64/aarch64.cc +++ b/gcc/config/aarch64/aarch64.cc @@ -3622,7 +3622,7 @@ aarch64_regmode_natural_size (machine_mode mode) and similarly for predicates. We can't independently modify anything smaller than that. */ /* ??? For now, only do this for variable-width SVE registers. - Doing it for constant-sized registers breaks lower-subreg.c. */ + Doing it for constant-sized registers breaks lower-subreg.cc. */ /* ??? And once that's fixed, we should probably have similar code for Advanced SIMD. */ if (!aarch64_sve_vg.is_constant ()) @@ -13909,7 +13909,7 @@ cost_plus: /* We can expand signed mod by power of 2 using a NEGS, two parallel ANDs and a CSNEG. Assume here that CSNEG is the same as the cost of an unconditional negate. This case should only ever be reached through - the set_smod_pow2_cheap check in expmed.c. */ + the set_smod_pow2_cheap check in expmed.cc. */ if (CONST_INT_P (XEXP (x, 1)) && exact_log2 (INTVAL (XEXP (x, 1))) > 0 && (mode == SImode || mode == DImode)) @@ -14699,7 +14699,7 @@ aarch64_sched_first_cycle_multipass_dfa_lookahead (void) /* Implement TARGET_SCHED_FIRST_CYCLE_MULTIPASS_DFA_LOOKAHEAD_GUARD as - autopref_multipass_dfa_lookahead_guard from haifa-sched.c. It only + autopref_multipass_dfa_lookahead_guard from haifa-sched.cc. It only has an effect if PARAM_SCHED_AUTOPREF_QUEUE_DEPTH > 0. */ static int @@ -18010,7 +18010,7 @@ aarch64_option_valid_attribute_p (tree fndecl, tree, tree args, int) /* If what we're processing is the current pragma string then the target option node is already stored in target_option_current_node - by aarch64_pragma_target_parse in aarch64-c.c. Use that to avoid + by aarch64_pragma_target_parse in aarch64-c.cc. Use that to avoid having to re-parse the string. This is especially useful to keep arm_neon.h compile times down since that header contains a lot of intrinsics enclosed in pragmas. */ @@ -19340,7 +19340,7 @@ aarch64_short_vector_p (const_tree type, Note that MODE itself is not sufficient in determining whether a type is such a composite type or not. This is because - stor-layout.c:compute_record_mode may have already changed the MODE + stor-layout.cc:compute_record_mode may have already changed the MODE (BLKmode) of a RECORD_TYPE TYPE to some other mode. For example, a structure with only one field may have its MODE set to the mode of the field. Also an integer mode whose size matches the size of the @@ -22205,7 +22205,7 @@ aarch64_float_const_representable_p (rtx x) gcc_assert (mantissa <= 15); /* GCC internally does not use IEEE754-like encoding (where normalized - significands are in the range [1, 2). GCC uses [0.5, 1) (see real.c). + significands are in the range [1, 2). GCC uses [0.5, 1) (see real.cc). Our mantissa values are shifted 4 places to the left relative to normalized IEEE754 so we must modify the exponent returned by REAL_EXP by 5 places to correct for GCC's representation. */ diff --git a/gcc/config/aarch64/aarch64.h b/gcc/config/aarch64/aarch64.h index 52ecfca..dddf133 100644 --- a/gcc/config/aarch64/aarch64.h +++ b/gcc/config/aarch64/aarch64.h @@ -636,7 +636,7 @@ extern unsigned aarch64_architecture_version; #define DBX_REGISTER_NUMBER(REGNO) aarch64_dbx_register_number (REGNO) /* Provide a definition of DWARF_FRAME_REGNUM here so that fallback unwinders can use DWARF_ALT_FRAME_RETURN_COLUMN defined below. This is just the same - as the default definition in dwarf2out.c. */ + as the default definition in dwarf2out.cc. */ #undef DWARF_FRAME_REGNUM #define DWARF_FRAME_REGNUM(REGNO) DBX_REGISTER_NUMBER (REGNO) @@ -1293,12 +1293,12 @@ extern const char *host_detect_local_cpu (int argc, const char **argv); #define ASM_OUTPUT_POOL_EPILOGUE aarch64_asm_output_pool_epilogue /* This type is the user-visible __fp16, and a pointer to that type. We - need it in many places in the backend. Defined in aarch64-builtins.c. */ + need it in many places in the backend. Defined in aarch64-builtins.cc. */ extern GTY(()) tree aarch64_fp16_type_node; extern GTY(()) tree aarch64_fp16_ptr_type_node; /* This type is the user-visible __bf16, and a pointer to that type. Defined - in aarch64-builtins.c. */ + in aarch64-builtins.cc. */ extern GTY(()) tree aarch64_bf16_type_node; extern GTY(()) tree aarch64_bf16_ptr_type_node; diff --git a/gcc/config/aarch64/cortex-a57-fma-steering.cc b/gcc/config/aarch64/cortex-a57-fma-steering.cc index f7bb1ea..2d96fc4 100644 --- a/gcc/config/aarch64/cortex-a57-fma-steering.cc +++ b/gcc/config/aarch64/cortex-a57-fma-steering.cc @@ -49,7 +49,7 @@ of FMUL or FMADD/FMSUB. This pass ensure that registers are renamed so that these conditions hold. - We reuse the existing register renaming facility from regrename.c to build + We reuse the existing register renaming facility from regrename.cc to build dependency chains and expose candidate registers for renaming. @@ -241,7 +241,7 @@ private: /* Rename the register HEAD->regno in all the insns in the chain HEAD to any register not in the set UNAVAILABLE. Adapted from rename_chains in - regrename.c. */ + regrename.cc. */ static bool rename_single_chain (du_head_p head, HARD_REG_SET *unavailable) diff --git a/gcc/config/aarch64/driver-aarch64.cc b/gcc/config/aarch64/driver-aarch64.cc index c27270d..8073a07 100644 --- a/gcc/config/aarch64/driver-aarch64.cc +++ b/gcc/config/aarch64/driver-aarch64.cc @@ -228,7 +228,7 @@ contains_core_p (unsigned *arr, unsigned core) return false; } -/* This will be called by the spec parser in gcc.c when it sees +/* This will be called by the spec parser in gcc.cc when it sees a %:local_cpu_detect(args) construct. Currently it will be called with either "arch", "cpu" or "tune" as argument depending on if -march=native, -mcpu=native or -mtune=native is to be substituted. diff --git a/gcc/config/aarch64/t-aarch64 b/gcc/config/aarch64/t-aarch64 index efa9e25..75b463d 100644 --- a/gcc/config/aarch64/t-aarch64 +++ b/gcc/config/aarch64/t-aarch64 @@ -34,7 +34,7 @@ s-aarch64-tune-md: $(srcdir)/config/aarch64/gentune.sh \ $(srcdir)/config/aarch64/aarch64-tune.md $(STAMP) s-aarch64-tune-md -aarch64-builtins.o: $(srcdir)/config/aarch64/aarch64-builtins.c $(CONFIG_H) \ +aarch64-builtins.o: $(srcdir)/config/aarch64/aarch64-builtins.cc $(CONFIG_H) \ $(SYSTEM_H) coretypes.h $(TM_H) \ $(RTL_H) $(TREE_H) expr.h $(TM_P_H) $(RECOG_H) langhooks.h \ $(DIAGNOSTIC_CORE_H) $(OPTABS_H) \ @@ -42,7 +42,7 @@ aarch64-builtins.o: $(srcdir)/config/aarch64/aarch64-builtins.c $(CONFIG_H) \ $(srcdir)/config/aarch64/aarch64-simd-builtin-types.def \ aarch64-builtin-iterators.h $(COMPILER) -c $(ALL_COMPILERFLAGS) $(ALL_CPPFLAGS) $(INCLUDES) \ - $(srcdir)/config/aarch64/aarch64-builtins.c + $(srcdir)/config/aarch64/aarch64-builtins.cc aarch64-sve-builtins.o: $(srcdir)/config/aarch64/aarch64-sve-builtins.cc \ $(srcdir)/config/aarch64/aarch64-sve-builtins.def \ @@ -104,30 +104,30 @@ aarch64-builtin-iterators.h: $(srcdir)/config/aarch64/geniterators.sh \ $(srcdir)/config/aarch64/iterators.md > \ aarch64-builtin-iterators.h -aarch-common.o: $(srcdir)/config/arm/aarch-common.c $(CONFIG_H) $(SYSTEM_H) \ +aarch-common.o: $(srcdir)/config/arm/aarch-common.cc $(CONFIG_H) $(SYSTEM_H) \ coretypes.h $(TM_H) $(TM_P_H) $(RTL_H) $(TREE_H) output.h $(C_COMMON_H) $(COMPILER) -c $(ALL_COMPILERFLAGS) $(ALL_CPPFLAGS) $(INCLUDES) \ - $(srcdir)/config/arm/aarch-common.c + $(srcdir)/config/arm/aarch-common.cc -aarch64-c.o: $(srcdir)/config/aarch64/aarch64-c.c $(CONFIG_H) $(SYSTEM_H) \ +aarch64-c.o: $(srcdir)/config/aarch64/aarch64-c.cc $(CONFIG_H) $(SYSTEM_H) \ coretypes.h $(TM_H) $(TREE_H) output.h $(C_COMMON_H) $(TARGET_H) $(COMPILER) -c $(ALL_COMPILERFLAGS) $(ALL_CPPFLAGS) $(INCLUDES) \ - $(srcdir)/config/aarch64/aarch64-c.c + $(srcdir)/config/aarch64/aarch64-c.cc -aarch64-d.o: $(srcdir)/config/aarch64/aarch64-d.c +aarch64-d.o: $(srcdir)/config/aarch64/aarch64-d.cc $(COMPILE) $< $(POSTCOMPILE) PASSES_EXTRA += $(srcdir)/config/aarch64/aarch64-passes.def -cortex-a57-fma-steering.o: $(srcdir)/config/aarch64/cortex-a57-fma-steering.c \ +cortex-a57-fma-steering.o: $(srcdir)/config/aarch64/cortex-a57-fma-steering.cc \ $(CONFIG_H) $(SYSTEM_H) $(TM_H) $(REGS_H) insn-config.h $(RTL_BASE_H) \ dominance.h cfg.h cfganal.h $(BASIC_BLOCK_H) $(INSN_ATTR_H) $(RECOG_H) \ output.h hash-map.h $(DF_H) $(OBSTACK_H) $(TARGET_H) $(RTL_H) \ $(CONTEXT_H) $(TREE_PASS_H) regrename.h \ $(srcdir)/config/aarch64/aarch64-protos.h $(COMPILER) -c $(ALL_COMPILERFLAGS) $(ALL_CPPFLAGS) $(INCLUDES) \ - $(srcdir)/config/aarch64/cortex-a57-fma-steering.c + $(srcdir)/config/aarch64/cortex-a57-fma-steering.cc aarch64-speculation.o: $(srcdir)/config/aarch64/aarch64-speculation.cc \ $(CONFIG_H) \ @@ -140,23 +140,23 @@ aarch64-speculation.o: $(srcdir)/config/aarch64/aarch64-speculation.cc \ $(srcdir)/config/aarch64/aarch64-speculation.cc falkor-tag-collision-avoidance.o: \ - $(srcdir)/config/aarch64/falkor-tag-collision-avoidance.c \ + $(srcdir)/config/aarch64/falkor-tag-collision-avoidance.cc \ $(CONFIG_H) $(SYSTEM_H) $(TM_H) $(REGS_H) insn-config.h $(RTL_BASE_H) \ dominance.h cfg.h cfganal.h $(BASIC_BLOCK_H) $(INSN_ATTR_H) $(RECOG_H) \ output.h hash-map.h $(DF_H) $(OBSTACK_H) $(TARGET_H) $(RTL_H) \ $(CONTEXT_H) $(TREE_PASS_H) regrename.h \ $(srcdir)/config/aarch64/aarch64-protos.h $(COMPILER) -c $(ALL_COMPILERFLAGS) $(ALL_CPPFLAGS) $(INCLUDES) \ - $(srcdir)/config/aarch64/falkor-tag-collision-avoidance.c + $(srcdir)/config/aarch64/falkor-tag-collision-avoidance.cc -aarch64-bti-insert.o: $(srcdir)/config/aarch64/aarch64-bti-insert.c \ +aarch64-bti-insert.o: $(srcdir)/config/aarch64/aarch64-bti-insert.cc \ $(CONFIG_H) $(SYSTEM_H) $(TM_H) $(REGS_H) insn-config.h $(RTL_BASE_H) \ dominance.h cfg.h cfganal.h $(BASIC_BLOCK_H) $(INSN_ATTR_H) $(RECOG_H) \ output.h hash-map.h $(DF_H) $(OBSTACK_H) $(TARGET_H) $(RTL_H) \ $(CONTEXT_H) $(TREE_PASS_H) regrename.h \ $(srcdir)/config/aarch64/aarch64-protos.h $(COMPILER) -c $(ALL_COMPILERFLAGS) $(ALL_CPPFLAGS) $(INCLUDES) \ - $(srcdir)/config/aarch64/aarch64-bti-insert.c + $(srcdir)/config/aarch64/aarch64-bti-insert.cc aarch64-cc-fusion.o: $(srcdir)/config/aarch64/aarch64-cc-fusion.cc \ $(CONFIG_H) $(SYSTEM_H) $(CORETYPES_H) $(BACKEND_H) $(RTL_H) $(DF_H) \ diff --git a/gcc/config/aarch64/x-aarch64 b/gcc/config/aarch64/x-aarch64 index 8c09e04..3cf701a 100644 --- a/gcc/config/aarch64/x-aarch64 +++ b/gcc/config/aarch64/x-aarch64 @@ -1,3 +1,3 @@ -driver-aarch64.o: $(srcdir)/config/aarch64/driver-aarch64.c \ +driver-aarch64.o: $(srcdir)/config/aarch64/driver-aarch64.cc \ $(CONFIG_H) $(SYSTEM_H) $(COMPILER) -c $(ALL_COMPILERFLAGS) $(ALL_CPPFLAGS) $(INCLUDES) $< diff --git a/gcc/config/aarch64/x-darwin b/gcc/config/aarch64/x-darwin index 6d788d5..1e0bad2 100644 --- a/gcc/config/aarch64/x-darwin +++ b/gcc/config/aarch64/x-darwin @@ -1,3 +1,3 @@ -host-aarch64-darwin.o : $(srcdir)/config/aarch64/host-aarch64-darwin.c +host-aarch64-darwin.o : $(srcdir)/config/aarch64/host-aarch64-darwin.cc $(COMPILE) $< $(POSTCOMPILE) diff --git a/gcc/config/alpha/alpha-protos.h b/gcc/config/alpha/alpha-protos.h index 7d8f2f0..0c832bf 100644 --- a/gcc/config/alpha/alpha-protos.h +++ b/gcc/config/alpha/alpha-protos.h @@ -1,4 +1,4 @@ -/* Prototypes for alpha.c functions used in the md file & elsewhere. +/* Prototypes for alpha.cc functions used in the md file & elsewhere. Copyright (C) 1999-2022 Free Software Foundation, Inc. This file is part of GCC. diff --git a/gcc/config/alpha/alpha.cc b/gcc/config/alpha/alpha.cc index 252f823..3db5337 100644 --- a/gcc/config/alpha/alpha.cc +++ b/gcc/config/alpha/alpha.cc @@ -702,7 +702,7 @@ alpha_scalar_mode_supported_p (scalar_mode mode) case E_HImode: case E_SImode: case E_DImode: - case E_TImode: /* via optabs.c */ + case E_TImode: /* via optabs.cc */ return true; case E_SFmode: diff --git a/gcc/config/alpha/alpha.h b/gcc/config/alpha/alpha.h index e6a9a09..c01353a 100644 --- a/gcc/config/alpha/alpha.h +++ b/gcc/config/alpha/alpha.h @@ -203,7 +203,7 @@ extern enum alpha_fp_trap_mode alpha_fptm; #define DOUBLE_TYPE_SIZE 64 #define LONG_DOUBLE_TYPE_SIZE (TARGET_LONG_DOUBLE_128 ? 128 : 64) -/* Work around target_flags dependency in ada/targtyps.c. */ +/* Work around target_flags dependency in ada/targtyps.cc. */ #define WIDEST_HARDWARE_FP_SIZE 64 #define WCHAR_TYPE "unsigned int" @@ -636,7 +636,7 @@ enum reg_class { /* Provide a definition of DWARF_FRAME_REGNUM here so that fallback unwinders can use DWARF_ALT_FRAME_RETURN_COLUMN defined below. This is just the same - as the default definition in dwarf2out.c. */ + as the default definition in dwarf2out.cc. */ #undef DWARF_FRAME_REGNUM #define DWARF_FRAME_REGNUM(REG) DBX_REGISTER_NUMBER (REG) @@ -661,7 +661,7 @@ enum reg_class { They give nonzero only if REGNO is a hard reg of the suitable class or a pseudo reg currently allocated to a suitable hard reg. Since they use reg_renumber, they are safe only once reg_renumber - has been allocated, which happens in reginfo.c during register + has been allocated, which happens in reginfo.cc during register allocation. */ #define REGNO_OK_FOR_INDEX_P(REGNO) 0 @@ -723,7 +723,7 @@ enum reg_class { /* Try a machine-dependent way of reloading an illegitimate address operand. If we find one, push the reload and jump to WIN. This - macro is used in only one place: `find_reloads_address' in reload.c. */ + macro is used in only one place: `find_reloads_address' in reload.cc. */ #define LEGITIMIZE_RELOAD_ADDRESS(X,MODE,OPNUM,TYPE,IND_L,WIN) \ do { \ diff --git a/gcc/config/alpha/alpha.md b/gcc/config/alpha/alpha.md index 19fa342..8751433 100644 --- a/gcc/config/alpha/alpha.md +++ b/gcc/config/alpha/alpha.md @@ -4667,7 +4667,7 @@ DONE; }) -;; Block move/clear, see alpha.c for more details. +;; Block move/clear, see alpha.cc for more details. ;; Argument 0 is the destination ;; Argument 1 is the source ;; Argument 2 is the length @@ -4920,7 +4920,7 @@ ;; an lda/ldah pair and we want to align them properly. So we have two ;; unspec_volatile insns, the first of which emits the ldgp assembler macro ;; and the second of which emits nothing. However, both are marked as type -;; IADD (the default) so the alignment code in alpha.c does the right thing +;; IADD (the default) so the alignment code in alpha.cc does the right thing ;; with them. (define_expand "prologue_ldgp" diff --git a/gcc/config/alpha/driver-alpha.cc b/gcc/config/alpha/driver-alpha.cc index 2868e54..fe17f86 100644 --- a/gcc/config/alpha/driver-alpha.cc +++ b/gcc/config/alpha/driver-alpha.cc @@ -41,7 +41,7 @@ along with GCC; see the file COPYING3. If not see #define AMASK_LOCKPFTCHOK 0x1000 /* Safe to prefetch lock cache block. */ -/* This will be called by the spec parser in gcc.c when it sees +/* This will be called by the spec parser in gcc.cc when it sees a %:local_cpu_detect(args) construct. Currently it will be called with either "cpu" or "tune" as argument depending on if -mcpu=native or -mtune=native is to be substituted. diff --git a/gcc/config/alpha/x-alpha b/gcc/config/alpha/x-alpha index 2b22e5e..60fa4a1 100644 --- a/gcc/config/alpha/x-alpha +++ b/gcc/config/alpha/x-alpha @@ -1,3 +1,3 @@ -driver-alpha.o: $(srcdir)/config/alpha/driver-alpha.c +driver-alpha.o: $(srcdir)/config/alpha/driver-alpha.cc $(COMPILE) $< $(POSTCOMPILE) diff --git a/gcc/config/arc/arc-protos.h b/gcc/config/arc/arc-protos.h index edad053..db542f0 100644 --- a/gcc/config/arc/arc-protos.h +++ b/gcc/config/arc/arc-protos.h @@ -97,7 +97,7 @@ extern bool arc_text_label (rtx_insn *insn); extern bool arc_short_comparison_p (rtx, int); extern bool arc_epilogue_uses (int regno); extern bool arc_eh_uses (int regno); -/* insn-attrtab.c doesn't include reload.h, which declares regno_clobbered_p. */ +/* insn-attrtab.cc doesn't include reload.h, which declares regno_clobbered_p. */ extern int regno_clobbered_p (unsigned int, rtx_insn *, machine_mode, int); extern bool arc_legitimize_reload_address (rtx *, machine_mode, int, int); extern void arc_secondary_reload_conv (rtx, rtx, rtx, bool); diff --git a/gcc/config/arc/arc.cc b/gcc/config/arc/arc.cc index 3096a9b..8cc1735 100644 --- a/gcc/config/arc/arc.cc +++ b/gcc/config/arc/arc.cc @@ -1391,7 +1391,7 @@ arc_override_options (void) #undef ARC_OPT /* Set cpu flags accordingly to architecture/selected cpu. The cpu - specific flags are set in arc-common.c. The architecture forces + specific flags are set in arc-common.cc. The architecture forces the default hardware configurations in, regardless what command line options are saying. The CPU optional hw options can be turned on or off. */ @@ -4472,7 +4472,7 @@ static int output_sdata = 0; /* Print operand X (an rtx) in assembler syntax to file FILE. CODE is a letter or dot (`z' in `%z0') or 0 if no letter was specified. For `%' followed by punctuation, CODE is the punctuation and X is null. */ -/* In final.c:output_asm_insn: +/* In final.cc:output_asm_insn: 'l' : label 'a' : address 'c' : constant address if CONSTANT_ADDRESS_P @@ -5455,7 +5455,7 @@ arc_ccfsm_advance (rtx_insn *insn, struct arc_ccfsm *state) } /* Restore recog_operand. Getting the attributes of other insns can - destroy this array, but final.c assumes that it remains intact + destroy this array, but final.cc assumes that it remains intact across this call; since the insn has been recognized already we call insn_extract direct. */ extract_insn_cached (insn); @@ -6542,7 +6542,7 @@ arc_arg_partial_bytes (cumulative_args_t cum_v, const function_arg_info &arg) arg_num = ROUND_ADVANCE_CUM (arg_num, arg.mode, arg.type); ret = GPR_REST_ARG_REGS (arg_num); - /* ICEd at function.c:2361, and ret is copied to data->partial */ + /* ICEd at function.cc:2361, and ret is copied to data->partial */ ret = (ret >= words ? 0 : ret * UNITS_PER_WORD); return ret; @@ -9517,12 +9517,12 @@ conditionalize_nonjump (rtx pat, rtx cond, rtx insn, bool annulled) } } - /* dwarf2out.c:dwarf2out_frame_debug_expr doesn't know + /* dwarf2out.cc:dwarf2out_frame_debug_expr doesn't know what to do with COND_EXEC. */ if (RTX_FRAME_RELATED_P (insn)) { /* If this is the delay slot insn of an anulled branch, - dwarf2out.c:scan_trace understands the anulling semantics + dwarf2out.cc:scan_trace understands the anulling semantics without the COND_EXEC. */ gcc_assert (annulled); rtx note = alloc_reg_note (REG_FRAME_RELATED_EXPR, pat, diff --git a/gcc/config/arc/arc.md b/gcc/config/arc/arc.md index 98510ee..d4e22a4 100644 --- a/gcc/config/arc/arc.md +++ b/gcc/config/arc/arc.md @@ -4042,7 +4042,7 @@ core_3, archs4x, archs4xd, archs4xd_slow" (set_attr_alternative "length" [(cond [(eq_attr "iscompact" "false") (const_int 4) - ; We have to mention (match_dup 3) to convince genattrtab.c that this + ; We have to mention (match_dup 3) to convince genattrtab.cc that this ; is a varying length insn. (eq (symbol_ref "1+1") (const_int 2)) (const_int 2) (gt (minus (match_dup 3) (pc)) (const_int 42)) (const_int 4)] @@ -4663,7 +4663,7 @@ core_3, archs4x, archs4xd, archs4xd_slow" return \"trap_s %0\"; } - /* Keep this message in sync with the one in arc.c:arc_expand_builtin, + /* Keep this message in sync with the one in arc.cc:arc_expand_builtin, because *.md files do not get scanned by exgettext. */ fatal_error (input_location, \"operand to trap_s should be an unsigned 6-bit value\"); @@ -4844,7 +4844,7 @@ core_3, archs4x, archs4xd, archs4xd_slow" "arc_can_use_return_insn ()" "") - ;; Comment in final.c (insn_current_reference_address) says + ;; Comment in final.cc (insn_current_reference_address) says ;; forward branch addresses are calculated from the next insn after branch ;; and for backward branches, it is calculated from the branch insn start. ;; The shortening logic here is tuned to accomodate this behavior @@ -5223,7 +5223,7 @@ core_3, archs4x, archs4xd, archs4xd_slow" ;; subdf alternative that matches a zero operand 1, which then can allow ;; to use bxor to flip the high bit of an integer register. ;; ??? we actually can't use the floating point hardware for neg, because -;; this would not work right for -0. OTOH optabs.c has already code +;; this would not work right for -0. OTOH optabs.cc has already code ;; to synthesyze negate by flipping the sign bit. ;;V2 instructions diff --git a/gcc/config/arc/builtins.def b/gcc/config/arc/builtins.def index 4604633..06d30e4 100644 --- a/gcc/config/arc/builtins.def +++ b/gcc/config/arc/builtins.def @@ -25,9 +25,9 @@ NAME: `__builtin_arc_name' will be the user-level name of the builtin. `ARC_BUILTIN_NAME' will be the internal builtin's id. N_ARGS: Number of input arguments. If special treatment is needed, - set to -1 and handle it by hand, see arc.c:arc_expand_builtin(). + set to -1 and handle it by hand, see arc.cc:arc_expand_builtin(). TYPE: A tree node describing the prototype of the built-in. - ICODE: Name of attached insn or expander. If special treatment in arc.c + ICODE: Name of attached insn or expander. If special treatment in arc.cc is needed to expand the built-in, use `nothing'. MASK: CPU selector mask. */ diff --git a/gcc/config/arc/t-arc b/gcc/config/arc/t-arc index 9f95c7a..9af2d2f 100644 --- a/gcc/config/arc/t-arc +++ b/gcc/config/arc/t-arc @@ -19,14 +19,14 @@ TM_H += $(srcdir)/config/arc/arc-c.def -driver-arc.o: $(srcdir)/config/arc/driver-arc.c \ +driver-arc.o: $(srcdir)/config/arc/driver-arc.cc \ $(CONFIG_H) $(SYSTEM_H) coretypes.h $(TM_H) $(COMPILER) -c $(ALL_COMPILERFLAGS) $(ALL_CPPFLAGS) $(INCLUDES) $< -arc-c.o: $(srcdir)/config/arc/arc-c.c $(CONFIG_H) $(SYSTEM_H) \ +arc-c.o: $(srcdir)/config/arc/arc-c.cc $(CONFIG_H) $(SYSTEM_H) \ $(TREE_H) $(TM_H) $(TM_P_H) coretypes.h $(COMPILER) -c $(ALL_COMPILERFLAGS) $(ALL_CPPFLAGS) $(INCLUDES) \ - $(srcdir)/config/arc/arc-c.c + $(srcdir)/config/arc/arc-c.cc #Run `arc-cpus` if you changed something in arc-cpus.def diff --git a/gcc/config/arm/arm-c.cc b/gcc/config/arm/arm-c.cc index 5d5697f..a8697b8 100644 --- a/gcc/config/arm/arm-c.cc +++ b/gcc/config/arm/arm-c.cc @@ -162,7 +162,7 @@ arm_resolve_overloaded_builtin (location_t loc, tree fndecl, void *arglist) } /* Output C specific EABI object attributes. These cannot be done in - arm.c because they require information from the C frontend. */ + arm.cc because they require information from the C frontend. */ static void arm_output_c_attributes (void) @@ -486,7 +486,7 @@ arm_pragma_target_parse (tree args, tree pop_target) } /* Register target pragmas. We need to add the hook for parsing #pragma GCC - option here rather than in arm.c since it will pull in various preprocessor + option here rather than in arm.cc since it will pull in various preprocessor functions, and those are not present in languages like fortran without a preprocessor. */ diff --git a/gcc/config/arm/arm-protos.h b/gcc/config/arm/arm-protos.h index fb365ac..cd55a9f 100644 --- a/gcc/config/arm/arm-protos.h +++ b/gcc/config/arm/arm-protos.h @@ -1,4 +1,4 @@ -/* Prototypes for exported functions defined in arm.c and pe.c +/* Prototypes for exported functions defined in arm.cc and pe.c Copyright (C) 1999-2022 Free Software Foundation, Inc. Contributed by Richard Earnshaw (rearnsha@arm.com) Minor hacks by Nick Clifton (nickc@cygnus.com) @@ -391,15 +391,15 @@ extern void arm_emit_eabi_attribute (const char *, int, int); extern void arm_reset_previous_fndecl (void); extern void save_restore_target_globals (tree); -/* Defined in gcc/common/config/arm-common.c. */ +/* Defined in gcc/common/config/arm-common.cc. */ extern const char *arm_rewrite_selected_cpu (const char *name); -/* Defined in gcc/common/config/arm-c.c. */ +/* Defined in gcc/common/config/arm-c.cc. */ extern void arm_lang_object_attributes_init (void); extern void arm_register_target_pragmas (void); extern void arm_cpu_cpp_builtins (struct cpp_reader *); -/* Defined in arm-d.c */ +/* Defined in arm-d.cc */ extern void arm_d_target_versions (void); extern void arm_d_register_target_info (void); diff --git a/gcc/config/arm/arm.cc b/gcc/config/arm/arm.cc index 084cbac..7825e36 100644 --- a/gcc/config/arm/arm.cc +++ b/gcc/config/arm/arm.cc @@ -12643,7 +12643,7 @@ vfp3_const_double_index (rtx x) /* The value of 5 here would be 4 if GCC used IEEE754-like encoding (where normalized significands are in the range [1, 2). (Our mantissa is shifted left 4 places at this point relative to normalized IEEE754 values). GCC - internally uses [0.5, 1) (see real.c), so the exponent returned from + internally uses [0.5, 1) (see real.cc), so the exponent returned from REAL_EXP must be altered. */ exponent = 5 - exponent; @@ -20801,7 +20801,7 @@ shift_op (rtx op, HOST_WIDE_INT *amountp) is) or not (and must be printed with an octal escape) must be made with reference to the *host* character set -- the situation is similar to that discussed in the comments above pp_c_char in - c-pretty-print.c. */ + c-pretty-print.cc. */ #define MAX_ASCII_LEN 51 @@ -24969,7 +24969,7 @@ thumb2_final_prescan_insn (rtx_insn *insn) break; } /* Restore recog_data (getting the attributes of other insns can - destroy this array, but final.c assumes that it remains intact + destroy this array, but final.cc assumes that it remains intact across this call). */ extract_constrain_insn_cached (first_insn); } @@ -25258,7 +25258,7 @@ arm_final_prescan_insn (rtx_insn *insn) } /* Restore recog_data (getting the attributes of other insns can - destroy this array, but final.c assumes that it remains intact + destroy this array, but final.cc assumes that it remains intact across this call. */ extract_constrain_insn_cached (insn); } @@ -28039,7 +28039,7 @@ arm_asm_output_labelref (FILE *stream, const char *name) the tag name in a comment so that anyone reading the assembler output will know which tag is being set. - This function is not static because arm-c.c needs it too. */ + This function is not static because arm-c.cc needs it too. */ void arm_emit_eabi_attribute (const char *name, int num, int val) @@ -29326,7 +29326,7 @@ arm_small_register_classes_for_mode_p (machine_mode mode ATTRIBUTE_UNUSED) /* Implement TARGET_SHIFT_TRUNCATION_MASK. SImode shifts use normal ARM insns and therefore guarantee that the shift count is modulo 256. - DImode shifts (those implemented by lib1funcs.S or by optabs.c) + DImode shifts (those implemented by lib1funcs.S or by optabs.cc) guarantee no particular behavior for out-of-range counts. */ static unsigned HOST_WIDE_INT diff --git a/gcc/config/arm/arm.h b/gcc/config/arm/arm.h index dacce2b..f52724d 100644 --- a/gcc/config/arm/arm.h +++ b/gcc/config/arm/arm.h @@ -79,11 +79,11 @@ extern GTY(()) rtx arm_target_insn; extern void (*arm_lang_output_object_attributes_hook)(void); /* This type is the user-visible __fp16. We need it in a few places in - the backend. Defined in arm-builtins.c. */ + the backend. Defined in arm-builtins.cc. */ extern tree arm_fp16_type_node; /* This type is the user-visible __bf16. We need it in a few places in - the backend. Defined in arm-builtins.c. */ + the backend. Defined in arm-builtins.cc. */ extern tree arm_bf16_type_node; extern tree arm_bf16_ptr_type_node; @@ -1715,7 +1715,7 @@ typedef struct bl mcount .word LP1 - profile_function() in final.c outputs the .data section, FUNCTION_PROFILER + profile_function() in final.cc outputs the .data section, FUNCTION_PROFILER will output the .text section. The ``mov ip,lr'' seems like a good idea to stick with cc convention. @@ -2228,7 +2228,7 @@ extern int making_const_table; that ASM_OUTPUT_REG_PUSH will be matched with ASM_OUTPUT_REG_POP, and that r7 isn't used by the function profiler, so we can use it as a scratch reg. WARNING: This isn't safe in the general case! It may be - sensitive to future changes in final.c:profile_function. */ + sensitive to future changes in final.cc:profile_function. */ #define ASM_OUTPUT_REG_PUSH(STREAM, REGNO) \ do \ { \ diff --git a/gcc/config/arm/arm.md b/gcc/config/arm/arm.md index 8a3ee06..90756fb 100644 --- a/gcc/config/arm/arm.md +++ b/gcc/config/arm/arm.md @@ -6553,7 +6553,7 @@ ;; This pattern will be split into one of the pic_load_addr_* patterns ;; and a move after GCSE optimizations. ;; -;; Note: Update arm.c: legitimize_pic_address() when changing this pattern. +;; Note: Update arm.cc: legitimize_pic_address() when changing this pattern. (define_expand "calculate_pic_address" [(set (match_operand:SI 0 "register_operand") (mem:SI (plus:SI (match_operand:SI 1 "register_operand") diff --git a/gcc/config/arm/driver-arm.cc b/gcc/config/arm/driver-arm.cc index f49e3a3..b10c1fe 100644 --- a/gcc/config/arm/driver-arm.cc +++ b/gcc/config/arm/driver-arm.cc @@ -40,7 +40,7 @@ struct vendor #include "arm-native.h" -/* This will be called by the spec parser in gcc.c when it sees +/* This will be called by the spec parser in gcc.cc when it sees a %:local_cpu_detect(args) construct. Currently it will be called with either "arch", "cpu" or "tune" as argument depending on if -march=native, -mcpu=native or -mtune=native is to be substituted. diff --git a/gcc/config/arm/symbian.h b/gcc/config/arm/symbian.h index e001524..7df39170 100644 --- a/gcc/config/arm/symbian.h +++ b/gcc/config/arm/symbian.h @@ -22,7 +22,7 @@ "__builtin"). Symbian OS code relies on properties of the standard library that go beyond those guaranteed by the ANSI/ISO standard. For example, "memcpy" works even with overlapping memory, like - "memmove". We cannot simply set flag_no_builtin in arm.c because + "memmove". We cannot simply set flag_no_builtin in arm.cc because (a) flag_no_builtin is not declared in language-independent code, and (b) that would prevent users from explicitly overriding the default with -fbuiltin, which may sometimes be useful. diff --git a/gcc/config/arm/t-arm b/gcc/config/arm/t-arm index 7133b43..041cc6e 100644 --- a/gcc/config/arm/t-arm +++ b/gcc/config/arm/t-arm @@ -121,12 +121,12 @@ s-arm-native: $(srcdir)/config/arm/parsecpu.awk \ $(SHELL) $(srcdir)/../move-if-change tmp-arm-native.h arm-native.h $(STAMP) s-arm-native -aarch-common.o: $(srcdir)/config/arm/aarch-common.c $(CONFIG_H) $(SYSTEM_H) \ +aarch-common.o: $(srcdir)/config/arm/aarch-common.cc $(CONFIG_H) $(SYSTEM_H) \ coretypes.h $(TM_H) $(TM_P_H) $(RTL_H) $(TREE_H) output.h $(C_COMMON_H) $(COMPILER) -c $(ALL_COMPILERFLAGS) $(ALL_CPPFLAGS) $(INCLUDES) \ - $(srcdir)/config/arm/aarch-common.c + $(srcdir)/config/arm/aarch-common.cc -arm.o: $(srcdir)/config/arm/arm.c $(CONFIG_H) $(SYSTEM_H) coretypes.h $(TM_H) \ +arm.o: $(srcdir)/config/arm/arm.cc $(CONFIG_H) $(SYSTEM_H) coretypes.h $(TM_H) \ $(RTL_H) $(TREE_H) $(HASH_TABLE_H) $(OBSTACK_H) $(REGS_H) hard-reg-set.h \ insn-config.h conditions.h output.h dumpfile.h \ $(INSN_ATTR_H) $(FLAGS_H) reload.h $(FUNCTION_H) \ @@ -140,7 +140,7 @@ arm.o: $(srcdir)/config/arm/arm.c $(CONFIG_H) $(SYSTEM_H) coretypes.h $(TM_H) \ $(srcdir)/config/arm/arm_vfp_builtins.def \ $(srcdir)/config/arm/arm_mve_builtins.def -arm-builtins.o: $(srcdir)/config/arm/arm-builtins.c $(CONFIG_H) \ +arm-builtins.o: $(srcdir)/config/arm/arm-builtins.cc $(CONFIG_H) \ $(SYSTEM_H) coretypes.h $(TM_H) \ $(RTL_H) $(TREE_H) expr.h $(TM_P_H) $(RECOG_H) langhooks.h \ $(DIAGNOSTIC_CORE_H) $(OPTABS_H) \ @@ -151,7 +151,7 @@ arm-builtins.o: $(srcdir)/config/arm/arm-builtins.c $(CONFIG_H) \ $(srcdir)/config/arm/arm_mve_builtins.def \ $(srcdir)/config/arm/arm-simd-builtin-types.def $(COMPILER) -c $(ALL_COMPILERFLAGS) $(ALL_CPPFLAGS) $(INCLUDES) \ - $(srcdir)/config/arm/arm-builtins.c + $(srcdir)/config/arm/arm-builtins.cc arm-mve-builtins.o: $(srcdir)/config/arm/arm-mve-builtins.cc $(CONFIG_H) \ $(SYSTEM_H) coretypes.h $(TM_H) $(TREE_H) \ @@ -163,12 +163,12 @@ arm-mve-builtins.o: $(srcdir)/config/arm/arm-mve-builtins.cc $(CONFIG_H) \ $(COMPILER) -c $(ALL_COMPILERFLAGS) $(ALL_CPPFLAGS) $(INCLUDES) \ $(srcdir)/config/arm/arm-mve-builtins.cc -arm-c.o: $(srcdir)/config/arm/arm-c.c $(CONFIG_H) $(SYSTEM_H) \ +arm-c.o: $(srcdir)/config/arm/arm-c.cc $(CONFIG_H) $(SYSTEM_H) \ coretypes.h $(TM_H) $(TREE_H) output.h $(C_COMMON_H) $(COMPILER) -c $(ALL_COMPILERFLAGS) $(ALL_CPPFLAGS) $(INCLUDES) \ - $(srcdir)/config/arm/arm-c.c + $(srcdir)/config/arm/arm-c.cc -arm-d.o: $(srcdir)/config/arm/arm-d.c +arm-d.o: $(srcdir)/config/arm/arm-d.cc $(COMPILE) $< $(POSTCOMPILE) diff --git a/gcc/config/arm/thumb1.md b/gcc/config/arm/thumb1.md index 3bcb7fa..30b8fb9 100644 --- a/gcc/config/arm/thumb1.md +++ b/gcc/config/arm/thumb1.md @@ -57,7 +57,7 @@ ;; Changes to the constraints of this pattern must be propagated to those of ;; atomic additions in sync.md and to the logic for bind_old_new in -;; arm_split_atomic_op in arm.c. These must be at least as strict as the +;; arm_split_atomic_op in arm.cc. These must be at least as strict as the ;; constraints here and aim to be as permissive. (define_insn_and_split "*thumb1_addsi3" [(set (match_operand:SI 0 "register_operand" "=l,l,l,*rk,*hk,l,k,l,l,l") @@ -137,7 +137,7 @@ ;; Changes to the constraints of this pattern must be propagated to those of ;; atomic subtractions in sync.md and to the logic for bind_old_new in -;; arm_split_atomic_op in arm.c. These must be at least as strict as the +;; arm_split_atomic_op in arm.cc. These must be at least as strict as the ;; constraints here and aim to be as permissive. (define_insn "thumb1_subsi3_insn" [(set (match_operand:SI 0 "register_operand" "=l") @@ -183,7 +183,7 @@ ;; Changes to the constraints of this pattern must be propagated to those of ;; atomic bitwise ANDs and NANDs in sync.md and to the logic for bind_old_new -;; in arm_split_atomic_op in arm.c. These must be at least as strict as the +;; in arm_split_atomic_op in arm.cc. These must be at least as strict as the ;; constraints here and aim to be as permissive. (define_insn "*thumb1_andsi3_insn" [(set (match_operand:SI 0 "register_operand" "=l") @@ -241,7 +241,7 @@ ;; Changes to the constraints of this pattern must be propagated to those of ;; atomic inclusive ORs in sync.md and to the logic for bind_old_new in -;; arm_split_atomic_op in arm.c. These must be at least as strict as the +;; arm_split_atomic_op in arm.cc. These must be at least as strict as the ;; constraints here and aim to be as permissive. (define_insn "*thumb1_iorsi3_insn" [(set (match_operand:SI 0 "register_operand" "=l") @@ -255,7 +255,7 @@ ;; Changes to the constraints of this pattern must be propagated to those of ;; atomic exclusive ORs in sync.md and to the logic for bind_old_new in -;; arm_split_atomic_op in arm.c. These must be at least as strict as the +;; arm_split_atomic_op in arm.cc. These must be at least as strict as the ;; constraints here and aim to be as permissive. (define_insn "*thumb1_xorsi3_insn" [(set (match_operand:SI 0 "register_operand" "=l") diff --git a/gcc/config/arm/x-arm b/gcc/config/arm/x-arm index 51cff1e..0fc9381 100644 --- a/gcc/config/arm/x-arm +++ b/gcc/config/arm/x-arm @@ -1,3 +1,3 @@ -driver-arm.o: $(srcdir)/config/arm/driver-arm.c \ +driver-arm.o: $(srcdir)/config/arm/driver-arm.cc \ $(CONFIG_H) $(SYSTEM_H) $(COMPILER) -c $(ALL_COMPILERFLAGS) $(ALL_CPPFLAGS) $(INCLUDES) $< diff --git a/gcc/config/avr/avr-c.cc b/gcc/config/avr/avr-c.cc index 4f0273a..00daa2e 100644 --- a/gcc/config/avr/avr-c.cc +++ b/gcc/config/avr/avr-c.cc @@ -17,7 +17,7 @@ along with GCC; see the file COPYING3. If not see . */ -/* Not included in avr.c since this requires C front end. */ +/* Not included in avr.cc since this requires C front end. */ #define IN_TARGET_CODE 1 @@ -254,7 +254,7 @@ avr_register_target_pragmas (void) gcc_assert (ADDR_SPACE_GENERIC == ADDR_SPACE_RAM); /* Register address spaces. The order must be the same as in the respective - enum from avr.h (or designated initializers must be used in avr.c). + enum from avr.h (or designated initializers must be used in avr.cc). We always register all address spaces even if some of them make no sense for some targets. Diagnose for non-supported spaces will be emit by TARGET_ADDR_SPACE_DIAGNOSE_USAGE. */ @@ -457,7 +457,7 @@ avr_cpu_cpp_builtins (struct cpp_reader *pfile) #if defined (WITH_DOUBLE_COMPARISON) #if WITH_DOUBLE_COMPARISON == 2 || WITH_DOUBLE_COMPARISON == 3 /* The number of states a DFmode comparison libcall might take and - reflects what avr.c:FLOAT_LIB_COMPARE_RETURNS_BOOL returns for + reflects what avr.cc:FLOAT_LIB_COMPARE_RETURNS_BOOL returns for DFmode. GCC's default is 3-state, but some libraries like LibF7 implement true / false (2-state). */ cpp_define_formatted (pfile, "__WITH_DOUBLE_COMPARISON__=%d", diff --git a/gcc/config/avr/avr-fixed.md b/gcc/config/avr/avr-fixed.md index 00c85bb..542d92e 100644 --- a/gcc/config/avr/avr-fixed.md +++ b/gcc/config/avr/avr-fixed.md @@ -170,7 +170,7 @@ ;** Saturated Negation and Absolute Value ;****************************************************************************** -;; Fixme: This will always result in 0. Dunno why simplify-rtx.c says +;; Fixme: This will always result in 0. Dunno why simplify-rtx.cc says ;; "unknown" on how to optimize this. libgcc call would be in order, ;; but the performance is *PLAIN* *HORROR* because the optimizers don't ;; manage to optimize out MEMCPY that's sprincled all over fixed-bit.c */ diff --git a/gcc/config/avr/avr-log.cc b/gcc/config/avr/avr-log.cc index 19983cb..4c2e92aa 100644 --- a/gcc/config/avr/avr-log.cc +++ b/gcc/config/avr/avr-log.cc @@ -273,7 +273,7 @@ avr_log_vadump (FILE *file, const char *caller, va_list ap) } -/* Called from avr.c:avr_option_override(). +/* Called from avr.cc:avr_option_override(). Parse argument of -mlog= and set respective fields in avr_log. */ void diff --git a/gcc/config/avr/avr-mcus.def b/gcc/config/avr/avr-mcus.def index 489f42c..1e12ab3 100644 --- a/gcc/config/avr/avr-mcus.def +++ b/gcc/config/avr/avr-mcus.def @@ -40,7 +40,7 @@ where the arguments are the fields of avr_mcu_t: NAME Name of the device as specified by -mmcu=. Also - used by DRIVER_SELF_SPECS and gen-avr-mmcu-specs.c for + used by DRIVER_SELF_SPECS and gen-avr-mmcu-specs.cc for - the name of the device specific specs file in -specs=device-specs/spec- - the name of the startup file crt.o diff --git a/gcc/config/avr/avr-modes.def b/gcc/config/avr/avr-modes.def index 992f8c8..0e71173 100644 --- a/gcc/config/avr/avr-modes.def +++ b/gcc/config/avr/avr-modes.def @@ -20,7 +20,7 @@ FRACTIONAL_INT_MODE (PSI, 24, 3); /* Make TA and UTA 64 bits wide. 128 bit wide modes would be insane on a 8-bit machine. - This needs special treatment in avr.c and avr-lib.h. */ + This needs special treatment in avr.cc and avr-lib.h. */ ADJUST_BYTESIZE (TA, 8); ADJUST_ALIGNMENT (TA, 1); diff --git a/gcc/config/avr/avr-passes.def b/gcc/config/avr/avr-passes.def index 066d970..d863015 100644 --- a/gcc/config/avr/avr-passes.def +++ b/gcc/config/avr/avr-passes.def @@ -24,7 +24,7 @@ INSERT_PASS_BEFORE (pass_thread_prologue_and_epilogue, 1, avr_pass_pre_proep); /* This avr-specific pass (re)computes insn notes, in particular REG_DEAD - notes which are used by `avr.c::reg_unused_after' and branch offset + notes which are used by `avr.cc::reg_unused_after' and branch offset computations. These notes must be correct, i.e. there must be no dangling REG_DEAD notes; otherwise wrong code might result, cf. PR64331. diff --git a/gcc/config/avr/avr-protos.h b/gcc/config/avr/avr-protos.h index 1ffd2f4..6023b33 100644 --- a/gcc/config/avr/avr-protos.h +++ b/gcc/config/avr/avr-protos.h @@ -1,4 +1,4 @@ -/* Prototypes for exported functions defined in avr.c +/* Prototypes for exported functions defined in avr.cc Copyright (C) 2000-2022 Free Software Foundation, Inc. Contributed by Denis Chertykov (chertykov@gmail.com) @@ -161,7 +161,7 @@ extern rtl_opt_pass *make_avr_pass_pre_proep (gcc::context *); extern rtl_opt_pass *make_avr_pass_recompute_notes (gcc::context *); extern rtl_opt_pass *make_avr_pass_casesi (gcc::context *); -/* From avr-log.c */ +/* From avr-log.cc */ #define avr_dump(...) avr_vdump (NULL, __FUNCTION__, __VA_ARGS__) #define avr_edump(...) avr_vdump (stderr, __FUNCTION__, __VA_ARGS__) diff --git a/gcc/config/avr/avr.cc b/gcc/config/avr/avr.cc index 6297392..9eec991 100644 --- a/gcc/config/avr/avr.cc +++ b/gcc/config/avr/avr.cc @@ -1,4 +1,4 @@ -/* Subroutines for insn-output.c for ATMEL AVR micro controllers +/* Subroutines for insn-output.cc for ATMEL AVR micro controllers Copyright (C) 1998-2022 Free Software Foundation, Inc. Contributed by Denis Chertykov (chertykov@gmail.com) @@ -734,7 +734,7 @@ avr_set_core_architecture (void) static void avr_option_override (void) { - /* caller-save.c looks for call-clobbered hard registers that are assigned + /* caller-save.cc looks for call-clobbered hard registers that are assigned to pseudos that cross calls and tries so save-restore them around calls in order to reduce the number of stack slots needed. @@ -746,7 +746,7 @@ avr_option_override (void) flag_caller_saves = 0; /* Unwind tables currently require a frame pointer for correctness, - see toplev.c:process_options(). */ + see toplev.cc:process_options(). */ if ((flag_unwind_tables || flag_non_call_exceptions @@ -772,7 +772,7 @@ avr_option_override (void) if (!avr_set_core_architecture()) return; - /* Sould be set by avr-common.c */ + /* Sould be set by avr-common.cc */ gcc_assert (avr_long_double >= avr_double && avr_double >= 32); /* RAM addresses of some SFRs common to all devices in respective arch. */ @@ -1284,8 +1284,8 @@ avr_build_builtin_va_list (void) which is auto-generated by genmodes, but the compiler assigns [U]DAmode to the long long accum modes instead of the desired [U]TAmode. - Fix this now, right after node setup in tree.c:build_common_tree_nodes(). - This must run before c-cppbuiltin.c:builtin_define_fixed_point_constants() + Fix this now, right after node setup in tree.cc:build_common_tree_nodes(). + This must run before c-cppbuiltin.cc:builtin_define_fixed_point_constants() which built-in defines macros like __ULLACCUM_FBIT__ that are used by libgcc to detect IBIT and FBIT. */ @@ -2324,7 +2324,7 @@ avr_mode_dependent_address_p (const_rtx addr ATTRIBUTE_UNUSED, addr_space_t as) /* FIXME: Non-generic addresses are not mode-dependent in themselves. This hook just serves to hack around PR rtl-optimization/52543 by claiming that non-generic addresses were mode-dependent so that - lower-subreg.c will skip these addresses. lower-subreg.c sets up fake + lower-subreg.cc will skip these addresses. lower-subreg.cc sets up fake RTXes to probe SET and MEM costs and assumes that MEM is always in the generic address space which is not true. */ @@ -3284,7 +3284,7 @@ avr_function_arg_advance (cumulative_args_t cum_v, && !call_used_or_fixed_reg_p (cum->regno)) { /* FIXME: We ship info on failing tail-call in struct machine_function. - This uses internals of calls.c:expand_call() and the way args_so_far + This uses internals of calls.cc:expand_call() and the way args_so_far is used. targetm.function_ok_for_sibcall() needs to be extended to pass &args_so_far, too. At present, CUMULATIVE_ARGS is target dependent so that such an extension is not wanted. */ @@ -10049,7 +10049,7 @@ avr_asm_output_aligned_decl_common (FILE * stream, return; } - /* __gnu_lto_slim is just a marker for the linker injected by toplev.c. + /* __gnu_lto_slim is just a marker for the linker injected by toplev.cc. There is no need to trigger __do_clear_bss code for them. */ if (!startswith (name, "__gnu_lto")) diff --git a/gcc/config/avr/avr.h b/gcc/config/avr/avr.h index c132bda..1b948c6 100644 --- a/gcc/config/avr/avr.h +++ b/gcc/config/avr/avr.h @@ -321,7 +321,7 @@ enum reg_class { #define RETURN_ADDR_RTX(count, tem) avr_return_addr_rtx (count, tem) -/* Don't use Push rounding. expr.c: emit_single_push_insn is broken +/* Don't use Push rounding. expr.cc: emit_single_push_insn is broken for POST_DEC targets (PR27386). */ /*#define PUSH_ROUNDING(NPUSHED) (NPUSHED)*/ @@ -399,7 +399,7 @@ typedef struct avr_args #define SUPPORTS_INIT_PRIORITY 0 /* We pretend jump tables are in text section because otherwise, - final.c will switch to .rodata before jump tables and thereby + final.cc will switch to .rodata before jump tables and thereby triggers __do_copy_data. As we implement ASM_OUTPUT_ADDR_VEC, we still have full control over the jump tables themselves. */ #define JUMP_TABLES_IN_TEXT_SECTION 1 diff --git a/gcc/config/avr/avr.md b/gcc/config/avr/avr.md index 30cf705..efae7ef 100644 --- a/gcc/config/avr/avr.md +++ b/gcc/config/avr/avr.md @@ -148,7 +148,7 @@ (const_int 2))] (const_int 2))) -;; Lengths of several insns are adjusted in avr.c:adjust_insn_length(). +;; Lengths of several insns are adjusted in avr.cc:adjust_insn_length(). ;; Following insn attribute tells if and how the adjustment has to be ;; done: ;; no No adjustment needed; attribute "length" is fine. @@ -328,7 +328,7 @@ ;; This avoids creating add/sub offsets in frame_pointer save/resore. ;; The 'null' receiver also avoids problems with optimisation ;; not recognising incoming jmp and removing code that resets frame_pointer. -;; The code derived from builtins.c. +;; The code derived from builtins.cc. (define_expand "nonlocal_goto_receiver" [(set (reg:HI REG_Y) @@ -346,7 +346,7 @@ ;; Defining nonlocal_goto_receiver means we must also define this -;; even though its function is identical to that in builtins.c +;; even though its function is identical to that in builtins.cc (define_expand "nonlocal_goto" [(use (match_operand 0 "general_operand")) diff --git a/gcc/config/avr/builtins.def b/gcc/config/avr/builtins.def index 3bb29f6..8ed70c4 100644 --- a/gcc/config/avr/builtins.def +++ b/gcc/config/avr/builtins.def @@ -25,9 +25,9 @@ NAME: `__builtin_avr_name' will be the user-level name of the builtin. `AVR_BUILTIN_NAME' will be the internal builtin's id. N_ARGS: Number of input arguments. If special treatment is needed, - set to -1 and handle it by hand, see avr.c:avr_expand_builtin(). + set to -1 and handle it by hand, see avr.cc:avr_expand_builtin(). TYPE: A tree node describing the prototype of the built-in. - ICODE: Name of attached insn or expander. If special treatment in avr.c + ICODE: Name of attached insn or expander. If special treatment in avr.cc is needed to expand the built-in, use `nothing'. LIBNAME: Name of the attached implementation in libgcc which is used if the builtin cannot be folded away and there is no insn. */ diff --git a/gcc/config/avr/gen-avr-mmcu-specs.cc b/gcc/config/avr/gen-avr-mmcu-specs.cc index 6e48cb9..bf9aa2c 100644 --- a/gcc/config/avr/gen-avr-mmcu-specs.cc +++ b/gcc/config/avr/gen-avr-mmcu-specs.cc @@ -27,7 +27,7 @@ #define IN_GEN_AVR_MMCU_TEXI -#include "avr-devices.c" +#include "avr-devices.cc" // Get rid of "defaults.h". We just need tm.h for `WITH_AVRLIBC' and // and `WITH_RTEMS'. */ @@ -53,8 +53,8 @@ static const char header[] = "#\n" - "# Generated by : ./gcc/config/avr/gen-avr-mmcu-specs.c\n" - "# Generated from : ./gcc/config/gcc.c\n" + "# Generated by : ./gcc/config/avr/gen-avr-mmcu-specs.cc\n" + "# Generated from : ./gcc/config/gcc.cc\n" "# ./gcc/config/avr/specs.h\n" #if defined (WITH_AVRLIBC) "# ./gcc/config/avr/avrlibc.h\n" diff --git a/gcc/config/avr/gen-avr-mmcu-texi.cc b/gcc/config/avr/gen-avr-mmcu-texi.cc index 05b81dd..d9c3a30 100644 --- a/gcc/config/avr/gen-avr-mmcu-texi.cc +++ b/gcc/config/avr/gen-avr-mmcu-texi.cc @@ -23,7 +23,7 @@ #define IN_GEN_AVR_MMCU_TEXI -#include "avr-devices.c" +#include "avr-devices.cc" static const avr_mcu_t* mcus[sizeof avr_mcu_types / sizeof avr_mcu_types[0]]; @@ -166,9 +166,9 @@ int main (void) "gcc/doc/include/fdl.texi.\n\n"); printf ("@c This file is generated automatically using\n"); - printf ("@c gcc/config/avr/gen-avr-mmcu-texi.c from:\n"); + printf ("@c gcc/config/avr/gen-avr-mmcu-texi.cc from:\n"); printf ("@c gcc/config/avr/avr-arch.h\n"); - printf ("@c gcc/config/avr/avr-devices.c\n"); + printf ("@c gcc/config/avr/avr-devices.cc\n"); printf ("@c gcc/config/avr/avr-mcus.def\n\n"); printf ("@c Please do not edit manually.\n\n"); diff --git a/gcc/config/avr/t-avr b/gcc/config/avr/t-avr index 17540fc..82f58dc 100644 --- a/gcc/config/avr/t-avr +++ b/gcc/config/avr/t-avr @@ -40,22 +40,22 @@ endif PASSES_EXTRA += $(srcdir)/config/avr/avr-passes.def -driver-avr.o: $(srcdir)/config/avr/driver-avr.c \ +driver-avr.o: $(srcdir)/config/avr/driver-avr.cc \ $(CONFIG_H) $(SYSTEM_H) coretypes.h \ $(srcdir)/config/avr/avr-arch.h $(TM_H) $(COMPILER) -c $(ALL_COMPILERFLAGS) $(ALL_CPPFLAGS) $(INCLUDES) $< -avr-devices.o: $(srcdir)/config/avr/avr-devices.c \ +avr-devices.o: $(srcdir)/config/avr/avr-devices.cc \ $(srcdir)/config/avr/avr-mcus.def \ $(srcdir)/config/avr/avr-arch.h \ $(CONFIG_H) $(SYSTEM_H) coretypes.h $(TM_H) $(COMPILER) -c $(ALL_COMPILERFLAGS) $(ALL_CPPFLAGS) $(INCLUDES) $< -avr-c.o: $(srcdir)/config/avr/avr-c.c \ +avr-c.o: $(srcdir)/config/avr/avr-c.cc \ $(CONFIG_H) $(SYSTEM_H) coretypes.h $(TM_H) $(TREE_H) $(C_COMMON_H) $(COMPILER) -c $(ALL_COMPILERFLAGS) $(ALL_CPPFLAGS) $(INCLUDES) $< -avr-log.o: $(srcdir)/config/avr/avr-log.c \ +avr-log.o: $(srcdir)/config/avr/avr-log.cc \ $(CONFIG_H) $(SYSTEM_H) coretypes.h $(TM_H) $(TREE_H) $(INPUT_H) dumpfile.h $(COMPILER) -c $(ALL_COMPILERFLAGS) $(ALL_CPPFLAGS) $(INCLUDES) $< @@ -81,13 +81,13 @@ AVR_MCUS = $(srcdir)/config/avr/avr-mcus.def avr-mcus: $(srcdir)/doc/avr-mmcu.texi ; @true # Make sure that native -mmcu= support is in sync with -mmcu= documentation. -gen-avr-mmcu-texi$(build_exeext): $(srcdir)/config/avr/gen-avr-mmcu-texi.c \ - $(AVR_MCUS) $(srcdir)/config/avr/avr-devices.c \ +gen-avr-mmcu-texi$(build_exeext): $(srcdir)/config/avr/gen-avr-mmcu-texi.cc \ + $(AVR_MCUS) $(srcdir)/config/avr/avr-devices.cc \ $(srcdir)/config/avr/avr-arch.h $(CC_FOR_BUILD) $(CFLAGS_FOR_BUILD) $< -o $@ -gen-avr-mmcu-specs$(build_exeext): $(srcdir)/config/avr/gen-avr-mmcu-specs.c \ - $(AVR_MCUS) $(srcdir)/config/avr/avr-devices.c \ +gen-avr-mmcu-specs$(build_exeext): $(srcdir)/config/avr/gen-avr-mmcu-specs.cc \ + $(AVR_MCUS) $(srcdir)/config/avr/avr-devices.cc \ $(srcdir)/config/avr/avr-arch.h $(TM_H) $(CXX_FOR_BUILD) $(CXXFLAGS_FOR_BUILD) $< -o $@ $(INCLUDES) diff --git a/gcc/config/bfin/bfin.cc b/gcc/config/bfin/bfin.cc index a7ae41e..a89a1b4 100644 --- a/gcc/config/bfin/bfin.cc +++ b/gcc/config/bfin/bfin.cc @@ -708,7 +708,7 @@ frame_related_constant_load (rtx reg, HOST_WIDE_INT constant, bool related) insn = emit_move_insn (reg, cst); else { - /* We don't call split_load_immediate here, since dwarf2out.c can get + /* We don't call split_load_immediate here, since dwarf2out.cc can get confused about some of the more clever sequences it can generate. */ insn = emit_insn (gen_movsi_high (reg, cst)); if (related) diff --git a/gcc/config/bpf/bpf-protos.h b/gcc/config/bpf/bpf-protos.h index 0d45558..5ee3248 100644 --- a/gcc/config/bpf/bpf-protos.h +++ b/gcc/config/bpf/bpf-protos.h @@ -20,7 +20,7 @@ along with GCC; see the file COPYING3. If not see #ifndef GCC_BPF_PROTOS_H #define GCC_BPF_PROTOS_H -/* Routines implemented in bpf.c. */ +/* Routines implemented in bpf.cc. */ extern HOST_WIDE_INT bpf_initial_elimination_offset (int, int); extern const char *bpf_output_call (rtx); diff --git a/gcc/config/bpf/bpf.h b/gcc/config/bpf/bpf.h index 1d5d760..5b3f4a5 100644 --- a/gcc/config/bpf/bpf.h +++ b/gcc/config/bpf/bpf.h @@ -276,7 +276,7 @@ enum reg_class /*** Passing Function Arguments on the Stack. */ /* The eBPF ABI doesn't support passing arguments on the stack. Only - in the first five registers. Code in bpf.c assures the stack is + in the first five registers. Code in bpf.cc assures the stack is never used when passing arguments. However, we still have to define the constants below. */ diff --git a/gcc/config/bpf/t-bpf b/gcc/config/bpf/t-bpf index b37bf85..3f3cf8d 100644 --- a/gcc/config/bpf/t-bpf +++ b/gcc/config/bpf/t-bpf @@ -1,7 +1,7 @@ TM_H += $(srcdir)/config/bpf/coreout.h -coreout.o: $(srcdir)/config/bpf/coreout.c +coreout.o: $(srcdir)/config/bpf/coreout.cc $(COMPILE) $< $(POSTCOMPILE) diff --git a/gcc/config/c6x/c6x-protos.h b/gcc/config/c6x/c6x-protos.h index 9ee291b..9cbe281 100644 --- a/gcc/config/c6x/c6x-protos.h +++ b/gcc/config/c6x/c6x-protos.h @@ -1,4 +1,4 @@ -/* Prototypes for exported functions defined in c6x.c. +/* Prototypes for exported functions defined in c6x.cc. Copyright (C) 2010-2022 Free Software Foundation, Inc. Contributed by CodeSourcery. @@ -21,7 +21,7 @@ #ifndef GCC_C6X_PROTOS_H #define GCC_C6X_PROTOS_H -/* Functions defined in c6x.c. */ +/* Functions defined in c6x.cc. */ #ifdef RTX_CODE extern void c6x_init_cumulative_args (CUMULATIVE_ARGS *, const_tree, rtx, int); diff --git a/gcc/config/cr16/cr16-protos.h b/gcc/config/cr16/cr16-protos.h index 6b717de..300bb31 100644 --- a/gcc/config/cr16/cr16-protos.h +++ b/gcc/config/cr16/cr16-protos.h @@ -1,4 +1,4 @@ -/* Prototypes for exported functions defined in cr16.c +/* Prototypes for exported functions defined in cr16.cc Copyright (C) 2012-2022 Free Software Foundation, Inc. Contributed by KPIT Cummins Infosystems Limited. diff --git a/gcc/config/cris/cris.cc b/gcc/config/cris/cris.cc index 63e6834..a7807b3 100644 --- a/gcc/config/cris/cris.cc +++ b/gcc/config/cris/cris.cc @@ -2022,7 +2022,7 @@ cris_address_cost (rtx x, machine_mode mode ATTRIBUTE_UNUSED, The metric used here is (the number of cycles needed) / 2, where we consider equal a cycle for a word of code and a cycle to read memory. FIXME: Adding "+ 1" to all values would avoid - returning 0, as tree-ssa-loop-ivopts.c as of r128272 "normalizes" + returning 0, as tree-ssa-loop-ivopts.cc as of r128272 "normalizes" 0 to 1, thereby giving equal costs to [rN + rM] and [rN]. Unfortunately(?) such a hack would expose other pessimizations, at least with g++.dg/tree-ssa/ivopts-1.C, adding insns to the @@ -2217,7 +2217,7 @@ cris_side_effect_mode_ok (enum rtx_code code, rtx *ops, } /* Queue an .ident string in the queue of top-level asm statements. - If the front-end is done, we must be being called from toplev.c. + If the front-end is done, we must be being called from toplev.cc. In that case, do nothing. */ void cris_asm_output_ident (const char *string) @@ -2441,7 +2441,7 @@ cris_init_machine_status (void) } /* Split a 2 word move (DI or presumably DF) into component parts. - Originally a copy of gen_split_move_double in m32r.c. */ + Originally a copy of gen_split_move_double in m32r.cc. */ rtx cris_split_movdx (rtx *operands) @@ -3270,7 +3270,7 @@ cris_emit_movem_store (rtx dest, rtx nregs_rtx, int increment, insn = emit_insn (gen_rtx_PARALLEL (VOIDmode, vec)); - /* Because dwarf2out.c handles the insns in a parallel as a sequence, + /* Because dwarf2out.cc handles the insns in a parallel as a sequence, we need to keep the stack adjustment separate, after the MEM-setters. Else the stack-adjustment in the second component of the parallel would be mishandled; the offsets for the SETs that diff --git a/gcc/config/cris/cris.h b/gcc/config/cris/cris.h index 8235509..c623d08 100644 --- a/gcc/config/cris/cris.h +++ b/gcc/config/cris/cris.h @@ -317,7 +317,7 @@ extern int cris_cpu_version; Note that to make this macro affect the alignment of stack locals, a fix was required, and special precautions when handling the stack pointer in various other macros (TARGET_ASM_FUNCTION_PROLOGUE - et al) were required. See file "function.c". If you would just define + et al) were required. See file "function.cc". If you would just define this macro, it would only affect the builtin alloca and variable local data (non-ANSI, non-K&R, Gnu C extension). */ #define STACK_BOUNDARY \ @@ -493,7 +493,7 @@ enum reg_class #define INDEX_REG_CLASS GENERAL_REGS /* Since it uses reg_renumber, it is safe only once reg_renumber - has been allocated, which happens in reginfo.c during register + has been allocated, which happens in reginfo.cc during register allocation. */ #define REGNO_OK_FOR_BASE_P(REGNO) \ ((REGNO) <= CRIS_LAST_GENERAL_REGISTER \ @@ -572,7 +572,7 @@ enum reg_class number and dwarf frame register, we would either need to include all registers in the gcc description (with some marked fixed of course), or an inverse mapping from dwarf register to gcc register. There is one - need in dwarf2out.c:expand_builtin_init_dwarf_reg_sizes. Right now, I + need in dwarf2out.cc:expand_builtin_init_dwarf_reg_sizes. Right now, I don't see that we need exact correspondence between DWARF *frame* registers and DBX_REGISTER_NUMBER, so map them onto GCC registers. */ #define DWARF_FRAME_REGNUM(REG) (REG) @@ -657,7 +657,7 @@ struct cum_args {int regs;}; /* Node: Function entry */ -/* See cris.c for TARGET_ASM_FUNCTION_PROLOGUE and +/* See cris.cc for TARGET_ASM_FUNCTION_PROLOGUE and TARGET_ASM_FUNCTION_EPILOGUE. */ /* Node: Profiling */ diff --git a/gcc/config/cris/cris.opt b/gcc/config/cris/cris.opt index a50764b..a417dd8 100644 --- a/gcc/config/cris/cris.opt +++ b/gcc/config/cris/cris.opt @@ -151,7 +151,7 @@ Use the most feature-enabling options allowed by other options. ; FIXME: The following comment relates to gcc before cris.opt. ; Check if it's still valid: ; We must call it "override-" since calling it "no-" will cause -; gcc.c to forget it, if there's a "later" -mbest-lib-options. +; gcc.cc to forget it, if there's a "later" -mbest-lib-options. ; Kludgy, but needed for some multilibbed files. moverride-best-lib-options Target RejectNegative diff --git a/gcc/config/cris/sync.md b/gcc/config/cris/sync.md index 798bafc..ec4212a 100644 --- a/gcc/config/cris/sync.md +++ b/gcc/config/cris/sync.md @@ -185,7 +185,7 @@ ;; This pattern is more-or-less assumed to always exist if any of the ;; other atomic patterns exist (see e.g. comment at the -;; can_compare_and_swap_p call in omp-low.c, 4.8 era). We'd slightly +;; can_compare_and_swap_p call in omp-low.cc, 4.8 era). We'd slightly ;; prefer atomic_exchange over this, but having both would be ;; redundant. ;; FIXME: handle memory without side-effects for operand[3]. diff --git a/gcc/config/csky/csky.cc b/gcc/config/csky/csky.cc index 08e4f3e..e315e09 100644 --- a/gcc/config/csky/csky.cc +++ b/gcc/config/csky/csky.cc @@ -5694,7 +5694,7 @@ csky_expand_prologue (void) /* If we have a parameter passed partially in regs and partially in memory, the registers will have been stored to memory already - in function.c. So we only need to copy varargs from registers + in function.cc. So we only need to copy varargs from registers to stack. */ if (cfun->machine->uses_anonymous_args) { diff --git a/gcc/config/darwin-c.cc b/gcc/config/darwin-c.cc index 9f46924..3770857 100644 --- a/gcc/config/darwin-c.cc +++ b/gcc/config/darwin-c.cc @@ -831,7 +831,7 @@ EXPORTED_CONST format_kind_info darwin_additional_format_types[] = { /* Support routines to dump the class references for NeXT ABI v1, aka 32-bits ObjC-2.0, as top-level asms. The following two functions should only be called from - objc/objc-next-runtime-abi-01.c. */ + objc/objc-next-runtime-abi-01.cc. */ static void darwin_objc_declare_unresolved_class_reference (const char *name) diff --git a/gcc/config/darwin-f.cc b/gcc/config/darwin-f.cc index c447491..e1efc58 100644 --- a/gcc/config/darwin-f.cc +++ b/gcc/config/darwin-f.cc @@ -27,7 +27,7 @@ along with GCC; see the file COPYING3. If not see However, we can define do-nothing stubs of said hooks as we are not interested in objc include files in Fortran. - The hooks original purpose (see also darwin-c.c): + The hooks original purpose (see also darwin-c.cc): * darwin_register_objc_includes Register the GNU objective-C runtime include path if STDINC. diff --git a/gcc/config/darwin-sections.def b/gcc/config/darwin-sections.def index 8b300ff..394ea16 100644 --- a/gcc/config/darwin-sections.def +++ b/gcc/config/darwin-sections.def @@ -17,7 +17,7 @@ along with GCC; see the file COPYING3. If not see . */ /* Since Darwin's ld will not allow zero-sized objects, and gcc wants them, - we emit one byte (in darwin.c) when such an object is encountered. + we emit one byte (in darwin.cc) when such an object is encountered. This messes up section anchoring because the emitted byte is not counted outside the port. To cope with this, we set aside sections for zero-sized @@ -25,9 +25,9 @@ along with GCC; see the file COPYING3. If not see ("zobj_" sections, below). Items that might be coalesced by the linker are prevented from participating, - (and those in mergeable sections are disallowed in varasm.c). */ + (and those in mergeable sections are disallowed in varasm.cc). */ -/* The .text section is generated in varasm.c */ +/* The .text section is generated in varasm.cc */ DEF_SECTION (text_coal_section, SECTION_CODE|SECTION_NO_ANCHOR, ".section __TEXT,__textcoal_nt,coalesced,pure_instructions", 0) @@ -62,7 +62,7 @@ DEF_SECTION (const_coal_section, SECTION_NO_ANCHOR, DEF_SECTION (zobj_const_section, SECTION_NO_ANCHOR, ".section\t__DATA,__zobj_const", 0) -/* Write-able data. '.data' handled in varasm.c */ +/* Write-able data. '.data' handled in varasm.cc */ DEF_SECTION (static_data_section, SECTION_WRITE, ".static_data", 0) DEF_SECTION (data_coal_section, SECTION_WRITE|SECTION_NO_ANCHOR, ".section __DATA,__datacoal_nt,coalesced", 0) diff --git a/gcc/config/darwin.cc b/gcc/config/darwin.cc index 3805743..783fe3c 100644 --- a/gcc/config/darwin.cc +++ b/gcc/config/darwin.cc @@ -212,7 +212,7 @@ output_objc_section_asm_op (const char *directive) else for (i = 0; i < ARRAY_SIZE (tomarkv2); i++) switch_to_section (darwin_sections[tomarkv2[i]]); - /* Make sure we don't get varasm.c out of sync with us. */ + /* Make sure we don't get varasm.cc out of sync with us. */ switch_to_section (saved_in_section); } output_section_asm_op (directive); @@ -2346,7 +2346,7 @@ fprintf (file, "# dadon: %s %s (%llu, %u) local %d weak %d" They must be made at least one byte, and the section containing must be marked as unsuitable for section-anchors (see storage allocators below). - For non-zero objects this output is handled by varasm.c. + For non-zero objects this output is handled by varasm.cc. */ if (!size) { @@ -2605,7 +2605,7 @@ fprintf (fp, "# albss: %s (%lld,%d) ro %d cst %d stat %d com %d" pub, weak, one, (unsigned long)DECL_INITIAL (decl)); #endif - /* ObjC metadata can get put in BSS because varasm.c decides it's BSS + /* ObjC metadata can get put in BSS because varasm.cc decides it's BSS before the target has a chance to comment. */ if ((meta = is_objc_metadata (decl))) { @@ -2730,7 +2730,7 @@ fprintf (fp, "# adcom: %s (%lld,%d) ro %d cst %d stat %d com %d pub %d" TREE_PUBLIC (decl), weak, one, (unsigned long)DECL_INITIAL (decl)); #endif - /* ObjC metadata can get put in BSS because varasm.c decides it's BSS + /* ObjC metadata can get put in BSS because varasm.cc decides it's BSS before the target has a chance to comment. */ if ((meta = is_objc_metadata (decl))) { @@ -2806,7 +2806,7 @@ fprintf (fp, "# adloc: %s (%lld,%d) ro %d cst %d stat %d one %d pub %d" weak , (unsigned long)DECL_INITIAL (decl)); #endif - /* ObjC metadata can get put in BSS because varasm.c decides it's BSS + /* ObjC metadata can get put in BSS because varasm.cc decides it's BSS before the target has a chance to comment. */ if ((meta = is_objc_metadata (decl))) { diff --git a/gcc/config/darwin.h b/gcc/config/darwin.h index a78476a..ceb043a 100644 --- a/gcc/config/darwin.h +++ b/gcc/config/darwin.h @@ -323,7 +323,7 @@ extern GTY(()) int darwin_ms_struct; } while (0) /* Machine dependent cpp options. Don't add more options here, add - them to darwin_cpp_builtins in darwin-c.c. */ + them to darwin_cpp_builtins in darwin-c.cc. */ #undef CPP_SPEC #define CPP_SPEC "%{static:%{!dynamic:-D__STATIC__}}%{!static:-D__DYNAMIC__}" \ @@ -586,7 +586,7 @@ extern GTY(()) int darwin_ms_struct; #endif #if HAVE_GNU_AS -/* The options are added in gcc.c for this case. */ +/* The options are added in gcc.cc for this case. */ #define ASM_OPTIONS "" #else /* When we detect that we're cctools or llvm as, we need to insert the right diff --git a/gcc/config/elfos.h b/gcc/config/elfos.h index 2e0c709..acb3762 100644 --- a/gcc/config/elfos.h +++ b/gcc/config/elfos.h @@ -466,7 +466,7 @@ see the files COPYING3 and COPYING.RUNTIME respectively. If not, see default_elf_asm_output_ascii ((FILE), (STR), (LENGTH)) /* Allow the use of the -frecord-gcc-switches switch via the - elf_record_gcc_switches function defined in varasm.c. */ + elf_record_gcc_switches function defined in varasm.cc. */ #undef TARGET_ASM_RECORD_GCC_SWITCHES #define TARGET_ASM_RECORD_GCC_SWITCHES elf_record_gcc_switches diff --git a/gcc/config/epiphany/epiphany-sched.md b/gcc/config/epiphany/epiphany-sched.md index d7fa0fb..d347ce6 100644 --- a/gcc/config/epiphany/epiphany-sched.md +++ b/gcc/config/epiphany/epiphany-sched.md @@ -77,7 +77,7 @@ "issue,issue+int,issue+int,issue+int,int") ;; Loads have a latency of two. -;; Note that we fix up the latency of post_modify in epiphany.c:epiphany_adjust_cost +;; Note that we fix up the latency of post_modify in epiphany.cc:epiphany_adjust_cost (define_insn_reservation "load" 3 (and (eq_attr "pipe_model" "epiphany") diff --git a/gcc/config/epiphany/epiphany.cc b/gcc/config/epiphany/epiphany.cc index c9c3215..f8c0493 100644 --- a/gcc/config/epiphany/epiphany.cc +++ b/gcc/config/epiphany/epiphany.cc @@ -1512,7 +1512,7 @@ epiphany_function_value (const_tree ret_type, /* We must change the mode like PROMOTE_MODE does. ??? PROMOTE_MODE is ignored for non-scalar types. The set of types tested here has to be kept in sync - with the one in explow.c:promote_mode. */ + with the one in explow.cc:promote_mode. */ if (GET_MODE_CLASS (mode) == MODE_INT && GET_MODE_SIZE (mode) < 4 && (TREE_CODE (ret_type) == INTEGER_TYPE diff --git a/gcc/config/epiphany/epiphany.h b/gcc/config/epiphany/epiphany.h index 2bedaac..8c723845a 100644 --- a/gcc/config/epiphany/epiphany.h +++ b/gcc/config/epiphany/epiphany.h @@ -378,7 +378,7 @@ extern enum reg_class epiphany_regno_reg_class[FIRST_PSEUDO_REGISTER]; They give nonzero only if REGNO is a hard reg of the suitable class or a pseudo reg currently allocated to a suitable hard reg. Since they use reg_renumber, they are safe only once reg_renumber - has been allocated, which happens in reginfo.c during register + has been allocated, which happens in reginfo.cc during register allocation. */ #define REGNO_OK_FOR_BASE_P(REGNO) \ ((REGNO) < FIRST_PSEUDO_REGISTER || (unsigned) reg_renumber[REGNO] < FIRST_PSEUDO_REGISTER) @@ -551,7 +551,7 @@ typedef struct GTY (()) machine_function && epiphany_is_interrupt_p (current_function_decl)) \ ? IRET_REGNUM : GPR_LR) /* This is not only for dwarf unwind info, but also for the benefit of - df-scan.c to tell it that LR is live at the function start. */ + df-scan.cc to tell it that LR is live at the function start. */ #define INCOMING_RETURN_ADDR_RTX gen_rtx_REG (Pmode, EPIPHANY_RETURN_REGNO) /* However, we haven't implemented the rest needed for dwarf2 unwind info. */ @@ -662,7 +662,7 @@ typedef struct GTY (()) machine_function #define NO_FUNCTION_CSE 1 /* Section selection. */ -/* WARNING: These section names also appear in dwarf2out.c. */ +/* WARNING: These section names also appear in dwarf2out.cc. */ #define TEXT_SECTION_ASM_OP "\t.section .text" #define DATA_SECTION_ASM_OP "\t.section .data" diff --git a/gcc/config/epiphany/mode-switch-use.cc b/gcc/config/epiphany/mode-switch-use.cc index 5d5058e..887550a 100644 --- a/gcc/config/epiphany/mode-switch-use.cc +++ b/gcc/config/epiphany/mode-switch-use.cc @@ -1,5 +1,5 @@ /* Insert USEs in instructions that require mode switching. - This should probably be merged into mode-switching.c . + This should probably be merged into mode-switching.cc . Copyright (C) 2011-2022 Free Software Foundation, Inc. Contributed by Embecosm on behalf of Adapteva, Inc. diff --git a/gcc/config/epiphany/predicates.md b/gcc/config/epiphany/predicates.md index 2d25ba8..5504e29 100644 --- a/gcc/config/epiphany/predicates.md +++ b/gcc/config/epiphany/predicates.md @@ -246,7 +246,7 @@ return REGNO (cc) == CC_REGNUM; /* From combiner. */ case E_QImode: case E_SImode: case E_SFmode: case E_HImode: - /* From cse.c:dead_libcall_p. */ + /* From cse.cc:dead_libcall_p. */ case E_DFmode: return 0; default: diff --git a/gcc/config/epiphany/t-epiphany b/gcc/config/epiphany/t-epiphany index 4baaee2..27a8052 100644 --- a/gcc/config/epiphany/t-epiphany +++ b/gcc/config/epiphany/t-epiphany @@ -17,13 +17,13 @@ # along with GCC; see the file COPYING3. If not see # . -mode-switch-use.o : $(srcdir)/config/epiphany/mode-switch-use.c \ +mode-switch-use.o : $(srcdir)/config/epiphany/mode-switch-use.cc \ $(CONFIG_H) $(SYSTEM_H) coretypes.h $(TM_H) $(TM_P_H) $(RTL_H) \ $(TREE_PASS_H) $(INSN_ATTR_H) $(EMIT_RTL_H) $(FUNCTION_H) $(RECOG_H) \ insn-config.h $(DF_H) $(COMPILER) -c $(ALL_COMPILERFLAGS) $(ALL_CPPFLAGS) $< -resolve-sw-modes.o : $(srcdir)/config/epiphany/resolve-sw-modes.c \ +resolve-sw-modes.o : $(srcdir)/config/epiphany/resolve-sw-modes.cc \ $(CONFIG_H) $(SYSTEM_H) coretypes.h $(MACHMODE_H) $(TM_H) hard-reg-set.h \ $(TM_P_H) $(VEC_H) sbitmap.h $(BASIC_BLOCK_H) $(DF_H) $(RTL_H) \ insn-config.h insn-codes.h $(EMIT_RTL_H) $(RECOG_H) $(FUNCTION_H) \ diff --git a/gcc/config/fr30/fr30-protos.h b/gcc/config/fr30/fr30-protos.h index 97529b6..80d9498 100644 --- a/gcc/config/fr30/fr30-protos.h +++ b/gcc/config/fr30/fr30-protos.h @@ -1,4 +1,4 @@ -/* Prototypes for fr30.c functions used in the md file & elsewhere. +/* Prototypes for fr30.cc functions used in the md file & elsewhere. Copyright (C) 1999-2022 Free Software Foundation, Inc. This file is part of GCC. diff --git a/gcc/config/frv/frv-protos.h b/gcc/config/frv/frv-protos.h index cd2c2ec..bc07111 100644 --- a/gcc/config/frv/frv-protos.h +++ b/gcc/config/frv/frv-protos.h @@ -18,7 +18,7 @@ You should have received a copy of the GNU General Public License along with GCC; see the file COPYING3. If not see . */ -/* Define functions defined in frv.c */ +/* Define functions defined in frv.cc */ extern void frv_expand_prologue (void); extern void frv_expand_epilogue (bool); extern frv_stack_t *frv_stack_info (void); diff --git a/gcc/config/frv/frv.cc b/gcc/config/frv/frv.cc index 088a9e0..d6c3993 100644 --- a/gcc/config/frv/frv.cc +++ b/gcc/config/frv/frv.cc @@ -9434,7 +9434,7 @@ frv_struct_value_rtx (tree fntype ATTRIBUTE_UNUSED, #define TLS_BIAS (2048 - 16) -/* This is called from dwarf2out.c via TARGET_ASM_OUTPUT_DWARF_DTPREL. +/* This is called from dwarf2out.cc via TARGET_ASM_OUTPUT_DWARF_DTPREL. We need to emit DTP-relative relocations. */ static void diff --git a/gcc/config/frv/frv.h b/gcc/config/frv/frv.h index ad0a0f8..8cd67f7 100644 --- a/gcc/config/frv/frv.h +++ b/gcc/config/frv/frv.h @@ -1525,7 +1525,7 @@ do { \ #undef ASM_OUTPUT_ALIGNED_LOCAL -/* This is for final.c, because it is used by ASM_DECLARE_OBJECT_NAME. */ +/* This is for final.cc, because it is used by ASM_DECLARE_OBJECT_NAME. */ extern int size_directive_output; /* Like `ASM_OUTPUT_ALIGNED_LOCAL' except that it takes an additional diff --git a/gcc/config/ft32/ft32-protos.h b/gcc/config/ft32/ft32-protos.h index f9d8e20..6cc777e 100644 --- a/gcc/config/ft32/ft32-protos.h +++ b/gcc/config/ft32/ft32-protos.h @@ -1,4 +1,4 @@ -/* Prototypes for ft32.c functions used in the md file & elsewhere. +/* Prototypes for ft32.cc functions used in the md file & elsewhere. Copyright (C) 2015-2022 Free Software Foundation, Inc. This file is part of GCC. diff --git a/gcc/config/gcn/gcn-hsa.h b/gcc/config/gcn/gcn-hsa.h index d43f429..9b5fee9 100644 --- a/gcc/config/gcn/gcn-hsa.h +++ b/gcc/config/gcn/gcn-hsa.h @@ -71,7 +71,7 @@ extern unsigned int gcn_local_sym_hash (const char *name); #define ASM_APP_ON "" #define ASM_APP_OFF "" -/* Avoid the default in ../../gcc.c, which adds "-pthread", which is not +/* Avoid the default in ../../gcc.cc, which adds "-pthread", which is not supported for gcn. */ #define GOMP_SELF_SPECS "" diff --git a/gcc/config/gcn/gcn.cc b/gcc/config/gcn/gcn.cc index e29f95e..74819c6 100644 --- a/gcc/config/gcn/gcn.cc +++ b/gcc/config/gcn/gcn.cc @@ -3755,7 +3755,7 @@ static void gcn_init_libfuncs (void) { /* BITS_PER_UNIT * 2 is 64 bits, which causes - optabs-libfuncs.c:gen_int_libfunc to omit TImode (i.e 128 bits) + optabs-libfuncs.cc:gen_int_libfunc to omit TImode (i.e 128 bits) libcalls that we need to support operations for that type. Initialise them here instead. */ set_optab_libfunc (udiv_optab, TImode, "__udivti3"); diff --git a/gcc/config/gcn/mkoffload.cc b/gcc/config/gcn/mkoffload.cc index 92c4689..94ba7ff 100644 --- a/gcc/config/gcn/mkoffload.cc +++ b/gcc/config/gcn/mkoffload.cc @@ -307,7 +307,7 @@ copy_early_debug_info (const char *infile, const char *outfile) int err; /* The simple_object code can handle extracting the debug sections. - This code is based on that in lto-wrapper.c. */ + This code is based on that in lto-wrapper.cc. */ int infd = open (infile, O_RDONLY | O_BINARY); if (infd == -1) return false; diff --git a/gcc/config/gcn/t-gcn-hsa b/gcc/config/gcn/t-gcn-hsa index c8d3af3..10e31f3 100644 --- a/gcc/config/gcn/t-gcn-hsa +++ b/gcc/config/gcn/t-gcn-hsa @@ -16,13 +16,13 @@ GTM_H += $(HASH_TABLE_H) -driver-gcn.o: $(srcdir)/config/gcn/driver-gcn.c +driver-gcn.o: $(srcdir)/config/gcn/driver-gcn.cc $(COMPILE) $< $(POSTCOMPILE) CFLAGS-mkoffload.o += $(DRIVER_DEFINES) \ -DGCC_INSTALL_NAME=\"$(GCC_INSTALL_NAME)\" -mkoffload.o: $(srcdir)/config/gcn/mkoffload.c +mkoffload.o: $(srcdir)/config/gcn/mkoffload.cc $(COMPILE) $< $(POSTCOMPILE) ALL_HOST_OBJS += mkoffload.o @@ -34,7 +34,7 @@ mkoffload$(exeext): mkoffload.o collect-utils.o libcommon-target.a \ CFLAGS-gcn-run.o += -DVERSION_STRING=$(PKGVERSION_s) COMPILE-gcn-run.o = $(filter-out -fno-rtti,$(COMPILE)) -gcn-run.o: $(srcdir)/config/gcn/gcn-run.c +gcn-run.o: $(srcdir)/config/gcn/gcn-run.cc $(COMPILE-gcn-run.o) -x c -std=gnu11 -Wno-error=pedantic $< $(POSTCOMPILE) ALL_HOST_OBJS += gcn-run.o @@ -45,7 +45,7 @@ gcn-run$(exeext): gcn-run.o MULTILIB_OPTIONS = march=gfx900/march=gfx906/march=gfx908 MULTILIB_DIRNAMES = gfx900 gfx906 gfx908 -gcn-tree.o: $(srcdir)/config/gcn/gcn-tree.c +gcn-tree.o: $(srcdir)/config/gcn/gcn-tree.cc $(COMPILE) $< $(POSTCOMPILE) ALL_HOST_OBJS += gcn-tree.o diff --git a/gcc/config/gcn/t-omp-device b/gcc/config/gcn/t-omp-device index 8461c43..cd56e2f 100644 --- a/gcc/config/gcn/t-omp-device +++ b/gcc/config/gcn/t-omp-device @@ -1,4 +1,4 @@ -omp-device-properties-gcn: $(srcdir)/config/gcn/gcn.c +omp-device-properties-gcn: $(srcdir)/config/gcn/gcn.cc echo kind: gpu > $@ echo arch: gcn >> $@ echo isa: fiji gfx900 gfx906 gfx908 >> $@ diff --git a/gcc/config/h8300/h8300-protos.h b/gcc/config/h8300/h8300-protos.h index a8d6bca..e9d434c 100644 --- a/gcc/config/h8300/h8300-protos.h +++ b/gcc/config/h8300/h8300-protos.h @@ -23,7 +23,7 @@ along with GCC; see the file COPYING3. If not see #ifndef GCC_H8300_PROTOS_H #define GCC_H8300_PROTOS_H -/* Declarations for functions used in insn-output.c. */ +/* Declarations for functions used in insn-output.cc. */ #ifdef RTX_CODE extern unsigned int compute_mov_length (rtx *); extern const char *output_plussi (rtx *, bool); @@ -59,7 +59,7 @@ extern int byte_accesses_mergeable_p (rtx, rtx); extern int same_cmp_preceding_p (rtx_insn *); extern int same_cmp_following_p (rtx_insn *); -/* Used in builtins.c */ +/* Used in builtins.cc */ extern rtx h8300_return_addr_rtx (int, rtx); /* Classifies an h8sx shift operation. diff --git a/gcc/config/h8300/h8300.cc b/gcc/config/h8300/h8300.cc index 0fc6a87..78cf15f 100644 --- a/gcc/config/h8300/h8300.cc +++ b/gcc/config/h8300/h8300.cc @@ -1,4 +1,4 @@ -/* Subroutines for insn-output.c for Renesas H8/300. +/* Subroutines for insn-output.cc for Renesas H8/300. Copyright (C) 1992-2022 Free Software Foundation, Inc. Contributed by Steve Chamberlain (sac@cygnus.com), Jim Wilson (wilson@cygnus.com), and Doug Evans (dje@cygnus.com). @@ -496,7 +496,7 @@ F (rtx_insn *x, bool set_it) /* Mark all the subexpressions of the PARALLEL rtx PAR as frame-related. Return PAR. - dwarf2out.c:dwarf2out_frame_debug_expr ignores sub-expressions of a + dwarf2out.cc:dwarf2out_frame_debug_expr ignores sub-expressions of a PARALLEL rtx other than the first if they do not have the FRAME_RELATED flag set on them. */ static rtx diff --git a/gcc/config/h8300/h8300.h b/gcc/config/h8300/h8300.h index 9218874..9a6c78c 100644 --- a/gcc/config/h8300/h8300.h +++ b/gcc/config/h8300/h8300.h @@ -25,7 +25,7 @@ along with GCC; see the file COPYING3. If not see extern int cpu_type; -/* Various globals defined in h8300.c. */ +/* Various globals defined in h8300.cc. */ extern const char *h8_push_op, *h8_pop_op, *h8_mov_op; extern const char * const *h8_reg_names; @@ -447,7 +447,7 @@ struct cum_arg They give nonzero only if REGNO is a hard reg of the suitable class or a pseudo reg currently allocated to a suitable hard reg. Since they use reg_renumber, they are safe only once reg_renumber - has been allocated, which happens in reginfo.c during register + has been allocated, which happens in reginfo.cc during register allocation. */ #define REGNO_OK_FOR_INDEX_P(regno) 0 @@ -564,7 +564,7 @@ struct cum_arg #define BRANCH_COST(speed_p, predictable_p) 0 -/* Tell final.c how to eliminate redundant test instructions. */ +/* Tell final.cc how to eliminate redundant test instructions. */ /* Here we define machine-dependent flags and fields in cc_status (see `conditions.h'). No extra ones are needed for the h8300. */ diff --git a/gcc/config/i386/cygming.h b/gcc/config/i386/cygming.h index 8ace098..4515045 100644 --- a/gcc/config/i386/cygming.h +++ b/gcc/config/i386/cygming.h @@ -151,7 +151,7 @@ along with GCC; see the file COPYING3. If not see } \ while (0) -/* Get tree.c to declare a target-specific specialization of +/* Get tree.cc to declare a target-specific specialization of merge_decl_attributes. */ #define TARGET_DLLIMPORT_DECL_ATTRIBUTES 1 @@ -381,7 +381,7 @@ do { \ #define DEFAULT_PCC_STRUCT_RETURN 0 /* MSVC returns aggregate types of up to 8 bytes via registers. - See i386.c:ix86_return_in_memory. */ + See i386.cc:ix86_return_in_memory. */ #undef MS_AGGREGATE_RETURN #define MS_AGGREGATE_RETURN 1 diff --git a/gcc/config/i386/djgpp.h b/gcc/config/i386/djgpp.h index a4adb23..909821e 100644 --- a/gcc/config/i386/djgpp.h +++ b/gcc/config/i386/djgpp.h @@ -166,7 +166,7 @@ along with GCC; see the file COPYING3. If not see #undef TARGET_ASM_LTO_END #define TARGET_ASM_LTO_END i386_djgpp_asm_lto_end -/* Function protypes for gcc/i386/djgpp.c */ +/* Function protypes for gcc/i386/djgpp.cc */ void i386_djgpp_asm_named_section(const char *name, unsigned int flags, diff --git a/gcc/config/i386/dragonfly.h b/gcc/config/i386/dragonfly.h index bb57d3d..39bd280 100644 --- a/gcc/config/i386/dragonfly.h +++ b/gcc/config/i386/dragonfly.h @@ -41,7 +41,7 @@ see the files COPYING3 and COPYING.RUNTIME respectively. If not, see #undef NO_PROFILE_COUNTERS #define NO_PROFILE_COUNTERS 1 -/* Tell final.c that we don't need a label passed to mcount. */ +/* Tell final.cc that we don't need a label passed to mcount. */ #undef MCOUNT_NAME #define MCOUNT_NAME ".mcount" diff --git a/gcc/config/i386/driver-i386.cc b/gcc/config/i386/driver-i386.cc index b078236..9e0ae0b 100644 --- a/gcc/config/i386/driver-i386.cc +++ b/gcc/config/i386/driver-i386.cc @@ -369,7 +369,7 @@ detect_caches_intel (bool xeon_mp, unsigned max_level, return describe_cache (level1, level2); } -/* This will be called by the spec parser in gcc.c when it sees +/* This will be called by the spec parser in gcc.cc when it sees a %:local_cpu_detect(args) construct. Currently it will be called with either "arch [32|64]" or "tune [32|64]" as argument depending on if -march=native or -mtune=native is to be substituted. diff --git a/gcc/config/i386/freebsd.h b/gcc/config/i386/freebsd.h index 2e81c5d..120e24c 100644 --- a/gcc/config/i386/freebsd.h +++ b/gcc/config/i386/freebsd.h @@ -39,7 +39,7 @@ along with GCC; see the file COPYING3. If not see #undef NO_PROFILE_COUNTERS #define NO_PROFILE_COUNTERS 1 -/* Tell final.c that we don't need a label passed to mcount. */ +/* Tell final.cc that we don't need a label passed to mcount. */ #undef MCOUNT_NAME #define MCOUNT_NAME ".mcount" diff --git a/gcc/config/i386/i386-c.cc b/gcc/config/i386/i386-c.cc index 1e1d2e9..c73c1b1 100644 --- a/gcc/config/i386/i386-c.cc +++ b/gcc/config/i386/i386-c.cc @@ -798,7 +798,7 @@ ix86_target_macros (void) /* Register target pragmas. We need to add the hook for parsing #pragma GCC - option here rather than in i386.c since it will pull in various preprocessor + option here rather than in i386.cc since it will pull in various preprocessor functions, and those are not present in languages like fortran without a preprocessor. */ diff --git a/gcc/config/i386/i386-expand.cc b/gcc/config/i386/i386-expand.cc index 5fae422..eb1930b 100644 --- a/gcc/config/i386/i386-expand.cc +++ b/gcc/config/i386/i386-expand.cc @@ -14786,7 +14786,7 @@ ix86_vector_duplicate_value (machine_mode mode, rtx target, rtx val) static machine_mode get_mode_wider_vector (machine_mode o) { - /* ??? Rely on the ordering that genmodes.c gives to vectors. */ + /* ??? Rely on the ordering that genmodes.cc gives to vectors. */ machine_mode n = GET_MODE_WIDER_MODE (o).require (); gcc_assert (GET_MODE_NUNITS (o) == GET_MODE_NUNITS (n) * 2); gcc_assert (GET_MODE_SIZE (o) == GET_MODE_SIZE (n)); diff --git a/gcc/config/i386/i386-options.cc b/gcc/config/i386/i386-options.cc index 4a89979..715d9a1 100644 --- a/gcc/config/i386/i386-options.cc +++ b/gcc/config/i386/i386-options.cc @@ -3074,7 +3074,7 @@ ix86_set_func_type (tree fndecl) ix86_optimize_mode_switching[X86_DIRFLAG] = 1; - /* Only dwarf2out.c can handle -WORD(AP) as a pointer argument. */ + /* Only dwarf2out.cc can handle -WORD(AP) as a pointer argument. */ if (write_symbols != NO_DEBUG && write_symbols != DWARF2_DEBUG) sorry ("only DWARF debug format is supported for interrupt " "service routine"); diff --git a/gcc/config/i386/i386-protos.h b/gcc/config/i386/i386-protos.h index a697dd2..6b3c951 100644 --- a/gcc/config/i386/i386-protos.h +++ b/gcc/config/i386/i386-protos.h @@ -17,13 +17,13 @@ You should have received a copy of the GNU General Public License along with GCC; see the file COPYING3. If not see . */ -/* In i386-common.c. */ +/* In i386-common.cc. */ extern bool ix86_handle_option (struct gcc_options *opts, struct gcc_options *opts_set ATTRIBUTE_UNUSED, const struct cl_decoded_option *decoded, location_t loc); -/* Functions in i386.c */ +/* Functions in i386.cc */ extern bool ix86_target_stack_probe (void); extern bool ix86_can_use_return_insn_p (void); extern bool ix86_function_ms_hook_prologue (const_tree fn); @@ -267,16 +267,16 @@ extern bool ix86_expand_vector_init_duplicate (bool, machine_mode, rtx, rtx); extern bool ix86_extract_perm_from_pool_constant (int*, rtx); -/* In i386-c.c */ +/* In i386-c.cc */ extern void ix86_target_macros (void); extern void ix86_register_pragmas (void); -/* In i386-d.c */ +/* In i386-d.cc */ extern void ix86_d_target_versions (void); extern void ix86_d_register_target_info (void); extern bool ix86_d_has_stdcall_convention (unsigned int *, unsigned int *); -/* In winnt.c */ +/* In winnt.cc */ extern void i386_pe_unique_section (tree, int); extern void i386_pe_declare_function_type (FILE *, const char *, int); extern void i386_pe_record_external_function (tree, const char *); @@ -309,7 +309,7 @@ extern void i386_pe_seh_unwind_emit (FILE *, rtx_insn *); extern void i386_pe_seh_emit_except_personality (rtx); extern void i386_pe_seh_init_sections (void); -/* In winnt-cxx.c and winnt-stubs.c */ +/* In winnt-cxx.cc and winnt-stubs.cc */ extern void i386_pe_adjust_class_at_definition (tree); extern bool i386_pe_type_dllimport_p (tree); extern bool i386_pe_type_dllexport_p (tree); diff --git a/gcc/config/i386/i386.cc b/gcc/config/i386/i386.cc index fb9b626..af82886 100644 --- a/gcc/config/i386/i386.cc +++ b/gcc/config/i386/i386.cc @@ -1438,7 +1438,7 @@ ix86_function_arg_regno_p (int regno) && regno < FIRST_MMX_REG + MMX_REGPARM_MAX)); /* TODO: The function should depend on current function ABI but - builtins.c would need updating then. Therefore we use the + builtins.cc would need updating then. Therefore we use the default ABI. */ call_abi = ix86_cfun_abi (); @@ -3648,7 +3648,7 @@ ix86_function_value_regno_p (const unsigned int regno) case ST0_REG: case ST1_REG: /* TODO: The function should depend on current function ABI but - builtins.c would need updating then. Therefore we use the + builtins.cc would need updating then. Therefore we use the default ABI. */ if (TARGET_64BIT && ix86_cfun_abi () == MS_ABI) return false; @@ -6854,7 +6854,7 @@ ix86_compute_frame_layout (void) if (TARGET_SEH) { /* Force the frame pointer to point at or below the lowest register save - area, see the SEH code in config/i386/winnt.c for the rationale. */ + area, see the SEH code in config/i386/winnt.cc for the rationale. */ frame->hard_frame_pointer_offset = frame->sse_reg_save_offset; /* If we can leave the frame pointer where it is, do so; however return @@ -11974,7 +11974,7 @@ legitimize_pe_coff_symbol (rtx addr, bool inreg) /* Try machine-dependent ways of modifying an illegitimate address to be legitimate. If we find one, return the new, valid address. - This macro is used in only one place: `memory_address' in explow.c. + This macro is used in only one place: `memory_address' in explow.cc. OLDX is the address as it was before break_out_memory_refs was called. In some cases it is useful to look at this to decide what needs to be done. @@ -11988,7 +11988,7 @@ legitimize_pe_coff_symbol (rtx addr, bool inreg) nothing needs to be done because REG can certainly go in a general reg. When -fpic is used, special handling is needed for symbolic references. - See comments by legitimize_pic_address in i386.c for details. */ + See comments by legitimize_pic_address in i386.cc for details. */ static rtx ix86_legitimize_address (rtx x, rtx, machine_mode mode) @@ -12334,7 +12334,7 @@ output_pic_addr_const (FILE *file, rtx x, int code) } } -/* This is called from dwarf2out.c via TARGET_ASM_OUTPUT_DWARF_DTPREL. +/* This is called from dwarf2out.cc via TARGET_ASM_OUTPUT_DWARF_DTPREL. We need to emit DTP-relative relocations. */ static void ATTRIBUTE_UNUSED diff --git a/gcc/config/i386/i386.h b/gcc/config/i386/i386.h index f1bb8a8..f41e090 100644 --- a/gcc/config/i386/i386.h +++ b/gcc/config/i386/i386.h @@ -551,9 +551,9 @@ extern GTY(()) tree x86_mfence; /* -march=native handling only makes sense with compiler running on an x86 or x86_64 chip. If changing this condition, also change - the condition in driver-i386.c. */ + the condition in driver-i386.cc. */ #if defined(__i386__) || defined(__x86_64__) -/* In driver-i386.c. */ +/* In driver-i386.cc. */ extern const char *host_detect_local_cpu (int argc, const char **argv); #define EXTRA_SPEC_FUNCTIONS \ { "local_cpu_detect", host_detect_local_cpu }, @@ -873,7 +873,7 @@ extern const char *host_detect_local_cpu (int argc, const char **argv); /* Standard register usage. */ -/* This processor has special stack-like registers. See reg-stack.c +/* This processor has special stack-like registers. See reg-stack.cc for details. */ #define STACK_REGS @@ -1662,7 +1662,7 @@ typedef struct ix86_args { They give nonzero only if REGNO is a hard reg of the suitable class or a pseudo reg currently allocated to a suitable hard reg. Since they use reg_renumber, they are safe only once reg_renumber - has been allocated, which happens in reginfo.c during register + has been allocated, which happens in reginfo.cc during register allocation. */ #define REGNO_OK_FOR_INDEX_P(REGNO) \ @@ -1724,7 +1724,7 @@ typedef struct ix86_args { The other macros defined here are used only in TARGET_LEGITIMATE_ADDRESS_P, except for CONSTANT_ADDRESS_P which is usually machine-independent. - See legitimize_pic_address in i386.c for details as to what + See legitimize_pic_address in i386.cc for details as to what constitutes a legitimate address when -fpic is used. */ #define MAX_REGS_PER_ADDRESS 2 @@ -1732,7 +1732,7 @@ typedef struct ix86_args { #define CONSTANT_ADDRESS_P(X) constant_address_p (X) /* If defined, a C expression to determine the base term of address X. - This macro is used in only one place: `find_base_term' in alias.c. + This macro is used in only one place: `find_base_term' in alias.cc. It is always safe for this macro to not be defined. It exists so that alias analysis can understand machine-dependent addresses. @@ -2204,7 +2204,7 @@ extern int const svr4_dbx_register_map[FIRST_PSEUDO_REGISTER]; #define DEFAULT_LARGE_SECTION_THRESHOLD 65536 /* Which processor to tune code generation for. These must be in sync - with processor_target_table in i386.c. */ + with processor_target_table in i386.cc. */ enum processor_type { @@ -2602,7 +2602,7 @@ struct GTY(()) machine_frame_state HOST_WIDE_INT sp_realigned_offset; }; -/* Private to winnt.c. */ +/* Private to winnt.cc. */ struct seh_frame_state; enum function_type diff --git a/gcc/config/i386/i386.md b/gcc/config/i386/i386.md index a2f095e..74da0d4 100644 --- a/gcc/config/i386/i386.md +++ b/gcc/config/i386/i386.md @@ -463,7 +463,7 @@ (ABI_UNKNOWN 2)]) ;; Insns whose names begin with "x86_" are emitted by gen_FOO calls -;; from i386.c. +;; from i386.cc. ;; In C guard expressions, put expressions which may be compile-time ;; constants first. This allows for better optimization. For @@ -5206,7 +5206,7 @@ ;; of the machinery. Please note the clobber of FLAGS_REG. In i387 control ;; word calculation (inserted by LCM in mode switching pass) a FLAGS_REG ;; clobbering insns can be used. Look at emit_i387_cw_initialization () -;; function in i386.c. +;; function in i386.cc. (define_insn_and_split "*fix_trunc_i387_1" [(set (match_operand:SWI248x 0 "nonimmediate_operand") (fix:SWI248x (match_operand 1 "register_operand"))) @@ -15298,7 +15298,7 @@ ;; Insn emitted into the body of a function to return from a function. ;; This is only done if the function's epilogue is known to be simple. -;; See comments for ix86_can_use_return_insn_p in i386.c. +;; See comments for ix86_can_use_return_insn_p in i386.cc. (define_expand "return" [(simple_return)] diff --git a/gcc/config/i386/lynx.h b/gcc/config/i386/lynx.h index 7918cac..baa62c1 100644 --- a/gcc/config/i386/lynx.h +++ b/gcc/config/i386/lynx.h @@ -60,7 +60,7 @@ along with GCC; see the file COPYING3. If not see #undef ASM_OUTPUT_ALIGN -/* The file i386.c defines TARGET_HAVE_TLS unconditionally if +/* The file i386.cc defines TARGET_HAVE_TLS unconditionally if HAVE_AS_TLS is defined. HAVE_AS_TLS is defined as gas support for TLS is detected by configure. We undefine it here. */ diff --git a/gcc/config/i386/mmx.md b/gcc/config/i386/mmx.md index 782da22..29d470b 100644 --- a/gcc/config/i386/mmx.md +++ b/gcc/config/i386/mmx.md @@ -1522,7 +1522,7 @@ }) ;; Avoid combining registers from different units in a single alternative, -;; see comment above inline_secondary_memory_needed function in i386.c +;; see comment above inline_secondary_memory_needed function in i386.cc (define_insn_and_split "*vec_extractv2sf_0" [(set (match_operand:SF 0 "nonimmediate_operand" "=x, m,y ,m,f,r") (vec_select:SF @@ -1537,7 +1537,7 @@ [(set_attr "mmx_isa" "*,*,native,native,*,*")]) ;; Avoid combining registers from different units in a single alternative, -;; see comment above inline_secondary_memory_needed function in i386.c +;; see comment above inline_secondary_memory_needed function in i386.cc (define_insn "*vec_extractv2sf_1" [(set (match_operand:SF 0 "nonimmediate_operand" "=y,x,x,y,x,f,r") (vec_select:SF @@ -3748,7 +3748,7 @@ }) ;; Avoid combining registers from different units in a single alternative, -;; see comment above inline_secondary_memory_needed function in i386.c +;; see comment above inline_secondary_memory_needed function in i386.cc (define_insn_and_split "*vec_extractv2si_0" [(set (match_operand:SI 0 "nonimmediate_operand" "=x,m,y, m,r,r") (vec_select:SI @@ -3805,7 +3805,7 @@ "operands[1] = gen_lowpart (SImode, operands[1]);") ;; Avoid combining registers from different units in a single alternative, -;; see comment above inline_secondary_memory_needed function in i386.c +;; see comment above inline_secondary_memory_needed function in i386.cc (define_insn "*vec_extractv2si_1" [(set (match_operand:SI 0 "nonimmediate_operand" "=y,rm,x,x,y,x,r") (vec_select:SI diff --git a/gcc/config/i386/sse.md b/gcc/config/i386/sse.md index ea72aa5..34175fd 100644 --- a/gcc/config/i386/sse.md +++ b/gcc/config/i386/sse.md @@ -10463,7 +10463,7 @@ (set_attr "mode" "DF")]) ;; Avoid combining registers from different units in a single alternative, -;; see comment above inline_secondary_memory_needed function in i386.c +;; see comment above inline_secondary_memory_needed function in i386.cc (define_insn "vec_set_0" [(set (match_operand:VI4F_128 0 "nonimmediate_operand" "=Yr,*x,v,v,v,x,x,v,Yr ,*x ,x ,m ,m ,m") @@ -12989,7 +12989,7 @@ (set_attr "mode" "V2DF")]) ;; Avoid combining registers from different units in a single alternative, -;; see comment above inline_secondary_memory_needed function in i386.c +;; see comment above inline_secondary_memory_needed function in i386.cc (define_insn "sse2_storehpd" [(set (match_operand:DF 0 "nonimmediate_operand" "=m,x,Yv,x,*f,r") (vec_select:DF @@ -13038,7 +13038,7 @@ (set_attr "mode" "V2SF,V4SF,V2SF")]) ;; Avoid combining registers from different units in a single alternative, -;; see comment above inline_secondary_memory_needed function in i386.c +;; see comment above inline_secondary_memory_needed function in i386.cc (define_insn "sse2_storelpd" [(set (match_operand:DF 0 "nonimmediate_operand" "=m,x,x,*f,r") (vec_select:DF @@ -13103,7 +13103,7 @@ }) ;; Avoid combining registers from different units in a single alternative, -;; see comment above inline_secondary_memory_needed function in i386.c +;; see comment above inline_secondary_memory_needed function in i386.cc (define_insn "sse2_loadhpd" [(set (match_operand:V2DF 0 "nonimmediate_operand" "=x,v,x,v ,o,o ,o") @@ -13162,7 +13162,7 @@ }) ;; Avoid combining registers from different units in a single alternative, -;; see comment above inline_secondary_memory_needed function in i386.c +;; see comment above inline_secondary_memory_needed function in i386.cc (define_insn "sse2_loadlpd" [(set (match_operand:V2DF 0 "nonimmediate_operand" "=v,x,v,x,v,x,x,v,m,m ,m") diff --git a/gcc/config/i386/t-cygming b/gcc/config/i386/t-cygming index 2e954cd..d4803de 100644 --- a/gcc/config/i386/t-cygming +++ b/gcc/config/i386/t-cygming @@ -20,33 +20,33 @@ # doing the build, it may not be installed yet. LIMITS_H_TEST = true -winnt.o: $(srcdir)/config/i386/winnt.c $(CONFIG_H) $(SYSTEM_H) coretypes.h \ +winnt.o: $(srcdir)/config/i386/winnt.cc $(CONFIG_H) $(SYSTEM_H) coretypes.h \ $(TM_H) $(RTL_H) $(REGS_H) hard-reg-set.h output.h $(TREE_H) flags.h \ $(TM_P_H) $(HASH_TABLE_H) $(GGC_H) $(LTO_STREAMER_H) $(COMPILER) -c $(ALL_COMPILERFLAGS) $(ALL_CPPFLAGS) $(INCLUDES) \ - $(srcdir)/config/i386/winnt.c + $(srcdir)/config/i386/winnt.cc -winnt-cxx.o: $(srcdir)/config/i386/winnt-cxx.c $(CONFIG_H) $(SYSTEM_H) coretypes.h \ +winnt-cxx.o: $(srcdir)/config/i386/winnt-cxx.cc $(CONFIG_H) $(SYSTEM_H) coretypes.h \ $(TM_H) $(TREE_H) flags.h \ $(TM_P_H) $(HASHTAB_H) $(GGC_H) $(COMPILER) -c $(ALL_COMPILERFLAGS) $(ALL_CPPFLAGS) $(INCLUDES) \ - $(srcdir)/config/i386/winnt-cxx.c + $(srcdir)/config/i386/winnt-cxx.cc -winnt-stubs.o: $(srcdir)/config/i386/winnt-stubs.c $(CONFIG_H) $(SYSTEM_H) coretypes.h \ +winnt-stubs.o: $(srcdir)/config/i386/winnt-stubs.cc $(CONFIG_H) $(SYSTEM_H) coretypes.h \ $(TM_H) $(RTL_H) $(REGS_H) hard-reg-set.h output.h $(TREE_H) flags.h \ $(TM_P_H) $(HASHTAB_H) $(GGC_H) $(COMPILER) -c $(ALL_COMPILERFLAGS) $(ALL_CPPFLAGS) $(INCLUDES) \ - $(srcdir)/config/i386/winnt-stubs.c + $(srcdir)/config/i386/winnt-stubs.cc -winnt-d.o: $(srcdir)/config/i386/winnt-d.c +winnt-d.o: $(srcdir)/config/i386/winnt-d.cc $(COMPILE) $< $(POSTCOMPILE) -msformat-c.o: $(srcdir)/config/i386/msformat-c.c $(CONFIG_H) $(SYSTEM_H) coretypes.h \ +msformat-c.o: $(srcdir)/config/i386/msformat-c.cc $(CONFIG_H) $(SYSTEM_H) coretypes.h \ $(TM_H) $(RTL_H) $(REGS_H) hard-reg-set.h output.h $(TREE_H) flags.h \ $(TM_P_H) $(HASHTAB_H) $(GGC_H) $(COMPILER) -c $(ALL_COMPILERFLAGS) $(ALL_CPPFLAGS) $(INCLUDES) \ - $(srcdir)/config/i386/msformat-c.c + $(srcdir)/config/i386/msformat-c.cc STMP_FIXINC=stmp-fixinc diff --git a/gcc/config/i386/t-djgpp b/gcc/config/i386/t-djgpp index dd3b32a..140f763 100644 --- a/gcc/config/i386/t-djgpp +++ b/gcc/config/i386/t-djgpp @@ -1,8 +1,8 @@ EXTRA_OBJS += djgpp.o -djgpp.o: $(srcdir)/config/i386/djgpp.c $(CONFIG_H) $(SYSTEM_H) coretypes.h \ +djgpp.o: $(srcdir)/config/i386/djgpp.cc $(CONFIG_H) $(SYSTEM_H) coretypes.h \ $(TM_H) $(RTL_H) $(REGS_H) hard-reg-set.h output.h $(TREE_H) flags.h \ $(TM_P_H) $(HASH_TABLE_H) $(GGC_H) $(LTO_STREAMER_H) $(COMPILER) -c $(ALL_COMPILERFLAGS) $(ALL_CPPFLAGS) $(INCLUDES) \ - $(srcdir)/config/i386/djgpp.c + $(srcdir)/config/i386/djgpp.cc diff --git a/gcc/config/i386/t-gnu-property b/gcc/config/i386/t-gnu-property index e5add0c..fc5c6f9 100644 --- a/gcc/config/i386/t-gnu-property +++ b/gcc/config/i386/t-gnu-property @@ -16,6 +16,6 @@ # along with GCC; see the file COPYING3. If not see # . -gnu-property.o: $(srcdir)/config/i386/gnu-property.c +gnu-property.o: $(srcdir)/config/i386/gnu-property.cc $(COMPILE) $< $(POSTCOMPILE) diff --git a/gcc/config/i386/t-i386 b/gcc/config/i386/t-i386 index 6f99b70f0..4e2a0ef 100644 --- a/gcc/config/i386/t-i386 +++ b/gcc/config/i386/t-i386 @@ -22,43 +22,43 @@ TM_H += $(srcdir)/config/i386/x86-tune.def \ $(srcdir)/config/i386/i386-isa.def PASSES_EXTRA += $(srcdir)/config/i386/i386-passes.def -i386-c.o: $(srcdir)/config/i386/i386-c.c +i386-c.o: $(srcdir)/config/i386/i386-c.cc $(COMPILE) $< $(POSTCOMPILE) -x86-tune-sched.o: $(srcdir)/config/i386/x86-tune-sched.c +x86-tune-sched.o: $(srcdir)/config/i386/x86-tune-sched.cc $(COMPILE) $< $(POSTCOMPILE) -x86-tune-sched-bd.o: $(srcdir)/config/i386/x86-tune-sched-bd.c +x86-tune-sched-bd.o: $(srcdir)/config/i386/x86-tune-sched-bd.cc $(COMPILE) $< $(POSTCOMPILE) -x86-tune-sched-atom.o: $(srcdir)/config/i386/x86-tune-sched-atom.c +x86-tune-sched-atom.o: $(srcdir)/config/i386/x86-tune-sched-atom.cc $(COMPILE) $< $(POSTCOMPILE) -x86-tune-sched-core.o: $(srcdir)/config/i386/x86-tune-sched-core.c +x86-tune-sched-core.o: $(srcdir)/config/i386/x86-tune-sched-core.cc $(COMPILE) $< $(POSTCOMPILE) -i386-d.o: $(srcdir)/config/i386/i386-d.c +i386-d.o: $(srcdir)/config/i386/i386-d.cc $(COMPILE) $< $(POSTCOMPILE) -i386-options.o: $(srcdir)/config/i386/i386-options.c +i386-options.o: $(srcdir)/config/i386/i386-options.cc $(COMPILE) $< $(POSTCOMPILE) -i386-builtins.o: $(srcdir)/config/i386/i386-builtins.c +i386-builtins.o: $(srcdir)/config/i386/i386-builtins.cc $(COMPILE) $< $(POSTCOMPILE) -i386-expand.o: $(srcdir)/config/i386/i386-expand.c +i386-expand.o: $(srcdir)/config/i386/i386-expand.cc $(COMPILE) $< $(POSTCOMPILE) -i386-features.o: $(srcdir)/config/i386/i386-features.c +i386-features.o: $(srcdir)/config/i386/i386-features.cc $(COMPILE) $< $(POSTCOMPILE) diff --git a/gcc/config/i386/t-intelmic b/gcc/config/i386/t-intelmic index 9de4b76..95d7e53 100644 --- a/gcc/config/i386/t-intelmic +++ b/gcc/config/i386/t-intelmic @@ -1,6 +1,6 @@ CFLAGS-mkoffload.o += $(DRIVER_DEFINES) -DGCC_INSTALL_NAME=\"$(GCC_INSTALL_NAME)\" -mkoffload.o: $(srcdir)/config/i386/intelmic-mkoffload.c +mkoffload.o: $(srcdir)/config/i386/intelmic-mkoffload.cc $(COMPILE) $< $(POSTCOMPILE) ALL_HOST_OBJS += mkoffload.o diff --git a/gcc/config/i386/t-omp-device b/gcc/config/i386/t-omp-device index 29350a1..cfb41ed 100644 --- a/gcc/config/i386/t-omp-device +++ b/gcc/config/i386/t-omp-device @@ -1,6 +1,6 @@ -omp-device-properties-i386: $(srcdir)/config/i386/i386-options.c +omp-device-properties-i386: $(srcdir)/config/i386/i386-options.cc echo kind: cpu > $@ echo arch: intel_mic x86 x86_64 i386 i486 i586 i686 ia32 >> $@ echo isa: sse4 `sed -n '/^static struct ix86_target_opts isa2\?_opts\[\] =/,/^};/p' \ - $(srcdir)/config/i386/i386-options.c | \ + $(srcdir)/config/i386/i386-options.cc | \ sed -n 's/",.*$$//;s/^ { "-m//p'` >> $@ diff --git a/gcc/config/i386/winnt-cxx.cc b/gcc/config/i386/winnt-cxx.cc index 1ea047d7..788c85c 100644 --- a/gcc/config/i386/winnt-cxx.cc +++ b/gcc/config/i386/winnt-cxx.cc @@ -47,7 +47,7 @@ i386_pe_type_dllimport_p (tree decl) return false; /* Overrides of the class dllimport decls by out-of-class definitions are - handled by tree.c:merge_dllimport_decl_attributes. */ + handled by tree.cc:merge_dllimport_decl_attributes. */ return true; } @@ -144,7 +144,7 @@ i386_pe_adjust_class_at_definition (tree t) that signals that the address of this symbol is not a compile-time constant. Any subsequent out-of-class declaration of members wil cause the DECL_DLLIMPORT_P flag to be unset. - (See tree.c: merge_dllimport_decl_attributes). + (See tree.cc: merge_dllimport_decl_attributes). That is just right since out-of class declarations can only be a definition. */ diff --git a/gcc/config/i386/winnt.cc b/gcc/config/i386/winnt.cc index 3d5eaeb..cd71369 100644 --- a/gcc/config/i386/winnt.cc +++ b/gcc/config/i386/winnt.cc @@ -1,4 +1,4 @@ -/* Subroutines for insn-output.c for Windows NT. +/* Subroutines for insn-output.cc for Windows NT. Contributed by Douglas Rupp (drupp@cs.washington.edu) Copyright (C) 1995-2022 Free Software Foundation, Inc. @@ -194,7 +194,7 @@ gen_stdcall_or_fastcall_suffix (tree decl, tree id, bool fastcall) return NULL_TREE; /* Quit if we hit an incomplete type. Error is reported - by convert_arguments in c-typeck.c or cp/typeck.c. */ + by convert_arguments in c-typeck.cc or cp/typeck.cc. */ FOREACH_FUNCTION_ARGS(type, arg, args_iter) { HOST_WIDE_INT parm_size; @@ -278,7 +278,7 @@ i386_pe_mangle_decl_assembler_name (tree decl, tree id) return (new_id ? new_id : id); } -/* This hook behaves the same as varasm.c/assemble_name(), but +/* This hook behaves the same as varasm.cc/assemble_name(), but generates the name into memory rather than outputting it to a file stream. */ @@ -319,7 +319,7 @@ i386_pe_encode_section_info (tree decl, rtx rtl, int first) } /* Mark the decl so we can tell from the rtl whether the object is - dllexport'd or dllimport'd. tree.c: merge_dllimport_decl_attributes + dllexport'd or dllimport'd. tree.cc: merge_dllimport_decl_attributes handles dllexport/dllimport override semantics. */ flags = (SYMBOL_REF_FLAGS (symbol) & ~(SYMBOL_FLAG_DLLIMPORT | SYMBOL_FLAG_DLLEXPORT)); diff --git a/gcc/config/i386/x-cygwin b/gcc/config/i386/x-cygwin index 752af76..d9b9091 100644 --- a/gcc/config/i386/x-cygwin +++ b/gcc/config/i386/x-cygwin @@ -1,4 +1,4 @@ -host-cygwin.o : $(srcdir)/config/i386/host-cygwin.c $(CONFIG_H) $(SYSTEM_H) \ +host-cygwin.o : $(srcdir)/config/i386/host-cygwin.cc $(CONFIG_H) $(SYSTEM_H) \ coretypes.h hosthooks.h $(HOSTHOOKS_DEF_H) toplev.h diagnostic.h $(COMPILER) -c $(ALL_COMPILERFLAGS) $(ALL_CPPFLAGS) $(INCLUDES) \ - $(srcdir)/config/i386/host-cygwin.c + $(srcdir)/config/i386/host-cygwin.cc diff --git a/gcc/config/i386/x-darwin b/gcc/config/i386/x-darwin index 4967d69..08b6ce5 100644 --- a/gcc/config/i386/x-darwin +++ b/gcc/config/i386/x-darwin @@ -1,3 +1,3 @@ -host-i386-darwin.o : $(srcdir)/config/i386/host-i386-darwin.c +host-i386-darwin.o : $(srcdir)/config/i386/host-i386-darwin.cc $(COMPILE) $< $(POSTCOMPILE) diff --git a/gcc/config/i386/x-i386 b/gcc/config/i386/x-i386 index 1f3db1d..29868e9 100644 --- a/gcc/config/i386/x-i386 +++ b/gcc/config/i386/x-i386 @@ -1,3 +1,3 @@ -driver-i386.o : $(srcdir)/config/i386/driver-i386.c +driver-i386.o : $(srcdir)/config/i386/driver-i386.cc $(COMPILE) $< $(POSTCOMPILE) diff --git a/gcc/config/i386/x-mingw32 b/gcc/config/i386/x-mingw32 index 85c7410..d481fc3 100644 --- a/gcc/config/i386/x-mingw32 +++ b/gcc/config/i386/x-mingw32 @@ -25,10 +25,10 @@ local_includedir=$(libsubdir)/$(unlibsubdir)/..`echo $(exec_prefix) | sed -e 's| # code does not handle that, so we have to disable checking here. WERROR_FLAGS += -Wno-format -host-mingw32.o : $(srcdir)/config/i386/host-mingw32.c $(CONFIG_H) $(SYSTEM_H) \ +host-mingw32.o : $(srcdir)/config/i386/host-mingw32.cc $(CONFIG_H) $(SYSTEM_H) \ coretypes.h hosthooks.h hosthooks-def.h toplev.h $(DIAGNOSTIC_H) $(HOOKS_H) $(COMPILER) -c $(ALL_COMPILERFLAGS) $(ALL_CPPFLAGS) $(INCLUDES) \ - $(srcdir)/config/i386/host-mingw32.c + $(srcdir)/config/i386/host-mingw32.cc -driver-mingw32.o : $(srcdir)/config/i386/driver-mingw32.c $(CONFIG_H) +driver-mingw32.o : $(srcdir)/config/i386/driver-mingw32.cc $(CONFIG_H) $(COMPILER) -c $(ALL_COMPILERFLAGS) $(ALL_CPPFLAGS) $(INCLUDES) $< diff --git a/gcc/config/i386/x86-tune-sched-core.cc b/gcc/config/i386/x86-tune-sched-core.cc index 0fe7c84..44968e8 100644 --- a/gcc/config/i386/x86-tune-sched-core.cc +++ b/gcc/config/i386/x86-tune-sched-core.cc @@ -37,7 +37,7 @@ along with GCC; see the file COPYING3. If not see /* Model decoder of Core 2/i7. - Below hooks for multipass scheduling (see haifa-sched.c:max_issue) + Below hooks for multipass scheduling (see haifa-sched.cc:max_issue) track the instruction fetch block boundaries and make sure that long (9+ bytes) instructions are assigned to D0. */ diff --git a/gcc/config/i386/x86-tune.def b/gcc/config/i386/x86-tune.def index f9eb3c2..82ca0ae 100644 --- a/gcc/config/i386/x86-tune.def +++ b/gcc/config/i386/x86-tune.def @@ -22,8 +22,8 @@ see the files COPYING3 and COPYING.RUNTIME respectively. If not, see - adding new CPU into: - adding PROCESSOR_XXX to processor_type (in i386.h) - possibly adding XXX into CPU attribute in i386.md - - adding XXX to processor_alias_table (in i386.c) - - introducing ix86_XXX_cost in i386.c + - adding XXX to processor_alias_table (in i386.cc) + - introducing ix86_XXX_cost in i386.cc - Stringop generation table can be build based on test_stringop - script (once rest of tuning is complete) - designing a scheduler model in diff --git a/gcc/config/i386/xm-djgpp.h b/gcc/config/i386/xm-djgpp.h index 8926524..1aff35f 100644 --- a/gcc/config/i386/xm-djgpp.h +++ b/gcc/config/i386/xm-djgpp.h @@ -39,7 +39,7 @@ along with GCC; see the file COPYING3. If not see #define STANDARD_STARTFILE_PREFIX_1 "/dev/env/DJDIR/lib/" /* Define STANDARD_STARTFILE_PREFIX_2 equal to STANDARD_STARTFILE_PREFIX_1 - to avoid gcc.c redefining it to /usr/lib */ + to avoid gcc.cc redefining it to /usr/lib */ #undef STANDARD_STARTFILE_PREFIX_2 #define STANDARD_STARTFILE_PREFIX_1 "/dev/env/DJDIR/lib/" @@ -92,7 +92,7 @@ along with GCC; see the file COPYING3. If not see } \ } while (0) -/* Canonicalize paths containing '/dev/env/'; used in prefix.c. +/* Canonicalize paths containing '/dev/env/'; used in prefix.cc. _fixpath is a djgpp-specific function to canonicalize a path. "/dev/env/DJDIR" evaluates to "c:/djgpp" if DJDIR is "c:/djgpp" for example. It removes any trailing '/', so add it back. */ diff --git a/gcc/config/ia64/freebsd.h b/gcc/config/ia64/freebsd.h index 7c978f2..e3ab57e 100644 --- a/gcc/config/ia64/freebsd.h +++ b/gcc/config/ia64/freebsd.h @@ -37,8 +37,8 @@ along with GCC; see the file COPYING3. If not see /************************[ Target stuff ]***********************************/ /* Define the actual types of some ANSI-mandated types. - Needs to agree with . GCC defaults come from c-decl.c, - c-common.c, and config//.h. */ + Needs to agree with . GCC defaults come from c-decl.cc, + c-common.cc, and config//.h. */ /* Earlier headers may get this wrong for FreeBSD. We use the GCC defaults instead. */ diff --git a/gcc/config/ia64/hpux.h b/gcc/config/ia64/hpux.h index fb196a0..fa705d7 100644 --- a/gcc/config/ia64/hpux.h +++ b/gcc/config/ia64/hpux.h @@ -131,7 +131,7 @@ do { \ #define REGISTER_TARGET_PRAGMAS() \ c_register_pragma (0, "builtin", ia64_hpux_handle_builtin_pragma) -/* Tell ia64.c that we are using the HP linker and we should delay output of +/* Tell ia64.cc that we are using the HP linker and we should delay output of function extern declarations so that we don't output them for functions which are never used (and may not be defined). */ diff --git a/gcc/config/ia64/ia64-protos.h b/gcc/config/ia64/ia64-protos.h index 21957c4..77e0cf7 100644 --- a/gcc/config/ia64/ia64-protos.h +++ b/gcc/config/ia64/ia64-protos.h @@ -20,7 +20,7 @@ along with GCC; see the file COPYING3. If not see /* Shared between the driver and cc1. */ extern enum unwind_info_type ia64_except_unwind_info (struct gcc_options *); -/* Functions defined in ia64.c */ +/* Functions defined in ia64.cc */ extern int bundling_p; #ifdef RTX_CODE diff --git a/gcc/config/ia64/ia64.cc b/gcc/config/ia64/ia64.cc index 829cf73..f9fb681 100644 --- a/gcc/config/ia64/ia64.cc +++ b/gcc/config/ia64/ia64.cc @@ -5319,7 +5319,7 @@ ia64_function_value_regno_p (const unsigned int regno) || (regno >= FR_RET_FIRST && regno <= FR_RET_LAST)); } -/* This is called from dwarf2out.c via TARGET_ASM_OUTPUT_DWARF_DTPREL. +/* This is called from dwarf2out.cc via TARGET_ASM_OUTPUT_DWARF_DTPREL. We need to emit DTP-relative relocations. */ static void @@ -5936,7 +5936,7 @@ ia64_secondary_reload_class (enum reg_class rclass, enabled, because paradoxical subregs are not accepted by register_operand when INSN_SCHEDULING is defined. Or alternatively, stop the paradoxical subreg stupidity in the *_operand functions - in recog.c. */ + in recog.cc. */ if (GET_CODE (x) == MEM && (GET_MODE (x) == SImode || GET_MODE (x) == HImode || GET_MODE (x) == QImode)) @@ -9226,7 +9226,7 @@ bundling (FILE *dump, int verbose, rtx_insn *prev_head_insn, rtx_insn *tail) if (verbose >= 2 && dump) { /* This structure is taken from generated code of the - pipeline hazard recognizer (see file insn-attrtab.c). + pipeline hazard recognizer (see file insn-attrtab.cc). Please don't forget to change the structure if a new automaton is added to .md file. */ struct DFA_chip diff --git a/gcc/config/ia64/ia64.h b/gcc/config/ia64/ia64.h index 5615951..bd0ef35e 100644 --- a/gcc/config/ia64/ia64.h +++ b/gcc/config/ia64/ia64.h @@ -1335,7 +1335,7 @@ do { \ } /* If defined, C string expressions to be used for the `%R', `%L', `%U', and - `%I' options of `asm_fprintf' (see `final.c'). */ + `%I' options of `asm_fprintf' (see `final.cc'). */ #define REGISTER_PREFIX "" #define LOCAL_LABEL_PREFIX "." diff --git a/gcc/config/ia64/ia64.md b/gcc/config/ia64/ia64.md index 48e8aa6..5d1d47d 100644 --- a/gcc/config/ia64/ia64.md +++ b/gcc/config/ia64/ia64.md @@ -549,7 +549,7 @@ ;; Define register predicate prefix. ;; We can generate speculative loads only for general and fp registers - this -;; is constrained in ia64.c: ia64_speculate_insn (). +;; is constrained in ia64.cc: ia64_speculate_insn (). (define_mode_attr reg_pred_prefix [(BI "gr") (QI "gr") (HI "gr") (SI "gr") (DI "grfr") (SF "grfr") (DF "grfr") (XF "fr") (TI "fr")]) (define_mode_attr ld_class [(BI "ld") (QI "ld") (HI "ld") (SI "ld") (DI "ld,fld") (SF "fld,ld") (DF "fld,ld") (XF "fld") (TI "fldp")]) @@ -1420,7 +1420,7 @@ if (width == 32 && shift == 0) { /* Directly generating the mix4left instruction confuses - optimize_bit_field in function.c. Since this is performing + optimize_bit_field in function.cc. Since this is performing a useful optimization, we defer generation of the complicated mix4left RTL to the first splitting phase. */ rtx tmp = gen_reg_rtx (DImode); diff --git a/gcc/config/ia64/predicates.md b/gcc/config/ia64/predicates.md index 157a01c..6364d2e 100644 --- a/gcc/config/ia64/predicates.md +++ b/gcc/config/ia64/predicates.md @@ -653,7 +653,7 @@ ;; True if OP is valid as a base register in a reg + offset address. ;; ??? Should I copy the flag_omit_frame_pointer and cse_not_expected -;; checks from pa.c basereg_operand as well? Seems to be OK without them +;; checks from pa.cc basereg_operand as well? Seems to be OK without them ;; in test runs. (define_predicate "basereg_operand" (match_operand 0 "register_operand") diff --git a/gcc/config/ia64/sysv4.h b/gcc/config/ia64/sysv4.h index 119c53f..045752a 100644 --- a/gcc/config/ia64/sysv4.h +++ b/gcc/config/ia64/sysv4.h @@ -59,10 +59,10 @@ see the files COPYING3 and COPYING.RUNTIME respectively. If not, see the Intel simulator. So we must explicitly put variables in .bss instead. This matters only if we care about the Intel assembler. */ -/* This is asm_output_aligned_bss from varasm.c without the +/* This is asm_output_aligned_bss from varasm.cc without the (*targetm.asm_out.globalize_label) call at the beginning. */ -/* This is for final.c, because it is used by ASM_DECLARE_OBJECT_NAME. */ +/* This is for final.cc, because it is used by ASM_DECLARE_OBJECT_NAME. */ extern int size_directive_output; #undef ASM_OUTPUT_ALIGNED_LOCAL diff --git a/gcc/config/ia64/t-ia64 b/gcc/config/ia64/t-ia64 index fc3a9bd..3fedb7b 100644 --- a/gcc/config/ia64/t-ia64 +++ b/gcc/config/ia64/t-ia64 @@ -16,13 +16,13 @@ # along with GCC; see the file COPYING3. If not see # . -ia64-c.o: $(srcdir)/config/ia64/ia64-c.c $(CONFIG_H) $(SYSTEM_H) \ +ia64-c.o: $(srcdir)/config/ia64/ia64-c.cc $(CONFIG_H) $(SYSTEM_H) \ coretypes.h $(TM_H) $(TREE_H) $(CPPLIB_H) $(C_COMMON_H) $(C_PRAGMA_H) $(COMPILER) -c $(ALL_COMPILERFLAGS) $(ALL_CPPFLAGS) $(INCLUDES) \ - $(srcdir)/config/ia64/ia64-c.c + $(srcdir)/config/ia64/ia64-c.cc # genattrtab generates very long string literals. insn-attrtab.o-warn = -Wno-error -ia64.o: $(srcdir)/config/ia64/ia64.c debug.h $(PARAMS_H) sel-sched.h reload.h \ +ia64.o: $(srcdir)/config/ia64/ia64.cc debug.h $(PARAMS_H) sel-sched.h reload.h \ $(OPTS_H) dumpfile.h $(HASH_TABLE_H) diff --git a/gcc/config/iq2000/iq2000.h b/gcc/config/iq2000/iq2000.h index 58a26cf..3327f14 100644 --- a/gcc/config/iq2000/iq2000.h +++ b/gcc/config/iq2000/iq2000.h @@ -525,7 +525,7 @@ while (0) #define FUNCTION_MODE SImode -/* IQ2000 external variables defined in iq2000.c. */ +/* IQ2000 external variables defined in iq2000.cc. */ /* Comparison type. */ enum cmp_type diff --git a/gcc/config/iq2000/iq2000.md b/gcc/config/iq2000/iq2000.md index 10f49bc..fdb346f 100644 --- a/gcc/config/iq2000/iq2000.md +++ b/gcc/config/iq2000/iq2000.md @@ -1495,7 +1495,7 @@ ;; ;; .................... -;; calls.c now passes a third argument, make saber happy +;; calls.cc now passes a third argument, make saber happy (define_expand "call" [(parallel [(call (match_operand 0 "memory_operand" "m") @@ -1565,7 +1565,7 @@ [(set_attr "type" "call") (set_attr "mode" "none")]) -;; calls.c now passes a fourth argument, make saber happy +;; calls.cc now passes a fourth argument, make saber happy (define_expand "call_value" [(parallel [(set (match_operand 0 "register_operand" "=d") diff --git a/gcc/config/linux.h b/gcc/config/linux.h index f394404..2e888e3 100644 --- a/gcc/config/linux.h +++ b/gcc/config/linux.h @@ -126,7 +126,7 @@ see the files COPYING3 and COPYING.RUNTIME respectively. If not, see #define TARGET_HAS_BIONIC (OPTION_BIONIC) /* musl avoids problematic includes by rearranging the include directories. - * Unfortunately, this is mostly duplicated from cppdefault.c */ + * Unfortunately, this is mostly duplicated from cppdefault.cc */ #if DEFAULT_LIBC == LIBC_MUSL #define INCLUDE_DEFAULTS_MUSL_GPP \ { GPLUSPLUS_INCLUDE_DIR, "G++", 1, 1, \ @@ -200,7 +200,7 @@ see the files COPYING3 and COPYING.RUNTIME respectively. If not, see #if (DEFAULT_LIBC == LIBC_UCLIBC) && defined (SINGLE_LIBC) /* uClinux */ /* This is a *uclinux* target. We don't define below macros to normal linux versions, because doing so would require *uclinux* targets to include - linux.c, linux-protos.h, linux.opt, etc. We could, alternatively, add + linux.cc, linux-protos.h, linux.opt, etc. We could, alternatively, add these files to *uclinux* targets, but that would only pollute option list (add -mglibc, etc.) without adding any useful support. */ diff --git a/gcc/config/m32c/m32c.cc b/gcc/config/m32c/m32c.cc index a004790..11ca9a4 100644 --- a/gcc/config/m32c/m32c.cc +++ b/gcc/config/m32c/m32c.cc @@ -4044,7 +4044,7 @@ m32c_function_needs_enter (void) /* Mark all the subexpressions of the PARALLEL rtx PAR as frame-related. Return PAR. - dwarf2out.c:dwarf2out_frame_debug_expr ignores sub-expressions of a + dwarf2out.cc:dwarf2out_frame_debug_expr ignores sub-expressions of a PARALLEL rtx other than the first if they do not have the FRAME_RELATED flag set on them. So this function is handy for marking up 'enter' instructions. */ diff --git a/gcc/config/m32c/m32c.h b/gcc/config/m32c/m32c.h index c419cf3..af99103 100644 --- a/gcc/config/m32c/m32c.h +++ b/gcc/config/m32c/m32c.h @@ -522,7 +522,7 @@ typedef struct m32c_cumulative_args #define MAX_REGS_PER_ADDRESS 1 /* This is passed to the macros below, so that they can be implemented - in m32c.c. */ + in m32c.cc. */ #ifdef REG_OK_STRICT #define REG_OK_STRICT_V 1 #else diff --git a/gcc/config/m32c/t-m32c b/gcc/config/m32c/t-m32c index 22995fd..8702608 100644 --- a/gcc/config/m32c/t-m32c +++ b/gcc/config/m32c/t-m32c @@ -31,7 +31,7 @@ md : $(MD_FILES:%=$(srcdir)/config/m32c/%.md) $(srcdir)/config/m32c/t-m32c echo "(include \"$(srcdir)/config/m32c/$$md.md\")"; \ done > md -m32c-pragma.o: $(srcdir)/config/m32c/m32c-pragma.c $(RTL_H) $(TREE_H) $(CONFIG_H) $(TM_H) +m32c-pragma.o: $(srcdir)/config/m32c/m32c-pragma.cc $(RTL_H) $(TREE_H) $(CONFIG_H) $(TM_H) $(COMPILER) -c $(ALL_COMPILERFLAGS) $(ALL_CPPFLAGS) $(INCLUDES) $< # We support four CPU series, but R8C and M16C share one multilib, and diff --git a/gcc/config/m32r/m32r-protos.h b/gcc/config/m32r/m32r-protos.h index ac6c2d0..dd07a99 100644 --- a/gcc/config/m32r/m32r-protos.h +++ b/gcc/config/m32r/m32r-protos.h @@ -1,4 +1,4 @@ -/* Prototypes for m32r.c functions used in the md file & elsewhere. +/* Prototypes for m32r.cc functions used in the md file & elsewhere. Copyright (C) 1999-2022 Free Software Foundation, Inc. This file is part of GCC. diff --git a/gcc/config/m32r/m32r.cc b/gcc/config/m32r/m32r.cc index e40a8f5..bca7681 100644 --- a/gcc/config/m32r/m32r.cc +++ b/gcc/config/m32r/m32r.cc @@ -2098,7 +2098,7 @@ m32r_print_operand (FILE * file, rtx x, int code) fprintf (file, "@("); /* Handle possible auto-increment. Since it is pre-increment and we have already done it, we can just use an offset of four. */ - /* ??? This is taken from rs6000.c I think. I don't think it is + /* ??? This is taken from rs6000.cc I think. I don't think it is currently necessary, but keep it around. */ if (GET_CODE (XEXP (x, 0)) == PRE_INC || GET_CODE (XEXP (x, 0)) == PRE_DEC) diff --git a/gcc/config/m32r/m32r.h b/gcc/config/m32r/m32r.h index 9eb964d..b96eec8 100644 --- a/gcc/config/m32r/m32r.h +++ b/gcc/config/m32r/m32r.h @@ -464,7 +464,7 @@ extern enum reg_class m32r_regno_reg_class[FIRST_PSEUDO_REGISTER]; They give nonzero only if REGNO is a hard reg of the suitable class or a pseudo reg currently allocated to a suitable hard reg. Since they use reg_renumber, they are safe only once reg_renumber - has been allocated, which happens in reginfo.c during register + has been allocated, which happens in reginfo.cc during register allocation. */ #define REGNO_OK_FOR_BASE_P(REGNO) \ ((REGNO) < FIRST_PSEUDO_REGISTER \ @@ -801,7 +801,7 @@ L2: .word STATIC } /* If defined, C string expressions to be used for the `%R', `%L', - `%U', and `%I' options of `asm_fprintf' (see `final.c'). These + `%U', and `%I' options of `asm_fprintf' (see `final.cc'). These are useful when a single `md' file must support multiple assembler formats. In that case, the various `tm.h' files can define these macros differently. */ diff --git a/gcc/config/m32r/m32r.md b/gcc/config/m32r/m32r.md index 26d4af4..1eb6859 100644 --- a/gcc/config/m32r/m32r.md +++ b/gcc/config/m32r/m32r.md @@ -2195,7 +2195,7 @@ ) -;; Block moves, see m32r.c for more details. +;; Block moves, see m32r.cc for more details. ;; Argument 0 is the destination ;; Argument 1 is the source ;; Argument 2 is the length diff --git a/gcc/config/m68k/m68k-isas.def b/gcc/config/m68k/m68k-isas.def index 6cb9785..ea95792 100644 --- a/gcc/config/m68k/m68k-isas.def +++ b/gcc/config/m68k/m68k-isas.def @@ -17,7 +17,7 @@ along with GCC; see the file COPYING3. If not see . */ -/* Define ISAs for the -march option, used both in m68k.c and to +/* Define ISAs for the -march option, used both in m68k.cc and to generate m68k-tables.opt. Before including this file, define a macro: diff --git a/gcc/config/m68k/m68k-microarchs.def b/gcc/config/m68k/m68k-microarchs.def index aa2a5ff..e488a93 100644 --- a/gcc/config/m68k/m68k-microarchs.def +++ b/gcc/config/m68k/m68k-microarchs.def @@ -18,7 +18,7 @@ . */ /* Define microarchitectures for the -mtune option, used both in - m68k.c and to generate m68k-tables.opt. Before including this + m68k.cc and to generate m68k-tables.opt. Before including this file, define a macro: M68K_MICROARCH (NAME, DEVICE, MICROARCH, ISA, FLAGS) diff --git a/gcc/config/m68k/m68k-protos.h b/gcc/config/m68k/m68k-protos.h index a1458bf..3139eb8 100644 --- a/gcc/config/m68k/m68k-protos.h +++ b/gcc/config/m68k/m68k-protos.h @@ -63,7 +63,7 @@ extern int floating_exact_log2 (rtx); extern bool strict_low_part_peephole_ok (machine_mode mode, rtx_insn *first_insn, rtx target); -/* Functions from m68k.c used in macros. */ +/* Functions from m68k.cc used in macros. */ extern int standard_68881_constant_p (rtx); extern void print_operand_address (FILE *, rtx); extern void print_operand (FILE *, rtx, int); @@ -85,10 +85,10 @@ extern bool m68k_movem_pattern_p (rtx, rtx, HOST_WIDE_INT, bool); extern const char *m68k_output_movem (rtx *, rtx, HOST_WIDE_INT, bool); extern bool m68k_epilogue_uses (int); -/* Functions from m68k.c used in constraints.md. */ +/* Functions from m68k.cc used in constraints.md. */ extern rtx m68k_unwrap_symbol (rtx, bool); -/* Functions from m68k.c used in genattrtab. */ +/* Functions from m68k.cc used in genattrtab. */ #ifdef HAVE_ATTR_cpu extern enum attr_cpu m68k_sched_cpu; extern enum attr_mac m68k_sched_mac; diff --git a/gcc/config/m68k/m68k.cc b/gcc/config/m68k/m68k.cc index 872b97a..1d5ef02 100644 --- a/gcc/config/m68k/m68k.cc +++ b/gcc/config/m68k/m68k.cc @@ -1,4 +1,4 @@ -/* Subroutines for insn-output.c for Motorola 68000 family. +/* Subroutines for insn-output.cc for Motorola 68000 family. Copyright (C) 1987-2022 Free Software Foundation, Inc. This file is part of GCC. @@ -2706,7 +2706,7 @@ m68k_call_tls_get_addr (rtx x, rtx eqv, enum m68k_reloc reloc) optimizations, sometimes cannot later fix this. As a consequence, additional register may be allocated resulting in a spill. For reference, see args processing loops in - calls.c:emit_library_call_value_1. + calls.cc:emit_library_call_value_1. For testcase, see gcc.target/m68k/tls-{gd, ld}.c */ x = m68k_wrap_symbol (x, reloc, m68k_get_gp (), NULL_RTX); @@ -6494,7 +6494,7 @@ m68k_sched_adjust_cost (rtx_insn *insn, int, rtx_insn *def_insn, int cost, if (sched_cfv4_bypass_data.scale == 1) /* Handle ColdFire V4 bypass for indexed address with 1x scale. */ { - /* haifa-sched.c: insn_cost () calls bypass_p () just before + /* haifa-sched.cc: insn_cost () calls bypass_p () just before targetm.sched.adjust_cost (). Hence, we can be relatively sure that the data in sched_cfv4_bypass_data is up to date. */ gcc_assert (sched_cfv4_bypass_data.pro == def_insn @@ -6517,7 +6517,7 @@ m68k_sched_adjust_cost (rtx_insn *insn, int, rtx_insn *def_insn, int cost, as their true dependence (default) latency is better to be set to 0 to workaround alias analysis limitations. This is, in fact, a machine independent tweak, so, probably, - it should be moved to haifa-sched.c: insn_cost (). */ + it should be moved to haifa-sched.cc: insn_cost (). */ delay = min_insn_conflict_delay (sched_adjust_cost_state, def_insn, insn); if (delay > cost) cost = delay; @@ -6798,7 +6798,7 @@ m68k_sched_md_init (FILE *sched_dump ATTRIBUTE_UNUSED, } if (sched_ib.enabled_p) - /* haifa-sched.c: schedule_block () calls advance_cycle () just before + /* haifa-sched.cc: schedule_block () calls advance_cycle () just before the first cycle. Workaround that. */ sched_ib.filled = -2; } diff --git a/gcc/config/m68k/m68k.h b/gcc/config/m68k/m68k.h index c302121..cd353db 100644 --- a/gcc/config/m68k/m68k.h +++ b/gcc/config/m68k/m68k.h @@ -865,7 +865,7 @@ __transfer_from_trampoline () \ || (CODE) == '$' || (CODE) == '&' || (CODE) == '/' || (CODE) == '?') -/* See m68k.c for the m68k specific codes. */ +/* See m68k.cc for the m68k specific codes. */ #define PRINT_OPERAND(FILE, X, CODE) print_operand (FILE, X, CODE) #define PRINT_OPERAND_ADDRESS(FILE, ADDR) print_operand_address (FILE, ADDR) @@ -888,7 +888,7 @@ enum m68k_function_kind m68k_fk_interrupt_thread }; -/* Variables in m68k.c; see there for details. */ +/* Variables in m68k.cc; see there for details. */ extern enum target_device m68k_cpu; extern enum uarch_type m68k_tune; extern enum fpu_type m68k_fpu; diff --git a/gcc/config/m68k/m68k.md b/gcc/config/m68k/m68k.md index e14255f..e4208cf 100644 --- a/gcc/config/m68k/m68k.md +++ b/gcc/config/m68k/m68k.md @@ -193,7 +193,7 @@ (define_attr "opy" "" (const_int 1)) ;; Type of the Y operand. -;; See m68k.c: enum attr_op_type. +;; See m68k.cc: enum attr_op_type. (define_attr "opy_type" "none,Rn,FPn,mem1,mem234,mem5,mem6,mem7,imm_q,imm_w,imm_l" (cond [(eq_attr "type" "ext,fbcc,ftst,neg_l,bcc,bra,bsr,clr,clr_l,ib,ignore, @@ -204,7 +204,7 @@ (symbol_ref "m68k_sched_attr_opy_type (insn, 0)"))) ;; Type of the X operand. -;; See m68k.c: enum attr_op_type. +;; See m68k.cc: enum attr_op_type. (define_attr "opx_type" "none,Rn,FPn,mem1,mem234,mem5,mem6,mem7,imm_q,imm_w,imm_l" (cond [(eq_attr "type" "ib,ignore,nop,rts,trap,unlk, diff --git a/gcc/config/m68k/m68kemb.h b/gcc/config/m68k/m68kemb.h index 1292454..ee55faf 100644 --- a/gcc/config/m68k/m68kemb.h +++ b/gcc/config/m68k/m68kemb.h @@ -39,7 +39,7 @@ } \ while (0) -/* Override the default LIB_SPEC from gcc.c. We don't currently support +/* Override the default LIB_SPEC from gcc.cc. We don't currently support profiling, or libg.a. */ #undef LIB_SPEC diff --git a/gcc/config/m68k/uclinux.h b/gcc/config/m68k/uclinux.h index 3027bf3..e438b6e 100644 --- a/gcc/config/m68k/uclinux.h +++ b/gcc/config/m68k/uclinux.h @@ -28,7 +28,7 @@ along with GCC; see the file COPYING3. If not see #undef ENDFILE_SPEC #define ENDFILE_SPEC "crtend.o%s crtn.o%s" -/* Override the default LIB_SPEC from gcc.c. We don't currently support +/* Override the default LIB_SPEC from gcc.cc. We don't currently support profiling, or libg.a. */ #undef LIB_SPEC #define LIB_SPEC \ diff --git a/gcc/config/mcore/mcore-protos.h b/gcc/config/mcore/mcore-protos.h index 1a6ffc6..52e0b7d 100644 --- a/gcc/config/mcore/mcore-protos.h +++ b/gcc/config/mcore/mcore-protos.h @@ -1,4 +1,4 @@ -/* Prototypes for exported functions defined in mcore.c +/* Prototypes for exported functions defined in mcore.cc Copyright (C) 2000-2022 Free Software Foundation, Inc. Contributed by Nick Clifton (nickc@redhat.com) diff --git a/gcc/config/mcore/mcore.cc b/gcc/config/mcore/mcore.cc index 11cf500..28e7074 100644 --- a/gcc/config/mcore/mcore.cc +++ b/gcc/config/mcore/mcore.cc @@ -1463,7 +1463,7 @@ mcore_expand_insv (rtx operands[]) int mask; rtx mreg, sreg, ereg; - /* To get width 1 insv, the test in store_bit_field() (expmed.c, line 191) + /* To get width 1 insv, the test in store_bit_field() (expmed.cc, line 191) for width==1 must be removed. Look around line 368. This is something we really want the md part to do. */ if (width == 1 && GET_CODE (operands[3]) == CONST_INT) @@ -2021,7 +2021,7 @@ mcore_expand_prolog (void) output_stack_adjust (-1, fi.growth[growth++]); /* Grows it. */ /* If we have a parameter passed partially in regs and partially in memory, - the registers will have been stored to memory already in function.c. So + the registers will have been stored to memory already in function.cc. So we only need to do something here for varargs functions. */ if (fi.arg_size != 0 && crtl->args.pretend_args_size == 0) { diff --git a/gcc/config/mcore/mcore.h b/gcc/config/mcore/mcore.h index 01e1674..c905c40 100644 --- a/gcc/config/mcore/mcore.h +++ b/gcc/config/mcore/mcore.h @@ -29,7 +29,7 @@ /* Run-time Target Specification. */ #define TARGET_MCORE -/* Get tree.c to declare a target-specific specialization of +/* Get tree.cc to declare a target-specific specialization of merge_decl_attributes. */ #define TARGET_DLLIMPORT_DECL_ATTRIBUTES 1 @@ -482,7 +482,7 @@ extern const enum reg_class regno_reg_class[FIRST_PSEUDO_REGISTER]; They give nonzero only if REGNO is a hard reg of the suitable class or a pseudo reg currently allocated to a suitable hard reg. Since they use reg_renumber, they are safe only once reg_renumber - has been allocated, which happens in reginfo.c during register + has been allocated, which happens in reginfo.cc during register allocation. */ #define REGNO_OK_FOR_BASE_P(REGNO) \ ((REGNO) < AP_REG || (unsigned) reg_renumber[(REGNO)] < AP_REG) diff --git a/gcc/config/mcore/mcore.md b/gcc/config/mcore/mcore.md index c977a48..ede545c 100644 --- a/gcc/config/mcore/mcore.md +++ b/gcc/config/mcore/mcore.md @@ -2642,7 +2642,7 @@ ; note: in the following patterns, use mcore_is_dead() to ensure that the ; reg we may be trashing really is dead. reload doesn't always mark -; deaths, so mcore_is_dead() (see mcore.c) scans forward to find its death. BRC +; deaths, so mcore_is_dead() (see mcore.cc) scans forward to find its death. BRC ;;; A peephole to convert the 3 instruction sequence generated by reload ;;; to load a FP-offset address into a 2 instruction sequence. diff --git a/gcc/config/microblaze/microblaze-protos.h b/gcc/config/microblaze/microblaze-protos.h index 702c528..d673556 100644 --- a/gcc/config/microblaze/microblaze-protos.h +++ b/gcc/config/microblaze/microblaze-protos.h @@ -61,7 +61,7 @@ extern bool microblaze_cannot_force_const_mem (machine_mode, rtx); extern void microblaze_eh_return (rtx op0); #endif /* RTX_CODE */ -/* Declare functions in microblaze-c.c. */ +/* Declare functions in microblaze-c.cc. */ extern void microblaze_cpp_define (struct cpp_reader *); #endif /* GCC_MICROBLAZE_PROTOS_H */ diff --git a/gcc/config/microblaze/microblaze.cc b/gcc/config/microblaze/microblaze.cc index 75767d8..f32effe 100644 --- a/gcc/config/microblaze/microblaze.cc +++ b/gcc/config/microblaze/microblaze.cc @@ -964,7 +964,7 @@ microblaze_legitimate_pic_operand (rtx x) /* Try machine-dependent ways of modifying an illegitimate address to be legitimate. If we find one, return the new, valid address. - This is used from only one place: `memory_address' in explow.c. + This is used from only one place: `memory_address' in explow.cc. OLDX is the address as it was before break_out_memory_refs was called. In some cases it is useful to look at this to decide what @@ -2767,7 +2767,7 @@ microblaze_function_prologue (FILE * file) const char *fnname; long fsiz = current_frame_info.total_size; - /* Get the function name the same way that toplev.c does before calling + /* Get the function name the same way that toplev.cc does before calling assemble_start_function. This is needed so that the name used here exactly matches the name used in ASM_DECLARE_FUNCTION_NAME. */ fnname = XSTR (XEXP (DECL_RTL (current_function_decl), 0), 0); @@ -3069,7 +3069,7 @@ microblaze_function_epilogue (FILE *file) { const char *fnname; - /* Get the function name the same way that toplev.c does before calling + /* Get the function name the same way that toplev.cc does before calling assemble_start_function. This is needed so that the name used here exactly matches the name used in ASM_DECLARE_FUNCTION_NAME. */ fnname = XSTR (XEXP (DECL_RTL (current_function_decl), 0), 0); @@ -3271,7 +3271,7 @@ microblaze_select_section (tree decl, int reloc, unsigned HOST_WIDE_INT align) /* Encode info about sections into the RTL based on a symbol's declaration. The default definition of this hook, default_encode_section_info in - `varasm.c', sets a number of commonly-useful bits in SYMBOL_REF_FLAGS. */ + `varasm.cc', sets a number of commonly-useful bits in SYMBOL_REF_FLAGS. */ static void microblaze_encode_section_info (tree decl, rtx rtl, int first) @@ -3357,7 +3357,7 @@ microblaze_asm_output_mi_thunk (FILE *file, tree thunk_fndecl ATTRIBUTE_UNUSED, emit_insn (gen_indirect_jump (temp2)); /* Run just enough of rest_of_compilation. This sequence was - "borrowed" from rs6000.c. */ + "borrowed" from rs6000.cc. */ insn = get_insns (); shorten_branches (insn); assemble_start_function (thunk_fndecl, fnname); @@ -3511,7 +3511,7 @@ microblaze_eh_return (rtx op0) /* Queue an .ident string in the queue of top-level asm statements. If the string size is below the threshold, put it into .sdata2. - If the front-end is done, we must be being called from toplev.c. + If the front-end is done, we must be being called from toplev.cc. In that case, do nothing. */ void microblaze_asm_output_ident (const char *string) diff --git a/gcc/config/microblaze/microblaze.h b/gcc/config/microblaze/microblaze.h index 01737df..d28bc76 100644 --- a/gcc/config/microblaze/microblaze.h +++ b/gcc/config/microblaze/microblaze.h @@ -21,7 +21,7 @@ /* Standard GCC variables that we reference. */ -/* MicroBlaze external variables defined in microblaze.c. */ +/* MicroBlaze external variables defined in microblaze.cc. */ /* Which pipeline to schedule for. */ enum pipeline_type diff --git a/gcc/config/microblaze/microblaze.md b/gcc/config/microblaze/microblaze.md index 7a6146c..0765ff9 100644 --- a/gcc/config/microblaze/microblaze.md +++ b/gcc/config/microblaze/microblaze.md @@ -1138,7 +1138,7 @@ (set_attr "mode" "QI") (set_attr "length" "4,4,8,4,8,4,8")]) -;; Block moves, see microblaze.c for more details. +;; Block moves, see microblaze.cc for more details. ;; Argument 0 is the destination ;; Argument 1 is the source ;; Argument 2 is the length @@ -2147,7 +2147,7 @@ (set_attr "mode" "none") (set_attr "length" "4")]) -;; calls.c now passes a fourth argument, make saber happy +;; calls.cc now passes a fourth argument, make saber happy (define_expand "call_value" [(parallel [(set (match_operand 0 "register_operand" "=d") diff --git a/gcc/config/microblaze/t-microblaze b/gcc/config/microblaze/t-microblaze index 41fa9a9..7e2fc5d 100644 --- a/gcc/config/microblaze/t-microblaze +++ b/gcc/config/microblaze/t-microblaze @@ -5,8 +5,8 @@ MULTILIB_EXCEPTIONS += *mxl-barrel-shift/mxl-multiply-high/mlittle-endian MULTILIB_EXCEPTIONS += mxl-multiply-high/mlittle-endian # Extra files -microblaze-c.o: $(srcdir)/config/microblaze/microblaze-c.c \ +microblaze-c.o: $(srcdir)/config/microblaze/microblaze-c.cc \ $(srcdir)/config/microblaze/microblaze-protos.h \ $(CONFIG_H) $(SYSTEM_H) $(CPPLIB_H) $(TM_P_H) $(TREE_H) errors.h $(TM_H) $(COMPILER) -c $(ALL_COMPILERFLAGS) $(ALL_CPPFLAGS) $(INCLUDES) \ - $(srcdir)/config/microblaze/microblaze-c.c + $(srcdir)/config/microblaze/microblaze-c.cc diff --git a/gcc/config/mips/driver-native.cc b/gcc/config/mips/driver-native.cc index 7cfa381..47627f8 100644 --- a/gcc/config/mips/driver-native.cc +++ b/gcc/config/mips/driver-native.cc @@ -24,7 +24,7 @@ along with GCC; see the file COPYING3. If not see #include "coretypes.h" #include "tm.h" -/* This will be called by the spec parser in gcc.c when it sees +/* This will be called by the spec parser in gcc.cc when it sees a %:local_cpu_detect(args) construct. Currently it will be called with either "arch" or "tune" as argument depending on if -march=native or -mtune=native is to be substituted. diff --git a/gcc/config/mips/loongson2ef.md b/gcc/config/mips/loongson2ef.md index 0038dde..793f208 100644 --- a/gcc/config/mips/loongson2ef.md +++ b/gcc/config/mips/loongson2ef.md @@ -96,7 +96,7 @@ ;; The following 4 instructions each subscribe one of ;; ls2_[f]alu{1,2}_turn_enabled units according to this attribute. -;; These instructions are used in mips.c: sched_ls2_dfa_post_advance_cycle. +;; These instructions are used in mips.cc: sched_ls2_dfa_post_advance_cycle. (define_attr "ls2_turn_type" "alu1,alu2,falu1,falu2,unknown,atomic,syncloop" (const_string "unknown")) diff --git a/gcc/config/mips/mips-protos.h b/gcc/config/mips/mips-protos.h index 877de78..9d0f4d9 100644 --- a/gcc/config/mips/mips-protos.h +++ b/gcc/config/mips/mips-protos.h @@ -388,7 +388,7 @@ extern void mips_register_frame_header_opt (void); extern void mips_expand_vec_cond_expr (machine_mode, machine_mode, rtx *); extern void mips_expand_vec_cmp_expr (rtx *); -/* Routines implemented in mips-d.c */ +/* Routines implemented in mips-d.cc */ extern void mips_d_target_versions (void); extern void mips_d_register_target_info (void); diff --git a/gcc/config/mips/mips.cc b/gcc/config/mips/mips.cc index 8c7d669..6c0da2b 100644 --- a/gcc/config/mips/mips.cc +++ b/gcc/config/mips/mips.cc @@ -4456,7 +4456,7 @@ mips_rtx_costs (rtx x, machine_mode mode, int outer_code, /* It is our responsibility to make division by a power of 2 as cheap as 2 register additions if we want the division expanders to be used for such operations; see the setting - of sdiv_pow2_cheap in optabs.c. Using (D)DIV for MIPS16 + of sdiv_pow2_cheap in optabs.cc. Using (D)DIV for MIPS16 should always produce shorter code than using expand_sdiv2_pow2. */ if (TARGET_MIPS16 @@ -9466,7 +9466,7 @@ mips_output_filename (FILE *stream, const char *name) output_quoted_string (stream, name); putc ('\n', stream); } - /* If we are emitting stabs, let dbxout.c handle this (except for + /* If we are emitting stabs, let dbxout.cc handle this (except for the mips_output_filename_first_time case). */ else if (write_symbols == DBX_DEBUG) return; @@ -11799,7 +11799,7 @@ mips_output_function_prologue (FILE *file) && crtl->args.info.fp_code != 0) mips16_build_function_stub (); - /* Get the function name the same way that toplev.c does before calling + /* Get the function name the same way that toplev.cc does before calling assemble_start_function. This is needed so that the name used here exactly matches the name used in ASM_DECLARE_FUNCTION_NAME. */ fnname = XSTR (XEXP (DECL_RTL (current_function_decl), 0), 0); @@ -11897,7 +11897,7 @@ mips_output_function_epilogue (FILE *) mips_pop_asm_switch (&mips_noreorder); } - /* Get the function name the same way that toplev.c does before calling + /* Get the function name the same way that toplev.cc does before calling assemble_start_function. This is needed so that the name used here exactly matches the name used in ASM_DECLARE_FUNCTION_NAME. */ fnname = XSTR (XEXP (DECL_RTL (current_function_decl), 0), 0); @@ -19620,7 +19620,7 @@ mips_output_mi_thunk (FILE *file, tree thunk_fndecl ATTRIBUTE_UNUSED, } /* Run just enough of rest_of_compilation. This sequence was - "borrowed" from alpha.c. */ + "borrowed" from alpha.cc. */ insn = get_insns (); split_all_insns_noflow (); mips16_lay_out_constants (true); diff --git a/gcc/config/mips/mips.h b/gcc/config/mips/mips.h index 30e6e2b..bf5c1d5 100644 --- a/gcc/config/mips/mips.h +++ b/gcc/config/mips/mips.h @@ -30,7 +30,7 @@ along with GCC; see the file COPYING3. If not see extern int target_flags_explicit; #endif -/* MIPS external variables defined in mips.c. */ +/* MIPS external variables defined in mips.cc. */ /* Which ABI to use. ABI_32 (original 32, or o32), ABI_N32 (n32), ABI_64 (n64) are all defined by SGI. ABI_O64 is o32 extended diff --git a/gcc/config/mips/mips.md b/gcc/config/mips/mips.md index cc412b1..e0f0a58 100644 --- a/gcc/config/mips/mips.md +++ b/gcc/config/mips/mips.md @@ -5657,7 +5657,7 @@ "cache\t0x14,0(%$)" [(set_attr "can_delay" "no")]) -;; Block moves, see mips.c for more details. +;; Block moves, see mips.cc for more details. ;; Argument 0 is the destination ;; Argument 1 is the source ;; Argument 2 is the length diff --git a/gcc/config/mips/t-mips b/gcc/config/mips/t-mips index 9920fb4..d7a934f 100644 --- a/gcc/config/mips/t-mips +++ b/gcc/config/mips/t-mips @@ -21,10 +21,10 @@ $(srcdir)/config/mips/mips-tables.opt: $(srcdir)/config/mips/genopt.sh \ $(SHELL) $(srcdir)/config/mips/genopt.sh $(srcdir)/config/mips > \ $(srcdir)/config/mips/mips-tables.opt -frame-header-opt.o: $(srcdir)/config/mips/frame-header-opt.c +frame-header-opt.o: $(srcdir)/config/mips/frame-header-opt.cc $(COMPILE) $< $(POSTCOMPILE) -mips-d.o: $(srcdir)/config/mips/mips-d.c +mips-d.o: $(srcdir)/config/mips/mips-d.cc $(COMPILE) $< $(POSTCOMPILE) diff --git a/gcc/config/mips/x-native b/gcc/config/mips/x-native index 5e31121..cf28636 100644 --- a/gcc/config/mips/x-native +++ b/gcc/config/mips/x-native @@ -1,3 +1,3 @@ -driver-native.o : $(srcdir)/config/mips/driver-native.c \ +driver-native.o : $(srcdir)/config/mips/driver-native.cc \ $(CONFIG_H) $(SYSTEM_H) $(COMPILER) -c $(ALL_COMPILERFLAGS) $(ALL_CPPFLAGS) $(INCLUDES) $< diff --git a/gcc/config/mmix/mmix-protos.h b/gcc/config/mmix/mmix-protos.h index 9ee84a2..d9a40d3 100644 --- a/gcc/config/mmix/mmix-protos.h +++ b/gcc/config/mmix/mmix-protos.h @@ -1,4 +1,4 @@ -/* Prototypes for exported functions defined in mmix.c +/* Prototypes for exported functions defined in mmix.cc Copyright (C) 2000-2022 Free Software Foundation, Inc. Contributed by Hans-Peter Nilsson (hp@bitrange.com) diff --git a/gcc/config/mmix/mmix.cc b/gcc/config/mmix/mmix.cc index 6e2bccd..18053d4 100644 --- a/gcc/config/mmix/mmix.cc +++ b/gcc/config/mmix/mmix.cc @@ -332,7 +332,7 @@ mmix_option_override (void) mixed-syntax assembly output already looks too ugly for the intent of being readable, and the resulting mix certainly fails the intent of being compatible with mmixal. See - varasm.c:default_file_start for this triple. See also + varasm.cc:default_file_start for this triple. See also mmix_assemble_integer. */ if (flag_verbose_asm || flag_debug_asm || flag_dump_rtl_in_asm) { @@ -1966,7 +1966,7 @@ mmix_dbx_register_number (unsigned regno) Now the MMIX port's own functions. First the exported ones. */ /* Wrapper for get_hard_reg_initial_val since integrate.h isn't included - from insn-emit.c. */ + from insn-emit.cc. */ rtx mmix_get_hard_reg_initial_val (machine_mode mode, int regno) @@ -2195,7 +2195,7 @@ mmix_expand_prologue (void) the register stack at landing pads. FIXME: It's a kludge because we can't describe the effect of the PUSHJ and PUSHGO insns on the register stack at the moment. Best thing would be to handle it - like stack-pointer offsets. Better: some hook into dwarf2out.c + like stack-pointer offsets. Better: some hook into dwarf2out.cc to produce DW_CFA_expression:s that specify the increment of rO, and unwind it at eh_return (preferred) or at the landing pad. Then saves to $0..$G-1 could be specified through that register. */ diff --git a/gcc/config/mmix/mmix.h b/gcc/config/mmix/mmix.h index 1e3018c..0fc45db 100644 --- a/gcc/config/mmix/mmix.h +++ b/gcc/config/mmix/mmix.h @@ -529,7 +529,7 @@ typedef struct { int regs; int lib; } CUMULATIVE_ARGS; /* Node: Function Entry */ -/* See mmix.c for TARGET_ASM_FUNCTION_PROLOGUE and +/* See mmix.cc for TARGET_ASM_FUNCTION_PROLOGUE and TARGET_ASM_FUNCTION_EPILOGUE. */ /* We need to say that the epilogue uses the return address, so the diff --git a/gcc/config/mmix/mmix.md b/gcc/config/mmix/mmix.md index 18e2164..8bafb1a 100644 --- a/gcc/config/mmix/mmix.md +++ b/gcc/config/mmix/mmix.md @@ -904,7 +904,7 @@ DIVU %1,%1,%2\;GET %0,:rR\;NEGU %2,0,%0\;CSNN %0,$255,%2") "" " { - /* The head comment of optabs.c:can_compare_p says we're required to + /* The head comment of optabs.cc:can_compare_p says we're required to implement this, so we have to clean up the mess here. */ if (GET_CODE (operands[0]) == LE || GET_CODE (operands[0]) == GE) { @@ -1036,7 +1036,7 @@ DIVU %1,%1,%2\;GET %0,:rR\;NEGU %2,0,%0\;CSNN %0,$255,%2") ;; Don't use 'p' here. A 'p' must stand first in constraints, or reload ;; messes up, not registering the address for reload. Several C++ ;; testcases, including g++.brendan/crash40.C. FIXME: This is arguably a -;; bug in gcc. Note line ~2612 in reload.c, that does things on the +;; bug in gcc. Note line ~2612 in reload.cc, that does things on the ;; condition <> and the comment on ;; ~3017 that says: ;; << case 'p': diff --git a/gcc/config/mmix/predicates.md b/gcc/config/mmix/predicates.md index 40c6317..96b214c 100644 --- a/gcc/config/mmix/predicates.md +++ b/gcc/config/mmix/predicates.md @@ -49,7 +49,7 @@ }) ;; Like comparison_operator, but only true if this comparison operator is -;; applied to a valid mode. Needed to avoid jump.c generating invalid +;; applied to a valid mode. Needed to avoid jump.cc generating invalid ;; code with -ffast-math (gcc.dg/20001228-1.c). (define_predicate "mmix_comparison_operator" diff --git a/gcc/config/mn10300/mn10300.cc b/gcc/config/mn10300/mn10300.cc index d375c70..2a58dd9 100644 --- a/gcc/config/mn10300/mn10300.cc +++ b/gcc/config/mn10300/mn10300.cc @@ -1,4 +1,4 @@ -/* Subroutines for insn-output.c for Matsushita MN10300 series +/* Subroutines for insn-output.cc for Matsushita MN10300 series Copyright (C) 1996-2022 Free Software Foundation, Inc. Contributed by Jeff Law (law@cygnus.com). @@ -1787,7 +1787,7 @@ mn10300_symbolic_operand (rtx op, /* Try machine dependent ways of modifying an illegitimate address to be legitimate. If we find one, return the new valid address. - This macro is used in only one place: `memory_address' in explow.c. + This macro is used in only one place: `memory_address' in explow.cc. OLDX is the address as it was before break_out_memory_refs was called. In some cases it is useful to look at this to decide what needs to be done. @@ -1928,7 +1928,7 @@ mn10300_legitimate_pic_operand_p (rtx x) Note it is still possible to use reg+reg addressing modes, it's just much more difficult. For a discussion of a possible - workaround and solution, see the comments in pa.c before the + workaround and solution, see the comments in pa.cc before the function record_unscaled_index_insn_codes. */ static bool diff --git a/gcc/config/mn10300/mn10300.h b/gcc/config/mn10300/mn10300.h index 815d50c..bc57f4b 100644 --- a/gcc/config/mn10300/mn10300.h +++ b/gcc/config/mn10300/mn10300.h @@ -318,7 +318,7 @@ enum reg_class They give nonzero only if REGNO is a hard reg of the suitable class or a pseudo reg currently allocated to a suitable hard reg. Since they use reg_renumber, they are safe only once reg_renumber - has been allocated, which happens in reginfo.c during register + has been allocated, which happens in reginfo.cc during register allocation. */ #ifndef REG_OK_STRICT @@ -546,7 +546,7 @@ do { \ #define NO_FUNCTION_CSE 1 -/* According expr.c, a value of around 6 should minimize code size, and +/* According expr.cc, a value of around 6 should minimize code size, and for the MN10300 series, that's our primary concern. */ #define MOVE_RATIO(speed) 6 @@ -624,7 +624,7 @@ do { \ } /* Print an instruction operand X on file FILE. - look in mn10300.c for details */ + look in mn10300.cc for details */ #define PRINT_OPERAND(FILE, X, CODE) \ mn10300_print_operand (FILE, X, CODE) diff --git a/gcc/config/moxie/moxie-protos.h b/gcc/config/moxie/moxie-protos.h index 288d68f..0a6c6cf 100644 --- a/gcc/config/moxie/moxie-protos.h +++ b/gcc/config/moxie/moxie-protos.h @@ -1,4 +1,4 @@ -/* Prototypes for moxie.c functions used in the md file & elsewhere. +/* Prototypes for moxie.cc functions used in the md file & elsewhere. Copyright (C) 2009-2022 Free Software Foundation, Inc. This file is part of GCC. diff --git a/gcc/config/moxie/uclinux.h b/gcc/config/moxie/uclinux.h index 3b3fdc6..b84d532 100644 --- a/gcc/config/moxie/uclinux.h +++ b/gcc/config/moxie/uclinux.h @@ -33,7 +33,7 @@ see the files COPYING3 and COPYING.RUNTIME respectively. If not, see #undef TARGET_LIBC_HAS_FUNCTION #define TARGET_LIBC_HAS_FUNCTION no_c99_libc_has_function -/* Like the definition in gcc.c, but for purposes of uClinux, every link is +/* Like the definition in gcc.cc, but for purposes of uClinux, every link is static. */ #define MFWRAP_SPEC " %{fmudflap|fmudflapth: \ --wrap=malloc --wrap=free --wrap=calloc --wrap=realloc\ diff --git a/gcc/config/msp430/msp430-devices.cc b/gcc/config/msp430/msp430-devices.cc index 85a2ad1..95288e5 100644 --- a/gcc/config/msp430/msp430-devices.cc +++ b/gcc/config/msp430/msp430-devices.cc @@ -98,7 +98,7 @@ extract_devices_dir_from_exec_prefix (char **devices_loc) char *gcc_exec_prefix = *devices_loc; int len = strlen (gcc_exec_prefix); - /* Copied from gcc.c. */ + /* Copied from gcc.cc. */ if (len > (int) sizeof ("/lib/gcc/") - 1 && (IS_DIR_SEPARATOR (gcc_exec_prefix[len-1]))) { diff --git a/gcc/config/msp430/msp430.cc b/gcc/config/msp430/msp430.cc index 136f014..18673ff 100644 --- a/gcc/config/msp430/msp430.cc +++ b/gcc/config/msp430/msp430.cc @@ -848,7 +848,7 @@ msp430_gimplify_va_arg_expr (tree valist, tree type, gimple_seq *pre_p, if (boundary > align && !integer_zerop (TYPE_SIZE (type))) { - /* FIXME: This is where this function diverts from targhooks.c: + /* FIXME: This is where this function diverts from targhooks.cc: std_gimplify_va_arg_expr(). It works, but I do not know why... */ if (! POINTER_TYPE_P (type)) { @@ -4426,7 +4426,7 @@ msp430_incoming_return_addr_rtx (void) /* If the path to the MSP430-GCC support files has been found by examining an environment variable (see msp430_check_env_var_for_devices in - msp430-devices.c), or -mdevices-csv-loc=, register this path as an include + msp430-devices.cc), or -mdevices-csv-loc=, register this path as an include directory so the user can #include msp430.h without needing to specify the path to the support files with -I. */ void diff --git a/gcc/config/msp430/msp430.h b/gcc/config/msp430/msp430.h index 8464784..3966765 100644 --- a/gcc/config/msp430/msp430.h +++ b/gcc/config/msp430/msp430.h @@ -103,7 +103,7 @@ extern const char * msp430_check_path_for_devices (int, const char **); extern const char *msp430_propagate_region_opt (int, const char **); extern const char *msp430_get_linker_devices_include_path (int, const char **); -/* There must be a trailing comma after the last item, see gcc.c +/* There must be a trailing comma after the last item, see gcc.cc "static_spec_functions". */ # define EXTRA_SPEC_FUNCTIONS \ { "msp430_hwmult_lib", msp430_select_hwmult_lib }, \ @@ -128,7 +128,7 @@ extern const char *msp430_get_linker_devices_include_path (int, const char **); reason that a spec function is used. There are so many possible values of FOO that a table is used to look up the name and map it to a hardware multiply library. This table (in device-msp430.c) - must be kept in sync with the same table in msp430.c. */ + must be kept in sync with the same table in msp430.cc. */ #undef LIB_SPEC #define LIB_SPEC " \ --start-group \ diff --git a/gcc/config/msp430/t-msp430 b/gcc/config/msp430/t-msp430 index 94720d8..bc7df12 100644 --- a/gcc/config/msp430/t-msp430 +++ b/gcc/config/msp430/t-msp430 @@ -18,11 +18,11 @@ # License along with GCC; see the file COPYING3. If not see # . -driver-msp430.o: $(srcdir)/config/msp430/driver-msp430.c \ +driver-msp430.o: $(srcdir)/config/msp430/driver-msp430.cc \ $(CONFIG_H) $(SYSTEM_H) coretypes.h $(TM_H) $(COMPILER) -c $(ALL_COMPILERFLAGS) $(ALL_CPPFLAGS) $(INCLUDES) $< -msp430-devices.o: $(srcdir)/config/msp430/msp430-devices.c \ +msp430-devices.o: $(srcdir)/config/msp430/msp430-devices.cc \ $(CONFIG_H) $(SYSTEM_H) coretypes.h $(TM_H) $(COMPILER) -c $(ALL_COMPILERFLAGS) $(ALL_CPPFLAGS) -DTARGET_SUBDIR=$(target_subdir) $(INCLUDES) $< @@ -49,5 +49,5 @@ MULTILIB_REQUIRED += mlarge/mdata-region=none/fno-exceptions MULTILIB_EXTRA_OPTS = -msp430-c.o: $(srcdir)/config/msp430/msp430-c.c $(RTL_H) $(TREE_H) $(CONFIG_H) $(TM_H) +msp430-c.o: $(srcdir)/config/msp430/msp430-c.cc $(RTL_H) $(TREE_H) $(CONFIG_H) $(TM_H) $(COMPILER) -c $(ALL_COMPILERFLAGS) $(ALL_CPPFLAGS) $(INCLUDES) $< diff --git a/gcc/config/nds32/nds32-cost.cc b/gcc/config/nds32/nds32-cost.cc index eccbbe5..af6ae07 100644 --- a/gcc/config/nds32/nds32-cost.cc +++ b/gcc/config/nds32/nds32-cost.cc @@ -66,7 +66,7 @@ nds32_rtx_costs_speed_prefer (rtx x ATTRIBUTE_UNUSED, switch (code) { case USE: - /* Used in combine.c as a marker. */ + /* Used in combine.cc as a marker. */ *total = 0; return true; @@ -418,7 +418,7 @@ nds32_rtx_costs_size_prefer (rtx x, return false; case USE: - /* Used in combine.c as a marker. */ + /* Used in combine.cc as a marker. */ *total = 0; break; @@ -506,7 +506,7 @@ nds32_init_rtx_costs (void) /* This target hook describes the relative costs of RTL expressions. Return 'true' when all subexpressions of x have been processed. Return 'false' to sum the costs of sub-rtx, plus cost of this operation. - Refer to gcc/rtlanal.c for more information. */ + Refer to gcc/rtlanal.cc for more information. */ bool nds32_rtx_costs_impl (rtx x, machine_mode mode ATTRIBUTE_UNUSED, diff --git a/gcc/config/nds32/nds32-doubleword.md b/gcc/config/nds32/nds32-doubleword.md index 3ce9c6c..19d4be3 100644 --- a/gcc/config/nds32/nds32-doubleword.md +++ b/gcc/config/nds32/nds32-doubleword.md @@ -150,7 +150,7 @@ /* Construct highpart rtx. */ /* Note that operands[1] can be VOIDmode constant, so we need to use gen_highpart_mode(). - Refer to gcc/emit-rtl.c for more information. */ + Refer to gcc/emit-rtl.cc for more information. */ operands[4] = gen_highpart (SImode, operands[0]); operands[5] = gen_highpart_mode (SImode, GET_MODE (operands[0]), operands[1]); diff --git a/gcc/config/nds32/nds32.cc b/gcc/config/nds32/nds32.cc index 7cf060b..aab02ff 100644 --- a/gcc/config/nds32/nds32.cc +++ b/gcc/config/nds32/nds32.cc @@ -3052,7 +3052,7 @@ nds32_memory_move_cost (machine_mode mode ATTRIBUTE_UNUSED, /* This target hook describes the relative costs of RTL expressions. Return 'true' when all subexpressions of x have been processed. Return 'false' to sum the costs of sub-rtx, plus cost of this operation. - Refer to gcc/rtlanal.c for more information. */ + Refer to gcc/rtlanal.cc for more information. */ static bool nds32_rtx_costs (rtx x, machine_mode mode, @@ -4219,7 +4219,7 @@ nds32_init_builtins (void) static tree nds32_builtin_decl (unsigned code, bool initialize_p) { - /* Implement in nds32-intrinsic.c. */ + /* Implement in nds32-intrinsic.cc. */ return nds32_builtin_decl_impl (code, initialize_p); } diff --git a/gcc/config/nds32/nds32.h b/gcc/config/nds32/nds32.h index d5662c1..18ef8ae 100644 --- a/gcc/config/nds32/nds32.h +++ b/gcc/config/nds32/nds32.h @@ -22,7 +22,7 @@ /* ------------------------------------------------------------------------ */ /* The following are auxiliary macros or structure declarations - that are used all over the nds32.c and nds32.h. */ + that are used all over the nds32.cc and nds32.h. */ #define ADJUST_INSN_LENGTH(INSN, LENGTH) \ (LENGTH = nds32_adjust_insn_length (INSN, LENGTH)) @@ -147,7 +147,7 @@ enum nds32_16bit_address_type /* Determine whether we would like to have code generation strictly aligned. We set it strictly aligned when -malways-align is enabled. - Check gcc/common/config/nds32/nds32-common.c for the optimizations that + Check gcc/common/config/nds32/nds32-common.cc for the optimizations that apply -malways-align. */ #define NDS32_ALIGN_P() (TARGET_ALWAYS_ALIGN) @@ -342,7 +342,7 @@ typedef struct 0 for reset handler, 1-8 for exception handler, and 9-72 for interrupt handler. - We use an array, which is defined in nds32.c, to record + We use an array, which is defined in nds32.cc, to record essential information for each vector. */ #define NDS32_N_ISR_VECTORS 73 @@ -373,7 +373,7 @@ enum nds32_isr_nested_type /* Define structure to record isr information. The isr vector array 'isr_vectors[]' with this structure - is defined in nds32.c. */ + is defined in nds32.cc. */ struct nds32_isr_info { /* The field to identify isr category. @@ -1411,7 +1411,7 @@ enum reg_class chain_value nested function address - Please check nds32.c implementation for more information. */ + Please check nds32.cc implementation for more information. */ #define TRAMPOLINE_SIZE 24 /* Because all instructions/data in trampoline template are 4-byte size, diff --git a/gcc/config/nds32/predicates.md b/gcc/config/nds32/predicates.md index 954573f..e09ff02 100644 --- a/gcc/config/nds32/predicates.md +++ b/gcc/config/nds32/predicates.md @@ -215,7 +215,7 @@ (match_code "parallel") { /* To verify 'load' operation, pass 'true' for the second argument. - See the implementation in nds32.c for details. */ + See the implementation in nds32.cc for details. */ return nds32_valid_multiple_load_store_p (op, true, false); }) @@ -224,7 +224,7 @@ { /* To verify 'load' operation, pass 'true' for the second argument. to verify 'update address' operation, pass 'true' for the third argument - See the implementation in nds32.c for details. */ + See the implementation in nds32.cc for details. */ return nds32_valid_multiple_load_store_p (op, true, true); }) @@ -232,7 +232,7 @@ (match_code "parallel") { /* To verify 'store' operation, pass 'false' for the second argument. - See the implementation in nds32.c for details. */ + See the implementation in nds32.cc for details. */ return nds32_valid_multiple_load_store_p (op, false, false); }) @@ -241,7 +241,7 @@ { /* To verify 'store' operation, pass 'false' for the second argument, to verify 'update address' operation, pass 'true' for the third argument - See the implementation in nds32.c for details. */ + See the implementation in nds32.cc for details. */ return nds32_valid_multiple_load_store_p (op, false, true); }) @@ -249,7 +249,7 @@ (match_code "parallel") { /* To verify 'push' operation, pass 'true' for the second argument. - See the implementation in nds32-predicates.c for details. */ + See the implementation in nds32-predicates.cc for details. */ return nds32_valid_stack_push_pop_p (op, true); }) @@ -257,7 +257,7 @@ (match_code "parallel") { /* To verify 'pop' operation, pass 'false' for the second argument. - See the implementation in nds32-predicates.c for details. */ + See the implementation in nds32-predicates.cc for details. */ return nds32_valid_stack_push_pop_p (op, false); }) diff --git a/gcc/config/nds32/t-nds32 b/gcc/config/nds32/t-nds32 index 1eb9de6..3833f3d 100644 --- a/gcc/config/nds32/t-nds32 +++ b/gcc/config/nds32/t-nds32 @@ -19,7 +19,7 @@ # . -nds32-md-auxiliary.o: $(srcdir)/config/nds32/nds32-md-auxiliary.c \ +nds32-md-auxiliary.o: $(srcdir)/config/nds32/nds32-md-auxiliary.cc \ $(CONFIG_H) $(SYSTEM_H) coretypes.h $(TM_H) \ $(RTL_H) $(TREE_H) $(HASH_TABLE_H) $(OBSTACK_H) $(REGS_H) hard-reg-set.h \ insn-config.h conditions.h output.h dumpfile.h \ @@ -29,9 +29,9 @@ nds32-md-auxiliary.o: $(srcdir)/config/nds32/nds32-md-auxiliary.c \ $(TARGET_H) $(TARGET_DEF_H) debug.h langhooks.h $(DF_H) \ intl.h libfuncs.h $(PARAMS_H) $(OPTS_H) $(COMPILER) -c $(ALL_COMPILERFLAGS) $(ALL_CPPFLAGS) $(INCLUDES) \ - $(srcdir)/config/nds32/nds32-md-auxiliary.c + $(srcdir)/config/nds32/nds32-md-auxiliary.cc -nds32-memory-manipulation.o: $(srcdir)/config/nds32/nds32-memory-manipulation.c \ +nds32-memory-manipulation.o: $(srcdir)/config/nds32/nds32-memory-manipulation.cc \ $(CONFIG_H) $(SYSTEM_H) coretypes.h $(TM_H) \ $(RTL_H) $(TREE_H) $(HASH_TABLE_H) $(OBSTACK_H) $(REGS_H) hard-reg-set.h \ insn-config.h conditions.h output.h dumpfile.h \ @@ -41,9 +41,9 @@ nds32-memory-manipulation.o: $(srcdir)/config/nds32/nds32-memory-manipulation.c $(TARGET_H) $(TARGET_DEF_H) debug.h langhooks.h $(DF_H) \ intl.h libfuncs.h $(PARAMS_H) $(OPTS_H) $(COMPILER) -c $(ALL_COMPILERFLAGS) $(ALL_CPPFLAGS) $(INCLUDES) \ - $(srcdir)/config/nds32/nds32-memory-manipulation.c + $(srcdir)/config/nds32/nds32-memory-manipulation.cc -nds32-predicates.o: $(srcdir)/config/nds32/nds32-predicates.c \ +nds32-predicates.o: $(srcdir)/config/nds32/nds32-predicates.cc \ $(CONFIG_H) $(SYSTEM_H) coretypes.h $(TM_H) \ $(RTL_H) $(TREE_H) $(HASH_TABLE_H) $(OBSTACK_H) $(REGS_H) hard-reg-set.h \ insn-config.h conditions.h output.h dumpfile.h \ @@ -53,9 +53,9 @@ nds32-predicates.o: $(srcdir)/config/nds32/nds32-predicates.c \ $(TARGET_H) $(TARGET_DEF_H) debug.h langhooks.h $(DF_H) \ intl.h libfuncs.h $(PARAMS_H) $(OPTS_H) $(COMPILER) -c $(ALL_COMPILERFLAGS) $(ALL_CPPFLAGS) $(INCLUDES) \ - $(srcdir)/config/nds32/nds32-predicates.c + $(srcdir)/config/nds32/nds32-predicates.cc -nds32-intrinsic.o: $(srcdir)/config/nds32/nds32-intrinsic.c \ +nds32-intrinsic.o: $(srcdir)/config/nds32/nds32-intrinsic.cc \ $(CONFIG_H) $(SYSTEM_H) coretypes.h $(TM_H) \ $(RTL_H) $(TREE_H) $(HASH_TABLE_H) $(OBSTACK_H) $(REGS_H) hard-reg-set.h \ insn-config.h conditions.h output.h dumpfile.h \ @@ -65,10 +65,10 @@ nds32-intrinsic.o: $(srcdir)/config/nds32/nds32-intrinsic.c \ $(TARGET_H) $(TARGET_DEF_H) debug.h langhooks.h $(DF_H) \ intl.h libfuncs.h $(PARAMS_H) $(OPTS_H) $(COMPILER) -c $(ALL_COMPILERFLAGS) $(ALL_CPPFLAGS) $(INCLUDES) \ - $(srcdir)/config/nds32/nds32-intrinsic.c + $(srcdir)/config/nds32/nds32-intrinsic.cc nds32-pipelines-auxiliary.o: \ - $(srcdir)/config/nds32/nds32-pipelines-auxiliary.c \ + $(srcdir)/config/nds32/nds32-pipelines-auxiliary.cc \ $(CONFIG_H) $(SYSTEM_H) coretypes.h $(TM_H) \ $(RTL_H) $(TREE_H) $(HASH_TABLE_H) $(OBSTACK_H) $(REGS_H) hard-reg-set.h \ insn-config.h conditions.h output.h dumpfile.h \ @@ -78,10 +78,10 @@ nds32-pipelines-auxiliary.o: \ $(TARGET_H) $(TARGET_DEF_H) debug.h langhooks.h $(DF_H) \ intl.h libfuncs.h $(PARAMS_H) $(OPTS_H) $(COMPILER) -c $(ALL_COMPILERFLAGS) $(ALL_CPPFLAGS) $(INCLUDES) \ - $(srcdir)/config/nds32/nds32-pipelines-auxiliary.c + $(srcdir)/config/nds32/nds32-pipelines-auxiliary.cc nds32-isr.o: \ - $(srcdir)/config/nds32/nds32-isr.c \ + $(srcdir)/config/nds32/nds32-isr.cc \ $(CONFIG_H) $(SYSTEM_H) coretypes.h $(TM_H) \ $(RTL_H) $(TREE_H) $(HASH_TABLE_H) $(OBSTACK_H) $(REGS_H) hard-reg-set.h \ insn-config.h conditions.h output.h dumpfile.h \ @@ -91,10 +91,10 @@ nds32-isr.o: \ $(TARGET_H) $(TARGET_DEF_H) debug.h langhooks.h $(DF_H) \ intl.h libfuncs.h $(PARAMS_H) $(OPTS_H) $(COMPILER) -c $(ALL_COMPILERFLAGS) $(ALL_CPPFLAGS) $(INCLUDES) \ - $(srcdir)/config/nds32/nds32-isr.c + $(srcdir)/config/nds32/nds32-isr.cc nds32-cost.o: \ - $(srcdir)/config/nds32/nds32-cost.c \ + $(srcdir)/config/nds32/nds32-cost.cc \ $(CONFIG_H) $(SYSTEM_H) coretypes.h $(TM_H) \ $(RTL_H) $(TREE_H) $(HASH_TABLE_H) $(OBSTACK_H) $(REGS_H) hard-reg-set.h \ insn-config.h conditions.h output.h dumpfile.h \ @@ -104,10 +104,10 @@ nds32-cost.o: \ $(TARGET_H) $(TARGET_DEF_H) debug.h langhooks.h $(DF_H) \ intl.h libfuncs.h $(PARAMS_H) $(OPTS_H) $(COMPILER) -c $(ALL_COMPILERFLAGS) $(ALL_CPPFLAGS) $(INCLUDES) \ - $(srcdir)/config/nds32/nds32-cost.c + $(srcdir)/config/nds32/nds32-cost.cc nds32-fp-as-gp.o: \ - $(srcdir)/config/nds32/nds32-fp-as-gp.c \ + $(srcdir)/config/nds32/nds32-fp-as-gp.cc \ $(CONFIG_H) $(SYSTEM_H) coretypes.h $(TM_H) \ $(RTL_H) $(TREE_H) $(HASH_TABLE_H) $(OBSTACK_H) $(REGS_H) hard-reg-set.h \ insn-config.h conditions.h output.h dumpfile.h \ @@ -117,10 +117,10 @@ nds32-fp-as-gp.o: \ $(TARGET_H) $(TARGET_DEF_H) debug.h langhooks.h $(DF_H) \ intl.h libfuncs.h $(PARAMS_H) $(OPTS_H) $(COMPILER) -c $(ALL_COMPILERFLAGS) $(ALL_CPPFLAGS) $(INCLUDES) \ - $(srcdir)/config/nds32/nds32-fp-as-gp.c + $(srcdir)/config/nds32/nds32-fp-as-gp.cc nds32-relax-opt.o: \ - $(srcdir)/config/nds32/nds32-relax-opt.c \ + $(srcdir)/config/nds32/nds32-relax-opt.cc \ $(CONFIG_H) $(SYSTEM_H) coretypes.h $(TM_H) \ $(RTL_H) $(TREE_H) $(HASH_TABLE_H) $(OBSTACK_H) $(REGS_H) hard-reg-set.h \ insn-config.h conditions.h output.h dumpfile.h \ @@ -130,10 +130,10 @@ nds32-relax-opt.o: \ $(TARGET_H) $(TARGET_DEF_H) debug.h langhooks.h $(DF_H) \ intl.h libfuncs.h $(PARAMS_H) $(OPTS_H) $(COMPILER) -c $(ALL_COMPILERFLAGS) $(ALL_CPPFLAGS) $(INCLUDES) \ - $(srcdir)/config/nds32/nds32-relax-opt.c + $(srcdir)/config/nds32/nds32-relax-opt.cc nds32-utils.o: \ - $(srcdir)/config/nds32/nds32-utils.c \ + $(srcdir)/config/nds32/nds32-utils.cc \ $(CONFIG_H) $(SYSTEM_H) coretypes.h $(TM_H) \ $(RTL_H) $(TREE_H) $(HASH_TABLE_H) $(OBSTACK_H) $(REGS_H) hard-reg-set.h \ insn-config.h conditions.h output.h dumpfile.h \ @@ -143,4 +143,4 @@ nds32-utils.o: \ $(TARGET_H) $(TARGET_DEF_H) debug.h langhooks.h $(DF_H) \ intl.h libfuncs.h $(PARAMS_H) $(OPTS_H) $(COMPILER) -c $(ALL_COMPILERFLAGS) $(ALL_CPPFLAGS) $(INCLUDES) \ - $(srcdir)/config/nds32/nds32-utils.c + $(srcdir)/config/nds32/nds32-utils.cc diff --git a/gcc/config/nios2/nios2.cc b/gcc/config/nios2/nios2.cc index 8c539fc..f193cde 100644 --- a/gcc/config/nios2/nios2.cc +++ b/gcc/config/nios2/nios2.cc @@ -4462,7 +4462,7 @@ nios2_pragma_target_parse (tree args, tree pop_target) We are just using this hook to add some additional error checking to the default behavior. GCC does not provide a target hook for merging the target options, and only correctly handles merging empty vs non-empty - option data; see merge_decls() in c-decl.c. + option data; see merge_decls() in c-decl.cc. So here we require either that at least one of the decls has empty target options, or that the target options/data be identical. */ static tree diff --git a/gcc/config/nvptx/nvptx-protos.h b/gcc/config/nvptx/nvptx-protos.h index ef23615..3d6ad14 100644 --- a/gcc/config/nvptx/nvptx-protos.h +++ b/gcc/config/nvptx/nvptx-protos.h @@ -1,4 +1,4 @@ -/* Prototypes for exported functions defined in nvptx.c. +/* Prototypes for exported functions defined in nvptx.cc. Copyright (C) 2014-2022 Free Software Foundation, Inc. Contributed by Bernd Schmidt diff --git a/gcc/config/nvptx/nvptx.cc b/gcc/config/nvptx/nvptx.cc index 5cc5e01..20fd893 100644 --- a/gcc/config/nvptx/nvptx.cc +++ b/gcc/config/nvptx/nvptx.cc @@ -6793,7 +6793,7 @@ nvptx_goacc_expand_var_decl (tree var) var, "gang"); if (dump_file && (dump_flags & TDF_DETAILS)) { - /* 'dumpfile.c:dump_loc' */ + /* 'dumpfile.cc:dump_loc' */ fprintf (dump_file, "%s:%d:%d: ", LOCATION_FILE (loc), LOCATION_LINE (loc), LOCATION_COLUMN (loc)); fprintf (dump_file, "%s: ", "note"); diff --git a/gcc/config/nvptx/nvptx.h b/gcc/config/nvptx/nvptx.h index d61bd70..9fda2f0 100644 --- a/gcc/config/nvptx/nvptx.h +++ b/gcc/config/nvptx/nvptx.h @@ -36,7 +36,7 @@ #define TARGET_CPU_CPP_BUILTINS() nvptx_cpu_cpp_builtins () -/* Avoid the default in ../../gcc.c, which adds "-pthread", which is not +/* Avoid the default in ../../gcc.cc, which adds "-pthread", which is not supported for nvptx. */ #define GOMP_SELF_SPECS "" diff --git a/gcc/config/nvptx/t-nvptx b/gcc/config/nvptx/t-nvptx index d33bacd..b170766 100644 --- a/gcc/config/nvptx/t-nvptx +++ b/gcc/config/nvptx/t-nvptx @@ -1,10 +1,10 @@ -nvptx-c.o: $(srcdir)/config/nvptx/nvptx-c.c +nvptx-c.o: $(srcdir)/config/nvptx/nvptx-c.cc $(COMPILE) $< $(POSTCOMPILE) CFLAGS-mkoffload.o += $(DRIVER_DEFINES) \ -DGCC_INSTALL_NAME=\"$(GCC_INSTALL_NAME)\" -mkoffload.o: $(srcdir)/config/nvptx/mkoffload.c +mkoffload.o: $(srcdir)/config/nvptx/mkoffload.cc $(COMPILE) $< $(POSTCOMPILE) ALL_HOST_OBJS += mkoffload.o diff --git a/gcc/config/nvptx/t-omp-device b/gcc/config/nvptx/t-omp-device index 6d03b43..8765d9f 100644 --- a/gcc/config/nvptx/t-omp-device +++ b/gcc/config/nvptx/t-omp-device @@ -1,4 +1,4 @@ -omp-device-properties-nvptx: $(srcdir)/config/nvptx/nvptx.c +omp-device-properties-nvptx: $(srcdir)/config/nvptx/nvptx.cc echo kind: gpu > $@ echo arch: nvptx >> $@ echo isa: sm_30 sm_35 >> $@ diff --git a/gcc/config/pa/elf.h b/gcc/config/pa/elf.h index 2c2f249..b58659c 100644 --- a/gcc/config/pa/elf.h +++ b/gcc/config/pa/elf.h @@ -17,7 +17,7 @@ You should have received a copy of the GNU General Public License along with GCC; see the file COPYING3. If not see . */ -/* So we can conditionalize small amounts of code in pa.c or pa.md. */ +/* So we can conditionalize small amounts of code in pa.cc or pa.md. */ #define OBJ_ELF #define ENDFILE_SPEC "crtend.o%s" diff --git a/gcc/config/pa/pa-linux.h b/gcc/config/pa/pa-linux.h index ea7157d..5af11a1 100644 --- a/gcc/config/pa/pa-linux.h +++ b/gcc/config/pa/pa-linux.h @@ -100,7 +100,7 @@ along with GCC; see the file COPYING3. If not see #define GLOBAL_ASM_OP ".globl " /* FIXME: Hacked from the one so that we avoid multiple - labels in a function declaration (since pa.c seems determined to do + labels in a function declaration (since pa.cc seems determined to do it differently). */ #undef ASM_DECLARE_FUNCTION_NAME diff --git a/gcc/config/pa/pa-netbsd.h b/gcc/config/pa/pa-netbsd.h index d52c4d5..f5eaec6 100644 --- a/gcc/config/pa/pa-netbsd.h +++ b/gcc/config/pa/pa-netbsd.h @@ -95,7 +95,7 @@ along with GCC; see the file COPYING3. If not see #define GLOBAL_ASM_OP ".globl " /* FIXME: Hacked from the one so that we avoid multiple - labels in a function declaration (since pa.c seems determined to do + labels in a function declaration (since pa.cc seems determined to do it differently) */ #undef ASM_DECLARE_FUNCTION_NAME diff --git a/gcc/config/pa/pa-openbsd.h b/gcc/config/pa/pa-openbsd.h index 6145298..455294f 100644 --- a/gcc/config/pa/pa-openbsd.h +++ b/gcc/config/pa/pa-openbsd.h @@ -69,7 +69,7 @@ along with GCC; see the file COPYING3. If not see #undef TARGET_ASM_GLOBALIZE_LABEL /* FIXME: Hacked from the one so that we avoid multiple - labels in a function declaration (since pa.c seems determined to do + labels in a function declaration (since pa.cc seems determined to do it differently) */ #undef ASM_DECLARE_FUNCTION_NAME diff --git a/gcc/config/pa/pa-protos.h b/gcc/config/pa/pa-protos.h index fcbffa7..d474d9e 100644 --- a/gcc/config/pa/pa-protos.h +++ b/gcc/config/pa/pa-protos.h @@ -1,4 +1,4 @@ -/* Prototypes for pa.c functions used in the md file & elsewhere. +/* Prototypes for pa.cc functions used in the md file & elsewhere. Copyright (C) 2000-2022 Free Software Foundation, Inc. This file is part of GCC. @@ -21,7 +21,7 @@ along with GCC; see the file COPYING3. If not see /* Prototype function used in various macros. */ extern rtx pa_eh_return_handler_rtx (void); -/* Define functions in pa.c and used in insn-output.c. */ +/* Define functions in pa.cc and used in insn-output.cc. */ extern const char *pa_output_and (rtx *); extern const char *pa_output_64bit_and (rtx *); @@ -67,7 +67,7 @@ extern int pa_attr_length_indirect_call (rtx_insn *); extern rtx pa_legitimize_reload_address (rtx, machine_mode, int, int, int); -/* Declare functions defined in pa.c and used in templates. */ +/* Declare functions defined in pa.cc and used in templates. */ extern rtx pa_return_addr_rtx (int, rtx); @@ -89,7 +89,7 @@ extern void pa_expand_prologue (void); extern void pa_expand_epilogue (void); extern bool pa_can_use_return_insn (void); -/* Miscellaneous functions in pa.c. */ +/* Miscellaneous functions in pa.cc. */ #ifdef TREE_CODE extern int pa_reloc_needed (tree); extern bool pa_return_in_memory (const_tree, const_tree); @@ -112,6 +112,6 @@ extern void hppa_profile_hook (int); extern const int pa_magic_milli[]; -/* Routines implemented in pa-d.c */ +/* Routines implemented in pa-d.cc */ extern void pa_d_target_versions (void); extern void pa_d_register_target_info (void); diff --git a/gcc/config/pa/pa.cc b/gcc/config/pa/pa.cc index b334518..54ab486 100644 --- a/gcc/config/pa/pa.cc +++ b/gcc/config/pa/pa.cc @@ -1,6 +1,6 @@ -/* Subroutines for insn-output.c for HPPA. +/* Subroutines for insn-output.cc for HPPA. Copyright (C) 1992-2022 Free Software Foundation, Inc. - Contributed by Tim Moore (moore@cs.utah.edu), based on sparc.c + Contributed by Tim Moore (moore@cs.utah.edu), based on sparc.cc This file is part of GCC. @@ -1026,7 +1026,7 @@ mem_shadd_or_shadd_rtx_p (rtx x) /* Try machine-dependent ways of modifying an illegitimate address to be legitimate. If we find one, return the new, valid address. - This macro is used in only one place: `memory_address' in explow.c. + This macro is used in only one place: `memory_address' in explow.cc. OLDX is the address as it was before break_out_memory_refs was called. In some cases it is useful to look at this to decide what needs to be done. @@ -10038,7 +10038,7 @@ som_output_text_section_asm_op (const char *data ATTRIBUTE_UNUSED) function has been completed. So, we are changing to the text section to output debugging information. Thus, we need to forget that we are in the text section so that - varasm.c will call us when text_section is selected again. */ + varasm.cc will call us when text_section is selected again. */ gcc_assert (!cfun || !cfun->machine || cfun->machine->in_nsubspa == 2); in_section = NULL; diff --git a/gcc/config/pa/pa.h b/gcc/config/pa/pa.h index 26a2d43..92d3d18 100644 --- a/gcc/config/pa/pa.h +++ b/gcc/config/pa/pa.h @@ -142,7 +142,7 @@ extern unsigned long total_code_bytes; /* This used to be zero (no max length), but big enums and such can cause huge strings which killed gas. - We also have to avoid lossage in dbxout.c -- it does not compute the + We also have to avoid lossage in dbxout.cc -- it does not compute the string size accurately, so we are real conservative here. */ #undef DBX_CONTIN_LENGTH #define DBX_CONTIN_LENGTH 3000 @@ -680,7 +680,7 @@ struct hppa_args {int words, nargs_prototype, incoming, indirect; }; /* The profile counter if emitted must come before the prologue. */ #define PROFILE_BEFORE_PROLOGUE 1 -/* We never want final.c to emit profile counters. When profile +/* We never want final.cc to emit profile counters. When profile counters are required, we have to defer emitting them to the end of the current file. */ #define NO_PROFILE_COUNTERS 1 @@ -730,7 +730,7 @@ extern int may_call_alloca; They give nonzero only if X is a hard reg of the suitable class or a pseudo reg currently allocated to a suitable hard reg. Since they use reg_renumber, they are safe only once reg_renumber - has been allocated, which happens in reginfo.c during register + has been allocated, which happens in reginfo.cc during register allocation. */ #define REGNO_OK_FOR_INDEX_P(X) \ @@ -919,7 +919,7 @@ extern int may_call_alloca; /* Try a machine-dependent way of reloading an illegitimate address operand. If we find one, push the reload and jump to WIN. This - macro is used in only one place: `find_reloads_address' in reload.c. */ + macro is used in only one place: `find_reloads_address' in reload.cc. */ #define LEGITIMIZE_RELOAD_ADDRESS(AD, MODE, OPNUM, TYPE, IND_L, WIN) \ do { \ diff --git a/gcc/config/pa/pa.md b/gcc/config/pa/pa.md index aacb403..76ae35d 100644 --- a/gcc/config/pa/pa.md +++ b/gcc/config/pa/pa.md @@ -3261,7 +3261,7 @@ ;; If the count is run-time determined, the register with the byte count ;; is clobbered by the copying code, and therefore it is forced to operand 2. ;; -;; We used to clobber operands 0 and 1. However, a change to regrename.c +;; We used to clobber operands 0 and 1. However, a change to regrename.cc ;; broke this semantic for pseudo registers. We can't use match_scratch ;; as this requires two registers in the class R1_REGS when the MEMs for ;; operands 0 and 1 are both equivalent to symbolic MEMs. Thus, we are @@ -3449,7 +3449,7 @@ ;; If the count is run-time determined, the register with the byte count ;; is clobbered by the copying code, and therefore it is forced to operand 2. ;; -;; We used to clobber operands 0 and 1. However, a change to regrename.c +;; We used to clobber operands 0 and 1. However, a change to regrename.cc ;; broke this semantic for pseudo registers. We can't use match_scratch ;; as this requires two registers in the class R1_REGS when the MEMs for ;; operands 0 and 1 are both equivalent to symbolic MEMs. Thus, we are @@ -6663,7 +6663,7 @@ DONE; } } - /* Fallback to using optabs.c's expand_doubleword_shift. */ + /* Fallback to using optabs.cc's expand_doubleword_shift. */ FAIL; } if (GET_CODE (operands[2]) != CONST_INT) @@ -6713,7 +6713,7 @@ DONE; } } - /* Fallback to using optabs.c's expand_doubleword_shift. */ + /* Fallback to using optabs.cc's expand_doubleword_shift. */ FAIL; }) diff --git a/gcc/config/pa/som.h b/gcc/config/pa/som.h index 586326c..d2510e9 100644 --- a/gcc/config/pa/som.h +++ b/gcc/config/pa/som.h @@ -17,7 +17,7 @@ You should have received a copy of the GNU General Public License along with GCC; see the file COPYING3. If not see . */ -/* So we can conditionalize small amounts of code in pa.c or pa.md. */ +/* So we can conditionalize small amounts of code in pa.cc or pa.md. */ #undef TARGET_SOM #define TARGET_SOM 1 diff --git a/gcc/config/pa/t-pa b/gcc/config/pa/t-pa index fbd05d2..2428280 100644 --- a/gcc/config/pa/t-pa +++ b/gcc/config/pa/t-pa @@ -1,4 +1,4 @@ -pa-d.o: $(srcdir)/config/pa/pa-d.c +pa-d.o: $(srcdir)/config/pa/pa-d.cc $(COMPILE) $< $(POSTCOMPILE) diff --git a/gcc/config/pdp11/pdp11.cc b/gcc/config/pdp11/pdp11.cc index 63f4642..f7482df 100644 --- a/gcc/config/pdp11/pdp11.cc +++ b/gcc/config/pdp11/pdp11.cc @@ -66,7 +66,7 @@ static void decode_pdp11_d (const struct real_format *, REAL_VALUE_TYPE *, const long *); /* These two are taken from the corresponding vax descriptors - in real.c, changing only the encode/decode routine pointers. */ + in real.cc, changing only the encode/decode routine pointers. */ const struct real_format pdp11_f_format = { encode_pdp11_f, diff --git a/gcc/config/pdp11/pdp11.h b/gcc/config/pdp11/pdp11.h index 22bede6..b7d66c3 100644 --- a/gcc/config/pdp11/pdp11.h +++ b/gcc/config/pdp11/pdp11.h @@ -416,7 +416,7 @@ extern int current_first_parm_offset; They give nonzero only if REGNO is a hard reg of the suitable class or a pseudo reg currently allocated to a suitable hard reg. Since they use reg_renumber, they are safe only once reg_renumber - has been allocated, which happens in reginfo.c during register + has been allocated, which happens in reginfo.cc during register allocation. */ #define REGNO_OK_FOR_BASE_P(REGNO) \ diff --git a/gcc/config/pdp11/pdp11.md b/gcc/config/pdp11/pdp11.md index d9c769f..a46efc1 100644 --- a/gcc/config/pdp11/pdp11.md +++ b/gcc/config/pdp11/pdp11.md @@ -2154,7 +2154,7 @@ ;; Note that there is no corresponding CC setter pattern. ;; The reason is that it won't be generated, because -;; compare-elim.c only does the transformation on input +;; compare-elim.cc only does the transformation on input ;; insns that have a two-element PARALLEL, as opposed to ;; the three-element one we have here. (define_insn "divmodhi4_nocc" diff --git a/gcc/config/pdp11/t-pdp11 b/gcc/config/pdp11/t-pdp11 index 8e8e24d..25cfbb5 100644 --- a/gcc/config/pdp11/t-pdp11 +++ b/gcc/config/pdp11/t-pdp11 @@ -22,7 +22,7 @@ MULTILIB_OPTIONS = msoft-float LIBGCC2_CFLAGS = -Os CRTSTUFF_T_CFLAGS = -Os -# Because the pdp11 POINTER_SIZE is only 16, in dwarf2out.c, +# Because the pdp11 POINTER_SIZE is only 16, in dwarf2out.cc, # DWARF_ARANGES_PAD_SIZE is 0, thus a loop in output_aranges that checks # (i < (unsigned) DWARF_ARANGES_PAD_SIZE) elicits a warning that the # comparison is always false. diff --git a/gcc/config/pru/pru.md b/gcc/config/pru/pru.md index a61255b..68dcab2 100644 --- a/gcc/config/pru/pru.md +++ b/gcc/config/pru/pru.md @@ -432,7 +432,7 @@ ;; We define it solely to allow combine to choose SImode ;; for word mode when trying to match our cbranch_qbbx_* insn. ;; -;; Check how combine.c:make_extraction() uses +;; Check how combine.cc:make_extraction() uses ;; get_best_reg_extraction_insn() to select the op size. (define_insn "extzv" [(set (match_operand:QISI 0 "register_operand" "=r") diff --git a/gcc/config/pru/t-pru b/gcc/config/pru/t-pru index a635b91..86b1d7a 100644 --- a/gcc/config/pru/t-pru +++ b/gcc/config/pru/t-pru @@ -22,10 +22,10 @@ # Unfortunately mabi=ti is not feature-complete enough to build newlib. # Hence we cannot present mabi=gnu/ti as a multilib option. -pru-pragma.o: $(srcdir)/config/pru/pru-pragma.c $(RTL_H) $(TREE_H) \ +pru-pragma.o: $(srcdir)/config/pru/pru-pragma.cc $(RTL_H) $(TREE_H) \ $(CONFIG_H) $(TM_H) $(srcdir)/config/pru/pru-protos.h $(COMPILER) -c $(ALL_COMPILERFLAGS) $(ALL_CPPFLAGS) $(INCLUDES) $< -pru-passes.o: $(srcdir)/config/pru/pru-passes.c $(RTL_H) $(TREE_H) \ +pru-passes.o: $(srcdir)/config/pru/pru-passes.cc $(RTL_H) $(TREE_H) \ $(CONFIG_H) $(TM_H) $(srcdir)/config/pru/pru-protos.h $(COMPILER) -c $(ALL_COMPILERFLAGS) $(ALL_CPPFLAGS) $(INCLUDES) $< diff --git a/gcc/config/riscv/riscv-protos.h b/gcc/config/riscv/riscv-protos.h index 6bca84c..20c2381 100644 --- a/gcc/config/riscv/riscv-protos.h +++ b/gcc/config/riscv/riscv-protos.h @@ -35,7 +35,7 @@ enum riscv_symbol_type { }; #define NUM_SYMBOL_TYPES (SYMBOL_TLS_GD + 1) -/* Routines implemented in riscv.c. */ +/* Routines implemented in riscv.cc. */ extern enum riscv_symbol_type riscv_classify_symbolic_expression (rtx); extern bool riscv_symbolic_constant_p (rtx, enum riscv_symbol_type *); extern int riscv_regno_mode_ok_for_base_p (int, machine_mode, bool); @@ -75,20 +75,20 @@ extern bool riscv_store_data_bypass_p (rtx_insn *, rtx_insn *); extern rtx riscv_gen_gpr_save_insn (struct riscv_frame_info *); extern bool riscv_gpr_save_operation_p (rtx); -/* Routines implemented in riscv-c.c. */ +/* Routines implemented in riscv-c.cc. */ void riscv_cpu_cpp_builtins (cpp_reader *); -/* Routines implemented in riscv-d.c */ +/* Routines implemented in riscv-d.cc */ extern void riscv_d_target_versions (void); extern void riscv_d_register_target_info (void); -/* Routines implemented in riscv-builtins.c. */ +/* Routines implemented in riscv-builtins.cc. */ extern void riscv_atomic_assign_expand_fenv (tree *, tree *, tree *); extern rtx riscv_expand_builtin (tree, rtx, rtx, machine_mode, int); extern tree riscv_builtin_decl (unsigned int, bool); extern void riscv_init_builtins (void); -/* Routines implemented in riscv-common.c. */ +/* Routines implemented in riscv-common.cc. */ extern std::string riscv_arch_str (bool version_p = true); extern bool riscv_hard_regno_rename_ok (unsigned, unsigned); diff --git a/gcc/config/riscv/riscv.cc b/gcc/config/riscv/riscv.cc index d9dadaa..7c80678 100644 --- a/gcc/config/riscv/riscv.cc +++ b/gcc/config/riscv/riscv.cc @@ -4933,7 +4933,7 @@ riscv_output_mi_thunk (FILE *file, tree thunk_fndecl ATTRIBUTE_UNUSED, SIBLING_CALL_P (insn) = 1; /* Run just enough of rest_of_compilation. This sequence was - "borrowed" from alpha.c. */ + "borrowed" from alpha.cc. */ insn = get_insns (); split_all_insns_noflow (); shorten_branches (insn); diff --git a/gcc/config/riscv/riscv.h b/gcc/config/riscv/riscv.h index 7c0473c..6956684 100644 --- a/gcc/config/riscv/riscv.h +++ b/gcc/config/riscv/riscv.h @@ -147,7 +147,7 @@ ASM_MISA_SPEC #define MIN_UNITS_PER_WORD 4 #endif -/* Allows SImode op in builtin overflow pattern, see internal-fn.c. */ +/* Allows SImode op in builtin overflow pattern, see internal-fn.cc. */ #undef TARGET_MIN_ARITHMETIC_PRECISION #define TARGET_MIN_ARITHMETIC_PRECISION riscv_min_arithmetic_precision @@ -996,7 +996,7 @@ extern unsigned riscv_stack_boundary; offset (an unsigned 5-bit value scaled by 4). */ #define CSW_MAX_OFFSET (((4LL << C_S_BITS) - 1) & ~3) -/* Called from RISCV_REORG, this is defined in riscv-sr.c. */ +/* Called from RISCV_REORG, this is defined in riscv-sr.cc. */ extern void riscv_remove_unneeded_save_restore_calls (void); diff --git a/gcc/config/riscv/t-riscv b/gcc/config/riscv/t-riscv index 1215ea8..096d70e 100644 --- a/gcc/config/riscv/t-riscv +++ b/gcc/config/riscv/t-riscv @@ -1,25 +1,25 @@ -riscv-builtins.o: $(srcdir)/config/riscv/riscv-builtins.c $(CONFIG_H) \ +riscv-builtins.o: $(srcdir)/config/riscv/riscv-builtins.cc $(CONFIG_H) \ $(SYSTEM_H) coretypes.h $(TM_H) $(RTL_H) $(TREE_H) $(RECOG_H) langhooks.h \ $(DIAGNOSTIC_CORE_H) $(OPTABS_H) $(srcdir)/config/riscv/riscv-ftypes.def \ $(srcdir)/config/riscv/riscv-modes.def $(COMPILER) -c $(ALL_COMPILERFLAGS) $(ALL_CPPFLAGS) $(INCLUDES) \ - $(srcdir)/config/riscv/riscv-builtins.c + $(srcdir)/config/riscv/riscv-builtins.cc -riscv-sr.o: $(srcdir)/config/riscv/riscv-sr.c $(CONFIG_H) \ +riscv-sr.o: $(srcdir)/config/riscv/riscv-sr.cc $(CONFIG_H) \ $(SYSTEM_H) $(COMPILER) -c $(ALL_COMPILERFLAGS) $(ALL_CPPFLAGS) $(INCLUDES) \ - $(srcdir)/config/riscv/riscv-sr.c + $(srcdir)/config/riscv/riscv-sr.cc -riscv-c.o: $(srcdir)/config/riscv/riscv-c.c $(CONFIG_H) $(SYSTEM_H) \ +riscv-c.o: $(srcdir)/config/riscv/riscv-c.cc $(CONFIG_H) $(SYSTEM_H) \ coretypes.h $(TM_H) $(TREE_H) output.h $(C_COMMON_H) $(TARGET_H) $(COMPILER) -c $(ALL_COMPILERFLAGS) $(ALL_CPPFLAGS) $(INCLUDES) \ - $(srcdir)/config/riscv/riscv-c.c + $(srcdir)/config/riscv/riscv-c.cc -riscv-d.o: $(srcdir)/config/riscv/riscv-d.c +riscv-d.o: $(srcdir)/config/riscv/riscv-d.cc $(COMPILE) $< $(POSTCOMPILE) -riscv-shorten-memrefs.o: $(srcdir)/config/riscv/riscv-shorten-memrefs.c +riscv-shorten-memrefs.o: $(srcdir)/config/riscv/riscv-shorten-memrefs.cc $(COMPILE) $< $(POSTCOMPILE) diff --git a/gcc/config/rl78/rl78.cc b/gcc/config/rl78/rl78.cc index a2bd788..b3727c0 100644 --- a/gcc/config/rl78/rl78.cc +++ b/gcc/config/rl78/rl78.cc @@ -4778,7 +4778,7 @@ rl78_asm_ctor_dtor (rtx symbol, int priority, bool is_ctor) if (priority != DEFAULT_INIT_PRIORITY) { /* This section of the function is based upon code copied - from: gcc/varasm.c:get_cdtor_priority_section(). */ + from: gcc/varasm.cc:get_cdtor_priority_section(). */ char buf[18]; sprintf (buf, "%s.%.5u", is_ctor ? ".ctors" : ".dtors", diff --git a/gcc/config/rl78/t-rl78 b/gcc/config/rl78/t-rl78 index cadd632..cd2a5084 100644 --- a/gcc/config/rl78/t-rl78 +++ b/gcc/config/rl78/t-rl78 @@ -18,7 +18,7 @@ # License along with GCC; see the file COPYING3. If not see # . -rl78-c.o: $(srcdir)/config/rl78/rl78-c.c $(RTL_H) $(TREE_H) $(CONFIG_H) $(TM_H) +rl78-c.o: $(srcdir)/config/rl78/rl78-c.cc $(RTL_H) $(TREE_H) $(CONFIG_H) $(TM_H) $(COMPILER) -c $(ALL_COMPILERFLAGS) $(ALL_CPPFLAGS) $(INCLUDES) $< # Enable multilibs: diff --git a/gcc/config/rs6000/aix.h b/gcc/config/rs6000/aix.h index 954c98e..ad3238b 100644 --- a/gcc/config/rs6000/aix.h +++ b/gcc/config/rs6000/aix.h @@ -65,10 +65,10 @@ The default value for this macro is `STACK_POINTER_OFFSET' plus the length of the outgoing arguments. The default is correct for most - machines. See `function.c' for details. + machines. See `function.cc' for details. This value must be a multiple of STACK_BOUNDARY (hard coded in - `emit-rtl.c'). */ + `emit-rtl.cc'). */ #undef STACK_DYNAMIC_OFFSET #define STACK_DYNAMIC_OFFSET(FUNDECL) \ RS6000_ALIGN (crtl->outgoing_args_size.to_constant () \ diff --git a/gcc/config/rs6000/aix71.h b/gcc/config/rs6000/aix71.h index afc506c..57e07bc 100644 --- a/gcc/config/rs6000/aix71.h +++ b/gcc/config/rs6000/aix71.h @@ -73,7 +73,7 @@ do { \ #define ASM_SPEC_COMMON "-u %(asm_cpu)" /* Common ASM definitions used by ASM_SPEC amongst the various targets for - handling -mcpu=xxx switches. There is a parallel list in driver-rs6000.c to + handling -mcpu=xxx switches. There is a parallel list in driver-rs6000.cc to provide the default assembler options if the user uses -mcpu=native, so if you make changes here, make them there also. */ #undef ASM_CPU_SPEC diff --git a/gcc/config/rs6000/aix72.h b/gcc/config/rs6000/aix72.h index 2a92048..ca73acb 100644 --- a/gcc/config/rs6000/aix72.h +++ b/gcc/config/rs6000/aix72.h @@ -73,7 +73,7 @@ do { \ #define ASM_SPEC_COMMON "-u %(asm_cpu)" /* Common ASM definitions used by ASM_SPEC amongst the various targets for - handling -mcpu=xxx switches. There is a parallel list in driver-rs6000.c to + handling -mcpu=xxx switches. There is a parallel list in driver-rs6000.cc to provide the default assembler options if the user uses -mcpu=native, so if you make changes here, make them there also. */ #undef ASM_CPU_SPEC diff --git a/gcc/config/rs6000/aix73.h b/gcc/config/rs6000/aix73.h index 2bc42ec..8baa27e 100644 --- a/gcc/config/rs6000/aix73.h +++ b/gcc/config/rs6000/aix73.h @@ -73,7 +73,7 @@ do { \ #define ASM_SPEC_COMMON "-u %(asm_cpu)" /* Common ASM definitions used by ASM_SPEC amongst the various targets for - handling -mcpu=xxx switches. There is a parallel list in driver-rs6000.c to + handling -mcpu=xxx switches. There is a parallel list in driver-rs6000.cc to provide the default assembler options if the user uses -mcpu=native, so if you make changes here, make them there also. */ #undef ASM_CPU_SPEC diff --git a/gcc/config/rs6000/darwin.h b/gcc/config/rs6000/darwin.h index 1ec9c20..b5cef42 100644 --- a/gcc/config/rs6000/darwin.h +++ b/gcc/config/rs6000/darwin.h @@ -246,10 +246,10 @@ The default value for this macro is `STACK_POINTER_OFFSET' plus the length of the outgoing arguments. The default is correct for most - machines. See `function.c' for details. + machines. See `function.cc' for details. This value must be a multiple of STACK_BOUNDARY (hard coded in - `emit-rtl.c'). */ + `emit-rtl.cc'). */ #undef STACK_DYNAMIC_OFFSET #define STACK_DYNAMIC_OFFSET(FUNDECL) \ @@ -306,7 +306,7 @@ #define GLOBAL_ASM_OP "\t.globl " #undef TARGET_ASM_GLOBALIZE_LABEL -/* This is how to output an internal label prefix. rs6000.c uses this +/* This is how to output an internal label prefix. rs6000.cc uses this when generating traceback tables. */ /* Not really used for Darwin? */ diff --git a/gcc/config/rs6000/driver-rs6000.cc b/gcc/config/rs6000/driver-rs6000.cc index 631054d..ec890e0 100644 --- a/gcc/config/rs6000/driver-rs6000.cc +++ b/gcc/config/rs6000/driver-rs6000.cc @@ -534,7 +534,7 @@ static const struct asm_name asm_names[] = { #endif }; -/* This will be called by the spec parser in gcc.c when it sees +/* This will be called by the spec parser in gcc.cc when it sees a %:local_cpu_detect(args) construct. Currently it will be called with either "arch" or "tune" as argument depending on if -march=native or -mtune=native is to be substituted. diff --git a/gcc/config/rs6000/freebsd.h b/gcc/config/rs6000/freebsd.h index c248aee..29ada25 100644 --- a/gcc/config/rs6000/freebsd.h +++ b/gcc/config/rs6000/freebsd.h @@ -51,8 +51,8 @@ /************************[ Target stuff ]***********************************/ /* Define the actual types of some ANSI-mandated types. - Needs to agree with . GCC defaults come from c-decl.c, - c-common.c, and config//.h. */ + Needs to agree with . GCC defaults come from c-decl.cc, + c-common.cc, and config//.h. */ #undef SIZE_TYPE #define SIZE_TYPE "unsigned int" diff --git a/gcc/config/rs6000/freebsd64.h b/gcc/config/rs6000/freebsd64.h index 5de20f1..a73752a 100644 --- a/gcc/config/rs6000/freebsd64.h +++ b/gcc/config/rs6000/freebsd64.h @@ -239,8 +239,8 @@ extern int dot_symbols; /************************[ Target stuff ]***********************************/ /* Define the actual types of some ANSI-mandated types. - Needs to agree with . GCC defaults come from c-decl.c, - c-common.c, and config//.h. */ + Needs to agree with . GCC defaults come from c-decl.cc, + c-common.cc, and config//.h. */ #undef SIZE_TYPE diff --git a/gcc/config/rs6000/lynx.h b/gcc/config/rs6000/lynx.h index f6e7d23..dcf5fc4 100644 --- a/gcc/config/rs6000/lynx.h +++ b/gcc/config/rs6000/lynx.h @@ -81,7 +81,7 @@ #undef SIZE_TYPE #undef ASM_OUTPUT_ALIGN -/* The file rs6000.c defines TARGET_HAVE_TLS unconditionally to the +/* The file rs6000.cc defines TARGET_HAVE_TLS unconditionally to the value of HAVE_AS_TLS. HAVE_AS_TLS is true as gas support for TLS is detected by configure. Override the definition to false. */ diff --git a/gcc/config/rs6000/rbtree.cc b/gcc/config/rs6000/rbtree.cc index 00ab9e9..065e8fc 100644 --- a/gcc/config/rs6000/rbtree.cc +++ b/gcc/config/rs6000/rbtree.cc @@ -1,4 +1,4 @@ -/* Partial red-black tree implementation for rs6000-gen-builtins.c. +/* Partial red-black tree implementation for rs6000-gen-builtins.cc. Copyright (C) 2020-2022 Free Software Foundation, Inc. Contributed by Bill Schmidt, IBM diff --git a/gcc/config/rs6000/rbtree.h b/gcc/config/rs6000/rbtree.h index 4ba88a0..9ee0f91 100644 --- a/gcc/config/rs6000/rbtree.h +++ b/gcc/config/rs6000/rbtree.h @@ -1,4 +1,4 @@ -/* Partial red-black tree implementation for rs6000-gen-builtins.c. +/* Partial red-black tree implementation for rs6000-gen-builtins.cc. Copyright (C) 2020-2022 Free Software Foundation, Inc. Contributed by Bill Schmidt, IBM diff --git a/gcc/config/rs6000/rs6000-c.cc b/gcc/config/rs6000/rs6000-c.cc index 24a081c..145421a 100644 --- a/gcc/config/rs6000/rs6000-c.cc +++ b/gcc/config/rs6000/rs6000-c.cc @@ -358,7 +358,7 @@ rs6000_target_modify_macros (bool define_p, HOST_WIDE_INT flags, flags are enabled or disabled implicitly, based on compiler defaults, configuration choices, and on the presence of certain related command-line options. Many, but not all, of these - implicit behaviors can be found in file "rs6000.c", the + implicit behaviors can be found in file "rs6000.cc", the rs6000_option_override_internal() function. In general, each of the flags may be automatically enabled in diff --git a/gcc/config/rs6000/rs6000-call.cc b/gcc/config/rs6000/rs6000-call.cc index c78b8b0..8968929 100644 --- a/gcc/config/rs6000/rs6000-call.cc +++ b/gcc/config/rs6000/rs6000-call.cc @@ -3335,7 +3335,7 @@ rs6000_invalid_builtin (enum rs6000_gen_builtins fncode) } /* Target hook for early folding of built-ins, shamelessly stolen - from ia64.c. */ + from ia64.cc. */ tree rs6000_fold_builtin (tree fndecl ATTRIBUTE_UNUSED, @@ -5493,7 +5493,7 @@ rs6000_expand_builtin (tree exp, rtx target, rtx /* subtarget */, IBM extended double (KFmode) or long double is IEEE 128-bit (TFmode). It is simpler if we only define one variant of the built-in function, and switch the code when defining it, rather than defining two built- - ins and using the overload table in rs6000-c.c to switch between the + ins and using the overload table in rs6000-c.cc to switch between the two. If we don't have the proper assembler, don't do this switch because CODE_FOR_*kf* and CODE_FOR_*tf* will be CODE_FOR_nothing. */ if (FLOAT128_IEEE_P (TFmode)) @@ -6122,7 +6122,7 @@ rs6000_init_builtins (void) format is IBM extended double. For IEEE 128-bit floating point, always create the type __ieee128. If the - user used -mfloat128, rs6000-c.c will create a define from __float128 to + user used -mfloat128, rs6000-c.cc will create a define from __float128 to __ieee128. */ if (TARGET_FLOAT128_TYPE) { diff --git a/gcc/config/rs6000/rs6000-cpus.def b/gcc/config/rs6000/rs6000-cpus.def index 50719f4..325b219 100644 --- a/gcc/config/rs6000/rs6000-cpus.def +++ b/gcc/config/rs6000/rs6000-cpus.def @@ -44,7 +44,7 @@ | OPTION_MASK_VSX) /* For now, don't provide an embedded version of ISA 2.07. Do not set power8 - fusion here, instead set it in rs6000.c if we are tuning for a power8 + fusion here, instead set it in rs6000.cc if we are tuning for a power8 system. */ #define ISA_2_7_MASKS_SERVER (ISA_2_6_MASKS_SERVER \ | OPTION_MASK_P8_VECTOR \ diff --git a/gcc/config/rs6000/rs6000-gen-builtins.cc b/gcc/config/rs6000/rs6000-gen-builtins.cc index 7dd7ab3..6a0858a 100644 --- a/gcc/config/rs6000/rs6000-gen-builtins.cc +++ b/gcc/config/rs6000/rs6000-gen-builtins.cc @@ -2823,7 +2823,7 @@ write_init_ovld_table (void) } } -/* Write everything to the initialization file (rs6000-builtins.c). +/* Write everything to the initialization file (rs6000-builtins.cc). Return 1 if successful, 0 otherwise. */ static int write_init_file (void) diff --git a/gcc/config/rs6000/rs6000-internal.h b/gcc/config/rs6000/rs6000-internal.h index fa06fa7..2d1090e 100644 --- a/gcc/config/rs6000/rs6000-internal.h +++ b/gcc/config/rs6000/rs6000-internal.h @@ -78,8 +78,8 @@ extern const char *rs6000_machine; #define ALTIVEC_REG_BIT(REGNO) (0x80000000 >> ((REGNO) - FIRST_ALTIVEC_REGNO)) -/* Declare functions in rs6000-logue.c or called in rs6000.c - from rs6000-logue.c */ +/* Declare functions in rs6000-logue.cc or called in rs6000.cc + from rs6000-logue.cc */ extern int uses_TOC (void); extern bool rs6000_global_entry_point_needed_p (void); @@ -113,7 +113,7 @@ quad_address_offset_p (HOST_WIDE_INT offset) return (IN_RANGE (offset, -32768, 32767) && ((offset) & 0xf) == 0); } -/* Mach-O (Darwin) support for longcalls, emitted from rs6000-logue.c. */ +/* Mach-O (Darwin) support for longcalls, emitted from rs6000-logue.cc. */ #if TARGET_MACHO @@ -127,8 +127,8 @@ extern vec *branch_islands; #endif -/* Declare functions in rs6000-call.c or called in rs6000.c - from rs6000-call.c */ +/* Declare functions in rs6000-call.cc or called in rs6000.cc + from rs6000-call.cc */ extern int rs6000_darwin64_struct_check_p (machine_mode mode, const_tree type); extern bool rs6000_discover_homogeneous_aggregate (machine_mode mode, const_tree type, diff --git a/gcc/config/rs6000/rs6000-logue.cc b/gcc/config/rs6000/rs6000-logue.cc index 2727afb2..59fe1c8 100644 --- a/gcc/config/rs6000/rs6000-logue.cc +++ b/gcc/config/rs6000/rs6000-logue.cc @@ -1931,7 +1931,7 @@ interesting_frame_related_regno (unsigned int regno) { /* Saves apparently of r0 are actually saving LR. It doesn't make sense to substitute the regno here to test save_reg_p (LR_REGNO). - We *know* LR needs saving, and dwarf2cfi.c is able to deduce that + We *know* LR needs saving, and dwarf2cfi.cc is able to deduce that (set (mem) (r0)) is saving LR from a prior (set (r0) (lr)) marked as frame related. */ if (regno == 0) @@ -4922,7 +4922,7 @@ rs6000_emit_epilogue (enum epilogue_type epilogue_type) a REG_CFA_DEF_CFA note. This must happen on the insn that restores the frame pointer, r31. We may have already emitted a REG_CFA_DEF_CFA note, but that's OK; A duplicate is - discarded by dwarf2cfi.c/dwarf2out.c, and in any case would + discarded by dwarf2cfi.cc/dwarf2out.cc, and in any case would be harmless if emitted. */ if (frame_pointer_needed) { diff --git a/gcc/config/rs6000/rs6000-overload.def b/gcc/config/rs6000/rs6000-overload.def index 93ce650..e279153 100644 --- a/gcc/config/rs6000/rs6000-overload.def +++ b/gcc/config/rs6000/rs6000-overload.def @@ -1516,7 +1516,7 @@ VEXPTEFP ; There are no actual builtins for vec_extract. There is special handling for -; this in altivec_resolve_overloaded_builtin in rs6000-c.c, where the call +; this in altivec_resolve_overloaded_builtin in rs6000-c.cc, where the call ; is replaced by "pointer tricks." The single overload here causes ; __builtin_vec_extract to be registered with the front end so this can ; happen. @@ -1733,7 +1733,7 @@ VGNB ; There are no actual builtins for vec_insert. There is special handling for -; this in altivec_resolve_overloaded_builtin in rs6000-c.c, where the call +; this in altivec_resolve_overloaded_builtin in rs6000-c.cc, where the call ; is replaced by "pointer tricks." The single overload here causes ; __builtin_vec_insert to be registered with the front end so this can happen. [VEC_INSERT, vec_insert, __builtin_vec_insert] @@ -2480,7 +2480,7 @@ void __builtin_vec_mtvscr (vui); MTVSCR MTVSCR_VUI -; Note that the entries for VEC_MUL are currently ignored. See rs6000-c.c: +; Note that the entries for VEC_MUL are currently ignored. See rs6000-c.cc: ; altivec_resolve_overloaded_builtin, where there is special-case code for ; VEC_MUL. TODO: Is this really necessary? Investigate. Seven missing ; prototypes here...no corresponding builtins. Also added "vmulld" in P10 @@ -3017,7 +3017,7 @@ VPRTYBQ VPRTYBQ_U ; There are no actual builtins for vec_promote. There is special handling for -; this in altivec_resolve_overloaded_builtin in rs6000-c.c, where the call +; this in altivec_resolve_overloaded_builtin in rs6000-c.cc, where the call ; is replaced by a constructor. The single overload here causes ; __builtin_vec_promote to be registered with the front end so that can happen. [VEC_PROMOTE, vec_promote, __builtin_vec_promote] @@ -3587,7 +3587,7 @@ VXXSPLTI32DX_V4SF ; There are no actual builtins for vec_splats. There is special handling for -; this in altivec_resolve_overloaded_builtin in rs6000-c.c, where the call +; this in altivec_resolve_overloaded_builtin in rs6000-c.cc, where the call ; is replaced by a constructor. The single overload here causes ; __builtin_vec_splats to be registered with the front end so that can happen. [VEC_SPLATS, vec_splats, __builtin_vec_splats] diff --git a/gcc/config/rs6000/rs6000-p8swap.cc b/gcc/config/rs6000/rs6000-p8swap.cc index 0517ee4..d301bc3 100644 --- a/gcc/config/rs6000/rs6000-p8swap.cc +++ b/gcc/config/rs6000/rs6000-p8swap.cc @@ -66,7 +66,7 @@ and stores may be removed. This pass uses some of the infrastructure and logical ideas from - the "web" pass in web.c. We create maximal webs of computations + the "web" pass in web.cc. We create maximal webs of computations fitting the description above using union-find. Each such web is then optimized by removing its unnecessary xxswapdi instructions. @@ -142,7 +142,7 @@ constant pool, we can replace M with M' as above at no cost beyond adding a constant pool entry. */ -/* This is based on the union-find logic in web.c. web_entry_base is +/* This is based on the union-find logic in web.cc. web_entry_base is defined in df.h. */ class swap_web_entry : public web_entry_base { diff --git a/gcc/config/rs6000/rs6000-protos.h b/gcc/config/rs6000/rs6000-protos.h index 1d1c89c..e322ac0 100644 --- a/gcc/config/rs6000/rs6000-protos.h +++ b/gcc/config/rs6000/rs6000-protos.h @@ -21,7 +21,7 @@ #ifndef GCC_RS6000_PROTOS_H #define GCC_RS6000_PROTOS_H -/* Declare functions in rs6000.c */ +/* Declare functions in rs6000.cc */ #ifdef RTX_CODE @@ -313,7 +313,7 @@ extern void rs6000_asm_output_dwarf_datarel (FILE *file, int size, const char *label); extern long rs6000_const_f32_to_i32 (rtx operand); -/* Declare functions in rs6000-c.c */ +/* Declare functions in rs6000-c.cc */ extern void rs6000_pragma_longcall (struct cpp_reader *); extern void rs6000_cpu_cpp_builtins (struct cpp_reader *); @@ -325,7 +325,7 @@ extern void rs6000_target_modify_macros (bool, HOST_WIDE_INT, HOST_WIDE_INT); extern void (*rs6000_target_modify_macros_ptr) (bool, HOST_WIDE_INT, HOST_WIDE_INT); -/* Declare functions in rs6000-d.c */ +/* Declare functions in rs6000-d.cc */ extern void rs6000_d_target_versions (void); extern void rs6000_d_register_target_info (void); diff --git a/gcc/config/rs6000/rs6000.cc b/gcc/config/rs6000/rs6000.cc index 7759f75..7a4ef5e 100644 --- a/gcc/config/rs6000/rs6000.cc +++ b/gcc/config/rs6000/rs6000.cc @@ -293,9 +293,9 @@ const char *tcb_verification_symbol = "__parse_hwcap_and_convert_at_platform"; /* True if we have expanded a CPU builtin. */ bool cpu_builtin_p = false; -/* Pointer to function (in rs6000-c.c) that can define or undefine target +/* Pointer to function (in rs6000-c.cc) that can define or undefine target macros that have changed. Languages that don't support the preprocessor - don't link in rs6000-c.c, so we can't call it directly. */ + don't link in rs6000-c.cc, so we can't call it directly. */ void (*rs6000_target_modify_macros_ptr) (bool, HOST_WIDE_INT, HOST_WIDE_INT); /* Simplfy register classes into simpler classifications. We assume @@ -9080,7 +9080,7 @@ legitimate_lo_sum_address_p (machine_mode mode, rtx x, int strict) /* Try machine-dependent ways of modifying an illegitimate address to be legitimate. If we find one, return the new, valid address. - This is used from only one place: `memory_address' in explow.c. + This is used from only one place: `memory_address' in explow.cc. OLDX is the address as it was before break_out_memory_refs was called. In some cases it is useful to look at this to decide what @@ -9265,7 +9265,7 @@ rs6000_debug_legitimize_address (rtx x, rtx oldx, machine_mode mode) return ret; } -/* This is called from dwarf2out.c via TARGET_ASM_OUTPUT_DWARF_DTPREL. +/* This is called from dwarf2out.cc via TARGET_ASM_OUTPUT_DWARF_DTPREL. We need to emit DTP-relative relocations. */ static void rs6000_output_dwarf_dtprel (FILE *, int, rtx) ATTRIBUTE_UNUSED; @@ -10004,7 +10004,7 @@ rs6000_mode_dependent_address (const_rtx addr) all bytes have the same high part address. */ return !legitimate_constant_pool_address_p (addr, QImode, false); - /* Auto-increment cases are now treated generically in recog.c. */ + /* Auto-increment cases are now treated generically in recog.cc. */ case PRE_MODIFY: return TARGET_UPDATE; @@ -18344,12 +18344,12 @@ rs6000_adjust_priority (rtx_insn *insn ATTRIBUTE_UNUSED, int priority) dispatch slot. */ if (rs6000_sched_restricted_insns_priority == 1) /* Attach highest priority to insn. This means that in - haifa-sched.c:ready_sort(), dispatch-slot restriction considerations + haifa-sched.cc:ready_sort(), dispatch-slot restriction considerations precede 'priority' (critical path) considerations. */ return current_sched_info->sched_max_insns_priority; else if (rs6000_sched_restricted_insns_priority == 2) /* Increase priority of insn by a minimal amount. This means that in - haifa-sched.c:ready_sort(), only 'priority' (critical path) + haifa-sched.cc:ready_sort(), only 'priority' (critical path) considerations precede dispatch-slot restriction considerations. */ return (priority + 1); } @@ -23989,7 +23989,7 @@ rs6000_c_mode_for_suffix (char suffix) /* At the moment, we are not defining a suffix for IBM extended double. If/when the default for -mabi=ieeelongdouble is changed, and we want to support __ibm128 constants in legacy library code, we may need to - re-evalaute this decision. Currently, c-lex.c only supports 'w' and + re-evalaute this decision. Currently, c-lex.cc only supports 'w' and 'q' as machine dependent suffixes. The x86_64 port uses 'w' for __float80 constants. */ } diff --git a/gcc/config/rs6000/rs6000.h b/gcc/config/rs6000/rs6000.h index a02dbbd..5fdb8f2 100644 --- a/gcc/config/rs6000/rs6000.h +++ b/gcc/config/rs6000/rs6000.h @@ -98,7 +98,7 @@ #endif /* Common ASM definitions used by ASM_SPEC among the various targets for - handling -mcpu=xxx switches. There is a parallel list in driver-rs6000.c to + handling -mcpu=xxx switches. There is a parallel list in driver-rs6000.cc to provide the default assembler options if the user uses -mcpu=native, so if you make changes here, make them also there. PR63177: Do not pass -mpower8 to the assembler if -mpower9-vector was also used. */ @@ -195,9 +195,9 @@ ASM_OPT_ANY /* -mcpu=native handling only makes sense with compiler running on an PowerPC chip. If changing this condition, also change - the condition in driver-rs6000.c. */ + the condition in driver-rs6000.cc. */ #if defined(__powerpc__) || defined(__POWERPC__) || defined(_AIX) -/* In driver-rs6000.c. */ +/* In driver-rs6000.cc. */ extern const char *host_detect_local_cpu (int argc, const char **argv); #define EXTRA_SPEC_FUNCTIONS \ { "local_cpu_detect", host_detect_local_cpu }, @@ -753,7 +753,7 @@ extern unsigned char rs6000_recip_bits[]; machine. If you don't define this, the default is two words. */ #define LONG_DOUBLE_TYPE_SIZE rs6000_long_double_type_size -/* Work around rs6000_long_double_type_size dependency in ada/targtyps.c. */ +/* Work around rs6000_long_double_type_size dependency in ada/targtyps.cc. */ #define WIDEST_HARDWARE_FP_SIZE 64 /* Width in bits of a pointer. @@ -1358,10 +1358,10 @@ extern enum reg_class rs6000_constraints[RS6000_CONSTRAINT_MAX]; The default value for this macro is `STACK_POINTER_OFFSET' plus the length of the outgoing arguments. The default is correct for most - machines. See `function.c' for details. + machines. See `function.cc' for details. This value must be a multiple of STACK_BOUNDARY (hard coded in - `emit-rtl.c'). */ + `emit-rtl.cc'). */ #define STACK_DYNAMIC_OFFSET(FUNDECL) \ RS6000_ALIGN (crtl->outgoing_args_size.to_constant () \ + STACK_POINTER_OFFSET, \ @@ -1607,7 +1607,7 @@ typedef struct rs6000_args /* #define RETURN_ADDR_IN_PREVIOUS_FRAME */ /* Number of bytes into the frame return addresses can be found. See - rs6000_stack_info in rs6000.c for more information on how the different + rs6000_stack_info in rs6000.cc for more information on how the different abi's store the return address. */ #define RETURN_ADDRESS_OFFSET \ ((DEFAULT_ABI == ABI_V4 ? 4 : 8) << (TARGET_64BIT ? 1 : 0)) @@ -1661,7 +1661,7 @@ typedef struct rs6000_args They give nonzero only if REGNO is a hard reg of the suitable class or a pseudo reg currently allocated to a suitable hard reg. Since they use reg_renumber, they are safe only once reg_renumber - has been allocated, which happens in reginfo.c during register + has been allocated, which happens in reginfo.cc during register allocation. */ #define REGNO_OK_FOR_INDEX_P(REGNO) \ diff --git a/gcc/config/rs6000/rs6000.md b/gcc/config/rs6000/rs6000.md index 6f74075..59531b6 100644 --- a/gcc/config/rs6000/rs6000.md +++ b/gcc/config/rs6000/rs6000.md @@ -5146,7 +5146,7 @@ (set_attr "isa" "*,p8v")]) ;; This expander is here to avoid FLOAT_WORDS_BIGENDIAN tests in -;; builtins.c and optabs.c that are not correct for IBM long double +;; builtins.cc and optabs.cc that are not correct for IBM long double ;; when little-endian. (define_expand "signbit2" [(set (match_dup 2) diff --git a/gcc/config/rs6000/sysv4.h b/gcc/config/rs6000/sysv4.h index 9522a46..7e2519d 100644 --- a/gcc/config/rs6000/sysv4.h +++ b/gcc/config/rs6000/sysv4.h @@ -309,7 +309,7 @@ do { \ in bits). This macro must evaluate to a value equal to or larger than STACK_BOUNDARY. For the SYSV ABI and variants the alignment of the stack pointer - is usually controlled manually in rs6000.c. However, to maintain + is usually controlled manually in rs6000.cc. However, to maintain alignment across alloca () in all circumstances, PREFERRED_STACK_BOUNDARY needs to be set as well. This has the additional advantage of allowing a bigger maximum diff --git a/gcc/config/rs6000/t-linux b/gcc/config/rs6000/t-linux index aeb7440..4e37125 100644 --- a/gcc/config/rs6000/t-linux +++ b/gcc/config/rs6000/t-linux @@ -14,6 +14,6 @@ MULTILIB_OSDIRNAMES := $(subst -linux,le-linux,$(MULTILIB_OSDIRNAMES)) endif endif -rs6000-linux.o: $(srcdir)/config/rs6000/rs6000-linux.c +rs6000-linux.o: $(srcdir)/config/rs6000/rs6000-linux.cc $(COMPILE) $< $(POSTCOMPILE) diff --git a/gcc/config/rs6000/t-linux64 b/gcc/config/rs6000/t-linux64 index 94aebeb..47e0efd 100644 --- a/gcc/config/rs6000/t-linux64 +++ b/gcc/config/rs6000/t-linux64 @@ -31,6 +31,6 @@ MULTILIB_EXTRA_OPTS := MULTILIB_OSDIRNAMES := m64=../lib64$(call if_multiarch,:powerpc64-linux-gnu) MULTILIB_OSDIRNAMES += m32=$(if $(wildcard $(shell echo $(SYSTEM_HEADER_DIR))/../../usr/lib32),../lib32,../lib)$(call if_multiarch,:powerpc-linux-gnu) -rs6000-linux.o: $(srcdir)/config/rs6000/rs6000-linux.c +rs6000-linux.o: $(srcdir)/config/rs6000/rs6000-linux.cc $(COMPILE) $< $(POSTCOMPILE) diff --git a/gcc/config/rs6000/t-rs6000 b/gcc/config/rs6000/t-rs6000 index d08deb1..90079ce 100644 --- a/gcc/config/rs6000/t-rs6000 +++ b/gcc/config/rs6000/t-rs6000 @@ -23,28 +23,28 @@ TM_H += $(srcdir)/config/rs6000/rs6000-modes.h PASSES_EXTRA += $(srcdir)/config/rs6000/rs6000-passes.def EXTRA_GTYPE_DEPS += $(srcdir)/config/rs6000/rs6000-builtins.def -rs6000-pcrel-opt.o: $(srcdir)/config/rs6000/rs6000-pcrel-opt.c +rs6000-pcrel-opt.o: $(srcdir)/config/rs6000/rs6000-pcrel-opt.cc $(COMPILE) $< $(POSTCOMPILE) -rs6000-string.o: $(srcdir)/config/rs6000/rs6000-string.c +rs6000-string.o: $(srcdir)/config/rs6000/rs6000-string.cc $(COMPILE) $< $(POSTCOMPILE) -rs6000-p8swap.o: $(srcdir)/config/rs6000/rs6000-p8swap.c +rs6000-p8swap.o: $(srcdir)/config/rs6000/rs6000-p8swap.cc $(COMPILE) $< $(POSTCOMPILE) -rs6000-d.o: $(srcdir)/config/rs6000/rs6000-d.c +rs6000-d.o: $(srcdir)/config/rs6000/rs6000-d.cc $(COMPILE) $< $(POSTCOMPILE) -rs6000-logue.o: $(srcdir)/config/rs6000/rs6000-logue.c +rs6000-logue.o: $(srcdir)/config/rs6000/rs6000-logue.cc $(COMPILE) $< $(POSTCOMPILE) -build/rs6000-gen-builtins.o: $(srcdir)/config/rs6000/rs6000-gen-builtins.c -build/rbtree.o: $(srcdir)/config/rs6000/rbtree.c +build/rs6000-gen-builtins.o: $(srcdir)/config/rs6000/rs6000-gen-builtins.cc +build/rbtree.o: $(srcdir)/config/rs6000/rbtree.cc build/rs6000-gen-builtins$(build_exeext): build/rs6000-gen-builtins.o \ build/rbtree.o $(BUILD_LIBDEPS) @@ -53,34 +53,34 @@ build/rs6000-gen-builtins$(build_exeext): build/rs6000-gen-builtins.o \ # TODO: Whenever GNU make 4.3 is the minimum required, we should use # grouped targets on this: -# rs6000-builtins.c rs6000-builtins.h rs6000-vecdefines.h &: +# rs6000-builtins.cc rs6000-builtins.h rs6000-vecdefines.h &: # -# For now, the header files depend on rs6000-builtins.c, which avoids -# races because the .c file is closed last in rs6000-gen-builtins.c. -rs6000-builtins.c: build/rs6000-gen-builtins$(build_exeext) \ +# For now, the header files depend on rs6000-builtins.cc, which avoids +# races because the .c file is closed last in rs6000-gen-builtins.cc. +rs6000-builtins.cc: build/rs6000-gen-builtins$(build_exeext) \ $(srcdir)/config/rs6000/rs6000-builtins.def \ $(srcdir)/config/rs6000/rs6000-overload.def $(RUN_GEN) ./build/rs6000-gen-builtins$(build_exeext) \ $(srcdir)/config/rs6000/rs6000-builtins.def \ $(srcdir)/config/rs6000/rs6000-overload.def rs6000-builtins.h \ - rs6000-builtins.c rs6000-vecdefines.h + rs6000-builtins.cc rs6000-vecdefines.h -rs6000-builtins.h: rs6000-builtins.c +rs6000-builtins.h: rs6000-builtins.cc rs6000.o: rs6000-builtins.h EXTRA_HEADERS += rs6000-vecdefines.h -rs6000-vecdefines.h: rs6000-builtins.c +rs6000-vecdefines.h: rs6000-builtins.cc -rs6000-builtins.o: rs6000-builtins.c +rs6000-builtins.o: rs6000-builtins.cc $(COMPILE) $< $(POSTCOMPILE) -rs6000-call.o: $(srcdir)/config/rs6000/rs6000-call.c rs6000-builtins.h +rs6000-call.o: $(srcdir)/config/rs6000/rs6000-call.cc rs6000-builtins.h $(COMPILE) $< $(POSTCOMPILE) -rs6000-c.o: $(srcdir)/config/rs6000/rs6000-c.c rs6000-builtins.h +rs6000-c.o: $(srcdir)/config/rs6000/rs6000-c.cc rs6000-builtins.h $(COMPILE) $< $(POSTCOMPILE) diff --git a/gcc/config/rs6000/x-darwin b/gcc/config/rs6000/x-darwin index 9d92ef5..908c60e 100644 --- a/gcc/config/rs6000/x-darwin +++ b/gcc/config/rs6000/x-darwin @@ -1,3 +1,3 @@ -host-ppc-darwin.o : $(srcdir)/config/rs6000/host-darwin.c +host-ppc-darwin.o : $(srcdir)/config/rs6000/host-darwin.cc $(COMPILE) $< $(POSTCOMPILE) diff --git a/gcc/config/rs6000/x-darwin64 b/gcc/config/rs6000/x-darwin64 index 0932771..5e9655c 100644 --- a/gcc/config/rs6000/x-darwin64 +++ b/gcc/config/rs6000/x-darwin64 @@ -1,3 +1,3 @@ -host-ppc64-darwin.o : $(srcdir)/config/rs6000/host-ppc64-darwin.c +host-ppc64-darwin.o : $(srcdir)/config/rs6000/host-ppc64-darwin.cc $(COMPILE) $< $(POSTCOMPILE) diff --git a/gcc/config/rs6000/x-rs6000 b/gcc/config/rs6000/x-rs6000 index 9e31f24..afd39ce 100644 --- a/gcc/config/rs6000/x-rs6000 +++ b/gcc/config/rs6000/x-rs6000 @@ -1,3 +1,3 @@ -driver-rs6000.o : $(srcdir)/config/rs6000/driver-rs6000.c \ +driver-rs6000.o : $(srcdir)/config/rs6000/driver-rs6000.cc \ $(CONFIG_H) $(SYSTEM_H) $(TM_H) coretypes.h $(COMPILER) -c $(ALL_COMPILERFLAGS) $(ALL_CPPFLAGS) $(INCLUDES) $< diff --git a/gcc/config/rs6000/xcoff.h b/gcc/config/rs6000/xcoff.h index 7471517..cd0f99c 100644 --- a/gcc/config/rs6000/xcoff.h +++ b/gcc/config/rs6000/xcoff.h @@ -30,7 +30,7 @@ /* Define the magic numbers that we recognize as COFF. AIX 4.3 adds U803XTOCMAGIC (0757) for 64-bit objects and AIX V5 adds - U64_TOCMAGIC (0767), but collect2.c does not include files in the + U64_TOCMAGIC (0767), but collect2.cc does not include files in the correct order to conditionally define the symbolic name in this macro. The AIX linker accepts import/export files as object files, @@ -184,7 +184,7 @@ #define ASM_OUTPUT_LABELREF(FILE,NAME) \ asm_fprintf ((FILE), "%U%s", rs6000_xcoff_strip_dollar (NAME)) -/* This is how to output an internal label prefix. rs6000.c uses this +/* This is how to output an internal label prefix. rs6000.cc uses this when generating traceback tables. */ #define ASM_OUTPUT_INTERNAL_LABEL_PREFIX(FILE,PREFIX) \ diff --git a/gcc/config/rx/rx.cc b/gcc/config/rx/rx.cc index 585542c..ba82482 100644 --- a/gcc/config/rx/rx.cc +++ b/gcc/config/rx/rx.cc @@ -2671,7 +2671,7 @@ rx_expand_builtin (tree exp, } /* Place an element into a constructor or destructor section. - Like default_ctor_section_asm_out_constructor in varasm.c + Like default_ctor_section_asm_out_constructor in varasm.cc except that it uses .init_array (or .fini_array) and it handles constructor priorities. */ diff --git a/gcc/config/s390/constraints.md b/gcc/config/s390/constraints.md index 70bc9d1..4854f34 100644 --- a/gcc/config/s390/constraints.md +++ b/gcc/config/s390/constraints.md @@ -1,7 +1,7 @@ ;; Constraints definitions belonging to the gcc backend for IBM S/390. ;; Copyright (C) 2006-2022 Free Software Foundation, Inc. ;; Written by Wolfgang Gellerich, using code and information found in -;; files s390.md, s390.h, and s390.c. +;; files s390.md, s390.h, and s390.cc. ;; ;; This file is part of GCC. ;; @@ -595,11 +595,11 @@ ;; This constraint must behave like "i", in particular, the matching values ;; must never be placed into registers or memory by -;; cfgexpand.c:expand_asm_stmt. It could be straightforward to start its name -;; with a letter from genpreds.c:const_int_constraints, however it would +;; cfgexpand.cc:expand_asm_stmt. It could be straightforward to start its name +;; with a letter from genpreds.cc:const_int_constraints, however it would ;; require using (match_code "const_int"), which is infeasible. To achieve the ;; same effect, that is, setting maybe_allows_reg and maybe_allows_mem to false -;; in genpreds.c:add_constraint, we explicitly exclude reg, subreg and mem +;; in genpreds.cc:add_constraint, we explicitly exclude reg, subreg and mem ;; codes. (define_constraint "jdd" "A constant operand that fits into the data section. diff --git a/gcc/config/s390/driver-native.cc b/gcc/config/s390/driver-native.cc index 3d9fb6c..48524c4 100644 --- a/gcc/config/s390/driver-native.cc +++ b/gcc/config/s390/driver-native.cc @@ -24,7 +24,7 @@ along with GCC; see the file COPYING3. If not see #include "coretypes.h" #include "tm.h" -/* This will be called by the spec parser in gcc.c when it sees +/* This will be called by the spec parser in gcc.cc when it sees a %:local_cpu_detect(args) construct. Currently it will be called with either "arch" or "tune" as argument depending on if -march=native or -mtune=native is to be substituted. diff --git a/gcc/config/s390/htmxlintrin.h b/gcc/config/s390/htmxlintrin.h index e5ac912..51d0b55 100644 --- a/gcc/config/s390/htmxlintrin.h +++ b/gcc/config/s390/htmxlintrin.h @@ -36,7 +36,7 @@ extern "C" { /* FIXME: __TM_simple_begin and __TM_begin should be marked __always_inline__ as well but this currently produces an error since the tbegin builtins are "returns_twice" and setjmp_call_p - (calls.c) therefore identifies the functions as calling setjmp. + (calls.cc) therefore identifies the functions as calling setjmp. The tree inliner currently refuses to inline functions calling setjmp. */ diff --git a/gcc/config/s390/s390-builtins.def b/gcc/config/s390/s390-builtins.def index dd89156..c7e893b 100644 --- a/gcc/config/s390/s390-builtins.def +++ b/gcc/config/s390/s390-builtins.def @@ -412,7 +412,7 @@ B_DEF (s390_vec_splat_s32, vec_splatsv4si, 0, B_DEF (s390_vec_splat_u64, vec_splatsv2di, 0, B_VX, O1_U16, BT_FN_UV2DI_USHORT) B_DEF (s390_vec_splat_s64, vec_splatsv2di, 0, B_VX, O1_S16, BT_FN_V2DI_SHORT) -/* First two operands are swapped in s390-c.c */ +/* First two operands are swapped in s390-c.cc */ OB_DEF (s390_vec_insert, s390_vec_insert_s8, s390_vec_insert_dbl,B_VX, BT_FN_OV4SI_INT_OV4SI_INT) OB_DEF_VAR (s390_vec_insert_s8, s390_vlvgb, 0, O3_ELEM, BT_OV_V16QI_SCHAR_V16QI_INT) OB_DEF_VAR (s390_vec_insert_u8, s390_vlvgb, 0, O3_ELEM, BT_OV_UV16QI_UCHAR_UV16QI_INT) @@ -497,7 +497,7 @@ B_DEF (s390_vllezf_flt, vec_insert_and_zerov4sf,0, B_DEF (s390_vllezg, vec_insert_and_zerov2di,0, B_VX, 0, BT_FN_UV2DI_ULONGLONGCONSTPTR) B_DEF (s390_vllezg_dbl, vec_insert_and_zerov2df,0, B_INT | B_VX, 0, BT_FN_V2DF_DBLCONSTPTR) -/* The 2nd operand will by translated in s390-c.c from 64, 128, 256, ... to 0, 1, 2, ... */ +/* The 2nd operand will by translated in s390-c.cc from 64, 128, 256, ... to 0, 1, 2, ... */ OB_DEF (s390_vec_load_bndry, s390_vec_load_bndry_s8,s390_vec_load_bndry_dbl,B_VX, BT_FN_OV4SI_INTCONSTPTR_INT) OB_DEF_VAR (s390_vec_load_bndry_s8, s390_vlbb, 0, O2_U16, BT_OV_V16QI_SCHARCONSTPTR_USHORT) OB_DEF_VAR (s390_vec_load_bndry_u8, s390_vlbb, 0, O2_U16, BT_OV_UV16QI_UCHARCONSTPTR_USHORT) @@ -516,7 +516,7 @@ OB_DEF (s390_vec_load_pair, s390_vec_load_pair_s64,s390_vec_load_pai OB_DEF_VAR (s390_vec_load_pair_s64, MAX, 0, 0, BT_OV_V2DI_LONGLONG_LONGLONG) /* vlvgp */ OB_DEF_VAR (s390_vec_load_pair_u64, MAX, 0, 0, BT_OV_UV2DI_ULONGLONG_ULONGLONG) /* vlvgp */ -/* First two operands are swapped in s390-c.c */ +/* First two operands are swapped in s390-c.cc */ OB_DEF (s390_vec_load_len, s390_vec_load_len_s8,s390_vec_load_len_dbl,B_VX, BT_FN_OV4SI_INTCONSTPTR_UINT) OB_DEF_VAR (s390_vec_load_len_s8, s390_vll, 0, 0, BT_OV_V16QI_SCHARCONSTPTR_UINT) OB_DEF_VAR (s390_vec_load_len_u8, s390_vll, 0, 0, BT_OV_UV16QI_UCHARCONSTPTR_UINT) @@ -702,7 +702,7 @@ OB_DEF_VAR (s390_vec_scatter_element_dbl,s390_vsceg, 0, B_DEF (s390_vscef, vec_scatter_elementv4si,0, B_VX, O4_U2, BT_FN_VOID_UV4SI_UV4SI_UINTPTR_ULONGLONG) B_DEF (s390_vsceg, vec_scatter_elementv2di,0, B_VX, O4_U1, BT_FN_VOID_UV2DI_UV2DI_ULONGLONGPTR_ULONGLONG) -/* First two operands are swapped in s390-c.c */ +/* First two operands are swapped in s390-c.cc */ OB_DEF (s390_vec_sel, s390_vec_sel_b8_a, s390_vec_sel_dbl_b, B_VX, BT_FN_OV4SI_OV4SI_OV4SI_OV4SI) OB_DEF_VAR (s390_vec_sel_b8_a, s390_vselb, 0, 0, BT_OV_BV16QI_BV16QI_BV16QI_UV16QI) OB_DEF_VAR (s390_vec_sel_b8_b, s390_vselb, 0, 0, BT_OV_BV16QI_BV16QI_BV16QI_BV16QI) diff --git a/gcc/config/s390/s390-builtins.h b/gcc/config/s390/s390-builtins.h index 091d690..8809f0e 100644 --- a/gcc/config/s390/s390-builtins.h +++ b/gcc/config/s390/s390-builtins.h @@ -20,7 +20,7 @@ . */ /* This files contains data structure definitions which can be used by - s390-builtins.c as well as s390-c.c. Since the latter is + s390-builtins.cc as well as s390-c.cc. Since the latter is considered to be part of the front-end we have to be careful not to use any of tree and rtx like data structures. */ diff --git a/gcc/config/s390/s390-c.cc b/gcc/config/s390/s390-c.cc index 6000184..569c4a4 100644 --- a/gcc/config/s390/s390-c.cc +++ b/gcc/config/s390/s390-c.cc @@ -20,7 +20,7 @@ along with GCC; see the file COPYING3. If not see . - Based on gcc/config/rs6000/rs6000-c.c. + Based on gcc/config/rs6000/rs6000-c.cc. In GCC terms this file belongs to the frontend. It will be compiled with -DIN_GCC_FRONTEND. With that rtl.h cannot be diff --git a/gcc/config/s390/s390-opts.h b/gcc/config/s390/s390-opts.h index a374329..1ec8463 100644 --- a/gcc/config/s390/s390-opts.h +++ b/gcc/config/s390/s390-opts.h @@ -23,7 +23,7 @@ along with GCC; see the file COPYING3. If not see /* Which processor to generate code or schedule for. The `cpu' attribute defines a list that mirrors this list, so changes to s390.md must be made at the same time. The enumeration must also be kept in sync with - `processor_table' and `processor_flags_table' in s390.c (the enumeration + `processor_table' and `processor_flags_table' in s390.cc (the enumeration values are used as indices into these tables). */ enum processor_type diff --git a/gcc/config/s390/s390-protos.h b/gcc/config/s390/s390-protos.h index a9d21c3..e625159 100644 --- a/gcc/config/s390/s390-protos.h +++ b/gcc/config/s390/s390-protos.h @@ -31,13 +31,13 @@ extern int s390_float_const_zero_p (rtx value); extern bool s390_check_symref_alignment (rtx addr, HOST_WIDE_INT alignment); -/* In s390-common.c. */ +/* In s390-common.cc. */ extern bool s390_handle_option (struct gcc_options *opts ATTRIBUTE_UNUSED, struct gcc_options *opts_set ATTRIBUTE_UNUSED, const struct cl_decoded_option *decoded, location_t loc); -/* Declare functions in s390.c. */ +/* Declare functions in s390.cc. */ extern HOST_WIDE_INT s390_initial_elimination_offset (int, int); extern void s390_emit_prologue (void); @@ -168,14 +168,14 @@ extern void s390_indirect_branch_via_thunk (unsigned int regno, extern void s390_indirect_branch_via_inline_thunk (rtx execute_target); #endif /* RTX_CODE */ -/* s390-c.c routines */ +/* s390-c.cc routines */ extern void s390_cpu_cpp_builtins (struct cpp_reader *); extern void s390_register_target_pragmas (void); -/* Routines for s390-c.c */ +/* Routines for s390-c.cc */ extern bool s390_const_operand_ok (tree, int, int, tree); -/* s390-d.c routines */ +/* s390-d.cc routines */ extern void s390_d_target_versions (void); extern void s390_d_register_target_info (void); diff --git a/gcc/config/s390/s390.cc b/gcc/config/s390/s390.cc index 056002e..7fc1901 100644 --- a/gcc/config/s390/s390.cc +++ b/gcc/config/s390/s390.cc @@ -651,9 +651,9 @@ s390_init_builtins (void) tree noreturn_attr = tree_cons (get_identifier ("noreturn"), NULL, NULL); tree c_uint64_type_node; - /* The uint64_type_node from tree.c is not compatible to the C99 + /* The uint64_type_node from tree.cc is not compatible to the C99 uint64_t data type. What we want is c_uint64_type_node from - c-common.c. But since backend code is not supposed to interface + c-common.cc. But since backend code is not supposed to interface with the frontend we recreate it here. */ if (TARGET_64BIT) c_uint64_type_node = long_unsigned_type_node; @@ -4769,7 +4769,7 @@ s390_expand_plus_operand (rtx target, rtx src, } /* According to the way these invalid addresses are generated - in reload.c, it should never happen (at least on s390) that + in reload.cc, it should never happen (at least on s390) that *neither* of the PLUS components, after find_replacements was applied, is an address register. */ if (sum1 == scratch && sum2 == scratch) @@ -7509,7 +7509,7 @@ s390_expand_atomic (machine_mode mode, enum rtx_code code, NULL_RTX, 1, OPTAB_DIRECT), 1); } -/* This is called from dwarf2out.c via TARGET_ASM_OUTPUT_DWARF_DTPREL. +/* This is called from dwarf2out.cc via TARGET_ASM_OUTPUT_DWARF_DTPREL. We need to emit DTP-relative relocations. */ static void s390_output_dwarf_dtprel (FILE *, int, rtx) ATTRIBUTE_UNUSED; @@ -15812,7 +15812,7 @@ s390_valid_target_attribute_inner_p (tree args, int num_pragma_values; int i; - /* Note: attribs.c:decl_attributes prepends the values from + /* Note: attribs.cc:decl_attributes prepends the values from current_target_pragma to the list of target attributes. To determine whether we're looking at a value of the attribute or the pragma we assume that the first [list_length (current_target_pragma)] values in @@ -15933,7 +15933,7 @@ s390_valid_target_attribute_inner_p (tree args, if (cl_options[opt].cl_uinteger) { /* Unsigned integer argument. Code based on the function - decode_cmdline_option () in opts-common.c. */ + decode_cmdline_option () in opts-common.cc. */ value = integral_argument (p + opt_len); } else diff --git a/gcc/config/s390/s390.h b/gcc/config/s390/s390.h index 85733c3..5a64048 100644 --- a/gcc/config/s390/s390.h +++ b/gcc/config/s390/s390.h @@ -404,7 +404,7 @@ extern const char *s390_host_detect_local_cpu (int argc, const char **argv); #define DOUBLE_TYPE_SIZE 64 #define LONG_DOUBLE_TYPE_SIZE (TARGET_LONG_DOUBLE_128 ? 128 : 64) -/* Work around target_flags dependency in ada/targtyps.c. */ +/* Work around target_flags dependency in ada/targtyps.cc. */ #define WIDEST_HARDWARE_FP_SIZE 64 /* We use "unsigned char" as default. */ @@ -817,7 +817,7 @@ CUMULATIVE_ARGS; /* Try a machine-dependent way of reloading an illegitimate address operand. If we find one, push the reload and jump to WIN. This - macro is used in only one place: `find_reloads_address' in reload.c. */ + macro is used in only one place: `find_reloads_address' in reload.cc. */ #define LEGITIMIZE_RELOAD_ADDRESS(AD, MODE, OPNUM, TYPE, IND, WIN) \ do { \ rtx new_rtx = legitimize_reload_address ((AD), (MODE), \ @@ -829,7 +829,7 @@ CUMULATIVE_ARGS; } \ } while (0) -/* Helper macro for s390.c and s390.md to check for symbolic constants. */ +/* Helper macro for s390.cc and s390.md to check for symbolic constants. */ #define SYMBOLIC_CONST(X) \ (GET_CODE (X) == SYMBOL_REF \ || GET_CODE (X) == LABEL_REF \ @@ -1213,7 +1213,7 @@ struct GTY(()) machine_function #define TARGET_INDIRECT_BRANCH_TABLE s390_indirect_branch_table #ifdef GENERATOR_FILE -/* gencondmd.c is built before insn-flags.h. Use an arbitrary opaque value +/* gencondmd.cc is built before insn-flags.h. Use an arbitrary opaque value that cannot be optimized away by gen_insn. */ #define HAVE_TF(icode) TARGET_HARD_FLOAT #else diff --git a/gcc/config/s390/s390.md b/gcc/config/s390/s390.md index 4d25666..e3ccbac 100644 --- a/gcc/config/s390/s390.md +++ b/gcc/config/s390/s390.md @@ -1949,7 +1949,7 @@ ; Splitters for loading TLS pointer from UNSPEC_GET_TP. ; UNSPEC_GET_TP is used instead of %a0:P, since the latter is a hard register, -; and those are not handled by Partial Redundancy Elimination (gcse.c), which +; and those are not handled by Partial Redundancy Elimination (gcse.cc), which ; results in generation of redundant thread pointer loads. (define_insn_and_split "*get_tp_31" @@ -11031,7 +11031,7 @@ [(set_attr "op_type" "RSY") (set_attr "type" "sem")]) -;; For SImode and larger, the optabs.c code will do just fine in +;; For SImode and larger, the optabs.cc code will do just fine in ;; expanding a compare-and-swap loop. For QI/HImode, we can do ;; better by expanding our own loop. @@ -11978,7 +11978,7 @@ (clobber (reg:TI 30)) (clobber (reg:TI 52)) (clobber (reg:TI 31)) (clobber (reg:TI 53))] ; CONST_OK_FOR_CONSTRAINT_P does not work with D constraint since D is -; not supposed to be used for immediates (see genpreds.c). +; not supposed to be used for immediates (see genpreds.cc). "TARGET_VX && INTVAL (operands[0]) >= 0 && INTVAL (operands[0]) <= 0xffff" "tbegin\t%1,%x0" [(set_attr "op_type" "SIL")]) @@ -12006,7 +12006,7 @@ (clobber (reg:DF 30)) (clobber (reg:DF 31))] ; CONST_OK_FOR_CONSTRAINT_P does not work with D constraint since D is -; not supposed to be used for immediates (see genpreds.c). +; not supposed to be used for immediates (see genpreds.cc). "TARGET_HTM && INTVAL (operands[0]) >= 0 && INTVAL (operands[0]) <= 0xffff" "tbegin\t%1,%x0" [(set_attr "op_type" "SIL")]) diff --git a/gcc/config/s390/t-s390 b/gcc/config/s390/t-s390 index 07896eb..767df10 100644 --- a/gcc/config/s390/t-s390 +++ b/gcc/config/s390/t-s390 @@ -20,13 +20,13 @@ TM_H += $(srcdir)/config/s390/s390-builtins.def TM_H += $(srcdir)/config/s390/s390-builtin-types.def PASSES_EXTRA += $(srcdir)/config/s390/s390-passes.def -s390-c.o: $(srcdir)/config/s390/s390-c.c \ +s390-c.o: $(srcdir)/config/s390/s390-c.cc \ $(srcdir)/config/s390/s390-protos.h $(CONFIG_H) $(SYSTEM_H) coretypes.h \ $(TM_H) $(TREE_H) $(TM_P_H) $(FLAGS_H) $(C_COMMON_H) $(GGC_H) \ $(TARGET_H) $(TARGET_DEF_H) $(CPPLIB_H) $(C_PRAGMA_H) $(COMPILER) -c $(ALL_COMPILERFLAGS) $(ALL_CPPFLAGS) $(INCLUDES) \ - $(srcdir)/config/s390/s390-c.c + $(srcdir)/config/s390/s390-c.cc -s390-d.o: $(srcdir)/config/s390/s390-d.c +s390-d.o: $(srcdir)/config/s390/s390-d.cc $(COMPILE) $< $(POSTCOMPILE) diff --git a/gcc/config/s390/vx-builtins.md b/gcc/config/s390/vx-builtins.md index caee417..d513079 100644 --- a/gcc/config/s390/vx-builtins.md +++ b/gcc/config/s390/vx-builtins.md @@ -514,7 +514,7 @@ ; implemented as: op0 = (op1 & op3) | (op2 & ~op3) ; Used to expand the vec_sel builtin. Operands op1 and op2 already got -; swapped in s390-c.c when we get here. +; swapped in s390-c.cc when we get here. (define_insn "vsel" [(set (match_operand:V_HW 0 "register_operand" "=v") diff --git a/gcc/config/s390/x-native b/gcc/config/s390/x-native index b33c8b6..d4c950d 100644 --- a/gcc/config/s390/x-native +++ b/gcc/config/s390/x-native @@ -1,3 +1,3 @@ -driver-native.o : $(srcdir)/config/s390/driver-native.c \ +driver-native.o : $(srcdir)/config/s390/driver-native.cc \ $(CONFIG_H) $(SYSTEM_H) $(COMPILER) -c $(ALL_COMPILERFLAGS) $(ALL_CPPFLAGS) $(INCLUDES) $< diff --git a/gcc/config/sh/divtab-sh4-300.cc b/gcc/config/sh/divtab-sh4-300.cc index 4026fb1..d9af737 100644 --- a/gcc/config/sh/divtab-sh4-300.cc +++ b/gcc/config/sh/divtab-sh4-300.cc @@ -33,7 +33,7 @@ main () int i, j; double q, r, err, max_err = 0, max_s_err = 0; - puts("/* This table has been generated by divtab-sh4.c. */"); + puts("/* This table has been generated by divtab-sh4.cc. */"); puts ("\t.balign 4"); for (i = -128; i < 128; i++) { diff --git a/gcc/config/sh/divtab-sh4.cc b/gcc/config/sh/divtab-sh4.cc index 0700fae..2c6d1f2 100644 --- a/gcc/config/sh/divtab-sh4.cc +++ b/gcc/config/sh/divtab-sh4.cc @@ -32,7 +32,7 @@ main () int i, j; double q, r, err, max_err = 0, max_s_err = 0; - puts("/* This table has been generated by divtab-sh4.c. */"); + puts("/* This table has been generated by divtab-sh4.cc. */"); puts ("\t.balign 4"); puts ("LOCAL(div_table_clz):"); /* output some dummy number for 1/0. */ diff --git a/gcc/config/sh/divtab.cc b/gcc/config/sh/divtab.cc index 10f7429..30d57f2 100644 --- a/gcc/config/sh/divtab.cc +++ b/gcc/config/sh/divtab.cc @@ -167,7 +167,7 @@ main () calc_defect (x_med, constant, factor); calc_defect (x_high, constant, factor); } - printf ("/* This table has been generated by divtab.c .\n"); + printf ("/* This table has been generated by divtab.cc .\n"); printf ("Defects for bias %d:\n", BIAS); printf (" Max defect: %e at %e\n", max_defect, max_defect_x); printf (" Min defect: %e at %e\n", min_defect, min_defect_x); diff --git a/gcc/config/sh/elf.h b/gcc/config/sh/elf.h index ffddd8d..afb3bc3 100644 --- a/gcc/config/sh/elf.h +++ b/gcc/config/sh/elf.h @@ -18,7 +18,7 @@ You should have received a copy of the GNU General Public License along with GCC; see the file COPYING3. If not see . */ -/* Let sh.c know this is ELF. */ +/* Let sh.cc know this is ELF. */ #undef TARGET_ELF #define TARGET_ELF 1 diff --git a/gcc/config/sh/sh-protos.h b/gcc/config/sh/sh-protos.h index 0fc37a9..44a4bdf 100644 --- a/gcc/config/sh/sh-protos.h +++ b/gcc/config/sh/sh-protos.h @@ -39,7 +39,7 @@ enum sh_function_kind { extern rtx sh_fsca_sf2int (void); extern rtx sh_fsca_int2sf (void); -/* Declare functions defined in sh.c and used in templates. */ +/* Declare functions defined in sh.cc and used in templates. */ extern bool sh_lra_p (void); extern const char *output_branch (int, rtx_insn *, rtx *); diff --git a/gcc/config/sh/sh.cc b/gcc/config/sh/sh.cc index ca096ad..dd8bce4 100644 --- a/gcc/config/sh/sh.cc +++ b/gcc/config/sh/sh.cc @@ -640,7 +640,7 @@ static const struct attribute_spec sh_attribute_table[] = #define SYMBOL_FLAG_FUNCVEC_FUNCTION (SYMBOL_FLAG_MACH_DEP << 0) /* The tas.b instruction sets the 7th bit in the byte, i.e. 0x80. This value - is used by optabs.c atomic op expansion code as well as in sync.md. */ + is used by optabs.cc atomic op expansion code as well as in sync.md. */ #undef TARGET_ATOMIC_TEST_AND_SET_TRUEVAL #define TARGET_ATOMIC_TEST_AND_SET_TRUEVAL 0x80 @@ -8123,7 +8123,7 @@ sh_struct_value_rtx (tree fndecl, int incoming ATTRIBUTE_UNUSED) mode like PROMOTE_MODE does. ??? PROMOTE_MODE is ignored for non-scalar types. The set of types tested here has to be kept in sync with the one in - explow.c:promote_mode. */ + explow.cc:promote_mode. */ static rtx sh_function_value (const_tree valtype, const_tree fn_decl_or_type, @@ -11823,7 +11823,7 @@ sh_remove_reg_dead_or_unused_notes (rtx_insn* i, int regno) /* Given an insn check if it contains any post/pre inc/dec mem operands and add the REG_INC notes accordingly. - FIXME: This function is very similar to lra.c (add_auto_inc_notes). + FIXME: This function is very similar to lra.cc (add_auto_inc_notes). FIXME: This function is currently used by peephole2 patterns because the peephole2 pass does not preserve REG_INC notes. If the notes are dropped the following passes will do wrong things. */ diff --git a/gcc/config/sh/sh.h b/gcc/config/sh/sh.h index a2497ab..4f209d2 100644 --- a/gcc/config/sh/sh.h +++ b/gcc/config/sh/sh.h @@ -24,8 +24,8 @@ along with GCC; see the file COPYING3. If not see #include "config/vxworks-dummy.h" -/* Unfortunately, insn-attrtab.c doesn't include insn-codes.h. We can't - include it here, because bconfig.h is also included by gencodes.c . */ +/* Unfortunately, insn-attrtab.cc doesn't include insn-codes.h. We can't + include it here, because bconfig.h is also included by gencodes.cc . */ /* ??? No longer true. */ extern int code_for_indirect_jump_scratch; @@ -433,7 +433,7 @@ extern const sh_atomic_model& selected_atomic_model (void); #define MIN_UNITS_PER_WORD 4 /* Scaling factor for Dwarf data offsets for CFI information. - The dwarf2out.c default would use -UNITS_PER_WORD. */ + The dwarf2out.cc default would use -UNITS_PER_WORD. */ #define DWARF_CIE_DATA_ALIGNMENT -4 /* Width in bits of a pointer. @@ -1284,7 +1284,7 @@ extern bool current_function_interrupt; They give nonzero only if REGNO is a hard reg of the suitable class or a pseudo reg currently allocated to a suitable hard reg. Since they use reg_renumber, they are safe only once reg_renumber - has been allocated, which happens in reginfo.c during register + has been allocated, which happens in reginfo.cc during register allocation. */ #define REGNO_OK_FOR_BASE_P(REGNO) \ (GENERAL_OR_AP_REGISTER_P (REGNO) \ diff --git a/gcc/config/sh/t-sh b/gcc/config/sh/t-sh index 37de2bb..dd5652e 100644 --- a/gcc/config/sh/t-sh +++ b/gcc/config/sh/t-sh @@ -20,10 +20,10 @@ sh-mem.o: $(srcdir)/config/sh/sh-mem.cc \ $(CONFIG_H) $(SYSTEM_H) $(TREE_H) $(TM_H) $(TM_P_H) $(COMPILER) -c $(ALL_COMPILERFLAGS) $(ALL_CPPFLAGS) $(INCLUDES) $< -sh-c.o: $(srcdir)/config/sh/sh-c.c \ +sh-c.o: $(srcdir)/config/sh/sh-c.cc \ $(CONFIG_H) $(SYSTEM_H) $(TREE_H) $(TM_H) $(TM_P_H) coretypes.h $(COMPILER) -c $(ALL_COMPILERFLAGS) $(ALL_CPPFLAGS) $(INCLUDES) \ - $(srcdir)/config/sh/sh-c.c + $(srcdir)/config/sh/sh-c.cc sh_treg_combine.o: $(srcdir)/config/sh/sh_treg_combine.cc \ $(CONFIG_H) $(SYSTEM_H) $(TREE_H) $(TM_H) $(TM_P_H) coretypes.h diff --git a/gcc/config/sol2-protos.h b/gcc/config/sol2-protos.h index b81b25b..6307e13 100644 --- a/gcc/config/sol2-protos.h +++ b/gcc/config/sol2-protos.h @@ -18,7 +18,7 @@ You should have received a copy of the GNU General Public License along with GCC; see the file COPYING3. If not see . */ -/* In sol2.c. */ +/* In sol2.cc. */ extern void solaris_assemble_visibility (tree, int); extern void solaris_elf_asm_comdat_section (const char *, unsigned int, tree); extern void solaris_file_end (void); @@ -26,8 +26,8 @@ extern void solaris_insert_attributes (tree, tree *); extern void solaris_output_init_fini (FILE *, tree); extern void solaris_override_options (void); -/* In sol2-c.c. */ +/* In sol2-c.cc. */ extern void solaris_register_pragmas (void); -/* In sol2-cxx.c. */ +/* In sol2-cxx.cc. */ extern tree solaris_cxx_decl_mangling_context (const_tree); diff --git a/gcc/config/sol2.h b/gcc/config/sol2.h index 5339956..e22c70c 100644 --- a/gcc/config/sol2.h +++ b/gcc/config/sol2.h @@ -449,7 +449,7 @@ along with GCC; see the file COPYING3. If not see "%{no-pie:} %{pie:%e-pie is not supported in this configuration} " #endif -/* collect2.c can only parse GNU nm -n output. Solaris nm needs -png to +/* collect2.cc can only parse GNU nm -n output. Solaris nm needs -png to produce the same format. */ #define NM_FLAGS "-png" @@ -466,7 +466,7 @@ along with GCC; see the file COPYING3. If not see { "fini", 0, 0, true, false, false, false, NULL, NULL } /* Solaris-specific #pragmas are implemented on top of attributes. Hook in - the bits from config/sol2.c. */ + the bits from config/sol2.cc. */ #define SUBTARGET_INSERT_ATTRIBUTES solaris_insert_attributes #define SUBTARGET_ATTRIBUTE_TABLE SOLARIS_ATTRIBUTE_TABLE diff --git a/gcc/config/sparc/driver-sparc.cc b/gcc/config/sparc/driver-sparc.cc index 719427b..73088e9 100644 --- a/gcc/config/sparc/driver-sparc.cc +++ b/gcc/config/sparc/driver-sparc.cc @@ -89,7 +89,7 @@ static const struct cpu_names { #include #endif -/* This will be called by the spec parser in gcc.c when it sees +/* This will be called by the spec parser in gcc.cc when it sees a %:local_cpu_detect(args) construct. Currently it will be called with either "cpu" or "tune" as argument depending on if -mcpu=native or -mtune=native is to be substituted. diff --git a/gcc/config/sparc/freebsd.h b/gcc/config/sparc/freebsd.h index fabfd68..98319c5 100644 --- a/gcc/config/sparc/freebsd.h +++ b/gcc/config/sparc/freebsd.h @@ -56,8 +56,8 @@ along with GCC; see the file COPYING3. If not see /************************[ Target stuff ]***********************************/ /* Define the actual types of some ANSI-mandated types. - Needs to agree with . GCC defaults come from c-decl.c, - c-common.c, and config//.h. */ + Needs to agree with . GCC defaults come from c-decl.cc, + c-common.cc, and config//.h. */ /* Earlier headers may get this wrong for FreeBSD. We use the GCC defaults instead. */ diff --git a/gcc/config/sparc/sparc-protos.h b/gcc/config/sparc/sparc-protos.h index 6819f6d..f9e1c74 100644 --- a/gcc/config/sparc/sparc-protos.h +++ b/gcc/config/sparc/sparc-protos.h @@ -112,7 +112,7 @@ unsigned int sparc_regmode_natural_size (machine_mode); extern rtl_opt_pass *make_pass_work_around_errata (gcc::context *); -/* Routines implemented in sparc-d.c */ +/* Routines implemented in sparc-d.cc */ extern void sparc_d_target_versions (void); extern void sparc_d_register_target_info (void); diff --git a/gcc/config/sparc/sparc.cc b/gcc/config/sparc/sparc.cc index 5331824..bb4ce88 100644 --- a/gcc/config/sparc/sparc.cc +++ b/gcc/config/sparc/sparc.cc @@ -1,4 +1,4 @@ -/* Subroutines for insn-output.c for SPARC. +/* Subroutines for insn-output.cc for SPARC. Copyright (C) 1987-2022 Free Software Foundation, Inc. Contributed by Michael Tiemann (tiemann@cygnus.com) 64-bit SPARC-V9 support by Michael Tiemann, Jim Wilson, and Doug Evans, @@ -12376,7 +12376,7 @@ sparc_output_mi_thunk (FILE *file, tree thunk_fndecl ATTRIBUTE_UNUSED, output_sibcall that we are in a leaf function. */ sparc_leaf_function_p = crtl->uses_only_leaf_regs = 1; - /* This will cause final.c to invoke leaf_renumber_regs so we + /* This will cause final.cc to invoke leaf_renumber_regs so we must behave as if we were in a not-yet-leafified function. */ int_arg_first = SPARC_INCOMING_INT_ARG_FIRST; } @@ -12581,7 +12581,7 @@ sparc_asan_shadow_offset (void) return TARGET_ARCH64 ? (HOST_WIDE_INT_1 << 43) : (HOST_WIDE_INT_1 << 29); } -/* This is called from dwarf2out.c via TARGET_ASM_OUTPUT_DWARF_DTPREL. +/* This is called from dwarf2out.cc via TARGET_ASM_OUTPUT_DWARF_DTPREL. We need to emit DTP-relative relocations. */ static void diff --git a/gcc/config/sparc/sparc.h b/gcc/config/sparc/sparc.h index e8242d8..2e17fca 100644 --- a/gcc/config/sparc/sparc.h +++ b/gcc/config/sparc/sparc.h @@ -1322,7 +1322,7 @@ do { \ They give nonzero only if REGNO is a hard reg of the suitable class or a pseudo reg currently allocated to a suitable hard reg. Since they use reg_renumber, they are safe only once reg_renumber - has been allocated, which happens in reginfo.c during register + has been allocated, which happens in reginfo.cc during register allocation. */ #define REGNO_OK_FOR_INDEX_P(REGNO) \ @@ -1366,7 +1366,7 @@ do { \ /* Try a machine-dependent way of reloading an illegitimate address operand. If we find one, push the reload and jump to WIN. This - macro is used in only one place: `find_reloads_address' in reload.c. */ + macro is used in only one place: `find_reloads_address' in reload.cc. */ #define LEGITIMIZE_RELOAD_ADDRESS(X,MODE,OPNUM,TYPE,IND_LEVELS,WIN) \ do { \ int win; \ @@ -1513,7 +1513,7 @@ do { \ /* On Sun 4, this limit is 2048. We use 1000 to be safe, since the length can run past this up to a continuation point. Once we used 1500, but a single entry in C++ can run more than 500 bytes, due to the length of - mangled symbol names. dbxout.c should really be fixed to do + mangled symbol names. dbxout.cc should really be fixed to do continuations when they are actually needed instead of trying to guess... */ #define DBX_CONTIN_LENGTH 1000 diff --git a/gcc/config/sparc/sparc.md b/gcc/config/sparc/sparc.md index 62b7b53..691e707 100644 --- a/gcc/config/sparc/sparc.md +++ b/gcc/config/sparc/sparc.md @@ -1935,7 +1935,7 @@ visl") "or\t%1, %%lo(%a3-(%a2-.)), %0") ;; SPARC-v9 code model support insns. See sparc_emit_set_symbolic_const64 -;; in sparc.c to see what is going on here... PIC stuff comes first. +;; in sparc.cc to see what is going on here... PIC stuff comes first. (define_insn "movdi_lo_sum_pic" [(set (match_operand:DI 0 "register_operand" "=r") @@ -2810,7 +2810,7 @@ visl") ;; it simple and only allow those constants supported by all flavors. ;; Note that emit_conditional_move canonicalizes operands 2,3 so that operand ;; 3 contains the constant if one is present, but we handle either for -;; generality (sparc.c puts a constant in operand 2). +;; generality (sparc.cc puts a constant in operand 2). ;; ;; Our instruction patterns, on the other hand, canonicalize such that ;; operand 3 must be the set destination. diff --git a/gcc/config/sparc/t-sparc b/gcc/config/sparc/t-sparc index 65b1313..2dd06c9 100644 --- a/gcc/config/sparc/t-sparc +++ b/gcc/config/sparc/t-sparc @@ -20,11 +20,11 @@ PASSES_EXTRA += $(srcdir)/config/sparc/sparc-passes.def -sparc-c.o: $(srcdir)/config/sparc/sparc-c.c +sparc-c.o: $(srcdir)/config/sparc/sparc-c.cc $(COMPILE) $< $(POSTCOMPILE) -sparc-d.o: $(srcdir)/config/sparc/sparc-d.c +sparc-d.o: $(srcdir)/config/sparc/sparc-d.cc $(COMPILE) $< $(POSTCOMPILE) diff --git a/gcc/config/sparc/x-sparc b/gcc/config/sparc/x-sparc index 5fc65be..a1b4ac3 100644 --- a/gcc/config/sparc/x-sparc +++ b/gcc/config/sparc/x-sparc @@ -1,4 +1,4 @@ -driver-sparc.o: $(srcdir)/config/sparc/driver-sparc.c +driver-sparc.o: $(srcdir)/config/sparc/driver-sparc.cc $(COMPILE) $< $(POSTCOMPILE) diff --git a/gcc/config/stormy16/stormy16.cc b/gcc/config/stormy16/stormy16.cc index f41c0dab..36fb97e 100644 --- a/gcc/config/stormy16/stormy16.cc +++ b/gcc/config/stormy16/stormy16.cc @@ -702,7 +702,7 @@ xstormy16_mode_dependent_address_p (const_rtx x, && ! LEGITIMATE_ADDRESS_INTEGER_P (XEXP (x, 1), 6)) return true; - /* Auto-increment addresses are now treated generically in recog.c. */ + /* Auto-increment addresses are now treated generically in recog.cc. */ return false; } diff --git a/gcc/config/t-darwin b/gcc/config/t-darwin index ffdd09c..879539e 100644 --- a/gcc/config/t-darwin +++ b/gcc/config/t-darwin @@ -18,22 +18,22 @@ TM_H += $(srcdir)/config/darwin-sections.def -darwin.o: $(srcdir)/config/darwin.c config/darwin-sections.def +darwin.o: $(srcdir)/config/darwin.cc config/darwin-sections.def $(COMPILE) $< $(POSTCOMPILE) -darwin-c.o: $(srcdir)/config/darwin-c.c +darwin-c.o: $(srcdir)/config/darwin-c.cc $(COMPILE) $(PREPROCESSOR_DEFINES) $< $(POSTCOMPILE) -darwin-d.o: $(srcdir)/config/darwin-d.c +darwin-d.o: $(srcdir)/config/darwin-d.cc $(COMPILE) $< $(POSTCOMPILE) -darwin-f.o: $(srcdir)/config/darwin-f.c +darwin-f.o: $(srcdir)/config/darwin-f.cc $(COMPILE) $< $(POSTCOMPILE) -darwin-driver.o: $(srcdir)/config/darwin-driver.c +darwin-driver.o: $(srcdir)/config/darwin-driver.cc $(COMPILE) $< $(POSTCOMPILE) diff --git a/gcc/config/t-dragonfly b/gcc/config/t-dragonfly index 0610f2d..a282579 100644 --- a/gcc/config/t-dragonfly +++ b/gcc/config/t-dragonfly @@ -16,6 +16,6 @@ # along with GCC; see the file COPYING3. If not see # . -dragonfly-d.o: $(srcdir)/config/dragonfly-d.c +dragonfly-d.o: $(srcdir)/config/dragonfly-d.cc $(COMPILE) $< $(POSTCOMPILE) diff --git a/gcc/config/t-freebsd b/gcc/config/t-freebsd index 9f24c3b..37049f7 100644 --- a/gcc/config/t-freebsd +++ b/gcc/config/t-freebsd @@ -16,6 +16,6 @@ # along with GCC; see the file COPYING3. If not see # . -freebsd-d.o: $(srcdir)/config/freebsd-d.c +freebsd-d.o: $(srcdir)/config/freebsd-d.cc $(COMPILE) $< $(POSTCOMPILE) diff --git a/gcc/config/t-glibc b/gcc/config/t-glibc index 5e3338a..c8b7d4e 100644 --- a/gcc/config/t-glibc +++ b/gcc/config/t-glibc @@ -16,10 +16,10 @@ # along with GCC; see the file COPYING3. If not see # . -glibc-c.o: config/glibc-c.c +glibc-c.o: config/glibc-c.cc $(COMPILE) $< $(POSTCOMPILE) -glibc-d.o: config/glibc-d.c +glibc-d.o: config/glibc-d.cc $(COMPILE) $< $(POSTCOMPILE) diff --git a/gcc/config/t-linux b/gcc/config/t-linux index 58d9243..d9bc9b8 100644 --- a/gcc/config/t-linux +++ b/gcc/config/t-linux @@ -16,6 +16,6 @@ # along with GCC; see the file COPYING3. If not see # . -linux.o: $(srcdir)/config/linux.c +linux.o: $(srcdir)/config/linux.cc $(COMPILE) $< $(POSTCOMPILE) diff --git a/gcc/config/t-netbsd b/gcc/config/t-netbsd index 5fec4d6..77f850f 100644 --- a/gcc/config/t-netbsd +++ b/gcc/config/t-netbsd @@ -16,10 +16,10 @@ # along with GCC; see the file COPYING3. If not see # . -netbsd.o: $(srcdir)/config/netbsd.c +netbsd.o: $(srcdir)/config/netbsd.cc $(COMPILE) $< $(POSTCOMPILE) -netbsd-d.o: $(srcdir)/config/netbsd-d.c +netbsd-d.o: $(srcdir)/config/netbsd-d.cc $(COMPILE) $< $(POSTCOMPILE) diff --git a/gcc/config/t-openbsd b/gcc/config/t-openbsd index 27a419d..69643f5 100644 --- a/gcc/config/t-openbsd +++ b/gcc/config/t-openbsd @@ -2,6 +2,6 @@ USER_H = $(EXTRA_HEADERS) # OpenBSD-specific D support. -openbsd-d.o: $(srcdir)/config/openbsd-d.c +openbsd-d.o: $(srcdir)/config/openbsd-d.cc $(COMPILE) $< $(POSTCOMPILE) diff --git a/gcc/config/t-pnt16-warn b/gcc/config/t-pnt16-warn index 5290578..1727a82 100644 --- a/gcc/config/t-pnt16-warn +++ b/gcc/config/t-pnt16-warn @@ -18,7 +18,7 @@ # . -# Because POINTER_SIZE is only 16, in dwarf2out.c, +# Because POINTER_SIZE is only 16, in dwarf2out.cc, # DWARF_ARANGES_PAD_SIZE is 0, thus a loop in output_aranges that checks # (i < (unsigned) DWARF_ARANGES_PAD_SIZE) elicits a warning that the # comparison is always false. diff --git a/gcc/config/t-sol2 b/gcc/config/t-sol2 index f0ee7d8..8732e2e 100644 --- a/gcc/config/t-sol2 +++ b/gcc/config/t-sol2 @@ -17,27 +17,27 @@ # . # Solaris-specific format checking and pragmas. -sol2-c.o: $(srcdir)/config/sol2-c.c +sol2-c.o: $(srcdir)/config/sol2-c.cc $(COMPILE) $< $(POSTCOMPILE) # Solaris-specific C++ mangling. -sol2-cxx.o: $(srcdir)/config/sol2-cxx.c +sol2-cxx.o: $(srcdir)/config/sol2-cxx.cc $(COMPILE) $< $(POSTCOMPILE) # Solaris-specific D support. -sol2-d.o: $(srcdir)/config/sol2-d.c +sol2-d.o: $(srcdir)/config/sol2-d.cc $(COMPILE) $< $(POSTCOMPILE) # Corresponding stub routines. -sol2-stubs.o: $(srcdir)/config/sol2-stubs.c +sol2-stubs.o: $(srcdir)/config/sol2-stubs.cc $(COMPILE) $< $(POSTCOMPILE) # Solaris-specific attributes -sol2.o: $(srcdir)/config/sol2.c +sol2.o: $(srcdir)/config/sol2.cc $(COMPILE) $< $(POSTCOMPILE) diff --git a/gcc/config/t-vxworks b/gcc/config/t-vxworks index cf90fcd..40c6cc4 100644 --- a/gcc/config/t-vxworks +++ b/gcc/config/t-vxworks @@ -16,11 +16,11 @@ # along with GCC; see the file COPYING3. If not see # . -vxworks.o: $(srcdir)/config/vxworks.c +vxworks.o: $(srcdir)/config/vxworks.cc $(COMPILE) $< $(POSTCOMPILE) -vxworks-c.o: $(srcdir)/config/vxworks-c.c +vxworks-c.o: $(srcdir)/config/vxworks-c.cc $(COMPILE) $< $(POSTCOMPILE) diff --git a/gcc/config/t-winnt b/gcc/config/t-winnt index 752bc53..c44e9bf 100644 --- a/gcc/config/t-winnt +++ b/gcc/config/t-winnt @@ -16,7 +16,7 @@ # along with GCC; see the file COPYING3. If not see # . -winnt-c.o: config/winnt-c.c $(CONFIG_H) $(SYSTEM_H) coretypes.h \ +winnt-c.o: config/winnt-c.cc $(CONFIG_H) $(SYSTEM_H) coretypes.h \ $(C_TARGET_H) $(C_TARGET_DEF_H) $(COMPILER) -c $(ALL_COMPILERFLAGS) $(ALL_CPPFLAGS) \ $< $(OUTPUT_OPTION) diff --git a/gcc/config/tilegx/t-tilegx b/gcc/config/tilegx/t-tilegx index 20ee6d3..f357194 100644 --- a/gcc/config/tilegx/t-tilegx +++ b/gcc/config/tilegx/t-tilegx @@ -5,17 +5,17 @@ MULTILIB_OSDIRNAMES = ../lib ../lib32 LIBGCC = stmp-multilib INSTALL_LIBGCC = install-multilib -tilegx-c.o: $(srcdir)/config/tilegx/tilegx-c.c \ +tilegx-c.o: $(srcdir)/config/tilegx/tilegx-c.cc \ $(CONFIG_H) $(SYSTEM_H) coretypes.h $(MACHMODE_H) \ $(TM_H) $(TM_P_H) $(CPPLIB_H) $(TREE_H) $(C_COMMON_H) $(COMPILER) -c $(ALL_COMPILERFLAGS) $(ALL_CPPFLAGS) $(INCLUDES) $< -$(srcdir)/config/tilegx/mul-tables.c: \ +$(srcdir)/config/tilegx/mul-tables.cc: \ $(srcdir)/config/tilepro/gen-mul-tables.cc $(CXX_FOR_BUILD) $(BUILD_CPPFLAGS) -O2 -o gen-mul-tables $<; ./gen-mul-tables > $@ -mul-tables.o: $(srcdir)/config/tilegx/mul-tables.c \ +mul-tables.o: $(srcdir)/config/tilegx/mul-tables.cc \ $(CONFIG_H) $(SYSTEM_H) coretypes.h $(EXPR_H) $(OPTABS_H) \ $(srcdir)/config/tilegx/tilegx-multiply.h $(COMPILER) -c $(ALL_COMPILERFLAGS) $(ALL_CPPFLAGS) $(INCLUDES) $< diff --git a/gcc/config/tilegx/tilegx-c.cc b/gcc/config/tilegx/tilegx-c.cc index 627a5ac..6ef6808 100644 --- a/gcc/config/tilegx/tilegx-c.cc +++ b/gcc/config/tilegx/tilegx-c.cc @@ -26,7 +26,7 @@ #include "tm.h" #include "c-family/c-common.h" -/* copy defines in c-cppbuiltin.c */ +/* copy defines in c-cppbuiltin.cc */ # define builtin_define(TXT) cpp_define (pfile, TXT) # define builtin_assert(TXT) cpp_assert (pfile, TXT) diff --git a/gcc/config/tilegx/tilegx-protos.h b/gcc/config/tilegx/tilegx-protos.h index 291d700..7263524 100644 --- a/gcc/config/tilegx/tilegx-protos.h +++ b/gcc/config/tilegx/tilegx-protos.h @@ -68,7 +68,7 @@ extern void tilegx_final_prescan_insn (rtx_insn *); extern const char *tilegx_asm_output_opcode (FILE *, const char *); extern void tilegx_function_profiler (FILE *, int); -/* Declare functions in tilegx-c.c */ +/* Declare functions in tilegx-c.cc */ extern void tilegx_cpu_cpp_builtins (struct cpp_reader *); diff --git a/gcc/config/tilegx/tilegx.md b/gcc/config/tilegx/tilegx.md index a98f4a7..7f89ae5 100644 --- a/gcc/config/tilegx/tilegx.md +++ b/gcc/config/tilegx/tilegx.md @@ -2421,7 +2421,7 @@ ;; -;; Divide stubs. These exist to work around a bug in expmed.c, which +;; Divide stubs. These exist to work around a bug in expmed.cc, which ;; will not attempt to convert a divide by constant into a multiply ;; unless there is a pattern for a divide of the same mode. The end ;; result is a 32-bit divide turns into 64-bit multiply. diff --git a/gcc/config/tilepro/t-tilepro b/gcc/config/tilepro/t-tilepro index 859331b..f64fd12 100644 --- a/gcc/config/tilepro/t-tilepro +++ b/gcc/config/tilepro/t-tilepro @@ -1,15 +1,15 @@ -tilepro-c.o: $(srcdir)/config/tilepro/tilepro-c.c \ +tilepro-c.o: $(srcdir)/config/tilepro/tilepro-c.cc \ $(CONFIG_H) $(SYSTEM_H) coretypes.h $(MACHMODE_H) \ $(TM_H) $(TM_P_H) $(CPPLIB_H) $(TREE_H) $(C_COMMON_H) $(COMPILER) -c $(ALL_COMPILERFLAGS) $(ALL_CPPFLAGS) $(INCLUDES) $< -$(srcdir)/config/tilepro/mul-tables.c: \ +$(srcdir)/config/tilepro/mul-tables.cc: \ $(srcdir)/config/tilepro/gen-mul-tables.cc $(CXX_FOR_BUILD) $(BUILD_CPPFLAGS) -O2 -DTILEPRO \ -o gen-mul-tables $<; ./gen-mul-tables > $@ -mul-tables.o: $(srcdir)/config/tilepro/mul-tables.c \ +mul-tables.o: $(srcdir)/config/tilepro/mul-tables.cc \ $(CONFIG_H) $(SYSTEM_H) coretypes.h $(EXPR_H) $(OPTABS_H) \ $(srcdir)/config/tilepro/tilepro-multiply.h $(COMPILER) -c $(ALL_COMPILERFLAGS) $(ALL_CPPFLAGS) $(INCLUDES) $< diff --git a/gcc/config/tilepro/tilepro-c.cc b/gcc/config/tilepro/tilepro-c.cc index 14b08ea..ed91e710 100644 --- a/gcc/config/tilepro/tilepro-c.cc +++ b/gcc/config/tilepro/tilepro-c.cc @@ -26,7 +26,7 @@ #include "tm.h" #include "c-family/c-common.h" -/* copy defines in c-cppbuiltin.c */ +/* copy defines in c-cppbuiltin.cc */ # define builtin_define(TXT) cpp_define (pfile, TXT) # define builtin_assert(TXT) cpp_assert (pfile, TXT) diff --git a/gcc/config/v850/t-v850 b/gcc/config/v850/t-v850 index 27d9842..275ee8f 100644 --- a/gcc/config/v850/t-v850 +++ b/gcc/config/v850/t-v850 @@ -25,10 +25,10 @@ MULTILIB_DIRNAMES += v850e3v5 TCFLAGS = -mno-app-regs -msmall-sld -Wa,-mwarn-signed-overflow -Wa,-mwarn-unsigned-overflow -v850-c.o: $(srcdir)/config/v850/v850-c.c $(CONFIG_H) $(SYSTEM_H) coretypes.h \ +v850-c.o: $(srcdir)/config/v850/v850-c.cc $(CONFIG_H) $(SYSTEM_H) coretypes.h \ $(TM_H) $(CPPLIB_H) $(TREE_H) $(C_PRAGMA_H) $(GGC_H) $(TM_P_H) $(COMPILER) -c $(ALL_COMPILERFLAGS) $(ALL_CPPFLAGS) $(INCLUDES) \ - $(srcdir)/config/v850/v850-c.c + $(srcdir)/config/v850/v850-c.cc # Local Variables: # mode: Makefile diff --git a/gcc/config/v850/v850-protos.h b/gcc/config/v850/v850-protos.h index e64c659..890552b 100644 --- a/gcc/config/v850/v850-protos.h +++ b/gcc/config/v850/v850-protos.h @@ -1,4 +1,4 @@ -/* Prototypes for v850.c functions used in the md file & elsewhere. +/* Prototypes for v850.cc functions used in the md file & elsewhere. Copyright (C) 1999-2022 Free Software Foundation, Inc. This file is part of GCC. diff --git a/gcc/config/v850/v850.cc b/gcc/config/v850/v850.cc index bb282b0..c7d4329 100644 --- a/gcc/config/v850/v850.cc +++ b/gcc/config/v850/v850.cc @@ -1,4 +1,4 @@ -/* Subroutines for insn-output.c for NEC V850 series +/* Subroutines for insn-output.cc for NEC V850 series Copyright (C) 1996-2022 Free Software Foundation, Inc. Contributed by Jeff Law (law@cygnus.com). @@ -89,7 +89,7 @@ F (rtx x) /* Mark all the subexpressions of the PARALLEL rtx PAR as frame-related. Return PAR. - dwarf2out.c:dwarf2out_frame_debug_expr ignores sub-expressions of a + dwarf2out.cc:dwarf2out_frame_debug_expr ignores sub-expressions of a PARALLEL rtx other than the first if they do not have the FRAME_RELATED flag set on them. */ diff --git a/gcc/config/v850/v850.h b/gcc/config/v850/v850.h index 544fbb3..328926e 100644 --- a/gcc/config/v850/v850.h +++ b/gcc/config/v850/v850.h @@ -351,7 +351,7 @@ enum reg_class They give nonzero only if REGNO is a hard reg of the suitable class or a pseudo reg currently allocated to a suitable hard reg. Since they use reg_renumber, they are safe only once reg_renumber - has been allocated, which happens in reginfo.c during register + has been allocated, which happens in reginfo.cc during register allocation. */ #define REGNO_OK_FOR_BASE_P(regno) \ @@ -569,7 +569,7 @@ struct cum_arg { int nbytes; }; than accessing full words. */ #define SLOW_BYTE_ACCESS 1 -/* According expr.c, a value of around 6 should minimize code size, and +/* According expr.cc, a value of around 6 should minimize code size, and for the V850 series, that's our primary concern. */ #define MOVE_RATIO(speed) 6 @@ -766,7 +766,7 @@ typedef enum /* enum GHS_SECTION_KIND is an enumeration of the kinds of sections that can appear in the "ghs section" pragma. These names are used to index into the GHS_default_section_names[] and GHS_current_section_names[] - that are defined in v850.c, and so the ordering of each must remain + that are defined in v850.cc, and so the ordering of each must remain consistent. These arrays give the default and current names for each kind of diff --git a/gcc/config/vax/vax.cc b/gcc/config/vax/vax.cc index a5ad10d..20c4d52 100644 --- a/gcc/config/vax/vax.cc +++ b/gcc/config/vax/vax.cc @@ -1,4 +1,4 @@ -/* Subroutines for insn-output.c for VAX. +/* Subroutines for insn-output.cc for VAX. Copyright (C) 1987-2022 Free Software Foundation, Inc. This file is part of GCC. @@ -1948,7 +1948,7 @@ vax_mode_dependent_address_p (const_rtx x, addr_space_t as ATTRIBUTE_UNUSED) { rtx xfoo0, xfoo1; - /* Auto-increment cases are now dealt with generically in recog.c. */ + /* Auto-increment cases are now dealt with generically in recog.cc. */ if (GET_CODE (x) != PLUS) return false; diff --git a/gcc/config/vax/vax.h b/gcc/config/vax/vax.h index 0a5da67..45c0e75 100644 --- a/gcc/config/vax/vax.h +++ b/gcc/config/vax/vax.h @@ -359,7 +359,7 @@ enum reg_class { NO_REGS, ALL_REGS, LIM_REG_CLASSES }; They give nonzero only if REGNO is a hard reg of the suitable class or a pseudo reg currently allocated to a suitable hard reg. Since they use reg_renumber, they are safe only once reg_renumber - has been allocated, which happens in reginfo.c during register + has been allocated, which happens in reginfo.cc during register allocation. */ #define REGNO_OK_FOR_INDEX_P(regno) \ diff --git a/gcc/config/vax/vax.md b/gcc/config/vax/vax.md index 5f2af49..2ce3620 100644 --- a/gcc/config/vax/vax.md +++ b/gcc/config/vax/vax.md @@ -1261,7 +1261,7 @@ ;; The following used to be needed because constant propagation can ;; create them starting from the bic insn patterns above. This is no ;; longer a problem. However, having these patterns allows optimization -;; opportunities in combine.c. +;; opportunities in combine.cc. (define_insn_and_split "*and3_const_int" [(set (match_operand:VAXint 0 "nonimmediate_operand" "=g,g") diff --git a/gcc/config/visium/visium.cc b/gcc/config/visium/visium.cc index d7a460e..03c1a33 100644 --- a/gcc/config/visium/visium.cc +++ b/gcc/config/visium/visium.cc @@ -1850,7 +1850,7 @@ visium_legitimate_address_p (machine_mode mode, rtx x, bool strict) /* Try machine-dependent ways of modifying an illegitimate address to be legitimate. If we find one, return the new, valid address. - This macro is used in only one place: `memory_address' in explow.c. + This macro is used in only one place: `memory_address' in explow.cc. OLDX is the address as it was before break_out_memory_refs was called. In some cases it is useful to look at this to decide what needs to be done. diff --git a/gcc/config/visium/visium.h b/gcc/config/visium/visium.h index d502e7d..e981924 100644 --- a/gcc/config/visium/visium.h +++ b/gcc/config/visium/visium.h @@ -376,7 +376,7 @@ with spaces, and write first any length keyword, then `unsigned' if appropriate, and finally `int'. The string must exactly match one of the data type names defined in the function - `init_decl_processing' in the file `c-decl.c'. You may not omit + `init_decl_processing' in the file `c-decl.cc'. You may not omit `int' or change the order--that would cause the compiler to crash on startup. @@ -1234,7 +1234,7 @@ do \ `EXTRA_SECTION_FUNCTIONS' - One or more functions to be defined in `varasm.c'. These functions + One or more functions to be defined in `varasm.cc'. These functions should do jobs analogous to those of `text_section' and `data_section', for your additional sections. Do not define this macro if you do not define `EXTRA_SECTIONS'. @@ -1344,7 +1344,7 @@ do \ `IMMEDIATE_PREFIX' If defined, C string expressions to be used for the `%R', `%L', - `%U', and `%I' options of `asm_fprintf' (see `final.c'). These are + `%U', and `%I' options of `asm_fprintf' (see `final.cc'). These are useful when a single `md' file must support multiple assembler formats. In that case, the various `tm.h' files can define these macros differently. */ diff --git a/gcc/config/vms/t-vms b/gcc/config/vms/t-vms index 5cb9773..f099b48 100644 --- a/gcc/config/vms/t-vms +++ b/gcc/config/vms/t-vms @@ -23,18 +23,18 @@ vms-crtlmap.h: $(srcdir)/config/vms/vms-crtlmap.map \ $(AWK) -f $(srcdir)/config/vms/make-crtlmap.awk \ $(srcdir)/config/vms/vms-crtlmap.map > $@ -vms.o: $(srcdir)/config/vms/vms.c $(TREE_H) $(CONFIG_H) $(SYSTEM_H) \ +vms.o: $(srcdir)/config/vms/vms.cc $(TREE_H) $(CONFIG_H) $(SYSTEM_H) \ coretypes.h $(TM_P_H) vms-crtlmap.h $(COMPILER) -c $(ALL_COMPILERFLAGS) $(ALL_CPPFLAGS) $(INCLUDES) \ $< -o $@ -vms-c.o: $(srcdir)/config/vms/vms-c.c $(CONFIG_H) $(SYSTEM_H) coretypes.h \ +vms-c.o: $(srcdir)/config/vms/vms-c.cc $(CONFIG_H) $(SYSTEM_H) coretypes.h \ $(TM_H) $(CPPLIB_H) $(TREE_H) c-family/c-pragma.h toplev.h $(GGC_H) \ $(TM_P_H) $(COMPILER) -c $(ALL_COMPILERFLAGS) $(ALL_CPPFLAGS) $(INCLUDES) \ $(PREPROCESSOR_DEFINES) $< -o $@ -vms-f.o: $(srcdir)/config/vms/vms-f.c $(CONFIG_H) $(SYSTEM_H) coretypes.h \ +vms-f.o: $(srcdir)/config/vms/vms-f.cc $(CONFIG_H) $(SYSTEM_H) coretypes.h \ $(TM_H) $(COMPILER) -c $(ALL_COMPILERFLAGS) $(ALL_CPPFLAGS) $(INCLUDES) \ $(PREPROCESSOR_DEFINES) $< -o $@ diff --git a/gcc/config/vms/vms-crtlmap.map b/gcc/config/vms/vms-crtlmap.map index e80e2af..80331b2 100644 --- a/gcc/config/vms/vms-crtlmap.map +++ b/gcc/config/vms/vms-crtlmap.map @@ -12,7 +12,7 @@ # - Comment lines start with '#' in the first column. # - map lines consist in an identifier optionnaly followed by at most 2 # space-separated flags. -# Flags are described in vms.c (prefixed by VMS_CRTL_). +# Flags are described in vms.cc (prefixed by VMS_CRTL_). # # Keep entries alpha-sorted - this is enforced by the awk script. # diff --git a/gcc/config/vms/vms-protos.h b/gcc/config/vms/vms-protos.h index 72607c4..b47aa83 100644 --- a/gcc/config/vms/vms-protos.h +++ b/gcc/config/vms/vms-protos.h @@ -17,13 +17,13 @@ You should have received a copy of the GNU General Public License along with GCC; see the file COPYING3. If not see . */ -/* vms-c.c */ +/* vms-c.cc */ extern void vms_c_register_pragma (void); extern void vms_c_common_override_options (void); extern int vms_c_get_crtl_ver (void); extern int vms_c_get_vms_ver (void); -/* vms.c */ +/* vms.cc */ void vms_patch_builtins (void); #ifdef TREE_CODE diff --git a/gcc/config/vx-common.h b/gcc/config/vx-common.h index 03f3316..aaae4f7 100644 --- a/gcc/config/vx-common.h +++ b/gcc/config/vx-common.h @@ -25,7 +25,7 @@ along with GCC; see the file COPYING3. If not see to be used in port-specific vxworks.h. */ /* REAL_LIBGCC_SPEC needs to be used since the non-static option is not - handled in gcc.c. */ + handled in gcc.cc. */ #undef REAL_LIBGCC_SPEC #define REAL_LIBGCC_SPEC VXWORKS_LIBGCC_SPEC #undef STARTFILE_SPEC diff --git a/gcc/config/x-darwin b/gcc/config/x-darwin index c6226c0..8be4ce3 100644 --- a/gcc/config/x-darwin +++ b/gcc/config/x-darwin @@ -1,3 +1,3 @@ -host-darwin.o : $(srcdir)/config/host-darwin.c +host-darwin.o : $(srcdir)/config/host-darwin.cc $(COMPILE) $< $(POSTCOMPILE) diff --git a/gcc/config/x-hpux b/gcc/config/x-hpux index e9f2f18..86295f0 100644 --- a/gcc/config/x-hpux +++ b/gcc/config/x-hpux @@ -1,4 +1,4 @@ -host-hpux.o : $(srcdir)/config/host-hpux.c $(CONFIG_H) $(SYSTEM_H) \ +host-hpux.o : $(srcdir)/config/host-hpux.cc $(CONFIG_H) $(SYSTEM_H) \ coretypes.h hosthooks.h hosthooks-def.h $(HOOKS_H) $(COMPILER) -c $(ALL_COMPILERFLAGS) $(ALL_CPPFLAGS) $(INCLUDES) \ - $(srcdir)/config/host-hpux.c + $(srcdir)/config/host-hpux.cc diff --git a/gcc/config/x-linux b/gcc/config/x-linux index dba21a6..dd5b3a5 100644 --- a/gcc/config/x-linux +++ b/gcc/config/x-linux @@ -1,3 +1,3 @@ -host-linux.o : $(srcdir)/config/host-linux.c +host-linux.o : $(srcdir)/config/host-linux.cc $(COMPILE) $< $(POSTCOMPILE) diff --git a/gcc/config/x-netbsd b/gcc/config/x-netbsd index beef745..c489bd7 100644 --- a/gcc/config/x-netbsd +++ b/gcc/config/x-netbsd @@ -1,4 +1,4 @@ -host-netbsd.o : $(srcdir)/config/host-netbsd.c $(CONFIG_H) $(SYSTEM_H) \ +host-netbsd.o : $(srcdir)/config/host-netbsd.cc $(CONFIG_H) $(SYSTEM_H) \ coretypes.h hosthooks.h hosthooks-def.h $(HOOKS_H) $(COMPILER) -c $(ALL_COMPILERFLAGS) $(ALL_CPPFLAGS) $(INCLUDES) \ - $(srcdir)/config/host-netbsd.c + $(srcdir)/config/host-netbsd.cc diff --git a/gcc/config/x-openbsd b/gcc/config/x-openbsd index 18e3f65..afec637 100644 --- a/gcc/config/x-openbsd +++ b/gcc/config/x-openbsd @@ -1,4 +1,4 @@ -host-openbsd.o : $(srcdir)/config/host-openbsd.c $(CONFIG_H) $(SYSTEM_H) \ +host-openbsd.o : $(srcdir)/config/host-openbsd.cc $(CONFIG_H) $(SYSTEM_H) \ coretypes.h hosthooks.h hosthooks-def.h $(HOOKS_H) $(COMPILER) -c $(ALL_COMPILERFLAGS) $(ALL_CPPFLAGS) $(INCLUDES) \ - $(srcdir)/config/host-openbsd.c + $(srcdir)/config/host-openbsd.cc diff --git a/gcc/config/x-solaris b/gcc/config/x-solaris index d50b4f5..c67b3e5 100644 --- a/gcc/config/x-solaris +++ b/gcc/config/x-solaris @@ -1,3 +1,3 @@ -host-solaris.o: $(srcdir)/config/host-solaris.c +host-solaris.o: $(srcdir)/config/host-solaris.cc $(COMPILE) $< $(POSTCOMPILE) diff --git a/gcc/config/xtensa/xtensa-protos.h b/gcc/config/xtensa/xtensa-protos.h index 357dba0..4bc42da 100644 --- a/gcc/config/xtensa/xtensa-protos.h +++ b/gcc/config/xtensa/xtensa-protos.h @@ -30,7 +30,7 @@ extern bool xtensa_b4constu (HOST_WIDE_INT); extern bool xtensa_mask_immediate (HOST_WIDE_INT); extern bool xtensa_mem_offset (unsigned, machine_mode); -/* Functions within xtensa.c that we reference. */ +/* Functions within xtensa.cc that we reference. */ #ifdef RTX_CODE extern int xt_true_regnum (rtx); extern int xtensa_valid_move (machine_mode, rtx *); diff --git a/gcc/config/xtensa/xtensa.cc b/gcc/config/xtensa/xtensa.cc index e115b09..198bd3c 100644 --- a/gcc/config/xtensa/xtensa.cc +++ b/gcc/config/xtensa/xtensa.cc @@ -1,4 +1,4 @@ -/* Subroutines for insn-output.c for Tensilica's Xtensa architecture. +/* Subroutines for insn-output.cc for Tensilica's Xtensa architecture. Copyright (C) 2001-2022 Free Software Foundation, Inc. Contributed by Bob Wilson (bwilson@tensilica.com) at Tensilica. @@ -2243,7 +2243,7 @@ xtensa_option_override (void) /* Use CONST16 in the absence of L32R. Set it in the TARGET_OPTION_OVERRIDE to avoid dependency on xtensa - configuration in the xtensa-common.c */ + configuration in the xtensa-common.cc */ if (!TARGET_L32R) target_flags |= MASK_CONST16; diff --git a/gcc/config/xtensa/xtensa.h b/gcc/config/xtensa/xtensa.h index ea1fca2..00e2930 100644 --- a/gcc/config/xtensa/xtensa.h +++ b/gcc/config/xtensa/xtensa.h @@ -21,7 +21,7 @@ along with GCC; see the file COPYING3. If not see /* Get Xtensa configuration settings */ #include "xtensa-config.h" -/* External variables defined in xtensa.c. */ +/* External variables defined in xtensa.cc. */ /* Macros used in the machine description to select various Xtensa configuration options. */ diff --git a/gcc/configure.ac b/gcc/configure.ac index f2cd2f8..40d6554 100644 --- a/gcc/configure.ac +++ b/gcc/configure.ac @@ -24,7 +24,7 @@ # -------------------------------- AC_INIT -AC_CONFIG_SRCDIR(tree.c) +AC_CONFIG_SRCDIR(tree.cc) AC_CONFIG_HEADER(auto-host.h:config.in) gcc_version=`cat $srcdir/BASE-VER` @@ -1202,7 +1202,7 @@ AC_PROG_MAKE_SET # Find some useful tools AC_PROG_AWK -# We need awk to create options.c and options.h. +# We need awk to create options.cc and options.h. # Bail out if it's missing. case ${AWK} in "") AC_MSG_ERROR([can't build without awk, bailing out]) ;; @@ -1617,7 +1617,7 @@ AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[ # On AIX 5.2, conflicts with , as both define incompatible # FREAD and FWRITE macros. Fortunately, for GCC's single usage of ldgetname -# in collect2.c, isn't visible, but the configure test below needs +# in collect2.cc, isn't visible, but the configure test below needs # to undef these macros to get the correct value for HAVE_DECL_LDGETNAME. gcc_AC_CHECK_DECLS(ldgetname, , ,[ #include "ansidecl.h" @@ -7570,7 +7570,7 @@ AC_DEFINE_UNQUOTED(DIAGNOSTICS_URLS_DEFAULT, $DIAGNOSTICS_URLS_DEFAULT, [The default for -fdiagnostics-urls option]) # Generate gcc-driver-name.h containing GCC_DRIVER_NAME for the benefit -# of jit/jit-playback.c. +# of jit/jit-playback.cc. gcc_driver_version=`eval "${get_gcc_base_ver} $srcdir/BASE-VER"` echo "gcc_driver_version: ${gcc_driver_version}" cat > gcc-driver-name.h < cc1plus-checksum.c.tmp && \ - $(srcdir)/../move-if-change cc1plus-checksum.c.tmp cc1plus-checksum.c; \ + checksum-options > cc1plus-checksum.cc.tmp && \ + $(srcdir)/../move-if-change cc1plus-checksum.cc.tmp cc1plus-checksum.cc; \ fi cc1plus$(exeext): $(CXX_OBJS) cc1plus-checksum.o $(BACKEND) $(CODYLIB) $(LIBDEPS) $(c++.prev) diff --git a/gcc/cp/config-lang.in b/gcc/cp/config-lang.in index 46696b2..9ac3dee 100644 --- a/gcc/cp/config-lang.in +++ b/gcc/cp/config-lang.in @@ -36,22 +36,22 @@ gtfiles="\ \$(srcdir)/c-family/c-common.h \$(srcdir)/c-family/c-objc.h \ \$(srcdir)/c-family/c-pragma.h \$(srcdir)/cp/decl.h \ \$(srcdir)/cp/parser.h \ -\$(srcdir)/c-family/c-common.c \$(srcdir)/c-family/c-format.c \ -\$(srcdir)/c-family/c-cppbuiltin.c \$(srcdir)/c-family/c-pragma.c \ -\$(srcdir)/cp/call.c \$(srcdir)/cp/class.c \$(srcdir)/cp/constexpr.c \ +\$(srcdir)/c-family/c-common.cc \$(srcdir)/c-family/c-format.cc \ +\$(srcdir)/c-family/c-cppbuiltin.cc \$(srcdir)/c-family/c-pragma.cc \ +\$(srcdir)/cp/call.cc \$(srcdir)/cp/class.cc \$(srcdir)/cp/constexpr.cc \ \$(srcdir)/cp/constraint.cc \$(srcdir)/cp/coroutines.cc \ -\$(srcdir)/cp/cp-gimplify.c \ -\$(srcdir)/cp/cp-lang.c \$(srcdir)/cp/cp-objcp-common.c \ -\$(srcdir)/cp/decl.c \$(srcdir)/cp/decl2.c \ -\$(srcdir)/cp/except.c \ -\$(srcdir)/cp/friend.c \ -\$(srcdir)/cp/init.c \ -\$(srcdir)/cp/lambda.c \$(srcdir)/cp/lex.c \$(srcdir)/cp/logic.cc \ -\$(srcdir)/cp/mangle.c \$(srcdir)/cp/method.c \$(srcdir)/cp/module.cc \ -\$(srcdir)/cp/name-lookup.c \ -\$(srcdir)/cp/parser.c \$(srcdir)/cp/pt.c \ -\$(srcdir)/cp/rtti.c \ -\$(srcdir)/cp/semantics.c \ -\$(srcdir)/cp/tree.c \$(srcdir)/cp/typeck2.c \ -\$(srcdir)/cp/vtable-class-hierarchy.c \ +\$(srcdir)/cp/cp-gimplify.cc \ +\$(srcdir)/cp/cp-lang.cc \$(srcdir)/cp/cp-objcp-common.cc \ +\$(srcdir)/cp/decl.cc \$(srcdir)/cp/decl2.cc \ +\$(srcdir)/cp/except.cc \ +\$(srcdir)/cp/friend.cc \ +\$(srcdir)/cp/init.cc \ +\$(srcdir)/cp/lambda.cc \$(srcdir)/cp/lex.cc \$(srcdir)/cp/logic.cc \ +\$(srcdir)/cp/mangle.cc \$(srcdir)/cp/method.cc \$(srcdir)/cp/module.cc \ +\$(srcdir)/cp/name-lookup.cc \ +\$(srcdir)/cp/parser.cc \$(srcdir)/cp/pt.cc \ +\$(srcdir)/cp/rtti.cc \ +\$(srcdir)/cp/semantics.cc \ +\$(srcdir)/cp/tree.cc \$(srcdir)/cp/typeck2.cc \ +\$(srcdir)/cp/vtable-class-hierarchy.cc \ " diff --git a/gcc/cp/constexpr.cc b/gcc/cp/constexpr.cc index d0da4a7..f73496f 100644 --- a/gcc/cp/constexpr.cc +++ b/gcc/cp/constexpr.cc @@ -6550,7 +6550,7 @@ cxx_eval_constant_expression (const constexpr_ctx *ctx, tree t, } /* fall through */ case CONST_DECL: - /* We used to not check lval for CONST_DECL, but darwin.c uses + /* We used to not check lval for CONST_DECL, but darwin.cc uses CONST_DECL for aggregate constants. */ if (lval) return t; diff --git a/gcc/cp/coroutines.cc b/gcc/cp/coroutines.cc index f9a8af8..1792bf6 100644 --- a/gcc/cp/coroutines.cc +++ b/gcc/cp/coroutines.cc @@ -4387,7 +4387,7 @@ morph_fn_to_coro (tree orig, tree *resumer, tree *destroyer) If we encounter a fatal error we might return a now-empty body. Note, the returned ramp body is not 'popped', to be compatible with - the way that decl.c handles regular functions, the scope pop is done + the way that decl.cc handles regular functions, the scope pop is done in the caller. */ tree newbody = push_stmt_list (); diff --git a/gcc/cp/cp-gimplify.cc b/gcc/cp/cp-gimplify.cc index ad61030..0166ef6 100644 --- a/gcc/cp/cp-gimplify.cc +++ b/gcc/cp/cp-gimplify.cc @@ -1,4 +1,4 @@ -/* C++-specific tree lowering bits; see also c-gimplify.c and gimple.c. +/* C++-specific tree lowering bits; see also c-gimplify.cc and gimple.cc. Copyright (C) 2002-2022 Free Software Foundation, Inc. Contributed by Jason Merrill @@ -553,7 +553,7 @@ cp_gimplify_expr (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p) gimplify_modify_expr gimplifies the RHS before the LHS, but that isn't quite strong enough in two cases: - 1) gimplify.c wants to leave a CALL_EXPR on the RHS, which would + 1) gimplify.cc wants to leave a CALL_EXPR on the RHS, which would mean it's evaluated after the LHS. 2) the value calculation of the RHS is also sequenced before the diff --git a/gcc/cp/cp-lang.cc b/gcc/cp/cp-lang.cc index f35e325..7861f93 100644 --- a/gcc/cp/cp-lang.cc +++ b/gcc/cp/cp-lang.cc @@ -103,7 +103,7 @@ static void cxx_omp_finish_decl_inits (void); /* Each front end provides its own lang hook initializer. */ struct lang_hooks lang_hooks = LANG_HOOKS_INITIALIZER; -/* Lang hook routines common to C++ and ObjC++ appear in cp/cp-objcp-common.c; +/* Lang hook routines common to C++ and ObjC++ appear in cp/cp-objcp-common.cc; there should be very few routines below. */ /* The following function does something real, but only in Objective-C++. */ @@ -226,7 +226,7 @@ get_template_argument_pack_elems_folded (const_tree t) } /* The C++ version of the enum_underlying_base_type langhook. - See also cp/semantics.c (finish_underlying_type). */ + See also cp/semantics.cc (finish_underlying_type). */ static tree cxx_enum_underlying_base_type (const_tree type) diff --git a/gcc/cp/cp-objcp-common.cc b/gcc/cp/cp-objcp-common.cc index b31c9e3..8f74802 100644 --- a/gcc/cp/cp-objcp-common.cc +++ b/gcc/cp/cp-objcp-common.cc @@ -100,7 +100,7 @@ cp_tree_size (enum tree_code code) /* Returns true if T is a variably modified type, in the sense of C99. FN is as passed to variably_modified_p. This routine needs only check cases that cannot be handled by the - language-independent logic in tree.c. */ + language-independent logic in tree.cc. */ bool cp_var_mod_type_p (tree type, tree fn) @@ -280,7 +280,7 @@ cp_unit_size_without_reusable_padding (tree type) return TYPE_SIZE_UNIT (type); } -/* Stubs to keep c-opts.c happy. */ +/* Stubs to keep c-opts.cc happy. */ void push_file_scope (void) { @@ -291,7 +291,7 @@ pop_file_scope (void) { } -/* c-pragma.c needs to query whether a decl has extern "C" linkage. */ +/* c-pragma.cc needs to query whether a decl has extern "C" linkage. */ bool has_c_linkage (const_tree decl) { @@ -356,7 +356,7 @@ cp_pushdecl (tree decl) } /* Get the global value binding of NAME. Called directly from - c-common.c, not via a hook. */ + c-common.cc, not via a hook. */ tree identifier_global_value (tree name) diff --git a/gcc/cp/cp-objcp-common.h b/gcc/cp/cp-objcp-common.h index 6c53bdf..4c13731 100644 --- a/gcc/cp/cp-objcp-common.h +++ b/gcc/cp/cp-objcp-common.h @@ -21,7 +21,7 @@ along with GCC; see the file COPYING3. If not see #ifndef GCC_CP_OBJCP_COMMON #define GCC_CP_OBJCP_COMMON -/* In cp/objcp-common.c, cp/cp-lang.c and objcp/objcp-lang.c. */ +/* In cp/objcp-common.c, cp/cp-lang.cc and objcp/objcp-lang.cc. */ extern tree cp_get_debug_type (const_tree); extern tree objcp_tsubst_copy_and_build (tree, tree, tsubst_flags_t, @@ -43,7 +43,7 @@ extern tree cxx_simulate_record_decl (location_t, const char *, array_slice); /* Lang hooks that are shared between C++ and ObjC++ are defined here. Hooks - specific to C++ or ObjC++ go in cp/cp-lang.c and objcp/objcp-lang.c, + specific to C++ or ObjC++ go in cp/cp-lang.cc and objcp/objcp-lang.cc, respectively. */ #undef LANG_HOOKS_FREE_LANG_DATA diff --git a/gcc/cp/cp-tree.h b/gcc/cp/cp-tree.h index f8225c1..e428df0 100644 --- a/gcc/cp/cp-tree.h +++ b/gcc/cp/cp-tree.h @@ -2027,7 +2027,7 @@ make_temp_override (T& var, type_identity_t overrider) #define cp_noexcept_operand scope_chain->noexcept_operand -struct named_label_entry; /* Defined in decl.c. */ +struct named_label_entry; /* Defined in decl.cc. */ struct named_label_hash : ggc_remove { @@ -2160,7 +2160,7 @@ struct GTY(()) language_function { #define current_function_return_value \ (cp_function_chain->x_return_value) -/* In parser.c. */ +/* In parser.cc. */ extern tree cp_literal_operator_id (const char *); #define NON_ERROR(NODE) ((NODE) == error_mark_node ? NULL_TREE : (NODE)) @@ -5277,7 +5277,7 @@ more_aggr_init_expr_args_p (const aggr_init_expr_arg_iterator *iter) /* A language-specific token attached to the OpenMP data clauses to hold code (or code fragments) related to ctors, dtors, and op=. - See semantics.c for details. */ + See semantics.cc for details. */ #define CP_OMP_CLAUSE_INFO(NODE) \ TREE_TYPE (OMP_CLAUSE_RANGE_CHECK (NODE, OMP_CLAUSE_PRIVATE, \ OMP_CLAUSE__CONDTEMP_)) @@ -5587,7 +5587,7 @@ extern int comparing_specializations; FIXME we should always do this except during deduction/ordering. */ extern int comparing_dependent_aliases; -/* In parser.c. */ +/* In parser.cc. */ /* Nonzero if we are parsing an unevaluated operand: an operand to sizeof, typeof, or alignof. This is a count since operands to @@ -5622,7 +5622,7 @@ public: c_inhibit_evaluation_warnings = inhibit; } }; -/* in pt.c */ +/* in pt.cc */ /* These values are used for the `STRICT' parameter to type_unification and fn_type_unification. Their meanings are described with the @@ -5655,11 +5655,11 @@ struct GTY((for_user)) spec_entry tree spec; /* The specialization itself. */ }; -/* in class.c */ +/* in class.cc */ extern int current_class_depth; -/* in decl.c */ +/* in decl.cc */ /* An array of static vars & fns. */ extern GTY(()) vec *static_decls; @@ -6029,7 +6029,7 @@ const unsigned int STF_STRIP_DEPENDENT = 1U << 1; ? TYPE_TI_TEMPLATE (NODE) \ : TYPE_NAME (NODE)) -/* in lex.c */ +/* in lex.cc */ extern void init_reswords (void); @@ -6477,7 +6477,7 @@ extern int class_dump_id; extern int module_dump_id; extern int raw_dump_id; -/* in call.c */ +/* in call.cc */ extern bool check_dtor_name (tree, tree); int magic_varargs_p (tree); @@ -6621,7 +6621,7 @@ extern bool cp_handle_deprecated_or_unavailable (tree, tsubst_flags_t = tf_warni extern void cp_warn_deprecated_use_scopes (tree); extern tree get_function_version_dispatcher (tree); -/* in class.c */ +/* in class.cc */ extern tree build_vfield_ref (tree, tree); extern tree build_if_in_charge (tree true_stmt, tree false_stmt = void_node); extern tree build_base_path (enum tree_code, tree, @@ -6707,7 +6707,7 @@ extern bool uniquely_derived_from_p (tree, tree); extern bool publicly_uniquely_derived_p (tree, tree); extern tree common_enclosing_class (tree, tree); -/* in cvt.c */ +/* in cvt.cc */ extern tree convert_to_reference (tree, tree, int, int, tree, tsubst_flags_t); extern tree convert_from_reference (tree); @@ -6734,12 +6734,12 @@ extern tree tx_unsafe_fn_variant (tree); extern bool fnptr_conv_p (tree, tree); extern tree strip_fnptr_conv (tree); -/* in name-lookup.c */ +/* in name-lookup.cc */ extern void maybe_push_cleanup_level (tree); extern tree maybe_push_decl (tree); extern tree current_decl_namespace (void); -/* decl.c */ +/* decl.cc */ extern tree poplevel (int, int, int); extern void cxx_init_decl_processing (void); enum cp_tree_node_structure_enum cp_tree_node_structure @@ -6854,7 +6854,7 @@ extern tree build_explicit_specifier (tree, tsubst_flags_t); extern void do_push_parm_decls (tree, tree, tree *); extern tree do_aggregate_paren_init (tree, tree); -/* in decl2.c */ +/* in decl2.cc */ extern void record_mangling (tree, bool); extern void overwrite_mangling (tree, tree); extern void note_mangling_alias (tree, tree); @@ -6922,7 +6922,7 @@ extern bool cp_omp_mappable_type (tree); extern bool cp_omp_emit_unmappable_type_notes (tree); extern void cp_check_const_attributes (tree); -/* in error.c */ +/* in error.cc */ extern const char *type_as_string (tree, int); extern const char *type_as_string_translate (tree, int); extern const char *decl_as_string (tree, int); @@ -6942,7 +6942,7 @@ extern location_t location_of (tree); extern void qualified_name_lookup_error (tree, tree, tree, location_t); -/* in except.c */ +/* in except.cc */ extern void init_exception_processing (void); extern tree expand_start_catch_block (tree); extern void expand_end_catch_block (void); @@ -6971,7 +6971,7 @@ extern tree template_parms_to_args (tree); extern tree template_parms_level_to_args (tree); extern tree generic_targs_for (tree); -/* in expr.c */ +/* in expr.cc */ extern tree cplus_expand_constant (tree); extern tree mark_use (tree expr, bool rvalue_p, bool read_p, location_t = UNKNOWN_LOCATION, @@ -6985,7 +6985,7 @@ extern tree mark_type_use (tree); extern tree mark_discarded_use (tree); extern void mark_exp_read (tree); -/* friend.c */ +/* friend.cc */ extern int is_friend (tree, tree); extern void make_friend_class (tree, tree, bool); extern void add_friend (tree, tree, bool); @@ -6995,7 +6995,7 @@ extern tree do_friend (tree, tree, tree, extern void set_global_friend (tree); extern bool is_global_friend (tree); -/* in init.c */ +/* in init.cc */ extern tree expand_member_init (tree); extern void emit_mem_initializers (tree); extern tree build_aggr_init (tree, tree, int, @@ -7035,7 +7035,7 @@ extern int diagnose_uninitialized_cst_or_ref_member (tree, bool, bool); extern tree build_vtbl_address (tree); extern bool maybe_reject_flexarray_init (tree, tree); -/* in lex.c */ +/* in lex.cc */ extern void cxx_dup_lang_specific_decl (tree); extern tree unqualified_name_lookup_error (tree, location_t = UNKNOWN_LOCATION); @@ -7061,7 +7061,7 @@ extern uintptr_t module_token_cdtor (cpp_reader *, uintptr_t); extern uintptr_t module_token_lang (int type, int keyword, tree value, location_t, uintptr_t); -/* in method.c */ +/* in method.cc */ extern void init_method (void); extern tree make_thunk (tree, bool, tree, tree); extern void finish_thunk (tree); @@ -7191,10 +7191,10 @@ extern void module_begin_main_file (cpp_reader *, line_maps *, extern void module_preprocess_options (cpp_reader *); extern bool handle_module_option (unsigned opt, const char *arg, int value); -/* In optimize.c */ +/* In optimize.cc */ extern bool maybe_clone_body (tree); -/* In parser.c */ +/* In parser.cc */ extern tree cp_convert_range_for (tree, tree, tree, tree, unsigned int, bool, unsigned short); extern void cp_convert_omp_range_for (tree &, vec *, tree &, @@ -7208,7 +7208,7 @@ extern location_t defparse_location (tree); extern void maybe_show_extern_c_location (void); extern bool literal_integer_zerop (const_tree); -/* in pt.c */ +/* in pt.cc */ extern tree canonical_type_parameter (tree); extern void push_access_scope (tree); extern void pop_access_scope (tree); @@ -7406,7 +7406,7 @@ extern tree add_outermost_template_args (tree, tree); extern tree add_extra_args (tree, tree, tsubst_flags_t, tree); extern tree build_extra_args (tree, tree, tsubst_flags_t); -/* in rtti.c */ +/* in rtti.cc */ /* A vector of all tinfo decls that haven't been emitted yet. */ extern GTY(()) vec *unemitted_tinfo_decls; @@ -7424,7 +7424,7 @@ extern unsigned get_pseudo_tinfo_index (tree); extern tree get_pseudo_tinfo_type (unsigned); extern tree build_if_nonnull (tree, tree, tsubst_flags_t); -/* in search.c */ +/* in search.cc */ extern tree get_parent_with_private_access (tree decl, tree binfo); extern bool accessible_base_p (tree, tree, bool); extern tree lookup_base (tree, tree, base_access, @@ -7468,7 +7468,7 @@ extern bool shared_member_p (tree); extern bool any_dependent_bases_p (tree = current_nonlambda_class_type ()); extern bool maybe_check_overriding_exception_spec (tree, tree); -/* in semantics.c */ +/* in semantics.cc */ extern void push_deferring_access_checks (deferring_kind); extern void resume_deferring_access_checks (void); extern void stop_deferring_access_checks (void); @@ -7718,7 +7718,7 @@ extern tree most_general_lambda (tree); extern tree finish_omp_target (location_t, tree, tree, bool); extern void finish_omp_target_clauses (location_t, tree, tree *); -/* in tree.c */ +/* in tree.cc */ extern int cp_tree_operand_length (const_tree); extern int cp_tree_code_length (enum tree_code); extern void cp_free_lang_data (tree t); @@ -7873,7 +7873,7 @@ extern tree cxx_copy_lang_qualifiers (const_tree, const_tree); extern void cxx_print_statistics (void); extern bool maybe_warn_zero_as_null_pointer_constant (tree, location_t); -/* in ptree.c */ +/* in ptree.cc */ extern void cxx_print_xnode (FILE *, tree, int); extern void cxx_print_decl (FILE *, tree, int); extern void cxx_print_type (FILE *, tree, int); @@ -7882,7 +7882,7 @@ extern void cxx_print_error_function (diagnostic_context *, const char *, struct diagnostic_info *); -/* in typeck.c */ +/* in typeck.cc */ /* Says how we should behave when comparing two arrays one of which has unknown bounds. */ enum compare_bounds_t { bounds_none, bounds_either, bounds_first }; @@ -8059,7 +8059,7 @@ extern tree finish_binary_fold_expr (tree, tree, int); extern tree treat_lvalue_as_rvalue_p (tree, bool); extern bool decl_in_std_namespace_p (tree); -/* in typeck2.c */ +/* in typeck2.cc */ extern void require_complete_eh_spec_types (tree, tree); extern void cxx_incomplete_type_diagnostic (location_t, const_tree, const_tree, diagnostic_t); @@ -8129,7 +8129,7 @@ extern tree build_functional_cast (location_t, tree, tree, extern tree add_exception_specifier (tree, tree, tsubst_flags_t); extern tree merge_exception_specifiers (tree, tree); -/* in mangle.c */ +/* in mangle.cc */ extern void init_mangle (void); extern void mangle_decl (tree); extern const char *mangle_type_string (tree); @@ -8152,10 +8152,10 @@ extern void mangle_module_substitution (int); extern void mangle_identifier (char, tree); extern tree mangle_module_global_init (int); -/* in dump.c */ +/* in dump.cc */ extern bool cp_dump_tree (void *, tree); -/* In cp/cp-objcp-common.c. */ +/* In cp/cp-objcp-common.cc. */ extern alias_set_type cxx_get_alias_set (tree); extern bool cxx_warn_unused_global_decl (const_tree); @@ -8165,7 +8165,7 @@ extern void cxx_initialize_diagnostics (diagnostic_context *); extern int cxx_types_compatible_p (tree, tree); extern bool cxx_block_may_fallthru (const_tree); -/* in cp-gimplify.c */ +/* in cp-gimplify.cc */ extern int cp_gimplify_expr (tree *, gimple_seq *, gimple_seq *); extern void cp_genericize (tree); @@ -8192,7 +8192,7 @@ extern tree process_stmt_hotness_attribute (tree, location_t); extern bool simple_empty_class_p (tree, tree, tree_code); extern tree fold_builtin_source_location (location_t); -/* in name-lookup.c */ +/* in name-lookup.cc */ extern tree strip_using_decl (tree); /* Tell the binding oracle what kind of binding we are looking for. */ @@ -8206,7 +8206,7 @@ enum cp_oracle_request create bindings when needed by the C compiler. The oracle is told the name and type of the binding to create. It can call pushdecl or the like to ensure the binding is visible; or do nothing, - leaving the binding untouched. c-decl.c takes note of when the + leaving the binding untouched. c-decl.cc takes note of when the oracle has been called and will not call it again if it fails to create a given binding. */ @@ -8216,7 +8216,7 @@ extern cp_binding_oracle_function *cp_binding_oracle; /* Set during diagnostics to record the failed constraint. This is a TREE_LIST whose VALUE is the constraint and whose PURPOSE are the - instantiation arguments Defined in pt.c. */ + instantiation arguments Defined in pt.cc. */ extern tree current_failed_constraint; @@ -8324,18 +8324,18 @@ struct atom_hasher : default_hash_traits /* in logic.cc */ extern bool subsumes (tree, tree); -/* In class.c */ +/* In class.cc */ extern void set_current_access_from_decl (tree); extern void cp_finish_injected_record_type (tree); -/* in vtable-class-hierarchy.c */ +/* in vtable-class-hierarchy.cc */ extern void vtv_compute_class_hierarchy_transitive_closure (void); extern void vtv_generate_init_routine (void); extern void vtv_save_class_info (tree); extern void vtv_recover_class_info (void); extern void vtv_build_vtable_verify_fndecl (void); -/* In constexpr.c */ +/* In constexpr.cc */ /* Representation of entries in the constexpr function definition table. */ struct GTY((for_user)) constexpr_fundef { @@ -8416,7 +8416,7 @@ struct uid_sensitive_constexpr_evaluation_checker void cp_tree_c_finish_parsing (); -/* In cp-ubsan.c */ +/* In cp-ubsan.cc */ extern void cp_ubsan_maybe_instrument_member_call (tree); extern void cp_ubsan_instrument_member_accesses (tree *); extern tree cp_ubsan_maybe_instrument_downcast (location_t, tree, tree, tree); diff --git a/gcc/cp/cvt.cc b/gcc/cp/cvt.cc index 187ea88..e9803c1 100644 --- a/gcc/cp/cvt.cc +++ b/gcc/cp/cvt.cc @@ -52,12 +52,12 @@ static void diagnose_ref_binding (location_t, tree, tree, tree); Here is a list of all the functions that assume that widening and narrowing is always done with a NOP_EXPR: - In convert.c, convert_to_integer[_maybe_fold]. - In c-typeck.c, build_binary_op_nodefault (boolean ops), + In convert.cc, convert_to_integer[_maybe_fold]. + In c-typeck.cc, build_binary_op_nodefault (boolean ops), and c_common_truthvalue_conversion. - In expr.c: expand_expr, for operands of a MULT_EXPR. - In fold-const.c: fold. - In tree.c: get_narrower and get_unwidened. + In expr.cc: expand_expr, for operands of a MULT_EXPR. + In fold-const.cc: fold. + In tree.cc: get_narrower and get_unwidened. C++: in multiple-inheritance, converting between pointers may involve adjusting them by a delta stored within the class definition. */ @@ -1386,9 +1386,9 @@ convert_to_void (tree expr, impl_conv_void implicit, tsubst_flags_t complain) /* Emit a warning (if enabled) when the "effect-less" INDIRECT_REF operation is stripped off. Note that we don't warn about - an expression with TREE_NO_WARNING set. (For an example of - such expressions, see build_over_call in call.c.) + such expressions, see build_over_call in call.cc.) - automatic dereferencing of references, since the user cannot - control it. (See also warn_if_unused_value() in c-common.c.) */ + control it. (See also warn_if_unused_value() in c-common.cc.) */ if (warn_unused_value && implicit != ICV_CAST && (complain & tf_warning) @@ -1711,7 +1711,7 @@ convert_force (tree type, tree expr, int convtype, tsubst_flags_t complain) if (code == POINTER_TYPE) return convert_to_pointer_force (type, e, complain); - /* From typeck.c convert_for_assignment */ + /* From typeck.cc convert_for_assignment */ if (((TYPE_PTR_P (TREE_TYPE (e)) && TREE_CODE (e) == ADDR_EXPR && TREE_CODE (TREE_TYPE (TREE_TYPE (e))) == METHOD_TYPE) || integer_zerop (e) @@ -2008,7 +2008,7 @@ type_promotes_to (tree type) /* The routines below this point are carefully written to conform to the standard. They use the same terminology, and follow the rules - closely. Although they are used only in pt.c at the moment, they + closely. Although they are used only in pt.cc at the moment, they should presumably be used everywhere in the future. */ /* True iff EXPR can be converted to TYPE via a qualification conversion. diff --git a/gcc/cp/decl.cc b/gcc/cp/decl.cc index 0e37f1a..2dade75 100644 --- a/gcc/cp/decl.cc +++ b/gcc/cp/decl.cc @@ -4268,7 +4268,7 @@ make_unbound_class_template_raw (tree context, tree name, tree parm_list) The calls to set_global_binding below should be eliminated. Built-in types should not be looked up name; their names are keywords that the parser can recognize. However, there - is code in c-common.c that uses identifier_global_value to look up + is code in c-common.cc that uses identifier_global_value to look up built-in types by name. */ void @@ -4610,7 +4610,7 @@ cxx_init_decl_processing (void) else new_eh_spec = noexcept_false_spec; - /* Ensure attribs.c is initialized. */ + /* Ensure attribs.cc is initialized. */ init_attributes (); extvisattr = build_tree_list (get_identifier ("externally_visible"), @@ -9721,7 +9721,7 @@ check_class_member_definition_namespace (tree decl) /* These checks only apply to member functions and static data members. */ gcc_assert (VAR_OR_FUNCTION_DECL_P (decl)); - /* We check for problems with specializations in pt.c in + /* We check for problems with specializations in pt.cc in check_specialization_namespace, where we can issue better diagnostics. */ if (processing_specialization) @@ -18098,7 +18098,7 @@ cxx_maybe_build_cleanup (tree decl, tsubst_flags_t complain) id = TREE_VALUE (TREE_VALUE (attr)); /* Look up the name to find the cleanup function to call. It is important to use lookup_name here because that is what is - used in c-common.c:handle_cleanup_attribute when performing + used in c-common.cc:handle_cleanup_attribute when performing initial checks on the attribute. Note that those checks include ensuring that the function found is not an overloaded function, or an object with an overloaded call operator, diff --git a/gcc/cp/decl2.cc b/gcc/cp/decl2.cc index 899a800..69b9744 100644 --- a/gcc/cp/decl2.cc +++ b/gcc/cp/decl2.cc @@ -2449,7 +2449,7 @@ maybe_emit_vtables (tree ctype, vec &consteval_vtables) } /* For abstract classes, the destructor has been removed from the - vtable (in class.c's build_vtbl_initializer). For a compiler- + vtable (in class.cc's build_vtbl_initializer). For a compiler- generated destructor, it hence might not have been generated in this translation unit - and with '#pragma interface' it might never get generated. */ diff --git a/gcc/cp/error.cc b/gcc/cp/error.cc index 8a3b7b5..1ab0c25 100644 --- a/gcc/cp/error.cc +++ b/gcc/cp/error.cc @@ -1931,7 +1931,7 @@ dump_function_name (cxx_pretty_printer *pp, tree t, int flags) tree name = DECL_NAME (t); /* We can get here with a decl that was synthesized by language- - independent machinery (e.g. coverage.c) in which case it won't + independent machinery (e.g. coverage.cc) in which case it won't have a lang_specific structure attached and DECL_CONSTRUCTOR_P will crash. In this case it is safe just to print out the literal name. */ diff --git a/gcc/cp/init.cc b/gcc/cp/init.cc index ccc4f5e..668a84d 100644 --- a/gcc/cp/init.cc +++ b/gcc/cp/init.cc @@ -2340,7 +2340,7 @@ is_class_type (tree type, int or_else) @@ Prints out lousy diagnostics for operator @@ fields. - @@ This function should be rewritten and placed in search.c. */ + @@ This function should be rewritten and placed in search.cc. */ tree build_offset_ref (tree type, tree member, bool address_p, @@ -3260,7 +3260,7 @@ build_new_1 (vec **placement, tree type, tree nelts, to make sure it doesn't exceed the implementation-defined maximum, as required by C++ 14 (in C++ 11 this requirement isn't explicitly stated but it's enforced anyway -- see - grokdeclarator in cp/decl.c). */ + grokdeclarator in cp/decl.cc). */ if (complain & tf_error) { size = cp_fully_fold (size); diff --git a/gcc/cp/lang-specs.h b/gcc/cp/lang-specs.h index f69b86b..f35c9fa 100644 --- a/gcc/cp/lang-specs.h +++ b/gcc/cp/lang-specs.h @@ -17,7 +17,7 @@ You should have received a copy of the GNU General Public License along with GCC; see the file COPYING3. If not see . */ -/* This is the contribution to the `default_compilers' array in gcc.c for +/* This is the contribution to the `default_compilers' array in gcc.cc for g++. */ #ifndef CPLUSPLUS_CPP_SPEC diff --git a/gcc/cp/method.cc b/gcc/cp/method.cc index fe1147c..903ee66 100644 --- a/gcc/cp/method.cc +++ b/gcc/cp/method.cc @@ -37,7 +37,7 @@ static void do_build_copy_assign (tree); static void do_build_copy_constructor (tree); static tree make_alias_for_thunk (tree); -/* Called once to initialize method.c. */ +/* Called once to initialize method.cc. */ void init_method (void) diff --git a/gcc/cp/module.cc b/gcc/cp/module.cc index 0134130..81ceef9 100644 --- a/gcc/cp/module.cc +++ b/gcc/cp/module.cc @@ -12823,7 +12823,7 @@ specialization_add (bool decl_p, spec_entry *entry, void *data_) { /* We exclusively use decls to locate things. Make sure there's no mismatch between the two specialization tables we keep. - pt.c optimizes instantiation lookup using a complicated + pt.cc optimizes instantiation lookup using a complicated heuristic. We don't attempt to replicate that algorithm, but observe its behaviour and reproduce it upon read back. */ @@ -14879,7 +14879,7 @@ module_state::read_cluster (unsigned snum) } } - /* Look, function.c's interface to cfun does too much for us, we + /* Look, function.cc's interface to cfun does too much for us, we just need to restore the old value. I do not want to go redesigning that API right now. */ #undef cfun diff --git a/gcc/cp/name-lookup.cc b/gcc/cp/name-lookup.cc index caa23d3..29b7f2e 100644 --- a/gcc/cp/name-lookup.cc +++ b/gcc/cp/name-lookup.cc @@ -3073,7 +3073,7 @@ check_extern_c_conflict (tree decl) } /* Returns a list of C-linkage decls with the name NAME. Used in - c-family/c-pragma.c to implement redefine_extname pragma. */ + c-family/c-pragma.cc to implement redefine_extname pragma. */ tree c_linkage_bindings (tree name) diff --git a/gcc/cp/name-lookup.h b/gcc/cp/name-lookup.h index 781d6b9..68d0872 100644 --- a/gcc/cp/name-lookup.h +++ b/gcc/cp/name-lookup.h @@ -59,7 +59,7 @@ struct GTY(()) cxx_binding { }; /* Datatype used to temporarily save C++ bindings (for implicit - instantiations purposes and like). Implemented in decl.c. */ + instantiations purposes and like). Implemented in decl.cc. */ struct GTY(()) cxx_saved_binding { /* The name of the current binding. */ tree identifier; diff --git a/gcc/cp/parser.cc b/gcc/cp/parser.cc index 97e9aea..b262b76 100644 --- a/gcc/cp/parser.cc +++ b/gcc/cp/parser.cc @@ -51,7 +51,7 @@ along with GCC; see the file COPYING3. If not see /* The lexer. */ /* The cp_lexer_* routines mediate between the lexer proper (in libcpp - and c-lex.c) and the C++ parser. */ + and c-lex.cc) and the C++ parser. */ /* The various kinds of non integral constant we encounter. */ enum non_integral_constant { @@ -4339,7 +4339,7 @@ cp_parser_identifier (cp_parser* parser) However, C99 6.4.5p4 says that this results in a wide string literal. We follow C99 here, for consistency with the C front end. - This code is largely lifted from lex_string() in c-lex.c. + This code is largely lifted from lex_string() in c-lex.cc. FUTURE: ObjC++ will need to handle @-strings here. */ static cp_expr diff --git a/gcc/cp/parser.h b/gcc/cp/parser.h index 163c487..d688fd1 100644 --- a/gcc/cp/parser.h +++ b/gcc/cp/parser.h @@ -434,7 +434,7 @@ struct GTY(()) cp_parser { }; -/* In parser.c */ +/* In parser.cc */ extern void debug (cp_token &ref); extern void debug (cp_token *ptr); extern void cp_lexer_debug_tokens (vec *); diff --git a/gcc/cp/pt.cc b/gcc/cp/pt.cc index 0fa4a16..4a2b33e 100644 --- a/gcc/cp/pt.cc +++ b/gcc/cp/pt.cc @@ -6765,7 +6765,7 @@ has_value_dependent_address (tree op) /* The next set of functions are used for providing helpful explanatory diagnostics for failed overload resolution. Their messages should be indented by two spaces for consistency with the messages in - call.c */ + call.cc */ static int unify_success (bool /*explain_p*/) @@ -10963,7 +10963,7 @@ push_tinst_level_loc (tree tldcl, tree targs, location_t loc) if (tinst_depth >= max_tinst_depth) { - /* Tell error.c not to try to instantiate any templates. */ + /* Tell error.cc not to try to instantiate any templates. */ at_eof = 2; fatal_error (input_location, "template instantiation depth exceeds maximum of %d" diff --git a/gcc/cp/semantics.cc b/gcc/cp/semantics.cc index 089ea5f..8e22944 100644 --- a/gcc/cp/semantics.cc +++ b/gcc/cp/semantics.cc @@ -5,7 +5,7 @@ Copyright (C) 1998-2022 Free Software Foundation, Inc. Written by Mark Mitchell (mmitchell@usa.net) based on code found - formerly in parse.y and pt.c. + formerly in parse.y and pt.cc. This file is part of GCC. @@ -8009,7 +8009,7 @@ finish_omp_clauses (tree clauses, enum c_omp_region_type ort) || OMP_CLAUSE_MAP_KIND (c) == GOMP_MAP_DETACH)) /* For attach/detach clauses, set OMP_CLAUSE_SIZE (representing a bias) to zero here, so it is not set erroneously to the pointer - size later on in gimplify.c. */ + size later on in gimplify.cc. */ OMP_CLAUSE_SIZE (c) = size_zero_node; if (REFERENCE_REF_P (t) && TREE_CODE (TREE_OPERAND (t, 0)) == COMPONENT_REF) @@ -10781,7 +10781,7 @@ finish_omp_atomic (location_t loc, enum tree_code code, enum tree_code opcode, } /* Avoid -Wunused-value warnings here, the whole construct has side-effects - and even if it might be wrapped from fold-const.c or c-omp.c wrapped + and even if it might be wrapped from fold-const.cc or c-omp.cc wrapped in some tree that appears to be unused, the value is not unused. */ warning_sentinel w (warn_unused_value); finish_expr_stmt (stmt); diff --git a/gcc/cp/tree.cc b/gcc/cp/tree.cc index 7f7de86..d27f64f 100644 --- a/gcc/cp/tree.cc +++ b/gcc/cp/tree.cc @@ -5542,7 +5542,7 @@ cp_save_expr (tree expr) return save_expr (expr); } -/* Initialize tree.c. */ +/* Initialize tree.cc. */ void init_tree (void) @@ -6000,7 +6000,7 @@ cp_free_lang_data (tree t) DECL_CHAIN (t) = NULL_TREE; } -/* Stub for c-common. Please keep in sync with c-decl.c. +/* Stub for c-common. Please keep in sync with c-decl.cc. FIXME: If address space support is target specific, then this should be a C target hook. But currently this is not possible, because this function is called via REGISTER_TARGET_PRAGMAS. */ diff --git a/gcc/cp/typeck.cc b/gcc/cp/typeck.cc index 8029b2b..3a28d63 100644 --- a/gcc/cp/typeck.cc +++ b/gcc/cp/typeck.cc @@ -395,7 +395,7 @@ cp_common_type (tree t1, tree t2) /* For __intN types, either the type is __int128 (and is lower priority than the types checked above, but higher than other 128-bit types) or it's known to not be the same size as other - types (enforced in toplev.c). Prefer the unsigned type. */ + types (enforced in toplev.cc). Prefer the unsigned type. */ for (i = 0; i < NUM_INT_N_ENTS; i ++) { if (int_n_enabled_p [i] @@ -948,7 +948,7 @@ strip_array_domain (tree type) return cp_build_type_attribute_variant (t2, TYPE_ATTRIBUTES (type)); } -/* Wrapper around cp_common_type that is used by c-common.c and other +/* Wrapper around cp_common_type that is used by c-common.cc and other front end optimizations that remove promotions. Return the common type for two arithmetic types T1 and T2 under the @@ -2584,7 +2584,7 @@ rationalize_conditional_expr (enum tree_code code, tree t, { location_t loc = cp_expr_loc_or_input_loc (t); - /* For MIN_EXPR or MAX_EXPR, fold-const.c has arranged things so that + /* For MIN_EXPR or MAX_EXPR, fold-const.cc has arranged things so that the first operand is always the one to be used if both operands are equal, so we know what conditional expression this used to be. */ if (TREE_CODE (t) == MIN_EXPR || TREE_CODE (t) == MAX_EXPR) @@ -10529,7 +10529,7 @@ check_return_expr (tree retval, bool *no_warning) current_function_returns_value = 1; /* And signal caller that TREE_NO_WARNING should be set on the RETURN_EXPR to avoid control reaches end of non-void function - warnings in tree-cfg.c. */ + warnings in tree-cfg.cc. */ *no_warning = true; } /* Check for a return statement with a value in a function that diff --git a/gcc/cp/vtable-class-hierarchy.cc b/gcc/cp/vtable-class-hierarchy.cc index 4c6e2f2..79cb5f8 100644 --- a/gcc/cp/vtable-class-hierarchy.cc +++ b/gcc/cp/vtable-class-hierarchy.cc @@ -108,7 +108,7 @@ along with GCC; see the file COPYING3. If not see structures used for collecting the class hierarchy data and building/maintaining the vtable map variable data are defined in gcc/vtable-verify.h, because they are used both here and in - gcc/vtable-verify.c. */ + gcc/vtable-verify.cc. */ #include "config.h" #include "system.h" diff --git a/gcc/cppdefault.h b/gcc/cppdefault.h index 95def39..fb97c0b 100644 --- a/gcc/cppdefault.h +++ b/gcc/cppdefault.h @@ -35,7 +35,7 @@ struct default_include { const char *const fname; /* The name of the directory. */ const char *const component; /* The component containing the directory - (see update_path in prefix.c) */ + (see update_path in prefix.cc) */ const char cplusplus; /* When this is non-zero, we should only consider this if we're compiling C++. When the -stdlib option is configured, this diff --git a/gcc/cprop.cc b/gcc/cprop.cc index c60f7e5..cf01c2d 100644 --- a/gcc/cprop.cc +++ b/gcc/cprop.cc @@ -1310,7 +1310,7 @@ local_cprop_pass (void) /* Similar to get_condition, only the resulting condition must be valid at JUMP, instead of at EARLIEST. - This differs from noce_get_condition in ifcvt.c in that we prefer not to + This differs from noce_get_condition in ifcvt.cc in that we prefer not to settle for the condition variable in the jump instruction being integral. We prefer to be able to record the value of a user variable, rather than the value of a temporary used in a condition. This could be solved by @@ -1909,7 +1909,7 @@ one_cprop_pass (void) /* All the passes implemented in this file. Each pass has its own gate and execute function, and at the end of the file a - pass definition for passes.c. + pass definition for passes.cc. We do not construct an accurate cfg in functions which call setjmp, so none of these passes runs if the function calls diff --git a/gcc/cse.cc b/gcc/cse.cc index 94acdb9..a18b599 100644 --- a/gcc/cse.cc +++ b/gcc/cse.cc @@ -2402,7 +2402,7 @@ hash_rtx_cb (const_rtx x, machine_mode mode, handling since the MEM may be BLKmode which normally prevents an entry from being made. Pure calls are marked by a USE which mentions BLKmode memory. - See calls.c:emit_call_1. */ + See calls.cc:emit_call_1. */ if (MEM_P (XEXP (x, 0)) && ! MEM_VOLATILE_P (XEXP (x, 0))) { @@ -3586,7 +3586,7 @@ fold_rtx (rtx x, rtx_insn *insn) is known to be of similar form, we may be able to replace the operation with a combined operation. This may eliminate the intermediate operation if every use is simplified in this way. - Note that the similar optimization done by combine.c only works + Note that the similar optimization done by combine.cc only works if the intermediate operation's result has only one reference. */ if (REG_P (folded_arg0) diff --git a/gcc/ctfc.h b/gcc/ctfc.h index 08e7bc8..4c22c17 100644 --- a/gcc/ctfc.h +++ b/gcc/ctfc.h @@ -22,7 +22,7 @@ along with GCC; see the file COPYING3. If not see representations and closely reflect the CTF format requirements in . The contents of the CTF container are used eventually for emission of both - CTF (ctfout.c) and BTF debug info (btfout.c), as the two type debug formats + CTF (ctfout.cc) and BTF debug info (btfout.cc), as the two type debug formats are close cousins. */ #ifndef GCC_CTFC_H @@ -372,7 +372,7 @@ extern size_t ctfc_get_num_vlen_bytes (ctf_container_ref); /* These APIs allow to initialize and finalize the CTF machinery and to add types to the CTF container associated to the current - translation unit. Used in dwarf2ctf.c. */ + translation unit. Used in dwarf2ctf.cc. */ extern void ctf_init (void); extern void ctf_output (const char * filename); diff --git a/gcc/d/d-gimplify.cc b/gcc/d/d-gimplify.cc index 1fad654..fbeb607 100644 --- a/gcc/d/d-gimplify.cc +++ b/gcc/d/d-gimplify.cc @@ -1,4 +1,4 @@ -/* D-specific tree lowering bits; see also gimple.c. +/* D-specific tree lowering bits; see also gimple.cc. Copyright (C) 2020-2022 Free Software Foundation, Inc. GCC is free software; you can redistribute it and/or modify diff --git a/gcc/d/d-incpath.cc b/gcc/d/d-incpath.cc index 4da0143..68d4796 100644 --- a/gcc/d/d-incpath.cc +++ b/gcc/d/d-incpath.cc @@ -26,7 +26,7 @@ along with GCC; see the file COPYING3. If not see /* Look for directories that start with the standard prefix. "Translate" them, i.e: replace /usr/local/lib/gcc with - IPREFIX and search them first. Based on incpath.c. */ + IPREFIX and search them first. Based on incpath.cc. */ static char * prefixed_path (const char *path, const char *iprefix) diff --git a/gcc/d/lang-specs.h b/gcc/d/lang-specs.h index b08b89f..7d3c119 100644 --- a/gcc/d/lang-specs.h +++ b/gcc/d/lang-specs.h @@ -15,7 +15,7 @@ You should have received a copy of the GNU General Public License along with GCC; see the file COPYING3. If not see . */ -/* This is the contribution to the `default_compilers' array in gcc.c +/* This is the contribution to the `default_compilers' array in gcc.cc for the D language. */ {".d", "@d", 0, 1, 0 }, diff --git a/gcc/data-streamer.h b/gcc/data-streamer.h index 825aaab..df01d00 100644 --- a/gcc/data-streamer.h +++ b/gcc/data-streamer.h @@ -43,13 +43,13 @@ struct bitpack_d void *stream; }; -/* In data-streamer.c */ +/* In data-streamer.cc */ void bp_pack_var_len_unsigned (struct bitpack_d *, unsigned HOST_WIDE_INT); void bp_pack_var_len_int (struct bitpack_d *, HOST_WIDE_INT); unsigned HOST_WIDE_INT bp_unpack_var_len_unsigned (struct bitpack_d *); HOST_WIDE_INT bp_unpack_var_len_int (struct bitpack_d *); -/* In data-streamer-out.c */ +/* In data-streamer-out.cc */ void streamer_write_zero (struct output_block *); void streamer_write_uhwi (struct output_block *, unsigned HOST_WIDE_INT); void streamer_write_hwi (struct output_block *, HOST_WIDE_INT); @@ -74,7 +74,7 @@ void streamer_write_data_stream (struct lto_output_stream *, const void *, void streamer_write_wide_int (struct output_block *, const wide_int &); void streamer_write_widest_int (struct output_block *, const widest_int &); -/* In data-streamer-in.c */ +/* In data-streamer-in.cc */ const char *streamer_read_string (class data_in *, class lto_input_block *); const char *streamer_read_indexed_string (class data_in *, class lto_input_block *, diff --git a/gcc/dbgcnt.def b/gcc/dbgcnt.def index 455d47b..3aa18cd 100644 --- a/gcc/dbgcnt.def +++ b/gcc/dbgcnt.def @@ -48,7 +48,7 @@ along with GCC; see the file COPYING3. If not see or for each copy instruction in register coalescing, or constant-propagation for each insn, or a block straightening, etc. - See dce.c for an example. With the dbg_cnt () call in dce.c, + See dce.cc for an example. With the dbg_cnt () call in dce.cc, now a developer can use -fdbg-cnt=dce:N to stop doing the dead code elimination after N times. diff --git a/gcc/dbxout.cc b/gcc/dbxout.cc index a3f0586..878d528 100644 --- a/gcc/dbxout.cc +++ b/gcc/dbxout.cc @@ -1400,7 +1400,7 @@ dbxout_early_global_decl (tree decl ATTRIBUTE_UNUSED) /* NYI for non-dwarf. */ } -/* Debug information for a global DECL. Called from toplev.c after +/* Debug information for a global DECL. Called from toplev.cc after compilation proper has finished. */ static void dbxout_late_global_decl (tree decl) @@ -3324,7 +3324,7 @@ dbxout_common_check (tree decl, int *value) ??? DECL_THREAD_LOCAL_P check prevents problems with improper .stabs for thread-local symbols. Can be handled via same mechanism as used - in dwarf2out.c. */ + in dwarf2out.cc. */ if (!VAR_P (decl) || !TREE_STATIC (decl) || !DECL_HAS_VALUE_EXPR_P (decl) diff --git a/gcc/dbxout.h b/gcc/dbxout.h index 2c57c7f..2c38e76 100644 --- a/gcc/dbxout.h +++ b/gcc/dbxout.h @@ -1,4 +1,4 @@ -/* dbxout.h - Various declarations for functions found in dbxout.c +/* dbxout.h - Various declarations for functions found in dbxout.cc Copyright (C) 1998-2022 Free Software Foundation, Inc. This file is part of GCC. diff --git a/gcc/debug.h b/gcc/debug.h index c1de725..17a7e48 100644 --- a/gcc/debug.h +++ b/gcc/debug.h @@ -20,7 +20,7 @@ /* This structure contains hooks for the debug information output functions, accessed through the global instance debug_hooks set in - toplev.c according to command line options. */ + toplev.cc according to command line options. */ /* WARNING: Do not add new debug hook targets - DWARF will be the only way to speak debug to the middle-end once we are able to get rid of the remaining targets. If you need alternate output formats instead @@ -130,7 +130,7 @@ struct gcc_debug_hooks void (* early_global_decl) (tree decl); /* Augment debug information generated by early_global_decl with - more complete debug info (if applicable). Called from toplev.c + more complete debug info (if applicable). Called from toplev.cc after the compilation proper has finished and cgraph information is available. @@ -143,7 +143,7 @@ struct gcc_debug_hooks to the hook to use what it needs. */ void (* late_global_decl) (tree decl); - /* Debug information for a type DECL. Called from toplev.c after + /* Debug information for a type DECL. Called from toplev.cc after compilation proper, also from various language front ends to record built-in types. The second argument is properly a boolean, which indicates whether or not the type is a "local" @@ -264,7 +264,7 @@ extern bool dwarf2out_default_as_locview_support (void); extern const struct gcc_debug_hooks * dump_go_spec_init (const char *, const struct gcc_debug_hooks *); -/* Instance discriminator mapping table. See final.c. */ +/* Instance discriminator mapping table. See final.cc. */ typedef hash_map decl_to_instance_map_t; extern decl_to_instance_map_t *decl_to_instance_map; diff --git a/gcc/df-core.cc b/gcc/df-core.cc index b0edcca..a901b84 100644 --- a/gcc/df-core.cc +++ b/gcc/df-core.cc @@ -28,7 +28,7 @@ The files in this collection (df*.c,df.h) provide a general framework for solving dataflow problems. The global dataflow is performed using a good implementation of iterative dataflow analysis. -The file df-problems.c provides problem instance for the most common +The file df-problems.cc provides problem instance for the most common dataflow problems: reaching defs, upward exposed uses, live variables, uninitialized variables, def-use chains, and use-def chains. However, the interface allows other dataflow problems to be defined as well. @@ -240,7 +240,7 @@ keep the dataflow information up to data (if this is really what is needed) it to formulate a problem specific solution. There are fine grained calls for creating and deleting references from -instructions in df-scan.c. However, these are not currently connected +instructions in df-scan.cc. However, these are not currently connected to the engine that resolves the dataflow equations. diff --git a/gcc/df-scan.cc b/gcc/df-scan.cc index 4e3291a..5df70e9 100644 --- a/gcc/df-scan.cc +++ b/gcc/df-scan.cc @@ -104,7 +104,7 @@ static void df_insn_info_delete (unsigned int); /* Indexed by hardware reg number, is true if that register is ever used in the current function. - In df-scan.c, this is set up to record the hard regs used + In df-scan.cc, this is set up to record the hard regs used explicitly. Reload adds in the hard regs used for holding pseudo regs. Final uses it to generate the code in the function prologue and epilogue to save and restore registers as needed. */ @@ -938,7 +938,7 @@ df_insn_delete (rtx_insn *insn) bb = BLOCK_FOR_INSN (insn); /* ??? bb can be NULL after pass_free_cfg. At that point, DF should - not exist anymore (as mentioned in df-core.c: "The only requirement + not exist anymore (as mentioned in df-core.cc: "The only requirement [for DF] is that there be a correct control flow graph." Clearly that isn't the case after pass_free_cfg. But DF is freed much later because some back-ends want to use DF info even though the CFG is diff --git a/gcc/df.h b/gcc/df.h index 1648e7c..bd32920 100644 --- a/gcc/df.h +++ b/gcc/df.h @@ -800,7 +800,7 @@ public: /* An obstack for bitmap not related to specific dataflow problems. This obstack should e.g. be used for bitmaps with a short life time - such as temporary bitmaps. This obstack is declared in df-core.c. */ + such as temporary bitmaps. This obstack is declared in df-core.cc. */ extern bitmap_obstack df_bitmap_obstack; @@ -959,7 +959,7 @@ extern class df_d *df; #endif -/* Functions defined in df-core.c. */ +/* Functions defined in df-core.cc. */ extern void df_add_problem (const struct df_problem *); extern int df_set_flags (int); @@ -1015,7 +1015,7 @@ extern void debug_df_useno (unsigned int); extern void debug_df_ref (df_ref); extern void debug_df_chain (struct df_link *); -/* Functions defined in df-problems.c. */ +/* Functions defined in df-problems.cc. */ extern struct df_link *df_chain_create (df_ref, df_ref); extern void df_chain_unlink (df_ref); @@ -1058,7 +1058,7 @@ extern bool can_move_insns_across (rtx_insn *, rtx_insn *, rtx_insn *, rtx_insn *, basic_block, regset, regset, rtx_insn **); -/* Functions defined in df-scan.c. */ +/* Functions defined in df-scan.cc. */ extern void df_scan_alloc (bitmap); extern void df_scan_add_problem (void); diff --git a/gcc/dfp.cc b/gcc/dfp.cc index fa54254..7c1db7d 100644 --- a/gcc/dfp.cc +++ b/gcc/dfp.cc @@ -366,7 +366,7 @@ decimal_from_binary (REAL_VALUE_TYPE *to, const REAL_VALUE_TYPE *from) decimal_real_from_string (to, string); } -/* Helper function to real.c:do_compare() to handle decimal internal +/* Helper function to real.cc:do_compare() to handle decimal internal representation including when one of the operands is still in the binary internal representation. */ diff --git a/gcc/diagnostic-color.cc b/gcc/diagnostic-color.cc index fa30707..640adfa 100644 --- a/gcc/diagnostic-color.cc +++ b/gcc/diagnostic-color.cc @@ -205,7 +205,7 @@ should_colorize (void) #ifdef __MINGW32__ /* For consistency reasons, one should check the handle returned by _get_osfhandle(_fileno(stderr)) because the function - pp_write_text_to_stream() in pretty-print.c calls fputs() on + pp_write_text_to_stream() in pretty-print.cc calls fputs() on that stream. However, the code below for non-Windows doesn't seem to care about it either... */ HANDLE h; diff --git a/gcc/diagnostic-event-id.h b/gcc/diagnostic-event-id.h index 07e6a23..35c6697 100644 --- a/gcc/diagnostic-event-id.h +++ b/gcc/diagnostic-event-id.h @@ -29,7 +29,7 @@ along with GCC; see the file COPYING3. If not see For example, a 3-event path has event offsets 0, 1, and 2, which would be shown to the user as "(1)", "(2)" and "(3)". - This has its own header so that pretty-print.c can use this + This has its own header so that pretty-print.cc can use this to implement "%@" without bringing in all of diagnostic_path (which e.g. refers to "tree"). */ diff --git a/gcc/diagnostic-show-locus.cc b/gcc/diagnostic-show-locus.cc index cc69eaa..0465788 100644 --- a/gcc/diagnostic-show-locus.cc +++ b/gcc/diagnostic-show-locus.cc @@ -3746,7 +3746,7 @@ test_one_liner_labels () } /* TODO: example of formatted printing (needs to be in - gcc-rich-location.c due to Makefile.in issues). */ + gcc-rich-location.cc due to Makefile.in issues). */ } /* Run the various one-liner tests. */ diff --git a/gcc/diagnostic.cc b/gcc/diagnostic.cc index 5c02ff0..97e2e2c 100644 --- a/gcc/diagnostic.cc +++ b/gcc/diagnostic.cc @@ -531,10 +531,10 @@ bt_callback (void *data, uintptr_t pc, const char *filename, int lineno, if (filename == NULL && function == NULL) return 0; - /* Skip functions in diagnostic.c. */ + /* Skip functions in diagnostic.cc. */ if (*pcount == 0 && filename != NULL - && strcmp (lbasename (filename), "diagnostic.c") == 0) + && strcmp (lbasename (filename), "diagnostic.cc") == 0) return 0; /* Print up to 20 functions. We could make this a --param, but @@ -1437,8 +1437,8 @@ num_digits (int value) /* Given a partial pathname as input, return another pathname that shares no directory elements with the pathname of __FILE__. This - is used by fancy_abort() to print `Internal compiler error in expr.c' - instead of `Internal compiler error in ../../GCC/gcc/expr.c'. */ + is used by fancy_abort() to print `Internal compiler error in expr.cc' + instead of `Internal compiler error in ../../GCC/gcc/expr.cc'. */ const char * trim_filename (const char *name) diff --git a/gcc/doc/avr-mmcu.texi b/gcc/doc/avr-mmcu.texi index 090088f..8c09f08 100644 --- a/gcc/doc/avr-mmcu.texi +++ b/gcc/doc/avr-mmcu.texi @@ -3,9 +3,9 @@ @c For copying conditions, see the file gcc/doc/include/fdl.texi. @c This file is generated automatically using -@c gcc/config/avr/gen-avr-mmcu-texi.c from: +@c gcc/config/avr/gen-avr-mmcu-texi.cc from: @c gcc/config/avr/avr-arch.h -@c gcc/config/avr/avr-devices.c +@c gcc/config/avr/avr-devices.cc @c gcc/config/avr/avr-mcus.def @c Please do not edit manually. diff --git a/gcc/doc/cfg.texi b/gcc/doc/cfg.texi index 2805845..32aacdd 100644 --- a/gcc/doc/cfg.texi +++ b/gcc/doc/cfg.texi @@ -670,7 +670,7 @@ In general @code{LIVE} is the most useful of the three. The macros The macros take a basic block number and return a bitmap that is indexed by the register number. This information is only guaranteed to be up to date after calls are made to @code{df_analyze}. See the file -@code{df-core.c} for details on using the dataflow. +@code{df-core.cc} for details on using the dataflow. @findex REG_DEAD, REG_UNUSED diff --git a/gcc/doc/contrib.texi b/gcc/doc/contrib.texi index 419436e..e14cf5e 100644 --- a/gcc/doc/contrib.texi +++ b/gcc/doc/contrib.texi @@ -668,7 +668,7 @@ entire Debian archive. @item David Miller for his direction via the steering committee, lots of -SPARC work, improvements in jump.c and interfacing with the Linux kernel +SPARC work, improvements in jump.cc and interfacing with the Linux kernel developers. @item diff --git a/gcc/doc/cppinternals.texi b/gcc/doc/cppinternals.texi index f308eee..75adbbe 100644 --- a/gcc/doc/cppinternals.texi +++ b/gcc/doc/cppinternals.texi @@ -131,7 +131,7 @@ behavior. @cindex escaped newlines @section Overview -The lexer is contained in the file @file{lex.c}. It is a hand-coded +The lexer is contained in the file @file{lex.cc}. It is a hand-coded lexer, and not implemented as a state machine. It can understand C, C++ and Objective-C source code, and has been extended to allow reasonably successful preprocessing of assembly language. The lexer does not make @@ -853,7 +853,7 @@ This variable therefore uniquely enumerates each line in the translation unit. With some simple infrastructure, it is straight forward to map from this to the original source file and line number pair, saving space whenever line number information needs to be saved. The code the -implements this mapping lies in the files @file{line-map.c} and +implements this mapping lies in the files @file{line-map.cc} and @file{line-map.h}. Command-line macros and assertions are implemented by pushing a buffer @@ -996,7 +996,7 @@ is turned off. @cindex files Fairly obviously, the file handling code of cpplib resides in the file -@file{files.c}. It takes care of the details of file searching, +@file{files.cc}. It takes care of the details of file searching, opening, reading and caching, for both the main source file and all the headers it recursively includes. diff --git a/gcc/doc/extend.texi b/gcc/doc/extend.texi index 20a5944..0775d97 100644 --- a/gcc/doc/extend.texi +++ b/gcc/doc/extend.texi @@ -7965,7 +7965,7 @@ If the location does not fit the address range of @code{LDS} and @code{STS}, there is currently (Binutils 2.26) just an unspecific warning like @quotation -@code{module.c:(.text+0x1c): warning: internal error: out of range error} +@code{module.cc:(.text+0x1c): warning: internal error: out of range error} @end quotation @end itemize diff --git a/gcc/doc/generic.texi b/gcc/doc/generic.texi index bb07775..3e5b06a 100644 --- a/gcc/doc/generic.texi +++ b/gcc/doc/generic.texi @@ -912,7 +912,7 @@ tree_contains_struct[FOO_DECL][TS_DECL_MINIMAL] = 1; @end smallexample For @code{DECL} nodes that are part of the middle-end, the setup code -goes into @file{tree.c}. +goes into @file{tree.cc}. @item Add macros to access any new fields and flags @@ -933,7 +933,7 @@ structures, something like the following should be used @end smallexample Reading them from the generated @file{all-tree.def} file (which in -turn includes all the @file{tree.def} files), @file{gencheck.c} is +turn includes all the @file{tree.def} files), @file{gencheck.cc} is used during GCC's build to generate the @code{*_CHECK} macros for all tree codes. @@ -2371,8 +2371,8 @@ label the critical section. This does not represent any OpenMP directive, it is an artificial marker to indicate the end of the body of an OpenMP@. It is used -by the flow graph (@code{tree-cfg.c}) and OpenMP region -building code (@code{omp-low.c}). +by the flow graph (@code{tree-cfg.cc}) and OpenMP region +building code (@code{omp-low.cc}). @item OMP_CONTINUE diff --git a/gcc/doc/gimple.texi b/gcc/doc/gimple.texi index 65ef63d..dd91493 100644 --- a/gcc/doc/gimple.texi +++ b/gcc/doc/gimple.texi @@ -2691,21 +2691,21 @@ modifying the file @code{gimple.def}, which contains all the GIMPLE codes. Then you must add a corresponding gimple subclass located in @code{gimple.h}. This in turn, will require you to add a corresponding @code{GTY} tag in @code{gsstruct.def}, and code to handle -this tag in @code{gss_for_code} which is located in @code{gimple.c}. +this tag in @code{gss_for_code} which is located in @code{gimple.cc}. In order for the garbage collector to know the size of the structure you created in @code{gimple.h}, you need to add a case to handle your new GIMPLE statement in @code{gimple_size} which is located -in @code{gimple.c}. +in @code{gimple.cc}. You will probably want to create a function to build the new -gimple statement in @code{gimple.c}. The function should be called +gimple statement in @code{gimple.cc}. The function should be called @code{gimple_build_@var{new-tuple-name}}, and should return the new tuple as a pointer to the appropriate gimple subclass. If your new statement requires accessors for any members or operands it may have, put simple inline accessors in -@code{gimple.h} and any non-trivial accessors in @code{gimple.c} with a +@code{gimple.h} and any non-trivial accessors in @code{gimple.cc} with a corresponding prototype in @code{gimple.h}. You should add the new statement subclass to the class hierarchy diagram diff --git a/gcc/doc/gty.texi b/gcc/doc/gty.texi index 6ba41ad..81aafd1 100644 --- a/gcc/doc/gty.texi +++ b/gcc/doc/gty.texi @@ -390,7 +390,7 @@ they are saved and restored correctly to PCH files. The @code{special} option is used to mark types that have to be dealt with by special case machinery. The parameter is the name of the -special case. See @file{gengtype.c} for further details. Avoid +special case. See @file{gengtype.cc} for further details. Avoid adding new special cases unless there is no other alternative. @findex user @@ -637,15 +637,15 @@ in the right place to be visible to the generated files. For a back-end header file, this should be done automatically. For a front-end header file, it needs to be included by the same file that includes @file{gtype-@var{lang}.h}. For other header files, it needs to be -included in @file{gtype-desc.c}, which is a generated file, so add it to -@code{ifiles} in @code{open_base_file} in @file{gengtype.c}. +included in @file{gtype-desc.cc}, which is a generated file, so add it to +@code{ifiles} in @code{open_base_file} in @file{gengtype.cc}. For source files that aren't header files, the machinery will generate a header file that should be included in the source file you just changed. The file will be called @file{gt-@var{path}.h} where @var{path} is the pathname relative to the @file{gcc} directory with slashes replaced by @verb{|-|}, so for example the header file to be included in -@file{cp/parser.c} is called @file{gt-cp-parser.h}. The +@file{cp/parser.cc} is called @file{gt-cp-parser.h}. The generated header file should be included after everything else in the source file. diff --git a/gcc/doc/invoke.texi b/gcc/doc/invoke.texi index 7f2205e..96a64f3 100644 --- a/gcc/doc/invoke.texi +++ b/gcc/doc/invoke.texi @@ -10711,7 +10711,7 @@ With @option{-O}, the compiler tries to reduce code size and execution time, without performing any optimizations that take a great deal of compilation time. -@c Note that in addition to the default_options_table list in opts.c, +@c Note that in addition to the default_options_table list in opts.cc, @c several optimization flags default to true but control optimization @c passes that are explicitly disabled at -O0. @@ -13448,7 +13448,7 @@ and the same optimization options for both compilations. With @option{-fbranch-probabilities}, GCC puts a @samp{REG_BR_PROB} note on each @samp{JUMP_INSN} and @samp{CALL_INSN}. These can be used to improve optimization. Currently, they are only -used in one place: in @file{reorg.c}, instead of guessing which path a +used in one place: in @file{reorg.cc}, instead of guessing which path a branch is most likely to take, the @samp{REG_BR_PROB} values are used to exactly determine which path is taken more often. @@ -14741,7 +14741,7 @@ Algorithm 2 was designed to be a compromise between the relatively conservative approach taken by algorithm 1 and the rather aggressive approach taken by the default scheduler. It relies more heavily on having a regular register file and accurate register pressure classes. -See @file{haifa-sched.c} in the GCC sources for more details. +See @file{haifa-sched.cc} in the GCC sources for more details. The default choice depends on the target. diff --git a/gcc/doc/loop.texi b/gcc/doc/loop.texi index f7930c5..d7b71a2 100644 --- a/gcc/doc/loop.texi +++ b/gcc/doc/loop.texi @@ -504,7 +504,7 @@ false unconditionally. @cindex Data Dependency Analysis The code for the data dependence analysis can be found in -@file{tree-data-ref.c} and its interface and data structures are +@file{tree-data-ref.cc} and its interface and data structures are described in @file{tree-data-ref.h}. The function that computes the data dependences for all the array and pointer references for a given loop is @code{compute_data_dependences_for_loop}. This function is diff --git a/gcc/doc/lto.texi b/gcc/doc/lto.texi index a6534da..8ee2a5b 100644 --- a/gcc/doc/lto.texi +++ b/gcc/doc/lto.texi @@ -69,23 +69,23 @@ Currently, this phase is composed of two IPA passes: @itemize @bullet @item @code{pass_ipa_lto_gimple_out} This pass executes the function @code{lto_output} in -@file{lto-streamer-out.c}, which traverses the call graph encoding +@file{lto-streamer-out.cc}, which traverses the call graph encoding every reachable declaration, type and function. This generates a memory representation of all the file sections described below. @item @code{pass_ipa_lto_finish_out} This pass executes the function @code{produce_asm_for_decls} in -@file{lto-streamer-out.c}, which takes the memory image built in the +@file{lto-streamer-out.cc}, which takes the memory image built in the previous pass and encodes it in the corresponding ELF file sections. @end itemize The second half of LTO support is the ``reader''. This is implemented -as the GCC front end @file{lto1} in @file{lto/lto.c}. When +as the GCC front end @file{lto1} in @file{lto/lto.cc}. When @file{collect2} detects a link set of @code{.o}/@code{.a} files with LTO information and the @option{-flto} is enabled, it invokes @file{lto1} which reads the set of files and aggregates them into a single translation unit for optimization. The main entry point for -the reader is @file{lto/lto.c}:@code{lto_main}. +the reader is @file{lto/lto.cc}:@code{lto_main}. @subsection LTO modes of operation @@ -157,8 +157,8 @@ LTO information is stored in several ELF sections inside object files. Data structures and enum codes for sections are defined in @file{lto-streamer.h}. -These sections are emitted from @file{lto-streamer-out.c} and mapped -in all at once from @file{lto/lto.c}:@code{lto_file_read}. The +These sections are emitted from @file{lto-streamer-out.cc} and mapped +in all at once from @file{lto/lto.cc}:@code{lto_file_read}. The individual functions dealing with the reading/writing of each section are described below. @@ -176,7 +176,7 @@ At link time, the options given on the command line and the options saved on all the files in a link-time set are applied globally. No attempt is made at validating the combination of flags (other than the usual validation done by option processing). This is implemented in -@file{lto/lto.c}:@code{lto_read_all_file_options}. +@file{lto/lto.cc}:@code{lto_read_all_file_options}. @item Symbol table (@code{.gnu.lto_.symtab}) @@ -196,7 +196,7 @@ optimization. This would lead to an undefined symbol if only one symbol table was used. The symbol table is emitted in -@file{lto-streamer-out.c}:@code{produce_symtab}. +@file{lto-streamer-out.cc}:@code{produce_symtab}. @item Global declarations and types (@code{.gnu.lto_.decls}) @@ -206,10 +206,10 @@ declarations and types required to represent the callgraph, static variables and top-level debug info. The contents of this section are emitted in -@file{lto-streamer-out.c}:@code{produce_asm_for_decls}. Types and +@file{lto-streamer-out.cc}:@code{produce_asm_for_decls}. Types and symbols are emitted in a topological order that preserves the sharing of pointers when the file is read back in -(@file{lto.c}:@code{read_cgraph_and_symbols}). +(@file{lto.cc}:@code{read_cgraph_and_symbols}). @item The callgraph (@code{.gnu.lto_.cgraph}) @@ -220,15 +220,15 @@ annotated multi-graph which represents the functions and call sites as well as the variables, aliases and top-level @code{asm} statements. This section is emitted in -@file{lto-streamer-out.c}:@code{output_cgraph} and read in -@file{lto-cgraph.c}:@code{input_cgraph}. +@file{lto-streamer-out.cc}:@code{output_cgraph} and read in +@file{lto-cgraph.cc}:@code{input_cgraph}. @item IPA references (@code{.gnu.lto_.refs}) This section contains references between function and static -variables. It is emitted by @file{lto-cgraph.c}:@code{output_refs} -and read by @file{lto-cgraph.c}:@code{input_refs}. +variables. It is emitted by @file{lto-cgraph.cc}:@code{output_refs} +and read by @file{lto-cgraph.cc}:@code{input_refs}. @item Function bodies (@code{.gnu.lto_.function_body.}) @@ -239,15 +239,15 @@ copying of the section independently to different object files or reading the function on demand. Functions are emitted in -@file{lto-streamer-out.c}:@code{output_function} and read in -@file{lto-streamer-in.c}:@code{input_function}. +@file{lto-streamer-out.cc}:@code{output_function} and read in +@file{lto-streamer-in.cc}:@code{input_function}. @item Static variable initializers (@code{.gnu.lto_.vars}) This section contains all the symbols in the global variable pool. It -is emitted by @file{lto-cgraph.c}:@code{output_varpool} and read in -@file{lto-cgraph.c}:@code{input_cgraph}. +is emitted by @file{lto-cgraph.cc}:@code{output_varpool} and read in +@file{lto-cgraph.cc}:@code{input_cgraph}. @item Summaries and optimization summaries used by IPA passes (@code{.gnu.lto_.}, where @code{} is one of @code{jmpfuncs}, @@ -451,9 +451,9 @@ locations where the address of @code{A} is taken and, when @code{A} is a variable, a list of all direct stores and reads to/from @code{A}. References represent an oriented multi-graph on the union of nodes of the callgraph and the varpool. See -@file{ipa-reference.c}:@code{ipa_reference_write_optimization_summary} +@file{ipa-reference.cc}:@code{ipa_reference_write_optimization_summary} and -@file{ipa-reference.c}:@code{ipa_reference_read_optimization_summary} +@file{ipa-reference.cc}:@code{ipa_reference_read_optimization_summary} for details. @subsection Jump functions diff --git a/gcc/doc/match-and-simplify.texi b/gcc/doc/match-and-simplify.texi index ed0270a..63a73ae 100644 --- a/gcc/doc/match-and-simplify.texi +++ b/gcc/doc/match-and-simplify.texi @@ -12,7 +12,7 @@ tries to address several issues. @enumerate @item unify expression simplifications currently spread and duplicated - over separate files like fold-const.c, gimple-fold.c and builtins.c + over separate files like fold-const.cc, gimple-fold.cc and builtins.cc @item allow for a cheap way to implement building and simplifying non-trivial GIMPLE expressions, avoiding the need to go through building and simplifying GENERIC via fold_buildN and then diff --git a/gcc/doc/md.texi b/gcc/doc/md.texi index 4dea8bb..7f0aab9 100644 --- a/gcc/doc/md.texi +++ b/gcc/doc/md.texi @@ -784,7 +784,7 @@ diagnosis when special predicates are used. @cindex generic predicates These are the generic predicates available to all back ends. They are -defined in @file{recog.c}. The first category of predicates allow +defined in @file{recog.cc}. The first category of predicates allow only constant, or @dfn{immediate}, operands. @defun immediate_operand @@ -2618,7 +2618,7 @@ now roughly the same as @samp{m} when not used together with @samp{<} or @samp{>}. @end table -@item M32C---@file{config/m32c/m32c.c} +@item M32C---@file{config/m32c/m32c.cc} @table @code @item Rsp @itemx Rfb @@ -8468,7 +8468,7 @@ original operation had sufficient precision to prevent overflow. @end itemize Further canonicalization rules are defined in the function -@code{commutative_operand_precedence} in @file{gcc/rtlanal.c}. +@code{commutative_operand_precedence} in @file{gcc/rtlanal.cc}. @end ifset @ifset INTERNALS diff --git a/gcc/doc/optinfo.texi b/gcc/doc/optinfo.texi index 619fba4..c024463 100644 --- a/gcc/doc/optinfo.texi +++ b/gcc/doc/optinfo.texi @@ -24,7 +24,7 @@ information about various compiler transformations and optimizations. A dump_manager class is defined in @file{dumpfile.h}. Various passes register dumping pass-specific information via @code{dump_register} in -@file{passes.c}. During the registration, an optimization pass can +@file{passes.cc}. During the registration, an optimization pass can select its optimization group (@pxref{Optimization groups}). After that optimization information corresponding to the entire group (presumably from multiple passes) can be output via command-line @@ -155,7 +155,7 @@ file name. The caller only needs to decide which dump output information is relevant, and under what conditions. This determines the associated flags. -Consider the following example from @file{loop-unroll.c} where an +Consider the following example from @file{loop-unroll.cc} where an informative message about a loop (along with its location) is printed when any of the following flags is enabled @itemize @minus diff --git a/gcc/doc/options.texi b/gcc/doc/options.texi index 5f63695..d552b64 100644 --- a/gcc/doc/options.texi +++ b/gcc/doc/options.texi @@ -70,7 +70,7 @@ name of the include file. @item A variable record to record any additional files that the -@file{options.c} or @file{options-save.c} file should include. This +@file{options.cc} or @file{options-save.cc} file should include. This is useful to provide inline functions needed for target variables and/or @code{#ifdef} sequences to properly set up the initialization. These records have diff --git a/gcc/doc/passes.texi b/gcc/doc/passes.texi index ed58a0a..1e821d4 100644 --- a/gcc/doc/passes.texi +++ b/gcc/doc/passes.texi @@ -125,7 +125,7 @@ and let the language-independent gimplifier do most of the work. @findex gimplify_expr @findex lang_hooks.gimplify_expr The main entry point to this pass is @code{gimplify_function_tree} -located in @file{gimplify.c}. From here we process the entire +located in @file{gimplify.cc}. From here we process the entire function gimplifying each statement in turn. The main workhorse for this pass is @code{gimplify_expr}. Approximately everything passes through here at least once, and it is from here that we @@ -146,7 +146,7 @@ semantic checks), it should return @code{GS_ERROR}. @node Pass manager @section Pass manager -The pass manager is located in @file{passes.c}, @file{tree-optimize.c} +The pass manager is located in @file{passes.cc}, @file{tree-optimize.c} and @file{tree-pass.h}. It processes passes as described in @file{passes.def}. Its job is to run all of the individual passes in the correct order, @@ -216,52 +216,52 @@ hooks are defined. @item IPA free lang data This pass frees resources that are used by the front end but are -not needed once it is done. It is located in @file{tree.c} and is described by +not needed once it is done. It is located in @file{tree.cc} and is described by @code{pass_ipa_free_lang_data}. @item IPA function and variable visibility This is a local function pass handling visibilities of all symbols. This happens before LTO streaming, so @option{-fwhole-program} should be ignored -at this level. It is located in @file{ipa-visibility.c} and is described by +at this level. It is located in @file{ipa-visibility.cc} and is described by @code{pass_ipa_function_and_variable_visibility}. @item IPA remove symbols This pass performs reachability analysis and reclaims all unreachable nodes. -It is located in @file{passes.c} and is described by +It is located in @file{passes.cc} and is described by @code{pass_ipa_remove_symbols}. @item IPA OpenACC This is a pass group for OpenACC processing. It is located in -@file{tree-ssa-loop.c} and is described by @code{pass_ipa_oacc}. +@file{tree-ssa-loop.cc} and is described by @code{pass_ipa_oacc}. @item IPA points-to analysis This is a tree-based points-to analysis pass. The idea behind this analyzer is to generate set constraints from the program, then solve the resulting constraints in order to generate the points-to sets. It is located in -@file{tree-ssa-structalias.c} and is described by @code{pass_ipa_pta}. +@file{tree-ssa-structalias.cc} and is described by @code{pass_ipa_pta}. @item IPA OpenACC kernels This is a pass group for processing OpenACC kernels regions. It is a subpass of the IPA OpenACC pass group that runs on offloaded functions containing OpenACC kernels loops. It is located in -@file{tree-ssa-loop.c} and is described by +@file{tree-ssa-loop.cc} and is described by @code{pass_ipa_oacc_kernels}. @item Target clone This is a pass for parsing functions with multiple target attributes. -It is located in @file{multiple_target.c} and is described by +It is located in @file{multiple_target.cc} and is described by @code{pass_target_clone}. @item IPA auto profile This pass uses AutoFDO profiling data to annotate the control flow graph. -It is located in @file{auto-profile.c} and is described by +It is located in @file{auto-profile.cc} and is described by @code{pass_ipa_auto_profile}. @item IPA tree profile @@ -269,32 +269,32 @@ It is located in @file{auto-profile.c} and is described by This pass does profiling for all functions in the call graph. It calculates branch probabilities and basic block execution counts. It is located -in @file{tree-profile.c} and is described by @code{pass_ipa_tree_profile}. +in @file{tree-profile.cc} and is described by @code{pass_ipa_tree_profile}. @item IPA free function summary This pass is a small IPA pass when argument @code{small_p} is true. It releases inline function summaries and call summaries. -It is located in @file{ipa-fnsummary.c} and is described by +It is located in @file{ipa-fnsummary.cc} and is described by @code{pass_ipa_free_free_fn_summary}. @item IPA increase alignment This pass increases the alignment of global arrays to improve -vectorization. It is located in @file{tree-vectorizer.c} +vectorization. It is located in @file{tree-vectorizer.cc} and is described by @code{pass_ipa_increase_alignment}. @item IPA transactional memory This pass is for transactional memory support. -It is located in @file{trans-mem.c} and is described by +It is located in @file{trans-mem.cc} and is described by @code{pass_ipa_tm}. @item IPA lower emulated TLS This pass lowers thread-local storage (TLS) operations to emulation functions provided by libgcc. -It is located in @file{tree-emutls.c} and is described by +It is located in @file{tree-emutls.cc} and is described by @code{pass_ipa_lower_emutls}. @end itemize @@ -313,13 +313,13 @@ hooks implemented in any of the LGEN, WPA or LTRANS stages (@pxref{IPA}). This pass performs various optimizations involving symbol visibility with @option{-fwhole-program}, including symbol privatization, discovering local functions, and dismantling comdat groups. It is -located in @file{ipa-visibility.c} and is described by +located in @file{ipa-visibility.cc} and is described by @code{pass_ipa_whole_program_visibility}. @item IPA profile The IPA profile pass propagates profiling frequencies across the call -graph. It is located in @file{ipa-profile.c} and is described by +graph. It is located in @file{ipa-profile.cc} and is described by @code{pass_ipa_profile}. @item IPA identical code folding @@ -327,21 +327,21 @@ graph. It is located in @file{ipa-profile.c} and is described by This is the inter-procedural identical code folding pass. The goal of this transformation is to discover functions and read-only variables that have exactly the same semantics. It is -located in @file{ipa-icf.c} and is described by @code{pass_ipa_icf}. +located in @file{ipa-icf.cc} and is described by @code{pass_ipa_icf}. @item IPA devirtualization This pass performs speculative devirtualization based on the type inheritance graph. When a polymorphic call has only one likely target in the unit, it is turned into a speculative call. It is located in -@file{ipa-devirt.c} and is described by @code{pass_ipa_devirt}. +@file{ipa-devirt.cc} and is described by @code{pass_ipa_devirt}. @item IPA constant propagation The goal of this pass is to discover functions that are always invoked with some arguments with the same known constant values and to modify the functions accordingly. It can also do partial specialization and -type-based devirtualization. It is located in @file{ipa-cp.c} and is +type-based devirtualization. It is located in @file{ipa-cp.cc} and is described by @code{pass_ipa_cp}. @item IPA scalar replacement of aggregates @@ -350,14 +350,14 @@ This pass can replace an aggregate parameter with a set of other parameters representing part of the original, turning those passed by reference into new ones which pass the value directly. It also removes unused function return values and unused function parameters. This pass is -located in @file{ipa-sra.c} and is described by @code{pass_ipa_sra}. +located in @file{ipa-sra.cc} and is described by @code{pass_ipa_sra}. @item IPA constructor/destructor merge This pass merges multiple constructors and destructors for static objects into single functions. It's only run at LTO time unless the target doesn't support constructors and destructors natively. The -pass is located in @file{ipa.c} and is described by +pass is located in @file{ipa.cc} and is described by @code{pass_ipa_cdtor_merge}. @item IPA function summary @@ -366,7 +366,7 @@ This pass provides function analysis for inter-procedural passes. It collects estimates of function body size, execution time, and frame size for each function. It also estimates information about function calls: call statement size, time and how often the parameters change -for each call. It is located in @file{ipa-fnsummary.c} and is +for each call. It is located in @file{ipa-fnsummary.cc} and is described by @code{pass_ipa_fn_summary}. @item IPA inline @@ -376,7 +376,7 @@ knowledge. Small functions that are candidates for inlining are ordered in increasing badness, bounded by unit growth parameters. Unreachable functions are removed from the call graph. Functions called once and not exported from the unit are inlined. This pass is located in -@file{ipa-inline.c} and is described by @code{pass_ipa_inline}. +@file{ipa-inline.cc} and is described by @code{pass_ipa_inline}. @item IPA pure/const analysis @@ -384,32 +384,32 @@ This pass marks functions as being either const (@code{TREE_READONLY}) or pure (@code{DECL_PURE_P}). The per-function information is produced by @code{pure_const_generate_summary}, then the global information is computed by performing a transitive closure over the call graph. It is located in -@file{ipa-pure-const.c} and is described by @code{pass_ipa_pure_const}. +@file{ipa-pure-const.cc} and is described by @code{pass_ipa_pure_const}. @item IPA free function summary This pass is a regular IPA pass when argument @code{small_p} is false. It releases inline function summaries and call summaries. -It is located in @file{ipa-fnsummary.c} and is described by +It is located in @file{ipa-fnsummary.cc} and is described by @code{pass_ipa_free_fn_summary}. @item IPA reference This pass gathers information about how variables whose scope is confined to the compilation unit are used. It is located in -@file{ipa-reference.c} and is described by @code{pass_ipa_reference}. +@file{ipa-reference.cc} and is described by @code{pass_ipa_reference}. @item IPA single use This pass checks whether variables are used by a single function. -It is located in @file{ipa.c} and is described by +It is located in @file{ipa.cc} and is described by @code{pass_ipa_single_use}. @item IPA comdats This pass looks for static symbols that are used exclusively within one comdat group, and moves them into that comdat group. It is -located in @file{ipa-comdats.c} and is described by +located in @file{ipa-comdats.cc} and is described by @code{pass_ipa_comdats}. @end itemize @@ -426,7 +426,7 @@ partitioning and thus see just parts of the compiled unit. @item Materialize all clones Once all functions from compilation unit are in memory, produce all clones -and update all calls. It is located in @file{ipa.c} and is described by +and update all calls. It is located in @file{ipa.cc} and is described by @code{pass_materialize_all_clones}. @item IPA points-to analysis @@ -438,7 +438,7 @@ run with the small IPA passes (@pxref{Small IPA passes}). This is the OpenMP constructs' SIMD clone pass. It creates the appropriate SIMD clones for functions tagged as elemental SIMD functions. -It is located in @file{omp-simd-clone.c} and is described by +It is located in @file{omp-simd-clone.cc} and is described by @code{pass_omp_simd_clone}. @end itemize @@ -459,7 +459,7 @@ exception handling constructs surrounding code that obviously cannot throw, remove lexical bindings that contain no variables, and other assorted simplistic cleanups. The idea is to get rid of the obvious stuff quickly rather than wait until later when it's more work to get -rid of it. This pass is located in @file{tree-cfg.c} and described by +rid of it. This pass is located in @file{tree-cfg.cc} and described by @code{pass_remove_useless_stmts}. @item OpenMP lowering @@ -471,14 +471,14 @@ Lowering of OpenMP constructs involves creating replacement expressions for local variables that have been mapped using data sharing clauses, exposing the control flow of most synchronization directives and adding region markers to facilitate the creation of the -control flow graph. The pass is located in @file{omp-low.c} and is +control flow graph. The pass is located in @file{omp-low.cc} and is described by @code{pass_lower_omp}. @item OpenMP expansion If OpenMP generation (@option{-fopenmp}) is enabled, this pass expands parallel regions into their own functions to be invoked by the thread -library. The pass is located in @file{omp-low.c} and is described by +library. The pass is located in @file{omp-low.cc} and is described by @code{pass_expand_omp}. @item Lower control flow @@ -489,7 +489,7 @@ this pass, all @code{if} statements will have exactly two @code{goto} statements in its @code{then} and @code{else} arms. Lexical binding information for each statement will be found in @code{TREE_BLOCK} rather than being inferred from its position under a @code{BIND_EXPR}. This -pass is found in @file{gimple-low.c} and is described by +pass is found in @file{gimple-low.cc} and is described by @code{pass_lower_cf}. @item Lower exception handling control flow @@ -502,13 +502,13 @@ number for any statement that may have EH control flow semantics; examine @code{tree_can_throw_internal} or @code{tree_can_throw_external} for exact semantics. Exact control flow may be extracted from @code{foreach_reachable_handler}. The EH region nesting tree is defined -in @file{except.h} and built in @file{except.c}. The lowering pass -itself is in @file{tree-eh.c} and is described by @code{pass_lower_eh}. +in @file{except.h} and built in @file{except.cc}. The lowering pass +itself is in @file{tree-eh.cc} and is described by @code{pass_lower_eh}. @item Build the control flow graph This pass decomposes a function into basic blocks and creates all of -the edges that connect them. It is located in @file{tree-cfg.c} and +the edges that connect them. It is located in @file{tree-cfg.cc} and is described by @code{pass_build_cfg}. @item Find all referenced variables @@ -517,7 +517,7 @@ This pass walks the entire function and collects an array of all variables referenced in the function, @code{referenced_vars}. The index at which a variable is found in the array is used as a UID for the variable within this function. This data is needed by the -SSA rewriting routines. The pass is located in @file{tree-dfa.c} +SSA rewriting routines. The pass is located in @file{tree-dfa.cc} and is described by @code{pass_referenced_vars}. @item Enter static single assignment form @@ -527,7 +527,7 @@ this pass, all @code{is_gimple_reg} variables will be referenced by @code{SSA_NAME}, and all occurrences of other variables will be annotated with @code{VDEFS} and @code{VUSES}; PHI nodes will have been inserted as necessary for each basic block. This pass is -located in @file{tree-ssa.c} and is described by @code{pass_build_ssa}. +located in @file{tree-ssa.cc} and is described by @code{pass_build_ssa}. @item Warn for uninitialized variables @@ -536,7 +536,7 @@ are fed by default definition. For non-parameter variables, such uses are uninitialized. The pass is run twice, before and after optimization (if turned on). In the first pass we only warn for uses that are positively uninitialized; in the second pass we warn for uses that -are possibly uninitialized. The pass is located in @file{tree-ssa.c} +are possibly uninitialized. The pass is located in @file{tree-ssa.cc} and is defined by @code{pass_early_warn_uninitialized} and @code{pass_late_warn_uninitialized}. @@ -546,13 +546,13 @@ This pass scans the function for statements without side effects whose result is unused. It does not do memory life analysis, so any value that is stored in memory is considered used. The pass is run multiple times throughout the optimization process. It is located in -@file{tree-ssa-dce.c} and is described by @code{pass_dce}. +@file{tree-ssa-dce.cc} and is described by @code{pass_dce}. @item Dominator optimizations This pass performs trivial dominator-based copy and constant propagation, expression simplification, and jump threading. It is run multiple times -throughout the optimization process. It is located in @file{tree-ssa-dom.c} +throughout the optimization process. It is located in @file{tree-ssa-dom.cc} and is described by @code{pass_dominator}. @item Forward propagation of single-use variables @@ -560,7 +560,7 @@ and is described by @code{pass_dominator}. This pass attempts to remove redundant computation by substituting variables that are used once into the expression that uses them and seeing if the result can be simplified. It is located in -@file{tree-ssa-forwprop.c} and is described by @code{pass_forwprop}. +@file{tree-ssa-forwprop.cc} and is described by @code{pass_forwprop}. @item Copy Renaming @@ -575,7 +575,7 @@ located in @file{tree-ssa-copyrename.c} and is described by This pass recognizes forms of PHI inputs that can be represented as conditional expressions and rewrites them into straight line code. -It is located in @file{tree-ssa-phiopt.c} and is described by +It is located in @file{tree-ssa-phiopt.cc} and is described by @code{pass_phiopt}. @item May-alias optimization @@ -586,17 +586,17 @@ is used to promote variables from in-memory addressable objects to non-aliased variables that can be renamed into SSA form. We also update the @code{VDEF}/@code{VUSE} memory tags for non-renameable aggregates so that we get fewer false kills. The pass is located -in @file{tree-ssa-alias.c} and is described by @code{pass_may_alias}. +in @file{tree-ssa-alias.cc} and is described by @code{pass_may_alias}. Interprocedural points-to information is located in -@file{tree-ssa-structalias.c} and described by @code{pass_ipa_pta}. +@file{tree-ssa-structalias.cc} and described by @code{pass_ipa_pta}. @item Profiling This pass instruments the function in order to collect runtime block and value profiling data. Such data may be fed back into the compiler on a subsequent run so as to allow optimization based on expected -execution frequencies. The pass is located in @file{tree-profile.c} and +execution frequencies. The pass is located in @file{tree-profile.cc} and is described by @code{pass_ipa_tree_profile}. @item Static profile estimation @@ -604,13 +604,13 @@ is described by @code{pass_ipa_tree_profile}. This pass implements series of heuristics to guess propababilities of branches. The resulting predictions are turned into edge profile by propagating branches across the control flow graphs. -The pass is located in @file{tree-profile.c} and is described by +The pass is located in @file{tree-profile.cc} and is described by @code{pass_profile}. @item Lower complex arithmetic This pass rewrites complex arithmetic operations into their component -scalar arithmetic operations. The pass is located in @file{tree-complex.c} +scalar arithmetic operations. The pass is located in @file{tree-complex.cc} and is described by @code{pass_lower_complex}. @item Scalar replacement of aggregates @@ -619,46 +619,46 @@ This pass rewrites suitable non-aliased local aggregate variables into a set of scalar variables. The resulting scalar variables are rewritten into SSA form, which allows subsequent optimization passes to do a significantly better job with them. The pass is located in -@file{tree-sra.c} and is described by @code{pass_sra}. +@file{tree-sra.cc} and is described by @code{pass_sra}. @item Dead store elimination This pass eliminates stores to memory that are subsequently overwritten by another store, without any intervening loads. The pass is located -in @file{tree-ssa-dse.c} and is described by @code{pass_dse}. +in @file{tree-ssa-dse.cc} and is described by @code{pass_dse}. @item Tail recursion elimination This pass transforms tail recursion into a loop. It is located in -@file{tree-tailcall.c} and is described by @code{pass_tail_recursion}. +@file{tree-tailcall.cc} and is described by @code{pass_tail_recursion}. @item Forward store motion This pass sinks stores and assignments down the flowgraph closer to their -use point. The pass is located in @file{tree-ssa-sink.c} and is +use point. The pass is located in @file{tree-ssa-sink.cc} and is described by @code{pass_sink_code}. @item Partial redundancy elimination This pass eliminates partially redundant computations, as well as -performing load motion. The pass is located in @file{tree-ssa-pre.c} +performing load motion. The pass is located in @file{tree-ssa-pre.cc} and is described by @code{pass_pre}. Just before partial redundancy elimination, if @option{-funsafe-math-optimizations} is on, GCC tries to convert divisions to multiplications by the reciprocal. The pass is located -in @file{tree-ssa-math-opts.c} and is described by +in @file{tree-ssa-math-opts.cc} and is described by @code{pass_cse_reciprocal}. @item Full redundancy elimination This is a simpler form of PRE that only eliminates redundancies that -occur on all paths. It is located in @file{tree-ssa-pre.c} and +occur on all paths. It is located in @file{tree-ssa-pre.cc} and described by @code{pass_fre}. @item Loop optimization -The main driver of the pass is placed in @file{tree-ssa-loop.c} +The main driver of the pass is placed in @file{tree-ssa-loop.cc} and described by @code{pass_loop}. The optimizations performed by this pass are: @@ -668,33 +668,33 @@ would be hard to handle on RTL level (function calls, operations that expand to nontrivial sequences of insns). With @option{-funswitch-loops} it also moves operands of conditions that are invariant out of the loop, so that we can use just trivial invariantness analysis in loop unswitching. The pass also includes -store motion. The pass is implemented in @file{tree-ssa-loop-im.c}. +store motion. The pass is implemented in @file{tree-ssa-loop-im.cc}. Canonical induction variable creation. This pass creates a simple counter for number of iterations of the loop and replaces the exit condition of the loop using it, in case when a complicated analysis is necessary to determine the number of iterations. Later optimizations then may determine the number -easily. The pass is implemented in @file{tree-ssa-loop-ivcanon.c}. +easily. The pass is implemented in @file{tree-ssa-loop-ivcanon.cc}. Induction variable optimizations. This pass performs standard induction variable optimizations, including strength reduction, induction variable merging and induction variable elimination. The pass is implemented in -@file{tree-ssa-loop-ivopts.c}. +@file{tree-ssa-loop-ivopts.cc}. Loop unswitching. This pass moves the conditional jumps that are invariant out of the loops. To achieve this, a duplicate of the loop is created for each possible outcome of conditional jump(s). The pass is implemented in -@file{tree-ssa-loop-unswitch.c}. +@file{tree-ssa-loop-unswitch.cc}. Loop splitting. If a loop contains a conditional statement that is always true for one part of the iteration space and false for the other this pass splits the loop into two, one dealing with one side the other only with the other, thereby removing one inner-loop conditional. The -pass is implemented in @file{tree-ssa-loop-split.c}. +pass is implemented in @file{tree-ssa-loop-split.cc}. The optimizations also use various utility functions contained in -@file{tree-ssa-loop-manip.c}, @file{cfgloop.c}, @file{cfgloopanal.c} and -@file{cfgloopmanip.c}. +@file{tree-ssa-loop-manip.cc}, @file{cfgloop.cc}, @file{cfgloopanal.cc} and +@file{cfgloopmanip.cc}. Vectorization. This pass transforms loops to operate on vector types instead of scalar types. Data parallelism across loop iterations is exploited @@ -706,20 +706,20 @@ the number of elements operated upon in parallel in each iteration, and the Additional loop transformations such as peeling and versioning may take place to align the number of iterations, and to align the memory accesses in the loop. -The pass is implemented in @file{tree-vectorizer.c} (the main driver), -@file{tree-vect-loop.c} and @file{tree-vect-loop-manip.c} (loop specific parts +The pass is implemented in @file{tree-vectorizer.cc} (the main driver), +@file{tree-vect-loop.cc} and @file{tree-vect-loop-manip.cc} (loop specific parts and general loop utilities), @file{tree-vect-slp} (loop-aware SLP -functionality), @file{tree-vect-stmts.c}, @file{tree-vect-data-refs.c} and -@file{tree-vect-slp-patterns.c} containing the SLP pattern matcher. -Analysis of data references is in @file{tree-data-ref.c}. +functionality), @file{tree-vect-stmts.cc}, @file{tree-vect-data-refs.cc} and +@file{tree-vect-slp-patterns.cc} containing the SLP pattern matcher. +Analysis of data references is in @file{tree-data-ref.cc}. SLP Vectorization. This pass performs vectorization of straight-line code. The -pass is implemented in @file{tree-vectorizer.c} (the main driver), -@file{tree-vect-slp.c}, @file{tree-vect-stmts.c} and -@file{tree-vect-data-refs.c}. +pass is implemented in @file{tree-vectorizer.cc} (the main driver), +@file{tree-vect-slp.cc}, @file{tree-vect-stmts.cc} and +@file{tree-vect-data-refs.cc}. Autoparallelization. This pass splits the loop iteration space to run -into several threads. The pass is implemented in @file{tree-parloops.c}. +into several threads. The pass is implemented in @file{tree-parloops.cc}. Graphite is a loop transformation framework based on the polyhedral model. Graphite stands for Gimple Represented as Polyhedra. The @@ -735,28 +735,28 @@ We identify if convertible loops, if-convert statements and merge basic blocks in one big block. The idea is to present loop in such form so that vectorizer can have one to one mapping between statements and available vector operations. This pass is located in -@file{tree-if-conv.c} and is described by @code{pass_if_conversion}. +@file{tree-if-conv.cc} and is described by @code{pass_if_conversion}. @item Conditional constant propagation This pass relaxes a lattice of values in order to identify those that must be constant even in the presence of conditional branches. -The pass is located in @file{tree-ssa-ccp.c} and is described +The pass is located in @file{tree-ssa-ccp.cc} and is described by @code{pass_ccp}. A related pass that works on memory loads and stores, and not just -register values, is located in @file{tree-ssa-ccp.c} and described by +register values, is located in @file{tree-ssa-ccp.cc} and described by @code{pass_store_ccp}. @item Conditional copy propagation This is similar to constant propagation but the lattice of values is the ``copy-of'' relation. It eliminates redundant copies from the -code. The pass is located in @file{tree-ssa-copy.c} and described by +code. The pass is located in @file{tree-ssa-copy.cc} and described by @code{pass_copy_prop}. A related pass that works on memory copies, and not just register -copies, is located in @file{tree-ssa-copy.c} and described by +copies, is located in @file{tree-ssa-copy.cc} and described by @code{pass_store_copy_prop}. @item Value range propagation @@ -770,26 +770,26 @@ contrast to Patterson's algorithm, this implementation does not propagate branch probabilities nor it uses more than a single range per SSA name. This means that the current implementation cannot be used for branch prediction (though adapting it would -not be difficult). The pass is located in @file{tree-vrp.c} and is +not be difficult). The pass is located in @file{tree-vrp.cc} and is described by @code{pass_vrp}. @item Folding built-in functions This pass simplifies built-in functions, as applicable, with constant arguments or with inferable string lengths. It is located in -@file{tree-ssa-ccp.c} and is described by @code{pass_fold_builtins}. +@file{tree-ssa-ccp.cc} and is described by @code{pass_fold_builtins}. @item Split critical edges This pass identifies critical edges and inserts empty basic blocks such that the edge is no longer critical. The pass is located in -@file{tree-cfg.c} and is described by @code{pass_split_crit_edges}. +@file{tree-cfg.cc} and is described by @code{pass_split_crit_edges}. @item Control dependence dead code elimination This pass is a stronger form of dead code elimination that can eliminate unnecessary control flow statements. It is located -in @file{tree-ssa-dce.c} and is described by @code{pass_cd_dce}. +in @file{tree-ssa-dce.cc} and is described by @code{pass_cd_dce}. @item Tail call elimination @@ -798,9 +798,9 @@ jumps. No code transformation is actually applied here, but the data and control flow problem is solved. The code transformation requires target support, and so is delayed until RTL@. In the meantime @code{CALL_EXPR_TAILCALL} is set indicating the possibility. -The pass is located in @file{tree-tailcall.c} and is described by +The pass is located in @file{tree-tailcall.cc} and is described by @code{pass_tail_calls}. The RTL transformation is handled by -@code{fixup_tail_calls} in @file{calls.c}. +@code{fixup_tail_calls} in @file{calls.cc}. @item Warn for function return without value @@ -808,7 +808,7 @@ For non-void functions, this pass locates return statements that do not specify a value and issues a warning. Such a statement may have been injected by falling off the end of the function. This pass is run last so that we have as much time as possible to prove that the -statement is not reachable. It is located in @file{tree-cfg.c} and +statement is not reachable. It is located in @file{tree-cfg.cc} and is described by @code{pass_warn_function_return}. @item Leave static single assignment form @@ -816,14 +816,14 @@ is described by @code{pass_warn_function_return}. This pass rewrites the function such that it is in normal form. At the same time, we eliminate as many single-use temporaries as possible, so the intermediate language is no longer GIMPLE, but GENERIC@. The -pass is located in @file{tree-outof-ssa.c} and is described by +pass is located in @file{tree-outof-ssa.cc} and is described by @code{pass_del_ssa}. @item Merge PHI nodes that feed into one another This is part of the CFG cleanup passes. It attempts to join PHI nodes from a forwarder CFG block into another block with PHI nodes. The -pass is located in @file{tree-cfgcleanup.c} and is described by +pass is located in @file{tree-cfgcleanup.cc} and is described by @code{pass_merge_phi}. @item Return value optimization @@ -832,7 +832,7 @@ If a function always returns the same local variable, and that local variable is an aggregate type, then the variable is replaced with the return value for the function (i.e., the function's DECL_RESULT). This is equivalent to the C++ named return value optimization applied to -GIMPLE@. The pass is located in @file{tree-nrv.c} and is described by +GIMPLE@. The pass is located in @file{tree-nrv.cc} and is described by @code{pass_nrv}. @item Return slot optimization @@ -840,7 +840,7 @@ GIMPLE@. The pass is located in @file{tree-nrv.c} and is described by If a function returns a memory object and is called as @code{var = foo()}, this pass tries to change the call so that the address of @code{var} is sent to the caller to avoid an extra memory copy. This -pass is located in @code{tree-nrv.c} and is described by +pass is located in @code{tree-nrv.cc} and is described by @code{pass_return_slot}. @item Optimize calls to @code{__builtin_object_size} @@ -848,13 +848,13 @@ pass is located in @code{tree-nrv.c} and is described by This is a propagation pass similar to CCP that tries to remove calls to @code{__builtin_object_size} when the size of the object can be computed at compile-time. This pass is located in -@file{tree-object-size.c} and is described by +@file{tree-object-size.cc} and is described by @code{pass_object_sizes}. @item Loop invariant motion This pass removes expensive loop-invariant computations out of loops. -The pass is located in @file{tree-ssa-loop.c} and described by +The pass is located in @file{tree-ssa-loop.cc} and described by @code{pass_lim}. @item Loop nest optimizations @@ -870,13 +870,13 @@ parallelization and vectorization. The pass is located in @item Removal of empty loops This pass removes loops with no code in them. The pass is located in -@file{tree-ssa-loop-ivcanon.c} and described by +@file{tree-ssa-loop-ivcanon.cc} and described by @code{pass_empty_loop}. @item Unrolling of small loops This pass completely unrolls loops with few iterations. The pass -is located in @file{tree-ssa-loop-ivcanon.c} and described by +is located in @file{tree-ssa-loop-ivcanon.cc} and described by @code{pass_complete_unroll}. @item Predictive commoning @@ -887,20 +887,20 @@ It does so by storing the values of these computations to a bank of temporary variables that are rotated at the end of loop. To avoid the need for this rotation, the loop is then unrolled and the copies of the loop body are rewritten to use the appropriate version of -the temporary variable. This pass is located in @file{tree-predcom.c} +the temporary variable. This pass is located in @file{tree-predcom.cc} and described by @code{pass_predcom}. @item Array prefetching This pass issues prefetch instructions for array references inside -loops. The pass is located in @file{tree-ssa-loop-prefetch.c} and +loops. The pass is located in @file{tree-ssa-loop-prefetch.cc} and described by @code{pass_loop_prefetch}. @item Reassociation This pass rewrites arithmetic expressions to enable optimizations that operate on them, like redundancy elimination and vectorization. The -pass is located in @file{tree-ssa-reassoc.c} and described by +pass is located in @file{tree-ssa-reassoc.cc} and described by @code{pass_reassoc}. @item Optimization of @code{stdarg} functions @@ -913,7 +913,7 @@ escape the function, it is only necessary to save registers that will be used in @code{va_arg} macros. For instance, if @code{va_arg} is only used with integral types in the function, floating point registers don't need to be saved. This pass is located in -@code{tree-stdarg.c} and described by @code{pass_stdarg}. +@code{tree-stdarg.cc} and described by @code{pass_stdarg}. @end itemize @@ -928,16 +928,16 @@ passes that are run after the Tree optimization passes. @c Avoiding overfull is tricky here. The source files for RTL generation include -@file{stmt.c}, -@file{calls.c}, -@file{expr.c}, -@file{explow.c}, -@file{expmed.c}, -@file{function.c}, -@file{optabs.c} -and @file{emit-rtl.c}. +@file{stmt.cc}, +@file{calls.cc}, +@file{expr.cc}, +@file{explow.cc}, +@file{expmed.cc}, +@file{function.cc}, +@file{optabs.cc} +and @file{emit-rtl.cc}. Also, the file -@file{insn-emit.c}, generated from the machine description by the +@file{insn-emit.cc}, generated from the machine description by the program @code{genemit}, is used in this pass. The header file @file{expr.h} is used for communication within this pass. @@ -954,7 +954,7 @@ This pass generates the glue that handles communication between the exception handling library routines and the exception handlers within the function. Entry points in the function that are invoked by the exception handling library are called @dfn{landing pads}. The code -for this pass is located in @file{except.c}. +for this pass is located in @file{except.cc}. @item Control flow graph cleanup @@ -962,8 +962,8 @@ This pass removes unreachable code, simplifies jumps to next, jumps to jump, jumps across jumps, etc. The pass is run multiple times. For historical reasons, it is occasionally referred to as the ``jump optimization pass''. The bulk of the code for this pass is in -@file{cfgcleanup.c}, and there are support routines in @file{cfgrtl.c} -and @file{jump.c}. +@file{cfgcleanup.cc}, and there are support routines in @file{cfgrtl.cc} +and @file{jump.cc}. @item Forward propagation of single-def values @@ -972,13 +972,13 @@ variables that come from a single definition, and seeing if the result can be simplified. It performs copy propagation and addressing mode selection. The pass is run twice, with values being propagated into loops only on the second run. The code is -located in @file{fwprop.c}. +located in @file{fwprop.cc}. @item Common subexpression elimination This pass removes redundant computation within basic blocks, and optimizes addressing modes based on cost. The pass is run twice. -The code for this pass is located in @file{cse.c}. +The code for this pass is located in @file{cse.cc}. @item Global common subexpression elimination @@ -997,26 +997,26 @@ based GCSE also does loop invariant code motion. We also perform load and store motion when optimizing for speed. Regardless of which type of GCSE is used, the GCSE pass also performs global constant and copy propagation. -The source file for this pass is @file{gcse.c}, and the LCM routines -are in @file{lcm.c}. +The source file for this pass is @file{gcse.cc}, and the LCM routines +are in @file{lcm.cc}. @item Loop optimization This pass performs several loop related optimizations. -The source files @file{cfgloopanal.c} and @file{cfgloopmanip.c} contain +The source files @file{cfgloopanal.cc} and @file{cfgloopmanip.cc} contain generic loop analysis and manipulation code. Initialization and finalization -of loop structures is handled by @file{loop-init.c}. -A loop invariant motion pass is implemented in @file{loop-invariant.c}. +of loop structures is handled by @file{loop-init.cc}. +A loop invariant motion pass is implemented in @file{loop-invariant.cc}. Basic block level optimizations---unrolling, and peeling loops--- -are implemented in @file{loop-unroll.c}. +are implemented in @file{loop-unroll.cc}. Replacing of the exit condition of loops by special machine-dependent -instructions is handled by @file{loop-doloop.c}. +instructions is handled by @file{loop-doloop.cc}. @item Jump bypassing This pass is an aggressive form of GCSE that transforms the control flow graph of a function by propagating constants into conditional -branch instructions. The source file for this pass is @file{gcse.c}. +branch instructions. The source file for this pass is @file{gcse.cc}. @item If conversion @@ -1024,13 +1024,13 @@ This pass attempts to replace conditional branches and surrounding assignments with arithmetic, boolean value producing comparison instructions, and conditional move instructions. In the very last invocation after reload/LRA, it will generate predicated instructions -when supported by the target. The code is located in @file{ifcvt.c}. +when supported by the target. The code is located in @file{ifcvt.cc}. @item Web construction This pass splits independent uses of each pseudo-register. This can improve effect of the other transformation, such as CSE or register -allocation. The code for this pass is located in @file{web.c}. +allocation. The code for this pass is located in @file{web.cc}. @item Instruction combination @@ -1038,7 +1038,7 @@ This pass attempts to combine groups of two or three instructions that are related by data flow into single instructions. It combines the RTL expressions for the instructions by substitution, simplifies the result using algebra, and then attempts to match the result against -the machine description. The code is located in @file{combine.c}. +the machine description. The code is located in @file{combine.cc}. @item Mode switching optimization @@ -1046,7 +1046,7 @@ This pass looks for instructions that require the processor to be in a specific ``mode'' and minimizes the number of mode changes required to satisfy all users. What these modes are, and what they apply to are completely target-specific. The code for this pass is located in -@file{mode-switching.c}. +@file{mode-switching.cc}. @cindex modulo scheduling @cindex sms, swing, software pipelining @@ -1055,7 +1055,7 @@ completely target-specific. The code for this pass is located in This pass looks at innermost loops and reorders their instructions by overlapping different iterations. Modulo scheduling is performed immediately before instruction scheduling. The code for this pass is -located in @file{modulo-sched.c}. +located in @file{modulo-sched.cc}. @item Instruction scheduling @@ -1065,8 +1065,8 @@ floating point instructions often have this behavior on RISC machines. It re-orders instructions within a basic block to try to separate the definition and use of items that otherwise would cause pipeline stalls. This pass is performed twice, before and after register -allocation. The code for this pass is located in @file{haifa-sched.c}, -@file{sched-deps.c}, @file{sched-ebb.c}, @file{sched-rgn.c} and +allocation. The code for this pass is located in @file{haifa-sched.cc}, +@file{sched-deps.cc}, @file{sched-ebb.cc}, @file{sched-rgn.cc} and @file{sched-vis.c}. @item Register allocation @@ -1092,9 +1092,9 @@ if there is one region. By default, IRA chooses regions using register pressure but the user can force it to use one region or regions corresponding to all loops. -Source files of the allocator are @file{ira.c}, @file{ira-build.c}, -@file{ira-costs.c}, @file{ira-conflicts.c}, @file{ira-color.c}, -@file{ira-emit.c}, @file{ira-lives}, plus header files @file{ira.h} +Source files of the allocator are @file{ira.cc}, @file{ira-build.cc}, +@file{ira-costs.cc}, @file{ira-conflicts.cc}, @file{ira-color.cc}, +@file{ira-emit.cc}, @file{ira-lives}, plus header files @file{ira.h} and @file{ira-int.h} used for the communication between the allocator and the rest of the compiler and between the IRA files. @@ -1112,15 +1112,15 @@ do the copying. The reload pass also optionally eliminates the frame pointer and inserts instructions to save and restore call-clobbered registers around calls. -Source files are @file{reload.c} and @file{reload1.c}, plus the header +Source files are @file{reload.cc} and @file{reload1.cc}, plus the header @file{reload.h} used for communication between them. @cindex Local Register Allocator (LRA) @item This pass is a modern replacement of the reload pass. Source files -are @file{lra.c}, @file{lra-assign.c}, @file{lra-coalesce.c}, -@file{lra-constraints.c}, @file{lra-eliminations.c}, -@file{lra-lives.c}, @file{lra-remat.c}, @file{lra-spills.c}, the +are @file{lra.cc}, @file{lra-assign.c}, @file{lra-coalesce.cc}, +@file{lra-constraints.cc}, @file{lra-eliminations.cc}, +@file{lra-lives.cc}, @file{lra-remat.cc}, @file{lra-spills.cc}, the header @file{lra-int.h} used for communication between them, and the header @file{lra.h} used for communication between LRA and the rest of compiler. @@ -1139,8 +1139,8 @@ This pass implements profile guided code positioning. If profile information is not available, various types of static analysis are performed to make the predictions normally coming from the profile feedback (IE execution frequency, branch probability, etc). It is -implemented in the file @file{bb-reorder.c}, and the various -prediction routines are in @file{predict.c}. +implemented in the file @file{bb-reorder.cc}, and the various +prediction routines are in @file{predict.cc}. @item Variable tracking @@ -1148,13 +1148,13 @@ This pass computes where the variables are stored at each position in code and generates notes describing the variable locations to RTL code. The location lists are then generated according to these notes to debug information if the debugging information format supports -location lists. The code is located in @file{var-tracking.c}. +location lists. The code is located in @file{var-tracking.cc}. @item Delayed branch scheduling This optional pass attempts to find instructions that can go into the delay slots of other instructions, usually jumps and calls. The code -for this pass is located in @file{reorg.c}. +for this pass is located in @file{reorg.cc}. @item Branch shortening @@ -1163,19 +1163,19 @@ Thus, longer sequences of instructions must be used for long branches. In this pass, the compiler figures out what how far each instruction will be from each other instruction, and therefore whether the usual instructions, or the longer sequences, must be used for each branch. -The code for this pass is located in @file{final.c}. +The code for this pass is located in @file{final.cc}. @item Register-to-stack conversion Conversion from usage of some hard registers to usage of a register stack may be done at this point. Currently, this is supported only for the floating-point registers of the Intel 80387 coprocessor. The -code for this pass is located in @file{reg-stack.c}. +code for this pass is located in @file{reg-stack.cc}. @item Final This pass outputs the assembler code for the function. The source files -are @file{final.c} plus @file{insn-output.c}; the latter is generated +are @file{final.cc} plus @file{insn-output.cc}; the latter is generated automatically from the machine description by the tool @file{genoutput}. The header file @file{conditions.h} is used for communication between these files. @@ -1184,9 +1184,9 @@ these files. This is run after final because it must output the stack slot offsets for pseudo registers that did not get hard registers. Source files -are @file{dbxout.c} for DBX symbol table format, @file{dwarfout.c} for -DWARF symbol table format, files @file{dwarf2out.c} and @file{dwarf2asm.c} -for DWARF2 symbol table format, and @file{vmsdbgout.c} for VMS debug +are @file{dbxout.cc} for DBX symbol table format, @file{dwarfout.c} for +DWARF symbol table format, files @file{dwarf2out.cc} and @file{dwarf2asm.cc} +for DWARF2 symbol table format, and @file{vmsdbgout.cc} for VMS debug symbol table format. @end itemize diff --git a/gcc/doc/plugins.texi b/gcc/doc/plugins.texi index 9f24db5..6d1a5fa 100644 --- a/gcc/doc/plugins.texi +++ b/gcc/doc/plugins.texi @@ -511,7 +511,7 @@ plugin.so: $(PLUGIN_SOURCE_FILES) @end smallexample A single source file plugin may be built with @code{g++ -I`gcc --print-file-name=plugin`/include -fPIC -shared -fno-rtti -O2 plugin.c -o +-print-file-name=plugin`/include -fPIC -shared -fno-rtti -O2 plugin.cc -o plugin.so}, using backquote shell syntax to query the @file{plugin} directory. @@ -554,7 +554,7 @@ compiler: @smallexample g++ -I`gcc -print-file-name=plugin`/include -shared -Wl,--export-all-symbols \ --o plugin.dll plugin.c `gcc -print-file-name=plugin`/cc1plus.exe.a +-o plugin.dll plugin.cc `gcc -print-file-name=plugin`/cc1plus.exe.a @end smallexample When a plugin needs to use @command{gengtype}, be sure that both diff --git a/gcc/doc/rtl.texi b/gcc/doc/rtl.texi index 8f55841..43c9ee8 100644 --- a/gcc/doc/rtl.texi +++ b/gcc/doc/rtl.texi @@ -2205,7 +2205,7 @@ On a few targets, @code{FLOAT_WORDS_BIG_ENDIAN} disagrees with @code{WORDS_BIG_ENDIAN}. However, most parts of the compiler treat floating point values as if they had the same endianness as integer values. This works because they handle them solely as a collection of -integer values, with no particular numerical value. Only real.c and +integer values, with no particular numerical value. Only real.cc and the runtime libraries care about @code{FLOAT_WORDS_BIG_ENDIAN}. Thus, @@ -3846,7 +3846,7 @@ equivalent to testing whether @samp{LABEL_KIND (label) == LABEL_NORMAL}. The only place that cares about the distinction between static, global, and weak alternate entry points, besides the front-end code that creates them, is the function @code{output_alternate_entry_point}, in -@file{final.c}. +@file{final.cc}. To set the kind of a label, use the @code{SET_LABEL_KIND} macro. @@ -4935,7 +4935,7 @@ It returns true on success or false if no suitable location exists. The pass should also tentatively change the pattern of the instruction to whatever form the pass wants the instruction to have. This should use -the facilities provided by @file{recog.c}. For example: +the facilities provided by @file{recog.cc}. For example: @smallexample rtl_insn *rtl = insn->rtl (); @@ -5223,7 +5223,7 @@ side-effects on other insns. @item During initial RTL generation, shared structure is freely introduced. After all the RTL for a function has been generated, all shared -structure is copied by @code{unshare_all_rtl} in @file{emit-rtl.c}, +structure is copied by @code{unshare_all_rtl} in @file{emit-rtl.cc}, after which the above rules are guaranteed to be followed. @findex copy_rtx_if_shared @@ -5240,7 +5240,7 @@ combiner is finished with the insn. This is done by calling To read an RTL object from a file, call @code{read_rtx}. It takes one argument, a stdio stream, and returns a single RTL object. This routine -is defined in @file{read-rtl.c}. It is not available in the compiler +is defined in @file{read-rtl.cc}. It is not available in the compiler itself, only the various programs that generate the compiler back end from the machine description. diff --git a/gcc/doc/sourcebuild.texi b/gcc/doc/sourcebuild.texi index 6095a35..2d128f4 100644 --- a/gcc/doc/sourcebuild.texi +++ b/gcc/doc/sourcebuild.texi @@ -523,7 +523,7 @@ link to such information in the front end's own manual. Details of source file suffixes for that language and @option{-x @var{lang}} options supported, in @file{gcc/doc/invoke.texi}. @item -Entries in @code{default_compilers} in @file{gcc.c} for source file +Entries in @code{default_compilers} in @file{gcc.cc} for source file suffixes for that language. @item Preferably testsuites, which may be under @file{gcc/testsuite} or @@ -607,7 +607,7 @@ This file registers the set of switches that the front end accepts on the command line, and their @option{--help} text. @xref{Options}. @item lang-specs.h This file provides entries for @code{default_compilers} in -@file{gcc.c} which override the default of giving an error that a +@file{gcc.cc} which override the default of giving an error that a compiler for that language is not installed. @item @var{language}-tree.def This file, which need not exist, defines any language-specific tree @@ -666,7 +666,7 @@ be used to create a file @file{@var{language}/Makefile} from everything from the single @file{gcc/Makefile} is preferred. @item gtfiles If defined, a space-separated list of files that should be scanned by -@file{gengtype.c} to generate the garbage collection tables and routines for +@file{gengtype.cc} to generate the garbage collection tables and routines for this language. This excludes the files that are common to all front ends. @xref{Type Information}. diff --git a/gcc/doc/tm.texi b/gcc/doc/tm.texi index c934f7a..962bbb8 100644 --- a/gcc/doc/tm.texi +++ b/gcc/doc/tm.texi @@ -240,7 +240,7 @@ between the two is that @code{LIB_SPEC} is used at the end of the command given to the linker. If this macro is not defined, a default is provided that -loads the standard C library from the usual place. See @file{gcc.c}. +loads the standard C library from the usual place. See @file{gcc.cc}. @end defmac @defmac LIBGCC_SPEC @@ -287,7 +287,7 @@ difference between the two is that @code{STARTFILE_SPEC} is used at the very beginning of the command given to the linker. If this macro is not defined, a default is provided that loads the -standard C startup file from the usual place. See @file{gcc.c}. +standard C startup file from the usual place. See @file{gcc.cc}. @end defmac @defmac ENDFILE_SPEC @@ -392,7 +392,7 @@ The default value of this macro is empty string. @defmac LINK_COMMAND_SPEC A C string constant giving the complete command line need to execute the linker. When you do this, you will need to update your port each time a -change is made to the link command line within @file{gcc.c}. Therefore, +change is made to the link command line within @file{gcc.cc}. Therefore, define this macro only if you need to completely redefine the command line for invoking the linker and there is no other way to accomplish the effect you need. Overriding this macro may be avoidable by overriding @@ -1494,7 +1494,7 @@ ordinary types as @samp{@w{U @var{n} @var{name} @var{code}}}, where @var{name} is the name used for the type qualifier in source code, @var{n} is the length of @var{name} as above, and @var{code} is the code used to represent the unqualified version of this type. (See -@code{write_builtin_type} in @file{cp/mangle.c} for the list of +@code{write_builtin_type} in @file{cp/mangle.cc} for the list of codes.) In both cases the spaces are for clarity; do not include any spaces in your string. @@ -1667,7 +1667,7 @@ The string can contain more than one keyword. If so, separate them with spaces, and write first any length keyword, then @code{unsigned} if appropriate, and finally @code{int}. The string must exactly match one of the data type names defined in the function -@code{c_common_nodes_and_builtins} in the file @file{c-family/c-common.c}. +@code{c_common_nodes_and_builtins} in the file @file{c-family/c-common.cc}. You may not omit @code{int} or change the order---that would cause the compiler to crash on startup. @@ -2347,7 +2347,7 @@ they must be consecutively numbered. Furthermore, the existing support for stack-like registers is specific to the 80387 floating point coprocessor. If you have a new architecture that uses stack-like registers, you will need to do substantial work on -@file{reg-stack.c} and write your machine description to cooperate +@file{reg-stack.cc} and write your machine description to cooperate with it, as well as defining these macros. @defmac STACK_REGS @@ -2877,7 +2877,7 @@ However, this default behavior is not correct on some machines, such as the DEC Alpha, that store short integers in floating-point registers differently than in integer registers. On those machines, the default widening will not work correctly and you must define this hook to -suppress that widening in some cases. See the file @file{alpha.c} for +suppress that widening in some cases. See the file @file{alpha.cc} for details. With LRA, the default is to use @var{mode} unmodified. @@ -3178,7 +3178,7 @@ on the stack, e.g., by @code{alloca}. The default value for this macro is @code{STACK_POINTER_OFFSET} plus the length of the outgoing arguments. The default is correct for most -machines. See @file{function.c} for details. +machines. See @file{function.cc} for details. @end defmac @defmac INITIAL_FRAME_ADDRESS_RTX @@ -4386,7 +4386,7 @@ type of @var{type}. If @var{type} is not a valid va_list type, it returns This hook performs target-specific gimplification of @code{VA_ARG_EXPR}. The first two parameters correspond to the arguments to @code{va_arg}; the latter two are as in -@code{gimplify.c:gimplify_expr}. +@code{gimplify.cc:gimplify_expr}. @end deftypefn @deftypefn {Target Hook} bool TARGET_VALID_POINTER_MODE (scalar_int_mode @var{mode}) @@ -4420,7 +4420,7 @@ must work. The default version of this hook returns true for any mode required to handle the basic C types (as defined by the port). Included here are the double-word arithmetic supported by the -code in @file{optabs.c}. +code in @file{optabs.cc}. @end deftypefn @deftypefn {Target Hook} bool TARGET_VECTOR_MODE_SUPPORTED_P (machine_mode @var{mode}) @@ -5642,7 +5642,7 @@ are ABI-mandated names that the compiler should provide. @deftypefn {Target Hook} void TARGET_INIT_LIBFUNCS (void) This hook should declare additional library routines or rename existing ones, using the functions @code{set_optab_libfunc} and -@code{init_one_libfunc} defined in @file{optabs.c}. +@code{init_one_libfunc} defined in @file{optabs.cc}. @code{init_optabs} calls this macro after initializing all the normal library routines. @@ -5868,9 +5868,9 @@ preserve functionality of inline assembly constructs using the @defmac FIND_BASE_TERM (@var{x}) A C expression to determine the base term of address @var{x}, -or to provide a simplified version of @var{x} from which @file{alias.c} +or to provide a simplified version of @var{x} from which @file{alias.cc} can easily find the base term. This macro is used in only two places: -@code{find_base_value} and @code{find_base_term} in @file{alias.c}. +@code{find_base_value} and @code{find_base_term} in @file{alias.cc}. It is always safe for this macro to not be defined. It exists so that alias analysis can understand machine-dependent addresses. @@ -7569,11 +7569,11 @@ section}, which holds initialized writable data; and the @dfn{bss section}, which holds uninitialized data. Some systems have other kinds of sections. -@file{varasm.c} provides several well-known sections, such as +@file{varasm.cc} provides several well-known sections, such as @code{text_section}, @code{data_section} and @code{bss_section}. The normal way of controlling a @code{@var{foo}_section} variable is to define the associated @code{@var{FOO}_SECTION_ASM_OP} macro, -as described below. The macros are only read once, when @file{varasm.c} +as described below. The macros are only read once, when @file{varasm.cc} initializes itself, so their values must be run-time constants. They may however depend on command-line flags. @@ -7593,7 +7593,7 @@ in @code{TARGET_ASM_INIT_SECTIONS}. The same is true of create a distinct @code{readonly_data_section}, the default is to reuse @code{text_section}. -All the other @file{varasm.c} sections are optional, and are null +All the other @file{varasm.cc} sections are optional, and are null if the target does not provide them. @defmac TEXT_SECTION_ASM_OP @@ -7740,7 +7740,7 @@ This macro is irrelevant if there is no separate readonly data section. @deftypefn {Target Hook} void TARGET_ASM_INIT_SECTIONS (void) Define this hook if you need to do something special to set up the -@file{varasm.c} sections, or if your target has some special sections +@file{varasm.cc} sections, or if your target has some special sections of its own that you need to create. GCC calls this hook after processing the command line, but before writing @@ -7879,7 +7879,7 @@ encode more than one bit of information, but this practice is now discouraged; use @code{SYMBOL_REF_FLAGS}. The default definition of this hook, @code{default_encode_section_info} -in @file{varasm.c}, sets a number of commonly-useful bits in +in @file{varasm.cc}, sets a number of commonly-useful bits in @code{SYMBOL_REF_FLAGS}. Check whether the default does what you need before overriding it. @end deftypefn @@ -8428,7 +8428,7 @@ A C statement (sans semicolon) to output to the stdio stream is the alignment specified as the number of bits. Try to use function @code{asm_output_aligned_bss} defined in file -@file{varasm.c} when defining this macro. If unable, use the expression +@file{varasm.cc} when defining this macro. If unable, use the expression @code{assemble_name (@var{stream}, @var{name})} to output the name itself; before and after that, output the additional assembler syntax for defining the name, and a newline. @@ -8789,7 +8789,7 @@ requires changes to @var{decl}, such as putting it in a separate section. A C expression which evaluates to true if the target supports one-only semantics. -If you don't define this macro, @file{varasm.c} provides a default +If you don't define this macro, @file{varasm.cc} provides a default definition. If @code{MAKE_DECL_ONE_ONLY} is defined, the default definition is @samp{1}; otherwise, it is @samp{0}. Define this macro if you want to control one-only symbol support with a compiler flag, or if @@ -8854,7 +8854,7 @@ systems. This macro is used in @code{assemble_name}. @end defmac @deftypefn {Target Hook} tree TARGET_MANGLE_ASSEMBLER_NAME (const char *@var{name}) -Given a symbol @var{name}, perform same mangling as @code{varasm.c}'s +Given a symbol @var{name}, perform same mangling as @code{varasm.cc}'s @code{assemble_name}, but in memory rather than to a file stream, returning result as an @code{IDENTIFIER_NODE}. Required for correct LTO symtabs. The default implementation calls the @code{TARGET_STRIP_NAME_ENCODING} hook and @@ -9469,7 +9469,7 @@ being output. @defmacx IMMEDIATE_PREFIX If defined, C string expressions to be used for the @samp{%R}, @samp{%L}, @samp{%U}, and @samp{%I} options of @code{asm_fprintf} (see -@file{final.c}). These are useful when a single @file{md} file must +@file{final.cc}). These are useful when a single @file{md} file must support multiple assembler formats. In that case, the various @file{tm.h} files can define these macros differently. @end defmac @@ -10593,7 +10593,7 @@ the expansion of @code{TARGET_MERGE_DECL_ATTRIBUTES}. You can also add @code{handle_dll_attribute} in the attribute table for your port to perform initial processing of the @samp{dllimport} and @samp{dllexport} attributes. This is done in @file{i386/cygwin.h} and -@file{i386/i386.c}, for example. +@file{i386/i386.cc}, for example. @end deftypefn @deftypefn {Target Hook} bool TARGET_VALID_DLLIMPORT_ATTRIBUTE_P (const_tree @var{decl}) diff --git a/gcc/doc/tm.texi.in b/gcc/doc/tm.texi.in index d6359aa..394b59e 100644 --- a/gcc/doc/tm.texi.in +++ b/gcc/doc/tm.texi.in @@ -240,7 +240,7 @@ between the two is that @code{LIB_SPEC} is used at the end of the command given to the linker. If this macro is not defined, a default is provided that -loads the standard C library from the usual place. See @file{gcc.c}. +loads the standard C library from the usual place. See @file{gcc.cc}. @end defmac @defmac LIBGCC_SPEC @@ -287,7 +287,7 @@ difference between the two is that @code{STARTFILE_SPEC} is used at the very beginning of the command given to the linker. If this macro is not defined, a default is provided that loads the -standard C startup file from the usual place. See @file{gcc.c}. +standard C startup file from the usual place. See @file{gcc.cc}. @end defmac @defmac ENDFILE_SPEC @@ -392,7 +392,7 @@ The default value of this macro is empty string. @defmac LINK_COMMAND_SPEC A C string constant giving the complete command line need to execute the linker. When you do this, you will need to update your port each time a -change is made to the link command line within @file{gcc.c}. Therefore, +change is made to the link command line within @file{gcc.cc}. Therefore, define this macro only if you need to completely redefine the command line for invoking the linker and there is no other way to accomplish the effect you need. Overriding this macro may be avoidable by overriding @@ -1435,7 +1435,7 @@ The string can contain more than one keyword. If so, separate them with spaces, and write first any length keyword, then @code{unsigned} if appropriate, and finally @code{int}. The string must exactly match one of the data type names defined in the function -@code{c_common_nodes_and_builtins} in the file @file{c-family/c-common.c}. +@code{c_common_nodes_and_builtins} in the file @file{c-family/c-common.cc}. You may not omit @code{int} or change the order---that would cause the compiler to crash on startup. @@ -1963,7 +1963,7 @@ they must be consecutively numbered. Furthermore, the existing support for stack-like registers is specific to the 80387 floating point coprocessor. If you have a new architecture that uses stack-like registers, you will need to do substantial work on -@file{reg-stack.c} and write your machine description to cooperate +@file{reg-stack.cc} and write your machine description to cooperate with it, as well as defining these macros. @defmac STACK_REGS @@ -2479,7 +2479,7 @@ on the stack, e.g., by @code{alloca}. The default value for this macro is @code{STACK_POINTER_OFFSET} plus the length of the outgoing arguments. The default is correct for most -machines. See @file{function.c} for details. +machines. See @file{function.cc} for details. @end defmac @defmac INITIAL_FRAME_ADDRESS_RTX @@ -4074,9 +4074,9 @@ preserve functionality of inline assembly constructs using the @defmac FIND_BASE_TERM (@var{x}) A C expression to determine the base term of address @var{x}, -or to provide a simplified version of @var{x} from which @file{alias.c} +or to provide a simplified version of @var{x} from which @file{alias.cc} can easily find the base term. This macro is used in only two places: -@code{find_base_value} and @code{find_base_term} in @file{alias.c}. +@code{find_base_value} and @code{find_base_term} in @file{alias.cc}. It is always safe for this macro to not be defined. It exists so that alias analysis can understand machine-dependent addresses. @@ -4745,11 +4745,11 @@ section}, which holds initialized writable data; and the @dfn{bss section}, which holds uninitialized data. Some systems have other kinds of sections. -@file{varasm.c} provides several well-known sections, such as +@file{varasm.cc} provides several well-known sections, such as @code{text_section}, @code{data_section} and @code{bss_section}. The normal way of controlling a @code{@var{foo}_section} variable is to define the associated @code{@var{FOO}_SECTION_ASM_OP} macro, -as described below. The macros are only read once, when @file{varasm.c} +as described below. The macros are only read once, when @file{varasm.cc} initializes itself, so their values must be run-time constants. They may however depend on command-line flags. @@ -4769,7 +4769,7 @@ in @code{TARGET_ASM_INIT_SECTIONS}. The same is true of create a distinct @code{readonly_data_section}, the default is to reuse @code{text_section}. -All the other @file{varasm.c} sections are optional, and are null +All the other @file{varasm.cc} sections are optional, and are null if the target does not provide them. @defmac TEXT_SECTION_ASM_OP @@ -5300,7 +5300,7 @@ A C statement (sans semicolon) to output to the stdio stream is the alignment specified as the number of bits. Try to use function @code{asm_output_aligned_bss} defined in file -@file{varasm.c} when defining this macro. If unable, use the expression +@file{varasm.cc} when defining this macro. If unable, use the expression @code{assemble_name (@var{stream}, @var{name})} to output the name itself; before and after that, output the additional assembler syntax for defining the name, and a newline. @@ -5631,7 +5631,7 @@ requires changes to @var{decl}, such as putting it in a separate section. A C expression which evaluates to true if the target supports one-only semantics. -If you don't define this macro, @file{varasm.c} provides a default +If you don't define this macro, @file{varasm.cc} provides a default definition. If @code{MAKE_DECL_ONE_ONLY} is defined, the default definition is @samp{1}; otherwise, it is @samp{0}. Define this macro if you want to control one-only symbol support with a compiler flag, or if @@ -6241,7 +6241,7 @@ being output. @defmacx IMMEDIATE_PREFIX If defined, C string expressions to be used for the @samp{%R}, @samp{%L}, @samp{%U}, and @samp{%I} options of @code{asm_fprintf} (see -@file{final.c}). These are useful when a single @file{md} file must +@file{final.cc}). These are useful when a single @file{md} file must support multiple assembler formats. In that case, the various @file{tm.h} files can define these macros differently. @end defmac diff --git a/gcc/doc/tree-ssa.texi b/gcc/doc/tree-ssa.texi index 5e6eb7e..f962ef9 100644 --- a/gcc/doc/tree-ssa.texi +++ b/gcc/doc/tree-ssa.texi @@ -183,7 +183,7 @@ call to @code{update_stmt}. @cindex Operand Iterators @cindex Operand Access Routines -Operands are collected by @file{tree-ssa-operands.c}. They are stored +Operands are collected by @file{tree-ssa-operands.cc}. They are stored inside each statement's annotation and can be accessed through either the operand iterators or an access routine. @@ -462,7 +462,7 @@ expressions are renamed so that their version number matches that of the most recent assignment. We represent variable versions using @code{SSA_NAME} nodes. The -renaming process in @file{tree-ssa.c} wraps every real and +renaming process in @file{tree-ssa.cc} wraps every real and virtual operand with an @code{SSA_NAME} node which contains the version number and the statement that created the @code{SSA_NAME}. Only definitions and virtual definitions may @@ -763,7 +763,7 @@ or that is used by pure or nested const calls. @item Type-based alias analysis Type-based alias analysis is frontend dependent though generic -support is provided by the middle-end in @code{alias.c}. TBAA +support is provided by the middle-end in @code{alias.cc}. TBAA code is used by both tree optimizers and RTL optimizers. Every language that wishes to perform language-specific alias analysis diff --git a/gcc/dojump.cc b/gcc/dojump.cc index f73ca11..0c880d6 100644 --- a/gcc/dojump.cc +++ b/gcc/dojump.cc @@ -472,7 +472,7 @@ do_jump (tree exp, rtx_code_label *if_false_label, } case COMPOUND_EXPR: - /* Lowered by gimplify.c. */ + /* Lowered by gimplify.cc. */ gcc_unreachable (); case MINUS_EXPR: diff --git a/gcc/dojump.h b/gcc/dojump.h index fb3fa89..e379cce 100644 --- a/gcc/dojump.h +++ b/gcc/dojump.h @@ -1,4 +1,4 @@ -/* Export function prototypes from dojump.c. +/* Export function prototypes from dojump.cc. Copyright (C) 2015-2022 Free Software Foundation, Inc. This file is part of GCC. diff --git a/gcc/dumpfile.cc b/gcc/dumpfile.cc index 778b0bf..44ee66f 100644 --- a/gcc/dumpfile.cc +++ b/gcc/dumpfile.cc @@ -2211,7 +2211,7 @@ test_impl_location () dump_location_t loc; const int expected_line = __LINE__ - 1; ASSERT_IMPL_LOCATION_EQ (loc.get_impl_location (), - "dumpfile.c", expected_line, "test_impl_location"); + "dumpfile.cc", expected_line, "test_impl_location"); } /* Constructing from a gimple. */ @@ -2219,7 +2219,7 @@ test_impl_location () dump_location_t loc ((gimple *)NULL); const int expected_line = __LINE__ - 1; ASSERT_IMPL_LOCATION_EQ (loc.get_impl_location (), - "dumpfile.c", expected_line, "test_impl_location"); + "dumpfile.cc", expected_line, "test_impl_location"); } /* Constructing from an rtx_insn. */ @@ -2227,7 +2227,7 @@ test_impl_location () dump_location_t loc ((rtx_insn *)NULL); const int expected_line = __LINE__ - 1; ASSERT_IMPL_LOCATION_EQ (loc.get_impl_location (), - "dumpfile.c", expected_line, "test_impl_location"); + "dumpfile.cc", expected_line, "test_impl_location"); } } @@ -2313,7 +2313,7 @@ test_capture_of_dump_calls (const line_table_case &case_) ASSERT_EQ (info->num_items (), 1); ASSERT_IS_TEXT (info->get_item (0), "int: 42 str: foo"); ASSERT_IMPL_LOCATION_EQ (info->get_impl_location (), - "dumpfile.c", expected_impl_line, + "dumpfile.cc", expected_impl_line, "test_capture_of_dump_calls"); } } @@ -2335,7 +2335,7 @@ test_capture_of_dump_calls (const line_table_case &case_) ASSERT_IS_TEXT (info->get_item (0), "tree: "); ASSERT_IS_TREE (info->get_item (1), UNKNOWN_LOCATION, "0"); ASSERT_IMPL_LOCATION_EQ (info->get_impl_location (), - "dumpfile.c", expected_impl_line, + "dumpfile.cc", expected_impl_line, "test_capture_of_dump_calls"); } } @@ -2357,7 +2357,7 @@ test_capture_of_dump_calls (const line_table_case &case_) ASSERT_IS_TEXT (info->get_item (0), "gimple: "); ASSERT_IS_GIMPLE (info->get_item (1), stmt_loc, "return;"); ASSERT_IMPL_LOCATION_EQ (info->get_impl_location (), - "dumpfile.c", expected_impl_line, + "dumpfile.cc", expected_impl_line, "test_capture_of_dump_calls"); } } @@ -2379,7 +2379,7 @@ test_capture_of_dump_calls (const line_table_case &case_) ASSERT_IS_TEXT (info->get_item (0), "gimple: "); ASSERT_IS_GIMPLE (info->get_item (1), stmt_loc, "return;\n"); ASSERT_IMPL_LOCATION_EQ (info->get_impl_location (), - "dumpfile.c", expected_impl_line, + "dumpfile.cc", expected_impl_line, "test_capture_of_dump_calls"); } } @@ -2401,7 +2401,7 @@ test_capture_of_dump_calls (const line_table_case &case_) ASSERT_IS_TEXT (info->get_item (0), "node: "); ASSERT_IS_SYMTAB_NODE (info->get_item (1), decl_loc, "test_decl/0"); ASSERT_IMPL_LOCATION_EQ (info->get_impl_location (), - "dumpfile.c", expected_impl_line, + "dumpfile.cc", expected_impl_line, "test_capture_of_dump_calls"); } } @@ -2461,7 +2461,7 @@ test_capture_of_dump_calls (const line_table_case &case_) ASSERT_IS_TEXT (info->get_item (0), "test of tree: "); ASSERT_IS_TREE (info->get_item (1), UNKNOWN_LOCATION, "0"); ASSERT_IMPL_LOCATION_EQ (info->get_impl_location (), - "dumpfile.c", expected_impl_line, + "dumpfile.cc", expected_impl_line, "test_capture_of_dump_calls"); } } @@ -2483,7 +2483,7 @@ test_capture_of_dump_calls (const line_table_case &case_) ASSERT_EQ (info->num_items (), 1); ASSERT_IS_TREE (info->get_item (0), UNKNOWN_LOCATION, "1"); ASSERT_IMPL_LOCATION_EQ (info->get_impl_location (), - "dumpfile.c", expected_impl_line, + "dumpfile.cc", expected_impl_line, "test_capture_of_dump_calls"); } } @@ -2505,7 +2505,7 @@ test_capture_of_dump_calls (const line_table_case &case_) ASSERT_EQ (info->num_items (), 1); ASSERT_IS_GIMPLE (info->get_item (0), stmt_loc, "return;\n"); ASSERT_IMPL_LOCATION_EQ (info->get_impl_location (), - "dumpfile.c", expected_impl_line, + "dumpfile.cc", expected_impl_line, "test_capture_of_dump_calls"); } } @@ -2525,7 +2525,7 @@ test_capture_of_dump_calls (const line_table_case &case_) ASSERT_EQ (info->num_items (), 1); ASSERT_IS_GIMPLE (info->get_item (0), stmt_loc, "return;\n"); ASSERT_IMPL_LOCATION_EQ (info->get_impl_location (), - "dumpfile.c", expected_impl_line, + "dumpfile.cc", expected_impl_line, "test_capture_of_dump_calls"); } } @@ -2545,7 +2545,7 @@ test_capture_of_dump_calls (const line_table_case &case_) ASSERT_EQ (info->num_items (), 1); ASSERT_IS_GIMPLE (info->get_item (0), stmt_loc, "return;"); ASSERT_IMPL_LOCATION_EQ (info->get_impl_location (), - "dumpfile.c", expected_impl_line, + "dumpfile.cc", expected_impl_line, "test_capture_of_dump_calls"); } } @@ -2565,7 +2565,7 @@ test_capture_of_dump_calls (const line_table_case &case_) ASSERT_EQ (info->num_items (), 1); ASSERT_IS_GIMPLE (info->get_item (0), stmt_loc, "return;"); ASSERT_IMPL_LOCATION_EQ (info->get_impl_location (), - "dumpfile.c", expected_impl_line, + "dumpfile.cc", expected_impl_line, "test_capture_of_dump_calls"); } } @@ -2587,7 +2587,7 @@ test_capture_of_dump_calls (const line_table_case &case_) ASSERT_EQ (info->num_items (), 1); ASSERT_IS_SYMTAB_NODE (info->get_item (0), decl_loc, "test_decl/0"); ASSERT_IMPL_LOCATION_EQ (info->get_impl_location (), - "dumpfile.c", expected_impl_line, + "dumpfile.cc", expected_impl_line, "test_capture_of_dump_calls"); } } @@ -2607,7 +2607,7 @@ test_capture_of_dump_calls (const line_table_case &case_) ASSERT_EQ (info->num_items (), 1); ASSERT_IS_TEXT (info->get_item (0), "42"); ASSERT_IMPL_LOCATION_EQ (info->get_impl_location (), - "dumpfile.c", expected_impl_line, + "dumpfile.cc", expected_impl_line, "test_capture_of_dump_calls"); } } @@ -2698,7 +2698,7 @@ test_capture_of_dump_calls (const line_table_case &case_) ASSERT_EQ (info->num_items (), 1); ASSERT_IS_TEXT (info->get_item (0), "msg 7\n"); ASSERT_IMPL_LOCATION_EQ (info->get_impl_location (), - "dumpfile.c", expected_impl_line, + "dumpfile.cc", expected_impl_line, "test_capture_of_dump_calls"); } } diff --git a/gcc/dumpfile.h b/gcc/dumpfile.h index 526eb1c..3c47f09 100644 --- a/gcc/dumpfile.h +++ b/gcc/dumpfile.h @@ -25,8 +25,8 @@ along with GCC; see the file COPYING3. If not see /* An attribute for annotating formatting printing functions that use the dumpfile/optinfo formatting codes. These are the pretty_printer - format codes (see pretty-print.c), with additional codes for middle-end - specific entities (see dumpfile.c). */ + format codes (see pretty-print.cc), with additional codes for middle-end + specific entities (see dumpfile.cc). */ #if GCC_VERSION >= 9000 #define ATTRIBUTE_GCC_DUMP_PRINTF(m, n) \ @@ -37,7 +37,7 @@ along with GCC; see the file COPYING3. If not see #endif /* Different tree dump places. When you add new tree dump places, - extend the DUMP_FILES array in dumpfile.c. */ + extend the DUMP_FILES array in dumpfile.cc. */ enum tree_dump_index { TDI_none, /* No dump */ @@ -71,7 +71,7 @@ enum dump_kind /* Bit masks to control dumping. Not all values are applicable to all dumps. Add new ones at the end. When you define new values, extend - the DUMP_OPTIONS array in dumpfile.c. The TDF_* flags coexist with + the DUMP_OPTIONS array in dumpfile.cc. The TDF_* flags coexist with MSG_* flags (for -fopt-info) and the bit values must be chosen to allow that. */ enum dump_flag : uint32_t @@ -509,7 +509,7 @@ class dump_location_t dump_impl_location_t m_impl_location; }; -/* In dumpfile.c */ +/* In dumpfile.cc */ extern FILE *dump_begin (int, dump_flags_t *, int part=-1); extern void dump_end (int, FILE *); extern int opt_info_switch_p (const char *); @@ -550,7 +550,7 @@ dump_enabled_p (void) (b) the "optinfo" destinations, if any: (b.1) as optimization records - dump_* (MSG_*) --> dumpfile.c --> items --> (a.1) dump_file + dump_* (MSG_*) --> dumpfile.cc --> items --> (a.1) dump_file | `-> (a.2) alt_dump_file | `--> (b) optinfo @@ -650,12 +650,12 @@ extern void dump_function (int phase, tree fn); extern void print_combine_total_stats (void); extern bool enable_rtl_dump_file (void); -/* In tree-dump.c */ +/* In tree-dump.cc */ extern void dump_node (const_tree, dump_flags_t, FILE *); -/* In combine.c */ +/* In combine.cc */ extern void dump_combine_total_stats (FILE *); -/* In cfghooks.c */ +/* In cfghooks.cc */ extern void dump_bb (FILE *, basic_block, int, dump_flags_t); class opt_pass; diff --git a/gcc/dwarf2asm.cc b/gcc/dwarf2asm.cc index 8f66338..274f574 100644 --- a/gcc/dwarf2asm.cc +++ b/gcc/dwarf2asm.cc @@ -857,7 +857,7 @@ dw2_asm_output_delta_uleb128 (const char *lab1 ATTRIBUTE_UNUSED, fputs ("\t.uleb128 ", asm_out_file); assemble_name (asm_out_file, lab1); putc ('-', asm_out_file); - /* dwarf2out.c might give us a label expression (e.g. .LVL548-1) + /* dwarf2out.cc might give us a label expression (e.g. .LVL548-1) as second argument. If so, make it a subexpression, to make sure the substraction is done in the right order. */ if (strchr (lab2, '-') != NULL) diff --git a/gcc/dwarf2ctf.h b/gcc/dwarf2ctf.h index 08c8d36..ae917ac 100644 --- a/gcc/dwarf2ctf.h +++ b/gcc/dwarf2ctf.h @@ -26,7 +26,7 @@ along with GCC; see the file COPYING3. If not see #include "dwarf2out.h" #include "flags.h" -/* Debug Format Interface. Used in dwarf2out.c. */ +/* Debug Format Interface. Used in dwarf2out.cc. */ extern void ctf_debug_init (void); extern void ctf_debug_init_postprocess (bool); @@ -35,7 +35,7 @@ extern void ctf_debug_early_finish (const char *); extern void ctf_debug_finish (const char *); /* Wrappers for CTF/BTF to fetch information from GCC DWARF DIE. Used in - ctfc.c. + ctfc.cc. A CTF container does not store all debug information internally. Some of the info is fetched indirectly via the DIE reference available in each CTF diff --git a/gcc/dwarf2out.cc b/gcc/dwarf2out.cc index 094fd0a..62b468d 100644 --- a/gcc/dwarf2out.cc +++ b/gcc/dwarf2out.cc @@ -1078,7 +1078,7 @@ dwarf2out_begin_prologue (unsigned int line ATTRIBUTE_UNUSED, do_frame = dwarf2out_do_frame (); - /* ??? current_function_func_begin_label is also used by except.c for + /* ??? current_function_func_begin_label is also used by except.cc for call-site information. We must emit this label if it might be used. */ if (!do_frame && (!flag_exceptions @@ -18061,7 +18061,7 @@ struct loc_descr_context that can be factorized in order to reduce the size of the output debug information. This is the whole point of DWARF procedures. - Thanks to stor-layout.c, size and offset expressions in GENERIC trees are + Thanks to stor-layout.cc, size and offset expressions in GENERIC trees are already factorized into functions ("size functions") in order to handle very big and complex types. Such functions are quite simple: they have integral arguments, they return an integral result and their body contains only a @@ -20497,7 +20497,7 @@ rtl_for_decl_location (tree decl) rarely enough that it is not a major problem, but it *is* a problem, and I'd like to fix it. - A future version of dwarf2out.c may generate two additional attributes for + A future version of dwarf2out.cc may generate two additional attributes for any given DW_TAG_formal_parameter DIE which will describe the "passed type" and the "passed location" for the given formal parameter in addition to the attributes we now generate to indicate the "declared type" and the @@ -20573,7 +20573,7 @@ rtl_for_decl_location (tree decl) /* If the parm was passed in registers, but lives on the stack, then make a big endian correction if the mode of the type of the parameter is not the same as the mode of the rtl. */ - /* ??? This is the same series of checks that are made in dbxout.c before + /* ??? This is the same series of checks that are made in dbxout.cc before we reach the big endian correction code there. It isn't clear if all of these checks are necessary here, but keeping them all is the safe thing to do. */ @@ -23807,7 +23807,7 @@ gen_subprogram_die (tree decl, dw_die_ref context_die) { /* DWARF requires here a location expression that computes the address of the enclosing subprogram's frame base. The machinery - in tree-nested.c is supposed to store this specific address in the + in tree-nested.cc is supposed to store this specific address in the last field of the FRAME record. */ const tree frame_type = TREE_TYPE (TREE_TYPE (fun->static_chain_decl)); @@ -24640,7 +24640,7 @@ gen_label_die (tree decl, dw_die_ref context_die) && NOTE_KIND (insn) == NOTE_INSN_DELETED_LABEL)))) { /* When optimization is enabled (via -O) some parts of the compiler - (e.g. jump.c and cse.c) may try to delete CODE_LABEL insns which + (e.g. jump.cc and cse.cc) may try to delete CODE_LABEL insns which represent source-level labels which were explicitly declared by the user. This really shouldn't be happening though, so catch it if it ever does happen. */ @@ -27133,7 +27133,7 @@ is_trivial_indirect_ref (tree expr) } /* Output debug information for global decl DECL. Called from - toplev.c after compilation proper has finished. */ + toplev.cc after compilation proper has finished. */ static void dwarf2out_late_global_decl (tree decl) @@ -27170,7 +27170,7 @@ dwarf2out_late_global_decl (tree decl) } } -/* Output debug information for type decl DECL. Called from toplev.c +/* Output debug information for type decl DECL. Called from toplev.cc and from language front ends (to record built-in types). */ static void dwarf2out_type_decl (tree decl, int local) @@ -27548,7 +27548,7 @@ dwarf_file_hasher::hash (dwarf_file_data *p) } /* Lookup FILE_NAME (in the list of filenames that we know about here in - dwarf2out.c) and return its "index". The index of each (known) filename is + dwarf2out.cc) and return its "index". The index of each (known) filename is just a unique number which is associated with only that one filename. We need such numbers for the sake of generating labels (in the .debug_sfnames section) and references to those files numbers (in the .debug_srcinfo @@ -28660,7 +28660,7 @@ dwarf2out_end_source_file (unsigned int lineno ATTRIBUTE_UNUSED) } } -/* Called from debug_define in toplev.c. The `buffer' parameter contains +/* Called from debug_define in toplev.cc. The `buffer' parameter contains the tail part of the directive line, i.e. the part which is past the initial whitespace, #, whitespace, directive-name, whitespace part. */ @@ -28687,7 +28687,7 @@ dwarf2out_define (unsigned int lineno ATTRIBUTE_UNUSED, } } -/* Called from debug_undef in toplev.c. The `buffer' parameter contains +/* Called from debug_undef in toplev.cc. The `buffer' parameter contains the tail part of the directive line, i.e. the part which is past the initial whitespace, #, whitespace, directive-name, whitespace part. */ @@ -33054,7 +33054,7 @@ dwarf2out_early_finish (const char *filename) switch_to_section (text_section); } -/* Reset all state within dwarf2out.c so that we can rerun the compiler +/* Reset all state within dwarf2out.cc so that we can rerun the compiler within the same process. For use by toplev::finalize. */ void diff --git a/gcc/dwarf2out.h b/gcc/dwarf2out.h index f4062af..ab2200b 100644 --- a/gcc/dwarf2out.h +++ b/gcc/dwarf2out.h @@ -1,4 +1,4 @@ -/* dwarf2out.h - Various declarations for functions found in dwarf2out.c +/* dwarf2out.h - Various declarations for functions found in dwarf2out.cc Copyright (C) 1998-2022 Free Software Foundation, Inc. This file is part of GCC. @@ -108,7 +108,7 @@ struct GTY(()) dw_fde_node { /* True iff dw_fde_second_begin label is in text_section or cold_text_section. */ unsigned second_in_std_section : 1; - /* True if Rule 18 described in dwarf2cfi.c is in action, i.e. for dynamic + /* True if Rule 18 described in dwarf2cfi.cc is in action, i.e. for dynamic stack realignment in between pushing of hard frame pointer to stack and setting hard frame pointer to stack pointer. The register save for hard frame pointer register should be emitted only on the latter @@ -313,7 +313,7 @@ struct GTY(()) dw_discr_list_node { int dw_discr_range; }; -/* Interface from dwarf2out.c to dwarf2cfi.c. */ +/* Interface from dwarf2out.cc to dwarf2cfi.cc. */ extern struct dw_loc_descr_node *build_cfa_loc (dw_cfa_location *, poly_int64); extern struct dw_loc_descr_node *build_cfa_aligned_loc @@ -329,7 +329,7 @@ extern unsigned long size_of_locs (dw_loc_descr_ref); extern void output_loc_sequence (dw_loc_descr_ref, int); extern void output_loc_sequence_raw (dw_loc_descr_ref); -/* Interface from dwarf2cfi.c to dwarf2out.c. */ +/* Interface from dwarf2cfi.cc to dwarf2out.cc. */ extern void lookup_cfa_1 (dw_cfi_ref cfi, dw_cfa_location *loc, dw_cfa_location *remember); extern bool cfa_equal_p (const dw_cfa_location *, const dw_cfa_location *); diff --git a/gcc/emit-rtl.cc b/gcc/emit-rtl.cc index feeee16..079e563 100644 --- a/gcc/emit-rtl.cc +++ b/gcc/emit-rtl.cc @@ -24,7 +24,7 @@ along with GCC; see the file COPYING3. If not see and manipulating them in the doubly-linked chain of insns. The patterns of the insns are created by machine-dependent - routines in insn-emit.c, which is generated automatically from + routines in insn-emit.cc, which is generated automatically from the machine description. These routines make the individual rtx's of the pattern with `gen_rtx_fmt_ee' and others in genrtl.[ch], which are automatically generated from rtl.def; what is machine @@ -489,7 +489,7 @@ gen_raw_REG (machine_mode mode, unsigned int regno) /* There are some RTL codes that require special attention; the generation functions do the raw handling. If you add to this list, modify - special_rtx in gengenrtl.c as well. */ + special_rtx in gengenrtl.cc as well. */ rtx_expr_list * gen_rtx_EXPR_LIST (machine_mode mode, rtx expr, rtx expr_list) @@ -1541,7 +1541,7 @@ maybe_set_max_label_num (rtx_code_label *x) representation is returned. This function handles the cases in common between gen_lowpart, below, - and two variants in cse.c and combine.c. These are the cases that can + and two variants in cse.cc and combine.cc. These are the cases that can be safely handled at all points in the compilation. If this is not a case we can handle, return 0. */ diff --git a/gcc/emit-rtl.h b/gcc/emit-rtl.h index 048325a..7a58fed 100644 --- a/gcc/emit-rtl.h +++ b/gcc/emit-rtl.h @@ -1,4 +1,4 @@ -/* Exported functions from emit-rtl.c +/* Exported functions from emit-rtl.cc Copyright (C) 2004-2022 Free Software Foundation, Inc. This file is part of GCC. @@ -76,7 +76,7 @@ struct GTY(()) rtl_data { rtl_ssa::function_info *GTY((skip)) ssa; - /* For function.c */ + /* For function.cc */ /* # of bytes of outgoing arguments. If ACCUMULATE_OUTGOING_ARGS is defined, the needed space is pushed by the prologue. */ @@ -232,7 +232,7 @@ struct GTY(()) rtl_data { bool arg_pointer_save_area_init; /* Nonzero if current function must be given a frame pointer. - Set in reload1.c or lra-eliminations.c if anything is allocated + Set in reload1.cc or lra-eliminations.cc if anything is allocated on the stack there. */ bool frame_pointer_needed; diff --git a/gcc/errors.cc b/gcc/errors.cc index baa3aaf..766e12e 100644 --- a/gcc/errors.cc +++ b/gcc/errors.cc @@ -19,7 +19,7 @@ along with GCC; see the file COPYING3. If not see /* warning, error, and fatal. These definitions are suitable for use in the generator programs; the compiler has a more elaborate suite - of diagnostic printers, found in diagnostic.c. */ + of diagnostic printers, found in diagnostic.cc. */ #ifdef HOST_GENERATOR_FILE #include "config.h" @@ -102,8 +102,8 @@ internal_error (const char *format, ...) /* Given a partial pathname as input, return another pathname that shares no directory elements with the pathname of __FILE__. This - is used by fancy_abort() to print `Internal compiler error in expr.c' - instead of `Internal compiler error in ../../GCC/gcc/expr.c'. This + is used by fancy_abort() to print `Internal compiler error in expr.cc' + instead of `Internal compiler error in ../../GCC/gcc/expr.cc'. This version is meant to be used for the gen* programs and therefor need not handle subdirectories. */ @@ -126,7 +126,7 @@ trim_filename (const char *name) /* "Fancy" abort. Reports where in the compiler someone gave up. This file is used only by build programs, so we're not as polite as - the version in diagnostic.c. */ + the version in diagnostic.cc. */ void fancy_abort (const char *file, int line, const char *func) { diff --git a/gcc/et-forest.cc b/gcc/et-forest.cc index 2d21b77..a1b1f57 100644 --- a/gcc/et-forest.cc +++ b/gcc/et-forest.cc @@ -770,7 +770,7 @@ et_root (struct et_node *node) namespace selftest { -/* Selftests for et-forest.c. */ +/* Selftests for et-forest.cc. */ /* Perform sanity checks for a tree consisting of a single node. */ diff --git a/gcc/except.cc b/gcc/except.cc index 0e17f28..b94de42 100644 --- a/gcc/except.cc +++ b/gcc/except.cc @@ -30,13 +30,13 @@ along with GCC; see the file COPYING3. If not see TRY_CATCH_EXPR, TRY_FINALLY_EXPR, EH_ELSE_EXPR, WITH_CLEANUP_EXPR, CLEANUP_POINT_EXPR, CATCH_EXPR, and EH_FILTER_EXPR. - During initial gimplification (gimplify.c) these are lowered to the + During initial gimplification (gimplify.cc) these are lowered to the GIMPLE_TRY, GIMPLE_CATCH, GIMPLE_EH_ELSE, and GIMPLE_EH_FILTER nodes. The WITH_CLEANUP_EXPR and CLEANUP_POINT_EXPR nodes are converted into GIMPLE_TRY_FINALLY nodes; the others are a more direct 1-1 conversion. - During pass_lower_eh (tree-eh.c) we record the nested structure + During pass_lower_eh (tree-eh.cc) we record the nested structure of the TRY nodes in EH_REGION nodes in CFUN->EH->REGION_TREE. We expand the eh_protect_cleanup_actions langhook into MUST_NOT_THROW regions at this time. We can then flatten the statements within @@ -53,7 +53,7 @@ along with GCC; see the file COPYING3. If not see select the action to perform among different CATCH and EH_FILTER regions. - During pass_lower_eh_dispatch (tree-eh.c), which is run after + During pass_lower_eh_dispatch (tree-eh.cc), which is run after all inlining is complete, we are able to run assign_filter_values, which allows us to map the set of types manipulated by all of the CATCH and EH_FILTER regions to a set of integers. This set of integers @@ -63,7 +63,7 @@ along with GCC; see the file COPYING3. If not see the runtime (__builtin_eh_filter) and the set of integers we computed in assign_filter_values. - During pass_lower_resx (tree-eh.c), which is run near the end + During pass_lower_resx (tree-eh.cc), which is run near the end of optimization, we expand RESX statements. If the eh region that is outer to the RESX statement is a MUST_NOT_THROW, then the RESX expands to some form of abort statement. If the eh @@ -74,7 +74,7 @@ along with GCC; see the file COPYING3. If not see up the call chain, so we call back into the exception runtime (__builtin_unwind_resume). - During pass_expand (cfgexpand.c), we generate REG_EH_REGION notes + During pass_expand (cfgexpand.cc), we generate REG_EH_REGION notes that create an rtl to eh_region mapping that corresponds to the gimple to eh_region mapping that had been recorded in the THROW_STMT_TABLE. @@ -90,7 +90,7 @@ along with GCC; see the file COPYING3. If not see calls into the runtime to register and unregister the current stack frame are emitted at this time. - During pass_convert_to_eh_region_ranges (except.c), we transform + During pass_convert_to_eh_region_ranges (except.cc), we transform the REG_EH_REGION notes attached to individual insns into non-overlapping ranges of insns bounded by NOTE_INSN_EH_REGION_BEG and NOTE_INSN_EH_REGION_END. Each insn within such ranges has the @@ -101,12 +101,12 @@ along with GCC; see the file COPYING3. If not see within the current function. Finally, during assembly generation, we call - output_function_exception_table (except.c) to emit the tables with + output_function_exception_table (except.cc) to emit the tables with which the exception runtime can determine if a given stack frame handles a given exception, and if so what filter value to provide to the function when the non-local control transfer is effected. If the target uses dwarf2 unwinding to implement exceptions, then - output_call_frame_info (dwarf2out.c) emits the required unwind data. */ + output_call_frame_info (dwarf2out.cc) emits the required unwind data. */ #include "config.h" @@ -358,7 +358,7 @@ init_eh_for_function (void) } /* Routines to generate the exception tree somewhat directly. - These are used from tree-eh.c when processing exception related + These are used from tree-eh.cc when processing exception related nodes during tree optimization. */ static eh_region diff --git a/gcc/explow.cc b/gcc/explow.cc index e2f4fd6..ddb4d6ae 100644 --- a/gcc/explow.cc +++ b/gcc/explow.cc @@ -903,7 +903,7 @@ promote_ssa_mode (const_tree name, int *punsignedp) gcc_assert (TREE_CODE (name) == SSA_NAME); /* Partitions holding parms and results must be promoted as expected - by function.c. */ + by function.cc. */ if (SSA_NAME_VAR (name) && (TREE_CODE (SSA_NAME_VAR (name)) == PARM_DECL || TREE_CODE (SSA_NAME_VAR (name)) == RESULT_DECL)) @@ -1264,7 +1264,7 @@ get_dynamic_stack_size (rtx *psize, unsigned size_align, /* We will need to ensure that the address we return is aligned to REQUIRED_ALIGN. At this point in the compilation, we don't always - know the final value of the STACK_DYNAMIC_OFFSET used in function.c + know the final value of the STACK_DYNAMIC_OFFSET used in function.cc (it might depend on the size of the outgoing parameter lists, for example), so we must preventively align the value. We leave space in SIZE for the hole that might result from the alignment operation. */ diff --git a/gcc/explow.h b/gcc/explow.h index 43fc64e..2b9f7e4 100644 --- a/gcc/explow.h +++ b/gcc/explow.h @@ -1,4 +1,4 @@ -/* Export function prototypes from explow.c. +/* Export function prototypes from explow.cc. Copyright (C) 2015-2022 Free Software Foundation, Inc. This file is part of GCC. diff --git a/gcc/expmed.h b/gcc/expmed.h index 2989615..ee1ddc8 100644 --- a/gcc/expmed.h +++ b/gcc/expmed.h @@ -1,4 +1,4 @@ -/* Target-dependent costs for expmed.c. +/* Target-dependent costs for expmed.cc. Copyright (C) 1987-2022 Free Software Foundation, Inc. This file is part of GCC. diff --git a/gcc/expr.cc b/gcc/expr.cc index 9fb0187..4324b18 100644 --- a/gcc/expr.cc +++ b/gcc/expr.cc @@ -8154,7 +8154,7 @@ safe_from_p (const_rtx x, tree exp, int top_p) case WITH_CLEANUP_EXPR: case CLEANUP_POINT_EXPR: - /* Lowered by gimplify.c. */ + /* Lowered by gimplify.cc. */ gcc_unreachable (); case SAVE_EXPR: @@ -9166,7 +9166,7 @@ expand_expr_real_2 (sepops ops, rtx target, machine_mode tmode, reduction and doing it this way will produce better code if the frame pointer or argument pointer is eliminated. - fold-const.c will ensure that the constant is always in the inner + fold-const.cc will ensure that the constant is always in the inner PLUS_EXPR, so the only case we need to do anything about is if sp, ap, or fp is our second argument, in which case we must swap the innermost first argument and our second argument. */ @@ -11777,7 +11777,7 @@ expand_expr_real_1 (tree exp, rtx target, machine_mode tmode, case GOTO_EXPR: case SWITCH_EXPR: case ASM_EXPR: - /* Expanded in cfgexpand.c. */ + /* Expanded in cfgexpand.cc. */ gcc_unreachable (); case TRY_CATCH_EXPR: @@ -11785,7 +11785,7 @@ expand_expr_real_1 (tree exp, rtx target, machine_mode tmode, case EH_FILTER_EXPR: case TRY_FINALLY_EXPR: case EH_ELSE_EXPR: - /* Lowered by tree-eh.c. */ + /* Lowered by tree-eh.cc. */ gcc_unreachable (); case WITH_CLEANUP_EXPR: @@ -11804,7 +11804,7 @@ expand_expr_real_1 (tree exp, rtx target, machine_mode tmode, case LOOP_EXPR: case EXIT_EXPR: case COMPOUND_LITERAL_EXPR: - /* Lowered by gimplify.c. */ + /* Lowered by gimplify.cc. */ gcc_unreachable (); case FDESC_EXPR: diff --git a/gcc/file-prefix-map.cc b/gcc/file-prefix-map.cc index 847e9f9..24733f8 100644 --- a/gcc/file-prefix-map.cc +++ b/gcc/file-prefix-map.cc @@ -87,7 +87,7 @@ remap_filename (file_prefix_map *maps, const char *filename) } /* NOTE: if adding another -f*-prefix-map option then don't forget to - ignore it in DW_AT_producer (dwarf2out.c). */ + ignore it in DW_AT_producer (dwarf2out.cc). */ /* Linked lists of file_prefix_map structures. */ static file_prefix_map *macro_prefix_maps; /* -fmacro-prefix-map */ diff --git a/gcc/final.cc b/gcc/final.cc index 296a938..a986886 100644 --- a/gcc/final.cc +++ b/gcc/final.cc @@ -156,7 +156,7 @@ static int override_discriminator; /* Whether to force emission of a line note before the next insn. */ static bool force_source_line = false; -extern const int length_unit_log; /* This is defined in insn-attrtab.c. */ +extern const int length_unit_log; /* This is defined in insn-attrtab.cc. */ /* Nonzero while outputting an `asm' with operands. This means that inconsistencies are the user's fault, so don't die. @@ -267,7 +267,7 @@ app_enable (void) } /* Disable APP processing of subsequent output. - Called from varasm.c before most kinds of output. */ + Called from varasm.cc before most kinds of output. */ void app_disable (void) @@ -829,7 +829,7 @@ make_pass_compute_alignments (gcc::context *ctxt) In order to do this, it needs proper length information, which it obtains by calling shorten_branches. This cannot be collapsed with shorten_branches itself into a single pass unless we also want to integrate - reorg.c, since the branch splitting exposes new instructions with delay + reorg.cc, since the branch splitting exposes new instructions with delay slots. */ void @@ -2439,7 +2439,7 @@ final_scan_insn_1 (rtx_insn *insn, FILE *file, int optimize_p ATTRIBUTE_UNUSED, case CODE_LABEL: /* The target port might emit labels in the output function for - some insn, e.g. sh.c output_branchy_insn. */ + some insn, e.g. sh.cc output_branchy_insn. */ if (CODE_LABEL_NUMBER (insn) <= max_labelno) { align_flags alignment = LABEL_TO_ALIGNMENT (insn); @@ -2948,7 +2948,7 @@ final_scan_insn (rtx_insn *insn, FILE *file, int optimize_p, /* Map DECLs to instance discriminators. This is allocated and - defined in ada/gcc-interfaces/trans.c, when compiling with -gnateS. + defined in ada/gcc-interfaces/trans.cc, when compiling with -gnateS. Mappings from this table are saved and restored for LTO, so link-time compilation will have this map set, at least in partitions containing at least one DECL with an associated instance diff --git a/gcc/fixed-value.h b/gcc/fixed-value.h index c2c8749..722b26c 100644 --- a/gcc/fixed-value.h +++ b/gcc/fixed-value.h @@ -64,7 +64,7 @@ const_fixed_from_double_int (double_int payload, extern void fixed_from_string (FIXED_VALUE_TYPE *, const char *, scalar_mode); -/* In tree.c: wrap up a FIXED_VALUE_TYPE in a tree node. */ +/* In tree.cc: wrap up a FIXED_VALUE_TYPE in a tree node. */ extern tree build_fixed (tree, FIXED_VALUE_TYPE); /* Extend or truncate to a new mode. */ diff --git a/gcc/flag-types.h b/gcc/flag-types.h index d92c167..bb0696e 100644 --- a/gcc/flag-types.h +++ b/gcc/flag-types.h @@ -36,26 +36,26 @@ enum debug_info_type }; #define NO_DEBUG (0U) -/* Write DBX debug info (using dbxout.c). */ +/* Write DBX debug info (using dbxout.cc). */ #define DBX_DEBUG (1U << DINFO_TYPE_DBX) -/* Write DWARF2 debug info (using dwarf2out.c). */ +/* Write DWARF2 debug info (using dwarf2out.cc). */ #define DWARF2_DEBUG (1U << DINFO_TYPE_DWARF2) -/* Write IBM/XCOFF debug info (using dbxout.c). */ +/* Write IBM/XCOFF debug info (using dbxout.cc). */ #define XCOFF_DEBUG (1U << DINFO_TYPE_XCOFF) -/* Write VMS debug info (using vmsdbgout.c). */ +/* Write VMS debug info (using vmsdbgout.cc). */ #define VMS_DEBUG (1U << DINFO_TYPE_VMS) -/* Write CTF debug info (using ctfout.c). */ +/* Write CTF debug info (using ctfout.cc). */ #define CTF_DEBUG (1U << DINFO_TYPE_CTF) -/* Write BTF debug info (using btfout.c). */ +/* Write BTF debug info (using btfout.cc). */ #define BTF_DEBUG (1U << DINFO_TYPE_BTF) -/* Write BTF debug info for BPF CO-RE usecase (using btfout.c). */ +/* Write BTF debug info for BPF CO-RE usecase (using btfout.cc). */ #define BTF_WITH_CORE_DEBUG (1U << DINFO_TYPE_BTF_WITH_CORE) /* Note: Adding new definitions to handle -combination- of debug formats, like VMS_AND_DWARF2_DEBUG is not recommended. This definition remains here for historical reasons. */ -/* Write VMS debug info (using vmsdbgout.c) and DWARF v2 debug info (using - dwarf2out.c). */ +/* Write VMS debug info (using vmsdbgout.cc) and DWARF v2 debug info (using + dwarf2out.cc). */ #define VMS_AND_DWARF2_DEBUG ((VMS_DEBUG | DWARF2_DEBUG)) enum debug_info_levels @@ -85,7 +85,7 @@ enum ctf_debug_info_levels The following function determines whether or not debug information should be generated for a given struct. The indirect parameter indicates that the struct is being handled indirectly, via - a pointer. See opts.c for the implementation. */ + a pointer. See opts.cc for the implementation. */ enum debug_info_usage { diff --git a/gcc/fold-const.cc b/gcc/fold-const.cc index cfeee9e..ff6a749 100644 --- a/gcc/fold-const.cc +++ b/gcc/fold-const.cc @@ -1421,7 +1421,7 @@ const_binop (enum tree_code code, tree arg1, tree arg2) if (flag_complex_method == 0) { /* Keep this algorithm in sync with - tree-complex.c:expand_complex_div_straight(). + tree-complex.cc:expand_complex_div_straight(). Expand complex division to scalars, straightforward algorithm. a / b = ((ar*br + ai*bi)/t) + i((ai*br - ar*bi)/t) @@ -1446,7 +1446,7 @@ const_binop (enum tree_code code, tree arg1, tree arg2) else { /* Keep this algorithm in sync with - tree-complex.c:expand_complex_div_wide(). + tree-complex.cc:expand_complex_div_wide(). Expand complex division to scalars, modified algorithm to minimize overflow with wide input ranges. */ @@ -11847,7 +11847,7 @@ fold_binary_loc (location_t loc, enum tree_code code, tree type, Note that only CEIL_DIV_EXPR and FLOOR_DIV_EXPR are rewritten now. At one time others generated faster code, it's not clear if they do - after the last round to changes to the DIV code in expmed.c. */ + after the last round to changes to the DIV code in expmed.cc. */ if ((code == CEIL_DIV_EXPR || code == FLOOR_DIV_EXPR) && multiple_of_p (type, arg0, arg1)) return fold_build2_loc (loc, EXACT_DIV_EXPR, type, @@ -13582,7 +13582,7 @@ fold_checksum_tree (const_tree expr, struct md5_ctx *ctx, else if (warning_suppressed_p (expr) && (DECL_P (expr) || EXPR_P (expr))) { /* Allow the no-warning bit to be set. Perhaps we shouldn't allow - that and change builtins.c etc. instead - see PR89543. */ + that and change builtins.cc etc. instead - see PR89543. */ size_t sz = tree_size (expr); buf = XALLOCAVAR (union tree_node, sz); memcpy ((char *) buf, expr, sz); diff --git a/gcc/fortran/check.cc b/gcc/fortran/check.cc index 053f856..5fe8d45 100644 --- a/gcc/fortran/check.cc +++ b/gcc/fortran/check.cc @@ -36,7 +36,7 @@ along with GCC; see the file COPYING3. If not see /* Reset a BOZ to a zero value. This is used to prevent run-on errors - from resolve.c(resolve_function). */ + from resolve.cc(resolve_function). */ static void reset_boz (gfc_expr *x) @@ -1356,7 +1356,7 @@ gfc_check_all_any (gfc_expr *mask, gfc_expr *dim) /* Limited checking for ALLOCATED intrinsic. Additional checking - is performed in intrinsic.c(sort_actual), because ALLOCATED + is performed in intrinsic.cc(sort_actual), because ALLOCATED has two mutually exclusive non-optional arguments. */ bool diff --git a/gcc/fortran/class.cc b/gcc/fortran/class.cc index 2cb0c65..731e9b0 100644 --- a/gcc/fortran/class.cc +++ b/gcc/fortran/class.cc @@ -20,7 +20,7 @@ along with GCC; see the file COPYING3. If not see . */ -/* class.c -- This file contains the front end functions needed to service +/* class.cc -- This file contains the front end functions needed to service the implementation of Fortran 2003 polymorphism and other object-oriented features. */ @@ -2761,7 +2761,7 @@ find_intrinsic_vtab (gfc_typespec *ts) c->attr.access = ACCESS_PRIVATE; /* Build a minimal expression to make use of - target-memory.c/gfc_element_size for 'size'. Special handling + target-memory.cc/gfc_element_size for 'size'. Special handling for character arrays, that are not constant sized: to support len (str) * kind, only the kind information is stored in the vtab. */ diff --git a/gcc/fortran/config-lang.in b/gcc/fortran/config-lang.in index 5642cdb..7492bfd 100644 --- a/gcc/fortran/config-lang.in +++ b/gcc/fortran/config-lang.in @@ -29,5 +29,5 @@ compilers="f951\$(exeext)" target_libs="target-libgfortran target-libbacktrace" -gtfiles="\$(srcdir)/fortran/f95-lang.c \$(srcdir)/fortran/trans-decl.c \$(srcdir)/fortran/trans-intrinsic.c \$(srcdir)/fortran/trans-io.c \$(srcdir)/fortran/trans-stmt.c \$(srcdir)/fortran/trans-types.c \$(srcdir)/fortran/trans-types.h \$(srcdir)/fortran/trans.h \$(srcdir)/fortran/trans-const.h" +gtfiles="\$(srcdir)/fortran/f95-lang.cc \$(srcdir)/fortran/trans-decl.cc \$(srcdir)/fortran/trans-intrinsic.cc \$(srcdir)/fortran/trans-io.cc \$(srcdir)/fortran/trans-stmt.cc \$(srcdir)/fortran/trans-types.cc \$(srcdir)/fortran/trans-types.h \$(srcdir)/fortran/trans.h \$(srcdir)/fortran/trans-const.h" diff --git a/gcc/fortran/cpp.cc b/gcc/fortran/cpp.cc index a655686..364bd0d 100644 --- a/gcc/fortran/cpp.cc +++ b/gcc/fortran/cpp.cc @@ -178,7 +178,7 @@ cpp_define_builtins (cpp_reader *pfile) /* The defines below are necessary for the TARGET_* macros. FIXME: Note that builtin_define_std() actually is a function - in c-cppbuiltin.c which uses flags undefined for Fortran. + in c-cppbuiltin.cc which uses flags undefined for Fortran. Let's skip this for now. If needed, one needs to look into it once more. */ @@ -189,7 +189,7 @@ cpp_define_builtins (cpp_reader *pfile) /* FIXME: Pandora's Box Using the macros below results in multiple breakages: - mingw will fail to compile this file as dependent macros - assume to be used in c-cppbuiltin.c only. Further, they use + assume to be used in c-cppbuiltin.cc only. Further, they use flags only valid/defined in C (same as noted above). [config/i386/mingw32.h, config/i386/cygming.h] - other platforms (not as popular) break similarly diff --git a/gcc/fortran/data.cc b/gcc/fortran/data.cc index 839e042..f7c9143 100644 --- a/gcc/fortran/data.cc +++ b/gcc/fortran/data.cc @@ -23,14 +23,14 @@ along with GCC; see the file COPYING3. If not see We first assign initial value to each symbol by gfc_assign_data_value during resolving DATA statement. Refer to check_data_variable and - traverse_data_list in resolve.c. + traverse_data_list in resolve.cc. The complexity exists in the handling of array section, implied do and array of struct appeared in DATA statement. We call gfc_conv_structure, gfc_con_array_array_initializer, - etc., to convert the initial value. Refer to trans-expr.c and - trans-array.c. */ + etc., to convert the initial value. Refer to trans-expr.cc and + trans-array.cc. */ #include "config.h" #include "system.h" @@ -80,7 +80,7 @@ get_array_index (gfc_array_ref *ar, mpz_t *offset) } /* Find if there is a constructor which component is equal to COM. - TODO: remove this, use symbol.c(gfc_find_component) instead. */ + TODO: remove this, use symbol.cc(gfc_find_component) instead. */ static gfc_constructor * find_con_by_component (gfc_component *com, gfc_constructor_base base) diff --git a/gcc/fortran/decl.cc b/gcc/fortran/decl.cc index c846923..bd586e7 100644 --- a/gcc/fortran/decl.cc +++ b/gcc/fortran/decl.cc @@ -791,7 +791,7 @@ match_clist_expr (gfc_expr **result, gfc_typespec *ts, gfc_array_spec *as) gcc_assert (ts); /* We have already matched '/' - now look for a constant list, as with - top_val_list from decl.c, but append the result to an array. */ + top_val_list from decl.cc, but append the result to an array. */ if (gfc_match ("/") == MATCH_YES) { gfc_error ("Empty old style initializer list at %C"); @@ -1277,7 +1277,7 @@ get_proc_name (const char *name, gfc_symbol **result, bool module_fcn_entry) /* Module functions have to be left in their own namespace because they have potentially (almost certainly!) already been referenced. In this sense, they are rather like external functions. This is - fixed up in resolve.c(resolve_entries), where the symbol name- + fixed up in resolve.cc(resolve_entries), where the symbol name- space is set to point to the master function, so that the fake result mechanism can work. */ if (module_fcn_entry) @@ -1494,7 +1494,7 @@ gfc_verify_c_interop_param (gfc_symbol *sym) int is_c_interop = 0; bool retval = true; - /* We check implicitly typed variables in symbol.c:gfc_set_default_type(). + /* We check implicitly typed variables in symbol.cc:gfc_set_default_type(). Don't repeat the checks here. */ if (sym->attr.implicit_type) return true; @@ -3808,7 +3808,7 @@ gfc_get_pdt_instance (gfc_actual_arglist *param_list, gfc_symbol **sym, continue; c1 = gfc_find_component (pdt, param->name, false, true, NULL); - /* An error should already have been thrown in resolve.c + /* An error should already have been thrown in resolve.cc (resolve_fl_derived0). */ if (!pdt->attr.use_assoc && !c1) goto error_return; @@ -4699,7 +4699,7 @@ get_kind: /* Match an IMPLICIT NONE statement. Actually, this statement is - already matched in parse.c, or we would not end up here in the + already matched in parse.cc, or we would not end up here in the first place. So the only thing we need to check, is if there is trailing garbage. If not, the match is successful. */ @@ -6568,7 +6568,7 @@ gfc_match_formal_arglist (gfc_symbol *progname, int st_flag, matching for the new declaration can be done. The numbers and names of the arguments are checked here. The interface formal arguments are retained in formal_arglist and the characteristics - are compared in resolve.c(resolve_fl_procedure). See the remark + are compared in resolve.cc(resolve_fl_procedure). See the remark in get_proc_name about the eventual need to copy the formal_arglist and populate the formal namespace of the interface symbol. */ if (progname->attr.module_procedure @@ -6711,7 +6711,7 @@ ok: /* gfc_error_now used in following and return with MATCH_YES because doing otherwise results in a cascade of extraneous errors and in - some cases an ICE in symbol.c(gfc_release_symbol). */ + some cases an ICE in symbol.cc(gfc_release_symbol). */ if (progname->attr.module_procedure && progname->attr.host_assoc) { bool arg_count_mismatch = false; @@ -7573,7 +7573,7 @@ cleanup: } -/* This is mostly a copy of parse.c(add_global_procedure) but modified to +/* This is mostly a copy of parse.cc(add_global_procedure) but modified to pass the name of the entry, rather than the gfc_current_block name, and to return false upon finding an existing global entry. */ @@ -10147,7 +10147,7 @@ gfc_get_type_attr_spec (symbol_attribute *attr, char *name) if (!gfc_add_is_bind_c (attr, NULL, &gfc_current_locus, 0)) return MATCH_ERROR; - /* TODO: attr conflicts need to be checked, probably in symbol.c. */ + /* TODO: attr conflicts need to be checked, probably in symbol.cc. */ } else if (gfc_match (" , abstract") == MATCH_YES) { @@ -11698,7 +11698,7 @@ const ext_attr_t ext_attr_list[] = { __attributes(( attribute-list )) matches then !GCC$ ATTRIBUTES attribute-list :: - Cf. c-parser.c's c_parser_attributes; the data can then directly be + Cf. c-parser.cc's c_parser_attributes; the data can then directly be saved into a TREE. As there is absolutely no risk of confusion, we should never return diff --git a/gcc/fortran/dependency.cc b/gcc/fortran/dependency.cc index 5d28606..ab3bd36 100644 --- a/gcc/fortran/dependency.cc +++ b/gcc/fortran/dependency.cc @@ -18,7 +18,7 @@ You should have received a copy of the GNU General Public License along with GCC; see the file COPYING3. If not see . */ -/* dependency.c -- Expression dependency analysis code. */ +/* dependency.cc -- Expression dependency analysis code. */ /* There's probably quite a bit of duplication in this file. We currently have different dependency checking functions for different types if dependencies. Ideally these would probably be merged. */ diff --git a/gcc/fortran/error.cc b/gcc/fortran/error.cc index e95c083..c9d6edb 100644 --- a/gcc/fortran/error.cc +++ b/gcc/fortran/error.cc @@ -1096,7 +1096,7 @@ gfc_format_decoder (pretty_printer *pp, text_info *text, const char *spec, return true; } default: - /* Fall through info the middle-end decoder, as e.g. stor-layout.c + /* Fall through info the middle-end decoder, as e.g. stor-layout.cc etc. diagnostics can use the FE printer while the FE is still active. */ return default_tree_printer (pp, text, spec, precision, wide, diff --git a/gcc/fortran/expr.cc b/gcc/fortran/expr.cc index 20b88a8..279d9b3 100644 --- a/gcc/fortran/expr.cc +++ b/gcc/fortran/expr.cc @@ -35,8 +35,8 @@ along with GCC; see the file COPYING3. If not see There are two functions available elsewhere that provide slightly different flavours of variables. Namely: - expr.c (gfc_get_variable_expr) - symbol.c (gfc_lval_expr_from_sym) + expr.cc (gfc_get_variable_expr) + symbol.cc (gfc_lval_expr_from_sym) TODO: Merge these functions, if possible. */ /* Get a new expression node. */ @@ -3464,7 +3464,7 @@ check_restricted (gfc_expr *e) break; /* gfc_is_formal_arg broadcasts that a formal argument list is being - processed in resolve.c(resolve_formal_arglist). This is done so + processed in resolve.cc(resolve_formal_arglist). This is done so that host associated dummy array indices are accepted (PR23446). This mechanism also does the same for the specification expressions of array-valued functions. */ @@ -4819,7 +4819,7 @@ gfc_build_default_init_expr (gfc_typespec *ts, locus *where) } /* Apply an initialization expression to a typespec. Can be used for symbols or - components. Similar to add_init_expr_to_sym in decl.c; could probably be + components. Similar to add_init_expr_to_sym in decl.cc; could probably be combined with some effort. */ void diff --git a/gcc/fortran/f95-lang.cc b/gcc/fortran/f95-lang.cc index 1c2fe05..1a895a2 100644 --- a/gcc/fortran/f95-lang.cc +++ b/gcc/fortran/f95-lang.cc @@ -18,7 +18,7 @@ You should have received a copy of the GNU General Public License along with GCC; see the file COPYING3. If not see . */ -/* f95-lang.c-- GCC backend interface stuff */ +/* f95-lang.cc-- GCC backend interface stuff */ /* declare required prototypes: */ diff --git a/gcc/fortran/gfc-internals.texi b/gcc/fortran/gfc-internals.texi index 6850791..1409e28 100644 --- a/gcc/fortran/gfc-internals.texi +++ b/gcc/fortran/gfc-internals.texi @@ -187,7 +187,7 @@ machinery to create the code that enables @command{gfortran} and call the relevant handler function. This generated code calls the @code{gfc_handle_option} code in -@file{options.c} with an enumerator variable indicating which option is +@file{options.cc} with an enumerator variable indicating which option is to be processed, and the relevant integer or string values associated with that option flag. Typically, @code{gfc_handle_option} uses these arguments to set global flags which record the option states. @@ -195,7 +195,7 @@ arguments to set global flags which record the option states. The global flags that record the option states are stored in the @code{gfc_option_t} struct, which is defined in @file{gfortran.h}. Before the options are processed, initial values for these flags are set -in @code{gfc_init_option} in @file{options.c}; these become the default +in @code{gfc_init_option} in @file{options.cc}; these become the default values for the options. @@ -232,7 +232,7 @@ variable, this will be parsed as an assignment statement, and the error discarded. However, when @code{IF} is not a valid variable, this buffered error message will be reported to the user. -The error handling code is implemented in @file{error.c}. Errors are +The error handling code is implemented in @file{error.cc}. Errors are normally entered into the buffer with the @code{gfc_error} function. Warnings go through a similar buffering process, and are entered into the buffer with @code{gfc_warning}. There is also a special-purpose @@ -269,7 +269,7 @@ The syntax for the strings used to produce the error/warning message in the various error and warning functions is similar to the @code{printf} syntax, with @samp{%}-escapes to insert variable values. The details, and the allowable codes, are documented in the @code{error_print} -function in @file{error.c}. +function in @file{error.cc}. @c --------------------------------------------------------------------- @c Frontend Data Structures @@ -281,7 +281,7 @@ function in @file{error.c}. This chapter should describe the details necessary to understand how the various @code{gfc_*} data are used and interact. In general it is -advisable to read the code in @file{dump-parse-tree.c} as its routines +advisable to read the code in @file{dump-parse-tree.cc} as its routines should exhaust all possible valid combinations of content for these structures. @@ -831,7 +831,7 @@ needs to be executed before and after evaluation of the expression. When using a local @code{gfc_se} to convert some expression, it is often necessary to add the generated @code{pre} and @code{post} blocks to the @code{pre} or @code{post} blocks of the outer @code{gfc_se}. -Code like this (lifted from @file{trans-expr.c}) is fairly common: +Code like this (lifted from @file{trans-expr.cc}) is fairly common: @smallexample gfc_se cont_se; diff --git a/gcc/fortran/gfortran.h b/gcc/fortran/gfortran.h index 26a15b1..00a558a 100644 --- a/gcc/fortran/gfortran.h +++ b/gcc/fortran/gfortran.h @@ -170,7 +170,7 @@ enum notification enum match { MATCH_NO = 1, MATCH_YES, MATCH_ERROR }; -/* Used for different Fortran source forms in places like scanner.c. */ +/* Used for different Fortran source forms in places like scanner.cc. */ enum gfc_source_form { FORM_FREE, FORM_FIXED, FORM_UNKNOWN }; @@ -344,7 +344,7 @@ enum procedure_type }; /* Intent types. Note that these values are also used in another enum in - decl.c (match_attr_spec). */ + decl.cc (match_attr_spec). */ enum sym_intent { INTENT_UNKNOWN = 0, INTENT_IN, INTENT_OUT, INTENT_INOUT }; @@ -380,7 +380,7 @@ enum oacc_routine_lop /* Strings for all symbol attributes. We use these for dumping the parse tree, in error messages, and also when reading and writing - modules. In symbol.c. */ + modules. In symbol.cc. */ extern const mstring flavors[]; extern const mstring procedures[]; extern const mstring intents[]; @@ -388,7 +388,7 @@ extern const mstring access_types[]; extern const mstring ifsrc_types[]; extern const mstring save_status[]; -/* Strings for DTIO procedure names. In symbol.c. */ +/* Strings for DTIO procedure names. In symbol.cc. */ extern const mstring dtio_procs[]; enum dtio_codes @@ -799,7 +799,7 @@ CInteropKind_t; /* Array of structs, where the structs represent the C interop kinds. The list will be implemented based on a hash of the kind name since these could be accessed multiple times. - Declared in trans-types.c as a global, since it's in that file + Declared in trans-types.cc as a global, since it's in that file that the list is initialized. */ extern CInteropKind_t c_interop_kinds_table[]; @@ -1824,7 +1824,7 @@ typedef struct gfc_symbol /* Defined only for Cray pointees; points to their pointer. */ struct gfc_symbol *cp_pointer; - int entry_id; /* Used in resolve.c for entries. */ + int entry_id; /* Used in resolve.cc for entries. */ /* CLASS hashed name for declared and dynamic types in the class. */ int hash_value; @@ -1849,7 +1849,7 @@ typedef struct gfc_symbol current statement have the mark member nonzero. Of these symbols, symbols with old_symbol equal to NULL are symbols created within the current statement. Otherwise, old_symbol points to a copy of - the old symbol. gfc_new is used in symbol.c to flag new symbols. + the old symbol. gfc_new is used in symbol.cc to flag new symbols. comp_mark is used to indicate variables which have component accesses in OpenMP/OpenACC directive clauses. */ struct gfc_symbol *old_symbol; @@ -2488,7 +2488,7 @@ typedef struct gfc_expr unsigned int error : 1; /* Mark an expression where a user operator has been substituted by - a function call in interface.c(gfc_extend_expr). */ + a function call in interface.cc(gfc_extend_expr). */ unsigned int user_operator : 1; /* Mark an expression as being a MOLD argument of ALLOCATE. */ @@ -3117,7 +3117,7 @@ gfc_finalizer; /************************ Function prototypes *************************/ -/* decl.c */ +/* decl.cc */ bool gfc_in_match_data (void); match gfc_match_char_spec (gfc_typespec *); extern int directive_unroll; @@ -3158,7 +3158,7 @@ match gfc_get_pdt_instance (gfc_actual_arglist *, gfc_symbol **, && gfc_state_stack->previous->previous->state == COMP_SUBMODULE \ && attr->module_procedure) -/* scanner.c */ +/* scanner.cc */ void gfc_scanner_done_1 (void); void gfc_scanner_init_1 (void); @@ -3207,7 +3207,7 @@ extern locus gfc_current_locus; void gfc_start_source_files (void); void gfc_end_source_files (void); -/* misc.c */ +/* misc.cc */ void gfc_clear_ts (gfc_typespec *); FILE *gfc_open_file (const char *); const char *gfc_basic_typename (bt); @@ -3240,7 +3240,7 @@ vec_push (char **&optr, size_t &osz, const char *elt) HOST_WIDE_INT gfc_mpz_get_hwi (mpz_t); void gfc_mpz_set_hwi (mpz_t, const HOST_WIDE_INT); -/* options.c */ +/* options.cc */ unsigned int gfc_option_lang_mask (void); void gfc_init_options_struct (struct gcc_options *); void gfc_init_options (unsigned int, @@ -3250,14 +3250,14 @@ bool gfc_handle_option (size_t, const char *, HOST_WIDE_INT, int, location_t, bool gfc_post_options (const char **); char *gfc_get_option_string (void); -/* f95-lang.c */ +/* f95-lang.cc */ void gfc_maybe_initialize_eh (void); -/* iresolve.c */ +/* iresolve.cc */ const char * gfc_get_string (const char *, ...) ATTRIBUTE_PRINTF_1; bool gfc_find_sym_in_expr (gfc_symbol *, gfc_expr *); -/* error.c */ +/* error.cc */ void gfc_error_init_1 (void); void gfc_diagnostics_init (void); void gfc_diagnostics_finish (void); @@ -3305,7 +3305,7 @@ void gfc_free_error (gfc_error_buffer *); void gfc_get_errors (int *, int *); void gfc_errors_to_warnings (bool); -/* arith.c */ +/* arith.cc */ void gfc_arith_init_1 (void); void gfc_arith_done_1 (void); arith gfc_check_integer_range (mpz_t p, int kind); @@ -3313,7 +3313,7 @@ bool gfc_check_character_range (gfc_char_t, int); extern bool gfc_seen_div0; -/* trans-types.c */ +/* trans-types.cc */ int gfc_validate_kind (bt, int, bool); int gfc_get_int_kind_from_width_isofortranenv (int size); int gfc_get_real_kind_from_width_isofortranenv (int size); @@ -3341,7 +3341,7 @@ extern int gfc_character_storage_size; #define gfc_integer_4_kind 4 #define gfc_real_4_kind 4 -/* symbol.c */ +/* symbol.cc */ void gfc_clear_new_implicit (void); bool gfc_add_new_implicit_range (int, int); bool gfc_merge_new_implicit (gfc_typespec *); @@ -3480,7 +3480,7 @@ bool gfc_type_compatible (gfc_typespec *, gfc_typespec *); void gfc_copy_formal_args_intr (gfc_symbol *, gfc_intrinsic_sym *, gfc_actual_arglist *, bool copy_type = false); -void gfc_free_finalizer (gfc_finalizer *el); /* Needed in resolve.c, too */ +void gfc_free_finalizer (gfc_finalizer *el); /* Needed in resolve.cc, too */ bool gfc_check_symbol_typed (gfc_symbol*, gfc_namespace*, bool, locus); gfc_namespace* gfc_find_proc_namespace (gfc_namespace*); @@ -3489,7 +3489,7 @@ bool gfc_is_associate_pointer (gfc_symbol*); gfc_symbol * gfc_find_dt_in_generic (gfc_symbol *); gfc_formal_arglist *gfc_sym_get_dummy_args (gfc_symbol *); -/* intrinsic.c -- true if working in an init-expr, false otherwise. */ +/* intrinsic.cc -- true if working in an init-expr, false otherwise. */ extern bool gfc_init_expr_flag; /* Given a symbol that we have decided is intrinsic, mark it as such @@ -3534,7 +3534,7 @@ void gfc_warn_intrinsic_shadow (const gfc_symbol*, bool, bool); bool gfc_check_intrinsic_standard (const gfc_intrinsic_sym*, const char**, bool, locus); -/* match.c -- FIXME */ +/* match.cc -- FIXME */ void gfc_free_iterator (gfc_iterator *, int); void gfc_free_forall_iterator (gfc_forall_iterator *); void gfc_free_alloc_list (gfc_alloc *); @@ -3546,10 +3546,10 @@ void gfc_free_data (gfc_data *); void gfc_reject_data (gfc_namespace *); void gfc_free_case_list (gfc_case *); -/* matchexp.c -- FIXME too? */ +/* matchexp.cc -- FIXME too? */ gfc_expr *gfc_get_parentheses (gfc_expr *); -/* openmp.c */ +/* openmp.cc */ struct gfc_omp_saved_state { void *ptrs[2]; int ints[1]; }; bool gfc_omp_requires_add_clause (gfc_omp_requires_kind, const char *, locus *, const char *); @@ -3576,7 +3576,7 @@ void gfc_resolve_oacc_declare (gfc_namespace *); void gfc_resolve_oacc_blocks (gfc_code *, gfc_namespace *); void gfc_resolve_oacc_routines (gfc_namespace *); -/* expr.c */ +/* expr.cc */ void gfc_free_actual_arglist (gfc_actual_arglist *); gfc_actual_arglist *gfc_copy_actual_arglist (gfc_actual_arglist *); @@ -3665,7 +3665,7 @@ gfc_expr* gfc_build_intrinsic_call (gfc_namespace *, gfc_isym_id, const char*, bool gfc_check_vardef_context (gfc_expr*, bool, bool, bool, const char*); -/* st.c */ +/* st.cc */ extern gfc_code new_st; void gfc_clear_new_st (void); @@ -3675,7 +3675,7 @@ void gfc_free_statement (gfc_code *); void gfc_free_statements (gfc_code *); void gfc_free_association_list (gfc_association_list *); -/* resolve.c */ +/* resolve.cc */ void gfc_expression_rank (gfc_expr *); bool gfc_resolve_ref (gfc_expr *); bool gfc_resolve_expr (gfc_expr *); @@ -3705,7 +3705,7 @@ int gfc_pure_function (gfc_expr *e, const char **name); int gfc_implicit_pure_function (gfc_expr *e); -/* array.c */ +/* array.cc */ gfc_iterator *gfc_copy_iterator (gfc_iterator *); void gfc_free_array_spec (gfc_array_spec *); @@ -3737,7 +3737,7 @@ bool gfc_is_compile_time_shape (gfc_array_spec *); bool gfc_ref_dimen_size (gfc_array_ref *, int dimen, mpz_t *, mpz_t *); -/* interface.c -- FIXME: some of these should be in symbol.c */ +/* interface.cc -- FIXME: some of these should be in symbol.cc */ void gfc_free_interface (gfc_interface *); bool gfc_compare_derived_types (gfc_symbol *, gfc_symbol *); bool gfc_compare_types (gfc_typespec *, gfc_typespec *); @@ -3774,7 +3774,7 @@ bool gfc_compare_actual_formal (gfc_actual_arglist **, gfc_formal_arglist *, int, int, bool, locus *); -/* io.c */ +/* io.cc */ extern gfc_st_label format_asterisk; void gfc_free_open (gfc_open *); @@ -3790,7 +3790,7 @@ bool gfc_resolve_dt (gfc_code *, gfc_dt *, locus *); void gfc_free_wait (gfc_wait *); bool gfc_resolve_wait (gfc_wait *); -/* module.c */ +/* module.cc */ void gfc_module_init_2 (void); void gfc_module_done_2 (void); void gfc_dump_module (const char *, int); @@ -3799,7 +3799,7 @@ void gfc_free_use_stmts (gfc_use_list *); const char *gfc_dt_lower_string (const char *); const char *gfc_dt_upper_string (const char *); -/* primary.c */ +/* primary.cc */ symbol_attribute gfc_variable_attr (gfc_expr *, gfc_typespec *); symbol_attribute gfc_expr_attr (gfc_expr *); symbol_attribute gfc_caf_attr (gfc_expr *, bool i = false, bool *r = NULL); @@ -3811,19 +3811,19 @@ bool gfc_convert_to_structure_constructor (gfc_expr *, gfc_symbol *, gfc_expr **, gfc_actual_arglist **, bool); -/* trans.c */ +/* trans.cc */ void gfc_generate_code (gfc_namespace *); void gfc_generate_module_code (gfc_namespace *); -/* trans-intrinsic.c */ +/* trans-intrinsic.cc */ bool gfc_inline_intrinsic_function_p (gfc_expr *); -/* bbt.c */ +/* bbt.cc */ typedef int (*compare_fn) (void *, void *); void gfc_insert_bbt (void *, void *, compare_fn); void gfc_delete_bbt (void *, void *, compare_fn); -/* dump-parse-tree.c */ +/* dump-parse-tree.cc */ void gfc_dump_parse_tree (gfc_namespace *, FILE *); void gfc_dump_c_prototypes (gfc_namespace *, FILE *); void gfc_dump_external_c_prototypes (FILE *); @@ -3831,17 +3831,17 @@ void gfc_dump_global_symbols (FILE *); void debug (gfc_symbol *); void debug (gfc_expr *); -/* parse.c */ +/* parse.cc */ bool gfc_parse_file (void); void gfc_global_used (gfc_gsymbol *, locus *); gfc_namespace* gfc_build_block_ns (gfc_namespace *); -/* dependency.c */ +/* dependency.cc */ int gfc_dep_compare_functions (gfc_expr *, gfc_expr *, bool); int gfc_dep_compare_expr (gfc_expr *, gfc_expr *); bool gfc_dep_difference (gfc_expr *, gfc_expr *, mpz_t *); -/* check.c */ +/* check.cc */ bool gfc_check_same_strlen (const gfc_expr*, const gfc_expr*, const char*); bool gfc_calculate_transfer_sizes (gfc_expr*, gfc_expr*, gfc_expr*, size_t*, size_t*, size_t*); @@ -3851,7 +3851,7 @@ bool gfc_invalid_boz (const char *, locus *); bool gfc_invalid_null_arg (gfc_expr *); -/* class.c */ +/* class.cc */ void gfc_fix_class_refs (gfc_expr *e); void gfc_add_component_ref (gfc_expr *, const char *); void gfc_add_class_array_ref (gfc_expr *); @@ -3894,7 +3894,7 @@ bool gfc_is_finalizable (gfc_symbol *, gfc_expr **); && CLASS_DATA (sym)->attr.dimension \ && !CLASS_DATA (sym)->attr.class_pointer) -/* frontend-passes.c */ +/* frontend-passes.cc */ void gfc_run_passes (gfc_namespace *); @@ -3908,17 +3908,17 @@ bool gfc_has_dimen_vector_ref (gfc_expr *e); void gfc_check_externals (gfc_namespace *); bool gfc_fix_implicit_pure (gfc_namespace *); -/* simplify.c */ +/* simplify.cc */ void gfc_convert_mpz_to_signed (mpz_t, int); gfc_expr *gfc_simplify_ieee_functions (gfc_expr *); bool gfc_is_size_zero_array (gfc_expr *); -/* trans-array.c */ +/* trans-array.cc */ bool gfc_is_reallocatable_lhs (gfc_expr *); -/* trans-decl.c */ +/* trans-decl.cc */ void finish_oacc_declare (gfc_namespace *, gfc_symbol *, bool); void gfc_adjust_builtins (void); diff --git a/gcc/fortran/gfortranspec.cc b/gcc/fortran/gfortranspec.cc index 4858366..cf76bdc 100644 --- a/gcc/fortran/gfortranspec.cc +++ b/gcc/fortran/gfortranspec.cc @@ -37,7 +37,7 @@ along with GCC; see the file COPYING3. If not see the linking phase is present, or if `-xfoo' is in effect. Note that a lack of source files or -l options disables linking. - This program was originally made out of gcc/cp/g++spec.c, but the + This program was originally made out of gcc/cp/g++spec.cc, but the way it builds the new argument list was rewritten so it is much easier to maintain, improve the way it decides to add or not add extra arguments, etc. And several improvements were made in the @@ -287,7 +287,7 @@ warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n\n" break; case OPT__help: - /* Let gcc.c handle this, as it has a really + /* Let gcc.cc handle this, as it has a really cool facility for handling --help and --verbose --help. */ return; diff --git a/gcc/fortran/interface.cc b/gcc/fortran/interface.cc index 0fd881d..000a530 100644 --- a/gcc/fortran/interface.cc +++ b/gcc/fortran/interface.cc @@ -3781,7 +3781,7 @@ compare_actual_expr (gfc_expr *e1, gfc_expr *e2) || e1->symtree->n.sym != e2->symtree->n.sym) return false; - /* TODO: improve comparison, see expr.c:show_ref(). */ + /* TODO: improve comparison, see expr.cc:show_ref(). */ for (r1 = e1->ref, r2 = e2->ref; r1 && r2; r1 = r1->next, r2 = r2->next) { if (r1->type != r2->type) diff --git a/gcc/fortran/intrinsic.cc b/gcc/fortran/intrinsic.cc index 9746cd5..52e5f4e 100644 --- a/gcc/fortran/intrinsic.cc +++ b/gcc/fortran/intrinsic.cc @@ -1395,7 +1395,7 @@ add_functions (void) make_generic ("abs", GFC_ISYM_ABS, GFC_STD_F77); /* The checking function for ACCESS is called gfc_check_access_func - because the name gfc_check_access is already used in module.c. */ + because the name gfc_check_access is already used in module.cc. */ add_sym_2 ("access", GFC_ISYM_ACCESS, CLASS_IMPURE, ACTUAL_NO, BT_INTEGER, di, GFC_STD_GNU, gfc_check_access_func, NULL, gfc_resolve_access, nm, BT_CHARACTER, dc, REQUIRED, md, BT_CHARACTER, dc, REQUIRED); @@ -2211,7 +2211,7 @@ add_functions (void) BT_INTEGER, di, REQUIRED, team, BT_VOID, di, OPTIONAL); /* The resolution function for INDEX is called gfc_resolve_index_func - because the name gfc_resolve_index is already used in resolve.c. */ + because the name gfc_resolve_index is already used in resolve.cc. */ add_sym_4 ("index", GFC_ISYM_INDEX, CLASS_ELEMENTAL, ACTUAL_YES, BT_INTEGER, di, GFC_STD_F77, gfc_check_index, gfc_simplify_index, gfc_resolve_index_func, diff --git a/gcc/fortran/iresolve.cc b/gcc/fortran/iresolve.cc index 97ac4eb..dea1935 100644 --- a/gcc/fortran/iresolve.cc +++ b/gcc/fortran/iresolve.cc @@ -1598,7 +1598,7 @@ gfc_resolve_matmul (gfc_expr *f, gfc_expr *a, gfc_expr *b) else { /* b->rank == 1 and a->rank == 2 here, all other cases have - been caught in check.c. */ + been caught in check.cc. */ if (a->shape) { f->shape = gfc_get_shape (f->rank); @@ -3258,7 +3258,7 @@ gfc_resolve_alarm_sub (gfc_code *c) /* handler can be either BT_INTEGER or BT_PROCEDURE. In all cases, the status argument is of default integer kind - (enforced in check.c) so that the function suffix is fixed. */ + (enforced in check.cc) so that the function suffix is fixed. */ if (handler->ts.type == BT_INTEGER) { if (handler->ts.kind != gfc_c_int_kind) diff --git a/gcc/fortran/iso-c-binding.def b/gcc/fortran/iso-c-binding.def index 48601f6..27779fa 100644 --- a/gcc/fortran/iso-c-binding.def +++ b/gcc/fortran/iso-c-binding.def @@ -50,7 +50,7 @@ along with GCC; see the file COPYING3. If not see /* The arguments to NAMED_*CST are: -- an internal name -- the symbol name in the module, as seen by Fortran code - -- the value it has, for use in trans-types.c + -- the value it has, for use in trans-types.cc -- the standard that supports this type */ NAMED_INTCST (ISOCBINDING_INT, "c_int", gfc_c_int_kind, GFC_STD_F2003) diff --git a/gcc/fortran/lang-specs.h b/gcc/fortran/lang-specs.h index 4e86195..371ee63 100644 --- a/gcc/fortran/lang-specs.h +++ b/gcc/fortran/lang-specs.h @@ -16,10 +16,10 @@ along with GCC; see the file COPYING3. If not see . */ -/* This is the contribution to the `default_compilers' array in gcc.c +/* This is the contribution to the `default_compilers' array in gcc.cc for the f95 language. */ -/* Identical to gcc.c (cpp_options), but omitting %(cpp_unique_options) +/* Identical to gcc.cc (cpp_options), but omitting %(cpp_unique_options) and -fpch-preprocess on -save-temps. */ #define CPP_ONLY_OPTIONS "%1 %{m*} %{f*} %{g*:%{!g0:%{g*} \ %{!fno-working-directory:-fworking-directory}}} \ diff --git a/gcc/fortran/libgfortran.h b/gcc/fortran/libgfortran.h index ddba41c..064795e 100644 --- a/gcc/fortran/libgfortran.h +++ b/gcc/fortran/libgfortran.h @@ -169,7 +169,7 @@ typedef enum #define GFC_STDOUT_UNIT_NUMBER 6 #define GFC_STDERR_UNIT_NUMBER 0 -/* F2003 onward. For std < F2003, error caught in array.c(gfc_match_array_ref). */ +/* F2003 onward. For std < F2003, error caught in array.cc(gfc_match_array_ref). */ #define GFC_MAX_DIMENSIONS 15 #define GFC_DTYPE_RANK_MASK 0x0F diff --git a/gcc/fortran/match.cc b/gcc/fortran/match.cc index 1afc555..8edfe4a 100644 --- a/gcc/fortran/match.cc +++ b/gcc/fortran/match.cc @@ -607,7 +607,7 @@ gfc_match_label (void) /* See if the current input looks like a name of some sort. Modifies the passed buffer which must be GFC_MAX_SYMBOL_LEN+1 bytes long. - Note that options.c restricts max_identifier_length to not more + Note that options.cc restricts max_identifier_length to not more than GFC_MAX_SYMBOL_LEN. */ match @@ -710,7 +710,7 @@ gfc_match_symbol (gfc_symbol **matched_symbol, int host_assoc) /* Match an intrinsic operator. Returns an INTRINSIC enum. While matching, we always find INTRINSIC_PLUS before INTRINSIC_UPLUS. We work around this - in matchexp.c. */ + in matchexp.cc. */ match gfc_match_intrinsic_op (gfc_intrinsic_op *result) @@ -2080,7 +2080,7 @@ match_derived_type_spec (gfc_typespec *ts) /* Match a Fortran 2003 type-spec (F03:R401). This is similar to - gfc_match_decl_type_spec() from decl.c, with the following exceptions: + gfc_match_decl_type_spec() from decl.cc, with the following exceptions: It only includes the intrinsic types from the Fortran 2003 standard (thus, neither BYTE nor forms like REAL*4 are allowed). Additionally, the implicit_flag is not needed, so it was removed. Derived types are @@ -6203,7 +6203,7 @@ copy_ts_from_selector_to_associate (gfc_expr *associate, gfc_expr *selector) { /* Ensure that the array reference type is set. We cannot use gfc_resolve_expr at this point, so the usable parts of - resolve.c(resolve_array_ref) are employed to do it. */ + resolve.cc(resolve_array_ref) are employed to do it. */ if (ref->u.ar.type == AR_UNKNOWN) { ref->u.ar.type = AR_ELEMENT; @@ -6838,7 +6838,7 @@ syntax: gfc_error ("Syntax error in CASE specification at %C"); cleanup: - gfc_free_case_list (head); /* new_st is cleaned up in parse.c. */ + gfc_free_case_list (head); /* new_st is cleaned up in parse.cc. */ return MATCH_ERROR; } @@ -6911,7 +6911,7 @@ syntax: cleanup: if (c != NULL) - gfc_free_case_list (c); /* new_st is cleaned up in parse.c. */ + gfc_free_case_list (c); /* new_st is cleaned up in parse.cc. */ return MATCH_ERROR; } @@ -6987,7 +6987,7 @@ syntax: cleanup: if (c != NULL) - gfc_free_case_list (c); /* new_st is cleaned up in parse.c. */ + gfc_free_case_list (c); /* new_st is cleaned up in parse.cc. */ return MATCH_ERROR; } @@ -7089,7 +7089,7 @@ syntax: cleanup: if (c != NULL) - gfc_free_case_list (c); /* new_st is cleaned up in parse.c. */ + gfc_free_case_list (c); /* new_st is cleaned up in parse.cc. */ return MATCH_ERROR; } diff --git a/gcc/fortran/match.h b/gcc/fortran/match.h index 65ee3b6..495c93e 100644 --- a/gcc/fortran/match.h +++ b/gcc/fortran/match.h @@ -39,7 +39,7 @@ extern gfc_access gfc_typebound_default_access; /****************** All gfc_match* routines *****************/ -/* match.c. */ +/* match.cc. */ /* Generic match subroutines. */ match gfc_match_special_char (gfc_char_t *); @@ -100,7 +100,7 @@ match gfc_match_call (void); /* We want to use this function to check for a common-block-name that can exist in a bind statement, so removed the "static" - declaration of the function in match.c. */ + declaration of the function in match.cc. */ match gfc_match_common_name (char *name); @@ -126,7 +126,7 @@ match gfc_match_forall (gfc_statement *); gfc_common_head *gfc_get_common (const char *, int); -/* openmp.c. */ +/* openmp.cc. */ /* OpenACC directive matchers. */ match gfc_match_oacc_atomic (void); @@ -229,7 +229,7 @@ match gfc_match_omp_end_critical (void); match gfc_match_omp_end_nowait (void); match gfc_match_omp_end_single (void); -/* decl.c. */ +/* decl.cc. */ match gfc_match_data (void); match gfc_match_null (gfc_expr **); @@ -288,38 +288,38 @@ match gfc_match_target (void); match gfc_match_value (void); match gfc_match_volatile (void); -/* decl.c. */ +/* decl.cc. */ /* Fortran 2003 c interop. - TODO: some of these should be moved to another file rather than decl.c */ + TODO: some of these should be moved to another file rather than decl.cc */ match gfc_match_bind_c_stmt (void); match gfc_match_bind_c (gfc_symbol *, bool); -/* primary.c. */ +/* primary.cc. */ match gfc_match_structure_constructor (gfc_symbol *, gfc_expr **); match gfc_match_variable (gfc_expr **, int); match gfc_match_equiv_variable (gfc_expr **); match gfc_match_actual_arglist (int, gfc_actual_arglist **, bool = false); match gfc_match_literal_constant (gfc_expr **, int); -/* expr.c -- FIXME: this one should be eliminated by moving the - matcher to matchexp.c and a call to a new function in expr.c that +/* expr.cc -- FIXME: this one should be eliminated by moving the + matcher to matchexp.cc and a call to a new function in expr.cc that only makes sure the init expr. is valid. */ bool gfc_reduce_init_expr (gfc_expr *expr); match gfc_match_init_expr (gfc_expr **); -/* array.c. */ +/* array.cc. */ match gfc_match_array_spec (gfc_array_spec **, bool, bool); match gfc_match_array_ref (gfc_array_ref *, gfc_array_spec *, int, int); match gfc_match_array_constructor (gfc_expr **); -/* interface.c. */ +/* interface.cc. */ match gfc_match_abstract_interface (void); match gfc_match_generic_spec (interface_type *, char *, gfc_intrinsic_op *); match gfc_match_interface (void); match gfc_match_end_interface (void); -/* io.c. */ +/* io.cc. */ match gfc_match_format (void); match gfc_match_open (void); match gfc_match_close (void); @@ -333,11 +333,11 @@ match gfc_match_wait (void); match gfc_match_write (void); match gfc_match_print (void); -/* matchexp.c. */ +/* matchexp.cc. */ match gfc_match_defined_op_name (char *, int); match gfc_match_expr (gfc_expr **); -/* module.c. */ +/* module.cc. */ match gfc_match_use (void); match gfc_match_submodule (void); void gfc_use_modules (void); diff --git a/gcc/fortran/matchexp.cc b/gcc/fortran/matchexp.cc index a582f5c..942af78 100644 --- a/gcc/fortran/matchexp.cc +++ b/gcc/fortran/matchexp.cc @@ -122,7 +122,7 @@ next_operator (gfc_intrinsic_op t) /* Call the INTRINSIC_PARENTHESES function. This is both - used explicitly, as below, or by resolve.c to generate + used explicitly, as below, or by resolve.cc to generate temporaries. */ gfc_expr * diff --git a/gcc/fortran/mathbuiltins.def b/gcc/fortran/mathbuiltins.def index 659e46c..615214e 100644 --- a/gcc/fortran/mathbuiltins.def +++ b/gcc/fortran/mathbuiltins.def @@ -19,7 +19,7 @@ along with GCC; see the file COPYING3. If not see /* DEFINE_MATH_BUILTIN (CODE, NAME, ARGTYPE) NAME The name of the builtin SNAME The name of the builtin as a string - ARGTYPE The type of the arguments. See f95-lang.c + ARGTYPE The type of the arguments. See f95-lang.cc Use DEFINE_MATH_BUILTIN_C if the complex versions of the builtin are also available. */ diff --git a/gcc/fortran/module.cc b/gcc/fortran/module.cc index 352e613..281b1b1 100644 --- a/gcc/fortran/module.cc +++ b/gcc/fortran/module.cc @@ -1079,7 +1079,7 @@ free_true_name (true_name *t) /* Module reading and writing. */ -/* The following are versions similar to the ones in scanner.c, but +/* The following are versions similar to the ones in scanner.cc, but for dealing with compressed module files. */ static gzFile diff --git a/gcc/fortran/openmp.cc b/gcc/fortran/openmp.cc index 4a03197..9b73b9f 100644 --- a/gcc/fortran/openmp.cc +++ b/gcc/fortran/openmp.cc @@ -8320,7 +8320,7 @@ gfc_resolve_omp_parallel_blocks (gfc_code *code, gfc_namespace *ns) } -/* Save and clear openmp.c private state. */ +/* Save and clear openmp.cc private state. */ void gfc_omp_save_and_clear_state (struct gfc_omp_saved_state *state) @@ -8334,7 +8334,7 @@ gfc_omp_save_and_clear_state (struct gfc_omp_saved_state *state) } -/* Restore openmp.c private state from the saved state. */ +/* Restore openmp.cc private state from the saved state. */ void gfc_omp_restore_state (struct gfc_omp_saved_state *state) diff --git a/gcc/fortran/parse.cc b/gcc/fortran/parse.cc index c04ad77..db91829 100644 --- a/gcc/fortran/parse.cc +++ b/gcc/fortran/parse.cc @@ -3431,7 +3431,7 @@ parse_union (void) c->ts.type = BT_DERIVED; c->ts.u.derived = gfc_new_block; /* Normally components get their initialization expressions when they - are created in decl.c (build_struct) so we can look through the + are created in decl.cc (build_struct) so we can look through the flat component list for initializers during resolution. Unions and maps create components along with their type definitions so we have to generate initializers here. */ @@ -6405,7 +6405,7 @@ set_syms_host_assoc (gfc_symbol *sym) /* Derived types with PRIVATE components that are declared in modules other than the parent module must not be changed to be PUBLIC. The 'use-assoc' attribute must be reset so that the - test in symbol.c(gfc_find_component) works correctly. This is + test in symbol.cc(gfc_find_component) works correctly. This is not necessary for PRIVATE symbols since they are not read from the module. */ memset(parent1, '\0', sizeof(parent1)); @@ -6939,7 +6939,7 @@ done: /* Dump the global symbol ist. We only do this here because part of it is generated after mangling the identifiers in - trans-decl.c. */ + trans-decl.cc. */ if (flag_dump_fortran_global) gfc_dump_global_symbols (stdout); diff --git a/gcc/fortran/resolve.cc b/gcc/fortran/resolve.cc index 43eeefe..835a478 100644 --- a/gcc/fortran/resolve.cc +++ b/gcc/fortran/resolve.cc @@ -2127,7 +2127,7 @@ resolve_actual_arglist (gfc_actual_arglist *arg, procedure_type ptype, } /* Expressions are assigned a default ts.type of BT_PROCEDURE in - primary.c (match_actual_arg). If above code determines that it + primary.cc (match_actual_arg). If above code determines that it is a variable instead, it needs to be resolved as it was not done at the beginning of this function. */ save_need_full_assumed_size = need_full_assumed_size; @@ -2161,7 +2161,7 @@ resolve_actual_arglist (gfc_actual_arglist *arg, procedure_type ptype, /* Intrinsics are still PROC_UNKNOWN here. However, since same file external procedures are not resolvable in gfortran, it is a good deal easier to leave them to - intrinsic.c. */ + intrinsic.cc. */ if (ptype != PROC_UNKNOWN && ptype != PROC_DUMMY && ptype != PROC_EXTERNAL @@ -2402,7 +2402,7 @@ resolve_elemental_actual (gfc_expr *expr, gfc_code *c) reference being resolved must correspond to the type of gsymbol. Otherwise, the new symbol is equipped with the attributes of the reference. The corresponding code that is called in creating - global entities is parse.c. + global entities is parse.cc. In addition, for all but -std=legacy, the gsymbols are used to check the interfaces of external procedures from the same file. @@ -6044,7 +6044,7 @@ check_host_association (gfc_expr *e) bool retval = e->expr_type == EXPR_FUNCTION; /* If the expression is the result of substitution in - interface.c(gfc_extend_expr) because there is no way in + interface.cc(gfc_extend_expr) because there is no way in which the host association can be wrong. */ if (e->symtree == NULL || e->symtree->n.sym == NULL @@ -6789,7 +6789,7 @@ resolve_typebound_function (gfc_expr* e) get_declared_from_expr (&class_ref, NULL, e, false); /* Trim away the extraneous references that emerge from nested - use of interface.c (extend_expr). */ + use of interface.cc (extend_expr). */ if (class_ref && class_ref->next) { gfc_free_ref_list (class_ref->next); @@ -6920,7 +6920,7 @@ resolve_typebound_subroutine (gfc_code *code) code->expr1->ref = gfc_copy_ref (expr->ref); /* Trim away the extraneous references that emerge from nested - use of interface.c (extend_expr). */ + use of interface.cc (extend_expr). */ get_declared_from_expr (&class_ref, NULL, code->expr1, false); if (class_ref && class_ref->next) { @@ -7152,7 +7152,7 @@ gfc_resolve_expr (gfc_expr *e) && e->symtree->n.sym->attr.dummy) { /* Deal with submodule specification expressions that are not - found to be referenced in module.c(read_cleanup). */ + found to be referenced in module.cc(read_cleanup). */ fixup_unique_dummy (e); } @@ -9103,7 +9103,7 @@ resolve_assoc_var (gfc_symbol* sym, bool resolve_target) /* Finally resolve if this is an array or not. */ if (sym->attr.dimension && target->rank == 0) { - /* primary.c makes the assumption that a reference to an associate + /* primary.cc makes the assumption that a reference to an associate name followed by a left parenthesis is an array reference. */ if (sym->ts.type != BT_CHARACTER) gfc_error ("Associate-name %qs at %L is used as array", @@ -9249,7 +9249,7 @@ resolve_assoc_var (gfc_symbol* sym, bool resolve_target) sym->ts.u.cl = gfc_new_charlen (sym->ns, NULL); sym->ts.deferred = 1; - /* This is reset in trans-stmt.c after the assignment + /* This is reset in trans-stmt.cc after the assignment of the target expression to the associate name. */ sym->attr.allocatable = 1; } @@ -14375,7 +14375,7 @@ resolve_typebound_procedures (gfc_symbol* derived) } -/* Add a derived type to the dt_list. The dt_list is used in trans-types.c +/* Add a derived type to the dt_list. The dt_list is used in trans-types.cc to give all identical derived types the same backend_decl. */ static void add_dt_to_dt_list (gfc_symbol *derived) @@ -16965,7 +16965,7 @@ resolve_equivalence_derived (gfc_symbol *derived, gfc_symbol *sym, gfc_expr *e) derived type shall not have components with default initialization nor shall two objects of an equivalence group be initialized. Either all or none of the objects shall have an protected attribute. - The simple constraints are done in symbol.c(check_conflict) and the rest + The simple constraints are done in symbol.cc(check_conflict) and the rest are implemented here. */ static void diff --git a/gcc/fortran/simplify.cc b/gcc/fortran/simplify.cc index cc7d33a..3881370 100644 --- a/gcc/fortran/simplify.cc +++ b/gcc/fortran/simplify.cc @@ -4289,7 +4289,7 @@ simplify_bound (gfc_expr *array, gfc_expr *dim, gfc_expr *kind, int upper) if (upper && type == AR_FULL && as && as->type == AS_ASSUMED_SIZE) { /* An error message will be emitted in - check_assumed_size_reference (resolve.c). */ + check_assumed_size_reference (resolve.cc). */ return &gfc_bad_expr; } diff --git a/gcc/fortran/symbol.cc b/gcc/fortran/symbol.cc index 1a4b022..7a80dfd0 100644 --- a/gcc/fortran/symbol.cc +++ b/gcc/fortran/symbol.cc @@ -357,7 +357,7 @@ gfc_set_default_type (gfc_symbol *sym, int error_flag, gfc_namespace *ns) } -/* This function is called from parse.c(parse_progunit) to check the +/* This function is called from parse.cc(parse_progunit) to check the type of the function is not implicitly typed in the host namespace and to implicitly type the function result, if necessary. */ @@ -995,7 +995,7 @@ gfc_add_ext_attribute (symbol_attribute *attr, ext_attr_id_t ext_attr, } -/* Called from decl.c (attr_decl1) to check attributes, when declared +/* Called from decl.cc (attr_decl1) to check attributes, when declared separately. */ bool diff --git a/gcc/fortran/target-memory.cc b/gcc/fortran/target-memory.cc index 9b5af8d..361907b 100644 --- a/gcc/fortran/target-memory.cc +++ b/gcc/fortran/target-memory.cc @@ -652,7 +652,7 @@ gfc_target_interpret_expr (unsigned char *buffer, size_t buffer_size, /* --------------------------------------------------------------- */ -/* Two functions used by trans-common.c to write overlapping +/* Two functions used by trans-common.cc to write overlapping equivalence initializers to a buffer. This is added to the union and the original initializers freed. */ diff --git a/gcc/fortran/target-memory.h b/gcc/fortran/target-memory.h index b451b6a..7ffdcb2 100644 --- a/gcc/fortran/target-memory.h +++ b/gcc/fortran/target-memory.h @@ -43,7 +43,7 @@ size_t gfc_interpret_character (unsigned char *, size_t, gfc_expr *); int gfc_interpret_derived (unsigned char *, size_t, gfc_expr *); size_t gfc_target_interpret_expr (unsigned char *, size_t, gfc_expr *, bool); -/* Merge overlapping equivalence initializers for trans-common.c. */ +/* Merge overlapping equivalence initializers for trans-common.cc. */ size_t gfc_merge_initializers (gfc_typespec, gfc_expr *, locus *, unsigned char *, unsigned char *, size_t); diff --git a/gcc/fortran/trans-array.cc b/gcc/fortran/trans-array.cc index a77f331..2f0c8a4 100644 --- a/gcc/fortran/trans-array.cc +++ b/gcc/fortran/trans-array.cc @@ -19,7 +19,7 @@ You should have received a copy of the GNU General Public License along with GCC; see the file COPYING3. If not see . */ -/* trans-array.c-- Various array related code, including scalarization, +/* trans-array.cc-- Various array related code, including scalarization, allocation, initialization and other support routines. */ /* How the scalarizer works. @@ -216,7 +216,7 @@ gfc_get_cfi_dim_sm (tree desc, tree idx) of an array descriptor. To understand these magic numbers, look at the comments - before gfc_build_array_type() in trans-types.c. + before gfc_build_array_type() in trans-types.cc. The code within these defines should be the only code which knows the format of an array descriptor. @@ -583,7 +583,7 @@ gfc_conv_shift_descriptor_lbound (stmtblock_t* block, tree desc, } -/* Obtain offsets for trans-types.c(gfc_get_array_descr_info). */ +/* Obtain offsets for trans-types.cc(gfc_get_array_descr_info). */ void gfc_get_descriptor_offsets_for_info (const_tree desc_type, tree *data_off, @@ -4693,7 +4693,7 @@ done: desc = info->descriptor; - /* This is the run-time equivalent of resolve.c's + /* This is the run-time equivalent of resolve.cc's check_dimension(). The logical is more readable there than it is here, with all the trees. */ lbound = gfc_conv_array_lbound (desc, dim); @@ -5029,7 +5029,7 @@ gfc_could_be_alias (gfc_ss * lss, gfc_ss * rss) /* Resolve array data dependencies. Creates a temporary if required. */ /* TODO: Calc dependencies with gfc_expr rather than gfc_ss, and move to - dependency.c. */ + dependency.cc. */ void gfc_conv_resolve_dependencies (gfc_loopinfo * loop, gfc_ss * dest, @@ -7216,7 +7216,7 @@ gfc_get_dataptr_offset (stmtblock_t *block, tree parm, tree desc, tree offset, by adding up the string lengths of all the elements in the expression. Function with non-constant expressions have their string lengths mapped onto the actual arguments using the - interface mapping machinery in trans-expr.c. */ + interface mapping machinery in trans-expr.cc. */ static void get_array_charlen (gfc_expr *expr, gfc_se *se) { diff --git a/gcc/fortran/trans-const.cc b/gcc/fortran/trans-const.cc index 35167b4..7b18fb4 100644 --- a/gcc/fortran/trans-const.cc +++ b/gcc/fortran/trans-const.cc @@ -18,7 +18,7 @@ You should have received a copy of the GNU General Public License along with GCC; see the file COPYING3. If not see . */ -/* trans-const.c -- convert constant values */ +/* trans-const.cc -- convert constant values */ #include "config.h" #include "system.h" diff --git a/gcc/fortran/trans-decl.cc b/gcc/fortran/trans-decl.cc index 08eaa5a..1112ca9 100644 --- a/gcc/fortran/trans-decl.cc +++ b/gcc/fortran/trans-decl.cc @@ -18,7 +18,7 @@ You should have received a copy of the GNU General Public License along with GCC; see the file COPYING3. If not see . */ -/* trans-decl.c -- Handling of backend function and variable decls, etc */ +/* trans-decl.cc -- Handling of backend function and variable decls, etc */ #include "config.h" #include "system.h" @@ -171,7 +171,7 @@ tree gfor_fndecl_caf_random_init; /* Math functions. Many other math functions are handled in - trans-intrinsic.c. */ + trans-intrinsic.cc. */ gfc_powdecl_list gfor_fndecl_math_powi[4][3]; tree gfor_fndecl_math_ishftc4; @@ -2896,7 +2896,7 @@ trans_function_start (gfc_symbol * sym) allocate_struct_function (fndecl, false); - /* function.c requires a push at the start of the function. */ + /* function.cc requires a push at the start of the function. */ pushlevel (); } @@ -4495,7 +4495,7 @@ gfc_trans_deferred_vars (gfc_symbol * proc_sym, gfc_wrapped_block * block) if (el->sym != el->sym->result) break; } - /* TODO: move to the appropriate place in resolve.c. */ + /* TODO: move to the appropriate place in resolve.cc. */ if (warn_return_type > 0 && el == NULL) gfc_warning (OPT_Wreturn_type, "Return value of function %qs at %L not set", @@ -5982,7 +5982,7 @@ generate_local_decl (gfc_symbol * sym) } else if (sym->attr.flavor == FL_PROCEDURE) { - /* TODO: move to the appropriate place in resolve.c. */ + /* TODO: move to the appropriate place in resolve.cc. */ if (warn_return_type > 0 && sym->attr.function && sym->result @@ -7723,7 +7723,7 @@ gfc_generate_function_code (gfc_namespace * ns) if (result == NULL_TREE || artificial_result_decl) { - /* TODO: move to the appropriate place in resolve.c. */ + /* TODO: move to the appropriate place in resolve.cc. */ if (warn_return_type > 0 && sym == sym->result) gfc_warning (OPT_Wreturn_type, "Return value of function %qs at %L not set", diff --git a/gcc/fortran/trans-expr.cc b/gcc/fortran/trans-expr.cc index 2e15a7e..eb6a78c 100644 --- a/gcc/fortran/trans-expr.cc +++ b/gcc/fortran/trans-expr.cc @@ -19,7 +19,7 @@ You should have received a copy of the GNU General Public License along with GCC; see the file COPYING3. If not see . */ -/* trans-expr.c-- generate GENERIC trees for gfc_expr. */ +/* trans-expr.cc-- generate GENERIC trees for gfc_expr. */ #include "config.h" #include "system.h" @@ -424,13 +424,13 @@ gfc_vptr_size_get (tree vptr) /* IF ts is null (default), search for the last _class ref in the chain of references of the expression and cut the chain there. Although - this routine is similiar to class.c:gfc_add_component_ref (), there + this routine is similiar to class.cc:gfc_add_component_ref (), there is a significant difference: gfc_add_component_ref () concentrates on an array ref that is the last ref in the chain and is oblivious to the kind of refs following. ELSE IF ts is non-null the cut is at the class entity or component that is followed by an array reference, which is not an element. - These calls come from trans-array.c:build_class_array_ref, which + These calls come from trans-array.cc:build_class_array_ref, which handles scalarized class array references.*/ gfc_expr * @@ -1647,7 +1647,7 @@ gfc_trans_class_array_init_assign (gfc_expr *rhs, gfc_expr *lhs, gfc_expr *obj) gfc_add_component_ref (ppc, "_copy"); ppc_code = gfc_get_code (EXEC_CALL); ppc_code->resolved_sym = ppc->symtree->n.sym; - /* Although '_copy' is set to be elemental in class.c, it is + /* Although '_copy' is set to be elemental in class.cc, it is not staying that way. Find out why, sometime.... */ ppc_code->resolved_sym->attr.elemental = 1; ppc_code->ext.actual = actual; @@ -3189,7 +3189,7 @@ gfc_conv_unary_op (enum tree_code code, gfc_se * se, gfc_expr * expr) with the first node being one. */ #define POWI_TABLE_SIZE 256 -/* The table is from builtins.c. */ +/* The table is from builtins.cc. */ static const unsigned char powi_table[POWI_TABLE_SIZE] = { 0, 1, 1, 2, 2, 3, 3, 4, /* 0 - 7 */ @@ -7016,7 +7016,7 @@ gfc_conv_procedure_call (gfc_se * se, gfc_symbol * sym, deallocated for non-variable scalars, array arguments to elemental procedures, and array arguments with descriptor to non-elemental procedures. As bounds information for descriptorless arrays is no - longer available here, they are dealt with in trans-array.c + longer available here, they are dealt with in trans-array.cc (gfc_conv_array_parameter). */ if (e && (e->ts.type == BT_DERIVED || e->ts.type == BT_CLASS) && e->ts.u.derived->attr.alloc_comp @@ -7394,7 +7394,7 @@ gfc_conv_procedure_call (gfc_se * se, gfc_symbol * sym, if (ts.u.cl->length == NULL) { /* Assumed character length results are not allowed by C418 of the 2003 - standard and are trapped in resolve.c; except in the case of SPREAD + standard and are trapped in resolve.cc; except in the case of SPREAD (and other intrinsics?) and dummy functions. In the case of SPREAD, we take the character length of the first argument for the result. For dummies, we have to look through the formal argument list for @@ -10847,7 +10847,7 @@ gfc_trans_arrayfunc_assign (gfc_expr * expr1, gfc_expr * expr2) the shape of the result is unknown and, in any case, the function must correctly take care of the reallocation internally. For intrinsic calls, the array data is freed and the library takes care of allocation. - TODO: Add logic of trans-array.c: gfc_alloc_allocatable_for_assignment + TODO: Add logic of trans-array.cc: gfc_alloc_allocatable_for_assignment to the library. */ if (flag_realloc_lhs && gfc_is_reallocatable_lhs (expr1) diff --git a/gcc/fortran/trans-intrinsic.cc b/gcc/fortran/trans-intrinsic.cc index a7cbbeb..fccf0a9 100644 --- a/gcc/fortran/trans-intrinsic.cc +++ b/gcc/fortran/trans-intrinsic.cc @@ -19,7 +19,7 @@ You should have received a copy of the GNU General Public License along with GCC; see the file COPYING3. If not see . */ -/* trans-intrinsic.c-- generate GENERIC trees for calls to intrinsics. */ +/* trans-intrinsic.cc-- generate GENERIC trees for calls to intrinsics. */ #include "config.h" #include "system.h" @@ -7358,7 +7358,7 @@ gfc_conv_intrinsic_len (gfc_se * se, gfc_expr * expr) case EXPR_ARRAY: /* Obtain the string length from the function used by - trans-array.c(gfc_trans_array_constructor). */ + trans-array.cc(gfc_trans_array_constructor). */ len = NULL_TREE; get_array_ctor_strlen (&se->pre, arg->value.constructor, &len); break; @@ -9495,7 +9495,7 @@ gfc_conv_intrinsic_loc (gfc_se * se, gfc_expr * expr) se->expr = convert (gfc_get_int_type (gfc_index_integer_kind), se->expr); /* Create a temporary variable for loc return value. Without this, - we get an error an ICE in gcc/expr.c(expand_expr_addr_expr_1). */ + we get an error an ICE in gcc/expr.cc(expand_expr_addr_expr_1). */ temp_var = gfc_create_var (gfc_get_int_type (gfc_index_integer_kind), NULL); gfc_add_modify (&se->pre, temp_var, se->expr); se->expr = temp_var; @@ -11948,7 +11948,7 @@ conv_intrinsic_event_query (gfc_code *code) /* This is a peculiar case because of the need to do dependency checking. - It is called via trans-stmt.c(gfc_trans_call), where it is picked out as + It is called via trans-stmt.cc(gfc_trans_call), where it is picked out as a special case and this function called instead of gfc_conv_procedure_call. */ void diff --git a/gcc/fortran/trans-io.cc b/gcc/fortran/trans-io.cc index 033b102..732221f 100644 --- a/gcc/fortran/trans-io.cc +++ b/gcc/fortran/trans-io.cc @@ -233,7 +233,7 @@ gfc_build_st_parameter (enum ioparam_type ptype, tree *types) /* Build code to test an error condition and call generate_error if needed. Note: This builds calls to generate_error in the runtime library function. The function generate_error is dependent on certain parameters in the - st_parameter_common flags to be set. (See libgfortran/runtime/error.c) + st_parameter_common flags to be set. (See libgfortran/runtime/error.cc) Therefore, the code to set these flags must be generated before this function is used. */ diff --git a/gcc/fortran/trans-openmp.cc b/gcc/fortran/trans-openmp.cc index d363258..9eabf68 100644 --- a/gcc/fortran/trans-openmp.cc +++ b/gcc/fortran/trans-openmp.cc @@ -116,7 +116,7 @@ gfc_omp_check_optional_argument (tree decl, bool for_present_check) /* Scalars with VALUE attribute which are passed by value use a hidden argument to denote the present status. They are passed as nonpointer type with one exception: 'type(c_ptr), value' as 'void*'. */ - /* Cf. trans-expr.c's gfc_conv_expr_present. */ + /* Cf. trans-expr.cc's gfc_conv_expr_present. */ if (TREE_CODE (TREE_TYPE (decl)) != POINTER_TYPE || VOID_TYPE_P (TREE_TYPE (TREE_TYPE (decl)))) { @@ -468,7 +468,7 @@ gfc_omp_unshare_expr_r (tree *tp, int *walk_subtrees, void *) /* Unshare in expr anything that the FE which normally doesn't care much about tree sharing (because during gimplification everything is unshared) could cause problems with tree sharing - at omp-low.c time. */ + at omp-low.cc time. */ static tree gfc_omp_unshare_expr (tree expr) @@ -2439,7 +2439,7 @@ gfc_trans_omp_array_section (stmtblock_t *block, gfc_omp_namelist *n, OMP_CLAUSE_DECL (node3) = gfc_conv_descriptor_data_get (decl); /* This purposely does not include GOMP_MAP_ALWAYS_POINTER. The extra - cast prevents gimplify.c from recognising it as being part of the + cast prevents gimplify.cc from recognising it as being part of the struct – and adding an 'alloc: for the 'desc.data' pointer, which would break as the 'desc' (the descriptor) is also mapped (see node4 above). */ @@ -3096,7 +3096,7 @@ gfc_trans_omp_clauses (stmtblock_t *block, gfc_omp_clauses *clauses, the variable is present; hence, we now set it to NULL to avoid accessing undefined variables. We cannot use a temporary variable here as otherwise the replacement - of the variables in omp-low.c will not work. */ + of the variables in omp-low.cc will not work. */ if (present && GFC_ARRAY_TYPE_P (TREE_TYPE (decl))) { tree tmp = fold_build2_loc (input_location, diff --git a/gcc/fortran/trans-stmt.cc b/gcc/fortran/trans-stmt.cc index a9b463d..04f8147 100644 --- a/gcc/fortran/trans-stmt.cc +++ b/gcc/fortran/trans-stmt.cc @@ -2182,7 +2182,7 @@ trans_associate_var (gfc_symbol *sym, gfc_wrapped_block *block) gfc_init_se (&se, NULL); - /* resolve.c converts some associate names to allocatable so that + /* resolve.cc converts some associate names to allocatable so that allocation can take place automatically in gfc_trans_assignment. The frontend prevents them from being either allocated, deallocated or reallocated. */ @@ -7337,7 +7337,7 @@ gfc_trans_deallocate (gfc_code *code) && TREE_CODE (TREE_TYPE (TREE_TYPE (se.expr))) == RECORD_TYPE) { - /* class.c(finalize_component) generates these, when a + /* class.cc(finalize_component) generates these, when a finalizable entity has a non-allocatable derived type array component, which has allocatable components. Obtain the derived type of the array and deallocate the allocatable diff --git a/gcc/fortran/trans-stmt.h b/gcc/fortran/trans-stmt.h index 77b5cc1..477add4 100644 --- a/gcc/fortran/trans-stmt.h +++ b/gcc/fortran/trans-stmt.h @@ -27,13 +27,13 @@ tree gfc_trans_code_cond (gfc_code *, tree); /* All other gfc_trans_* should only need be called by gfc_trans_code */ -/* trans-expr.c */ +/* trans-expr.cc */ tree gfc_trans_assign (gfc_code *); tree gfc_trans_pointer_assign (gfc_code *); tree gfc_trans_init_assign (gfc_code *); tree gfc_trans_class_init_assign (gfc_code *); -/* trans-stmt.c */ +/* trans-stmt.cc */ tree gfc_trans_cycle (gfc_code *); tree gfc_trans_critical (gfc_code *); tree gfc_trans_exit (gfc_code *); @@ -67,14 +67,14 @@ tree gfc_trans_where (gfc_code *); tree gfc_trans_allocate (gfc_code *); tree gfc_trans_deallocate (gfc_code *); -/* trans-openmp.c */ +/* trans-openmp.cc */ tree gfc_trans_omp_directive (gfc_code *); void gfc_trans_omp_declare_simd (gfc_namespace *); void gfc_trans_omp_declare_variant (gfc_namespace *); tree gfc_trans_oacc_directive (gfc_code *); tree gfc_trans_oacc_declare (gfc_namespace *); -/* trans-io.c */ +/* trans-io.cc */ tree gfc_trans_open (gfc_code *); tree gfc_trans_close (gfc_code *); tree gfc_trans_read (gfc_code *); diff --git a/gcc/fortran/trans-types.cc b/gcc/fortran/trans-types.cc index 5de43bb..a56337b 100644 --- a/gcc/fortran/trans-types.cc +++ b/gcc/fortran/trans-types.cc @@ -19,7 +19,7 @@ You should have received a copy of the GNU General Public License along with GCC; see the file COPYING3. If not see . */ -/* trans-types.c -- gfortran backend types */ +/* trans-types.cc -- gfortran backend types */ #include "config.h" #include "system.h" diff --git a/gcc/fortran/trans-types.h b/gcc/fortran/trans-types.h index 4ec6ddc..09a51e6 100644 --- a/gcc/fortran/trans-types.h +++ b/gcc/fortran/trans-types.h @@ -65,7 +65,7 @@ enum gfc_packed { PACKED_STATIC }; -/* trans-types.c */ +/* trans-types.cc */ void gfc_init_kinds (void); void gfc_init_types (void); void gfc_init_c_interop_kinds (void); diff --git a/gcc/fortran/trans.cc b/gcc/fortran/trans.cc index 26f0815..333dfa6 100644 --- a/gcc/fortran/trans.cc +++ b/gcc/fortran/trans.cc @@ -50,7 +50,7 @@ const char gfc_msg_fault[] = N_("Array reference out of bounds"); /* Return a location_t suitable for 'tree' for a gfortran locus. The way the parser works in gfortran, loc->lb->location contains only the line number and LOCATION_COLUMN is 0; hence, the column has to be added when generating - locations for 'tree'. Cf. error.c's gfc_format_decoder. */ + locations for 'tree'. Cf. error.cc's gfc_format_decoder. */ location_t gfc_get_location (locus *loc) @@ -2252,7 +2252,7 @@ trans_code (gfc_code * code, tree cond) /* Translate an executable statement with condition, cond. The condition is used by gfc_trans_do to test for IO result conditions inside implied - DO loops of READ and WRITE statements. See build_dt in trans-io.c. */ + DO loops of READ and WRITE statements. See build_dt in trans-io.cc. */ tree gfc_trans_code_cond (gfc_code * code, tree cond) diff --git a/gcc/fortran/trans.h b/gcc/fortran/trans.h index c0352cf..738c748 100644 --- a/gcc/fortran/trans.h +++ b/gcc/fortran/trans.h @@ -493,7 +493,7 @@ tree gfc_build_compare_string (tree, tree, tree, tree, int, enum tree_code); when a POST chain may be created, and what the returned expression may be used for. Note that character strings have special handling. This should not be a problem as most statements/operations only deal with - numeric/logical types. See the implementations in trans-expr.c + numeric/logical types. See the implementations in trans-expr.cc for details of the individual functions. */ void gfc_conv_expr (gfc_se * se, gfc_expr * expr); @@ -504,7 +504,7 @@ void gfc_conv_expr_reference (gfc_se * se, gfc_expr * expr, void gfc_conv_expr_type (gfc_se * se, gfc_expr *, tree); -/* trans-expr.c */ +/* trans-expr.cc */ tree gfc_get_character_len_in_bytes (tree); tree gfc_conv_scalar_to_descriptor (gfc_se *, tree, symbol_attribute); tree gfc_get_ultimate_alloc_ptr_comps_caf_token (gfc_se *, gfc_expr *); @@ -791,18 +791,18 @@ void gfc_process_block_locals (gfc_namespace*); /* Output initialization/clean-up code that was deferred. */ void gfc_trans_deferred_vars (gfc_symbol*, gfc_wrapped_block *); -/* In f95-lang.c. */ +/* In f95-lang.cc. */ tree pushdecl (tree); tree pushdecl_top_level (tree); void pushlevel (void); tree poplevel (int, int); tree getdecls (void); -/* In trans-types.c. */ +/* In trans-types.cc. */ struct array_descr_info; bool gfc_get_array_descr_info (const_tree, struct array_descr_info *); -/* In trans-openmp.c */ +/* In trans-openmp.cc */ bool gfc_omp_is_allocatable_or_ptr (const_tree); tree gfc_omp_check_optional_argument (tree, bool); tree gfc_omp_array_data (tree, bool); @@ -825,7 +825,7 @@ bool gfc_omp_private_outer_ref (tree); struct gimplify_omp_ctx; void gfc_omp_firstprivatize_type_sizes (struct gimplify_omp_ctx *, tree); -/* In trans-intrinsic.c. */ +/* In trans-intrinsic.cc. */ void gfc_conv_intrinsic_mvbits (gfc_se *, gfc_actual_arglist *, gfc_loopinfo *); @@ -900,7 +900,7 @@ extern GTY(()) tree gfor_fndecl_co_sum; extern GTY(()) tree gfor_fndecl_caf_is_present; /* Math functions. Many other math functions are handled in - trans-intrinsic.c. */ + trans-intrinsic.cc. */ typedef struct GTY(()) gfc_powdecl_list { tree integer; diff --git a/gcc/fp-test.cc b/gcc/fp-test.cc index b7dc155..eef4b43 100644 --- a/gcc/fp-test.cc +++ b/gcc/fp-test.cc @@ -1,4 +1,4 @@ -/* fp-test.c - Check that all floating-point operations are available. +/* fp-test.cc - Check that all floating-point operations are available. Copyright (C) 1995-2022 Free Software Foundation, Inc. Contributed by Ronald F. Guilmette . diff --git a/gcc/function.cc b/gcc/function.cc index 210418e..e1d2565 100644 --- a/gcc/function.cc +++ b/gcc/function.cc @@ -105,7 +105,7 @@ along with GCC; see the file COPYING3. If not see /* Nonzero once virtual register instantiation has been done. assign_stack_local uses frame_pointer_rtx when this is nonzero. - calls.c:emit_library_call_value_1 uses it to set up + calls.cc:emit_library_call_value_1 uses it to set up post-instantiation libcalls. */ int virtuals_instantiated; @@ -5399,7 +5399,7 @@ expand_function_end (void) if (targetm_common.except_unwind_info (&global_options) == UI_SJLJ) { - /* Let except.c know where it should emit the call to unregister + /* Let except.cc know where it should emit the call to unregister the function context for sjlj exceptions. */ if (flag_exceptions) sjlj_emit_function_exit_after (get_last_insn ()); diff --git a/gcc/function.h b/gcc/function.h index b0c2b8b..fb60979 100644 --- a/gcc/function.h +++ b/gcc/function.h @@ -277,7 +277,7 @@ struct GTY(()) function { flags for the actions that they have taken. */ unsigned int pending_TODOs; - /* For function.c. */ + /* For function.cc. */ /* Points to the FUNCTION_DECL of this function. */ tree decl; diff --git a/gcc/fwprop.cc b/gcc/fwprop.cc index 3acb552..d12fc2f 100644 --- a/gcc/fwprop.cc +++ b/gcc/fwprop.cc @@ -153,7 +153,7 @@ should_replace_address (int old_num_changes, rtx mem, rtx_insn *insn) /* If the addresses have equivalent cost, prefer the new address if it has the highest `set_src_cost'. That has the potential of eliminating the most insns without additional costs, and it - is the same that cse.c used to do. */ + is the same that cse.cc used to do. */ if (gain == 0) { gain = set_src_cost (XEXP (mem, 0), VOIDmode, speed); diff --git a/gcc/gcc-main.cc b/gcc/gcc-main.cc index 41baf36..2d0ef4d 100644 --- a/gcc/gcc-main.cc +++ b/gcc/gcc-main.cc @@ -18,7 +18,7 @@ along with GCC; see the file COPYING3. If not see . */ /* This source file contains "main" for the compiler driver. - All of the real work is done within gcc.c; we implement "main" + All of the real work is done within gcc.cc; we implement "main" in here for the "gcc" binary so that gcc.o can be used in libgccjit.so. */ @@ -34,7 +34,7 @@ along with GCC; see the file COPYING3. If not see #include "gcc.h" /* Implement the top-level "main" within the driver in terms of - driver::main (implemented in gcc.c). */ + driver::main (implemented in gcc.cc). */ extern int main (int, char **); diff --git a/gcc/gcc-rich-location.h b/gcc/gcc-rich-location.h index b94f5f0..a43fe38 100644 --- a/gcc/gcc-rich-location.h +++ b/gcc/gcc-rich-location.h @@ -62,7 +62,7 @@ class gcc_rich_location : public rich_location if (!added secondary) inform (secondary_loc, "message for secondary"); - Implemented in diagnostic-show-locus.c. */ + Implemented in diagnostic-show-locus.cc. */ bool add_location_if_nearby (location_t loc, bool restrict_to_current_line_spans = true, diff --git a/gcc/gcc-symtab.h b/gcc/gcc-symtab.h index 0f347ca..feb1033 100644 --- a/gcc/gcc-symtab.h +++ b/gcc/gcc-symtab.h @@ -1,4 +1,4 @@ -/* Declarations for symtab.c. +/* Declarations for symtab.cc. FIXME - This file should be named symtab.h, but that name conflicts with libcpp's symtab.h. diff --git a/gcc/gcc.cc b/gcc/gcc.cc index 29fa0f7..a4d863c 100644 --- a/gcc/gcc.cc +++ b/gcc/gcc.cc @@ -202,7 +202,7 @@ static const char dir_separator_str[] = { DIR_SEPARATOR, 0 }; #define MIN_FATAL_STATUS 1 -/* Flag set by cppspec.c to 1. */ +/* Flag set by cppspec.cc to 1. */ int is_cpp_driver; /* Flag set to nonzero if an @file argument has been supplied to gcc. */ @@ -4584,9 +4584,9 @@ driver_handle_option (struct gcc_options *opts, case OPT_static_libgfortran: case OPT_static_libphobos: case OPT_static_libstdc__: - /* These are always valid, since gcc.c itself understands the - first two, gfortranspec.c understands -static-libgfortran, - d-spec.cc understands -static-libphobos, and g++spec.c + /* These are always valid, since gcc.cc itself understands the + first two, gfortranspec.cc understands -static-libgfortran, + d-spec.cc understands -static-libphobos, and g++spec.cc understands -static-libstdc++ */ validated = true; break; @@ -4945,7 +4945,7 @@ process_command (unsigned int decoded_options_count, #endif } - /* Handle -gtoggle as it would later in toplev.c:process_options to + /* Handle -gtoggle as it would later in toplev.cc:process_options to make the debug-level-gt spec function work as expected. */ if (flag_gtoggle) { @@ -11057,7 +11057,7 @@ quote_spec_arg (char *orig) return quote_spec (orig); } -/* Restore all state within gcc.c to the initial state, so that the driver +/* Restore all state within gcc.cc to the initial state, so that the driver code can be safely re-run in-process. Many const char * variables are referenced by static specs (see @@ -11068,7 +11068,7 @@ quote_spec_arg (char *orig) values (often implicitly 0). Free the various obstacks in this file, along with "opts_obstack" - from opts.c. + from opts.cc. This function also restores any environment variables that were changed. */ @@ -11103,7 +11103,7 @@ driver::finalize () greatest_status = 1; obstack_free (&obstack, NULL); - obstack_free (&opts_obstack, NULL); /* in opts.c */ + obstack_free (&opts_obstack, NULL); /* in opts.cc */ obstack_free (&collect_obstack, NULL); link_command_spec = LINK_COMMAND_SPEC; diff --git a/gcc/gcc.h b/gcc/gcc.h index fc941bf..63231dd 100644 --- a/gcc/gcc.h +++ b/gcc/gcc.h @@ -1,4 +1,4 @@ -/* Header file for modules that link with gcc.c +/* Header file for modules that link with gcc.cc Copyright (C) 1999-2022 Free Software Foundation, Inc. This file is part of GCC. @@ -69,12 +69,12 @@ struct spec_function const char *(*func) (int, const char **); }; -/* These are exported by gcc.c. */ +/* These are exported by gcc.cc. */ extern int do_spec (const char *); extern void record_temp_file (const char *, int, int); extern void set_input (const char *); -/* Spec files linked with gcc.c must provide definitions for these. */ +/* Spec files linked with gcc.cc must provide definitions for these. */ /* Called before processing to change/add/remove arguments. */ extern void lang_specific_driver (struct cl_decoded_option **, diff --git a/gcc/gcov-dump.cc b/gcc/gcov-dump.cc index 1c8c7cd..0804c79 100644 --- a/gcc/gcov-dump.cc +++ b/gcc/gcov-dump.cc @@ -26,7 +26,7 @@ along with Gcov; see the file COPYING3. If not see #include #define IN_GCOV (-1) #include "gcov-io.h" -#include "gcov-io.c" +#include "gcov-io.cc" static void dump_gcov_file (const char *); static void print_prefix (const char *, unsigned, gcov_position_t); diff --git a/gcc/gcov.cc b/gcc/gcov.cc index 73bdfc7..27be5ff 100644 --- a/gcc/gcov.cc +++ b/gcc/gcov.cc @@ -56,15 +56,15 @@ using namespace std; #define IN_GCOV 1 #include "gcov-io.h" -#include "gcov-io.c" +#include "gcov-io.cc" /* The gcno file is generated by -ftest-coverage option. The gcda file is generated by a program compiled with -fprofile-arcs. Their formats are documented in gcov-io.h. */ /* The functions in this file for creating and solution program flow graphs - are very similar to functions in the gcc source file profile.c. In - some places we make use of the knowledge of how profile.c works to + are very similar to functions in the gcc source file profile.cc. In + some places we make use of the knowledge of how profile.cc works to select particular algorithms here. */ /* The code validates that the profile information read in corresponds @@ -2173,7 +2173,7 @@ solve_flow_graph (function_info *fn) } /* Propagate the measured counts, this must be done in the same - order as the code in profile.c */ + order as the code in profile.cc */ for (unsigned i = 0; i < fn->blocks.size (); i++) { blk = &fn->blocks[i]; @@ -2218,7 +2218,7 @@ solve_flow_graph (function_info *fn) } } - /* Sort the successor arcs into ascending dst order. profile.c + /* Sort the successor arcs into ascending dst order. profile.cc normally produces arcs in the right order, but sometimes with one or two out of order. We're not using a particularly smart sort. */ diff --git a/gcc/gcse-common.cc b/gcc/gcse-common.cc index 471cb73..e86d4c4 100644 --- a/gcc/gcse-common.cc +++ b/gcc/gcse-common.cc @@ -17,7 +17,7 @@ along with GCC; see the file COPYING3. If not see . - It is expected that more hunks of gcse.c and postreload-gcse.c should + It is expected that more hunks of gcse.cc and postreload-gcse.cc should migrate into this file. */ #include "config.h" diff --git a/gcc/gcse.cc b/gcc/gcse.cc index 5a3ac71..1e3113d 100644 --- a/gcc/gcse.cc +++ b/gcc/gcse.cc @@ -2684,7 +2684,7 @@ static sbitmap *hoist_vbeout; /* ??? We could compute post dominators and run this algorithm in reverse to perform tail merging, doing so would probably be - more effective than the tail merging code in jump.c. + more effective than the tail merging code in jump.cc. It's unclear if tail merging could be run in parallel with code hoisting. It would be nice. */ @@ -4124,7 +4124,7 @@ make_pass_rtl_hoist (gcc::context *ctxt) return new pass_rtl_hoist (ctxt); } -/* Reset all state within gcse.c so that we can rerun the compiler +/* Reset all state within gcse.cc so that we can rerun the compiler within the same process. For use by toplev::finalize. */ void diff --git a/gcc/genattr-common.cc b/gcc/genattr-common.cc index 2a47ba4..9d78036 100644 --- a/gcc/genattr-common.cc +++ b/gcc/genattr-common.cc @@ -1,6 +1,6 @@ /* Generate attribute information shared between driver and core compilers (insn-attr-common.h) from machine description. Split out - of genattr.c. + of genattr.cc. Copyright (C) 1991-2022 Free Software Foundation, Inc. This file is part of GCC. diff --git a/gcc/genattrtab.cc b/gcc/genattrtab.cc index bd3e2a1..4f8157b 100644 --- a/gcc/genattrtab.cc +++ b/gcc/genattrtab.cc @@ -300,8 +300,8 @@ static rtx min_fn (rtx); /* This gen* file is unique, in that it writes out multiple files. - Before GCC 4.8, insn-attrtab.c was written out containing many large - functions and tables. This made insn-attrtab.c _the_ bottle-neck in + Before GCC 4.8, insn-attrtab.cc was written out containing many large + functions and tables. This made insn-attrtab.cc _the_ bottle-neck in a parallel build, and even made it impossible to build GCC on machines with relatively small RAM space (PR other/29442). Therefore, the atrribute functions/tables are now written out to three separate @@ -4782,7 +4782,7 @@ write_const_num_delay_slots (FILE *outf) } } -/* Synthetic attributes used by insn-automata.c and the scheduler. +/* Synthetic attributes used by insn-automata.cc and the scheduler. These are primarily concerned with (define_insn_reservation) patterns. */ diff --git a/gcc/genautomata.cc b/gcc/genautomata.cc index 5872aca..e43314e 100644 --- a/gcc/genautomata.cc +++ b/gcc/genautomata.cc @@ -73,7 +73,7 @@ along with GCC; see the file COPYING3. If not see `gen_final_presence_set', `gen_absence_set', `gen_final_absence_set', `gen_automaton', `gen_automata_option', `gen_reserv', `gen_insn_reserv' are called from file - `genattrtab.c'. They transform RTL constructions describing + `genattrtab.cc'. They transform RTL constructions describing automata in .md file into internal representation convenient for further processing. diff --git a/gcc/genconditions.cc b/gcc/genconditions.cc index 93739d4..202813d 100644 --- a/gcc/genconditions.cc +++ b/gcc/genconditions.cc @@ -149,7 +149,7 @@ write_one_condition (void **slot, void * ARG_UNUSED (dummy)) } /* Write out the complete conditions table, its size, and a flag - indicating that gensupport.c can now do insn elision. */ + indicating that gensupport.cc can now do insn elision. */ static void write_conditions (void) { diff --git a/gcc/genconstants.cc b/gcc/genconstants.cc index d1089b5..73b0ecd 100644 --- a/gcc/genconstants.cc +++ b/gcc/genconstants.cc @@ -20,7 +20,7 @@ You should have received a copy of the GNU General Public License along with GCC; see the file COPYING3. If not see . */ -/* This program does not use gensupport.c because it does not need to +/* This program does not use gensupport.cc because it does not need to look at insn patterns, only (define_constants), and we want to minimize dependencies. */ diff --git a/gcc/genemit.cc b/gcc/genemit.cc index e0632cb..909ac89 100644 --- a/gcc/genemit.cc +++ b/gcc/genemit.cc @@ -203,7 +203,7 @@ gen_exp (rtx x, enum rtx_code subroutine_type, char *used, md_rtx_info *info) case CONST_FIXED: case CONST_WIDE_INT: /* These shouldn't be written in MD files. Instead, the appropriate - routines in varasm.c should be called. */ + routines in varasm.cc should be called. */ gcc_unreachable (); default: @@ -865,7 +865,7 @@ main (int argc, const char **argv) #include "internal-fn.def" /* Assign sequential codes to all entries in the machine description - in parallel with the tables in insn-output.c. */ + in parallel with the tables in insn-output.cc. */ printf ("/* Generated automatically by the program `genemit'\n\ from the machine description file `md'. */\n\n"); diff --git a/gcc/generic-match-head.cc b/gcc/generic-match-head.cc index 062d1b1..e11a736b 100644 --- a/gcc/generic-match-head.cc +++ b/gcc/generic-match-head.cc @@ -1,4 +1,4 @@ -/* Preamble and helpers for the autogenerated generic-match.c file. +/* Preamble and helpers for the autogenerated generic-match.cc file. Copyright (C) 2014-2022 Free Software Foundation, Inc. This file is part of GCC. diff --git a/gcc/genextract.cc b/gcc/genextract.cc index 06af688..6259cb5 100644 --- a/gcc/genextract.cc +++ b/gcc/genextract.cc @@ -34,7 +34,7 @@ along with GCC; see the file COPYING3. If not see The string for each operand describes that path to the operand and contains `0' through `9' when going into an expression and `a' through `z' then 'A' through to 'Z' when going into a vector. We assume here that - only the first operand of an rtl expression is a vector. genrecog.c makes + only the first operand of an rtl expression is a vector. genrecog.cc makes the same assumption (and uses the same representation) and it is currently true. */ diff --git a/gcc/gengenrtl.cc b/gcc/gengenrtl.cc index 4a62b16..b2b5c3c 100644 --- a/gcc/gengenrtl.cc +++ b/gcc/gengenrtl.cc @@ -130,7 +130,7 @@ always_void_p (int idx) /* Return nonzero if the RTL code given by index IDX is one that we should generate a gen_rtx_raw_FOO macro for, not gen_rtx_FOO (because gen_rtx_FOO - is a wrapper in emit-rtl.c). */ + is a wrapper in emit-rtl.cc). */ static int special_rtx (int idx) diff --git a/gcc/gengtype-parse.cc b/gcc/gengtype-parse.cc index 442ca45..1223ad0 100644 --- a/gcc/gengtype-parse.cc +++ b/gcc/gengtype-parse.cc @@ -604,7 +604,7 @@ gtymarker_opt (void) -/* Declarators. The logic here is largely lifted from c-parser.c. +/* Declarators. The logic here is largely lifted from c-parser.cc. Note that we do not have to process abstract declarators, which can appear only in parameter type lists or casts (but see absdecl, above). Also, type qualifiers are thrown out in gengtype-lex.l so diff --git a/gcc/gengtype-state.cc b/gcc/gengtype-state.cc index fea12df..ea566af 100644 --- a/gcc/gengtype-state.cc +++ b/gcc/gengtype-state.cc @@ -274,7 +274,7 @@ state_writer::state_writer () /* Fatal error messages when reading the state. They are extremely - unlikely, and only appear when this gengtype-state.c file is buggy, + unlikely, and only appear when this gengtype-state.cc file is buggy, or when reading a gengtype state which was not generated by the same version of gengtype or GCC. */ @@ -1342,7 +1342,7 @@ write_state_trailer (void) } /* The write_state routine is the only writing routine called by main - in gengtype.c. To avoid messing the state if gengtype is + in gengtype.cc. To avoid messing the state if gengtype is interrupted or aborted, we write a temporary file and rename it after having written it in totality. */ void @@ -2609,7 +2609,7 @@ equals_type_number (const void *ty1, const void *ty2) } -/* The function reading the state, called by main from gengtype.c. */ +/* The function reading the state, called by main from gengtype.cc. */ void read_state (const char *path) { @@ -2658,4 +2658,4 @@ read_state (const char *path) state_path = NULL; } -/* End of file gengtype-state.c. */ +/* End of file gengtype-state.cc. */ diff --git a/gcc/gengtype.cc b/gcc/gengtype.cc index 9b374c0..e737c93 100644 --- a/gcc/gengtype.cc +++ b/gcc/gengtype.cc @@ -143,12 +143,12 @@ get_ultimate_base_class (type_p s) const input_file **gt_files; size_t num_gt_files; -/* Table of headers to be included in gtype-desc.c that are generated +/* Table of headers to be included in gtype-desc.cc that are generated during the build. These are identified as "./.h". */ const char **build_headers; size_t num_build_headers; -/* A number of places use the name of this "gengtype.c" file for a +/* A number of places use the name of this "gengtype.cc" file for a location for things that we can't rely on the source to define. Make sure we can still use pointer comparison on filenames. */ input_file* this_file; @@ -1726,7 +1726,7 @@ open_base_files (void) base_files[i] = create_file (lang_dir_names[i], xasprintf ("gtype-%s.h", lang_dir_names[i])); - /* gtype-desc.c is a little special, so we create it here. */ + /* gtype-desc.cc is a little special, so we create it here. */ { /* The order of files here matters very much. */ static const char *const ifiles[] = { @@ -1753,7 +1753,7 @@ open_base_files (void) const char *const *ifp; outf_p gtype_desc_c; - gtype_desc_c = create_file ("GCC", "gtype-desc.c"); + gtype_desc_c = create_file ("GCC", "gtype-desc.cc"); for (ifp = ifiles; *ifp; ifp++) oprintf (gtype_desc_c, "#include \"%s\"\n", *ifp); for (int j = 0; j < (int) num_build_headers; j++) @@ -1978,42 +1978,42 @@ struct file_rule_st files_rules[] = { REG_EXTENDED, NULL_REGEX, "gt-c-family-$3.h", "c-family/$3.h", NULL_FRULACT}, - /* Both c-lang.h & c-tree.h gives gt-c-c-decl.h for c-decl.c ! */ + /* Both c-lang.h & c-tree.h gives gt-c-c-decl.h for c-decl.cc ! */ { DIR_PREFIX_REGEX "c/c-lang\\.h$", - REG_EXTENDED, NULL_REGEX, "gt-c-c-decl.h", "c/c-decl.c", NULL_FRULACT}, + REG_EXTENDED, NULL_REGEX, "gt-c-c-decl.h", "c/c-decl.cc", NULL_FRULACT}, { DIR_PREFIX_REGEX "c/c-tree\\.h$", - REG_EXTENDED, NULL_REGEX, "gt-c-c-decl.h", "c/c-decl.c", NULL_FRULACT}, + REG_EXTENDED, NULL_REGEX, "gt-c-c-decl.h", "c/c-decl.cc", NULL_FRULACT}, - /* cp/cp-tree.h gives gt-cp-tree.h for cp/tree.c ! */ + /* cp/cp-tree.h gives gt-cp-tree.h for cp/tree.cc ! */ { DIR_PREFIX_REGEX "cp/cp-tree\\.h$", REG_EXTENDED, NULL_REGEX, - "gt-cp-tree.h", "cp/tree.c", NULL_FRULACT }, + "gt-cp-tree.h", "cp/tree.cc", NULL_FRULACT }, - /* cp/decl.h & cp/decl.c gives gt-cp-decl.h for cp/decl.c ! */ + /* cp/decl.h & cp/decl.cc gives gt-cp-decl.h for cp/decl.cc ! */ { DIR_PREFIX_REGEX "cp/decl\\.[ch]$", REG_EXTENDED, NULL_REGEX, - "gt-cp-decl.h", "cp/decl.c", NULL_FRULACT }, + "gt-cp-decl.h", "cp/decl.cc", NULL_FRULACT }, - /* cp/name-lookup.h gives gt-cp-name-lookup.h for cp/name-lookup.c ! */ + /* cp/name-lookup.h gives gt-cp-name-lookup.h for cp/name-lookup.cc ! */ { DIR_PREFIX_REGEX "cp/name-lookup\\.h$", REG_EXTENDED, NULL_REGEX, - "gt-cp-name-lookup.h", "cp/name-lookup.c", NULL_FRULACT }, + "gt-cp-name-lookup.h", "cp/name-lookup.cc", NULL_FRULACT }, - /* cp/parser.h gives gt-cp-parser.h for cp/parser.c ! */ + /* cp/parser.h gives gt-cp-parser.h for cp/parser.cc ! */ { DIR_PREFIX_REGEX "cp/parser\\.h$", REG_EXTENDED, NULL_REGEX, - "gt-cp-parser.h", "cp/parser.c", NULL_FRULACT }, + "gt-cp-parser.h", "cp/parser.cc", NULL_FRULACT }, - /* objc/objc-act.h gives gt-objc-objc-act.h for objc/objc-act.c ! */ + /* objc/objc-act.h gives gt-objc-objc-act.h for objc/objc-act.cc ! */ { DIR_PREFIX_REGEX "objc/objc-act\\.h$", REG_EXTENDED, NULL_REGEX, - "gt-objc-objc-act.h", "objc/objc-act.c", NULL_FRULACT }, + "gt-objc-objc-act.h", "objc/objc-act.cc", NULL_FRULACT }, - /* objc/objc-map.h gives gt-objc-objc-map.h for objc/objc-map.c ! */ + /* objc/objc-map.h gives gt-objc-objc-map.h for objc/objc-map.cc ! */ { DIR_PREFIX_REGEX "objc/objc-map\\.h$", REG_EXTENDED, NULL_REGEX, - "gt-objc-objc-map.h", "objc/objc-map.c", NULL_FRULACT }, + "gt-objc-objc-map.h", "objc/objc-map.cc", NULL_FRULACT }, /* General cases. For header *.h and source *.c or *.cc files, we * need special actions to handle the language. */ @@ -2030,7 +2030,7 @@ struct file_rule_st files_rules[] = { { DIR_PREFIX_REGEX "([[:alnum:]_-]*)\\.cc$", REG_EXTENDED, NULL_REGEX, "gt-$3.h", "$3.cc", source_dot_c_frul}, - /* Common header files get "gtype-desc.c" as their output_name, + /* Common header files get "gtype-desc.cc" as their output_name, * while language specific header files are handled specially. So * we need the header_dot_h_frul action. */ { DIR_PREFIX_REGEX "([[:alnum:]_-]*)\\.h$", @@ -2044,7 +2044,7 @@ struct file_rule_st files_rules[] = { }; /* Special file rules action for handling *.h header files. It gives - "gtype-desc.c" for common headers and corresponding output + "gtype-desc.cc" for common headers and corresponding output files for language-specific header files. */ static outf_p header_dot_h_frul (input_file* inpf, char**poutname, @@ -2072,11 +2072,11 @@ header_dot_h_frul (input_file* inpf, char**poutname, else { /* The header is common to all front-end languages. So - output_name is "gtype-desc.c" file. The calling function + output_name is "gtype-desc.cc" file. The calling function get_output_file_with_visibility will find its outf_p. */ free (*poutname); - *poutname = xstrdup ("gtype-desc.c"); - DBGPRINTF ("special 'gtype-desc.c' for inpname %s", + *poutname = xstrdup ("gtype-desc.cc"); + DBGPRINTF ("special 'gtype-desc.cc' for inpname %s", get_input_file_name (inpf)); return NULL; } diff --git a/gcc/gengtype.h b/gcc/gengtype.h index ebe87f8..76c1fe6 100644 --- a/gcc/gengtype.h +++ b/gcc/gengtype.h @@ -55,12 +55,12 @@ struct fileloc extern const input_file** gt_files; extern size_t num_gt_files; -/* Table of headers to be included in gtype-desc.c that are generated +/* Table of headers to be included in gtype-desc.cc that are generated during the build. These are identified as "./.h". */ extern const char **build_headers; extern size_t num_build_headers; -/* A number of places use the name of this "gengtype.c" file for a +/* A number of places use the name of this "gengtype.cc" file for a location for things that we can't rely on the source to define. We also need to refer to the "system.h" file specifically. These two pointers are initialized early in main. */ @@ -126,7 +126,7 @@ extern int lexer_toplevel_done; extern struct fileloc lexer_line; /* Various things, organized as linked lists, needed both in - gengtype.c & in gengtype-state.c files. */ + gengtype.cc & in gengtype-state.cc files. */ extern pair_p typedefs; extern type_p structures; extern pair_p variables; @@ -419,7 +419,7 @@ extern const char *read_state_filename; /* (-r) program argument. */ extern const char *write_state_filename; /* (-w) program argument. */ /* Functions reading and writing the entire gengtype state, called from - main, and implemented in file gengtype-state.c. */ + main, and implemented in file gengtype-state.cc. */ void read_state (const char* path); /* Write the state, and update the state_number field in types. */ void write_state (const char* path); diff --git a/gcc/genmatch.cc b/gcc/genmatch.cc index e526219..97f6f00 100644 --- a/gcc/genmatch.cc +++ b/gcc/genmatch.cc @@ -5206,9 +5206,9 @@ main (int argc, char **argv) parser p (r, gimple); if (gimple) - write_header (stdout, "gimple-match-head.c"); + write_header (stdout, "gimple-match-head.cc"); else - write_header (stdout, "generic-match-head.c"); + write_header (stdout, "generic-match-head.cc"); /* Go over all predicates defined with patterns and perform lowering and code generation. */ diff --git a/gcc/genmddeps.cc b/gcc/genmddeps.cc index 6b0ca4a1b..577d3a7 100644 --- a/gcc/genmddeps.cc +++ b/gcc/genmddeps.cc @@ -1,4 +1,4 @@ -/* genmddeps.c - creates a makefile dependency fragment for the md file. +/* genmddeps.cc - creates a makefile dependency fragment for the md file. Copyright (C) 2004-2022 Free Software Foundation, Inc. This program is free software; you can redistribute it and/or modify it diff --git a/gcc/genmodes.cc b/gcc/genmodes.cc index 6001b85..0185716 100644 --- a/gcc/genmodes.cc +++ b/gcc/genmodes.cc @@ -1614,7 +1614,7 @@ emit_mode_inner (void) print_closer (); } -/* Emit mode_unit_size array into insn-modes.c file. */ +/* Emit mode_unit_size array into insn-modes.cc file. */ static void emit_mode_unit_size (void) { @@ -1632,7 +1632,7 @@ emit_mode_unit_size (void) print_closer (); } -/* Emit mode_unit_precision array into insn-modes.c file. */ +/* Emit mode_unit_precision array into insn-modes.cc file. */ static void emit_mode_unit_precision (void) { diff --git a/gcc/genpeep.cc b/gcc/genpeep.cc index 875598d..24b991a 100644 --- a/gcc/genpeep.cc +++ b/gcc/genpeep.cc @@ -107,7 +107,7 @@ gen_peephole (md_rtx_info *info) if (ninsns > 1) printf (" delete_for_peephole (NEXT_INSN (ins1), insn);\n"); - /* See reload1.c for insertion of NOTE which guarantees that this + /* See reload1.cc for insertion of NOTE which guarantees that this cannot be zero. */ printf (" return NEXT_INSN (insn);\n"); diff --git a/gcc/genpreds.cc b/gcc/genpreds.cc index 72a6448..f71da09 100644 --- a/gcc/genpreds.cc +++ b/gcc/genpreds.cc @@ -1,7 +1,7 @@ /* Generate from machine description: - prototype declarations for operand predicates (tm-preds.h) - function definitions of operand predicates, if defined new-style - (insn-preds.c) + (insn-preds.cc) Copyright (C) 2001-2022 Free Software Foundation, Inc. This file is part of GCC. @@ -1548,7 +1548,7 @@ write_tm_preds_h (void) puts ("#endif /* tm-preds.h */"); } -/* Write insn-preds.c. +/* Write insn-preds.cc. N.B. the list of headers to include was copied from genrecog; it may not be ideal. diff --git a/gcc/genrecog.cc b/gcc/genrecog.cc index 3ddf48c..77f8fb97 100644 --- a/gcc/genrecog.cc +++ b/gcc/genrecog.cc @@ -18,7 +18,7 @@ . */ -/* This program is used to produce insn-recog.c, which contains a +/* This program is used to produce insn-recog.cc, which contains a function called `recog' plus its subroutines. These functions contain a decision tree that recognizes whether an rtx, the argument given to recog, is a valid instruction. @@ -28,7 +28,7 @@ for the pattern that matched. This is the same as the order in the machine description of the entry that matched. This number can be used as an index into various insn_* tables, such as insn_template, - insn_outfun, and insn_n_operands (found in insn-output.c). + insn_outfun, and insn_n_operands (found in insn-output.cc). The third argument to recog is an optional pointer to an int. If present, recog will accept a pattern if it matches except for @@ -37,7 +37,7 @@ CLOBBERs that need to be added (it should be initialized to zero by the caller). If it is set nonzero, the caller should allocate a PARALLEL of the appropriate size, copy the initial entries, and - call add_clobbers (found in insn-emit.c) to fill in the CLOBBERs. + call add_clobbers (found in insn-emit.cc) to fill in the CLOBBERs. This program also generates the function `split_insns', which returns 0 if the rtl could not be split, or it returns the split @@ -93,14 +93,14 @@ former case and MINUS and DImode in the latter case. The main aim of this phase is to reduce the compile time of the - insn-recog.c code and to reduce the amount of object code in + insn-recog.cc code and to reduce the amount of object code in insn-recog.o. 4. Split the matching trees into functions, trying to limit the size of each function to a sensible amount. Again, the main aim of this phase is to reduce the compile time - of insn-recog.c. (It doesn't help with the size of insn-recog.o.) + of insn-recog.cc. (It doesn't help with the size of insn-recog.o.) 5. Write out C++ code for each function. */ @@ -627,7 +627,7 @@ validate_pattern (rtx pattern, md_rtx_info *info, rtx set, int set_code) /* Allowing non-lvalues in destinations -- particularly CONST_INT -- while not likely to occur at runtime, results in less efficient - code from insn-recog.c. */ + code from insn-recog.cc. */ if (set && pred && pred->allows_non_lvalue) error_at (info->loc, "destination operand %d allows non-lvalue", XINT (pattern, 0)); @@ -4302,7 +4302,7 @@ write_header (void) puts ("\ is set nonzero, the caller should allocate a PARALLEL of the\n\ appropriate size, copy the initial entries, and call add_clobbers\n\ - (found in insn-emit.c) to fill in the CLOBBERs.\n\ + (found in insn-emit.cc) to fill in the CLOBBERs.\n\ "); puts ("\n\ @@ -5386,7 +5386,7 @@ main (int argc, const char **argv) match_pattern (&split_root, &info, pattern, acceptance); /* Declare the gen_split routine that we'll call if the - pattern matches. The definition comes from insn-emit.c. */ + pattern matches. The definition comes from insn-emit.cc. */ printf ("extern rtx_insn *gen_split_%d (rtx_insn *, rtx *);\n", info.index); break; @@ -5398,7 +5398,7 @@ main (int argc, const char **argv) match_pattern (&peephole2_root, &info, pattern, acceptance); /* Declare the gen_peephole2 routine that we'll call if the - pattern matches. The definition comes from insn-emit.c. */ + pattern matches. The definition comes from insn-emit.cc. */ printf ("extern rtx_insn *gen_peephole2_%d (rtx_insn *, rtx *);\n", info.index); break; diff --git a/gcc/gensupport.cc b/gcc/gensupport.cc index 37d21ca..4268049 100644 --- a/gcc/gensupport.cc +++ b/gcc/gensupport.cc @@ -747,7 +747,7 @@ change_subst_attribute (class queue_elem *elem, represented by SUBST_ELEM and this attribute has value SUBST_TRUE. DEFINE_SUBST isn't applied to patterns without such attribute. In other words, we suppose the default value of the attribute to be 'no' since it is - always generated automatically in read-rtl.c. */ + always generated automatically in read-rtl.cc. */ static bool has_subst_attribute (class queue_elem *elem, class queue_elem *subst_elem) { @@ -2846,7 +2846,7 @@ traverse_c_tests (htab_trav callback, void *info) } /* Helper functions for define_predicate and define_special_predicate - processing. Shared between genrecog.c and genpreds.c. */ + processing. Shared between genrecog.cc and genpreds.cc. */ static htab_t predicate_table; struct pred_data *first_predicate; @@ -2918,7 +2918,7 @@ add_predicate (struct pred_data *pred) } /* This array gives the initial content of the predicate table. It - has entries for all predicates defined in recog.c. */ + has entries for all predicates defined in recog.cc. */ struct std_pred_table { @@ -2992,7 +2992,7 @@ init_predicate_table (void) } } -/* These functions allow linkage with print-rtl.c. Also, some generators +/* These functions allow linkage with print-rtl.cc. Also, some generators like to annotate their output with insn names. */ /* Holds an array of names indexed by insn_code_number. */ diff --git a/gcc/gensupport.h b/gcc/gensupport.h index dc7c7bd..9a0fd73 100644 --- a/gcc/gensupport.h +++ b/gcc/gensupport.h @@ -121,7 +121,7 @@ struct optab_pattern unsigned int m1, m2; /* An index that provides a lexicographical sort of (OP, M2, M1). - Used by genopinit.c. */ + Used by genopinit.cc. */ unsigned int sort_num; }; @@ -133,7 +133,7 @@ extern bool read_md_rtx (md_rtx_info *); extern unsigned int get_num_insn_codes (); /* Set this to 0 to disable automatic elision of insn patterns which - can never be used in this configuration. See genconditions.c. + can never be used in this configuration. See genconditions.cc. Must be set before calling init_md_reader. */ extern int insn_elision; @@ -148,10 +148,10 @@ extern const char *get_c_test (rtx); extern int maybe_eval_c_test (const char *); /* Add an entry to the table of conditions. Used by genconditions and - by read-rtl.c. */ + by read-rtl.cc. */ extern void add_c_test (const char *, int); -/* This structure is used internally by gensupport.c and genconditions.c. */ +/* This structure is used internally by gensupport.cc and genconditions.cc. */ struct c_test { const char *expr; @@ -172,11 +172,11 @@ struct pred_data const char *name; /* predicate name */ bool special; /* special handling of modes? */ - /* data used primarily by genpreds.c */ + /* data used primarily by genpreds.cc */ const char *c_block; /* C test block */ rtx exp; /* RTL test expression */ - /* data used primarily by genrecog.c */ + /* data used primarily by genrecog.cc */ enum rtx_code singleton; /* if pred takes only one code, that code */ int num_codes; /* number of codes accepted */ bool allows_non_lvalue; /* if pred allows non-lvalue expressions */ diff --git a/gcc/ggc-internal.h b/gcc/ggc-internal.h index 23cbdc6..a353de4 100644 --- a/gcc/ggc-internal.h +++ b/gcc/ggc-internal.h @@ -1,5 +1,5 @@ /* Garbage collection for the GNU compiler. Internal definitions - for ggc-*.c and stringpool.c. + for ggc-*.c and stringpool.cc. Copyright (C) 2009-2022 Free Software Foundation, Inc. diff --git a/gcc/gimple-fold.cc b/gcc/gimple-fold.cc index 77c551a..08d3cc2 100644 --- a/gcc/gimple-fold.cc +++ b/gcc/gimple-fold.cc @@ -1,6 +1,6 @@ /* Statement simplification on GIMPLE. Copyright (C) 2010-2022 Free Software Foundation, Inc. - Split out from tree-ssa-ccp.c. + Split out from tree-ssa-ccp.cc. This file is part of GCC. @@ -346,7 +346,7 @@ maybe_fold_reference (tree expr) GIMPLE assignment. We validate the entire tree, not just the root node, thus catching expressions that embed complex operands that are not permitted in GIMPLE. This function - is needed because the folding routines in fold-const.c + is needed because the folding routines in fold-const.cc may return such expressions in some cases, e.g., an array access with an embedded index addition. It may make more sense to have folding routines that are sensitive to the @@ -1686,7 +1686,7 @@ get_range_strlen_tree (tree arg, bitmap visited, strlen_range_kind rkind, flexible array members that can be initialized to arbitrary numbers of elements as an extension (static structs are okay). FIXME: Make this less conservative -- see - component_ref_size in tree.c. */ + component_ref_size in tree.cc. */ tree ref = TREE_OPERAND (TREE_OPERAND (arg, 0), 0); if ((TREE_CODE (ref) == PARM_DECL || VAR_P (ref)) && (decl_binds_to_current_def_p (ref) diff --git a/gcc/gimple-fold.h b/gcc/gimple-fold.h index 45eb465..11e5732 100644 --- a/gcc/gimple-fold.h +++ b/gcc/gimple-fold.h @@ -165,7 +165,7 @@ gimple_build_round_up (gimple_seq *seq, tree type, tree old_size, extern bool gimple_stmt_nonnegative_warnv_p (gimple *, bool *, int = 0); extern bool gimple_stmt_integer_valued_real_p (gimple *, int = 0); -/* In gimple-match.c. */ +/* In gimple-match.cc. */ extern tree gimple_simplify (enum tree_code, tree, tree, gimple_seq *, tree (*)(tree)); extern tree gimple_simplify (enum tree_code, tree, tree, tree, diff --git a/gcc/gimple-low.cc b/gcc/gimple-low.cc index 668be4e..2ec19d5 100644 --- a/gcc/gimple-low.cc +++ b/gcc/gimple-low.cc @@ -41,7 +41,7 @@ along with GCC; see the file COPYING3. If not see 2- GIMPLE_TRY and GIMPLE_CATCH are converted to abnormal control flow and exception regions are built as an on-the-side region - hierarchy (See tree-eh.c:lower_eh_constructs). + hierarchy (See tree-eh.cc:lower_eh_constructs). 3- Multiple identical return statements are grouped into a single return and gotos to the unique return site. */ diff --git a/gcc/gimple-match-head.cc b/gcc/gimple-match-head.cc index f27107d..74d5818 100644 --- a/gcc/gimple-match-head.cc +++ b/gcc/gimple-match-head.cc @@ -1,4 +1,4 @@ -/* Preamble and helpers for the autogenerated gimple-match.c file. +/* Preamble and helpers for the autogenerated gimple-match.cc file. Copyright (C) 2014-2022 Free Software Foundation, Inc. This file is part of GCC. @@ -1381,7 +1381,7 @@ directly_supported_p (code_helper code, tree type, optab_subtype query_type) && direct_internal_fn_supported_p (ifn, type, OPTIMIZE_FOR_SPEED)); } -/* A wrapper around the internal-fn.c versions of get_conditional_internal_fn +/* A wrapper around the internal-fn.cc versions of get_conditional_internal_fn for a code_helper CODE operating on type TYPE. */ internal_fn diff --git a/gcc/gimple-pretty-print.h b/gcc/gimple-pretty-print.h index 295f397..2adac2a8 100644 --- a/gcc/gimple-pretty-print.h +++ b/gcc/gimple-pretty-print.h @@ -23,7 +23,7 @@ along with GCC; see the file COPYING3. If not see #include "tree-pretty-print.h" -/* In gimple-pretty-print.c */ +/* In gimple-pretty-print.cc */ extern void debug_gimple_stmt (gimple *); extern void debug_gimple_seq (gimple_seq); extern void print_gimple_seq (FILE *, gimple_seq, int, dump_flags_t); diff --git a/gcc/gimple-ssa-sprintf.cc b/gcc/gimple-ssa-sprintf.cc index 1f756b7..98ab563 100644 --- a/gcc/gimple-ssa-sprintf.cc +++ b/gcc/gimple-ssa-sprintf.cc @@ -985,7 +985,7 @@ format_percent (const directive &, tree, range_query *) /* Compute intmax_type_node and uintmax_type_node similarly to how - tree.c builds size_type_node. */ + tree.cc builds size_type_node. */ static void build_intmax_type_nodes (tree *pintmax, tree *puintmax) @@ -1168,7 +1168,7 @@ adjust_range_for_overflow (tree dirtype, tree *argmin, tree *argmax) return false; /* The logic below was inspired/lifted from the CONVERT_EXPR_CODE_P - branch in the extract_range_from_unary_expr function in tree-vrp.c. */ + branch in the extract_range_from_unary_expr function in tree-vrp.cc. */ if (TREE_CODE (*argmin) == INTEGER_CST && TREE_CODE (*argmax) == INTEGER_CST diff --git a/gcc/gimple-streamer.h b/gcc/gimple-streamer.h index a52ce37..aa88ea2 100644 --- a/gcc/gimple-streamer.h +++ b/gcc/gimple-streamer.h @@ -24,11 +24,11 @@ along with GCC; see the file COPYING3. If not see #include "tree-streamer.h" -/* In gimple-streamer-in.c */ +/* In gimple-streamer-in.cc */ void input_bb (class lto_input_block *, enum LTO_tags, class data_in *, struct function *, int); -/* In gimple-streamer-out.c */ +/* In gimple-streamer-out.cc */ void output_bb (struct output_block *, basic_block, struct function *); #endif /* GCC_GIMPLE_STREAMER_H */ diff --git a/gcc/gimple.h b/gcc/gimple.h index 7935073..441d29a 100644 --- a/gcc/gimple.h +++ b/gcc/gimple.h @@ -405,7 +405,7 @@ struct GTY((tag("GSS_BIND"))) which is analogous to TREE_BLOCK (i.e., the lexical block holding this statement). This field is the equivalent of BIND_EXPR_BLOCK in tree land (i.e., the lexical scope defined by this bind). See - gimple-low.c. */ + gimple-low.cc. */ tree block; /* [ WORD 9 ] */ @@ -6748,7 +6748,7 @@ is_gimple_resx (const gimple *gs) /* Enum and arrays used for allocation stats. Keep in sync with - gimple.c:gimple_alloc_kind_names. */ + gimple.cc:gimple_alloc_kind_names. */ enum gimple_alloc_kind { gimple_alloc_kind_assign, /* Assignments. */ diff --git a/gcc/gimplify.cc b/gcc/gimplify.cc index d64d9c4..ab9874a 100644 --- a/gcc/gimplify.cc +++ b/gcc/gimplify.cc @@ -251,7 +251,7 @@ static hash_map *oacc_declare_returns; static enum gimplify_status gimplify_expr (tree *, gimple_seq *, gimple_seq *, bool (*) (tree), fallback_t, bool); -/* Shorter alias name for the above function for use in gimplify.c +/* Shorter alias name for the above function for use in gimplify.cc only. */ static inline void @@ -5111,7 +5111,7 @@ gimplify_init_constructor (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p, computed at runtime), then partition the constructor into constant and non-constant parts. Block copy the constant parts in, then generate code for the non-constant parts. */ - /* TODO. There's code in cp/typeck.c to do this. */ + /* TODO. There's code in cp/typeck.cc to do this. */ if (int_size_in_bytes (TREE_TYPE (ctor)) < 0) /* store_constructor will ignore the clearing of variable-sized @@ -11856,7 +11856,7 @@ omp_construct_selector_matches (enum tree_code *constructs, int nconstructs, DECL_ATTRIBUTES (current_function_decl))) { /* Declare simd is a maybe case, it is supposed to be added only to the - omp-simd-clone.c added clones and not to the base function. */ + omp-simd-clone.cc added clones and not to the base function. */ declare_simd_cnt = cnt++; if (scores) codes.safe_push (OMP_SIMD); @@ -14195,7 +14195,7 @@ gimplify_omp_target_update (tree *expr_p, gimple_seq *pre_p) /* Fortran arrays with descriptors must map that descriptor when doing standalone "attach" operations (in OpenACC). In that case GOMP_MAP_TO_PSET appears by itself with no preceding - clause (see trans-openmp.c:gfc_trans_omp_clauses). */ + clause (see trans-openmp.cc:gfc_trans_omp_clauses). */ break; case GOMP_MAP_POINTER: /* TODO PR92929: we may see these here, but they'll always follow @@ -14750,7 +14750,7 @@ gimplify_omp_ordered (tree expr, gimple_seq body) GIMPLE_TEST_F points to a function that takes a tree T and returns nonzero if T is in the GIMPLE form requested by the - caller. The GIMPLE predicates are in gimple.c. + caller. The GIMPLE predicates are in gimple.cc. FALLBACK tells the function what sort of a temporary we want if gimplification cannot produce an expression that complies with @@ -16475,7 +16475,7 @@ gimplify_va_arg_expr (tree *expr_p, gimple_seq *pre_p, have_va_type = targetm.canonical_va_list_type (have_va_type); if (have_va_type == NULL_TREE && POINTER_TYPE_P (TREE_TYPE (valist))) - /* Handle 'Case 1: Not an array type' from c-common.c/build_va_arg. */ + /* Handle 'Case 1: Not an array type' from c-common.cc/build_va_arg. */ have_va_type = targetm.canonical_va_list_type (TREE_TYPE (TREE_TYPE (valist))); gcc_assert (have_va_type != NULL_TREE); diff --git a/gcc/go/config-lang.in b/gcc/go/config-lang.in index 4a026d3..19fdbc3 100644 --- a/gcc/go/config-lang.in +++ b/gcc/go/config-lang.in @@ -31,7 +31,7 @@ compilers="go1\$(exeext)" target_libs="target-libgo target-libffi target-libbacktrace" lang_dirs="gotools" -gtfiles="\$(srcdir)/go/go-lang.c \$(srcdir)/go/go-c.h" +gtfiles="\$(srcdir)/go/go-lang.cc \$(srcdir)/go/go-c.h" # Do not build by default. build_by_default="no" diff --git a/gcc/go/go-backend.cc b/gcc/go/go-backend.cc index c82c425..7eed943 100644 --- a/gcc/go/go-backend.cc +++ b/gcc/go/go-backend.cc @@ -1,4 +1,4 @@ -/* go-backend.c -- Go frontend interface to gcc backend. +/* go-backend.cc -- Go frontend interface to gcc backend. Copyright (C) 2010-2022 Free Software Foundation, Inc. This file is part of GCC. diff --git a/gcc/go/go-lang.cc b/gcc/go/go-lang.cc index 740167b..c8365d2 100644 --- a/gcc/go/go-lang.cc +++ b/gcc/go/go-lang.cc @@ -1,4 +1,4 @@ -/* go-lang.c -- Go frontend gcc interface. +/* go-lang.cc -- Go frontend gcc interface. Copyright (C) 2009-2022 Free Software Foundation, Inc. This file is part of GCC. diff --git a/gcc/go/gospec.cc b/gcc/go/gospec.cc index daa6ce4..df92b62 100644 --- a/gcc/go/gospec.cc +++ b/gcc/go/gospec.cc @@ -1,4 +1,4 @@ -/* gospec.c -- Specific flags and argument handling of the gcc Go front end. +/* gospec.cc -- Specific flags and argument handling of the gcc Go front end. Copyright (C) 2009-2022 Free Software Foundation, Inc. This file is part of GCC. diff --git a/gcc/go/lang-specs.h b/gcc/go/lang-specs.h index 1a76f3b..0c6005a 100644 --- a/gcc/go/lang-specs.h +++ b/gcc/go/lang-specs.h @@ -17,7 +17,7 @@ You should have received a copy of the GNU General Public License along with GCC; see the file COPYING3. If not see . */ -/* This is the contribution to the `default_compilers' array in gcc.c +/* This is the contribution to the `default_compilers' array in gcc.cc for the Go language. */ {".go", "@go", 0, 1, 0}, diff --git a/gcc/graphite-isl-ast-to-gimple.cc b/gcc/graphite-isl-ast-to-gimple.cc index 375a983..ea1129f 100644 --- a/gcc/graphite-isl-ast-to-gimple.cc +++ b/gcc/graphite-isl-ast-to-gimple.cc @@ -1133,7 +1133,7 @@ should_copy_to_new_region (gimple *stmt, sese_info_p region) && TREE_CODE (lhs) == SSA_NAME && scev_analyzable_p (lhs, region->region) /* But to code-generate liveouts - liveout PHI generation is - in generic sese.c code that cannot do code generation. */ + in generic sese.cc code that cannot do code generation. */ && ! bitmap_bit_p (region->liveout, SSA_NAME_VERSION (lhs))) return false; diff --git a/gcc/haifa-sched.cc b/gcc/haifa-sched.cc index 8f152b5..4efaa94 100644 --- a/gcc/haifa-sched.cc +++ b/gcc/haifa-sched.cc @@ -19,9 +19,9 @@ You should have received a copy of the GNU General Public License along with GCC; see the file COPYING3. If not see . */ -/* Instruction scheduling pass. This file, along with sched-deps.c, +/* Instruction scheduling pass. This file, along with sched-deps.cc, contains the generic parts. The actual entry point for - the normal instruction scheduling pass is found in sched-rgn.c. + the normal instruction scheduling pass is found in sched-rgn.cc. We compute insn priorities based on data dependencies. Flow analysis only creates a fraction of the data-dependencies we must @@ -317,7 +317,7 @@ bool adding_bb_to_current_region_p = true; /* Implement a circular buffer to delay instructions until sufficient time has passed. For the new pipeline description interface, MAX_INSN_QUEUE_INDEX is a power of two minus one which is not less - than maximal time of instruction execution computed by genattr.c on + than maximal time of instruction execution computed by genattr.cc on the base maximal time of functional unit reservations and getting a result. This is the longest time an insn may be queued. */ @@ -1510,20 +1510,20 @@ dep_cost (dep_t link) return dep_cost_1 (link, 0); } -/* Use this sel-sched.c friendly function in reorder2 instead of increasing +/* Use this sel-sched.cc friendly function in reorder2 instead of increasing INSN_PRIORITY explicitly. */ void increase_insn_priority (rtx_insn *insn, int amount) { if (!sel_sched_p ()) { - /* We're dealing with haifa-sched.c INSN_PRIORITY. */ + /* We're dealing with haifa-sched.cc INSN_PRIORITY. */ if (INSN_PRIORITY_KNOWN (insn)) INSN_PRIORITY (insn) += amount; } else { - /* In sel-sched.c INSN_PRIORITY is not kept up to date. + /* In sel-sched.cc INSN_PRIORITY is not kept up to date. Use EXPR_PRIORITY instead. */ sel_add_to_insn_priority (insn, amount); } @@ -7579,7 +7579,7 @@ try_ready (rtx_insn *next) has speculative pattern. We can't assert (!(new_ts & HARD_DEP) || new_ts == old_ts) here because - control-speculative NEXT could have been discarded by sched-rgn.c + control-speculative NEXT could have been discarded by sched-rgn.cc (the same case as when discarded by can_schedule_ready_p ()). */ if ((new_ts & SPECULATIVE) @@ -7637,7 +7637,7 @@ try_ready (rtx_insn *next) if (new_ts & (HARD_DEP | DEP_POSTPONED)) { /* We can't assert (QUEUE_INDEX (next) == QUEUE_NOWHERE) here because - control-speculative NEXT could have been discarded by sched-rgn.c + control-speculative NEXT could have been discarded by sched-rgn.cc (the same case as when discarded by can_schedule_ready_p ()). */ /*gcc_assert (QUEUE_INDEX (next) == QUEUE_NOWHERE);*/ @@ -8272,7 +8272,7 @@ sched_create_recovery_edges (basic_block first_bb, basic_block rec, /* TODO: The actual probability can be determined and is computed as 'todo_spec' variable in create_check_block_twin and - in sel-sched.c `check_ds' in create_speculation_check. */ + in sel-sched.cc `check_ds' in create_speculation_check. */ e->probability = profile_probability::very_unlikely (); rec->count = e->count (); e2->probability = e->probability.invert (); @@ -8286,7 +8286,7 @@ sched_create_recovery_edges (basic_block first_bb, basic_block rec, if (BB_PARTITION (second_bb) != BB_PARTITION (rec)) /* Partition type is the same, if it is "unpartitioned". */ { - /* Rewritten from cfgrtl.c. */ + /* Rewritten from cfgrtl.cc. */ if (crtl->has_bb_partition && targetm_common.have_named_sections) { /* We don't need the same note for the check because diff --git a/gcc/ifcvt.cc b/gcc/ifcvt.cc index 9a3e453..f40faf8 100644 --- a/gcc/ifcvt.cc +++ b/gcc/ifcvt.cc @@ -4897,7 +4897,7 @@ find_if_case_1 (basic_block test_bb, edge then_edge, edge else_edge) be optimizable (or blocks that appear to be mergeable), but which really must be left untouched (they are required to make it safely across partition boundaries). See the comments at the top of - bb-reorder.c:partition_hot_cold_basic_blocks for complete details. */ + bb-reorder.cc:partition_hot_cold_basic_blocks for complete details. */ if ((BB_END (then_bb) && JUMP_P (BB_END (then_bb)) @@ -5018,7 +5018,7 @@ find_if_case_2 (basic_block test_bb, edge then_edge, edge else_edge) be optimizable (or blocks that appear to be mergeable), but which really must be left untouched (they are required to make it safely across partition boundaries). See the comments at the top of - bb-reorder.c:partition_hot_cold_basic_blocks for complete details. */ + bb-reorder.cc:partition_hot_cold_basic_blocks for complete details. */ if ((BB_END (then_bb) && JUMP_P (BB_END (then_bb)) diff --git a/gcc/inchash.h b/gcc/inchash.h index afcbdcb..efee54b 100644 --- a/gcc/inchash.h +++ b/gcc/inchash.h @@ -26,7 +26,7 @@ along with GCC; see the file COPYING3. If not see (not in a single memory block) into a single value. The goal is to make it easy to plug in efficient hash algorithms. Currently it just implements the plain old jhash based - incremental hash from gcc's tree.c. */ + incremental hash from gcc's tree.cc. */ hashval_t iterative_hash_host_wide_int (HOST_WIDE_INT, hashval_t); hashval_t iterative_hash_hashval_t (hashval_t, hashval_t); diff --git a/gcc/incpath.cc b/gcc/incpath.cc index 12b1607..bd2a979 100644 --- a/gcc/incpath.cc +++ b/gcc/incpath.cc @@ -125,7 +125,7 @@ add_env_var_paths (const char *env_var, incpath_kind chain) } } -/* Append the standard include chain defined in cppdefault.c. */ +/* Append the standard include chain defined in cppdefault.cc. */ static void add_standard_paths (const char *sysroot, const char *iprefix, const char *imultilib, int cxx_stdinc) diff --git a/gcc/input.cc b/gcc/input.cc index 82e79be..4a92e55 100644 --- a/gcc/input.cc +++ b/gcc/input.cc @@ -1370,7 +1370,7 @@ dump_location_info (FILE *stream) /* I'm typically seeing 4 uninitialized entries at the end of 0xafafafaf. - This appears to be due to macro.c:replace_args + This appears to be due to macro.cc:replace_args adding 2 extra args for padding tokens; presumably there may be a leading and/or trailing padding token injected, each for 2 more location slots. @@ -1862,8 +1862,8 @@ assert_loceq (const char *exp_filename, int exp_linenum, int exp_colnum, of situations: - line_table->default_range_bits: some frontends use a non-zero value and others use zero - - the fallback modes within line-map.c: there are various threshold - values for location_t beyond line-map.c changes + - the fallback modes within line-map.cc: there are various threshold + values for location_t beyond line-map.cc changes behavior (disabling of the range-packing optimization, disabling of column-tracking). We can exercise these by starting the line_table at interesting values at or near these thresholds. @@ -2279,7 +2279,7 @@ public: The line_table_test must be first, since the cpp_reader_ptr uses it. The cpp_reader must be cleaned up *after* the temp_source_file - since the filenames in input.c's input cache are owned by the + since the filenames in input.cc's input cache are owned by the cpp_reader; in particular, when ~temp_source_file evicts the filename the filenames must still be alive. */ line_table_test m_ltt; @@ -2332,7 +2332,7 @@ class ebcdic_execution_charset : public lexer_test_options #ifdef ENABLE_NLS msg = dgettext ("cpplib", msg); #endif - /* Detect and record errors emitted by libcpp/charset.c:init_iconv_desc + /* Detect and record errors emitted by libcpp/charset.cc:init_iconv_desc when the local iconv build doesn't support the conversion. */ if (strcmp (msgid, msg) == 0) { @@ -3264,7 +3264,7 @@ test_lexer_string_locations_concatenation_1 (const line_table_case &case_) ASSERT_STREQ ("0123456789", (const char *)dst_string.text); free (const_cast (dst_string.text)); - /* Simulate c-lex.c's lex_string in order to record concatenation. */ + /* Simulate c-lex.cc's lex_string in order to record concatenation. */ test.m_concats.record_string_concatenation (2, input_locs); location_t initial_loc = input_locs[0]; @@ -3316,7 +3316,7 @@ test_lexer_string_locations_concatenation_2 (const line_table_case &case_) ASSERT_STREQ ("0123456789", (const char *)dst_string.text); free (const_cast (dst_string.text)); - /* Simulate c-lex.c's lex_string in order to record concatenation. */ + /* Simulate c-lex.cc's lex_string in order to record concatenation. */ test.m_concats.record_string_concatenation (5, input_locs); location_t initial_loc = input_locs[0]; @@ -3390,7 +3390,7 @@ test_lexer_string_locations_concatenation_3 (const line_table_case &case_) ASSERT_STREQ ("0123456789", (const char *)dst_string.text); free (const_cast (dst_string.text)); - /* Simulate c-lex.c's lex_string in order to record concatenation. */ + /* Simulate c-lex.cc's lex_string in order to record concatenation. */ test.m_concats.record_string_concatenation (4, input_locs); location_t initial_loc = input_locs[0]; @@ -3479,7 +3479,7 @@ test_lexer_string_locations_stringified_macro_argument __builtin_printf (a, 0.5); ^ - when c-format.c erroneously used the indicated one-character + when c-format.cc erroneously used the indicated one-character location as the format string location, leading to a read past the end of a string buffer in cpp_interpret_string_1. */ diff --git a/gcc/input.h b/gcc/input.h index c7b58c1..f1ae3ae 100644 --- a/gcc/input.h +++ b/gcc/input.h @@ -32,7 +32,7 @@ extern GTY(()) class line_maps *saved_line_table; /* The location for declarations in "" */ #define BUILTINS_LOCATION ((location_t) 1) -/* line-map.c reserves RESERVED_LOCATION_COUNT to the user. Ensure +/* line-map.cc reserves RESERVED_LOCATION_COUNT to the user. Ensure both UNKNOWN_LOCATION and BUILTINS_LOCATION fit into that. */ STATIC_ASSERT (BUILTINS_LOCATION < RESERVED_LOCATION_COUNT); @@ -269,7 +269,7 @@ class GTY(()) string_concat_db static location_t get_key_loc (location_t loc); /* For the fields to be private, we must grant access to the - generated code in gtype-desc.c. */ + generated code in gtype-desc.cc. */ friend void ::gt_ggc_mx_string_concat_db (void *x_p); friend void ::gt_pch_nx_string_concat_db (void *x_p); diff --git a/gcc/internal-fn.cc b/gcc/internal-fn.cc index e7f6302..71ac483 100644 --- a/gcc/internal-fn.cc +++ b/gcc/internal-fn.cc @@ -2632,7 +2632,7 @@ expand_MUL_OVERFLOW (internal_fn, gcall *stmt) expand_arith_overflow (MULT_EXPR, stmt); } -/* This should get folded in tree-vectorizer.c. */ +/* This should get folded in tree-vectorizer.cc. */ static void expand_LOOP_VECTORIZED (internal_fn, gcall *) @@ -2640,7 +2640,7 @@ expand_LOOP_VECTORIZED (internal_fn, gcall *) gcc_unreachable (); } -/* This should get folded in tree-vectorizer.c. */ +/* This should get folded in tree-vectorizer.cc. */ static void expand_LOOP_DIST_ALIAS (internal_fn, gcall *) diff --git a/gcc/ipa-cp.cc b/gcc/ipa-cp.cc index bf46c63..e16015f 100644 --- a/gcc/ipa-cp.cc +++ b/gcc/ipa-cp.cc @@ -96,8 +96,8 @@ along with GCC; see the file COPYING3. If not see Third phase - materialization of clones, call statement updates. ============================================ - This stage is currently performed by call graph code (mainly in cgraphunit.c - and tree-inline.c) according to instructions inserted to the call graph by + This stage is currently performed by call graph code (mainly in cgraphunit.cc + and tree-inline.cc) according to instructions inserted to the call graph by the second stage. */ #include "config.h" @@ -6626,7 +6626,7 @@ make_pass_ipa_cp (gcc::context *ctxt) return new pass_ipa_cp (ctxt); } -/* Reset all state within ipa-cp.c so that we can rerun the compiler +/* Reset all state within ipa-cp.cc so that we can rerun the compiler within the same process. For use by toplev::finalize. */ void diff --git a/gcc/ipa-fnsummary.cc b/gcc/ipa-fnsummary.cc index b95babf..7e7afb0 100644 --- a/gcc/ipa-fnsummary.cc +++ b/gcc/ipa-fnsummary.cc @@ -803,7 +803,7 @@ remap_freqcounting_preds_after_dup (vec *v, } -/* Hook that is called by cgraph.c when a node is duplicated. */ +/* Hook that is called by cgraph.cc when a node is duplicated. */ void ipa_fn_summary_t::duplicate (cgraph_node *src, cgraph_node *dst, @@ -963,7 +963,7 @@ ipa_fn_summary_t::duplicate (cgraph_node *src, } -/* Hook that is called by cgraph.c when a node is duplicated. */ +/* Hook that is called by cgraph.cc when a node is duplicated. */ void ipa_call_summary_t::duplicate (struct cgraph_edge *src, @@ -4962,7 +4962,7 @@ make_pass_ipa_fn_summary (gcc::context *ctxt) return new pass_ipa_fn_summary (ctxt); } -/* Reset all state within ipa-fnsummary.c so that we can rerun the compiler +/* Reset all state within ipa-fnsummary.cc so that we can rerun the compiler within the same process. For use by toplev::finalize. */ void diff --git a/gcc/ipa-fnsummary.h b/gcc/ipa-fnsummary.h index fc386ee..34c2398 100644 --- a/gcc/ipa-fnsummary.h +++ b/gcc/ipa-fnsummary.h @@ -42,11 +42,11 @@ enum ipa_hints_vals { win. */ INLINE_HINT_in_scc = 16, /* If function is declared inline by user, it may be good idea to inline - it. Set by simple_edge_hints in ipa-inline-analysis.c. */ + it. Set by simple_edge_hints in ipa-inline-analysis.cc. */ INLINE_HINT_declared_inline = 32, /* Programs are usually still organized for non-LTO compilation and thus if functions are in different modules, inlining may not be so important. - Set by simple_edge_hints in ipa-inline-analysis.c. */ + Set by simple_edge_hints in ipa-inline-analysis.cc. */ INLINE_HINT_cross_module = 64, /* We know that the callee is hot by profile. */ INLINE_HINT_known_hot = 128, @@ -403,7 +403,7 @@ public: extern fast_call_summary *ipa_call_summaries; -/* In ipa-fnsummary.c */ +/* In ipa-fnsummary.cc */ void ipa_debug_fn_summary (struct cgraph_node *); void ipa_dump_fn_summaries (FILE *f); void ipa_dump_fn_summary (FILE *f, struct cgraph_node *node); diff --git a/gcc/ipa-free-lang-data.cc b/gcc/ipa-free-lang-data.cc index 431ced4..f596eef 100644 --- a/gcc/ipa-free-lang-data.cc +++ b/gcc/ipa-free-lang-data.cc @@ -354,7 +354,7 @@ fld_simplified_type (tree t, class free_lang_data_d *fld) /* Reset the expression *EXPR_P, a size or position. ??? We could reset all non-constant sizes or positions. But it's cheap - enough to not do so and refrain from adding workarounds to dwarf2out.c. + enough to not do so and refrain from adding workarounds to dwarf2out.cc. We need to reset self-referential sizes or positions because they cannot be gimplified and thus can contain a CALL_EXPR after the gimplification @@ -613,7 +613,7 @@ free_lang_data_in_decl (tree decl, class free_lang_data_d *fld) DECL_SAVED_TREE (decl) = NULL_TREE; /* Clear the abstract origin if it refers to a method. - Otherwise dwarf2out.c will ICE as we splice functions out of + Otherwise dwarf2out.cc will ICE as we splice functions out of TYPE_FIELDS and thus the origin will not be output correctly. */ if (DECL_ABSTRACT_ORIGIN (decl) diff --git a/gcc/ipa-inline.cc b/gcc/ipa-inline.cc index 9b70daf..3852277 100644 --- a/gcc/ipa-inline.cc +++ b/gcc/ipa-inline.cc @@ -797,7 +797,7 @@ compute_inlined_call_time (struct cgraph_edge *edge, else time = time >> 11; - /* This calculation should match one in ipa-inline-analysis.c + /* This calculation should match one in ipa-inline-analysis.cc (estimate_edge_size_and_time). */ time -= (sreal)ipa_call_summaries->get (edge)->call_stmt_time * freq; time += caller_time; @@ -2862,7 +2862,7 @@ inline_always_inline_functions (struct cgraph_node *node) { /* Set inlined to true if the callee is marked "always_inline" but is not inlinable. This will allow flagging an error later in - expand_call_inline in tree-inline.c. */ + expand_call_inline in tree-inline.cc. */ if (lookup_attribute ("always_inline", DECL_ATTRIBUTES (callee->decl)) != NULL) inlined = true; diff --git a/gcc/ipa-inline.h b/gcc/ipa-inline.h index ee37f2b..dbaf8ee 100644 --- a/gcc/ipa-inline.h +++ b/gcc/ipa-inline.h @@ -41,7 +41,7 @@ public: extern fast_call_summary *edge_growth_cache; -/* In ipa-inline-analysis.c */ +/* In ipa-inline-analysis.cc */ int estimate_size_after_inlining (struct cgraph_node *, struct cgraph_edge *); int estimate_growth (struct cgraph_node *); bool growth_positive_p (struct cgraph_node *, struct cgraph_edge *, int); @@ -52,12 +52,12 @@ void reset_node_cache (struct cgraph_node *node); void initialize_growth_caches (); void free_growth_caches (void); -/* In ipa-inline.c */ +/* In ipa-inline.cc */ unsigned int early_inliner (function *fun); bool inline_account_function_p (struct cgraph_node *node); -/* In ipa-inline-transform.c */ +/* In ipa-inline-transform.cc */ bool inline_call (struct cgraph_edge *, bool, vec *, int *, bool, bool *callee_removed = NULL); unsigned int inline_transform (struct cgraph_node *); diff --git a/gcc/ipa-modref.cc b/gcc/ipa-modref.cc index 866cc42..37b5355 100644 --- a/gcc/ipa-modref.cc +++ b/gcc/ipa-modref.cc @@ -1762,7 +1762,7 @@ modref_access_analysis::analyze_stmt (gimple *stmt, bool always_executed) /* In general we can not ignore clobbers because they are barriers for code motion, however after inlining it is safe to do because local optimization passes do not consider clobbers from other functions. - Similar logic is in ipa-pure-const.c. */ + Similar logic is in ipa-pure-const.cc. */ if ((m_ipa || cfun->after_inlining) && gimple_clobber_p (stmt)) { if (always_executed && record_access_p (gimple_assign_lhs (stmt))) @@ -2429,7 +2429,7 @@ modref_eaf_analysis::analyze_ssa_name (tree name, bool deferred) m_lattice[index].merge (~EAF_UNUSED); /* Gimple return may load the return value. - Returning name counts as an use by tree-ssa-structalias.c */ + Returning name counts as an use by tree-ssa-structalias.cc */ if (greturn *ret = dyn_cast (use_stmt)) { /* Returning through return slot is seen as memory write earlier. */ @@ -2630,7 +2630,7 @@ modref_eaf_analysis::analyze_ssa_name (tree name, bool deferred) barriers for code motion, however after inlining it is safe to do because local optimization passes do not consider clobbers from other functions. - Similar logic is in ipa-pure-const.c. */ + Similar logic is in ipa-pure-const.cc. */ if (!cfun->after_inlining || !gimple_clobber_p (assign)) m_lattice[index].merge_direct_store (); } @@ -2647,7 +2647,7 @@ modref_eaf_analysis::analyze_ssa_name (tree name, bool deferred) enum tree_code code = gimple_assign_rhs_code (assign); /* See if operation is a merge as considered by - tree-ssa-structalias.c:find_func_aliases. */ + tree-ssa-structalias.cc:find_func_aliases. */ if (!truth_value_p (code) && code != POINTER_DIFF_EXPR && (code != POINTER_PLUS_EXPR diff --git a/gcc/ipa-param-manipulation.cc b/gcc/ipa-param-manipulation.cc index fa6815e..38328c3 100644 --- a/gcc/ipa-param-manipulation.cc +++ b/gcc/ipa-param-manipulation.cc @@ -1096,7 +1096,7 @@ ipa_param_body_adjustments::mark_dead_statements (tree dead_param, /* Calls containing dead arguments cannot be deleted, modify_call_stmt will instead remove just the argument later on. - If isra_track_scalar_value_uses in ipa-sra.c is extended to look + If isra_track_scalar_value_uses in ipa-sra.cc is extended to look through const functions, we will need to do so here too. */ if (is_gimple_call (stmt) || (m_id->blocks_to_copy @@ -1197,7 +1197,7 @@ ipa_param_body_adjustments::remap_with_debug_expressions (tree *t) It is perhaps simpler to handle the SSA_NAME cases directly and only invoke walk_tree on more complex expressions. When - remap_with_debug_expressions is called from tree-inline.c, a to-be-reset + remap_with_debug_expressions is called from tree-inline.cc, a to-be-reset SSA_NAME can be an operand to such expressions and the entire debug variable we are remapping should be reset. This is signaled by walk_tree returning error_mark_node and done by setting *t to NULL. */ diff --git a/gcc/ipa-prop.cc b/gcc/ipa-prop.cc index 29ab2ce..e55fe27 100644 --- a/gcc/ipa-prop.cc +++ b/gcc/ipa-prop.cc @@ -4375,7 +4375,7 @@ ipa_set_node_agg_value_chain (struct cgraph_node *node, s->agg_values = aggvals; } -/* Hook that is called by cgraph.c when an edge is removed. Adjust reference +/* Hook that is called by cgraph.cc when an edge is removed. Adjust reference count data structures accordingly. */ void diff --git a/gcc/ipa-prop.h b/gcc/ipa-prop.h index dc84e5c..12f7626 100644 --- a/gcc/ipa-prop.h +++ b/gcc/ipa-prop.h @@ -25,7 +25,7 @@ along with GCC; see the file COPYING3. If not see #define IPA_UNDESCRIBED_USE -1 -/* ipa-prop.c stuff (ipa-cp, indirect inlining): */ +/* ipa-prop.cc stuff (ipa-cp, indirect inlining): */ /* A jump function for a callsite represents the values passed as actual arguments of the callsite. They were originally proposed in a paper called @@ -59,7 +59,7 @@ along with GCC; see the file COPYING3. If not see parameter or can apply one simple binary operation to it (such jump functions are called polynomial). - Jump functions are computed in ipa-prop.c by function + Jump functions are computed in ipa-prop.cc by function update_call_notes_after_inlining. Some information can be lost and jump functions degraded accordingly when inlining, see update_call_notes_after_inlining in the same file. */ @@ -1184,11 +1184,11 @@ bool ipcp_get_parm_bits (tree, tree *, widest_int *); bool unadjusted_ptr_and_unit_offset (tree op, tree *ret, poly_int64 *offset_ret); -/* From tree-sra.c: */ +/* From tree-sra.cc: */ tree build_ref_for_offset (location_t, tree, poly_int64, bool, tree, gimple_stmt_iterator *, bool); -/* In ipa-cp.c */ +/* In ipa-cp.cc */ void ipa_cp_c_finalize (void); #endif /* IPA_PROP_H */ diff --git a/gcc/ipa-reference.cc b/gcc/ipa-reference.cc index 2d309767..a2f2fad 100644 --- a/gcc/ipa-reference.cc +++ b/gcc/ipa-reference.cc @@ -1318,7 +1318,7 @@ make_pass_ipa_reference (gcc::context *ctxt) return new pass_ipa_reference (ctxt); } -/* Reset all state within ipa-reference.c so that we can rerun the compiler +/* Reset all state within ipa-reference.cc so that we can rerun the compiler within the same process. For use by toplev::finalize. */ void diff --git a/gcc/ipa-reference.h b/gcc/ipa-reference.h index 4ad9f49..be25beb 100644 --- a/gcc/ipa-reference.h +++ b/gcc/ipa-reference.h @@ -21,7 +21,7 @@ along with GCC; see the file COPYING3. If not see #ifndef GCC_IPA_REFERENCE_H #define GCC_IPA_REFERENCE_H -/* In ipa-reference.c */ +/* In ipa-reference.cc */ bitmap ipa_reference_get_read_global (struct cgraph_node *fn); bitmap ipa_reference_get_written_global (struct cgraph_node *fn); void ipa_reference_c_finalize (void); diff --git a/gcc/ipa-split.cc b/gcc/ipa-split.cc index 91f9fcc..fc6be8e 100644 --- a/gcc/ipa-split.cc +++ b/gcc/ipa-split.cc @@ -574,7 +574,7 @@ consider_split (class split_point *current, bitmap non_ssa_vars, /* Splitting functions brings the target out of comdat group; this will lead to code duplication if the function is reused by other unit. - Limit this duplication. This is consistent with limit in tree-sra.c + Limit this duplication. This is consistent with limit in tree-sra.cc FIXME: with LTO we ought to be able to do better! */ if (DECL_ONE_ONLY (current_function_decl) && current->split_size >= (unsigned int) param_max_inline_insns_auto + 10) diff --git a/gcc/ipa-sra.cc b/gcc/ipa-sra.cc index f300a32..969160f 100644 --- a/gcc/ipa-sra.cc +++ b/gcc/ipa-sra.cc @@ -2723,7 +2723,7 @@ isra_read_node_info (struct lto_input_block *ib, cgraph_node *node, } /* Read IPA-SRA summaries from a section in file FILE_DATA of length LEN with - data DATA. TODO: This function was copied almost verbatim from ipa-prop.c, + data DATA. TODO: This function was copied almost verbatim from ipa-prop.cc, it should be possible to unify them somehow. */ static void diff --git a/gcc/ipa-utils.h b/gcc/ipa-utils.h index ede672d..dc6ba0d 100644 --- a/gcc/ipa-utils.h +++ b/gcc/ipa-utils.h @@ -34,7 +34,7 @@ struct ipa_dfs_info { }; -/* In ipa-utils.c */ +/* In ipa-utils.cc */ void ipa_print_order (FILE*, const char *, struct cgraph_node**, int); int ipa_reduced_postorder (struct cgraph_node **, bool, bool (*ignore_edge) (struct cgraph_edge *)); @@ -47,16 +47,16 @@ void ipa_merge_profiles (struct cgraph_node *dst, struct cgraph_node *src, bool preserve_body = false); bool recursive_call_p (tree, tree); -/* In ipa-pure-const.c */ +/* In ipa-pure-const.cc */ bool finite_function_p (); bool builtin_safe_for_const_function_p (bool *, tree); bool ipa_make_function_const (cgraph_node *, bool, bool); bool ipa_make_function_pure (cgraph_node *, bool, bool); -/* In ipa-profile.c */ +/* In ipa-profile.cc */ bool ipa_propagate_frequency (struct cgraph_node *node); -/* In ipa-devirt.c */ +/* In ipa-devirt.cc */ struct odr_type_d; typedef odr_type_d *odr_type; diff --git a/gcc/ira-build.cc b/gcc/ira-build.cc index ab3e871..3bf117c 100644 --- a/gcc/ira-build.cc +++ b/gcc/ira-build.cc @@ -488,7 +488,7 @@ ira_create_allocno (int regno, bool cap_p, if (loop_tree_node->regno_allocno_map[regno] == NULL) /* Remember that we can create temporary allocnos to break cycles in register shuffle on region borders (see - ira-emit.c). */ + ira-emit.cc). */ loop_tree_node->regno_allocno_map[regno] = a; } ALLOCNO_CAP (a) = NULL; @@ -2211,7 +2211,7 @@ low_pressure_loop_node_p (ira_loop_tree_node_t node) #ifdef STACK_REGS /* Return TRUE if LOOP has a complex enter or exit edge. We don't form a region from such loop if the target use stack register - because reg-stack.c cannot deal with such edges. */ + because reg-stack.cc cannot deal with such edges. */ static bool loop_with_complex_edge_p (class loop *loop) { @@ -3319,7 +3319,7 @@ ira_flattening (int max_regno_before_emit, int ira_max_point_before_emit) = regno_top_level_allocno_map[REGNO (allocno_emit_reg (cp->second))]; node = cp->loop_tree_node; if (node == NULL) - keep_p = true; /* It copy generated in ira-emit.c. */ + keep_p = true; /* It copy generated in ira-emit.cc. */ else { /* Check that the copy was not propagated from level on diff --git a/gcc/ira-color.cc b/gcc/ira-color.cc index 59d978f..8b6db1b 100644 --- a/gcc/ira-color.cc +++ b/gcc/ira-color.cc @@ -3747,7 +3747,7 @@ do_coloring (void) -/* Move spill/restore code, which are to be generated in ira-emit.c, +/* Move spill/restore code, which are to be generated in ira-emit.cc, to less frequent points (if it is profitable) by reassigning some allocnos (in loop with subloops containing in another loop) to memory which results in longer live-range where the corresponding @@ -3956,7 +3956,7 @@ update_curr_costs (ira_allocno_t a) /* Try to assign hard registers to the unassigned allocnos and allocnos conflicting with them or conflicting with allocnos whose regno >= START_REGNO. The function is called after ira_flattening, - so more allocnos (including ones created in ira-emit.c) will have a + so more allocnos (including ones created in ira-emit.cc) will have a chance to get a hard register. We use simple assignment algorithm based on priorities. */ void diff --git a/gcc/ira-conflicts.cc b/gcc/ira-conflicts.cc index 62e4ce0..e43b513 100644 --- a/gcc/ira-conflicts.cc +++ b/gcc/ira-conflicts.cc @@ -309,7 +309,7 @@ process_regs_for_copy (rtx reg1, rtx reg2, bool constraint_p, rtx_insn *insn, aclass = ALLOCNO_CLASS (a); if (only_regs_p && insn != NULL_RTX && reg_class_size[rclass] <= ira_reg_class_max_nregs [rclass][mode]) - /* It is already taken into account in ira-costs.c. */ + /* It is already taken into account in ira-costs.cc. */ return false; index = ira_class_hard_reg_index[aclass][allocno_preferenced_hard_regno]; if (index < 0) diff --git a/gcc/ira-int.h b/gcc/ira-int.h index e80fdeb..957604b 100644 --- a/gcc/ira-int.h +++ b/gcc/ira-int.h @@ -479,7 +479,7 @@ typedef struct ira_emit_data *ira_emit_data_t; struct ira_emit_data { /* TRUE if the allocno assigned to memory was a destination of - removed move (see ira-emit.c) at loop exit because the value of + removed move (see ira-emit.cc) at loop exit because the value of the corresponding pseudo-register is not changed inside the loop. */ unsigned int mem_optimized_dest_p : 1; @@ -493,7 +493,7 @@ struct ira_emit_data /* Final rtx representation of the allocno. */ rtx reg; /* Non NULL if we remove restoring value from given allocno to - MEM_OPTIMIZED_DEST at loop exit (see ira-emit.c) because the + MEM_OPTIMIZED_DEST at loop exit (see ira-emit.cc) because the allocno value is not changed inside the loop. */ ira_allocno_t mem_optimized_dest; }; @@ -632,7 +632,7 @@ extern class ira_spilled_reg_stack_slot *ira_spilled_reg_stack_slots; /* Correspondingly overall cost of the allocation, cost of the allocnos assigned to hard-registers, cost of the allocnos assigned to memory, cost of loads, stores and register move insns generated - for pseudo-register live range splitting (see ira-emit.c). */ + for pseudo-register live range splitting (see ira-emit.cc). */ extern int64_t ira_overall_cost; extern int64_t ira_reg_cost, ira_mem_cost; extern int64_t ira_load_cost, ira_store_cost, ira_shuffle_cost; @@ -969,7 +969,7 @@ extern class target_ira_int *this_target_ira_int; #define ira_prohibited_mode_move_regs \ (this_target_ira_int->x_ira_prohibited_mode_move_regs) -/* ira.c: */ +/* ira.cc: */ extern void *ira_allocate (size_t); extern void ira_free (void *addr); @@ -982,7 +982,7 @@ extern void ira_init_register_move_cost (machine_mode); extern alternative_mask ira_setup_alts (rtx_insn *); extern int ira_get_dup_out_num (int, alternative_mask, bool &); -/* ira-build.c */ +/* ira-build.cc */ /* The current loop tree node and its regno allocno map. */ extern ira_loop_tree_node_t ira_curr_loop_tree_node; @@ -1041,13 +1041,13 @@ extern void ira_flattening (int, int); extern bool ira_build (void); extern void ira_destroy (void); -/* ira-costs.c */ +/* ira-costs.cc */ extern void ira_init_costs_once (void); extern void ira_init_costs (void); extern void ira_costs (void); extern void ira_tune_allocno_costs (void); -/* ira-lives.c */ +/* ira-lives.cc */ extern void ira_rebuild_start_finish_chains (void); extern void ira_print_live_range_list (FILE *, live_range_t); @@ -1062,11 +1062,11 @@ extern void ira_finish_allocno_live_ranges (void); extern void ira_implicitly_set_insn_hard_regs (HARD_REG_SET *, alternative_mask); -/* ira-conflicts.c */ +/* ira-conflicts.cc */ extern void ira_debug_conflicts (bool); extern void ira_build_conflicts (void); -/* ira-color.c */ +/* ira-color.cc */ extern ira_allocno_t ira_soft_conflict (ira_allocno_t, ira_allocno_t); extern void ira_debug_hard_regs_forest (void); extern int ira_loop_edge_freq (ira_loop_tree_node_t, int, bool); @@ -1075,7 +1075,7 @@ extern void ira_initiate_assign (void); extern void ira_finish_assign (void); extern void ira_color (void); -/* ira-emit.c */ +/* ira-emit.cc */ extern void ira_initiate_emit_data (void); extern void ira_finish_emit_data (void); extern void ira_emit (bool); diff --git a/gcc/ira-lives.cc b/gcc/ira-lives.cc index 4075cc8..7a92c44 100644 --- a/gcc/ira-lives.cc +++ b/gcc/ira-lives.cc @@ -1396,7 +1396,7 @@ process_bb_node_lives (ira_loop_tree_node_t loop_tree_node) sparseset_set_bit (allocnos_processed, num); if (allocno_saved_at_call[num] != last_call_num) - /* Here we are mimicking caller-save.c behavior + /* Here we are mimicking caller-save.cc behavior which does not save hard register at a call if it was saved on previous call in the same basic block and the hard register was not mentioned diff --git a/gcc/ira.cc b/gcc/ira.cc index 3bece66..f294f03 100644 --- a/gcc/ira.cc +++ b/gcc/ira.cc @@ -147,7 +147,7 @@ along with GCC; see the file COPYING3. If not see following subpasses: * First, IRA builds regions and creates allocnos (file - ira-build.c) and initializes most of their attributes. + ira-build.cc) and initializes most of their attributes. * Then IRA finds an allocno class for each allocno and calculates its initial (non-accumulated) cost of memory and @@ -156,26 +156,26 @@ along with GCC; see the file COPYING3. If not see * IRA creates live ranges of each allocno, calculates register pressure for each pressure class in each region, sets up conflict hard registers for each allocno and info about calls - the allocno lives through (file ira-lives.c). + the allocno lives through (file ira-lives.cc). * IRA removes low register pressure loops from the regions - mostly to speed IRA up (file ira-build.c). + mostly to speed IRA up (file ira-build.cc). * IRA propagates accumulated allocno info from lower region allocnos to corresponding upper region allocnos (file - ira-build.c). + ira-build.cc). - * IRA creates all caps (file ira-build.c). + * IRA creates all caps (file ira-build.cc). * Having live-ranges of allocnos and their classes, IRA creates conflicting allocnos for each allocno. Conflicting allocnos are stored as a bit vector or array of pointers to the conflicting allocnos whatever is more profitable (file - ira-conflicts.c). At this point IRA creates allocno copies. + ira-conflicts.cc). At this point IRA creates allocno copies. o Coloring. Now IRA has all necessary info to start graph coloring process. It is done in each region on top-down traverse of the - region tree (file ira-color.c). There are following subpasses: + region tree (file ira-color.cc). There are following subpasses: * Finding profitable hard registers of corresponding allocno class for each allocno. For example, only callee-saved hard @@ -280,7 +280,7 @@ along with GCC; see the file COPYING3. If not see memory). In this case IRA creates and uses a new pseudo-register inside the region and adds code to move allocno values on the region's borders. This is done during top-down - traversal of the regions (file ira-emit.c). In some + traversal of the regions (file ira-emit.cc). In some complicated cases IRA can create a new allocno to move allocno values (e.g. when a swap of values stored in two hard-registers is needed). At this stage, the new allocno is marked as @@ -302,20 +302,20 @@ along with GCC; see the file COPYING3. If not see o Flattening internal representation. After changing code, IRA transforms its internal representation for several regions into - one region representation (file ira-build.c). This process is + one region representation (file ira-build.cc). This process is called IR flattening. Such process is more complicated than IR rebuilding would be, but is much faster. o After IR flattening, IRA tries to assign hard registers to all spilled allocnos. This is implemented by a simple and fast priority coloring algorithm (see function - ira_reassign_conflict_allocnos::ira-color.c). Here new allocnos + ira_reassign_conflict_allocnos::ira-color.cc). Here new allocnos created during the code change pass can be assigned to hard registers. o At the end IRA calls the reload pass. The reload pass communicates with IRA through several functions in file - ira-color.c to improve its decisions in + ira-color.cc to improve its decisions in * sharing stack slots for the spilled pseudos based on IRA info about pseudo-register conflicts. @@ -328,7 +328,7 @@ along with GCC; see the file COPYING3. If not see in places where the pseudo-register lives. IRA uses a lot of data representing the target processors. These - data are initialized in file ira.c. + data are initialized in file ira.cc. If function has no loops (or the loops are ignored when -fira-algorithm=CB is used), we have classic Chaitin-Briggs @@ -417,7 +417,7 @@ class ira_spilled_reg_stack_slot *ira_spilled_reg_stack_slots; reload, cost of the allocnos assigned to hard-registers, cost of the allocnos assigned to memory, cost of loads, stores and register move insns generated for pseudo-register live range splitting (see - ira-emit.c). */ + ira-emit.cc). */ int64_t ira_overall_cost, overall_cost_before; int64_t ira_reg_cost, ira_mem_cost; int64_t ira_load_cost, ira_store_cost, ira_shuffle_cost; @@ -965,7 +965,7 @@ setup_uniform_class_p (void) calculations efforts we introduce allocno classes which contain unique non-empty sets of allocatable hard-registers. - Pseudo class cost calculation in ira-costs.c is very expensive. + Pseudo class cost calculation in ira-costs.cc is very expensive. Therefore we are trying to decrease number of classes involved in such calculation. Register classes used in the cost calculation are called important classes. They are allocno classes and other @@ -977,7 +977,7 @@ setup_uniform_class_p (void) registers are the same for the both classes). The important classes will contain GENERAL_REGS and LEGACY_REGS. It is done because a machine description insn constraint may refers for - LEGACY_REGS and code in ira-costs.c is mostly base on investigation + LEGACY_REGS and code in ira-costs.cc is mostly base on investigation of the insn constraints. */ static void setup_allocno_and_important_classes (void) @@ -3464,7 +3464,7 @@ def_dominates_uses (int regno) for non-local goto, regs defined on function entry) then def_info is NULL and the reg is always live before any use. We might reasonably return true in that case, but since the only call - of this function is currently here in ira.c when we are looking + of this function is currently here in ira.cc when we are looking at a defining insn we can't have an artificial def as that would bump DF_REG_DEF_COUNT. */ gcc_assert (DF_REG_DEF_COUNT (regno) == 1 && def_info != NULL); diff --git a/gcc/ira.h b/gcc/ira.h index b048974..9a22276 100644 --- a/gcc/ira.h +++ b/gcc/ira.h @@ -215,10 +215,10 @@ extern bool ira_remove_insn_scratches (rtx_insn *insn, bool all_p, FILE *dump_fi extern void ira_restore_scratches (FILE *dump_file); extern void ira_nullify_asm_goto (rtx_insn *insn); -/* ira-costs.c */ +/* ira-costs.cc */ extern void ira_costs_c_finalize (void); -/* ira-lives.c */ +/* ira-lives.cc */ extern rtx non_conflicting_reg_copy_p (rtx_insn *); /* Spilling static chain pseudo may result in generation of wrong diff --git a/gcc/jit/config-lang.in b/gcc/jit/config-lang.in index 5da2690..dac0e1a 100644 --- a/gcc/jit/config-lang.in +++ b/gcc/jit/config-lang.in @@ -29,7 +29,7 @@ compilers="" target_libs="" -gtfiles="\$(srcdir)/jit/dummy-frontend.c" +gtfiles="\$(srcdir)/jit/dummy-frontend.cc" # The configuration requires --enable-host-shared # for jit to be supported (only when not building for Mingw). diff --git a/gcc/jit/docs/_build/texinfo/libgccjit.texi b/gcc/jit/docs/_build/texinfo/libgccjit.texi index d28cbc2..603de63 100644 --- a/gcc/jit/docs/_build/texinfo/libgccjit.texi +++ b/gcc/jit/docs/_build/texinfo/libgccjit.texi @@ -14959,12 +14959,12 @@ extension for legacy reasons. @itemize * @item -@code{libgccjit.c} implements the API entrypoints. It performs error +@code{libgccjit.cc} implements the API entrypoints. It performs error checking, then calls into classes of the gcc::jit::recording namespace -within @code{jit-recording.c} and @code{jit-recording.h}. +within @code{jit-recording.cc} and @code{jit-recording.h}. @item -The gcc::jit::recording classes (within @code{jit-recording.c} and +The gcc::jit::recording classes (within @code{jit-recording.cc} and @code{jit-recording.h}) record the API calls that are made: @quotation @@ -15004,7 +15004,7 @@ The gcc::jit::recording classes (within @code{jit-recording.c} and @item When the context is compiled, the gcc::jit::playback classes (within -@code{jit-playback.c} and @code{jit-playback.h}) replay the API calls +@code{jit-playback.cc} and @code{jit-playback.h}) replay the API calls within langhook:parse_file: @quotation @@ -15038,10 +15038,10 @@ Client Code . Generated . libgccjit.so ──────────────────────────> . . . . │ . . . . V . . - . . ──> libgccjit.c . + . . ──> libgccjit.cc . . . │ (error-checking). . . │ . - . . ──> jit-recording.c + . . ──> jit-recording.cc . . (record API calls) . . <─────── . . . │ . . @@ -15068,7 +15068,7 @@ Client Code . Generated . libgccjit.so . . . │ . ..........................................│..................VVVVVVVVVVVVV... . . . │ . No GC in here - . . . │ jit-playback.c + . . . │ jit-playback.cc . . . │ (playback of API calls) . . . ───────────────> creation of functions, . . . . types, expression trees @@ -15425,9 +15425,9 @@ It should not be possible for client code to cause an internal compiler error. If this @emph{does} happen, the root cause should be isolated (perhaps using @ref{5d,,gcc_jit_context_dump_reproducer_to_file()}) and the cause should be rejected via additional checking. The checking ideally should -be within the libgccjit API entrypoints in libgccjit.c, since this is as +be within the libgccjit API entrypoints in libgccjit.cc, since this is as close as possible to the error; failing that, a good place is within -@code{recording::context::validate ()} in jit-recording.c. +@code{recording::context::validate ()} in jit-recording.cc. @node Submitting patches,,Design notes,Internals @anchor{internals/index submitting-patches}@anchor{392} diff --git a/gcc/jit/docs/internals/index.rst b/gcc/jit/docs/internals/index.rst index 3766aad..9200181 100644 --- a/gcc/jit/docs/internals/index.rst +++ b/gcc/jit/docs/internals/index.rst @@ -294,11 +294,11 @@ Overview of code structure The library is implemented in C++. The source files have the ``.c`` extension for legacy reasons. -* ``libgccjit.c`` implements the API entrypoints. It performs error +* ``libgccjit.cc`` implements the API entrypoints. It performs error checking, then calls into classes of the gcc::jit::recording namespace - within ``jit-recording.c`` and ``jit-recording.h``. + within ``jit-recording.cc`` and ``jit-recording.h``. -* The gcc::jit::recording classes (within ``jit-recording.c`` and +* The gcc::jit::recording classes (within ``jit-recording.cc`` and ``jit-recording.h``) record the API calls that are made: .. literalinclude:: ../../jit-common.h @@ -307,7 +307,7 @@ extension for legacy reasons. :language: c++ * When the context is compiled, the gcc::jit::playback classes (within - ``jit-playback.c`` and ``jit-playback.h``) replay the API calls + ``jit-playback.cc`` and ``jit-playback.h``) replay the API calls within langhook:parse_file: .. literalinclude:: ../../jit-common.h @@ -339,9 +339,9 @@ It should not be possible for client code to cause an internal compiler error. If this *does* happen, the root cause should be isolated (perhaps using :c:func:`gcc_jit_context_dump_reproducer_to_file`) and the cause should be rejected via additional checking. The checking ideally should -be within the libgccjit API entrypoints in libgccjit.c, since this is as +be within the libgccjit API entrypoints in libgccjit.cc, since this is as close as possible to the error; failing that, a good place is within -``recording::context::validate ()`` in jit-recording.c. +``recording::context::validate ()`` in jit-recording.cc. Submitting patches ------------------ diff --git a/gcc/jit/jit-builtins.cc b/gcc/jit/jit-builtins.cc index 0b62108..71c38eb 100644 --- a/gcc/jit/jit-builtins.cc +++ b/gcc/jit/jit-builtins.cc @@ -1,4 +1,4 @@ -/* jit-builtins.c -- Handling of builtin functions during JIT-compilation. +/* jit-builtins.cc -- Handling of builtin functions during JIT-compilation. Copyright (C) 2014-2022 Free Software Foundation, Inc. This file is part of GCC. @@ -230,7 +230,7 @@ builtins_manager::make_builtin_function (enum built_in_function builtin_id) if (builtin_id == BUILT_IN_COS || builtin_id == BUILT_IN_SIN) (void)get_builtin_function_by_id (BUILT_IN_CEXPI); - /* builtins.c:expand_builtin_cexpi can optimize the various + /* builtins.cc:expand_builtin_cexpi can optimize the various CEXP builtins to SINCOS builtins, and hence we may require SINCOS builtins latter. diff --git a/gcc/jit/jit-playback.cc b/gcc/jit/jit-playback.cc index 1d64caf..d1835c7 100644 --- a/gcc/jit/jit-playback.cc +++ b/gcc/jit/jit-playback.cc @@ -109,8 +109,8 @@ namespace jit { static tree fold_const_var (tree node) { - /* See c_fully_fold_internal in c-fold.c and decl_constant_value_1 - in c-typeck.c. */ + /* See c_fully_fold_internal in c-fold.cc and decl_constant_value_1 + in c-typeck.cc. */ if (VAR_P (node) && TREE_READONLY (node) && !TREE_THIS_VOLATILE (node) @@ -185,7 +185,7 @@ playback::context::~context () ("by hand", rather than by gengtype). This is called on the active playback context (if any) by the - my_ggc_walker hook in the jit_root_table in dummy-frontend.c. */ + my_ggc_walker hook in the jit_root_table in dummy-frontend.cc. */ void playback::context:: @@ -320,7 +320,7 @@ new_field (location *loc, gcc_assert (type); gcc_assert (name); - /* compare with c/c-decl.c:grokfield and grokdeclarator. */ + /* compare with c/c-decl.cc:grokfield and grokdeclarator. */ tree decl = build_decl (UNKNOWN_LOCATION, FIELD_DECL, get_identifier (name), type->as_tree ()); @@ -343,7 +343,7 @@ new_bitfield (location *loc, gcc_assert (name); gcc_assert (width); - /* compare with c/c-decl.c:grokfield, grokdeclarator and + /* compare with c/c-decl.cc:grokfield, grokdeclarator and check_bitfield_type_and_width. */ tree tree_type = type->as_tree (); @@ -380,7 +380,7 @@ new_compound_type (location *loc, { gcc_assert (name); - /* Compare with c/c-decl.c: start_struct. */ + /* Compare with c/c-decl.cc: start_struct. */ tree t = make_node (is_struct ? RECORD_TYPE : UNION_TYPE); TYPE_NAME (t) = get_identifier (name); @@ -395,7 +395,7 @@ new_compound_type (location *loc, void playback::compound_type::set_fields (const auto_vec *fields) { - /* Compare with c/c-decl.c: finish_struct. */ + /* Compare with c/c-decl.cc: finish_struct. */ tree t = as_tree (); tree fieldlist = NULL; @@ -661,7 +661,7 @@ global_set_init_rvalue (lvalue* variable, /* We need to fold all expressions as much as possible. The code for a DECL_INITIAL only handles some operations, etc addition, minus, 'address of'. See output_addressed_constants () - in varasm.c. */ + in varasm.cc. */ tree init_tree = init->as_tree (); tree folded = fold_const_var (init_tree); @@ -767,7 +767,7 @@ load_blob_in_ctor (vec *&constructor_elements, size_t num_elem, const void *initializer) { - /* Loosely based on 'output_init_element' c-typeck.c:9691. */ + /* Loosely based on 'output_init_element' c-typeck.cc:9691. */ const T *p = (const T *)initializer; tree node = make_unsigned_type (BITS_PER_UNIT * sizeof (T)); for (size_t i = 0; i < num_elem; i++) @@ -820,11 +820,11 @@ new_global_initialized (location *loc, these are all covered by the previous cases. */ gcc_unreachable (); } - /* Compare with 'pop_init_level' c-typeck.c:8780. */ + /* Compare with 'pop_init_level' c-typeck.cc:8780. */ tree ctor = build_constructor (type->as_tree (), constructor_elements); constructor_elements = NULL; - /* Compare with 'store_init_value' c-typeck.c:7555. */ + /* Compare with 'store_init_value' c-typeck.cc:7555. */ DECL_INITIAL (inner) = ctor; return global_finalize_lvalue (inner); @@ -903,7 +903,7 @@ new_rvalue_from_const (type *type, /* We have a "double", we want a REAL_VALUE_TYPE. - real.c:real_from_target appears to require the representation to be + real.cc:real_from_target appears to require the representation to be split into 32-bit values, and then sent as an pair of host long ints. */ REAL_VALUE_TYPE real_value; @@ -947,7 +947,7 @@ playback::rvalue * playback::context:: new_string_literal (const char *value) { - /* Compare with c-family/c-common.c: fix_string_type. */ + /* Compare with c-family/c-common.cc: fix_string_type. */ size_t len = strlen (value); tree i_type = build_index_type (size_int (len)); tree a_type = build_array_type (char_type_node, i_type); @@ -957,7 +957,7 @@ new_string_literal (const char *value) TREE_TYPE (t_str) = a_type; /* Convert to (const char*), loosely based on - c/c-typeck.c: array_to_pointer_conversion, + c/c-typeck.cc: array_to_pointer_conversion, by taking address of start of string. */ tree t_addr = build1 (ADDR_EXPR, m_const_char_ptr, t_str); @@ -986,7 +986,7 @@ tree playback::context:: as_truth_value (tree expr, location *loc) { - /* Compare to c-typeck.c:c_objc_common_truthvalue_conversion */ + /* Compare to c-typeck.cc:c_objc_common_truthvalue_conversion */ tree typed_zero = fold_build1 (CONVERT_EXPR, TREE_TYPE (expr), integer_zero_node); @@ -1263,13 +1263,13 @@ build_call (location *loc, return new rvalue (this, call); - /* see c-typeck.c: build_function_call + /* see c-typeck.cc: build_function_call which calls build_function_call_vec which does lots of checking, then: result = build_call_array_loc (loc, TREE_TYPE (fntype), function, nargs, argarray); - which is in tree.c + which is in tree.cc (see also build_call_vec) */ } @@ -1321,8 +1321,8 @@ playback::context::build_cast (playback::location *loc, playback::type *type_) { /* For comparison, see: - - c/c-typeck.c:build_c_cast - - c/c-convert.c: convert + - c/c-typeck.cc:build_c_cast + - c/c-convert.cc: convert - convert.h Only some kinds of cast are currently supported here. */ @@ -1403,8 +1403,8 @@ new_array_access (location *loc, gcc_assert (index); /* For comparison, see: - c/c-typeck.c: build_array_ref - c-family/c-common.c: pointer_int_sum + c/c-typeck.cc: build_array_ref + c-family/c-common.cc: pointer_int_sum */ tree t_ptr = ptr->as_tree (); t_ptr = fold_const_var (t_ptr); @@ -1459,7 +1459,7 @@ new_field_access (location *loc, gcc_assert (datum); gcc_assert (field); - /* Compare with c/c-typeck.c:lookup_field, build_indirect_ref, and + /* Compare with c/c-typeck.cc:lookup_field, build_indirect_ref, and build_component_ref. */ tree type = TREE_TYPE (datum); gcc_assert (type); @@ -1577,7 +1577,7 @@ dereference (location *loc) /* Mark the lvalue saying that we need to be able to take the address of it; it should not be allocated in a register. - Compare with e.g. c/c-typeck.c: c_mark_addressable really_atomic_lvalue. + Compare with e.g. c/c-typeck.cc: c_mark_addressable really_atomic_lvalue. Returns false if a failure occurred (an error will already have been added to the active context for this case). */ @@ -1821,7 +1821,7 @@ postprocess () if (m_ctxt->get_bool_option (GCC_JIT_BOOL_OPTION_DUMP_INITIAL_TREE)) debug_tree (m_stmt_list); - /* Do we need this to force cgraphunit.c to output the function? */ + /* Do we need this to force cgraphunit.cc to output the function? */ if (m_kind == GCC_JIT_FUNCTION_EXPORTED) { DECL_EXTERNAL (m_inner_fndecl) = 0; @@ -1837,7 +1837,7 @@ postprocess () if (m_kind != GCC_JIT_FUNCTION_IMPORTED) { - /* Seem to need this in gimple-low.c: */ + /* Seem to need this in gimple-low.cc: */ gcc_assert (m_inner_block); DECL_INITIAL (m_inner_fndecl) = m_inner_block; @@ -2009,7 +2009,7 @@ add_jump (location *loc, add_stmt (stmt); /* - from c-typeck.c: + from c-typeck.cc: tree c_finish_goto_label (location_t loc, tree label) { @@ -2092,11 +2092,11 @@ add_switch (location *loc, const auto_vec *cases) { /* Compare with: - - c/c-typeck.c: c_start_case - - c-family/c-common.c:c_add_case_label - - java/expr.c:expand_java_switch and expand_java_add_case + - c/c-typeck.cc: c_start_case + - c-family/c-common.cc:c_add_case_label + - java/expr.cc:expand_java_switch and expand_java_add_case We've already rejected overlaps and duplicates in - libgccjit.c:case_range_validator::validate. */ + libgccjit.cc:case_range_validator::validate. */ tree t_expr = expr->as_tree (); tree t_type = TREE_TYPE (t_expr); @@ -2182,8 +2182,8 @@ build_goto_operands (const auto_vec *blocks) /* Add an extended asm statement to this block. - Compare with c_parser_asm_statement (in c/c-parser.c) - and build_asm_expr (in c/c-typeck.c). */ + Compare with c_parser_asm_statement (in c/c-parser.cc) + and build_asm_expr (in c/c-typeck.cc). */ void playback::block::add_extended_asm (location *loc, @@ -2874,7 +2874,7 @@ playback::context::read_dump_file (const char *path) /* Part of playback::context::compile (). We have a .s file; we want a .so file. - We could reuse parts of gcc/gcc.c to do this. + We could reuse parts of gcc/gcc.cc to do this. For now, just use the driver binary from the install, as named in gcc-driver-name.h e.g. "x86_64-unknown-linux-gnu-gcc-5.0.0". */ @@ -3280,7 +3280,7 @@ void playback::context:: init_types () { - /* See lto_init() in lto-lang.c or void visit (TypeBasic *t) in D's types.cc + /* See lto_init() in lto-lang.cc or void visit (TypeBasic *t) in D's types.cc for reference. If TYPE_NAME is not set, debug info will not contain types */ #define NAME_TYPE(t,n) \ if (t) \ diff --git a/gcc/jit/jit-recording.cc b/gcc/jit/jit-recording.cc index ee89341..1e3fadf 100644 --- a/gcc/jit/jit-recording.cc +++ b/gcc/jit/jit-recording.cc @@ -798,7 +798,7 @@ recording::context::get_int_type (int num_bytes, int is_signed) /* We can't use a switch here since some of the values are macros affected by options; e.g. i386.h has #define LONG_TYPE_SIZE (TARGET_X32 ? 32 : BITS_PER_WORD) - Compare with tree.c's make_or_reuse_type. Note that the _SIZE macros + Compare with tree.cc's make_or_reuse_type. Note that the _SIZE macros are in bits, rather than bytes. */ const int num_bits = num_bytes * 8; diff --git a/gcc/jit/jit-recording.h b/gcc/jit/jit-recording.h index b663d0f..846d65c 100644 --- a/gcc/jit/jit-recording.h +++ b/gcc/jit/jit-recording.h @@ -1038,7 +1038,7 @@ private: /* An abstract base class for operations that visit all rvalues within an expression tree. Currently the only implementation is class rvalue_usage_validator within - jit-recording.c. */ + jit-recording.cc. */ class rvalue_visitor { diff --git a/gcc/jit/libgccjit.cc b/gcc/jit/libgccjit.cc index 03704ef..4c352e8 100644 --- a/gcc/jit/libgccjit.cc +++ b/gcc/jit/libgccjit.cc @@ -357,7 +357,7 @@ compatible_types (gcc::jit::recording::type *ltype, gcc_jit_context_new_child_context below. The real work is done in the constructor for - gcc::jit::recording::context in jit-recording.c. */ + gcc::jit::recording::context in jit-recording.cc. */ gcc_jit_context * gcc_jit_context_acquire (void) @@ -369,7 +369,7 @@ gcc_jit_context_acquire (void) /* Public entrypoint for releasing a gcc_jit_context. The real work is done in the destructor for - gcc::jit::recording::context in jit-recording.c. */ + gcc::jit::recording::context in jit-recording.cc. */ void gcc_jit_context_release (gcc_jit_context *ctxt) @@ -384,7 +384,7 @@ gcc_jit_context_release (gcc_jit_context *ctxt) PARENT_CTXT. See description in libgccjit.h. The real work is done in the constructor for - gcc::jit::recording::context in jit-recording.c. */ + gcc::jit::recording::context in jit-recording.cc. */ gcc_jit_context * gcc_jit_context_new_child_context (gcc_jit_context *parent_ctxt) @@ -401,7 +401,7 @@ gcc_jit_context_new_child_context (gcc_jit_context *parent_ctxt) After error-checking, the real work is done by the gcc::jit::recording::context::new_location - method in jit-recording.c. */ + method in jit-recording.cc. */ gcc_jit_location * gcc_jit_context_new_location (gcc_jit_context *ctxt, @@ -446,7 +446,7 @@ gcc_jit_type_as_object (gcc_jit_type *type) After error-checking, the real work is done by the gcc::jit::recording::context::get_type method, in - jit-recording.c */ + jit-recording.cc */ gcc_jit_type * gcc_jit_context_get_type (gcc_jit_context *ctxt, @@ -468,7 +468,7 @@ gcc_jit_context_get_type (gcc_jit_context *ctxt, After error-checking, the real work is done by the gcc::jit::recording::context::get_int_type method, - in jit-recording.c. */ + in jit-recording.cc. */ gcc_jit_type * gcc_jit_context_get_int_type (gcc_jit_context *ctxt, @@ -485,7 +485,7 @@ gcc_jit_context_get_int_type (gcc_jit_context *ctxt, After error-checking, the real work is done by the gcc::jit::recording::type::get_pointer method, in - jit-recording.c */ + jit-recording.cc */ gcc_jit_type * gcc_jit_type_get_pointer (gcc_jit_type *type) @@ -499,7 +499,7 @@ gcc_jit_type_get_pointer (gcc_jit_type *type) After error-checking, the real work is done by the gcc::jit::recording::type::get_const method, in - jit-recording.c. */ + jit-recording.cc. */ gcc_jit_type * gcc_jit_type_get_const (gcc_jit_type *type) @@ -513,7 +513,7 @@ gcc_jit_type_get_const (gcc_jit_type *type) After error-checking, the real work is done by the gcc::jit::recording::type::get_volatile method, in - jit-recording.c. */ + jit-recording.cc. */ gcc_jit_type * gcc_jit_type_get_volatile (gcc_jit_type *type) @@ -527,7 +527,7 @@ gcc_jit_type_get_volatile (gcc_jit_type *type) After error-checking, the real work is done by the gcc::jit::recording::type::is_array method, in - jit-recording.c. */ + jit-recording.cc. */ gcc_jit_type * gcc_jit_type_dyncast_array (gcc_jit_type *type) @@ -541,7 +541,7 @@ gcc_jit_type_dyncast_array (gcc_jit_type *type) After error-checking, the real work is done by the gcc::jit::recording::type::is_bool method, in - jit-recording.c. */ + jit-recording.cc. */ int gcc_jit_type_is_bool (gcc_jit_type *type) @@ -555,7 +555,7 @@ gcc_jit_type_is_bool (gcc_jit_type *type) After error-checking, the real work is done by the gcc::jit::recording::type::is_pointer method, in - jit-recording.c. */ + jit-recording.cc. */ gcc_jit_type * gcc_jit_type_is_pointer (gcc_jit_type *type) @@ -569,7 +569,7 @@ gcc_jit_type_is_pointer (gcc_jit_type *type) After error-checking, the real work is done by the gcc::jit::recording::type::is_int method, in - jit-recording.c. */ + jit-recording.cc. */ int gcc_jit_type_is_integral (gcc_jit_type *type) @@ -583,7 +583,7 @@ gcc_jit_type_is_integral (gcc_jit_type *type) After error-checking, the real work is done by the gcc::jit::recording::type::is_vector method, in - jit-recording.c. */ + jit-recording.cc. */ gcc_jit_vector_type * gcc_jit_type_dyncast_vector (gcc_jit_type *type) @@ -597,7 +597,7 @@ gcc_jit_type_dyncast_vector (gcc_jit_type *type) After error-checking, the real work is done by the gcc::jit::recording::type::is_struct method, in - jit-recording.c. */ + jit-recording.cc. */ gcc_jit_struct * gcc_jit_type_is_struct (gcc_jit_type *type) @@ -611,7 +611,7 @@ gcc_jit_type_is_struct (gcc_jit_type *type) After error-checking, the real work is done by the gcc::jit::recording::vector_type::get_num_units method, in - jit-recording.c. */ + jit-recording.cc. */ size_t gcc_jit_vector_type_get_num_units (gcc_jit_vector_type *vector_type) @@ -624,7 +624,7 @@ gcc_jit_vector_type_get_num_units (gcc_jit_vector_type *vector_type) After error-checking, the real work is done by the gcc::jit::recording::vector_type::get_element_type method, in - jit-recording.c. */ + jit-recording.cc. */ gcc_jit_type * gcc_jit_vector_type_get_element_type (gcc_jit_vector_type *vector_type) @@ -637,7 +637,7 @@ gcc_jit_vector_type_get_element_type (gcc_jit_vector_type *vector_type) After error-checking, the real work is done by the gcc::jit::recording::type::unqualified method, in - jit-recording.c. */ + jit-recording.cc. */ gcc_jit_type * gcc_jit_type_unqualified (gcc_jit_type *type) @@ -651,7 +651,7 @@ gcc_jit_type_unqualified (gcc_jit_type *type) After error-checking, the real work is done by the gcc::jit::recording::type::dyn_cast_function_type method, in - jit-recording.c. */ + jit-recording.cc. */ gcc_jit_function_type * gcc_jit_type_dyncast_function_ptr_type (gcc_jit_type *type) @@ -670,7 +670,7 @@ gcc_jit_type_dyncast_function_ptr_type (gcc_jit_type *type) After error-checking, the real work is done by the gcc::jit::recording::function_type::get_return_type method, in - jit-recording.c. */ + jit-recording.cc. */ gcc_jit_type * gcc_jit_function_type_get_return_type (gcc_jit_function_type *function_type) @@ -683,7 +683,7 @@ gcc_jit_function_type_get_return_type (gcc_jit_function_type *function_type) After error-checking, the real work is done by the gcc::jit::recording::function_type::get_param_types method, in - jit-recording.c. */ + jit-recording.cc. */ size_t gcc_jit_function_type_get_param_count (gcc_jit_function_type *function_type) @@ -696,7 +696,7 @@ gcc_jit_function_type_get_param_count (gcc_jit_function_type *function_type) After error-checking, the real work is done by the gcc::jit::recording::function_type::get_param_types method, in - jit-recording.c. */ + jit-recording.cc. */ gcc_jit_type * gcc_jit_function_type_get_param_type (gcc_jit_function_type *function_type, @@ -718,7 +718,7 @@ gcc_jit_function_type_get_param_type (gcc_jit_function_type *function_type, After error-checking, the real work is done by the gcc::jit::recording::context::new_array_type method, in - jit-recording.c. */ + jit-recording.cc. */ gcc_jit_type * gcc_jit_context_new_array_type (gcc_jit_context *ctxt, @@ -743,7 +743,7 @@ gcc_jit_context_new_array_type (gcc_jit_context *ctxt, After error-checking, the real work is done by the gcc::jit::recording::context::new_field method, in - jit-recording.c. */ + jit-recording.cc. */ gcc_jit_field * gcc_jit_context_new_field (gcc_jit_context *ctxt, @@ -775,7 +775,7 @@ gcc_jit_context_new_field (gcc_jit_context *ctxt, After error-checking, the real work is done by the gcc::jit::recording::context::new_bitfield method, in - jit-recording.c. */ + jit-recording.cc. */ gcc_jit_field * gcc_jit_context_new_bitfield (gcc_jit_context *ctxt, @@ -826,7 +826,7 @@ gcc_jit_field_as_object (gcc_jit_field *field) After error-checking, the real work is done by the gcc::jit::recording::context::new_struct_type method, immediately followed by a "set_fields" call on the resulting - gcc::jit::recording::compound_type *, both in jit-recording.c */ + gcc::jit::recording::compound_type *, both in jit-recording.cc */ gcc_jit_struct * gcc_jit_context_new_struct_type (gcc_jit_context *ctxt, @@ -864,7 +864,7 @@ gcc_jit_context_new_struct_type (gcc_jit_context *ctxt, After error-checking, the real work is done by the gcc::jit::recording::context::new_struct_type method in - jit-recording.c. */ + jit-recording.cc. */ gcc_jit_struct * gcc_jit_context_new_opaque_struct (gcc_jit_context *ctxt, @@ -897,7 +897,7 @@ gcc_jit_struct_as_type (gcc_jit_struct *struct_type) After error-checking, the real work is done by the gcc::jit::recording::compound_type::set_fields method in - jit-recording.c. */ + jit-recording.cc. */ void gcc_jit_struct_set_fields (gcc_jit_struct *struct_type, @@ -940,7 +940,7 @@ gcc_jit_struct_set_fields (gcc_jit_struct *struct_type, After error-checking, the real work is done by the gcc::jit::recording::fields::get_field method in - jit-recording.c. */ + jit-recording.cc. */ extern gcc_jit_field * gcc_jit_struct_get_field (gcc_jit_struct *struct_type, size_t index) @@ -976,7 +976,7 @@ gcc_jit_struct_get_field_count (gcc_jit_struct *struct_type) After error-checking, the real work is done by the gcc::jit::recording::context::new_union_type method, immediately followed by a "set_fields" call on the resulting - gcc::jit::recording::compound_type *, both in jit-recording.c */ + gcc::jit::recording::compound_type *, both in jit-recording.cc */ gcc_jit_type * gcc_jit_context_new_union_type (gcc_jit_context *ctxt, @@ -1014,7 +1014,7 @@ gcc_jit_context_new_union_type (gcc_jit_context *ctxt, After error-checking, the real work is done by the gcc::jit::recording::context::new_function_ptr_type method, - in jit-recording.c */ + in jit-recording.cc */ gcc_jit_type * gcc_jit_context_new_function_ptr_type (gcc_jit_context *ctxt, @@ -1055,7 +1055,7 @@ gcc_jit_context_new_function_ptr_type (gcc_jit_context *ctxt, /* Public entrypoint. See description in libgccjit.h. After error-checking, the real work is done by the - gcc::jit::recording::context::new_param method, in jit-recording.c */ + gcc::jit::recording::context::new_param method, in jit-recording.cc */ gcc_jit_param * gcc_jit_context_new_param (gcc_jit_context *ctxt, @@ -1120,7 +1120,7 @@ gcc_jit_param_as_rvalue (gcc_jit_param *param) After error-checking, the real work is done by the gcc::jit::recording::context::new_function method, in - jit-recording.c. */ + jit-recording.cc. */ gcc_jit_function * gcc_jit_context_new_function (gcc_jit_context *ctxt, @@ -1201,7 +1201,7 @@ gcc_jit_context_new_function (gcc_jit_context *ctxt, After error-checking, the real work is done by the gcc::jit::recording::context::get_builtin_function method, in - jit-recording.c. */ + jit-recording.cc. */ gcc_jit_function * gcc_jit_context_get_builtin_function (gcc_jit_context *ctxt, @@ -1285,7 +1285,7 @@ gcc_jit_function_get_return_type (gcc_jit_function *func) After error-checking, the real work is done by the gcc::jit::recording::function::dump_to_dot method, in - jit-recording.c. */ + jit-recording.cc. */ void gcc_jit_function_dump_to_dot (gcc_jit_function *func, @@ -1303,7 +1303,7 @@ gcc_jit_function_dump_to_dot (gcc_jit_function *func, After error-checking, the real work is done by the gcc::jit::recording::function::new_block method, in - jit-recording.c. */ + jit-recording.cc. */ gcc_jit_block* gcc_jit_function_new_block (gcc_jit_function *func, @@ -1351,7 +1351,7 @@ gcc_jit_block_get_function (gcc_jit_block *block) After error-checking, the real work is done by the gcc::jit::recording::context::new_global method, in - jit-recording.c. */ + jit-recording.cc. */ gcc_jit_lvalue * gcc_jit_context_new_global (gcc_jit_context *ctxt, @@ -1777,7 +1777,7 @@ gcc_jit_global_set_initializer_rvalue (gcc_jit_lvalue *global, After error-checking, the real work is done by the gcc::jit::recording::global::set_initializer method, in - jit-recording.c. */ + jit-recording.cc. */ extern gcc_jit_lvalue * gcc_jit_global_set_initializer (gcc_jit_lvalue *global, @@ -1898,7 +1898,7 @@ gcc_jit_rvalue_get_type (gcc_jit_rvalue *rvalue) After error-checking, the real work is done by the gcc::jit::recording::context::new_rvalue_from_const method in - jit-recording.c. */ + jit-recording.cc. */ gcc_jit_rvalue * gcc_jit_context_new_rvalue_from_int (gcc_jit_context *ctxt, @@ -1917,7 +1917,7 @@ gcc_jit_context_new_rvalue_from_int (gcc_jit_context *ctxt, After error-checking, the real work is done by the gcc::jit::recording::context::new_rvalue_from_const method - in jit-recording.c. */ + in jit-recording.cc. */ gcc_jit_rvalue * gcc_jit_context_new_rvalue_from_long (gcc_jit_context *ctxt, @@ -1970,7 +1970,7 @@ gcc_jit_context_one (gcc_jit_context *ctxt, After error-checking, the real work is done by the gcc::jit::recording::context::new_rvalue_from_const method in - jit-recording.c. */ + jit-recording.cc. */ gcc_jit_rvalue * gcc_jit_context_new_rvalue_from_double (gcc_jit_context *ctxt, @@ -1989,7 +1989,7 @@ gcc_jit_context_new_rvalue_from_double (gcc_jit_context *ctxt, After error-checking, the real work is done by the gcc::jit::recording::context::new_rvalue_from_const method - in jit-recording.c. */ + in jit-recording.cc. */ gcc_jit_rvalue * gcc_jit_context_new_rvalue_from_ptr (gcc_jit_context *ctxt, @@ -2035,7 +2035,7 @@ gcc_jit_context_null (gcc_jit_context *ctxt, After error-checking, the real work is done by the gcc::jit::recording::context::new_string_literal method in - jit-recording.c. */ + jit-recording.cc. */ gcc_jit_rvalue * gcc_jit_context_new_string_literal (gcc_jit_context *ctxt, @@ -2052,7 +2052,7 @@ gcc_jit_context_new_string_literal (gcc_jit_context *ctxt, After error-checking, the real work is done by the gcc::jit::recording::context::new_unary_op method in - jit-recording.c. */ + jit-recording.cc. */ gcc_jit_rvalue * gcc_jit_context_new_unary_op (gcc_jit_context *ctxt, @@ -2098,7 +2098,7 @@ valid_binary_op_p (enum gcc_jit_binary_op op) After error-checking, the real work is done by the gcc::jit::recording::context::new_binary_op method in - jit-recording.c. */ + jit-recording.cc. */ gcc_jit_rvalue * gcc_jit_context_new_binary_op (gcc_jit_context *ctxt, @@ -2142,7 +2142,7 @@ gcc_jit_context_new_binary_op (gcc_jit_context *ctxt, After error-checking, the real work is done by the gcc::jit::recording::context::new_comparison method in - jit-recording.c. */ + jit-recording.cc. */ gcc_jit_rvalue * gcc_jit_context_new_comparison (gcc_jit_context *ctxt, @@ -2178,7 +2178,7 @@ gcc_jit_context_new_comparison (gcc_jit_context *ctxt, After error-checking, the real work is done by the gcc::jit::recording::context::new_call method in - jit-recording.c. */ + jit-recording.cc. */ gcc_jit_rvalue * gcc_jit_context_new_call (gcc_jit_context *ctxt, @@ -2251,7 +2251,7 @@ gcc_jit_context_new_call (gcc_jit_context *ctxt, After error-checking, the real work is done by the gcc::jit::recording::context::new_call_through_ptr method in - jit-recording.c. */ + jit-recording.cc. */ gcc_jit_rvalue * gcc_jit_context_new_call_through_ptr (gcc_jit_context *ctxt, @@ -2381,7 +2381,7 @@ is_valid_cast (gcc::jit::recording::type *src_type, /* Public entrypoint. See description in libgccjit.h. After error-checking, the real work is done by the - gcc::jit::recording::context::new_cast method in jit-recording.c. */ + gcc::jit::recording::context::new_cast method in jit-recording.cc. */ gcc_jit_rvalue * gcc_jit_context_new_cast (gcc_jit_context *ctxt, @@ -2409,7 +2409,7 @@ gcc_jit_context_new_cast (gcc_jit_context *ctxt, After error-checking, the real work is done by the gcc::jit::recording::context::new_array_access method in - jit-recording.c. */ + jit-recording.cc. */ extern gcc_jit_lvalue * gcc_jit_context_new_array_access (gcc_jit_context *ctxt, @@ -2456,7 +2456,7 @@ gcc_jit_object_get_context (gcc_jit_object *obj) After error-checking, the real work is done by the gcc::jit::recording::memento::get_debug_string method in - jit-recording.c. */ + jit-recording.cc. */ const char * gcc_jit_object_get_debug_string (gcc_jit_object *obj) @@ -2470,7 +2470,7 @@ gcc_jit_object_get_debug_string (gcc_jit_object *obj) After error-checking, the real work is done by the gcc::jit::recording::lvalue::access_field method in - jit-recording.c. */ + jit-recording.cc. */ gcc_jit_lvalue * gcc_jit_lvalue_access_field (gcc_jit_lvalue *struct_, @@ -2502,7 +2502,7 @@ gcc_jit_lvalue_access_field (gcc_jit_lvalue *struct_, After error-checking, the real work is done by the gcc::jit::recording::rvalue::access_field method in - jit-recording.c. */ + jit-recording.cc. */ gcc_jit_rvalue * gcc_jit_rvalue_access_field (gcc_jit_rvalue *struct_, @@ -2534,7 +2534,7 @@ gcc_jit_rvalue_access_field (gcc_jit_rvalue *struct_, After error-checking, the real work is done by the gcc::jit::recording::rvalue::deference_field method in - jit-recording.c. */ + jit-recording.cc. */ gcc_jit_lvalue * gcc_jit_rvalue_dereference_field (gcc_jit_rvalue *ptr, @@ -2572,7 +2572,7 @@ gcc_jit_rvalue_dereference_field (gcc_jit_rvalue *ptr, After error-checking, the real work is done by the gcc::jit::recording::rvalue::deference method in - jit-recording.c. */ + jit-recording.cc. */ gcc_jit_lvalue * gcc_jit_rvalue_dereference (gcc_jit_rvalue *rvalue, @@ -2605,7 +2605,7 @@ gcc_jit_rvalue_dereference (gcc_jit_rvalue *rvalue, /* Public entrypoint. See description in libgccjit.h. After error-checking, the real work is done by the - gcc::jit::recording::lvalue::get_address method in jit-recording.c. */ + gcc::jit::recording::lvalue::get_address method in jit-recording.cc. */ gcc_jit_rvalue * gcc_jit_lvalue_get_address (gcc_jit_lvalue *lvalue, @@ -2621,7 +2621,7 @@ gcc_jit_lvalue_get_address (gcc_jit_lvalue *lvalue, /* Public entrypoint. See description in libgccjit.h. After error-checking, the real work is done by the - gcc::jit::recording::lvalue::set_tls_model method in jit-recording.c. */ + gcc::jit::recording::lvalue::set_tls_model method in jit-recording.cc. */ void gcc_jit_lvalue_set_tls_model (gcc_jit_lvalue *lvalue, @@ -2639,7 +2639,7 @@ gcc_jit_lvalue_set_tls_model (gcc_jit_lvalue *lvalue, /* Public entrypoint. See description in libgccjit.h. After error-checking, the real work is done by the - gcc::jit::recording::lvalue::set_link_section method in jit-recording.c. */ + gcc::jit::recording::lvalue::set_link_section method in jit-recording.cc. */ void gcc_jit_lvalue_set_link_section (gcc_jit_lvalue *lvalue, @@ -2652,7 +2652,7 @@ gcc_jit_lvalue_set_link_section (gcc_jit_lvalue *lvalue, /* Public entrypoint. See description in libgccjit.h. After error-checking, the real work is done by the - gcc::jit::recording::function::new_local method in jit-recording.c. */ + gcc::jit::recording::function::new_local method in jit-recording.cc. */ gcc_jit_lvalue * gcc_jit_function_new_local (gcc_jit_function *func, @@ -2687,7 +2687,7 @@ gcc_jit_function_new_local (gcc_jit_function *func, /* Public entrypoint. See description in libgccjit.h. After error-checking, the real work is done by the - gcc::jit::recording::block::add_eval method in jit-recording.c. */ + gcc::jit::recording::block::add_eval method in jit-recording.cc. */ void gcc_jit_block_add_eval (gcc_jit_block *block, @@ -2714,7 +2714,7 @@ gcc_jit_block_add_eval (gcc_jit_block *block, After error-checking, the real work is done by the gcc::jit::recording::block::add_assignment method in - jit-recording.c. */ + jit-recording.cc. */ void gcc_jit_block_add_assignment (gcc_jit_block *block, @@ -2754,7 +2754,7 @@ gcc_jit_block_add_assignment (gcc_jit_block *block, After error-checking, the real work is done by the gcc::jit::recording::block::add_assignment_op method in - jit-recording.c. */ + jit-recording.cc. */ void gcc_jit_block_add_assignment_op (gcc_jit_block *block, @@ -2812,7 +2812,7 @@ is_bool (gcc_jit_rvalue *boolval) After error-checking, the real work is done by the gcc::jit::recording::block::end_with_conditional method in - jit-recording.c. */ + jit-recording.cc. */ void gcc_jit_block_end_with_conditional (gcc_jit_block *block, @@ -2868,7 +2868,7 @@ gcc_jit_block_end_with_conditional (gcc_jit_block *block, After error-checking, the real work is done by the gcc::jit::recording::block::add_comment method in - jit-recording.c. */ + jit-recording.cc. */ void gcc_jit_block_add_comment (gcc_jit_block *block, @@ -2888,7 +2888,7 @@ gcc_jit_block_add_comment (gcc_jit_block *block, After error-checking, the real work is done by the gcc::jit::recording::block::end_with_jump method in - jit-recording.c. */ + jit-recording.cc. */ void gcc_jit_block_end_with_jump (gcc_jit_block *block, @@ -2918,7 +2918,7 @@ gcc_jit_block_end_with_jump (gcc_jit_block *block, After error-checking, the real work is done by the gcc::jit::recording::block::end_with_return method in - jit-recording.c. */ + jit-recording.cc. */ void gcc_jit_block_end_with_return (gcc_jit_block *block, @@ -2957,7 +2957,7 @@ gcc_jit_block_end_with_return (gcc_jit_block *block, After error-checking, the real work is done by the gcc::jit::recording::block::end_with_return method in - jit-recording.c. */ + jit-recording.cc. */ void gcc_jit_block_end_with_void_return (gcc_jit_block *block, @@ -2983,7 +2983,7 @@ gcc_jit_block_end_with_void_return (gcc_jit_block *block, After error-checking, the real work is done by the gcc::jit::recording::context::new_case method in - jit-recording.c. */ + jit-recording.cc. */ gcc_jit_case * gcc_jit_context_new_case (gcc_jit_context *ctxt, @@ -3202,7 +3202,7 @@ case_range_validator::case_range_validator (gcc::jit::recording::context *ctxt, ranges of cases we've already seen. Return true if everything is OK. Return false and emit an error if there is an overlap. - Compare with c-family/c-common.c:c_add_case_label. */ + Compare with c-family/c-common.cc:c_add_case_label. */ bool case_range_validator::validate (gcc_jit_case *case_, @@ -3268,7 +3268,7 @@ case_range_validator::validate (gcc_jit_case *case_, return true; } -/* Compare with c-family/c-common.c:case_compare, which acts on tree +/* Compare with c-family/c-common.cc:case_compare, which acts on tree nodes, rather than rvalue *. Comparator for case label values. K1 and K2 must be constant integer @@ -3302,7 +3302,7 @@ case_range_validator::get_wide_int (gcc::jit::recording::rvalue *k) After error-checking, the real work is done by the gcc::jit::recording::block::end_with_switch method in - jit-recording.c. */ + jit-recording.cc. */ void gcc_jit_block_end_with_switch (gcc_jit_block *block, @@ -3363,7 +3363,7 @@ gcc_jit_block_end_with_switch (gcc_jit_block *block, After error-checking, the real work is done by the gcc::jit::recording::context::set_str_option method in - jit-recording.c. */ + jit-recording.cc. */ void gcc_jit_context_set_str_option (gcc_jit_context *ctxt, @@ -3382,7 +3382,7 @@ gcc_jit_context_set_str_option (gcc_jit_context *ctxt, After error-checking, the real work is done by the gcc::jit::recording::context::set_int_option method in - jit-recording.c. */ + jit-recording.cc. */ void gcc_jit_context_set_int_option (gcc_jit_context *ctxt, @@ -3400,7 +3400,7 @@ gcc_jit_context_set_int_option (gcc_jit_context *ctxt, After error-checking, the real work is done by the gcc::jit::recording::context::set_bool_option method in - jit-recording.c. */ + jit-recording.cc. */ void gcc_jit_context_set_bool_option (gcc_jit_context *ctxt, @@ -3418,7 +3418,7 @@ gcc_jit_context_set_bool_option (gcc_jit_context *ctxt, After error-checking, the real work is done by the gcc::jit::recording::context::set_inner_bool_option method in - jit-recording.c. */ + jit-recording.cc. */ void gcc_jit_context_set_bool_allow_unreachable_blocks (gcc_jit_context *ctxt, @@ -3435,7 +3435,7 @@ gcc_jit_context_set_bool_allow_unreachable_blocks (gcc_jit_context *ctxt, After error-checking, the real work is done by the gcc::jit::recording::context::set_inner_bool_option method in - jit-recording.c. */ + jit-recording.cc. */ extern void gcc_jit_context_set_bool_use_external_driver (gcc_jit_context *ctxt, @@ -3452,7 +3452,7 @@ gcc_jit_context_set_bool_use_external_driver (gcc_jit_context *ctxt, After error-checking, the real work is done by the gcc::jit::recording::context::add_command_line_option method in - jit-recording.c. */ + jit-recording.cc. */ void gcc_jit_context_add_command_line_option (gcc_jit_context *ctxt, @@ -3471,7 +3471,7 @@ gcc_jit_context_add_command_line_option (gcc_jit_context *ctxt, The real work is done by the gcc::jit::recording::context::add_driver_option method in - jit-recording.c. */ + jit-recording.cc. */ void gcc_jit_context_add_driver_option (gcc_jit_context *ctxt, @@ -3490,7 +3490,7 @@ gcc_jit_context_add_driver_option (gcc_jit_context *ctxt, After error-checking, the real work is done by the gcc::jit::recording::context::enable_dump method in - jit-recording.c. */ + jit-recording.cc. */ void gcc_jit_context_enable_dump (gcc_jit_context *ctxt, @@ -3509,7 +3509,7 @@ gcc_jit_context_enable_dump (gcc_jit_context *ctxt, After error-checking, the real work is done by the gcc::jit::recording::context::compile method in - jit-recording.c. */ + jit-recording.cc. */ gcc_jit_result * gcc_jit_context_compile (gcc_jit_context *ctxt) @@ -3532,7 +3532,7 @@ gcc_jit_context_compile (gcc_jit_context *ctxt) After error-checking, the real work is done by the gcc::jit::recording::context::compile_to_file method in - jit-recording.c. */ + jit-recording.cc. */ void gcc_jit_context_compile_to_file (gcc_jit_context *ctxt, @@ -3561,7 +3561,7 @@ gcc_jit_context_compile_to_file (gcc_jit_context *ctxt, After error-checking, the real work is done by the gcc::jit::recording::context::dump_to_file method in - jit-recording.c. */ + jit-recording.cc. */ void gcc_jit_context_dump_to_file (gcc_jit_context *ctxt, @@ -3599,7 +3599,7 @@ gcc_jit_context_set_logfile (gcc_jit_context *ctxt, After error-checking, the real work is done by the gcc::jit::recording::context::dump_reproducer_to_file method in - jit-recording.c. */ + jit-recording.cc. */ void gcc_jit_context_dump_reproducer_to_file (gcc_jit_context *ctxt, @@ -3615,7 +3615,7 @@ gcc_jit_context_dump_reproducer_to_file (gcc_jit_context *ctxt, After error-checking, the real work is done by the gcc::jit::recording::context::get_first_error method in - jit-recording.c. */ + jit-recording.cc. */ const char * gcc_jit_context_get_first_error (gcc_jit_context *ctxt) @@ -3630,7 +3630,7 @@ gcc_jit_context_get_first_error (gcc_jit_context *ctxt) After error-checking, the real work is done by the gcc::jit::recording::context::get_last_error method in - jit-recording.c. */ + jit-recording.cc. */ const char * gcc_jit_context_get_last_error (gcc_jit_context *ctxt) @@ -3643,7 +3643,7 @@ gcc_jit_context_get_last_error (gcc_jit_context *ctxt) /* Public entrypoint. See description in libgccjit.h. After error-checking, the real work is done by the - gcc::jit::result::get_code method in jit-result.c. */ + gcc::jit::result::get_code method in jit-result.cc. */ void * gcc_jit_result_get_code (gcc_jit_result *result, @@ -3663,7 +3663,7 @@ gcc_jit_result_get_code (gcc_jit_result *result, /* Public entrypoint. See description in libgccjit.h. After error-checking, the real work is done by the - gcc::jit::result::get_global method in jit-result.c. */ + gcc::jit::result::get_global method in jit-result.cc. */ void * gcc_jit_result_get_global (gcc_jit_result *result, @@ -3682,7 +3682,7 @@ gcc_jit_result_get_global (gcc_jit_result *result, /* Public entrypoint. See description in libgccjit.h. After error-checking, this is essentially a wrapper around the - destructor for gcc::jit::result in jit-result.c. */ + destructor for gcc::jit::result in jit-result.cc. */ void gcc_jit_result_release (gcc_jit_result *result) @@ -3821,7 +3821,7 @@ gcc_jit_rvalue_set_bool_require_tail_call (gcc_jit_rvalue *rvalue, After error-checking, the real work is done by the gcc::jit::recording::type::get_aligned method, in - jit-recording.c. */ + jit-recording.cc. */ gcc_jit_type * gcc_jit_type_get_aligned (gcc_jit_type *type, @@ -3846,7 +3846,7 @@ gcc_jit_type_get_aligned (gcc_jit_type *type, After error-checking, the real work is done by the gcc::jit::recording::type::get_vector method, in - jit-recording.c. */ + jit-recording.cc. */ gcc_jit_type * gcc_jit_type_get_vector (gcc_jit_type *type, size_t num_units) @@ -3874,7 +3874,7 @@ gcc_jit_type_get_vector (gcc_jit_type *type, size_t num_units) After error-checking, the real work is done by the gcc::jit::recording::function::get_address method, in - jit-recording.c. */ + jit-recording.cc. */ gcc_jit_rvalue * gcc_jit_function_get_address (gcc_jit_function *fn, @@ -3894,7 +3894,7 @@ gcc_jit_function_get_address (gcc_jit_function *fn, After error-checking, the real work is done by the gcc::jit::recording::context::new_rvalue_from_vector method, in - jit-recording.c. */ + jit-recording.cc. */ extern gcc_jit_rvalue * gcc_jit_context_new_rvalue_from_vector (gcc_jit_context *ctxt, @@ -4000,7 +4000,7 @@ gcc_jit_version_patchlevel (void) After error-checking, the real work is done by the gcc::jit::recording::block::add_extended_asm, in - jit-recording.c. */ + jit-recording.cc. */ gcc_jit_extended_asm * gcc_jit_block_add_extended_asm (gcc_jit_block *block, @@ -4020,7 +4020,7 @@ gcc_jit_block_add_extended_asm (gcc_jit_block *block, After error-checking, the real work is done by the gcc::jit::recording::block::end_with_extended_asm_goto, in - jit-recording.c. */ + jit-recording.cc. */ gcc_jit_extended_asm * gcc_jit_block_end_with_extended_asm_goto (gcc_jit_block *block, @@ -4065,7 +4065,7 @@ gcc_jit_extended_asm_as_object (gcc_jit_extended_asm *ext_asm) After error-checking, the real work is done by the gcc::jit::recording::extended_asm::set_volatile_flag, in - jit-recording.c. */ + jit-recording.cc. */ void gcc_jit_extended_asm_set_volatile_flag (gcc_jit_extended_asm *ext_asm, @@ -4079,7 +4079,7 @@ gcc_jit_extended_asm_set_volatile_flag (gcc_jit_extended_asm *ext_asm, After error-checking, the real work is done by the gcc::jit::recording::extended_asm::set_inline_flag, in - jit-recording.c. */ + jit-recording.cc. */ void gcc_jit_extended_asm_set_inline_flag (gcc_jit_extended_asm *ext_asm, @@ -4093,7 +4093,7 @@ gcc_jit_extended_asm_set_inline_flag (gcc_jit_extended_asm *ext_asm, After error-checking, the real work is done by the gcc::jit::recording::extended_asm::add_output_operand, in - jit-recording.c. */ + jit-recording.cc. */ void gcc_jit_extended_asm_add_output_operand (gcc_jit_extended_asm *ext_asm, @@ -4117,7 +4117,7 @@ gcc_jit_extended_asm_add_output_operand (gcc_jit_extended_asm *ext_asm, After error-checking, the real work is done by the gcc::jit::recording::extended_asm::add_input_operand, in - jit-recording.c. */ + jit-recording.cc. */ extern void gcc_jit_extended_asm_add_input_operand (gcc_jit_extended_asm *ext_asm, @@ -4139,7 +4139,7 @@ gcc_jit_extended_asm_add_input_operand (gcc_jit_extended_asm *ext_asm, After error-checking, the real work is done by the gcc::jit::recording::extended_asm::add_clobber, in - jit-recording.c. */ + jit-recording.cc. */ void gcc_jit_extended_asm_add_clobber (gcc_jit_extended_asm *ext_asm, @@ -4157,7 +4157,7 @@ gcc_jit_extended_asm_add_clobber (gcc_jit_extended_asm *ext_asm, After error-checking, the real work is done by the gcc::jit::recording::context::add_top_level_asm, in - jit-recording.c. */ + jit-recording.cc. */ void gcc_jit_context_add_top_level_asm (gcc_jit_context *ctxt, diff --git a/gcc/jit/notes.txt b/gcc/jit/notes.txt index 36e05cb..ad0d957 100644 --- a/gcc/jit/notes.txt +++ b/gcc/jit/notes.txt @@ -6,10 +6,10 @@ Client Code . Generated . libgccjit.so ──────────────────────────> . . . . │ . . . . V . . - . . ──> libgccjit.c . + . . ──> libgccjit.cc . . . │ (error-checking). . . │ . - . . ──> jit-recording.c + . . ──> jit-recording.cc . . (record API calls) . . <─────── . . . │ . . @@ -36,7 +36,7 @@ Client Code . Generated . libgccjit.so . . . │ . ..........................................│..................VVVVVVVVVVVVV... . . . │ . No GC in here - . . . │ jit-playback.c + . . . │ jit-playback.cc . . . │ (playback of API calls) . . . ───────────────> creation of functions, . . . . types, expression trees diff --git a/gcc/langhooks.cc b/gcc/langhooks.cc index e15e412..df97067 100644 --- a/gcc/langhooks.cc +++ b/gcc/langhooks.cc @@ -104,7 +104,7 @@ lhd_post_options (const char ** ARG_UNUSED (pfilename)) return false; } -/* Called from by print-tree.c. */ +/* Called from by print-tree.cc. */ void lhd_print_tree_nothing (FILE * ARG_UNUSED (file), diff --git a/gcc/langhooks.h b/gcc/langhooks.h index 4306a09..0eec1b0 100644 --- a/gcc/langhooks.h +++ b/gcc/langhooks.h @@ -36,7 +36,7 @@ enum classify_record class substring_loc; -/* The following hooks are documented in langhooks.c. Must not be +/* The following hooks are documented in langhooks.cc. Must not be NULL. */ struct lang_hooks_for_tree_inlining @@ -44,7 +44,7 @@ struct lang_hooks_for_tree_inlining bool (*var_mod_type_p) (tree, tree); }; -/* The following hooks are used by tree-dump.c. */ +/* The following hooks are used by tree-dump.cc. */ struct lang_hooks_for_tree_dump { @@ -113,7 +113,7 @@ struct lang_hooks_for_types in C. The default hook ignores the declaration. */ void (*register_builtin_type) (tree, const char *); - /* This routine is called in tree.c to print an error message for + /* This routine is called in tree.cc to print an error message for invalid use of an incomplete type. VALUE is the expression that was used (or 0 if that isn't known) and TYPE is the type that was invalid. LOC is the location of the use. */ @@ -166,7 +166,7 @@ struct lang_hooks_for_types /* Returns the tree that represents the underlying data type used to implement the enumeration. The default implementation will just use - type_for_size. Used in dwarf2out.c to add a DW_AT_type base type + type_for_size. Used in dwarf2out.cc to add a DW_AT_type base type reference to a DW_TAG_enumeration. */ tree (*enum_underlying_base_type) (const_tree); @@ -521,7 +521,7 @@ struct lang_hooks HOST_WIDE_INT (*to_target_charset) (HOST_WIDE_INT); /* Pointers to machine-independent attribute tables, for front ends - using attribs.c. If one is NULL, it is ignored. Respectively, a + using attribs.cc. If one is NULL, it is ignored. Respectively, a table of attributes specific to the language, a table of attributes common to two or more languages (to allow easy sharing), and a table of attributes for checking formats. */ @@ -631,7 +631,7 @@ struct lang_hooks void (*finalize_early_debug) (void); /* Whenever you add entries here, make sure you adjust langhooks-def.h - and langhooks.c accordingly. */ + and langhooks.cc accordingly. */ }; /* Each front end provides its own. */ diff --git a/gcc/libfuncs.h b/gcc/libfuncs.h index b6cf3e0..354be0b 100644 --- a/gcc/libfuncs.h +++ b/gcc/libfuncs.h @@ -78,7 +78,7 @@ extern struct target_libfuncs *this_target_libfuncs; (libfunc_table[LTI_unwind_sjlj_unregister]) #define synchronize_libfunc (libfunc_table[LTI_synchronize]) -/* In explow.c */ +/* In explow.cc */ extern void set_stack_check_libfunc (const char *); #endif /* GCC_LIBFUNCS_H */ diff --git a/gcc/loop-doloop.cc b/gcc/loop-doloop.cc index 8ef94f9..30b45c8 100644 --- a/gcc/loop-doloop.cc +++ b/gcc/loop-doloop.cc @@ -91,7 +91,7 @@ doloop_condition_get (rtx_insn *doloop_pat) (additional clobbers and uses)]) The branch must be the first entry of the parallel (also required - by jump.c), and the second entry of the parallel must be a set of + by jump.cc), and the second entry of the parallel must be a set of the loop counter register. Some targets (IA-64) wrap the set of the loop counter in an if_then_else too. diff --git a/gcc/loop-init.cc b/gcc/loop-init.cc index db386e0..1e4f6cf 100644 --- a/gcc/loop-init.cc +++ b/gcc/loop-init.cc @@ -331,7 +331,7 @@ fix_loop_structure (bitmap changed_bbs) return number_of_loops (cfun) - old_nloops; } -/* The RTL loop superpass. The actual passes are subpasses. See passes.c for +/* The RTL loop superpass. The actual passes are subpasses. See passes.cc for more on that. */ namespace { diff --git a/gcc/loop-invariant.cc b/gcc/loop-invariant.cc index 783d8ba..f324854 100644 --- a/gcc/loop-invariant.cc +++ b/gcc/loop-invariant.cc @@ -20,7 +20,7 @@ along with GCC; see the file COPYING3. If not see /* This implements the loop invariant motion pass. It is very simple (no calls, no loads/stores, etc.). This should be sufficient to cleanup things like address arithmetics -- other more complicated invariants should - be eliminated on GIMPLE either in tree-ssa-loop-im.c or in tree-ssa-pre.c. + be eliminated on GIMPLE either in tree-ssa-loop-im.cc or in tree-ssa-pre.cc. We proceed loop by loop -- it is simpler than trying to handle things globally and should not lose much. First we inspect all sets inside loop diff --git a/gcc/lower-subreg.h b/gcc/lower-subreg.h index 065f854..72db492 100644 --- a/gcc/lower-subreg.h +++ b/gcc/lower-subreg.h @@ -1,4 +1,4 @@ -/* Target-dependent costs for lower-subreg.c. +/* Target-dependent costs for lower-subreg.cc. Copyright (C) 2012-2022 Free Software Foundation, Inc. This file is part of GCC. diff --git a/gcc/lra-constraints.cc b/gcc/lra-constraints.cc index 9a333a8..e3d1d51 100644 --- a/gcc/lra-constraints.cc +++ b/gcc/lra-constraints.cc @@ -4457,7 +4457,7 @@ curr_insn_transform (bool check_only_p) /* Generate reloads for different output and matched input registers. This is the easiest way to avoid creation of non-existing register conflicts in - lra-lives.c. */ + lra-lives.cc. */ match_reload (i, goal_alt_matched[i], outputs, goal_alt[i], &before, &after, TRUE); } diff --git a/gcc/lra-int.h b/gcc/lra-int.h index 67fd18b..8ad0b4a 100644 --- a/gcc/lra-int.h +++ b/gcc/lra-int.h @@ -100,14 +100,14 @@ public: int val; /* Offset from relative eliminate register to pesudo reg. */ poly_int64 offset; - /* These members are set up in lra-lives.c and updated in - lra-coalesce.c. */ + /* These members are set up in lra-lives.cc and updated in + lra-coalesce.cc. */ /* The biggest size mode in which each pseudo reg is referred in whole function (possibly via subreg). */ machine_mode biggest_mode; /* Live ranges of the pseudo. */ lra_live_range_t live_ranges; - /* This member is set up in lra-lives.c for subsequent + /* This member is set up in lra-lives.cc for subsequent assignments. */ lra_copy_t copies; }; @@ -119,7 +119,7 @@ extern HARD_REG_SET hard_regs_spilled_into; /* Static info about each insn operand (common for all insns with the same ICODE). Warning: if the structure definition is changed, the - initializer for debug_operand_data in lra.c should be changed + initializer for debug_operand_data in lra.cc should be changed too. */ struct lra_operand_data { @@ -164,7 +164,7 @@ struct lra_insn_reg internal insn info. It exists in at most one exemplar for each non-negative ICODE. There is only one exception. Each asm insn has own structure. Warning: if the structure definition is changed, - the initializer for debug_insn_static_data in lra.c should be + the initializer for debug_insn_static_data in lra.cc should be changed too. */ struct lra_static_insn_data { @@ -269,7 +269,7 @@ typedef class lra_insn_recog_data *lra_insn_recog_data_t; #error wrong LRA_MAX_REMATERIALIZATION_PASSES value #endif -/* lra.c: */ +/* lra.cc: */ extern FILE *lra_dump_file; @@ -330,7 +330,7 @@ extern bitmap_head lra_split_regs; extern bitmap_head lra_subreg_reload_pseudos; extern bitmap_head lra_optional_reload_pseudos; -/* lra-constraints.c: */ +/* lra-constraints.cc: */ extern void lra_init_equiv (void); extern int lra_constraint_offset (int, machine_mode); @@ -347,7 +347,7 @@ extern bool spill_hard_reg_in_range (int, enum reg_class, rtx_insn *, rtx_insn * extern void lra_inheritance (void); extern bool lra_undo_inheritance (void); -/* lra-lives.c: */ +/* lra-lives.cc: */ extern int lra_live_max_point; extern int *lra_point_freq; @@ -372,7 +372,7 @@ extern void lra_live_ranges_init (void); extern void lra_live_ranges_finish (void); extern void lra_setup_reload_pseudo_preferenced_hard_reg (int, int, int); -/* lra-assigns.c: */ +/* lra-assigns.cc: */ extern int lra_assignment_iter; extern int lra_assignment_iter_after_spill; @@ -380,19 +380,19 @@ extern void lra_setup_reg_renumber (int, int, bool); extern bool lra_assign (bool &); extern bool lra_split_hard_reg_for (void); -/* lra-coalesce.c: */ +/* lra-coalesce.cc: */ extern int lra_coalesce_iter; extern bool lra_coalesce (void); -/* lra-spills.c: */ +/* lra-spills.cc: */ extern bool lra_need_for_scratch_reg_p (void); extern bool lra_need_for_spills_p (void); extern void lra_spill (void); extern void lra_final_code_change (void); -/* lra-remat.c: */ +/* lra-remat.cc: */ extern int lra_rematerialization_iter; extern bool lra_remat (void); diff --git a/gcc/lra-spills.cc b/gcc/lra-spills.cc index feb6b33..4ddbe47 100644 --- a/gcc/lra-spills.cc +++ b/gcc/lra-spills.cc @@ -791,7 +791,7 @@ lra_final_code_change (void) if (GET_CODE (pat) == USE && XEXP (pat, 0) == const1_rtx) { /* Remove markers to eliminate critical edges for jump insn - output reloads (see code in ira.c::ira). */ + output reloads (see code in ira.cc::ira). */ lra_invalidate_insn_data (insn); delete_insn (insn); continue; diff --git a/gcc/lra.cc b/gcc/lra.cc index 55ba970..028d26a 100644 --- a/gcc/lra.cc +++ b/gcc/lra.cc @@ -1901,7 +1901,7 @@ lra_process_new_insns (rtx_insn *insn, rtx_insn *before, rtx_insn *after, FOR_EACH_EDGE (e, ei, BLOCK_FOR_INSN (insn)->succs) if (e->dest != EXIT_BLOCK_PTR_FOR_FN (cfun)) { - /* We already made the edge no-critical in ira.c::ira */ + /* We already made the edge no-critical in ira.cc::ira */ lra_assert (!EDGE_CRITICAL_P (e)); rtx_insn *curr, *tmp = BB_HEAD (e->dest); if (LABEL_P (tmp)) diff --git a/gcc/lto-compress.h b/gcc/lto-compress.h index 5cd79c8..3a3e72b 100644 --- a/gcc/lto-compress.h +++ b/gcc/lto-compress.h @@ -24,7 +24,7 @@ along with GCC; see the file COPYING3. If not see struct lto_compression_stream; -/* In lto-compress.c. */ +/* In lto-compress.cc. */ extern struct lto_compression_stream *lto_start_compression (void (*callback) (const char *, unsigned, void *), void *opaque); diff --git a/gcc/lto-streamer-out.cc b/gcc/lto-streamer-out.cc index f9dc727..471f35c 100644 --- a/gcc/lto-streamer-out.cc +++ b/gcc/lto-streamer-out.cc @@ -644,7 +644,7 @@ private: /* Return true if type can not be merged with structurally same tree in other translation unit. During stream out this information is propagated to all trees referring to T and they are not streamed with additional - information needed by the tree merging in lto-common.c (in particular, + information needed by the tree merging in lto-common.cc (in particular, scc hash codes are not streamed). TRANSLATION_UNIT_DECL is handled specially since references to it does @@ -1116,7 +1116,7 @@ DFS::DFS_write_tree_body (struct output_block *ob, /* Do not follow BLOCK_NONLOCALIZED_VARS. We cannot handle debug information for early inlined BLOCKs so drop it on the floor instead - of ICEing in dwarf2out.c. */ + of ICEing in dwarf2out.cc. */ /* BLOCK_FRAGMENT_ORIGIN and BLOCK_FRAGMENT_CHAIN is not live at LTO streaming time. */ @@ -2960,7 +2960,7 @@ write_symbol (struct streamer_tree_cache_d *cache, name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (t)); - /* This behaves like assemble_name_raw in varasm.c, performing the + /* This behaves like assemble_name_raw in varasm.cc, performing the same name manipulations that ASM_OUTPUT_LABELREF does. */ name = IDENTIFIER_POINTER ((*targetm.asm_out.mangle_assembler_name) (name)); diff --git a/gcc/lto-streamer.h b/gcc/lto-streamer.h index d3a6448..597e9e4 100644 --- a/gcc/lto-streamer.h +++ b/gcc/lto-streamer.h @@ -79,7 +79,7 @@ along with GCC; see the file COPYING3. If not see put out in a post order traversial of the tree. Siblings are output as lists terminated by a 0. The set of fields matches the fields - defined in except.c. + defined in except.cc. last_basic_block - in uleb128 form. @@ -203,7 +203,7 @@ enum LTO_tags own section type to store its summary information. When adding a new section type, you must also extend the - LTO_SECTION_NAME array in lto-section-in.c. */ + LTO_SECTION_NAME array in lto-section-in.cc. */ enum lto_section_type { LTO_section_decls = 0, @@ -760,7 +760,7 @@ public: }; -/* In lto-section-in.c */ +/* In lto-section-in.cc */ extern class lto_input_block * lto_create_simple_input_block ( struct lto_file_decl_data *, enum lto_section_type, const char **, size_t *); @@ -805,7 +805,7 @@ extern void lto_value_range_error (const char *, HOST_WIDE_INT, HOST_WIDE_INT, HOST_WIDE_INT) ATTRIBUTE_NORETURN; -/* In lto-section-out.c */ +/* In lto-section-out.cc */ extern void lto_begin_section (const char *, bool); extern void lto_end_section (void); extern void lto_write_data (const void *, unsigned int); @@ -824,7 +824,7 @@ extern void lto_record_function_out_decl_state (tree, extern void lto_append_block (struct lto_output_stream *); -/* In lto-streamer.c. */ +/* In lto-streamer.cc. */ /* Set when streaming LTO for offloading compiler. */ extern bool lto_stream_offload_p; @@ -838,7 +838,7 @@ extern bool gate_lto_out (void); extern void lto_check_version (int, int, const char *); extern void lto_streamer_hooks_init (void); -/* In lto-streamer-in.c */ +/* In lto-streamer-in.cc */ extern void lto_input_cgraph (struct lto_file_decl_data *, const char *); extern void lto_reader_init (void); extern void lto_free_file_name_hash (void); @@ -870,7 +870,7 @@ tree lto_input_tree (class lto_input_block *, class data_in *); tree stream_read_tree_ref (class lto_input_block *, class data_in *); -/* In lto-streamer-out.c */ +/* In lto-streamer-out.cc */ extern void lto_register_decl_definition (tree, struct lto_file_decl_data *); extern struct output_block *create_output_block (enum lto_section_type); extern void destroy_output_block (struct output_block *); @@ -899,7 +899,7 @@ void lto_output_init_mode_table (void); void lto_prepare_function_for_streaming (cgraph_node *); -/* In lto-cgraph.c */ +/* In lto-cgraph.cc */ extern bool asm_nodes_output; lto_symtab_encoder_t lto_symtab_encoder_new (bool); int lto_symtab_encoder_encode (lto_symtab_encoder_t, symtab_node *); @@ -929,13 +929,13 @@ bool reachable_from_this_partition_p (struct cgraph_node *, lto_symtab_encoder_t compute_ltrans_boundary (lto_symtab_encoder_t encoder); void select_what_to_stream (void); -/* In omp-general.c. */ +/* In omp-general.cc. */ void omp_lto_output_declare_variant_alt (lto_simple_output_block *, cgraph_node *, lto_symtab_encoder_t); void omp_lto_input_declare_variant_alt (lto_input_block *, cgraph_node *, vec); -/* In options-save.c. */ +/* In options-save.cc. */ void cl_target_option_stream_out (struct output_block *, struct bitpack_d *, struct cl_target_option *); @@ -951,7 +951,7 @@ void cl_optimization_stream_in (class data_in *, -/* In lto-opts.c. */ +/* In lto-opts.cc. */ extern void lto_write_options (void); diff --git a/gcc/lto-wrapper.cc b/gcc/lto-wrapper.cc index e270928..6027fd9 100644 --- a/gcc/lto-wrapper.cc +++ b/gcc/lto-wrapper.cc @@ -690,7 +690,7 @@ append_compiler_options (obstack *argv_obstack, vec opts) { cl_decoded_option *option = &opts[j]; - /* File options have been properly filtered by lto-opts.c. */ + /* File options have been properly filtered by lto-opts.cc. */ switch (option->opt_index) { /* Drop arguments that we want to take from the link line. */ diff --git a/gcc/lto/config-lang.in b/gcc/lto/config-lang.in index 5c7b63d..8525519 100644 --- a/gcc/lto/config-lang.in +++ b/gcc/lto/config-lang.in @@ -20,7 +20,7 @@ language="lto" compilers="lto1\$(exeext)" -gtfiles="\$(srcdir)/lto/lto-tree.h \$(srcdir)/lto/lto-lang.c \$(srcdir)/lto/lto.c \$(srcdir)/lto/lto.h \$(srcdir)/lto/lto-common.h \$(srcdir)/lto/lto-common.c \$(srcdir)/lto/lto-dump.c" +gtfiles="\$(srcdir)/lto/lto-tree.h \$(srcdir)/lto/lto-lang.cc \$(srcdir)/lto/lto.cc \$(srcdir)/lto/lto.h \$(srcdir)/lto/lto-common.h \$(srcdir)/lto/lto-common.cc \$(srcdir)/lto/lto-dump.cc" # LTO is a special front end. From a user's perspective it is not # really a language, but a middle end feature. However, the GIMPLE diff --git a/gcc/lto/lang-specs.h b/gcc/lto/lang-specs.h index a751f82..53431bd 100644 --- a/gcc/lto/lang-specs.h +++ b/gcc/lto/lang-specs.h @@ -18,7 +18,7 @@ You should have received a copy of the GNU General Public License along with GCC; see the file COPYING3. If not see . */ -/* LTO contributions to the "compilers" array in gcc.c. */ +/* LTO contributions to the "compilers" array in gcc.cc. */ {"@lto", "lto1 %(cc1_options) %i %{!fsyntax-only:%(invoke_as)}", /*cpp_spec=*/NULL, /*combinable=*/1, /*needs_preprocessing=*/0}, diff --git a/gcc/lto/lto-common.cc b/gcc/lto/lto-common.cc index 853b3fb..4d6686b 100644 --- a/gcc/lto/lto-common.cc +++ b/gcc/lto/lto-common.cc @@ -507,7 +507,7 @@ gimple_register_canonical_type_1 (tree t, hashval_t hash) This is used by LTO to merge structurally equivalent types for type-based aliasing purposes across different TUs and languages. - ??? This merging does not exactly match how the tree.c middle-end + ??? This merging does not exactly match how the tree.cc middle-end functions will assign TYPE_CANONICAL when new types are created during optimization (which at least happens for pointer and array types). */ diff --git a/gcc/lto/lto-common.h b/gcc/lto/lto-common.h index 71685bc..6bf7dbf 100644 --- a/gcc/lto/lto-common.h +++ b/gcc/lto/lto-common.h @@ -1,4 +1,4 @@ -/* LTO common functions between lto.c and lto-dump.c header file. +/* LTO common functions between lto.cc and lto-dump.cc header file. Copyright (C) 2018-2022 Free Software Foundation, Inc. This file is part of GCC. diff --git a/gcc/lto/lto-dump.cc b/gcc/lto/lto-dump.cc index a779dd8..1fb3fb8 100644 --- a/gcc/lto/lto-dump.cc +++ b/gcc/lto/lto-dump.cc @@ -322,7 +322,7 @@ lto_main (void) Because it is called as a front end, TV_PHASE_PARSING and TV_PARSE_GLOBAL are active, and we need to turn them off while doing LTO. Later we turn them back on so they are active up in - toplev.c. */ + toplev.cc. */ /* Initialize the LTO front end. */ lto_fe_init (); diff --git a/gcc/lto/lto-lang.cc b/gcc/lto/lto-lang.cc index a7f6f02..8d58d92 100644 --- a/gcc/lto/lto-lang.cc +++ b/gcc/lto/lto-lang.cc @@ -583,7 +583,7 @@ handle_fnspec_attribute (tree *node ATTRIBUTE_UNUSED, tree ARG_UNUSED (name), return NULL_TREE; } -/* Cribbed from c-common.c. */ +/* Cribbed from c-common.cc. */ static void def_fn_type (builtin_type def, builtin_type ret, bool var, int n, ...) @@ -1204,7 +1204,7 @@ static tree lto_getdecls (void) { /* We have our own write_globals langhook, hence the getdecls - langhook shouldn't be used, except by dbxout.c, so we can't + langhook shouldn't be used, except by dbxout.cc, so we can't just abort here. */ return NULL_TREE; } @@ -1349,7 +1349,7 @@ lto_init (void) /* Assign names to the builtin types, otherwise they'll end up as __unknown__ in debug info. ??? We simply need to stop pre-seeding the streamer cache. - Below is modeled after from c-common.c:c_common_nodes_and_builtins */ + Below is modeled after from c-common.cc:c_common_nodes_and_builtins */ #define NAME_TYPE(t,n) \ if (t) \ TYPE_NAME (t) = build_decl (UNKNOWN_LOCATION, TYPE_DECL, \ diff --git a/gcc/lto/lto.cc b/gcc/lto/lto.cc index 018c236..98c336a 100644 --- a/gcc/lto/lto.cc +++ b/gcc/lto/lto.cc @@ -608,7 +608,7 @@ lto_main (void) Because it is called as a front end, TV_PHASE_PARSING and TV_PARSE_GLOBAL are active, and we need to turn them off while doing LTO. Later we turn them back on so they are active up in - toplev.c. */ + toplev.cc. */ timevar_pop (TV_PARSE_GLOBAL); timevar_stop (TV_PHASE_PARSING); diff --git a/gcc/lto/lto.h b/gcc/lto/lto.h index 35ba1ce..9f7fae9 100644 --- a/gcc/lto/lto.h +++ b/gcc/lto/lto.h @@ -31,10 +31,10 @@ struct lto_file off_t offset; }; -/* In lto-lang.c */ +/* In lto-lang.cc */ extern const char *resolution_file_name; -/* In lto.c */ +/* In lto.cc */ extern tree lto_eh_personality (void); extern void lto_main (void); extern void lto_read_all_file_options (void); diff --git a/gcc/machmode.def b/gcc/machmode.def index 866a208..c6baa75 100644 --- a/gcc/machmode.def +++ b/gcc/machmode.def @@ -184,7 +184,7 @@ along with GCC; see the file COPYING3. If not see the number of units doubles the size and precision as well. Note: If a mode is ever made which is more than 255 bytes wide, - machmode.h and genmodes.c will have to be changed to allocate + machmode.h and genmodes.cc will have to be changed to allocate more space for the mode_size and mode_alignment arrays. */ /* VOIDmode is used when no mode needs to be specified, diff --git a/gcc/machmode.h b/gcc/machmode.h index a0d8f04..45df720df 100644 --- a/gcc/machmode.h +++ b/gcc/machmode.h @@ -956,7 +956,7 @@ extern scalar_int_mode byte_mode; extern scalar_int_mode word_mode; extern scalar_int_mode ptr_mode; -/* Target-dependent machine mode initialization - in insn-modes.c. */ +/* Target-dependent machine mode initialization - in insn-modes.cc. */ extern void init_adjust_machine_modes (void); #define TRULY_NOOP_TRUNCATION_MODES_P(MODE1, MODE2) \ @@ -987,7 +987,7 @@ struct int_n_data_t { /* RID_* is RID_INTN_BASE + index into this array */ }; -/* This is also in tree.h. genmodes.c guarantees the're sorted from +/* This is also in tree.h. genmodes.cc guarantees the're sorted from smallest bitsize to largest bitsize. */ extern bool int_n_enabled_p[NUM_INT_N_ENTS]; extern const int_n_data_t int_n_data[NUM_INT_N_ENTS]; diff --git a/gcc/main.cc b/gcc/main.cc index ef9b09f..f9dd6b2 100644 --- a/gcc/main.cc +++ b/gcc/main.cc @@ -26,7 +26,7 @@ along with GCC; see the file COPYING3. If not see int main (int argc, char **argv); -/* We define main() to call toplev::main(), which is defined in toplev.c. +/* We define main() to call toplev::main(), which is defined in toplev.cc. We do this in a separate file in order to allow the language front-end to define a different main(), if it so desires. */ diff --git a/gcc/match.pd b/gcc/match.pd index f5dcbf3..3680b89 100644 --- a/gcc/match.pd +++ b/gcc/match.pd @@ -1,6 +1,6 @@ /* Match-and-simplify patterns for shared GENERIC and GIMPLE folding. - This file is consumed by genmatch which produces gimple-match.c - and generic-match.c from it. + This file is consumed by genmatch which produces gimple-match.cc + and generic-match.cc from it. Copyright (C) 2014-2022 Free Software Foundation, Inc. Contributed by Richard Biener @@ -1523,7 +1523,7 @@ DEFINE_INT_AND_FLOAT_ROUND_FN (RINT) ) ) -/* A few cases of fold-const.c negate_expr_p predicate. */ +/* A few cases of fold-const.cc negate_expr_p predicate. */ (match negate_expr_p INTEGER_CST (if ((INTEGRAL_TYPE_P (type) @@ -1629,7 +1629,7 @@ DEFINE_INT_AND_FLOAT_ROUND_FN (RINT) && (int_fits_type_p (@1, TREE_TYPE (@0)) || tree_nop_conversion_p (TREE_TYPE (@0), type))) || types_match (@0, @1)) - /* ??? This transform conflicts with fold-const.c doing + /* ??? This transform conflicts with fold-const.cc doing Convert (T)(x & c) into (T)x & (T)c, if c is an integer constants (if x has signed type, the sign bit cannot be set in c). This folds extension into the BIT_AND_EXPR. @@ -4008,9 +4008,9 @@ DEFINE_INT_AND_FLOAT_ROUND_FN (RINT) Only optimize constant conditions when the selected branch has the same type as the COND_EXPR. This avoids optimizing away "c ? x : throw", where the throw has a void type. - Note that we cannot throw away the fold-const.c variant nor + Note that we cannot throw away the fold-const.cc variant nor this one as we depend on doing this transform before possibly - A ? B : B -> B triggers and the fold-const.c one can optimize + A ? B : B -> B triggers and the fold-const.cc one can optimize 0 ? A : B to B even if A has side-effects. Something genmatch cannot handle. */ (simplify @@ -5744,7 +5744,7 @@ DEFINE_INT_AND_FLOAT_ROUND_FN (RINT) /* When one argument is a constant, overflow detection can be simplified. Currently restricted to single use so as not to interfere too much with - ADD_OVERFLOW detection in tree-ssa-math-opts.c. + ADD_OVERFLOW detection in tree-ssa-math-opts.cc. CONVERT?(CONVERT?(A) + CST) CMP A -> A CMP' CST' */ (for cmp (lt le ge gt) out (gt gt le le) @@ -5764,7 +5764,7 @@ DEFINE_INT_AND_FLOAT_ROUND_FN (RINT) - wi::to_wide (@1)); }))))) /* To detect overflow in unsigned A - B, A < B is simpler than A - B > A. - However, the detection logic for SUB_OVERFLOW in tree-ssa-math-opts.c + However, the detection logic for SUB_OVERFLOW in tree-ssa-math-opts.cc expects the long form, so we restrict the transformation for now. */ (for cmp (gt le) (simplify diff --git a/gcc/objc/Make-lang.in b/gcc/objc/Make-lang.in index 8778e9a..6e4ebf5 100644 --- a/gcc/objc/Make-lang.in +++ b/gcc/objc/Make-lang.in @@ -60,7 +60,7 @@ objc_OBJS = $(OBJC_OBJS) cc1obj-checksum.o # compute checksum over all object files and the options # re-use the checksum from the prev-final stage so it passes # the bootstrap comparison and allows comparing of the cc1 binary -cc1obj-checksum.c : build/genchecksum$(build_exeext) checksum-options \ +cc1obj-checksum.cc : build/genchecksum$(build_exeext) checksum-options \ $(OBJC_OBJS) $(C_AND_OBJC_OBJS) $(BACKEND) $(LIBDEPS) if [ -f ../stage_final ] \ && cmp -s ../stage_current ../stage_final \ diff --git a/gcc/objc/config-lang.in b/gcc/objc/config-lang.in index da13fed..8cf3524 100644 --- a/gcc/objc/config-lang.in +++ b/gcc/objc/config-lang.in @@ -35,4 +35,4 @@ lang_requires="c" # Order is important. If you change this list, make sure you test # building without C++ as well; that is, remove the gcc/cp directory, # and build with --enable-languages=c,objc. -gtfiles="\$(srcdir)/objc/objc-map.h \$(srcdir)/c-family/c-objc.h \$(srcdir)/objc/objc-act.h \$(srcdir)/objc/objc-act.c \$(srcdir)/objc/objc-runtime-shared-support.c \$(srcdir)/objc/objc-gnu-runtime-abi-01.c \$(srcdir)/objc/objc-next-runtime-abi-01.c \$(srcdir)/objc/objc-next-runtime-abi-02.c \$(srcdir)/c/c-parser.h \$(srcdir)/c/c-parser.c \$(srcdir)/c/c-tree.h \$(srcdir)/c/c-decl.c \$(srcdir)/c/c-lang.h \$(srcdir)/c/c-objc-common.c \$(srcdir)/c-family/c-common.c \$(srcdir)/c-family/c-common.h \$(srcdir)/c-family/c-cppbuiltin.c \$(srcdir)/c-family/c-pragma.h \$(srcdir)/c-family/c-pragma.c \$(srcdir)/c-family/c-format.c" +gtfiles="\$(srcdir)/objc/objc-map.h \$(srcdir)/c-family/c-objc.h \$(srcdir)/objc/objc-act.h \$(srcdir)/objc/objc-act.cc \$(srcdir)/objc/objc-runtime-shared-support.cc \$(srcdir)/objc/objc-gnu-runtime-abi-01.cc \$(srcdir)/objc/objc-next-runtime-abi-01.cc \$(srcdir)/objc/objc-next-runtime-abi-02.cc \$(srcdir)/c/c-parser.h \$(srcdir)/c/c-parser.cc \$(srcdir)/c/c-tree.h \$(srcdir)/c/c-decl.cc \$(srcdir)/c/c-lang.h \$(srcdir)/c/c-objc-common.cc \$(srcdir)/c-family/c-common.cc \$(srcdir)/c-family/c-common.h \$(srcdir)/c-family/c-cppbuiltin.cc \$(srcdir)/c-family/c-pragma.h \$(srcdir)/c-family/c-pragma.cc \$(srcdir)/c-family/c-format.cc" diff --git a/gcc/objc/lang-specs.h b/gcc/objc/lang-specs.h index 656f878..1a785ac 100644 --- a/gcc/objc/lang-specs.h +++ b/gcc/objc/lang-specs.h @@ -18,7 +18,7 @@ along with GCC; see the file COPYING3. If not see . */ -/* This is the contribution to the `default_compilers' array in gcc.c +/* This is the contribution to the `default_compilers' array in gcc.cc for objc. */ {".m", "@objective-c", 0, 0, 0}, diff --git a/gcc/objc/objc-act.cc b/gcc/objc/objc-act.cc index 4d95bc6..252274c 100644 --- a/gcc/objc/objc-act.cc +++ b/gcc/objc/objc-act.cc @@ -2817,7 +2817,7 @@ objc_build_component_ref (tree datum, tree component) } /* Recursively copy inheritance information rooted at BINFO. To do this, - we emulate the song and dance performed by cp/tree.c:copy_binfo(). */ + we emulate the song and dance performed by cp/tree.cc:copy_binfo(). */ static tree objc_copy_binfo (tree binfo) @@ -2844,7 +2844,7 @@ objc_copy_binfo (tree binfo) } /* Record superclass information provided in BASETYPE for ObjC class REF. - This is loosely based on cp/decl.c:xref_basetypes(). */ + This is loosely based on cp/decl.cc:xref_basetypes(). */ static void objc_xref_basetypes (tree ref, tree basetype) @@ -5490,7 +5490,7 @@ lookup_method_in_hash_lists (tree sel_name, int is_class) /* The 'objc_finish_message_expr' routine is called from within 'objc_build_message_expr' for non-template functions. In the case of C++ template functions, it is called from 'build_expr_from_tree' - (in decl2.c) after RECEIVER and METHOD_PARAMS have been expanded. + (in decl2.cc) after RECEIVER and METHOD_PARAMS have been expanded. If the method_prototype_avail argument is NULL, then we warn if the method being used is deprecated. If it is not NULL, instead @@ -9962,10 +9962,10 @@ objc_finish_foreach_loop (location_t location, tree object_expression, tree coll } /* { */ - /* Done by c-parser.c. */ + /* Done by c-parser.cc. */ /* type object; */ - /* Done by c-parser.c. */ + /* Done by c-parser.cc. */ /* Disable warnings that 'object' is unused. For example the code @@ -10296,7 +10296,7 @@ objc_finish_foreach_loop (location_t location, tree object_expression, tree coll #endif /* } */ - /* Done by c-parser.c */ + /* Done by c-parser.cc */ } /* --- SUPPORT FOR FORMAT ARG CHECKING --- */ diff --git a/gcc/objc/objc-act.h b/gcc/objc/objc-act.h index 478d687..7d0c6d5 100644 --- a/gcc/objc/objc-act.h +++ b/gcc/objc/objc-act.h @@ -1,4 +1,4 @@ -/* Declarations for objc-act.c. +/* Declarations for objc-act.cc. Copyright (C) 1990-2022 Free Software Foundation, Inc. This file is part of GCC. @@ -29,7 +29,7 @@ int objc_gimplify_expr (tree *, gimple_seq *, gimple_seq *); void objc_common_init_ts (void); /* NB: The remaining public functions are prototyped in c-common.h, for the - benefit of stub-objc.c and objc-act.c. */ + benefit of stub-objc.cc and objc-act.cc. */ /* Objective-C structures */ diff --git a/gcc/objc/objc-gnu-runtime-abi-01.cc b/gcc/objc/objc-gnu-runtime-abi-01.cc index 8aa2044..9413314 100644 --- a/gcc/objc/objc-gnu-runtime-abi-01.cc +++ b/gcc/objc/objc-gnu-runtime-abi-01.cc @@ -1,6 +1,6 @@ /* GNU Runtime ABI version 8 Copyright (C) 2011-2022 Free Software Foundation, Inc. - Contributed by Iain Sandoe (split from objc-act.c) + Contributed by Iain Sandoe (split from objc-act.cc) This file is part of GCC. diff --git a/gcc/objc/objc-lang.cc b/gcc/objc/objc-lang.cc index 1fb2053..ef664f5 100644 --- a/gcc/objc/objc-lang.cc +++ b/gcc/objc/objc-lang.cc @@ -50,7 +50,7 @@ enum c_language_kind c_language = clk_objc; /* Each front end provides its own lang hook initializer. */ struct lang_hooks lang_hooks = LANG_HOOKS_INITIALIZER; -/* Lang hook routines common to C and ObjC appear in c-objc-common.c; +/* Lang hook routines common to C and ObjC appear in c-objc-common.cc; there should be very few (if any) routines below. */ #include "gtype-objc.h" diff --git a/gcc/objc/objc-map.cc b/gcc/objc/objc-map.cc index a0ba7e3..963a558 100644 --- a/gcc/objc/objc-map.cc +++ b/gcc/objc/objc-map.cc @@ -1,4 +1,4 @@ -/* objc-map.c -- Implementation of map data structures for ObjC compiler +/* objc-map.cc -- Implementation of map data structures for ObjC compiler Copyright (C) 2011-2022 Free Software Foundation, Inc. Written by Nicola Pero diff --git a/gcc/objc/objc-next-runtime-abi-01.cc b/gcc/objc/objc-next-runtime-abi-01.cc index a4287e4..409b777 100644 --- a/gcc/objc/objc-next-runtime-abi-01.cc +++ b/gcc/objc/objc-next-runtime-abi-01.cc @@ -1,6 +1,6 @@ /* Next Runtime (ABI-0/1) private. Copyright (C) 2011-2022 Free Software Foundation, Inc. - Contributed by Iain Sandoe (split from objc-act.c) + Contributed by Iain Sandoe (split from objc-act.cc) This file is part of GCC. @@ -2275,7 +2275,7 @@ generate_objc_symtab_decl (void) executable image, preserving unix archive semantics. At present (4.8), the only targets implementing this are Darwin; these - use top level asms to implement a scheme (see config/darwin-c.c). The + use top level asms to implement a scheme (see config/darwin-c.cc). The latter method is a hack, but compatible with LTO see also PR48109 for further discussion and other possible methods. */ diff --git a/gcc/objc/objc-runtime-shared-support.cc b/gcc/objc/objc-runtime-shared-support.cc index b12a7ce..75c28fb 100644 --- a/gcc/objc/objc-runtime-shared-support.cc +++ b/gcc/objc/objc-runtime-shared-support.cc @@ -1,6 +1,6 @@ /* Support routines shared by all runtimes. Copyright (C) 2011-2022 Free Software Foundation, Inc. - Contributed by Iain Sandoe (partially split from objc-act.c) + Contributed by Iain Sandoe (partially split from objc-act.cc) This file is part of GCC. diff --git a/gcc/objc/objc-runtime-shared-support.h b/gcc/objc/objc-runtime-shared-support.h index 1981c94..5b6c212 100644 --- a/gcc/objc/objc-runtime-shared-support.h +++ b/gcc/objc/objc-runtime-shared-support.h @@ -63,7 +63,7 @@ extern tree build_descriptor_table_initializer (tree, tree); extern tree build_method_prototype_list_template (tree, int); extern tree build_protocol_initializer (tree, tree, tree, tree, tree); -/* Moved or new routines in objc-runtime-shared-support.c */ +/* Moved or new routines in objc-runtime-shared-support.cc */ extern tree build_selector (tree); extern tree build_method_template (void); diff --git a/gcc/objcp/Make-lang.in b/gcc/objcp/Make-lang.in index 87b0fa1..fc8e05b 100644 --- a/gcc/objcp/Make-lang.in +++ b/gcc/objcp/Make-lang.in @@ -63,7 +63,7 @@ obj-c++_OBJS = $(OBJCXX_OBJS) cc1objplus-checksum.o # compute checksum over all object files and the options # re-use the checksum from the prev-final stage so it passes # the bootstrap comparison and allows comparing of the cc1 binary -cc1objplus-checksum.c : build/genchecksum$(build_exeext) checksum-options \ +cc1objplus-checksum.cc : build/genchecksum$(build_exeext) checksum-options \ $(OBJCXX_OBJS) $(BACKEND) $(CODYLIB) $(LIBDEPS) if [ -f ../stage_final ] \ && cmp -s ../stage_current ../stage_final \ @@ -85,31 +85,31 @@ cc1objplus$(exeext): $(OBJCXX_OBJS) cc1objplus-checksum.o $(BACKEND) \ # Objective C++ language specific files. -objcp/objc-runtime-shared-support.o: objc/objc-runtime-shared-support.c +objcp/objc-runtime-shared-support.o: objc/objc-runtime-shared-support.cc $(COMPILE) $< $(POSTCOMPILE) -objcp/objc-gnu-runtime-abi-01.o: objc/objc-gnu-runtime-abi-01.c +objcp/objc-gnu-runtime-abi-01.o: objc/objc-gnu-runtime-abi-01.cc $(COMPILE) $< $(POSTCOMPILE) -objcp/objc-next-runtime-abi-01.o: objc/objc-next-runtime-abi-01.c +objcp/objc-next-runtime-abi-01.o: objc/objc-next-runtime-abi-01.cc $(COMPILE) $< $(POSTCOMPILE) -objcp/objc-next-runtime-abi-02.o: objc/objc-next-runtime-abi-02.c +objcp/objc-next-runtime-abi-02.o: objc/objc-next-runtime-abi-02.cc $(COMPILE) $< $(POSTCOMPILE) -objcp/objcp-act.o: objc/objc-act.c +objcp/objcp-act.o: objc/objc-act.cc $(COMPILE) $< $(POSTCOMPILE) -objcp/objc-encoding.o: objc/objc-encoding.c +objcp/objc-encoding.o: objc/objc-encoding.cc $(COMPILE) $< $(POSTCOMPILE) -objcp/objc-map.o: objc/objc-map.c +objcp/objc-map.o: objc/objc-map.cc $(COMPILE) $< $(POSTCOMPILE) diff --git a/gcc/objcp/config-lang.in b/gcc/objcp/config-lang.in index 918635c..65c0fa5 100644 --- a/gcc/objcp/config-lang.in +++ b/gcc/objcp/config-lang.in @@ -39,23 +39,23 @@ subdir_requires="objc cp" # When you add to this gtfiles list a header which comes from a # directory belonging to another language (ie, C++ or ObjC), you need -# to also edit gengtype.c adding a special rule for the header to +# to also edit gengtype.cc adding a special rule for the header to # avoid having the GC stuff from that header being added to gtype-cp.h # or gtype-objc.h. # Get the C++ FE's gtfiles list. Do this in a subshell, so we can -# extract exactly the gtfiles var, but munge cp-lang.c into objcp-lang.c. +# extract exactly the gtfiles var, but munge cp-lang.cc into objcp-lang.cc. gtfiles="$(. $srcdir/cp/config-lang.in ; \ - echo $gtfiles | sed 's+/cp/cp-lang.c +/objcp/objcp-lang.c +')" + echo $gtfiles | sed 's+/cp/cp-lang.cc +/objcp/objcp-lang.cc +')" # Now add our special bits to it. Please keep this list sorted. gtfiles="$gtfiles \ \$(srcdir)/objc/objc-act.h \ \$(srcdir)/objc/objc-map.h \ -\$(srcdir)/objc/objc-act.c \ -\$(srcdir)/objc/objc-gnu-runtime-abi-01.c \ -\$(srcdir)/objc/objc-next-runtime-abi-01.c \ -\$(srcdir)/objc/objc-next-runtime-abi-02.c \ -\$(srcdir)/objc/objc-runtime-shared-support.c \ +\$(srcdir)/objc/objc-act.cc \ +\$(srcdir)/objc/objc-gnu-runtime-abi-01.cc \ +\$(srcdir)/objc/objc-next-runtime-abi-01.cc \ +\$(srcdir)/objc/objc-next-runtime-abi-02.cc \ +\$(srcdir)/objc/objc-runtime-shared-support.cc \ " diff --git a/gcc/objcp/lang-specs.h b/gcc/objcp/lang-specs.h index 0739313..2d70f30 100644 --- a/gcc/objcp/lang-specs.h +++ b/gcc/objcp/lang-specs.h @@ -19,7 +19,7 @@ along with GCC; see the file COPYING3. If not see . */ -/* This is the contribution to the `default_compilers' array in gcc.c for +/* This is the contribution to the `default_compilers' array in gcc.cc for obj-c++. It is based on -- and should be kept in sync with -- the g++ spec (found in cp/lang-specs.h). */ diff --git a/gcc/objcp/objcp-decl.cc b/gcc/objcp/objcp-decl.cc index 712bff3..6db262b 100644 --- a/gcc/objcp/objcp-decl.cc +++ b/gcc/objcp/objcp-decl.cc @@ -103,7 +103,7 @@ tree objcp_end_compound_stmt (tree stmt, int flags ATTRIBUTE_UNUSED) { /* The following has been snarfed from - cp/semantics.c:finish_compound_stmt(). */ + cp/semantics.cc:finish_compound_stmt(). */ if (TREE_CODE (stmt) == BIND_EXPR) BIND_EXPR_BODY (stmt) = do_poplevel (BIND_EXPR_BODY (stmt)); else if (STATEMENT_LIST_NO_SCOPE (stmt)) diff --git a/gcc/objcp/objcp-lang.cc b/gcc/objcp/objcp-lang.cc index b309b26..2e8809b 100644 --- a/gcc/objcp/objcp-lang.cc +++ b/gcc/objcp/objcp-lang.cc @@ -46,7 +46,7 @@ static void objcxx_init_ts (void); /* Each front end provides its own lang hook initializer. */ struct lang_hooks lang_hooks = LANG_HOOKS_INITIALIZER; -/* Lang hook routines common to C++ and ObjC++ appear in cp/cp-objcp-common.c; +/* Lang hook routines common to C++ and ObjC++ appear in cp/cp-objcp-common.cc; there should be very few (if any) routines below. */ tree diff --git a/gcc/omp-builtins.def b/gcc/omp-builtins.def index b93bc06f..cfa6483 100644 --- a/gcc/omp-builtins.def +++ b/gcc/omp-builtins.def @@ -111,7 +111,7 @@ DEF_GOMP_BUILTIN (BUILT_IN_GOMP_CRITICAL_NAME_END, BT_FN_VOID_PTRPTR, ATTR_NOTHROW_LEAF_LIST) /* NOTE: Do not change the order of BUILT_IN_GOMP_LOOP_*_START. They are used in index arithmetic with enum omp_clause_schedule_kind - in omp-low.c. */ + in omp-low.cc. */ DEF_GOMP_BUILTIN (BUILT_IN_GOMP_LOOP_STATIC_START, "GOMP_loop_static_start", BT_FN_BOOL_LONG_LONG_LONG_LONG_LONGPTR_LONGPTR, @@ -334,7 +334,7 @@ DEF_GOMP_BUILTIN (BUILT_IN_GOMP_LOOP_ULL_ORDERED_RUNTIME_NEXT, BT_FN_BOOL_ULONGLONGPTR_ULONGLONGPTR, ATTR_NOTHROW_LEAF_LIST) /* NOTE: Do not change the order of BUILT_IN_GOMP_PARALLEL_LOOP_*. They are used in index arithmetic with enum omp_clause_schedule_kind - in omp-low.c. */ + in omp-low.cc. */ DEF_GOMP_BUILTIN (BUILT_IN_GOMP_PARALLEL_LOOP_STATIC, "GOMP_parallel_loop_static", BT_FN_VOID_OMPFN_PTR_UINT_LONG_LONG_LONG_LONG_UINT, diff --git a/gcc/omp-expand.cc b/gcc/omp-expand.cc index 520982e..ee70831 100644 --- a/gcc/omp-expand.cc +++ b/gcc/omp-expand.cc @@ -8850,7 +8850,7 @@ expand_omp_atomic_fetch_op (basic_block load_bb, /* We could test all of the various optabs involved, but the fact of the matter is that (with the exception of i486 vs i586 and xadd) all targets that support any atomic operaton optab also implements compare-and-swap. - Let optabs.c take care of expanding any compare-and-swap loop. */ + Let optabs.cc take care of expanding any compare-and-swap loop. */ if (!can_compare_and_swap_p (imode, true) || !can_atomic_load_p (imode)) return false; @@ -10637,7 +10637,7 @@ make_pass_expand_omp_ssa (gcc::context *ctxt) return new pass_expand_omp_ssa (ctxt); } -/* Called from tree-cfg.c::make_edges to create cfg edges for all relevant +/* Called from tree-cfg.cc::make_edges to create cfg edges for all relevant GIMPLE_* codes. */ bool diff --git a/gcc/omp-low.cc b/gcc/omp-low.cc index f223742..c33b3da 100644 --- a/gcc/omp-low.cc +++ b/gcc/omp-low.cc @@ -78,7 +78,7 @@ along with GCC; see the file COPYING3. If not see struct omp_context { /* This field must be at the beginning, as we do "inheritance": Some - callback functions for tree-inline.c (e.g., omp_copy_decl) + callback functions for tree-inline.cc (e.g., omp_copy_decl) receive a copy_body_data pointer that is up-casted to an omp_context pointer. */ copy_body_data cb; @@ -11866,7 +11866,7 @@ check_combined_parallel (gimple_stmt_iterator *gsi_p, struct omp_taskcopy_context { /* This field must be at the beginning, as we do "inheritance": Some - callback functions for tree-inline.c (e.g., omp_copy_decl) + callback functions for tree-inline.cc (e.g., omp_copy_decl) receive a copy_body_data pointer that is up-casted to an omp_context pointer. */ copy_body_data cb; @@ -14361,7 +14361,7 @@ lower_omp (gimple_seq *body, omp_context *ctx) for (gsi = gsi_start (*body); !gsi_end_p (gsi); gsi_next (&gsi)) lower_omp_1 (&gsi, ctx); /* During gimplification, we haven't folded statments inside offloading - or taskreg regions (gimplify.c:maybe_fold_stmt); do that now. */ + or taskreg regions (gimplify.cc:maybe_fold_stmt); do that now. */ if (target_nesting_level || taskreg_nesting_level) for (gsi = gsi_start (*body); !gsi_end_p (gsi); gsi_next (&gsi)) fold_stmt (&gsi); diff --git a/gcc/omp-oacc-neuter-broadcast.cc b/gcc/omp-oacc-neuter-broadcast.cc index 14695a9..7fb691d 100644 --- a/gcc/omp-oacc-neuter-broadcast.cc +++ b/gcc/omp-oacc-neuter-broadcast.cc @@ -58,7 +58,7 @@ /* Loop structure of the function. The entire function is described as a NULL loop. */ -/* Adapted from 'gcc/config/nvptx/nvptx.c:struct parallel'. */ +/* Adapted from 'gcc/config/nvptx/nvptx.cc:struct parallel'. */ struct parallel_g { @@ -186,7 +186,7 @@ omp_sese_active_worker_call (gcall *call) partitioning mode of the function as a whole. Populate MAP with head and tail blocks. We also clear the BB visited flag, which is used when finding partitions. */ -/* Adapted from 'gcc/config/nvptx/nvptx.c:nvptx_split_blocks'. */ +/* Adapted from 'gcc/config/nvptx/nvptx.cc:nvptx_split_blocks'. */ static void omp_sese_split_blocks (bb_stmt_map_t *map) @@ -345,7 +345,7 @@ mask_name (unsigned mask) } /* Dump this parallel and all its inner parallels. */ -/* Adapted from 'gcc/config/nvptx/nvptx.c:nvptx_dump_pars'. */ +/* Adapted from 'gcc/config/nvptx/nvptx.cc:nvptx_dump_pars'. */ static void omp_sese_dump_pars (parallel_g *par, unsigned depth) @@ -371,7 +371,7 @@ omp_sese_dump_pars (parallel_g *par, unsigned depth) /* If BLOCK contains a fork/join marker, process it to create or terminate a loop structure. Add this block to the current loop, and then walk successor blocks. */ -/* Adapted from 'gcc/config/nvptx/nvptx.c:nvptx_find_par'. */ +/* Adapted from 'gcc/config/nvptx/nvptx.cc:nvptx_find_par'. */ static parallel_g * omp_sese_find_par (bb_stmt_map_t *map, parallel_g *par, basic_block block) @@ -477,7 +477,7 @@ walk_successors: to head & tail markers, discovered when splitting blocks. This speeds up the discovery. We rely on the BB visited flag having been cleared when splitting blocks. */ -/* Adapted from 'gcc/config/nvptx/nvptx.c:nvptx_discover_pars'. */ +/* Adapted from 'gcc/config/nvptx/nvptx.cc:nvptx_discover_pars'. */ static parallel_g * omp_sese_discover_pars (bb_stmt_map_t *map) @@ -939,7 +939,7 @@ worker_single_simple (basic_block from, basic_block to, /* Build COMPONENT_REF and set TREE_THIS_VOLATILE and TREE_READONLY on it as appropriate. */ -/* Adapted from 'gcc/omp-low.c:omp_build_component_ref'. */ +/* Adapted from 'gcc/omp-low.cc:omp_build_component_ref'. */ static tree oacc_build_component_ref (tree obj, tree field) diff --git a/gcc/omp-offload.cc b/gcc/omp-offload.cc index 8fd40da..ad4e772 100644 --- a/gcc/omp-offload.cc +++ b/gcc/omp-offload.cc @@ -127,7 +127,7 @@ add_decls_addresses_to_decl_constructor (vec *v_decls, #endif && lookup_attribute ("omp declare target link", DECL_ATTRIBUTES (it)); - /* See also omp_finish_file and output_offload_tables in lto-cgraph.c. */ + /* See also omp_finish_file and output_offload_tables in lto-cgraph.cc. */ if (!in_lto_p && !symtab_node::get (it)) continue; @@ -446,7 +446,7 @@ omp_finish_file (void) { tree it = (*offload_funcs)[i]; /* See also add_decls_addresses_to_decl_constructor - and output_offload_tables in lto-cgraph.c. */ + and output_offload_tables in lto-cgraph.cc. */ if (!in_lto_p && !symtab_node::get (it)) continue; targetm.record_offload_symbol (it); @@ -2057,7 +2057,7 @@ execute_oacc_loop_designation () if (is_oacc_kernels && is_oacc_kernels_parallelized) { /* Parallelized OpenACC kernels constructs use gang parallelism. See - also tree-parloops.c:create_parallel_loop. */ + also tree-parloops.cc:create_parallel_loop. */ used_mask |= GOMP_DIM_MASK (GOMP_DIM_GANG); } diff --git a/gcc/optabs-query.cc b/gcc/optabs-query.cc index 3253eca..2ce8d74 100644 --- a/gcc/optabs-query.cc +++ b/gcc/optabs-query.cc @@ -691,7 +691,7 @@ bool lshift_cheap_p (bool speed_p) { /* FIXME: This should be made target dependent via this "this_target" - mechanism, similar to e.g. can_copy_init_p in gcse.c. */ + mechanism, similar to e.g. can_copy_init_p in gcse.cc. */ static bool init[2] = { false, false }; static bool cheap[2] = { true, true }; diff --git a/gcc/optc-gen.awk b/gcc/optc-gen.awk index 3a1102a..8a66126 100644 --- a/gcc/optc-gen.awk +++ b/gcc/optc-gen.awk @@ -25,7 +25,7 @@ # opt-read.awk. # # Usage: awk -f opt-functions.awk -f opt-read.awk -f optc-gen.awk \ -# [-v header_name=header.h] < inputfile > options.c +# [-v header_name=header.h] < inputfile > options.cc # Dump that array of options into a C file. END { diff --git a/gcc/optc-save-gen.awk b/gcc/optc-save-gen.awk index 34261a7..9911bab 100644 --- a/gcc/optc-save-gen.awk +++ b/gcc/optc-save-gen.awk @@ -25,7 +25,7 @@ # opt-read.awk. # # Usage: awk -f opt-functions.awk -f opt-read.awk -f optc-save-gen.awk \ -# [-v header_name=header.h] < inputfile > options-save.c +# [-v header_name=header.h] < inputfile > options-save.cc # Dump that array of options into a C file. END { diff --git a/gcc/optinfo-emit-json.cc b/gcc/optinfo-emit-json.cc index 34c777c..ca18d26 100644 --- a/gcc/optinfo-emit-json.cc +++ b/gcc/optinfo-emit-json.cc @@ -55,7 +55,7 @@ optrecord_json_writer::optrecord_json_writer () { m_root_tuple = new json::array (); - /* Populate with metadata; compare with toplev.c: print_version. */ + /* Populate with metadata; compare with toplev.cc: print_version. */ json::object *metadata = new json::object (); m_root_tuple->append (metadata); metadata->set ("format", new json::string ("1")); @@ -68,7 +68,7 @@ optrecord_json_writer::optrecord_json_writer () generator->set ("target", new json::string (TARGET_NAME)); /* TODO: capture command-line? - see gen_producer_string in dwarf2out.c (currently static). */ + see gen_producer_string in dwarf2out.cc (currently static). */ /* TODO: capture "any plugins?" flag (or the plugins themselves). */ diff --git a/gcc/opts-common.cc b/gcc/opts-common.cc index 0ce0937..37d2e5f 100644 --- a/gcc/opts-common.cc +++ b/gcc/opts-common.cc @@ -463,7 +463,7 @@ static const struct option_map option_map[] = { "--no-", NULL, "-f", false, true } }; -/* Helper function for gcc.c's driver::suggest_option, for populating the +/* Helper function for gcc.cc's driver::suggest_option, for populating the vec of suggestions for misspelled options. option_map above provides various prefixes for spelling command-line diff --git a/gcc/output.h b/gcc/output.h index c54d0c6..6dea630 100644 --- a/gcc/output.h +++ b/gcc/output.h @@ -1,5 +1,5 @@ -/* Declarations for insn-output.c and other code to write to asm_out_file. - These functions are defined in final.c, and varasm.c. +/* Declarations for insn-output.cc and other code to write to asm_out_file. + These functions are defined in final.cc, and varasm.cc. Copyright (C) 1987-2022 Free Software Foundation, Inc. This file is part of GCC. @@ -29,7 +29,7 @@ extern void init_final (const char *); extern void app_enable (void); /* Disable APP processing of subsequent output. - Called from varasm.c before most kinds of output. */ + Called from varasm.cc before most kinds of output. */ extern void app_disable (void); /* Return the number of slots filled in the current @@ -86,16 +86,16 @@ extern void output_operand (rtx, int); extern void output_operand_lossage (const char *, ...) ATTRIBUTE_PRINTF_1; /* Output a string of assembler code, substituting insn operands. - Defined in final.c. */ + Defined in final.cc. */ extern void output_asm_insn (const char *, rtx *); /* Compute a worst-case reference address of a branch so that it can be safely used in the presence of aligned labels. - Defined in final.c. */ + Defined in final.cc. */ extern int insn_current_reference_address (rtx_insn *); /* Find the alignment associated with a CODE_LABEL. - Defined in final.c. */ + Defined in final.cc. */ extern align_flags label_to_alignment (rtx); /* Output a LABEL_REF, or a bare CODE_LABEL, as an assembler symbol. */ @@ -147,7 +147,7 @@ extern void leaf_renumber_regs_insn (rtx); /* Locate the proper template for the given insn-code. */ extern const char *get_insn_template (int, rtx_insn *); -/* Functions in varasm.c. */ +/* Functions in varasm.cc. */ /* Emit any pending weak declarations. */ extern void weak_finish (void); @@ -308,7 +308,7 @@ extern void output_quoted_string (FILE *, const char *); sequence is being output, so it can be used as a test in the insn output code. - This variable is defined in final.c. */ + This variable is defined in final.cc. */ extern rtx_sequence *final_sequence; /* File in which assembler code is being written. */ diff --git a/gcc/pass_manager.h b/gcc/pass_manager.h index 327c61b..6484d2c 100644 --- a/gcc/pass_manager.h +++ b/gcc/pass_manager.h @@ -23,7 +23,7 @@ along with GCC; see the file COPYING3. If not see class opt_pass; struct register_pass_info; -/* Define a list of pass lists so that both passes.c and plugins can easily +/* Define a list of pass lists so that both passes.cc and plugins can easily find all the pass lists. */ #define GCC_PASS_LISTS \ DEF_PASS_LIST (all_lowering_passes) \ diff --git a/gcc/plugin.cc b/gcc/plugin.cc index d129b86..fe28b82 100644 --- a/gcc/plugin.cc +++ b/gcc/plugin.cc @@ -766,7 +766,7 @@ init_one_plugin (void **slot, void * ARG_UNUSED (info)) #endif /* ENABLE_PLUGIN */ /* Main plugin initialization function. Called from compile_file() in - toplev.c. */ + toplev.cc. */ void initialize_plugins (void) diff --git a/gcc/plugin.def b/gcc/plugin.def index 8ab706a..a880828 100644 --- a/gcc/plugin.def +++ b/gcc/plugin.def @@ -104,7 +104,7 @@ DEFEVENT (PLUGIN_INCLUDE_FILE) DEFEVENT (PLUGIN_ANALYZER_INIT) /* When adding a new hard-coded plugin event, don't forget to edit in - file plugin.c the functions register_callback and + file plugin.cc the functions register_callback and invoke_plugin_callbacks_full accordingly! */ /* After the hard-coded events above, plugins can dynamically allocate events diff --git a/gcc/plugin.h b/gcc/plugin.h index 21d0913..ff999c4 100644 --- a/gcc/plugin.h +++ b/gcc/plugin.h @@ -194,7 +194,7 @@ invoke_plugin_callbacks (int event ATTRIBUTE_UNUSED, return PLUGEVT_NO_CALLBACK; } -/* In attribs.c. */ +/* In attribs.cc. */ extern void register_attribute (const struct attribute_spec *attr); /* The default argument for the third parameter is given in attribs.h. */ diff --git a/gcc/po/EXCLUDES b/gcc/po/EXCLUDES index 9a879ad..02550be 100644 --- a/gcc/po/EXCLUDES +++ b/gcc/po/EXCLUDES @@ -30,26 +30,26 @@ limity.h # These programs are meant to be executed only by GCC maintainers or # installers. Such files do not need to be translated, as these # people typically need to be able to read English anyway. -genattr.c -genattrtab.c -genautomata.c -gencheck.c -gencodes.c -genconditions.c -genconfig.c -genconstants.c -genemit.c -genextract.c -genflags.c -gengenrtl.c -gengtype.c -genhooks.c -genmodes.c -genopinit.c -genoutput.c -genpeep.c -genpreds.c -genrecog.c -gensupport.c +genattr.cc +genattrtab.cc +genautomata.cc +gencheck.cc +gencodes.cc +genconditions.cc +genconfig.cc +genconstants.cc +genemit.cc +genextract.cc +genflags.cc +gengenrtl.cc +gengtype.cc +genhooks.cc +genmodes.cc +genopinit.cc +genoutput.cc +genpeep.cc +genpreds.cc +genrecog.cc +gensupport.cc gensupport.h -read-md.c +read-md.cc diff --git a/gcc/pointer-query.cc b/gcc/pointer-query.cc index 9f932e9..a61ac89 100644 --- a/gcc/pointer-query.cc +++ b/gcc/pointer-query.cc @@ -1989,7 +1989,7 @@ handle_mem_ref (tree mref, gimple *stmt, int ostype, access_ref *pref, FIXME: Vectorized assignments should only be present after vectorization so this hack is only necessary after it has run and could be avoided in calls from prior passes (e.g., - tree-ssa-strlen.c). + tree-ssa-strlen.cc). FIXME: Deal with this more generally, e.g., by marking up such MEM_REFs at the time they're created. */ ostype = 0; diff --git a/gcc/postreload-gcse.cc b/gcc/postreload-gcse.cc index 841fba5..fc63f0b 100644 --- a/gcc/postreload-gcse.cc +++ b/gcc/postreload-gcse.cc @@ -295,7 +295,7 @@ alloc_mem (void) /* Allocate the available expressions hash table. We don't want to make the hash table too small, but unnecessarily making it too large - also doesn't help. The i/4 is a gcse.c relic, and seems like a + also doesn't help. The i/4 is a gcse.cc relic, and seems like a reasonable choice. */ expr_table = new hash_table (MAX (i / 4, 13)); diff --git a/gcc/predict.h b/gcc/predict.h index 6cd78b8..8649974 100644 --- a/gcc/predict.h +++ b/gcc/predict.h @@ -48,7 +48,7 @@ enum prediction TAKEN }; -/* In emit-rtl.c. */ +/* In emit-rtl.cc. */ extern profile_probability split_branch_probability; extern gcov_type get_hot_bb_threshold (void); @@ -104,7 +104,7 @@ extern void change_edge_frequency (edge, profile_probability); extern void add_reg_br_prob_note (rtx_insn *, profile_probability); -/* In ipa-pure-const.c */ +/* In ipa-pure-const.cc */ extern void warn_function_cold (tree); #endif /* GCC_PREDICT_H */ diff --git a/gcc/prefix.h b/gcc/prefix.h index 6a48a87..8276eb8 100644 --- a/gcc/prefix.h +++ b/gcc/prefix.h @@ -1,4 +1,4 @@ -/* Provide prototypes for functions exported from prefix.c. +/* Provide prototypes for functions exported from prefix.cc. Copyright (C) 1999-2022 Free Software Foundation, Inc. This file is part of GCC. diff --git a/gcc/profile.h b/gcc/profile.h index dcad47d..c5b6f48 100644 --- a/gcc/profile.h +++ b/gcc/profile.h @@ -74,7 +74,7 @@ extern void del_node_map (void); extern void get_working_sets (void); /* Counter summary from the last set of coverage counts read by - profile.c. */ + profile.cc. */ extern struct gcov_summary *profile_info; #endif /* PROFILE_H */ diff --git a/gcc/read-md.cc b/gcc/read-md.cc index b22d2de..6dce411 100644 --- a/gcc/read-md.cc +++ b/gcc/read-md.cc @@ -35,7 +35,7 @@ along with GCC; see the file COPYING3. If not see #ifndef GENERATOR_FILE -/* Minimal reimplementation of errors.c for use by RTL frontend +/* Minimal reimplementation of errors.cc for use by RTL frontend within cc1. */ int have_error = 0; diff --git a/gcc/read-md.h b/gcc/read-md.h index ac11f3c..34a64fa 100644 --- a/gcc/read-md.h +++ b/gcc/read-md.h @@ -136,7 +136,7 @@ struct mapping; /* A class for reading .md files and RTL dump files. - Implemented in read-md.c. + Implemented in read-md.cc. This class has responsibility for reading chars from input files, and for certain common top-level directives including the "include" @@ -144,7 +144,7 @@ struct mapping; It does not handle parsing the hierarchically-nested expressions of rtl.def; for that see the rtx_reader subclass below (implemented in - read-rtl.c). */ + read-rtl.cc). */ class md_reader { @@ -175,7 +175,7 @@ class md_reader bool is_compact () const { return m_compact; } - /* Defined in read-md.c. */ + /* Defined in read-md.cc. */ int read_char (void); void unread_char (int ch); file_location read_name (struct md_name *name); @@ -207,7 +207,7 @@ class md_reader void fprint_c_condition (FILE *outf, const char *cond); void print_c_condition (const char *cond); - /* Defined in read-rtl.c. */ + /* Defined in read-rtl.cc. */ const char *apply_iterator_to_string (const char *string); rtx copy_rtx_for_iterators (rtx original); void read_conditions (); @@ -336,7 +336,7 @@ class noop_reader : public md_reader /* An md_reader subclass that actually handles full hierarchical rtx expressions. - Implemented in read-rtl.c. */ + Implemented in read-rtl.cc. */ class rtx_reader : public md_reader { diff --git a/gcc/read-rtl-function.cc b/gcc/read-rtl-function.cc index 918dccd..85faf2f 100644 --- a/gcc/read-rtl-function.cc +++ b/gcc/read-rtl-function.cc @@ -1,4 +1,4 @@ -/* read-rtl-function.c - Reader for RTL function dumps +/* read-rtl-function.cc - Reader for RTL function dumps Copyright (C) 2016-2022 Free Software Foundation, Inc. This file is part of GCC. @@ -515,7 +515,7 @@ function_reader::create_function () cfun->curr_properties = (PROP_cfg | PROP_rtl); - /* Do we need this to force cgraphunit.c to output the function? */ + /* Do we need this to force cgraphunit.cc to output the function? */ DECL_EXTERNAL (fndecl) = 0; DECL_PRESERVE_P (fndecl) = 1; @@ -1148,7 +1148,7 @@ function_reader::extra_parsing_for_operand_code_0 (rtx x, int idx) if (SYMBOL_REF_HAS_BLOCK_INFO_P (x)) { /* Emulate the allocation normally done by - varasm.c:create_block_symbol. */ + varasm.cc:create_block_symbol. */ unsigned int size = RTX_HDR_SIZE + sizeof (struct block_symbol); rtx new_x = (rtx) ggc_internal_alloc (size); @@ -1212,7 +1212,7 @@ function_reader::extra_parsing_for_operand_code_0 (rtx x, int idx) } /* Implementation of rtx_reader::handle_any_trailing_information. - Handle the various additional information that print-rtl.c can + Handle the various additional information that print-rtl.cc can write after the regular fields, when parsing X. */ void diff --git a/gcc/read-rtl.cc b/gcc/read-rtl.cc index 55cfec2..798d248 100644 --- a/gcc/read-rtl.cc +++ b/gcc/read-rtl.cc @@ -1081,7 +1081,7 @@ initialize_iterators (void) ]) It's not intended to appear in machine descriptions. It is - generated by (the program generated by) genconditions.c, and + generated by (the program generated by) genconditions.cc, and slipped in at the beginning of the sequence of MD files read by most of the other generators. */ void diff --git a/gcc/real.cc b/gcc/real.cc index e887418..4e63b14 100644 --- a/gcc/real.cc +++ b/gcc/real.cc @@ -1,4 +1,4 @@ -/* real.c - software floating point emulation. +/* real.cc - software floating point emulation. Copyright (C) 1993-2022 Free Software Foundation, Inc. Contributed by Stephen L. Moshier (moshier@world.std.com). Re-written by Richard Henderson diff --git a/gcc/real.h b/gcc/real.h index ca23e79..845ef29 100644 --- a/gcc/real.h +++ b/gcc/real.h @@ -48,7 +48,7 @@ struct GTY(()) real_value { /* 1 if number is signalling. */ unsigned int signalling : 1; /* 1 if number is canonical - All are generally used for handling cases in real.c. */ + All are generally used for handling cases in real.cc. */ unsigned int canonical : 1; /* unbiased exponent of the number. */ unsigned int uexp : EXP_BITS; @@ -233,7 +233,7 @@ inline format_helper::format_helper (const T &m) : m_format (m == VOIDmode ? 0 : REAL_MODE_FORMAT (m)) {} -/* Declare functions in real.c. */ +/* Declare functions in real.cc. */ /* True if the given mode has a NaN representation and the treatment of NaN operands is important. Certain optimizations, such as folding @@ -342,7 +342,7 @@ extern void real_2expN (REAL_VALUE_TYPE *, int, format_helper); extern unsigned int real_hash (const REAL_VALUE_TYPE *); -/* Target formats defined in real.c. */ +/* Target formats defined in real.cc. */ extern const struct real_format ieee_single_format; extern const struct real_format mips_single_format; extern const struct real_format motorola_single_format; @@ -488,7 +488,7 @@ extern bool exact_real_inverse (format_helper, REAL_VALUE_TYPE *); in TMODE. */ bool real_can_shorten_arithmetic (machine_mode, machine_mode); -/* In tree.c: wrap up a REAL_VALUE_TYPE in a tree node. */ +/* In tree.cc: wrap up a REAL_VALUE_TYPE in a tree node. */ extern tree build_real (tree, REAL_VALUE_TYPE); /* Likewise, but first truncate the value to the type. */ diff --git a/gcc/recog.cc b/gcc/recog.cc index d8ff40e..1c9fe71 100644 --- a/gcc/recog.cc +++ b/gcc/recog.cc @@ -61,9 +61,9 @@ struct target_recog *this_target_recog = &default_target_recog; /* Nonzero means allow operands to be volatile. This should be 0 if you are generating rtl, such as if you are calling - the functions in optabs.c and expmed.c (most of the time). + the functions in optabs.cc and expmed.cc (most of the time). This should be 1 if all valid insns need to be recognized, - such as in reginfo.c and final.c and reload.c. + such as in reginfo.cc and final.cc and reload.cc. init_recog and init_recog_no_volatile are responsible for setting this. */ @@ -86,7 +86,7 @@ static operand_alternative asm_op_alt[MAX_RECOG_OPERANDS int which_alternative; /* Nonzero after end of reload pass. - Set to 1 or 0 by toplev.c. + Set to 1 or 0 by toplev.cc. Controls the significance of (SUBREG (MEM)). */ int reload_completed; @@ -2397,7 +2397,7 @@ offsettable_nonstrict_memref_p (rtx op) We do check that it is valid for narrower modes. If STRICTP is nonzero, we require a strictly valid address, - for the sake of use in reload.c. */ + for the sake of use in reload.cc. */ bool offsettable_address_addr_space_p (int strictp, machine_mode mode, rtx y, @@ -3174,7 +3174,7 @@ constrain_operands (int strict, alternative_mask alternatives) break; /* No need to check general_operand again; - it was done in insn-recog.c. Well, except that reload + it was done in insn-recog.cc. Well, except that reload doesn't check the validity of its replacements, but that should only matter when there's a bug. */ case 'g': diff --git a/gcc/recog.h b/gcc/recog.h index b025e44..66da18d 100644 --- a/gcc/recog.h +++ b/gcc/recog.h @@ -1,4 +1,4 @@ -/* Declarations for interface to insn recognizer and insn-output.c. +/* Declarations for interface to insn recognizer and insn-output.cc. Copyright (C) 1987-2022 Free Software Foundation, Inc. This file is part of GCC. @@ -24,7 +24,7 @@ along with GCC; see the file COPYING3. If not see a type that has at least MAX_RECOG_ALTERNATIVES + 1 bits, with the extra bit giving an invalid value that can be used to mean "uninitialized". */ #define MAX_RECOG_ALTERNATIVES 35 -typedef uint64_t alternative_mask; /* Keep in sync with genattrtab.c. */ +typedef uint64_t alternative_mask; /* Keep in sync with genattrtab.cc. */ /* A mask of all alternatives. */ #define ALL_ALTERNATIVES ((alternative_mask) -1) @@ -390,7 +390,7 @@ which_op_alt () return &recog_op_alt[which_alternative * recog_data.n_operands]; } -/* A table defined in insn-output.c that give information about +/* A table defined in insn-output.cc that give information about each insn-code value. */ typedef bool (*insn_operand_predicate_fn) (rtx, machine_mode); @@ -413,7 +413,7 @@ struct insn_gen_fn // The wrapped function pointer must be public and there must not be any // constructors. Otherwise the insn_data_d struct initializers generated - // by genoutput.c will result in static initializer functions, which defeats + // by genoutput.cc will result in static initializer functions, which defeats // the purpose of the generated insn_data_d array. stored_funcptr func; }; diff --git a/gcc/reg-notes.def b/gcc/reg-notes.def index 724b744..704bc75 100644 --- a/gcc/reg-notes.def +++ b/gcc/reg-notes.def @@ -209,7 +209,7 @@ REG_NOTE (TM) ACCUMULATE_OUTGOING_ARGS is false. */ REG_NOTE (ARGS_SIZE) -/* Used for communication between IRA and caller-save.c, indicates +/* Used for communication between IRA and caller-save.cc, indicates that the return value of a call can be used to reinitialize a pseudo reg. */ REG_NOTE (RETURNED) diff --git a/gcc/reg-stack.cc b/gcc/reg-stack.cc index 27b3271..5afeadf 100644 --- a/gcc/reg-stack.cc +++ b/gcc/reg-stack.cc @@ -146,7 +146,7 @@ This asm takes two inputs, which are popped by the fyl2xp1 opcode, and replaces them with one output. The user must code the "st(1)" - clobber for reg-stack.c to know that fyl2xp1 pops both inputs. + clobber for reg-stack.cc to know that fyl2xp1 pops both inputs. asm ("fyl2xp1" : "=t" (result) : "0" (x), "u" (y) : "st(1)"); diff --git a/gcc/regs.h b/gcc/regs.h index a72a218..74f1f63 100644 --- a/gcc/regs.h +++ b/gcc/regs.h @@ -88,7 +88,7 @@ REG_N_SETS (int regno) /* Given a REG, return TRUE if the reg is a PARM_DECL, FALSE otherwise. */ extern bool reg_is_parm_p (rtx); -/* Functions defined in regstat.c. */ +/* Functions defined in regstat.cc. */ extern void regstat_init_n_sets_and_refs (void); extern void regstat_free_n_sets_and_refs (void); extern void regstat_compute_ri (void); diff --git a/gcc/regset.h b/gcc/regset.h index ef79d8d..0053538 100644 --- a/gcc/regset.h +++ b/gcc/regset.h @@ -117,7 +117,7 @@ typedef bitmap_iterator reg_set_iterator; /* An obstack for regsets. */ extern bitmap_obstack reg_obstack; -/* In df-core.c (which should use regset consistently instead of bitmap...) */ +/* In df-core.cc (which should use regset consistently instead of bitmap...) */ extern void dump_regset (regset, FILE *); #endif /* GCC_REGSET_H */ diff --git a/gcc/reload.cc b/gcc/reload.cc index 9967a9d..664082a 100644 --- a/gcc/reload.cc +++ b/gcc/reload.cc @@ -17,7 +17,7 @@ You should have received a copy of the GNU General Public License along with GCC; see the file COPYING3. If not see . */ -/* This file contains subroutines used only from the file reload1.c. +/* This file contains subroutines used only from the file reload1.cc. It knows how to scan one insn for operands and values that need to be copied into registers to make valid code. It also finds other operands and values which are valid @@ -1120,7 +1120,7 @@ push_reload (rtx in, rtx out, rtx *inloc, rtx *outloc, && LOAD_EXTEND_OP (GET_MODE (in)) == UNKNOWN && MEM_P (in)) /* This is supposed to happen only for paradoxical subregs made by - combine.c. (SUBREG (MEM)) isn't supposed to occur other ways. */ + combine.cc. (SUBREG (MEM)) isn't supposed to occur other ways. */ gcc_assert (known_le (GET_MODE_SIZE (GET_MODE (in)), GET_MODE_SIZE (inmode))); @@ -3120,7 +3120,7 @@ find_reloads (rtx_insn *insn, int replace, int ind_levels, int live_known, On machines that extend byte operations and we have a SUBREG where both the inner and outer modes are no wider than a word and the inner mode is narrower, is integral, - and gets extended when loaded from memory, combine.c has + and gets extended when loaded from memory, combine.cc has made assumptions about the behavior of the machine in such register access. If the data is, in fact, in memory we must always load using the size assumed to be in the @@ -5909,7 +5909,7 @@ find_reloads_address_1 (machine_mode mode, addr_space_t as, Note that this is actually conservative: it would be slightly more efficient to use the value of SPILL_INDIRECT_LEVELS from - reload1.c here. */ + reload1.cc here. */ find_reloads_address (GET_MODE (x), loc, XEXP (x, 0), &XEXP (x, 0), opnum, ADDR_TYPE (type), ind_levels, insn); @@ -5930,7 +5930,7 @@ find_reloads_address_1 (machine_mode mode, addr_space_t as, return 1; } -#if 0 /* This might screw code in reload1.c to delete prior output-reload +#if 0 /* This might screw code in reload1.cc to delete prior output-reload that feeds this insn. */ if (reg_equiv_mem (regno) != 0) { @@ -6412,7 +6412,7 @@ find_replacement (rtx *loc) References contained within the substructure at LOC do not count. LOC may be zero, meaning don't ignore anything. - This is similar to refers_to_regno_p in rtlanal.c except that we + This is similar to refers_to_regno_p in rtlanal.cc except that we look at equivalences for pseudos that didn't get hard registers. */ static int @@ -6531,7 +6531,7 @@ refers_to_regno_for_reload_p (unsigned int regno, unsigned int endregno, contains a MEM (we don't bother checking for memory addresses that can't conflict because we expect this to be a rare case. - This function is similar to reg_overlap_mentioned_p in rtlanal.c except + This function is similar to reg_overlap_mentioned_p in rtlanal.cc except that we look at equivalences for pseudos that didn't get hard registers. */ int @@ -6656,7 +6656,7 @@ refers_to_mem_for_reload_p (rtx x) MODE is the machine mode of the value we want an equivalence for. If GOAL is nonzero and not VOIDmode, then it must have mode MODE. - This function is used by jump.c as well as in the reload pass. + This function is used by jump.cc as well as in the reload pass. If GOAL is the sum of the stack pointer and a constant, we treat it as if it were a constant except that sp is required to be unchanging. */ diff --git a/gcc/reload.h b/gcc/reload.h index ffc05fd..927a181 100644 --- a/gcc/reload.h +++ b/gcc/reload.h @@ -1,4 +1,4 @@ -/* Communication between reload.c, reload1.c and the rest of compiler. +/* Communication between reload.cc, reload1.cc and the rest of compiler. Copyright (C) 1987-2022 Free Software Foundation, Inc. This file is part of GCC. @@ -330,7 +330,7 @@ extern class insn_chain *new_insn_chain (void); extern void compute_use_by_pseudos (HARD_REG_SET *, bitmap); #endif -/* Functions from reload.c: */ +/* Functions from reload.cc: */ extern reg_class_t secondary_reload_class (bool, reg_class_t, machine_mode, rtx); @@ -411,7 +411,7 @@ extern int push_reload (rtx, rtx, rtx *, rtx *, enum reg_class, machine_mode, machine_mode, int, int, int, enum reload_type); -/* Functions in reload1.c: */ +/* Functions in reload1.cc: */ /* Initialize the reload pass once per compilation. */ extern void init_reload (void); @@ -435,7 +435,7 @@ extern void calculate_elim_costs_all_insns (void); /* Deallocate the reload register used by reload number R. */ extern void deallocate_reload_reg (int r); -/* Functions in caller-save.c: */ +/* Functions in caller-save.cc: */ /* Initialize for caller-save. */ extern void init_caller_save (void); diff --git a/gcc/reload1.cc b/gcc/reload1.cc index 358b368..728dc2a 100644 --- a/gcc/reload1.cc +++ b/gcc/reload1.cc @@ -71,7 +71,7 @@ along with GCC; see the file COPYING3. If not see of the register class needed for each reload, and make sure that we allocate enough reload registers of each class. - The file reload.c contains the code that checks one insn for + The file reload.cc contains the code that checks one insn for validity and reports the reloads that it needs. This file is in charge of scanning the entire rtl code, accumulating the reload needs, spilling, assigning reload registers to use for @@ -7301,7 +7301,7 @@ emit_input_reload_insns (class insn_chain *chain, struct reload *rl, /* If OLDEQUIV is a pseudo with a MEM, get the real MEM and similarly for OLD. - See comments in get_secondary_reload in reload.c. */ + See comments in get_secondary_reload in reload.cc. */ /* If it is a pseudo that cannot be replaced with its equivalent MEM, we must fall back to reload_in, which will have all the necessary substitutions registered. diff --git a/gcc/reorg.cc b/gcc/reorg.cc index 510c52f..7624f51 100644 --- a/gcc/reorg.cc +++ b/gcc/reorg.cc @@ -110,7 +110,7 @@ along with GCC; see the file COPYING3. If not see /* First, some functions that were used before GCC got a control flow graph. - These functions are now only used here in reorg.c, and have therefore + These functions are now only used here in reorg.cc, and have therefore been moved here to avoid inadvertent misuse elsewhere in the compiler. */ /* Return the last label to mark the same position as LABEL. Return LABEL @@ -3112,7 +3112,7 @@ relax_delay_slots (rtx_insn *first) /* We have just removed a BARRIER, which means that the block number of the next insns has effectively been changed (see - find_basic_block in resource.c), so clear it. */ + find_basic_block in resource.cc), so clear it. */ clear_hashed_info_until_next_barrier (direct_label); } @@ -3142,7 +3142,7 @@ relax_delay_slots (rtx_insn *first) /* Be careful how we do this to avoid deleting code or labels that are momentarily dead. See similar optimization - in jump.c. + in jump.cc. We also need to ensure we properly handle the case when invert_jump fails. */ @@ -3157,7 +3157,7 @@ relax_delay_slots (rtx_insn *first) /* We have just removed a BARRIER, which means that the block number of the next insns has effectively been changed (see - find_basic_block in resource.c), so clear it. */ + find_basic_block in resource.cc), so clear it. */ if (from) clear_hashed_info_until_next_barrier (from); @@ -3420,7 +3420,7 @@ relax_delay_slots (rtx_insn *first) { /* Be careful how we do this to avoid deleting code or labels that are momentarily dead. See similar optimization in - jump.c */ + jump.cc */ if (old_label) ++LABEL_NUSES (old_label); @@ -3437,7 +3437,7 @@ relax_delay_slots (rtx_insn *first) /* We have just removed a BARRIER, which means that the block number of the next insns has effectively been changed (see - find_basic_block in resource.c), so clear it. */ + find_basic_block in resource.cc), so clear it. */ rtx_insn *from = delete_related_insns (next); if (from) clear_hashed_info_until_next_barrier (from); diff --git a/gcc/rtl.def b/gcc/rtl.def index 6593b89..08e31fa 100644 --- a/gcc/rtl.def +++ b/gcc/rtl.def @@ -39,7 +39,7 @@ along with GCC; see the file COPYING3. If not see 3. The print format, and type of each rtx->u.fld[] (field) in this rtx. These formats are stored in rtx_format[]. - The meaning of the formats is documented in front of this array in rtl.c + The meaning of the formats is documented in front of this array in rtl.cc 4. The class of the rtx. These are stored in rtx_class and are accessed via the GET_RTX_CLASS macro. They are defined as follows: @@ -81,7 +81,7 @@ along with GCC; see the file COPYING3. If not see DEF_RTL_EXPR(UNKNOWN, "UnKnown", "*", RTX_EXTRA) /* Used in the cselib routines to describe a value. Objects of this - kind are only allocated in cselib.c, in an alloc pool instead of in + kind are only allocated in cselib.cc, in an alloc pool instead of in GC memory. The only operand of a VALUE is a cselib_val. var-tracking requires this to have a distinct integral value from DECL codes in trees. */ @@ -125,7 +125,7 @@ DEF_RTL_EXPR(INT_LIST, "int_list", "ie", RTX_EXTRA) objects. Only passes after pass_free_cfg are expected to handle them. */ DEF_RTL_EXPR(SEQUENCE, "sequence", "E", RTX_EXTRA) -/* Represents a non-global base address. This is only used in alias.c. */ +/* Represents a non-global base address. This is only used in alias.cc. */ DEF_RTL_EXPR(ADDRESS, "address", "i", RTX_EXTRA) /* ---------------------------------------------------------------------- @@ -167,7 +167,7 @@ DEF_RTL_EXPR(BARRIER, "barrier", "uu00000", RTX_EXTRA) /* Holds a label that is followed by instructions. Operand: - 3: is used in jump.c for the use-count of the label. + 3: is used in jump.cc for the use-count of the label. 4: is used in the sh backend. 5: is a number that is unique in the entire compilation. 6: is the user-given name of the label, if any. */ @@ -224,7 +224,7 @@ DEF_RTL_EXPR(ASM_OPERANDS, "asm_operands", "ssiEEEi", RTX_EXTRA) 2nd operand is a unique value saying which of a number of machine-specific operations is to be performed. (Note that the vector must be the first operand because of the way that - genrecog.c record positions within an insn.) + genrecog.cc record positions within an insn.) UNSPEC can occur all by itself in a PATTERN, as a component of a PARALLEL, or inside an expression. @@ -1312,7 +1312,7 @@ DEF_RTL_EXPR(EQ_ATTR_ALT, "eq_attr_alt", "ww", RTX_EXTRA) /* A conditional expression which is true if the specified flag is true for the insn being scheduled in reorg. - genattr.c defines the following flags which can be tested by + genattr.cc defines the following flags which can be tested by (attr_flag "foo") expressions in eligible_for_delay: forward, backward. */ DEF_RTL_EXPR (ATTR_FLAG, "attr_flag", "s", RTX_EXTRA) diff --git a/gcc/rtl.h b/gcc/rtl.h index b5d629b..648f9b8 100644 --- a/gcc/rtl.h +++ b/gcc/rtl.h @@ -321,8 +321,8 @@ struct GTY((desc("0"), tag("0"), 1 in a CALL_INSN if it is a sibling call. 1 in a SET that is for a return. In a CODE_LABEL, part of the two-bit alternate entry field. - 1 in a CONCAT is VAL_EXPR_IS_COPIED in var-tracking.c. - 1 in a VALUE is SP_BASED_VALUE_P in cselib.c. + 1 in a CONCAT is VAL_EXPR_IS_COPIED in var-tracking.cc. + 1 in a VALUE is SP_BASED_VALUE_P in cselib.cc. 1 in a SUBREG generated by LRA for reload insns. 1 in a REG if this is a static chain register. Dumped as "/j" in RTL dumps. */ @@ -331,7 +331,7 @@ struct GTY((desc("0"), tag("0"), 1 in a MEM if it cannot trap. 1 in a CALL_INSN logically equivalent to ECF_LOOPING_CONST_OR_PURE and DECL_LOOPING_CONST_OR_PURE_P. - 1 in a VALUE is SP_DERIVED_VALUE_P in cselib.c. + 1 in a VALUE is SP_DERIVED_VALUE_P in cselib.cc. Dumped as "/c" in RTL dumps. */ unsigned int call : 1; /* 1 in a REG, MEM, or CONCAT if the value is set at most once, anywhere. @@ -341,8 +341,8 @@ struct GTY((desc("0"), tag("0"), 1 in a CALL_INSN logically equivalent to ECF_CONST and TREE_READONLY. 1 in a NOTE, or EXPR_LIST for a const call. 1 in a JUMP_INSN of an annulling branch. - 1 in a CONCAT is VAL_EXPR_IS_CLOBBERED in var-tracking.c. - 1 in a preserved VALUE is PRESERVED_VALUE_P in cselib.c. + 1 in a CONCAT is VAL_EXPR_IS_CLOBBERED in var-tracking.cc. + 1 in a preserved VALUE is PRESERVED_VALUE_P in cselib.cc. 1 in a clobber temporarily created for LRA. Dumped as "/u" in RTL dumps. */ unsigned int unchanging : 1; @@ -357,7 +357,7 @@ struct GTY((desc("0"), tag("0"), In a SYMBOL_REF, this flag is used for machine-specific purposes. In a PREFETCH, this flag indicates that it should be considered a scheduling barrier. - 1 in a CONCAT is VAL_NEEDS_RESOLUTION in var-tracking.c. + 1 in a CONCAT is VAL_NEEDS_RESOLUTION in var-tracking.cc. Dumped as "/v" in RTL dumps. */ unsigned int volatil : 1; /* 1 in a REG if the register is used only in exit code a loop. @@ -381,8 +381,8 @@ struct GTY((desc("0"), tag("0"), in `leaf_renumber_regs_insn'. 1 in a SYMBOL_REF, means that emit_library_call has used it as the function. - 1 in a CONCAT is VAL_HOLDS_TRACK_EXPR in var-tracking.c. - 1 in a VALUE or DEBUG_EXPR is VALUE_RECURSED_INTO in var-tracking.c. */ + 1 in a CONCAT is VAL_HOLDS_TRACK_EXPR in var-tracking.cc. + 1 in a VALUE or DEBUG_EXPR is VALUE_RECURSED_INTO in var-tracking.cc. */ unsigned int used : 1; /* 1 in an INSN or a SET if this rtx is related to the call frame, either changing how we compute the frame address or saving and @@ -390,14 +390,14 @@ struct GTY((desc("0"), tag("0"), 1 in a REG or MEM if it is a pointer. 1 in a SYMBOL_REF if it addresses something in the per-function constant string pool. - 1 in a VALUE is VALUE_CHANGED in var-tracking.c. + 1 in a VALUE is VALUE_CHANGED in var-tracking.cc. Dumped as "/f" in RTL dumps. */ unsigned frame_related : 1; /* 1 in a REG or PARALLEL that is the current function's return value. 1 in a SYMBOL_REF for a weak symbol. 1 in a CALL_INSN logically equivalent to ECF_PURE and DECL_PURE_P. - 1 in a CONCAT is VAL_EXPR_HAS_REVERSE in var-tracking.c. - 1 in a VALUE or DEBUG_EXPR is NO_LOC_P in var-tracking.c. + 1 in a CONCAT is VAL_EXPR_HAS_REVERSE in var-tracking.cc. + 1 in a VALUE or DEBUG_EXPR is NO_LOC_P in var-tracking.cc. Dumped as "/i" in RTL dumps. */ unsigned return_val : 1; @@ -1808,7 +1808,7 @@ extern const char * const note_insn_name[NOTE_INSN_MAX]; in the input source code. */ #define LABEL_NAME(RTX) XCSTR (RTX, 6, CODE_LABEL) -/* In jump.c, each label contains a count of the number +/* In jump.cc, each label contains a count of the number of LABEL_REFs that point at it, so unused labels can be deleted. */ #define LABEL_NUSES(RTX) XCINT (RTX, 4, CODE_LABEL) @@ -1862,7 +1862,7 @@ enum label_kind #define LABEL_ALT_ENTRY_P(LABEL) (LABEL_KIND (LABEL) != LABEL_NORMAL) -/* In jump.c, each JUMP_INSN can point to a label that it can jump to, +/* In jump.cc, each JUMP_INSN can point to a label that it can jump to, so that if the JUMP_INSN is deleted, the label's LABEL_NUSES can be decremented and possibly the label can be deleted. */ #define JUMP_LABEL(INSN) XCEXP (INSN, 7, JUMP_INSN) @@ -2046,7 +2046,7 @@ const_vector_encoded_nelts (const_rtx x) #define SUBREG_REG(RTX) XCEXP (RTX, 0, SUBREG) #define SUBREG_BYTE(RTX) XCSUBREG (RTX, 1, SUBREG) -/* in rtlanal.c */ +/* in rtlanal.cc */ /* Return the right cost to give to an operation to make the cost of the corresponding register-to-register instruction N times that of a fast register-to-register instruction. */ @@ -2711,7 +2711,7 @@ do { \ (RTL_FLAG_CHECK1 ("CONSTANT_POOL_ADDRESS_P", (RTX), SYMBOL_REF)->unchanging) /* 1 if RTX is a symbol_ref that addresses a value in the file's - tree constant pool. This information is private to varasm.c. */ + tree constant pool. This information is private to varasm.cc. */ #define TREE_CONSTANT_POOL_ADDRESS_P(RTX) \ (RTL_FLAG_CHECK1 ("TREE_CONSTANT_POOL_ADDRESS_P", \ (RTX), SYMBOL_REF)->frame_related) @@ -2962,13 +2962,13 @@ get_full_set_src_cost (rtx x, machine_mode mode, struct full_rtx_costs *c) && IN_RANGE ((SIZE), 1, (unsigned HOST_WIDE_INT) (RANGE) \ - (unsigned HOST_WIDE_INT)(POS))) -/* In explow.c */ +/* In explow.cc */ extern HOST_WIDE_INT trunc_int_for_mode (HOST_WIDE_INT, machine_mode); extern poly_int64 trunc_int_for_mode (poly_int64, machine_mode); extern rtx plus_constant (machine_mode, rtx, poly_int64, bool = false); extern HOST_WIDE_INT get_stack_check_protect (void); -/* In rtl.c */ +/* In rtl.cc */ extern rtx rtx_alloc (RTX_CODE CXX_MEM_STAT_INFO); inline rtx rtx_init (rtx rt, RTX_CODE code) @@ -2993,10 +2993,10 @@ extern rtx copy_rtx (rtx); extern enum rtx_code classify_insn (rtx); extern void dump_rtx_statistics (void); -/* In emit-rtl.c */ +/* In emit-rtl.cc */ extern rtx copy_rtx_if_shared (rtx); -/* In rtl.c */ +/* In rtl.cc */ extern unsigned int rtx_size (const_rtx); extern rtx shallow_copy_rtx (const_rtx CXX_MEM_STAT_INFO); extern int rtx_equal_p (const_rtx, const_rtx); @@ -3056,7 +3056,7 @@ unwrap_const_vec_duplicate (T x) return x; } -/* In emit-rtl.c. */ +/* In emit-rtl.cc. */ extern wide_int const_vector_int_elt (const_rtx, unsigned int); extern rtx const_vector_elt (const_rtx, unsigned int); extern bool const_vec_series_p_1 (const_rtx, rtx *, rtx *); @@ -3133,7 +3133,7 @@ subreg_promoted_mode (rtx x) return as_a (GET_MODE (SUBREG_REG (x))); } -/* In emit-rtl.c */ +/* In emit-rtl.cc */ extern rtvec gen_rtvec_v (int, rtx *); extern rtvec gen_rtvec_v (int, rtx_insn **); extern rtx gen_reg_rtx (machine_mode); @@ -3143,15 +3143,15 @@ extern rtx gen_reg_rtx_and_attrs (rtx); extern rtx_code_label *gen_label_rtx (void); extern rtx gen_lowpart_common (machine_mode, rtx); -/* In cse.c */ +/* In cse.cc */ extern rtx gen_lowpart_if_possible (machine_mode, rtx); -/* In emit-rtl.c */ +/* In emit-rtl.cc */ extern rtx gen_highpart (machine_mode, rtx); extern rtx gen_highpart_mode (machine_mode, machine_mode, rtx); extern rtx operand_subword (rtx, poly_uint64, int, machine_mode); -/* In emit-rtl.c */ +/* In emit-rtl.cc */ extern rtx operand_subword_force (rtx, poly_uint64, machine_mode); extern int subreg_lowpart_p (const_rtx); extern poly_uint64 subreg_size_lowpart_offset (poly_uint64, poly_uint64); @@ -3286,10 +3286,10 @@ extern rtx immed_double_const (HOST_WIDE_INT, HOST_WIDE_INT, #endif extern rtx immed_wide_int_const (const poly_wide_int_ref &, machine_mode); -/* In varasm.c */ +/* In varasm.cc */ extern rtx force_const_mem (machine_mode, rtx); -/* In varasm.c */ +/* In varasm.cc */ struct function; extern rtx get_pool_constant (const_rtx); @@ -3298,7 +3298,7 @@ extern fixed_size_mode get_pool_mode (const_rtx); extern rtx simplify_subtraction (rtx); extern void decide_function_section (tree); -/* In emit-rtl.c */ +/* In emit-rtl.cc */ extern rtx_insn *emit_insn_before (rtx, rtx_insn *); extern rtx_insn *emit_insn_before_noloc (rtx, rtx_insn *, basic_block); extern rtx_insn *emit_insn_before_setloc (rtx, rtx_insn *, location_t); @@ -3364,14 +3364,14 @@ extern rtx_insn *prev_active_insn (rtx_insn *); extern rtx_insn *next_active_insn (rtx_insn *); extern int active_insn_p (const rtx_insn *); -/* In emit-rtl.c */ +/* In emit-rtl.cc */ extern int insn_line (const rtx_insn *); extern const char * insn_file (const rtx_insn *); extern tree insn_scope (const rtx_insn *); extern expanded_location insn_location (const rtx_insn *); extern location_t prologue_location, epilogue_location; -/* In jump.c */ +/* In jump.cc */ extern enum rtx_code reverse_condition (enum rtx_code); extern enum rtx_code reverse_condition_maybe_unordered (enum rtx_code); extern enum rtx_code swap_condition (enum rtx_code); @@ -3388,19 +3388,19 @@ unsigned_condition_p (enum rtx_code code) return unsigned_condition (code) == code; } -/* In jump.c */ +/* In jump.cc */ extern rtx_insn *delete_related_insns (rtx); -/* In recog.c */ +/* In recog.cc */ extern rtx *find_constant_term_loc (rtx *); -/* In emit-rtl.c */ +/* In emit-rtl.cc */ extern rtx_insn *try_split (rtx, rtx_insn *, int); -/* In insn-recog.c (generated by genrecog). */ +/* In insn-recog.cc (generated by genrecog). */ extern rtx_insn *split_insns (rtx, rtx_insn *); -/* In simplify-rtx.c */ +/* In simplify-rtx.cc */ /* A class that records the context in which a simplification is being mode. */ @@ -3566,18 +3566,18 @@ extern bool val_signbit_known_set_p (machine_mode, extern bool val_signbit_known_clear_p (machine_mode, unsigned HOST_WIDE_INT); -/* In reginfo.c */ +/* In reginfo.cc */ extern machine_mode choose_hard_reg_mode (unsigned int, unsigned int, const predefined_function_abi *); extern const HARD_REG_SET &simplifiable_subregs (const subreg_shape &); -/* In emit-rtl.c */ +/* In emit-rtl.cc */ extern rtx set_for_reg_notes (rtx); extern rtx set_unique_reg_note (rtx, enum reg_note, rtx); extern rtx set_dst_reg_note (rtx, enum reg_note, rtx, rtx); extern void set_insn_deleted (rtx_insn *); -/* Functions in rtlanal.c */ +/* Functions in rtlanal.cc */ extern rtx single_set_2 (const rtx_insn *, const_rtx); extern rtx simple_regno_set (rtx, unsigned int); @@ -3750,7 +3750,7 @@ extern void subreg_get_info (unsigned int, machine_mode, poly_uint64, machine_mode, struct subreg_info *); -/* lists.c */ +/* lists.cc */ extern void free_EXPR_LIST_list (rtx_expr_list **); extern void free_INSN_LIST_list (rtx_insn_list **); @@ -3766,7 +3766,7 @@ extern rtx_insn *remove_free_INSN_LIST_node (rtx_insn_list **); extern rtx remove_free_EXPR_LIST_node (rtx_expr_list **); -/* reginfo.c */ +/* reginfo.cc */ /* Resize reg info. */ extern bool resize_reg_info (void); @@ -3775,7 +3775,7 @@ extern void free_reg_info (void); extern void init_subregs_of_mode (void); extern void finish_subregs_of_mode (void); -/* recog.c */ +/* recog.cc */ extern rtx extract_asm_operands (rtx); extern int asm_noperands (const_rtx); extern const char *decode_asm_operands (rtx, rtx *, rtx **, const char **, @@ -3971,7 +3971,7 @@ get_mem_attrs (const_rtx x) /* There are some RTL codes that require special attention; the generation functions included above do the raw handling. If you - add to this list, modify special_rtx in gengenrtl.c as well. */ + add to this list, modify special_rtx in gengenrtl.cc as well. */ extern rtx_expr_list *gen_rtx_EXPR_LIST (machine_mode, rtx, rtx); extern rtx_insn_list *gen_rtx_INSN_LIST (machine_mode, rtx, rtx); @@ -4089,7 +4089,7 @@ extern rtx output_constant_def (tree, int); extern rtx lookup_constant_def (tree); /* Nonzero after end of reload pass. - Set to 1 or 0 by reload1.c. */ + Set to 1 or 0 by reload1.cc. */ extern int reload_completed; @@ -4111,7 +4111,7 @@ extern int lra_in_progress; #ifdef STACK_REGS /* Nonzero after end of regstack pass. - Set to 1 or 0 by reg-stack.c. */ + Set to 1 or 0 by reg-stack.cc. */ extern int regstack_completed; #endif @@ -4129,15 +4129,15 @@ extern int cse_not_expected; extern int rtx_to_tree_code (enum rtx_code); -/* In cse.c */ +/* In cse.cc */ extern int delete_trivially_dead_insns (rtx_insn *, int); extern int exp_equiv_p (const_rtx, const_rtx, int, bool); extern unsigned hash_rtx (const_rtx x, machine_mode, int *, int *, bool); -/* In dse.c */ +/* In dse.cc */ extern bool check_for_inc_dec (rtx_insn *insn); -/* In jump.c */ +/* In jump.cc */ extern int comparison_dominates_p (enum rtx_code, enum rtx_code); extern bool jump_to_label_p (const rtx_insn *); extern int condjump_p (const rtx_insn *); @@ -4166,7 +4166,7 @@ extern enum rtx_code reversed_comparison_code_parts (enum rtx_code, const_rtx, extern void delete_for_peephole (rtx_insn *, rtx_insn *); extern int condjump_in_parallel_p (const rtx_insn *); -/* In emit-rtl.c. */ +/* In emit-rtl.cc. */ extern int max_reg_num (void); extern int max_label_num (void); extern int get_first_label_num (void); @@ -4204,23 +4204,23 @@ extern rtx gen_tmp_stack_mem (machine_mode, rtx); extern bool validate_subreg (machine_mode, machine_mode, const_rtx, poly_uint64); -/* In combine.c */ +/* In combine.cc */ extern unsigned int extended_count (const_rtx, machine_mode, int); extern rtx remove_death (unsigned int, rtx_insn *); extern void dump_combine_stats (FILE *); extern void dump_combine_total_stats (FILE *); extern rtx make_compound_operation (rtx, enum rtx_code); -/* In sched-rgn.c. */ +/* In sched-rgn.cc. */ extern void schedule_insns (void); -/* In sched-ebb.c. */ +/* In sched-ebb.cc. */ extern void schedule_ebbs (void); -/* In sel-sched-dump.c. */ +/* In sel-sched-dump.cc. */ extern void sel_sched_fix_param (const char *param, const char *val); -/* In print-rtl.c */ +/* In print-rtl.cc */ extern const char *print_rtx_head; extern void debug (const rtx_def &ref); extern void debug (const rtx_def *ptr); @@ -4235,7 +4235,7 @@ extern int print_rtl_single (FILE *, const_rtx); extern int print_rtl_single_with_indent (FILE *, const_rtx, int); extern void print_inline_rtx (FILE *, const_rtx, int); -/* In stmt.c */ +/* In stmt.cc */ extern void expand_null_return (void); extern void expand_naked_return (void); extern void emit_jump (rtx); @@ -4255,33 +4255,33 @@ enum memop_ret RETURN_END_MINUS_ONE }; -/* In expr.c */ +/* In expr.cc */ extern rtx move_by_pieces (rtx, rtx, unsigned HOST_WIDE_INT, unsigned int, memop_ret); extern poly_int64 find_args_size_adjust (rtx_insn *); extern poly_int64 fixup_args_size_notes (rtx_insn *, rtx_insn *, poly_int64); -/* In expmed.c */ +/* In expmed.cc */ extern void init_expmed (void); extern void expand_inc (rtx, rtx); extern void expand_dec (rtx, rtx); -/* In lower-subreg.c */ +/* In lower-subreg.cc */ extern void init_lower_subreg (void); -/* In gcse.c */ +/* In gcse.cc */ extern bool can_copy_p (machine_mode); extern bool can_assign_to_reg_without_clobbers_p (rtx, machine_mode); extern rtx_insn *prepare_copy_insn (rtx, rtx); -/* In cprop.c */ +/* In cprop.cc */ extern rtx fis_get_condition (rtx_insn *); -/* In ira.c */ +/* In ira.cc */ extern HARD_REG_SET eliminable_regset; extern void mark_elimination (int, int); -/* In reginfo.c */ +/* In reginfo.cc */ extern int reg_classes_intersect_p (reg_class_t, reg_class_t); extern int reg_class_subset_p (reg_class_t, reg_class_t); extern void globalize_reg (tree, int); @@ -4296,10 +4296,10 @@ extern void reg_scan (rtx_insn *, unsigned int); extern void fix_register (const char *, int, int); extern const HARD_REG_SET *valid_mode_changes_for_regno (unsigned int); -/* In reload1.c */ +/* In reload1.cc */ extern int function_invariant_p (const_rtx); -/* In calls.c */ +/* In calls.cc */ enum libcall_type { LCT_NORMAL = 0, @@ -4443,17 +4443,17 @@ emit_library_call_value (rtx fun, rtx value, libcall_type fn_type, return emit_library_call_value_1 (1, fun, value, fn_type, outmode, 4, args); } -/* In varasm.c */ +/* In varasm.cc */ extern void init_varasm_once (void); extern rtx make_debug_expr_from_rtl (const_rtx); -/* In read-rtl.c */ +/* In read-rtl.cc */ #ifdef GENERATOR_FILE extern bool read_rtx (const char *, vec *); #endif -/* In alias.c */ +/* In alias.cc */ extern rtx canon_rtx (rtx); extern int true_dependence (const_rtx, machine_mode, const_rtx); extern rtx get_addr (rtx); @@ -4483,22 +4483,22 @@ extern rtx extract_mem_from_operand (rtx); extern int stack_regs_mentioned (const_rtx insn); #endif -/* In toplev.c */ +/* In toplev.cc */ extern GTY(()) rtx stack_limit_rtx; -/* In var-tracking.c */ +/* In var-tracking.cc */ extern unsigned int variable_tracking_main (void); extern void delete_vta_debug_insns (bool); -/* In stor-layout.c. */ +/* In stor-layout.cc. */ extern void get_mode_bounds (scalar_int_mode, int, scalar_int_mode, rtx *, rtx *); -/* In loop-iv.c */ +/* In loop-iv.cc */ extern rtx canon_condition (rtx); extern void simplify_using_condition (rtx, rtx *, bitmap); -/* In final.c */ +/* In final.cc */ extern unsigned int compute_alignments (void); extern void update_alignments (vec &); extern int asm_str_count (const char *templ); @@ -4531,7 +4531,7 @@ extern void set_curr_insn_location (location_t); extern location_t curr_insn_location (void); extern void set_insn_locations (rtx_insn *, location_t); -/* rtl-error.c */ +/* rtl-error.cc */ extern void _fatal_insn_not_found (const_rtx, const char *, int, const char *) ATTRIBUTE_NORETURN ATTRIBUTE_COLD; extern void _fatal_insn (const char *, const_rtx, const char *, int, const char *) @@ -4542,7 +4542,7 @@ extern void _fatal_insn (const char *, const_rtx, const char *, int, const char #define fatal_insn_not_found(insn) \ _fatal_insn_not_found (insn, __FILE__, __LINE__, __FUNCTION__) -/* reginfo.c */ +/* reginfo.cc */ extern tree GTY(()) global_regs_decl[FIRST_PSEUDO_REGISTER]; /* Information about the function that is propagated by the RTL backend. @@ -4605,7 +4605,7 @@ word_register_operation_p (const_rtx x) } } -/* gtype-desc.c. */ +/* gtype-desc.cc. */ extern void gt_ggc_mx (rtx &); extern void gt_pch_nx (rtx &); extern void gt_pch_nx (rtx &, gt_pointer_operator, void *); diff --git a/gcc/rtlanal.cc b/gcc/rtlanal.cc index 69e7f39..e1824bf 100644 --- a/gcc/rtlanal.cc +++ b/gcc/rtlanal.cc @@ -851,7 +851,7 @@ get_call_fndecl (const rtx_insn *insn) /* Return the value of the integer term in X, if one is apparent; otherwise return 0. Only obvious integer terms are detected. - This is used in cse.c with the `related_value' field. */ + This is used in cse.cc with the `related_value' field. */ HOST_WIDE_INT get_integer_term (const_rtx x) @@ -3079,7 +3079,7 @@ side_effects_p (const_rtx x) return 0; case CLOBBER: - /* Reject CLOBBER with a non-VOID mode. These are made by combine.c + /* Reject CLOBBER with a non-VOID mode. These are made by combine.cc when some combination can't be done. If we see one, don't think that we can simplify the expression. */ return (GET_MODE (x) != VOIDmode); @@ -4362,7 +4362,7 @@ subreg_nregs (const_rtx x) } /* Return the number of registers that a subreg REG with REGNO - expression refers to. This is a copy of the rtlanal.c:subreg_nregs + expression refers to. This is a copy of the rtlanal.cc:subreg_nregs changed so that the regno can be passed in. */ unsigned int @@ -4591,7 +4591,7 @@ rtx_cost (rtx x, machine_mode mode, enum rtx_code outer_code, total = factor * factor * COSTS_N_INSNS (7); break; case USE: - /* Used in combine.c as a marker. */ + /* Used in combine.cc as a marker. */ total = 0; break; default: @@ -5877,7 +5877,7 @@ canonicalize_condition (rtx_insn *insn, rtx cond, int reverse, /* If we are comparing a register with zero, see if the register is set in the previous insn to a COMPARE or a comparison operation. Perform the same tests as a function of STORE_FLAG_VALUE as find_comparison_args - in cse.c */ + in cse.cc */ while ((GET_RTX_CLASS (code) == RTX_COMPARE || GET_RTX_CLASS (code) == RTX_COMM_COMPARE) diff --git a/gcc/rtlanal.h b/gcc/rtlanal.h index 8f6ca65..9fd84a7 100644 --- a/gcc/rtlanal.h +++ b/gcc/rtlanal.h @@ -17,7 +17,7 @@ You should have received a copy of the GNU General Public License along with GCC; see the file COPYING3. If not see . */ -/* Note that for historical reasons, many rtlanal.c functions are +/* Note that for historical reasons, many rtlanal.cc functions are declared in rtl.h rather than here. */ #ifndef GCC_RTLANAL_H @@ -187,7 +187,7 @@ rtx_properties::try_to_add_note (const_rtx x) /* Return true if the rtx has side effects, in the sense of side_effects_p (except for side_effects_p's special handling - of combine.c clobbers). */ + of combine.cc clobbers). */ inline bool rtx_properties::has_side_effects () const diff --git a/gcc/run-rtl-passes.cc b/gcc/run-rtl-passes.cc index c22e393..5399fb9 100644 --- a/gcc/run-rtl-passes.cc +++ b/gcc/run-rtl-passes.cc @@ -1,4 +1,4 @@ -/* run-rtl-passes.c - Run RTL passes directly from frontend +/* run-rtl-passes.cc - Run RTL passes directly from frontend Copyright (C) 2016-2022 Free Software Foundation, Inc. This file is part of GCC. @@ -45,7 +45,7 @@ run_rtl_passes (char *initial_pass_name) cfun->pass_startwith = initial_pass_name; max_regno = max_reg_num (); - /* cgraphunit.c normally handles this. */ + /* cgraphunit.cc normally handles this. */ switch_to_section (text_section); (*debug_hooks->assembly_start) (); diff --git a/gcc/sanitizer.def b/gcc/sanitizer.def index 1e80521..4c71858 100644 --- a/gcc/sanitizer.def +++ b/gcc/sanitizer.def @@ -24,8 +24,8 @@ along with GCC; see the file COPYING3. If not see DEF_SANITIZER_BUILTIN (ENUM, NAME, TYPE, ATTRS) See builtins.def for details. - The builtins are created by the C-family of FEs in c-family/c-common.c, - for other FEs by asan.c. */ + The builtins are created by the C-family of FEs in c-family/c-common.cc, + for other FEs by asan.cc. */ /* This has to come before all the sanitizer builtins. */ DEF_BUILTIN_STUB(BEGIN_SANITIZER_BUILTINS, (const char *)0) @@ -36,7 +36,7 @@ DEF_SANITIZER_BUILTIN(BUILT_IN_ASAN_INIT, "__asan_init", DEF_SANITIZER_BUILTIN(BUILT_IN_ASAN_VERSION_MISMATCH_CHECK, "__asan_version_mismatch_check_v8", BT_FN_VOID, ATTR_NOTHROW_LEAF_LIST) -/* Do not reorder the BUILT_IN_ASAN_{REPORT,CHECK}* builtins, e.g. cfgcleanup.c +/* Do not reorder the BUILT_IN_ASAN_{REPORT,CHECK}* builtins, e.g. cfgcleanup.cc relies on this order. */ DEF_SANITIZER_BUILTIN(BUILT_IN_ASAN_REPORT_LOAD1, "__asan_report_load1", BT_FN_VOID_PTR, ATTR_TMPURE_NORETURN_NOTHROW_LEAF_LIST) diff --git a/gcc/sched-deps.cc b/gcc/sched-deps.cc index 5b717ce..948aa0c 100644 --- a/gcc/sched-deps.cc +++ b/gcc/sched-deps.cc @@ -4269,7 +4269,7 @@ add_dependence_1 (rtx_insn *insn, rtx_insn *elem, enum reg_note dep_type) ds = DEP_ANTI; } - /* When add_dependence is called from inside sched-deps.c, we expect + /* When add_dependence is called from inside sched-deps.cc, we expect cur_insn to be non-null. */ internal = cur_insn != NULL; if (internal) diff --git a/gcc/sched-ebb.cc b/gcc/sched-ebb.cc index 04d5a27..71d72b6 100644 --- a/gcc/sched-ebb.cc +++ b/gcc/sched-ebb.cc @@ -190,7 +190,7 @@ begin_move_insn (rtx_insn *insn, rtx_insn *last) /* split_edge () creates BB before E->DEST. Keep in mind, that this operation extends scheduling region till the end of BB. - Hence, we need to shift NEXT_TAIL, so haifa-sched.c won't go out + Hence, we need to shift NEXT_TAIL, so haifa-sched.cc won't go out of the scheduling region. */ current_sched_info->next_tail = NEXT_INSN (BB_END (bb)); gcc_assert (current_sched_info->next_tail); @@ -417,7 +417,7 @@ add_deps_for_risky_insns (rtx_insn *head, rtx_insn *tail) case IRISKY: case PRISKY_CANDIDATE: /* ??? We could implement better checking PRISKY_CANDIDATEs - analogous to sched-rgn.c. */ + analogous to sched-rgn.cc. */ /* We cannot change the mode of the backward dependency because REG_DEP_ANTI has the lowest rank. */ @@ -691,7 +691,7 @@ advance_target_bb (basic_block bb, rtx_insn *insn) && control_flow_insn_p (insn) /* We handle interblock movement of the speculation check or over a speculation check in - haifa-sched.c: move_block_after_check (). */ + haifa-sched.cc: move_block_after_check (). */ && !IS_SPECULATION_BRANCHY_CHECK_P (insn) && !IS_SPECULATION_BRANCHY_CHECK_P (BB_END (bb))) { diff --git a/gcc/sched-int.h b/gcc/sched-int.h index 8720b36..5bd3f4d 100644 --- a/gcc/sched-int.h +++ b/gcc/sched-int.h @@ -131,10 +131,10 @@ extern void *xrecalloc (void *, size_t, size_t, size_t); extern void reemit_notes (rtx_insn *); -/* Functions in haifa-sched.c. */ +/* Functions in haifa-sched.cc. */ extern int haifa_classify_insn (const_rtx); -/* Functions in sel-sched-ir.c. */ +/* Functions in sel-sched-ir.cc. */ extern void sel_find_rgns (void); extern void sel_mark_hard_insn (rtx); @@ -862,7 +862,7 @@ struct _haifa_insn_data current knowledge. */ int tick_estimate; - /* See comment on QUEUE_INDEX macro in haifa-sched.c. */ + /* See comment on QUEUE_INDEX macro in haifa-sched.cc. */ int queue_index; short cost; @@ -948,8 +948,8 @@ extern vec h_i_d; #define HID(INSN) (&h_i_d[INSN_UID (INSN)]) -/* Accessor macros for h_i_d. There are more in haifa-sched.c and - sched-rgn.c. */ +/* Accessor macros for h_i_d. There are more in haifa-sched.cc and + sched-rgn.cc. */ #define INSN_PRIORITY(INSN) (HID (INSN)->priority) #define INSN_FUSION_PRIORITY(INSN) (HID (INSN)->fusion_priority) #define INSN_REG_PRESSURE(INSN) (HID (INSN)->reg_pressure) @@ -1024,7 +1024,7 @@ extern vec h_d_i_d; generated to preserve semantics of the program. The probability values can be set or retrieved using the functions - the set_dep_weak() and get_dep_weak() in sched-deps.c. The values + the set_dep_weak() and get_dep_weak() in sched-deps.cc. The values are always in the range [0, MAX_DEP_WEAK]. BEGIN_DATA : BITS_PER_DEP_WEAK @@ -1053,7 +1053,7 @@ extern vec h_d_i_d; some form of speculation. RESERVED : 1 => Reserved for use in the delay slot scheduler. - See also: check_dep_status () in sched-deps.c . */ + See also: check_dep_status () in sched-deps.cc . */ /* The number of bits per weakness probability. There are 4 weakness types and we need 8 bits for other data in a DS_T. */ @@ -1159,7 +1159,7 @@ enum SPEC_TYPES_OFFSETS { #define DEP_CANCELLED (DEP_POSTPONED << 1) -/* This represents the results of calling sched-deps.c functions, +/* This represents the results of calling sched-deps.cc functions, which modify dependencies. */ enum DEPS_ADJUST_RESULT { /* No dependence needed (e.g. producer == consumer). */ @@ -1343,7 +1343,7 @@ struct sched_deps_info_def extern struct sched_deps_info_def *sched_deps_info; -/* Functions in sched-deps.c. */ +/* Functions in sched-deps.cc. */ extern rtx sched_get_reverse_condition_uncached (const rtx_insn *); extern bool sched_insns_conditions_mutex_p (const rtx_insn *, const rtx_insn *); @@ -1389,7 +1389,7 @@ extern void extend_dependency_caches (int, bool); extern void debug_ds (ds_t); -/* Functions in haifa-sched.c. */ +/* Functions in haifa-sched.cc. */ extern void initialize_live_range_shrinkage (void); extern void finish_live_range_shrinkage (void); extern void sched_init_region_reg_pressure_info (void); @@ -1429,13 +1429,13 @@ extern rtx_insn *sched_emit_insn (rtx); extern rtx_insn *get_ready_element (int); extern int number_in_ready (void); -/* Types and functions in sched-ebb.c. */ +/* Types and functions in sched-ebb.cc. */ extern basic_block schedule_ebb (rtx_insn *, rtx_insn *, bool); extern void schedule_ebbs_init (void); extern void schedule_ebbs_finish (void); -/* Types and functions in sched-rgn.c. */ +/* Types and functions in sched-rgn.cc. */ /* A region is the main entity for interblock scheduling: insns are allowed to move between blocks in the same region, along @@ -1526,7 +1526,7 @@ extern void haifa_sched_finish (void); extern void find_modifiable_mems (rtx_insn *, rtx_insn *); -/* sched-deps.c interface to walk, add, search, update, resolve, delete +/* sched-deps.cc interface to walk, add, search, update, resolve, delete and debug instruction dependencies. */ /* Constants defining dependences lists. */ @@ -1579,7 +1579,7 @@ struct _sd_iterator typedef struct _sd_iterator sd_iterator_def; /* ??? We can move some definitions that are used in below inline functions - out of sched-int.h to sched-deps.c provided that the below functions will + out of sched-int.h to sched-deps.cc provided that the below functions will become global externals. These definitions include: * struct _deps_list: opaque pointer is needed at global scope. diff --git a/gcc/sched-rgn.cc b/gcc/sched-rgn.cc index ee92105..a0dfdb7 100644 --- a/gcc/sched-rgn.cc +++ b/gcc/sched-rgn.cc @@ -2802,7 +2802,7 @@ debug_rgn_dependencies (int from_bb) } /* Print dependencies information for instructions between HEAD and TAIL. - ??? This function would probably fit best in haifa-sched.c. */ + ??? This function would probably fit best in haifa-sched.cc. */ void debug_dependencies (rtx_insn *head, rtx_insn *tail) { rtx_insn *insn; diff --git a/gcc/sel-sched-dump.cc b/gcc/sel-sched-dump.cc index ff0e90a..efeb1cc 100644 --- a/gcc/sel-sched-dump.cc +++ b/gcc/sel-sched-dump.cc @@ -456,7 +456,7 @@ dump_lv_set (regset lv) { sel_print ("{"); - /* This code was adapted from cfg.c: dump_regset (). */ + /* This code was adapted from cfg.cc: dump_regset (). */ if (lv == NULL) sel_print ("nil"); else diff --git a/gcc/sel-sched-dump.h b/gcc/sel-sched-dump.h index 0a7a8e2..329f023 100644 --- a/gcc/sel-sched-dump.h +++ b/gcc/sel-sched-dump.h @@ -193,7 +193,7 @@ extern void debug_insn (insn_t); extern bool sched_dump_to_dot_p; -/* Functions from sel-sched-dump.c. */ +/* Functions from sel-sched-dump.cc. */ extern void sel_print (const char *fmt, ...) ATTRIBUTE_PRINTF_1; extern const char * sel_print_insn (const rtx_insn *, int); extern void free_sel_dump_data (void); diff --git a/gcc/sel-sched-ir.cc b/gcc/sel-sched-ir.cc index 5d2f797..92dcef6 100644 --- a/gcc/sel-sched-ir.cc +++ b/gcc/sel-sched-ir.cc @@ -1319,7 +1319,7 @@ sel_insn_rtx_cost (rtx_insn *insn) } /* Return the cost of the VI. - !!! FIXME: Unify with haifa-sched.c: insn_sched_cost (). */ + !!! FIXME: Unify with haifa-sched.cc: insn_sched_cost (). */ int sel_vinsn_cost (vinsn_t vi) { @@ -2678,7 +2678,7 @@ setup_id_reg_sets (idata_t id, insn_t insn) { unsigned int regno = DF_REF_REGNO (def); - /* Post modifies are treated like clobbers by sched-deps.c. */ + /* Post modifies are treated like clobbers by sched-deps.cc. */ if (DF_REF_FLAGS_IS_SET (def, (DF_REF_MUST_CLOBBER | DF_REF_PRE_POST_MODIFY))) SET_REGNO_REG_SET (IDATA_REG_CLOBBERS (id), regno); @@ -2688,7 +2688,7 @@ setup_id_reg_sets (idata_t id, insn_t insn) #ifdef STACK_REGS /* For stack registers, treat writes to them as writes - to the first one to be consistent with sched-deps.c. */ + to the first one to be consistent with sched-deps.cc. */ if (IN_RANGE (regno, FIRST_STACK_REG, LAST_STACK_REG)) SET_REGNO_REG_SET (IDATA_REG_SETS (id), FIRST_STACK_REG); #endif @@ -2713,7 +2713,7 @@ setup_id_reg_sets (idata_t id, insn_t insn) #ifdef STACK_REGS /* For stack registers, treat reads from them as reads from - the first one to be consistent with sched-deps.c. */ + the first one to be consistent with sched-deps.cc. */ if (IN_RANGE (regno, FIRST_STACK_REG, LAST_STACK_REG)) SET_REGNO_REG_SET (IDATA_REG_USES (id), FIRST_STACK_REG); #endif @@ -3124,7 +3124,7 @@ static struct deps_t dc; /* A variable to track which part of rtx we are scanning in - sched-deps.c: sched_analyze_insn (). */ + sched-deps.cc: sched_analyze_insn (). */ deps_where_t where; /* Current producer. */ @@ -3428,7 +3428,7 @@ has_dependence_p (expr_t expr, insn_t pred, ds_t **has_dep_pp) has_dependence_data.has_dep_p[DEPS_IN_INSN] = DEP_ANTI; /* Do not allow stores to memory to move through checks. Currently - we don't move this to sched-deps.c as the check doesn't have + we don't move this to sched-deps.cc as the check doesn't have obvious places to which this dependence can be attached. FIMXE: this should go to a hook. */ if (EXPR_LHS (expr) @@ -4872,7 +4872,7 @@ sel_num_cfg_preds_gt_1 (insn_t insn) } /* Returns true when BB should be the end of an ebb. Adapted from the - code in sched-ebb.c. */ + code in sched-ebb.cc. */ bool bb_ends_ebb_p (basic_block bb) { @@ -4882,7 +4882,7 @@ bb_ends_ebb_p (basic_block bb) if (next_bb == EXIT_BLOCK_PTR_FOR_FN (cfun) || bitmap_bit_p (forced_ebb_heads, next_bb->index) || (LABEL_P (BB_HEAD (next_bb)) - /* NB: LABEL_NUSES () is not maintained outside of jump.c. + /* NB: LABEL_NUSES () is not maintained outside of jump.cc. Work around that. */ && !single_pred_p (next_bb))) return true; diff --git a/gcc/sel-sched-ir.h b/gcc/sel-sched-ir.h index 6dc819a..c63d54b 100644 --- a/gcc/sel-sched-ir.h +++ b/gcc/sel-sched-ir.h @@ -356,7 +356,7 @@ struct _list_node /* _list_t functions. All of _*list_* functions are used through accessor macros, thus - we can't move them in sel-sched-ir.c. */ + we can't move them in sel-sched-ir.cc. */ extern object_allocator<_list_node> sched_lists_pool; static inline _list_t @@ -609,7 +609,7 @@ struct idata_def rtx rhs; /* Registers that are set/used by this insn. This info is now gathered - via sched-deps.c. The downside of this is that we also use live info + via sched-deps.cc. The downside of this is that we also use live info from flow that is accumulated in the basic blocks. These two infos can be slightly inconsistent, hence in the beginning we make a pass through CFG and calculating the conservative solution for the info in @@ -874,7 +874,7 @@ extern bitmap blocks_to_reschedule; /* A variable to track which part of rtx we are scanning in - sched-deps.c: sched_analyze_insn (). */ + sched-deps.cc: sched_analyze_insn (). */ enum deps_where_t { DEPS_IN_INSN, @@ -1497,7 +1497,7 @@ bb_next_bb (basic_block bb) -/* Functions that are used in sel-sched.c. */ +/* Functions that are used in sel-sched.cc. */ /* List functions. */ extern ilist_t ilist_copy (ilist_t); diff --git a/gcc/sel-sched.cc b/gcc/sel-sched.cc index e6a59a1..ea36365 100644 --- a/gcc/sel-sched.cc +++ b/gcc/sel-sched.cc @@ -160,12 +160,12 @@ along with GCC; see the file COPYING3. If not see When pipelining, we reschedule the blocks from which insns were pipelined to get a tighter schedule. On Itanium, we also perform bundling via - the same routine from ia64.c. + the same routine from ia64.cc. Dependence analysis changes =========================== - We augmented the sched-deps.c with hooks that get called when a particular + We augmented the sched-deps.cc with hooks that get called when a particular dependence is found in a particular part of an insn. Using these hooks, we can do several actions such as: determine whether an insn can be moved through another (has_dependence_p, moveup_expr); find out whether an insn can be @@ -177,7 +177,7 @@ along with GCC; see the file COPYING3. If not see Initialization changes ====================== - There are parts of haifa-sched.c, sched-deps.c, and sched-rgn.c that are + There are parts of haifa-sched.cc, sched-deps.cc, and sched-rgn.cc that are reused in all of the schedulers. We have split up the initialization of data of such parts into different functions prefixed with scheduler type and postfixed with the type of data initialized: {,sel_,haifa_}sched_{init,finish}, @@ -441,7 +441,7 @@ extern struct code_motion_path_driver_info_def move_op_hooks, fur_hooks; /* True if/when we want to emulate Haifa scheduler in the common code. This is used in sched_rgn_local_init and in various places in - sched-deps.c. */ + sched-deps.cc. */ int sched_emulate_haifa_p; /* GLOBAL_LEVEL is used to discard information stored in basic block headers @@ -976,7 +976,7 @@ vinsn_writes_one_of_regs_p (vinsn_t vi, regset used_regs, Returns NO_REGS for call insns because some targets have constraints on destination register of a call insn. - Code adopted from regrename.c::build_def_use. */ + Code adopted from regrename.cc::build_def_use. */ static enum reg_class get_reg_class (rtx_insn *insn) { @@ -1284,7 +1284,7 @@ static int reg_rename_this_tick; for single rhs since we moving it up and merging along different paths. - Some code is adapted from regrename.c (regrename_optimize). + Some code is adapted from regrename.cc (regrename_optimize). If original register is available, function returns it. Otherwise it performs the checks, so the new register should comply with the following: @@ -1471,7 +1471,7 @@ choose_best_pseudo_reg (regset used_regs, { /* Don't let register cross a call if it doesn't already cross one. This condition is written in accordance with - that in sched-deps.c sched_analyze_reg(). */ + that in sched-deps.cc sched_analyze_reg(). */ if (!reg_rename_p->crossed_call_abis || REG_N_CALLS_CROSSED (orig_regno) > 0) return gen_rtx_REG (mode, orig_regno); @@ -1544,7 +1544,7 @@ verify_target_availability (expr_t expr, regset used_regs, in which successors target register is actually available. The last condition handles the case when a dependence from a call insn - was created in sched-deps.c for insns with destination registers that + was created in sched-deps.cc for insns with destination registers that never crossed a call before, but do cross one after our code motion. FIXME: in the latter case, we just uselessly called find_used_regs, @@ -1739,7 +1739,7 @@ can_speculate_dep_p (ds_t ds) return false; { - /* FIXME: make sched-deps.c produce only those non-hard dependencies, + /* FIXME: make sched-deps.cc produce only those non-hard dependencies, that we can overcome. */ ds_t spec_mask = spec_info->mask; @@ -3403,7 +3403,7 @@ sel_rank_for_schedule (const void *x, const void *y) return val; if (spec_info != NULL && spec_info->mask != 0) - /* This code was taken from haifa-sched.c: rank_for_schedule (). */ + /* This code was taken from haifa-sched.cc: rank_for_schedule (). */ { ds_t ds1, ds2; dw_t dw1, dw2; diff --git a/gcc/selftest-run-tests.cc b/gcc/selftest-run-tests.cc index aacd126..4123e54 100644 --- a/gcc/selftest-run-tests.cc +++ b/gcc/selftest-run-tests.cc @@ -29,7 +29,7 @@ along with GCC; see the file COPYING3. If not see #include "attribs.h" #include "analyzer/analyzer-selftests.h" -/* This function needed to be split out from selftest.c as it references +/* This function needed to be split out from selftest.cc as it references tests from the whole source tree, and so is within OBJS in Makefile.in, whereas selftest.o is within OBJS-libcommon. This allows us to embed tests within files in OBJS-libcommon without @@ -45,7 +45,7 @@ selftest::run_tests () /* Makefile.in has -fself-test=$(srcdir)/testsuite/selftests, so that flag_self_test contains the path to the selftest subdirectory of the source tree (without a trailing slash). Copy it up to - path_to_selftest_files, to avoid selftest.c depending on + path_to_selftest_files, to avoid selftest.cc depending on option-handling. */ path_to_selftest_files = flag_self_test; diff --git a/gcc/selftest.h b/gcc/selftest.h index e37d06f..386c0d9 100644 --- a/gcc/selftest.h +++ b/gcc/selftest.h @@ -143,8 +143,8 @@ class auto_fix_quotes of situations: - line_table->default_range_bits: some frontends use a non-zero value and others use zero - - the fallback modes within line-map.c: there are various threshold - values for location_t beyond line-map.c changes + - the fallback modes within line-map.cc: there are various threshold + values for location_t beyond line-map.cc changes behavior (disabling of the range-packing optimization, disabling of column-tracking). We can exercise these by starting the line_table at interesting values at or near these thresholds. diff --git a/gcc/shrink-wrap.cc b/gcc/shrink-wrap.cc index f022039..30166bd 100644 --- a/gcc/shrink-wrap.cc +++ b/gcc/shrink-wrap.cc @@ -549,7 +549,7 @@ handle_simple_exit (edge e) if (e->flags & EDGE_SIBCALL) { - /* Tell function.c to take no further action on this edge. */ + /* Tell function.cc to take no further action on this edge. */ e->flags |= EDGE_IGNORE; e->flags &= ~EDGE_FALLTHRU; diff --git a/gcc/shrink-wrap.h b/gcc/shrink-wrap.h index 84dbd3f..04a7544 100644 --- a/gcc/shrink-wrap.h +++ b/gcc/shrink-wrap.h @@ -22,7 +22,7 @@ along with GCC; see the file COPYING3. If not see #include "function.h" -/* In shrink-wrap.c. */ +/* In shrink-wrap.cc. */ extern bool requires_stack_frame_p (rtx_insn *, HARD_REG_SET, HARD_REG_SET); extern void try_shrink_wrapping (edge *entry_edge, rtx_insn *prologue_seq); extern void try_shrink_wrapping_separate (basic_block first_bb); diff --git a/gcc/simplify-rtx.cc b/gcc/simplify-rtx.cc index c36c825..f17c917 100644 --- a/gcc/simplify-rtx.cc +++ b/gcc/simplify-rtx.cc @@ -2263,7 +2263,7 @@ simplify_context::simplify_associative_operation (rtx_code code, { rtx tem; - /* Normally expressions simplified by simplify-rtx.c are combined + /* Normally expressions simplified by simplify-rtx.cc are combined at most from a few machine instructions and therefore the expressions should be fairly small. During var-tracking we can see arbitrarily large expressions though and reassociating @@ -7665,10 +7665,10 @@ simplify_context::simplify_gen_vec_select (rtx op, unsigned int index) Right now GCC has three (yes, three) major bodies of RTL simplification code that need to be unified. - 1. fold_rtx in cse.c. This code uses various CSE specific + 1. fold_rtx in cse.cc. This code uses various CSE specific information to aid in RTL simplification. - 2. simplify_rtx in combine.c. Similar to fold_rtx, except that + 2. simplify_rtx in combine.cc. Similar to fold_rtx, except that it uses combine specific information to aid in RTL simplification. @@ -7686,7 +7686,7 @@ simplify_context::simplify_gen_vec_select (rtx op, unsigned int index) 3. Allow for pass dependent state to be provided to these routines and add simplifications based on the pass dependent - state. Remove code from cse.c & combine.c that becomes + state. Remove code from cse.cc & combine.cc that becomes redundant/dead. It will take time, but ultimately the compiler will be easier to diff --git a/gcc/spellcheck-tree.h b/gcc/spellcheck-tree.h index 6eeb1d6..a584d26 100644 --- a/gcc/spellcheck-tree.h +++ b/gcc/spellcheck-tree.h @@ -22,7 +22,7 @@ along with GCC; see the file COPYING3. If not see #include "spellcheck.h" -/* spellcheck-tree.c */ +/* spellcheck-tree.cc */ extern edit_distance_t get_edit_distance (tree ident_s, tree ident_t); diff --git a/gcc/spellcheck.h b/gcc/spellcheck.h index 2c56d3d..9b62236 100644 --- a/gcc/spellcheck.h +++ b/gcc/spellcheck.h @@ -23,7 +23,7 @@ along with GCC; see the file COPYING3. If not see typedef unsigned int edit_distance_t; const edit_distance_t MAX_EDIT_DISTANCE = UINT_MAX; -/* spellcheck.c */ +/* spellcheck.cc */ extern edit_distance_t get_edit_distance (const char *s, int len_s, const char *t, int len_t); diff --git a/gcc/statistics.h b/gcc/statistics.h index 79961cb..c0ce486 100644 --- a/gcc/statistics.h +++ b/gcc/statistics.h @@ -60,7 +60,7 @@ struct function; -/* In statistics.c */ +/* In statistics.cc */ extern void statistics_early_init (void); extern void statistics_init (void); extern void statistics_fini (void); diff --git a/gcc/stmt.cc b/gcc/stmt.cc index c143063..ea78a50 100644 --- a/gcc/stmt.cc +++ b/gcc/stmt.cc @@ -18,7 +18,7 @@ along with GCC; see the file COPYING3. If not see . */ /* This file handles the generation of rtl code from tree structure - above the level of expressions, using subroutines in exp*.c and emit-rtl.c. + above the level of expressions, using subroutines in exp*.c and emit-rtl.cc. The functions whose names start with `expand_' are called by the expander to generate RTL instructions for various kinds of constructs. */ @@ -736,7 +736,7 @@ conditional_probability (profile_probability target_prob, Then, a table with the target labels is emitted. The process is unaware of the CFG. The caller has to fix up - the CFG itself. This is done in cfgexpand.c. */ + the CFG itself. This is done in cfgexpand.cc. */ static void emit_case_dispatch_table (tree index_expr, tree index_type, diff --git a/gcc/stmt.h b/gcc/stmt.h index 6cfd2ed..06e15c8 100644 --- a/gcc/stmt.h +++ b/gcc/stmt.h @@ -1,4 +1,4 @@ -/* Declarations and data structures for stmt.c. +/* Declarations and data structures for stmt.cc. Copyright (C) 2013-2022 Free Software Foundation, Inc. This file is part of GCC. diff --git a/gcc/stor-layout.h b/gcc/stor-layout.h index b67abeb..22c9159 100644 --- a/gcc/stor-layout.h +++ b/gcc/stor-layout.h @@ -1,4 +1,4 @@ -/* Definitions and declarations for stor-layout.c. +/* Definitions and declarations for stor-layout.cc. Copyright (C) 2013-2022 Free Software Foundation, Inc. This file is part of GCC. diff --git a/gcc/streamer-hooks.h b/gcc/streamer-hooks.h index 4b09b21..9b1570f 100644 --- a/gcc/streamer-hooks.h +++ b/gcc/streamer-hooks.h @@ -86,7 +86,7 @@ struct streamer_hooks { /* Streamer hooks. */ extern struct streamer_hooks streamer_hooks; -/* In streamer-hooks.c. */ +/* In streamer-hooks.cc. */ void streamer_hooks_init (void); #endif /* GCC_STREAMER_HOOKS_H */ diff --git a/gcc/stringpool.h b/gcc/stringpool.h index 3f88a06..5e301c6 100644 --- a/gcc/stringpool.h +++ b/gcc/stringpool.h @@ -1,4 +1,4 @@ -/* Declarations and definitons for stringpool.c. +/* Declarations and definitons for stringpool.cc. Copyright (C) 2013-2022 Free Software Foundation, Inc. This file is part of GCC. diff --git a/gcc/symtab.cc b/gcc/symtab.cc index 87cd560..8670337 100644 --- a/gcc/symtab.cc +++ b/gcc/symtab.cc @@ -310,7 +310,7 @@ symbol_table::change_decl_assembler_name (tree decl, tree name) } /* If we change assembler name, also all transparent aliases must be updated. There are three kinds - those having same assembler name, - those being renamed in varasm.c and weakref being renamed by the + those being renamed in varasm.cc and weakref being renamed by the assembler. */ if (node) { diff --git a/gcc/target.def b/gcc/target.def index 8fd2533..57e64b2 100644 --- a/gcc/target.def +++ b/gcc/target.def @@ -423,7 +423,7 @@ function's arguments that this function should pop is available in\n\ DEFHOOK (init_sections, "Define this hook if you need to do something special to set up the\n\ -@file{varasm.c} sections, or if your target has some special sections\n\ +@file{varasm.cc} sections, or if your target has some special sections\n\ of its own that you need to create.\n\ \n\ GCC calls this hook after processing the command line, but before writing\n\ @@ -918,7 +918,7 @@ DEFHOOK_UNDOC ASM_OUTPUT_LABELREF, returning result as an IDENTIFIER_NODE. */ DEFHOOK (mangle_assembler_name, - "Given a symbol @var{name}, perform same mangling as @code{varasm.c}'s\n\ + "Given a symbol @var{name}, perform same mangling as @code{varasm.cc}'s\n\ @code{assemble_name}, but in memory rather than to a file stream, returning\n\ result as an @code{IDENTIFIER_NODE}. Required for correct LTO symtabs. The\n\ default implementation calls the @code{TARGET_STRIP_NAME_ENCODING} hook and\n\ @@ -929,7 +929,7 @@ then prepends the @code{USER_LABEL_PREFIX}, if any.", HOOK_VECTOR_END (asm_out) /* Functions relating to instruction scheduling. All of these - default to null pointers, which haifa-sched.c looks for and handles. */ + default to null pointers, which haifa-sched.cc looks for and handles. */ #undef HOOK_PREFIX #define HOOK_PREFIX "TARGET_SCHED_" HOOK_VECTOR (TARGET_SCHED, sched) @@ -2182,7 +2182,7 @@ the expansion of @code{TARGET_MERGE_DECL_ATTRIBUTES}. You can also\n\ add @code{handle_dll_attribute} in the attribute table for your port\n\ to perform initial processing of the @samp{dllimport} and\n\ @samp{dllexport} attributes. This is done in @file{i386/cygwin.h} and\n\ -@file{i386/i386.c}, for example.", +@file{i386/i386.cc}, for example.", tree, (tree olddecl, tree newdecl), merge_decl_attributes) @@ -2565,7 +2565,7 @@ ordinary types as @samp{@w{U @var{n} @var{name} @var{code}}}, where\n\ @var{name} is the name used for the type qualifier in source code,\n\ @var{n} is the length of @var{name} as above, and @var{code} is the\n\ code used to represent the unqualified version of this type. (See\n\ -@code{write_builtin_type} in @file{cp/mangle.c} for the list of\n\ +@code{write_builtin_type} in @file{cp/mangle.cc} for the list of\n\ codes.) In both cases the spaces are for clarity; do not include any\n\ spaces in your string.\n\ \n\ @@ -2585,7 +2585,7 @@ DEFHOOK (init_libfuncs, "This hook should declare additional library routines or rename\n\ existing ones, using the functions @code{set_optab_libfunc} and\n\ -@code{init_one_libfunc} defined in @file{optabs.c}.\n\ +@code{init_one_libfunc} defined in @file{optabs.cc}.\n\ @code{init_optabs} calls this macro after initializing all the normal\n\ library routines.\n\ \n\ @@ -3123,7 +3123,7 @@ encode more than one bit of information, but this practice is now\n\ discouraged; use @code{SYMBOL_REF_FLAGS}.\n\ \n\ The default definition of this hook, @code{default_encode_section_info}\n\ -in @file{varasm.c}, sets a number of commonly-useful bits in\n\ +in @file{varasm.cc}, sets a number of commonly-useful bits in\n\ @code{SYMBOL_REF_FLAGS}. Check whether the default does what you need\n\ before overriding it.", void, (tree decl, rtx rtl, int new_decl_p), @@ -3442,7 +3442,7 @@ must work.\n\ The default version of this hook returns true for any mode\n\ required to handle the basic C types (as defined by the port).\n\ Included here are the double-word arithmetic supported by the\n\ -code in @file{optabs.c}.", +code in @file{optabs.cc}.", bool, (scalar_mode mode), default_scalar_mode_supported_p) @@ -3964,7 +3964,7 @@ allocation.", rtx, (rtx hard_reg), NULL) /* Return nonzero if evaluating UNSPEC X might cause a trap. - FLAGS has the same meaning as in rtlanal.c: may_trap_p_1. */ + FLAGS has the same meaning as in rtlanal.cc: may_trap_p_1. */ DEFHOOK (unspec_may_trap_p, "This target hook returns nonzero if @var{x}, an @code{unspec} or\n\ @@ -4135,7 +4135,7 @@ DEFHOOK "This hook performs target-specific gimplification of\n\ @code{VA_ARG_EXPR}. The first two parameters correspond to the\n\ arguments to @code{va_arg}; the latter two are as in\n\ -@code{gimplify.c:gimplify_expr}.", +@code{gimplify.cc:gimplify_expr}.", tree, (tree valist, tree type, gimple_seq *pre_p, gimple_seq *post_p), std_gimplify_va_arg_expr) @@ -5568,7 +5568,7 @@ Normally, this is not needed.", bool, (const_tree field, machine_mode mode), default_member_type_forces_blk) -/* See tree-ssa-math-opts.c:divmod_candidate_p for conditions +/* See tree-ssa-math-opts.cc:divmod_candidate_p for conditions that gate the divod transform. */ DEFHOOK (expand_divmod_libfunc, @@ -5697,7 +5697,7 @@ However, this default behavior is not correct on some machines, such as\n\ the DEC Alpha, that store short integers in floating-point registers\n\ differently than in integer registers. On those machines, the default\n\ widening will not work correctly and you must define this hook to\n\ -suppress that widening in some cases. See the file @file{alpha.c} for\n\ +suppress that widening in some cases. See the file @file{alpha.cc} for\n\ details.\n\ \n\ With LRA, the default is to use @var{mode} unmodified.", diff --git a/gcc/target.h b/gcc/target.h index a404276..d6fa693 100644 --- a/gcc/target.h +++ b/gcc/target.h @@ -70,7 +70,7 @@ union cumulative_args_t { void *p; }; /* Types of memory operation understood by the "by_pieces" infrastructure. Used by the TARGET_USE_BY_PIECES_INFRASTRUCTURE_P target hook and - internally by the functions in expr.c. */ + internally by the functions in expr.cc. */ enum by_pieces_operation { @@ -86,7 +86,7 @@ extern unsigned HOST_WIDE_INT by_pieces_ninsns (unsigned HOST_WIDE_INT, unsigned int, by_pieces_operation); -/* An example implementation for ELF targets. Defined in varasm.c */ +/* An example implementation for ELF targets. Defined in varasm.cc */ extern void elf_record_gcc_switches (const char *); /* Some places still assume that all pointer or address modes are the @@ -143,7 +143,7 @@ class function_arg_info; /* This is defined in function-abi.h. */ class predefined_function_abi; -/* These are defined in tree-vect-stmts.c. */ +/* These are defined in tree-vect-stmts.cc. */ extern tree stmt_vectype (class _stmt_vec_info *); extern bool stmt_in_inner_loop_p (class vec_info *, class _stmt_vec_info *); diff --git a/gcc/targhooks.cc b/gcc/targhooks.cc index 116a23b..fc49235 100644 --- a/gcc/targhooks.cc +++ b/gcc/targhooks.cc @@ -412,7 +412,7 @@ default_translate_mode_attribute (machine_mode mode) By default we guess this means that any C type is supported. If we can't map the mode back to a type that would be available in C, then reject it. Special case, here, is the double-word arithmetic - supported by optabs.c. */ + supported by optabs.cc. */ bool default_scalar_mode_supported_p (scalar_mode mode) diff --git a/gcc/timevar.def b/gcc/timevar.def index 9729627..c239e8e 100644 --- a/gcc/timevar.def +++ b/gcc/timevar.def @@ -20,7 +20,7 @@ . */ /* This file contains timing variable definitions, used by timevar.h - and timevar.c. + and timevar.cc. Syntax: diff --git a/gcc/timevar.h b/gcc/timevar.h index db33aa0..5715d69 100644 --- a/gcc/timevar.h +++ b/gcc/timevar.h @@ -175,7 +175,7 @@ class timer /* A class for managing a collection of named timing items, for use e.g. by libgccjit for timing client code. This class is declared - inside timevar.c to avoid everything using timevar.h + inside timevar.cc to avoid everything using timevar.h from needing vec and hash_map. */ class named_items; diff --git a/gcc/toplev.h b/gcc/toplev.h index d399734..a82ef8b 100644 --- a/gcc/toplev.h +++ b/gcc/toplev.h @@ -1,4 +1,4 @@ -/* toplev.h - Various declarations for functions found in toplev.c +/* toplev.h - Various declarations for functions found in toplev.cc Copyright (C) 1998-2022 Free Software Foundation, Inc. This file is part of GCC. @@ -54,9 +54,9 @@ extern void rest_of_type_compilation (tree, int); extern void init_optimization_passes (void); extern bool enable_rtl_dump_file (void); -/* In except.c. Initialize exception handling. This is used by the Ada - and LTO front ends to initialize EH "on demand". See lto-streamer-in.c - and ada/gcc-interface/misc.c. */ +/* In except.cc. Initialize exception handling. This is used by the Ada + and LTO front ends to initialize EH "on demand". See lto-streamer-in.cc + and ada/gcc-interface/misc.cc. */ extern void init_eh (void); extern void announce_function (tree); @@ -76,7 +76,7 @@ extern void target_reinit (void); /* A unique local time stamp, might be zero if none is available. */ extern unsigned local_tick; -/* See toplev.c. */ +/* See toplev.cc. */ extern int flag_rerun_cse_after_global_opts; extern void print_version (FILE *, const char *, bool); diff --git a/gcc/trans-mem.cc b/gcc/trans-mem.cc index ad568a8..e9feac2 100644 --- a/gcc/trans-mem.cc +++ b/gcc/trans-mem.cc @@ -80,7 +80,7 @@ __tm_abort; } - During initial gimplification (gimplify.c) the TRANSACTION_EXPR node is + During initial gimplification (gimplify.cc) the TRANSACTION_EXPR node is trivially replaced with a GIMPLE_TRANSACTION node. During pass_lower_tm, we examine the body of transactions looking @@ -2765,7 +2765,7 @@ collect_bb2reg (struct tm_region *region, void *data) // as we have no info within the program that suggests that the blocks cannot // be shared. // -// ??? There is currently a hack inside tree-ssa-pre.c to work around the +// ??? There is currently a hack inside tree-ssa-pre.cc to work around the // only known instance of this block sharing. static vec diff --git a/gcc/tree-call-cdce.cc b/gcc/tree-call-cdce.cc index 08adcda..83991fe 100644 --- a/gcc/tree-call-cdce.cc +++ b/gcc/tree-call-cdce.cc @@ -663,7 +663,7 @@ gen_conditions_for_pow (gcall *pow_call, vec conds, assumption is that single precision float type is always SF mode, and double type is DF mode. This function is quite implementation specific, so it may not be suitable to be part of - builtins.c. This needs to be revisited later to see if it can + builtins.cc. This needs to be revisited later to see if it can be leveraged in x87 assembly expansion. */ static inp_domain diff --git a/gcc/tree-cfg.cc b/gcc/tree-cfg.cc index 14f121d..4a8e224 100644 --- a/gcc/tree-cfg.cc +++ b/gcc/tree-cfg.cc @@ -2275,7 +2275,7 @@ remove_bb (basic_block bb) { /* Walk backwards so as to get a chance to substitute all released DEFs into debug stmts. See - eliminate_unnecessary_stmts() in tree-ssa-dce.c for more + eliminate_unnecessary_stmts() in tree-ssa-dce.cc for more details. */ for (i = gsi_last_bb (bb); !gsi_end_p (i);) { @@ -4925,7 +4925,7 @@ verify_gimple_debug (gimple *stmt ATTRIBUTE_UNUSED) a VAR_DECL or a PARM_DECL, but that could also be some scalarized component or member of an aggregate type, to another tree, that can be an arbitrary expression. These stmts expand into debug - insns, and are converted to debug notes by var-tracking.c. */ + insns, and are converted to debug notes by var-tracking.cc. */ return false; } @@ -8825,7 +8825,7 @@ remove_edge_and_dominated_blocks (edge e) { /* Walk backwards so as to get a chance to substitute all released DEFs into debug stmts. See - eliminate_unnecessary_stmts() in tree-ssa-dce.c for more + eliminate_unnecessary_stmts() in tree-ssa-dce.cc for more details. */ for (i = bbs_to_remove.length (); i-- > 0; ) delete_basic_block (bbs_to_remove[i]); @@ -9983,7 +9983,7 @@ push_fndecl (const char *name) } /* These tests directly create CFGs. - Compare with the static fns within tree-cfg.c: + Compare with the static fns within tree-cfg.cc: - build_gimple_cfg - make_blocks: calls create_basic_block (seq, bb); - make_edges. */ diff --git a/gcc/tree-cfgcleanup.h b/gcc/tree-cfgcleanup.h index 97f9632..16f5f3e 100644 --- a/gcc/tree-cfgcleanup.h +++ b/gcc/tree-cfgcleanup.h @@ -20,7 +20,7 @@ along with GCC; see the file COPYING3. If not see #ifndef GCC_TREE_CFGCLEANUP_H #define GCC_TREE_CFGCLEANUP_H -/* In tree-cfgcleanup.c */ +/* In tree-cfgcleanup.cc */ extern bitmap cfgcleanup_altered_bbs; extern bool cleanup_tree_cfg (unsigned = 0); extern bool fixup_noreturn_call (gimple *stmt); diff --git a/gcc/tree-complex.cc b/gcc/tree-complex.cc index 9acb1ad..8f03b23 100644 --- a/gcc/tree-complex.cc +++ b/gcc/tree-complex.cc @@ -1237,7 +1237,7 @@ expand_complex_multiplication (gimple_stmt_iterator *gsi, tree type, update_complex_assignment (gsi, rr, ri); } -/* Keep this algorithm in sync with fold-const.c:const_binop(). +/* Keep this algorithm in sync with fold-const.cc:const_binop(). Expand complex division to scalars, straightforward algorithm. a / b = ((ar*br + ai*bi)/t) + i((ai*br - ar*bi)/t) @@ -1271,7 +1271,7 @@ expand_complex_div_straight (gimple_stmt_iterator *gsi, tree inner_type, update_complex_assignment (gsi, rr, ri); } -/* Keep this algorithm in sync with fold-const.c:const_binop(). +/* Keep this algorithm in sync with fold-const.cc:const_binop(). Expand complex division to scalars, modified algorithm to minimize overflow with wide input ranges. */ diff --git a/gcc/tree-core.h b/gcc/tree-core.h index 61ae4bd..e83669f 100644 --- a/gcc/tree-core.h +++ b/gcc/tree-core.h @@ -686,7 +686,7 @@ enum tree_index { /* Put the complex types after their component types, so that in (sequential) tree streaming we can assert that their component types have already been - handled (see tree-streamer.c:record_common_node). */ + handled (see tree-streamer.cc:record_common_node). */ TI_COMPLEX_INTEGER_TYPE, TI_COMPLEX_FLOAT_TYPE, TI_COMPLEX_DOUBLE_TYPE, @@ -821,7 +821,7 @@ enum tree_index { /* An enumeration of the standard C integer types. These must be ordered so that shorter types appear before longer ones, and so that signed types appear before unsigned ones, for the correct - functioning of interpret_integer() in c-lex.c. */ + functioning of interpret_integer() in c-lex.cc. */ enum integer_type_kind { itk_char, itk_signed_char, @@ -933,7 +933,7 @@ enum operand_equal_flag { }; /* Enum and arrays used for tree allocation stats. - Keep in sync with tree.c:tree_node_kind_names. */ + Keep in sync with tree.cc:tree_node_kind_names. */ enum tree_node_kind { d_kind, t_kind, diff --git a/gcc/tree-eh.cc b/gcc/tree-eh.cc index 0f8a3ad..c37a584 100644 --- a/gcc/tree-eh.cc +++ b/gcc/tree-eh.cc @@ -1020,7 +1020,7 @@ honor_protect_cleanup_actions (struct leh_state *outer_state, set, the handler of the TRY_CATCH_EXPR is another cleanup which ought to be in an enclosing scope, but needs to be implemented at this level to avoid a nesting violation (see wrap_temporary_cleanups in - cp/decl.c). Since it's logically at an outer level, we should call + cp/decl.cc). Since it's logically at an outer level, we should call terminate before we get to it, so strip it away before adding the MUST_NOT_THROW filter. */ gimple_stmt_iterator gsi = gsi_start (finally); diff --git a/gcc/tree-if-conv.cc b/gcc/tree-if-conv.cc index 8baecea..375628e 100644 --- a/gcc/tree-if-conv.cc +++ b/gcc/tree-if-conv.cc @@ -1029,7 +1029,7 @@ if_convertible_gimple_assign_stmt_p (gimple *stmt, return false; } - /* tree-into-ssa.c uses GF_PLF_1, so avoid it, because + /* tree-into-ssa.cc uses GF_PLF_1, so avoid it, because in between if_convertible_loop_p and combine_blocks we can perform loop versioning. */ gimple_set_plf (stmt, GF_PLF_2, false); diff --git a/gcc/tree-inline.cc b/gcc/tree-inline.cc index 8ea8de7..497aa66 100644 --- a/gcc/tree-inline.cc +++ b/gcc/tree-inline.cc @@ -3673,7 +3673,7 @@ initialize_inlined_parameters (copy_body_data *id, gimple *stmt, gcc_assert (fn != current_function_decl); if (p) { - /* No static chain? Seems like a bug in tree-nested.c. */ + /* No static chain? Seems like a bug in tree-nested.cc. */ gcc_assert (static_chain); setup_one_parameter (id, p, static_chain, fn, bb, &vars); diff --git a/gcc/tree-inline.h b/gcc/tree-inline.h index 80c0da0..c601cad 100644 --- a/gcc/tree-inline.h +++ b/gcc/tree-inline.h @@ -249,7 +249,7 @@ extern tree copy_decl_for_dup_finish (copy_body_data *id, tree decl, tree copy); extern tree copy_decl_to_var (tree, copy_body_data *); extern tree force_value_to_type (tree type, tree value); -/* This is in tree-inline.c since the routine uses +/* This is in tree-inline.cc since the routine uses data structures from the inliner. */ extern tree build_duplicate_type (tree); diff --git a/gcc/tree-nested.cc b/gcc/tree-nested.cc index 1c322cb..b7e9a3b 100644 --- a/gcc/tree-nested.cc +++ b/gcc/tree-nested.cc @@ -480,7 +480,7 @@ get_chain_decl (struct nesting_info *info) DECL_CONTEXT (decl) = info->context; DECL_ARG_TYPE (decl) = type; - /* Tell tree-inline.c that we never write to this variable, so + /* Tell tree-inline.cc that we never write to this variable, so it can copy-prop the replacement value immediately. */ TREE_READONLY (decl) = 1; @@ -906,7 +906,7 @@ walk_all_functions (walk_stmt_fn callback_stmt, walk_tree_fn callback_op, trying to inline to use for checking whether any argument is variably modified by anything in it. - It would be better to do this in tree-inline.c so that we could give + It would be better to do this in tree-inline.cc so that we could give the appropriate warning for why a function can't be inlined, but that's too late since the nesting structure has already been flattened and adding a flag just to record this fact seems a waste of a flag. */ diff --git a/gcc/tree-object-size.h b/gcc/tree-object-size.h index aeccb99..f9431c3 100644 --- a/gcc/tree-object-size.h +++ b/gcc/tree-object-size.h @@ -1,4 +1,4 @@ -/* Declarations for tree-object-size.c. +/* Declarations for tree-object-size.cc. Copyright (C) 2013-2022 Free Software Foundation, Inc. This file is part of GCC. diff --git a/gcc/tree-outof-ssa.cc b/gcc/tree-outof-ssa.cc index 65d4de3..ec88312 100644 --- a/gcc/tree-outof-ssa.cc +++ b/gcc/tree-outof-ssa.cc @@ -47,7 +47,7 @@ along with GCC; see the file COPYING3. If not see #include "dojump.h" /* FIXME: A lot of code here deals with expanding to RTL. All that code - should be in cfgexpand.c. */ + should be in cfgexpand.cc. */ #include "explow.h" #include "expr.h" diff --git a/gcc/tree-parloops.cc b/gcc/tree-parloops.cc index e2df7e1..7fcb0d5 100644 --- a/gcc/tree-parloops.cc +++ b/gcc/tree-parloops.cc @@ -2867,7 +2867,7 @@ create_parallel_loop (class loop *loop, tree loop_fn, tree data, /* Emit GIMPLE_OMP_FOR. */ if (oacc_kernels_p) /* Parallelized OpenACC kernels constructs use gang parallelism. See also - omp-offload.c:execute_oacc_loop_designation. */ + omp-offload.cc:execute_oacc_loop_designation. */ t = build_omp_clause (loc, OMP_CLAUSE_GANG); else { diff --git a/gcc/tree-pretty-print.cc b/gcc/tree-pretty-print.cc index 3526625..6130c30 100644 --- a/gcc/tree-pretty-print.cc +++ b/gcc/tree-pretty-print.cc @@ -1,6 +1,6 @@ /* Pretty formatting of GENERIC trees in C syntax. Copyright (C) 2001-2022 Free Software Foundation, Inc. - Adapted from c-pretty-print.c by Diego Novillo + Adapted from c-pretty-print.cc by Diego Novillo This file is part of GCC. @@ -188,7 +188,7 @@ print_generic_expr_to_str (tree t) /* Dump NAME, an IDENTIFIER_POINTER, sanitized so that D sequences in it are replaced with Dxxxx, as long as they are at the start or preceded by $ and at the end or followed by $. See make_fancy_name - in tree-sra.c. */ + in tree-sra.cc. */ static void dump_fancy_name (pretty_printer *pp, tree name) @@ -2118,7 +2118,7 @@ dump_generic_node (pretty_printer *pp, tree node, int spc, dump_flags_t flags, in such a way that the two INTEGER_CST nodes for "5" have different values but identical types. In the latter - case, the 5 is multiplied by sizeof (int) in c-common.c + case, the 5 is multiplied by sizeof (int) in c-common.cc (pointer_int_sum) to convert it to a byte address, and yet the type of the node is left unchanged. Argh. What is consistent though is that the number value corresponds diff --git a/gcc/tree-profile.cc b/gcc/tree-profile.cc index 20420d2..6d40401 100644 --- a/gcc/tree-profile.cc +++ b/gcc/tree-profile.cc @@ -22,7 +22,7 @@ along with GCC; see the file COPYING3. If not see . */ /* Generate basic block profile instrumentation and auxiliary files. - Tree-based version. See profile.c for overview. */ + Tree-based version. See profile.cc for overview. */ #include "config.h" #include "system.h" @@ -720,7 +720,7 @@ tree_profiling (void) ? PROFILE_UPDATE_ATOMIC : PROFILE_UPDATE_SINGLE; /* This is a small-ipa pass that gets called only once, from - cgraphunit.c:ipa_passes(). */ + cgraphunit.cc:ipa_passes(). */ gcc_assert (symtab->state == IPA_SSA); init_node_map (true); diff --git a/gcc/tree-sra.cc b/gcc/tree-sra.cc index e0ea2c7..a86f8c0 100644 --- a/gcc/tree-sra.cc +++ b/gcc/tree-sra.cc @@ -1920,7 +1920,7 @@ maybe_add_sra_candidate (tree var) reject (var, msg); return false; } - if (/* Fix for PR 41089. tree-stdarg.c needs to have va_lists intact but + if (/* Fix for PR 41089. tree-stdarg.cc needs to have va_lists intact but we also want to schedule it rather late. Thus we ignore it in the early pass. */ (sra_mode == SRA_MODE_EARLY_INTRA diff --git a/gcc/tree-ssa-address.cc b/gcc/tree-ssa-address.cc index 04ff156..ba7b7c9 100644 --- a/gcc/tree-ssa-address.cc +++ b/gcc/tree-ssa-address.cc @@ -72,7 +72,7 @@ along with GCC; see the file COPYING3. If not see be incorrect for (4) or (5). An incorrect result here does not cause incorrect results out the - back end, because the expander in expr.c validizes the address. However + back end, because the expander in expr.cc validizes the address. However it would be nice to improve the handling here in order to produce more precise results. */ diff --git a/gcc/tree-ssa-alias.cc b/gcc/tree-ssa-alias.cc index 8bb79b8..d434446 100644 --- a/gcc/tree-ssa-alias.cc +++ b/gcc/tree-ssa-alias.cc @@ -94,7 +94,7 @@ along with GCC; see the file COPYING3. If not see More low-level disambiguators are available and documented in this file. Low-level disambiguators dealing with points-to - information are in tree-ssa-structalias.c. */ + information are in tree-ssa-structalias.cc. */ static int nonoverlapping_refs_since_match_p (tree, tree, tree, tree, bool); static bool nonoverlapping_component_refs_p (const_tree, const_tree); diff --git a/gcc/tree-ssa-alias.h b/gcc/tree-ssa-alias.h index 831dcae..6ae1a65 100644 --- a/gcc/tree-ssa-alias.h +++ b/gcc/tree-ssa-alias.h @@ -108,7 +108,7 @@ ao_ref::max_size_known_p () const return known_size_p (max_size); } -/* In tree-ssa-alias.c */ +/* In tree-ssa-alias.cc */ extern void ao_ref_init (ao_ref *, tree); extern void ao_ref_init_from_ptr_and_size (ao_ref *, tree, tree); extern void ao_ref_init_from_ptr_and_range (ao_ref *, tree, bool, @@ -165,7 +165,7 @@ extern void debug_points_to_info_for (tree); extern void dump_alias_stats (FILE *); -/* In tree-ssa-structalias.c */ +/* In tree-ssa-structalias.cc */ extern unsigned int compute_may_aliases (void); extern bool pt_solution_empty_p (const pt_solution *); extern bool pt_solution_singleton_or_null_p (struct pt_solution *, unsigned *); diff --git a/gcc/tree-ssa-ccp.cc b/gcc/tree-ssa-ccp.cc index 93fa536..48683f04 100644 --- a/gcc/tree-ssa-ccp.cc +++ b/gcc/tree-ssa-ccp.cc @@ -20,7 +20,7 @@ along with GCC; see the file COPYING3. If not see . */ /* Conditional constant propagation (CCP) is based on the SSA - propagation engine (tree-ssa-propagate.c). Constant assignments of + propagation engine (tree-ssa-propagate.cc). Constant assignments of the form VAR = CST are propagated from the assignments into uses of VAR, which in turn may generate new constants. The simulation uses a four level lattice to keep track of constant values associated diff --git a/gcc/tree-ssa-coalesce.h b/gcc/tree-ssa-coalesce.h index 68bc1a6..ef4610b 100644 --- a/gcc/tree-ssa-coalesce.h +++ b/gcc/tree-ssa-coalesce.h @@ -1,4 +1,4 @@ -/* Header file for tree-ssa-coalesce.c exports. +/* Header file for tree-ssa-coalesce.cc exports. Copyright (C) 2013-2022 Free Software Foundation, Inc. This file is part of GCC. diff --git a/gcc/tree-ssa-live.cc b/gcc/tree-ssa-live.cc index 2076640..3196c6a 100644 --- a/gcc/tree-ssa-live.cc +++ b/gcc/tree-ssa-live.cc @@ -417,7 +417,7 @@ remove_unused_scope_block_p (tree scope, bool in_ctor_dtor_block) bool unused = !TREE_USED (scope); int nsubblocks = 0; - /* For ipa-polymorphic-call.c purposes, preserve blocks: + /* For ipa-polymorphic-call.cc purposes, preserve blocks: 1) with BLOCK_ABSTRACT_ORIGIN of a ctor/dtor or their clones */ if (inlined_polymorphic_ctor_dtor_block_p (scope, true)) { diff --git a/gcc/tree-ssa-loop-manip.cc b/gcc/tree-ssa-loop-manip.cc index c7600f9..770cbd2 100644 --- a/gcc/tree-ssa-loop-manip.cc +++ b/gcc/tree-ssa-loop-manip.cc @@ -911,7 +911,7 @@ copy_phi_node_args (unsigned first_new_block) } -/* The same as cfgloopmanip.c:duplicate_loop_body_to_header_edge, but also +/* The same as cfgloopmanip.cc:duplicate_loop_body_to_header_edge, but also updates the PHI nodes at start of the copied region. In order to achieve this, only loops whose exits all lead to the same location are handled. diff --git a/gcc/tree-ssa-loop-unswitch.cc b/gcc/tree-ssa-loop-unswitch.cc index 46a6ff5..a405119 100644 --- a/gcc/tree-ssa-loop-unswitch.cc +++ b/gcc/tree-ssa-loop-unswitch.cc @@ -72,7 +72,7 @@ along with GCC; see the file COPYING3. If not see } Inv is considered invariant iff the values it compares are both invariant; - tree-ssa-loop-im.c ensures that all the suitable conditions are in this + tree-ssa-loop-im.cc ensures that all the suitable conditions are in this shape. */ static class loop *tree_unswitch_loop (class loop *, basic_block, tree); diff --git a/gcc/tree-ssa-math-opts.cc b/gcc/tree-ssa-math-opts.cc index e3c3bd8..3d7104a 100644 --- a/gcc/tree-ssa-math-opts.cc +++ b/gcc/tree-ssa-math-opts.cc @@ -77,7 +77,7 @@ along with GCC; see the file COPYING3. If not see divisions, and they tend to be in the same basic block, so insert_bb is called very few times. - If we did this using domwalk.c, an efficient implementation would have + If we did this using domwalk.cc, an efficient implementation would have to work on all the variables in a single pass, because we could not work on just a subset of the dominator tree, as we do now, and the cost would also be something like O(n_statements * n_basic_blocks). diff --git a/gcc/tree-ssa-operands.cc b/gcc/tree-ssa-operands.cc index c77759b..4915622 100644 --- a/gcc/tree-ssa-operands.cc +++ b/gcc/tree-ssa-operands.cc @@ -205,7 +205,7 @@ class operands_scanner void finalize_ssa_defs (); }; -/* Accessor to tree-ssa-operands.c caches. */ +/* Accessor to tree-ssa-operands.cc caches. */ static inline struct ssa_operands * gimple_ssa_operands (const struct function *fun) { diff --git a/gcc/tree-ssa-pre.cc b/gcc/tree-ssa-pre.cc index 5113256..7c2a52e 100644 --- a/gcc/tree-ssa-pre.cc +++ b/gcc/tree-ssa-pre.cc @@ -53,9 +53,9 @@ along with GCC; see the file COPYING3. If not see #include "alias.h" #include "gimple-range.h" -/* Even though this file is called tree-ssa-pre.c, we actually +/* Even though this file is called tree-ssa-pre.cc, we actually implement a bit more than just PRE here. All of them piggy-back - on GVN which is implemented in tree-ssa-sccvn.c. + on GVN which is implemented in tree-ssa-sccvn.cc. 1. Full Redundancy Elimination (FRE) This is the elimination phase of GVN. diff --git a/gcc/tree-ssa-reassoc.cc b/gcc/tree-ssa-reassoc.cc index 48acc1f..756ba6b 100644 --- a/gcc/tree-ssa-reassoc.cc +++ b/gcc/tree-ssa-reassoc.cc @@ -2472,7 +2472,7 @@ optimize_ops_list (enum tree_code opcode, are converted to (unsigned) (X - 2) <= 3 - For more information see comments above fold_test_range in fold-const.c, + For more information see comments above fold_test_range in fold-const.cc, this implementation is for GIMPLE. */ @@ -2500,7 +2500,7 @@ debug_range_entry (struct range_entry *r) fputc ('\n', stderr); } -/* This is similar to make_range in fold-const.c, but on top of +/* This is similar to make_range in fold-const.cc, but on top of GIMPLE instead of trees. If EXP is non-NULL, it should be an SSA_NAME and STMT argument is ignored, otherwise STMT argument should be a GIMPLE_COND. */ diff --git a/gcc/tree-ssa-sccvn.cc b/gcc/tree-ssa-sccvn.cc index e11adb7..a03f0aa 100644 --- a/gcc/tree-ssa-sccvn.cc +++ b/gcc/tree-ssa-sccvn.cc @@ -6276,7 +6276,7 @@ eliminate_dom_walker::eliminate_stmt (basic_block b, gimple_stmt_iterator *gsi) /* If this now constitutes a copy duplicate points-to and range info appropriately. This is especially - important for inserted code. See tree-ssa-copy.c + important for inserted code. See tree-ssa-copy.cc for similar code. */ if (sprime && TREE_CODE (sprime) == SSA_NAME) diff --git a/gcc/tree-ssa-sccvn.h b/gcc/tree-ssa-sccvn.h index 1a8be0c..f161b80 100644 --- a/gcc/tree-ssa-sccvn.h +++ b/gcc/tree-ssa-sccvn.h @@ -21,7 +21,7 @@ #ifndef TREE_SSA_SCCVN_H #define TREE_SSA_SCCVN_H -/* In tree-ssa-sccvn.c */ +/* In tree-ssa-sccvn.cc */ bool expressions_equal_p (tree, tree, bool = true); diff --git a/gcc/tree-ssa-scopedtables.cc b/gcc/tree-ssa-scopedtables.cc index f8237d8..6d203ef 100644 --- a/gcc/tree-ssa-scopedtables.cc +++ b/gcc/tree-ssa-scopedtables.cc @@ -384,7 +384,7 @@ add_expr_commutative (const_tree t1, const_tree t2, hash &hstate) previously accumulated hash value VAL. If two hashable_expr values compare equal with hashable_expr_equal_p, they must hash to the same value, given an identical value of VAL. - The logic is intended to follow inchash::add_expr in tree.c. */ + The logic is intended to follow inchash::add_expr in tree.cc. */ static void add_hashable_expr (const struct hashable_expr *expr, hash &hstate) @@ -555,7 +555,7 @@ equal_mem_array_ref_p (tree t0, tree t1) /* Compare two hashable_expr structures for equivalence. They are considered equivalent when the expressions they denote must necessarily be equal. The logic is intended to follow that of - operand_equal_p in fold-const.c */ + operand_equal_p in fold-const.cc */ static bool hashable_expr_equal_p (const struct hashable_expr *expr0, diff --git a/gcc/tree-ssa-strlen.cc b/gcc/tree-ssa-strlen.cc index 16098b1..df97b86 100644 --- a/gcc/tree-ssa-strlen.cc +++ b/gcc/tree-ssa-strlen.cc @@ -2849,7 +2849,7 @@ is_strlen_related_p (tree src, tree len) } /* Called by handle_builtin_stxncpy_strncat and by - gimple_fold_builtin_strncpy in gimple-fold.c. + gimple_fold_builtin_strncpy in gimple-fold.cc. Check to see if the specified bound is a) equal to the size of the destination DST and if so, b) if it's immediately followed by DST[CNT - 1] = '\0'. If a) holds and b) does not, warn. Otherwise, diff --git a/gcc/tree-ssa-strlen.h b/gcc/tree-ssa-strlen.h index b87091f..eca1481 100644 --- a/gcc/tree-ssa-strlen.h +++ b/gcc/tree-ssa-strlen.h @@ -35,7 +35,7 @@ struct c_strlen_data; extern void get_range_strlen_dynamic (tree, gimple *, c_strlen_data *, class range_query *); -/* APIs internal to strlen pass. Defined in gimple-ssa-sprintf.c. */ +/* APIs internal to strlen pass. Defined in gimple-ssa-sprintf.cc. */ extern bool handle_printf_call (gimple_stmt_iterator *, pointer_query &); #endif // GCC_TREE_SSA_STRLEN_H diff --git a/gcc/tree-ssa-tail-merge.cc b/gcc/tree-ssa-tail-merge.cc index 8e1ea1a..9721fda 100644 --- a/gcc/tree-ssa-tail-merge.cc +++ b/gcc/tree-ssa-tail-merge.cc @@ -316,7 +316,7 @@ stmt_local_def (gimple *stmt) || gimple_has_side_effects (stmt) || gimple_could_trap_p_1 (stmt, false, false) || gimple_vuse (stmt) != NULL_TREE - /* Copied from tree-ssa-ifcombine.c:bb_no_side_effects_p(): + /* Copied from tree-ssa-ifcombine.cc:bb_no_side_effects_p(): const calls don't match any of the above, yet they could still have some side-effects - they could contain gimple_could_trap_p statements, like floating point diff --git a/gcc/tree-ssa-ter.h b/gcc/tree-ssa-ter.h index 1f0e418..85533a9 100644 --- a/gcc/tree-ssa-ter.h +++ b/gcc/tree-ssa-ter.h @@ -1,4 +1,4 @@ -/* Header file for tree-ssa-ter.c exports. +/* Header file for tree-ssa-ter.cc exports. Copyright (C) 2013-2022 Free Software Foundation, Inc. This file is part of GCC. diff --git a/gcc/tree-ssa-threadupdate.h b/gcc/tree-ssa-threadupdate.h index 0f41cb8..cd6be4a 100644 --- a/gcc/tree-ssa-threadupdate.h +++ b/gcc/tree-ssa-threadupdate.h @@ -144,7 +144,7 @@ enum bb_dom_status enum bb_dom_status determine_bb_domination_status (class loop *, basic_block); -// In tree-ssa-dom.c. +// In tree-ssa-dom.cc. extern void free_dom_edge_info (edge); #endif diff --git a/gcc/tree-streamer-in.cc b/gcc/tree-streamer-in.cc index 0d5108e..65cdf12 100644 --- a/gcc/tree-streamer-in.cc +++ b/gcc/tree-streamer-in.cc @@ -942,7 +942,7 @@ lto_input_ts_block_tree_pointers (class lto_input_block *ib, BLOCK_ABSTRACT_ORIGIN (expr) = DECL_ORIGIN (BLOCK_ABSTRACT_ORIGIN (expr)); /* Do not stream BLOCK_NONLOCALIZED_VARS. We cannot handle debug information for early inlined BLOCKs so drop it on the floor instead of ICEing in - dwarf2out.c. */ + dwarf2out.cc. */ /* BLOCK_FRAGMENT_ORIGIN and BLOCK_FRAGMENT_CHAIN is not live at LTO streaming time. */ diff --git a/gcc/tree-streamer-out.cc b/gcc/tree-streamer-out.cc index 23d15a5..783b94d 100644 --- a/gcc/tree-streamer-out.cc +++ b/gcc/tree-streamer-out.cc @@ -379,7 +379,7 @@ pack_ts_block_value_fields (struct output_block *ob, /* BLOCK_NUMBER is recomputed. */ /* Stream BLOCK_SOURCE_LOCATION for the limited cases we can handle - those that represent inlined function scopes. - For the rest them on the floor instead of ICEing in dwarf2out.c. */ + For the rest them on the floor instead of ICEing in dwarf2out.cc. */ if (inlined_function_outer_scope_p (expr)) stream_output_location (ob, bp, BLOCK_SOURCE_LOCATION (expr)); else @@ -808,7 +808,7 @@ write_ts_block_tree_pointers (struct output_block *ob, tree expr) /* Do not stream BLOCK_NONLOCALIZED_VARS. We cannot handle debug information for early inlined BLOCKs so drop it on the floor instead of ICEing in - dwarf2out.c. */ + dwarf2out.cc. */ /* BLOCK_FRAGMENT_ORIGIN and BLOCK_FRAGMENT_CHAIN is not live at LTO streaming time. */ diff --git a/gcc/tree-streamer.h b/gcc/tree-streamer.h index 654ba51..2a5b53b 100644 --- a/gcc/tree-streamer.h +++ b/gcc/tree-streamer.h @@ -57,7 +57,7 @@ struct streamer_tree_cache_d unsigned next_idx; }; -/* In tree-streamer-in.c. */ +/* In tree-streamer-in.cc. */ tree streamer_read_string_cst (class data_in *, class lto_input_block *); tree streamer_alloc_tree (class lto_input_block *, class data_in *, enum LTO_tags); @@ -66,7 +66,7 @@ tree streamer_get_pickled_tree (class lto_input_block *, class data_in *); void streamer_read_tree_bitfields (class lto_input_block *, class data_in *, tree); -/* In tree-streamer-out.c. */ +/* In tree-streamer-out.cc. */ void streamer_write_string_cst (struct output_block *, struct lto_output_stream *, tree); void streamer_write_tree_header (struct output_block *, tree); @@ -74,7 +74,7 @@ void streamer_write_tree_bitfields (struct output_block *, tree); void streamer_write_tree_body (struct output_block *, tree); void streamer_write_integer_cst (struct output_block *, tree); -/* In tree-streamer.c. */ +/* In tree-streamer.cc. */ extern unsigned char streamer_mode_table[1 << 8]; void streamer_check_handled_ts_structures (void); bool streamer_tree_cache_insert (struct streamer_tree_cache_d *, tree, diff --git a/gcc/tree-vect-patterns.cc b/gcc/tree-vect-patterns.cc index 3ea9055..bea0499 100644 --- a/gcc/tree-vect-patterns.cc +++ b/gcc/tree-vect-patterns.cc @@ -3019,7 +3019,7 @@ apply_binop_and_append_stmt (vec_info *vinfo, and simple arithmetic operations to be vectorized. Record the statements produced in STMT_VINFO and return the last statement in the sequence or NULL if it's not possible to synthesize such a multiplication. - This function mirrors the behavior of expand_mult_const in expmed.c but + This function mirrors the behavior of expand_mult_const in expmed.cc but works on tree-ssa form. */ static gimple * @@ -3184,7 +3184,7 @@ vect_synth_mult_by_constant (vec_info *vinfo, tree op, tree val, /* Detect multiplication by constant and convert it into a sequence of shifts and additions, subtractions, negations. We reuse the - choose_mult_variant algorithms from expmed.c + choose_mult_variant algorithms from expmed.cc Input/Output: diff --git a/gcc/tree-vect-stmts.cc b/gcc/tree-vect-stmts.cc index 44ef7a6..95be4f3 100644 --- a/gcc/tree-vect-stmts.cc +++ b/gcc/tree-vect-stmts.cc @@ -6233,7 +6233,7 @@ vectorizable_operation (vec_info *vinfo, { /* The above vect_model_simple_cost call handles constants in the prologue and (mis-)costs one of the stmts as - vector stmt. See tree-vect-generic.c:do_plus_minus/do_negate + vector stmt. See tree-vect-generic.cc:do_plus_minus/do_negate for the actual lowering that will be applied. */ unsigned n = slp_node ? SLP_TREE_NUMBER_OF_VEC_STMTS (slp_node) : ncopies; diff --git a/gcc/tree-vectorizer.cc b/gcc/tree-vectorizer.cc index 48eed40..344dc41 100644 --- a/gcc/tree-vectorizer.cc +++ b/gcc/tree-vectorizer.cc @@ -27,31 +27,31 @@ along with GCC; see the file COPYING3. If not see (3) BB vectorizer (out-of-loops), aka SLP The rest of the vectorizer's code is organized as follows: - - tree-vect-loop.c - loop specific parts such as reductions, etc. These are + - tree-vect-loop.cc - loop specific parts such as reductions, etc. These are used by drivers (1) and (2). - - tree-vect-loop-manip.c - vectorizer's loop control-flow utilities, used by + - tree-vect-loop-manip.cc - vectorizer's loop control-flow utilities, used by drivers (1) and (2). - - tree-vect-slp.c - BB vectorization specific analysis and transformation, + - tree-vect-slp.cc - BB vectorization specific analysis and transformation, used by drivers (2) and (3). - - tree-vect-stmts.c - statements analysis and transformation (used by all). - - tree-vect-data-refs.c - vectorizer specific data-refs analysis and + - tree-vect-stmts.cc - statements analysis and transformation (used by all). + - tree-vect-data-refs.cc - vectorizer specific data-refs analysis and manipulations (used by all). - - tree-vect-patterns.c - vectorizable code patterns detector (used by all) + - tree-vect-patterns.cc - vectorizable code patterns detector (used by all) Here's a poor attempt at illustrating that: - tree-vectorizer.c: + tree-vectorizer.cc: loop_vect() loop_aware_slp() slp_vect() | / \ / | / \ / - tree-vect-loop.c tree-vect-slp.c + tree-vect-loop.cc tree-vect-slp.cc | \ \ / / | | \ \/ / | | \ /\ / | | \ / \ / | - tree-vect-stmts.c tree-vect-data-refs.c + tree-vect-stmts.cc tree-vect-data-refs.cc \ / - tree-vect-patterns.c + tree-vect-patterns.cc */ #include "config.h" diff --git a/gcc/tree-vectorizer.h b/gcc/tree-vectorizer.h index 7e077f6..86f90ae 100644 --- a/gcc/tree-vectorizer.h +++ b/gcc/tree-vectorizer.h @@ -2015,7 +2015,7 @@ class auto_purge_vect_location /*-----------------------------------------------------------------*/ /* Simple loop peeling and versioning utilities for vectorizer's purposes - - in tree-vect-loop-manip.c. */ + in tree-vect-loop-manip.cc. */ extern void vect_set_loop_condition (class loop *, loop_vec_info, tree, tree, tree, bool); extern bool slpeel_can_duplicate_loop_p (const class loop *, const_edge); @@ -2031,7 +2031,7 @@ extern dump_user_location_t find_loop_location (class loop *); extern bool vect_can_advance_ivs_p (loop_vec_info); extern void vect_update_inits_of_drs (loop_vec_info, tree, tree_code); -/* In tree-vect-stmts.c. */ +/* In tree-vect-stmts.cc. */ extern tree get_related_vectype_for_scalar_type (machine_mode, tree, poly_uint64 = 0); extern tree get_vectype_for_scalar_type (vec_info *, tree, unsigned int = 0); @@ -2122,7 +2122,7 @@ extern opt_result vect_get_vector_types_for_stmt (vec_info *, tree *, unsigned int = 0); extern opt_tree vect_get_mask_type_for_stmt (stmt_vec_info, unsigned int = 0); -/* In tree-vect-data-refs.c. */ +/* In tree-vect-data-refs.cc. */ extern bool vect_can_force_dr_alignment_p (const_tree, poly_uint64); extern enum dr_alignment_support vect_supportable_dr_alignment (vec_info *, dr_vec_info *, tree, int); @@ -2174,14 +2174,14 @@ extern tree vect_create_addr_base_for_vector_ref (vec_info *, stmt_vec_info, gimple_seq *, tree); -/* In tree-vect-loop.c. */ +/* In tree-vect-loop.cc. */ extern tree neutral_op_for_reduction (tree, code_helper, tree); extern widest_int vect_iv_limit_for_partial_vectors (loop_vec_info loop_vinfo); bool vect_rgroup_iv_might_wrap_p (loop_vec_info, rgroup_controls *); -/* Used in tree-vect-loop-manip.c */ +/* Used in tree-vect-loop-manip.cc */ extern opt_result vect_determine_partial_vectors_and_peeling (loop_vec_info, bool); -/* Used in gimple-loop-interchange.c and tree-parloops.c. */ +/* Used in gimple-loop-interchange.c and tree-parloops.cc. */ extern bool check_reduction_path (dump_user_location_t, loop_p, gphi *, tree, enum tree_code); extern bool needs_fold_left_reduction_p (tree, code_helper); @@ -2247,7 +2247,7 @@ extern int vect_get_known_peeling_cost (loop_vec_info, int, int *, stmt_vector_for_cost *); extern tree cse_and_gimplify_to_preheader (loop_vec_info, tree); -/* In tree-vect-slp.c. */ +/* In tree-vect-slp.cc. */ extern void vect_slp_init (void); extern void vect_slp_fini (void); extern void vect_free_slp_instance (slp_instance); @@ -2279,7 +2279,7 @@ extern int vect_get_place_in_interleaving_chain (stmt_vec_info, stmt_vec_info); extern slp_tree vect_create_new_slp_node (unsigned, tree_code); extern void vect_free_slp_tree (slp_tree); -/* In tree-vect-patterns.c. */ +/* In tree-vect-patterns.cc. */ extern void vect_mark_pattern_stmts (vec_info *, stmt_vec_info, gimple *, tree); @@ -2288,13 +2288,13 @@ vect_mark_pattern_stmts (vec_info *, stmt_vec_info, gimple *, tree); in the future. */ void vect_pattern_recog (vec_info *); -/* In tree-vectorizer.c. */ +/* In tree-vectorizer.cc. */ unsigned vectorize_loops (void); void vect_free_loop_info_assumptions (class loop *); gimple *vect_loop_vectorized_call (class loop *, gcond **cond = NULL); bool vect_stmt_dominates_stmt_p (gimple *, gimple *); -/* SLP Pattern matcher types, tree-vect-slp-patterns.c. */ +/* SLP Pattern matcher types, tree-vect-slp-patterns.cc. */ /* Forward declaration of possible two operands operation that can be matched by the complex numbers pattern matchers. */ diff --git a/gcc/tree.cc b/gcc/tree.cc index d98b77d..ae159ee 100644 --- a/gcc/tree.cc +++ b/gcc/tree.cc @@ -673,7 +673,7 @@ initialize_tree_contains_struct (void) } -/* Init tree.c. */ +/* Init tree.cc. */ void init_ttree (void) @@ -747,7 +747,7 @@ need_assembler_name_p (tree decl) A special case are integer types where mangling do make differences between char/signed char/unsigned char etc. Storing name for these makes e.g. -fno-signed-char/-fsigned-char mismatches to be handled well. - See cp/mangle.c:write_builtin_type for details. */ + See cp/mangle.cc:write_builtin_type for details. */ if (TREE_CODE (decl) == TYPE_DECL) { @@ -13244,7 +13244,7 @@ type_with_interoperable_signedness (const_tree type) /* Return true iff T1 and T2 are structurally identical for what TBAA is concerned. - This function is used both by lto.c canonical type merging and by the + This function is used both by lto.cc canonical type merging and by the verifier. If TRUST_TYPE_CANONICAL we do not look into structure of types that have TYPE_CANONICAL defined and assume them equivalent. This is useful only for LTO because only in these cases TYPE_CANONICAL equivalence diff --git a/gcc/tree.def b/gcc/tree.def index 36b91f0..bd43dbc 100644 --- a/gcc/tree.def +++ b/gcc/tree.def @@ -981,7 +981,7 @@ DEFTREECODE (SWITCH_EXPR, "switch_expr", tcc_statement, 2) Operand 1 is CASE_HIGH. If it is NULL_TREE, the label is a simple (one-value) case label. If it is non-NULL_TREE, the case is a range. Operand 2 is CASE_LABEL, which has the corresponding LABEL_DECL. - Operand 3 is CASE_CHAIN. This operand is only used in tree-cfg.c to + Operand 3 is CASE_CHAIN. This operand is only used in tree-cfg.cc to speed up the lookup of case labels which use a particular edge in the control flow graph. */ DEFTREECODE (CASE_LABEL_EXPR, "case_label_expr", tcc_statement, 4) diff --git a/gcc/tree.h b/gcc/tree.h index 318019c..30bc53c 100644 --- a/gcc/tree.h +++ b/gcc/tree.h @@ -2328,13 +2328,13 @@ extern tree vector_element_bits_tree (const_tree); hooks are responsible for consistently using only a specific macro. */ -/* Symtab field as an integer. Used by stabs generator in dbxout.c to +/* Symtab field as an integer. Used by stabs generator in dbxout.cc to hold the type's number in the generated stabs. */ #define TYPE_SYMTAB_ADDRESS(NODE) \ (TYPE_CHECK (NODE)->type_common.symtab.address) /* Symtab field as a pointer to a DWARF DIE. Used by DWARF generator - in dwarf2out.c to point to the DIE generated for the type. */ + in dwarf2out.cc to point to the DIE generated for the type. */ #define TYPE_SYMTAB_DIE(NODE) \ (TYPE_CHECK (NODE)->type_common.symtab.die) @@ -4740,7 +4740,7 @@ poly_int_tree_p (const_tree t, poly_uint64_pod *value) return false; } -/* From expmed.c. Since rtl.h is included after tree.h, we can't +/* From expmed.cc. Since rtl.h is included after tree.h, we can't put the prototype here. Rtl.h does declare the prototype if tree.h had been included. */ @@ -5218,7 +5218,7 @@ inlined_function_outer_scope_p (const_tree block) (TREE = function_args_iter_cond (&(ITER))) != NULL_TREE; \ function_args_iter_next (&(ITER))) -/* In tree.c */ +/* In tree.cc */ extern unsigned crc32_unsigned_n (unsigned, unsigned, unsigned); extern unsigned crc32_string (unsigned, const char *); inline unsigned @@ -5503,7 +5503,7 @@ tree_code_for_canonical_type_merging (enum tree_code code) /* Return ture if get_alias_set care about TYPE_CANONICAL of given type. We don't define the types for pointers, arrays and vectors. The reason is that pointers are handled specially: ptr_type_node accesses conflict with - accesses to all other pointers. This is done by alias.c. + accesses to all other pointers. This is done by alias.cc. Because alias sets of arrays and vectors are the same as types of their elements, we can't compute canonical type either. Otherwise we could go form void *[10] to int *[10] (because they are equivalent for canonical type diff --git a/gcc/value-prof.cc b/gcc/value-prof.cc index 78688ca..9785c7a 100644 --- a/gcc/value-prof.cc +++ b/gcc/value-prof.cc @@ -75,7 +75,7 @@ along with GCC; see the file COPYING3. If not see For a -fprofile-generate run, the statements for which values should be recorded, are instrumented in instrument_values(). The instrumentation - is done by helper functions that can be found in tree-profile.c, where + is done by helper functions that can be found in tree-profile.cc, where new types of histograms can be added if necessary. After a -fprofile-use, the value profiling data is read back in by @@ -93,7 +93,7 @@ along with GCC; see the file COPYING3. If not see Limitations / FIXME / TODO: * Only one histogram of each type can be associated with a statement. - * Some value profile transformations are done in builtins.c (?!) + * Some value profile transformations are done in builtins.cc (?!) * Updating of histograms needs some TLC. * The value profiling code could be used to record analysis results from non-profiling (e.g. VRP). diff --git a/gcc/value-prof.h b/gcc/value-prof.h index b28f236..d852c41 100644 --- a/gcc/value-prof.h +++ b/gcc/value-prof.h @@ -94,7 +94,7 @@ bool get_nth_most_common_value (gimple *stmt, const char *counter_type, gcov_type *count, gcov_type *all, unsigned n = 0); -/* In tree-profile.c. */ +/* In tree-profile.cc. */ extern void gimple_init_gcov_profiler (void); extern void gimple_gen_edge_profiler (int, edge); extern void gimple_gen_interval_profiler (histogram_value, unsigned); @@ -110,7 +110,7 @@ extern void stream_in_histogram_value (class lto_input_block *, gimple *); extern struct cgraph_node* find_func_by_profile_id (int func_id); -/* In profile.c. */ +/* In profile.cc. */ extern void init_branch_prob (void); extern void branch_prob (bool); extern void read_thunk_profile (struct cgraph_node *); diff --git a/gcc/value-range.cc b/gcc/value-range.cc index 6e41ff6..000bbcf 100644 --- a/gcc/value-range.cc +++ b/gcc/value-range.cc @@ -2111,7 +2111,7 @@ vrp_operand_equal_p (const_tree val1, const_tree val2) return true; } -// ?? These stubs are for ipa-prop.c which use a value_range in a +// ?? These stubs are for ipa-prop.cc which use a value_range in a // hash_traits. hash-traits.h defines an extern of gt_ggc_mx (T &) // instead of picking up the gt_ggc_mx (T *) version. void diff --git a/gcc/value-range.h b/gcc/value-range.h index 67930b5..d4cba22 100644 --- a/gcc/value-range.h +++ b/gcc/value-range.h @@ -162,7 +162,7 @@ private: template friend void gt_pch_nx (int_range *, gt_pointer_operator, void *); - // ?? These stubs are for ipa-prop.c which use a value_range in a + // ?? These stubs are for ipa-prop.cc which use a value_range in a // hash_traits. hash-traits.h defines an extern of gt_ggc_mx (T &) // instead of picking up the gt_ggc_mx (T *) version. friend void gt_ggc_mx (int_range<1> *&); diff --git a/gcc/var-tracking.cc b/gcc/var-tracking.cc index ce1d920..7c3ad0a 100644 --- a/gcc/var-tracking.cc +++ b/gcc/var-tracking.cc @@ -119,7 +119,7 @@ typedef fibonacci_heap bb_heap_t; -/* var-tracking.c assumes that tree code with the same value as VALUE rtx code +/* var-tracking.cc assumes that tree code with the same value as VALUE rtx code has no chance to appear in REG_EXPR/MEM_EXPRs and isn't a decl. Currently the value is the same as IDENTIFIER_NODE, which has such a property. If this compile time assertion ever fails, make sure that diff --git a/gcc/varasm.cc b/gcc/varasm.cc index 76574be..d6743f37 100644 --- a/gcc/varasm.cc +++ b/gcc/varasm.cc @@ -645,7 +645,7 @@ default_function_section (tree decl, enum node_frequency freq, /* Return the section for function DECL. If DECL is NULL_TREE, return the text section. We can be passed - NULL_TREE under some circumstances by dbxout.c at least. + NULL_TREE under some circumstances by dbxout.cc at least. If FORCE_COLD is true, return cold function section ignoring the frequency info of cgraph_node. */ @@ -698,7 +698,7 @@ function_section_1 (tree decl, bool force_cold) /* Return the section for function DECL. If DECL is NULL_TREE, return the text section. We can be passed - NULL_TREE under some circumstances by dbxout.c at least. */ + NULL_TREE under some circumstances by dbxout.cc at least. */ section * function_section (tree decl) @@ -2387,7 +2387,7 @@ assemble_variable (tree decl, int top_level ATTRIBUTE_UNUSED, if (DECL_INITIAL (decl) && DECL_INITIAL (decl) != error_mark_node) output_addressed_constants (DECL_INITIAL (decl), 0); - /* dbxout.c needs to know this. */ + /* dbxout.cc needs to know this. */ if (sect && (sect->common.flags & SECTION_CODE) != 0) DECL_IN_TEXT_SECTION (decl) = 1; @@ -2569,7 +2569,7 @@ assemble_external (tree decl ATTRIBUTE_UNUSED) #if 0 /* This function should only be called if we are expanding, or have expanded, to RTL. - Ideally, only final.c would be calling this function, but it is + Ideally, only final.cc would be calling this function, but it is not clear whether that would break things somehow. See PR 17982 for further discussion. */ gcc_assert (state == EXPANSION @@ -8482,7 +8482,7 @@ handle_vtv_comdat_section (section *sect, const_tree decl ATTRIBUTE_UNUSED) everything in .vtable_map_vars at the end. A fix could be made in - gcc/config/i386/winnt.c: i386_pe_unique_section. */ + gcc/config/i386/winnt.cc: i386_pe_unique_section. */ if (TARGET_PECOFF) { char *name; diff --git a/gcc/vec.h b/gcc/vec.h index c32d6ff..3ba7ea7 100644 --- a/gcc/vec.h +++ b/gcc/vec.h @@ -193,7 +193,7 @@ struct vec_prefix /* FIXME - These fields should be private, but we need to cater to compilers that have stricter notions of PODness for types. */ - /* Memory allocation support routines in vec.c. */ + /* Memory allocation support routines in vec.cc. */ void register_overhead (void *, size_t, size_t CXX_MEM_STAT_INFO); void release_overhead (void *, size_t, size_t, bool CXX_MEM_STAT_INFO); static unsigned calculate_allocation (vec_prefix *, unsigned, bool); diff --git a/gcc/vmsdbgout.cc b/gcc/vmsdbgout.cc index b068bf6..2cae456 100644 --- a/gcc/vmsdbgout.cc +++ b/gcc/vmsdbgout.cc @@ -1303,7 +1303,7 @@ full_name (const char *filename) } /* Lookup a filename (in the list of filenames that we know about here in - vmsdbgout.c) and return its "index". The index of each (known) filename is + vmsdbgout.cc) and return its "index". The index of each (known) filename is just a unique number which is associated with only that one filename. We need such numbers for the sake of generating labels and references to those files numbers. If the filename given as an argument is not diff --git a/gcc/vtable-verify.cc b/gcc/vtable-verify.cc index 2bd40b9..48f9987 100644 --- a/gcc/vtable-verify.cc +++ b/gcc/vtable-verify.cc @@ -109,7 +109,7 @@ along with GCC; see the file COPYING3. If not see are defined in gcc/vtable-verify.h. These data structures are shared with the code in the C++ front end that collects the class hierarchy & vtable information and generates the vtable map - variables (see cp/vtable-class-hierarchy.c). This tree pass should + variables (see cp/vtable-class-hierarchy.cc). This tree pass should run just before the gimple is converted to RTL. Some implementation details for this pass: diff --git a/gcc/vtable-verify.h b/gcc/vtable-verify.h index 5876de8..d6b2bc6 100644 --- a/gcc/vtable-verify.h +++ b/gcc/vtable-verify.h @@ -96,7 +96,7 @@ struct vtv_graph_node { node; generate a unique (monotonically ascending) id for both the vtbl_map_node and the vtv_graph_node; and insert the node into two data structures (to make it easy to find in several different - ways): 1). A hash table ("vtbl_map_hash" in vtable-verify.c). + ways): 1). A hash table ("vtbl_map_hash" in vtable-verify.cc). This gives us an easy way to check to see if we already have a node for the vtable map variable or not; and 2). An array (vector) of vtbl_map_nodes, where the array index corresponds to the unique id diff --git a/gcc/xcoffout.cc b/gcc/xcoffout.cc index b9d8521..bafd355 100644 --- a/gcc/xcoffout.cc +++ b/gcc/xcoffout.cc @@ -18,7 +18,7 @@ along with GCC; see the file COPYING3. If not see . */ /* Output xcoff-format symbol table data. The main functionality is contained - in dbxout.c. This file implements the sdbout-like parts of the xcoff + in dbxout.cc. This file implements the sdbout-like parts of the xcoff interface. Many functions are very similar to their counterparts in the former sdbout.c file. */ @@ -155,7 +155,7 @@ static const struct xcoff_type_number xcoff_type_numbers[] = { }; /* Returns an XCOFF fundamental type number for DECL (assumed to be a - TYPE_DECL), or 0 if dbxout.c should assign a type number normally. */ + TYPE_DECL), or 0 if dbxout.cc should assign a type number normally. */ int xcoff_assign_fundamental_type_number (tree decl) { diff --git a/gcc/xcoffout.h b/gcc/xcoffout.h index a889acd..f28e83e 100644 --- a/gcc/xcoffout.h +++ b/gcc/xcoffout.h @@ -1,4 +1,4 @@ -/* XCOFF definitions. These are needed in dbxout.c, final.c, +/* XCOFF definitions. These are needed in dbxout.cc, final.cc, and xcoffout.h. Copyright (C) 1998-2022 Free Software Foundation, Inc. @@ -103,8 +103,8 @@ along with GCC; see the file COPYING3. If not see fputs (",0\n", asm_out_file); \ } while (0) -/* These are IBM XCOFF extensions we need to reference in dbxout.c - and xcoffout.c. */ +/* These are IBM XCOFF extensions we need to reference in dbxout.cc + and xcoffout.cc. */ /* AIX XCOFF uses this for typedefs. This can have any value, since it is only used for translation into a C_DECL storage class. */ @@ -178,7 +178,7 @@ do { \ #define DEBUG_SYMS_TEXT -/* Prototype functions in xcoffout.c. */ +/* Prototype functions in xcoffout.cc. */ extern int stab_to_sclass (int); extern void xcoffout_begin_prologue (unsigned int, unsigned int, const char *); diff --git a/libcpp/Makefile.in b/libcpp/Makefile.in index 90d29da..fd20c36 100644 --- a/libcpp/Makefile.in +++ b/libcpp/Makefile.in @@ -89,9 +89,9 @@ libcpp_a_OBJS = charset.o directives.o errors.o \ expr.o files.o identifiers.o init.o lex.o line-map.o macro.o \ mkdeps.o pch.o symtab.o traditional.o -libcpp_a_SOURCES = charset.c directives.c errors.c \ - expr.c files.c identifiers.c init.c lex.c line-map.c macro.c \ - mkdeps.c pch.c symtab.c traditional.c +libcpp_a_SOURCES = charset.cc directives.cc errors.cc \ + expr.cc files.cc identifiers.cc init.cc lex.cc line-map.cc macro.cc \ + mkdeps.cc pch.cc symtab.cc traditional.cc all: libcpp.a $(USED_CATALOGS) diff --git a/libcpp/charset.cc b/libcpp/charset.cc index b306f5d..ca8b7cf 100644 --- a/libcpp/charset.cc +++ b/libcpp/charset.cc @@ -1,7 +1,7 @@ /* CPP Library - charsets Copyright (C) 1998-2022 Free Software Foundation, Inc. - Broken out of c-lex.c Apr 2003, adding valid C99 UCN ranges. + Broken out of c-lex.cc Apr 2003, adding valid C99 UCN ranges. This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the @@ -1581,7 +1581,7 @@ convert_escape (cpp_reader *pfile, const uchar *from, const uchar *limit, { encoding_rich_location rich_loc (pfile); - /* diagnostic.c does not support "%03o". When it does, this + /* diagnostic.cc does not support "%03o". When it does, this code can use %03o directly in the diagnostic again. */ char buf[32]; sprintf(buf, "%03o", (int) c); diff --git a/libcpp/directives.cc b/libcpp/directives.cc index 3bee192..60fd274 100644 --- a/libcpp/directives.cc +++ b/libcpp/directives.cc @@ -416,7 +416,7 @@ directive_diagnostics (cpp_reader *pfile, const directive *dir, int indented) /* Check if we have a known directive. INDENTED is true if the '#' of the directive was indented. This function is in this file - to save unnecessarily exporting dtable etc. to lex.c. Returns + to save unnecessarily exporting dtable etc. to lex.cc. Returns nonzero if the line of tokens has been handled, zero if we should continue processing the line. */ int @@ -480,7 +480,7 @@ _cpp_handle_directive (cpp_reader *pfile, bool indented) does not cause '#define foo bar' to get executed when compiled with -save-temps, we recognize directives in - -fpreprocessed mode only if the # is in column 1. macro.c + -fpreprocessed mode only if the # is in column 1. macro.cc puts a space in front of any '#' at the start of a macro. We exclude the -fdirectives-only case because macro expansion @@ -632,7 +632,7 @@ lex_macro_node (cpp_reader *pfile, bool is_def_or_undef) return NULL; } -/* Process a #define directive. Most work is done in macro.c. */ +/* Process a #define directive. Most work is done in macro.cc. */ static void do_define (cpp_reader *pfile) { diff --git a/libcpp/include/cpplib.h b/libcpp/include/cpplib.h index ebf6fcc..940c79f 100644 --- a/libcpp/include/cpplib.h +++ b/libcpp/include/cpplib.h @@ -46,7 +46,7 @@ struct _cpp_file; '='. The lexer needs operators ending in '=', like ">>=", to be in the same order as their counterparts without the '=', like ">>". - See the cpp_operator table optab in expr.c if you change the order or + See the cpp_operator table optab in expr.cc if you change the order or add or remove anything in the first group. */ #define TTYPE_TABLE \ @@ -192,7 +192,7 @@ struct GTY(()) cpp_string { comment. */ #define BOL (1 << 6) /* Token at beginning of line. */ #define PURE_ZERO (1 << 7) /* Single 0 digit, used by the C++ frontend, - set in c-lex.c. */ + set in c-lex.cc. */ #define SP_DIGRAPH (1 << 8) /* # or ## token was a digraph. */ #define SP_PREV_WHITE (1 << 9) /* If whitespace before a ## operator, or before this token @@ -1195,7 +1195,7 @@ extern int cpp_defined (cpp_reader *, const unsigned char *, int); the double integer are set to zero. */ /* This type has to be equal to unsigned HOST_WIDE_INT, see - gcc/c-family/c-lex.c. */ + gcc/c-family/c-lex.cc. */ typedef uint64_t cpp_num_part; typedef struct cpp_num cpp_num; struct cpp_num @@ -1333,7 +1333,7 @@ extern bool cpp_error_at (cpp_reader * pfile, enum cpp_diagnostic_level, rich_location *richloc, const char *msgid, ...) ATTRIBUTE_PRINTF_4; -/* In lex.c */ +/* In lex.cc */ extern int cpp_ideq (const cpp_token *, const char *); extern void cpp_output_line (cpp_reader *, FILE *); extern unsigned char *cpp_output_line_to_string (cpp_reader *, @@ -1390,7 +1390,7 @@ extern cpp_hashnode *cpp_lookup (cpp_reader *, const unsigned char *, typedef int (*cpp_cb) (cpp_reader *, cpp_hashnode *, void *); extern void cpp_forall_identifiers (cpp_reader *, cpp_cb, void *); -/* In macro.c */ +/* In macro.cc */ extern void cpp_scan_nooutput (cpp_reader *); extern int cpp_sys_macro_p (cpp_reader *); extern unsigned char *cpp_quote_string (unsigned char *, const unsigned char *, @@ -1398,7 +1398,7 @@ extern unsigned char *cpp_quote_string (unsigned char *, const unsigned char *, extern bool cpp_compare_macros (const cpp_macro *macro1, const cpp_macro *macro2); -/* In files.c */ +/* In files.cc */ extern bool cpp_included (cpp_reader *, const char *); extern bool cpp_included_before (cpp_reader *, const char *, location_t); extern void cpp_make_system_header (cpp_reader *, int, int); @@ -1426,7 +1426,7 @@ struct cpp_converted_source cpp_converted_source cpp_get_converted_source (const char *fname, const char *input_charset); -/* In pch.c */ +/* In pch.cc */ struct save_macro_data; extern int cpp_save_state (cpp_reader *, FILE *); extern int cpp_write_pch_deps (cpp_reader *, FILE *); @@ -1436,7 +1436,7 @@ extern void cpp_prepare_state (cpp_reader *, struct save_macro_data **); extern int cpp_read_state (cpp_reader *, const char *, FILE *, struct save_macro_data *); -/* In lex.c */ +/* In lex.cc */ extern void cpp_force_token_locations (cpp_reader *, location_t); extern void cpp_stop_forcing_token_locations (cpp_reader *); enum CPP_DO_task @@ -1452,7 +1452,7 @@ extern void cpp_directive_only_process (cpp_reader *pfile, CPP_DO_task, void *data, ...)); -/* In expr.c */ +/* In expr.cc */ extern enum cpp_ttype cpp_userdef_string_remove_type (enum cpp_ttype type); extern enum cpp_ttype cpp_userdef_string_add_type @@ -1468,7 +1468,7 @@ extern bool cpp_userdef_char_p extern const char * cpp_get_userdef_suffix (const cpp_token *); -/* In charset.c */ +/* In charset.cc */ /* The result of attempting to decode a run of UTF-8 bytes. */ @@ -1486,7 +1486,7 @@ struct cpp_decoded_char This is a tabstop value, along with a callback for getting the widths of characters. Normally this callback is cpp_wcwidth, but we support other schemes for escaping non-ASCII unicode as a series of - ASCII chars when printing the user's source code in diagnostic-show-locus.c + ASCII chars when printing the user's source code in diagnostic-show-locus.cc For example, consider: - the Unicode character U+03C0 "GREEK SMALL LETTER PI" (UTF-8: 0xCF 0x80) diff --git a/libcpp/include/line-map.h b/libcpp/include/line-map.h index 3053ec0..3f39eb4 100644 --- a/libcpp/include/line-map.h +++ b/libcpp/include/line-map.h @@ -83,7 +83,7 @@ enum lc_reason This key only has meaning in relation to a line_maps instance. Within gcc there is a single line_maps instance: "line_table", declared in - gcc/input.h and defined in gcc/input.c. + gcc/input.h and defined in gcc/input.cc. The values of the keys are intended to be internal to libcpp, but for ease-of-understanding the implementation, they are currently @@ -2106,8 +2106,8 @@ enum location_aspect /* The rich_location class requires a way to expand location_t instances. We would directly use expand_location_to_spelling_point, which is - implemented in gcc/input.c, but we also need to use it for rich_location - within genmatch.c. + implemented in gcc/input.cc, but we also need to use it for rich_location + within genmatch.cc. Hence we require client code of libcpp to implement the following symbol. */ extern expanded_location diff --git a/libcpp/include/mkdeps.h b/libcpp/include/mkdeps.h index e8a633c..96d6464 100644 --- a/libcpp/include/mkdeps.h +++ b/libcpp/include/mkdeps.h @@ -25,7 +25,7 @@ along with this program; see the file COPYING3. If not see #include "cpplib.h" -/* This is the data structure used by all the functions in mkdeps.c. +/* This is the data structure used by all the functions in mkdeps.cc. It's quite straightforward, but should be treated as opaque. */ class mkdeps; diff --git a/libcpp/init.cc b/libcpp/init.cc index 2a1a001..f4ab83d 100644 --- a/libcpp/init.cc +++ b/libcpp/init.cc @@ -382,7 +382,7 @@ cpp_destroy (cpp_reader *pfile) There are two tables of these. builtin_array holds all the "builtin" macros: these are handled by builtin_macro() in - macro.c. Builtin is somewhat of a misnomer -- the property of + macro.cc. Builtin is somewhat of a misnomer -- the property of interest is that these macros require special code to compute their expansions. The value is a "cpp_builtin_type" enumerator. @@ -412,7 +412,7 @@ static const struct builtin_macro builtin_array[] = B("__INCLUDE_LEVEL__", BT_INCLUDE_LEVEL, true), B("__COUNTER__", BT_COUNTER, true), /* Make sure to update the list of built-in - function-like macros in traditional.c: + function-like macros in traditional.cc: fun_like_macro() when adding more following */ B("__has_attribute", BT_HAS_ATTRIBUTE, true), B("__has_c_attribute", BT_HAS_STD_ATTRIBUTE, true), @@ -848,7 +848,7 @@ cpp_finish (cpp_reader *pfile, FILE *deps_stream) if (CPP_OPTION (pfile, warn_unused_macros)) cpp_forall_identifiers (pfile, _cpp_warn_if_unused_macro, NULL); - /* lex.c leaves the final buffer on the stack. This it so that + /* lex.cc leaves the final buffer on the stack. This it so that it returns an unending stream of CPP_EOFs to the client. If we popped the buffer, we'd dereference a NULL buffer pointer and segfault. It's nice to allow the client to do worry-free excess diff --git a/libcpp/internal.h b/libcpp/internal.h index e49b6d1..364c41c 100644 --- a/libcpp/internal.h +++ b/libcpp/internal.h @@ -534,15 +534,15 @@ struct cpp_reader cpp_token avoid_paste; cpp_token endarg; - /* Opaque handle to the dependencies of mkdeps.c. */ + /* Opaque handle to the dependencies of mkdeps.cc. */ class mkdeps *deps; /* Obstack holding all macro hash nodes. This never shrinks. - See identifiers.c */ + See identifiers.cc */ struct obstack hash_ob; /* Obstack holding buffer and conditional structures. This is a - real stack. See directives.c. */ + real stack. See directives.cc. */ struct obstack buffer_ob; /* Pragma table - dynamic, because a library user can add to the @@ -577,7 +577,7 @@ struct cpp_reader location_t first_line; } out; - /* Used for buffer overlays by traditional.c. */ + /* Used for buffer overlays by traditional.cc. */ const unsigned char *saved_cur, *saved_rlimit, *saved_line_base; /* A saved list of the defined macros, for dependency checking @@ -614,7 +614,7 @@ struct cpp_reader definition of a pp-number in the C standard [section 6.4.8 of C99]. In the unlikely event that characters other than \r and \n enter - the set is_vspace, the macro handle_newline() in lex.c must be + the set is_vspace, the macro handle_newline() in lex.cc must be updated. */ #define _dollar_ok(x) ((x) == '$' && CPP_OPTION (pfile, dollars_in_ident)) @@ -673,7 +673,7 @@ inline bool _cpp_defined_macro_p (cpp_hashnode *node) return cpp_macro_p (node) && !(node->flags & NODE_CONDITIONAL); } -/* In macro.c */ +/* In macro.cc */ extern bool _cpp_notify_macro_use (cpp_reader *pfile, cpp_hashnode *node, location_t); inline bool _cpp_maybe_notify_macro_use (cpp_reader *pfile, cpp_hashnode *node, @@ -702,11 +702,11 @@ extern void _cpp_push_token_context (cpp_reader *, cpp_hashnode *, const cpp_token *, unsigned int); extern void _cpp_backup_tokens_direct (cpp_reader *, unsigned int); -/* In identifiers.c */ +/* In identifiers.cc */ extern void _cpp_init_hashtable (cpp_reader *, cpp_hash_table *); extern void _cpp_destroy_hashtable (cpp_reader *); -/* In files.c */ +/* In files.cc */ enum _cpp_find_file_kind { _cpp_FFK_NORMAL, _cpp_FFK_FAKE, _cpp_FFK_PRE_INCLUDE, _cpp_FFK_HAS_INCLUDE }; extern _cpp_file *_cpp_find_file (cpp_reader *, const char *, cpp_dir *, @@ -732,11 +732,11 @@ extern struct stat *_cpp_get_file_stat (_cpp_file *); extern bool _cpp_has_header (cpp_reader *, const char *, int, enum include_type); -/* In expr.c */ +/* In expr.cc */ extern bool _cpp_parse_expr (cpp_reader *, bool); extern struct op *_cpp_expand_op_stack (cpp_reader *); -/* In lex.c */ +/* In lex.cc */ extern void _cpp_process_line_notes (cpp_reader *, int); extern void _cpp_clean_line (cpp_reader *); extern bool _cpp_get_fresh_line (cpp_reader *); @@ -759,13 +759,13 @@ static inline void *_cpp_reserve_room (cpp_reader *pfile, size_t have, } extern void *_cpp_commit_buff (cpp_reader *pfile, size_t size); -/* In init.c. */ +/* In init.cc. */ extern void _cpp_maybe_push_include_file (cpp_reader *); extern const char *cpp_named_operator2name (enum cpp_ttype type); extern void _cpp_restore_special_builtin (cpp_reader *pfile, struct def_pragma_macro *); -/* In directives.c */ +/* In directives.cc */ extern int _cpp_test_assertion (cpp_reader *, unsigned int *); extern int _cpp_handle_directive (cpp_reader *, bool); extern void _cpp_define_builtin (cpp_reader *, const char *); @@ -779,10 +779,10 @@ extern void _cpp_do_file_change (cpp_reader *, enum lc_reason, const char *, extern void _cpp_pop_buffer (cpp_reader *); extern char *_cpp_bracket_include (cpp_reader *); -/* In errors.c */ +/* In errors.cc */ extern location_t cpp_diagnostic_get_current_location (cpp_reader *); -/* In traditional.c. */ +/* In traditional.cc. */ extern bool _cpp_scan_out_logical_line (cpp_reader *, cpp_macro *, bool); extern bool _cpp_read_logical_line_trad (cpp_reader *); extern void _cpp_overlay_buffer (cpp_reader *pfile, const unsigned char *, @@ -795,7 +795,7 @@ extern unsigned char *_cpp_copy_replacement_text (const cpp_macro *, unsigned char *); extern size_t _cpp_replacement_text_len (const cpp_macro *); -/* In charset.c. */ +/* In charset.cc. */ /* The normalization state at this point in the sequence. It starts initialized to all zeros, and at the end @@ -900,7 +900,7 @@ ufputs (const unsigned char *s, FILE *f) return fputs ((const char *)s, f); } -/* In line-map.c. */ +/* In line-map.cc. */ /* Create and return a virtual location for a token that is part of a macro expansion-list at a macro expansion point. See the comment diff --git a/libcpp/line-map.cc b/libcpp/line-map.cc index 91ac2d3..b18cb67 100644 --- a/libcpp/line-map.cc +++ b/libcpp/line-map.cc @@ -44,7 +44,7 @@ static location_t linemap_macro_loc_to_exp_point (line_maps *, location_t, const line_map_ordinary **); -/* Counters defined in macro.c. */ +/* Counters defined in macro.cc. */ extern unsigned num_expanded_macros_counter; extern unsigned num_macro_tokens_counter; @@ -374,7 +374,7 @@ linemap_check_files_exited (line_maps *set) for (const line_map_ordinary *map = LINEMAPS_LAST_ORDINARY_MAP (set); ! MAIN_FILE_P (map); map = linemap_included_from_linemap (set, map)) - fprintf (stderr, "line-map.c: file \"%s\" entered but not left\n", + fprintf (stderr, "line-map.cc: file \"%s\" entered but not left\n", ORDINARY_MAP_FILE_NAME (map)); } @@ -410,7 +410,7 @@ line_map_new_raw (line_maps *set, bool macro_p, unsigned num) /* We are going to execute some dance to try to reduce the overhead of the memory allocator, in case we are using the - ggc-page.c one. + ggc-page.cc one. The actual size of memory we are going to get back from the allocator may well be larger than what we ask for. Use this diff --git a/libcpp/traditional.cc b/libcpp/traditional.cc index 1ce93a6..d02ea48 100644 --- a/libcpp/traditional.cc +++ b/libcpp/traditional.cc @@ -80,7 +80,7 @@ enum ls {ls_none = 0, /* Normal state. */ ls_answer /* In answer to predicate. */ }; -/* Lexing TODO: Maybe handle space in escaped newlines. Stop lex.c +/* Lexing TODO: Maybe handle space in escaped newlines. Stop lex.cc from recognizing comments and directives during its lexing pass. */ static const uchar *skip_whitespace (cpp_reader *, const uchar *, int); -- cgit v1.1