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.

44 files changed, 181 insertions, 181 deletions

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
 <http://www.gnu.org/licenses/>.  */
 
 
-/* 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
 <http://www.gnu.org/licenses/>.  */
 
-/* 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
 <http://www.gnu.org/licenses/>.  */
 
-/* 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
    <http://www.gnu.org/licenses/>.  */
 
-/* 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
 <http://www.gnu.org/licenses/>.  */
 
-/* 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
 <http://www.gnu.org/licenses/>.  */
 
-/* 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
 <http://www.gnu.org/licenses/>.  */
 
-/* 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
 <http://www.gnu.org/licenses/>.  */
 
-/* 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
 <http://www.gnu.org/licenses/>.  */
 
-/* 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
 <http://www.gnu.org/licenses/>.  */
 
-/* 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;