Add CiWasmTarget.functionId

aeneas/src/core/Eval.v3

@@ -951,6 +951,13 @@ def evalOp(op: Operator, args: Arguments) -> Result {
 			if (sys == null) prog.system = sys = SystemCallState.new();
 			return syscall.eval(sys, args);
 		}
+//----------------------------------------------------------------------------
+		WasmFunctionId => {
+			var prog = args.getProgram();
+			var del = Closure.!(args.vals[0]);
+			if (del == null) return args.throw(V3Exception.NullCheck, null);
+			return Int.box(prog.makeFunctionId(del.memberRef));
+		}
 		_ => ;
 	}
 	return args.throw("EvalUnimplemented", op.opcode.name);

aeneas/src/core/Opcode.v3

@@ -175,6 +175,7 @@ type Opcode {
 	case Alloc;
 	// Wasm target
 	case WasmFunctionTypeId;
+	case WasmFunctionId;
 	// Call
 	case CallAddress(p: Mach_FuncRep);
 	case CallKernel(kernel: Kernel);

aeneas/src/core/Operator.v3

@@ -569,6 +569,11 @@ component V3Op {
 		var ta = [paramType, resultType];
 		return newOp0(Opcode.WasmFunctionTypeId, ta, TypeUtil.NO_TYPES, Int.TYPE);
 	}
+	def newWasmFunctionId(paramType: Type, resultType: Type) -> Operator {
+		var ta = [paramType, resultType];
+		var funcType = Function.newType(paramType, resultType);
+		return newOp0(Opcode.WasmFunctionId, ta, [funcType], Int.TYPE);
+	}
 //----------------------------------------------------------------------------
 	def bestCallVirtual(spec: IrSpec) -> Operator {
 		if (spec.receiver.typeCon.kind == Kind.CLASS) {

aeneas/src/core/Program.v3

@@ -22,13 +22,16 @@ class Program {
 	var mainRootIndex = -1;
 	var explicitName: string;
 	var tprog: TargetProgram;
+	var numImports = 0;
 
 	// dynamic portion of the program, including initialized state
 	var initState: Array<InitState>;
 	var compRecords: Array<Record>;
 	var strRecords: Array<Record>;
 	var recordCount: int;
 	var system: SystemCallState;
+	var wasmFuncId_imported = 0;
+	var wasmFuncId_internal = 0;
 
 	new() {
 		opBuilder = IrOpMethodBuilder.new(this);
@@ -193,6 +196,22 @@ class Program {
 			if (trt != frt) requestMapper(frt, trt);  // results are covariant
 		}
 	}
+	def makeFunctionId(meth: IrSpec) -> int {
+		// XXX: linear search for function id
+		for (i < ir.roots.length) {
+			var r = ir.roots[i];
+			if (r.spec.equals(meth)) {
+				if (r.functionId < 0) r.functionId = assignFunctionId(meth);
+				return r.functionId;
+			}
+		}
+		var r = IrRoot.new(null, meth);
+		ir.roots.put(r);
+		return r.functionId = assignFunctionId(meth);
+	}
+	def assignFunctionId(meth: IrSpec) -> int {
+		return if(meth.asMethod().isImported(), wasmFuncId_imported++, wasmFuncId_internal++);
+	}
 }
 // Representation of the program appropriate for the target, e.g. a machine.
 class TargetProgram(prog: Program) {

aeneas/src/ir/Ir.v3

@@ -100,6 +100,9 @@ class IrMethod extends IrMember {
 	def getMethodType() -> Type {
 		return sig.funcType();
 	}
+	def isImported() -> bool {
+		return source != null && source.importName != null;
+	}
 }
 // a virtual method selector consisting of a method and a vtable index
 // (the vtable index may differ from the method's in the case of partial specialization)
@@ -250,7 +253,9 @@ class IrSpec(receiver: Type, typeArgs: Array<Type>, member: IrMember) {
 	}
 }
 
-class IrRoot(name: string, spec: IrSpec) { }
+class IrRoot(name: string, spec: IrSpec) {
+	var functionId = -1;
+}
 
 // Utility methods for dealing with Ir classes, methods, and fields
 component IrUtil {
@@ -263,7 +268,7 @@ component IrUtil {
 		return HashMap<IrItem, T>.new(IrItem.uid, IrItem.==);
 	}
 }
-// representation of a module, including classes, components, methods, etc.
+// Representation of a module, including classes, components, methods, etc.
 class IrModule {
 	def classMap = TypeUtil.newTypeMap<IrClass>();
 	def classes = Vector<IrClass>.new();

aeneas/src/ir/Normalization.v3

@@ -504,7 +504,9 @@ class ReachabilityNormalizer(config: NormalizerConfig, ra: ReachabilityAnalyzer)
 		newIr.roots.length = old.length;
 		for (i < old.length) {
 			var o = old[i];
-			newIr.roots[i] = IrRoot.new(o.name, normalizeMethodRef(o.spec).1);
+			var r = IrRoot.new(o.name, normalizeMethodRef(o.spec).1);
+			r.functionId = o.functionId;
+			newIr.roots[i] = r;
 		}
 		ra.prog.ir = newIr;
 		// do remaining work; normalize record instances

aeneas/src/vst/Verifier.v3

@@ -12,6 +12,7 @@ class Verifier(compiler: Compiler, prog: Program) {
 	def ir = prog.ir = IrModule.new();
 	var exportMap: PartialMap<string, ExportDecl>;
 	var methodOverrideChecks: List<(VstCompoundVerifier, VstMethod)>;
+	var numImports = 0;
 
 	def forAll<T>(vec: Vector<T>, do: T -> void) {
 		for (i < vec.length) {
@@ -55,6 +56,8 @@ class Verifier(compiler: Compiler, prog: Program) {
 			for (r in vst.fieldRedefs.asArray()) redefineField(r, tc);
 		}
 		if (ERROR.noErrors) forAll(vst.exports, addExport);
+
+		prog.wasmFuncId_internal = numImports;
 	}
 	def buildFile(file: VstFile) {
 		if (file == null) return;
@@ -629,6 +632,7 @@ class VstCompoundVerifier {
 				if (decl.importName == null) decl.importName = decl.token;
 				if (decl.typeParams != null) errAtDecl(decl).ImportError("imported methods cannot have type parameters");
 			}
+			verifier.numImports++;
 		}
 		typeEnv = compound.typeEnv;
 		if (decl.isIndexed() && VstComponent.?(compound)) {

aeneas/src/wasm/WasmCodeGen.v3

@@ -1550,6 +1550,14 @@ class WasmCodeGen extends SsaMachGen {
 			_ => context.fail1("unimplemented main parameter type %q", t.render);
 		}
 	}
+	def emitUnassignedFunction() {
+		def b = w.putb;
+
+		b(/*body_size=*/3);
+		b(/*locals_count=*/0);
+		b(WasmOp.UNREACHABLE.opcode);
+		b(WasmOp.END.opcode);
+	}
 	def emitAllocationStub() {
 		var gcmeth = rt.getRiGc();
 		def b = w.putb;

aeneas/src/wasm/WasmGcTarget.v3

@@ -1447,9 +1447,8 @@ class WasmGcProgram extends WasmProgram {
 		if (m.machIndex < 0) context.fail1("method not assigned an index: %q", m.renderLong);
 		requestIndirectAdapter(m);
 	}
-	def addIrMethods() -> Vector<IrMethod> {
+	def addIrMethods() -> void {
 		context.fail("addIrMethods called for WasmGc target");
-		return null;
 	}
 	def addIrMethodsGc(infos: Vector<FunctionInfo>) -> Vector<IrMethod> {
 		var methods = mach.prog.ir.methods;
@@ -1506,8 +1505,9 @@ class WasmGcProgram extends WasmProgram {
 		Arrays.copyInto(sorted, methods.array, 0);  // update the IrModule's method vector.
 		return methods;
 	}
-	def addMethod(m: IrMethod) {
+	def addMethod(m: IrMethod, wf: WasmFuncKind) -> int {
 		context.fail("addMethod called for WasmGc target");
+		return -1;
 	}
 	def addMethodGc(m: IrMethod, infos: Vector<FunctionInfo>, imported: bool) {
 		var sigIdx = addSig(m.ssa.params[0].vtype, m.sig);