aboutsummaryrefslogtreecommitdiffstats
path: root/lib/compiler/src
AgeCommit message (Collapse)Author
2019-06-10beam_ssa_type: Fix incorrect bitstring unit determinationJohn Högberg
The compiler would treat the "Unit" of bs_init instructions as the unit of the result instead of the required unit of the input, causing is_binary checks to be wrongly optimized away.
2019-05-29Merge branch 'bjorn/compiler/fix-beam_ssa_dead-patch/OTP-15845' into maint-22Erlang/OTP
* bjorn/compiler/fix-beam_ssa_dead-patch/OTP-15845: Fix unsafe optimizations where guard tests could be removed
2019-05-29Merge branch ↵Erlang/OTP
'bjorng_ghub/bjorn/compiler/fix-beam_ssa_dead-crash/ERL-956/OTP-15848' into maint-22 * bjorng_ghub/bjorn/compiler/fix-beam_ssa_dead-crash/ERL-956/OTP-15848: Eliminate crash in the beam_ssa_dead compiler pass
2019-05-29Merge branch 'bjorn/compiler/fix-unloadable-code-patch/ERL-955/OTP-15846' ↵Erlang/OTP
into maint-22 * bjorn/compiler/fix-unloadable-code-patch/ERL-955/OTP-15846: Fix loading of Core Erlang code for extracting a map element
2019-05-29Merge branch 'bjorn/compiler/fix-beam_except/ERL-954/OTP-15839' into maint-22Erlang/OTP
* bjorn/compiler/fix-beam_except/ERL-954/OTP-15839: Fix compiler crash in beam_except
2019-05-29Merge branch 'bjorn/compiler/fix-unsafe-type-inference/OTP-15838' into maint-22Erlang/OTP
* bjorn/compiler/fix-unsafe-type-inference/OTP-15838: Fix unsafe negative type inference # Conflicts: # lib/compiler/src/beam_ssa_type.erl
2019-05-29Merge branch 'john/compiler/list_append_type/OTP-15841' into maint-22Erlang/OTP
* john/compiler/list_append_type/OTP-15841: compiler: Fix broken type for erlang:'++'/2
2019-05-29Merge branch 'bjorn/compiler/fix-receive-patch/ERL-950/OTP-15832' into maint-22Erlang/OTP
* bjorn/compiler/fix-receive-patch/ERL-950/OTP-15832: Eliminate compiler crash when compiling complex receive statements
2019-05-28Fix unsafe optimizations where guard tests could be removedBjörn Gustavsson
A repeated test could be optimized away. Example: bar(A) -> if is_bitstring(A) -> if is_binary(A) -> binary; true -> bitstring end; true -> other end. In the example, the `is_binary/1` test would be optimized away, basically turning the example into: bar(A) -> if is_bitstring(A) -> bitstring; true -> other end. Thanks user Marcus Kruse in the Elixir forum for noticing this bug.
2019-05-28Eliminate crash in the beam_ssa_dead compiler passBjörn Gustavsson
The compiler could crash in the beam_ssa_dead pass while compiling complex nested `case` expressions. See the added test case for an example and explanation. https://bugs.erlang.org/browse/ERL-956
2019-05-27Fix compiler crash in beam_exceptBjörn Gustavsson
The compiler would crash in `beam_except` while compiling this function: bar(Req) -> ok = case Req of "POST" -> {error, <<"BAD METHOD ", Req/binary>>, Req}; _ -> ok end. https://bugs.erlang.org/browse/ERL-954
2019-05-27compiler: Fix broken type for erlang:'++'/2John Högberg
2019-05-27Fix loading of Core Erlang code for extracting a map elementBjörn Gustavsson
The following Core Erlang code could not be loaded: 'f'/1 = fun (_1) -> case <_1> of <~{'foo':='foo'}~> when 'true' -> _1 end Loading would fail with the following message: beam/beam_load.c(2314): Error loading function example:f/1: op i_get_map_element_hash p x a u x: no specific operation found https://bugs.erlang.org/browse/ERL-955
2019-05-24Fix unsafe negative type inferenceBjörn Gustavsson
The type optimizer pass (`beam_ssa_type`) could make unsafe negative inferences. That is, incorrectly infer that a variable could *not* have a particular type. This bug was found when adding another optimization. It is not clear how write a failing test case without that added optimization.
2019-05-21Eliminate compiler crash when compiling complex receive statementsBjörn Gustavsson
Certain complex receive statements would result in an internal compiler failure. That would happen when the compiler would fail to find the common exit block following a receive. See the added test case for an example. https://bugs.erlang.org/browse/ERL-950
2019-05-20Fix non-terminating compilationBjörn Gustavsson
The compiler would not terminate while compiling the following code: foo(<<N:32>>, Tuple, NewValue) -> _ = element(N, Tuple), setelement(N, Tuple, NewValue). The type analysis pass would attempt to construct a huge list when attempting analyse the type of `Tuple` after the call to `setelement/3`. https://bugs.erlang.org/browse/ERL-948
2019-04-30Merge branch 'john/compiler/fix-missing-match-reposition/ERL-923'John Högberg
* john/compiler/fix-missing-match-reposition/ERL-923: compiler: Propagate match context position on fail path
2019-04-29compiler: Propagate match context position on fail pathJohn Högberg
2019-04-23beam_validator: Don't infer types for dead valuesJohn Högberg
2019-04-15Optimize encoding of simple literalsBjörn Gustavsson
`beam_asm` would encode `{literal,[]}`, `{literal,erlang}`, and `{literal,42}` in a less efficient way than the equivalent values `nil`, `{atom,erlang}`, and `{integer,42}`. That would increase the size of BEAM files and could increase the loaded code size. It would probably not harm performance, because `literal` was only used this way in code that generates `badmatch` and `case_clause` exceptions.
2019-04-10compiler: Add missing header dependenciesJohn Högberg
2019-04-04cerl_clauses: Fix broken linkBjörn Gustavsson
2019-03-28compile: Add some types to core_parse.hrlHans Bolinder
The core_parse.hrl can be used in applications with the +warn_untyped_record compiler flag.
2019-03-28compiler: Fix documentation of cerl:c_binary/1Hans Bolinder
2019-03-28Merge branch 'bjorn/compiler/cuddle-with-tests'Björn Gustavsson
* bjorn/compiler/cuddle-with-tests: Verify the highest opcode for the r21 test suites Add test_lib:highest_opcode/1 sys_core_fold: Simplify case_expand_var/2 beam_validator: Remove uncovered lines in lists_mod_return_type/3 Cover return type determination of lists functions
2019-03-26compiler: Fully disable no_return optimizations in try blocksJohn Högberg
Validation could fail when a function that never returned was used in a try block (see attached test case). It's possible to solve this without disabling the optimization as the generated code is sound, but I'm not comfortable making such a large change this close to the OTP 22 release.
2019-03-25sys_core_fold: Simplify case_expand_var/2Björn Gustavsson
5239eb0c62a9 stopped storing patterns that a variable has matched. The only tuples that are stored in the type database are tuples that have been previously constructed. Therefore, the code in sys_core_fold:case_expand_var/2 and friends that converts a tuple pattern to a tuple construction can be simplified to used the stored tuple directly.
2019-03-25beam_validator: Remove uncovered lines in lists_mod_return_type/3Björn Gustavsson
Don't bother infering the return types for lists function that beam_ssa_type does not handle.
2019-03-21Merge branch 'bjorn/hipe-compilation/OTP-15596'Björn Gustavsson
* bjorn/hipe-compilation/OTP-15596: HiPE: Don't fail the compilation for unimplemented instructions
2019-03-20HiPE: Don't fail the compilation for unimplemented instructionsBjörn Gustavsson
2019-03-18beam_validator: Infer types on both sides of '=:='John Högberg
2019-03-08beam_ssa_opt: Fix crash in ssa_opt_floatJohn Högberg
For reasons better explained in the source code, ssa_opt_float skips optimizing inside guards but it failed to do so consistently; while the pass never processed guard blocks, it was still possible to erroneously defer error checking to a guard block, crashing the compiler once it realized its state was invalid.
2019-03-06beam_validator: Express test_arity/is_tagged_tuple as type testsJohn Högberg
This ensures that unreachable branches are properly ignored on repeated checks (although tuple type subtraction isn't complete yet).
2019-03-06beam_validator: Fix type subtraction on select_* and inequalityJohn Högberg
Type subtraction never resulted in the 'none' type, even when it was obvious that it should. Once that was fixed it became apparent that inequality checks also fell into the same subtraction trap that the type pass warned about in a comment. This then led to another funny problem with select_val, consider the following code: {bif,'>=',{f,0},[{x,0},{integer,1}],{x,0}}. {select_val,{x,0},{f,70},{list,[{atom,false},{f,69}, {atom,true},{f,68}]}}. The validator knows that '>=' can only return a boolean, so once it has subtracted 'false' and 'true' it killed the state because all all valid branches had been taken, so validation would crash once it tried to branch off the fail label.
2019-03-05beam_validator: Style fix for asserts in list comprehensionsJohn Högberg
2019-03-05beam_validator: Infer types from bs_put instructionsJohn Högberg
2019-03-05beam_validator: is_map no longer needs special treatmentJohn Högberg
2019-03-05beam_validator: Refactor type conflict resolutionJohn Högberg
The current type conflict resolution works well for the example case in the comment, but doesn't handle branched code properly, consider the following: {label,2}. {test,is_tagged_tuple,{f,ignored},[{x,0},3,{atom,r}]}. {allocate_zero,2,1}. {move,{x,0},{y,0}}. %% {y,0} is known to be {r, _, _} now. {get_tuple_element,{x,0},2,{x,0}}. {'try',{y,1},{f,3}}. %% ... snip ... {jump,{f,5}}. {label,3}. {try_case,{y,1}}. %% {x,0} is the error class (an atom), {x,1} is the error term. {test,is_eq_exact,{f,ignored},[{x,0},{y,0}]}. %% ... since tuples and atoms can't meet, the type of {y,0} is %% now {atom,[]} because the current code assumes the type %% we're updating with. {move,{x,1},{x,0}}. {jump,{f,5}}. {label,5}. %% ... joining tuple (block 2) and atom (block 3) means 'term', %% so the get_tuple_element instruction fails to validate %% despite this being unrechable from block 3. {test_heap,3,1}. {get_tuple_element,{y,0},1,{x,1}}. {put_tuple2,{x,0},{list,[{x,1},{x,0}]}}. {deallocate,2}. return. This commit kills the state on type conflicts, making unreachable instructions truly unreachable.
2019-03-05beam_validator: Refactor branch handlingJohn Högberg
While complex_test made certain branching instructions a lot easier to read, we're still using `branch_state` for many others which is hard to read and makes it impossible to "abort" branches on type conflicts. This commit replaces nearly all uses of `branch_state` with a general branching mechanism, improving readability and paving the way for proper type conflict resolution.
2019-03-04beam_validator: Fix element/2 BIF handlingJohn Högberg
The element type can not be extracted before the tuple type has been updated.
2019-03-04beam_validator: Rename get_move_term_type and clean up get_raw_typeJohn Högberg
2019-03-04Merge pull request #2168 from josevalim/jv-v3_kernel-binary-allBjörn Gustavsson
Move size=all binary clause pruning to v3_kernel
2019-03-04Merge pull request #2167 from bjorng/bjorn/tune-beamBjörn Gustavsson
Tune BEAM instructions for the new compiler (part 1)
2019-03-04Merge pull request #2166 from bjorng/bjorn/compiler/fix-slow-beam_ssa_deadBjörn Gustavsson
Optimize the beam_ssa_dead sub pass
2019-03-01Move size=all binary clause prunning to v3_kernelJosé Valim
The advantage of moving it up is that it reduces the size of the code emitted by v3_kernel, speeding v3_kernel itself and beam_kernel_to_ssa pass.
2019-03-01Optimize v3_kernel for thousands of clausesJosé Valim
Prior to this patch, v3_kernel would do multiple passes on the clauses to group them. This commit unrolls those passes, making v3_kernel up to 10% faster in those cases.
2019-03-01Add a comment about the time complexity of beam_ssa_deadBjörn Gustavsson
2019-03-01Pass the from node as a function argument instead of in a mapBjörn Gustavsson
This is cleaner and slightly faster.
2019-03-01Do some minor optimizations of compilation timesBjörn Gustavsson
The general complexity of the shortcut sub pass of `beam_ssa_dead` is quadratic, but those optimizations will reduce the constant factor somewhat.
2019-03-01Keep the set of unset variables as small as possibleBjörn Gustavsson
Refactor the code to avoid putting any variable from a skippable block into the set of unset variables. Keeping the set of unset variables as small as possible will make beam_ssa_dead almost twice as fast when compiling lib/unicode/tokenizer.ex in elixir.
generated by cgit v1.2.3 (git 2.25.1) at 2024-11-16 15:23:03 +0000