azalea/kotlin-fork
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Get rid of myStack holding intermediate StackValues and use functional style visitor instead.

Browse Source
This commit is contained in:
Maxim Shafirov
2011-08-22 18:36:41 +04:00
parent 4571d94c82
commit b3b8a23f4e
17 changed files with 259 additions and 291 deletions
Download Patch File Download Diff File Expand all files Collapse all files
idea/src/org/jetbrains/jet/codegen/ClassContext.java
+1 -1
View File
@@ -37,7 +37,7 @@ public class ClassContext {
}
public StackValue getThisExpression() {
if (parentContext == null) return null;
if (parentContext == null) return StackValue.none();
thisWasUsed = true;
if (thisExpression != null) return thisExpression;
idea/src/org/jetbrains/jet/codegen/ExpressionCodegen.java
+203 -226
View File
File diff suppressed because it is too large Load Diff
idea/src/org/jetbrains/jet/codegen/FunctionCodegen.java
+6 -30
View File
@@ -3,7 +3,9 @@ package org.jetbrains.jet.codegen;
import org.jetbrains.jet.lang.descriptors.FunctionDescriptor;
import org.jetbrains.jet.lang.descriptors.TypeParameterDescriptor;
import org.jetbrains.jet.lang.descriptors.ValueParameterDescriptor;
import org.jetbrains.jet.lang.psi.*;
import org.jetbrains.jet.lang.psi.JetDeclarationWithBody;
import org.jetbrains.jet.lang.psi.JetExpression;
import org.jetbrains.jet.lang.psi.JetNamedFunction;
import org.jetbrains.jet.lang.resolve.BindingContext;
import org.objectweb.asm.ClassVisitor;
import org.objectweb.asm.MethodVisitor;
@@ -12,7 +14,6 @@ import org.objectweb.asm.Type;
import org.objectweb.asm.commons.InstructionAdapter;
import org.objectweb.asm.commons.Method;
import java.util.Collections;
import java.util.List;
/**
@@ -40,11 +41,10 @@ public class FunctionCodegen {
ClassContext funContext = owner.intoFunction(functionDescriptor);
final JetExpression bodyExpression = f.getBodyExpression();
final List<JetElement> bodyExpressions = bodyExpression != null ? Collections.<JetElement>singletonList(bodyExpression) : null;
generatedMethod(bodyExpressions, jvmMethod, funContext, functionDescriptor.getValueParameters(), functionDescriptor.getTypeParameters());
generatedMethod(bodyExpression, jvmMethod, funContext, functionDescriptor.getValueParameters(), functionDescriptor.getTypeParameters());
}
private void generatedMethod(List<JetElement> bodyExpressions,
private void generatedMethod(JetExpression bodyExpressions,
Method jvmSignature,
ClassContext context,
List<ValueParameterDescriptor> paramDescrs,
@@ -95,35 +95,11 @@ public class FunctionCodegen {
iv.areturn(jvmSignature.getReturnType());
}
else if (!isAbstract) {
JetElement last = null;
for (JetElement expression : bodyExpressions) {
expression.accept(codegen);
last = expression;
}
generateReturn(mv, last, codegen, jvmSignature);
codegen.returnExpression(bodyExpressions);
}
mv.visitMaxs(0, 0);
mv.visitEnd();
}
}
private void generateReturn(MethodVisitor mv, JetElement bodyExpression, ExpressionCodegen codegen, Method jvmSignature) {
if (!endsWithReturn(bodyExpression)) {
if (jvmSignature.getReturnType() == Type.VOID_TYPE) {
mv.visitInsn(Opcodes.RETURN);
}
else {
codegen.returnTopOfStack();
}
}
}
private static boolean endsWithReturn(JetElement bodyExpression) {
if (bodyExpression instanceof JetBlockExpression) {
final List<JetElement> statements = ((JetBlockExpression) bodyExpression).getStatements();
return statements.size() > 0 && statements.get(statements.size()-1) instanceof JetReturnExpression;
}
return bodyExpression instanceof JetReturnExpression;
}
}
idea/src/org/jetbrains/jet/codegen/StackValue.java
+16 -2
View File
@@ -48,8 +48,7 @@ public abstract class StackValue {
}
public static StackValue onStack(Type type) {
assert type != Type.VOID_TYPE;
return new OnStack(type);
return type == Type.VOID_TYPE ? none() : new OnStack(type);
}
public static StackValue constant(Object value, Type type) {
@@ -190,6 +189,21 @@ public abstract class StackValue {
v.mark(end);
}
public static StackValue none() {
return None.INSTANCE;
}
private static class None extends StackValue {
public static None INSTANCE = new None();
private None() {
super(Type.VOID_TYPE);
}
@Override
public void put(Type type, InstructionAdapter v) {
}
}
public static class Local extends StackValue {
private final int index;
idea/src/org/jetbrains/jet/codegen/intrinsics/ArraySize.java
+2 -2
View File
@@ -15,8 +15,8 @@ import java.util.List;
*/
public class ArraySize implements IntrinsicMethod {
@Override
public StackValue generate(ExpressionCodegen codegen, InstructionAdapter v, Type expectedType, PsiElement element, List<JetExpression> arguments, boolean haveReceiver) {
codegen.ensureReceiverOnStack(element, null, JetTypeMapper.TYPE_OBJECT);
public StackValue generate(ExpressionCodegen codegen, InstructionAdapter v, Type expectedType, PsiElement element, List<JetExpression> arguments, StackValue receiver) {
receiver.put(JetTypeMapper.TYPE_OBJECT, v);
v.arraylength();
return StackValue.onStack(Type.INT_TYPE);
}
idea/src/org/jetbrains/jet/codegen/intrinsics/BinaryOp.java
+5 -6
View File
@@ -2,7 +2,6 @@ package org.jetbrains.jet.codegen.intrinsics;
import com.intellij.psi.PsiElement;
import org.jetbrains.jet.codegen.ExpressionCodegen;
import org.jetbrains.jet.codegen.JetTypeMapper;
import org.jetbrains.jet.codegen.StackValue;
import org.jetbrains.jet.lang.psi.JetExpression;
import org.objectweb.asm.Type;
@@ -21,16 +20,16 @@ public class BinaryOp implements IntrinsicMethod {
}
@Override
public StackValue generate(ExpressionCodegen codegen, InstructionAdapter v, Type expectedType, PsiElement element, List<JetExpression> arguments, boolean haveReceiver) {
public StackValue generate(ExpressionCodegen codegen, InstructionAdapter v, Type expectedType, PsiElement element, List<JetExpression> arguments, StackValue receiver) {
if (arguments.size() == 1) {
// intrinsic is called as an ordinary function
codegen.ensureReceiverOnStack(element, null, expectedType);
if (receiver != null) {
receiver.put(expectedType, v);
}
codegen.gen(arguments.get(0), expectedType);
}
else {
if (!haveReceiver) {
codegen.gen(arguments.get(0), expectedType);
}
codegen.gen(arguments.get(0), expectedType);
codegen.gen(arguments.get(1), expectedType);
}
v.visitInsn(expectedType.getOpcode(opcode));
idea/src/org/jetbrains/jet/codegen/intrinsics/Concat.java
+9 -7
View File
@@ -14,16 +14,18 @@ import java.util.List;
*/
public class Concat implements IntrinsicMethod {
@Override
public StackValue generate(ExpressionCodegen codegen, InstructionAdapter v, Type expectedType, PsiElement element, List<JetExpression> arguments, boolean haveReceiver) {
public StackValue generate(ExpressionCodegen codegen, InstructionAdapter v, Type expectedType, PsiElement element, List<JetExpression> arguments, StackValue receiver) {
codegen.generateStringBuilderConstructor();
if (haveReceiver) {
v.swap();
codegen.invokeAppendMethod(codegen.expressionType(arguments.get(0)));
}
else {
if (receiver == null) { // LHS.plus(RHS)
v.swap(); // StringBuilder LHS
codegen.invokeAppendMethod(codegen.expressionType(arguments.get(0))); // StringBuilder(LHS)
codegen.invokeAppend(arguments.get(0));
}
codegen.invokeAppend(arguments.get(1));
else { // LHS + RHS
codegen.invokeAppend(arguments.get(0)); // StringBuilder(LHS)
codegen.invokeAppend(arguments.get(1));
}
v.invokevirtual(ExpressionCodegen.CLASS_STRING_BUILDER, "toString", "()Ljava/lang/String;");
return StackValue.onStack(Type.getObjectType("java/lang/String"));
}
idea/src/org/jetbrains/jet/codegen/intrinsics/Increment.java
+2 -2
View File
@@ -22,7 +22,7 @@ public class Increment implements IntrinsicMethod {
}
@Override
public StackValue generate(ExpressionCodegen codegen, InstructionAdapter v, Type expectedType, PsiElement element, List<JetExpression> arguments, boolean haveReceiver) {
public StackValue generate(ExpressionCodegen codegen, InstructionAdapter v, Type expectedType, PsiElement element, List<JetExpression> arguments, StackValue receiver) {
final JetExpression operand = arguments.get(0);
if (operand instanceof JetReferenceExpression) {
final int index = codegen.indexOfLocal((JetReferenceExpression) operand);
@@ -31,7 +31,7 @@ public class Increment implements IntrinsicMethod {
return StackValue.local(index, expectedType);
}
}
StackValue value = codegen.generateIntermediateValue(operand);
StackValue value = codegen.genQualified(receiver, operand);
value.dupReceiver(v, 0);
value.put(expectedType, v);
if (expectedType == Type.LONG_TYPE) {
idea/src/org/jetbrains/jet/codegen/intrinsics/IntrinsicMethod.java
+1 -1
View File
@@ -14,5 +14,5 @@ import java.util.List;
* @author yole
*/
public interface IntrinsicMethod extends Callable {
StackValue generate(ExpressionCodegen codegen, InstructionAdapter v, Type expectedType, PsiElement element, List<JetExpression> arguments, boolean haveReceiver);
StackValue generate(ExpressionCodegen codegen, InstructionAdapter v, Type expectedType, PsiElement element, List<JetExpression> arguments, StackValue receiver);
}
idea/src/org/jetbrains/jet/codegen/intrinsics/Inv.java
+2 -2
View File
@@ -14,8 +14,8 @@ import java.util.List;
*/
public class Inv implements IntrinsicMethod {
@Override
public StackValue generate(ExpressionCodegen codegen, InstructionAdapter v, Type expectedType, PsiElement element, List<JetExpression> arguments, boolean haveReceiver) {
codegen.putTopOfStack(expectedType);
public StackValue generate(ExpressionCodegen codegen, InstructionAdapter v, Type expectedType, PsiElement element, List<JetExpression> arguments, StackValue receiver) {
receiver.put(expectedType, v);
v.aconst(-1);
v.xor(expectedType);
return StackValue.onStack(expectedType);
idea/src/org/jetbrains/jet/codegen/intrinsics/Not.java
+3 -3
View File
@@ -14,13 +14,13 @@ import java.util.List;
*/
public class Not implements IntrinsicMethod {
@Override
public StackValue generate(ExpressionCodegen codegen, InstructionAdapter v, Type expectedType, PsiElement element, List<JetExpression> arguments, boolean haveReceiver) {
public StackValue generate(ExpressionCodegen codegen, InstructionAdapter v, Type expectedType, PsiElement element, List<JetExpression> arguments, StackValue receiver) {
final StackValue stackValue;
if (arguments.size() == 1) {
stackValue = codegen.generateIntermediateValue(arguments.get(0));
stackValue = codegen.gen(arguments.get(0));
}
else {
stackValue = codegen.getReceiverAsStackValue(element, null, expectedType);
stackValue = receiver;
}
return StackValue.not(stackValue);
}
idea/src/org/jetbrains/jet/codegen/intrinsics/NumberCast.java
+2 -2
View File
@@ -14,8 +14,8 @@ import java.util.List;
*/
public class NumberCast implements IntrinsicMethod {
@Override
public StackValue generate(ExpressionCodegen codegen, InstructionAdapter v, Type expectedType, PsiElement element, List<JetExpression> arguments, boolean haveReceiver) {
codegen.putTopOfStack(expectedType);
public StackValue generate(ExpressionCodegen codegen, InstructionAdapter v, Type expectedType, PsiElement element, List<JetExpression> arguments, StackValue receiver) {
receiver.put(expectedType, v);
return StackValue.onStack(expectedType);
}
}
idea/src/org/jetbrains/jet/codegen/intrinsics/PsiMethodCall.java
+2 -2
View File
@@ -24,9 +24,9 @@ public class PsiMethodCall implements IntrinsicMethod {
@Override
public StackValue generate(ExpressionCodegen codegen, InstructionAdapter v, Type expectedType, PsiElement element,
List<JetExpression> arguments, boolean haveReceiver) {
List<JetExpression> arguments, StackValue receiver) {
final CallableMethod callableMethod = codegen.getTypeMapper().mapToCallableMethod(myMethod);
codegen.invokeMethodWithArguments(callableMethod, (JetCallExpression) element, haveReceiver);
codegen.invokeMethodWithArguments(callableMethod, (JetCallExpression) element, receiver);
return StackValue.onStack(callableMethod.getSignature().getReturnType());
}
}
idea/src/org/jetbrains/jet/codegen/intrinsics/RangeTo.java
+1 -1
View File
@@ -21,7 +21,7 @@ public class RangeTo implements IntrinsicMethod {
private static final String CLASS_INT_RANGE = "jet/IntRange";
@Override
public StackValue generate(ExpressionCodegen codegen, InstructionAdapter v, Type expectedType, PsiElement element, List<JetExpression> arguments, boolean haveReceiver) {
public StackValue generate(ExpressionCodegen codegen, InstructionAdapter v, Type expectedType, PsiElement element, List<JetExpression> arguments, StackValue receiver) {
JetBinaryExpression expression = (JetBinaryExpression) element;
final Type leftType = codegen.expressionType(expression.getLeft());
if (JetTypeMapper.isIntPrimitive(leftType)) {
idea/src/org/jetbrains/jet/codegen/intrinsics/TypeInfo.java
+1 -1
View File
@@ -17,7 +17,7 @@ import java.util.List;
*/
public class TypeInfo implements IntrinsicMethod {
@Override
public StackValue generate(ExpressionCodegen codegen, InstructionAdapter v, Type expectedType, PsiElement element, List<JetExpression> arguments, boolean haveReceiver) {
public StackValue generate(ExpressionCodegen codegen, InstructionAdapter v, Type expectedType, PsiElement element, List<JetExpression> arguments, StackValue receiver) {
final List<JetTypeProjection> typeArguments = ((JetCallExpression) element).getTypeArguments();
if (typeArguments.size() != 1) {
throw new UnsupportedOperationException("one type argument expected");
idea/src/org/jetbrains/jet/codegen/intrinsics/UnaryMinus.java
+2 -2
View File
@@ -14,12 +14,12 @@ import java.util.List;
*/
public class UnaryMinus implements IntrinsicMethod {
@Override
public StackValue generate(ExpressionCodegen codegen, InstructionAdapter v, Type expectedType, PsiElement element, List<JetExpression> arguments, boolean haveReceiver) {
public StackValue generate(ExpressionCodegen codegen, InstructionAdapter v, Type expectedType, PsiElement element, List<JetExpression> arguments, StackValue receiver) {
if (arguments.size() == 1) {
codegen.gen(arguments.get(0), expectedType);
}
else {
codegen.ensureReceiverOnStack(element, null, expectedType);
receiver.put(expectedType, v);
}
v.neg(expectedType);
return StackValue.onStack(expectedType);
idea/src/org/jetbrains/jet/codegen/intrinsics/ValueTypeInfo.java
+1 -1
View File
@@ -15,7 +15,7 @@ import java.util.List;
*/
public class ValueTypeInfo implements IntrinsicMethod {
@Override
public StackValue generate(ExpressionCodegen codegen, InstructionAdapter v, Type expectedType, PsiElement element, List<JetExpression> arguments, boolean haveReceiver) {
public StackValue generate(ExpressionCodegen codegen, InstructionAdapter v, Type expectedType, PsiElement element, List<JetExpression> arguments, StackValue receiver) {
codegen.gen(arguments.get(0), JetTypeMapper.TYPE_JET_OBJECT);
v.invokeinterface("jet/JetObject", "getTypeInfo", "()Ljet/typeinfo/TypeInfo;");
return StackValue.onStack(JetTypeMapper.TYPE_TYPEINFO);