| Age | Commit message (Collapse) | Author |
|---|
|
* hb/kernel/spec_fix/OTP-10473:
Fix the contract of erl_ddll:format_error/1
|
|
* hb/stdlib/spec_fix/OTP-10474:
Change the type of some arguments in filename to file:name()
|
|
|
|
|
|
* bjorn/compiler/minor-optimization-polishing/OTP-10193: (25 commits)
beam_bsm: Handle calls slightly better
Break apart tail-recursive call instructions
Represent the 'send' instruction as a call_ext/2 instruction
Rewrite select_val and select_tuple_arity to a select instruction
Rewrite binary creation instructions to bs_init instructions
Rewrite bs_add, bs_utf*_size to BIF instructions in optimizations
Rewrite bs_put* instructions to a generic bs_put instruction
Refactor removal of unused labels
Introduce the mandatory beam_a and beam_z passes
compile: Fix bug in selection of passes
beam_receive: Optimize receives using refs created by spawn_monitor/{1,3}
compile: Give a friendler error message if a parse transform cannot be found
beam_jump: Don't move a block which can be entered via a fallthrough
beam_jump: Fix broken optimization
v3_kernel: Fix match code for matched out segment size in multiple clauses
Improve binary matching of literals
v3_codegen: Combine adjacent bs_match_string instructions
beam_bool: Recognize more safe optimizations
beam_utils: Correct usage calculations for GC BIFs in blocks
beam_utils:live_opt/1: Correct liveness calculation for 'try'
...
|
|
We were too conservative when handling a call when there were copies of
the match context in both x and y registers. Don't give up if there
is are copies of the match context in y registers, as long as those
copies are killed by the code that follows the call.
|
|
Somewhat reduce the code bloat by eliminating special cases.
|
|
Somewhat reduce code bloat.
|
|
Eliminate some code bloat.
|
|
|
|
* egil/fix-boot_combo-test:
test: Fix smoke_test_SUITE
|
|
* siri/sasl/appup-regexp-fix/OTP-10463:
Fix release_handler:find_script so it can read regexp in appups
|
|
* maint:
Fix bug when making nsis target
|
|
* lukas/erts/whitespace_nsis_fix/OTP-10481:
Fix bug when making nsis target
|
|
* Skip boot_combo tests where cannot start slave nodes
(The binary will not exist)
|
|
Rewrite the five binary creation instructions to a bs_init
instruction, in order to somewhat reduce code bloat.
|
|
We can remove some code bloat by handling the special instructions
as BIF instructions in the optimization passes. Also note that
bs_utf*_size was not handled by beam_utils:check_liveness/3
(meaning the conservative answer instead of the correct answer
would be returned).
|
|
Seven bs_put_* instructions can be combined into one generic bs_put
instruction to avoid some code bloat. That will also improve some
optimizations (such as beam_trim) that did not handle all bs_put*
variants.
|
|
Since we always want to remove unused labels directly after code
generation (whether we'll run the optimization passes or not),
we can simplify the code by doing it in beam_a.
|
|
Introduce the mandary beam_a pass that will be run directly after code
generation, and the mandatory beam_z pass that will be run just before
beam_asm. Since these passes surround the optimizations, beam_a can
(for example) do instruction renaming to simplify the optimization
passes and beam_z can undo those renamings.
|
|
|
|
|
|
Don't throw the parse tree in the face of the user.
OTP-8707
|
|
beam_jump moves short code sequences ending in an instruction that causes
an exception to the end of the function, in the hope that a jump around
the moved blocked can be replaced with a fallthrough. Therefore, moving
a block that is entered via a fallthrough defeats the purpose of the
optimization.
Also add two more test cases for the beam_receive module to ensure that
all lines are still covered.
|
|
A test instruction with the same target label as jump immediately
followed it was supposed to be removed, but it was kept anyway.
Fix that optimization, but also make sure that the test instruction
is kept if the test instruction may have side effects (such as
a bit syntax matching instruction).
While at it, make the code cleaner by breaking it up into two clauses
and don't remove the jump instruction if it is redudant (removal of
redundant jump instructions is already handled in another place).
|
|
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.
|
|
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.
|
|
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.
|
|
* maint:
Add comment about eproviderfailedinit error
Increase sbct for win64 as block alignment is 16
|
|
* lukas/erts/bucket_mask_fix/OTP-10374:
Add comment about eproviderfailedinit error
Increase sbct for win64 as block alignment is 16
|
|
|
|
|
|
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".
|
|
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.
|
|
The liveness at the failure label should be ignored, because if
there is an exception, all x registers will be killed.
|
|
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.
|
|
Less conservative liveness analysis allows more optimizations
to be applied (such as the ones in beam_bool).
|
|
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.)
|
|
|
|
|
|
* egil/inets/remove-tracing-in-tests:
inets: Remove dbg tracing from testcases
|
|
* egil/remove-unused-files:
Remove unused files from old native dns resolver
|
|
* sze/improve-interoperability-SSH-clients:
Improve interoperability with SSH clients
OTP-10475
|
|
* jn/ets-match-pattern-export-type:
Export ets:match_pattern/0 type
Conflicts:
lib/stdlib/src/ets.erl
OTP-10472
|
|
The bug in the contract of erl_ddll:format_error_int/1 in R15B that
was copied to R16B (OTP-9862) has been fixed.
|
|
* hb/stdlib/opaque_warnings/OTP-10436:
Fix Dialyzer warnings
|
|
* sverk/code-load-refactor-later-op:
erts: Fix faulty lock check assert
erts: Refactor naming regarding code_write_permission
erts: Refactor tracing to use erts_schedule_thr_prgr_later_op
erts: Allow thr_prgr_later_op to reschedule
erts: Refactor code loading to use erts_schedule_thr_prgr_later_op
erts: Remove some compiler warnings
|
|
* ia/ssl/controlling-process-on-listen-socket/OTP-10447:
ssl: Improve #sslsocket{} API
ssl: It is now possible to call controlling_process on a listen socket, same as in gen_tcp.
|
|
This patch fixes a few problems of the SSH shell server that affect the
interoperability with SSH clients in widespread use.
First problem is that, whenever a channel_request message is
received with want_reply=true, the reply ends up being sent to the
servers channel id, not the clients channel id. This causes the client
to terminate the connection. The easiest solution to the problem appears
to be a new function in ssh_connection_manager.erl that translates the
servers channel id before sending the reply (in the same manner as
other functions do it).
Second problem is in ssh_cli.erl. When an SSH client sends a
window_change request between PTY allocation and starting the shell
(which appears to happen with some clients), ssh_cli.erl crashes
because #state.buf is yet 'undefined'. Allocating an empty buffer at PTY
allocation time solves the problem.
Affected SSH clients:
- all clients based on SSH-2.0-TrileadSSH2Java_213 (problem #1)
- SSH Term Pro (problem #2)
|
|
Scaling timetraps depending on cover, debug-compiled emulator and so
on is built-in to the test_server. Therefore, {multiply_timetraps,Scale}
should not be set (it would multiply the timeout value twice). Only
{scale_timetraps,true} needs to be set, and it must be set
unconditionally as the feature tests in
test_server:timetrap_scale_factor() may not return the correct
scale factor until the test_server node and test cases have been
started (for example, there is no cover server running).
|
