Consider the following code
f = g (case v of
V a b -> a : t f)
where g is expensive. Liberate case will turn this into
f = g (case v of
V a b -> a : t (letrec f = g (case v of
V a b -> a : f t)
in f)
)
Yikes! We evaluate g twice. This leads to a O(2^n) explosion
if g calls back to the same code recursively.
This happen sometimes in HPC, because every tick is a liberate-able case,
but is a general problem to case liberation (I think).
import StaticFlags ( opt_Static )
#endif
import StaticFlags ( opt_PIC, WayName(..), v_Ways, v_Build_tag,
- v_RTS_Build_tag )
+ v_RTS_Build_tag, opt_Hpc )
import {-# SOURCE #-} Packages (PackageState)
import DriverPhases ( Phase(..), phaseInputExt )
import Config
cse = dopt Opt_CSE dflags
spec_constr = dopt Opt_SpecConstr dflags
liberate_case = dopt Opt_LiberateCase dflags
+ && not opt_Hpc
rule_check = ruleCheck dflags
core_todo =