free globals

Author: MikeInnes

src/backend/compiler.ts

@@ -1,11 +1,12 @@
+import * as types from '../frontend/types.js'
 import { tag } from '../frontend/types.js'
 import * as mods from '../frontend/modules.js'
 import { Interpreter, interpreter } from '../middle/interpret.js'
 import { MatchMethods } from '../middle/patterns.js'
 import { Inferred, Redirect } from '../middle/abstract.js'
 import { Expanded } from '../middle/expand.js'
 import { Inlined, opcount } from '../middle/inline.js'
-import { refcounts } from '../middle/refcount.js'
+import { isreftype, release_method, refcounts } from '../middle/refcount.js'
 import * as wasm from './wasm.js'
 import { irfunc } from '../wasm/ir.js'
 import { reset, pipe, Caching, withtime } from '../utils/cache.js'
@@ -14,6 +15,7 @@ import { binding, options } from '../utils/options.js'
 import { assigned_globals } from '../frontend/lower.js'
 import { core } from '../middle/primitives.js'
 import { only } from '../utils/map.js'
+import { Def } from '../dwarf/index.js'
 
 export { Pipeline, Compiler, emit, withEmit }
 
@@ -57,10 +59,26 @@ class Pipeline implements Caching {
     for (const [b, T] of gs) this.sources.set(b, T)
     if (gs.size > 0) reset(this)
     if (opcount(ir) <= 0) return
+    if (em instanceof wasm.BatchEmitter) this.destructors(gs, em)
     wir = wasm.lowerwasm_globals(wir, this.wasm.globals)
     em.emit(fns, irfunc(name, wir))
   }
 
+  private destructors(gs: Map<mods.Binding, types.Type>, em: wasm.BatchEmitter) {
+    for (const [b, T] of gs) {
+      if (!isreftype(T)) continue
+      const ids = this.wasm.globals.get(b)
+      const fname = `__release_global.${ids[0]}`
+      const code = mods.MIR(Def(fname))
+      const value = code.push(code.stmt(mods.xglobal(b), { type: T }))
+      code.return(code.push(code.stmt(new mods.Invoke(release_method, [value]), { type: types.nil })))
+      const wir = this.wasm.lower(code)
+      const func = irfunc(fname, wir)
+      const calls = wasm.calltree(this.wasm, func)
+      em.destructor(calls, func)
+    }
+  }
+
   async loadcommon(emitter: wasm.Emitter, load: Loader): Promise<this> {
     const emit = (m: mods.Method) => {
       reset(this)
@@ -117,6 +135,7 @@ class Compiler {
       await withEmit(emitIR, async () => { await reload(this.pipe.sources, src, this.load) })
       reset(this.pipe)
       if (options().memcheck && em.funcs.some(fn => fn.name.startsWith('common.malloc!'))) {
+        em.main.push(...em.destructors)
         const checks = this.pipe.defs.methods(tag('common.checkAllocations'))
         this.pipe.emit(only(checks), em)
       }

src/backend/wasm.ts

@@ -263,12 +263,14 @@ type Emitter = { emit(calls: Map<string, wasm.Func | WSig>, func: wasm.Func): vo
 class BatchEmitter implements Emitter {
   tables: Tables
   main: string[]
+  destructors: string[]
   seen: Set<string>
   funcs: wasm.Func[]
   imports: wasm.Import[]
   constructor(tables: Tables) {
     this.tables = tables
     this.main = []
+    this.destructors = []
     this.seen = new Set()
     this.funcs = []
     this.imports = []
@@ -277,6 +279,7 @@ class BatchEmitter implements Emitter {
   clone(): BatchEmitter {
     const em = new BatchEmitter(this.tables)
     em.main = [...this.main]
+    em.destructors = [...this.destructors]
     em.seen = new Set(this.seen)
     em.funcs = [...this.funcs]
     em.imports = [...this.imports]
@@ -303,6 +306,12 @@ class BatchEmitter implements Emitter {
     for (const f of this.tables.funcs) this.emitName(calls, f)
     this.main.push(func.name)
   }
+
+  destructor(calls: Map<string, wasm.Func | WSig>, func: wasm.Func) {
+    this.emitFunc(calls, func)
+    for (const f of this.tables.funcs) this.emitName(calls, f)
+    this.destructors.push(func.name)
+  }
 }
 
 const refTable = 'jsrefs'

src/middle/expand.ts

@@ -22,15 +22,14 @@ import * as types from '../frontend/types.js'
 import { Type } from '../frontend/types.js'
 import { ValueType, sizeof as wsizeof } from '../wasm/wasm.js'
 import * as wasm from '../wasm/wasm.js'
-import { MIR, Method, Value, xstring, Global, Invoke, Wasm } from '../frontend/modules.js'
+import { MIR, Method, Value, xstring, Global, Invoke, Wasm, xwasm } from '../frontend/modules.js'
 import { Def } from '../dwarf/index.js'
 import { Inferred, Redirect, Sig, sig as resolveSig } from './abstract.js'
 import { wasmPartials } from '../backend/wasm.js'
 import { isEqual } from '../utils/isEqual.js'
 import { Pipe, Block, Fragment, expr, Branch, Val, Anno, unreachable, asType } from '../utils/ir.js'
 import { some } from '../utils/map.js'
 import { xcall, xtuple } from '../frontend/lower.js'
-import { xwasm } from '../frontend/modules.js'
 import { isreftype } from './refcount.js'
 import { partial_part, getIntValue, nparts, constValue, partial_set, copy_method } from './primitives.js'
 import { inlinePrimitive, InvokeSt, outlinePrimitive, primitive } from './prim_map.js'

test/language.ts

@@ -935,6 +935,14 @@ test('array values', async () => {
   `, { output: '[[1], [1, 2], [1, 2, 3]]' })
 })
 
+test('global list release', async () => {
+  await rv(`
+    xs = collect(range(1, widen(3)))
+    xs = collect(range(1, widen(3)))
+    test length(xs) == 3
+  `)
+})
+
 test('allocs', async () => {
   await rv(`
     test (allocs 1 + 2) == 0