| Commit message (Collapse) | Author | Age | Files | Lines |
|---|
| ... | |
| |
|
|
|
|
| |
* share/txr/stdlib/optimize.tl (basic-blocks
thread-jumps-block): The two accidental occurrences of @reg
will never match each other: rename one to @dn.
|
| |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
* share/txr/stdlib/compiler.tl (compiler optimize): Perform
the control flow optimizations of jump threading and dead code
elimination first. Then, do the data-flow-assisted
optimizations on the re-calculated control flow graph.
With this, two more useless insructions are shaved off the
pattern matching Ackermann:
(defun ack (:match)
((0 @n) (+ n 1))
((@m 0) (ack (- m 1) 1))
((@m @n) (ack (- m 1) (ack m (- n 1)))))
It now compiles down to 16 instructions instead of 18;
and the speedup of (ack 3 7) versus interpreted goes
from 36.0 to 37.3 times.
The reason that the new reduction in the code is possible
is that previously, the code being analyzed was in separate
basic blocks, which are now merged together in the dead code
elimination pass.
* share/txr/stdlib/compiler.tl (compiler optimize): Move
calc-liveness and peephole after elim-dead-code.
|
| |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
After eliminating dead code and useless forward jumps, there
can be blocks which unconditionally proceed to subsequent
blocks, which have no other predecessor. These blocks can be
merged together. This currently does nothing to alter the
generated code. The advantage will be obvious in a subsequent
commit.
* share/txr/stdlib/optimize.tl (struct basic-block): New slot,
rlinks: reverse links.
(basic-blocks join-block): New method.
(basic-blocks link-graph): Populate rlinks slots.
(basic-blocks join-blocks): New method.
(basic-blocks elim-dead-code): Reset rlinks also before
re-calculating the graph connectivity with link-graph.
Call join-blocks to merge together consecutive blocks.
|
| |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
The optimizer relies too much on labels. The basic block graph
is linked via labels instead of directly, and the blocks
are maintained in order via a label list. Let's get rid
of this.
* share/txr/stdlib/optimize.tl (struct basic-blocks): Member
slot removed. Oh look, we have a list slot that is not
utilized at all; that will be used instead.
(basic-blocks :postinit): Don't calculate the bb.labels.
(basic-blocks get-insns): Loop over list instead of labels,
and get the .insns directly without label hash lookup.
(basic-blocks (cut-block, next-block)): Operate with and
return blocks instead of labels.
(basic-blocks link-graph): Link graph using direct pointers
rather than indirection through labels.
(basic-blocks calc-liveness): Get rid of small amount of label
indirection here.
(basic-blocks thread-jumps-block): Drop unused label argument.
Do some needed label hash lookups now to produce block
argument for cut-block and next-block methods.
(basic-blocks peephole-block): Several rules need to do some
hash lookup to work with cut-block and next-block, and
retrieve a needed label from a block.
(basic-blocks (peephole, thread-jumps)): Loops simplified, no
dealing with labels.
(basic-blocks elim-next-jump): Drop label argument,
use bl in call to next-block.
(basic-blocks elim-dead-code): Loops and recursion simplified
without label indirection.
|
| |
|
|
|
|
|
|
|
|
|
|
| |
* RELNOTES: Updated.
* configure, txr.1: Bumped version and date.
* share/txr/stdlib/ver.tl: Bumped.
* txr.vim, tl.vim: Regenerated.
* protsym.c: Likewise.
|
| |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
We cannot assume that a d register is has a non-nil value.
This is because d registers are exploited in the
implementation of load-time: the result of a load-time form is
stored by mutating a d register, and the value could be nil.
Since we still want to be able to assume that d registers
are non-nil, what we can do is just avoid that assumption for
those d regisers that are used for load-time values.
* share/txr/stdlib/compiler.tl (struct compiler): When
constructing basic-blocks, pass a new constructor argument:
the list of load-time d-regs. This is easily obtained by
mapping the load-time frags to their oreg slots, which are
those d-regs.
* share/txr/stdlib/optimize.tl (struct basic-blocks): New
slot and BOA constructor argument, lt-dregs.
(basic-blocks thread-jumps-block): Add a require to the
pattern (if (d @reg) @jlabel), that the register must not
be one of the load-time d-regs.
|
| |
|
|
|
|
|
|
|
|
|
|
|
|
| |
* share/txr/stdlib/copy-file.tl (package copy-file): Removed.
I cannot remember why I used this, but it was probably because
this source file was developed in "user space". Then it likely
became an experiment in the use of merge-delete-package to
define material in a temporary package which is merged down to
the ultimate target package like sys. Why get rid of this?
It's causing a problem. The second and subsequent recompile of
copy-path-rec causes its internal block not to be optimized
away. I spotted this while checking whether a recompile of the
library using the fully compiled library is different from
the initial compile: copy-path-rec's block is not optimized away.
|
| |
|
|
|
|
| |
* share/txr/stdlib/compiler.tl (compiler comp-setqf): When an
assignment to a function is compiled, we must register the
occurrence of a free function, not a free variable.
|
| |
|
|
|
|
|
|
|
| |
* share/txr/stdlib/optimize.tl (basic-blocks elim-next-jump):
New method, which detects that the basic block ends with a
(jmp label), where label is the next block in emit order.
This jmp instruction can be eliminated.
(basic-blocks elim-dead-code): Walk the reachable labels,
and call elim-next-jmp to remove useless jumps.
|
| |
|
|
|
|
|
|
|
| |
* share/txr/stdlib/optimize.tl (basic-blocks
thread-jumps-block): This is a complementary optimization to
the one which matches (if (d @reg) @jlabel). An if
instruction conditional on the nil register (t 0) is always
taken, and can be rewritten to a jmp. This can promote
elimination of dead code.
|
| |
|
|
|
|
|
|
|
|
|
| |
* share/txr/stdlib/compiler.tl (compiler optimize): Call new
elim-dead-code method on basic-blocks object.
* share/txr/stdlib/optimize.tl (basic-blocks elim-dead-code):
New method. We reset the links information for each basic
block and re-build the graph. Then we traverse it to determine
what blocks are reachable, and cull the original blocks list
of those that are not.
|
| |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
The register removal optimization now works for registers
initialized from variables. For instance
mov t13 v00000
mov t12 v00001
gcall t7 3 t13 d0
gcall t8 4 t12 t19
can, under the right conditions, be replaced with
gcall t7 3 v00000 d0
gcall t8 4 v00001 t19
where the useless copies of the v0 and v1 registers to
t13 and t12 are gone, and the refernces to those registers
are renamed to those v registers.
* share/txr/stdlib/optimize.tl (basic-blocks local-liveness):
We now use the def field of a live-info structure differently.
The def field holds a register, instead of a t register
number. For any instruction that defines a register, the
register is stored, whether it is v or t register.
(basic-blocks peephole-block): The rule is simplified and
extended to cover t-regs that receive a v-reg. A special
additional condition applies in this case: v-registers are
tied to a frame, and must not be accessed if their frame has ended.
Our optimization carries the risk that the variable was copied
into a register precisely for the purpose that the v register
is going out of scope, and the value is needed outside of the
frame. We don't have frame level information in the basic
block, so to be conservative, we guess like this: if any end
instructions occur (potentially ending a frame), and if the
register is used after an end instruction, then we don't do
the replacement.
* share/txr/stdlib/compiler.tl (compiler comp-catch): Remove
inappropriate jend. Control definitely flows past this
instruction, because we jump here in the case when no
exception has taken place to continue the program. This bug
has resulted in some blocks being declared unreachable by the
control flow graph construction, and thus not included in
register liveness calculations, resulting in having a nil
in the live slot. This was exposed by the new new
optimization.
|
| |
|
|
|
|
|
|
|
|
|
|
| |
The list-builder methods, other than del, del* and get,
now return the object instead of nil.
* share/txr/stdlib/build.tl (list-builder (add, add*, pend,
pend*, ncon, ncon*): Return the object, self.
(list-builder-flets): Do not return the object out of the
local functions which invoke the above methods.
* txr.1: Documented.
|
| |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
Using liveness information, if we are very careful about the
circumstances, we can can eliminate instructions of the form
mov tN src
and replace every subsequent occurrence of tN in the basic
block by src. For instance, simple case: if a function
ends with
mov t13 d5
end t13
that can be rewriten as
end d5
The most important condition is that t13 is not live on exit
from that basic block. There are other conditions. For now,
one of the conditions is that src cannot be a v register.
* share/txr/stdlib/optimize.tl (struct live-info): New slot,
def. This indicates which t register is being clobbered, if
any, by the instruction to which this info is attached.
(basic-blocks local-liveness): Adjust the propagation of the
defined info. If an instruction both consumes a register and
overwrites it, we track that as both a use and a definition.
We set up the def fields of live-info. We do that by mutation,
so we must be careful to copy the structure. The def field
pertains to just one instruction, but the same info can be
attached to multiple instructions.
(subst-preserve): New function.
(basic-blocks peephole-block): New optimization added.
Now takes a basic-block argument, bl.
(basic-blocks peephole): Pass bl to peephole-block.
|
| |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
The optimizer now calculates t liveness information for the t
registers. In every basic block, it now knows which t regs
are live on exit, and which are used in the block, at every
instruction.
One small optimization is based on this so far: the removal
of a move instruction targeting a dead register. This appears
stable.
* share/txr/stdlib/compiler.tl (compiler comp-unwind-protect):
The protected code of a uwprot must terminate with a regular
end instruction, rather than the jend pseudo-instruction.
This is because the clean-up block is executed after the
protected block and references values generated in it: t
registers are live between he pfrag and the cfrag. Without
this, the compile-file-conditionally function was wrongly
optimized, causing it to return false due to the setting of
the success flag (that having been moved into a t register)
having being optimized away.
(compiler optimize): Add the call the basic-blocks method
to calculate liveness.
* share/txr/stdlib/optimize.tl (struct live-info, struct
basic-block): New structure types. The basic-block
structure type now representes basic blocks instead of raw
lists.
(struct basic-blocks): New slots, root, li-hash.
(basic-blocks jump-ops): We add few instructions that
reference labels, just to be safe.
(basic-blocks :postinit): Refactor division into basic blocks
so that it generates basic-block objects instead of just lists
of instructions. Also, the new method link-graph is called
which analyzes the tail instructions of all the blocks to
determine connectivity and sets the next and links fields
of the objects to build a graph.
(basic-blocks (get-insns, cut-blocks)): Refactor for struct
represenation of basic blocks.
(basic-blocks (link-graph, local-liveness, calc-liveness): New
methods.
(basic-blocks thread-jumps-block): Refactor for struct
representation of basic blocks.
(basic-blocks peephole-blocks): Likewise, and new pattern for
removing moves into dead t-registers, assisted by liveness
information.
(basic-blocks (peephole, thread-jumps)): Refactor for
basic-blocks representation.
|
| |
|
|
|
|
|
|
|
|
|
|
|
|
| |
Compiling a form like
(caseq op ((a b c d e f g h i j k) 42)))
Results in a run-time error in the compiler, similar to:
list-vec: (#:l0048) is not of type vec
* share/txr/stdlib/compiler.tl (compiler comp-switch): Make
sure cases is also still a vector in the complex case when
it's not just a copy of cases-vec.
|
| |
|
|
|
|
|
| |
* share/txr/stdlib/optimize.tl (thread-jumps-block): Add
missing argument to close instruction pattern. This causes us
to miss a threading opportunity due to the new ntregs
parameter being mistaken for a label, which is not found.
|
| |
|
|
|
|
|
|
|
|
|
|
| |
* share/txr/stdlib/compiler.tl (compiler comp-arith-form):
Pass env to reduce-constant.
(compiler comp-fun-form): Likewise, and don't bother checking
%const-foldable% because reduce-constant does that again.
(compiler comp-apply-call): Pass env to reduce-constant.
(reduce-constant): Take env argument. If the function is
constant foldable, check that there is no lexical function
call binding shadowing it. If so, it's not the function we
think it is, and we must not constant-fold it.
|
| |
|
|
|
|
|
|
|
|
| |
* share/txr/stdlib/compiler.tl (compiler comp-apply-call):
Constant-fold the arguments. Check for special cases involving
call and route to regular function call.
(compiler comp-dwim): Don't wrap all arguments with
sys:lisp1-value, only those that are bindable symbols. This
way constant expressions, including keywords, t and nil, are
not wrapped, and detectable by constantp.
|
| |
|
|
|
|
|
|
| |
* share/txr/stdlib/compiler.tl (%const-foldable-funs%): Add
numerous eligible functions that are registered in eval.c. We
avoid anything with functional arguments, environmental
dependencies or anything that may be relied upon to produce a
fresh object.
|
| |
|
|
|
|
|
| |
* share/txr/stdlib/compiler.tl (%const-foldable-funs%): Add
all of the cadr, caddr, and other functions. Take out first
and second; these will be later added together with other
things that are being registered in eval.c.
|
| |
|
|
|
|
|
|
| |
* share/txr/stdlib/compiler.tl (%const-foldable-funs%): Add
most functions from arith module.
(%const-foldable%): New variable, hash built from list.
(compiler comp-fun-form, reduce-constant): Refer to
%const-foldable% hash instead of %const-foldable-funs% list.
|
| |
|
|
|
|
|
|
|
|
|
|
| |
* share/txr/stdlib/compiler.tl (%const-foldable-funs%): Add
pred, succ and their sisters.
* share/txr/stdlib/vm-param.tl (%max-lev-idx%, %max-v-lev%,
%max-sm-lev-idx%): Get rid of macro-time wrapping in
calculation, which are there for manual constant folding.
* share/txr/stdlib/asm.tl (with-lev-idx): Remove macro-time
providing manual constant folding.
|
| |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
Introducing folding of certain expressions that can be
evaluated at compile time, with some special handling for
common arithmetic functions, in which we can collapse
consecutive arguments that are constant integer expressions.
* share/txr/stdlib/compiler.tl (%const-foldable-funs%): New
global variable.
(compiler compile): Send multiplication and division through
new methods that that treat integer arguments.
(compiler comp-arith-form, compiler comp-neg-arith-form): New
methods.
(comp-fun-form): Apply constant folding to a proper function
call whose operator is listed in %const-foldable-funs%.
(reduce-constant): New function.
|
| |
|
|
|
|
|
| |
* share/txr/stdlib/compiler.tl (compiler comp-if): Recognize
the pattern (if (not (eq ...) ..), and convert to (if (neq
...) ...) and likewise for eql and equal. This is fed back to
comp-if, whereby it may be further reduced.
|
| |
|
|
|
|
| |
* share/txr/stdlib/compiler.tl (fixed-point): New macro.
(reduce-lisp): Hide irrelevant iteration details by using
fixed-point macro.
|
| |
|
|
|
| |
* share/txr/stdlib/compiler.tl (compiler comp-fun-form):
Reduce negated eq, eql, equal to neq, neql, nequal.
|
| |
|
|
|
| |
* share/txr/stdlib/compiler.tl (compiler comp-if): Support
reduction of nequal in the same way as equal.
|
| |
|
|
|
|
|
| |
* share/txr/stdlib/compiler.tl (reduce-lisp): Add one more
reduction case. There is a "hit" for this somewhere, because
even though this adds code, overall 200 bytes are saved over
the entire library.
|
| |
|
|
|
|
|
|
|
|
|
|
| |
The raw size of the library compiled files shrinks by over 2%
from this optimization, not to mention that some list
construction code is faster.
* share/txr/stdlib/compiler.tl (compiler comp-fun-form):
Reduce common list construction primitives via reduce-lisp
function which algebraically transforms to a form with fewer
function calls.
(reduce-lisp): New function.
|
| |
|
|
|
|
|
|
|
|
| |
* share/txr/stdlib/compiler.tl (compiler comp-if): Remove the
pointless cases which check for test being nil, since that is
subsumed under constantp. Move all the constantp cases up,
making them match-case clauses. The handling of %test-funs%
in several places becomes a single pattern case. The remaining
cases don't have any more sub-cases to test, so the cond
forms are gone.
|
| |
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
Here, we look for (equal x y) expressions that can be reduced
to (eql x y) or (eq x y) and compiled that way. Also, we
look for (if (equal x y) ...) expressions that can be turned
into (if (eql x y) ...) or (if (eq x y) ...) which then
compile into ifq or ifql instructions.
* share/txr/stdlib/compiler.tl (compiler comp-if): Convert
tree-case into match case, and then handle the
(if (equal ...)) pattern.
(comp-fun-form): Add recognition for (equal x y) expressions,
and reduce their strength, if possible.
(eq-comparable, eql-comparable): New functions.
|
| |
|
|
|
|
|
|
|
|
| |
* share/txr/stdlib/optimize.tl (basic-blocks
thread-jumps-block): We want a set here, not a pset, otherwise
we are processing the old-instruction again rather than
iterating. This breaks jump threading where multiple
iterations are required to get to the ultimate target. It
showed up as a difference in the compiled image of the
sys:compile-match function.
|
| |
|
|
|
| |
* share/txr/stdlib/compiler.tl (compiler comp-fun-form):
Rewritten more compactly and extensibly using match-case.
|
| |
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
Jump threading just needs to looks at the last instruction in
a basic blocks now; it's a waste of cycles to be pattern
matching on jump intruction patterns while peephole scanning.
* share/txr/stdlib/compiler.tl (compiler optimize): Invoke
new thread-jumps after peephole.
* share/txr/stdlib/optimize.tl (basic-blocks
thread-jumps-block): New method.
(basic-blocks peephole-block): Remove jump-threading cases;
they are in thread-jumps block.
(basic-blocks thread-jumps): New method.
|
| |
|
|
|
|
|
|
| |
* share/txr/stdlib/optimize.tl (basic-blocks peephole-block):
Remove the special optimization involving an unconditional
jump followed by an if, to a block which tests the same
register with another if. This optimization can't match
because a jmp and if cannot be in a basic block together.
|
| |
|
|
|
|
|
|
|
|
|
| |
* share/txr/stdlib/optimize.tl (basic-blocks peephole-block):
If we move a frame instruction past a jump into the next
block, we must add that block's label to the rescan list.
There may be an opportunity to propagate the frame instruction
deeper into that block. I'm not seeing a difference from this
change in the compilation of the standard library, which
indicates that this is happening by fluke; the alteration of
that block is happening before it has been visited.
|
| |
|
|
|
|
|
|
| |
* share/txr/stdlib/optimize.tl (struct basic-blocks): Include
the close instruction in the set which terminate a basic
block. A close is an unconditional jump; execution never
continues after a close instruction, but goes unconditionally
to a branch target.
|
| |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
If cut-block is called during peephole optimization, it can
introduce blocks that can be missed, in which there might be
some opportunity for peephole reduction. Let's keep track
of newly added blocks in a re-scan list.
* share/txr/stdlib/optimize.tl (struct basic-blocks): New
slot, rescan.
(basic-blocks cut-block): Add new block's label to
rescan list.
(basic-blocks peephole-block): New method, formed out of the
bulk of basic-blocks peephole.
(basic-blocks peephole): After processing the blocks from
the hash table, iterate on the rescan list.
|
| |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
* share/txr/stdlib/optimize.tl (struct basic-blocks):
jump-ops, new static member.
(basic-blocks :postinit): Cut the code into basic blocks
rather than extended basic blocks. This means that the
insruction which follows every jumping instructions is now a
block leader. Every block needs a label, so we add them.
(basic-blocks peephole): The optimization which slides a frame
instruction past a jump must be refactored to move the frame
instruction into the next block. Firstly, moving anything
past a jump instruction is no longer allowed, because the
result is no longer a basic block. Secondly, doing so prevents
further frame movements, because the block no longer has any
instructions after the jump over which the frame can be moved.
|
| |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
The jend pseudo-instruction is a simple alias for end. It
indicates a jumping end: an end that does not fall through to
the next instruction but could go somewhere else.
This is for "future correctness" as well as clarity. The
difference is important in analysis of code into basic blocks.
Currently this won't make a difference because all the jend
instructions except for the one at the end of compiled
top-level form are followed by a label which kicks off a basic
block anyway.
* share/txr/stdlib/asm.tl (defopcode-alias): New macro.
(jend): New opcode, defined as alias for end.
* share/txr/stdlib/compiler.tl (comp-unwind-protect,
comp-lambda-impl, compile-toplevel): Use jend instruction for
a jumping end: the one after the protected code block of a
uwprot, the one at the end of a function, and the one at the
end of a top-level form.
|
| |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
Since we have are breaking binary compatibility in the
upcoming TXR 252, we might as well take the opportunity to
remove deprecated opcodes that the compiler doesn't use.
* share/txr/stdlib/asm.tl (op-fin): Opcode removed.
(op-pprof): Derive directly from op-end rather than op-fin.
(op-movrsi, op-movsmi, op-movrbi, op-movi-pseudo): Opcodes
removed.
* vm.c (vm_fin, vm_movrsi, vm_movsmi, vm_movrbi): Functions
removed.
(vm_execute): FIN, MOVRSI, MOVSMI, MOVRBI cases removed.
* vmop.h: Regenerated.
(vm_op_t): Enum members FIN, MOVRSI, MOVSMI, MOVRBI removed.
|
| |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
The block elimination logic doesn't work for self-recursive
functions, even if they invoke no block returning, and use
only system functions that don't have anything to do with
block returns. This is because the recursive call is not
recognized, and treated as a call to an unknown function.
Let's put in a simple hack. The defun and defmacro operators
will use a new secret special operator called sys:blk instead
of block to generate the block. The compilation of sys:blk
will assume that (sys:blk name ...) is only used in a defun or
defmacro by that same name, and include name in the list of OK
functions.
So that functions created using the interpreter and then
dynamically compiled will also benefit, we add this operator
to the interpreter.
* eval.c (sys_blk_s): New symbol variable.
(op_defun): For defun and defmacro, use sys:blk for the block
for the block
(eval_init): Initialize sys_blk_s with the interned symbol
sys:blk. Register the sys:blk operator.
* share/txr/stdlib/compiler.tl (compiler compile): Recognize
the sys:blk special form and handle via comp-block.
(comp-block): If sys:blk is being compiled, then include the
block name in the list of functions that do not perform block
returns. (If this is false, other checks will fail before use
that.)
(expand-defun): Use sys:blk for defun and defmacro.
|
| |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
Closures do not share t-registers with surrounding code; they
do not store a value into such a register that code outside
the closure would read and vice versa.
When compiling closures, we can can temporarily reset the
compiler's t-register allocator machinery to get low
t-register values. Then, when executing the closure, we
reserve space just for the registers it needs, not based off
the containing vm description.
Here we make a backwards-incompatible change. The VM close
instruction needs an extra parameter indicating the number of
t-regisers. This is stored into the closure and used for
allocating the frame when it is dispatched.
* parser.c (read_file_common): We read nothing but version 6
tlo files now.
* share/txr/stdlib/asm.tl (op-close asm): Parse new ntreg
argument from close syntax, and put it out as an extra word.
Here is where we pay for this improvement in extra code size.
(op-close dis): Extract the new argument from the machine code
and add it to the disassembled format.
* share/txr/stdlib/compiler.tl (compile-in-toplevel): Save and
restore the t-reg discards list also. Don't bother with a
gensym for the compiler; the argument is always a symbol,
which we can use unhygienically like in with-var-spy.
(compile-with-fresh-tregs): New macro based on
compile-in-toplevel: almost the same but doesn't reset the
level.
(comp-lambda-impl): Use compile-with-fresh-tregs to compile
the entire closure with a minimized register set.
Place the treg-cntr into the closure instruction to indicate
the number of registers the closure requires.
* vm.c (struct vm): New member, nreg.
(vm_make_closure): New parameter, nreg, stored into the
closure.
(vm_close): Extract a third opcode word, and pull the nreg
value from the bottom half. Pass this to vm_make_closure.
(vm_execute_closure, vm_funcall_common): Calculate frame size
based on the closur's nreg rather than the VM description's.
* txr.1: Document that the upcoming version 252 produces
version 6.0 object files and only loads version 6.
|
| |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
This optimization identifies let blocks whose variables are
not captured by closures. The variables are relocated to
registers and the frame M N ... end reg wrapping is removed.
* parser.c (read_file_common): Load version 6 files.
We remain backwards-compatible.
* share/txr/stdlib/compiler.tl (var-spy, capture-var-spy): New
structure types.
(struct compiler): New slot, var-spies.
(with-var-spy): New macro.
(compiler (alloc-new-treg, unalloc-reg-count, push-var-spy,
pop-var-spy)): New methods.
(compiler (comp-atom, compt-setq, comp-list-setq,
comp-lisp1-value)): Inform the spies in the spy notification
stack about assignments and accesses.
(compiler eliminate-frame): New method.
(compiler comp-let): Use spies to determine which variables
from this frame are captured, and if none are, then use
eliminate-frame to rename all the variables to t-registers and
drop the frame setup/teardown.
(compiler comp-lambda): Set up a capture-var-spy which
intercepts accesses and assignments within a lambda, and
informs other spies about the captures.
(%tlo-ver%): Bump compiled file version to to (6 0), because
of some behavioral changes necessary in the VM. We might
revert this if the issues are solved differently.
* vm.c (vm_getz): Do not null out T registers.
(vm_execute_toplevel, vm_execute_closure): Use zalloca to
allocate the register part of the frame, so T registers are
initialized to nil.
|
| |
|
|
|
|
|
| |
* share/txr/stdlib/optimize.tl (dedup-labels): Use
rewrite-case macro defined in the same file instead of
rewrite/lambda/match-case. Also change two-argument list*
to cons.
|
| |
|
|
|
|
|
|
|
|
|
|
|
| |
Bad test case:
(unwind-protect 42 1 2 3) -> 3 ;; should be 42
* share/txr/stdlib/compiler.tl (compile comp-unwind-protect):
In the case when the protected code compiles to zero code,
because it is a simple variable or constant, the code that
we return must still nominate the that fragment's output
register as its output, and not the output register of the
cleanup forms.
|
| |
|
|
|
|
| |
* share/txr/stdlib/match.tl (compile-hash-match): Use
mac-param-bind instead of tree-bind, like in the other
functions.
|
| |
|
|
|
|
| |
* share/txr/stdlib/optimize.tl (basic-blocks peephole): Rename
jlabel3 variable to jlabel2, so it is in sequence after
jlabel0 and jlabel1.
|
| |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
Until now, the obj.[fun ...] syntax has uselessly denoted
exactly the same thing as [obj.fun ...]. This latter syntax
is what should be used for that meaning.
The new meaning of obj.[fun ...] will be that it performs
method dispatch, where obj is passed to obj.fun as
the leftmost argument: obj.[fun ...] is [obj.fun obj ...],
with obj evaluated once.
* share/txr/stdlib/struct.tl (qref): Expansion change done
here, with backward compat switch.
* share/txr/stdlib/termios.tl (termios (go-raw, go-cbreak)):
Some a.[b c] turned to [a.b c] here.
* tests/012/oop.tl (animal print): Likewise.
* tests/012/struct.tl: Likewise, and some expansion tests
updated to reflect the new expansion.
* txr.1: Documentation revised in multiple places and compat
note added.
|
