diff --git a/src/de/inetsoftware/jwebassembly/module/BranchManger.java b/src/de/inetsoftware/jwebassembly/module/BranchManger.java index 3ea1641..b81de36 100644 --- a/src/de/inetsoftware/jwebassembly/module/BranchManger.java +++ b/src/de/inetsoftware/jwebassembly/module/BranchManger.java @@ -244,8 +244,8 @@ class BranchManger { gotoBlock.op = JavaBlockOperator.LOOP; gotoBlock.endPosition = conditionEnd; - instructions.add( i, new WasmBlockInstruction( WasmBlockOperator.BR, 0, conditionNew ) ); - instructions.add( conditionIdx++, new WasmBlockInstruction( WasmBlockOperator.BR_IF, 1, conditionNew ) ); + instructions.add( i, new WasmBlockInstruction( WasmBlockOperator.BR, 0, conditionNew, gotoBlock.lineNumber ) ); + instructions.add( conditionIdx++, new WasmBlockInstruction( WasmBlockOperator.BR_IF, 1, conditionNew, gotoBlock.lineNumber ) ); } /** @@ -743,15 +743,18 @@ class BranchManger { void handle( CodeInputStream byteCode ) { int codePosition = -1; for( int idx = 0; idx < instructions.size(); idx++ ) { - int nextCodePosition = instructions.get( idx ).getCodePosition(); + WasmInstruction instr = instructions.get( idx ); + int lineNumber; + int nextCodePosition = instr.getCodePosition(); if( nextCodePosition <= codePosition ) { continue; } else { codePosition = nextCodePosition; + lineNumber = instr.getLineNumber(); } - idx = root.handle( codePosition, instructions, idx ); + idx = root.handle( codePosition, instructions, idx, lineNumber ); } - root.handle( byteCode.getCodePosition(), instructions, instructions.size() ); + root.handle( byteCode.getCodePosition(), instructions, instructions.size(), byteCode.getLineNumber() ); } /** @@ -947,20 +950,22 @@ class BranchManger { * the target for instructions * @param idx * index in the current instruction + * @param lineNumber + * the line number in the Java source code * @return the new index in the instructions */ - int handle( int codePosition, List instructions, int idx ) { + int handle( int codePosition, List instructions, int idx, int lineNumber ) { if( codePosition < startPos || codePosition > endPos ) { return idx; } if( codePosition == startPos && startOp != null ) { - instructions.add( idx++, new WasmBlockInstruction( startOp, data, codePosition ) ); + instructions.add( idx++, new WasmBlockInstruction( startOp, data, codePosition, lineNumber ) ); } for( BranchNode branch : this ) { - idx = branch.handle( codePosition, instructions, idx ); + idx = branch.handle( codePosition, instructions, idx, lineNumber ); } if( codePosition == endPos && endOp != null ) { - instructions.add( idx++, new WasmBlockInstruction( endOp, null, codePosition ) ); + instructions.add( idx++, new WasmBlockInstruction( endOp, null, codePosition, lineNumber ) ); } return idx; } diff --git a/src/de/inetsoftware/jwebassembly/module/JavaMethodWasmCodeBuilder.java b/src/de/inetsoftware/jwebassembly/module/JavaMethodWasmCodeBuilder.java index 4c1cde0..4db8ac0 100644 --- a/src/de/inetsoftware/jwebassembly/module/JavaMethodWasmCodeBuilder.java +++ b/src/de/inetsoftware/jwebassembly/module/JavaMethodWasmCodeBuilder.java @@ -40,7 +40,7 @@ import de.inetsoftware.jwebassembly.wasm.WasmBlockOperator; */ class JavaMethodWasmCodeBuilder extends WasmCodeBuilder { - private BranchManger branchManager = new BranchManger( getInstructions() ); + private BranchManger branchManager = new BranchManger( getInstructions() ); /** * Build the wasm instructions @@ -67,7 +67,6 @@ class JavaMethodWasmCodeBuilder extends WasmCodeBuilder { } } - /** * Write the byte code of a method. * @@ -80,17 +79,18 @@ class JavaMethodWasmCodeBuilder extends WasmCodeBuilder { * @throws WasmException * if some Java code can't converted */ - private void writeCode( CodeInputStream byteCode, ConstantPool constantPool, boolean hasReturn ) throws WasmException { + private void writeCode( CodeInputStream byteCode, ConstantPool constantPool, boolean hasReturn ) throws WasmException { try { boolean wide = false; while( byteCode.available() > 0 ) { int codePos = byteCode.getCodePosition(); + int lineNumber = byteCode.getLineNumber(); int op = byteCode.readUnsignedByte(); switch( op ) { case 0: // nop break; case 1: // aconst_null - addStructInstruction( StructOperator.NULL, null, null, codePos ); + addStructInstruction( StructOperator.NULL, null, null, codePos, lineNumber ); break; case 2: // iconst_m1 case 3: // iconst_0 @@ -99,142 +99,142 @@ class JavaMethodWasmCodeBuilder extends WasmCodeBuilder { case 6: // iconst_3 case 7: // iconst_4 case 8: // iconst_5 - addConstInstruction( Integer.valueOf( op - 3 ), ValueType.i32, codePos ); + addConstInstruction( Integer.valueOf( op - 3 ), ValueType.i32, codePos, lineNumber ); break; - case 9: // lconst_0 + case 9: // lconst_0 case 10: // lconst_1 - addConstInstruction( Long.valueOf( op - 9 ), ValueType.i64, codePos ); + addConstInstruction( Long.valueOf( op - 9 ), ValueType.i64, codePos, lineNumber ); break; case 11: // fconst_0 case 12: // fconst_1 case 13: // fconst_2 - addConstInstruction( Float.valueOf( op - 11 ), ValueType.f32, codePos ); + addConstInstruction( Float.valueOf( op - 11 ), ValueType.f32, codePos, lineNumber ); break; case 14: // dconst_0 case 15: // dconst_1 - addConstInstruction( Double.valueOf( op - 14 ), ValueType.f64, codePos ); + addConstInstruction( Double.valueOf( op - 14 ), ValueType.f64, codePos, lineNumber ); break; case 16: // bipush - addConstInstruction( Integer.valueOf( byteCode.readByte() ), ValueType.i32, codePos ); + addConstInstruction( Integer.valueOf( byteCode.readByte() ), ValueType.i32, codePos, lineNumber ); break; case 17: // sipush - addConstInstruction( Integer.valueOf( byteCode.readShort() ), ValueType.i32, codePos ); + addConstInstruction( Integer.valueOf( byteCode.readShort() ), ValueType.i32, codePos, lineNumber ); break; case 18: // ldc - addConstInstruction( (Number)constantPool.get( byteCode.readUnsignedByte() ), codePos ); + addConstInstruction( (Number)constantPool.get( byteCode.readUnsignedByte() ), codePos, lineNumber ); break; case 19: // ldc_w case 20: // ldc2_w - addConstInstruction( (Number)constantPool.get( byteCode.readUnsignedShort() ), codePos ); + addConstInstruction( (Number)constantPool.get( byteCode.readUnsignedShort() ), codePos, lineNumber ); break; case 21: // iload - addLoadStoreInstruction( ValueType.i32, true, byteCode.readUnsignedIndex( wide ), codePos ); + addLoadStoreInstruction( ValueType.i32, true, byteCode.readUnsignedIndex( wide ), codePos, lineNumber ); break; case 22: // lload - addLoadStoreInstruction( ValueType.i64, true, byteCode.readUnsignedIndex( wide ), codePos ); + addLoadStoreInstruction( ValueType.i64, true, byteCode.readUnsignedIndex( wide ), codePos, lineNumber ); break; case 23: // fload - addLoadStoreInstruction( ValueType.f32, true, byteCode.readUnsignedIndex( wide ), codePos ); + addLoadStoreInstruction( ValueType.f32, true, byteCode.readUnsignedIndex( wide ), codePos, lineNumber ); break; case 24: // dload - addLoadStoreInstruction( ValueType.f64, true, byteCode.readUnsignedIndex( wide ), codePos ); + addLoadStoreInstruction( ValueType.f64, true, byteCode.readUnsignedIndex( wide ), codePos, lineNumber ); break; case 25: // aload - addLoadStoreInstruction( ValueType.anyref, true, byteCode.readUnsignedIndex( wide ), codePos ); + addLoadStoreInstruction( ValueType.anyref, true, byteCode.readUnsignedIndex( wide ), codePos, lineNumber ); break; case 26: // iload_0 case 27: // iload_1 case 28: // iload_2 case 29: // iload_3 - addLoadStoreInstruction( ValueType.i32, true, op - 26, codePos ); + addLoadStoreInstruction( ValueType.i32, true, op - 26, codePos, lineNumber ); break; case 30: // lload_0 case 31: // lload_1 case 32: // lload_2 case 33: // lload_3 - addLoadStoreInstruction( ValueType.i64, true, op - 30, codePos ); + addLoadStoreInstruction( ValueType.i64, true, op - 30, codePos, lineNumber ); break; case 34: // fload_0 case 35: // fload_1 case 36: // fload_2 case 37: // fload_3 - addLoadStoreInstruction( ValueType.f32, true, op - 34, codePos ); + addLoadStoreInstruction( ValueType.f32, true, op - 34, codePos, lineNumber ); break; case 38: // dload_0 case 39: // dload_1 case 40: // dload_2 case 41: // dload_3 - addLoadStoreInstruction( ValueType.f64, true, op - 38, codePos ); + addLoadStoreInstruction( ValueType.f64, true, op - 38, codePos, lineNumber ); break; case 42: //aload_0 case 43: //aload_1 case 44: //aload_2 case 45: //aload_3 - addLoadStoreInstruction( ValueType.anyref, true, op - 42, codePos ); + addLoadStoreInstruction( ValueType.anyref, true, op - 42, codePos, lineNumber ); break; case 46: // iaload - addArrayInstruction( ArrayOperator.GET, ValueType.i32, codePos ); + addArrayInstruction( ArrayOperator.GET, ValueType.i32, codePos, lineNumber ); break; case 47: // laload - addArrayInstruction( ArrayOperator.GET, ValueType.i64, codePos ); + addArrayInstruction( ArrayOperator.GET, ValueType.i64, codePos, lineNumber ); break; case 48: // faload - addArrayInstruction( ArrayOperator.GET, ValueType.f32, codePos ); + addArrayInstruction( ArrayOperator.GET, ValueType.f32, codePos, lineNumber ); break; case 49: // daload - addArrayInstruction( ArrayOperator.GET, ValueType.f64, codePos ); + addArrayInstruction( ArrayOperator.GET, ValueType.f64, codePos, lineNumber ); break; case 50: // aaload AnyType storeType = findPreviousPushInstructionPushValueType(); - addArrayInstruction( ArrayOperator.GET, storeType, codePos ); + addArrayInstruction( ArrayOperator.GET, storeType, codePos, lineNumber ); break; case 51: // baload - addArrayInstruction( ArrayOperator.GET, ValueType.i8, codePos ); + addArrayInstruction( ArrayOperator.GET, ValueType.i8, codePos, lineNumber ); break; case 52: // caload - addArrayInstruction( ArrayOperator.GET, ValueType.i16, codePos ); + addArrayInstruction( ArrayOperator.GET, ValueType.i16, codePos, lineNumber ); break; case 53: // saload - addArrayInstruction( ArrayOperator.GET, ValueType.i16, codePos ); + addArrayInstruction( ArrayOperator.GET, ValueType.i16, codePos, lineNumber ); break; case 54: // istore - addLoadStoreInstruction( ValueType.i32, false, byteCode.readUnsignedIndex( wide ), codePos ); + addLoadStoreInstruction( ValueType.i32, false, byteCode.readUnsignedIndex( wide ), codePos, lineNumber ); break; case 55: // lstore - addLoadStoreInstruction( ValueType.i64, false, byteCode.readUnsignedIndex( wide ), codePos ); + addLoadStoreInstruction( ValueType.i64, false, byteCode.readUnsignedIndex( wide ), codePos, lineNumber ); break; case 56: // fstore - addLoadStoreInstruction( ValueType.f32, false, byteCode.readUnsignedIndex( wide ), codePos ); + addLoadStoreInstruction( ValueType.f32, false, byteCode.readUnsignedIndex( wide ), codePos, lineNumber ); break; case 57: // dstore - addLoadStoreInstruction( ValueType.f64, false, byteCode.readUnsignedIndex( wide ), codePos ); + addLoadStoreInstruction( ValueType.f64, false, byteCode.readUnsignedIndex( wide ), codePos, lineNumber ); break; case 58: // astore - addLoadStoreInstruction( ValueType.anyref, false, byteCode.readUnsignedIndex( wide ), codePos ); + addLoadStoreInstruction( ValueType.anyref, false, byteCode.readUnsignedIndex( wide ), codePos, lineNumber ); break; case 59: // istore_0 case 60: // istore_1 case 61: // istore_2 case 62: // istore_3 - addLoadStoreInstruction( ValueType.i32, false, op - 59, codePos ); + addLoadStoreInstruction( ValueType.i32, false, op - 59, codePos, lineNumber ); break; case 63: // lstore_0 case 64: // lstore_1 case 65: // lstore_2 case 66: // lstore_3 - addLoadStoreInstruction( ValueType.i64, false, op - 63, codePos ); + addLoadStoreInstruction( ValueType.i64, false, op - 63, codePos, lineNumber ); break; case 67: // fstore_0 case 68: // fstore_1 case 69: // fstore_2 case 70: // fstore_3 - addLoadStoreInstruction( ValueType.f32, false, op - 67, codePos ); + addLoadStoreInstruction( ValueType.f32, false, op - 67, codePos, lineNumber ); break; case 71: // dstore_0 case 72: // dstore_1 case 73: // dstore_2 case 74: // dstore_3 - addLoadStoreInstruction( ValueType.f64, false, op - 71, codePos ); + addLoadStoreInstruction( ValueType.f64, false, op - 71, codePos, lineNumber ); break; case 75: // astore_0 case 76: // astore_1 @@ -245,41 +245,42 @@ class JavaMethodWasmCodeBuilder extends WasmCodeBuilder { } else { storeType = findPreviousPushInstructionPushValueType(); } - addLoadStoreInstruction( storeType, false, op - 75, codePos ); + addLoadStoreInstruction( storeType, false, op - 75, codePos, lineNumber ); break; case 79: // iastore - addArrayInstruction( ArrayOperator.SET, ValueType.i32, codePos ); + addArrayInstruction( ArrayOperator.SET, ValueType.i32, codePos, lineNumber ); break; case 80: // lastore - addArrayInstruction( ArrayOperator.SET, ValueType.i64, codePos ); + addArrayInstruction( ArrayOperator.SET, ValueType.i64, codePos, lineNumber ); break; case 81: // fastore - addArrayInstruction( ArrayOperator.SET, ValueType.f32, codePos ); + addArrayInstruction( ArrayOperator.SET, ValueType.f32, codePos, lineNumber ); break; case 82: // dastore - addArrayInstruction( ArrayOperator.SET, ValueType.f64, codePos ); + addArrayInstruction( ArrayOperator.SET, ValueType.f64, codePos, lineNumber ); break; case 83: // aastore storeType = findPreviousPushInstructionPushValueType(); - addArrayInstruction( ArrayOperator.SET, storeType, codePos ); + addArrayInstruction( ArrayOperator.SET, storeType, codePos, lineNumber ); break; case 84: // bastore - addArrayInstruction( ArrayOperator.SET, ValueType.i8, codePos ); + addArrayInstruction( ArrayOperator.SET, ValueType.i8, codePos, lineNumber ); break; case 85: // castore - addArrayInstruction( ArrayOperator.SET, ValueType.i16, codePos ); + addArrayInstruction( ArrayOperator.SET, ValueType.i16, codePos, lineNumber ); break; case 86: // sastore - addArrayInstruction( ArrayOperator.SET, ValueType.i16, codePos ); + addArrayInstruction( ArrayOperator.SET, ValueType.i16, codePos, lineNumber ); break; case 87: // pop case 88: // pop2 - addBlockInstruction( WasmBlockOperator.DROP, null, codePos ); + addBlockInstruction( WasmBlockOperator.DROP, null, codePos, lineNumber ); break; case 89: // dup: duplicate the value on top of the stack case 92: // dup2 storeType = findPreviousPushInstructionPushValueType(); - addCallInstruction( new SyntheticFunctionName( "dup" + storeType, "local.get 0 local.get 0 return", storeType, null, storeType, storeType ), codePos ); + addCallInstruction( new SyntheticFunctionName( "dup" + + storeType, "local.get 0 local.get 0 return", storeType, null, storeType, storeType ), codePos, lineNumber ); break; case 90: // dup_x1 case 91: // dup_x2 @@ -287,237 +288,239 @@ class JavaMethodWasmCodeBuilder extends WasmCodeBuilder { case 94: // dup2_x2 case 95: // swap // can be do with functions with more as one return value in future WASM standard - throw new WasmException( "Stack duplicate is not supported in current WASM. try to save immediate values in a local variable: " + op, byteCode.getLineNumber() ); + throw new WasmException( "Stack duplicate is not supported in current WASM. try to save immediate values in a local variable: " + + op, lineNumber ); case 96: // iadd - addNumericInstruction( NumericOperator.add, ValueType.i32, codePos); + addNumericInstruction( NumericOperator.add, ValueType.i32, codePos, lineNumber ); break; case 97: // ladd - addNumericInstruction( NumericOperator.add, ValueType.i64, codePos ); + addNumericInstruction( NumericOperator.add, ValueType.i64, codePos, lineNumber ); break; case 98: // fadd - addNumericInstruction( NumericOperator.add, ValueType.f32, codePos ); + addNumericInstruction( NumericOperator.add, ValueType.f32, codePos, lineNumber ); break; case 99: // dadd - addNumericInstruction( NumericOperator.add, ValueType.f64, codePos ); + addNumericInstruction( NumericOperator.add, ValueType.f64, codePos, lineNumber ); break; case 100: // isub - addNumericInstruction( NumericOperator.sub, ValueType.i32, codePos ); + addNumericInstruction( NumericOperator.sub, ValueType.i32, codePos, lineNumber ); break; case 101: // lsub - addNumericInstruction( NumericOperator.sub, ValueType.i64, codePos ); + addNumericInstruction( NumericOperator.sub, ValueType.i64, codePos, lineNumber ); break; case 102: // fsub - addNumericInstruction( NumericOperator.sub, ValueType.f32, codePos ); + addNumericInstruction( NumericOperator.sub, ValueType.f32, codePos, lineNumber ); break; case 103: // dsub - addNumericInstruction( NumericOperator.sub, ValueType.f64, codePos ); + addNumericInstruction( NumericOperator.sub, ValueType.f64, codePos, lineNumber ); break; case 104: // imul; - addNumericInstruction( NumericOperator.mul, ValueType.i32, codePos ); + addNumericInstruction( NumericOperator.mul, ValueType.i32, codePos, lineNumber ); break; case 105: // lmul - addNumericInstruction( NumericOperator.mul, ValueType.i64, codePos ); + addNumericInstruction( NumericOperator.mul, ValueType.i64, codePos, lineNumber ); break; case 106: // fmul - addNumericInstruction( NumericOperator.mul, ValueType.f32, codePos ); + addNumericInstruction( NumericOperator.mul, ValueType.f32, codePos, lineNumber ); break; case 107: // dmul - addNumericInstruction( NumericOperator.mul, ValueType.f64, codePos ); + addNumericInstruction( NumericOperator.mul, ValueType.f64, codePos, lineNumber ); break; case 108: // idiv - addNumericInstruction( NumericOperator.div, ValueType.i32, codePos ); + addNumericInstruction( NumericOperator.div, ValueType.i32, codePos, lineNumber ); break; case 109: // ldiv - addNumericInstruction( NumericOperator.div, ValueType.i64, codePos ); + addNumericInstruction( NumericOperator.div, ValueType.i64, codePos, lineNumber ); break; case 110: // fdiv - addNumericInstruction( NumericOperator.div, ValueType.f32, codePos ); + addNumericInstruction( NumericOperator.div, ValueType.f32, codePos, lineNumber ); break; case 111: // ddiv - addNumericInstruction( NumericOperator.div, ValueType.f64, codePos ); + addNumericInstruction( NumericOperator.div, ValueType.f64, codePos, lineNumber ); break; case 112: // irem - addNumericInstruction( NumericOperator.rem, ValueType.i32, codePos ); + addNumericInstruction( NumericOperator.rem, ValueType.i32, codePos, lineNumber ); break; case 113: // lrem - addNumericInstruction( NumericOperator.rem, ValueType.i64, codePos ); + addNumericInstruction( NumericOperator.rem, ValueType.i64, codePos, lineNumber ); break; case 114: // frem //helper function like: (a - (int)(a / b) * (float)b) - addCallInstruction( new SyntheticFunctionName( "frem", "local.get 0 local.get 0 local.get 1 f32.div i32.trunc_sat_f32_s f32.convert_i32_s local.get 1 f32.mul f32.sub return", ValueType.f32, ValueType.f32, null, ValueType.f32 ), codePos ); + addCallInstruction( new SyntheticFunctionName( "frem", "local.get 0 local.get 0 local.get 1 f32.div i32.trunc_sat_f32_s f32.convert_i32_s local.get 1 f32.mul f32.sub return", ValueType.f32, ValueType.f32, null, ValueType.f32 ), codePos, lineNumber ); break; case 115: // drem //helper function like: (a - (long)(a / b) * (double)b) - addCallInstruction( new SyntheticFunctionName( "drem", "local.get 0 local.get 0 local.get 1 f64.div i64.trunc_sat_f64_s f64.convert_i64_s local.get 1 f64.mul f64.sub return", ValueType.f64, ValueType.f64, null, ValueType.f64 ), codePos ); + addCallInstruction( new SyntheticFunctionName( "drem", "local.get 0 local.get 0 local.get 1 f64.div i64.trunc_sat_f64_s f64.convert_i64_s local.get 1 f64.mul f64.sub return", ValueType.f64, ValueType.f64, null, ValueType.f64 ), codePos, lineNumber ); break; case 116: // ineg - addConstInstruction( -1, ValueType.i32, codePos ); - addNumericInstruction( NumericOperator.mul, ValueType.i32, codePos ); + addConstInstruction( -1, ValueType.i32, codePos, lineNumber ); + addNumericInstruction( NumericOperator.mul, ValueType.i32, codePos, lineNumber ); break; case 117: // lneg - addConstInstruction( (long)-1, ValueType.i64, codePos ); - addNumericInstruction( NumericOperator.mul, ValueType.i64, codePos ); + addConstInstruction( (long)-1, ValueType.i64, codePos, lineNumber ); + addNumericInstruction( NumericOperator.mul, ValueType.i64, codePos, lineNumber ); break; case 118: // fneg - addNumericInstruction( NumericOperator.neg, ValueType.f32, codePos ); + addNumericInstruction( NumericOperator.neg, ValueType.f32, codePos, lineNumber ); break; case 119: // dneg - addNumericInstruction( NumericOperator.neg, ValueType.f64, codePos ); + addNumericInstruction( NumericOperator.neg, ValueType.f64, codePos, lineNumber ); break; case 120: // ishl - addNumericInstruction( NumericOperator.shl, ValueType.i32, codePos ); + addNumericInstruction( NumericOperator.shl, ValueType.i32, codePos, lineNumber ); break; case 121: // lshl - addConvertInstruction( ValueTypeConvertion.i2l, codePos ); // the shift parameter must be of type long!!! - addNumericInstruction( NumericOperator.shl, ValueType.i64, codePos ); + addConvertInstruction( ValueTypeConvertion.i2l, codePos, lineNumber ); // the shift parameter must be of type long!!! + addNumericInstruction( NumericOperator.shl, ValueType.i64, codePos, lineNumber ); break; case 122: // ishr - addNumericInstruction( NumericOperator.shr_s, ValueType.i32, codePos ); + addNumericInstruction( NumericOperator.shr_s, ValueType.i32, codePos, lineNumber ); break; case 123: // lshr - addConvertInstruction( ValueTypeConvertion.i2l, codePos ); // the shift parameter must be of type long!!! - addNumericInstruction( NumericOperator.shr_s, ValueType.i64, codePos ); + addConvertInstruction( ValueTypeConvertion.i2l, codePos, lineNumber ); // the shift parameter must be of type long!!! + addNumericInstruction( NumericOperator.shr_s, ValueType.i64, codePos, lineNumber ); break; case 124: // iushr - addNumericInstruction( NumericOperator.shr_u, ValueType.i32, codePos ); + addNumericInstruction( NumericOperator.shr_u, ValueType.i32, codePos, lineNumber ); break; case 125: // lushr - addConvertInstruction( ValueTypeConvertion.i2l, codePos ); // the shift parameter must be of type long!!! - addNumericInstruction( NumericOperator.shr_u, ValueType.i64, codePos ); + addConvertInstruction( ValueTypeConvertion.i2l, codePos, lineNumber ); // the shift parameter must be of type long!!! + addNumericInstruction( NumericOperator.shr_u, ValueType.i64, codePos, lineNumber ); break; case 126: // iand - addNumericInstruction( NumericOperator.and, ValueType.i32, codePos ); + addNumericInstruction( NumericOperator.and, ValueType.i32, codePos, lineNumber ); break; case 127: // land - addNumericInstruction( NumericOperator.and, ValueType.i64, codePos ); + addNumericInstruction( NumericOperator.and, ValueType.i64, codePos, lineNumber ); break; case 128: // ior - addNumericInstruction( NumericOperator.or, ValueType.i32, codePos ); + addNumericInstruction( NumericOperator.or, ValueType.i32, codePos, lineNumber ); break; case 129: // lor - addNumericInstruction( NumericOperator.or, ValueType.i64, codePos ); + addNumericInstruction( NumericOperator.or, ValueType.i64, codePos, lineNumber ); break; case 130: // ixor - addNumericInstruction( NumericOperator.xor, ValueType.i32, codePos ); + addNumericInstruction( NumericOperator.xor, ValueType.i32, codePos, lineNumber ); break; case 131: // lxor - addNumericInstruction( NumericOperator.xor, ValueType.i64, codePos ); + addNumericInstruction( NumericOperator.xor, ValueType.i64, codePos, lineNumber ); break; case 132: // iinc int idx = byteCode.readUnsignedIndex( wide ); - addLoadStoreInstruction( ValueType.i32, true, idx, codePos ); - addConstInstruction( (int)(wide ? byteCode.readShort() : byteCode.readByte()), ValueType.i32, codePos ); - addNumericInstruction( NumericOperator.add, ValueType.i32, codePos); - addLoadStoreInstruction( ValueType.i32, false, idx, codePos ); + addLoadStoreInstruction( ValueType.i32, true, idx, codePos, lineNumber ); + addConstInstruction( (int)(wide ? byteCode.readShort() : byteCode.readByte()), ValueType.i32, codePos, lineNumber ); + addNumericInstruction( NumericOperator.add, ValueType.i32, codePos, lineNumber ); + addLoadStoreInstruction( ValueType.i32, false, idx, codePos, lineNumber ); break; case 133: // i2l - addConvertInstruction( ValueTypeConvertion.i2l, codePos ); + addConvertInstruction( ValueTypeConvertion.i2l, codePos, lineNumber ); break; case 134: // i2f - addConvertInstruction( ValueTypeConvertion.i2f, codePos ); + addConvertInstruction( ValueTypeConvertion.i2f, codePos, lineNumber ); break; case 135: // i2d - addConvertInstruction( ValueTypeConvertion.i2d, codePos ); + addConvertInstruction( ValueTypeConvertion.i2d, codePos, lineNumber ); break; case 136: // l2i - addConvertInstruction( ValueTypeConvertion.l2i, codePos ); + addConvertInstruction( ValueTypeConvertion.l2i, codePos, lineNumber ); break; case 137: // l2f - addConvertInstruction( ValueTypeConvertion.l2f, codePos ); + addConvertInstruction( ValueTypeConvertion.l2f, codePos, lineNumber ); break; case 138: // l2d - addConvertInstruction( ValueTypeConvertion.l2d, codePos ); + addConvertInstruction( ValueTypeConvertion.l2d, codePos, lineNumber ); break; case 139: // f2i - addConvertInstruction( ValueTypeConvertion.f2i, codePos ); + addConvertInstruction( ValueTypeConvertion.f2i, codePos, lineNumber ); break; case 140: // f2l - addConvertInstruction( ValueTypeConvertion.f2l, codePos ); + addConvertInstruction( ValueTypeConvertion.f2l, codePos, lineNumber ); break; case 141: // f2d - addConvertInstruction( ValueTypeConvertion.f2d, codePos ); + addConvertInstruction( ValueTypeConvertion.f2d, codePos, lineNumber ); break; case 142: // d2i - addConvertInstruction( ValueTypeConvertion.d2i, codePos ); + addConvertInstruction( ValueTypeConvertion.d2i, codePos, lineNumber ); break; case 143: // d2l - addConvertInstruction( ValueTypeConvertion.d2l, codePos ); + addConvertInstruction( ValueTypeConvertion.d2l, codePos, lineNumber ); break; case 144: // d2f - addConvertInstruction( ValueTypeConvertion.d2f, codePos ); + addConvertInstruction( ValueTypeConvertion.d2f, codePos, lineNumber ); break; case 145: // i2b - addConvertInstruction( ValueTypeConvertion.i2b, codePos ); + addConvertInstruction( ValueTypeConvertion.i2b, codePos, lineNumber ); break; case 146: // i2c - addConstInstruction( 0xFFFF, ValueType.i32, codePos ); - addNumericInstruction( NumericOperator.and, ValueType.i32, codePos ); + addConstInstruction( 0xFFFF, ValueType.i32, codePos, lineNumber ); + addNumericInstruction( NumericOperator.and, ValueType.i32, codePos, lineNumber ); break; case 147: // i2s - addConvertInstruction( ValueTypeConvertion.i2s, codePos ); + addConvertInstruction( ValueTypeConvertion.i2s, codePos, lineNumber ); break; case 148: // lcmp - opCompare( ValueType.i64, byteCode, codePos ); + opCompare( ValueType.i64, byteCode, codePos, lineNumber ); break; case 149: // fcmpl case 150: // fcmpg - opCompare( ValueType.f32, byteCode, codePos ); + opCompare( ValueType.f32, byteCode, codePos, lineNumber ); break; case 151: // dcmpl case 152: // dcmpg - opCompare( ValueType.f64, byteCode, codePos ); + opCompare( ValueType.f64, byteCode, codePos, lineNumber ); break; case 153: // ifeq - opIfCondition( NumericOperator.eq, byteCode, codePos ); + opIfCondition( NumericOperator.eq, byteCode, codePos, lineNumber ); break; case 154: // ifne - opIfCondition( NumericOperator.ne, byteCode, codePos ); + opIfCondition( NumericOperator.ne, byteCode, codePos, lineNumber ); break; case 155: // iflt - opIfCondition( NumericOperator.lt, byteCode, codePos ); + opIfCondition( NumericOperator.lt, byteCode, codePos, lineNumber ); break; case 156: // ifge - opIfCondition( NumericOperator.ge, byteCode, codePos ); + opIfCondition( NumericOperator.ge, byteCode, codePos, lineNumber ); break; case 157: // ifgt - opIfCondition( NumericOperator.gt, byteCode, codePos ); + opIfCondition( NumericOperator.gt, byteCode, codePos, lineNumber ); break; case 158: // ifle - opIfCondition( NumericOperator.le, byteCode, codePos ); + opIfCondition( NumericOperator.le, byteCode, codePos, lineNumber ); break; case 159: // if_icmpeq - opIfCompareCondition( NumericOperator.eq, byteCode, codePos ); + opIfCompareCondition( NumericOperator.eq, byteCode, codePos, lineNumber ); break; case 160: // if_icmpne - opIfCompareCondition( NumericOperator.ne, byteCode, codePos ); + opIfCompareCondition( NumericOperator.ne, byteCode, codePos, lineNumber ); break; case 161: // if_icmplt - opIfCompareCondition( NumericOperator.lt, byteCode, codePos ); + opIfCompareCondition( NumericOperator.lt, byteCode, codePos, lineNumber ); break; case 162: // if_icmpge - opIfCompareCondition( NumericOperator.ge, byteCode, codePos ); + opIfCompareCondition( NumericOperator.ge, byteCode, codePos, lineNumber ); break; case 163: // if_icmpgt - opIfCompareCondition( NumericOperator.gt, byteCode, codePos ); + opIfCompareCondition( NumericOperator.gt, byteCode, codePos, lineNumber ); break; case 164: // if_icmple - opIfCompareCondition( NumericOperator.le, byteCode, codePos ); + opIfCompareCondition( NumericOperator.le, byteCode, codePos, lineNumber ); break; case 165: // if_acmpeq - opIfCompareCondition( NumericOperator.ref_eq, byteCode, codePos ); + opIfCompareCondition( NumericOperator.ref_eq, byteCode, codePos, lineNumber ); break; case 166: // if_acmpne - opIfCompareCondition( NumericOperator.ref_ne, byteCode, codePos ); + opIfCompareCondition( NumericOperator.ref_ne, byteCode, codePos, lineNumber ); break; case 167: // goto int offset = byteCode.readShort(); - branchManager.addGotoOperator( codePos, offset, byteCode.getCodePosition(), byteCode.getLineNumber() ); - addNopInstruction( codePos ); // marker of the line number for the branch manager + branchManager.addGotoOperator( codePos, offset, byteCode.getCodePosition(), lineNumber ); + addNopInstruction( codePos, lineNumber ); // marker of the line number for the branch manager break; case 168: // jsr case 169: // ret case 201: // jsr_w - throw new WasmException( "Finally block of Java 5 or older is not supported. Compile the sources with a Java SE 6 or newer: " + op, byteCode.getLineNumber() ); + throw new WasmException( "Finally block of Java 5 or older is not supported. Compile the sources with a Java SE 6 or newer: " + + op, lineNumber ); case 170: // tableswitch case 171: // lookupswitch writeSwitchCode( byteCode, op == 171 ); @@ -529,7 +532,7 @@ class JavaMethodWasmCodeBuilder extends WasmCodeBuilder { case 176: // areturn case 177: // return void ValueType type = null; - switch ( op ) { + switch( op ) { case 172: // ireturn type = ValueType.i32; break; @@ -546,43 +549,43 @@ class JavaMethodWasmCodeBuilder extends WasmCodeBuilder { type = ValueType.anyref; break; } - addBlockInstruction( WasmBlockOperator.RETURN, type, codePos ); + addBlockInstruction( WasmBlockOperator.RETURN, type, codePos, lineNumber ); break; case 178: // getstatic ConstantRef ref = (ConstantRef)constantPool.get( byteCode.readUnsignedShort() ); - addGlobalInstruction( true, ref, codePos ); + addGlobalInstruction( true, ref, codePos, lineNumber ); break; case 179: // putstatic ref = (ConstantRef)constantPool.get( byteCode.readUnsignedShort() ); - addGlobalInstruction( false, ref, codePos ); + addGlobalInstruction( false, ref, codePos, lineNumber ); break; case 180: // getfield ref = (ConstantRef)constantPool.get( byteCode.readUnsignedShort() ); - addStructInstruction( StructOperator.GET, ref.getClassName(), ref.getName(), codePos ); + addStructInstruction( StructOperator.GET, ref.getClassName(), ref.getName(), codePos, lineNumber ); break; case 181: // putfield ref = (ConstantRef)constantPool.get( byteCode.readUnsignedShort() ); - addStructInstruction( StructOperator.SET, ref.getClassName(), ref.getName(), codePos ); + addStructInstruction( StructOperator.SET, ref.getClassName(), ref.getName(), codePos, lineNumber ); break; case 182: // invokevirtual case 183: // invokespecial, invoke a constructor case 184: // invokestatic idx = byteCode.readUnsignedShort(); ref = (ConstantRef)constantPool.get( idx ); - addCallInstruction( new FunctionName( ref ), codePos ); + addCallInstruction( new FunctionName( ref ), codePos, lineNumber ); break; //TODO case 185: // invokeinterface //TODO case 186: // invokedynamic case 187: // new String name = ((ConstantClass)constantPool.get( byteCode.readUnsignedShort() )).getName(); - addStructInstruction( StructOperator.NEW_DEFAULT, name, null, codePos ); + addStructInstruction( StructOperator.NEW_DEFAULT, name, null, codePos, lineNumber ); break; case 188: // newarray int typeValue = byteCode.readByte(); switch( typeValue ) { case 4: // boolean case 5: // char - type = ValueType.i32; + type = ValueType.i32; break; case 6: //float type = ValueType.f32; @@ -599,28 +602,28 @@ class JavaMethodWasmCodeBuilder extends WasmCodeBuilder { type = ValueType.i64; break; default: - throw new WasmException( "Invalid Java byte code newarray: " + typeValue, byteCode.getLineNumber() ); + throw new WasmException( "Invalid Java byte code newarray: " + typeValue, lineNumber ); } - addArrayInstruction( ArrayOperator.NEW, type, codePos ); + addArrayInstruction( ArrayOperator.NEW, type, codePos, lineNumber ); break; case 189: // anewarray name = ((ConstantClass)constantPool.get( byteCode.readUnsignedShort() )).getName(); type = ValueType.anyref; //TODO we need to use the right type from name - addArrayInstruction( ArrayOperator.NEW, type, codePos ); + addArrayInstruction( ArrayOperator.NEW, type, codePos, lineNumber ); break; case 190: // arraylength - addArrayInstruction( ArrayOperator.LENGTH, ValueType.i32, codePos ); + addArrayInstruction( ArrayOperator.LENGTH, ValueType.i32, codePos, lineNumber ); break; case 191: // athrow - addBlockInstruction( WasmBlockOperator.THROW, null, codePos ); + addBlockInstruction( WasmBlockOperator.THROW, null, codePos, lineNumber ); break; //TODO case 192: // checkcast //TODO case 193: // instanceof case 194: // monitorenter - addBlockInstruction( WasmBlockOperator.MONITOR_ENTER, null, codePos ); + addBlockInstruction( WasmBlockOperator.MONITOR_ENTER, null, codePos, lineNumber ); break; case 195: // monitorexit - addBlockInstruction( WasmBlockOperator.MONITOR_EXIT, null, codePos ); + addBlockInstruction( WasmBlockOperator.MONITOR_EXIT, null, codePos, lineNumber ); break; case 196: // wide // https://docs.oracle.com/javase/specs/jvms/se8/html/jvms-6.html#jvms-6.5.wide @@ -628,18 +631,18 @@ class JavaMethodWasmCodeBuilder extends WasmCodeBuilder { continue; //TODO case 197: // multianewarray case 198: // ifnull - opIfCompareCondition( NumericOperator.ifnull, byteCode, codePos ); + opIfCompareCondition( NumericOperator.ifnull, byteCode, codePos, lineNumber ); break; case 199: // ifnonnull - opIfCompareCondition( NumericOperator.ifnonnull, byteCode, codePos ); + opIfCompareCondition( NumericOperator.ifnonnull, byteCode, codePos, lineNumber ); break; case 200: // goto_w offset = byteCode.readInt(); - branchManager.addGotoOperator( codePos, offset, byteCode.getCodePosition(), byteCode.getLineNumber() ); - addNopInstruction( codePos ); // marker of the line number for the branch manager + branchManager.addGotoOperator( codePos, offset, byteCode.getCodePosition(), lineNumber ); + addNopInstruction( codePos, lineNumber ); // marker of the line number for the branch manager break; default: - throw new WasmException( "Unimplemented Java byte code operation: " + op, byteCode.getLineNumber() ); + throw new WasmException( "Unimplemented Java byte code operation: " + op, lineNumber ); } wide = false; } @@ -649,7 +652,7 @@ class JavaMethodWasmCodeBuilder extends WasmCodeBuilder { // if a method ends with a loop or block without a break then code after the loop is no reachable // Java does not need a return byte code in this case // But WebAssembly need the dead code to validate - addBlockInstruction( WasmBlockOperator.UNREACHABLE, null, byteCode.getCodePosition() ); + addBlockInstruction( WasmBlockOperator.UNREACHABLE, null, byteCode.getCodePosition(), byteCode.getLineNumber() ); } } catch( WasmException ex ) { throw ex; @@ -694,7 +697,7 @@ class JavaMethodWasmCodeBuilder extends WasmCodeBuilder { int block = 0; int defaultBlock = -1; int currentPos = -1; - addLoadStoreInstruction( ValueType.i32, false, tempI32, codePos ); + addLoadStoreInstruction( ValueType.i32, false, tempI32, codePos, lineNumber ); do { int nextPos = findNext( currentPos, positions ); if( nextPos == currentPos ) { @@ -711,10 +714,10 @@ class JavaMethodWasmCodeBuilder extends WasmCodeBuilder { } for( int i = 0; i < positions.length; i++ ) { if( positions[i] == currentPos ) { - addLoadStoreInstruction( ValueType.i32, true, tempI32, codePos ); - addConstInstruction( keys[i], ValueType.i32, codePos ); - addNumericInstruction( NumericOperator.eq, ValueType.i32, codePos ); - addBlockInstruction( WasmBlockOperator.BR_IF, block, codePos ); + addLoadStoreInstruction( ValueType.i32, true, tempI32, codePos, lineNumber ); + addConstInstruction( keys[i], ValueType.i32, codePos, lineNumber ); + addNumericInstruction( NumericOperator.eq, ValueType.i32, codePos, lineNumber ); + addBlockInstruction( WasmBlockOperator.BR_IF, block, codePos, lineNumber ); } } block++; @@ -722,7 +725,7 @@ class JavaMethodWasmCodeBuilder extends WasmCodeBuilder { if( defaultBlock < 0 ) { defaultBlock = block; } - addBlockInstruction( WasmBlockOperator.BR, defaultBlock, codePos ); + addBlockInstruction( WasmBlockOperator.BR, defaultBlock, codePos, lineNumber ); } else { int low = byteCode.readInt(); keys = null; @@ -732,8 +735,8 @@ class JavaMethodWasmCodeBuilder extends WasmCodeBuilder { positions[i] = startPosition + byteCode.readInt(); } if( low != 0 ) { // the br_table starts ever with the value 0. That we need to subtract the start value if it different - addConstInstruction( low, ValueType.i32, codePos ); - addNumericInstruction( NumericOperator.sub, ValueType.i32, codePos ); + addConstInstruction( low, ValueType.i32, codePos, lineNumber ); + addNumericInstruction( NumericOperator.sub, ValueType.i32, codePos, lineNumber ); } } branchManager.addSwitchOperator( switchValuestartPosition, 0, lineNumber, keys, positions, defaultPosition ); @@ -810,38 +813,42 @@ class JavaMethodWasmCodeBuilder extends WasmCodeBuilder { * Handle the if of the Java byte code. This Java instruction compare the first stack value with value 0. * Important: In the Java IF expression the condition for the jump to the else block is saved. In WebAssembler we * need to use condition for the if block. The caller of the method must already negate this + * * @param compareOp * The condition for the continue of a loop. * @param byteCode * current byte code stream to read the target offset. * @param codePos * the code position/offset in the Java method - * + * @param lineNumber + * the line number in the Java source code * @throws IOException * if any I/O errors occur. */ - private void opIfCondition( NumericOperator compareOp, CodeInputStream byteCode, int codePos ) throws IOException { - addConstInstruction( 0, ValueType.i32, codePos ); - opIfCompareCondition( compareOp, byteCode, codePos ); + private void opIfCondition( NumericOperator compareOp, CodeInputStream byteCode, int codePos, int lineNumber ) throws IOException { + addConstInstruction( 0, ValueType.i32, codePos, lineNumber ); + opIfCompareCondition( compareOp, byteCode, codePos, lineNumber ); } /** - * Handle the if of the Java byte code. This Java instruction compare 2 values from stack. - * Important: In the Java IF expression the condition for the jump to the else block is saved. In WebAssembler we need to use + * Handle the if of the Java byte code. This Java instruction compare 2 values from stack. Important: In + * the Java IF expression the condition for the jump to the else block is saved. In WebAssembler we need to use * condition for the if block. The caller of the method must already negate this. + * * @param compareOp * The condition for the continue of a loop. * @param byteCode * current byte code stream to read the target offset. * @param codePos * the code position/offset in the Java method - * + * @param lineNumber + * the line number in the Java source code * @throws IOException * if any I/O errors occur. */ - private void opIfCompareCondition( NumericOperator compareOp, CodeInputStream byteCode, int codePos ) throws IOException { + private void opIfCompareCondition( NumericOperator compareOp, CodeInputStream byteCode, int codePos, int lineNumber ) throws IOException { int offset = byteCode.readShort(); - WasmNumericInstruction compare = new WasmNumericInstruction( compareOp, ValueType.i32, codePos ); + WasmNumericInstruction compare = new WasmNumericInstruction( compareOp, ValueType.i32, codePos, lineNumber ); branchManager.addIfOperator( codePos, offset, byteCode.getLineNumber(), compare ); getInstructions().add( compare ); } @@ -856,14 +863,16 @@ class JavaMethodWasmCodeBuilder extends WasmCodeBuilder { * current byte code stream to read the next operation. * @param codePos * the code position/offset in the Java method + * @param lineNumber + * the line number in the Java source code * @throws IOException * if any I/O errors occur. */ - private void opCompare( ValueType valueType, CodeInputStream byteCode, int codePos ) throws IOException { + private void opCompare( ValueType valueType, CodeInputStream byteCode, int codePos, int lineNumber ) throws IOException { codePos = byteCode.getCodePosition(); NumericOperator numOp; int nextOp = byteCode.read(); - switch( nextOp ){ + switch( nextOp ) { case 153: // ifeq numOp = NumericOperator.eq; break; @@ -886,7 +895,7 @@ class JavaMethodWasmCodeBuilder extends WasmCodeBuilder { throw new WasmException( "Unexpected compare sub operation: " + nextOp, -1 ); } int offset = byteCode.readShort(); - WasmNumericInstruction compare = new WasmNumericInstruction( numOp, valueType, codePos ); + WasmNumericInstruction compare = new WasmNumericInstruction( numOp, valueType, codePos, lineNumber ); branchManager.addIfOperator( codePos, offset, byteCode.getLineNumber(), compare ); getInstructions().add( compare ); } diff --git a/src/de/inetsoftware/jwebassembly/module/WasmArrayInstruction.java b/src/de/inetsoftware/jwebassembly/module/WasmArrayInstruction.java index 75b0a40..a0f06cf 100644 --- a/src/de/inetsoftware/jwebassembly/module/WasmArrayInstruction.java +++ b/src/de/inetsoftware/jwebassembly/module/WasmArrayInstruction.java @@ -47,9 +47,11 @@ class WasmArrayInstruction extends WasmInstruction { * the type of the parameters * @param javaCodePos * the code position/offset in the Java method + * @param lineNumber + * the line number in the Java source code */ - WasmArrayInstruction( @Nullable ArrayOperator op, @Nullable AnyType type, int javaCodePos ) { - super( javaCodePos ); + WasmArrayInstruction( @Nullable ArrayOperator op, @Nullable AnyType type, int javaCodePos, int lineNumber ) { + super( javaCodePos, lineNumber ); this.op = op; this.type = type; } diff --git a/src/de/inetsoftware/jwebassembly/module/WasmBlockInstruction.java b/src/de/inetsoftware/jwebassembly/module/WasmBlockInstruction.java index 9d5ea96..490a924 100644 --- a/src/de/inetsoftware/jwebassembly/module/WasmBlockInstruction.java +++ b/src/de/inetsoftware/jwebassembly/module/WasmBlockInstruction.java @@ -46,9 +46,11 @@ class WasmBlockInstruction extends WasmInstruction { * extra data depending of the operator * @param javaCodePos * the code position/offset in the Java method + * @param lineNumber + * the line number in the Java source code */ - WasmBlockInstruction( @Nonnull WasmBlockOperator op, @Nullable Object data, int javaCodePos ) { - super( javaCodePos ); + WasmBlockInstruction( @Nonnull WasmBlockOperator op, @Nullable Object data, int javaCodePos, int lineNumber ) { + super( javaCodePos, lineNumber ); this.op = op; this.data = data; } diff --git a/src/de/inetsoftware/jwebassembly/module/WasmCallInstruction.java b/src/de/inetsoftware/jwebassembly/module/WasmCallInstruction.java index 609b28b..142e34e 100644 --- a/src/de/inetsoftware/jwebassembly/module/WasmCallInstruction.java +++ b/src/de/inetsoftware/jwebassembly/module/WasmCallInstruction.java @@ -44,9 +44,11 @@ class WasmCallInstruction extends WasmInstruction { * the function name that should be called * @param javaCodePos * the code position/offset in the Java method + * @param lineNumber + * the line number in the Java source code */ - WasmCallInstruction( FunctionName name, int javaCodePos ) { - super( javaCodePos ); + WasmCallInstruction( FunctionName name, int javaCodePos, int lineNumber ) { + super( javaCodePos, lineNumber ); this.name = name; } diff --git a/src/de/inetsoftware/jwebassembly/module/WasmCodeBuilder.java b/src/de/inetsoftware/jwebassembly/module/WasmCodeBuilder.java index 8a4a5b8..14910be 100644 --- a/src/de/inetsoftware/jwebassembly/module/WasmCodeBuilder.java +++ b/src/de/inetsoftware/jwebassembly/module/WasmCodeBuilder.java @@ -113,11 +113,13 @@ public abstract class WasmCodeBuilder { * the memory/slot index of the variable in Java byte code * @param javaCodePos * the code position/offset in the Java method + * @param lineNumber + * the line number in the Java source code */ @Nonnull - protected void addLoadStoreInstruction( AnyType valueType, boolean load, @Nonnegative int javaIdx, int javaCodePos ) { + protected void addLoadStoreInstruction( AnyType valueType, boolean load, @Nonnegative int javaIdx, int javaCodePos, int lineNumber ) { localVariables.use( valueType, javaIdx ); - instructions.add( new WasmLoadStoreInstruction( load, javaIdx, localVariables, javaCodePos ) ); + instructions.add( new WasmLoadStoreInstruction( load, javaIdx, localVariables, javaCodePos, lineNumber ) ); } /** @@ -129,10 +131,12 @@ public abstract class WasmCodeBuilder { * the index of the variable * @param javaCodePos * the code position/offset in the Java method + * @param lineNumber + * the line number in the Java source code */ @Nonnull - protected void addLocalInstruction( boolean load, @Nonnegative int wasmIdx, int javaCodePos ) { - instructions.add( new WasmLocalInstruction( load, wasmIdx, javaCodePos ) ); + protected void addLocalInstruction( boolean load, @Nonnegative int wasmIdx, int javaCodePos, int lineNumber ) { + instructions.add( new WasmLocalInstruction( load, wasmIdx, javaCodePos, lineNumber ) ); } /** @@ -144,9 +148,11 @@ public abstract class WasmCodeBuilder { * reference to a static field * @param javaCodePos * the code position/offset in the Java method + * @param lineNumber + * the line number in the Java source code */ - protected void addGlobalInstruction( boolean load, Member ref, int javaCodePos ) { - instructions.add( new WasmGlobalInstruction( load, ref, javaCodePos ) ); + protected void addGlobalInstruction( boolean load, Member ref, int javaCodePos, int lineNumber ) { + instructions.add( new WasmGlobalInstruction( load, ref, javaCodePos, lineNumber ) ); } /** @@ -158,9 +164,11 @@ public abstract class WasmCodeBuilder { * the value type * @param javaCodePos * the code position/offset in the Java method + * @param lineNumber + * the line number in the Java source code */ - protected void addConstInstruction( Number value, ValueType valueType, int javaCodePos ) { - instructions.add( new WasmConstInstruction( value, valueType, javaCodePos ) ); + protected void addConstInstruction( Number value, ValueType valueType, int javaCodePos, int lineNumber ) { + instructions.add( new WasmConstInstruction( value, valueType, javaCodePos, lineNumber ) ); } /** @@ -170,9 +178,11 @@ public abstract class WasmCodeBuilder { * the value * @param javaCodePos * the code position/offset in the Java method + * @param lineNumber + * the line number in the Java source code */ - protected void addConstInstruction( Number value, int javaCodePos ) { - instructions.add( new WasmConstInstruction( value, javaCodePos ) ); + protected void addConstInstruction( Number value, int javaCodePos, int lineNumber ) { + instructions.add( new WasmConstInstruction( value, javaCodePos, lineNumber ) ); } /** @@ -184,9 +194,11 @@ public abstract class WasmCodeBuilder { * the value type * @param javaCodePos * the code position/offset in the Java method + * @param lineNumber + * the line number in the Java source code */ - protected void addNumericInstruction( @Nullable NumericOperator numOp, @Nullable ValueType valueType, int javaCodePos ) { - instructions.add( new WasmNumericInstruction( numOp, valueType, javaCodePos ) ); + protected void addNumericInstruction( @Nullable NumericOperator numOp, @Nullable ValueType valueType, int javaCodePos, int lineNumber ) { + instructions.add( new WasmNumericInstruction( numOp, valueType, javaCodePos, lineNumber ) ); } /** @@ -196,9 +208,11 @@ public abstract class WasmCodeBuilder { * the conversion * @param javaCodePos * the code position/offset in the Java method + * @param lineNumber + * the line number in the Java source code */ - protected void addConvertInstruction( ValueTypeConvertion conversion, int javaCodePos ) { - instructions.add( new WasmConvertInstruction( conversion, javaCodePos ) ); + protected void addConvertInstruction( ValueTypeConvertion conversion, int javaCodePos, int lineNumber ) { + instructions.add( new WasmConvertInstruction( conversion, javaCodePos, lineNumber ) ); } /** @@ -208,9 +222,11 @@ public abstract class WasmCodeBuilder { * the function name that should be called * @param javaCodePos * the code position/offset in the Java method + * @param lineNumber + * the line number in the Java source code */ - protected void addCallInstruction( FunctionName name, int javaCodePos ) { - instructions.add( new WasmCallInstruction( name, javaCodePos ) ); + protected void addCallInstruction( FunctionName name, int javaCodePos, int lineNumber ) { + instructions.add( new WasmCallInstruction( name, javaCodePos, lineNumber ) ); } /** @@ -222,9 +238,11 @@ public abstract class WasmCodeBuilder { * extra data for some operations * @param javaCodePos * the code position/offset in the Java method + * @param lineNumber + * the line number in the Java source code */ - protected void addBlockInstruction( WasmBlockOperator op, @Nullable Object data, int javaCodePos ) { - instructions.add( new WasmBlockInstruction( op, data, javaCodePos ) ); + protected void addBlockInstruction( WasmBlockOperator op, @Nullable Object data, int javaCodePos, int lineNumber ) { + instructions.add( new WasmBlockInstruction( op, data, javaCodePos, lineNumber ) ); } /** @@ -233,9 +251,11 @@ public abstract class WasmCodeBuilder { * * @param javaCodePos * the code position/offset in the Java method + * @param lineNumber + * the line number in the Java source code */ - protected void addNopInstruction( int javaCodePos ) { - instructions.add( new WasmNopInstruction( javaCodePos ) ); + protected void addNopInstruction( int javaCodePos, int lineNumber ) { + instructions.add( new WasmNopInstruction( javaCodePos, lineNumber ) ); } /** @@ -247,9 +267,11 @@ public abstract class WasmCodeBuilder { * the array type * @param javaCodePos * the code position/offset in the Java method + * @param lineNumber + * the line number in the Java source code */ - protected void addArrayInstruction( ArrayOperator op, AnyType type, int javaCodePos ) { - instructions.add( new WasmArrayInstruction( op, type, javaCodePos ) ); + protected void addArrayInstruction( ArrayOperator op, AnyType type, int javaCodePos, int lineNumber ) { + instructions.add( new WasmArrayInstruction( op, type, javaCodePos, lineNumber ) ); } /** @@ -263,8 +285,10 @@ public abstract class WasmCodeBuilder { * the name of field if needed for the operation * @param javaCodePos * the code position/offset in the Java method + * @param lineNumber + * the line number in the Java source code */ - protected void addStructInstruction( StructOperator op, @Nullable String typeName, @Nullable String fieldName, int javaCodePos ) { - instructions.add( new WasmStructInstruction( op, typeName == null ? null : types.valueOf( typeName ), fieldName, javaCodePos ) ); + protected void addStructInstruction( StructOperator op, @Nullable String typeName, @Nullable String fieldName, int javaCodePos, int lineNumber ) { + instructions.add( new WasmStructInstruction( op, typeName == null ? null : types.valueOf( typeName ), fieldName, javaCodePos, lineNumber ) ); } } diff --git a/src/de/inetsoftware/jwebassembly/module/WasmConstInstruction.java b/src/de/inetsoftware/jwebassembly/module/WasmConstInstruction.java index f831ada..8fdff86 100644 --- a/src/de/inetsoftware/jwebassembly/module/WasmConstInstruction.java +++ b/src/de/inetsoftware/jwebassembly/module/WasmConstInstruction.java @@ -21,7 +21,6 @@ import java.io.IOException; import javax.annotation.Nonnull; import de.inetsoftware.jwebassembly.WasmException; -import de.inetsoftware.jwebassembly.module.WasmInstruction.Type; import de.inetsoftware.jwebassembly.wasm.AnyType; import de.inetsoftware.jwebassembly.wasm.ValueType; @@ -46,9 +45,11 @@ class WasmConstInstruction extends WasmInstruction { * the data type of the number * @param javaCodePos * the code position/offset in the Java method + * @param lineNumber + * the line number in the Java source code */ - WasmConstInstruction( Number value, ValueType valueType, int javaCodePos ) { - super( javaCodePos ); + WasmConstInstruction( Number value, ValueType valueType, int javaCodePos, int lineNumber ) { + super( javaCodePos, lineNumber ); this.value = value; this.valueType = valueType; } @@ -60,9 +61,11 @@ class WasmConstInstruction extends WasmInstruction { * the constant value * @param javaCodePos * the code position/offset in the Java method + * @param lineNumber + * the line number in the Java source code */ - WasmConstInstruction( Number value, int javaCodePos ) { - this( value, getValueType( value ), javaCodePos ); + WasmConstInstruction( Number value, int javaCodePos, int lineNumber ) { + this( value, getValueType( value ), javaCodePos, lineNumber ); } /** diff --git a/src/de/inetsoftware/jwebassembly/module/WasmConvertInstruction.java b/src/de/inetsoftware/jwebassembly/module/WasmConvertInstruction.java index 5b0f516..af90fd3 100644 --- a/src/de/inetsoftware/jwebassembly/module/WasmConvertInstruction.java +++ b/src/de/inetsoftware/jwebassembly/module/WasmConvertInstruction.java @@ -17,7 +17,6 @@ package de.inetsoftware.jwebassembly.module; import java.io.IOException; -import de.inetsoftware.jwebassembly.module.WasmInstruction.Type; import de.inetsoftware.jwebassembly.wasm.AnyType; import de.inetsoftware.jwebassembly.wasm.ValueType; @@ -38,9 +37,11 @@ class WasmConvertInstruction extends WasmInstruction { * the conversion type * @param javaCodePos * the code position/offset in the Java method + * @param lineNumber + * the line number in the Java source code */ - WasmConvertInstruction( ValueTypeConvertion conversion, int javaCodePos ) { - super( javaCodePos ); + WasmConvertInstruction( ValueTypeConvertion conversion, int javaCodePos, int lineNumber ) { + super( javaCodePos, lineNumber ); this.conversion = conversion; } diff --git a/src/de/inetsoftware/jwebassembly/module/WasmGlobalInstruction.java b/src/de/inetsoftware/jwebassembly/module/WasmGlobalInstruction.java index 321cf53..5876dfc 100644 --- a/src/de/inetsoftware/jwebassembly/module/WasmGlobalInstruction.java +++ b/src/de/inetsoftware/jwebassembly/module/WasmGlobalInstruction.java @@ -21,7 +21,6 @@ import java.io.IOException; import javax.annotation.Nonnull; import de.inetsoftware.classparser.Member; -import de.inetsoftware.jwebassembly.module.WasmInstruction.Type; import de.inetsoftware.jwebassembly.wasm.AnyType; import de.inetsoftware.jwebassembly.wasm.ValueType; @@ -46,9 +45,11 @@ class WasmGlobalInstruction extends WasmInstruction { * reference to a static field * @param javaCodePos * the code position/offset in the Java method + * @param lineNumber + * the line number in the Java source code */ - WasmGlobalInstruction( boolean load, Member ref, int javaCodePos ) { - super( javaCodePos ); + WasmGlobalInstruction( boolean load, Member ref, int javaCodePos, int lineNumber ) { + super( javaCodePos, lineNumber ); this.load = load; this.ref = ref; } diff --git a/src/de/inetsoftware/jwebassembly/module/WasmInstruction.java b/src/de/inetsoftware/jwebassembly/module/WasmInstruction.java index 48bd8fd..ef9c471 100644 --- a/src/de/inetsoftware/jwebassembly/module/WasmInstruction.java +++ b/src/de/inetsoftware/jwebassembly/module/WasmInstruction.java @@ -38,20 +38,26 @@ abstract class WasmInstruction { Const, Convert, Local, Global, Block, Numeric, Nop, Call, Array, Struct; } - private int javaCodePos; + private int javaCodePos; + + private final int lineNumber; /** * Create a new instance of an instruction * * @param javaCodePos * the code position/offset in the Java method + * @param lineNumber + * the line number in the Java source code */ - WasmInstruction( int javaCodePos ) { + WasmInstruction( int javaCodePos, int lineNumber ) { this.javaCodePos = javaCodePos; + this.lineNumber = lineNumber; } /** * Get the type of instruction + * * @return the type */ @Nonnull @@ -69,18 +75,30 @@ abstract class WasmInstruction { /** * Get current code position in Java method. + * * @return the position */ int getCodePosition() { return javaCodePos; } + /** + * Get the line number in the Java source file + * + * @return the line number + */ + int getLineNumber() { + return lineNumber; + } + /** * Set a new code position after reorganize the order - * @param newPos new position + * + * @param newPos + * new position */ void setCodePosition( int newPos ) { - this.javaCodePos = newPos; + this.javaCodePos = newPos; } /** diff --git a/src/de/inetsoftware/jwebassembly/module/WasmLoadStoreInstruction.java b/src/de/inetsoftware/jwebassembly/module/WasmLoadStoreInstruction.java index 12c62ca..8dfe76e 100644 --- a/src/de/inetsoftware/jwebassembly/module/WasmLoadStoreInstruction.java +++ b/src/de/inetsoftware/jwebassembly/module/WasmLoadStoreInstruction.java @@ -41,9 +41,11 @@ class WasmLoadStoreInstruction extends WasmLocalInstruction { * the manager for local variables * @param javaCodePos * the code position/offset in the Java method + * @param lineNumber + * the line number in the Java source code */ - WasmLoadStoreInstruction( boolean load, @Nonnegative int idx, LocaleVariableManager localVariables, int javaCodePos ) { - super( load, idx, javaCodePos ); + WasmLoadStoreInstruction( boolean load, @Nonnegative int idx, LocaleVariableManager localVariables, int javaCodePos, int lineNumber ) { + super( load, idx, javaCodePos, lineNumber ); this.localVariables = localVariables; } diff --git a/src/de/inetsoftware/jwebassembly/module/WasmLocalInstruction.java b/src/de/inetsoftware/jwebassembly/module/WasmLocalInstruction.java index f425e5c..f23355d 100644 --- a/src/de/inetsoftware/jwebassembly/module/WasmLocalInstruction.java +++ b/src/de/inetsoftware/jwebassembly/module/WasmLocalInstruction.java @@ -47,9 +47,11 @@ class WasmLocalInstruction extends WasmInstruction { * the memory/slot idx of the variable * @param javaCodePos * the code position/offset in the Java method + * @param lineNumber + * the line number in the Java source code */ - WasmLocalInstruction( boolean load, @Nonnegative int idx, int javaCodePos ) { - super( javaCodePos ); + WasmLocalInstruction( boolean load, @Nonnegative int idx, int javaCodePos, int lineNumber ) { + super( javaCodePos, lineNumber ); this.op = load ? get : set; this.idx = idx; } diff --git a/src/de/inetsoftware/jwebassembly/module/WasmNopInstruction.java b/src/de/inetsoftware/jwebassembly/module/WasmNopInstruction.java index da74c6e..042e058 100644 --- a/src/de/inetsoftware/jwebassembly/module/WasmNopInstruction.java +++ b/src/de/inetsoftware/jwebassembly/module/WasmNopInstruction.java @@ -20,7 +20,6 @@ import java.io.IOException; import javax.annotation.Nonnull; -import de.inetsoftware.jwebassembly.module.WasmInstruction.Type; import de.inetsoftware.jwebassembly.wasm.AnyType; /** @@ -36,9 +35,11 @@ class WasmNopInstruction extends WasmInstruction { * * @param javaCodePos * the code position/offset in the Java method + * @param lineNumber + * the line number in the Java source code */ - WasmNopInstruction( int javaCodePos ) { - super( javaCodePos ); + WasmNopInstruction( int javaCodePos, int lineNumber ) { + super( javaCodePos, lineNumber ); } /** diff --git a/src/de/inetsoftware/jwebassembly/module/WasmNumericInstruction.java b/src/de/inetsoftware/jwebassembly/module/WasmNumericInstruction.java index 9cbff71..4d6b326 100644 --- a/src/de/inetsoftware/jwebassembly/module/WasmNumericInstruction.java +++ b/src/de/inetsoftware/jwebassembly/module/WasmNumericInstruction.java @@ -21,7 +21,6 @@ import java.io.IOException; import javax.annotation.Nonnull; import javax.annotation.Nullable; -import de.inetsoftware.jwebassembly.module.WasmInstruction.Type; import de.inetsoftware.jwebassembly.wasm.AnyType; import de.inetsoftware.jwebassembly.wasm.NumericOperator; import de.inetsoftware.jwebassembly.wasm.ValueType; @@ -47,9 +46,11 @@ class WasmNumericInstruction extends WasmInstruction { * the type of the parameters * @param javaCodePos * the code position/offset in the Java method + * @param lineNumber + * the line number in the Java source code */ - WasmNumericInstruction( @Nullable NumericOperator numOp, @Nullable ValueType valueType, int javaCodePos ) { - super( javaCodePos ); + WasmNumericInstruction( @Nullable NumericOperator numOp, @Nullable ValueType valueType, int javaCodePos, int lineNumber ) { + super( javaCodePos, lineNumber ); this.numOp = numOp; this.valueType = valueType; } diff --git a/src/de/inetsoftware/jwebassembly/module/WasmStructInstruction.java b/src/de/inetsoftware/jwebassembly/module/WasmStructInstruction.java index 58e259a..8439c50 100644 --- a/src/de/inetsoftware/jwebassembly/module/WasmStructInstruction.java +++ b/src/de/inetsoftware/jwebassembly/module/WasmStructInstruction.java @@ -52,9 +52,11 @@ class WasmStructInstruction extends WasmInstruction { * the name of field if needed for the operation * @param javaCodePos * the code position/offset in the Java method + * @param lineNumber + * the line number in the Java source code */ - WasmStructInstruction( @Nullable StructOperator op, @Nullable StructType type, @Nullable String fieldName, int javaCodePos ) { - super( javaCodePos ); + WasmStructInstruction( @Nullable StructOperator op, @Nullable StructType type, @Nullable String fieldName, int javaCodePos, int lineNumber ) { + super( javaCodePos, lineNumber ); this.op = op; this.type = type; this.fieldName = fieldName; diff --git a/src/de/inetsoftware/jwebassembly/watparser/WatParser.java b/src/de/inetsoftware/jwebassembly/watparser/WatParser.java index 3a508ac..5ced1f0 100644 --- a/src/de/inetsoftware/jwebassembly/watparser/WatParser.java +++ b/src/de/inetsoftware/jwebassembly/watparser/WatParser.java @@ -55,64 +55,64 @@ public class WatParser extends WasmCodeBuilder { String tok = tokens.get( i ); switch( tok ) { case "local.get": - addLocalInstruction( true, getInt( tokens, ++i), javaCodePos ); + addLocalInstruction( true, getInt( tokens, ++i), javaCodePos, lineNumber ); break; case "local.set": - addLocalInstruction( false, getInt( tokens, ++i), javaCodePos ); + addLocalInstruction( false, getInt( tokens, ++i), javaCodePos, lineNumber ); break; // case "get_global": // addGlobalInstruction( true, ref, javaCodePos ); // break; case "i32.const": - addConstInstruction( getInt( tokens, ++i), ValueType.i32, javaCodePos ); + addConstInstruction( getInt( tokens, ++i), ValueType.i32, javaCodePos, lineNumber ); break; case "i32.add": - addNumericInstruction( NumericOperator.add, ValueType.i32, javaCodePos ); + addNumericInstruction( NumericOperator.add, ValueType.i32, javaCodePos, lineNumber ); break; case "i32.trunc_sat_f32_s": - addConvertInstruction( ValueTypeConvertion.f2i, javaCodePos ); + addConvertInstruction( ValueTypeConvertion.f2i, javaCodePos, lineNumber ); break; case "i64.extend_i32_s": - addConvertInstruction( ValueTypeConvertion.i2l, javaCodePos ); + addConvertInstruction( ValueTypeConvertion.i2l, javaCodePos, lineNumber ); break; case "i64.trunc_sat_f64_s": - addConvertInstruction( ValueTypeConvertion.d2l, javaCodePos ); + addConvertInstruction( ValueTypeConvertion.d2l, javaCodePos, lineNumber ); break; case "f32.convert_i32_s": - addConvertInstruction( ValueTypeConvertion.i2f, javaCodePos ); + addConvertInstruction( ValueTypeConvertion.i2f, javaCodePos, lineNumber ); break; case "f32.div": - addNumericInstruction( NumericOperator.div, ValueType.f32, javaCodePos ); + addNumericInstruction( NumericOperator.div, ValueType.f32, javaCodePos, lineNumber ); break; case "f32.max": - addNumericInstruction( NumericOperator.max, ValueType.f32, javaCodePos ); + addNumericInstruction( NumericOperator.max, ValueType.f32, javaCodePos, lineNumber ); break; case "f32.mul": - addNumericInstruction( NumericOperator.mul, ValueType.f32, javaCodePos ); + addNumericInstruction( NumericOperator.mul, ValueType.f32, javaCodePos, lineNumber ); break; case "f32.sub": - addNumericInstruction( NumericOperator.sub, ValueType.f32, javaCodePos ); + addNumericInstruction( NumericOperator.sub, ValueType.f32, javaCodePos, lineNumber ); break; case "f64.convert_i64_s": - addConvertInstruction( ValueTypeConvertion.l2d, javaCodePos ); + addConvertInstruction( ValueTypeConvertion.l2d, javaCodePos, lineNumber ); break; case "f64.div": - addNumericInstruction( NumericOperator.div, ValueType.f64, javaCodePos ); + addNumericInstruction( NumericOperator.div, ValueType.f64, javaCodePos, lineNumber ); break; case "f64.max": - addNumericInstruction( NumericOperator.max, ValueType.f64, javaCodePos ); + addNumericInstruction( NumericOperator.max, ValueType.f64, javaCodePos, lineNumber ); break; case "f64.mul": - addNumericInstruction( NumericOperator.mul, ValueType.f64, javaCodePos ); + addNumericInstruction( NumericOperator.mul, ValueType.f64, javaCodePos, lineNumber ); break; case "f64.sub": - addNumericInstruction( NumericOperator.sub, ValueType.f64, javaCodePos ); + addNumericInstruction( NumericOperator.sub, ValueType.f64, javaCodePos, lineNumber ); break; // case "call": // addCallInstruction( method, javaCodePos ); // break; case "return": - addBlockInstruction( WasmBlockOperator.RETURN, null, javaCodePos ); + addBlockInstruction( WasmBlockOperator.RETURN, null, javaCodePos, lineNumber ); break; default: throw new WasmException( "Unknown WASM token: " + tok, lineNumber );