[erlc] Very long compilation time for nested record accesses in guards

[RobinMorisset]

Describe the bug
Many programs with nested record accesses in a guard take a surprisingly long time to compile (30+ seconds is not rare).
Additionally, that time is extremely sensitive to details of the code, making me suspect that a corner case in the compiler causes an exponential blow-up.

To Reproduce
Run erlc on the following code:

-export([f1/1]).
-record(r1, {rf0}).

f1(_V0) when
    (not #r1{
        rf0 =
            (((true andalso
                (true >
                    #r1{
                        rf0 =
                            (((((#r1{
                                rf0 =
                                    (((#r1{
                                        rf0 =
                                            is_function(
                                                [0, _V0],
                                                0
                                            )
                                    })#r1.rf0)#r1.rf0)#r1.rf0 xor
                                        (floor(0) band
                                            ((((#r1{
                                                rf0 =
                                                    (is_function(
                                                        <<>>,
                                                        1
                                                    )) orelse
                                                        ([])#r1.rf0
                                            })#r1.rf0 rem
                                                (bnot (((true andalso
                                                    #r1.rf0) andalso
                                                    ([])#r1.rf0#r1.rf0)#r1.rf0))) bxor
                                                (((false orelse
                                                    [])#r1.rf0)#r1.rf0)) bxor
                                                byte_size(
                                                    true andalso
                                                        <<>>
                                                )))
                            })#r1.rf0)#r1.rf0)#r1.rf0) andalso [])
                    }#r1.rf0)) andalso
                [])#r1.rf0)#r1.rf0
    }#r1.rf0)#r1.rf0
->
    0.0.

It takes about 10s to compile, which falls to 4s if for example the initial not is removed, to 2s if the _V0 is removed, etc..
I can easily provide many more such test cases, but they resist automated reduction and tend to be significantly larger than this one.

Expected behavior
Compile time which is roughly linear with code size (even quadratic would be fine)

Affected versions

• master
• Eliminate crash for nested guards in record initialization #8196

Additional context
This is a low-priority issue since such code is unlikely to be written by humans. I'm only reporting it because it makes it impossible to fuzz record accesses in guards.

[frej]

Running erlc +time it looks like it is mainly the ssa_opt_cse pass. With the initial not it accounts for 70% of the total runtime, without for 62% (of 8s and 3.5s respectively). The next most expensive pass is beam_ssa_bool which accounts for ~17% of the runtime in both cases.