| Age | Commit message (Collapse) | Author |
|---|
|
The {list,List,Dst} instruction gives us as general way to
capture the building of something into a variable. That will make
inlining of intermediate code much easier.
It also allows us to eliminate the versions of the apply, call_gen,
and cond instructions that takes a target variable.
Also remove the optimization in the alignment optimization pass
that attempts to replace calls to complete/1 with calls to
iolist_to_binary/1. That optimization will not work anymore without
rewriting, so we will remove it in this commit and introcude a
more powerful optimization in a future commit.
|
|
Instead of generating:
{assign,Dst,"element(2, Val)"}
generate:
{call,erlang,element,[2,{var,"Val"}],Dst}
The latter expression is easier to understand since there is no
need to parse a string which may contain an arbitrary expression.
While at it, also discontinue the practice to treat "naked"
atoms as variables. A variable must always be given as {var,String}.
|
|
The {assign,Dst,Src} instruction is difficult to cope with when
doing advanced optimizations, since its source argument is a string
which may contain any expression.
Instead of changing how {assign,_,_} works, we will introduce new
instructions that can be used instead of {assign,_}, and remove
{assign,_,_} in a later commit when it is no longer used.
The first new instruction we will introduce is:
{set,{var,Src},{var,Dst}}
It is useful for common sub-expression elemination among other things.
For the moment, we will only allow a variable as a source argument,
but we could extend it in the future to allow constants as well.
|
|
To facilitate inlining of apply calls in the intermediate format.
|
|
It will greatly facilitate further optimizations if we include the
intermediate code (if available) in the call_gen tuple.
|
|
|
|
|
|
|
|
Make sure that we don't construct:
{cons,{integer,I},{cons,{binary,B},T}} - OR -
{cons,{binary,B},{cons,{integer,I},T}}
but:
{cons,{binary,[{put_bits,I,8,[1]}|B]},T} - OR -
{cons,{binary,B++[{put_bits,I,8,[1]}]},T}
|
|
The function name could contain hyphens or other characters not
allowed in non-quoted function names.
|
|
|
|
* bjorn/compiler/optimizations/OTP-11584:
Generalize optimizations of case statements
Ignore warnings when running sys_core_fold after inlining
|
|
* bjorn/fix-line-number-in-bs-exception/OTP-11572:
compiler: Correct line number in exception from binary construction
|
|
Because 26940a8c0c lifted code in the 'after' clause of 'try' to
a new function, Dialyzer could produce false warnings for code such
as:
try
...
after
file:close(F)
end.
Mark the the call to the generated function as 'compiler_generated'
to silence the warning.
|
|
* RoadRunnr/ecdh_crypto:
crypto: selective support for GF2m curves
ssl: add brainpool elliptic curves to TLS (RFC-7027)
public_key: add brainpool elliptic curves (RFC-5639)
crypto: document ec_curves/0 and ec_curve/1
crypto: add brainpool (RFC 5639) curves
crypto: move elitic curve definitions from OpenSSL built-ins to Erlang
crypto: add ECDH test vectors for more curves
OTP-11578
|
|
* rickard/ts_install_mXX_build:
Teach ts_install --enable-mXX-build flag
|
|
Pick up --enable-m32-build and --enable-m64-build configure
flags from the CONFIG_FLAGS environment variable and pass
along to the ts configure script.
|
|
Case expressions such as:
case {Expr1,Expr} of
{V1,V2} -> ...
end
are already optimized to not actually build the tuple. Generalize
the optimization to avoid building any kind of composite term,
such as:
case {ok,[A,B]} of
{ok,[X,Y]} -> ...
end
We don't expect programmers to write such code directly, but
inlining can produce such code.
We need to be careful about the warnings we produce. If the case
expression is a literal, it is expected that no warnings should be
produced for clauses that don't match. We must make sure that we
continue to suppress those warnings.
|
|
Reported-by: Stanislav Seletskiy
|
|
* nox/odbcserver-tolower:
Include ctype.h in odbcserver.c for tolower()
OTP-11569
|
|
* puzza007/remove-query-reserved-word-from-emacs-mode:
remove support for query keyword from emacs mode
OTP-11568
|
|
* ad/ssh_expand_test:
fix calculation of variable thanks to Alexander Demidenko
OTP-11566
|
|
Newer OpenSSL versions allow to selectively disable GF2m elliptic curves.
Selectively enable GF2m curves is support for them is available.
|
|
|
|
|
|
|
|
RFC-5649, Section 1, documents the advantages that these curves
might have over others (ANSI, SEC1/2)
|
|
Decouple eliptic curve definition from OpenSSL and define them in
Erlang.
|
|
Vectors have been taken from NIST's CRYPTOGRAPHIC ALGORITHM VALIDATION
PROGRAM (CAVP) (http://csrc.nist.gov/groups/STM/cavp/)
|
|
odbcserver.c:2772:12: warning: implicit declaration of function 'tolower' is invalid in C99
[-Wimplicit-function-declaration]
str[i] = tolower(str[i]);
^
|
|
|
|
thanks to Alexander Demidenko
|
|
To reproduce the error:
$ echo '-module(hello).' > hello.erl
$ erl
1> c(hello, [native,{hipe,[no_remove_comments]}]).
[...]
<HiPE (v 3.10.2.1)> Error: [hipe:834]: ERROR: {{case_clause,
{icode_comment,call_ext_only}},
[{hipe_icode,successors,1,
[{file,"hipe_icode.erl"},
{line,1444}]},
[...]
|
|
* sv/faster-orddict-from_list/OTP-11552:
improve performance for orddict:from_list/1
|
|
* nox/fix-dbg_ieval-exporting-rules/OTP-11553:
compiler tests: Test exporting rules for andalso/orelse
Fix evaluation of andalso and orelse in the debugger
|
|
|
|
The new inliner (cerl_inline) does not mark inlined code as compiler
generated. Therefore, when sys_core_fold is run after inlining, it
may generate spurious warnings.
The easiest way out (for now, at least) is to discard all warnings
found when running sys_core_fold after inlining.
|
|
* bjorn/compiler/fix-slow-compilation/OTP-10652:
Eliminate bottlenecks in sys_core_fold
|
|
OTP-11550
* florianZ/crypto/error-fixes:
crypto: Fix memory leaks and invalid deallocations
|
|
|
|
|
|
Improve the performance of orddict:from_list/1 by reimplementing it using
the lists module in a way that preserves backward compatibility.
The QuickCheck programs linked below were used to verify backward
compatibility:
* https://gist.github.com/vinoski/3bd216efa421c581174a
* https://gist.github.com/vinoski/c6db70e8dc725083843d
Both tests, which were run on R16B03, require the original orddict module
to be renamed to olddict, and that code:unstick_mod/1 be applied to orddict
in order to allow it to be replaced with the revised orddict.
The first QuickCheck test first generates a list of pairs of terms, then
uses the list to create both an original and revised orddict using
from_list/1, then verifies that the results of the operation are the same
for both instances. The second QuickCheck test is similar except that it
first creates an instance of the original and revised orddicts and then
folds over a randomly-generated list of orddict functions, applying each
function to each orddict instance and verifying that the results match.
The revised orddict:from_list/1 function was also tested to assess
performance against the original orddict implementation. The test program
used is available here:
* https://gist.github.com/vinoski/61772a052f3501e1e128
Since an orddict instance is implemented as a list, the test program
creates ordicts of length 1, 10, 100, and 1000 and uses them to assess
performance at each length. Performance was measured using timer:tc/3 to
time a number of iterations of various tests against the original orddict
and against the revised orddict. To test from_list/1, orddicts of lengths
1, 10, 100, and 1000 are created from a list of random pairs with integer
keys. For lengths greater than 1, two different tests are performed: one
passing a list of pairs in sorted key order, and the other passing a list
of pairs in reverse sorted key order. Since orddicts are ordered, these
orderings effect worst-case and best-case behavior of the original
orddict:from_list/2 implementation respectively.
These tests were performed against R16B02 on a Macbook Pro with an Intel
Core i7 processor running at 2.7GHz and 16GB of RAM running OS X 10.8.5,
and on a Dell system with a 3.4GHz Intel Core i7 and 16GB of RAM running
Ubuntu Linux 12.04.
The tables below show results for OS X and Linux respectively. Each table
lists the name of each test followed by two numbers, each a time in
microseconds of the average of 10 runs of the test. The first number is the
result for the original orddict, the second for the revised orddict.
As the numbers for both platforms show, the revised from_list/1 function is
always faster than the original version, in some cases quite a bit faster.
Results from OS X:
------------------
from_list length 1: 1.789 0.116
from_list length 10 ordered: 10.082 3.040
from_list length 10 reverse ordered: 4.853 3.604
from_list length 100 ordered: 397.213 20.134
from_list length 100 reverse ordered: 25.473 20.745
from_list length 1000 ordered: 37490.26 251.46
from_list length 1000 reverse ordered: 307.94 215.96
Results from Linux:
-------------------
from_list length 1: 0.146 0.025
from_list length 10 ordered: 4.729 0.815
from_list length 10 reverse ordered: 1.687 0.956
from_list length 100 ordered: 144.467 5.896
from_list length 100 reverse ordered: 6.694 5.816
from_list length 1000 ordered: 13755.19 79.413
from_list length 1000 reverse ordered: 91.54 64.308
|
|
* siri/master-cuddle-with-tests:
[sasl] Fix error printout in release_handler_SUITE to handle unicode path
|
|
Compiling programs with very many uses of the "dot notation"
for extracting a record element could be very slow. The reason
is that each extraction of a record element (R#r.a) would first be
transformed to code like this:
case R of
{r,rec0,_,_} -> rec0;
_ -> error({badrecord,r})
end
In Core Erlang, each '_' would be become a new variable. The
resulting code would be optimized by sys_core_fold, but the
optimization process could be very slow.
Profiling shows that sub_del_var/2 was the worst bottleneck, and the
sub_is_val/2 the second worst bottleneck. In both cases, the culprit
is the linear traversal of a very long list (the list of variable
substitutions). Fortunately, there already is a gb_set (the scope)
which contains all variables that are currently live. If a variable is
not known to be live, it is no point in doing the linear operation on
the list.
|
|
erlc is wired to treat *.core files as core and build them as
compile:file(File, [from_core]), but this is not documented. There's
also an udocumented compile:file/2 option called 'from_core'. This has
been in place and in use for a long time. Therefore, it should be
supported officially.
To fix that, make the following changes:
* document erlc handling of *.core files
* document 'from_core'
|
|
erlc is wired to treat *.S files as assembler and build them as
compile:file(File, [from_asm]), but this is not documented. There's also
a documented compile:file/2 option called 'asm' (mapping to 'from_asm'),
but the wording discourages its use. All of this has been in place and
in use for a long time. Therefore, it should be supported officially.
To fix that, make the following changes:
* document erlc handling of *.core files
* un-document 'asm' and document 'from_asm' instead
* deprecate 'asm'
While at it, fix a minor typo in the test suite.
|
|
* nox/asm-reentrant/OTP-11544:
Test compilation of BEAM assembly with optimisations on
Keep exit blocks in order when moving them in beam_jump
Add missing recv_set, recv_mark and '%' to BEAM live annotation
Collect all optimised allocate instructions in beam_block
Properly collect allocate_zero instructions in beam_block
Properly let floating-point instructions through in the BEAM compiler
|
|
|
|
Yielding binary_to_term.
OTP-11535
* tag 'OTP_R16B03_yielding_binary_to_term':
Increase versions for OTP_R16B03_yielding_binary_to_term
erts: Adjust term_to_binary reduction factors
erts: Yield after trapping term_to_binary if gc has been ordered
erts: Let term_to_binary disable gc while trapping
erts: Improve stress of binary_to_term in binary_SUITE
erts: Fix bug in binary_to_term for compressed on halfword
erts: Fix crash when binary_to_term throws badarg
erts: Trapping memcpy in binary_to_term
erts: Cleanup code for trapping binary_to_term
erts: Add erlang wrappers to binary_to_term
trapping uncompress
trapping size calculation
trapping binary_to_term/2
trapping STRING_EXT
trapping lists and tuples
trapping binary_to_term passing binary_SUITE
Conflicts:
erts/preloaded/ebin/erlang.beam
erts/preloaded/ebin/erts_internal.beam
erts/vsn.mk
lib/kernel/vsn.mk
lib/stdlib/vsn.mk
|
|
in mod_pow, mod_exp and generate_key(srp,...)
|
