Add function inlining to SPC

src/engine/Metrics.v3

@@ -31,6 +31,13 @@ component Metrics {
 		"Number of functions successfully compiled by single-pass compiler");
 	def spc_time_per_byte	= r("spc:time_per_byte", spc_time_us, spc_in_bytes,
 		"Ratio of compile time per input bytecode byte");
+	def spc_static_calls         = m("spc:static_calls", "calls", "Number of call instructions encountered by single-pass compiler");
+	def spc_static_inlined_calls = m("spc:static_inlined_calls", "calls", "Number of direct call sites inlined by single-pass compiler");
+		// XXX does not include inlined whamm probes, but does include inlining within a whamm inline
+	def spc_dynamic_calls         = m("spc:dynamic_calls", "calls", "Number of call instructions executed at runtime");
+	def spc_dynamic_inlined_calls = m("spc:dynamic_inlined_calls", "calls", "Number of inlined call sites executed at runtime");
+	def spc_static_remat          = m("spc:static_remat", "sites", "Number of sites where stack frame reconstruction is emitted");
+	def spc_dynamic_remat         = m("spc:dynamic_remat", "sites", "Number of stack frame reconstructions executed at runtime");
 
 	// Metrics from executing wasm code.
 	def start_time_us	= t("start:time_us", "Time taken to execute wasm module start function(s).");

src/engine/Tuning.v3

@@ -59,7 +59,10 @@ component SpcTuning {
 	var intrinsifyOperandProbe = true; 	// recognize and optimize OperandProbes
 	var compileWhammModules = true;		// compile whamm module, if possible
 	var intrinsifyWhammProbe = true;	// recognize and optimize WhammProbes
-	var inlineSmallFunc = true;		// inline small functions, currently only applicable for whamm probes
+	var inlineWhammProbe = true;		// inline whamm probe functions
+	var maxInlineBytecodeSize = 100;	// max bytecode size to inline
+	var maxInlineParams = 10;		// max parameters to inline
+	var maxInlineDepth = 0;			// max inlining nesting depth
 	def probeCallFreesRegs = true;		// probe calls frees registers in abstract state
 	def runtimeCallFreesRegs = true;	// runtime calls frees registers in abstract state
 	var intrinsifyMemoryProbes = true;

src/engine/compiler/CompilerOptions.v3

@@ -27,8 +27,14 @@ component CompilerOptions {
 			.onSet(fun v => void(SpcTuning.intrinsifyMemoryProbes = v));
 		group.newBoolOption("compile-whamm-modules", true, "Compile whamm monitor modules before execution.")
 			.onSet(fun v => void(SpcTuning.compileWhammModules = v));
-		group.newBoolOption("inline-whamm-probes", true, "Inline small whamm probes.")
-			.onSet(fun v => void(SpcTuning.inlineSmallFunc = v));
+		group.newBoolOption("inline-whamm-probes", true, "Inline whamm probes.")
+			.onSet(fun v => void(SpcTuning.inlineWhammProbe = v));
+		group.newIntOption("inline-max-bytecode-size", SpcTuning.maxInlineBytecodeSize, "Maximum number of bytecodes in a function that can be inlined.")
+			.onSet(fun v => void(SpcTuning.maxInlineBytecodeSize = v));
+		group.newIntOption("inline-max-params", SpcTuning.maxInlineParams, "Maximum number of parameters of a function that can be inlined.")
+			.onSet(fun v => void(SpcTuning.maxInlineParams = v));
+		group.newIntOption("inline-max-depth", SpcTuning.maxInlineDepth, "Maximum inlining nesting depth.")
+			.onSet(fun v => void(SpcTuning.maxInlineDepth = v));
 	}
 
 	def printHelp(out: TraceBuilder) {

src/engine/compiler/MacroAssembler.v3

@@ -21,8 +21,11 @@ class MasmLabel(create_pos: int) {
 class MacroAssembler(valuerep: Tagging, regConfig: RegConfig) {
 	var unimplemented: void -> void;	// function to call for unimplemented bytecodes
 	var trap_labels: Array<MasmLabel>;	// maps TrapReason to a label
-	var source_locs: Vector<(int, int)>;	// list of (offset, source_loc) pairs
+	var source_locs: Vector<(int, List<(int, int)>)>;	// list of (offset, [(fid, pc)])
+	var inline_ctx: List<(int, int)>; 	// list of (fid, pc)
 	var source_loc: int = -1;		// current source location, if any
+	var current_fid: int = -1;		// current function id, if any
+
 	var newTrapLabel: TrapReason -> MasmLabel;
 	var embeddedRefOffsets: Vector<int>;
 	var offsets = Target.getOffsets();
@@ -80,7 +83,15 @@ class MacroAssembler(valuerep: Tagging, regConfig: RegConfig) {
 	def recordSourceLoc(offset: int) {
 		if (source_loc < 0) return;
 		if (source_locs == null) source_locs = Vector.new();
-		source_locs.put(offset, source_loc);
+
+		source_locs.put(offset, List.new((current_fid, source_loc), inline_ctx));
+	}
+	def pushInlineContext(fid: int) {
+		inline_ctx = List.new((fid, source_loc), inline_ctx);
+	}
+	def popInlineContext() {
+		if (inline_ctx != null) // need more specific than null?
+			inline_ctx = inline_ctx.tail;
 	}
 	def at(src: int) -> this {
 		source_loc = src;
@@ -336,6 +347,7 @@ class MacroAssembler(valuerep: Tagging, regConfig: RegConfig) {
 	def emit_call_runtime_Probe_instr();
 	def emit_call_runtime_getFrameAccessorMetaRef();
 	def emit_increment_CountProbe(tmp: Reg, probe: CountProbe, increment: u64);
+	def emit_inc_metric(metric: Metric);
 	def emit_call_OperandProbe_i_v_fire(probe: OperandProbe_i_v, value_reg: Reg);
 	def emit_call_MemoryReadProbe_fire(probe: MemoryReadProbe);
 	def emit_call_runtime_cast();