From 5c69acb32329d49e58c26fa41ae74229a52b9106 Mon Sep 17 00:00:00 2001 From: Martin Liska Date: Fri, 14 Jan 2022 16:56:44 +0100 Subject: Rename .c files to .cc files. gcc/ada/ChangeLog: * adadecode.c: Moved to... * adadecode.cc: ...here. * affinity.c: Moved to... * affinity.cc: ...here. * argv-lynxos178-raven-cert.c: Moved to... * argv-lynxos178-raven-cert.cc: ...here. * argv.c: Moved to... * argv.cc: ...here. * aux-io.c: Moved to... * aux-io.cc: ...here. * cio.c: Moved to... * cio.cc: ...here. * cstreams.c: Moved to... * cstreams.cc: ...here. * env.c: Moved to... * env.cc: ...here. * exit.c: Moved to... * exit.cc: ...here. * expect.c: Moved to... * expect.cc: ...here. * final.c: Moved to... * final.cc: ...here. * gcc-interface/cuintp.c: Moved to... * gcc-interface/cuintp.cc: ...here. * gcc-interface/decl.c: Moved to... * gcc-interface/decl.cc: ...here. * gcc-interface/misc.c: Moved to... * gcc-interface/misc.cc: ...here. * gcc-interface/targtyps.c: Moved to... * gcc-interface/targtyps.cc: ...here. * gcc-interface/trans.c: Moved to... * gcc-interface/trans.cc: ...here. * gcc-interface/utils.c: Moved to... * gcc-interface/utils.cc: ...here. * gcc-interface/utils2.c: Moved to... * gcc-interface/utils2.cc: ...here. * init.c: Moved to... * init.cc: ...here. * initialize.c: Moved to... * initialize.cc: ...here. * libgnarl/thread.c: Moved to... * libgnarl/thread.cc: ...here. * link.c: Moved to... * link.cc: ...here. * locales.c: Moved to... * locales.cc: ...here. * mkdir.c: Moved to... * mkdir.cc: ...here. * raise.c: Moved to... * raise.cc: ...here. * rtfinal.c: Moved to... * rtfinal.cc: ...here. * rtinit.c: Moved to... * rtinit.cc: ...here. * seh_init.c: Moved to... * seh_init.cc: ...here. * sigtramp-armdroid.c: Moved to... * sigtramp-armdroid.cc: ...here. * sigtramp-ios.c: Moved to... * sigtramp-ios.cc: ...here. * sigtramp-qnx.c: Moved to... * sigtramp-qnx.cc: ...here. * sigtramp-vxworks.c: Moved to... * sigtramp-vxworks.cc: ...here. * socket.c: Moved to... * socket.cc: ...here. * tracebak.c: Moved to... * tracebak.cc: ...here. * version.c: Moved to... * version.cc: ...here. * vx_stack_info.c: Moved to... * vx_stack_info.cc: ...here. gcc/ChangeLog: * adjust-alignment.c: Moved to... * adjust-alignment.cc: ...here. * alias.c: Moved to... * alias.cc: ...here. * alloc-pool.c: Moved to... * alloc-pool.cc: ...here. * asan.c: Moved to... * asan.cc: ...here. * attribs.c: Moved to... * attribs.cc: ...here. * auto-inc-dec.c: Moved to... * auto-inc-dec.cc: ...here. * auto-profile.c: Moved to... * auto-profile.cc: ...here. * bb-reorder.c: Moved to... * bb-reorder.cc: ...here. * bitmap.c: Moved to... * bitmap.cc: ...here. * btfout.c: Moved to... * btfout.cc: ...here. * builtins.c: Moved to... * builtins.cc: ...here. * caller-save.c: Moved to... * caller-save.cc: ...here. * calls.c: Moved to... * calls.cc: ...here. * ccmp.c: Moved to... * ccmp.cc: ...here. * cfg.c: Moved to... * cfg.cc: ...here. * cfganal.c: Moved to... * cfganal.cc: ...here. * cfgbuild.c: Moved to... * cfgbuild.cc: ...here. * cfgcleanup.c: Moved to... * cfgcleanup.cc: ...here. * cfgexpand.c: Moved to... * cfgexpand.cc: ...here. * cfghooks.c: Moved to... * cfghooks.cc: ...here. * cfgloop.c: Moved to... * cfgloop.cc: ...here. * cfgloopanal.c: Moved to... * cfgloopanal.cc: ...here. * cfgloopmanip.c: Moved to... * cfgloopmanip.cc: ...here. * cfgrtl.c: Moved to... * cfgrtl.cc: ...here. * cgraph.c: Moved to... * cgraph.cc: ...here. * cgraphbuild.c: Moved to... * cgraphbuild.cc: ...here. * cgraphclones.c: Moved to... * cgraphclones.cc: ...here. * cgraphunit.c: Moved to... * cgraphunit.cc: ...here. * collect-utils.c: Moved to... * collect-utils.cc: ...here. * collect2-aix.c: Moved to... * collect2-aix.cc: ...here. * collect2.c: Moved to... * collect2.cc: ...here. * combine-stack-adj.c: Moved to... * combine-stack-adj.cc: ...here. * combine.c: Moved to... * combine.cc: ...here. * common/common-targhooks.c: Moved to... * common/common-targhooks.cc: ...here. * common/config/aarch64/aarch64-common.c: Moved to... * common/config/aarch64/aarch64-common.cc: ...here. * common/config/alpha/alpha-common.c: Moved to... * common/config/alpha/alpha-common.cc: ...here. * common/config/arc/arc-common.c: Moved to... * common/config/arc/arc-common.cc: ...here. * common/config/arm/arm-common.c: Moved to... * common/config/arm/arm-common.cc: ...here. * common/config/avr/avr-common.c: Moved to... * common/config/avr/avr-common.cc: ...here. * common/config/bfin/bfin-common.c: Moved to... * common/config/bfin/bfin-common.cc: ...here. * common/config/bpf/bpf-common.c: Moved to... * common/config/bpf/bpf-common.cc: ...here. * common/config/c6x/c6x-common.c: Moved to... * common/config/c6x/c6x-common.cc: ...here. * common/config/cr16/cr16-common.c: Moved to... * common/config/cr16/cr16-common.cc: ...here. * common/config/cris/cris-common.c: Moved to... * common/config/cris/cris-common.cc: ...here. * common/config/csky/csky-common.c: Moved to... * common/config/csky/csky-common.cc: ...here. * common/config/default-common.c: Moved to... * common/config/default-common.cc: ...here. * common/config/epiphany/epiphany-common.c: Moved to... * common/config/epiphany/epiphany-common.cc: ...here. * common/config/fr30/fr30-common.c: Moved to... * common/config/fr30/fr30-common.cc: ...here. * common/config/frv/frv-common.c: Moved to... * common/config/frv/frv-common.cc: ...here. * common/config/gcn/gcn-common.c: Moved to... * common/config/gcn/gcn-common.cc: ...here. * common/config/h8300/h8300-common.c: Moved to... * common/config/h8300/h8300-common.cc: ...here. * common/config/i386/i386-common.c: Moved to... * common/config/i386/i386-common.cc: ...here. * common/config/ia64/ia64-common.c: Moved to... * common/config/ia64/ia64-common.cc: ...here. * common/config/iq2000/iq2000-common.c: Moved to... * common/config/iq2000/iq2000-common.cc: ...here. * common/config/lm32/lm32-common.c: Moved to... * common/config/lm32/lm32-common.cc: ...here. * common/config/m32r/m32r-common.c: Moved to... * common/config/m32r/m32r-common.cc: ...here. * common/config/m68k/m68k-common.c: Moved to... * common/config/m68k/m68k-common.cc: ...here. * common/config/mcore/mcore-common.c: Moved to... * common/config/mcore/mcore-common.cc: ...here. * common/config/microblaze/microblaze-common.c: Moved to... * common/config/microblaze/microblaze-common.cc: ...here. * common/config/mips/mips-common.c: Moved to... * common/config/mips/mips-common.cc: ...here. * common/config/mmix/mmix-common.c: Moved to... * common/config/mmix/mmix-common.cc: ...here. * common/config/mn10300/mn10300-common.c: Moved to... * common/config/mn10300/mn10300-common.cc: ...here. * common/config/msp430/msp430-common.c: Moved to... * common/config/msp430/msp430-common.cc: ...here. * common/config/nds32/nds32-common.c: Moved to... * common/config/nds32/nds32-common.cc: ...here. * common/config/nios2/nios2-common.c: Moved to... * common/config/nios2/nios2-common.cc: ...here. * common/config/nvptx/nvptx-common.c: Moved to... * common/config/nvptx/nvptx-common.cc: ...here. * common/config/or1k/or1k-common.c: Moved to... * common/config/or1k/or1k-common.cc: ...here. * common/config/pa/pa-common.c: Moved to... * common/config/pa/pa-common.cc: ...here. * common/config/pdp11/pdp11-common.c: Moved to... * common/config/pdp11/pdp11-common.cc: ...here. * common/config/pru/pru-common.c: Moved to... * common/config/pru/pru-common.cc: ...here. * common/config/riscv/riscv-common.c: Moved to... * common/config/riscv/riscv-common.cc: ...here. * common/config/rs6000/rs6000-common.c: Moved to... * common/config/rs6000/rs6000-common.cc: ...here. * common/config/rx/rx-common.c: Moved to... * common/config/rx/rx-common.cc: ...here. * common/config/s390/s390-common.c: Moved to... * common/config/s390/s390-common.cc: ...here. * common/config/sh/sh-common.c: Moved to... * common/config/sh/sh-common.cc: ...here. * common/config/sparc/sparc-common.c: Moved to... * common/config/sparc/sparc-common.cc: ...here. * common/config/tilegx/tilegx-common.c: Moved to... * common/config/tilegx/tilegx-common.cc: ...here. * common/config/tilepro/tilepro-common.c: Moved to... * common/config/tilepro/tilepro-common.cc: ...here. * common/config/v850/v850-common.c: Moved to... * common/config/v850/v850-common.cc: ...here. * common/config/vax/vax-common.c: Moved to... * common/config/vax/vax-common.cc: ...here. * common/config/visium/visium-common.c: Moved to... * common/config/visium/visium-common.cc: ...here. * common/config/xstormy16/xstormy16-common.c: Moved to... * common/config/xstormy16/xstormy16-common.cc: ...here. * common/config/xtensa/xtensa-common.c: Moved to... * common/config/xtensa/xtensa-common.cc: ...here. * compare-elim.c: Moved to... * compare-elim.cc: ...here. * config/aarch64/aarch64-bti-insert.c: Moved to... * config/aarch64/aarch64-bti-insert.cc: ...here. * config/aarch64/aarch64-builtins.c: Moved to... * config/aarch64/aarch64-builtins.cc: ...here. * config/aarch64/aarch64-c.c: Moved to... * config/aarch64/aarch64-c.cc: ...here. * config/aarch64/aarch64-d.c: Moved to... * config/aarch64/aarch64-d.cc: ...here. * config/aarch64/aarch64.c: Moved to... * config/aarch64/aarch64.cc: ...here. * config/aarch64/cortex-a57-fma-steering.c: Moved to... * config/aarch64/cortex-a57-fma-steering.cc: ...here. * config/aarch64/driver-aarch64.c: Moved to... * config/aarch64/driver-aarch64.cc: ...here. * config/aarch64/falkor-tag-collision-avoidance.c: Moved to... * config/aarch64/falkor-tag-collision-avoidance.cc: ...here. * config/aarch64/host-aarch64-darwin.c: Moved to... * config/aarch64/host-aarch64-darwin.cc: ...here. * config/alpha/alpha.c: Moved to... * config/alpha/alpha.cc: ...here. * config/alpha/driver-alpha.c: Moved to... * config/alpha/driver-alpha.cc: ...here. * config/arc/arc-c.c: Moved to... * config/arc/arc-c.cc: ...here. * config/arc/arc.c: Moved to... * config/arc/arc.cc: ...here. * config/arc/driver-arc.c: Moved to... * config/arc/driver-arc.cc: ...here. * config/arm/aarch-common.c: Moved to... * config/arm/aarch-common.cc: ...here. * config/arm/arm-builtins.c: Moved to... * config/arm/arm-builtins.cc: ...here. * config/arm/arm-c.c: Moved to... * config/arm/arm-c.cc: ...here. * config/arm/arm-d.c: Moved to... * config/arm/arm-d.cc: ...here. * config/arm/arm.c: Moved to... * config/arm/arm.cc: ...here. * config/arm/driver-arm.c: Moved to... * config/arm/driver-arm.cc: ...here. * config/avr/avr-c.c: Moved to... * config/avr/avr-c.cc: ...here. * config/avr/avr-devices.c: Moved to... * config/avr/avr-devices.cc: ...here. * config/avr/avr-log.c: Moved to... * config/avr/avr-log.cc: ...here. * config/avr/avr.c: Moved to... * config/avr/avr.cc: ...here. * config/avr/driver-avr.c: Moved to... * config/avr/driver-avr.cc: ...here. * config/avr/gen-avr-mmcu-specs.c: Moved to... * config/avr/gen-avr-mmcu-specs.cc: ...here. * config/avr/gen-avr-mmcu-texi.c: Moved to... * config/avr/gen-avr-mmcu-texi.cc: ...here. * config/bfin/bfin.c: Moved to... * config/bfin/bfin.cc: ...here. * config/bpf/bpf.c: Moved to... * config/bpf/bpf.cc: ...here. * config/bpf/coreout.c: Moved to... * config/bpf/coreout.cc: ...here. * config/c6x/c6x.c: Moved to... * config/c6x/c6x.cc: ...here. * config/cr16/cr16.c: Moved to... * config/cr16/cr16.cc: ...here. * config/cris/cris.c: Moved to... * config/cris/cris.cc: ...here. * config/csky/csky.c: Moved to... * config/csky/csky.cc: ...here. * config/darwin-c.c: Moved to... * config/darwin-c.cc: ...here. * config/darwin-d.c: Moved to... * config/darwin-d.cc: ...here. * config/darwin-driver.c: Moved to... * config/darwin-driver.cc: ...here. * config/darwin-f.c: Moved to... * config/darwin-f.cc: ...here. * config/darwin.c: Moved to... * config/darwin.cc: ...here. * config/default-c.c: Moved to... * config/default-c.cc: ...here. * config/default-d.c: Moved to... * config/default-d.cc: ...here. * config/dragonfly-d.c: Moved to... * config/dragonfly-d.cc: ...here. * config/epiphany/epiphany.c: Moved to... * config/epiphany/epiphany.cc: ...here. * config/epiphany/mode-switch-use.c: Moved to... * config/epiphany/mode-switch-use.cc: ...here. * config/epiphany/resolve-sw-modes.c: Moved to... * config/epiphany/resolve-sw-modes.cc: ...here. * config/fr30/fr30.c: Moved to... * config/fr30/fr30.cc: ...here. * config/freebsd-d.c: Moved to... * config/freebsd-d.cc: ...here. * config/frv/frv.c: Moved to... * config/frv/frv.cc: ...here. * config/ft32/ft32.c: Moved to... * config/ft32/ft32.cc: ...here. * config/gcn/driver-gcn.c: Moved to... * config/gcn/driver-gcn.cc: ...here. * config/gcn/gcn-run.c: Moved to... * config/gcn/gcn-run.cc: ...here. * config/gcn/gcn-tree.c: Moved to... * config/gcn/gcn-tree.cc: ...here. * config/gcn/gcn.c: Moved to... * config/gcn/gcn.cc: ...here. * config/gcn/mkoffload.c: Moved to... * config/gcn/mkoffload.cc: ...here. * config/glibc-c.c: Moved to... * config/glibc-c.cc: ...here. * config/glibc-d.c: Moved to... * config/glibc-d.cc: ...here. * config/h8300/h8300.c: Moved to... * config/h8300/h8300.cc: ...here. * config/host-darwin.c: Moved to... * config/host-darwin.cc: ...here. * config/host-hpux.c: Moved to... * config/host-hpux.cc: ...here. * config/host-linux.c: Moved to... * config/host-linux.cc: ...here. * config/host-netbsd.c: Moved to... * config/host-netbsd.cc: ...here. * config/host-openbsd.c: Moved to... * config/host-openbsd.cc: ...here. * config/host-solaris.c: Moved to... * config/host-solaris.cc: ...here. * config/i386/djgpp.c: Moved to... * config/i386/djgpp.cc: ...here. * config/i386/driver-i386.c: Moved to... * config/i386/driver-i386.cc: ...here. * config/i386/driver-mingw32.c: Moved to... * config/i386/driver-mingw32.cc: ...here. * config/i386/gnu-property.c: Moved to... * config/i386/gnu-property.cc: ...here. * config/i386/host-cygwin.c: Moved to... * config/i386/host-cygwin.cc: ...here. * config/i386/host-i386-darwin.c: Moved to... * config/i386/host-i386-darwin.cc: ...here. * config/i386/host-mingw32.c: Moved to... * config/i386/host-mingw32.cc: ...here. * config/i386/i386-builtins.c: Moved to... * config/i386/i386-builtins.cc: ...here. * config/i386/i386-c.c: Moved to... * config/i386/i386-c.cc: ...here. * config/i386/i386-d.c: Moved to... * config/i386/i386-d.cc: ...here. * config/i386/i386-expand.c: Moved to... * config/i386/i386-expand.cc: ...here. * config/i386/i386-features.c: Moved to... * config/i386/i386-features.cc: ...here. * config/i386/i386-options.c: Moved to... * config/i386/i386-options.cc: ...here. * config/i386/i386.c: Moved to... * config/i386/i386.cc: ...here. * config/i386/intelmic-mkoffload.c: Moved to... * config/i386/intelmic-mkoffload.cc: ...here. * config/i386/msformat-c.c: Moved to... * config/i386/msformat-c.cc: ...here. * config/i386/winnt-cxx.c: Moved to... * config/i386/winnt-cxx.cc: ...here. * config/i386/winnt-d.c: Moved to... * config/i386/winnt-d.cc: ...here. * config/i386/winnt-stubs.c: Moved to... * config/i386/winnt-stubs.cc: ...here. * config/i386/winnt.c: Moved to... * config/i386/winnt.cc: ...here. * config/i386/x86-tune-sched-atom.c: Moved to... * config/i386/x86-tune-sched-atom.cc: ...here. * config/i386/x86-tune-sched-bd.c: Moved to... * config/i386/x86-tune-sched-bd.cc: ...here. * config/i386/x86-tune-sched-core.c: Moved to... * config/i386/x86-tune-sched-core.cc: ...here. * config/i386/x86-tune-sched.c: Moved to... * config/i386/x86-tune-sched.cc: ...here. * config/ia64/ia64-c.c: Moved to... * config/ia64/ia64-c.cc: ...here. * config/ia64/ia64.c: Moved to... * config/ia64/ia64.cc: ...here. * config/iq2000/iq2000.c: Moved to... * config/iq2000/iq2000.cc: ...here. * config/linux.c: Moved to... * config/linux.cc: ...here. * config/lm32/lm32.c: Moved to... * config/lm32/lm32.cc: ...here. * config/m32c/m32c-pragma.c: Moved to... * config/m32c/m32c-pragma.cc: ...here. * config/m32c/m32c.c: Moved to... * config/m32c/m32c.cc: ...here. * config/m32r/m32r.c: Moved to... * config/m32r/m32r.cc: ...here. * config/m68k/m68k.c: Moved to... * config/m68k/m68k.cc: ...here. * config/mcore/mcore.c: Moved to... * config/mcore/mcore.cc: ...here. * config/microblaze/microblaze-c.c: Moved to... * config/microblaze/microblaze-c.cc: ...here. * config/microblaze/microblaze.c: Moved to... * config/microblaze/microblaze.cc: ...here. * config/mips/driver-native.c: Moved to... * config/mips/driver-native.cc: ...here. * config/mips/frame-header-opt.c: Moved to... * config/mips/frame-header-opt.cc: ...here. * config/mips/mips-d.c: Moved to... * config/mips/mips-d.cc: ...here. * config/mips/mips.c: Moved to... * config/mips/mips.cc: ...here. * config/mmix/mmix.c: Moved to... * config/mmix/mmix.cc: ...here. * config/mn10300/mn10300.c: Moved to... * config/mn10300/mn10300.cc: ...here. * config/moxie/moxie.c: Moved to... * config/moxie/moxie.cc: ...here. * config/msp430/driver-msp430.c: Moved to... * config/msp430/driver-msp430.cc: ...here. * config/msp430/msp430-c.c: Moved to... * config/msp430/msp430-c.cc: ...here. * config/msp430/msp430-devices.c: Moved to... * config/msp430/msp430-devices.cc: ...here. * config/msp430/msp430.c: Moved to... * config/msp430/msp430.cc: ...here. * config/nds32/nds32-cost.c: Moved to... * config/nds32/nds32-cost.cc: ...here. * config/nds32/nds32-fp-as-gp.c: Moved to... * config/nds32/nds32-fp-as-gp.cc: ...here. * config/nds32/nds32-intrinsic.c: Moved to... * config/nds32/nds32-intrinsic.cc: ...here. * config/nds32/nds32-isr.c: Moved to... * config/nds32/nds32-isr.cc: ...here. * config/nds32/nds32-md-auxiliary.c: Moved to... * config/nds32/nds32-md-auxiliary.cc: ...here. * config/nds32/nds32-memory-manipulation.c: Moved to... * config/nds32/nds32-memory-manipulation.cc: ...here. * config/nds32/nds32-pipelines-auxiliary.c: Moved to... * config/nds32/nds32-pipelines-auxiliary.cc: ...here. * config/nds32/nds32-predicates.c: Moved to... * config/nds32/nds32-predicates.cc: ...here. * config/nds32/nds32-relax-opt.c: Moved to... * config/nds32/nds32-relax-opt.cc: ...here. * config/nds32/nds32-utils.c: Moved to... * config/nds32/nds32-utils.cc: ...here. * config/nds32/nds32.c: Moved to... * config/nds32/nds32.cc: ...here. * config/netbsd-d.c: Moved to... * config/netbsd-d.cc: ...here. * config/netbsd.c: Moved to... * config/netbsd.cc: ...here. * config/nios2/nios2.c: Moved to... * config/nios2/nios2.cc: ...here. * config/nvptx/mkoffload.c: Moved to... * config/nvptx/mkoffload.cc: ...here. * config/nvptx/nvptx-c.c: Moved to... * config/nvptx/nvptx-c.cc: ...here. * config/nvptx/nvptx.c: Moved to... * config/nvptx/nvptx.cc: ...here. * config/openbsd-d.c: Moved to... * config/openbsd-d.cc: ...here. * config/or1k/or1k.c: Moved to... * config/or1k/or1k.cc: ...here. * config/pa/pa-d.c: Moved to... * config/pa/pa-d.cc: ...here. * config/pa/pa.c: Moved to... * config/pa/pa.cc: ...here. * config/pdp11/pdp11.c: Moved to... * config/pdp11/pdp11.cc: ...here. * config/pru/pru-passes.c: Moved to... * config/pru/pru-passes.cc: ...here. * config/pru/pru-pragma.c: Moved to... * config/pru/pru-pragma.cc: ...here. * config/pru/pru.c: Moved to... * config/pru/pru.cc: ...here. * config/riscv/riscv-builtins.c: Moved to... * config/riscv/riscv-builtins.cc: ...here. * config/riscv/riscv-c.c: Moved to... * config/riscv/riscv-c.cc: ...here. * config/riscv/riscv-d.c: Moved to... * config/riscv/riscv-d.cc: ...here. * config/riscv/riscv-shorten-memrefs.c: Moved to... * config/riscv/riscv-shorten-memrefs.cc: ...here. * config/riscv/riscv-sr.c: Moved to... * config/riscv/riscv-sr.cc: ...here. * config/riscv/riscv.c: Moved to... * config/riscv/riscv.cc: ...here. * config/rl78/rl78-c.c: Moved to... * config/rl78/rl78-c.cc: ...here. * config/rl78/rl78.c: Moved to... * config/rl78/rl78.cc: ...here. * config/rs6000/driver-rs6000.c: Moved to... * config/rs6000/driver-rs6000.cc: ...here. * config/rs6000/host-darwin.c: Moved to... * config/rs6000/host-darwin.cc: ...here. * config/rs6000/host-ppc64-darwin.c: Moved to... * config/rs6000/host-ppc64-darwin.cc: ...here. * config/rs6000/rbtree.c: Moved to... * config/rs6000/rbtree.cc: ...here. * config/rs6000/rs6000-c.c: Moved to... * config/rs6000/rs6000-c.cc: ...here. * config/rs6000/rs6000-call.c: Moved to... * config/rs6000/rs6000-call.cc: ...here. * config/rs6000/rs6000-d.c: Moved to... * config/rs6000/rs6000-d.cc: ...here. * config/rs6000/rs6000-gen-builtins.c: Moved to... * config/rs6000/rs6000-gen-builtins.cc: ...here. * config/rs6000/rs6000-linux.c: Moved to... * config/rs6000/rs6000-linux.cc: ...here. * config/rs6000/rs6000-logue.c: Moved to... * config/rs6000/rs6000-logue.cc: ...here. * config/rs6000/rs6000-p8swap.c: Moved to... * config/rs6000/rs6000-p8swap.cc: ...here. * config/rs6000/rs6000-pcrel-opt.c: Moved to... * config/rs6000/rs6000-pcrel-opt.cc: ...here. * config/rs6000/rs6000-string.c: Moved to... * config/rs6000/rs6000-string.cc: ...here. * config/rs6000/rs6000.c: Moved to... * config/rs6000/rs6000.cc: ...here. * config/rx/rx.c: Moved to... * config/rx/rx.cc: ...here. * config/s390/driver-native.c: Moved to... * config/s390/driver-native.cc: ...here. * config/s390/s390-c.c: Moved to... * config/s390/s390-c.cc: ...here. * config/s390/s390-d.c: Moved to... * config/s390/s390-d.cc: ...here. * config/s390/s390.c: Moved to... * config/s390/s390.cc: ...here. * config/sh/divtab-sh4-300.c: Moved to... * config/sh/divtab-sh4-300.cc: ...here. * config/sh/divtab-sh4.c: Moved to... * config/sh/divtab-sh4.cc: ...here. * config/sh/divtab.c: Moved to... * config/sh/divtab.cc: ...here. * config/sh/sh-c.c: Moved to... * config/sh/sh-c.cc: ...here. * config/sh/sh.c: Moved to... * config/sh/sh.cc: ...here. * config/sol2-c.c: Moved to... * config/sol2-c.cc: ...here. * config/sol2-cxx.c: Moved to... * config/sol2-cxx.cc: ...here. * config/sol2-d.c: Moved to... * config/sol2-d.cc: ...here. * config/sol2-stubs.c: Moved to... * config/sol2-stubs.cc: ...here. * config/sol2.c: Moved to... * config/sol2.cc: ...here. * config/sparc/driver-sparc.c: Moved to... * config/sparc/driver-sparc.cc: ...here. * config/sparc/sparc-c.c: Moved to... * config/sparc/sparc-c.cc: ...here. * config/sparc/sparc-d.c: Moved to... * config/sparc/sparc-d.cc: ...here. * config/sparc/sparc.c: Moved to... * config/sparc/sparc.cc: ...here. * config/stormy16/stormy16.c: Moved to... * config/stormy16/stormy16.cc: ...here. * config/tilegx/mul-tables.c: Moved to... * config/tilegx/mul-tables.cc: ...here. * config/tilegx/tilegx-c.c: Moved to... * config/tilegx/tilegx-c.cc: ...here. * config/tilegx/tilegx.c: Moved to... * config/tilegx/tilegx.cc: ...here. * config/tilepro/mul-tables.c: Moved to... * config/tilepro/mul-tables.cc: ...here. * config/tilepro/tilepro-c.c: Moved to... * config/tilepro/tilepro-c.cc: ...here. * config/tilepro/tilepro.c: Moved to... * config/tilepro/tilepro.cc: ...here. * config/v850/v850-c.c: Moved to... * config/v850/v850-c.cc: ...here. * config/v850/v850.c: Moved to... * config/v850/v850.cc: ...here. * config/vax/vax.c: Moved to... * config/vax/vax.cc: ...here. * config/visium/visium.c: Moved to... * config/visium/visium.cc: ...here. * config/vms/vms-c.c: Moved to... * config/vms/vms-c.cc: ...here. * config/vms/vms-f.c: Moved to... * config/vms/vms-f.cc: ...here. * config/vms/vms.c: Moved to... * config/vms/vms.cc: ...here. * config/vxworks-c.c: Moved to... * config/vxworks-c.cc: ...here. * config/vxworks.c: Moved to... * config/vxworks.cc: ...here. * config/winnt-c.c: Moved to... * config/winnt-c.cc: ...here. * config/xtensa/xtensa.c: Moved to... * config/xtensa/xtensa.cc: ...here. * context.c: Moved to... * context.cc: ...here. * convert.c: Moved to... * convert.cc: ...here. * coverage.c: Moved to... * coverage.cc: ...here. * cppbuiltin.c: Moved to... * cppbuiltin.cc: ...here. * cppdefault.c: Moved to... * cppdefault.cc: ...here. * cprop.c: Moved to... * cprop.cc: ...here. * cse.c: Moved to... * cse.cc: ...here. * cselib.c: Moved to... * cselib.cc: ...here. * ctfc.c: Moved to... * ctfc.cc: ...here. * ctfout.c: Moved to... * ctfout.cc: ...here. * data-streamer-in.c: Moved to... * data-streamer-in.cc: ...here. * data-streamer-out.c: Moved to... * data-streamer-out.cc: ...here. * data-streamer.c: Moved to... * data-streamer.cc: ...here. * dbgcnt.c: Moved to... * dbgcnt.cc: ...here. * dbxout.c: Moved to... * dbxout.cc: ...here. * dce.c: Moved to... * dce.cc: ...here. * ddg.c: Moved to... * ddg.cc: ...here. * debug.c: Moved to... * debug.cc: ...here. * df-core.c: Moved to... * df-core.cc: ...here. * df-problems.c: Moved to... * df-problems.cc: ...here. * df-scan.c: Moved to... * df-scan.cc: ...here. * dfp.c: Moved to... * dfp.cc: ...here. * diagnostic-color.c: Moved to... * diagnostic-color.cc: ...here. * diagnostic-show-locus.c: Moved to... * diagnostic-show-locus.cc: ...here. * diagnostic-spec.c: Moved to... * diagnostic-spec.cc: ...here. * diagnostic.c: Moved to... * diagnostic.cc: ...here. * dojump.c: Moved to... * dojump.cc: ...here. * dominance.c: Moved to... * dominance.cc: ...here. * domwalk.c: Moved to... * domwalk.cc: ...here. * double-int.c: Moved to... * double-int.cc: ...here. * dse.c: Moved to... * dse.cc: ...here. * dumpfile.c: Moved to... * dumpfile.cc: ...here. * dwarf2asm.c: Moved to... * dwarf2asm.cc: ...here. * dwarf2cfi.c: Moved to... * dwarf2cfi.cc: ...here. * dwarf2ctf.c: Moved to... * dwarf2ctf.cc: ...here. * dwarf2out.c: Moved to... * dwarf2out.cc: ...here. * early-remat.c: Moved to... * early-remat.cc: ...here. * edit-context.c: Moved to... * edit-context.cc: ...here. * emit-rtl.c: Moved to... * emit-rtl.cc: ...here. * errors.c: Moved to... * errors.cc: ...here. * et-forest.c: Moved to... * et-forest.cc: ...here. * except.c: Moved to... * except.cc: ...here. * explow.c: Moved to... * explow.cc: ...here. * expmed.c: Moved to... * expmed.cc: ...here. * expr.c: Moved to... * expr.cc: ...here. * fibonacci_heap.c: Moved to... * fibonacci_heap.cc: ...here. * file-find.c: Moved to... * file-find.cc: ...here. * file-prefix-map.c: Moved to... * file-prefix-map.cc: ...here. * final.c: Moved to... * final.cc: ...here. * fixed-value.c: Moved to... * fixed-value.cc: ...here. * fold-const-call.c: Moved to... * fold-const-call.cc: ...here. * fold-const.c: Moved to... * fold-const.cc: ...here. * fp-test.c: Moved to... * fp-test.cc: ...here. * function-tests.c: Moved to... * function-tests.cc: ...here. * function.c: Moved to... * function.cc: ...here. * fwprop.c: Moved to... * fwprop.cc: ...here. * gcc-ar.c: Moved to... * gcc-ar.cc: ...here. * gcc-main.c: Moved to... * gcc-main.cc: ...here. * gcc-rich-location.c: Moved to... * gcc-rich-location.cc: ...here. * gcc.c: Moved to... * gcc.cc: ...here. * gcov-dump.c: Moved to... * gcov-dump.cc: ...here. * gcov-io.c: Moved to... * gcov-io.cc: ...here. * gcov-tool.c: Moved to... * gcov-tool.cc: ...here. * gcov.c: Moved to... * gcov.cc: ...here. * gcse-common.c: Moved to... * gcse-common.cc: ...here. * gcse.c: Moved to... * gcse.cc: ...here. * genattr-common.c: Moved to... * genattr-common.cc: ...here. * genattr.c: Moved to... * genattr.cc: ...here. * genattrtab.c: Moved to... * genattrtab.cc: ...here. * genautomata.c: Moved to... * genautomata.cc: ...here. * gencfn-macros.c: Moved to... * gencfn-macros.cc: ...here. * gencheck.c: Moved to... * gencheck.cc: ...here. * genchecksum.c: Moved to... * genchecksum.cc: ...here. * gencodes.c: Moved to... * gencodes.cc: ...here. * genconditions.c: Moved to... * genconditions.cc: ...here. * genconfig.c: Moved to... * genconfig.cc: ...here. * genconstants.c: Moved to... * genconstants.cc: ...here. * genemit.c: Moved to... * genemit.cc: ...here. * genenums.c: Moved to... * genenums.cc: ...here. * generic-match-head.c: Moved to... * generic-match-head.cc: ...here. * genextract.c: Moved to... * genextract.cc: ...here. * genflags.c: Moved to... * genflags.cc: ...here. * gengenrtl.c: Moved to... * gengenrtl.cc: ...here. * gengtype-parse.c: Moved to... * gengtype-parse.cc: ...here. * gengtype-state.c: Moved to... * gengtype-state.cc: ...here. * gengtype.c: Moved to... * gengtype.cc: ...here. * genhooks.c: Moved to... * genhooks.cc: ...here. * genmatch.c: Moved to... * genmatch.cc: ...here. * genmddeps.c: Moved to... * genmddeps.cc: ...here. * genmddump.c: Moved to... * genmddump.cc: ...here. * genmodes.c: Moved to... * genmodes.cc: ...here. * genopinit.c: Moved to... * genopinit.cc: ...here. * genoutput.c: Moved to... * genoutput.cc: ...here. * genpeep.c: Moved to... * genpeep.cc: ...here. * genpreds.c: Moved to... * genpreds.cc: ...here. * genrecog.c: Moved to... * genrecog.cc: ...here. * gensupport.c: Moved to... * gensupport.cc: ...here. * gentarget-def.c: Moved to... * gentarget-def.cc: ...here. * genversion.c: Moved to... * genversion.cc: ...here. * ggc-common.c: Moved to... * ggc-common.cc: ...here. * ggc-none.c: Moved to... * ggc-none.cc: ...here. * ggc-page.c: Moved to... * ggc-page.cc: ...here. * ggc-tests.c: Moved to... * ggc-tests.cc: ...here. * gimple-builder.c: Moved to... * gimple-builder.cc: ...here. * gimple-expr.c: Moved to... * gimple-expr.cc: ...here. * gimple-fold.c: Moved to... * gimple-fold.cc: ...here. * gimple-iterator.c: Moved to... * gimple-iterator.cc: ...here. * gimple-laddress.c: Moved to... * gimple-laddress.cc: ...here. * gimple-loop-jam.c: Moved to... * gimple-loop-jam.cc: ...here. * gimple-low.c: Moved to... * gimple-low.cc: ...here. * gimple-match-head.c: Moved to... * gimple-match-head.cc: ...here. * gimple-pretty-print.c: Moved to... * gimple-pretty-print.cc: ...here. * gimple-ssa-backprop.c: Moved to... * gimple-ssa-backprop.cc: ...here. * gimple-ssa-evrp-analyze.c: Moved to... * gimple-ssa-evrp-analyze.cc: ...here. * gimple-ssa-evrp.c: Moved to... * gimple-ssa-evrp.cc: ...here. * gimple-ssa-isolate-paths.c: Moved to... * gimple-ssa-isolate-paths.cc: ...here. * gimple-ssa-nonnull-compare.c: Moved to... * gimple-ssa-nonnull-compare.cc: ...here. * gimple-ssa-split-paths.c: Moved to... * gimple-ssa-split-paths.cc: ...here. * gimple-ssa-sprintf.c: Moved to... * gimple-ssa-sprintf.cc: ...here. * gimple-ssa-store-merging.c: Moved to... * gimple-ssa-store-merging.cc: ...here. * gimple-ssa-strength-reduction.c: Moved to... * gimple-ssa-strength-reduction.cc: ...here. * gimple-ssa-warn-alloca.c: Moved to... * gimple-ssa-warn-alloca.cc: ...here. * gimple-ssa-warn-restrict.c: Moved to... * gimple-ssa-warn-restrict.cc: ...here. * gimple-streamer-in.c: Moved to... * gimple-streamer-in.cc: ...here. * gimple-streamer-out.c: Moved to... * gimple-streamer-out.cc: ...here. * gimple-walk.c: Moved to... * gimple-walk.cc: ...here. * gimple-warn-recursion.c: Moved to... * gimple-warn-recursion.cc: ...here. * gimple.c: Moved to... * gimple.cc: ...here. * gimplify-me.c: Moved to... * gimplify-me.cc: ...here. * gimplify.c: Moved to... * gimplify.cc: ...here. * godump.c: Moved to... * godump.cc: ...here. * graph.c: Moved to... * graph.cc: ...here. * graphds.c: Moved to... * graphds.cc: ...here. * graphite-dependences.c: Moved to... * graphite-dependences.cc: ...here. * graphite-isl-ast-to-gimple.c: Moved to... * graphite-isl-ast-to-gimple.cc: ...here. * graphite-optimize-isl.c: Moved to... * graphite-optimize-isl.cc: ...here. * graphite-poly.c: Moved to... * graphite-poly.cc: ...here. * graphite-scop-detection.c: Moved to... * graphite-scop-detection.cc: ...here. * graphite-sese-to-poly.c: Moved to... * graphite-sese-to-poly.cc: ...here. * graphite.c: Moved to... * graphite.cc: ...here. * haifa-sched.c: Moved to... * haifa-sched.cc: ...here. * hash-map-tests.c: Moved to... * hash-map-tests.cc: ...here. * hash-set-tests.c: Moved to... * hash-set-tests.cc: ...here. * hash-table.c: Moved to... * hash-table.cc: ...here. * hooks.c: Moved to... * hooks.cc: ...here. * host-default.c: Moved to... * host-default.cc: ...here. * hw-doloop.c: Moved to... * hw-doloop.cc: ...here. * hwint.c: Moved to... * hwint.cc: ...here. * ifcvt.c: Moved to... * ifcvt.cc: ...here. * inchash.c: Moved to... * inchash.cc: ...here. * incpath.c: Moved to... * incpath.cc: ...here. * init-regs.c: Moved to... * init-regs.cc: ...here. * input.c: Moved to... * input.cc: ...here. * internal-fn.c: Moved to... * internal-fn.cc: ...here. * intl.c: Moved to... * intl.cc: ...here. * ipa-comdats.c: Moved to... * ipa-comdats.cc: ...here. * ipa-cp.c: Moved to... * ipa-cp.cc: ...here. * ipa-devirt.c: Moved to... * ipa-devirt.cc: ...here. * ipa-fnsummary.c: Moved to... * ipa-fnsummary.cc: ...here. * ipa-icf-gimple.c: Moved to... * ipa-icf-gimple.cc: ...here. * ipa-icf.c: Moved to... * ipa-icf.cc: ...here. * ipa-inline-analysis.c: Moved to... * ipa-inline-analysis.cc: ...here. * ipa-inline-transform.c: Moved to... * ipa-inline-transform.cc: ...here. * ipa-inline.c: Moved to... * ipa-inline.cc: ...here. * ipa-modref-tree.c: Moved to... * ipa-modref-tree.cc: ...here. * ipa-modref.c: Moved to... * ipa-modref.cc: ...here. * ipa-param-manipulation.c: Moved to... * ipa-param-manipulation.cc: ...here. * ipa-polymorphic-call.c: Moved to... * ipa-polymorphic-call.cc: ...here. * ipa-predicate.c: Moved to... * ipa-predicate.cc: ...here. * ipa-profile.c: Moved to... * ipa-profile.cc: ...here. * ipa-prop.c: Moved to... * ipa-prop.cc: ...here. * ipa-pure-const.c: Moved to... * ipa-pure-const.cc: ...here. * ipa-ref.c: Moved to... * ipa-ref.cc: ...here. * ipa-reference.c: Moved to... * ipa-reference.cc: ...here. * ipa-split.c: Moved to... * ipa-split.cc: ...here. * ipa-sra.c: Moved to... * ipa-sra.cc: ...here. * ipa-utils.c: Moved to... * ipa-utils.cc: ...here. * ipa-visibility.c: Moved to... * ipa-visibility.cc: ...here. * ipa.c: Moved to... * ipa.cc: ...here. * ira-build.c: Moved to... * ira-build.cc: ...here. * ira-color.c: Moved to... * ira-color.cc: ...here. * ira-conflicts.c: Moved to... * ira-conflicts.cc: ...here. * ira-costs.c: Moved to... * ira-costs.cc: ...here. * ira-emit.c: Moved to... * ira-emit.cc: ...here. * ira-lives.c: Moved to... * ira-lives.cc: ...here. * ira.c: Moved to... * ira.cc: ...here. * jump.c: Moved to... * jump.cc: ...here. * langhooks.c: Moved to... * langhooks.cc: ...here. * lcm.c: Moved to... * lcm.cc: ...here. * lists.c: Moved to... * lists.cc: ...here. * loop-doloop.c: Moved to... * loop-doloop.cc: ...here. * loop-init.c: Moved to... * loop-init.cc: ...here. * loop-invariant.c: Moved to... * loop-invariant.cc: ...here. * loop-iv.c: Moved to... * loop-iv.cc: ...here. * loop-unroll.c: Moved to... * loop-unroll.cc: ...here. * lower-subreg.c: Moved to... * lower-subreg.cc: ...here. * lra-assigns.c: Moved to... * lra-assigns.cc: ...here. * lra-coalesce.c: Moved to... * lra-coalesce.cc: ...here. * lra-constraints.c: Moved to... * lra-constraints.cc: ...here. * lra-eliminations.c: Moved to... * lra-eliminations.cc: ...here. * lra-lives.c: Moved to... * lra-lives.cc: ...here. * lra-remat.c: Moved to... * lra-remat.cc: ...here. * lra-spills.c: Moved to... * lra-spills.cc: ...here. * lra.c: Moved to... * lra.cc: ...here. * lto-cgraph.c: Moved to... * lto-cgraph.cc: ...here. * lto-compress.c: Moved to... * lto-compress.cc: ...here. * lto-opts.c: Moved to... * lto-opts.cc: ...here. * lto-section-in.c: Moved to... * lto-section-in.cc: ...here. * lto-section-out.c: Moved to... * lto-section-out.cc: ...here. * lto-streamer-in.c: Moved to... * lto-streamer-in.cc: ...here. * lto-streamer-out.c: Moved to... * lto-streamer-out.cc: ...here. * lto-streamer.c: Moved to... * lto-streamer.cc: ...here. * lto-wrapper.c: Moved to... * lto-wrapper.cc: ...here. * main.c: Moved to... * main.cc: ...here. * mcf.c: Moved to... * mcf.cc: ...here. * mode-switching.c: Moved to... * mode-switching.cc: ...here. * modulo-sched.c: Moved to... * modulo-sched.cc: ...here. * multiple_target.c: Moved to... * multiple_target.cc: ...here. * omp-expand.c: Moved to... * omp-expand.cc: ...here. * omp-general.c: Moved to... * omp-general.cc: ...here. * omp-low.c: Moved to... * omp-low.cc: ...here. * omp-offload.c: Moved to... * omp-offload.cc: ...here. * omp-simd-clone.c: Moved to... * omp-simd-clone.cc: ...here. * opt-suggestions.c: Moved to... * opt-suggestions.cc: ...here. * optabs-libfuncs.c: Moved to... * optabs-libfuncs.cc: ...here. * optabs-query.c: Moved to... * optabs-query.cc: ...here. * optabs-tree.c: Moved to... * optabs-tree.cc: ...here. * optabs.c: Moved to... * optabs.cc: ...here. * opts-common.c: Moved to... * opts-common.cc: ...here. * opts-global.c: Moved to... * opts-global.cc: ...here. * opts.c: Moved to... * opts.cc: ...here. * passes.c: Moved to... * passes.cc: ...here. * plugin.c: Moved to... * plugin.cc: ...here. * postreload-gcse.c: Moved to... * postreload-gcse.cc: ...here. * postreload.c: Moved to... * postreload.cc: ...here. * predict.c: Moved to... * predict.cc: ...here. * prefix.c: Moved to... * prefix.cc: ...here. * pretty-print.c: Moved to... * pretty-print.cc: ...here. * print-rtl-function.c: Moved to... * print-rtl-function.cc: ...here. * print-rtl.c: Moved to... * print-rtl.cc: ...here. * print-tree.c: Moved to... * print-tree.cc: ...here. * profile-count.c: Moved to... * profile-count.cc: ...here. * profile.c: Moved to... * profile.cc: ...here. * read-md.c: Moved to... * read-md.cc: ...here. * read-rtl-function.c: Moved to... * read-rtl-function.cc: ...here. * read-rtl.c: Moved to... * read-rtl.cc: ...here. * real.c: Moved to... * real.cc: ...here. * realmpfr.c: Moved to... * realmpfr.cc: ...here. * recog.c: Moved to... * recog.cc: ...here. * ree.c: Moved to... * ree.cc: ...here. * reg-stack.c: Moved to... * reg-stack.cc: ...here. * regcprop.c: Moved to... * regcprop.cc: ...here. * reginfo.c: Moved to... * reginfo.cc: ...here. * regrename.c: Moved to... * regrename.cc: ...here. * regstat.c: Moved to... * regstat.cc: ...here. * reload.c: Moved to... * reload.cc: ...here. * reload1.c: Moved to... * reload1.cc: ...here. * reorg.c: Moved to... * reorg.cc: ...here. * resource.c: Moved to... * resource.cc: ...here. * rtl-error.c: Moved to... * rtl-error.cc: ...here. * rtl-tests.c: Moved to... * rtl-tests.cc: ...here. * rtl.c: Moved to... * rtl.cc: ...here. * rtlanal.c: Moved to... * rtlanal.cc: ...here. * rtlhash.c: Moved to... * rtlhash.cc: ...here. * rtlhooks.c: Moved to... * rtlhooks.cc: ...here. * rtx-vector-builder.c: Moved to... * rtx-vector-builder.cc: ...here. * run-rtl-passes.c: Moved to... * run-rtl-passes.cc: ...here. * sancov.c: Moved to... * sancov.cc: ...here. * sanopt.c: Moved to... * sanopt.cc: ...here. * sbitmap.c: Moved to... * sbitmap.cc: ...here. * sched-deps.c: Moved to... * sched-deps.cc: ...here. * sched-ebb.c: Moved to... * sched-ebb.cc: ...here. * sched-rgn.c: Moved to... * sched-rgn.cc: ...here. * sel-sched-dump.c: Moved to... * sel-sched-dump.cc: ...here. * sel-sched-ir.c: Moved to... * sel-sched-ir.cc: ...here. * sel-sched.c: Moved to... * sel-sched.cc: ...here. * selftest-diagnostic.c: Moved to... * selftest-diagnostic.cc: ...here. * selftest-rtl.c: Moved to... * selftest-rtl.cc: ...here. * selftest-run-tests.c: Moved to... * selftest-run-tests.cc: ...here. * selftest.c: Moved to... * selftest.cc: ...here. * sese.c: Moved to... * sese.cc: ...here. * shrink-wrap.c: Moved to... * shrink-wrap.cc: ...here. * simplify-rtx.c: Moved to... * simplify-rtx.cc: ...here. * sparseset.c: Moved to... * sparseset.cc: ...here. * spellcheck-tree.c: Moved to... * spellcheck-tree.cc: ...here. * spellcheck.c: Moved to... * spellcheck.cc: ...here. * sreal.c: Moved to... * sreal.cc: ...here. * stack-ptr-mod.c: Moved to... * stack-ptr-mod.cc: ...here. * statistics.c: Moved to... * statistics.cc: ...here. * stmt.c: Moved to... * stmt.cc: ...here. * stor-layout.c: Moved to... * stor-layout.cc: ...here. * store-motion.c: Moved to... * store-motion.cc: ...here. * streamer-hooks.c: Moved to... * streamer-hooks.cc: ...here. * stringpool.c: Moved to... * stringpool.cc: ...here. * substring-locations.c: Moved to... * substring-locations.cc: ...here. * symtab.c: Moved to... * symtab.cc: ...here. * target-globals.c: Moved to... * target-globals.cc: ...here. * targhooks.c: Moved to... * targhooks.cc: ...here. * timevar.c: Moved to... * timevar.cc: ...here. * toplev.c: Moved to... * toplev.cc: ...here. * tracer.c: Moved to... * tracer.cc: ...here. * trans-mem.c: Moved to... * trans-mem.cc: ...here. * tree-affine.c: Moved to... * tree-affine.cc: ...here. * tree-call-cdce.c: Moved to... * tree-call-cdce.cc: ...here. * tree-cfg.c: Moved to... * tree-cfg.cc: ...here. * tree-cfgcleanup.c: Moved to... * tree-cfgcleanup.cc: ...here. * tree-chrec.c: Moved to... * tree-chrec.cc: ...here. * tree-complex.c: Moved to... * tree-complex.cc: ...here. * tree-data-ref.c: Moved to... * tree-data-ref.cc: ...here. * tree-dfa.c: Moved to... * tree-dfa.cc: ...here. * tree-diagnostic.c: Moved to... * tree-diagnostic.cc: ...here. * tree-dump.c: Moved to... * tree-dump.cc: ...here. * tree-eh.c: Moved to... * tree-eh.cc: ...here. * tree-emutls.c: Moved to... * tree-emutls.cc: ...here. * tree-if-conv.c: Moved to... * tree-if-conv.cc: ...here. * tree-inline.c: Moved to... * tree-inline.cc: ...here. * tree-into-ssa.c: Moved to... * tree-into-ssa.cc: ...here. * tree-iterator.c: Moved to... * tree-iterator.cc: ...here. * tree-loop-distribution.c: Moved to... * tree-loop-distribution.cc: ...here. * tree-nested.c: Moved to... * tree-nested.cc: ...here. * tree-nrv.c: Moved to... * tree-nrv.cc: ...here. * tree-object-size.c: Moved to... * tree-object-size.cc: ...here. * tree-outof-ssa.c: Moved to... * tree-outof-ssa.cc: ...here. * tree-parloops.c: Moved to... * tree-parloops.cc: ...here. * tree-phinodes.c: Moved to... * tree-phinodes.cc: ...here. * tree-predcom.c: Moved to... * tree-predcom.cc: ...here. * tree-pretty-print.c: Moved to... * tree-pretty-print.cc: ...here. * tree-profile.c: Moved to... * tree-profile.cc: ...here. * tree-scalar-evolution.c: Moved to... * tree-scalar-evolution.cc: ...here. * tree-sra.c: Moved to... * tree-sra.cc: ...here. * tree-ssa-address.c: Moved to... * tree-ssa-address.cc: ...here. * tree-ssa-alias.c: Moved to... * tree-ssa-alias.cc: ...here. * tree-ssa-ccp.c: Moved to... * tree-ssa-ccp.cc: ...here. * tree-ssa-coalesce.c: Moved to... * tree-ssa-coalesce.cc: ...here. * tree-ssa-copy.c: Moved to... * tree-ssa-copy.cc: ...here. * tree-ssa-dce.c: Moved to... * tree-ssa-dce.cc: ...here. * tree-ssa-dom.c: Moved to... * tree-ssa-dom.cc: ...here. * tree-ssa-dse.c: Moved to... * tree-ssa-dse.cc: ...here. * tree-ssa-forwprop.c: Moved to... * tree-ssa-forwprop.cc: ...here. * tree-ssa-ifcombine.c: Moved to... * tree-ssa-ifcombine.cc: ...here. * tree-ssa-live.c: Moved to... * tree-ssa-live.cc: ...here. * tree-ssa-loop-ch.c: Moved to... * tree-ssa-loop-ch.cc: ...here. * tree-ssa-loop-im.c: Moved to... * tree-ssa-loop-im.cc: ...here. * tree-ssa-loop-ivcanon.c: Moved to... * tree-ssa-loop-ivcanon.cc: ...here. * tree-ssa-loop-ivopts.c: Moved to... * tree-ssa-loop-ivopts.cc: ...here. * tree-ssa-loop-manip.c: Moved to... * tree-ssa-loop-manip.cc: ...here. * tree-ssa-loop-niter.c: Moved to... * tree-ssa-loop-niter.cc: ...here. * tree-ssa-loop-prefetch.c: Moved to... * tree-ssa-loop-prefetch.cc: ...here. * tree-ssa-loop-split.c: Moved to... * tree-ssa-loop-split.cc: ...here. * tree-ssa-loop-unswitch.c: Moved to... * tree-ssa-loop-unswitch.cc: ...here. * tree-ssa-loop.c: Moved to... * tree-ssa-loop.cc: ...here. * tree-ssa-math-opts.c: Moved to... * tree-ssa-math-opts.cc: ...here. * tree-ssa-operands.c: Moved to... * tree-ssa-operands.cc: ...here. * tree-ssa-phiopt.c: Moved to... * tree-ssa-phiopt.cc: ...here. * tree-ssa-phiprop.c: Moved to... * tree-ssa-phiprop.cc: ...here. * tree-ssa-pre.c: Moved to... * tree-ssa-pre.cc: ...here. * tree-ssa-propagate.c: Moved to... * tree-ssa-propagate.cc: ...here. * tree-ssa-reassoc.c: Moved to... * tree-ssa-reassoc.cc: ...here. * tree-ssa-sccvn.c: Moved to... * tree-ssa-sccvn.cc: ...here. * tree-ssa-scopedtables.c: Moved to... * tree-ssa-scopedtables.cc: ...here. * tree-ssa-sink.c: Moved to... * tree-ssa-sink.cc: ...here. * tree-ssa-strlen.c: Moved to... * tree-ssa-strlen.cc: ...here. * tree-ssa-structalias.c: Moved to... * tree-ssa-structalias.cc: ...here. * tree-ssa-tail-merge.c: Moved to... * tree-ssa-tail-merge.cc: ...here. * tree-ssa-ter.c: Moved to... * tree-ssa-ter.cc: ...here. * tree-ssa-threadbackward.c: Moved to... * tree-ssa-threadbackward.cc: ...here. * tree-ssa-threadedge.c: Moved to... * tree-ssa-threadedge.cc: ...here. * tree-ssa-threadupdate.c: Moved to... * tree-ssa-threadupdate.cc: ...here. * tree-ssa-uncprop.c: Moved to... * tree-ssa-uncprop.cc: ...here. * tree-ssa-uninit.c: Moved to... * tree-ssa-uninit.cc: ...here. * tree-ssa.c: Moved to... * tree-ssa.cc: ...here. * tree-ssanames.c: Moved to... * tree-ssanames.cc: ...here. * tree-stdarg.c: Moved to... * tree-stdarg.cc: ...here. * tree-streamer-in.c: Moved to... * tree-streamer-in.cc: ...here. * tree-streamer-out.c: Moved to... * tree-streamer-out.cc: ...here. * tree-streamer.c: Moved to... * tree-streamer.cc: ...here. * tree-switch-conversion.c: Moved to... * tree-switch-conversion.cc: ...here. * tree-tailcall.c: Moved to... * tree-tailcall.cc: ...here. * tree-vect-data-refs.c: Moved to... * tree-vect-data-refs.cc: ...here. * tree-vect-generic.c: Moved to... * tree-vect-generic.cc: ...here. * tree-vect-loop-manip.c: Moved to... * tree-vect-loop-manip.cc: ...here. * tree-vect-loop.c: Moved to... * tree-vect-loop.cc: ...here. * tree-vect-patterns.c: Moved to... * tree-vect-patterns.cc: ...here. * tree-vect-slp-patterns.c: Moved to... * tree-vect-slp-patterns.cc: ...here. * tree-vect-slp.c: Moved to... * tree-vect-slp.cc: ...here. * tree-vect-stmts.c: Moved to... * tree-vect-stmts.cc: ...here. * tree-vector-builder.c: Moved to... * tree-vector-builder.cc: ...here. * tree-vectorizer.c: Moved to... * tree-vectorizer.cc: ...here. * tree-vrp.c: Moved to... * tree-vrp.cc: ...here. * tree.c: Moved to... * tree.cc: ...here. * tsan.c: Moved to... * tsan.cc: ...here. * typed-splay-tree.c: Moved to... * typed-splay-tree.cc: ...here. * ubsan.c: Moved to... * ubsan.cc: ...here. * valtrack.c: Moved to... * valtrack.cc: ...here. * value-prof.c: Moved to... * value-prof.cc: ...here. * var-tracking.c: Moved to... * var-tracking.cc: ...here. * varasm.c: Moved to... * varasm.cc: ...here. * varpool.c: Moved to... * varpool.cc: ...here. * vec-perm-indices.c: Moved to... * vec-perm-indices.cc: ...here. * vec.c: Moved to... * vec.cc: ...here. * vmsdbgout.c: Moved to... * vmsdbgout.cc: ...here. * vr-values.c: Moved to... * vr-values.cc: ...here. * vtable-verify.c: Moved to... * vtable-verify.cc: ...here. * web.c: Moved to... * web.cc: ...here. * xcoffout.c: Moved to... * xcoffout.cc: ...here. gcc/c-family/ChangeLog: * c-ada-spec.c: Moved to... * c-ada-spec.cc: ...here. * c-attribs.c: Moved to... * c-attribs.cc: ...here. * c-common.c: Moved to... * c-common.cc: ...here. * c-cppbuiltin.c: Moved to... * c-cppbuiltin.cc: ...here. * c-dump.c: Moved to... * c-dump.cc: ...here. * c-format.c: Moved to... * c-format.cc: ...here. * c-gimplify.c: Moved to... * c-gimplify.cc: ...here. * c-indentation.c: Moved to... * c-indentation.cc: ...here. * c-lex.c: Moved to... * c-lex.cc: ...here. * c-omp.c: Moved to... * c-omp.cc: ...here. * c-opts.c: Moved to... * c-opts.cc: ...here. * c-pch.c: Moved to... * c-pch.cc: ...here. * c-ppoutput.c: Moved to... * c-ppoutput.cc: ...here. * c-pragma.c: Moved to... * c-pragma.cc: ...here. * c-pretty-print.c: Moved to... * c-pretty-print.cc: ...here. * c-semantics.c: Moved to... * c-semantics.cc: ...here. * c-ubsan.c: Moved to... * c-ubsan.cc: ...here. * c-warn.c: Moved to... * c-warn.cc: ...here. * cppspec.c: Moved to... * cppspec.cc: ...here. * stub-objc.c: Moved to... * stub-objc.cc: ...here. gcc/c/ChangeLog: * c-aux-info.c: Moved to... * c-aux-info.cc: ...here. * c-convert.c: Moved to... * c-convert.cc: ...here. * c-decl.c: Moved to... * c-decl.cc: ...here. * c-errors.c: Moved to... * c-errors.cc: ...here. * c-fold.c: Moved to... * c-fold.cc: ...here. * c-lang.c: Moved to... * c-lang.cc: ...here. * c-objc-common.c: Moved to... * c-objc-common.cc: ...here. * c-parser.c: Moved to... * c-parser.cc: ...here. * c-typeck.c: Moved to... * c-typeck.cc: ...here. * gccspec.c: Moved to... * gccspec.cc: ...here. * gimple-parser.c: Moved to... * gimple-parser.cc: ...here. gcc/cp/ChangeLog: * call.c: Moved to... * call.cc: ...here. * class.c: Moved to... * class.cc: ...here. * constexpr.c: Moved to... * constexpr.cc: ...here. * cp-gimplify.c: Moved to... * cp-gimplify.cc: ...here. * cp-lang.c: Moved to... * cp-lang.cc: ...here. * cp-objcp-common.c: Moved to... * cp-objcp-common.cc: ...here. * cp-ubsan.c: Moved to... * cp-ubsan.cc: ...here. * cvt.c: Moved to... * cvt.cc: ...here. * cxx-pretty-print.c: Moved to... * cxx-pretty-print.cc: ...here. * decl.c: Moved to... * decl.cc: ...here. * decl2.c: Moved to... * decl2.cc: ...here. * dump.c: Moved to... * dump.cc: ...here. * error.c: Moved to... * error.cc: ...here. * except.c: Moved to... * except.cc: ...here. * expr.c: Moved to... * expr.cc: ...here. * friend.c: Moved to... * friend.cc: ...here. * g++spec.c: Moved to... * g++spec.cc: ...here. * init.c: Moved to... * init.cc: ...here. * lambda.c: Moved to... * lambda.cc: ...here. * lex.c: Moved to... * lex.cc: ...here. * mangle.c: Moved to... * mangle.cc: ...here. * method.c: Moved to... * method.cc: ...here. * name-lookup.c: Moved to... * name-lookup.cc: ...here. * optimize.c: Moved to... * optimize.cc: ...here. * parser.c: Moved to... * parser.cc: ...here. * pt.c: Moved to... * pt.cc: ...here. * ptree.c: Moved to... * ptree.cc: ...here. * rtti.c: Moved to... * rtti.cc: ...here. * search.c: Moved to... * search.cc: ...here. * semantics.c: Moved to... * semantics.cc: ...here. * tree.c: Moved to... * tree.cc: ...here. * typeck.c: Moved to... * typeck.cc: ...here. * typeck2.c: Moved to... * typeck2.cc: ...here. * vtable-class-hierarchy.c: Moved to... * vtable-class-hierarchy.cc: ...here. gcc/fortran/ChangeLog: * arith.c: Moved to... * arith.cc: ...here. * array.c: Moved to... * array.cc: ...here. * bbt.c: Moved to... * bbt.cc: ...here. * check.c: Moved to... * check.cc: ...here. * class.c: Moved to... * class.cc: ...here. * constructor.c: Moved to... * constructor.cc: ...here. * convert.c: Moved to... * convert.cc: ...here. * cpp.c: Moved to... * cpp.cc: ...here. * data.c: Moved to... * data.cc: ...here. * decl.c: Moved to... * decl.cc: ...here. * dependency.c: Moved to... * dependency.cc: ...here. * dump-parse-tree.c: Moved to... * dump-parse-tree.cc: ...here. * error.c: Moved to... * error.cc: ...here. * expr.c: Moved to... * expr.cc: ...here. * f95-lang.c: Moved to... * f95-lang.cc: ...here. * frontend-passes.c: Moved to... * frontend-passes.cc: ...here. * gfortranspec.c: Moved to... * gfortranspec.cc: ...here. * interface.c: Moved to... * interface.cc: ...here. * intrinsic.c: Moved to... * intrinsic.cc: ...here. * io.c: Moved to... * io.cc: ...here. * iresolve.c: Moved to... * iresolve.cc: ...here. * match.c: Moved to... * match.cc: ...here. * matchexp.c: Moved to... * matchexp.cc: ...here. * misc.c: Moved to... * misc.cc: ...here. * module.c: Moved to... * module.cc: ...here. * openmp.c: Moved to... * openmp.cc: ...here. * options.c: Moved to... * options.cc: ...here. * parse.c: Moved to... * parse.cc: ...here. * primary.c: Moved to... * primary.cc: ...here. * resolve.c: Moved to... * resolve.cc: ...here. * scanner.c: Moved to... * scanner.cc: ...here. * simplify.c: Moved to... * simplify.cc: ...here. * st.c: Moved to... * st.cc: ...here. * symbol.c: Moved to... * symbol.cc: ...here. * target-memory.c: Moved to... * target-memory.cc: ...here. * trans-array.c: Moved to... * trans-array.cc: ...here. * trans-common.c: Moved to... * trans-common.cc: ...here. * trans-const.c: Moved to... * trans-const.cc: ...here. * trans-decl.c: Moved to... * trans-decl.cc: ...here. * trans-expr.c: Moved to... * trans-expr.cc: ...here. * trans-intrinsic.c: Moved to... * trans-intrinsic.cc: ...here. * trans-io.c: Moved to... * trans-io.cc: ...here. * trans-openmp.c: Moved to... * trans-openmp.cc: ...here. * trans-stmt.c: Moved to... * trans-stmt.cc: ...here. * trans-types.c: Moved to... * trans-types.cc: ...here. * trans.c: Moved to... * trans.cc: ...here. gcc/go/ChangeLog: * go-backend.c: Moved to... * go-backend.cc: ...here. * go-lang.c: Moved to... * go-lang.cc: ...here. * gospec.c: Moved to... * gospec.cc: ...here. gcc/jit/ChangeLog: * dummy-frontend.c: Moved to... * dummy-frontend.cc: ...here. * jit-builtins.c: Moved to... * jit-builtins.cc: ...here. * jit-logging.c: Moved to... * jit-logging.cc: ...here. * jit-playback.c: Moved to... * jit-playback.cc: ...here. * jit-recording.c: Moved to... * jit-recording.cc: ...here. * jit-result.c: Moved to... * jit-result.cc: ...here. * jit-spec.c: Moved to... * jit-spec.cc: ...here. * jit-tempdir.c: Moved to... * jit-tempdir.cc: ...here. * jit-w32.c: Moved to... * jit-w32.cc: ...here. * libgccjit.c: Moved to... * libgccjit.cc: ...here. gcc/lto/ChangeLog: * common.c: Moved to... * common.cc: ...here. * lto-common.c: Moved to... * lto-common.cc: ...here. * lto-dump.c: Moved to... * lto-dump.cc: ...here. * lto-lang.c: Moved to... * lto-lang.cc: ...here. * lto-object.c: Moved to... * lto-object.cc: ...here. * lto-partition.c: Moved to... * lto-partition.cc: ...here. * lto-symtab.c: Moved to... * lto-symtab.cc: ...here. * lto.c: Moved to... * lto.cc: ...here. gcc/objc/ChangeLog: * objc-act.c: Moved to... * objc-act.cc: ...here. * objc-encoding.c: Moved to... * objc-encoding.cc: ...here. * objc-gnu-runtime-abi-01.c: Moved to... * objc-gnu-runtime-abi-01.cc: ...here. * objc-lang.c: Moved to... * objc-lang.cc: ...here. * objc-map.c: Moved to... * objc-map.cc: ...here. * objc-next-runtime-abi-01.c: Moved to... * objc-next-runtime-abi-01.cc: ...here. * objc-next-runtime-abi-02.c: Moved to... * objc-next-runtime-abi-02.cc: ...here. * objc-runtime-shared-support.c: Moved to... * objc-runtime-shared-support.cc: ...here. gcc/objcp/ChangeLog: * objcp-decl.c: Moved to... * objcp-decl.cc: ...here. * objcp-lang.c: Moved to... * objcp-lang.cc: ...here. libcpp/ChangeLog: * charset.c: Moved to... * charset.cc: ...here. * directives.c: Moved to... * directives.cc: ...here. * errors.c: Moved to... * errors.cc: ...here. * expr.c: Moved to... * expr.cc: ...here. * files.c: Moved to... * files.cc: ...here. * identifiers.c: Moved to... * identifiers.cc: ...here. * init.c: Moved to... * init.cc: ...here. * lex.c: Moved to... * lex.cc: ...here. * line-map.c: Moved to... * line-map.cc: ...here. * macro.c: Moved to... * macro.cc: ...here. * makeucnid.c: Moved to... * makeucnid.cc: ...here. * mkdeps.c: Moved to... * mkdeps.cc: ...here. * pch.c: Moved to... * pch.cc: ...here. * symtab.c: Moved to... * symtab.cc: ...here. * traditional.c: Moved to... * traditional.cc: ...here. --- gcc/tree-eh.c | 5052 --------------------------------------------------------- 1 file changed, 5052 deletions(-) delete mode 100644 gcc/tree-eh.c (limited to 'gcc/tree-eh.c') diff --git a/gcc/tree-eh.c b/gcc/tree-eh.c deleted file mode 100644 index 0f8a3ad..0000000 --- a/gcc/tree-eh.c +++ /dev/null @@ -1,5052 +0,0 @@ -/* Exception handling semantics and decomposition for trees. - Copyright (C) 2003-2022 Free Software Foundation, Inc. - -This file is part of GCC. - -GCC is free software; you can redistribute it and/or modify -it under the terms of the GNU General Public License as published by -the Free Software Foundation; either version 3, or (at your option) -any later version. - -GCC is distributed in the hope that it will be useful, -but WITHOUT ANY WARRANTY; without even the implied warranty of -MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -GNU General Public License for more details. - -You should have received a copy of the GNU General Public License -along with GCC; see the file COPYING3. If not see -. */ - -#include "config.h" -#include "system.h" -#include "coretypes.h" -#include "backend.h" -#include "rtl.h" -#include "tree.h" -#include "gimple.h" -#include "cfghooks.h" -#include "tree-pass.h" -#include "ssa.h" -#include "cgraph.h" -#include "diagnostic-core.h" -#include "fold-const.h" -#include "calls.h" -#include "except.h" -#include "cfganal.h" -#include "cfgcleanup.h" -#include "tree-eh.h" -#include "gimple-iterator.h" -#include "tree-cfg.h" -#include "tree-into-ssa.h" -#include "tree-ssa.h" -#include "tree-inline.h" -#include "langhooks.h" -#include "cfgloop.h" -#include "gimple-low.h" -#include "stringpool.h" -#include "attribs.h" -#include "asan.h" -#include "gimplify.h" - -/* In some instances a tree and a gimple need to be stored in a same table, - i.e. in hash tables. This is a structure to do this. */ -typedef union {tree *tp; tree t; gimple *g;} treemple; - -/* Misc functions used in this file. */ - -/* Remember and lookup EH landing pad data for arbitrary statements. - Really this means any statement that could_throw_p. We could - stuff this information into the stmt_ann data structure, but: - - (1) We absolutely rely on this information being kept until - we get to rtl. Once we're done with lowering here, if we lose - the information there's no way to recover it! - - (2) There are many more statements that *cannot* throw as - compared to those that can. We should be saving some amount - of space by only allocating memory for those that can throw. */ - -/* Add statement T in function IFUN to landing pad NUM. */ - -static void -add_stmt_to_eh_lp_fn (struct function *ifun, gimple *t, int num) -{ - gcc_assert (num != 0); - - if (!get_eh_throw_stmt_table (ifun)) - set_eh_throw_stmt_table (ifun, hash_map::create_ggc (31)); - - gcc_assert (!get_eh_throw_stmt_table (ifun)->put (t, num)); -} - -/* Add statement T in the current function (cfun) to EH landing pad NUM. */ - -void -add_stmt_to_eh_lp (gimple *t, int num) -{ - add_stmt_to_eh_lp_fn (cfun, t, num); -} - -/* Add statement T to the single EH landing pad in REGION. */ - -static void -record_stmt_eh_region (eh_region region, gimple *t) -{ - if (region == NULL) - return; - if (region->type == ERT_MUST_NOT_THROW) - add_stmt_to_eh_lp_fn (cfun, t, -region->index); - else - { - eh_landing_pad lp = region->landing_pads; - if (lp == NULL) - lp = gen_eh_landing_pad (region); - else - gcc_assert (lp->next_lp == NULL); - add_stmt_to_eh_lp_fn (cfun, t, lp->index); - } -} - - -/* Remove statement T in function IFUN from its EH landing pad. */ - -bool -remove_stmt_from_eh_lp_fn (struct function *ifun, gimple *t) -{ - if (!get_eh_throw_stmt_table (ifun)) - return false; - - if (!get_eh_throw_stmt_table (ifun)->get (t)) - return false; - - get_eh_throw_stmt_table (ifun)->remove (t); - return true; -} - - -/* Remove statement T in the current function (cfun) from its - EH landing pad. */ - -bool -remove_stmt_from_eh_lp (gimple *t) -{ - return remove_stmt_from_eh_lp_fn (cfun, t); -} - -/* Determine if statement T is inside an EH region in function IFUN. - Positive numbers indicate a landing pad index; negative numbers - indicate a MUST_NOT_THROW region index; zero indicates that the - statement is not recorded in the region table. */ - -int -lookup_stmt_eh_lp_fn (struct function *ifun, const gimple *t) -{ - if (ifun->eh->throw_stmt_table == NULL) - return 0; - - int *lp_nr = ifun->eh->throw_stmt_table->get (const_cast (t)); - return lp_nr ? *lp_nr : 0; -} - -/* Likewise, but always use the current function. */ - -int -lookup_stmt_eh_lp (const gimple *t) -{ - /* We can get called from initialized data when -fnon-call-exceptions - is on; prevent crash. */ - if (!cfun) - return 0; - return lookup_stmt_eh_lp_fn (cfun, t); -} - -/* First pass of EH node decomposition. Build up a tree of GIMPLE_TRY_FINALLY - nodes and LABEL_DECL nodes. We will use this during the second phase to - determine if a goto leaves the body of a TRY_FINALLY_EXPR node. */ - -struct finally_tree_node -{ - /* When storing a GIMPLE_TRY, we have to record a gimple. However - when deciding whether a GOTO to a certain LABEL_DECL (which is a - tree) leaves the TRY block, its necessary to record a tree in - this field. Thus a treemple is used. */ - treemple child; - gtry *parent; -}; - -/* Hashtable helpers. */ - -struct finally_tree_hasher : free_ptr_hash -{ - static inline hashval_t hash (const finally_tree_node *); - static inline bool equal (const finally_tree_node *, - const finally_tree_node *); -}; - -inline hashval_t -finally_tree_hasher::hash (const finally_tree_node *v) -{ - return (intptr_t)v->child.t >> 4; -} - -inline bool -finally_tree_hasher::equal (const finally_tree_node *v, - const finally_tree_node *c) -{ - return v->child.t == c->child.t; -} - -/* Note that this table is *not* marked GTY. It is short-lived. */ -static hash_table *finally_tree; - -static void -record_in_finally_tree (treemple child, gtry *parent) -{ - struct finally_tree_node *n; - finally_tree_node **slot; - - n = XNEW (struct finally_tree_node); - n->child = child; - n->parent = parent; - - slot = finally_tree->find_slot (n, INSERT); - gcc_assert (!*slot); - *slot = n; -} - -static void -collect_finally_tree (gimple *stmt, gtry *region); - -/* Go through the gimple sequence. Works with collect_finally_tree to - record all GIMPLE_LABEL and GIMPLE_TRY statements. */ - -static void -collect_finally_tree_1 (gimple_seq seq, gtry *region) -{ - gimple_stmt_iterator gsi; - - for (gsi = gsi_start (seq); !gsi_end_p (gsi); gsi_next (&gsi)) - collect_finally_tree (gsi_stmt (gsi), region); -} - -static void -collect_finally_tree (gimple *stmt, gtry *region) -{ - treemple temp; - - switch (gimple_code (stmt)) - { - case GIMPLE_LABEL: - temp.t = gimple_label_label (as_a (stmt)); - record_in_finally_tree (temp, region); - break; - - case GIMPLE_TRY: - if (gimple_try_kind (stmt) == GIMPLE_TRY_FINALLY) - { - temp.g = stmt; - record_in_finally_tree (temp, region); - collect_finally_tree_1 (gimple_try_eval (stmt), - as_a (stmt)); - collect_finally_tree_1 (gimple_try_cleanup (stmt), region); - } - else if (gimple_try_kind (stmt) == GIMPLE_TRY_CATCH) - { - collect_finally_tree_1 (gimple_try_eval (stmt), region); - collect_finally_tree_1 (gimple_try_cleanup (stmt), region); - } - break; - - case GIMPLE_CATCH: - collect_finally_tree_1 (gimple_catch_handler ( - as_a (stmt)), - region); - break; - - case GIMPLE_EH_FILTER: - collect_finally_tree_1 (gimple_eh_filter_failure (stmt), region); - break; - - case GIMPLE_EH_ELSE: - { - geh_else *eh_else_stmt = as_a (stmt); - collect_finally_tree_1 (gimple_eh_else_n_body (eh_else_stmt), region); - collect_finally_tree_1 (gimple_eh_else_e_body (eh_else_stmt), region); - } - break; - - default: - /* A type, a decl, or some kind of statement that we're not - interested in. Don't walk them. */ - break; - } -} - - -/* Use the finally tree to determine if a jump from START to TARGET - would leave the try_finally node that START lives in. */ - -static bool -outside_finally_tree (treemple start, gimple *target) -{ - struct finally_tree_node n, *p; - - do - { - n.child = start; - p = finally_tree->find (&n); - if (!p) - return true; - start.g = p->parent; - } - while (start.g != target); - - return false; -} - -/* Second pass of EH node decomposition. Actually transform the GIMPLE_TRY - nodes into a set of gotos, magic labels, and eh regions. - The eh region creation is straight-forward, but frobbing all the gotos - and such into shape isn't. */ - -/* The sequence into which we record all EH stuff. This will be - placed at the end of the function when we're all done. */ -static gimple_seq eh_seq; - -/* Record whether an EH region contains something that can throw, - indexed by EH region number. */ -static bitmap eh_region_may_contain_throw_map; - -/* The GOTO_QUEUE is an array of GIMPLE_GOTO and GIMPLE_RETURN - statements that are seen to escape this GIMPLE_TRY_FINALLY node. - The idea is to record a gimple statement for everything except for - the conditionals, which get their labels recorded. Since labels are - of type 'tree', we need this node to store both gimple and tree - objects. REPL_STMT is the sequence used to replace the goto/return - statement. CONT_STMT is used to store the statement that allows - the return/goto to jump to the original destination. */ - -struct goto_queue_node -{ - treemple stmt; - location_t location; - gimple_seq repl_stmt; - gimple *cont_stmt; - int index; - /* This is used when index >= 0 to indicate that stmt is a label (as - opposed to a goto stmt). */ - int is_label; -}; - -/* State of the world while lowering. */ - -struct leh_state -{ - /* What's "current" while constructing the eh region tree. These - correspond to variables of the same name in cfun->eh, which we - don't have easy access to. */ - eh_region cur_region; - - /* What's "current" for the purposes of __builtin_eh_pointer. For - a CATCH, this is the associated TRY. For an EH_FILTER, this is - the associated ALLOWED_EXCEPTIONS, etc. */ - eh_region ehp_region; - - /* Processing of TRY_FINALLY requires a bit more state. This is - split out into a separate structure so that we don't have to - copy so much when processing other nodes. */ - struct leh_tf_state *tf; - - /* Outer non-clean up region. */ - eh_region outer_non_cleanup; -}; - -struct leh_tf_state -{ - /* Pointer to the GIMPLE_TRY_FINALLY node under discussion. The - try_finally_expr is the original GIMPLE_TRY_FINALLY. We need to retain - this so that outside_finally_tree can reliably reference the tree used - in the collect_finally_tree data structures. */ - gtry *try_finally_expr; - gtry *top_p; - - /* While lowering a top_p usually it is expanded into multiple statements, - thus we need the following field to store them. */ - gimple_seq top_p_seq; - - /* The state outside this try_finally node. */ - struct leh_state *outer; - - /* The exception region created for it. */ - eh_region region; - - /* The goto queue. */ - struct goto_queue_node *goto_queue; - size_t goto_queue_size; - size_t goto_queue_active; - - /* Pointer map to help in searching goto_queue when it is large. */ - hash_map *goto_queue_map; - - /* The set of unique labels seen as entries in the goto queue. */ - vec dest_array; - - /* A label to be added at the end of the completed transformed - sequence. It will be set if may_fallthru was true *at one time*, - though subsequent transformations may have cleared that flag. */ - tree fallthru_label; - - /* True if it is possible to fall out the bottom of the try block. - Cleared if the fallthru is converted to a goto. */ - bool may_fallthru; - - /* True if any entry in goto_queue is a GIMPLE_RETURN. */ - bool may_return; - - /* True if the finally block can receive an exception edge. - Cleared if the exception case is handled by code duplication. */ - bool may_throw; -}; - -static gimple_seq lower_eh_must_not_throw (struct leh_state *, gtry *); - -/* Search for STMT in the goto queue. Return the replacement, - or null if the statement isn't in the queue. */ - -#define LARGE_GOTO_QUEUE 20 - -static void lower_eh_constructs_1 (struct leh_state *state, gimple_seq *seq); - -static gimple_seq -find_goto_replacement (struct leh_tf_state *tf, treemple stmt) -{ - unsigned int i; - - if (tf->goto_queue_active < LARGE_GOTO_QUEUE) - { - for (i = 0; i < tf->goto_queue_active; i++) - if ( tf->goto_queue[i].stmt.g == stmt.g) - return tf->goto_queue[i].repl_stmt; - return NULL; - } - - /* If we have a large number of entries in the goto_queue, create a - pointer map and use that for searching. */ - - if (!tf->goto_queue_map) - { - tf->goto_queue_map = new hash_map; - for (i = 0; i < tf->goto_queue_active; i++) - { - bool existed = tf->goto_queue_map->put (tf->goto_queue[i].stmt.g, - &tf->goto_queue[i]); - gcc_assert (!existed); - } - } - - goto_queue_node **slot = tf->goto_queue_map->get (stmt.g); - if (slot != NULL) - return ((*slot)->repl_stmt); - - return NULL; -} - -/* A subroutine of replace_goto_queue_1. Handles the sub-clauses of a - lowered GIMPLE_COND. If, by chance, the replacement is a simple goto, - then we can just splat it in, otherwise we add the new stmts immediately - after the GIMPLE_COND and redirect. */ - -static void -replace_goto_queue_cond_clause (tree *tp, struct leh_tf_state *tf, - gimple_stmt_iterator *gsi) -{ - tree label; - gimple_seq new_seq; - treemple temp; - location_t loc = gimple_location (gsi_stmt (*gsi)); - - temp.tp = tp; - new_seq = find_goto_replacement (tf, temp); - if (!new_seq) - return; - - if (gimple_seq_singleton_p (new_seq) - && gimple_code (gimple_seq_first_stmt (new_seq)) == GIMPLE_GOTO) - { - *tp = gimple_goto_dest (gimple_seq_first_stmt (new_seq)); - return; - } - - label = create_artificial_label (loc); - /* Set the new label for the GIMPLE_COND */ - *tp = label; - - gsi_insert_after (gsi, gimple_build_label (label), GSI_CONTINUE_LINKING); - gsi_insert_seq_after (gsi, gimple_seq_copy (new_seq), GSI_CONTINUE_LINKING); -} - -/* The real work of replace_goto_queue. Returns with TSI updated to - point to the next statement. */ - -static void replace_goto_queue_stmt_list (gimple_seq *, struct leh_tf_state *); - -static void -replace_goto_queue_1 (gimple *stmt, struct leh_tf_state *tf, - gimple_stmt_iterator *gsi) -{ - gimple_seq seq; - treemple temp; - temp.g = NULL; - - switch (gimple_code (stmt)) - { - case GIMPLE_GOTO: - case GIMPLE_RETURN: - temp.g = stmt; - seq = find_goto_replacement (tf, temp); - if (seq) - { - gimple_stmt_iterator i; - seq = gimple_seq_copy (seq); - for (i = gsi_start (seq); !gsi_end_p (i); gsi_next (&i)) - gimple_set_location (gsi_stmt (i), gimple_location (stmt)); - gsi_insert_seq_before (gsi, seq, GSI_SAME_STMT); - gsi_remove (gsi, false); - return; - } - break; - - case GIMPLE_COND: - replace_goto_queue_cond_clause (gimple_op_ptr (stmt, 2), tf, gsi); - replace_goto_queue_cond_clause (gimple_op_ptr (stmt, 3), tf, gsi); - break; - - case GIMPLE_TRY: - replace_goto_queue_stmt_list (gimple_try_eval_ptr (stmt), tf); - replace_goto_queue_stmt_list (gimple_try_cleanup_ptr (stmt), tf); - break; - case GIMPLE_CATCH: - replace_goto_queue_stmt_list (gimple_catch_handler_ptr ( - as_a (stmt)), - tf); - break; - case GIMPLE_EH_FILTER: - replace_goto_queue_stmt_list (gimple_eh_filter_failure_ptr (stmt), tf); - break; - case GIMPLE_EH_ELSE: - { - geh_else *eh_else_stmt = as_a (stmt); - replace_goto_queue_stmt_list (gimple_eh_else_n_body_ptr (eh_else_stmt), - tf); - replace_goto_queue_stmt_list (gimple_eh_else_e_body_ptr (eh_else_stmt), - tf); - } - break; - - default: - /* These won't have gotos in them. */ - break; - } - - gsi_next (gsi); -} - -/* A subroutine of replace_goto_queue. Handles GIMPLE_SEQ. */ - -static void -replace_goto_queue_stmt_list (gimple_seq *seq, struct leh_tf_state *tf) -{ - gimple_stmt_iterator gsi = gsi_start (*seq); - - while (!gsi_end_p (gsi)) - replace_goto_queue_1 (gsi_stmt (gsi), tf, &gsi); -} - -/* Replace all goto queue members. */ - -static void -replace_goto_queue (struct leh_tf_state *tf) -{ - if (tf->goto_queue_active == 0) - return; - replace_goto_queue_stmt_list (&tf->top_p_seq, tf); - replace_goto_queue_stmt_list (&eh_seq, tf); -} - -/* Add a new record to the goto queue contained in TF. NEW_STMT is the - data to be added, IS_LABEL indicates whether NEW_STMT is a label or - a gimple return. */ - -static void -record_in_goto_queue (struct leh_tf_state *tf, - treemple new_stmt, - int index, - bool is_label, - location_t location) -{ - size_t active, size; - struct goto_queue_node *q; - - gcc_assert (!tf->goto_queue_map); - - active = tf->goto_queue_active; - size = tf->goto_queue_size; - if (active >= size) - { - size = (size ? size * 2 : 32); - tf->goto_queue_size = size; - tf->goto_queue - = XRESIZEVEC (struct goto_queue_node, tf->goto_queue, size); - } - - q = &tf->goto_queue[active]; - tf->goto_queue_active = active + 1; - - memset (q, 0, sizeof (*q)); - q->stmt = new_stmt; - q->index = index; - q->location = location; - q->is_label = is_label; -} - -/* Record the LABEL label in the goto queue contained in TF. - TF is not null. */ - -static void -record_in_goto_queue_label (struct leh_tf_state *tf, treemple stmt, tree label, - location_t location) -{ - int index; - treemple temp, new_stmt; - - if (!label) - return; - - /* Computed and non-local gotos do not get processed. Given - their nature we can neither tell whether we've escaped the - finally block nor redirect them if we knew. */ - if (TREE_CODE (label) != LABEL_DECL) - return; - - /* No need to record gotos that don't leave the try block. */ - temp.t = label; - if (!outside_finally_tree (temp, tf->try_finally_expr)) - return; - - if (! tf->dest_array.exists ()) - { - tf->dest_array.create (10); - tf->dest_array.quick_push (label); - index = 0; - } - else - { - int n = tf->dest_array.length (); - for (index = 0; index < n; ++index) - if (tf->dest_array[index] == label) - break; - if (index == n) - tf->dest_array.safe_push (label); - } - - /* In the case of a GOTO we want to record the destination label, - since with a GIMPLE_COND we have an easy access to the then/else - labels. */ - new_stmt = stmt; - record_in_goto_queue (tf, new_stmt, index, true, location); -} - -/* For any GIMPLE_GOTO or GIMPLE_RETURN, decide whether it leaves a try_finally - node, and if so record that fact in the goto queue associated with that - try_finally node. */ - -static void -maybe_record_in_goto_queue (struct leh_state *state, gimple *stmt) -{ - struct leh_tf_state *tf = state->tf; - treemple new_stmt; - - if (!tf) - return; - - switch (gimple_code (stmt)) - { - case GIMPLE_COND: - { - gcond *cond_stmt = as_a (stmt); - new_stmt.tp = gimple_op_ptr (cond_stmt, 2); - record_in_goto_queue_label (tf, new_stmt, - gimple_cond_true_label (cond_stmt), - EXPR_LOCATION (*new_stmt.tp)); - new_stmt.tp = gimple_op_ptr (cond_stmt, 3); - record_in_goto_queue_label (tf, new_stmt, - gimple_cond_false_label (cond_stmt), - EXPR_LOCATION (*new_stmt.tp)); - } - break; - case GIMPLE_GOTO: - new_stmt.g = stmt; - record_in_goto_queue_label (tf, new_stmt, gimple_goto_dest (stmt), - gimple_location (stmt)); - break; - - case GIMPLE_RETURN: - tf->may_return = true; - new_stmt.g = stmt; - record_in_goto_queue (tf, new_stmt, -1, false, gimple_location (stmt)); - break; - - default: - gcc_unreachable (); - } -} - - -#if CHECKING_P -/* We do not process GIMPLE_SWITCHes for now. As long as the original source - was in fact structured, and we've not yet done jump threading, then none - of the labels will leave outer GIMPLE_TRY_FINALLY nodes. Verify this. */ - -static void -verify_norecord_switch_expr (struct leh_state *state, - gswitch *switch_expr) -{ - struct leh_tf_state *tf = state->tf; - size_t i, n; - - if (!tf) - return; - - n = gimple_switch_num_labels (switch_expr); - - for (i = 0; i < n; ++i) - { - treemple temp; - tree lab = CASE_LABEL (gimple_switch_label (switch_expr, i)); - temp.t = lab; - gcc_assert (!outside_finally_tree (temp, tf->try_finally_expr)); - } -} -#else -#define verify_norecord_switch_expr(state, switch_expr) -#endif - -/* Redirect a RETURN_EXPR pointed to by Q to FINLAB. If MOD is - non-null, insert it before the new branch. */ - -static void -do_return_redirection (struct goto_queue_node *q, tree finlab, gimple_seq mod) -{ - gimple *x; - - /* In the case of a return, the queue node must be a gimple statement. */ - gcc_assert (!q->is_label); - - /* Note that the return value may have already been computed, e.g., - - int x; - int foo (void) - { - x = 0; - try { - return x; - } finally { - x++; - } - } - - should return 0, not 1. We don't have to do anything to make - this happens because the return value has been placed in the - RESULT_DECL already. */ - - q->cont_stmt = q->stmt.g; - - if (mod) - gimple_seq_add_seq (&q->repl_stmt, mod); - - x = gimple_build_goto (finlab); - gimple_set_location (x, q->location); - gimple_seq_add_stmt (&q->repl_stmt, x); -} - -/* Similar, but easier, for GIMPLE_GOTO. */ - -static void -do_goto_redirection (struct goto_queue_node *q, tree finlab, gimple_seq mod, - struct leh_tf_state *tf) -{ - ggoto *x; - - gcc_assert (q->is_label); - - q->cont_stmt = gimple_build_goto (tf->dest_array[q->index]); - - if (mod) - gimple_seq_add_seq (&q->repl_stmt, mod); - - x = gimple_build_goto (finlab); - gimple_set_location (x, q->location); - gimple_seq_add_stmt (&q->repl_stmt, x); -} - -/* Emit a standard landing pad sequence into SEQ for REGION. */ - -static void -emit_post_landing_pad (gimple_seq *seq, eh_region region) -{ - eh_landing_pad lp = region->landing_pads; - glabel *x; - - if (lp == NULL) - lp = gen_eh_landing_pad (region); - - lp->post_landing_pad = create_artificial_label (UNKNOWN_LOCATION); - EH_LANDING_PAD_NR (lp->post_landing_pad) = lp->index; - - x = gimple_build_label (lp->post_landing_pad); - gimple_seq_add_stmt (seq, x); -} - -/* Emit a RESX statement into SEQ for REGION. */ - -static void -emit_resx (gimple_seq *seq, eh_region region) -{ - gresx *x = gimple_build_resx (region->index); - gimple_seq_add_stmt (seq, x); - if (region->outer) - record_stmt_eh_region (region->outer, x); -} - -/* Note that the current EH region may contain a throw, or a - call to a function which itself may contain a throw. */ - -static void -note_eh_region_may_contain_throw (eh_region region) -{ - while (bitmap_set_bit (eh_region_may_contain_throw_map, region->index)) - { - if (region->type == ERT_MUST_NOT_THROW) - break; - region = region->outer; - if (region == NULL) - break; - } -} - -/* Check if REGION has been marked as containing a throw. If REGION is - NULL, this predicate is false. */ - -static inline bool -eh_region_may_contain_throw (eh_region r) -{ - return r && bitmap_bit_p (eh_region_may_contain_throw_map, r->index); -} - -/* We want to transform - try { body; } catch { stuff; } - to - normal_sequence: - body; - over: - eh_sequence: - landing_pad: - stuff; - goto over; - - TP is a GIMPLE_TRY node. REGION is the region whose post_landing_pad - should be placed before the second operand, or NULL. OVER is - an existing label that should be put at the exit, or NULL. */ - -static gimple_seq -frob_into_branch_around (gtry *tp, eh_region region, tree over) -{ - gimple *x; - gimple_seq cleanup, result; - location_t loc = gimple_location (tp); - - cleanup = gimple_try_cleanup (tp); - result = gimple_try_eval (tp); - - if (region) - emit_post_landing_pad (&eh_seq, region); - - if (gimple_seq_may_fallthru (cleanup)) - { - if (!over) - over = create_artificial_label (loc); - x = gimple_build_goto (over); - gimple_set_location (x, loc); - gimple_seq_add_stmt (&cleanup, x); - } - gimple_seq_add_seq (&eh_seq, cleanup); - - if (over) - { - x = gimple_build_label (over); - gimple_seq_add_stmt (&result, x); - } - return result; -} - -/* A subroutine of lower_try_finally. Duplicate the tree rooted at T. - Make sure to record all new labels found. */ - -static gimple_seq -lower_try_finally_dup_block (gimple_seq seq, struct leh_state *outer_state, - location_t loc) -{ - gtry *region = NULL; - gimple_seq new_seq; - gimple_stmt_iterator gsi; - - new_seq = copy_gimple_seq_and_replace_locals (seq); - - for (gsi = gsi_start (new_seq); !gsi_end_p (gsi); gsi_next (&gsi)) - { - gimple *stmt = gsi_stmt (gsi); - if (LOCATION_LOCUS (gimple_location (stmt)) == UNKNOWN_LOCATION) - { - tree block = gimple_block (stmt); - gimple_set_location (stmt, loc); - gimple_set_block (stmt, block); - } - } - - if (outer_state->tf) - region = outer_state->tf->try_finally_expr; - collect_finally_tree_1 (new_seq, region); - - return new_seq; -} - -/* A subroutine of lower_try_finally. Create a fallthru label for - the given try_finally state. The only tricky bit here is that - we have to make sure to record the label in our outer context. */ - -static tree -lower_try_finally_fallthru_label (struct leh_tf_state *tf) -{ - tree label = tf->fallthru_label; - treemple temp; - - if (!label) - { - label = create_artificial_label (gimple_location (tf->try_finally_expr)); - tf->fallthru_label = label; - if (tf->outer->tf) - { - temp.t = label; - record_in_finally_tree (temp, tf->outer->tf->try_finally_expr); - } - } - return label; -} - -/* A subroutine of lower_try_finally. If FINALLY consits of a - GIMPLE_EH_ELSE node, return it. */ - -static inline geh_else * -get_eh_else (gimple_seq finally) -{ - gimple *x = gimple_seq_first_stmt (finally); - if (gimple_code (x) == GIMPLE_EH_ELSE) - { - gcc_assert (gimple_seq_singleton_p (finally)); - return as_a (x); - } - return NULL; -} - -/* A subroutine of lower_try_finally. If the eh_protect_cleanup_actions - langhook returns non-null, then the language requires that the exception - path out of a try_finally be treated specially. To wit: the code within - the finally block may not itself throw an exception. We have two choices - here. First we can duplicate the finally block and wrap it in a - must_not_throw region. Second, we can generate code like - - try { - finally_block; - } catch { - if (fintmp == eh_edge) - protect_cleanup_actions; - } - - where "fintmp" is the temporary used in the switch statement generation - alternative considered below. For the nonce, we always choose the first - option. - - THIS_STATE may be null if this is a try-cleanup, not a try-finally. */ - -static void -honor_protect_cleanup_actions (struct leh_state *outer_state, - struct leh_state *this_state, - struct leh_tf_state *tf) -{ - gimple_seq finally = gimple_try_cleanup (tf->top_p); - - /* EH_ELSE doesn't come from user code; only compiler generated stuff. - It does need to be handled here, so as to separate the (different) - EH path from the normal path. But we should not attempt to wrap - it with a must-not-throw node (which indeed gets in the way). */ - if (geh_else *eh_else = get_eh_else (finally)) - { - gimple_try_set_cleanup (tf->top_p, gimple_eh_else_n_body (eh_else)); - finally = gimple_eh_else_e_body (eh_else); - - /* Let the ELSE see the exception that's being processed, but - since the cleanup is outside the try block, process it with - outer_state, otherwise it may be used as a cleanup for - itself, and Bad Things (TM) ensue. */ - eh_region save_ehp = outer_state->ehp_region; - outer_state->ehp_region = this_state->cur_region; - lower_eh_constructs_1 (outer_state, &finally); - outer_state->ehp_region = save_ehp; - } - else - { - /* First check for nothing to do. */ - if (lang_hooks.eh_protect_cleanup_actions == NULL) - return; - tree actions = lang_hooks.eh_protect_cleanup_actions (); - if (actions == NULL) - return; - - if (this_state) - finally = lower_try_finally_dup_block (finally, outer_state, - gimple_location (tf->try_finally_expr)); - - /* If this cleanup consists of a TRY_CATCH_EXPR with TRY_CATCH_IS_CLEANUP - set, the handler of the TRY_CATCH_EXPR is another cleanup which ought - to be in an enclosing scope, but needs to be implemented at this level - to avoid a nesting violation (see wrap_temporary_cleanups in - cp/decl.c). Since it's logically at an outer level, we should call - terminate before we get to it, so strip it away before adding the - MUST_NOT_THROW filter. */ - gimple_stmt_iterator gsi = gsi_start (finally); - gimple *x = gsi_stmt (gsi); - if (gimple_code (x) == GIMPLE_TRY - && gimple_try_kind (x) == GIMPLE_TRY_CATCH - && gimple_try_catch_is_cleanup (x)) - { - gsi_insert_seq_before (&gsi, gimple_try_eval (x), GSI_SAME_STMT); - gsi_remove (&gsi, false); - } - - /* Wrap the block with protect_cleanup_actions as the action. */ - geh_mnt *eh_mnt = gimple_build_eh_must_not_throw (actions); - gtry *try_stmt = gimple_build_try (finally, - gimple_seq_alloc_with_stmt (eh_mnt), - GIMPLE_TRY_CATCH); - finally = lower_eh_must_not_throw (outer_state, try_stmt); - } - - /* Drop all of this into the exception sequence. */ - emit_post_landing_pad (&eh_seq, tf->region); - gimple_seq_add_seq (&eh_seq, finally); - if (gimple_seq_may_fallthru (finally)) - emit_resx (&eh_seq, tf->region); - - /* Having now been handled, EH isn't to be considered with - the rest of the outgoing edges. */ - tf->may_throw = false; -} - -/* A subroutine of lower_try_finally. We have determined that there is - no fallthru edge out of the finally block. This means that there is - no outgoing edge corresponding to any incoming edge. Restructure the - try_finally node for this special case. */ - -static void -lower_try_finally_nofallthru (struct leh_state *state, - struct leh_tf_state *tf) -{ - tree lab; - gimple *x; - geh_else *eh_else; - gimple_seq finally; - struct goto_queue_node *q, *qe; - - lab = create_artificial_label (gimple_location (tf->try_finally_expr)); - - /* We expect that tf->top_p is a GIMPLE_TRY. */ - finally = gimple_try_cleanup (tf->top_p); - tf->top_p_seq = gimple_try_eval (tf->top_p); - - x = gimple_build_label (lab); - gimple_seq_add_stmt (&tf->top_p_seq, x); - - q = tf->goto_queue; - qe = q + tf->goto_queue_active; - for (; q < qe; ++q) - if (q->index < 0) - do_return_redirection (q, lab, NULL); - else - do_goto_redirection (q, lab, NULL, tf); - - replace_goto_queue (tf); - - /* Emit the finally block into the stream. Lower EH_ELSE at this time. */ - eh_else = get_eh_else (finally); - if (eh_else) - { - finally = gimple_eh_else_n_body (eh_else); - lower_eh_constructs_1 (state, &finally); - gimple_seq_add_seq (&tf->top_p_seq, finally); - - if (tf->may_throw) - { - finally = gimple_eh_else_e_body (eh_else); - lower_eh_constructs_1 (state, &finally); - - emit_post_landing_pad (&eh_seq, tf->region); - gimple_seq_add_seq (&eh_seq, finally); - } - } - else - { - lower_eh_constructs_1 (state, &finally); - gimple_seq_add_seq (&tf->top_p_seq, finally); - - if (tf->may_throw) - { - emit_post_landing_pad (&eh_seq, tf->region); - - x = gimple_build_goto (lab); - gimple_set_location (x, gimple_location (tf->try_finally_expr)); - gimple_seq_add_stmt (&eh_seq, x); - } - } -} - -/* A subroutine of lower_try_finally. We have determined that there is - exactly one destination of the finally block. Restructure the - try_finally node for this special case. */ - -static void -lower_try_finally_onedest (struct leh_state *state, struct leh_tf_state *tf) -{ - struct goto_queue_node *q, *qe; - geh_else *eh_else; - glabel *label_stmt; - gimple *x; - gimple_seq finally; - gimple_stmt_iterator gsi; - tree finally_label; - location_t loc = gimple_location (tf->try_finally_expr); - - finally = gimple_try_cleanup (tf->top_p); - tf->top_p_seq = gimple_try_eval (tf->top_p); - - /* Since there's only one destination, and the destination edge can only - either be EH or non-EH, that implies that all of our incoming edges - are of the same type. Therefore we can lower EH_ELSE immediately. */ - eh_else = get_eh_else (finally); - if (eh_else) - { - if (tf->may_throw) - finally = gimple_eh_else_e_body (eh_else); - else - finally = gimple_eh_else_n_body (eh_else); - } - - lower_eh_constructs_1 (state, &finally); - - for (gsi = gsi_start (finally); !gsi_end_p (gsi); gsi_next (&gsi)) - { - gimple *stmt = gsi_stmt (gsi); - if (LOCATION_LOCUS (gimple_location (stmt)) == UNKNOWN_LOCATION) - { - tree block = gimple_block (stmt); - gimple_set_location (stmt, gimple_location (tf->try_finally_expr)); - gimple_set_block (stmt, block); - } - } - - if (tf->may_throw) - { - /* Only reachable via the exception edge. Add the given label to - the head of the FINALLY block. Append a RESX at the end. */ - emit_post_landing_pad (&eh_seq, tf->region); - gimple_seq_add_seq (&eh_seq, finally); - emit_resx (&eh_seq, tf->region); - return; - } - - if (tf->may_fallthru) - { - /* Only reachable via the fallthru edge. Do nothing but let - the two blocks run together; we'll fall out the bottom. */ - gimple_seq_add_seq (&tf->top_p_seq, finally); - return; - } - - finally_label = create_artificial_label (loc); - label_stmt = gimple_build_label (finally_label); - gimple_seq_add_stmt (&tf->top_p_seq, label_stmt); - - gimple_seq_add_seq (&tf->top_p_seq, finally); - - q = tf->goto_queue; - qe = q + tf->goto_queue_active; - - if (tf->may_return) - { - /* Reachable by return expressions only. Redirect them. */ - for (; q < qe; ++q) - do_return_redirection (q, finally_label, NULL); - replace_goto_queue (tf); - } - else - { - /* Reachable by goto expressions only. Redirect them. */ - for (; q < qe; ++q) - do_goto_redirection (q, finally_label, NULL, tf); - replace_goto_queue (tf); - - if (tf->dest_array[0] == tf->fallthru_label) - { - /* Reachable by goto to fallthru label only. Redirect it - to the new label (already created, sadly), and do not - emit the final branch out, or the fallthru label. */ - tf->fallthru_label = NULL; - return; - } - } - - /* Place the original return/goto to the original destination - immediately after the finally block. */ - x = tf->goto_queue[0].cont_stmt; - gimple_seq_add_stmt (&tf->top_p_seq, x); - maybe_record_in_goto_queue (state, x); -} - -/* A subroutine of lower_try_finally. There are multiple edges incoming - and outgoing from the finally block. Implement this by duplicating the - finally block for every destination. */ - -static void -lower_try_finally_copy (struct leh_state *state, struct leh_tf_state *tf) -{ - gimple_seq finally; - gimple_seq new_stmt; - gimple_seq seq; - gimple *x; - geh_else *eh_else; - tree tmp; - location_t tf_loc = gimple_location (tf->try_finally_expr); - - finally = gimple_try_cleanup (tf->top_p); - - /* Notice EH_ELSE, and simplify some of the remaining code - by considering FINALLY to be the normal return path only. */ - eh_else = get_eh_else (finally); - if (eh_else) - finally = gimple_eh_else_n_body (eh_else); - - tf->top_p_seq = gimple_try_eval (tf->top_p); - new_stmt = NULL; - - if (tf->may_fallthru) - { - seq = lower_try_finally_dup_block (finally, state, tf_loc); - lower_eh_constructs_1 (state, &seq); - gimple_seq_add_seq (&new_stmt, seq); - - tmp = lower_try_finally_fallthru_label (tf); - x = gimple_build_goto (tmp); - gimple_set_location (x, tf_loc); - gimple_seq_add_stmt (&new_stmt, x); - } - - if (tf->may_throw) - { - /* We don't need to copy the EH path of EH_ELSE, - since it is only emitted once. */ - if (eh_else) - seq = gimple_eh_else_e_body (eh_else); - else - seq = lower_try_finally_dup_block (finally, state, tf_loc); - lower_eh_constructs_1 (state, &seq); - - emit_post_landing_pad (&eh_seq, tf->region); - gimple_seq_add_seq (&eh_seq, seq); - emit_resx (&eh_seq, tf->region); - } - - if (tf->goto_queue) - { - struct goto_queue_node *q, *qe; - int return_index, index; - struct labels_s - { - struct goto_queue_node *q; - tree label; - } *labels; - - return_index = tf->dest_array.length (); - labels = XCNEWVEC (struct labels_s, return_index + 1); - - q = tf->goto_queue; - qe = q + tf->goto_queue_active; - for (; q < qe; q++) - { - index = q->index < 0 ? return_index : q->index; - - if (!labels[index].q) - labels[index].q = q; - } - - for (index = 0; index < return_index + 1; index++) - { - tree lab; - - q = labels[index].q; - if (! q) - continue; - - lab = labels[index].label - = create_artificial_label (tf_loc); - - if (index == return_index) - do_return_redirection (q, lab, NULL); - else - do_goto_redirection (q, lab, NULL, tf); - - x = gimple_build_label (lab); - gimple_seq_add_stmt (&new_stmt, x); - - seq = lower_try_finally_dup_block (finally, state, q->location); - lower_eh_constructs_1 (state, &seq); - gimple_seq_add_seq (&new_stmt, seq); - - gimple_seq_add_stmt (&new_stmt, q->cont_stmt); - maybe_record_in_goto_queue (state, q->cont_stmt); - } - - for (q = tf->goto_queue; q < qe; q++) - { - tree lab; - - index = q->index < 0 ? return_index : q->index; - - if (labels[index].q == q) - continue; - - lab = labels[index].label; - - if (index == return_index) - do_return_redirection (q, lab, NULL); - else - do_goto_redirection (q, lab, NULL, tf); - } - - replace_goto_queue (tf); - free (labels); - } - - /* Need to link new stmts after running replace_goto_queue due - to not wanting to process the same goto stmts twice. */ - gimple_seq_add_seq (&tf->top_p_seq, new_stmt); -} - -/* A subroutine of lower_try_finally. There are multiple edges incoming - and outgoing from the finally block. Implement this by instrumenting - each incoming edge and creating a switch statement at the end of the - finally block that branches to the appropriate destination. */ - -static void -lower_try_finally_switch (struct leh_state *state, struct leh_tf_state *tf) -{ - struct goto_queue_node *q, *qe; - tree finally_tmp, finally_label; - int return_index, eh_index, fallthru_index; - int nlabels, ndests, j, last_case_index; - tree last_case; - auto_vec case_label_vec; - gimple_seq switch_body = NULL; - gimple *x; - geh_else *eh_else; - tree tmp; - gimple *switch_stmt; - gimple_seq finally; - hash_map *cont_map = NULL; - /* The location of the TRY_FINALLY stmt. */ - location_t tf_loc = gimple_location (tf->try_finally_expr); - /* The location of the finally block. */ - location_t finally_loc; - - finally = gimple_try_cleanup (tf->top_p); - eh_else = get_eh_else (finally); - - /* Mash the TRY block to the head of the chain. */ - tf->top_p_seq = gimple_try_eval (tf->top_p); - - /* The location of the finally is either the last stmt in the finally - block or the location of the TRY_FINALLY itself. */ - x = gimple_seq_last_stmt (finally); - finally_loc = x ? gimple_location (x) : tf_loc; - - /* Prepare for switch statement generation. */ - nlabels = tf->dest_array.length (); - return_index = nlabels; - eh_index = return_index + tf->may_return; - fallthru_index = eh_index + (tf->may_throw && !eh_else); - ndests = fallthru_index + tf->may_fallthru; - - finally_tmp = create_tmp_var (integer_type_node, "finally_tmp"); - finally_label = create_artificial_label (finally_loc); - - /* We use vec::quick_push on case_label_vec throughout this function, - since we know the size in advance and allocate precisely as muce - space as needed. */ - case_label_vec.create (ndests); - last_case = NULL; - last_case_index = 0; - - /* Begin inserting code for getting to the finally block. Things - are done in this order to correspond to the sequence the code is - laid out. */ - - if (tf->may_fallthru) - { - x = gimple_build_assign (finally_tmp, - build_int_cst (integer_type_node, - fallthru_index)); - gimple_set_location (x, finally_loc); - gimple_seq_add_stmt (&tf->top_p_seq, x); - - tmp = build_int_cst (integer_type_node, fallthru_index); - last_case = build_case_label (tmp, NULL, - create_artificial_label (finally_loc)); - case_label_vec.quick_push (last_case); - last_case_index++; - - x = gimple_build_label (CASE_LABEL (last_case)); - gimple_seq_add_stmt (&switch_body, x); - - tmp = lower_try_finally_fallthru_label (tf); - x = gimple_build_goto (tmp); - gimple_set_location (x, finally_loc); - gimple_seq_add_stmt (&switch_body, x); - } - - /* For EH_ELSE, emit the exception path (plus resx) now, then - subsequently we only need consider the normal path. */ - if (eh_else) - { - if (tf->may_throw) - { - finally = gimple_eh_else_e_body (eh_else); - lower_eh_constructs_1 (state, &finally); - - emit_post_landing_pad (&eh_seq, tf->region); - gimple_seq_add_seq (&eh_seq, finally); - emit_resx (&eh_seq, tf->region); - } - - finally = gimple_eh_else_n_body (eh_else); - } - else if (tf->may_throw) - { - emit_post_landing_pad (&eh_seq, tf->region); - - x = gimple_build_assign (finally_tmp, - build_int_cst (integer_type_node, eh_index)); - gimple_seq_add_stmt (&eh_seq, x); - - x = gimple_build_goto (finally_label); - gimple_set_location (x, tf_loc); - gimple_seq_add_stmt (&eh_seq, x); - - tmp = build_int_cst (integer_type_node, eh_index); - last_case = build_case_label (tmp, NULL, - create_artificial_label (tf_loc)); - case_label_vec.quick_push (last_case); - last_case_index++; - - x = gimple_build_label (CASE_LABEL (last_case)); - gimple_seq_add_stmt (&eh_seq, x); - emit_resx (&eh_seq, tf->region); - } - - x = gimple_build_label (finally_label); - gimple_seq_add_stmt (&tf->top_p_seq, x); - - lower_eh_constructs_1 (state, &finally); - gimple_seq_add_seq (&tf->top_p_seq, finally); - - /* Redirect each incoming goto edge. */ - q = tf->goto_queue; - qe = q + tf->goto_queue_active; - j = last_case_index + tf->may_return; - /* Prepare the assignments to finally_tmp that are executed upon the - entrance through a particular edge. */ - for (; q < qe; ++q) - { - gimple_seq mod = NULL; - int switch_id; - unsigned int case_index; - - if (q->index < 0) - { - x = gimple_build_assign (finally_tmp, - build_int_cst (integer_type_node, - return_index)); - gimple_seq_add_stmt (&mod, x); - do_return_redirection (q, finally_label, mod); - switch_id = return_index; - } - else - { - x = gimple_build_assign (finally_tmp, - build_int_cst (integer_type_node, q->index)); - gimple_seq_add_stmt (&mod, x); - do_goto_redirection (q, finally_label, mod, tf); - switch_id = q->index; - } - - case_index = j + q->index; - if (case_label_vec.length () <= case_index || !case_label_vec[case_index]) - { - tree case_lab; - tmp = build_int_cst (integer_type_node, switch_id); - case_lab = build_case_label (tmp, NULL, - create_artificial_label (tf_loc)); - /* We store the cont_stmt in the pointer map, so that we can recover - it in the loop below. */ - if (!cont_map) - cont_map = new hash_map; - cont_map->put (case_lab, q->cont_stmt); - case_label_vec.quick_push (case_lab); - } - } - for (j = last_case_index; j < last_case_index + nlabels; j++) - { - gimple *cont_stmt; - - last_case = case_label_vec[j]; - - gcc_assert (last_case); - gcc_assert (cont_map); - - cont_stmt = *cont_map->get (last_case); - - x = gimple_build_label (CASE_LABEL (last_case)); - gimple_seq_add_stmt (&switch_body, x); - gimple_seq_add_stmt (&switch_body, cont_stmt); - maybe_record_in_goto_queue (state, cont_stmt); - } - if (cont_map) - delete cont_map; - - replace_goto_queue (tf); - - /* Make sure that the last case is the default label, as one is required. - Then sort the labels, which is also required in GIMPLE. */ - CASE_LOW (last_case) = NULL; - tree tem = case_label_vec.pop (); - gcc_assert (tem == last_case); - sort_case_labels (case_label_vec); - - /* Build the switch statement, setting last_case to be the default - label. */ - switch_stmt = gimple_build_switch (finally_tmp, last_case, - case_label_vec); - gimple_set_location (switch_stmt, finally_loc); - - /* Need to link SWITCH_STMT after running replace_goto_queue - due to not wanting to process the same goto stmts twice. */ - gimple_seq_add_stmt (&tf->top_p_seq, switch_stmt); - gimple_seq_add_seq (&tf->top_p_seq, switch_body); -} - -/* Decide whether or not we are going to duplicate the finally block. - There are several considerations. - - Second, we'd like to prevent egregious code growth. One way to - do this is to estimate the size of the finally block, multiply - that by the number of copies we'd need to make, and compare against - the estimate of the size of the switch machinery we'd have to add. */ - -static bool -decide_copy_try_finally (int ndests, bool may_throw, gimple_seq finally) -{ - int f_estimate, sw_estimate; - geh_else *eh_else; - - /* If there's an EH_ELSE involved, the exception path is separate - and really doesn't come into play for this computation. */ - eh_else = get_eh_else (finally); - if (eh_else) - { - ndests -= may_throw; - finally = gimple_eh_else_n_body (eh_else); - } - - if (!optimize) - { - gimple_stmt_iterator gsi; - - if (ndests == 1) - return true; - - for (gsi = gsi_start (finally); !gsi_end_p (gsi); gsi_next (&gsi)) - { - /* Duplicate __builtin_stack_restore in the hope of eliminating it - on the EH paths and, consequently, useless cleanups. */ - gimple *stmt = gsi_stmt (gsi); - if (!is_gimple_debug (stmt) - && !gimple_clobber_p (stmt) - && !gimple_call_builtin_p (stmt, BUILT_IN_STACK_RESTORE)) - return false; - } - return true; - } - - /* Finally estimate N times, plus N gotos. */ - f_estimate = estimate_num_insns_seq (finally, &eni_size_weights); - f_estimate = (f_estimate + 1) * ndests; - - /* Switch statement (cost 10), N variable assignments, N gotos. */ - sw_estimate = 10 + 2 * ndests; - - /* Optimize for size clearly wants our best guess. */ - if (optimize_function_for_size_p (cfun)) - return f_estimate < sw_estimate; - - /* ??? These numbers are completely made up so far. */ - if (optimize > 1) - return f_estimate < 100 || f_estimate < sw_estimate * 2; - else - return f_estimate < 40 || f_estimate * 2 < sw_estimate * 3; -} - -/* REG is current region of a LEH state. - is the enclosing region for a possible cleanup region, or the region - itself. Returns TRUE if such a region would be unreachable. - - Cleanup regions within a must-not-throw region aren't actually reachable - even if there are throwing stmts within them, because the personality - routine will call terminate before unwinding. */ - -static bool -cleanup_is_dead_in (leh_state *state) -{ - if (flag_checking) - { - eh_region reg = state->cur_region; - while (reg && reg->type == ERT_CLEANUP) - reg = reg->outer; - - gcc_assert (reg == state->outer_non_cleanup); - } - - eh_region reg = state->outer_non_cleanup; - return (reg && reg->type == ERT_MUST_NOT_THROW); -} - -/* A subroutine of lower_eh_constructs_1. Lower a GIMPLE_TRY_FINALLY nodes - to a sequence of labels and blocks, plus the exception region trees - that record all the magic. This is complicated by the need to - arrange for the FINALLY block to be executed on all exits. */ - -static gimple_seq -lower_try_finally (struct leh_state *state, gtry *tp) -{ - struct leh_tf_state this_tf; - struct leh_state this_state; - int ndests; - gimple_seq old_eh_seq; - - /* Process the try block. */ - - memset (&this_tf, 0, sizeof (this_tf)); - this_tf.try_finally_expr = tp; - this_tf.top_p = tp; - this_tf.outer = state; - if (using_eh_for_cleanups_p () && !cleanup_is_dead_in (state)) - { - this_tf.region = gen_eh_region_cleanup (state->cur_region); - this_state.cur_region = this_tf.region; - } - else - { - this_tf.region = NULL; - this_state.cur_region = state->cur_region; - } - - this_state.outer_non_cleanup = state->outer_non_cleanup; - this_state.ehp_region = state->ehp_region; - this_state.tf = &this_tf; - - old_eh_seq = eh_seq; - eh_seq = NULL; - - lower_eh_constructs_1 (&this_state, gimple_try_eval_ptr (tp)); - - /* Determine if the try block is escaped through the bottom. */ - this_tf.may_fallthru = gimple_seq_may_fallthru (gimple_try_eval (tp)); - - /* Determine if any exceptions are possible within the try block. */ - if (this_tf.region) - this_tf.may_throw = eh_region_may_contain_throw (this_tf.region); - if (this_tf.may_throw) - honor_protect_cleanup_actions (state, &this_state, &this_tf); - - /* Determine how many edges (still) reach the finally block. Or rather, - how many destinations are reached by the finally block. Use this to - determine how we process the finally block itself. */ - - ndests = this_tf.dest_array.length (); - ndests += this_tf.may_fallthru; - ndests += this_tf.may_return; - ndests += this_tf.may_throw; - - /* If the FINALLY block is not reachable, dike it out. */ - if (ndests == 0) - { - gimple_seq_add_seq (&this_tf.top_p_seq, gimple_try_eval (tp)); - gimple_try_set_cleanup (tp, NULL); - } - /* If the finally block doesn't fall through, then any destination - we might try to impose there isn't reached either. There may be - some minor amount of cleanup and redirection still needed. */ - else if (!gimple_seq_may_fallthru (gimple_try_cleanup (tp))) - lower_try_finally_nofallthru (state, &this_tf); - - /* We can easily special-case redirection to a single destination. */ - else if (ndests == 1) - lower_try_finally_onedest (state, &this_tf); - else if (decide_copy_try_finally (ndests, this_tf.may_throw, - gimple_try_cleanup (tp))) - lower_try_finally_copy (state, &this_tf); - else - lower_try_finally_switch (state, &this_tf); - - /* If someone requested we add a label at the end of the transformed - block, do so. */ - if (this_tf.fallthru_label) - { - /* This must be reached only if ndests == 0. */ - gimple *x = gimple_build_label (this_tf.fallthru_label); - gimple_seq_add_stmt (&this_tf.top_p_seq, x); - } - - this_tf.dest_array.release (); - free (this_tf.goto_queue); - if (this_tf.goto_queue_map) - delete this_tf.goto_queue_map; - - /* If there was an old (aka outer) eh_seq, append the current eh_seq. - If there was no old eh_seq, then the append is trivially already done. */ - if (old_eh_seq) - { - if (eh_seq == NULL) - eh_seq = old_eh_seq; - else - { - gimple_seq new_eh_seq = eh_seq; - eh_seq = old_eh_seq; - gimple_seq_add_seq (&eh_seq, new_eh_seq); - } - } - - return this_tf.top_p_seq; -} - -/* A subroutine of lower_eh_constructs_1. Lower a GIMPLE_TRY_CATCH with a - list of GIMPLE_CATCH to a sequence of labels and blocks, plus the - exception region trees that records all the magic. */ - -static gimple_seq -lower_catch (struct leh_state *state, gtry *tp) -{ - eh_region try_region = NULL; - struct leh_state this_state = *state; - gimple_stmt_iterator gsi; - tree out_label; - gimple_seq new_seq, cleanup; - gimple *x; - geh_dispatch *eh_dispatch; - location_t try_catch_loc = gimple_location (tp); - location_t catch_loc = UNKNOWN_LOCATION; - - if (flag_exceptions) - { - try_region = gen_eh_region_try (state->cur_region); - this_state.cur_region = try_region; - this_state.outer_non_cleanup = this_state.cur_region; - } - - lower_eh_constructs_1 (&this_state, gimple_try_eval_ptr (tp)); - - if (!eh_region_may_contain_throw (try_region)) - return gimple_try_eval (tp); - - new_seq = NULL; - eh_dispatch = gimple_build_eh_dispatch (try_region->index); - gimple_seq_add_stmt (&new_seq, eh_dispatch); - emit_resx (&new_seq, try_region); - - this_state.cur_region = state->cur_region; - this_state.outer_non_cleanup = state->outer_non_cleanup; - this_state.ehp_region = try_region; - - /* Add eh_seq from lowering EH in the cleanup sequence after the cleanup - itself, so that e.g. for coverage purposes the nested cleanups don't - appear before the cleanup body. See PR64634 for details. */ - gimple_seq old_eh_seq = eh_seq; - eh_seq = NULL; - - out_label = NULL; - cleanup = gimple_try_cleanup (tp); - for (gsi = gsi_start (cleanup); - !gsi_end_p (gsi); - gsi_next (&gsi)) - { - eh_catch c; - gcatch *catch_stmt; - gimple_seq handler; - - catch_stmt = as_a (gsi_stmt (gsi)); - if (catch_loc == UNKNOWN_LOCATION) - catch_loc = gimple_location (catch_stmt); - c = gen_eh_region_catch (try_region, gimple_catch_types (catch_stmt)); - - handler = gimple_catch_handler (catch_stmt); - lower_eh_constructs_1 (&this_state, &handler); - - c->label = create_artificial_label (UNKNOWN_LOCATION); - x = gimple_build_label (c->label); - gimple_seq_add_stmt (&new_seq, x); - - gimple_seq_add_seq (&new_seq, handler); - - if (gimple_seq_may_fallthru (new_seq)) - { - if (!out_label) - out_label = create_artificial_label (try_catch_loc); - - x = gimple_build_goto (out_label); - gimple_seq_add_stmt (&new_seq, x); - } - if (!c->type_list) - break; - } - - /* Try to set a location on the dispatching construct to avoid inheriting - the location of the previous statement. */ - gimple_set_location (eh_dispatch, catch_loc); - - gimple_try_set_cleanup (tp, new_seq); - - gimple_seq new_eh_seq = eh_seq; - eh_seq = old_eh_seq; - gimple_seq ret_seq = frob_into_branch_around (tp, try_region, out_label); - gimple_seq_add_seq (&eh_seq, new_eh_seq); - return ret_seq; -} - -/* A subroutine of lower_eh_constructs_1. Lower a GIMPLE_TRY with a - GIMPLE_EH_FILTER to a sequence of labels and blocks, plus the exception - region trees that record all the magic. */ - -static gimple_seq -lower_eh_filter (struct leh_state *state, gtry *tp) -{ - struct leh_state this_state = *state; - eh_region this_region = NULL; - gimple *inner, *x; - gimple_seq new_seq; - - inner = gimple_seq_first_stmt (gimple_try_cleanup (tp)); - - if (flag_exceptions) - { - this_region = gen_eh_region_allowed (state->cur_region, - gimple_eh_filter_types (inner)); - this_state.cur_region = this_region; - this_state.outer_non_cleanup = this_state.cur_region; - } - - lower_eh_constructs_1 (&this_state, gimple_try_eval_ptr (tp)); - - if (!eh_region_may_contain_throw (this_region)) - return gimple_try_eval (tp); - - this_state.cur_region = state->cur_region; - this_state.ehp_region = this_region; - - new_seq = NULL; - x = gimple_build_eh_dispatch (this_region->index); - gimple_set_location (x, gimple_location (tp)); - gimple_seq_add_stmt (&new_seq, x); - emit_resx (&new_seq, this_region); - - this_region->u.allowed.label = create_artificial_label (UNKNOWN_LOCATION); - x = gimple_build_label (this_region->u.allowed.label); - gimple_seq_add_stmt (&new_seq, x); - - lower_eh_constructs_1 (&this_state, gimple_eh_filter_failure_ptr (inner)); - gimple_seq_add_seq (&new_seq, gimple_eh_filter_failure (inner)); - - gimple_try_set_cleanup (tp, new_seq); - - return frob_into_branch_around (tp, this_region, NULL); -} - -/* A subroutine of lower_eh_constructs_1. Lower a GIMPLE_TRY with - an GIMPLE_EH_MUST_NOT_THROW to a sequence of labels and blocks, - plus the exception region trees that record all the magic. */ - -static gimple_seq -lower_eh_must_not_throw (struct leh_state *state, gtry *tp) -{ - struct leh_state this_state = *state; - - if (flag_exceptions) - { - gimple *inner = gimple_seq_first_stmt (gimple_try_cleanup (tp)); - eh_region this_region; - - this_region = gen_eh_region_must_not_throw (state->cur_region); - this_region->u.must_not_throw.failure_decl - = gimple_eh_must_not_throw_fndecl ( - as_a (inner)); - this_region->u.must_not_throw.failure_loc - = LOCATION_LOCUS (gimple_location (tp)); - - /* In order to get mangling applied to this decl, we must mark it - used now. Otherwise, pass_ipa_free_lang_data won't think it - needs to happen. */ - TREE_USED (this_region->u.must_not_throw.failure_decl) = 1; - - this_state.cur_region = this_region; - this_state.outer_non_cleanup = this_state.cur_region; - } - - lower_eh_constructs_1 (&this_state, gimple_try_eval_ptr (tp)); - - return gimple_try_eval (tp); -} - -/* Implement a cleanup expression. This is similar to try-finally, - except that we only execute the cleanup block for exception edges. */ - -static gimple_seq -lower_cleanup (struct leh_state *state, gtry *tp) -{ - struct leh_state this_state = *state; - eh_region this_region = NULL; - struct leh_tf_state fake_tf; - gimple_seq result; - bool cleanup_dead = cleanup_is_dead_in (state); - - if (flag_exceptions && !cleanup_dead) - { - this_region = gen_eh_region_cleanup (state->cur_region); - this_state.cur_region = this_region; - this_state.outer_non_cleanup = state->outer_non_cleanup; - } - - lower_eh_constructs_1 (&this_state, gimple_try_eval_ptr (tp)); - - if (cleanup_dead || !eh_region_may_contain_throw (this_region)) - return gimple_try_eval (tp); - - /* Build enough of a try-finally state so that we can reuse - honor_protect_cleanup_actions. */ - memset (&fake_tf, 0, sizeof (fake_tf)); - fake_tf.top_p = fake_tf.try_finally_expr = tp; - fake_tf.outer = state; - fake_tf.region = this_region; - fake_tf.may_fallthru = gimple_seq_may_fallthru (gimple_try_eval (tp)); - fake_tf.may_throw = true; - - honor_protect_cleanup_actions (state, NULL, &fake_tf); - - if (fake_tf.may_throw) - { - /* In this case honor_protect_cleanup_actions had nothing to do, - and we should process this normally. */ - lower_eh_constructs_1 (state, gimple_try_cleanup_ptr (tp)); - result = frob_into_branch_around (tp, this_region, - fake_tf.fallthru_label); - } - else - { - /* In this case honor_protect_cleanup_actions did nearly all of - the work. All we have left is to append the fallthru_label. */ - - result = gimple_try_eval (tp); - if (fake_tf.fallthru_label) - { - gimple *x = gimple_build_label (fake_tf.fallthru_label); - gimple_seq_add_stmt (&result, x); - } - } - return result; -} - -/* Main loop for lowering eh constructs. Also moves gsi to the next - statement. */ - -static void -lower_eh_constructs_2 (struct leh_state *state, gimple_stmt_iterator *gsi) -{ - gimple_seq replace; - gimple *x; - gimple *stmt = gsi_stmt (*gsi); - - switch (gimple_code (stmt)) - { - case GIMPLE_CALL: - { - tree fndecl = gimple_call_fndecl (stmt); - tree rhs, lhs; - - if (fndecl && fndecl_built_in_p (fndecl, BUILT_IN_NORMAL)) - switch (DECL_FUNCTION_CODE (fndecl)) - { - case BUILT_IN_EH_POINTER: - /* The front end may have generated a call to - __builtin_eh_pointer (0) within a catch region. Replace - this zero argument with the current catch region number. */ - if (state->ehp_region) - { - tree nr = build_int_cst (integer_type_node, - state->ehp_region->index); - gimple_call_set_arg (stmt, 0, nr); - } - else - { - /* The user has dome something silly. Remove it. */ - rhs = null_pointer_node; - goto do_replace; - } - break; - - case BUILT_IN_EH_FILTER: - /* ??? This should never appear, but since it's a builtin it - is accessible to abuse by users. Just remove it and - replace the use with the arbitrary value zero. */ - rhs = build_int_cst (TREE_TYPE (TREE_TYPE (fndecl)), 0); - do_replace: - lhs = gimple_call_lhs (stmt); - x = gimple_build_assign (lhs, rhs); - gsi_insert_before (gsi, x, GSI_SAME_STMT); - /* FALLTHRU */ - - case BUILT_IN_EH_COPY_VALUES: - /* Likewise this should not appear. Remove it. */ - gsi_remove (gsi, true); - return; - - default: - break; - } - } - /* FALLTHRU */ - - case GIMPLE_ASSIGN: - /* If the stmt can throw, use a new temporary for the assignment - to a LHS. This makes sure the old value of the LHS is - available on the EH edge. Only do so for statements that - potentially fall through (no noreturn calls e.g.), otherwise - this new assignment might create fake fallthru regions. */ - if (stmt_could_throw_p (cfun, stmt) - && gimple_has_lhs (stmt) - && gimple_stmt_may_fallthru (stmt) - && !tree_could_throw_p (gimple_get_lhs (stmt)) - && is_gimple_reg_type (TREE_TYPE (gimple_get_lhs (stmt)))) - { - tree lhs = gimple_get_lhs (stmt); - tree tmp = create_tmp_var (TREE_TYPE (lhs)); - gimple *s = gimple_build_assign (lhs, tmp); - gimple_set_location (s, gimple_location (stmt)); - gimple_set_block (s, gimple_block (stmt)); - gimple_set_lhs (stmt, tmp); - gsi_insert_after (gsi, s, GSI_SAME_STMT); - } - /* Look for things that can throw exceptions, and record them. */ - if (state->cur_region && stmt_could_throw_p (cfun, stmt)) - { - record_stmt_eh_region (state->cur_region, stmt); - note_eh_region_may_contain_throw (state->cur_region); - } - break; - - case GIMPLE_COND: - case GIMPLE_GOTO: - case GIMPLE_RETURN: - maybe_record_in_goto_queue (state, stmt); - break; - - case GIMPLE_SWITCH: - verify_norecord_switch_expr (state, as_a (stmt)); - break; - - case GIMPLE_TRY: - { - gtry *try_stmt = as_a (stmt); - if (gimple_try_kind (try_stmt) == GIMPLE_TRY_FINALLY) - replace = lower_try_finally (state, try_stmt); - else - { - x = gimple_seq_first_stmt (gimple_try_cleanup (try_stmt)); - if (!x) - { - replace = gimple_try_eval (try_stmt); - lower_eh_constructs_1 (state, &replace); - } - else - switch (gimple_code (x)) - { - case GIMPLE_CATCH: - replace = lower_catch (state, try_stmt); - break; - case GIMPLE_EH_FILTER: - replace = lower_eh_filter (state, try_stmt); - break; - case GIMPLE_EH_MUST_NOT_THROW: - replace = lower_eh_must_not_throw (state, try_stmt); - break; - case GIMPLE_EH_ELSE: - /* This code is only valid with GIMPLE_TRY_FINALLY. */ - gcc_unreachable (); - default: - replace = lower_cleanup (state, try_stmt); - break; - } - } - } - - /* Remove the old stmt and insert the transformed sequence - instead. */ - gsi_insert_seq_before (gsi, replace, GSI_SAME_STMT); - gsi_remove (gsi, true); - - /* Return since we don't want gsi_next () */ - return; - - case GIMPLE_EH_ELSE: - /* We should be eliminating this in lower_try_finally et al. */ - gcc_unreachable (); - - default: - /* A type, a decl, or some kind of statement that we're not - interested in. Don't walk them. */ - break; - } - - gsi_next (gsi); -} - -/* A helper to unwrap a gimple_seq and feed stmts to lower_eh_constructs_2. */ - -static void -lower_eh_constructs_1 (struct leh_state *state, gimple_seq *pseq) -{ - gimple_stmt_iterator gsi; - for (gsi = gsi_start (*pseq); !gsi_end_p (gsi);) - lower_eh_constructs_2 (state, &gsi); -} - -namespace { - -const pass_data pass_data_lower_eh = -{ - GIMPLE_PASS, /* type */ - "eh", /* name */ - OPTGROUP_NONE, /* optinfo_flags */ - TV_TREE_EH, /* tv_id */ - PROP_gimple_lcf, /* properties_required */ - PROP_gimple_leh, /* properties_provided */ - 0, /* properties_destroyed */ - 0, /* todo_flags_start */ - 0, /* todo_flags_finish */ -}; - -class pass_lower_eh : public gimple_opt_pass -{ -public: - pass_lower_eh (gcc::context *ctxt) - : gimple_opt_pass (pass_data_lower_eh, ctxt) - {} - - /* opt_pass methods: */ - virtual unsigned int execute (function *); - -}; // class pass_lower_eh - -unsigned int -pass_lower_eh::execute (function *fun) -{ - struct leh_state null_state; - gimple_seq bodyp; - - bodyp = gimple_body (current_function_decl); - if (bodyp == NULL) - return 0; - - finally_tree = new hash_table (31); - eh_region_may_contain_throw_map = BITMAP_ALLOC (NULL); - memset (&null_state, 0, sizeof (null_state)); - - collect_finally_tree_1 (bodyp, NULL); - lower_eh_constructs_1 (&null_state, &bodyp); - gimple_set_body (current_function_decl, bodyp); - - /* We assume there's a return statement, or something, at the end of - the function, and thus ploping the EH sequence afterward won't - change anything. */ - gcc_assert (!gimple_seq_may_fallthru (bodyp)); - gimple_seq_add_seq (&bodyp, eh_seq); - - /* We assume that since BODYP already existed, adding EH_SEQ to it - didn't change its value, and we don't have to re-set the function. */ - gcc_assert (bodyp == gimple_body (current_function_decl)); - - delete finally_tree; - finally_tree = NULL; - BITMAP_FREE (eh_region_may_contain_throw_map); - eh_seq = NULL; - - /* If this function needs a language specific EH personality routine - and the frontend didn't already set one do so now. */ - if (function_needs_eh_personality (fun) == eh_personality_lang - && !DECL_FUNCTION_PERSONALITY (current_function_decl)) - DECL_FUNCTION_PERSONALITY (current_function_decl) - = lang_hooks.eh_personality (); - - return 0; -} - -} // anon namespace - -gimple_opt_pass * -make_pass_lower_eh (gcc::context *ctxt) -{ - return new pass_lower_eh (ctxt); -} - -/* Create the multiple edges from an EH_DISPATCH statement to all of - the possible handlers for its EH region. Return true if there's - no fallthru edge; false if there is. */ - -bool -make_eh_dispatch_edges (geh_dispatch *stmt) -{ - eh_region r; - eh_catch c; - basic_block src, dst; - - r = get_eh_region_from_number (gimple_eh_dispatch_region (stmt)); - src = gimple_bb (stmt); - - switch (r->type) - { - case ERT_TRY: - for (c = r->u.eh_try.first_catch; c ; c = c->next_catch) - { - dst = label_to_block (cfun, c->label); - make_edge (src, dst, 0); - - /* A catch-all handler doesn't have a fallthru. */ - if (c->type_list == NULL) - return false; - } - break; - - case ERT_ALLOWED_EXCEPTIONS: - dst = label_to_block (cfun, r->u.allowed.label); - make_edge (src, dst, 0); - break; - - default: - gcc_unreachable (); - } - - return true; -} - -/* Create the single EH edge from STMT to its nearest landing pad, - if there is such a landing pad within the current function. */ - -void -make_eh_edges (gimple *stmt) -{ - basic_block src, dst; - eh_landing_pad lp; - int lp_nr; - - lp_nr = lookup_stmt_eh_lp (stmt); - if (lp_nr <= 0) - return; - - lp = get_eh_landing_pad_from_number (lp_nr); - gcc_assert (lp != NULL); - - src = gimple_bb (stmt); - dst = label_to_block (cfun, lp->post_landing_pad); - make_edge (src, dst, EDGE_EH); -} - -/* Do the work in redirecting EDGE_IN to NEW_BB within the EH region tree; - do not actually perform the final edge redirection. - - CHANGE_REGION is true when we're being called from cleanup_empty_eh and - we intend to change the destination EH region as well; this means - EH_LANDING_PAD_NR must already be set on the destination block label. - If false, we're being called from generic cfg manipulation code and we - should preserve our place within the region tree. */ - -static void -redirect_eh_edge_1 (edge edge_in, basic_block new_bb, bool change_region) -{ - eh_landing_pad old_lp, new_lp; - basic_block old_bb; - gimple *throw_stmt; - int old_lp_nr, new_lp_nr; - tree old_label, new_label; - edge_iterator ei; - edge e; - - old_bb = edge_in->dest; - old_label = gimple_block_label (old_bb); - old_lp_nr = EH_LANDING_PAD_NR (old_label); - gcc_assert (old_lp_nr > 0); - old_lp = get_eh_landing_pad_from_number (old_lp_nr); - - throw_stmt = last_stmt (edge_in->src); - gcc_checking_assert (lookup_stmt_eh_lp (throw_stmt) == old_lp_nr); - - new_label = gimple_block_label (new_bb); - - /* Look for an existing region that might be using NEW_BB already. */ - new_lp_nr = EH_LANDING_PAD_NR (new_label); - if (new_lp_nr) - { - new_lp = get_eh_landing_pad_from_number (new_lp_nr); - gcc_assert (new_lp); - - /* Unless CHANGE_REGION is true, the new and old landing pad - had better be associated with the same EH region. */ - gcc_assert (change_region || new_lp->region == old_lp->region); - } - else - { - new_lp = NULL; - gcc_assert (!change_region); - } - - /* Notice when we redirect the last EH edge away from OLD_BB. */ - FOR_EACH_EDGE (e, ei, old_bb->preds) - if (e != edge_in && (e->flags & EDGE_EH)) - break; - - if (new_lp) - { - /* NEW_LP already exists. If there are still edges into OLD_LP, - there's nothing to do with the EH tree. If there are no more - edges into OLD_LP, then we want to remove OLD_LP as it is unused. - If CHANGE_REGION is true, then our caller is expecting to remove - the landing pad. */ - if (e == NULL && !change_region) - remove_eh_landing_pad (old_lp); - } - else - { - /* No correct landing pad exists. If there are no more edges - into OLD_LP, then we can simply re-use the existing landing pad. - Otherwise, we have to create a new landing pad. */ - if (e == NULL) - { - EH_LANDING_PAD_NR (old_lp->post_landing_pad) = 0; - new_lp = old_lp; - } - else - new_lp = gen_eh_landing_pad (old_lp->region); - new_lp->post_landing_pad = new_label; - EH_LANDING_PAD_NR (new_label) = new_lp->index; - } - - /* Maybe move the throwing statement to the new region. */ - if (old_lp != new_lp) - { - remove_stmt_from_eh_lp (throw_stmt); - add_stmt_to_eh_lp (throw_stmt, new_lp->index); - } -} - -/* Redirect EH edge E to NEW_BB. */ - -edge -redirect_eh_edge (edge edge_in, basic_block new_bb) -{ - redirect_eh_edge_1 (edge_in, new_bb, false); - return ssa_redirect_edge (edge_in, new_bb); -} - -/* This is a subroutine of gimple_redirect_edge_and_branch. Update the - labels for redirecting a non-fallthru EH_DISPATCH edge E to NEW_BB. - The actual edge update will happen in the caller. */ - -void -redirect_eh_dispatch_edge (geh_dispatch *stmt, edge e, basic_block new_bb) -{ - tree new_lab = gimple_block_label (new_bb); - bool any_changed = false; - basic_block old_bb; - eh_region r; - eh_catch c; - - r = get_eh_region_from_number (gimple_eh_dispatch_region (stmt)); - switch (r->type) - { - case ERT_TRY: - for (c = r->u.eh_try.first_catch; c ; c = c->next_catch) - { - old_bb = label_to_block (cfun, c->label); - if (old_bb == e->dest) - { - c->label = new_lab; - any_changed = true; - } - } - break; - - case ERT_ALLOWED_EXCEPTIONS: - old_bb = label_to_block (cfun, r->u.allowed.label); - gcc_assert (old_bb == e->dest); - r->u.allowed.label = new_lab; - any_changed = true; - break; - - default: - gcc_unreachable (); - } - - gcc_assert (any_changed); -} - -/* Helper function for operation_could_trap_p and stmt_could_throw_p. */ - -bool -operation_could_trap_helper_p (enum tree_code op, - bool fp_operation, - bool honor_trapv, - bool honor_nans, - bool honor_snans, - tree divisor, - bool *handled) -{ - *handled = true; - switch (op) - { - case TRUNC_DIV_EXPR: - case CEIL_DIV_EXPR: - case FLOOR_DIV_EXPR: - case ROUND_DIV_EXPR: - case EXACT_DIV_EXPR: - case CEIL_MOD_EXPR: - case FLOOR_MOD_EXPR: - case ROUND_MOD_EXPR: - case TRUNC_MOD_EXPR: - if (!TREE_CONSTANT (divisor) || integer_zerop (divisor)) - return true; - if (TREE_CODE (divisor) == VECTOR_CST) - { - /* Inspired by initializer_each_zero_or_onep. */ - unsigned HOST_WIDE_INT nelts = vector_cst_encoded_nelts (divisor); - if (VECTOR_CST_STEPPED_P (divisor) - && !TYPE_VECTOR_SUBPARTS (TREE_TYPE (divisor)) - .is_constant (&nelts)) - return true; - for (unsigned int i = 0; i < nelts; ++i) - { - tree elt = vector_cst_elt (divisor, i); - if (integer_zerop (elt)) - return true; - } - } - return false; - - case RDIV_EXPR: - if (fp_operation) - { - if (honor_snans) - return true; - return flag_trapping_math; - } - /* Fixed point operations also use RDIV_EXPR. */ - if (!TREE_CONSTANT (divisor) || fixed_zerop (divisor)) - return true; - return false; - - case LT_EXPR: - case LE_EXPR: - case GT_EXPR: - case GE_EXPR: - case LTGT_EXPR: - /* Some floating point comparisons may trap. */ - return honor_nans; - - case EQ_EXPR: - case NE_EXPR: - case UNORDERED_EXPR: - case ORDERED_EXPR: - case UNLT_EXPR: - case UNLE_EXPR: - case UNGT_EXPR: - case UNGE_EXPR: - case UNEQ_EXPR: - return honor_snans; - - case NEGATE_EXPR: - case ABS_EXPR: - case CONJ_EXPR: - /* These operations don't trap with floating point. */ - if (honor_trapv) - return true; - return false; - - case ABSU_EXPR: - /* ABSU_EXPR never traps. */ - return false; - - case PLUS_EXPR: - case MINUS_EXPR: - case MULT_EXPR: - /* Any floating arithmetic may trap. */ - if (fp_operation && flag_trapping_math) - return true; - if (honor_trapv) - return true; - return false; - - case COMPLEX_EXPR: - case CONSTRUCTOR: - /* Constructing an object cannot trap. */ - return false; - - case COND_EXPR: - case VEC_COND_EXPR: - /* Whether *COND_EXPR can trap depends on whether the - first argument can trap, so signal it as not handled. - Whether lhs is floating or not doesn't matter. */ - *handled = false; - return false; - - default: - /* Any floating arithmetic may trap. */ - if (fp_operation && flag_trapping_math) - return true; - - *handled = false; - return false; - } -} - -/* Return true if operation OP may trap. FP_OPERATION is true if OP is applied - on floating-point values. HONOR_TRAPV is true if OP is applied on integer - type operands that may trap. If OP is a division operator, DIVISOR contains - the value of the divisor. */ - -bool -operation_could_trap_p (enum tree_code op, bool fp_operation, bool honor_trapv, - tree divisor) -{ - bool honor_nans = (fp_operation && flag_trapping_math - && !flag_finite_math_only); - bool honor_snans = fp_operation && flag_signaling_nans != 0; - bool handled; - - /* This function cannot tell whether or not COND_EXPR could trap, - because that depends on its condition op. */ - gcc_assert (op != COND_EXPR); - - if (TREE_CODE_CLASS (op) != tcc_comparison - && TREE_CODE_CLASS (op) != tcc_unary - && TREE_CODE_CLASS (op) != tcc_binary) - return false; - - return operation_could_trap_helper_p (op, fp_operation, honor_trapv, - honor_nans, honor_snans, divisor, - &handled); -} - - -/* Returns true if it is possible to prove that the index of - an array access REF (an ARRAY_REF expression) falls into the - array bounds. */ - -static bool -in_array_bounds_p (tree ref) -{ - tree idx = TREE_OPERAND (ref, 1); - tree min, max; - - if (TREE_CODE (idx) != INTEGER_CST) - return false; - - min = array_ref_low_bound (ref); - max = array_ref_up_bound (ref); - if (!min - || !max - || TREE_CODE (min) != INTEGER_CST - || TREE_CODE (max) != INTEGER_CST) - return false; - - if (tree_int_cst_lt (idx, min) - || tree_int_cst_lt (max, idx)) - return false; - - return true; -} - -/* Returns true if it is possible to prove that the range of - an array access REF (an ARRAY_RANGE_REF expression) falls - into the array bounds. */ - -static bool -range_in_array_bounds_p (tree ref) -{ - tree domain_type = TYPE_DOMAIN (TREE_TYPE (ref)); - tree range_min, range_max, min, max; - - range_min = TYPE_MIN_VALUE (domain_type); - range_max = TYPE_MAX_VALUE (domain_type); - if (!range_min - || !range_max - || TREE_CODE (range_min) != INTEGER_CST - || TREE_CODE (range_max) != INTEGER_CST) - return false; - - min = array_ref_low_bound (ref); - max = array_ref_up_bound (ref); - if (!min - || !max - || TREE_CODE (min) != INTEGER_CST - || TREE_CODE (max) != INTEGER_CST) - return false; - - if (tree_int_cst_lt (range_min, min) - || tree_int_cst_lt (max, range_max)) - return false; - - return true; -} - -/* Return true if EXPR can trap, as in dereferencing an invalid pointer - location or floating point arithmetic. C.f. the rtl version, may_trap_p. - This routine expects only GIMPLE lhs or rhs input. */ - -bool -tree_could_trap_p (tree expr) -{ - enum tree_code code; - bool fp_operation = false; - bool honor_trapv = false; - tree t, base, div = NULL_TREE; - - if (!expr) - return false; - - /* In COND_EXPR and VEC_COND_EXPR only the condition may trap, but - they won't appear as operands in GIMPLE form, so this is just for the - GENERIC uses where it needs to recurse on the operands and so - *COND_EXPR itself doesn't trap. */ - if (TREE_CODE (expr) == COND_EXPR || TREE_CODE (expr) == VEC_COND_EXPR) - return false; - - code = TREE_CODE (expr); - t = TREE_TYPE (expr); - - if (t) - { - if (COMPARISON_CLASS_P (expr)) - fp_operation = FLOAT_TYPE_P (TREE_TYPE (TREE_OPERAND (expr, 0))); - else - fp_operation = FLOAT_TYPE_P (t); - honor_trapv = INTEGRAL_TYPE_P (t) && TYPE_OVERFLOW_TRAPS (t); - } - - if (TREE_CODE_CLASS (code) == tcc_binary) - div = TREE_OPERAND (expr, 1); - if (operation_could_trap_p (code, fp_operation, honor_trapv, div)) - return true; - - restart: - switch (code) - { - case COMPONENT_REF: - case REALPART_EXPR: - case IMAGPART_EXPR: - case BIT_FIELD_REF: - case VIEW_CONVERT_EXPR: - case WITH_SIZE_EXPR: - expr = TREE_OPERAND (expr, 0); - code = TREE_CODE (expr); - goto restart; - - case ARRAY_RANGE_REF: - base = TREE_OPERAND (expr, 0); - if (tree_could_trap_p (base)) - return true; - if (TREE_THIS_NOTRAP (expr)) - return false; - return !range_in_array_bounds_p (expr); - - case ARRAY_REF: - base = TREE_OPERAND (expr, 0); - if (tree_could_trap_p (base)) - return true; - if (TREE_THIS_NOTRAP (expr)) - return false; - return !in_array_bounds_p (expr); - - case TARGET_MEM_REF: - case MEM_REF: - if (TREE_CODE (TREE_OPERAND (expr, 0)) == ADDR_EXPR - && tree_could_trap_p (TREE_OPERAND (TREE_OPERAND (expr, 0), 0))) - return true; - if (TREE_THIS_NOTRAP (expr)) - return false; - /* We cannot prove that the access is in-bounds when we have - variable-index TARGET_MEM_REFs. */ - if (code == TARGET_MEM_REF - && (TMR_INDEX (expr) || TMR_INDEX2 (expr))) - return true; - if (TREE_CODE (TREE_OPERAND (expr, 0)) == ADDR_EXPR) - { - tree base = TREE_OPERAND (TREE_OPERAND (expr, 0), 0); - poly_offset_int off = mem_ref_offset (expr); - if (maybe_lt (off, 0)) - return true; - if (TREE_CODE (base) == STRING_CST) - return maybe_le (TREE_STRING_LENGTH (base), off); - tree size = DECL_SIZE_UNIT (base); - if (size == NULL_TREE - || !poly_int_tree_p (size) - || maybe_le (wi::to_poly_offset (size), off)) - return true; - /* Now we are sure the first byte of the access is inside - the object. */ - return false; - } - return true; - - case INDIRECT_REF: - return !TREE_THIS_NOTRAP (expr); - - case ASM_EXPR: - return TREE_THIS_VOLATILE (expr); - - case CALL_EXPR: - /* Internal function calls do not trap. */ - if (CALL_EXPR_FN (expr) == NULL_TREE) - return false; - t = get_callee_fndecl (expr); - /* Assume that indirect and calls to weak functions may trap. */ - if (!t || !DECL_P (t)) - return true; - if (DECL_WEAK (t)) - return tree_could_trap_p (t); - return false; - - case FUNCTION_DECL: - /* Assume that accesses to weak functions may trap, unless we know - they are certainly defined in current TU or in some other - LTO partition. */ - if (DECL_WEAK (expr) && !DECL_COMDAT (expr) && DECL_EXTERNAL (expr)) - { - cgraph_node *node = cgraph_node::get (expr); - if (node) - node = node->function_symbol (); - return !(node && node->in_other_partition); - } - return false; - - case VAR_DECL: - /* Assume that accesses to weak vars may trap, unless we know - they are certainly defined in current TU or in some other - LTO partition. */ - if (DECL_WEAK (expr) && !DECL_COMDAT (expr) && DECL_EXTERNAL (expr)) - { - varpool_node *node = varpool_node::get (expr); - if (node) - node = node->ultimate_alias_target (); - return !(node && node->in_other_partition); - } - return false; - - default: - return false; - } -} - -/* Return non-NULL if there is an integer operation with trapping overflow - we can rewrite into non-trapping. Called via walk_tree from - rewrite_to_non_trapping_overflow. */ - -static tree -find_trapping_overflow (tree *tp, int *walk_subtrees, void *data) -{ - if (EXPR_P (*tp) - && ANY_INTEGRAL_TYPE_P (TREE_TYPE (*tp)) - && !operation_no_trapping_overflow (TREE_TYPE (*tp), TREE_CODE (*tp))) - return *tp; - if (IS_TYPE_OR_DECL_P (*tp) - || (TREE_CODE (*tp) == SAVE_EXPR && data == NULL)) - *walk_subtrees = 0; - return NULL_TREE; -} - -/* Rewrite selected operations into unsigned arithmetics, so that they - don't trap on overflow. */ - -static tree -replace_trapping_overflow (tree *tp, int *walk_subtrees, void *data) -{ - if (find_trapping_overflow (tp, walk_subtrees, data)) - { - tree type = TREE_TYPE (*tp); - tree utype = unsigned_type_for (type); - *walk_subtrees = 0; - int len = TREE_OPERAND_LENGTH (*tp); - for (int i = 0; i < len; ++i) - walk_tree (&TREE_OPERAND (*tp, i), replace_trapping_overflow, - data, (hash_set *) data); - - if (TREE_CODE (*tp) == ABS_EXPR) - { - TREE_SET_CODE (*tp, ABSU_EXPR); - TREE_TYPE (*tp) = utype; - *tp = fold_convert (type, *tp); - } - else - { - TREE_TYPE (*tp) = utype; - len = TREE_OPERAND_LENGTH (*tp); - for (int i = 0; i < len; ++i) - TREE_OPERAND (*tp, i) - = fold_convert (utype, TREE_OPERAND (*tp, i)); - *tp = fold_convert (type, *tp); - } - } - return NULL_TREE; -} - -/* If any subexpression of EXPR can trap due to -ftrapv, rewrite it - using unsigned arithmetics to avoid traps in it. */ - -tree -rewrite_to_non_trapping_overflow (tree expr) -{ - if (!flag_trapv) - return expr; - hash_set pset; - if (!walk_tree (&expr, find_trapping_overflow, &pset, &pset)) - return expr; - expr = unshare_expr (expr); - pset.empty (); - walk_tree (&expr, replace_trapping_overflow, &pset, &pset); - return expr; -} - -/* Helper for stmt_could_throw_p. Return true if STMT (assumed to be a - an assignment or a conditional) may throw. */ - -static bool -stmt_could_throw_1_p (gassign *stmt) -{ - enum tree_code code = gimple_assign_rhs_code (stmt); - bool honor_nans = false; - bool honor_snans = false; - bool fp_operation = false; - bool honor_trapv = false; - tree t; - size_t i; - bool handled, ret; - - if (TREE_CODE_CLASS (code) == tcc_comparison - || TREE_CODE_CLASS (code) == tcc_unary - || TREE_CODE_CLASS (code) == tcc_binary) - { - if (TREE_CODE_CLASS (code) == tcc_comparison) - t = TREE_TYPE (gimple_assign_rhs1 (stmt)); - else - t = TREE_TYPE (gimple_assign_lhs (stmt)); - fp_operation = FLOAT_TYPE_P (t); - if (fp_operation) - { - honor_nans = flag_trapping_math && !flag_finite_math_only; - honor_snans = flag_signaling_nans != 0; - } - else if (INTEGRAL_TYPE_P (t) && TYPE_OVERFLOW_TRAPS (t)) - honor_trapv = true; - } - - /* First check the LHS. */ - if (tree_could_trap_p (gimple_assign_lhs (stmt))) - return true; - - /* Check if the main expression may trap. */ - ret = operation_could_trap_helper_p (code, fp_operation, honor_trapv, - honor_nans, honor_snans, - gimple_assign_rhs2 (stmt), - &handled); - if (handled) - return ret; - - /* If the expression does not trap, see if any of the individual operands may - trap. */ - for (i = 1; i < gimple_num_ops (stmt); i++) - if (tree_could_trap_p (gimple_op (stmt, i))) - return true; - - return false; -} - - -/* Return true if statement STMT within FUN could throw an exception. */ - -bool -stmt_could_throw_p (function *fun, gimple *stmt) -{ - if (!flag_exceptions) - return false; - - /* The only statements that can throw an exception are assignments, - conditionals, calls, resx, and asms. */ - switch (gimple_code (stmt)) - { - case GIMPLE_RESX: - return true; - - case GIMPLE_CALL: - return !gimple_call_nothrow_p (as_a (stmt)); - - case GIMPLE_COND: - { - if (fun && !fun->can_throw_non_call_exceptions) - return false; - gcond *cond = as_a (stmt); - tree lhs = gimple_cond_lhs (cond); - return operation_could_trap_p (gimple_cond_code (cond), - FLOAT_TYPE_P (TREE_TYPE (lhs)), - false, NULL_TREE); - } - - case GIMPLE_ASSIGN: - if ((fun && !fun->can_throw_non_call_exceptions) - || gimple_clobber_p (stmt)) - return false; - return stmt_could_throw_1_p (as_a (stmt)); - - case GIMPLE_ASM: - if (fun && !fun->can_throw_non_call_exceptions) - return false; - return gimple_asm_volatile_p (as_a (stmt)); - - default: - return false; - } -} - -/* Return true if STMT in function FUN must be assumed necessary because of - non-call exceptions. */ - -bool -stmt_unremovable_because_of_non_call_eh_p (function *fun, gimple *stmt) -{ - return (fun->can_throw_non_call_exceptions - && !fun->can_delete_dead_exceptions - && stmt_could_throw_p (fun, stmt)); -} - -/* Return true if expression T could throw an exception. */ - -bool -tree_could_throw_p (tree t) -{ - if (!flag_exceptions) - return false; - if (TREE_CODE (t) == MODIFY_EXPR) - { - if (cfun->can_throw_non_call_exceptions - && tree_could_trap_p (TREE_OPERAND (t, 0))) - return true; - t = TREE_OPERAND (t, 1); - } - - if (TREE_CODE (t) == WITH_SIZE_EXPR) - t = TREE_OPERAND (t, 0); - if (TREE_CODE (t) == CALL_EXPR) - return (call_expr_flags (t) & ECF_NOTHROW) == 0; - if (cfun->can_throw_non_call_exceptions) - return tree_could_trap_p (t); - return false; -} - -/* Return true if STMT can throw an exception that is not caught within its - function FUN. FUN can be NULL but the function is extra conservative - then. */ - -bool -stmt_can_throw_external (function *fun, gimple *stmt) -{ - int lp_nr; - - if (!stmt_could_throw_p (fun, stmt)) - return false; - if (!fun) - return true; - - lp_nr = lookup_stmt_eh_lp_fn (fun, stmt); - return lp_nr == 0; -} - -/* Return true if STMT can throw an exception that is caught within its - function FUN. */ - -bool -stmt_can_throw_internal (function *fun, gimple *stmt) -{ - int lp_nr; - - gcc_checking_assert (fun); - if (!stmt_could_throw_p (fun, stmt)) - return false; - - lp_nr = lookup_stmt_eh_lp_fn (fun, stmt); - return lp_nr > 0; -} - -/* Given a statement STMT in IFUN, if STMT can no longer throw, then - remove any entry it might have from the EH table. Return true if - any change was made. */ - -bool -maybe_clean_eh_stmt_fn (struct function *ifun, gimple *stmt) -{ - if (stmt_could_throw_p (ifun, stmt)) - return false; - return remove_stmt_from_eh_lp_fn (ifun, stmt); -} - -/* Likewise, but always use the current function. */ - -bool -maybe_clean_eh_stmt (gimple *stmt) -{ - return maybe_clean_eh_stmt_fn (cfun, stmt); -} - -/* Given a statement OLD_STMT and a new statement NEW_STMT that has replaced - OLD_STMT in the function, remove OLD_STMT from the EH table and put NEW_STMT - in the table if it should be in there. Return TRUE if a replacement was - done that my require an EH edge purge. */ - -bool -maybe_clean_or_replace_eh_stmt (gimple *old_stmt, gimple *new_stmt) -{ - int lp_nr = lookup_stmt_eh_lp (old_stmt); - - if (lp_nr != 0) - { - bool new_stmt_could_throw = stmt_could_throw_p (cfun, new_stmt); - - if (new_stmt == old_stmt && new_stmt_could_throw) - return false; - - remove_stmt_from_eh_lp (old_stmt); - if (new_stmt_could_throw) - { - add_stmt_to_eh_lp (new_stmt, lp_nr); - return false; - } - else - return true; - } - - return false; -} - -/* Given a statement OLD_STMT in OLD_FUN and a duplicate statement NEW_STMT - in NEW_FUN, copy the EH table data from OLD_STMT to NEW_STMT. The MAP - operand is the return value of duplicate_eh_regions. */ - -bool -maybe_duplicate_eh_stmt_fn (struct function *new_fun, gimple *new_stmt, - struct function *old_fun, gimple *old_stmt, - hash_map *map, - int default_lp_nr) -{ - int old_lp_nr, new_lp_nr; - - if (!stmt_could_throw_p (new_fun, new_stmt)) - return false; - - old_lp_nr = lookup_stmt_eh_lp_fn (old_fun, old_stmt); - if (old_lp_nr == 0) - { - if (default_lp_nr == 0) - return false; - new_lp_nr = default_lp_nr; - } - else if (old_lp_nr > 0) - { - eh_landing_pad old_lp, new_lp; - - old_lp = (*old_fun->eh->lp_array)[old_lp_nr]; - new_lp = static_cast (*map->get (old_lp)); - new_lp_nr = new_lp->index; - } - else - { - eh_region old_r, new_r; - - old_r = (*old_fun->eh->region_array)[-old_lp_nr]; - new_r = static_cast (*map->get (old_r)); - new_lp_nr = -new_r->index; - } - - add_stmt_to_eh_lp_fn (new_fun, new_stmt, new_lp_nr); - return true; -} - -/* Similar, but both OLD_STMT and NEW_STMT are within the current function, - and thus no remapping is required. */ - -bool -maybe_duplicate_eh_stmt (gimple *new_stmt, gimple *old_stmt) -{ - int lp_nr; - - if (!stmt_could_throw_p (cfun, new_stmt)) - return false; - - lp_nr = lookup_stmt_eh_lp (old_stmt); - if (lp_nr == 0) - return false; - - add_stmt_to_eh_lp (new_stmt, lp_nr); - return true; -} - -/* Returns TRUE if oneh and twoh are exception handlers (gimple_try_cleanup of - GIMPLE_TRY) that are similar enough to be considered the same. Currently - this only handles handlers consisting of a single call, as that's the - important case for C++: a destructor call for a particular object showing - up in multiple handlers. */ - -static bool -same_handler_p (gimple_seq oneh, gimple_seq twoh) -{ - gimple_stmt_iterator gsi; - gimple *ones, *twos; - unsigned int ai; - - gsi = gsi_start (oneh); - if (!gsi_one_before_end_p (gsi)) - return false; - ones = gsi_stmt (gsi); - - gsi = gsi_start (twoh); - if (!gsi_one_before_end_p (gsi)) - return false; - twos = gsi_stmt (gsi); - - if (!is_gimple_call (ones) - || !is_gimple_call (twos) - || gimple_call_lhs (ones) - || gimple_call_lhs (twos) - || gimple_call_chain (ones) - || gimple_call_chain (twos) - || !gimple_call_same_target_p (ones, twos) - || gimple_call_num_args (ones) != gimple_call_num_args (twos)) - return false; - - for (ai = 0; ai < gimple_call_num_args (ones); ++ai) - if (!operand_equal_p (gimple_call_arg (ones, ai), - gimple_call_arg (twos, ai), 0)) - return false; - - return true; -} - -/* Optimize - try { A() } finally { try { ~B() } catch { ~A() } } - try { ... } finally { ~A() } - into - try { A() } catch { ~B() } - try { ~B() ... } finally { ~A() } - - This occurs frequently in C++, where A is a local variable and B is a - temporary used in the initializer for A. */ - -static void -optimize_double_finally (gtry *one, gtry *two) -{ - gimple *oneh; - gimple_stmt_iterator gsi; - gimple_seq cleanup; - - cleanup = gimple_try_cleanup (one); - gsi = gsi_start (cleanup); - if (!gsi_one_before_end_p (gsi)) - return; - - oneh = gsi_stmt (gsi); - if (gimple_code (oneh) != GIMPLE_TRY - || gimple_try_kind (oneh) != GIMPLE_TRY_CATCH) - return; - - if (same_handler_p (gimple_try_cleanup (oneh), gimple_try_cleanup (two))) - { - gimple_seq seq = gimple_try_eval (oneh); - - gimple_try_set_cleanup (one, seq); - gimple_try_set_kind (one, GIMPLE_TRY_CATCH); - seq = copy_gimple_seq_and_replace_locals (seq); - gimple_seq_add_seq (&seq, gimple_try_eval (two)); - gimple_try_set_eval (two, seq); - } -} - -/* Perform EH refactoring optimizations that are simpler to do when code - flow has been lowered but EH structures haven't. */ - -static void -refactor_eh_r (gimple_seq seq) -{ - gimple_stmt_iterator gsi; - gimple *one, *two; - - one = NULL; - two = NULL; - gsi = gsi_start (seq); - while (1) - { - one = two; - if (gsi_end_p (gsi)) - two = NULL; - else - two = gsi_stmt (gsi); - if (one && two) - if (gtry *try_one = dyn_cast (one)) - if (gtry *try_two = dyn_cast (two)) - if (gimple_try_kind (try_one) == GIMPLE_TRY_FINALLY - && gimple_try_kind (try_two) == GIMPLE_TRY_FINALLY) - optimize_double_finally (try_one, try_two); - if (one) - switch (gimple_code (one)) - { - case GIMPLE_TRY: - refactor_eh_r (gimple_try_eval (one)); - refactor_eh_r (gimple_try_cleanup (one)); - break; - case GIMPLE_CATCH: - refactor_eh_r (gimple_catch_handler (as_a (one))); - break; - case GIMPLE_EH_FILTER: - refactor_eh_r (gimple_eh_filter_failure (one)); - break; - case GIMPLE_EH_ELSE: - { - geh_else *eh_else_stmt = as_a (one); - refactor_eh_r (gimple_eh_else_n_body (eh_else_stmt)); - refactor_eh_r (gimple_eh_else_e_body (eh_else_stmt)); - } - break; - default: - break; - } - if (two) - gsi_next (&gsi); - else - break; - } -} - -namespace { - -const pass_data pass_data_refactor_eh = -{ - GIMPLE_PASS, /* type */ - "ehopt", /* name */ - OPTGROUP_NONE, /* optinfo_flags */ - TV_TREE_EH, /* tv_id */ - PROP_gimple_lcf, /* properties_required */ - 0, /* properties_provided */ - 0, /* properties_destroyed */ - 0, /* todo_flags_start */ - 0, /* todo_flags_finish */ -}; - -class pass_refactor_eh : public gimple_opt_pass -{ -public: - pass_refactor_eh (gcc::context *ctxt) - : gimple_opt_pass (pass_data_refactor_eh, ctxt) - {} - - /* opt_pass methods: */ - virtual bool gate (function *) { return flag_exceptions != 0; } - virtual unsigned int execute (function *) - { - refactor_eh_r (gimple_body (current_function_decl)); - return 0; - } - -}; // class pass_refactor_eh - -} // anon namespace - -gimple_opt_pass * -make_pass_refactor_eh (gcc::context *ctxt) -{ - return new pass_refactor_eh (ctxt); -} - -/* At the end of gimple optimization, we can lower RESX. */ - -static bool -lower_resx (basic_block bb, gresx *stmt, - hash_map *mnt_map) -{ - int lp_nr; - eh_region src_r, dst_r; - gimple_stmt_iterator gsi; - gimple *x; - tree fn, src_nr; - bool ret = false; - - lp_nr = lookup_stmt_eh_lp (stmt); - if (lp_nr != 0) - dst_r = get_eh_region_from_lp_number (lp_nr); - else - dst_r = NULL; - - src_r = get_eh_region_from_number (gimple_resx_region (stmt)); - gsi = gsi_last_bb (bb); - - if (src_r == NULL) - { - /* We can wind up with no source region when pass_cleanup_eh shows - that there are no entries into an eh region and deletes it, but - then the block that contains the resx isn't removed. This can - happen without optimization when the switch statement created by - lower_try_finally_switch isn't simplified to remove the eh case. - - Resolve this by expanding the resx node to an abort. */ - - fn = builtin_decl_implicit (BUILT_IN_TRAP); - x = gimple_build_call (fn, 0); - gsi_insert_before (&gsi, x, GSI_SAME_STMT); - - while (EDGE_COUNT (bb->succs) > 0) - remove_edge (EDGE_SUCC (bb, 0)); - } - else if (dst_r) - { - /* When we have a destination region, we resolve this by copying - the excptr and filter values into place, and changing the edge - to immediately after the landing pad. */ - edge e; - - if (lp_nr < 0) - { - basic_block new_bb; - tree lab; - - /* We are resuming into a MUST_NOT_CALL region. Expand a call to - the failure decl into a new block, if needed. */ - gcc_assert (dst_r->type == ERT_MUST_NOT_THROW); - - tree *slot = mnt_map->get (dst_r); - if (slot == NULL) - { - gimple_stmt_iterator gsi2; - - new_bb = create_empty_bb (bb); - new_bb->count = bb->count; - add_bb_to_loop (new_bb, bb->loop_father); - lab = gimple_block_label (new_bb); - gsi2 = gsi_start_bb (new_bb); - - fn = dst_r->u.must_not_throw.failure_decl; - x = gimple_build_call (fn, 0); - gimple_set_location (x, dst_r->u.must_not_throw.failure_loc); - gsi_insert_after (&gsi2, x, GSI_CONTINUE_LINKING); - - mnt_map->put (dst_r, lab); - } - else - { - lab = *slot; - new_bb = label_to_block (cfun, lab); - } - - gcc_assert (EDGE_COUNT (bb->succs) == 0); - e = make_single_succ_edge (bb, new_bb, EDGE_FALLTHRU); - } - else - { - edge_iterator ei; - tree dst_nr = build_int_cst (integer_type_node, dst_r->index); - - fn = builtin_decl_implicit (BUILT_IN_EH_COPY_VALUES); - src_nr = build_int_cst (integer_type_node, src_r->index); - x = gimple_build_call (fn, 2, dst_nr, src_nr); - gsi_insert_before (&gsi, x, GSI_SAME_STMT); - - /* Update the flags for the outgoing edge. */ - e = single_succ_edge (bb); - gcc_assert (e->flags & EDGE_EH); - e->flags = (e->flags & ~EDGE_EH) | EDGE_FALLTHRU; - e->probability = profile_probability::always (); - - /* If there are no more EH users of the landing pad, delete it. */ - FOR_EACH_EDGE (e, ei, e->dest->preds) - if (e->flags & EDGE_EH) - break; - if (e == NULL) - { - eh_landing_pad lp = get_eh_landing_pad_from_number (lp_nr); - remove_eh_landing_pad (lp); - } - } - - ret = true; - } - else - { - tree var; - - /* When we don't have a destination region, this exception escapes - up the call chain. We resolve this by generating a call to the - _Unwind_Resume library function. */ - - /* The ARM EABI redefines _Unwind_Resume as __cxa_end_cleanup - with no arguments for C++. Check for that. */ - if (src_r->use_cxa_end_cleanup) - { - fn = builtin_decl_implicit (BUILT_IN_CXA_END_CLEANUP); - x = gimple_build_call (fn, 0); - gsi_insert_before (&gsi, x, GSI_SAME_STMT); - } - else - { - fn = builtin_decl_implicit (BUILT_IN_EH_POINTER); - src_nr = build_int_cst (integer_type_node, src_r->index); - x = gimple_build_call (fn, 1, src_nr); - var = create_tmp_var (ptr_type_node); - var = make_ssa_name (var, x); - gimple_call_set_lhs (x, var); - gsi_insert_before (&gsi, x, GSI_SAME_STMT); - - /* When exception handling is delegated to a caller function, we - have to guarantee that shadow memory variables living on stack - will be cleaner before control is given to a parent function. */ - if (sanitize_flags_p (SANITIZE_ADDRESS)) - { - tree decl - = builtin_decl_implicit (BUILT_IN_ASAN_HANDLE_NO_RETURN); - gimple *g = gimple_build_call (decl, 0); - gimple_set_location (g, gimple_location (stmt)); - gsi_insert_before (&gsi, g, GSI_SAME_STMT); - } - - fn = builtin_decl_implicit (BUILT_IN_UNWIND_RESUME); - x = gimple_build_call (fn, 1, var); - gsi_insert_before (&gsi, x, GSI_SAME_STMT); - } - - gcc_assert (EDGE_COUNT (bb->succs) == 0); - } - - gsi_remove (&gsi, true); - - return ret; -} - -namespace { - -const pass_data pass_data_lower_resx = -{ - GIMPLE_PASS, /* type */ - "resx", /* name */ - OPTGROUP_NONE, /* optinfo_flags */ - TV_TREE_EH, /* tv_id */ - PROP_gimple_lcf, /* properties_required */ - 0, /* properties_provided */ - 0, /* properties_destroyed */ - 0, /* todo_flags_start */ - 0, /* todo_flags_finish */ -}; - -class pass_lower_resx : public gimple_opt_pass -{ -public: - pass_lower_resx (gcc::context *ctxt) - : gimple_opt_pass (pass_data_lower_resx, ctxt) - {} - - /* opt_pass methods: */ - virtual bool gate (function *) { return flag_exceptions != 0; } - virtual unsigned int execute (function *); - -}; // class pass_lower_resx - -unsigned -pass_lower_resx::execute (function *fun) -{ - basic_block bb; - bool dominance_invalidated = false; - bool any_rewritten = false; - - hash_map mnt_map; - - FOR_EACH_BB_FN (bb, fun) - { - gimple *last = last_stmt (bb); - if (last && is_gimple_resx (last)) - { - dominance_invalidated |= - lower_resx (bb, as_a (last), &mnt_map); - any_rewritten = true; - } - } - - if (dominance_invalidated) - { - free_dominance_info (CDI_DOMINATORS); - free_dominance_info (CDI_POST_DOMINATORS); - } - - return any_rewritten ? TODO_update_ssa_only_virtuals : 0; -} - -} // anon namespace - -gimple_opt_pass * -make_pass_lower_resx (gcc::context *ctxt) -{ - return new pass_lower_resx (ctxt); -} - -/* Try to optimize var = {v} {CLOBBER} stmts followed just by - external throw. */ - -static void -optimize_clobbers (basic_block bb) -{ - gimple_stmt_iterator gsi = gsi_last_bb (bb); - bool any_clobbers = false; - bool seen_stack_restore = false; - edge_iterator ei; - edge e; - - /* Only optimize anything if the bb contains at least one clobber, - ends with resx (checked by caller), optionally contains some - debug stmts or labels, or at most one __builtin_stack_restore - call, and has an incoming EH edge. */ - for (gsi_prev (&gsi); !gsi_end_p (gsi); gsi_prev (&gsi)) - { - gimple *stmt = gsi_stmt (gsi); - if (is_gimple_debug (stmt)) - continue; - if (gimple_clobber_p (stmt)) - { - any_clobbers = true; - continue; - } - if (!seen_stack_restore - && gimple_call_builtin_p (stmt, BUILT_IN_STACK_RESTORE)) - { - seen_stack_restore = true; - continue; - } - if (gimple_code (stmt) == GIMPLE_LABEL) - break; - return; - } - if (!any_clobbers) - return; - FOR_EACH_EDGE (e, ei, bb->preds) - if (e->flags & EDGE_EH) - break; - if (e == NULL) - return; - gsi = gsi_last_bb (bb); - for (gsi_prev (&gsi); !gsi_end_p (gsi); gsi_prev (&gsi)) - { - gimple *stmt = gsi_stmt (gsi); - if (!gimple_clobber_p (stmt)) - continue; - unlink_stmt_vdef (stmt); - gsi_remove (&gsi, true); - release_defs (stmt); - } -} - -/* Try to sink var = {v} {CLOBBER} stmts followed just by - internal throw to successor BB. - SUNK, if not NULL, is an array of sequences indexed by basic-block - index to sink to and to pick up sinking opportunities from. - If FOUND_OPPORTUNITY is not NULL then do not perform the optimization - but set *FOUND_OPPORTUNITY to true. */ - -static int -sink_clobbers (basic_block bb, - gimple_seq *sunk = NULL, bool *found_opportunity = NULL) -{ - edge e; - edge_iterator ei; - gimple_stmt_iterator gsi, dgsi; - basic_block succbb; - bool any_clobbers = false; - unsigned todo = 0; - - /* Only optimize if BB has a single EH successor and - all predecessor edges are EH too. */ - if (!single_succ_p (bb) - || (single_succ_edge (bb)->flags & EDGE_EH) == 0) - return 0; - - FOR_EACH_EDGE (e, ei, bb->preds) - { - if ((e->flags & EDGE_EH) == 0) - return 0; - } - - /* And BB contains only CLOBBER stmts before the final - RESX. */ - gsi = gsi_last_bb (bb); - for (gsi_prev (&gsi); !gsi_end_p (gsi); gsi_prev (&gsi)) - { - gimple *stmt = gsi_stmt (gsi); - if (is_gimple_debug (stmt)) - continue; - if (gimple_code (stmt) == GIMPLE_LABEL) - break; - if (!gimple_clobber_p (stmt)) - return 0; - any_clobbers = true; - } - if (!any_clobbers && (!sunk || gimple_seq_empty_p (sunk[bb->index]))) - return 0; - - /* If this was a dry run, tell it we found clobbers to sink. */ - if (found_opportunity) - { - *found_opportunity = true; - return 0; - } - - edge succe = single_succ_edge (bb); - succbb = succe->dest; - - /* See if there is a virtual PHI node to take an updated virtual - operand from. */ - gphi *vphi = NULL; - for (gphi_iterator gpi = gsi_start_phis (succbb); - !gsi_end_p (gpi); gsi_next (&gpi)) - { - tree res = gimple_phi_result (gpi.phi ()); - if (virtual_operand_p (res)) - { - vphi = gpi.phi (); - break; - } - } - - gimple *first_sunk = NULL; - gimple *last_sunk = NULL; - if (sunk && !(succbb->flags & BB_VISITED)) - dgsi = gsi_start (sunk[succbb->index]); - else - dgsi = gsi_after_labels (succbb); - gsi = gsi_last_bb (bb); - for (gsi_prev (&gsi); !gsi_end_p (gsi); gsi_prev (&gsi)) - { - gimple *stmt = gsi_stmt (gsi); - tree lhs; - if (is_gimple_debug (stmt)) - continue; - if (gimple_code (stmt) == GIMPLE_LABEL) - break; - lhs = gimple_assign_lhs (stmt); - /* Unfortunately we don't have dominance info updated at this - point, so checking if - dominated_by_p (CDI_DOMINATORS, succbb, - gimple_bb (SSA_NAME_DEF_STMT (TREE_OPERAND (lhs, 0))) - would be too costly. Thus, avoid sinking any clobbers that - refer to non-(D) SSA_NAMEs. */ - if (TREE_CODE (lhs) == MEM_REF - && TREE_CODE (TREE_OPERAND (lhs, 0)) == SSA_NAME - && !SSA_NAME_IS_DEFAULT_DEF (TREE_OPERAND (lhs, 0))) - { - unlink_stmt_vdef (stmt); - gsi_remove (&gsi, true); - release_defs (stmt); - continue; - } - - /* As we do not change stmt order when sinking across a - forwarder edge we can keep virtual operands in place. */ - gsi_remove (&gsi, false); - gsi_insert_before (&dgsi, stmt, GSI_NEW_STMT); - if (!first_sunk) - first_sunk = stmt; - last_sunk = stmt; - } - if (sunk && !gimple_seq_empty_p (sunk[bb->index])) - { - if (!first_sunk) - first_sunk = gsi_stmt (gsi_last (sunk[bb->index])); - last_sunk = gsi_stmt (gsi_start (sunk[bb->index])); - gsi_insert_seq_before_without_update (&dgsi, - sunk[bb->index], GSI_NEW_STMT); - sunk[bb->index] = NULL; - } - if (first_sunk) - { - /* Adjust virtual operands if we sunk across a virtual PHI. */ - if (vphi) - { - imm_use_iterator iter; - use_operand_p use_p; - gimple *use_stmt; - tree phi_def = gimple_phi_result (vphi); - FOR_EACH_IMM_USE_STMT (use_stmt, iter, phi_def) - FOR_EACH_IMM_USE_ON_STMT (use_p, iter) - SET_USE (use_p, gimple_vdef (first_sunk)); - if (SSA_NAME_OCCURS_IN_ABNORMAL_PHI (phi_def)) - { - SSA_NAME_OCCURS_IN_ABNORMAL_PHI (gimple_vdef (first_sunk)) = 1; - SSA_NAME_OCCURS_IN_ABNORMAL_PHI (phi_def) = 0; - } - SET_USE (PHI_ARG_DEF_PTR_FROM_EDGE (vphi, succe), - gimple_vuse (last_sunk)); - SET_USE (gimple_vuse_op (last_sunk), phi_def); - } - /* If there isn't a single predecessor but no virtual PHI node - arrange for virtual operands to be renamed. */ - else if (!single_pred_p (succbb) - && TREE_CODE (gimple_vuse (last_sunk)) == SSA_NAME) - { - mark_virtual_operand_for_renaming (gimple_vuse (last_sunk)); - todo |= TODO_update_ssa_only_virtuals; - } - } - - return todo; -} - -/* At the end of inlining, we can lower EH_DISPATCH. Return true when - we have found some duplicate labels and removed some edges. */ - -static bool -lower_eh_dispatch (basic_block src, geh_dispatch *stmt) -{ - gimple_stmt_iterator gsi; - int region_nr; - eh_region r; - tree filter, fn; - gimple *x; - bool redirected = false; - - region_nr = gimple_eh_dispatch_region (stmt); - r = get_eh_region_from_number (region_nr); - - gsi = gsi_last_bb (src); - - switch (r->type) - { - case ERT_TRY: - { - auto_vec labels; - tree default_label = NULL; - eh_catch c; - edge_iterator ei; - edge e; - hash_set seen_values; - - /* Collect the labels for a switch. Zero the post_landing_pad - field becase we'll no longer have anything keeping these labels - in existence and the optimizer will be free to merge these - blocks at will. */ - for (c = r->u.eh_try.first_catch; c ; c = c->next_catch) - { - tree tp_node, flt_node, lab = c->label; - bool have_label = false; - - c->label = NULL; - tp_node = c->type_list; - flt_node = c->filter_list; - - if (tp_node == NULL) - { - default_label = lab; - break; - } - do - { - /* Filter out duplicate labels that arise when this handler - is shadowed by an earlier one. When no labels are - attached to the handler anymore, we remove - the corresponding edge and then we delete unreachable - blocks at the end of this pass. */ - if (! seen_values.contains (TREE_VALUE (flt_node))) - { - tree t = build_case_label (TREE_VALUE (flt_node), - NULL, lab); - labels.safe_push (t); - seen_values.add (TREE_VALUE (flt_node)); - have_label = true; - } - - tp_node = TREE_CHAIN (tp_node); - flt_node = TREE_CHAIN (flt_node); - } - while (tp_node); - if (! have_label) - { - remove_edge (find_edge (src, label_to_block (cfun, lab))); - redirected = true; - } - } - - /* Clean up the edge flags. */ - FOR_EACH_EDGE (e, ei, src->succs) - { - if (e->flags & EDGE_FALLTHRU) - { - /* If there was no catch-all, use the fallthru edge. */ - if (default_label == NULL) - default_label = gimple_block_label (e->dest); - e->flags &= ~EDGE_FALLTHRU; - } - } - gcc_assert (default_label != NULL); - - /* Don't generate a switch if there's only a default case. - This is common in the form of try { A; } catch (...) { B; }. */ - if (!labels.exists ()) - { - e = single_succ_edge (src); - e->flags |= EDGE_FALLTHRU; - } - else - { - fn = builtin_decl_implicit (BUILT_IN_EH_FILTER); - x = gimple_build_call (fn, 1, build_int_cst (integer_type_node, - region_nr)); - filter = create_tmp_var (TREE_TYPE (TREE_TYPE (fn))); - filter = make_ssa_name (filter, x); - gimple_call_set_lhs (x, filter); - gimple_set_location (x, gimple_location (stmt)); - gsi_insert_before (&gsi, x, GSI_SAME_STMT); - - /* Turn the default label into a default case. */ - default_label = build_case_label (NULL, NULL, default_label); - sort_case_labels (labels); - - x = gimple_build_switch (filter, default_label, labels); - gimple_set_location (x, gimple_location (stmt)); - gsi_insert_before (&gsi, x, GSI_SAME_STMT); - } - } - break; - - case ERT_ALLOWED_EXCEPTIONS: - { - edge b_e = BRANCH_EDGE (src); - edge f_e = FALLTHRU_EDGE (src); - - fn = builtin_decl_implicit (BUILT_IN_EH_FILTER); - x = gimple_build_call (fn, 1, build_int_cst (integer_type_node, - region_nr)); - filter = create_tmp_var (TREE_TYPE (TREE_TYPE (fn))); - filter = make_ssa_name (filter, x); - gimple_call_set_lhs (x, filter); - gimple_set_location (x, gimple_location (stmt)); - gsi_insert_before (&gsi, x, GSI_SAME_STMT); - - r->u.allowed.label = NULL; - x = gimple_build_cond (EQ_EXPR, filter, - build_int_cst (TREE_TYPE (filter), - r->u.allowed.filter), - NULL_TREE, NULL_TREE); - gsi_insert_before (&gsi, x, GSI_SAME_STMT); - - b_e->flags = b_e->flags | EDGE_TRUE_VALUE; - f_e->flags = (f_e->flags & ~EDGE_FALLTHRU) | EDGE_FALSE_VALUE; - } - break; - - default: - gcc_unreachable (); - } - - /* Replace the EH_DISPATCH with the SWITCH or COND generated above. */ - gsi_remove (&gsi, true); - return redirected; -} - -namespace { - -const pass_data pass_data_lower_eh_dispatch = -{ - GIMPLE_PASS, /* type */ - "ehdisp", /* name */ - OPTGROUP_NONE, /* optinfo_flags */ - TV_TREE_EH, /* tv_id */ - PROP_gimple_lcf, /* properties_required */ - 0, /* properties_provided */ - 0, /* properties_destroyed */ - 0, /* todo_flags_start */ - 0, /* todo_flags_finish */ -}; - -class pass_lower_eh_dispatch : public gimple_opt_pass -{ -public: - pass_lower_eh_dispatch (gcc::context *ctxt) - : gimple_opt_pass (pass_data_lower_eh_dispatch, ctxt) - {} - - /* opt_pass methods: */ - virtual bool gate (function *fun) { return fun->eh->region_tree != NULL; } - virtual unsigned int execute (function *); - -}; // class pass_lower_eh_dispatch - -unsigned -pass_lower_eh_dispatch::execute (function *fun) -{ - basic_block bb; - int flags = 0; - bool redirected = false; - bool any_resx_to_process = false; - - assign_filter_values (); - - FOR_EACH_BB_FN (bb, fun) - { - gimple *last = last_stmt (bb); - if (last == NULL) - continue; - if (gimple_code (last) == GIMPLE_EH_DISPATCH) - { - redirected |= lower_eh_dispatch (bb, - as_a (last)); - flags |= TODO_update_ssa_only_virtuals; - } - else if (gimple_code (last) == GIMPLE_RESX) - { - if (stmt_can_throw_external (fun, last)) - optimize_clobbers (bb); - else if (!any_resx_to_process) - sink_clobbers (bb, NULL, &any_resx_to_process); - } - bb->flags &= ~BB_VISITED; - } - if (redirected) - { - free_dominance_info (CDI_DOMINATORS); - delete_unreachable_blocks (); - } - - if (any_resx_to_process) - { - /* Make sure to catch all secondary sinking opportunities by processing - blocks in RPO order and after all CFG modifications from lowering - and unreachable block removal. */ - int *rpo = XNEWVEC (int, n_basic_blocks_for_fn (fun)); - int rpo_n = pre_and_rev_post_order_compute_fn (fun, NULL, rpo, false); - gimple_seq *sunk = XCNEWVEC (gimple_seq, last_basic_block_for_fn (fun)); - for (int i = 0; i < rpo_n; ++i) - { - bb = BASIC_BLOCK_FOR_FN (fun, rpo[i]); - gimple *last = last_stmt (bb); - if (last - && gimple_code (last) == GIMPLE_RESX - && !stmt_can_throw_external (fun, last)) - flags |= sink_clobbers (bb, sunk); - /* If there were any clobbers sunk into this BB, insert them now. */ - if (!gimple_seq_empty_p (sunk[bb->index])) - { - gimple_stmt_iterator gsi = gsi_after_labels (bb); - gsi_insert_seq_before (&gsi, sunk[bb->index], GSI_NEW_STMT); - sunk[bb->index] = NULL; - } - bb->flags |= BB_VISITED; - } - free (rpo); - free (sunk); - } - - return flags; -} - -} // anon namespace - -gimple_opt_pass * -make_pass_lower_eh_dispatch (gcc::context *ctxt) -{ - return new pass_lower_eh_dispatch (ctxt); -} - -/* Walk statements, see what regions and, optionally, landing pads - are really referenced. - - Returns in R_REACHABLEP an sbitmap with bits set for reachable regions, - and in LP_REACHABLE an sbitmap with bits set for reachable landing pads. - - Passing NULL for LP_REACHABLE is valid, in this case only reachable - regions are marked. - - The caller is responsible for freeing the returned sbitmaps. */ - -static void -mark_reachable_handlers (sbitmap *r_reachablep, sbitmap *lp_reachablep) -{ - sbitmap r_reachable, lp_reachable; - basic_block bb; - bool mark_landing_pads = (lp_reachablep != NULL); - gcc_checking_assert (r_reachablep != NULL); - - r_reachable = sbitmap_alloc (cfun->eh->region_array->length ()); - bitmap_clear (r_reachable); - *r_reachablep = r_reachable; - - if (mark_landing_pads) - { - lp_reachable = sbitmap_alloc (cfun->eh->lp_array->length ()); - bitmap_clear (lp_reachable); - *lp_reachablep = lp_reachable; - } - else - lp_reachable = NULL; - - FOR_EACH_BB_FN (bb, cfun) - { - gimple_stmt_iterator gsi; - - for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi)) - { - gimple *stmt = gsi_stmt (gsi); - - if (mark_landing_pads) - { - int lp_nr = lookup_stmt_eh_lp (stmt); - - /* Negative LP numbers are MUST_NOT_THROW regions which - are not considered BB enders. */ - if (lp_nr < 0) - bitmap_set_bit (r_reachable, -lp_nr); - - /* Positive LP numbers are real landing pads, and BB enders. */ - else if (lp_nr > 0) - { - gcc_assert (gsi_one_before_end_p (gsi)); - eh_region region = get_eh_region_from_lp_number (lp_nr); - bitmap_set_bit (r_reachable, region->index); - bitmap_set_bit (lp_reachable, lp_nr); - } - } - - /* Avoid removing regions referenced from RESX/EH_DISPATCH. */ - switch (gimple_code (stmt)) - { - case GIMPLE_RESX: - bitmap_set_bit (r_reachable, - gimple_resx_region (as_a (stmt))); - break; - case GIMPLE_EH_DISPATCH: - bitmap_set_bit (r_reachable, - gimple_eh_dispatch_region ( - as_a (stmt))); - break; - case GIMPLE_CALL: - if (gimple_call_builtin_p (stmt, BUILT_IN_EH_COPY_VALUES)) - for (int i = 0; i < 2; ++i) - { - tree rt = gimple_call_arg (stmt, i); - HOST_WIDE_INT ri = tree_to_shwi (rt); - - gcc_assert (ri == (int)ri); - bitmap_set_bit (r_reachable, ri); - } - break; - default: - break; - } - } - } -} - -/* Remove unreachable handlers and unreachable landing pads. */ - -static void -remove_unreachable_handlers (void) -{ - sbitmap r_reachable, lp_reachable; - eh_region region; - eh_landing_pad lp; - unsigned i; - - mark_reachable_handlers (&r_reachable, &lp_reachable); - - if (dump_file) - { - fprintf (dump_file, "Before removal of unreachable regions:\n"); - dump_eh_tree (dump_file, cfun); - fprintf (dump_file, "Reachable regions: "); - dump_bitmap_file (dump_file, r_reachable); - fprintf (dump_file, "Reachable landing pads: "); - dump_bitmap_file (dump_file, lp_reachable); - } - - if (dump_file) - { - FOR_EACH_VEC_SAFE_ELT (cfun->eh->region_array, i, region) - if (region && !bitmap_bit_p (r_reachable, region->index)) - fprintf (dump_file, - "Removing unreachable region %d\n", - region->index); - } - - remove_unreachable_eh_regions (r_reachable); - - FOR_EACH_VEC_SAFE_ELT (cfun->eh->lp_array, i, lp) - if (lp && !bitmap_bit_p (lp_reachable, lp->index)) - { - if (dump_file) - fprintf (dump_file, - "Removing unreachable landing pad %d\n", - lp->index); - remove_eh_landing_pad (lp); - } - - if (dump_file) - { - fprintf (dump_file, "\n\nAfter removal of unreachable regions:\n"); - dump_eh_tree (dump_file, cfun); - fprintf (dump_file, "\n\n"); - } - - sbitmap_free (r_reachable); - sbitmap_free (lp_reachable); - - if (flag_checking) - verify_eh_tree (cfun); -} - -/* Remove unreachable handlers if any landing pads have been removed after - last ehcleanup pass (due to gimple_purge_dead_eh_edges). */ - -void -maybe_remove_unreachable_handlers (void) -{ - eh_landing_pad lp; - unsigned i; - - if (cfun->eh == NULL) - return; - - FOR_EACH_VEC_SAFE_ELT (cfun->eh->lp_array, i, lp) - if (lp - && (lp->post_landing_pad == NULL_TREE - || label_to_block (cfun, lp->post_landing_pad) == NULL)) - { - remove_unreachable_handlers (); - return; - } -} - -/* Remove regions that do not have landing pads. This assumes - that remove_unreachable_handlers has already been run, and - that we've just manipulated the landing pads since then. - - Preserve regions with landing pads and regions that prevent - exceptions from propagating further, even if these regions - are not reachable. */ - -static void -remove_unreachable_handlers_no_lp (void) -{ - eh_region region; - sbitmap r_reachable; - unsigned i; - - mark_reachable_handlers (&r_reachable, /*lp_reachablep=*/NULL); - - FOR_EACH_VEC_SAFE_ELT (cfun->eh->region_array, i, region) - { - if (! region) - continue; - - if (region->landing_pads != NULL - || region->type == ERT_MUST_NOT_THROW) - bitmap_set_bit (r_reachable, region->index); - - if (dump_file - && !bitmap_bit_p (r_reachable, region->index)) - fprintf (dump_file, - "Removing unreachable region %d\n", - region->index); - } - - remove_unreachable_eh_regions (r_reachable); - - sbitmap_free (r_reachable); -} - -/* Undo critical edge splitting on an EH landing pad. Earlier, we - optimisticaly split all sorts of edges, including EH edges. The - optimization passes in between may not have needed them; if not, - we should undo the split. - - Recognize this case by having one EH edge incoming to the BB and - one normal edge outgoing; BB should be empty apart from the - post_landing_pad label. - - Note that this is slightly different from the empty handler case - handled by cleanup_empty_eh, in that the actual handler may yet - have actual code but the landing pad has been separated from the - handler. As such, cleanup_empty_eh relies on this transformation - having been done first. */ - -static bool -unsplit_eh (eh_landing_pad lp) -{ - basic_block bb = label_to_block (cfun, lp->post_landing_pad); - gimple_stmt_iterator gsi; - edge e_in, e_out; - - /* Quickly check the edge counts on BB for singularity. */ - if (!single_pred_p (bb) || !single_succ_p (bb)) - return false; - e_in = single_pred_edge (bb); - e_out = single_succ_edge (bb); - - /* Input edge must be EH and output edge must be normal. */ - if ((e_in->flags & EDGE_EH) == 0 || (e_out->flags & EDGE_EH) != 0) - return false; - - /* The block must be empty except for the labels and debug insns. */ - gsi = gsi_after_labels (bb); - if (!gsi_end_p (gsi) && is_gimple_debug (gsi_stmt (gsi))) - gsi_next_nondebug (&gsi); - if (!gsi_end_p (gsi)) - return false; - - /* The destination block must not already have a landing pad - for a different region. */ - for (gsi = gsi_start_bb (e_out->dest); !gsi_end_p (gsi); gsi_next (&gsi)) - { - glabel *label_stmt = dyn_cast (gsi_stmt (gsi)); - tree lab; - int lp_nr; - - if (!label_stmt) - break; - lab = gimple_label_label (label_stmt); - lp_nr = EH_LANDING_PAD_NR (lab); - if (lp_nr && get_eh_region_from_lp_number (lp_nr) != lp->region) - return false; - } - - /* The new destination block must not already be a destination of - the source block, lest we merge fallthru and eh edges and get - all sorts of confused. */ - if (find_edge (e_in->src, e_out->dest)) - return false; - - /* ??? We can get degenerate phis due to cfg cleanups. I would have - thought this should have been cleaned up by a phicprop pass, but - that doesn't appear to handle virtuals. Propagate by hand. */ - if (!gimple_seq_empty_p (phi_nodes (bb))) - { - for (gphi_iterator gpi = gsi_start_phis (bb); !gsi_end_p (gpi); ) - { - gimple *use_stmt; - gphi *phi = gpi.phi (); - tree lhs = gimple_phi_result (phi); - tree rhs = gimple_phi_arg_def (phi, 0); - use_operand_p use_p; - imm_use_iterator iter; - - FOR_EACH_IMM_USE_STMT (use_stmt, iter, lhs) - { - FOR_EACH_IMM_USE_ON_STMT (use_p, iter) - SET_USE (use_p, rhs); - } - - if (SSA_NAME_OCCURS_IN_ABNORMAL_PHI (lhs)) - SSA_NAME_OCCURS_IN_ABNORMAL_PHI (rhs) = 1; - - remove_phi_node (&gpi, true); - } - } - - if (dump_file && (dump_flags & TDF_DETAILS)) - fprintf (dump_file, "Unsplit EH landing pad %d to block %i.\n", - lp->index, e_out->dest->index); - - /* Redirect the edge. Since redirect_eh_edge_1 expects to be moving - a successor edge, humor it. But do the real CFG change with the - predecessor of E_OUT in order to preserve the ordering of arguments - to the PHI nodes in E_OUT->DEST. */ - redirect_eh_edge_1 (e_in, e_out->dest, false); - redirect_edge_pred (e_out, e_in->src); - e_out->flags = e_in->flags; - e_out->probability = e_in->probability; - remove_edge (e_in); - - return true; -} - -/* Examine each landing pad block and see if it matches unsplit_eh. */ - -static bool -unsplit_all_eh (void) -{ - bool changed = false; - eh_landing_pad lp; - int i; - - for (i = 1; vec_safe_iterate (cfun->eh->lp_array, i, &lp); ++i) - if (lp) - changed |= unsplit_eh (lp); - - return changed; -} - -/* Wrapper around unsplit_all_eh that makes it usable everywhere. */ - -void -unsplit_eh_edges (void) -{ - bool changed; - - /* unsplit_all_eh can die looking up unreachable landing pads. */ - maybe_remove_unreachable_handlers (); - - changed = unsplit_all_eh (); - - /* If EH edges have been unsplit, delete unreachable forwarder blocks. */ - if (changed) - { - free_dominance_info (CDI_DOMINATORS); - free_dominance_info (CDI_POST_DOMINATORS); - delete_unreachable_blocks (); - } -} - -/* A subroutine of cleanup_empty_eh. Redirect all EH edges incoming - to OLD_BB to NEW_BB; return true on success, false on failure. - - OLD_BB_OUT is the edge into NEW_BB from OLD_BB, so if we miss any - PHI variables from OLD_BB we can pick them up from OLD_BB_OUT. - Virtual PHIs may be deleted and marked for renaming. */ - -static bool -cleanup_empty_eh_merge_phis (basic_block new_bb, basic_block old_bb, - edge old_bb_out, bool change_region) -{ - gphi_iterator ngsi, ogsi; - edge_iterator ei; - edge e; - bitmap ophi_handled; - - /* The destination block must not be a regular successor for any - of the preds of the landing pad. Thus, avoid turning - <..> - | \ EH - | <..> - | / - <..> - into - <..> - | | EH - <..> - which CFG verification would choke on. See PR45172 and PR51089. */ - if (!single_pred_p (new_bb)) - FOR_EACH_EDGE (e, ei, old_bb->preds) - if (find_edge (e->src, new_bb)) - return false; - - FOR_EACH_EDGE (e, ei, old_bb->preds) - redirect_edge_var_map_clear (e); - - ophi_handled = BITMAP_ALLOC (NULL); - - /* First, iterate through the PHIs on NEW_BB and set up the edge_var_map - for the edges we're going to move. */ - for (ngsi = gsi_start_phis (new_bb); !gsi_end_p (ngsi); gsi_next (&ngsi)) - { - gphi *ophi, *nphi = ngsi.phi (); - tree nresult, nop; - - nresult = gimple_phi_result (nphi); - nop = gimple_phi_arg_def (nphi, old_bb_out->dest_idx); - - /* Find the corresponding PHI in OLD_BB so we can forward-propagate - the source ssa_name. */ - ophi = NULL; - for (ogsi = gsi_start_phis (old_bb); !gsi_end_p (ogsi); gsi_next (&ogsi)) - { - ophi = ogsi.phi (); - if (gimple_phi_result (ophi) == nop) - break; - ophi = NULL; - } - - /* If we did find the corresponding PHI, copy those inputs. */ - if (ophi) - { - /* If NOP is used somewhere else beyond phis in new_bb, give up. */ - if (!has_single_use (nop)) - { - imm_use_iterator imm_iter; - use_operand_p use_p; - - FOR_EACH_IMM_USE_FAST (use_p, imm_iter, nop) - { - if (!gimple_debug_bind_p (USE_STMT (use_p)) - && (gimple_code (USE_STMT (use_p)) != GIMPLE_PHI - || gimple_bb (USE_STMT (use_p)) != new_bb)) - goto fail; - } - } - bitmap_set_bit (ophi_handled, SSA_NAME_VERSION (nop)); - FOR_EACH_EDGE (e, ei, old_bb->preds) - { - location_t oloc; - tree oop; - - if ((e->flags & EDGE_EH) == 0) - continue; - oop = gimple_phi_arg_def (ophi, e->dest_idx); - oloc = gimple_phi_arg_location (ophi, e->dest_idx); - redirect_edge_var_map_add (e, nresult, oop, oloc); - } - } - /* If we didn't find the PHI, if it's a real variable or a VOP, we know - from the fact that OLD_BB is tree_empty_eh_handler_p that the - variable is unchanged from input to the block and we can simply - re-use the input to NEW_BB from the OLD_BB_OUT edge. */ - else - { - location_t nloc - = gimple_phi_arg_location (nphi, old_bb_out->dest_idx); - FOR_EACH_EDGE (e, ei, old_bb->preds) - redirect_edge_var_map_add (e, nresult, nop, nloc); - } - } - - /* Second, verify that all PHIs from OLD_BB have been handled. If not, - we don't know what values from the other edges into NEW_BB to use. */ - for (ogsi = gsi_start_phis (old_bb); !gsi_end_p (ogsi); gsi_next (&ogsi)) - { - gphi *ophi = ogsi.phi (); - tree oresult = gimple_phi_result (ophi); - if (!bitmap_bit_p (ophi_handled, SSA_NAME_VERSION (oresult))) - goto fail; - } - - /* Finally, move the edges and update the PHIs. */ - for (ei = ei_start (old_bb->preds); (e = ei_safe_edge (ei)); ) - if (e->flags & EDGE_EH) - { - /* ??? CFG manipluation routines do not try to update loop - form on edge redirection. Do so manually here for now. */ - /* If we redirect a loop entry or latch edge that will either create - a multiple entry loop or rotate the loop. If the loops merge - we may have created a loop with multiple latches. - All of this isn't easily fixed thus cancel the affected loop - and mark the other loop as possibly having multiple latches. */ - if (e->dest == e->dest->loop_father->header) - { - mark_loop_for_removal (e->dest->loop_father); - new_bb->loop_father->latch = NULL; - loops_state_set (LOOPS_MAY_HAVE_MULTIPLE_LATCHES); - } - redirect_eh_edge_1 (e, new_bb, change_region); - redirect_edge_succ (e, new_bb); - flush_pending_stmts (e); - } - else - ei_next (&ei); - - BITMAP_FREE (ophi_handled); - return true; - - fail: - FOR_EACH_EDGE (e, ei, old_bb->preds) - redirect_edge_var_map_clear (e); - BITMAP_FREE (ophi_handled); - return false; -} - -/* A subroutine of cleanup_empty_eh. Move a landing pad LP from its - old region to NEW_REGION at BB. */ - -static void -cleanup_empty_eh_move_lp (basic_block bb, edge e_out, - eh_landing_pad lp, eh_region new_region) -{ - gimple_stmt_iterator gsi; - eh_landing_pad *pp; - - for (pp = &lp->region->landing_pads; *pp != lp; pp = &(*pp)->next_lp) - continue; - *pp = lp->next_lp; - - lp->region = new_region; - lp->next_lp = new_region->landing_pads; - new_region->landing_pads = lp; - - /* Delete the RESX that was matched within the empty handler block. */ - gsi = gsi_last_bb (bb); - unlink_stmt_vdef (gsi_stmt (gsi)); - gsi_remove (&gsi, true); - - /* Clean up E_OUT for the fallthru. */ - e_out->flags = (e_out->flags & ~EDGE_EH) | EDGE_FALLTHRU; - e_out->probability = profile_probability::always (); -} - -/* A subroutine of cleanup_empty_eh. Handle more complex cases of - unsplitting than unsplit_eh was prepared to handle, e.g. when - multiple incoming edges and phis are involved. */ - -static bool -cleanup_empty_eh_unsplit (basic_block bb, edge e_out, eh_landing_pad lp) -{ - gimple_stmt_iterator gsi; - tree lab; - - /* We really ought not have totally lost everything following - a landing pad label. Given that BB is empty, there had better - be a successor. */ - gcc_assert (e_out != NULL); - - /* The destination block must not already have a landing pad - for a different region. */ - lab = NULL; - for (gsi = gsi_start_bb (e_out->dest); !gsi_end_p (gsi); gsi_next (&gsi)) - { - glabel *stmt = dyn_cast (gsi_stmt (gsi)); - int lp_nr; - - if (!stmt) - break; - lab = gimple_label_label (stmt); - lp_nr = EH_LANDING_PAD_NR (lab); - if (lp_nr && get_eh_region_from_lp_number (lp_nr) != lp->region) - return false; - } - - /* Attempt to move the PHIs into the successor block. */ - if (cleanup_empty_eh_merge_phis (e_out->dest, bb, e_out, false)) - { - if (dump_file && (dump_flags & TDF_DETAILS)) - fprintf (dump_file, - "Unsplit EH landing pad %d to block %i " - "(via cleanup_empty_eh).\n", - lp->index, e_out->dest->index); - return true; - } - - return false; -} - -/* Return true if edge E_FIRST is part of an empty infinite loop - or leads to such a loop through a series of single successor - empty bbs. */ - -static bool -infinite_empty_loop_p (edge e_first) -{ - bool inf_loop = false; - edge e; - - if (e_first->dest == e_first->src) - return true; - - e_first->src->aux = (void *) 1; - for (e = e_first; single_succ_p (e->dest); e = single_succ_edge (e->dest)) - { - gimple_stmt_iterator gsi; - if (e->dest->aux) - { - inf_loop = true; - break; - } - e->dest->aux = (void *) 1; - gsi = gsi_after_labels (e->dest); - if (!gsi_end_p (gsi) && is_gimple_debug (gsi_stmt (gsi))) - gsi_next_nondebug (&gsi); - if (!gsi_end_p (gsi)) - break; - } - e_first->src->aux = NULL; - for (e = e_first; e->dest->aux; e = single_succ_edge (e->dest)) - e->dest->aux = NULL; - - return inf_loop; -} - -/* Examine the block associated with LP to determine if it's an empty - handler for its EH region. If so, attempt to redirect EH edges to - an outer region. Return true the CFG was updated in any way. This - is similar to jump forwarding, just across EH edges. */ - -static bool -cleanup_empty_eh (eh_landing_pad lp) -{ - basic_block bb = label_to_block (cfun, lp->post_landing_pad); - gimple_stmt_iterator gsi; - gimple *resx; - eh_region new_region; - edge_iterator ei; - edge e, e_out; - bool has_non_eh_pred; - bool ret = false; - int new_lp_nr; - - /* There can be zero or one edges out of BB. This is the quickest test. */ - switch (EDGE_COUNT (bb->succs)) - { - case 0: - e_out = NULL; - break; - case 1: - e_out = single_succ_edge (bb); - break; - default: - return false; - } - - gsi = gsi_last_nondebug_bb (bb); - resx = gsi_stmt (gsi); - if (resx && is_gimple_resx (resx)) - { - if (stmt_can_throw_external (cfun, resx)) - optimize_clobbers (bb); - else if (sink_clobbers (bb)) - ret = true; - } - - gsi = gsi_after_labels (bb); - - /* Make sure to skip debug statements. */ - if (!gsi_end_p (gsi) && is_gimple_debug (gsi_stmt (gsi))) - gsi_next_nondebug (&gsi); - - /* If the block is totally empty, look for more unsplitting cases. */ - if (gsi_end_p (gsi)) - { - /* For the degenerate case of an infinite loop bail out. - If bb has no successors and is totally empty, which can happen e.g. - because of incorrect noreturn attribute, bail out too. */ - if (e_out == NULL - || infinite_empty_loop_p (e_out)) - return ret; - - return ret | cleanup_empty_eh_unsplit (bb, e_out, lp); - } - - /* The block should consist only of a single RESX statement, modulo a - preceding call to __builtin_stack_restore if there is no outgoing - edge, since the call can be eliminated in this case. */ - resx = gsi_stmt (gsi); - if (!e_out && gimple_call_builtin_p (resx, BUILT_IN_STACK_RESTORE)) - { - gsi_next_nondebug (&gsi); - resx = gsi_stmt (gsi); - } - if (!is_gimple_resx (resx)) - return ret; - gcc_assert (gsi_one_nondebug_before_end_p (gsi)); - - /* Determine if there are non-EH edges, or resx edges into the handler. */ - has_non_eh_pred = false; - FOR_EACH_EDGE (e, ei, bb->preds) - if (!(e->flags & EDGE_EH)) - has_non_eh_pred = true; - - /* Find the handler that's outer of the empty handler by looking at - where the RESX instruction was vectored. */ - new_lp_nr = lookup_stmt_eh_lp (resx); - new_region = get_eh_region_from_lp_number (new_lp_nr); - - /* If there's no destination region within the current function, - redirection is trivial via removing the throwing statements from - the EH region, removing the EH edges, and allowing the block - to go unreachable. */ - if (new_region == NULL) - { - gcc_assert (e_out == NULL); - for (ei = ei_start (bb->preds); (e = ei_safe_edge (ei)); ) - if (e->flags & EDGE_EH) - { - gimple *stmt = last_stmt (e->src); - remove_stmt_from_eh_lp (stmt); - remove_edge (e); - } - else - ei_next (&ei); - goto succeed; - } - - /* If the destination region is a MUST_NOT_THROW, allow the runtime - to handle the abort and allow the blocks to go unreachable. */ - if (new_region->type == ERT_MUST_NOT_THROW) - { - for (ei = ei_start (bb->preds); (e = ei_safe_edge (ei)); ) - if (e->flags & EDGE_EH) - { - gimple *stmt = last_stmt (e->src); - remove_stmt_from_eh_lp (stmt); - add_stmt_to_eh_lp (stmt, new_lp_nr); - remove_edge (e); - } - else - ei_next (&ei); - goto succeed; - } - - /* Try to redirect the EH edges and merge the PHIs into the destination - landing pad block. If the merge succeeds, we'll already have redirected - all the EH edges. The handler itself will go unreachable if there were - no normal edges. */ - if (cleanup_empty_eh_merge_phis (e_out->dest, bb, e_out, true)) - goto succeed; - - /* Finally, if all input edges are EH edges, then we can (potentially) - reduce the number of transfers from the runtime by moving the landing - pad from the original region to the new region. This is a win when - we remove the last CLEANUP region along a particular exception - propagation path. Since nothing changes except for the region with - which the landing pad is associated, the PHI nodes do not need to be - adjusted at all. */ - if (!has_non_eh_pred) - { - cleanup_empty_eh_move_lp (bb, e_out, lp, new_region); - if (dump_file && (dump_flags & TDF_DETAILS)) - fprintf (dump_file, "Empty EH handler %i moved to EH region %i.\n", - lp->index, new_region->index); - - /* ??? The CFG didn't change, but we may have rendered the - old EH region unreachable. Trigger a cleanup there. */ - return true; - } - - return ret; - - succeed: - if (dump_file && (dump_flags & TDF_DETAILS)) - fprintf (dump_file, "Empty EH handler %i removed.\n", lp->index); - remove_eh_landing_pad (lp); - return true; -} - -/* Do a post-order traversal of the EH region tree. Examine each - post_landing_pad block and see if we can eliminate it as empty. */ - -static bool -cleanup_all_empty_eh (void) -{ - bool changed = false; - eh_landing_pad lp; - int i; - - /* The post-order traversal may lead to quadraticness in the redirection - of incoming EH edges from inner LPs, so first try to walk the region - tree from inner to outer LPs in order to eliminate these edges. */ - for (i = vec_safe_length (cfun->eh->lp_array) - 1; i >= 1; --i) - { - lp = (*cfun->eh->lp_array)[i]; - if (lp) - changed |= cleanup_empty_eh (lp); - } - - /* Now do the post-order traversal to eliminate outer empty LPs. */ - for (i = 1; vec_safe_iterate (cfun->eh->lp_array, i, &lp); ++i) - if (lp) - changed |= cleanup_empty_eh (lp); - - return changed; -} - -/* Perform cleanups and lowering of exception handling - 1) cleanups regions with handlers doing nothing are optimized out - 2) MUST_NOT_THROW regions that became dead because of 1) are optimized out - 3) Info about regions that are containing instructions, and regions - reachable via local EH edges is collected - 4) Eh tree is pruned for regions no longer necessary. - - TODO: Push MUST_NOT_THROW regions to the root of the EH tree. - Unify those that have the same failure decl and locus. -*/ - -static unsigned int -execute_cleanup_eh_1 (void) -{ - /* Do this first: unsplit_all_eh and cleanup_all_empty_eh can die - looking up unreachable landing pads. */ - remove_unreachable_handlers (); - - /* Watch out for the region tree vanishing due to all unreachable. */ - if (cfun->eh->region_tree) - { - bool changed = false; - - if (optimize) - changed |= unsplit_all_eh (); - changed |= cleanup_all_empty_eh (); - - if (changed) - { - free_dominance_info (CDI_DOMINATORS); - free_dominance_info (CDI_POST_DOMINATORS); - - /* We delayed all basic block deletion, as we may have performed - cleanups on EH edges while non-EH edges were still present. */ - delete_unreachable_blocks (); - - /* We manipulated the landing pads. Remove any region that no - longer has a landing pad. */ - remove_unreachable_handlers_no_lp (); - - return TODO_cleanup_cfg | TODO_update_ssa_only_virtuals; - } - } - - return 0; -} - -namespace { - -const pass_data pass_data_cleanup_eh = -{ - GIMPLE_PASS, /* type */ - "ehcleanup", /* name */ - OPTGROUP_NONE, /* optinfo_flags */ - TV_TREE_EH, /* tv_id */ - PROP_gimple_lcf, /* properties_required */ - 0, /* properties_provided */ - 0, /* properties_destroyed */ - 0, /* todo_flags_start */ - 0, /* todo_flags_finish */ -}; - -class pass_cleanup_eh : public gimple_opt_pass -{ -public: - pass_cleanup_eh (gcc::context *ctxt) - : gimple_opt_pass (pass_data_cleanup_eh, ctxt) - {} - - /* opt_pass methods: */ - opt_pass * clone () { return new pass_cleanup_eh (m_ctxt); } - virtual bool gate (function *fun) - { - return fun->eh != NULL && fun->eh->region_tree != NULL; - } - - virtual unsigned int execute (function *); - -}; // class pass_cleanup_eh - -unsigned int -pass_cleanup_eh::execute (function *fun) -{ - int ret = execute_cleanup_eh_1 (); - - /* If the function no longer needs an EH personality routine - clear it. This exposes cross-language inlining opportunities - and avoids references to a never defined personality routine. */ - if (DECL_FUNCTION_PERSONALITY (current_function_decl) - && function_needs_eh_personality (fun) != eh_personality_lang) - DECL_FUNCTION_PERSONALITY (current_function_decl) = NULL_TREE; - - return ret; -} - -} // anon namespace - -gimple_opt_pass * -make_pass_cleanup_eh (gcc::context *ctxt) -{ - return new pass_cleanup_eh (ctxt); -} - -/* Disable warnings about missing quoting in GCC diagnostics for - the verification errors. Their format strings don't follow GCC - diagnostic conventions but are only used for debugging. */ -#if __GNUC__ >= 10 -# pragma GCC diagnostic push -# pragma GCC diagnostic ignored "-Wformat-diag" -#endif - -/* Verify that BB containing STMT as the last statement, has precisely the - edge that make_eh_edges would create. */ - -DEBUG_FUNCTION bool -verify_eh_edges (gimple *stmt) -{ - basic_block bb = gimple_bb (stmt); - eh_landing_pad lp = NULL; - int lp_nr; - edge_iterator ei; - edge e, eh_edge; - - lp_nr = lookup_stmt_eh_lp (stmt); - if (lp_nr > 0) - lp = get_eh_landing_pad_from_number (lp_nr); - - eh_edge = NULL; - FOR_EACH_EDGE (e, ei, bb->succs) - { - if (e->flags & EDGE_EH) - { - if (eh_edge) - { - error ("BB %i has multiple EH edges", bb->index); - return true; - } - else - eh_edge = e; - } - } - - if (lp == NULL) - { - if (eh_edge) - { - error ("BB %i cannot throw but has an EH edge", bb->index); - return true; - } - return false; - } - - if (!stmt_could_throw_p (cfun, stmt)) - { - error ("BB %i last statement has incorrectly set lp", bb->index); - return true; - } - - if (eh_edge == NULL) - { - error ("BB %i is missing an EH edge", bb->index); - return true; - } - - if (eh_edge->dest != label_to_block (cfun, lp->post_landing_pad)) - { - error ("Incorrect EH edge %i->%i", bb->index, eh_edge->dest->index); - return true; - } - - return false; -} - -/* Similarly, but handle GIMPLE_EH_DISPATCH specifically. */ - -DEBUG_FUNCTION bool -verify_eh_dispatch_edge (geh_dispatch *stmt) -{ - eh_region r; - eh_catch c; - basic_block src, dst; - bool want_fallthru = true; - edge_iterator ei; - edge e, fall_edge; - - r = get_eh_region_from_number (gimple_eh_dispatch_region (stmt)); - src = gimple_bb (stmt); - - FOR_EACH_EDGE (e, ei, src->succs) - gcc_assert (e->aux == NULL); - - switch (r->type) - { - case ERT_TRY: - for (c = r->u.eh_try.first_catch; c ; c = c->next_catch) - { - dst = label_to_block (cfun, c->label); - e = find_edge (src, dst); - if (e == NULL) - { - error ("BB %i is missing an edge", src->index); - return true; - } - e->aux = (void *)e; - - /* A catch-all handler doesn't have a fallthru. */ - if (c->type_list == NULL) - { - want_fallthru = false; - break; - } - } - break; - - case ERT_ALLOWED_EXCEPTIONS: - dst = label_to_block (cfun, r->u.allowed.label); - e = find_edge (src, dst); - if (e == NULL) - { - error ("BB %i is missing an edge", src->index); - return true; - } - e->aux = (void *)e; - break; - - default: - gcc_unreachable (); - } - - fall_edge = NULL; - FOR_EACH_EDGE (e, ei, src->succs) - { - if (e->flags & EDGE_FALLTHRU) - { - if (fall_edge != NULL) - { - error ("BB %i too many fallthru edges", src->index); - return true; - } - fall_edge = e; - } - else if (e->aux) - e->aux = NULL; - else - { - error ("BB %i has incorrect edge", src->index); - return true; - } - } - if ((fall_edge != NULL) ^ want_fallthru) - { - error ("BB %i has incorrect fallthru edge", src->index); - return true; - } - - return false; -} - -#if __GNUC__ >= 10 -# pragma GCC diagnostic pop -#endif -- cgit v1.1