aboutsummaryrefslogtreecommitdiffstats
path: root/lib/compiler
AgeCommit message (Collapse)Author
2012-11-26beam_bsm: Improve handling of bs_start_match2 instructionsBjörn Gustavsson
The handling of bs_start_match2 was both too conservative and too careless. It was too conservative in that would not do the optimization if the were copies of the match state in other registers. It was careless in that it did not consider the failure branch. Reorganize the code and fix both these issues. Add a test case to test that the failure branch is considered.
2012-11-26beam_utils: Improve is_not_used/3 for bit syntax matchingBjörn Gustavsson
2012-11-26beam_bsm: Make the optimization applicable in more circumstancesBjörn Gustavsson
When determining whether the delayed creation of sub-binaries optimizations is applicable, this module some tests whether the register containg the match state is killed. That is actually a stronger condition than necessary; since the register is initialized, it suffices to test whether the register is unused.
2012-11-26beam_jump: Move bs_context_to_binary/1 + exit instructionBjörn Gustavsson
Generate slightly smaller and faster code.
2012-11-23Merge branch 'maint'Björn-Egil Dahlberg
2012-11-23Update copyright yearsBjörn-Egil Dahlberg
2012-11-12Merge branch 'maint'Björn Gustavsson
* maint: Fix compiler crash for binary matching and a complicated guard
2012-11-07compiler tests: Correct error in receive_SUITE:groups/0Björn Gustavsson
Commit c4375a62cfaabfd8de757f59714623ba1a8cb915 added a parallel group, but incorrectly, so no test cases at all were run in receive_SUITE.
2012-11-06Fix compiler crash for binary matching and a complicated guardBjörn Gustavsson
The compiler would crash when attempting to compile a function head that did binary matching and had a complex expression using 'andalso' and 'not'. Noticed-by: José Valim
2012-10-23Correct typo in test suite nameBjörn Gustavsson
It should be beam_except_SUITE, since it tests the beam_except module (introduced in 726f6e4c7afe8ce37b30eedbebe583e7b9bfc51b).
2012-10-23compiler: Run testcases in parallelBjörn Gustavsson
Run testcases in parallel will make the test suite run slightly faster. Another reason for this change is that we want more testing of parallel testcase support in common_test.
2012-10-10beam_bsm: Handle calls slightly betterBjörn Gustavsson
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.
2012-10-10Break apart tail-recursive call instructionsBjörn Gustavsson
Somewhat reduce the code bloat by eliminating special cases.
2012-10-10Represent the 'send' instruction as a call_ext/2 instructionBjörn Gustavsson
Somewhat reduce code bloat.
2012-10-10Rewrite select_val and select_tuple_arity to a select instructionBjörn Gustavsson
Eliminate some code bloat.
2012-10-09Rewrite binary creation instructions to bs_init instructionsBjörn Gustavsson
Rewrite the five binary creation instructions to a bs_init instruction, in order to somewhat reduce code bloat.
2012-10-09Rewrite bs_add, bs_utf*_size to BIF instructions in optimizationsBjörn Gustavsson
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).
2012-10-09Rewrite bs_put* instructions to a generic bs_put instructionBjörn Gustavsson
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.
2012-10-09Refactor removal of unused labelsBjörn Gustavsson
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.
2012-10-09Introduce the mandatory beam_a and beam_z passesBjörn Gustavsson
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.
2012-10-09compile: Fix bug in selection of passesBjörn Gustavsson
2012-10-09beam_receive: Optimize receives using refs created by spawn_monitor/{1,3}Björn Gustavsson
2012-10-09compile: Give a friendler error message if a parse transform cannot be foundBjörn Gustavsson
Don't throw the parse tree in the face of the user. OTP-8707
2012-10-09beam_jump: Don't move a block which can be entered via a fallthroughBjörn Gustavsson
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.
2012-10-09beam_jump: Fix broken optimizationBjörn Gustavsson
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).
2012-10-09v3_kernel: Fix match code for matched out segment size in multiple clausesBjörn Gustavsson
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.
2012-10-09Improve binary matching of literalsBjörn Gustavsson
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.
2012-10-09v3_codegen: Combine adjacent bs_match_string instructionsBjörn Gustavsson
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.
2012-10-09beam_bool: Recognize more safe optimizationsBjörn Gustavsson
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".
2012-10-09beam_utils: Correct usage calculations for GC BIFs in blocksBjörn Gustavsson
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.
2012-10-09beam_utils:live_opt/1: Correct liveness calculation for 'try'Björn Gustavsson
The liveness at the failure label should be ignored, because if there is an exception, all x registers will be killed.
2012-10-09beam_utils: Extend live_opt/1 to recalculate live registers in allocsBjörn Gustavsson
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.
2012-10-09beam_utils: Check liveness in catches and try/catch blocksBjörn Gustavsson
Less conservative liveness analysis allows more optimizations to be applied (such as the ones in beam_bool).
2012-10-09v3_codegen: Clarify code generation for binary constructionBjörn Gustavsson
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.)
2012-10-09v3_codegen: Clean up comments and remove out-commented codeBjörn Gustavsson
2012-10-09v3_codegen: Don't duplicate the functionality of cg_reg_arg/2Björn Gustavsson
2012-09-04Merge tag 'OTP_R15B02'Björn-Egil Dahlberg
The R15B02 release
2012-09-03Prepare releaseOTP_R15B02Erlang/OTP
2012-08-31Merge branch 'maint'Björn-Egil Dahlberg
Conflicts: lib/diameter/autoconf/vxworks/sed.general xcomp/README.md
2012-08-31Update copyright yearsBjörn-Egil Dahlberg
2012-08-29Merge branch 'maint'Henrik Nord
2012-08-29Merge branch 'ta/docsmaint' into maintHenrik Nord
* ta/docsmaint: Fix various doc typos for R15B02 Fix various code typos for R15B02 OTP-10245
2012-08-24Merge branch 'maint'Fredrik Gustafsson
* maint: Fix the erlc -MP flag
2012-08-24Merge branch 'rc/fix-MP-compiler-flag/OTP-10211' into maintFredrik Gustafsson
2012-08-23Merge branch 'maint'Björn Gustavsson
* maint: compiler: Warn if the size of a binary segment is invalid
2012-08-23Merge branch 'bjorn/compiler/illegal-size/OTP-10197' into maintBjörn Gustavsson
* bjorn/compiler/illegal-size/OTP-10197: compiler: Warn if the size of a binary segment is invalid
2012-08-22Merge branch 'maint'Lukas Larsson
* maint: Revert "Merge branch 'nox/compile-column-numbers' into maint"
2012-08-22Revert "Merge branch 'nox/compile-column-numbers' into maint"Lukas Larsson
Column numbers was merged without understanding all the whole story. See mail on erlang-patches for details. This reverts commit df8e67e203b83f95d1e098fec88ad5d0ad840069, reversing changes made to 0c9d90f314f364e5b1301ec89d762baabc57c7aa.
2012-08-22compiler: Warn if the size of a binary segment is invalidBjörn Gustavsson
The compiler would silently accept and Dialyzer would crash on code like: <<X:(2.5)>> It is never acceptable for Dialyzer to crash. The compiler should at least generate a warning for such code. It is tempting to let the compiler generate an error, but that would mean that code like: Sz = 42.0, <<X:Sz>>. would be possible to compile with optimizations disabled, but not with optimizations enabled. Dialyzer crashes because it calls cerl:bitstr_bitsize/1, which crashes if the type of size for the segment is invalid. The easiest way to avoid that crash is to extend the sanity checks in v3_core to also include the size field of binary segments. That will cause the compiler to issue a warning and to replace the bad binary construction with a call to erlang:error/1. (It also means that Dialyzer will not issue a warning for bad size fields.)
2012-08-17Remove support for tuple funsBjörn Gustavsson
Tuple funs were deprecated in R15B (in commit a4029940e309518f5500).