codegeneration.jrag

JDK1.4编译器后端

  // emitInvoke

  public void MethodDecl.emitInvokeMethod(CodeGeneration gen, TypeDecl hostType) {
    if(hostType.isInterfaceDecl()) {
      int size = type().variableSize() - 1;
      for(int i = 0; i < getNumParameter(); i++)
        size -= getParameter(i).type().variableSize();
      String classname = hostType.constantPoolName();
      String      desc = descName();
      String      name = name();
      int index = gen.constantPool().addInterfaceMethodref(classname, name, desc);
      int numArg = 1; // instance
      for(int i = 0; i < getNumParameter(); i++)
        numArg += getParameter(i).type().variableSize();
      gen.emit(Bytecode.INVOKEINTERFACE, size).add2(index).add(numArg).add(0);
    }
    else {
      String classname = hostType.constantPoolName();
      String      desc = descName();
      String      name = name();
      int index = gen.constantPool().addMethodref(classname, name, desc);
      if(isStatic()) {
        int size = type().variableSize();
        for(int i = 0; i < getNumParameter(); i++)
          size -= getParameter(i).type().variableSize();
        gen.emit(Bytecode.INVOKESTATIC, size).add2(index);
      }
      else {
        int size = type().variableSize() - 1;
        for(int i = 0; i < getNumParameter(); i++)
          size -= getParameter(i).type().variableSize();
        gen.emit(Bytecode.INVOKEVIRTUAL, size).add2(index);
      }
    }
  }
  
  public void MethodDecl.emitInvokeSpecialMethod(CodeGeneration gen, TypeDecl hostType) {
    String classname = hostType.constantPoolName();
    String      desc = descName();
    String      name = name();
    int index = gen.constantPool().addMethodref(classname, name, desc);
    int size = type().variableSize() - 1;
    for(int i = 0; i < getNumParameter(); i++)
      size -= getParameter(i).type().variableSize();
    gen.emit(Bytecode.INVOKESPECIAL, size).add2(index);
  }

  public void ConstructorDecl.emitInvokeConstructor(CodeGeneration gen) {
    int size = -1;
    for(int i = 0; i < getNumParameter(); i++)
      size -= getParameter(i).type().variableSize();
    if(hostType().needsEnclosing())
      size--;
    if(hostType().needsSuperEnclosing()) {
      size--;
    }
    String classname = hostType().constantPoolName();
    String      desc = descName();
    String      name = "<init>";
    int index = gen.constantPool().addMethodref(classname, name, desc);
    gen.emit(Bytecode.INVOKESPECIAL, size).add2(index);
  }

  // emitNew

  public void TypeDecl.emitNew(CodeGeneration gen) {
    int index = gen.constantPool().addClass(constantPoolName());
    gen.emit(Bytecode.NEW).add2(index);
  }
}
aspect CodeGenerationConversions {
  void TypeDecl.emitAssignConvTo(CodeGeneration gen, TypeDecl type) {
    if(!type.isIntegralType() || !isIntegralType() || type.isLong())
      emitCastTo(gen, type);
  }
  
  void TypeDecl.emitCastTo(CodeGeneration gen, TypeDecl type) { throw new Error("CastTo not implemented for " + getClass().getName()); }
  void ReferenceType.emitCastTo(CodeGeneration gen, TypeDecl type) { if(!instanceOf(type) && !type.isNull()) gen.emitCheckCast(type); }
  void IntType.emitCastTo(CodeGeneration gen, TypeDecl type)      { type.intToThis(gen); }
  void FloatType.emitCastTo(CodeGeneration gen, TypeDecl type)    { type.floatToThis(gen); }
  void DoubleType.emitCastTo(CodeGeneration gen, TypeDecl type)   { type.doubleToThis(gen); }
  void LongType.emitCastTo(CodeGeneration gen, TypeDecl type)     { type.longToThis(gen); }
  void ByteType.emitCastTo(CodeGeneration gen, TypeDecl type)     { type.byteToThis(gen); }
  void ShortType.emitCastTo(CodeGeneration gen, TypeDecl type)    { type.shortToThis(gen); }
  void CharType.emitCastTo(CodeGeneration gen, TypeDecl type)     { type.charToThis(gen); }
  void BooleanType.emitCastTo(CodeGeneration gen, TypeDecl type)  { }
  void NullType.emitCastTo(CodeGeneration gen, TypeDecl type)     { }

  void TypeDecl.intToThis(CodeGeneration gen) { throw new Error("intToThis not implemented for " + getClass().getName()); }
  void IntType.intToThis(CodeGeneration gen)    { }
  void LongType.intToThis(CodeGeneration gen)   { gen.emit(Bytecode.I2L); }
  void FloatType.intToThis(CodeGeneration gen)  { gen.emit(Bytecode.I2F); }
  void DoubleType.intToThis(CodeGeneration gen) { gen.emit(Bytecode.I2D); }
  void ByteType.intToThis(CodeGeneration gen)   { gen.emit(Bytecode.I2B); }
  void CharType.intToThis(CodeGeneration gen)   { gen.emit(Bytecode.I2C); }
  void ShortType.intToThis(CodeGeneration gen)  { gen.emit(Bytecode.I2S); }

  void TypeDecl.floatToThis(CodeGeneration gen) { throw new Error("floatToThis not implemented for " + getClass().getName()); }
  void IntType.floatToThis(CodeGeneration gen)    { gen.emit(Bytecode.F2I); }
  void ByteType.floatToThis(CodeGeneration gen)   { gen.emit(Bytecode.F2I).emit(Bytecode.I2B); }
  void ShortType.floatToThis(CodeGeneration gen)  { gen.emit(Bytecode.F2I).emit(Bytecode.I2S); }
  void CharType.floatToThis(CodeGeneration gen)   { gen.emit(Bytecode.F2I).emit(Bytecode.I2C); }
  void FloatType.floatToThis(CodeGeneration gen)  { }
  void LongType.floatToThis(CodeGeneration gen)   { gen.emit(Bytecode.F2L); }
  void DoubleType.floatToThis(CodeGeneration gen) { gen.emit(Bytecode.F2D); }

  void TypeDecl.doubleToThis(CodeGeneration gen) { throw new Error("doubleToThis not implemented for " + getClass().getName()); }
  void IntType.doubleToThis(CodeGeneration gen)    { gen.emit(Bytecode.D2I); }
  void ByteType.doubleToThis(CodeGeneration gen)   { gen.emit(Bytecode.D2I).emit(Bytecode.I2B); }
  void ShortType.doubleToThis(CodeGeneration gen)  { gen.emit(Bytecode.D2I).emit(Bytecode.I2S); }
  void CharType.doubleToThis(CodeGeneration gen)   { gen.emit(Bytecode.D2I).emit(Bytecode.I2C); }
  void FloatType.doubleToThis(CodeGeneration gen)  { gen.emit(Bytecode.D2F); }
  void LongType.doubleToThis(CodeGeneration gen)   { gen.emit(Bytecode.D2L); }
  void DoubleType.doubleToThis(CodeGeneration gen) { }

  void TypeDecl.longToThis(CodeGeneration gen) { throw new Error("longToThis not implemented for " + getClass().getName()); }
  void IntType.longToThis(CodeGeneration gen)    { gen.emit(Bytecode.L2I); }
  void ByteType.longToThis(CodeGeneration gen)   { gen.emit(Bytecode.L2I).emit(Bytecode.I2B); }
  void ShortType.longToThis(CodeGeneration gen)  { gen.emit(Bytecode.L2I).emit(Bytecode.I2S); }
  void CharType.longToThis(CodeGeneration gen)   { gen.emit(Bytecode.L2I).emit(Bytecode.I2C); }
  void FloatType.longToThis(CodeGeneration gen)  { gen.emit(Bytecode.L2F); }
  void LongType.longToThis(CodeGeneration gen)   { }
  void DoubleType.longToThis(CodeGeneration gen) { gen.emit(Bytecode.L2D); }

  void TypeDecl.byteToThis(CodeGeneration gen) { throw new Error("byteToThis not implemented for " + getClass().getName()); }
  void IntegralType.byteToThis(CodeGeneration gen) { }
  void CharType.byteToThis(CodeGeneration gen)     { gen.emit(Bytecode.I2C); }
  void FloatType.byteToThis(CodeGeneration gen)    { gen.emit(Bytecode.I2F); }
  void LongType.byteToThis(CodeGeneration gen)     { gen.emit(Bytecode.I2L); }
  void DoubleType.byteToThis(CodeGeneration gen)   { gen.emit(Bytecode.I2D);}
  
  void TypeDecl.charToThis(CodeGeneration gen) { throw new Error("charToThis not implemented for " + getClass().getName()); }
  void IntegralType.charToThis(CodeGeneration gen) { }
  void ByteType.charToThis(CodeGeneration gen)     { gen.emit(Bytecode.I2B); }
  void ShortType.charToThis(CodeGeneration gen)    { gen.emit(Bytecode.I2S); }
  void FloatType.charToThis(CodeGeneration gen)    { gen.emit(Bytecode.I2F); }
  void LongType.charToThis(CodeGeneration gen)     { gen.emit(Bytecode.I2L); }
  void DoubleType.charToThis(CodeGeneration gen)   { gen.emit(Bytecode.I2D);}
  
  void TypeDecl.shortToThis(CodeGeneration gen) { throw new Error("shortToThis not implemented for " + getClass().getName()); }
  void IntegralType.shortToThis(CodeGeneration gen) { }
  void ByteType.shortToThis(CodeGeneration gen)     { gen.emit(Bytecode.I2B); }
  void CharType.shortToThis(CodeGeneration gen)     { gen.emit(Bytecode.I2C); }
  void FloatType.shortToThis(CodeGeneration gen)    { gen.emit(Bytecode.I2F); }
  void LongType.shortToThis(CodeGeneration gen)     { gen.emit(Bytecode.I2L); }
  void DoubleType.shortToThis(CodeGeneration gen)   { gen.emit(Bytecode.I2D); }

}

aspect CodeGenerationBinaryOperations {
  // emit the desired operation on the operand(s) on the stack
  void Expr.emitOperation(CodeGeneration gen) {error();}
  // unary
  void MinusExpr.emitOperation(CodeGeneration gen)  { type().neg(gen); }
  void PlusExpr.emitOperation(CodeGeneration gen)   { }
  void BitNotExpr.emitOperation(CodeGeneration gen) { type().bitNot(gen); }
  void LogNotExpr.emitOperation(CodeGeneration gen) { type().logNot(gen); }

  // binary
  void AddExpr.emitOperation(CodeGeneration gen) { type().add(gen); }
  void SubExpr.emitOperation(CodeGeneration gen) { type().sub(gen); }
  void MulExpr.emitOperation(CodeGeneration gen) { type().mul(gen); }
  void DivExpr.emitOperation(CodeGeneration gen) { type().div(gen); }
  void ModExpr.emitOperation(CodeGeneration gen) { type().rem(gen); }

  void LShiftExpr.emitOperation(CodeGeneration gen)     { type().shl(gen); }
  void RShiftExpr.emitOperation(CodeGeneration gen)     { type().shr(gen); }
  void URShiftExpr.emitOperation(CodeGeneration gen)    { type().ushr(gen); }
  void OrBitwiseExpr.emitOperation(CodeGeneration gen)  { type().bitor(gen); }
  void AndBitwiseExpr.emitOperation(CodeGeneration gen) { type().bitand(gen); }
  void XorBitwiseExpr.emitOperation(CodeGeneration gen) { type().bitxor(gen); }
  
  void TypeDecl.neg(CodeGeneration gen) { error(); }
  void IntegralType.neg(CodeGeneration gen) { gen.emit(Bytecode.INEG); }
  void LongType.neg(CodeGeneration gen)     { gen.emit(Bytecode.LNEG); }
  void FloatType.neg(CodeGeneration gen)    { gen.emit(Bytecode.FNEG); }
  void DoubleType.neg(CodeGeneration gen)   { gen.emit(Bytecode.DNEG); }

  void TypeDecl.bitNot(CodeGeneration gen) { error(); }
  void IntegralType.bitNot(CodeGeneration gen) { gen.emit(Bytecode.ICONST_M1).emit(Bytecode.IXOR); }
  void LongType.bitNot(CodeGeneration gen)     { emitPushConstant(gen, -1); gen.emit(Bytecode.LXOR); }

  void TypeDecl.logNot(CodeGeneration gen) { error();}
  void BooleanType.logNot(CodeGeneration gen) { gen.emit(Bytecode.ICONST_1).emit(Bytecode.IXOR); }

  void TypeDecl.add(CodeGeneration gen) {error();}
  void LongType.add(CodeGeneration gen) {gen.emit(Bytecode.LADD);}
  void FloatType.add(CodeGeneration gen) {gen.emit(Bytecode.FADD);}
  void DoubleType.add(CodeGeneration gen) {gen.emit(Bytecode.DADD);}
  void IntegralType.add(CodeGeneration gen) {gen.emit(Bytecode.IADD);}

  void TypeDecl.sub(CodeGeneration gen) {error();}
  void LongType.sub(CodeGeneration gen) {gen.emit(Bytecode.LSUB);}
  void FloatType.sub(CodeGeneration gen) {gen.emit(Bytecode.FSUB);}
  void DoubleType.sub(CodeGeneration gen) {gen.emit(Bytecode.DSUB);}
  void IntegralType.sub(CodeGeneration gen) {gen.emit(Bytecode.ISUB);}

  void TypeDecl.mul(CodeGeneration gen) {error();}
  void LongType.mul(CodeGeneration gen) {gen.emit(Bytecode.LMUL);}
  void FloatType.mul(CodeGeneration gen) {gen.emit(Bytecode.FMUL);}
  void DoubleType.mul(CodeGeneration gen) {gen.emit(Bytecode.DMUL);}
  void IntegralType.mul(CodeGeneration gen) {gen.emit(Bytecode.IMUL);}

  void TypeDecl.div(CodeGeneration gen) {error();}
  void LongType.div(CodeGeneration gen) {gen.emit(Bytecode.LDIV);}
  void FloatType.div(CodeGeneration gen) {gen.emit(Bytecode.FDIV);}
  void DoubleType.div(CodeGeneration gen) {gen.emit(Bytecode.DDIV);}
  void IntegralType.div(CodeGeneration gen) {gen.emit(Bytecode.IDIV);}

  void TypeDecl.rem(CodeGeneration gen) {error();}
  void LongType.rem(CodeGeneration gen) {gen.emit(Bytecode.LREM);}
  void FloatType.rem(CodeGeneration gen) {gen.emit(Bytecode.FREM);}
  void DoubleType.rem(CodeGeneration gen) {gen.emit(Bytecode.DREM);}
  void IntegralType.rem(CodeGeneration gen) {gen.emit(Bytecode.IREM);}

  void TypeDecl.shl(CodeGeneration gen) {error();}
  void LongType.shl(CodeGeneration gen) {gen.emit(Bytecode.LSHL);}
  void IntegralType.shl(CodeGeneration gen) {gen.emit(Bytecode.ISHL);}

  void TypeDecl.shr(CodeGeneration gen) {error();}
  void LongType.shr(CodeGeneration gen) {gen.emit(Bytecode.LSHR);}
  void IntegralType.shr(CodeGeneration gen) {gen.emit(Bytecode.ISHR);}

  void TypeDecl.ushr(CodeGeneration gen) {error();}
  void LongType.ushr(CodeGeneration gen) {gen.emit(Bytecode.LUSHR);}
  void IntegralType.ushr(CodeGeneration gen) {gen.emit(Bytecode.IUSHR);}

  void TypeDecl.bitand(CodeGeneration gen) {error();}
  void LongType.bitand(CodeGeneration gen) {gen.emit(Bytecode.LAND);}
  void IntegralType.bitand(CodeGeneration gen) {gen.emit(Bytecode.IAND);}
  void BooleanType.bitand(CodeGeneration gen) {gen.emit(Bytecode.IAND);}

  void TypeDecl.bitor(CodeGeneration gen) {error();}
  void LongType.bitor(CodeGeneration gen) {gen.emit(Bytecode.LOR);}
  void IntegralType.bitor(CodeGeneration gen) {gen.emit(Bytecode.IOR);}
  void BooleanType.bitor(CodeGeneration gen) {gen.emit(Bytecode.IOR);}

  void TypeDecl.bitxor(CodeGeneration gen) {error();}
  void LongType.bitxor(CodeGeneration gen) {gen.emit(Bytecode.LXOR);}
  void IntegralType.bitxor(CodeGeneration gen) {gen.emit(Bytecode.IXOR);}
  void BooleanType.bitxor(CodeGeneration gen) {gen.emit(Bytecode.IXOR);}
}

aspect CodeGenerationBranch {
  public void TypeDecl.branchLT(CodeGeneration gen, int label) { throw new Error("branchLT not supported for " + getClass().getName()); }
  public void DoubleType.branchLT(CodeGeneration gen, int label)   { gen.emit(Bytecode.DCMPG).emitCompare(Bytecode.IFLT, label); }
  public void FloatType.branchLT(CodeGeneration gen, int label)    { gen.emit(Bytecode.FCMPG).emitCompare(Bytecode.IFLT, label); }
  public void LongType.branchLT(CodeGeneration gen, int label)     { gen.emit(Bytecode.LCMP).emitCompare(Bytecode.IFLT, label); }
  public void IntegralType.branchLT(CodeGeneration gen, int label) { gen.emitCompare(Bytecode.IF_ICMPLT, label); }
    
  public void TypeDecl.branchLE(CodeGeneration gen, int label) { throw new Error("branchLE not supported for " + getClass().getName()); }
  public void DoubleType.branchLE(CodeGeneration gen, int label)   { gen.emit(Bytecode.DCMPG).emitCompare(Bytecode.IFLE, label); }
  public void FloatType.branchLE(CodeGeneration gen, int label)    { gen.emit(Bytecode.FCMPG).emitCompare(Bytecode.IFLE, label); }
  public void LongType.branchLE(CodeGeneration gen, int label)     { gen.emit(Bytecode.LCMP).emitCompare(Bytecode.IFLE, label); }
  public void IntegralType.branchLE(CodeGeneration gen, int label) { gen.emitCompare(Bytecode.IF_ICMPLE, label); }
  
  public void TypeDecl.branchGE(CodeGeneration gen, int label) { throw new Error("branchGE not supported for " + getClass().getName()); }
  public void DoubleType.branchGE(CodeGeneration gen, int label)   { gen.emit(Bytecode.DCMPL).emitCompare(Bytecode.IFGE, label); }
  public void FloatType.branchGE(CodeGeneration gen, int label)    { gen.emit(Bytecode.FCMPL).emitCompare(Bytecode.IFGE, label); }
  public void LongType.branchGE(CodeGeneration gen, int label)     { gen.emit(Bytecode.LCMP).emitCompare(Bytecode.IFGE, label); }
  public void IntegralType.branchGE(CodeGeneration gen, int label) { gen.emitCompare(Bytecode.IF_ICMPGE, label); }
  
  public void TypeDecl.branchGT(CodeGeneration gen, int label) { throw new Error("branchGT not supported for " + getClass().getName()); }
  public void DoubleType.branchGT(CodeGeneration gen, int label)   { gen.emit(Bytecode.DCMPL).emitCompare(Bytecode.IFGT, label); }
  public void FloatType.branchGT(CodeGeneration gen, int label)    { gen.emit(Bytecode.FCMPL).emitCompare(Bytecode.IFGT, label); }
  public void LongType.branchGT(CodeGeneration gen, int label)     { gen.emit(Bytecode.LCMP).emitCompare(Bytecode.IFGT, label); }
  public void IntegralType.branchGT(CodeGeneration gen, int label) { gen.emitCompare(Bytecode.IF_ICMPGT, label); }

  public void TypeDecl.branchEQ(CodeGeneration gen, int label) { throw new Error("branchEQ not supported for " + getClass().getName()); }
  public void DoubleType.branchEQ(CodeGeneration gen, int label)    { gen.emit(Bytecode.DCMPL).emitCompare(Bytecode.IFEQ, label); }
  public void FloatType.branchEQ(CodeGeneration gen, int label)     { gen.emit(Bytecode.FCMPL).emitCompare(Bytecode.IFEQ, label); }
  public void LongType.branchEQ(CodeGeneration gen, int label)      { gen.emit(Bytecode.LCMP).emitCompare(Bytecode.IFEQ, label); }
  public void IntegralType.branchEQ(CodeGeneration gen, int label)  { gen.emitCompare(Bytecode.IF_ICMPEQ, label); }
  public void BooleanType.branchEQ(CodeGeneration gen, int label)   { gen.emitCompare(Bytecode.IF_ICMPEQ, label); }
  public void ReferenceType.branchEQ(CodeGeneration gen, int label) { gen.emitCompare(Bytecode.IF_ACMPEQ, label); }
  public void NullType.branchEQ(CodeGeneration gen, int label)      { gen.emitCompare(Bytecode.IF_ACMPEQ, label); }
  
  public void TypeDecl.branchNE(CodeGeneration gen, int label) { throw new Error("branchNE not supported for " + getClass().getName()); }
  public void DoubleType.branchNE(CodeGeneration gen, int label)    { gen.emit(Bytecode.DCMPL).emitCompare(Bytecode.IFNE, label); }
  public void FloatType.branchNE(CodeGeneration gen, int label)     { gen.emit(Bytecode.FCMPL).emitCompare(Bytecode.IFNE, label); }
  public void LongType.branchNE(CodeGeneration gen, int label)      { gen.emit(Bytecode.LCMP).emitCompare(Bytecode.IFNE, label); }
  public void IntegralType.branchNE(CodeGeneration gen, int label)  { gen.emitCompare(Bytecode.IF_ICMPNE, label); }
  public void BooleanType.branchNE(CodeGeneration gen, int label)   { gen.emitCompare(Bytecode.IF_ICMPNE, label); }
  public void ReferenceType.branchNE(CodeGeneration gen, int label) { gen.emitCompare(Bytecode.IF_ACMPNE, label); }
  public void NullType.branchNE(CodeGeneration gen, int label)      { gen.emitCompare(Bytecode.IF_ACMPNE, label); }
}