mirror of
https://github.com/i-net-software/JWebAssembly.git
synced 2025-03-25 23:47:51 +01:00
1085 lines
44 KiB
Java
1085 lines
44 KiB
Java
/*
|
|
* Copyright 2018 - 2022 Volker Berlin (i-net software)
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
package de.inetsoftware.jwebassembly.module;
|
|
|
|
import java.io.IOException;
|
|
import java.util.ArrayList;
|
|
import java.util.Collections;
|
|
import java.util.Iterator;
|
|
import java.util.List;
|
|
import java.util.function.Function;
|
|
|
|
import javax.annotation.Nonnegative;
|
|
import javax.annotation.Nonnull;
|
|
import javax.annotation.Nullable;
|
|
|
|
import de.inetsoftware.classparser.BootstrapMethod;
|
|
import de.inetsoftware.classparser.ClassFile;
|
|
import de.inetsoftware.classparser.ConstantClass;
|
|
import de.inetsoftware.classparser.FieldInfo;
|
|
import de.inetsoftware.classparser.LocalVariableTable;
|
|
import de.inetsoftware.classparser.Member;
|
|
import de.inetsoftware.classparser.MethodInfo;
|
|
import de.inetsoftware.jwebassembly.WasmException;
|
|
import de.inetsoftware.jwebassembly.javascript.NonGC;
|
|
import de.inetsoftware.jwebassembly.module.StackInspector.StackValue;
|
|
import de.inetsoftware.jwebassembly.module.TypeManager.LambdaType;
|
|
import de.inetsoftware.jwebassembly.module.TypeManager.StructType;
|
|
import de.inetsoftware.jwebassembly.module.WasmInstruction.Type;
|
|
import de.inetsoftware.jwebassembly.wasm.AnyType;
|
|
import de.inetsoftware.jwebassembly.wasm.ArrayOperator;
|
|
import de.inetsoftware.jwebassembly.wasm.ArrayType;
|
|
import de.inetsoftware.jwebassembly.wasm.MemoryOperator;
|
|
import de.inetsoftware.jwebassembly.wasm.NamedStorageType;
|
|
import de.inetsoftware.jwebassembly.wasm.NumericOperator;
|
|
import de.inetsoftware.jwebassembly.wasm.StructOperator;
|
|
import de.inetsoftware.jwebassembly.wasm.ValueType;
|
|
import de.inetsoftware.jwebassembly.wasm.ValueTypeParser;
|
|
import de.inetsoftware.jwebassembly.wasm.VariableOperator;
|
|
import de.inetsoftware.jwebassembly.wasm.WasmBlockOperator;
|
|
|
|
/**
|
|
* Base class for Code Building.
|
|
*
|
|
* @author Volker Berlin
|
|
*/
|
|
public abstract class WasmCodeBuilder {
|
|
|
|
/** Java method name of of constructor */
|
|
static final String CONSTRUCTOR = "<init>";
|
|
|
|
/** Java method name of static constructor or initialization method */
|
|
static final String CLASS_INIT = "<clinit>";
|
|
|
|
private final LocaleVariableManager localVariables;
|
|
|
|
private final List<WasmInstruction> instructions;
|
|
|
|
private TypeManager types;
|
|
|
|
private FunctionManager functions;
|
|
|
|
private WasmOptions options;
|
|
|
|
private StringManager strings;
|
|
|
|
private ClassFileLoader classFileLoader;
|
|
|
|
/**
|
|
* Create a new instance of CodeBuilder
|
|
*/
|
|
protected WasmCodeBuilder() {
|
|
localVariables = new LocaleVariableManager();
|
|
instructions = new ArrayList<>();
|
|
}
|
|
|
|
/**
|
|
* Create a new instance with shared resources
|
|
*
|
|
* @param codeBuilder
|
|
* other instance of CodeBuilder
|
|
*/
|
|
WasmCodeBuilder( @Nonnull WasmCodeBuilder codeBuilder ) {
|
|
localVariables = codeBuilder.localVariables;
|
|
instructions = codeBuilder.instructions;
|
|
}
|
|
|
|
/**
|
|
* Initialize the code builder;
|
|
*
|
|
* @param options
|
|
* compiler properties
|
|
* @param classFileLoader
|
|
* for loading the class files
|
|
*/
|
|
void init( WasmOptions options, ClassFileLoader classFileLoader ) {
|
|
this.localVariables.init( options.types );
|
|
this.types = options.types;
|
|
this.functions = options.functions;
|
|
this.strings = options.strings;
|
|
this.options = options;
|
|
this.classFileLoader = classFileLoader;
|
|
}
|
|
|
|
/**
|
|
* Get the list of instructions
|
|
*
|
|
* @return the list
|
|
*/
|
|
@Nonnull
|
|
List<WasmInstruction> getInstructions() {
|
|
return instructions;
|
|
}
|
|
|
|
/**
|
|
* Get the manager of local variables
|
|
* @return the manager
|
|
*/
|
|
@Nonnull
|
|
LocaleVariableManager getLocalVariables() {
|
|
return localVariables;
|
|
}
|
|
|
|
/**
|
|
* Get the compiler settings
|
|
*
|
|
* @return the settings
|
|
*/
|
|
@Nonnull
|
|
WasmOptions getOptions() {
|
|
return options;
|
|
}
|
|
|
|
/**
|
|
* Check if the last instruction is a return instruction
|
|
*
|
|
* @return true, if a return
|
|
*/
|
|
boolean isEndsWithReturn() {
|
|
WasmInstruction instr = instructions.get( instructions.size() - 1 );
|
|
if( instr.getType() == Type.Block ) {
|
|
return ((WasmBlockInstruction)instr).getOperation() == WasmBlockOperator.RETURN;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* We need a value (or several) from the stack inside a block. We need to find the WasmInstruction where the block
|
|
* can can begin. If it is a function call or a numeric expression, it can be complicated to find the right point.
|
|
*
|
|
* @param count
|
|
* the count of values on the stack back. 1 means the last value. 2 means the penultimate value.
|
|
* @param instructions
|
|
* the instruction list for searching
|
|
* @param idx
|
|
* the start index for the search. Between 0 and instructions.size().
|
|
* @return the code position that push the last instruction
|
|
*/
|
|
static int findBlockStart( int count, List<WasmInstruction> instructions, int idx ) {
|
|
int valueCount = 0;
|
|
for( int i = idx - 1; i >= 0; i-- ) {
|
|
WasmInstruction instr = instructions.get( i );
|
|
AnyType valueType = instr.getPushValueType();
|
|
if( valueType != null ) {
|
|
valueCount++;
|
|
}
|
|
int popCount = instr.getPopCount();
|
|
valueCount -= popCount;
|
|
if( valueCount == count && popCount == 0 ) {
|
|
int codePos = instr.getCodePosition();
|
|
if( i == 0 || instructions.get( i - 1 ).getCodePosition() < codePos ) {
|
|
// if the same codePos is used from multiple instructions then it is not an atomic operation in Java
|
|
return codePos;
|
|
}
|
|
}
|
|
}
|
|
throw new WasmException( "Block start position not found", -1 ); // should never occur
|
|
}
|
|
|
|
/**
|
|
* We need the value type from the stack.
|
|
*
|
|
* @param count
|
|
* the count of values on the stack back. 1 means the last value. 2 means the penultimate value.
|
|
* @param javaCodePos
|
|
* current code position for which the stack is inspected
|
|
* @return the type of the last push value
|
|
*/
|
|
@Nonnull
|
|
AnyType findValueTypeFromStack( int count, int javaCodePos ) {
|
|
return StackInspector.findInstructionThatPushValue( instructions, count, javaCodePos ).instr.getPushValueType();
|
|
}
|
|
|
|
/**
|
|
* Find the array component type from stack.
|
|
*
|
|
* @param count
|
|
* the count of values on the stack back. 1 means the last value. 2 means the penultimate value.
|
|
* @param javaCodePos
|
|
* current code position for which the stack is inspected
|
|
* @return
|
|
*/
|
|
@Nonnull
|
|
AnyType findArrayTypeFromStack( int count, int javaCodePos ) {
|
|
StackValue stackValue = StackInspector.findInstructionThatPushValue( instructions, count, javaCodePos );
|
|
AnyType type = stackValue.instr.getPushValueType();
|
|
if( type instanceof ArrayType ) {
|
|
return ((ArrayType)type).getArrayType();
|
|
}
|
|
|
|
if( stackValue.instr instanceof WasmLoadStoreInstruction ) {
|
|
int slot = ((WasmLoadStoreInstruction)stackValue.instr).getSlot();
|
|
ArrayType arrayType = types.arrayType( types.valueOf( "java/lang/Object" ) );
|
|
localVariables.use( arrayType, slot, javaCodePos );
|
|
return arrayType.getArrayType();
|
|
}
|
|
return ValueType.eqref;
|
|
}
|
|
|
|
/**
|
|
* Find the instruction that push the x-th value to the stack.
|
|
*
|
|
* @param count
|
|
* the count of values on the stack back. 1 means the last value. 2 means the penultimate value.
|
|
* @param javaCodePos
|
|
* current code position for which the stack is inspected
|
|
* @return the instruction
|
|
*/
|
|
@Nonnull
|
|
private WasmInstruction findInstructionThatPushValue( int count, int javaCodePos ) {
|
|
return StackInspector.findInstructionThatPushValue( instructions, count, javaCodePos ).instr;
|
|
}
|
|
|
|
/**
|
|
* Get the data types of the local variables. The value is only valid until the next call.
|
|
*
|
|
* @param paramCount
|
|
* the count of method parameter which should be exclude
|
|
* @return the reused list with fresh values
|
|
*/
|
|
List<AnyType> getLocalTypes( int paramCount ) {
|
|
return localVariables.getLocalTypes( paramCount );
|
|
}
|
|
|
|
/**
|
|
* Get the name of the variable or null if no name available
|
|
*
|
|
* @param idx
|
|
* the wasm variable index
|
|
* @return the name
|
|
*/
|
|
String getLocalName( int idx ) {
|
|
return localVariables.getLocalName( idx );
|
|
}
|
|
|
|
/**
|
|
* Get the slot of the temporary variable.
|
|
*
|
|
* @param valueType
|
|
* the valueType for the variable
|
|
* @param startCodePosition
|
|
* the start of the Java code position
|
|
* @param endCodePosition
|
|
* the end of the Java code position
|
|
* @return the slot
|
|
*/
|
|
int getTempVariable( AnyType valueType, int startCodePosition, int endCodePosition ) {
|
|
return localVariables.getTempVariable( valueType, startCodePosition, endCodePosition );
|
|
}
|
|
|
|
/**
|
|
* Get the type manager.
|
|
*
|
|
* @return the type manager
|
|
*/
|
|
protected TypeManager getTypeManager() {
|
|
return types;
|
|
}
|
|
|
|
/**
|
|
* Reset the code builder.
|
|
*
|
|
* @param variableTable
|
|
* variable table of the Java method.
|
|
* @param method
|
|
* the method with signature as fallback for a missing variable table. If null signature is used and the method must be static.
|
|
* @param signature
|
|
* alternative for method signature, can be null if method is set
|
|
*/
|
|
protected void reset( LocalVariableTable variableTable, MethodInfo method, Iterator<AnyType> signature ) {
|
|
instructions.clear();
|
|
localVariables.reset( variableTable, method, signature );
|
|
}
|
|
|
|
/**
|
|
* Calculate the index of the variables
|
|
*/
|
|
protected void calculateVariables() {
|
|
localVariables.calculate();
|
|
}
|
|
|
|
/**
|
|
* Create a WasmLoadStoreInstruction.
|
|
*
|
|
* @param valueType
|
|
* the value type
|
|
* @param load
|
|
* true: if load
|
|
* @param javaIdx
|
|
* 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
|
|
*/
|
|
protected void addLoadStoreInstruction( AnyType valueType, boolean load, @Nonnegative int javaIdx, int javaCodePos, int lineNumber ) {
|
|
localVariables.use( valueType, javaIdx, javaCodePos );
|
|
instructions.add( new WasmLoadStoreInstruction( load ? VariableOperator.get : VariableOperator.set, javaIdx, localVariables, javaCodePos, lineNumber ) );
|
|
}
|
|
|
|
/**
|
|
* Create a WasmLoadStoreInstruction local.get/local.set.
|
|
*
|
|
* @param op
|
|
* the operation
|
|
* @param wasmIdx
|
|
* 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
|
|
*/
|
|
protected void addLocalInstruction( VariableOperator op, @Nonnegative int wasmIdx, int javaCodePos, int lineNumber ) {
|
|
switch( op ) {
|
|
case set:
|
|
case tee:
|
|
AnyType valueType = findValueTypeFromStack( 1, javaCodePos );
|
|
localVariables.useIndex( valueType, wasmIdx );
|
|
}
|
|
instructions.add( new WasmLocalInstruction( op, wasmIdx, localVariables, javaCodePos, lineNumber ) );
|
|
}
|
|
|
|
/**
|
|
* Get a possible slot from the instruction
|
|
*
|
|
* @param instr
|
|
* the instruction
|
|
* @return the slot or -1 if there no slot
|
|
*/
|
|
private static int getPossibleSlot( @Nonnull WasmInstruction instr ) {
|
|
// if it is a GET to a local variable then we can use it
|
|
if( instr.getType() == Type.Local ) {
|
|
WasmLocalInstruction local1 = (WasmLocalInstruction)instr;
|
|
switch( local1.getOperator() ) {
|
|
case get:
|
|
case tee:
|
|
return local1.getSlot();
|
|
default:
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
/**
|
|
* Create a WasmDupInstruction.
|
|
*
|
|
* @param dup2
|
|
* call from dup2 instruction
|
|
* @param javaCodePos
|
|
* the code position/offset in the Java method
|
|
* @param lineNumber
|
|
* the line number in the Java source code
|
|
*/
|
|
protected void addDupInstruction( boolean dup2, int javaCodePos, int lineNumber ) {
|
|
WasmInstruction instr = findInstructionThatPushValue( 1, javaCodePos );
|
|
AnyType type = instr.getPushValueType();
|
|
int slot = getPossibleSlot( instr );
|
|
|
|
// occur with:
|
|
// int[] data = new int[x];
|
|
// data[i] |= any;
|
|
instr = dup2 && type != ValueType.i64 && type != ValueType.f64 ? //
|
|
findInstructionThatPushValue( 2, javaCodePos ) : null;
|
|
|
|
int slot2;
|
|
if( instr != null ) {
|
|
slot2 = getPossibleSlot( instr );
|
|
if( slot2 < 0 ) {
|
|
slot2 = getTempVariable( instr.getPushValueType(), javaCodePos, javaCodePos + 1 );
|
|
if( slot < 0 ) {
|
|
slot = getTempVariable( type, javaCodePos, javaCodePos + 1 );
|
|
instructions.add( new WasmLoadStoreInstruction( VariableOperator.set, slot, localVariables, javaCodePos, lineNumber ) );
|
|
} else {
|
|
instructions.add( new WasmBlockInstruction( WasmBlockOperator.DROP, null, javaCodePos, lineNumber ) );
|
|
}
|
|
instructions.add( new WasmLoadStoreInstruction( VariableOperator.tee, slot2, localVariables, javaCodePos, lineNumber ) );
|
|
instructions.add( new WasmLoadStoreInstruction( VariableOperator.get, slot, localVariables, javaCodePos, lineNumber ) );
|
|
}
|
|
} else {
|
|
slot2 = -1; // for compiler only
|
|
}
|
|
|
|
//alternate we need to create a new locale variable
|
|
if( slot < 0 ) {
|
|
slot = getTempVariable( type, javaCodePos, javaCodePos + 1 );
|
|
instructions.add( new WasmLoadStoreInstruction( VariableOperator.tee, slot, localVariables, javaCodePos, lineNumber ) );
|
|
} else {
|
|
localVariables.expandUse( slot, javaCodePos );
|
|
}
|
|
if( instr != null ) {
|
|
instructions.add( new WasmLoadStoreInstruction( VariableOperator.get, slot2, localVariables, javaCodePos, lineNumber ) );
|
|
}
|
|
instructions.add( new WasmLoadStoreInstruction( VariableOperator.get, slot, localVariables, javaCodePos, lineNumber ) );
|
|
}
|
|
|
|
/**
|
|
* Simulate the dup_x1 Java byte code instruction.<p>
|
|
*
|
|
* ..., value2, value1 → ..., value1, value2, value1
|
|
*
|
|
* @param javaCodePos
|
|
* the code position/offset in the Java method
|
|
* @param lineNumber
|
|
* the line number in the Java source code
|
|
*/
|
|
protected void addDupX1Instruction( int javaCodePos, int lineNumber ) {
|
|
AnyType type1 = findValueTypeFromStack( 1, javaCodePos );
|
|
AnyType type2 = findValueTypeFromStack( 2, javaCodePos );
|
|
|
|
int varSlot1 = getTempVariable( type1, javaCodePos, javaCodePos + 1 );
|
|
int varSlot2 = getTempVariable( type2, javaCodePos, javaCodePos + 1 );
|
|
|
|
// save in temp variables
|
|
instructions.add( new WasmLoadStoreInstruction( VariableOperator.set, varSlot1, localVariables, javaCodePos, lineNumber ) );
|
|
instructions.add( new WasmLoadStoreInstruction( VariableOperator.set, varSlot2, localVariables, javaCodePos, lineNumber ) );
|
|
|
|
// and restore it in new order on the stack
|
|
instructions.add( new WasmLoadStoreInstruction( VariableOperator.get, varSlot1, localVariables, javaCodePos, lineNumber ) );
|
|
instructions.add( new WasmLoadStoreInstruction( VariableOperator.get, varSlot2, localVariables, javaCodePos, lineNumber ) );
|
|
instructions.add( new WasmLoadStoreInstruction( VariableOperator.get, varSlot1, localVariables, javaCodePos, lineNumber ) );
|
|
}
|
|
|
|
/**
|
|
* Simulate the dup_x2 Java byte code instruction.<p>
|
|
*
|
|
* ..., value3, value2, value1 → ..., value1, value3, value2, value1
|
|
*
|
|
* @param javaCodePos
|
|
* the code position/offset in the Java method
|
|
* @param lineNumber
|
|
* the line number in the Java source code
|
|
*/
|
|
protected void addDupX2Instruction( int javaCodePos, int lineNumber ) {
|
|
AnyType type1 = findValueTypeFromStack( 1, javaCodePos );
|
|
AnyType type2 = findValueTypeFromStack( 2, javaCodePos );
|
|
AnyType type3 = findValueTypeFromStack( 3, javaCodePos );
|
|
|
|
int varSlot1 = getTempVariable( type1, javaCodePos, javaCodePos + 1 );
|
|
int varSlot2 = getTempVariable( type2, javaCodePos, javaCodePos + 1 );
|
|
int varSlot3 = getTempVariable( type3, javaCodePos, javaCodePos + 1 );
|
|
|
|
// save in temp variables
|
|
instructions.add( new WasmLoadStoreInstruction( VariableOperator.set, varSlot1, localVariables, javaCodePos, lineNumber ) );
|
|
instructions.add( new WasmLoadStoreInstruction( VariableOperator.set, varSlot2, localVariables, javaCodePos, lineNumber ) );
|
|
instructions.add( new WasmLoadStoreInstruction( VariableOperator.set, varSlot3, localVariables, javaCodePos, lineNumber ) );
|
|
|
|
// and restore it in new order on the stack
|
|
instructions.add( new WasmLoadStoreInstruction( VariableOperator.get, varSlot1, localVariables, javaCodePos, lineNumber ) );
|
|
instructions.add( new WasmLoadStoreInstruction( VariableOperator.get, varSlot3, localVariables, javaCodePos, lineNumber ) );
|
|
instructions.add( new WasmLoadStoreInstruction( VariableOperator.get, varSlot2, localVariables, javaCodePos, lineNumber ) );
|
|
instructions.add( new WasmLoadStoreInstruction( VariableOperator.get, varSlot1, localVariables, javaCodePos, lineNumber ) );
|
|
}
|
|
|
|
/**
|
|
* Add a global instruction
|
|
*
|
|
* @param load
|
|
* true: if load
|
|
* @param ref
|
|
* 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, int lineNumber ) {
|
|
FunctionName name = new FunctionName( ref );
|
|
AnyType type = new ValueTypeParser( ref.getType(), types ).next();
|
|
FunctionName clinit;
|
|
if( load ) {
|
|
clinit = new FunctionName( name.className, CLASS_INIT, "()V" );
|
|
if( !functions.isUsed( clinit ) ) {
|
|
clinit = null;
|
|
}
|
|
} else {
|
|
clinit = null;
|
|
}
|
|
addGlobalInstruction( load, name, type, clinit, javaCodePos, lineNumber );
|
|
}
|
|
|
|
/**
|
|
* Add a global instruction
|
|
*
|
|
* @param load
|
|
* true: if load
|
|
* @param name
|
|
* reference to a static field
|
|
* @param type
|
|
* the type of the static field
|
|
* @param clinit
|
|
* a reference to the class/static constructor which should executed before access 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, FunctionName name, AnyType type, FunctionName clinit, int javaCodePos, int lineNumber ) {
|
|
instructions.add( new WasmGlobalInstruction( load, name, type, clinit, javaCodePos, lineNumber ) );
|
|
functions.markClassAsUsed( name.className );
|
|
}
|
|
|
|
/**
|
|
* Add a global field access instruction
|
|
*
|
|
* @param load
|
|
* true: if load (get)
|
|
* @param fieldName
|
|
* the fieldName like java/lang/System.err
|
|
* @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, String fieldName, int javaCodePos, int lineNumber ) {
|
|
try {
|
|
if( fieldName.startsWith( "$" ) ) {
|
|
fieldName = fieldName.substring( 1 );
|
|
}
|
|
FunctionName name = new FunctionName( fieldName + "()V" );
|
|
ClassFile classFile = classFileLoader.get( name.className );
|
|
FieldInfo field = classFile.getField( name.methodName );
|
|
AnyType type = new ValueTypeParser( field.getType(), types ).next();
|
|
addGlobalInstruction( load, name, type, null, javaCodePos, lineNumber );
|
|
} catch( Throwable ex ) {
|
|
throw WasmException.create( ex, lineNumber );
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Add a WasmTableInstruction table.get/table.set.
|
|
*
|
|
* @param load
|
|
* true: if load
|
|
* @param idx
|
|
* the index of the table
|
|
* @param javaCodePos
|
|
* the code position/offset in the Java method
|
|
* @param lineNumber
|
|
* the line number in the Java source code
|
|
*/
|
|
protected void addTableInstruction( boolean load, @Nonnegative int idx, int javaCodePos, int lineNumber ) {
|
|
instructions.add( new WasmTableInstruction( load, idx, javaCodePos, lineNumber ) );
|
|
}
|
|
|
|
/**
|
|
* Add a constant instruction.
|
|
*
|
|
* @param value
|
|
* the value
|
|
* @param valueType
|
|
* 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, int lineNumber ) {
|
|
instructions.add( new WasmConstInstruction( value, valueType, javaCodePos, lineNumber ) );
|
|
}
|
|
|
|
/**
|
|
* Add a constant instruction with unknown value type.
|
|
*
|
|
* @param value
|
|
* 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( Object value, int javaCodePos, int lineNumber ) {
|
|
if( value.getClass() == String.class ) {
|
|
Integer id = strings.get( value );
|
|
FunctionName name = strings.getStringConstantFunction();
|
|
instructions.add( new WasmConstInstruction( id, ValueType.i32, javaCodePos, lineNumber ) );
|
|
String comment = (String)value;
|
|
if( !isAscii( comment ) ) {
|
|
comment = null;
|
|
}
|
|
instructions.add( new WasmCallInstruction( name, javaCodePos, lineNumber, types, false, comment ) );
|
|
} else if( value instanceof Number ) {
|
|
instructions.add( new WasmConstInstruction( (Number)value, javaCodePos, lineNumber ) );
|
|
} else if( value instanceof ConstantClass ) {
|
|
String className = ((ConstantClass)value).getName();
|
|
Integer id = types.valueOf( className ).getClassIndex();
|
|
FunctionName name = types.getClassConstantFunction();
|
|
instructions.add( new WasmConstInstruction( id, ValueType.i32, javaCodePos, lineNumber ) );
|
|
addCallInstruction( name, false, javaCodePos, lineNumber );
|
|
} else {
|
|
//TODO There can be ConstantClass, MethodType and MethodHandle
|
|
throw new WasmException( "Class constants are not supported. : " + value, lineNumber );
|
|
}
|
|
}
|
|
|
|
/**
|
|
* if the string contains only ASCCI characters
|
|
*
|
|
* @param str
|
|
* the staring
|
|
* @return true, if only ASCII
|
|
*/
|
|
private static boolean isAscii( String str ) {
|
|
int length = str.length();
|
|
for( int i = 0; i < length; i++ ) {
|
|
int c = str.charAt( i );
|
|
if( c >= 0x20 && c < 0x7F ) {
|
|
continue;
|
|
}
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Add a numeric operation instruction
|
|
*
|
|
* @param numOp
|
|
* the operation
|
|
* @param valueType
|
|
* the value type
|
|
* @param javaCodePos
|
|
* the code position/offset in the Java method
|
|
* @param lineNumber
|
|
* the line number in the Java source code
|
|
* @return the added instruction
|
|
*/
|
|
protected WasmNumericInstruction addNumericInstruction( @Nullable NumericOperator numOp, @Nullable ValueType valueType, int javaCodePos, int lineNumber ) {
|
|
WasmNumericInstruction numeric = new WasmNumericInstruction( numOp, valueType, javaCodePos, lineNumber );
|
|
instructions.add( numeric );
|
|
if( !options.useGC() && options.ref_eq == null && (numOp == NumericOperator.ref_eq || numOp == NumericOperator.ref_ne ) ) {
|
|
functions.markAsNeeded( options.ref_eq = getNonGC( "ref_eq", lineNumber ), false );
|
|
}
|
|
return numeric;
|
|
}
|
|
|
|
/**
|
|
* Add a value convert/cast instruction.
|
|
*
|
|
* @param conversion
|
|
* 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, int lineNumber ) {
|
|
instructions.add( new WasmConvertInstruction( conversion, javaCodePos, lineNumber ) );
|
|
}
|
|
|
|
/**
|
|
* Add a static function call.
|
|
*
|
|
* @param name
|
|
* the function name that should be called
|
|
* @param needThisParameter true, if the hidden THIS parameter is needed, If it is an instance method call.
|
|
* @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, boolean needThisParameter, int javaCodePos, int lineNumber ) {
|
|
name = functions.markAsNeeded( name, needThisParameter );
|
|
WasmCallInstruction instruction = new WasmCallInstruction( name, javaCodePos, lineNumber, types, needThisParameter );
|
|
|
|
if( CONSTRUCTOR.equals( name.methodName ) ) {
|
|
// check if there a factory for the constructor in JavaScript then we need to do some more complex patching
|
|
Function<String, Object> importAnannotation = functions.getImportAnannotation( name );
|
|
FunctionName factoryName = null;
|
|
|
|
if( importAnannotation != null ) { // JavaScript replacement for a constructor via import
|
|
// The new signature need a return value. The <init> of Java has ever a void return value
|
|
String signature = name.signature;
|
|
signature = signature.substring( 0, signature.length() - 1 ) + "Ljava/lang/Object;";
|
|
factoryName = new ImportSyntheticFunctionName( "String", "init", signature, importAnannotation );
|
|
} else {
|
|
MethodInfo replace = functions.replace( name, null );
|
|
if( replace != null && !CONSTRUCTOR.equals( replace.getName() ) ) {
|
|
// the constructor was replaced with a factory method. Typical this method called then a JavaScript replacement
|
|
factoryName = new FunctionName( replace );
|
|
}
|
|
}
|
|
|
|
if( factoryName != null ) {
|
|
// the constructor was replaced we need also replace the create instance instruction
|
|
List<WasmInstruction> instructions = this.instructions;
|
|
for( int i = instructions.size() - 1; i >= 0; i-- ) {
|
|
WasmInstruction instr = instructions.get( i );
|
|
if( instr.getType() == Type.Struct ) {
|
|
WasmStructInstruction struct = (WasmStructInstruction)instr;
|
|
if( struct.getOperator() == StructOperator.NEW_DEFAULT ) {
|
|
instructions.set( i, new WasmNopInstruction( struct.getCodePosition(), struct.getLineNumber() ) ); // replace NEW_DEFAULT with Nop, Nop because the code position can be needed for the branch manager
|
|
instr = instructions.get( ++i );
|
|
// if( instr.getType() == Type.Dup ) {
|
|
// instructions.remove( i ); // dup of the instance reference if it is later assign, missing if the object after the constructor is never assign
|
|
// }
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
// the new instruction
|
|
instruction = new WasmCallInstruction( factoryName, javaCodePos, lineNumber, types, false );
|
|
}
|
|
}
|
|
|
|
instructions.add( instruction );
|
|
functions.markClassAsUsed( name.className );
|
|
}
|
|
|
|
/**
|
|
* Add indirect call to the instruction.
|
|
*
|
|
* @param indirectCall
|
|
* the instruction
|
|
*/
|
|
private void addCallIndirectInstruction( WasmCallIndirectInstruction indirectCall ) {
|
|
// For access to the vtable the THIS parameter must be duplicated on stack before the function parameters
|
|
|
|
// find the instruction that THIS push on the stack
|
|
int count = indirectCall.getPopCount();
|
|
int javaCodePos = indirectCall.getCodePosition();
|
|
StackValue stackValue = StackInspector.findInstructionThatPushValue( instructions, count, javaCodePos );
|
|
WasmInstruction instr = stackValue.instr;
|
|
int varSlot = -1;
|
|
// if it is a GET to a local variable then we can use it
|
|
if( instr.getType() == Type.Local ) {
|
|
WasmLocalInstruction local1 = (WasmLocalInstruction)instr;
|
|
if( local1.getOperator() == VariableOperator.get ) {
|
|
varSlot = local1.getSlot();
|
|
}
|
|
}
|
|
//alternate we need to create a new locale variable
|
|
if( varSlot < 0 ) {
|
|
varSlot = getTempVariable( indirectCall.getThisType(), instr.getCodePosition(), javaCodePos + 1 );
|
|
int idx = count == 1 ? instructions.size() : stackValue.idx + 1;
|
|
instructions.add( idx, new DupThis( indirectCall, varSlot, localVariables, instr.getCodePosition() + 1 ) );
|
|
}
|
|
indirectCall.setVariableSlotOfThis( varSlot, localVariables );
|
|
instructions.add( indirectCall );
|
|
options.registerGet_i32(); // for later access of the vtable
|
|
}
|
|
|
|
/**
|
|
* Add a virtual/method function call.
|
|
*
|
|
* @param name
|
|
* 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 addCallVirtualInstruction( FunctionName name, int javaCodePos, int lineNumber ) {
|
|
name = functions.markAsNeeded( name, true );
|
|
addCallIndirectInstruction( new WasmCallVirtualInstruction( name, javaCodePos, lineNumber, types, options ) );
|
|
options.getCallVirtual(); // mark the function as needed
|
|
functions.markClassAsUsed( name.className );
|
|
}
|
|
|
|
/**
|
|
* Add interface function call
|
|
* @param name
|
|
* 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 addCallInterfaceInstruction( FunctionName name, int javaCodePos, int lineNumber ) {
|
|
name = functions.markAsNeeded( name, true );
|
|
addCallIndirectInstruction( new WasmCallInterfaceInstruction( name, javaCodePos, lineNumber, types, options ) );
|
|
options.getCallInterface(); // mark the function as needed
|
|
functions.markClassAsUsed( name.className );
|
|
}
|
|
|
|
/**
|
|
* Add a block operation.
|
|
*
|
|
* @param op
|
|
* the operation
|
|
* @param data
|
|
* 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, int lineNumber ) {
|
|
instructions.add( new WasmBlockInstruction( op, data, javaCodePos, lineNumber ) );
|
|
}
|
|
|
|
/**
|
|
* Add a no operation to the instruction list as marker on the code position. This instruction will not be write to
|
|
* the output.
|
|
*
|
|
* @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, int lineNumber ) {
|
|
instructions.add( new WasmNopInstruction( javaCodePos, lineNumber ) );
|
|
}
|
|
|
|
/**
|
|
* Add a Jump instruction for later stack inspection
|
|
*
|
|
* @param jumpPos
|
|
* the position of the jump
|
|
* @param popCount
|
|
* the the count of values that are removed from the stack.
|
|
* @param pushValueType
|
|
* optional type of a push value
|
|
* @param javaCodePos
|
|
* the code position/offset in the Java method
|
|
* @param lineNumber
|
|
* the line number in the Java source code
|
|
*/
|
|
protected void addJumpPlaceholder( int jumpPos, int popCount, AnyType pushValueType, int javaCodePos, int lineNumber ) {
|
|
instructions.add( new JumpInstruction( jumpPos, popCount, pushValueType, javaCodePos, lineNumber ) );
|
|
}
|
|
|
|
/**
|
|
* Get a non GC polyfill function.
|
|
* @param name the function name
|
|
* @param lineNumber the line number for a possible error
|
|
* @return the function name
|
|
*/
|
|
private FunctionName getNonGC( String name, int lineNumber ) {
|
|
try {
|
|
ClassFile classFile = classFileLoader.get( NonGC.class.getName().replace( '.', '/' ) );
|
|
for( MethodInfo method : classFile.getMethods() ) {
|
|
if( name.equals( method.getName() ) ) {
|
|
return new FunctionName( method );
|
|
}
|
|
}
|
|
} catch( Throwable ex ) {
|
|
throw WasmException.create( ex, lineNumber );
|
|
}
|
|
throw new WasmException( "Not implemented NonGC polyfill function: " + name, lineNumber );
|
|
}
|
|
|
|
/**
|
|
* Add an array operation to the instruction list as marker on the code position.
|
|
*
|
|
* @param op
|
|
* the operation
|
|
* @param type
|
|
* the array/component type of the array
|
|
* @param javaCodePos
|
|
* the code position/offset in the Java method
|
|
* @param lineNumber
|
|
* the line number in the Java source code
|
|
*/
|
|
protected void addArrayInstruction( @Nonnull ArrayOperator op, @Nonnull AnyType type, int javaCodePos, int lineNumber ) {
|
|
boolean useGC = options.useGC();
|
|
if( useGC ) {
|
|
// replace the the array wrapper on the stack with the native array
|
|
int idx;
|
|
int javaPos = javaCodePos;
|
|
switch( op ) {
|
|
case GET:
|
|
case GET_S:
|
|
case GET_U:
|
|
StackValue stackValue = StackInspector.findInstructionThatPushValue( instructions, 1, javaCodePos );
|
|
idx = stackValue.idx;
|
|
javaPos = stackValue.instr.getCodePosition();
|
|
break;
|
|
case SET:
|
|
stackValue = StackInspector.findInstructionThatPushValue( instructions, 2, javaCodePos );
|
|
idx = stackValue.idx;
|
|
javaPos = stackValue.instr.getCodePosition();
|
|
break;
|
|
case LEN:
|
|
idx = instructions.size();
|
|
break;
|
|
default:
|
|
idx = -1;
|
|
}
|
|
if( idx >= 0 ) {
|
|
ArrayType arrayType = types.arrayType( type );
|
|
instructions.add( idx, new WasmStructInstruction( StructOperator.GET, arrayType, arrayType.getNativeFieldName(), javaPos, lineNumber, types ) );
|
|
}
|
|
}
|
|
|
|
WasmArrayInstruction arrayInst = new WasmArrayInstruction( op, type, types, javaCodePos, lineNumber );
|
|
instructions.add( arrayInst );
|
|
SyntheticFunctionName name = arrayInst.createNonGcFunction( useGC );
|
|
if( name != null ) {
|
|
functions.markAsNeeded( name, !name.istStatic() );
|
|
functions.markAsImport( name, name.getAnnotation() );
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Add a new multi dimensional array instruction
|
|
*
|
|
* @param dim
|
|
* the dimension of the array >= 2
|
|
* @param typeName
|
|
* the full type name
|
|
* @param javaCodePos
|
|
* the code position/offset in the Java method
|
|
* @param lineNumber
|
|
* the line number in the Java source code
|
|
*/
|
|
protected void addMultiNewArrayInstruction( int dim, String typeName, int javaCodePos, int lineNumber ) {
|
|
ArrayType type = (ArrayType)new ValueTypeParser( typeName, types ).next();
|
|
addMultiNewArrayInstruction( dim, type, javaCodePos, lineNumber );
|
|
}
|
|
|
|
/**
|
|
* Add a new multi dimensional array instruction
|
|
*
|
|
* @param dim
|
|
* the dimension of the array >= 2
|
|
* @param type
|
|
* the full type
|
|
* @param javaCodePos
|
|
* the code position/offset in the Java method
|
|
* @param lineNumber
|
|
* the line number in the Java source code
|
|
*/
|
|
protected void addMultiNewArrayInstruction( int dim, ArrayType type, int javaCodePos, int lineNumber ) {
|
|
MultiArrayFunctionName name = new MultiArrayFunctionName( dim, type );
|
|
addCallInstruction( name, false, javaCodePos, lineNumber );
|
|
}
|
|
|
|
/**
|
|
* Add a struct/object operation to the instruction list.
|
|
*
|
|
* @param op
|
|
* the operation
|
|
* @param typeName
|
|
* the type name like "java/lang/Object"
|
|
* @param fieldName
|
|
* 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, @Nonnull String typeName, @Nullable NamedStorageType fieldName, int javaCodePos, int lineNumber ) {
|
|
WasmStructInstruction structInst = new WasmStructInstruction( op, typeName, fieldName, javaCodePos, lineNumber, types );
|
|
instructions.add( structInst );
|
|
switch( op ) {
|
|
case CAST:
|
|
case INSTANCEOF:
|
|
structInst.createNonGcFunction();
|
|
break;
|
|
case NEW_DEFAULT:
|
|
if( options.useGC() ) {
|
|
addDupInstruction( false, javaCodePos, lineNumber );
|
|
addConstInstruction( structInst.getStructType().getVTable(), javaCodePos, lineNumber );
|
|
instructions.add( new WasmStructInstruction( StructOperator.SET, typeName, new NamedStorageType( ValueType.i32, "", TypeManager.FIELD_VTABLE ), javaCodePos, lineNumber, types ) );
|
|
break;
|
|
}
|
|
//$FALL-THROUGH$
|
|
default:
|
|
if( !options.useGC() ) {
|
|
SyntheticFunctionName name = structInst.createNonGcFunction();
|
|
if( name != null ) {
|
|
functions.markAsNeeded( name, !name.istStatic() );
|
|
functions.markAsImport( name, name.getAnnotation() );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Add invoke dynamic operation. (Creating of a lambda expression)
|
|
*
|
|
* @param method
|
|
* the BootstrapMethod, described the method that should be executed
|
|
* @param factorySignature
|
|
* Get the signature of the factory method. For example "()Ljava.lang.Runnable;" for the lamba expression
|
|
* <code>Runnable run = () -> foo();</code>
|
|
* @param interfaceMethodName
|
|
* The simple name of the generated method of the single function interface.
|
|
* @param javaCodePos
|
|
* the code position/offset in the Java method
|
|
* @param lineNumber
|
|
* the line number in the Java source code
|
|
*/
|
|
protected void addInvokeDynamic( BootstrapMethod method, String factorySignature, String interfaceMethodName, int javaCodePos, int lineNumber ) {
|
|
// Create the synthetic lambda class that hold the lambda expression.
|
|
ValueTypeParser parser = new ValueTypeParser( factorySignature, types );
|
|
ArrayList<AnyType> params = new ArrayList<>();
|
|
do {
|
|
AnyType param = parser.next();
|
|
if( param == null ) {
|
|
break;
|
|
}
|
|
params.add( param );
|
|
} while( true );
|
|
StructType interfaceType = (StructType)parser.next();
|
|
LambdaType type = types.lambdaType( method, params, interfaceType, interfaceMethodName );
|
|
functions.markAsNeeded( type.getLambdaMethod(), true );
|
|
String lambdaTypeName = type.getName();
|
|
|
|
// Create the instance of the synthetic lambda class and save the parameters in fields
|
|
ArrayList<NamedStorageType> paramFields = type.getParamFields();
|
|
int paramCount = paramFields.size();
|
|
if( paramCount == 0 ) {
|
|
addStructInstruction( StructOperator.NEW_DEFAULT, lambdaTypeName, null, javaCodePos, lineNumber );
|
|
} else {
|
|
// Lambda with parameters from the stack
|
|
int idx = StackInspector.findInstructionThatPushValue( instructions, paramCount, javaCodePos ).idx;
|
|
int pos = instructions.size();
|
|
addStructInstruction( StructOperator.NEW_DEFAULT, lambdaTypeName, null, javaCodePos, lineNumber );
|
|
if( !options.useGC() ) {
|
|
addDupInstruction( false, javaCodePos, lineNumber );
|
|
}
|
|
int slot = ((WasmLocalInstruction)findInstructionThatPushValue( 1, javaCodePos )).getSlot();
|
|
|
|
// move the creating of the lambda instance before the parameters on the stack
|
|
Collections.rotate( instructions.subList( idx, instructions.size() ), idx - pos );
|
|
|
|
for( int i = 0; i < paramCount; i++ ) {
|
|
NamedStorageType field = paramFields.get( i );
|
|
idx = StackInspector.findInstructionThatPushValue( instructions, paramCount - i, javaCodePos ).idx;
|
|
instructions.add( idx, new WasmLoadStoreInstruction( VariableOperator.get, slot, localVariables, javaCodePos, lineNumber ) );
|
|
pos = instructions.size();
|
|
idx = paramCount - i - 1;
|
|
idx = idx == 0 ? pos : StackInspector.findInstructionThatPushValue( instructions, idx, javaCodePos ).idx;
|
|
addStructInstruction( StructOperator.SET, lambdaTypeName, field, javaCodePos, lineNumber );
|
|
if( idx < pos ) {
|
|
Collections.rotate( instructions.subList( idx, instructions.size() ), idx - pos );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Create an instance of a load/store to the linear memory instruction
|
|
*
|
|
* @param op
|
|
* the operation
|
|
* @param type
|
|
* the type of the static field
|
|
* @param offset
|
|
* the base offset which will be added to the offset value on the stack
|
|
* @param alignment
|
|
* the alignment of the value on the linear memory (0: 8 Bit; 1: 16 Bit; 2: 32 Bit)
|
|
* @param javaCodePos
|
|
* the code position/offset in the Java method
|
|
* @param lineNumber
|
|
* the line number in the Java source code
|
|
*/
|
|
protected void addMemoryInstruction( MemoryOperator op, ValueType type, int offset, int alignment, int javaCodePos, int lineNumber ) {
|
|
instructions.add( new WasmMemoryInstruction( op, type, offset, alignment, javaCodePos, lineNumber ) );
|
|
}
|
|
}
|