darmie / wasp Goto Github PK

import wasp.Module;
import wasp.disasm.Disassembly;
import haxe.io.BytesInput;
import sys.FileSystem;
import sys.io.File;
import wasp.wast.Writer;

...

try {
    // get wasm binary
    var source = FileSystem.fullPath("globals.wasm");
    if (FileSystem.exists(source)) {
        var raw = File.getBytes(source); // get raw bytes
        var reader = new BytesInput(raw);

        var module = Module.read(reader, null); // read wasm module

        var output = new StringBuf();


        Writer.writeTo(output, module); // write wasm bytes to text dump (wat) 

        Sys.println(output.toString()); // print dump
    }
} catch(e:Any){
    throw e;
}

/**
 * ISA describes an instruction, consisting of an operator, with its
 * appropriate immediate value(s).
 */
typedef ISA = {
	?op:InstructionSet,

	/**
	 * Immediates are arguments to an operator in the bytecode stream itself.
	 * Valid value types are:
	 * - (u)(int/float)(32/64)
	 * - BlockType
	 */
	?immediates:Array<Dynamic>,
	// non-nil if the instruction creates or unwinds a stack.
	?newStack:StackInfo,
	// non-nil if the instruction starts or ends a new block.
	?block:BlockInfo,
	// whether the operator can be reached during execution
	?unreachable:Bool,
	// IsReturn is true if executing this instruction will result in the
	// function returning. This is true for branches (br, br_if) to
	// the depth <max_relative_depth> + 1, or the return operator itself.
	// If true, NewStack for this instruction is nil.
	?isReturn:Bool,
	// If the operator is br_table (ops.BrTable), this is a list of StackInfo
	// fields for each of the blocks/branches referenced by the operator.
	?branches:Array<StackInfo>
}

/**
 * StackInfo stores details about a new stack created or unwound by an instruction.
 */
typedef StackInfo = {
	// The difference between the stack depths at the end of the block
	?stackTopDiff:Int,
	// Whether the value on the top of the stack should be preserved while unwinding
	?preserveTop:Bool,
	// Whether the unwind is equivalent to a return
	?isReturn:Bool
}

/**
 * BlockInfo stores details about a block created or ended by an instruction.
 */
typedef BlockInfo = {
	?start:Bool, // If true, this instruction starts a block. Else this instruction ends it.
	?signature:BlockType, // 0x40

	// The block signature
	// Indices to the accompanying control operator.
	// For 'if', this is the index to the 'else' operator.
	?ifElseIndex:Int,   // For 'else', this is the index to the 'if' operator.
	?elseIfIndex:Int,   // The index to the `end' operator for if/else/loop/block.
	?endIndex:Int,      // For end, it is the index to the operator that starts the block.
	?blockStartIndex:Int
}

var module = Module.read(reader, null); // read wasm module
var o = new StringBuf();
// compile the function index space
for(func in module.functionIndexSpace){
    var hasParams = func.sig.paramTypes.length != 0;
    var hasReturn = func.sig.returnTypes.length != 0;

    var code:Array<ISA> = new Disassembly(func, module).code;  // disassemble the function
    // Todo: execute !
    

    // dump text
    o.add("("); // open
    o.add("func ");
    if (hasParams) {
        var params = [for (_p in func.sig.paramTypes) _p.toString()].join(" ");
        o.add("("); // open
        o.add('param ${params}');
        o.add(")"); // close
    }
    if (hasReturn) {
        var ret = [for (_p in func.sig.returnTypes) _p.toString()].join(" ");
        o.add("("); // open
        o.add('result ${ret}');
        o.add(")"); // close
    }

    
    var fbody:String = '${[for(c in code) '(${Ops.fromInstr(c.op)} ${c.immediates.join(" ")})'].join("\n\t")}';
    
    o.add(' => \n\t ${fbody}');

    o.add("\n)\n"); // close
}
Sys.println(o.toString());