/*
* Copyright (c) 2016, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
package jdk.test.lib.jittester.visitors;
import java.util.ArrayDeque;
import java.util.Deque;
import java.util.HashMap;
import java.util.List;
import java.util.NoSuchElementException;
import java.util.Objects;
import java.util.SortedMap;
import java.util.TreeMap;
import java.util.stream.Collectors;
import java.util.stream.Stream;
import jdk.internal.org.objectweb.asm.ClassWriter;
import jdk.internal.org.objectweb.asm.FieldVisitor;
import jdk.internal.org.objectweb.asm.Label;
import jdk.internal.org.objectweb.asm.MethodVisitor;
import jdk.internal.org.objectweb.asm.Opcodes;
import jdk.test.lib.util.Pair;
import jdk.test.lib.jittester.BinaryOperator;
import jdk.test.lib.jittester.Block;
import jdk.test.lib.jittester.BuiltInType;
import jdk.test.lib.jittester.Break;
import jdk.test.lib.jittester.CastOperator;
import jdk.test.lib.jittester.CatchBlock;
import jdk.test.lib.jittester.Continue;
import jdk.test.lib.jittester.Declaration;
import jdk.test.lib.jittester.IRNode;
import jdk.test.lib.jittester.If;
import jdk.test.lib.jittester.Initialization;
import jdk.test.lib.jittester.Literal;
import jdk.test.lib.jittester.LocalVariable;
import jdk.test.lib.jittester.NonStaticMemberVariable;
import jdk.test.lib.jittester.Nothing;
import jdk.test.lib.jittester.Operator;
import jdk.test.lib.jittester.OperatorKind;
import jdk.test.lib.jittester.PrintVariables;
import jdk.test.lib.jittester.ProductionParams;
import jdk.test.lib.jittester.Statement;
import jdk.test.lib.jittester.StaticMemberVariable;
import jdk.test.lib.jittester.Switch;
import jdk.test.lib.jittester.Symbol;
import jdk.test.lib.jittester.TernaryOperator;
import jdk.test.lib.jittester.Throw;
import jdk.test.lib.jittester.TryCatchBlock;
import jdk.test.lib.jittester.Type;
import jdk.test.lib.jittester.TypeList;
import jdk.test.lib.jittester.UnaryOperator;
import jdk.test.lib.jittester.VariableBase;
import jdk.test.lib.jittester.VariableDeclaration;
import jdk.test.lib.jittester.VariableDeclarationBlock;
import jdk.test.lib.jittester.VariableInfo;
import jdk.test.lib.jittester.VariableInitialization;
import jdk.test.lib.jittester.arrays.ArrayCreation;
import jdk.test.lib.jittester.arrays.ArrayElement;
import jdk.test.lib.jittester.arrays.ArrayExtraction;
import jdk.test.lib.jittester.classes.ClassDefinitionBlock;
import jdk.test.lib.jittester.classes.Interface;
import jdk.test.lib.jittester.classes.Klass;
import jdk.test.lib.jittester.classes.MainKlass;
import jdk.test.lib.jittester.functions.ArgumentDeclaration;
import jdk.test.lib.jittester.functions.ConstructorDefinition;
import jdk.test.lib.jittester.functions.ConstructorDefinitionBlock;
import jdk.test.lib.jittester.functions.Function;
import jdk.test.lib.jittester.functions.FunctionDeclaration;
import jdk.test.lib.jittester.functions.FunctionDeclarationBlock;
import jdk.test.lib.jittester.functions.FunctionDefinition;
import jdk.test.lib.jittester.functions.FunctionDefinitionBlock;
import jdk.test.lib.jittester.functions.FunctionInfo;
import jdk.test.lib.jittester.functions.FunctionRedefinition;
import jdk.test.lib.jittester.functions.FunctionRedefinitionBlock;
import jdk.test.lib.jittester.functions.Return;
import jdk.test.lib.jittester.functions.StaticConstructorDefinition;
import jdk.test.lib.jittester.loops.CounterInitializer;
import jdk.test.lib.jittester.loops.CounterManipulator;
import jdk.test.lib.jittester.loops.DoWhile;
import jdk.test.lib.jittester.loops.For;
import jdk.test.lib.jittester.loops.Loop;
import jdk.test.lib.jittester.loops.LoopingCondition;
import jdk.test.lib.jittester.loops.While;
import jdk.test.lib.jittester.types.TypeArray;
import jdk.test.lib.jittester.types.TypeKlass;
import jdk.test.lib.jittester.utils.FixedTrees;
import jdk.test.lib.jittester.utils.PseudoRandom;
public class ByteCodeVisitor implements Visitor<byte[]> {
private final GeneratedClassesContext context = new GeneratedClassesContext();
private final byte[] EMPTY_BYTE_ARRAY = new byte[0];
private final int CLASS_WRITER_FLAGS = ContextDependedClassWriter.COMPUTE_MAXS | ContextDependedClassWriter.COMPUTE_FRAMES;
private final HashMap<String, ContextDependedClassWriter> classWriters = new HashMap<>();
private MethodVisitor currentMV;
private TypeKlass currentClass;
private final LocalVariablesTable locals = new LocalVariablesTable();
private final Deque<Label> endLabels = new ArrayDeque<>();
private final Deque<Label> beginLabels = new ArrayDeque<>();
@Override
public byte[] visit(ArgumentDeclaration node) {
/* handled by FunctionDefinition for ByteCodeVisitor */
return EMPTY_BYTE_ARRAY;
}
@Override
public byte[] visit(ArrayCreation node) {
int dimensions = node.getDimensionsCount();
TypeArray arrayType = node.getArrayType();
Type basicType = arrayType.type;
for (IRNode child : node.getChildren()) {
child.accept(this);
}
if (dimensions == 1) {
if (basicType.equals(TypeList.BOOLEAN)) {
currentMV.visitIntInsn(Opcodes.NEWARRAY, Opcodes.T_BOOLEAN);
} else if (basicType.equals(TypeList.BYTE)) {
currentMV.visitIntInsn(Opcodes.NEWARRAY, Opcodes.T_BYTE);
} else if (basicType.equals(TypeList.CHAR)) {
currentMV.visitIntInsn(Opcodes.NEWARRAY, Opcodes.T_CHAR);
} else if (basicType.equals(TypeList.SHORT)) {
currentMV.visitIntInsn(Opcodes.NEWARRAY, Opcodes.T_SHORT);
} else if (basicType.equals(TypeList.INT)) {
currentMV.visitIntInsn(Opcodes.NEWARRAY, Opcodes.T_INT);
} else if (basicType.equals(TypeList.LONG)) {
currentMV.visitIntInsn(Opcodes.NEWARRAY, Opcodes.T_LONG);
} else if (basicType.equals(TypeList.FLOAT)) {
currentMV.visitIntInsn(Opcodes.NEWARRAY, Opcodes.T_FLOAT);
} else if (basicType.equals(TypeList.DOUBLE)) {
currentMV.visitIntInsn(Opcodes.NEWARRAY, Opcodes.T_DOUBLE);
} else {
currentMV.visitTypeInsn(Opcodes.ANEWARRAY, asInternalName(basicType.getName()));
}
} else {
currentMV.visitMultiANewArrayInsn(new String(arrayType.accept(this)), dimensions);
}
return EMPTY_BYTE_ARRAY;
}
@Override
public byte[] visit(ArrayElement node) {
node.getChild(0).accept(this);
int dimensions = node.getChildren().size() - 1;
Type resultType = node.getResultType();
for (int i = 1; i < dimensions; i++) {
node.getChild(i).accept(this);
currentMV.visitInsn(Opcodes.AALOAD);
}
node.getChild(dimensions).accept(this);
if (resultType.equals(TypeList.BOOLEAN) || resultType.equals(TypeList.BYTE)) {
currentMV.visitInsn(Opcodes.BALOAD);
} else if (resultType.equals(TypeList.CHAR)) {
currentMV.visitInsn(Opcodes.CALOAD);
} else if (resultType.equals(TypeList.SHORT)) {
currentMV.visitInsn(Opcodes.SALOAD);
} else if (resultType.equals(TypeList.INT)) {
currentMV.visitInsn(Opcodes.IALOAD);
} else if (resultType.equals(TypeList.LONG)) {
currentMV.visitInsn(Opcodes.LALOAD);
} else if (resultType.equals(TypeList.FLOAT)) {
currentMV.visitInsn(Opcodes.FALOAD);
} else if (resultType.equals(TypeList.DOUBLE)) {
currentMV.visitInsn(Opcodes.DALOAD);
} else {
currentMV.visitInsn(Opcodes.AALOAD);
}
return EMPTY_BYTE_ARRAY;
}
@Override
public byte[] visit(ArrayExtraction node) {
node.getChild(0).accept(this);
int dimensions = node.getChildren().size() - 1;
Type resultType = node.getResultType();
for (int i = 1; i < dimensions; i++) {
node.getChild(i).accept(this);
currentMV.visitInsn(Opcodes.AALOAD);
}
node.getChild(dimensions).accept(this);
if (resultType.equals(TypeList.BOOLEAN) || resultType.equals(TypeList.BYTE)) {
currentMV.visitInsn(Opcodes.BALOAD);
} else if (resultType.equals(TypeList.CHAR)) {
currentMV.visitInsn(Opcodes.CALOAD);
} else if (resultType.equals(TypeList.SHORT)) {
currentMV.visitInsn(Opcodes.SALOAD);
} else if (resultType.equals(TypeList.INT)) {
currentMV.visitInsn(Opcodes.IALOAD);
} else if (resultType.equals(TypeList.LONG)) {
currentMV.visitInsn(Opcodes.LALOAD);
} else if (resultType.equals(TypeList.FLOAT)) {
currentMV.visitInsn(Opcodes.FALOAD);
} else if (resultType.equals(TypeList.DOUBLE)) {
currentMV.visitInsn(Opcodes.DALOAD);
} else {
currentMV.visitInsn(Opcodes.AALOAD);
}
return EMPTY_BYTE_ARRAY;
}
@Override
public byte[] visit(BinaryOperator node) {
OperatorKind kind = node.getOperationKind();
IRNode left = node.getChild(Operator.Order.LEFT.ordinal());
IRNode right = node.getChild(Operator.Order.RIGHT.ordinal());
Type resultType = node.getResultType();
if (left == null || right == null) {
return EMPTY_BYTE_ARRAY;
}
boolean needTypeConversion = false;
boolean convertRightArg = false;
Type leftType = left.getResultType();
Type rightType = right.getResultType();
if (!leftType.equals(rightType) && leftType instanceof BuiltInType
&& rightType instanceof BuiltInType
&& kind != OperatorKind.SAR && kind != OperatorKind.SHL
&& kind != OperatorKind.SHR && kind != OperatorKind.ASSIGN
&& kind != OperatorKind.AND && kind != OperatorKind.OR) {
needTypeConversion = true;
BuiltInType leftBuiltIn = (BuiltInType) leftType;
BuiltInType rightBuiltIn = (BuiltInType) rightType;
convertRightArg = leftBuiltIn.isMoreCapaciousThan(rightBuiltIn);
}
Type mostCapacious = convertRightArg ? leftType : rightType;
if (!rightType.equals(TypeList.INT)
&& (kind == OperatorKind.SHL || kind == OperatorKind.SHR
|| kind == OperatorKind.SAR)) {
left.accept(this);
right.accept(this);
convertTopType(rightType, TypeList.INT);
} else if (kind != OperatorKind.ASSIGN && kind != OperatorKind.OR
&& kind != OperatorKind.AND && kind != OperatorKind.COMPOUND_ADD
&& kind != OperatorKind.COMPOUND_AND && kind != OperatorKind.COMPOUND_DIV
&& kind != OperatorKind.COMPOUND_MOD && kind != OperatorKind.COMPOUND_MUL
&& kind != OperatorKind.COMPOUND_OR && kind != OperatorKind.COMPOUND_SAR
&& kind != OperatorKind.COMPOUND_SHL && kind != OperatorKind.COMPOUND_SHR
&& kind != OperatorKind.COMPOUND_SUB && kind != OperatorKind.COMPOUND_XOR
&& kind != OperatorKind.STRADD) {
/* "assign", "and", "or", concat and all compound operators are
handled differently and shouldn't just place left and right
operands on stack */
left.accept(this);
if (needTypeConversion && !convertRightArg) {
convertTopType(leftType, rightType);
}
right.accept(this);
if (needTypeConversion && convertRightArg) {
convertTopType(rightType, leftType);
}
}
switch (kind) {
case ASSIGN:
VariableInfo vi = ((VariableBase)left).getVariableInfo();
Type varType = vi.type;
if (left instanceof LocalVariable) {
right.accept(this);
convertTopType(rightType, leftType);
int index = locals.getLocalIndex(vi);
if (varType.equals(TypeList.LONG)) {
currentMV.visitVarInsn(Opcodes.LSTORE, index);
currentMV.visitVarInsn(Opcodes.LLOAD, index);
} else if (varType.equals(TypeList.DOUBLE)) {
currentMV.visitVarInsn(Opcodes.DSTORE, index);
currentMV.visitVarInsn(Opcodes.DLOAD, index);
} else if (varType.equals(TypeList.FLOAT)) {
currentMV.visitVarInsn(Opcodes.FSTORE, index);
currentMV.visitVarInsn(Opcodes.FLOAD, index);
} else if (varType instanceof TypeKlass) {
currentMV.visitVarInsn(Opcodes.ASTORE, index);
currentMV.visitVarInsn(Opcodes.ALOAD, index);
} else {
currentMV.visitVarInsn(Opcodes.ISTORE, index);
currentMV.visitVarInsn(Opcodes.ILOAD, index);
}
} else if (left instanceof StaticMemberVariable) {
right.accept(this);
convertTopType(rightType, leftType);
String typeDescr = new String(vi.type.accept(this));
String ownerName = asInternalName(vi.getOwner().getName());
currentMV.visitFieldInsn(Opcodes.PUTSTATIC, ownerName,
vi.name, typeDescr);
currentMV.visitFieldInsn(Opcodes.GETSTATIC, ownerName,
vi.name, typeDescr);
} else if (left instanceof NonStaticMemberVariable) {
// put object to stack for putfield
left.getChild(0).accept(this);
// put object to stack for getfield
currentMV.visitInsn(Opcodes.DUP);
right.accept(this);
convertTopType(rightType, leftType);
String typeDescr = new String(vi.type.accept(this));
String ownerName = asInternalName(vi.getOwner().getName());
currentMV.visitFieldInsn(Opcodes.PUTFIELD, ownerName,
vi.name, typeDescr);
currentMV.visitFieldInsn(Opcodes.GETFIELD, ownerName,
vi.name, typeDescr);
} else {
throw new IllegalArgumentException("illegal left operand : "
+ left + "("+left.getClass()+")");
}
break;
case OR:
generateBasicLogicOperator(Opcodes.IFNE, false, left, right);
break;
case AND:
generateBasicLogicOperator(Opcodes.IFEQ, true, left, right);
break;
case BIT_OR:
if (mostCapacious.equals(TypeList.LONG)) {
currentMV.visitInsn(Opcodes.LOR);
} else {
currentMV.visitInsn(Opcodes.IOR);
}
break;
case BIT_XOR:
if (mostCapacious.equals(TypeList.LONG)) {
currentMV.visitInsn(Opcodes.LXOR);
} else {
currentMV.visitInsn(Opcodes.IXOR);
}
break;
case BIT_AND:
if (mostCapacious.equals(TypeList.LONG)) {
currentMV.visitInsn(Opcodes.LAND);
} else {
currentMV.visitInsn(Opcodes.IAND);
}
break;
case EQ:
generateCmpBasedCode(mostCapacious, Opcodes.IFEQ, Opcodes.IF_ICMPEQ);
break;
case NE:
generateCmpBasedCode(mostCapacious, Opcodes.IFNE, Opcodes.IF_ICMPNE);
break;
case GT:
generateCmpBasedCode(mostCapacious, Opcodes.IFGT, Opcodes.IF_ICMPGT);
break;
case LT:
generateCmpBasedCode(mostCapacious, Opcodes.IFLT, Opcodes.IF_ICMPLT);
break;
case GE:
generateCmpBasedCode(mostCapacious, Opcodes.IFGE, Opcodes.IF_ICMPGE);
break;
case LE:
generateCmpBasedCode(mostCapacious, Opcodes.IFLE, Opcodes.IF_ICMPLE);
break;
case SHR:
if (leftType.equals(TypeList.LONG)) {
currentMV.visitInsn(Opcodes.LSHR);
} else {
currentMV.visitInsn(Opcodes.ISHR);
}
break;
case SHL:
if (leftType.equals(TypeList.LONG)) {
currentMV.visitInsn(Opcodes.LSHL);
} else {
currentMV.visitInsn(Opcodes.ISHL);
}
break;
case SAR:
if (leftType.equals(TypeList.LONG)) {
currentMV.visitInsn(Opcodes.LUSHR);
} else {
currentMV.visitInsn(Opcodes.IUSHR);
}
break;
case STRADD:
// we use String::valueOf to change null to "null"
left.accept(this);
currentMV.visitMethodInsn(Opcodes.INVOKESTATIC, "java/lang/String", "valueOf",
"(Ljava/lang/Object;)Ljava/lang/String;", false /* not interface */);
right.accept(this);
currentMV.visitMethodInsn(Opcodes.INVOKESTATIC, "java/lang/String", "valueOf",
"(Ljava/lang/Object;)Ljava/lang/String;", false /* not interface */);
currentMV.visitMethodInsn(Opcodes.INVOKEVIRTUAL, "java/lang/String", "concat",
"(Ljava/lang/String;)Ljava/lang/String;", false /* not interface */);
break;
case ADD:
if (mostCapacious.equals(TypeList.LONG)) {
currentMV.visitInsn(Opcodes.LADD);
} else if (mostCapacious.equals(TypeList.DOUBLE)) {
currentMV.visitInsn(Opcodes.DADD);
} else if (mostCapacious.equals(TypeList.FLOAT)) {
currentMV.visitInsn(Opcodes.FADD);
} else {
currentMV.visitInsn(Opcodes.IADD);
}
break;
case SUB:
if (mostCapacious.equals(TypeList.LONG)) {
currentMV.visitInsn(Opcodes.LSUB);
} else if (mostCapacious.equals(TypeList.DOUBLE)) {
currentMV.visitInsn(Opcodes.DSUB);
} else if (mostCapacious.equals(TypeList.FLOAT)) {
currentMV.visitInsn(Opcodes.FSUB);
} else {
currentMV.visitInsn(Opcodes.ISUB);
}
break;
case MUL:
if (mostCapacious.equals(TypeList.LONG)) {
currentMV.visitInsn(Opcodes.LMUL);
} else if (mostCapacious.equals(TypeList.DOUBLE)) {
currentMV.visitInsn(Opcodes.DMUL);
} else if (mostCapacious.equals(TypeList.FLOAT)) {
currentMV.visitInsn(Opcodes.FMUL);
} else {
currentMV.visitInsn(Opcodes.IMUL);
}
break;
case DIV:
if (mostCapacious.equals(TypeList.LONG)) {
currentMV.visitInsn(Opcodes.LDIV);
} else if (mostCapacious.equals(TypeList.DOUBLE)) {
currentMV.visitInsn(Opcodes.DDIV);
} else if (mostCapacious.equals(TypeList.FLOAT)) {
currentMV.visitInsn(Opcodes.FDIV);
} else {
currentMV.visitInsn(Opcodes.IDIV);
}
break;
case MOD:
if (mostCapacious.equals(TypeList.LONG)) {
currentMV.visitInsn(Opcodes.LREM);
} else if (mostCapacious.equals(TypeList.DOUBLE)) {
currentMV.visitInsn(Opcodes.DREM);
} else if (mostCapacious.equals(TypeList.FLOAT)) {
currentMV.visitInsn(Opcodes.FREM);
} else {
currentMV.visitInsn(Opcodes.IREM);
}
break;
case COMPOUND_ADD:
lowerCompoundBinaryOperator("java.lang.String".equals(leftType.getName())
? OperatorKind.STRADD : OperatorKind.ADD, node);
break;
case COMPOUND_SUB:
lowerCompoundBinaryOperator(OperatorKind.SUB, node);
break;
case COMPOUND_MUL:
lowerCompoundBinaryOperator(OperatorKind.MUL, node);
break;
case COMPOUND_DIV:
lowerCompoundBinaryOperator(OperatorKind.DIV, node);
break;
case COMPOUND_MOD:
lowerCompoundBinaryOperator(OperatorKind.MOD, node);
break;
case COMPOUND_AND:
lowerCompoundBinaryOperator(leftType.equals(TypeList.BOOLEAN)
? OperatorKind.AND : OperatorKind.BIT_AND, node);
break;
case COMPOUND_OR:
lowerCompoundBinaryOperator(leftType.equals(TypeList.BOOLEAN)
? OperatorKind.OR : OperatorKind.BIT_OR, node);
break;
case COMPOUND_XOR:
lowerCompoundBinaryOperator(OperatorKind.BIT_XOR, node);
break;
case COMPOUND_SHR:
lowerCompoundBinaryOperator(OperatorKind.SHR, node);
break;
case COMPOUND_SHL:
lowerCompoundBinaryOperator(OperatorKind.SHL, node);
break;
case COMPOUND_SAR:
lowerCompoundBinaryOperator(OperatorKind.SAR, node);
break;
default:
throw new Error("Unsupported binary operator");
}
return EMPTY_BYTE_ARRAY;
}
private static int tmpObject;
private void lowerCompoundBinaryOperator(OperatorKind kind, IRNode node) {
IRNode left = node.getChild(Operator.Order.LEFT.ordinal());
IRNode right = node.getChild(Operator.Order.RIGHT.ordinal());
if (left instanceof NonStaticMemberVariable) {
NonStaticMemberVariable var = (NonStaticMemberVariable) left;
IRNode holder = var.getChild(0);
Type type = holder.getResultType();
VariableInfo tmpInfo = new VariableInfo("tmpObject_" + tmpObject++,
currentClass, type, VariableInfo.LOCAL);
new Statement(new VariableInitialization(tmpInfo, holder), true).accept(this);
left = new NonStaticMemberVariable(new LocalVariable(tmpInfo), var.getVariableInfo());
}
Type leftType = left.getResultType();
Type rightType = right.getResultType();
Type resultType = leftType;
if (leftType instanceof BuiltInType && rightType instanceof BuiltInType) {
if (kind != OperatorKind.SHL && kind != OperatorKind.SHR && kind != OperatorKind.SAR
&& ((BuiltInType) rightType).isMoreCapaciousThan((BuiltInType) leftType)) {
resultType = rightType;
}
}
IRNode result = new CastOperator(leftType,
new BinaryOperator(kind, resultType, left, right));
new BinaryOperator(OperatorKind.ASSIGN, leftType, left, result).accept(this);
}
private void generateBasicLogicOperator(int ifOpcode, boolean retTrueFirst, IRNode left,
IRNode right) {
Label secondCase = new Label();
Label endLabel = new Label();
left.accept(this);
currentMV.visitJumpInsn(ifOpcode, secondCase);
right.accept(this);
currentMV.visitJumpInsn(ifOpcode, secondCase);
currentMV.visitInsn(retTrueFirst ? Opcodes.ICONST_1 : Opcodes.ICONST_0);
currentMV.visitJumpInsn(Opcodes.GOTO, endLabel);
currentMV.visitLabel(secondCase);
currentMV.visitInsn(retTrueFirst ? Opcodes.ICONST_0 : Opcodes.ICONST_1);
currentMV.visitLabel(endLabel);
}
private void generateCmpBasedCode(Type type, int nonIntOpcode, int intOpcode) {
boolean useNonIntOpcode = false;
if (type.equals(TypeList.LONG) || type.equals(TypeList.FLOAT)
|| type.equals(TypeList.DOUBLE)) {
if (type.equals(TypeList.LONG)) {
currentMV.visitInsn(Opcodes.LCMP);
} else if (type.equals(TypeList.FLOAT)) {
currentMV.visitInsn(Opcodes.FCMPL);
} else {
currentMV.visitInsn(Opcodes.DCMPL);
}
useNonIntOpcode = true;
}
int opcodeToUse;
if (!useNonIntOpcode) {
if (type instanceof TypeKlass) {
if (intOpcode == Opcodes.IF_ICMPEQ) {
opcodeToUse = Opcodes.IF_ACMPEQ;
} else if (intOpcode == Opcodes.IF_ICMPNE) {
opcodeToUse = Opcodes.IF_ACMPNE;
} else {
throw new Error("Can't compare references");
}
} else {
opcodeToUse = intOpcode;
}
} else {
opcodeToUse = nonIntOpcode;
}
Label retTrue = new Label();
Label end = new Label();
currentMV.visitJumpInsn(opcodeToUse, retTrue);
currentMV.visitInsn(Opcodes.ICONST_0);
currentMV.visitJumpInsn(Opcodes.GOTO, end);
currentMV.visitLabel(retTrue);
currentMV.visitInsn(Opcodes.ICONST_1);
currentMV.visitLabel(end);
}
/*
* Converts top-stack element from one builtin type to another
*/
private void convertTopType(Type from, Type to) {
if (!(from instanceof BuiltInType) || !(to instanceof BuiltInType) || from.equals(to)) {
return; // skip
}
boolean castedToInt = false;
if (from.equals(TypeList.FLOAT)) {
if (to.equals(TypeList.DOUBLE)) {
currentMV.visitInsn(Opcodes.F2D);
} else if (to.equals(TypeList.LONG)) {
currentMV.visitInsn(Opcodes.F2L);
} else {
currentMV.visitInsn(Opcodes.F2I);
castedToInt = true;
}
} else if (from.equals(TypeList.DOUBLE)) {
if (to.equals(TypeList.FLOAT)) {
currentMV.visitInsn(Opcodes.D2F);
} else if (to.equals(TypeList.LONG)) {
currentMV.visitInsn(Opcodes.D2L);
} else {
currentMV.visitInsn(Opcodes.D2I);
castedToInt = true;
}
} else if (from.equals(TypeList.LONG)) {
if (to.equals(TypeList.DOUBLE)) {
currentMV.visitInsn(Opcodes.L2D);
} else if (to.equals(TypeList.FLOAT)) {
currentMV.visitInsn(Opcodes.L2F);
} else {
currentMV.visitInsn(Opcodes.L2I);
castedToInt = true;
}
} else {
if (to.equals(TypeList.BYTE)) {
currentMV.visitInsn(Opcodes.I2B);
} else if (to.equals(TypeList.CHAR)) {
currentMV.visitInsn(Opcodes.I2C);
} else if (to.equals(TypeList.SHORT)) {
currentMV.visitInsn(Opcodes.I2S);
} else if (to.equals(TypeList.LONG)) {
currentMV.visitInsn(Opcodes.I2L);
} else if (to.equals(TypeList.FLOAT)) {
currentMV.visitInsn(Opcodes.I2F);
} else if (to.equals(TypeList.DOUBLE)) {
currentMV.visitInsn(Opcodes.I2D);
}
}
if (castedToInt) {
if (to.equals(TypeList.BYTE)) {
currentMV.visitInsn(Opcodes.I2B);
} else if (to.equals(TypeList.CHAR)) {
currentMV.visitInsn(Opcodes.I2C);
} else if (to.equals(TypeList.SHORT)) {
currentMV.visitInsn(Opcodes.I2S);
}
}
}
@Override
public byte[] visit(Block node) {
return iterateBlock(node);
}
@Override
public byte[] visit(Break node) {
Label label = endLabels.peek();
if (label != null) {
currentMV.visitJumpInsn(Opcodes.GOTO, label);
}
return EMPTY_BYTE_ARRAY;
}
@Override
public byte[] visit(CastOperator node) {
IRNode expression = node.getChild(0);
expression.accept(this);
Type to = node.getResultType();
Type from = expression.getResultType();
// TODO boxing/unboxing
if (!TypeList.isBuiltIn(to) || !TypeList.isBuiltIn(from)) {
// class cast
currentMV.visitTypeInsn(Opcodes.CHECKCAST, asInternalName(to.getName()));
} else {
convertTopType(from, to);
}
return EMPTY_BYTE_ARRAY;
}
@Override
public byte[] visit(CatchBlock node) {
Type type = node.throwables.get(0);
VariableInfo exInfo = new VariableInfo("ex", currentClass,
type, VariableInfo.LOCAL);
int index = locals.getLocalIndex(exInfo);
currentMV.visitVarInsn(Opcodes.ASTORE, index);
node.getChild(0).accept(this);
return EMPTY_BYTE_ARRAY;
}
@Override
public byte[] visit(ClassDefinitionBlock node) {
return iterateBlock(node);
}
@Override
public byte[] visit(ConstructorDefinition node) {
FunctionInfo info = node.getFunctionInfo();
String ownerName = node.getOwner().getName();
TypeKlass parentClass = currentClass.getParent();
ContextDependedClassWriter cw = classWriters.get(ownerName);
String descriptor = getDescriptor(node, 1, "V");
currentMV = cw.visitMethod(asAccessFlags(info), "<init>", descriptor, null, null);
currentMV.visitVarInsn(Opcodes.ALOAD, 0);
currentMV.visitMethodInsn(Opcodes.INVOKESPECIAL,
parentClass != null ? asInternalName(parentClass.getName()) : "java/lang/Object",
"<init>", "()V", false);
locals.initConstructorArguments(node.getOwner(), info);
// TODO: add datamemebers as child to all ctors
generateDataMembers(node.getParent().getParent().getChild(Klass.KlassPart.DATA_MEMBERS.ordinal()));
IRNode body = node.getChild(0);
body.accept(this);
currentMV.visitInsn(Opcodes.RETURN);
currentMV.visitMaxs(0, 0);
currentMV.visitEnd();
return EMPTY_BYTE_ARRAY;
}
private void generateDataMembers(IRNode node) {
// TODO shouldn't we skip declaration?
if (node != null) {
node.accept(this);
}
}
@Override
public byte[] visit(ConstructorDefinitionBlock node) {
return iterateBlock(node);
}
@Override
public byte[] visit(Continue node) {
Label label = beginLabels.peek();
if (label != null) {
currentMV.visitJumpInsn(Opcodes.GOTO, label);
}
return EMPTY_BYTE_ARRAY;
}
@Override
public byte[] visit(CounterInitializer node) {
visitLocalVar(node);
emitPop(node.getVariableInfo().type);
return EMPTY_BYTE_ARRAY;
}
private byte[] visitLocalVar(Initialization node) {
VariableInfo vi = node.getVariableInfo();
int index = locals.addLocal(vi);
int store;
node.getChild(0).accept(this); // place initialization expression on stack
emitDup(vi.type);
if (vi.type instanceof TypeKlass) {
store = Opcodes.ASTORE;
} else if (vi.type.equals(TypeList.DOUBLE)) {
store = Opcodes.DSTORE;
} else if (vi.type.equals(TypeList.LONG)) {
store = Opcodes.LSTORE;
} else if (vi.type.equals(TypeList.FLOAT)) {
store = Opcodes.FSTORE;
} else {
store = Opcodes.ISTORE;
}
currentMV.visitVarInsn(store, index);
return EMPTY_BYTE_ARRAY;
}
@Override
public byte[] visit(CounterManipulator node) {
return node.getChild(0).accept(this);
}
@Override
public byte[] visit(Declaration node) {
IRNode child = node.getChild(0);
child.accept(this);
if (child instanceof Initialization) {
emitPop(((Initialization) child).getVariableInfo().type);
}
return EMPTY_BYTE_ARRAY;
}
@Override
public byte[] visit(DoWhile node) {
Loop loop = node.getLoop();
loop.initialization.accept(this);
node.getChild(DoWhile.DoWhilePart.HEADER.ordinal()).accept(this);
Label currentLoopBegin = new Label();
beginLabels.push(currentLoopBegin);
Label currentLoopEnd = new Label();
endLabels.push(currentLoopEnd);
currentMV.visitLabel(currentLoopBegin);
node.getChild(DoWhile.DoWhilePart.BODY1.ordinal()).accept(this);
loop.manipulator.accept(this);
node.getChild(DoWhile.DoWhilePart.BODY2.ordinal()).accept(this);
loop.condition.accept(this);
assert loop.condition.getResultType() == TypeList.BOOLEAN;
currentMV.visitJumpInsn(Opcodes.IFEQ, currentLoopBegin);
currentMV.visitLabel(currentLoopEnd);
Label a = beginLabels.pop();
assert currentLoopBegin == a;
a = endLabels.pop();
assert currentLoopEnd == a;
return EMPTY_BYTE_ARRAY;
}
@Override
public byte[] visit(For node) {
Loop loop = node.getLoop();
loop.initialization.accept(this);
node.getChild(For.ForPart.HEADER.ordinal()).accept(this);
node.getChild(For.ForPart.STATEMENT1.ordinal()).accept(this);
Label currentLoopBegin = new Label();
beginLabels.push(currentLoopBegin);
currentMV.visitLabel(currentLoopBegin);
loop.condition.accept(this);
assert loop.condition.getResultType() == TypeList.BOOLEAN;
Label currentLoopEnd = new Label();
endLabels.push(currentLoopEnd);
currentMV.visitJumpInsn(Opcodes.IFEQ, currentLoopEnd);
node.getChild(For.ForPart.STATEMENT2.ordinal()).accept(this);
node.getChild(For.ForPart.BODY1.ordinal()).accept(this);
loop.manipulator.accept(this);
node.getChild(For.ForPart.BODY2.ordinal()).accept(this);
node.getChild(For.ForPart.BODY3.ordinal()).accept(this);
currentMV.visitJumpInsn(Opcodes.GOTO, currentLoopBegin);
currentMV.visitLabel(currentLoopEnd);
Label a = beginLabels.pop();
assert currentLoopBegin == a;
a = endLabels.pop();
assert currentLoopEnd == a;
return EMPTY_BYTE_ARRAY;
}
@Override
public byte[] visit(Function node) {
FunctionInfo info = node.getValue();
boolean needInstance = !info.isStatic() && !info.isConstructor();
if (needInstance) {
node.getChild(0).accept(this); // placing instance on stack
}
// call itself with specific invoke*
String signature = info.argTypes.stream()
.skip(!needInstance ? 0 : 1)
.map(vi -> new String(vi.type.accept(this)))
.collect(Collectors.joining("", "(", ")"))
+ (info.isConstructor() ? "V" : new String(node.getResultType().accept(this)));
int invokeCode = Opcodes.INVOKEVIRTUAL;
if (info.isStatic()) {
invokeCode = Opcodes.INVOKESTATIC;
} else if (info.isConstructor() || info.isPrivate()) {
// TODO : superclass method invocation?
invokeCode = Opcodes.INVOKESPECIAL;
} else {
if (info.owner.isInterface()) {
invokeCode = Opcodes.INVOKEINTERFACE;
}
}
if (info.isConstructor()) {
currentMV.visitTypeInsn(Opcodes.NEW, asInternalName(info.owner.getName()));
currentMV.visitInsn(Opcodes.DUP);
}
// calculating parameters
node.getChildren().stream()
.skip(!needInstance ? 0 : 1)
.forEachOrdered(c -> c.accept(this));
currentMV.visitMethodInsn(invokeCode, asInternalName(info.owner.getName()),
info.isConstructor() ? "<init>" : info.name, signature,
invokeCode == Opcodes.INVOKEINTERFACE);
return EMPTY_BYTE_ARRAY;
}
@Override
public byte[] visit(FunctionDeclaration node) {
FunctionInfo info = node.getFunctionInfo();
String ownerName = node.getOwner().getName();
ContextDependedClassWriter cw = classWriters.get(ownerName);
String returnType = new String(info.type.accept(this));
String descriptor = getDescriptor(node, 0, returnType);
currentMV = cw.visitMethod(asAccessFlags(info) + Opcodes.ACC_ABSTRACT,
info.name, descriptor, null, null);
currentMV.visitEnd();
return EMPTY_BYTE_ARRAY;
}
@Override
public byte[] visit(FunctionDeclarationBlock node) {
return iterateBlock(node);
}
@Override
public byte[] visit(FunctionDefinition node) {
FunctionInfo info = node.getFunctionInfo();
String ownerName = node.getOwner().getName();
ContextDependedClassWriter cw = classWriters.get(ownerName);
String returnType = new String(info.type.accept(this));
String descriptor = getDescriptor(node, 2, returnType);
currentMV = cw.visitMethod(asAccessFlags(info), info.name, descriptor, null, null);
locals.initFunctionArguments(info);
IRNode body = node.getChild(0);
body.accept(this);
IRNode ret = node.getChild(1);
ret.accept(this);
currentMV.visitMaxs(0, 0);
currentMV.visitEnd();
return EMPTY_BYTE_ARRAY;
}
@Override
public byte[] visit(FunctionDefinitionBlock node) {
return iterateBlock(node);
}
@Override
public byte[] visit(FunctionRedefinition node) {
FunctionInfo info = node.getFunctionInfo();
String ownerName = node.getOwner().getName();
ContextDependedClassWriter cw = classWriters.get(ownerName);
String returnType = new String(info.type.accept(this));
String descriptor = getDescriptor(node, 2, returnType);
currentMV = cw.visitMethod(asAccessFlags(info), info.name, descriptor, null, null);
locals.initFunctionArguments(info);
IRNode body = node.getChild(0);
body.accept(this);
IRNode ret = node.getChild(1);
ret.accept(this);
currentMV.visitMaxs(0, 0);
currentMV.visitEnd();
return EMPTY_BYTE_ARRAY;
}
@Override
public byte[] visit(FunctionRedefinitionBlock node) {
return iterateBlock(node);
}
@Override
public byte[] visit(If node) {
IRNode conditionBlock = node.getChild(If.IfPart.CONDITION.ordinal());
// get the condition type to emit correct if
conditionBlock.accept(this);
generateIf(Opcodes.IFEQ, node.getChild(If.IfPart.THEN.ordinal()),
node.getChild(If.IfPart.ELSE.ordinal()));
return EMPTY_BYTE_ARRAY;
}
/*
* Generates if block with then and else blocks for the given IF opcode
*/
private void generateIf(int ifOpcode, IRNode thenBlock, IRNode elseBlock) {
Label elseLabel = new Label();
// if the opposite condition is met then go to the else statement
currentMV.visitJumpInsn(ifOpcode, elseLabel);
// write THEN block
thenBlock.accept(this);
if (elseBlock != null) {
// goto the end after THEN
Label endLabel = new Label();
currentMV.visitJumpInsn(Opcodes.GOTO, endLabel);
// ELSE block
currentMV.visitLabel(elseLabel);
elseBlock.accept(this);
currentMV.visitLabel(endLabel);
} else {
currentMV.visitLabel(elseLabel);
}
}
@Override
public byte[] visit(Initialization node) {
VariableInfo vi = node.getVariableInfo();
if (vi.isLocal()) {
return visitLocalVar(node);
}
String ownerName = vi.getOwner().getName();
ContextDependedClassWriter cw = classWriters.get(ownerName);
String typeName = new String(vi.type.accept(this));
// constant value used only for final static fields
FieldVisitor fw = cw.visitField(asAccessFlags(vi), vi.name,
typeName,
null /* Generic */,
null /* Constant value */);
fw.visitEnd(); // doesn't need visitAnnotation and visitAttribute
if (vi.isStatic()) {
node.getChild(0).accept(this); // put value to stack
emitDup(vi.type);
currentMV.visitFieldInsn(Opcodes.PUTSTATIC,
asInternalName(vi.getOwner().getName()),
vi.name,
new String(vi.type.accept(this)));
} else {
// TODO : can it be another object?
currentMV.visitVarInsn(Opcodes.ALOAD, 0); // put this to stack
node.getChild(0).accept(this); // put value to stack
emitDupX1(vi.type);
currentMV.visitFieldInsn(Opcodes.PUTFIELD,
asInternalName(vi.getOwner().getName()),
vi.name,
new String(vi.type.accept(this)));
}
return EMPTY_BYTE_ARRAY;
}
private void emitDupX1(Type type) {
if (TypeList.DOUBLE.equals(type) || TypeList.LONG.equals(type)) {
currentMV.visitInsn(Opcodes.DUP2_X1);
} else if (!TypeList.VOID.equals(type)){
currentMV.visitInsn(Opcodes.DUP_X1);
}
}
private void emitDup(Type type) {
if (TypeList.DOUBLE.equals(type) || TypeList.LONG.equals(type)) {
currentMV.visitInsn(Opcodes.DUP2);
} else if (!TypeList.VOID.equals(type)){
currentMV.visitInsn(Opcodes.DUP);
}
}
@Override
public byte[] visit(Interface node) {
String name = node.getName();
ContextDependedClassWriter classWriter = new ContextDependedClassWriter(context, CLASS_WRITER_FLAGS);
classWriters.put(name, classWriter);
TypeKlass parentKlass = node.getParentKlass();
classWriter.visit(Opcodes.V1_8,
Opcodes.ACC_ABSTRACT | Opcodes.ACC_INTERFACE,
asInternalName(name),
null /* Generic */,
"java/lang/Object",
parentKlass == null ? null : new String[] {
asInternalName(parentKlass.getName())});
if (node.getChildren().size() > 0) {
node.getChild(0).accept(this);
}
classWriter.visitEnd();
byte[] byteCode = classWriter.toByteArray();
context.register(name, byteCode);
return byteCode;
}
@Override
public byte[] visit(Klass node) {
String name = node.getName();
TypeKlass prevClass = currentClass;
currentClass = node.getThisKlass();
ContextDependedClassWriter classWriter = new ContextDependedClassWriter(context, CLASS_WRITER_FLAGS);
classWriters.put(name, classWriter);
TypeKlass thisClass = node.getThisKlass();
TypeKlass parentClass = node.getParentKlass();
String[] interfaces = node.getInterfaces().stream()
.map(IRNode::getName)
.map(ByteCodeVisitor::asInternalName)
.toArray(String[]::new);
classWriter.visit(Opcodes.V1_8, asAccessFlags(thisClass),
asInternalName(name),
null /* Generic */,
parentClass != null ? asInternalName(parentClass.getName()) : "java/lang/Object",
interfaces);
IRNode constructors = node.getChild(Klass.KlassPart.CONSTRUCTORS.ordinal());
if (constructors != null) {
constructors.accept(this);
} else {
// generate default ctor
currentMV = classWriter.visitMethod(Opcodes.ACC_PUBLIC, "<init>", "()V", null, null);
currentMV.visitVarInsn(Opcodes.ALOAD, 0);
currentMV.visitMethodInsn(Opcodes.INVOKESPECIAL, "java/lang/Object", "<init>", "()V", false);
locals.clear();
locals.addLocal(new VariableInfo("this", thisClass, thisClass, VariableInfo.NONE));
generateDataMembers(node.getChild(Klass.KlassPart.DATA_MEMBERS.ordinal()));
currentMV.visitInsn(Opcodes.RETURN);
currentMV.visitMaxs(0, 0);
currentMV.visitEnd();
}
IRNode redefinedFunctions = node.getChild(Klass.KlassPart.REDEFINED_FUNCTIONS.ordinal());
if (redefinedFunctions != null) {
redefinedFunctions.accept(this);
}
IRNode overridenFunctions = node.getChild(Klass.KlassPart.OVERRIDEN_FUNCTIONS.ordinal());
if (overridenFunctions != null) {
overridenFunctions.accept(this);
}
IRNode memberFunctions = node.getChild(Klass.KlassPart.MEMBER_FUNCTIONS.ordinal());
if (memberFunctions != null) {
memberFunctions.accept(this);
}
IRNode memberFunctionDecls = node.getChild(Klass.KlassPart.MEMBER_FUNCTIONS_DECLARATIONS.ordinal());
if (memberFunctionDecls != null) {
memberFunctionDecls.accept(this);
}
IRNode printVariables = node.getChild(Klass.KlassPart.PRINT_VARIABLES.ordinal());
if (printVariables != null) {
printVariables.accept(this);
}
classWriter.visitEnd();
byte[] byteCode = classWriter.toByteArray();
context.register(name, byteCode);
currentClass = prevClass;
return byteCode;
}
private void visitLiteral(boolean value) {
double chance = PseudoRandom.random();
if (chance < CONSTANT_INST_CHANCE) {
currentMV.visitInsn(value ? Opcodes.ICONST_1 : Opcodes.ICONST_0);
} else {
currentMV.visitIntInsn(Opcodes.BIPUSH, value ? 1 : 0);
}
}
private void visitLiteral(byte value) {
double chance = PseudoRandom.random();
if (chance < CONSTANT_INST_CHANCE && value > -2 && value < 6) {
currentMV.visitInsn(Opcodes.ICONST_0 + value);
} else {
currentMV.visitIntInsn(Opcodes.BIPUSH, value);
}
}
private void visitLiteral(short value) {
double chance = PseudoRandom.random();
if (chance < CONSTANT_INST_CHANCE && value > -2 && value < 6) {
currentMV.visitInsn(Opcodes.ICONST_0 + value);
} else {
currentMV.visitIntInsn(Opcodes.SIPUSH, value);
}
}
private void visitLiteral(char value) {
double chance = PseudoRandom.random();
if (chance < CONSTANT_INST_CHANCE && value < 6) {
currentMV.visitInsn(Opcodes.ICONST_0 + value);
} else {
// TODO : check for widechar/unicode
currentMV.visitIntInsn(Opcodes.BIPUSH, value);
}
}
private void visitLiteral(int value) {
double chance = PseudoRandom.random();
if (chance < CONSTANT_INST_CHANCE && value > -2 && value < 6) {
currentMV.visitInsn(Opcodes.ICONST_0 + value);
} else {
currentMV.visitLdcInsn(value);
}
}
private void visitLiteral(long value) {
double chance = PseudoRandom.random();
if (chance < CONSTANT_INST_CHANCE && value > -1 && value < 2) {
currentMV.visitInsn(Opcodes.LCONST_0 + (int)value);
} else {
currentMV.visitLdcInsn(value);
}
}
private void visitLiteral(float value) {
double chance = PseudoRandom.random();
if (chance < CONSTANT_INST_CHANCE && (value == 0.0f || value == 1.0f || value == 2.0f)) {
currentMV.visitInsn(Opcodes.FCONST_0 + (int)value);
} else {
currentMV.visitLdcInsn(value);
}
}
private void visitLiteral(double value) {
double chance = PseudoRandom.random();
if (chance < CONSTANT_INST_CHANCE && (value == 0.0 || value == 1.0)) {
currentMV.visitInsn(Opcodes.DCONST_0 + (int)value);
} else {
currentMV.visitLdcInsn(value);
}
}
@Override
public byte[] visit(Literal node) {
/*
ICONST_n (−1 ≤ n ≤ 5) <==> BIPUSH <n>
LCONST_n (0 ≤ n ≤ 1)
FCONST_n (0 ≤ n ≤ 2)
DCONST_n (0 ≤ n ≤ 1)
ACONST_NULL
BIPUSH b, −128 ≤ b < 127
SIPUSH s, −32768 ≤ s < 32767
LDC cst (int, float, long, double, String or Type)
*/
Type type = node.getResultType();
double chance = PseudoRandom.random();
if (type.equals(TypeList.BOOLEAN)) {
visitLiteral(Boolean.valueOf(node.getValue().toString()));
} else if (type.equals(TypeList.BYTE)) {
visitLiteral(Byte.valueOf(node.getValue().toString()));
} else if (type.equals(TypeList.SHORT)) {
visitLiteral(Short.valueOf(node.getValue().toString()));
} else if (type.equals(TypeList.CHAR)) {
visitLiteral(node.getValue().toString().charAt(0));
} else if (type.equals(TypeList.INT)) {
visitLiteral(Integer.valueOf(node.getValue().toString()));
} else if (type.equals(TypeList.LONG)) {
visitLiteral(Long.valueOf(node.getValue().toString()));
} else if (type.equals(TypeList.FLOAT)) {
visitLiteral(Float.valueOf(node.getValue().toString()));
} else if (type.equals(TypeList.DOUBLE)) {
visitLiteral(Double.valueOf(node.getValue().toString()));
} else {
currentMV.visitLdcInsn(node.getValue());
}
return EMPTY_BYTE_ARRAY;
}
private static final double CONSTANT_INST_CHANCE = 0.5;
@Override
public byte[] visit(LocalVariable node) {
// This node is for "reading" only. Writing is handled in BinaryOperator visit(see ASSIGN)
VariableInfo vi = node.getVariableInfo();
Type varType = vi.type;
int index = locals.getLocalIndex(vi);
if (varType.equals(TypeList.LONG)) {
currentMV.visitVarInsn(Opcodes.LLOAD, index);
} else if (varType.equals(TypeList.DOUBLE)) {
currentMV.visitVarInsn(Opcodes.DLOAD, index);
} else if (varType.equals(TypeList.FLOAT)) {
currentMV.visitVarInsn(Opcodes.FLOAD, index);
} else if (varType instanceof TypeKlass) {
currentMV.visitVarInsn(Opcodes.ALOAD, index);
} else {
currentMV.visitVarInsn(Opcodes.ILOAD, index);
}
return EMPTY_BYTE_ARRAY;
}
@Override
public byte[] visit(LoopingCondition node) {
return node.getCondition().accept(this);
}
@Override
public byte[] visit(MainKlass node) {
TypeKlass prevClass = currentClass;
currentClass = node.getThisKlass();
String name = node.getName();
ContextDependedClassWriter mainClassWriter = new ContextDependedClassWriter(context, CLASS_WRITER_FLAGS);
classWriters.put(name, mainClassWriter);
TypeKlass thisClass = node.getThisKlass();
mainClassWriter.visit(Opcodes.V1_8, Opcodes.ACC_PUBLIC,
asInternalName(name),
null /* Generic */,
"java/lang/Object",
null /* interfaces */);
// TODO: constructor for main class
currentMV = mainClassWriter.visitMethod(Opcodes.ACC_PUBLIC, "<init>", "()V", null, null);
currentMV.visitVarInsn(Opcodes.ALOAD, 0);
currentMV.visitMethodInsn(Opcodes.INVOKESPECIAL, "java/lang/Object", "<init>", "()V", false);
locals.clear();
locals.addLocal(new VariableInfo("this", thisClass, thisClass, VariableInfo.NONE));
generateDataMembers(node.getChild(MainKlass.MainKlassPart.DATA_MEMBERS.ordinal()));
currentMV.visitInsn(Opcodes.RETURN);
currentMV.visitMaxs(0, 0);
currentMV.visitEnd();
IRNode memberFunctions = node.getChild(MainKlass.MainKlassPart.MEMBER_FUNCTIONS.ordinal());
if (memberFunctions != null) {
memberFunctions.accept(this);
}
IRNode testFunction = node.getChild(MainKlass.MainKlassPart.TEST_FUNCTION.ordinal());
if (testFunction != null) {
currentMV = mainClassWriter.visitMethod(
Opcodes.ACC_PRIVATE,
"test",
"()V",
null,
null);
locals.clear();
locals.addLocal(new VariableInfo("this", thisClass, thisClass, VariableInfo.NONE));
testFunction.accept(this);
currentMV.visitInsn(Opcodes.RETURN);
currentMV.visitMaxs(0, 0);
currentMV.visitEnd();
}
IRNode printVariables = node.getChild(MainKlass.MainKlassPart.PRINT_VARIABLES.ordinal());
if (printVariables != null) {
printVariables.accept(this);
}
mainClassWriter.visitEnd();
byte[] byteCode = mainClassWriter.toByteArray();
context.register(name, byteCode);
currentClass = prevClass;
return byteCode;
}
@Override
public byte[] visit(NonStaticMemberVariable node) {
// This node is for "reading" only. Writing is handled in BinaryOperator visit(see ASSIGN)
VariableInfo vi = node.getVariableInfo();
// put object to stack
node.getChild(0).accept(this);
currentMV.visitFieldInsn(Opcodes.GETFIELD, asInternalName(vi.getOwner().getName()), vi.name,
new String(vi.type.accept(this)));
return EMPTY_BYTE_ARRAY;
}
@Override
public byte[] visit(Nothing node) {
// TODO : add randomness
currentMV.visitInsn(Opcodes.NOP);
return EMPTY_BYTE_ARRAY;
}
@Override
public byte[] visit(PrintVariables node) {
return FixedTrees.printVariablesAsFunction(node).accept(this);
}
@Override
public byte[] visit(Return node) {
node.getExpression().accept(this);
Type result = node.getResultType();
if (result instanceof TypeKlass) {
currentMV.visitInsn(Opcodes.ARETURN);
} else if (result.equals(TypeList.VOID)) {
currentMV.visitInsn(Opcodes.RETURN);
} else if (result.equals(TypeList.DOUBLE)) {
currentMV.visitInsn(Opcodes.DRETURN);
} else if (result.equals(TypeList.FLOAT)) {
currentMV.visitInsn(Opcodes.FRETURN);
} else if (result.equals(TypeList.LONG)) {
currentMV.visitInsn(Opcodes.LRETURN);
} else {
currentMV.visitInsn(Opcodes.IRETURN);
}
return EMPTY_BYTE_ARRAY;
}
@Override
public byte[] visit(Statement node) {
IRNode child = node.getChild(0);
child.accept(this);
Type resultType = child.getResultType();
emitPop(resultType);
return EMPTY_BYTE_ARRAY;
}
private void emitPop(Type resultType) {
if (resultType.equals(TypeList.LONG) || resultType.equals(TypeList.DOUBLE)) {
currentMV.visitInsn(Opcodes.POP2);
} else if (!resultType.equals(TypeList.VOID)) {
currentMV.visitInsn(Opcodes.POP);
}
}
@Override
public byte[] visit(StaticConstructorDefinition node) {
String ownerName = node.getOwner().getName();
ContextDependedClassWriter cw = classWriters.get(ownerName);
String descriptor = getDescriptor(node, 1, "V");
currentMV = cw.visitMethod(Opcodes.ACC_STATIC, "<clinit>", descriptor, null, null);
locals.clear();
IRNode body = node.getChild(0);
body.accept(this);
currentMV.visitInsn(Opcodes.RETURN);
currentMV.visitMaxs(0, 0);
currentMV.visitEnd();
return EMPTY_BYTE_ARRAY;
}
@Override
public byte[] visit(StaticMemberVariable node) {
// This node is for "reading" only. Writing is handled in BinaryOperator visit(see ASSIGN)
VariableInfo vi = node.getVariableInfo();
currentMV.visitFieldInsn(Opcodes.GETSTATIC,
asInternalName(vi.getOwner().getName()),
vi.name,
new String(vi.type.accept(this)));
return EMPTY_BYTE_ARRAY;
}
@Override
public byte[] visit(Switch node) {
node.getChild(0).accept(this);
int caseBlockIdx = node.getCaseBlockIndex();
Label defaultCase = new Label();
IRNode defaultBlock = null;
SortedMap<Integer, Pair<Label, IRNode>> cases = new TreeMap<>();
for (int i = 0; i < caseBlockIdx - 1; ++i) {
if (node.getChild(i + 1) instanceof Nothing) {
defaultBlock = node.getChild(i + caseBlockIdx);
} else {
Literal literal = (Literal) node.getChild(i + 1);
int value = 0;
if (literal.value instanceof Integer) {
value = (Integer) literal.value;
} else if (literal.value instanceof Short) {
value = (Short) literal.value;
} else if (literal.value instanceof Byte) {
value = (Byte) literal.value;
} else if (literal.value instanceof Character) {
value = (Character) literal.value;
}
cases.put(value, new Pair<>(new Label(), node.getChild(i + caseBlockIdx)));
}
}
Label breakLabel = new Label();
endLabels.push(breakLabel);
currentMV.visitLookupSwitchInsn(defaultCase,
cases.keySet().stream()
.mapToInt(Integer::intValue)
.toArray(),
cases.values().stream()
.map(p -> p.first)
.toArray(Label[]::new));
for (Pair<Label, IRNode> p : cases.values()) {
currentMV.visitLabel(p.first);
p.second.accept(this);
}
currentMV.visitLabel(defaultCase);
if (defaultBlock != null) {
defaultBlock.accept(this);
}
Label a = endLabels.pop();
assert breakLabel == a;
currentMV.visitLabel(breakLabel);
return EMPTY_BYTE_ARRAY;
}
@Override
public byte[] visit(TernaryOperator node) {
IRNode conditionBlock = node.getChild(TernaryOperator.TernaryPart.CONDITION.ordinal());
// get the condition type to emit correct if
conditionBlock.accept(this);
generateIf(Opcodes.IFEQ, node.getChild(TernaryOperator.TernaryPart.TRUE.ordinal()),
node.getChild(TernaryOperator.TernaryPart.FALSE.ordinal()));
return EMPTY_BYTE_ARRAY;
}
@Override
public byte[] visit(Throw node) {
node.getThowable().accept(this);
currentMV.visitInsn(Opcodes.ATHROW);
return EMPTY_BYTE_ARRAY;
}
@Override
public byte[] visit(TryCatchBlock node) {
List<? extends IRNode> children = node.getChildren();
IRNode tryBlock = children.get(0);
IRNode finallyBlock = children.get(1);
Label tryStart = new Label();
Label tryEnd = new Label();
Label finallyStart = new Label();
Label finallyEnd = new Label();
currentMV.visitLabel(tryStart);
tryBlock.accept(this);
currentMV.visitLabel(tryEnd);
finallyBlock.accept(this);
currentMV.visitJumpInsn(Opcodes.GOTO, finallyEnd);
VariableInfo exInfo = new VariableInfo("ex", currentClass,
new TypeKlass("java.lang.Throwable"), VariableInfo.LOCAL);
int index = locals.addLocal(exInfo);
for (int i = 2; i < children.size(); ++i) {
Label handlerBegin = new Label();
Label handlerEnd = new Label();
CatchBlock catchBlock = (CatchBlock) children.get(i);
for (Type t : catchBlock.throwables) {
currentMV.visitTryCatchBlock(tryStart, tryEnd, handlerBegin, asInternalName(t.getName()));
}
currentMV.visitLabel(handlerBegin);
catchBlock.accept(this);
currentMV.visitLabel(handlerEnd);
finallyBlock.accept(this);
currentMV.visitJumpInsn(Opcodes.GOTO, finallyEnd);
currentMV.visitTryCatchBlock(handlerBegin, handlerEnd, finallyStart, null);
}
currentMV.visitTryCatchBlock(tryStart, tryEnd, finallyStart, null);
currentMV.visitLabel(finallyStart);
currentMV.visitVarInsn(Opcodes.ASTORE, index);
finallyBlock.accept(this);
currentMV.visitVarInsn(Opcodes.ALOAD, index);
currentMV.visitInsn(Opcodes.ATHROW);
currentMV.visitLabel(finallyEnd);
return EMPTY_BYTE_ARRAY;
}
@Override
public byte[] visit(Type node) {
String name;
if (TypeList.isBuiltIn(node)) {
switch (node.getName()) {
case "void":
name = "V";
break;
case "boolean":
name = "Z";
break;
case "byte":
name = "B";
break;
case "char":
name = "C";
break;
case "short":
name = "S";
break;
case "int":
name = "I";
break;
case "long":
name = "J";
break;
case "float":
name = "F";
break;
case "double":
name = "D";
break;
default:
throw new IllegalArgumentException("Unknown type '" + node.getName());
}
} else {
name = "L" + asInternalName(node.getName()) + ";";
}
return name.getBytes();
}
@Override
public byte[] visit(TypeArray node) {
String name;
String prefix = Stream.generate(() -> "[")
.limit(node.dimensions)
.collect(Collectors.joining());
name = prefix + new String(node.getType().accept(this));
return name.getBytes();
}
@Override
public byte[] visit(UnaryOperator node) {
OperatorKind opKind = node.getOperationKind();
IRNode exp = node.getChild(0);
// argument expression is handled separately for inc and dec operators
if (opKind != OperatorKind.POST_DEC && opKind != OperatorKind.POST_INC
&& opKind != OperatorKind.PRE_DEC && opKind != OperatorKind.PRE_INC) {
exp.accept(this);
}
Type resultType = exp.getResultType();
switch (opKind) {
case NOT:
Label retTrueForNot = new Label();
Label endForNot = new Label();
currentMV.visitJumpInsn(Opcodes.IFEQ, retTrueForNot);
currentMV.visitInsn(Opcodes.ICONST_0);
currentMV.visitJumpInsn(Opcodes.GOTO, endForNot);
currentMV.visitLabel(retTrueForNot);
currentMV.visitInsn(Opcodes.ICONST_1);
currentMV.visitLabel(endForNot);
break;
case BIT_NOT:
if (resultType.equals(TypeList.LONG)) {
currentMV.visitLdcInsn(-1L);
currentMV.visitInsn(Opcodes.LXOR);
} else {
currentMV.visitInsn(Opcodes.ICONST_M1);
currentMV.visitInsn(Opcodes.IXOR);
}
break;
case UNARY_MINUS:
if (resultType.equals(TypeList.LONG)) {
currentMV.visitInsn(Opcodes.LNEG);
} else if (resultType.equals(TypeList.FLOAT)) {
currentMV.visitInsn(Opcodes.FNEG);
} else if (resultType.equals(TypeList.DOUBLE)) {
currentMV.visitInsn(Opcodes.DNEG);
} else {
currentMV.visitInsn(Opcodes.INEG);
}
break;
case UNARY_PLUS:
break;
case PRE_DEC:
lowerIncDecUnaryOperator(OperatorKind.SUB, true, node);
break;
case POST_DEC:
lowerIncDecUnaryOperator(OperatorKind.SUB, false, node);
break;
case PRE_INC:
lowerIncDecUnaryOperator(OperatorKind.ADD, true, node);
break;
case POST_INC:
lowerIncDecUnaryOperator(OperatorKind.ADD, false, node);
break;
default:
throw new RuntimeException("Incorrect unary operator: " + opKind);
}
return EMPTY_BYTE_ARRAY;
}
private void lowerIncDecUnaryOperator(OperatorKind kind, boolean isPrefix, IRNode node) {
IRNode var = node.getChild(0);
Literal one;
Type resultType = node.getResultType();
if (resultType.equals(TypeList.LONG)) {
one = new Literal(1L, TypeList.LONG);
} else if (resultType.equals(TypeList.INT)) {
one = new Literal(1, TypeList.INT);
} else if (resultType.equals(TypeList.SHORT)) {
one = new Literal((short) 1, TypeList.SHORT);
} else {
one = new Literal((byte) 1, TypeList.BYTE);
}
if (var instanceof NonStaticMemberVariable) {
IRNode holder = var.getChild(0);
Type type = holder.getResultType();
VariableInfo tmpInfo = new VariableInfo("tmpObject_" + tmpObject++,
currentClass, type, VariableInfo.LOCAL);
new Statement(new VariableInitialization(tmpInfo, holder), true).accept(this);
var = new NonStaticMemberVariable(new LocalVariable(tmpInfo),
((NonStaticMemberVariable) var).getVariableInfo());
}
BinaryOperator calculation = new BinaryOperator(kind, resultType, var, one);
BinaryOperator changeValue = new BinaryOperator(OperatorKind.ASSIGN, resultType, var, calculation);
Statement finalChangeStatement = new Statement(changeValue, true);
if (isPrefix) {
finalChangeStatement.accept(this);
var.accept(this);
} else {
var.accept(this);
finalChangeStatement.accept(this);
}
}
@Override
public byte[] visit(VariableDeclaration node) {
VariableInfo vi = node.getVariableInfo();
String ownerName = vi.getOwner().getName();
ContextDependedClassWriter cw = classWriters.get(ownerName);
String typeName = new String(vi.type.accept(this));
if (vi.isLocal()) {
locals.addLocal(vi);
} else {
FieldVisitor fv = cw.visitField(asAccessFlags(vi),
vi.name,
typeName,
null /* Generic */,
null /* Constant value */);
fv.visitEnd(); // doesn't need visitAnnotation and visitAttribute
}
return EMPTY_BYTE_ARRAY;
}
@Override
public byte[] visit(VariableDeclarationBlock node) {
return iterateBlock(node);
}
@Override
public byte[] visit(While node) {
Loop loop = node.getLoop();
loop.initialization.accept(this);
node.getChild(While.WhilePart.HEADER.ordinal()).accept(this);
Label currentLoopBegin = new Label();
beginLabels.push(currentLoopBegin);
currentMV.visitLabel(currentLoopBegin);
loop.condition.accept(this);
assert loop.condition.getResultType() == TypeList.BOOLEAN;
Label currentLoopEnd = new Label();
endLabels.push(currentLoopEnd);
currentMV.visitJumpInsn(Opcodes.IFEQ, currentLoopEnd);
node.getChild(While.WhilePart.BODY1.ordinal()).accept(this);
loop.manipulator.accept(this);
node.getChild(While.WhilePart.BODY2.ordinal()).accept(this);
node.getChild(While.WhilePart.BODY3.ordinal()).accept(this);
currentMV.visitJumpInsn(Opcodes.GOTO, currentLoopBegin);
currentMV.visitLabel(currentLoopEnd);
Label a = beginLabels.pop();
assert currentLoopBegin == a;
a = endLabels.pop();
assert currentLoopEnd == a;
return EMPTY_BYTE_ARRAY;
}
public byte[] getByteCode(String name) {
return context.get(name);
}
private static byte[] concat(byte[] a, byte[] b) {
byte[] r = new byte[a.length + b.length];
System.arraycopy(a, 0, r, 0, a.length);
System.arraycopy(b, 0, r, a.length, b.length);
return r;
}
private String argTypeToString(ArgumentDeclaration declarations) {
return new String(declarations.variableInfo.type.accept(this));
}
private byte[] iterateBlock(IRNode node) {
return node.getChildren().stream()
.map(ch -> ch.accept(this))
.reduce(new byte[0], ByteCodeVisitor::concat);
}
private String getDescriptor(IRNode node, int skipChilds, String returnType) {
return node.getChildren().stream()
.skip(skipChilds)
.map(c -> argTypeToString((ArgumentDeclaration)c))
.collect(Collectors.joining("", "(", ")" + returnType));
}
private static String asInternalName(String type) {
return type.replace('.', '/');
}
private static int asAccessFlags(TypeKlass klass) {
int attr = Opcodes.ACC_SUPER;
attr |= klass.isFinal() ? Opcodes.ACC_FINAL : 0;
attr |= klass.isAbstract() ? Opcodes.ACC_ABSTRACT : 0;
attr |= klass.isInterface() ? Opcodes.ACC_INTERFACE : 0;
return attr;
}
private static int asAccessFlags(FunctionInfo fi) {
int result = asAccessFlags((Symbol) fi);
result |= ProductionParams.enableStrictFP.value() ? Opcodes.ACC_STRICT : 0;
result |= fi.isSynchronized() ? Opcodes.ACC_SYNCHRONIZED : 0;
return result;
}
private static int asAccessFlags(Symbol s) {
int attr = 0;
attr |= s.isPublic() ? Opcodes.ACC_PUBLIC : 0;
attr |= s.isPrivate() ? Opcodes.ACC_PRIVATE : 0;
attr |= s.isProtected() ? Opcodes.ACC_PROTECTED : 0;
attr |= s.isStatic() ? Opcodes.ACC_STATIC : 0;
attr |= s.isFinal() ? Opcodes.ACC_FINAL : 0;
return attr;
}
private static class LocalVariablesTable {
private int nextLocalIndex = 0;
// a map keeping local variable table index for a local variable
private final HashMap<String, Integer> locals = new HashMap<>();
public int addLocal(VariableInfo vi) {
int indexToReturn = nextLocalIndex;
locals.put(vi.name, nextLocalIndex++);
if (vi.type.equals(TypeList.DOUBLE) || vi.type.equals(TypeList.LONG)) {
nextLocalIndex++;
}
return indexToReturn;
}
public int getLocalIndex(VariableInfo vi) {
if (!locals.containsKey(vi.name)) {
throw new NoSuchElementException(vi.name);
}
return locals.get(vi.name);
}
public void clear() {
locals.clear();
nextLocalIndex = 0;
}
public void initFunctionArguments(FunctionInfo info) {
initArguments(null, info);
}
public void initConstructorArguments(TypeKlass owner, FunctionInfo info) {
Objects.requireNonNull(owner, "owner is null");
initArguments(owner, info);
}
private void initArguments(TypeKlass owner, FunctionInfo info) {
clear();
if (owner != null) {
addLocal(new VariableInfo("this", owner, owner, VariableInfo.LOCAL | VariableInfo.INITIALIZED));
}
for (VariableInfo vi : info.argTypes) {
addLocal(vi);
}
}
}
private static class GeneratedClassesContext extends java.lang.ClassLoader {
private final HashMap<String, byte[]> byteCodes = new HashMap<>();
public void register(String name, byte[] bytecode) {
defineClass(name, bytecode, 0, bytecode.length);
byteCodes.put(name, bytecode);
}
public byte[] get(String name) {
return byteCodes.get(name);
}
}
private static class ContextDependedClassWriter extends ClassWriter {
private final GeneratedClassesContext context;
public ContextDependedClassWriter(GeneratedClassesContext context, int flags) {
super(flags);
this.context = context;
}
protected String getCommonSuperClass(String className1, String className2) {
Class<?> klass1;
Class<?> klass2;
try {
klass1 = Class.forName(className1.replace('/', '.'), false, context);
klass2 = Class.forName(className2.replace('/', '.'), false, context);
} catch (ClassNotFoundException e) {
throw new Error("can not get common supper for " + className1
+ " and " + className2, e);
}
if (klass1.isAssignableFrom(klass2)) {
return className1;
} else if (klass2.isAssignableFrom(klass1)) {
return className2;
} else if (!klass1.isInterface() && !klass2.isInterface()) {
do {
klass1 = klass1.getSuperclass();
} while (!klass1.isAssignableFrom(klass2));
return asInternalName(className1);
} else {
return "java/lang/Object";
}
}
}
}