This document describes the changes made to the Compiler application.
Several problems in the inliner have been fixed.
Own Id: OTP-8552
The module binary from EEP31 (and EEP9) is implemented.
Own Id: OTP-8217
Local and imported functions now override the auto-imported BIFs when the names clash. The pre R14 behaviour was that auto-imported BIFs would override local functions. To avoid that old programs change behaviour, the following will generate an error:
Doing a call without explicit module name to a local function having a name clashing with the name of an auto-imported BIF that was present (and auto-imported) before OTP R14A
Explicitly importing a function having a name clashing with the name of an autoimported BIF that was present (and autoimported) before OTP R14A
Using any form of the old compiler directive
If the BIF was added or auto-imported in OTP R14A or later, overriding it with an import or a local function will only result in a warning,
To resolve clashes, you
can either use the explicit module name
The
change makes it possible to add auto-imported BIFs
without breaking or silently changing old code in the
future. However some current code ingeniously utilizing
the old behaviour or the
*** POTENTIAL INCOMPATIBILITY ***
Own Id: OTP-8579
The undocumented, unsupport, and deprecated function
Own Id: OTP-8584
Nested records can now be accessed without parenthesis. See the Reference Manual for examples. (Thanks to YAMASHINA Hio and Tuncer Ayaz.)
Own Id: OTP-8597
It is now possible to suppress the warning in code
such as "
Own Id: OTP-8602
Own Id: OTP-8623
The compiler optimizes record operations better.
Own Id: OTP-8668
Using complex boolean expressions in ifs could cause the compiler to either crash or teminate with an internal error. (Thanks to Simon Cornish.)
Own Id: OTP-8338
Bit string comprehensions can now be used in parameterized modules. (Thanks to Jebu Ittiachen.)
Own Id: OTP-8447
The expected return value for an on_load function has been changed. (See the section about code loading in the Reference manual.)
*** POTENTIAL INCOMPATIBILITY ***
Own Id: OTP-8339
In rare circumstances when using garbaging collecting guard BIFs, the validation pass (beam_validator) would signal that the code was unsafe, when it in fact was correct. (Thanks to Kiran Khaladkar.)
Own Id: OTP-8378
The
Own Id: OTP-8382
Macros overloading has been implemented. (Thanks to Christopher Faulet.)
Own Id: OTP-8388
The compiler's 'E' option now works with modules with types and specifications.
Own Id: OTP-8238 Aux Id: OTP-8150
Certain uses of binary matching in a
Own Id: OTP-8271
The documentation is now built with open source tools (xsltproc and fop) that exists on most platforms. One visible change is that the frames are removed.
Own Id: OTP-8201
The compiler could crash if invalid calls to is_record/2 was used in (for example) a list comprehension. (Thanks to Tobias Lindahl.)
Own Id: OTP-8269
The -on_load() directive can be used to run a function when a module is loaded. It is documented in the section about code loading in the Reference Manual.
Own Id: OTP-8295
Corrected liveness optimization to eliminate a compiler crash that could occur when compiling bit syntax construction code. (Thanks to Mikage Sawatari.)
Calling BIFs such as
Using filter expressions containing
Own Id: OTP-8054
A guard with nested 'not' operators could cause the compiler to crash. (Thanks to Tuncer Ayaz.)
Own Id: OTP-8131
The compiler would crash while compiling certain complex
function bodies containing
Own Id: OTP-7980
Miscellaneous minor bugs fixed.
Own Id: OTP-7937
There will be more efficient code if there is a clause that matches the empty binary and no other clauses that matches non-empty binaries.
Own Id: OTP-7924
There is new option to allow a module to have a module name other than the filename. Do not use it unless you know what you are doing.
Own Id: OTP-7927
Using
Som large and complex functions could require extremely long compilation times (hours or days).
Own Id: OTP-7905
For some complex guards which used
Own Id: OTP-7679
Code that (incorrectly) used the the value of nested
applications of
Own Id: OTP-7690
Modules containing huge integers (consisting of several hundreds of thousands of digits or more) could be slow to compile. This problem has been corrected.
Own Id: OTP-7707 Aux Id: seq11129
If the generator in a list comprehension is given a
non-list term, there will now be
Own Id: OTP-7844
The compiler could crash if the size for a binary segment in matching was a complex literal such as binary or tuple.
Own Id: OTP-7650
The compiler generates more compact and faster code for matching of complex constants (such as constant lists and tuples).
Own Id: OTP-7655
The undocumented, unsupported, and deprecated guard BIF
*** INCOMPATIBILITY with R12B ***
Own Id: OTP-7673
The compiler generates better code for many guard
expressions, and especially for guards that use
(In technical terms,
Own Id: OTP-7718
The default size for the resulting binary created by a binary comprehension was 64Kb in R12B (it would grow if needed). This was often far too much. In this release, the default is changed to 256 bytes. Furthermore, for most binary comprehensions without filters, the exact size of the resulting binary can be calculated beforehand and the compiler now generates code that does that calculation.
Own Id: OTP-7737
The short-circuit operators
*** POTENTIAL INCOMPATIBILITY ***
Own Id: OTP-7748
The compiler will refuse to a compile file where the module name in the file differs from the output file name.
When compiling using
*** POTENTIAL INCOMPATIBILITY ***
Own Id: OTP-7793
There will no longer be any warnings for list comprehensions without generators, as such list comprehension have turned out to be useful.
Own Id: OTP-7846
Warnings for obsolete guard tests are now turned on.
(That is, writing
The warnings can be turned off using the
Own Id: OTP-7850
The copyright notices have been updated.
Own Id: OTP-7851
If a module contains an exported function with the
same name as an auto-imported BIF (such as
(The reason for the change is to avoid breaking code in a future major release, R14 or R15, in which we plan to make calls without a module prefix always call the local function in the same module even if there is an auto-imported BIF with the same name.)
*** POTENTIAL INCOMPATIBILITY ***
Own Id: OTP-7873
Matching on a zero-width segment in the bit syntax would crash the compiler. (Thanks to Will.)
Own Id: OTP-7591
In bit syntax expressions which started with a binary segment, and was followed by at least two segments of variable size, too little space could be allocated for the binary, leading to memory corruption.
Own Id: OTP-7556
In user-defined attributes,
The
Own Id: OTP-7586
Certain complex bit syntax matching operations matching out binaries and having several clauses could give incorrect results (the matched out binaries were too short). (Thanks to Christian von Roques for bug report and correction.)
Own Id: OTP-7498
New option
Own Id: OTP-7392
In rare circumstances, the length/1 BIF (and a few other guard BIFs) would seem to return an incorrect value (of any type).
Own Id: OTP-7345 Aux Id: seq10962
A bug in the old inliner has been fixed. Some undocumented functionality has been removed.
Own Id: OTP-7223
Matching several binary patterns in parallel using the '=' operator is not allowed (an implementation limitation), but the compiler did not reject all such attempts (depending on the patterns, the generated code might or might not work correctly). Now the compiler rejects all binary patterns joined by '='.
Own Id: OTP-7227
Complex combinations of record operations and binary matching could cause the compiler to crash. (Thanks to Vladimir Klebansky.)
Own Id: OTP-7233
In rare circumstances, mixing binary matching clauses with clauses matching other data types, the compiler could crash.
Own Id: OTP-7240 Aux Id: seq10916
Corrected a compiler bug that could cause a complex binary matching operation to fail when it shouldn't. (Thanks to Tomas Stejskal.)
Own Id: OTP-7188
In unusual circumstances, the environment for a fun could bind wrong values.
Own Id: OTP-7202 Aux Id: seq10887
Long sequences of list comprehensions without
generators joined by the '++' operator would cause a code
expansion explosion, which could cause the compiler to
run out of memory. To resolve this problem, in
'
Note about evaluation order: The Reference manual says
that subexpressions are evaluated in any order
before the expression itself. Therefore, in an expression
such as '
Own Id: OTP-7206
A match expression inside a function call could cause a false "a term is constructed but never used" warning.
Own Id: OTP-7018 Aux Id: seq10824
The compiler could crash if a binary tail was matched out, and then used in a binary append operation. (Thanks to Oleg Avdeev.)
Similarly, the compiler could crash if a binary tail was matched out, and then used (incorrectly) in binary construction in an integer field. (Thanks to Fredrik Svahn.) Or was incorrectly used in a float field. Or was used in a binary field with a given length. (Thanks to Chih - Wei Yu.)
Own Id: OTP-7022
Matching an empty binary in a record and then using the same record again could cause a compiler crash. (Thanks to Fredrik Thulin.)
Own Id: OTP-7029
In rare circumstances, constants containing floating points and integers could be confused. Example:
Both
Own Id: OTP-7073
Some bit syntax code such as
could crash the compiler. (Thanks to Simon Cornish.)
Own Id: OTP-7094
In unusual circumstances, a call to a fun could fail due to an unsafe optimization. (Thanks to Simon Cornish.)
Own Id: OTP-7102
Bit syntax matching with a guard containing two or more uses of andalso/orelse could cause the compiler to crash. (Thanks to Mateusz Berezecki.)
Own Id: OTP-7113
This was only a problem if you generated or wrote your
own Core Erlang code: The Core Erlang optimizer code
could move nested calls such as
Own Id: OTP-7117
The compiler could generate suboptimal code for record updates if the record update code consisted of multiple source code lines.
Own Id: OTP-7101
The compiler used to allow that a binary field without
size could be used in other positions than at the end in
bit syntax pattern. For instance,
Also, it is now longer permitted to give a literal
string in a binary pattern a type or a size; for
instance,
Own Id: OTP-6885
Bitstrings (bit-level) binaries and binary comprehensions are now part of the language. See the Reference Manual.
Own Id: OTP-6558
The '
Own Id: OTP-6801
If the value of a list comprehension is not used, such
as in '
If the value of an expression is not used, and the
expression has no side effects except for possibly
throwing an exception, a warning will be generated.
Examples: '
Own Id: OTP-6824
Three new functions have been added to the
Own Id: OTP-6829
Many bit syntax operations, both construction and matching, are faster. For further information, see the Efficiency Guide.
Own Id: OTP-6838
Literal lists, tuples, and binaries are no longer constructed at run-time as they used to be, but are stored in a per-module constant pool. Literals that are used more than once are stored only once.
This is not a change to the language, only in the details of its implementation. Therefore, the implications of this change is described in the Efficiency Guide.
Example 1: In the expression
Example 2: Literal strings, such as
Own Id: OTP-6850
Recursive calls now usually consume less stack than in R11B. See the Efficiency Guide.
Own Id: OTP-6862 Aux Id: seq10746
Two new guard BIFs have been introduced as a
recommended replacement for
There is also a new
Own Id: OTP-6902
The two internal functions
Own Id: OTP-6966
The compiler would crash if you tried to combine to
non-list literals with '
Own Id: OTP-6630 Aux Id: seq10635
Minor Makefile changes.
Own Id: OTP-6689
Incorrect code could be generated for bit syntax matching if the old inliner was used with aggressive settings.
Own Id: OTP-6461
The R10B compiler could generate unsafe
Own Id: OTP-6386
Directives for parse transforms that have been run are now removed from the abstract code stored when the debug_info option is given, to prevent the parse transforms to be run again.
Own Id: OTP-5344
Minor improvements in code generation for some guards expression involving boolean expressions.
Own Id: OTP-6347
The compiler could generate incorrect code for bit syntax matching consisting of several clauses.
Own Id: OTP-6392 Aux Id: seq10539
Defining a fun itself containing a fun in an
Shorter compilation times for modules containing with an extreme number of functions (10000 functions or more).
(The compiled could generate deprecated instructions for certain bit syntax matching operations.)
Own Id: OTP-6212 Aux Id: seq10446
Fixed several bugs that would cause warnings to be shown without file name and line number.
Own Id: OTP-6260 Aux Id: seq10461
The
If necessary, the record tests can be turned off by
giving the
The
*** POTENTIAL INCOMPATIBILITY ***
Own Id: OTP-6294
The compiler used to crash if a module contained code
similar to '
The compiler would spend really long time compiling
bit syntax expressions such as
'
The compiler would compile list comprehensions with many generators really, really slow. (Thanks to Thomas Raes.)
Module attributes would be stored in reverse order
compared to the order in the source code. (Thus,
Defining a fun in an
The combination of binary pattern and a guard with andalso/orelse could cause the compiler to crash.
Own Id: OTP-6121 Aux Id: seq10400
When a
Own Id: OTP-5944
The
Own Id: OTP-5894 Aux Id: OTP-5149
When given the new option
The Erlang shell always applies strict record tests.
Own Id: OTP-5915 Aux Id: OTP-5714
The BIF
Own Id: OTP-5916
The compiler options
*** POTENTIAL INCOMPATIBILITY ***
Own Id: OTP-6058
The following code would crash the compiler:
The compiler could crash if binaries were constructed in certain guards involving boolean operators (including semicolon). (Thanks to Torbjorn Tornkvist.)
Own Id: OTP-5872
The compiler will now warn that the
Own Id: OTP-5976
The compiler would assume that some patterns with aliases ('=') would not match if they were split into several lines. (Thanks to Peter Nagy/Mats Cronqvist.)
Minor cleanups to eliminate Dialyzer warnings.
Own Id: OTP-5791 Aux Id: seq10141
When given the new option
The beam validator pass of the compiler could crash given in rare circumstances when given certain combinations of catches and record operations. (Thanks to Mats Cronqvist.)
Attributes containing binaries (such as -a(<<1,2,3>>)) would crash the compiler. (Thanks to Roger Price.)
Multiple behaviours in the same module will no longer
generate a warning, unless one or more callbacks for the
behaviours overlap. For instance, using both the
Own Id: OTP-5714 Aux Id: seq10073
The pre-processor used to complain that the macro
definition
Own Id: OTP-5777
Updating at least two fields of a record with a literal
string could cause the compiler to generate dangerous
code that could cause a crash at run-time (e.g.
Unecessary tests (such as a 'case' with two case branches that were identical) could cause the compiler to crash. (Thanks to Fredrik Thulin.)
The validation pass of the compiler could generate an error for correct code when floating point operations were used in try/catch statements.
In bit syntax construction, any field following a binary field would always be marked as "aligned" (which may or may not be correct). That would cause the hipe native compiler to generate incorrect code if the field was in fact unaligned. (Thanks to Per Gustafsson.)
Some complex guard expressions (such as
Compilation speed has been increased for modules with many functions and/or atoms (such as modules generated by the Asn1 application or other code generators).
Own Id: OTP-5632 Aux Id: seq10057
In some circumstances, having two try/catch constructs following each in a function body, would cause an internal error to be generated (when in fact the generated code was correct). (Thanks to Fredrik Thulin.)
Incorrect calls such as
Own Id: OTP-5553
The new
The new type test
Own Id: OTP-5584
Further improvements of encrypted debug info: New option
Own Id: OTP-5541 Aux Id: seq9837
Fixed a bug in the validator of the generated code (beam_validator) which caused an internal compiler error even though the generated code was indeed correct.
Own Id: OTP-5481 Aux Id: seq9798
It is now possible to encrypt the debug information in
Beam files, to help keep the source code secret. See the
documentation for
The
Own Id: OTP-5460 Aux Id: seq9787
Complex functions could cause the internal validator in the compiler to generate an internal error even though the generated code was correct.
Own Id: OTP-5436 Aux Id: seq9781
In rare circumstances, incorrect code for record or tuple access could be generated. The incorrect code would either trigger an internal error in the compiler or cause an exception at run time. (Thanks to Martin Bjorklund.)
Corrected a bug in in bit syntax matching where clauses could match in the wrong order. (Thanks to Ulf Wiger.)
Own Id: OTP-5404 Aux Id: seq9767
Given bit syntax construction in certain complex contexts involving a catch, the compiler would either crash or terminate due to failure in an internal consistency check. (Thanks to Fredrik Thulin.)
Matches such as
Shadowing of variables in bit syntax matches in fun heads
such as in
A bug in the validation pass has been corrected. It
sometimes occurred when the compiler optimized by reusing
code for causing an exception when the reused code was
called from within catch or try-catch statements. Then the
validator refused to approve the code and complained about
A bug in the unknown_catch_try_state.
Corrected a bug in the optimizer that would cause the compiler to crash. (Thanks to Peter-Henry Mander.)
There are now warnings generated if a bit syntax
construction will fail at run-time because of a type
mismatch (e.g.
Own Id: OTP-5342 Aux Id: OTP-5118, OTP-5270, OTP-5323
Binary pattern matching such as
Own Id: OTP-5371
In rare cases, the code compiler code generate code for a tuple match that could crash the emulator if passed a term that was not a tuple.
If a bit syntax construction failed within a catch, previously assigned variables could get the wrong value.
The compiler now runs a validation pass on the generated code and aborts before writing a Beam file if any suspect code is found. In particular, the validation pass checks for incorrect code that may cause emulator crashes or other strange symptoms in the emulator.
Some corrections to the unsupported feature parameterized modules by Richard Carlsson (HiPE).
Own Id: OTP-5247 Aux Id: OTP-5235
Corrected the release note regarding
A few minor issues code generation issues were corrected. Although the generated code was correct, it was slightly slower and larger than it needed to be.
A debug printout (that could be seen in rare circumstances) has been removed.
New options
The
Corrected some bugs in the undocumented feature "parameterized modules".
Own Id: OTP-5198
When the undocumented feature "parameterized modules" was
used, the
Own Id: OTP-5224