Implement world.release to emit anydsl_release calls in backend, similar

to alloc.

src/thorin/be/llvm/amdgpu.h

@@ -22,6 +22,7 @@ class AMDGPUCodeGen : public CodeGen {
     llvm::Value* emit_mathop(llvm::IRBuilder<>&, const MathOp*) override;
     llvm::Value* emit_reserve(llvm::IRBuilder<>&, const Continuation*) override;
     std::string get_alloc_name() const override { return "malloc"; }
+    std::string get_release_name() const override { return "free"; }
 
     const Cont2Config& kernel_config_;
 };

src/thorin/be/llvm/cpu.h

@@ -13,6 +13,7 @@ class CPUCodeGen : public CodeGen {
 
 protected:
     std::string get_alloc_name() const override { return "anydsl_alloc"; }
+    std::string get_release_name() const override { return "anydsl_release"; }
 };
 
 }

src/thorin/be/llvm/llvm.cpp

@@ -1013,6 +1013,9 @@ llvm::Value* CodeGen::emit_builder(llvm::IRBuilder<>& irbuilder, const Def* def)
     } else if (auto alloc = def->isa<Alloc>()) {
         emit_unsafe(alloc->mem());
         return emit_alloc(irbuilder, alloc->alloced_type(), alloc->extra());
+    } else if (auto release = def->isa<Release>()) {
+        emit_unsafe(release->mem());
+        return emit_release(irbuilder, release->alloc());
     } else if (auto slot = def->isa<Slot>()) {
         return emit_alloca(irbuilder, convert(slot->type()->as<PtrType>()->pointee()), slot->unique_name());
     } else if (auto vector = def->isa<Vector>()) {
@@ -1058,6 +1061,14 @@ llvm::Value* CodeGen::emit_alloc(llvm::IRBuilder<>& irbuilder, const Type* type,
     return irbuilder.CreatePointerCast(void_ptr, llvm::PointerType::get(context(), 0));
 }
 
+llvm::Value* CodeGen::emit_release(llvm::IRBuilder<>& irbuilder, const Def* alloc) {
+    auto llvm_release = runtime_->get(*this, get_release_name().c_str());
+    llvm::Value* llvm_alloc = emit(alloc);
+    llvm::Value* release_args[] = { irbuilder.getInt32(0), llvm_alloc };
+    irbuilder.CreateCall(llvm_release, release_args);
+    return nullptr;
+}
+
 llvm::AllocaInst* CodeGen::emit_alloca(llvm::IRBuilder<>& irbuilder, llvm::Type* type, const std::string& name) {
     // Emit the alloca in the entry block
     auto entry = &irbuilder.GetInsertBlock()->getParent()->getEntryBlock();

src/thorin/be/llvm/llvm.h

@@ -74,6 +74,7 @@ class CodeGen : public thorin::CodeGen, public thorin::Emitter<llvm::Value*, llv
 
     llvm::AllocaInst* emit_alloca(llvm::IRBuilder<>&, llvm::Type*, const std::string&);
     llvm::Value*      emit_alloc (llvm::IRBuilder<>&, const Type*, const Def*);
+    llvm::Value*      emit_release (llvm::IRBuilder<>&, const Def*);
     virtual void emit_fun_decl_hook(Continuation*, llvm::Function*) {}
     virtual llvm::Value* map_param(llvm::Function*, llvm::Argument* a, const Param*) { return a; }
 
@@ -87,6 +88,7 @@ class CodeGen : public thorin::CodeGen, public thorin::Emitter<llvm::Value*, llv
     llvm::Value* emit_reserve_shared(llvm::IRBuilder<>&, const Continuation*, bool=false);
 
     virtual std::string get_alloc_name() const = 0;
+    virtual std::string get_release_name() const = 0;
     llvm::BasicBlock* cont2bb(Continuation* cont) { return cont2bb_[cont].first; }
 
     virtual llvm::Value* emit_global(const Global*);

src/thorin/be/llvm/nvvm.h

@@ -33,6 +33,7 @@ class NVVMCodeGen : public CodeGen {
     llvm::Value* emit_global(const Global*) override;
 
     std::string get_alloc_name() const override { return "malloc"; }
+    std::string get_release_name() const override { return "free"; }
 
 private:
     llvm::Function* get_texture_handle_fun(llvm::IRBuilder<>&);

src/thorin/primop.cpp

@@ -112,6 +112,12 @@ Alloc::Alloc(World& world, const Type* type, const Def* mem, const Def* extra, D
     set_type(world.tuple_type({world.mem_type(), world.ptr_type(type)}));
 }
 
+Release::Release(World& world, const Def* mem, const Def* alloc, Debug dbg)
+    : MemOp(world, Node_Release, nullptr, {mem, alloc}, dbg)
+{
+    set_type(world.mem_type());
+}
+
 Load::Load(World& world, const Def* mem, const Def* ptr, Debug dbg)
     : Access(world, Node_Load, nullptr, {mem, ptr}, dbg)
 {
@@ -223,6 +229,10 @@ const Def* Alloc::rebuild(World& w, const Type* t, Defs o) const {
     return w.alloc(t->as<TupleType>()->op(1)->as<PtrType>()->pointee(), o[0], o[1], debug());
 }
 
+const Def* Release::rebuild(World& w, const Type* t, Defs o) const {
+    return w.release(o[0], o[1], debug());
+}
+
 const Def* Assembly::rebuild(World& w, const Type* t, Defs o) const {
     return w.assembly(t, o, asm_template(), output_constraints(), input_constraints(), clobbers(), flags(), debug());
 }

src/thorin/primop.h

@@ -585,6 +585,20 @@ class Alloc : public MemOp {
     friend class World;
 };
 
+class Release : public MemOp {
+private:
+    Release(World& world, const Def* mem, const Def* alloc, Debug dbg);
+
+public:
+    const Def* alloc() const { return op(1); }
+
+private:
+    const Def* rebuild(World&, const Type*, Defs) const override;
+
+    friend class World;
+};
+
+
 /// Base class for @p Load and @p Store.
 class Access : public MemOp {
 protected:

src/thorin/tables/nodetable.h

@@ -12,6 +12,7 @@
             THORIN_NODE(BlobPtr, mem_blob)
         // MemOp
             THORIN_NODE(Alloc, alloc)
+            THORIN_NODE(Release, release)
             // Access
                 THORIN_NODE(Load, load)
                 THORIN_NODE(Store, store)

src/thorin/world.cpp

@@ -1055,6 +1055,10 @@ const Def* World::alloc(const Type* type, const Def* mem, const Def* extra, Debu
     return cse(new Alloc(*this, type, mem, extra, dbg));
 }
 
+const Def* World::release(const Def* mem, const Def* alloc, Debug dbg) {
+    return cse(new Release(*this, mem, alloc, dbg));
+}
+
 const Def* World::global(const Def* init, bool is_mutable, Debug dbg) {
     return cse(new Global(*this, init, is_mutable, dbg));
 }

src/thorin/world.h

@@ -248,6 +248,7 @@ class World : public Streamable<World> {
     const Def* slot(const Type* type, const Def* frame, Debug dbg = {}) { return cse(new Slot(*this, type, frame, dbg)); }
     const Def* alloc(const Type* type, const Def* mem, const Def* extra, Debug dbg = {});
     const Def* alloc(const Type* type, const Def* mem, Debug dbg = {}) { return alloc(type, mem, literal_qu64(0, dbg), dbg); }
+    const Def* release(const Def* mem, const Def* alloc, Debug dbg = {});
     const Def* global(const Def* init, bool is_mutable = true, Debug dbg = {});
     const Def* global_immutable_string(const std::string& str, Debug dbg = {});
     const Def* lea(const Def* ptr, const Def* index, Debug dbg);