Fix bug when making nsis target
Fix release_handler:find_script so it can read regexp in appups
Fix the contract of erl_ddll:format_error/1

The bug in the contract of erl_ddll:format_error_int/1 in R15B that
was copied to R16B (OTP-9862) has been fixed.
test_server: Refactor timetrap_scale_factor/0
test_server: Let start_node/3 utilize scalefactor

 * test_server_node:start_node/3 now uses timetrap_scale_factor for
   timeouts (peer nodes)
v3_codegen: Don't duplicate the functionality of cg_reg_arg/2
v3_codegen: Clean up comments and remove out-commented code
v3_codegen: Clarify code generation for binary construction

Add some comments to make the code generation for binary
construction somewhat clearer. Also get rid of the cg_bo_newregs/2
function that serves no useful purpose. (It was probably
intended to undo the effect of cg_live/2, but note that the
value passed to cg_bo_newregs/2 has not passed through cg_live/2.)
beam_utils: Check liveness in catches and try/catch blocks

Less conservative liveness analysis allows more optimizations
to be applied (such as the ones in beam_bool).
beam_utils: Extend live_opt/1 to recalculate live registers in allocs

The code generator uses conservative liveness information. Therefore
the number of live registers in allocation instructions (such as
test_heap/2) may be too high. Use the actual liveness information
to lower the number of live register if it's too high.

The main reason we want to do this is to enable more optimizations
that depend on liveness analysis, such as the beam_bool and beam_dead
passes.
beam_utils:live_opt/1: Correct liveness calculation for 'try'

The liveness at the failure label should be ignored, because if
there is an exception, all x registers will be killed.
beam_utils: Correct usage calculations for GC BIFs in blocks

The usage calculation only looked at the allocation in GC BIFs, not
at the source and destination registers. Also, if there is a failure
label, make sure that we test whether the register can be used there.
beam_bool: Recognize more safe optimizations

The optimizer of boolean expressions can often reject optimizations
that it does not recognize as safe. For instance, if a boolean
expression was preceded by 'move' instructions that saved x registers
into y registers, it would almost certainly reject the optimization
because it required the y register not be used in the code that
follows.

Fix this problem by allowing identical 'move' instructions that assing
to y registers at the beginning of the old and the optimized code.

While at it, correct the spelling of "preceding".
Increase sbct for win64 as block alignment is 16
Add comment about eproviderfailedinit error
Merge branch 'lukas/erts/bucket_mask_fix/OTP-10374' into maint

* lukas/erts/bucket_mask_fix/OTP-10374:
  Add comment about eproviderfailedinit error
  Increase sbct for win64 as block alignment is 16
Merge branch 'maint'

* maint:
  Add comment about eproviderfailedinit error
  Increase sbct for win64 as block alignment is 16
v3_codegen: Combine adjacent bs_match_string instructions

In modules with huge functions with many bs_match_string
instructions, we can speed up the compilation by combining
adjacent bs_match_strings instruction in v3_codegen (as opposed
to in beam_block where we used to do it).

For instance, on my computer the v3_codegen became more than
twice as fast when compiling the re_testoutput1_split_test module
in the STDLIB test suites.
Improve binary matching of literals

The bs_match_string instruction is used to speed up matching of
binary literals. For example, given this source code:

foo1(<<1,2,3>>) -> ok.

The matching part of the code will look like:

    {test,bs_start_match2,{f,1},1,[{x,0},0],{x,0}}.
    {test,bs_match_string,{f,3},[{x,0},24,{string,[1,2,3]}]}.
    {test,bs_test_tail2,{f,3},[{x,0},0]}.

Nice. However, if we do a simple change to the source code:

foo2(<<1,2,3>>) -> ok;
foo2(<<>>) -> error.

the resulting matching code will look like (sligthly simplified):

    {test,bs_start_match2,{f,4},1,[{x,0},0],{x,0}}.
    {test,bs_get_integer2,{f,7},1,[{x,0},{integer,8},1,Flags],{x,1}}.
    {test,is_eq_exact,{f,8},[{x,1},{integer,1}]}.
    {test,bs_match_string,{f,6},[{x,0},16,{string,[2,3]}]}.
    {test,bs_test_tail2,{f,6},[{x,0},0]}.
    {move,{atom,ok},{x,0}}.
    return.
  {label,6}.
    {bs_restore2,{x,0},{atom,start}}.
  {label,7}.
    {test,bs_test_tail2,{f,8},[{x,0},0]}.

That is, matching of the first byte is not combined into the
bs_match_string instruction that follows.

Fix this problem by allowing a bs_match_string instruction to be
used if all clauses will match either the same integer literal or
the empty binary.
v3_kernel: Fix match code for matched out segment size in multiple clauses

When matched variable is used as a size field in multiple clauses,
as in:

foo(<<L:8,A:L>>) -> A;
foo(<<L:8,A:L,B:8>>) -> {A,B}.

the match tree would branch out before the segment that used the
matched-out variable (in this example, the tree would branch out before
the matching of A:L). That happens because the pattern matching
compilator did not take variable substitutions into account when
grouping clauses that match the same value.

That is, the generated code would work similarly to this code:

foo(<<L:8,T/binary>>) ->
  case T of
    <<A:L>> ->
      A;
    _ ->
      case T of
        <<A:L,B:8>> ->   %% A matched out again!
	  {A,B}
	end
  end.

We would like the matching to work more like:

foo(<<L,A:L,T/binary>>) ->
  case T of
    <<>> -> A;
    <<B:8>> -> {A,B}
  end.

Fix the problem by taking the substitutions into account when grouping
clauses that match out the same value.