Skip to content

Commit 5a4afeb

Browse files
levno-710levno-710
committed
Add new expression kinds to compiler
1 parent f267004 commit 5a4afeb

File tree

1 file changed

+112
-62
lines changed

1 file changed

+112
-62
lines changed

‎src/prometheus/compiler/compiler.lua‎

Lines changed: 112 additions & 62 deletions
Original file line numberDiff line numberDiff line change
@@ -4,7 +4,7 @@
44
-- This Script contains the new Compiler
55

66
-- The max Number of variables used as registers
7-
local MAX_REGS = 100;
7+
local MAX_REGS = 40;
88

99
local Compiler = {};
1010

@@ -25,6 +25,7 @@ function Compiler:new()
2525
};
2626
activeBlock = nil;
2727
registersForVar = {};
28+
usedRegisters = 0;
2829
maxUsedRegister = 0;
2930
registerVars = {};
3031

@@ -48,7 +49,6 @@ function Compiler:new()
4849
AstKind.MulExpression,
4950
AstKind.DivExpression,
5051
AstKind.ModExpression,
51-
AstKind.NegateExpression,
5252
AstKind.PowExpression,
5353
}
5454
};
@@ -78,12 +78,12 @@ function Compiler:setActiveBlock(block)
7878
self.activeBlock = block;
7979
end
8080

81-
function Compiler:addStatement(statement, writes, reads, doNotMove)
81+
function Compiler:addStatement(statement, writes, reads, usesUpvals)
8282
table.insert(self.activeBlock.statements, {
8383
statement = statement,
8484
writes = lookupify(writes),
8585
reads = lookupify(reads),
86-
doNotMove = doNotMove or false,
86+
usesUpvals = usesUpvals or false,
8787
});
8888
end
8989

@@ -93,6 +93,7 @@ function Compiler:compile(ast)
9393
self.activeBlock = nil;
9494
self.registersForVar = {};
9595
self.maxUsedRegister = 0;
96+
self.usedRegisters = 0;
9697
self.registerVars = {};
9798

9899

@@ -200,52 +201,51 @@ function Compiler:emitContainerFuncBody()
200201
-- Shuffle Blockstats
201202
for i = 2, #blockstats do
202203
local stat = blockstats[i];
203-
if not stat.doNotMove then
204-
local reads = stat.reads;
205-
local writes = stat.writes;
206-
local maxShift = 0;
207-
for shift = 1, i - 1 do
208-
local stat2 = blockstats[i - shift];
209-
210-
if stat2.doNotMove then
204+
local reads = stat.reads;
205+
local writes = stat.writes;
206+
local maxShift = 0;
207+
local usesUpvals = stat.usesUpvals;
208+
for shift = 1, i - 1 do
209+
local stat2 = blockstats[i - shift];
210+
211+
if stat2.usesUpvals and usesUpvals then
212+
break;
213+
end
214+
215+
local reads2 = stat2.reads;
216+
local writes2 = stat2.writes;
217+
local f = true;
218+
219+
for r, b in pairs(reads2) do
220+
if(writes[r]) then
221+
f = false;
211222
break;
212223
end
224+
end
213225

214-
local reads2 = stat2.reads;
215-
local writes2 = stat2.writes;
216-
local f = true;
217-
218-
for r, b in pairs(reads2) do
226+
if f then
227+
for r, b in pairs(writes2) do
219228
if(writes[r]) then
220229
f = false;
221230
break;
222231
end
223-
end
224-
225-
if f then
226-
for r, b in pairs(writes2) do
227-
if(writes[r]) then
228-
f = false;
229-
break;
230-
end
231-
if(reads[r]) then
232-
f = false;
233-
break;
234-
end
232+
if(reads[r]) then
233+
f = false;
234+
break;
235235
end
236236
end
237+
end
237238

238-
if not f then
239-
break
240-
end
241-
242-
maxShift = shift;
239+
if not f then
240+
break
243241
end
244242

245-
local shift = math.random(0, maxShift);
246-
for j = 1, shift do
243+
maxShift = shift;
244+
end
245+
246+
local shift = math.random(0, maxShift);
247+
for j = 1, shift do
247248
blockstats[i - j], blockstats[i - j + 1] = blockstats[i - j + 1], blockstats[i - j];
248-
end
249249
end
250250
end
251251

@@ -304,11 +304,13 @@ end
304304

305305
function Compiler:freeRegister(id, force)
306306
if force or not (self.registers[id] == self.VAR_REGISTER) then
307+
self.usedRegisters = self.usedRegisters - 1;
307308
self.registers[id] = false
308309
end
309310
end
310311

311312
function Compiler:allocRegister(isVar, isUpval)
313+
self.usedRegisters = self.usedRegisters + 1;
312314

313315
-- POS register can be temporarily used
314316
if not isVar and not self.registers[self.POS_REGISTER] then
@@ -323,9 +325,15 @@ function Compiler:allocRegister(isVar, isUpval)
323325
end
324326

325327
local id = 0;
326-
repeat
327-
id = id + 1;
328-
until not self.registers[id];
328+
if self.usedRegisters < MAX_REGS * 0.75 then
329+
repeat
330+
id = math.random(1, MAX_REGS - 1);
331+
until not self.registers[id];
332+
else
333+
repeat
334+
id = id + 1;
335+
until not self.registers[id];
336+
end
329337

330338
if id > self.maxUsedRegister then
331339
self.maxUsedRegister = id;
@@ -483,6 +491,16 @@ function Compiler:jmp(scope, to)
483491
end
484492

485493
function Compiler:setPos(scope, val)
494+
if not val then
495+
local v;
496+
if math.random(1, 2) == 1 then
497+
v = Ast.NilExpression();
498+
else
499+
v = Ast.BooleanExpression(false);
500+
end
501+
scope:addReferenceToHigherScope(self.containerFuncScope, self.posVar);
502+
return Ast.AssignmentStatement({Ast.AssignmentVariable(self.containerFuncScope, self.posVar)}, {v});
503+
end
486504
scope:addReferenceToHigherScope(self.containerFuncScope, self.posVar);
487505
return Ast.AssignmentStatement({Ast.AssignmentVariable(self.containerFuncScope, self.posVar)}, {Ast.NumberExpression(val) or Ast.NilExpression()});
488506
end
@@ -513,7 +531,7 @@ function Compiler:compileTopNode(node)
513531
if(self.activeBlock.advanceToNextBlock) then
514532
self.activeBlock.advanceToNextBlock = false;
515533
self:addStatement(self:setPos(self.activeBlock.scope, nil), {self.POS_REGISTER}, {}, false);
516-
self:addStatement(self:setReturn(self.activeBlock.scope, Ast.TableConstructorExpression({})), {self.RETURN_REGISTER}, {})
534+
self:addStatement(self:setReturn(self.activeBlock.scope, Ast.TableConstructorExpression({})), {self.RETURN_REGISTER}, {}, false)
517535
end
518536

519537
self:resetRegisters();
@@ -551,7 +569,7 @@ function Compiler:compileStatement(statement, funcDepth)
551569
self:freeRegister(reg, false);
552570
end
553571

554-
self:addStatement(self:setReturn(scope, Ast.TableConstructorExpression(entries)), {self.RETURN_REGISTER}, regs, true);
572+
self:addStatement(self:setReturn(scope, Ast.TableConstructorExpression(entries)), {self.RETURN_REGISTER}, regs, false);
555573
self.activeBlock.advanceToNextBlock = false;
556574
self:addStatement(self:setPos(self.activeBlock.scope, nil), {self.POS_REGISTER}, {}, false);
557575

@@ -582,7 +600,7 @@ function Compiler:compileStatement(statement, funcDepth)
582600
self:freeRegister(exprregs[i], false);
583601
end
584602

585-
self:addStatement(self:copyRegisters(scope, varregs, exprregs), varregs, exprregs);
603+
self:addStatement(self:copyRegisters(scope, varregs, exprregs), varregs, exprregs, false);
586604
return;
587605
end
588606

@@ -597,7 +615,7 @@ function Compiler:compileStatement(statement, funcDepth)
597615
table.insert(argRegs, self:compileExpression(expr, funcDepth, 1)[1]);
598616
end
599617

600-
self:addStatement(self:setRegister(scope, retReg, Ast.FunctionCallExpression(self:register(scope, baseReg), self:registerList(scope, argRegs))), {retReg}, {baseReg, argRegs}, true);
618+
self:addStatement(self:setRegister(scope, retReg, Ast.FunctionCallExpression(self:register(scope, baseReg), self:registerList(scope, argRegs))), {retReg}, {baseReg, unpack(argRegs)}, true);
601619
self:freeRegister(baseReg, false);
602620
self:freeRegister(retReg, false);
603621
for i, reg in ipairs(argRegs) do
@@ -618,8 +636,8 @@ function Compiler:compileStatement(statement, funcDepth)
618636
table.insert(argRegs, self:compileExpression(expr, funcDepth, 1)[1]);
619637
end
620638

621-
self:addStatement(self:setRegister(scope, tmpReg, Ast.StringExpression(statement.passSelfFunctionName)), {tmpReg}, {});
622-
self:addStatement(self:setRegister(scope, tmpReg, Ast.IndexExpression(self:register(scope, baseReg), self:register(scope, tmpReg))), {tmpReg}, {tmpReg, baseReg});
639+
self:addStatement(self:setRegister(scope, tmpReg, Ast.StringExpression(statement.passSelfFunctionName)), {tmpReg}, {}, false);
640+
self:addStatement(self:setRegister(scope, tmpReg, Ast.IndexExpression(self:register(scope, baseReg), self:register(scope, tmpReg))), {tmpReg}, {tmpReg, baseReg}, false);
623641

624642
self:addStatement(self:setRegister(scope, tmpReg, Ast.FunctionCallExpression(self:register(scope, tmpReg), self:registerList(scope, argRegs))), {tmpReg}, {tmpReg, unpack(argRegs)}, true);
625643
self:freeRegister(baseReg, false);
@@ -645,9 +663,9 @@ function Compiler:compileExpression(expression, funcDepth, numReturns)
645663
for i=1, numReturns, 1 do
646664
regs[i] = self:allocRegister();
647665
if(i == 1) then
648-
self:addStatement(self:setRegister(scope, regs[i], Ast.StringExpression(expression.value)), {regs[i]}, {});
666+
self:addStatement(self:setRegister(scope, regs[i], Ast.StringExpression(expression.value)), {regs[i]}, {}, false);
649667
else
650-
self:addStatement(self:setRegister(scope, regs[i], Ast.NilExpression()), {regs[i]}, {});
668+
self:addStatement(self:setRegister(scope, regs[i], Ast.NilExpression()), {regs[i]}, {}, false);
651669
end
652670
end
653671
return regs;
@@ -659,9 +677,9 @@ function Compiler:compileExpression(expression, funcDepth, numReturns)
659677
for i=1, numReturns do
660678
regs[i] = self:allocRegister();
661679
if(i == 1) then
662-
self:addStatement(self:setRegister(scope, regs[i], Ast.NumberExpression(expression.value)), {regs[i]}, {});
680+
self:addStatement(self:setRegister(scope, regs[i], Ast.NumberExpression(expression.value)), {regs[i]}, {}, false);
663681
else
664-
self:addStatement(self:setRegister(scope, regs[i], Ast.NilExpression()), {regs[i]}, {});
682+
self:addStatement(self:setRegister(scope, regs[i], Ast.NilExpression()), {regs[i]}, {}, false);
665683
end
666684
end
667685
return regs;
@@ -673,9 +691,9 @@ function Compiler:compileExpression(expression, funcDepth, numReturns)
673691
for i=1, numReturns do
674692
regs[i] = self:allocRegister();
675693
if(i == 1) then
676-
self:addStatement(self:setRegister(scope, regs[i], Ast.BooleanExpression(expression.value)), {regs[i]}, {});
694+
self:addStatement(self:setRegister(scope, regs[i], Ast.BooleanExpression(expression.value)), {regs[i]}, {}, false);
677695
else
678-
self:addStatement(self:setRegister(scope, regs[i], Ast.NilExpression()), {regs[i]}, {});
696+
self:addStatement(self:setRegister(scope, regs[i], Ast.NilExpression()), {regs[i]}, {}, false);
679697
end
680698
end
681699
return regs;
@@ -686,7 +704,7 @@ function Compiler:compileExpression(expression, funcDepth, numReturns)
686704
local regs = {};
687705
for i=1, numReturns do
688706
regs[i] = self:allocRegister();
689-
self:addStatement(self:setRegister(scope, regs[i], Ast.NilExpression()), {regs[i]}, {});
707+
self:addStatement(self:setRegister(scope, regs[i], Ast.NilExpression()), {regs[i]}, {}, false);
690708
end
691709
return regs;
692710
end
@@ -701,16 +719,16 @@ function Compiler:compileExpression(expression, funcDepth, numReturns)
701719
-- Global Variable
702720
regs[i] = self:allocRegister(false, false);
703721
local tmpReg = self:allocRegister(false, false);
704-
self:addStatement(self:setRegister(scope, tmpReg, Ast.StringExpression(expression.scope:getVariableName(expression.id))), {tmpReg}, {});
705-
self:addStatement(self:setRegister(scope, regs[i], Ast.IndexExpression(self:env(scope), self:register(scope, tmpReg))), {regs[i]}, {tmpReg});
722+
self:addStatement(self:setRegister(scope, tmpReg, Ast.StringExpression(expression.scope:getVariableName(expression.id))), {tmpReg}, {}, false);
723+
self:addStatement(self:setRegister(scope, regs[i], Ast.IndexExpression(self:env(scope), self:register(scope, tmpReg))), {regs[i]}, {tmpReg}, true);
706724
self:freeRegister(tmpReg, false);
707725
else
708726
-- Local Variable
709727
regs[i] = self:getVarRegister(expression.scope, expression.id);
710728
end
711729
else
712730
regs[i] = self:allocRegister();
713-
self:addStatement(self:setRegister(scope, regs[i], Ast.NilExpression()), {regs[i]}, {});
731+
self:addStatement(self:setRegister(scope, regs[i], Ast.NilExpression()), {regs[i]}, {}, false);
714732
end
715733
end
716734
return regs;
@@ -754,8 +772,8 @@ function Compiler:compileExpression(expression, funcDepth, numReturns)
754772
table.insert(argRegs, self:compileExpression(expr, funcDepth, 1)[1]);
755773
end
756774

757-
self:addStatement(self:setRegister(scope, tmpReg, Ast.StringExpression(expression.passSelfFunctionName)), {tmpReg}, {});
758-
self:addStatement(self:setRegister(scope, tmpReg, Ast.IndexExpression(self:register(scope, baseReg), self:register(scope, tmpReg))), {tmpReg}, {baseReg, tmpReg});
775+
self:addStatement(self:setRegister(scope, tmpReg, Ast.StringExpression(expression.passSelfFunctionName)), {tmpReg}, {}, false);
776+
self:addStatement(self:setRegister(scope, tmpReg, Ast.IndexExpression(self:register(scope, baseReg), self:register(scope, tmpReg))), {tmpReg}, {baseReg, tmpReg}, false);
759777

760778
self:addStatement(self:setRegisters(scope, retRegs, {Ast.FunctionCallExpression(self:register(scope, tmpReg), self:registerList(scope, argRegs))}), retRegs, {tmpReg, unpack(argRegs)}, true)
761779
self:freeRegister(baseReg, false);
@@ -775,11 +793,11 @@ function Compiler:compileExpression(expression, funcDepth, numReturns)
775793
local baseReg = self:compileExpression(expression.base, funcDepth, 1)[1];
776794
local indexReg = self:compileExpression(expression.index, funcDepth, 1)[1];
777795

778-
self:addStatement(self:setRegister(scope, regs[i], Ast.IndexExpression(self:register(scope, baseReg), self:register(scope, indexReg))), {regs[i]}, {baseReg, indexReg});
796+
self:addStatement(self:setRegister(scope, regs[i], Ast.IndexExpression(self:register(scope, baseReg), self:register(scope, indexReg))), {regs[i]}, {baseReg, indexReg}, false);
779797
self:freeRegister(baseReg, false);
780798
self:freeRegister(indexReg, false)
781799
else
782-
self:addStatement(self:setRegister(scope, regs[i], Ast.NilExpression()), {regs[i]}, {});
800+
self:addStatement(self:setRegister(scope, regs[i], Ast.NilExpression()), {regs[i]}, {}, false);
783801
end
784802
end
785803
return regs;
@@ -794,11 +812,43 @@ function Compiler:compileExpression(expression, funcDepth, numReturns)
794812
local lhsReg = self:compileExpression(expression.lhs, funcDepth, 1)[1];
795813
local rhsReg = self:compileExpression(expression.rhs, funcDepth, 1)[1];
796814

797-
self:addStatement(self:setRegister(scope, regs[i], Ast[expression.kind](self:register(scope, lhsReg), self:register(scope, rhsReg))), {regs[i]}, {lhsReg, rhsReg});
815+
self:addStatement(self:setRegister(scope, regs[i], Ast[expression.kind](self:register(scope, lhsReg), self:register(scope, rhsReg))), {regs[i]}, {lhsReg, rhsReg}, false);
798816
self:freeRegister(rhsReg, false);
799817
self:freeRegister(lhsReg, false)
800818
else
801-
self:addStatement(self:setRegister(scope, regs[i], Ast.NilExpression()), {regs[i]}, {});
819+
self:addStatement(self:setRegister(scope, regs[i], Ast.NilExpression()), {regs[i]}, {}, false);
820+
end
821+
end
822+
return regs;
823+
end
824+
825+
if(expression.kind == AstKind.NotExpression) then
826+
local regs = {};
827+
for i=1, numReturns do
828+
regs[i] = self:allocRegister();
829+
if(i == 1) then
830+
local rhsReg = self:compileExpression(expression.rhs, funcDepth, 1)[1];
831+
832+
self:addStatement(self:setRegister(scope, regs[i], Ast.NotExpression(self:register(scope, rhsReg))), {regs[i]}, {rhsReg}, false);
833+
self:freeRegister(rhsReg, false)
834+
else
835+
self:addStatement(self:setRegister(scope, regs[i], Ast.NilExpression()), {regs[i]}, {}, false);
836+
end
837+
end
838+
return regs;
839+
end
840+
841+
if(expression.kind == AstKind.NegateExpression) then
842+
local regs = {};
843+
for i=1, numReturns do
844+
regs[i] = self:allocRegister();
845+
if(i == 1) then
846+
local rhsReg = self:compileExpression(expression.rhs, funcDepth, 1)[1];
847+
848+
self:addStatement(self:setRegister(scope, regs[i], Ast.NegateExpression(self:register(scope, rhsReg))), {regs[i]}, {rhsReg}, false);
849+
self:freeRegister(rhsReg, false)
850+
else
851+
self:addStatement(self:setRegister(scope, regs[i], Ast.NilExpression()), {regs[i]}, {}, false);
802852
end
803853
end
804854
return regs;

0 commit comments

Comments
 (0)