diff --git a/ChangeLog b/ChangeLog index 0460248..15e1ee0 100644 --- a/ChangeLog +++ b/ChangeLog @@ -1,3 +1,8 @@ +Sun Dec 7 23:26:50 2008 Minero Aoki + + * net: revert r4100; implementing alloca() is too difficult for + current architecture. + Sun Dec 7 23:25:25 2008 Minero Aoki * lib/libcbc.cb -> lib/stdarg.cb diff --git a/net/loveruby/cflat/asm/AsmOperand.java b/net/loveruby/cflat/asm/AsmOperand.java index a21afc7..6d374d4 100644 --- a/net/loveruby/cflat/asm/AsmOperand.java +++ b/net/loveruby/cflat/asm/AsmOperand.java @@ -21,8 +21,4 @@ abstract public class AsmOperand implements OperandPattern { public boolean match(AsmOperand operand) { return equals(operand); } - - public void fixStackOffset(long diff) { - // does nothing by default - } } diff --git a/net/loveruby/cflat/asm/Assembler.java b/net/loveruby/cflat/asm/Assembler.java index 9ee5b8a..339732c 100644 --- a/net/loveruby/cflat/asm/Assembler.java +++ b/net/loveruby/cflat/asm/Assembler.java @@ -275,11 +275,6 @@ public class Assembler { mov(naturalType, src, dest); } - // for stack access - public void relocatableMov(AsmOperand src, AsmOperand dest) { - assemblies.add(new Instruction("mov", typeSuffix(naturalType), src, dest, true)); - } - public void mov(Type type, AsmOperand src, AsmOperand dest) { insn(type, "mov", src, dest); } diff --git a/net/loveruby/cflat/asm/Assembly.java b/net/loveruby/cflat/asm/Assembly.java index 1f0d5dd..ee5986e 100644 --- a/net/loveruby/cflat/asm/Assembly.java +++ b/net/loveruby/cflat/asm/Assembly.java @@ -22,8 +22,4 @@ abstract public class Assembly { public void collectStatistics(AsmStatistics stats) { // does nothing by default. } - - public void fixStackOffset(long diff) { - // does nothing by default. - } } diff --git a/net/loveruby/cflat/asm/BaseSymbol.java b/net/loveruby/cflat/asm/BaseSymbol.java index 8b11c2f..ce53853 100644 --- a/net/loveruby/cflat/asm/BaseSymbol.java +++ b/net/loveruby/cflat/asm/BaseSymbol.java @@ -8,8 +8,4 @@ abstract public class BaseSymbol implements Symbol { public void collectStatistics(AsmStatistics stats) { stats.symbolUsed(this); } - - public Literal plus(long n) { - throw new Error("must not happen: BaseSymbol.plus called"); - } } diff --git a/net/loveruby/cflat/asm/IndirectMemoryReference.java b/net/loveruby/cflat/asm/IndirectMemoryReference.java index b65907a..2283557 100644 --- a/net/loveruby/cflat/asm/IndirectMemoryReference.java +++ b/net/loveruby/cflat/asm/IndirectMemoryReference.java @@ -43,10 +43,6 @@ public class IndirectMemoryReference extends MemoryReference { base.collectStatistics(stats); } - public void fixStackOffset(long diff) { - offset = offset.plus(diff); - } - public String toString() { return toSource(SymbolTable.dummy()); } diff --git a/net/loveruby/cflat/asm/Instruction.java b/net/loveruby/cflat/asm/Instruction.java index 7a1f42e..ff244dd 100644 --- a/net/loveruby/cflat/asm/Instruction.java +++ b/net/loveruby/cflat/asm/Instruction.java @@ -5,41 +5,32 @@ public class Instruction extends Assembly { protected String mnemonic; protected String suffix; protected AsmOperand[] operands; - protected boolean needRelocation; public Instruction(String mnemonic) { - this(mnemonic, "", new AsmOperand[0], false); + this(mnemonic, "", new AsmOperand[0]); } public Instruction(String mnemonic, String suffix, AsmOperand a1) { - this(mnemonic, suffix, new AsmOperand[] { a1 }, false); + this(mnemonic, suffix, new AsmOperand[] { a1 }); } public Instruction(String mnemonic, String suffix, AsmOperand a1, AsmOperand a2) { - this(mnemonic, suffix, new AsmOperand[] { a1, a2 }, false); + this(mnemonic, suffix, new AsmOperand[] { a1, a2 }); } - public Instruction(String mnemonic, String suffix, - AsmOperand a1, AsmOperand a2, boolean reloc) { - this(mnemonic, suffix, new AsmOperand[] { a1, a2 }, reloc); - } - - public Instruction(String mnemonic, String suffix, AsmOperand[] operands, boolean reloc) { + public Instruction(String mnemonic, String suffix, AsmOperand[] operands) { this.mnemonic = mnemonic; this.suffix = suffix; this.operands = operands; - this.needRelocation = reloc; } public Instruction build(String mnemonic, AsmOperand o1) { - return new Instruction(mnemonic, this.suffix, - new AsmOperand[] { o1 }, needRelocation); + return new Instruction(mnemonic, this.suffix, new AsmOperand[] { o1 }); } public Instruction build(String mnemonic, AsmOperand o1, AsmOperand o2) { - return new Instruction(mnemonic, this.suffix, - new AsmOperand[] { o1, o2 }, needRelocation); + return new Instruction(mnemonic, this.suffix, new AsmOperand[] { o1, o2 }); } public boolean isInstruction() { @@ -88,13 +79,6 @@ public class Instruction extends Assembly { } } - public void fixStackOffset(long diff) { - if (!needRelocation) return; - for (int i = 0; i < operands.length; i++) { - operands[i].fixStackOffset(diff); - } - } - public String toSource(SymbolTable table) { StringBuffer buf = new StringBuffer(); buf.append("\t"); diff --git a/net/loveruby/cflat/asm/IntegerLiteral.java b/net/loveruby/cflat/asm/IntegerLiteral.java index 5c8603e..f9e3149 100644 --- a/net/loveruby/cflat/asm/IntegerLiteral.java +++ b/net/loveruby/cflat/asm/IntegerLiteral.java @@ -24,10 +24,6 @@ public class IntegerLiteral implements Literal { return value == 0; } - public IntegerLiteral plus(long diff) { - return new IntegerLiteral(value + diff); - } - public IntegerLiteral integerLiteral() { return this; } @@ -43,8 +39,4 @@ public class IntegerLiteral implements Literal { public void collectStatistics(AsmStatistics stats) { // does nothing } - - public String toString() { - return "$" + value; - } } diff --git a/net/loveruby/cflat/asm/Literal.java b/net/loveruby/cflat/asm/Literal.java index 966be81..95836fe 100644 --- a/net/loveruby/cflat/asm/Literal.java +++ b/net/loveruby/cflat/asm/Literal.java @@ -5,5 +5,4 @@ public interface Literal { public String toSource(SymbolTable table); public void collectStatistics(AsmStatistics stats); public boolean isZero(); - public Literal plus(long diff); } diff --git a/net/loveruby/cflat/asm/SuffixedSymbol.java b/net/loveruby/cflat/asm/SuffixedSymbol.java index e98c819..a288beb 100644 --- a/net/loveruby/cflat/asm/SuffixedSymbol.java +++ b/net/loveruby/cflat/asm/SuffixedSymbol.java @@ -17,10 +17,6 @@ public class SuffixedSymbol implements Symbol { base.collectStatistics(stats); } - public Literal plus(long n) { - throw new Error("must not happen: SuffixedSymbol.plus called"); - } - public String name() { return base.name(); } diff --git a/net/loveruby/cflat/compiler/CodeGenerator.java b/net/loveruby/cflat/compiler/CodeGenerator.java index efcc78e..4208604 100644 --- a/net/loveruby/cflat/compiler/CodeGenerator.java +++ b/net/loveruby/cflat/compiler/CodeGenerator.java @@ -304,15 +304,13 @@ public class CodeGenerator // #@@} protected void compileFunctionBody(DefinedFunction func) { - initStackParams(); List bodyAsms = compileStmts(func); AsmStatistics stats = AsmStatistics.collect(bodyAsms); bodyAsms = reduceLabels(bodyAsms, stats); List saveRegs = usedCalleeSavedRegisters(stats); - long lvarBytes = allocateLocalVariables(func.body().scope(), savedRegsSize(saveRegs)); - fixStackOffsets(bodyAsms, savedRegsSize(saveRegs) + lvarBytes); - - prologue(func, saveRegs, savedRegsSize(saveRegs) + lvarBytes + maxStackLength()); + long lvarBytes = allocateLocalVariables(func.body().scope(), + saveRegs.size()); + prologue(func, saveRegs, lvarBytes); if (options.isPositionIndependent() && stats.doesRegisterUsed(GOTBaseReg())) { loadGOTBaseAddress(GOTBaseReg()); } @@ -320,16 +318,6 @@ public class CodeGenerator epilogue(func, saveRegs, lvarBytes); } - protected long savedRegsSize(List regs) { - long numReallySaved = 0; - for (Register reg : regs) { - if (! reg.baseName().equals("bp")) { - numReallySaved++; - } - } - return numReallySaved * stackWordSize; - } - protected List compileStmts(DefinedFunction func) { pushAssembler(); currentFunction = func; @@ -430,11 +418,11 @@ public class CodeGenerator // #@@range/prologue{ protected void prologue(DefinedFunction func, List saveRegs, - long frameSize) { - truePush(bp()); + long lvarBytes) { + push(bp()); mov(sp(), bp()); saveRegisters(saveRegs); - allocateStack(frameSize); + extendStack(lvarBytes); if (options.isVerboseAsm()) { for (DefinedVariable var : func.localVariables()) { comment("mem " + var.memref() + ": " + var.name()); @@ -447,10 +435,10 @@ public class CodeGenerator protected void epilogue(DefinedFunction func, List savedRegs, long lvarBytes) { - //shrinkStack(lvarBytes); + shrinkStack(lvarBytes); restoreRegisters(savedRegs); mov(bp(), sp()); - truePop(bp()); + pop(bp()); ret(); } // #@@} @@ -501,9 +489,10 @@ public class CodeGenerator * Returns byte-length of the local variable area. * Note that numSavedRegs includes bp. */ - protected long allocateLocalVariables(LocalScope scope, long offset) { - long maxLen = allocateScope(scope, offset); - return maxLen - offset; + protected long allocateLocalVariables(LocalScope scope, long numSavedRegs) { + long initLen = (numSavedRegs - 1) * stackWordSize; + long maxLen = allocateScope(scope, initLen); + return maxLen - initLen; } protected long allocateScope(LocalScope scope, long parentStackLen) { @@ -532,60 +521,15 @@ public class CodeGenerator memref.fixOffset(offset); } - protected void allocateStack(long len) { - if (len > 0) { - if (stackGrowsLower) { - sub(imm(len), sp()); - } - else { - add(imm(len), sp()); - } - } - } - - protected long stackPointer; - protected long stackPointerMax; - - protected void initStackParams() { - stackPointer = 0; - stackPointerMax = stackPointer; - } - - protected long maxStackLength() { - return stackPointerMax; - } - - protected IndirectMemoryReference stackTop() { - if (stackGrowsLower) { - return mem(-stackPointer, bp()); - } - else { - return mem(stackPointer - stackWordSize, bp()); - } - } - - protected void push(Register reg) { - extendStack(stackWordSize); - as.relocatableMov(reg, stackTop()); - } - - protected void pop(Register reg) { - as.relocatableMov(stackTop(), reg); - rewindStack(stackWordSize); - } - protected void extendStack(long len) { - stackPointer += len; - stackPointerMax = Math.max(stackPointerMax, stackPointer); + if (len > 0) { + add(imm(len * (stackGrowsLower ? -1 : 1)), sp()); + } } - protected void rewindStack(long len) { - stackPointer -= len; - } - - protected void fixStackOffsets(List asms, long offset) { - for (Assembly asm : asms) { - asm.fixStackOffset(offset * (stackGrowsLower ? -1 : 1)); + protected void shrinkStack(long len) { + if (len > 0) { + add(imm(len * (stackGrowsLower ? 1 : -1)), sp()); } } @@ -597,12 +541,9 @@ public class CodeGenerator public void visit(FuncallNode node) { // compile function arguments from right to left. ListIterator args = node.finalArg(); - long argIndex = node.numArgs() - 1; while (args.hasPrevious()) { compile(args.previous()); - mov(reg("ax"), argMemory(argIndex)); - argIndex--; - extendStack(stackWordSize); + push(reg("ax")); } // call if (node.isStaticCall()) { @@ -616,16 +557,7 @@ public class CodeGenerator } // rewind stack // >4 bytes arguments are not supported. - rewindStack(node.numArgs() * stackWordSize); - } - - protected IndirectMemoryReference argMemory(long argIndex) { - if (stackGrowsLower) { - return mem(stackWordSize * argIndex, sp()); - } - else { - return mem(-stackWordSize * (argIndex + 1), sp()); - } + shrinkStack(node.numArgs() * stackWordSize); } public void visit(ReturnNode node) { @@ -1316,8 +1248,8 @@ public class CodeGenerator public void setl(Register reg) { as.setl(reg); } public void setle(Register reg) { as.setle(reg); } public void test(Type type, Register a, Register b) { as.test(type, a, b); } - protected void truePush(Register reg) { as.push(reg); } - protected void truePop(Register reg) { as.pop(reg); } + public void push(Register reg) { as.push(reg); } + public void pop(Register reg) { as.pop(reg); } public void call(Symbol sym) { as.call(sym); } public void callAbsolute(Register reg) { as.callAbsolute(reg); } public void ret() { as.ret(); }