https://bugs.erlang.org/browse/ERL-1026

The compiler would crash when compiling the following code:

    do(Acc) ->
        receive
            {Pid, abc} ->
                ok;
            {Pid, []} ->
                ok;
            {Pid, _Res} ->
                exit(_Res)
        end,
        do([Pid | Acc]).

The last clause that always raises an exception would confuse the
compiler so that it would think that the `receive` statement was at the
end of the function and it would generate incorrect code for the `do/1`
call following the `receive`.

https://bugs.erlang.org/browse/ERL-1022

* bjorn/compiler/fix-stack-init/ERL-1017/OTP-15968:
  Ensure that the stack slots are initialized when matching maps

When matching a map, the compiler could fail to generate code that
would initialize all stack slots (Y registers) properly. Here is a
general outline of code that *could* cause this problem:

    foo(Key, Map) ->
         Res = case Map of
                  #{Key := Val} ->
                      %% Do something with Val here.
		        .
			.
			.
                  #{} ->
		      []
              end,
	%% The stack slot for Val might not have been initialized
	%% here if the key was not present in the map.
	.
	.
	.
	%% Use Res.
	.
	.
	.

The code generator would wrongly assume that the map matching would
always initialize the stack slot, and if nothing else happened to
force that stack slot to be initialized, it would remain
uninitialized, which would likely crash the runtime system at the next
garbage collection.

`beam_validator` is supposed to find these kind of problems, but a bug
in `beam_validator` prevented it from detecting this problem.

https://bugs.erlang.org/browse/ERL-1017

* john/compiler/fix-delayed-type-inference/OTP-15954/ERL-995:
  beam_validator: Values referenced by other values must be merged

Avoid extremely long compilation times for huge functions

OTP-15970

* 'bjorn/compiler/length-misuse/ERL-1013' of https://github.com/bjorng/otp:
  Eliminate a crash in the type optimizer pass

OTP-15969

* 'bjorn/compiler/fix-no_type_opt/ERL-997' of https://github.com/bjorng/otp:
  Fix compiler crash when compiling with +no_type_opt

Compiling this example takes less than a second for OTP 21:

    -define(B, {?A,?A,?A,?A,?A}).
    -define(C, {?B,?B,?B,?B,?B}).
    -define(D, {?C,?C,?C,?C,?C}).
    -define(E, {?D,?D,?D}).

    f() -> ?E = foo:bar().

The compilation time for OTP 22 is about 10 seconds. Most of the
time is spent in `beam_ssa_dead`.

This commit introduces several optimizations to bring the compilation
time down to about a second.

The most important of those optimizations is limiting the effort spent
searching forward for a joining point for the success and failure
labels for a two-way branch. This change is helped by the change of
representation of variable sets from `ordsets` to `cerl_sets`.

https://bugs.erlang.org/browse/ERL-1014

* bjorn/compiler/fix-unsafe-sharing/OTP-15963:
  Fix unsafe code sharing