Val: add TableVal::Assign() overload with IntrusivePtr

Prepare the transition to IntrusivePtr for various callers.

src/Conn.cc

@@ -337,13 +337,13 @@ RecordVal* Connection::BuildConnVal()
 
 		TransportProto prot_type = ConnTransport();
 
-		RecordVal* id_val = new RecordVal(conn_id);
+		auto id_val = make_intrusive<RecordVal>(conn_id);
-		id_val->Assign(0, new AddrVal(orig_addr));
+		id_val->Assign(0, make_intrusive<AddrVal>(orig_addr));
 		id_val->Assign(1, val_mgr->GetPort(ntohs(orig_port), prot_type));
-		id_val->Assign(2, new AddrVal(resp_addr));
+		id_val->Assign(2, make_intrusive<AddrVal>(resp_addr));
 		id_val->Assign(3, val_mgr->GetPort(ntohs(resp_port), prot_type));
 
-		RecordVal* orig_endp = new RecordVal(endpoint);
+		auto orig_endp = make_intrusive<RecordVal>(endpoint);
 		orig_endp->Assign(0, val_mgr->GetCount(0));
 		orig_endp->Assign(1, val_mgr->GetCount(0));
 		orig_endp->Assign(4, val_mgr->GetCount(orig_flow_label));
@@ -352,27 +352,27 @@ RecordVal* Connection::BuildConnVal()
 		char null[l2_len]{};
 
 		if ( memcmp(&orig_l2_addr, &null, l2_len) != 0 )
-			orig_endp->Assign(5, new StringVal(fmt_mac(orig_l2_addr, l2_len)));
+			orig_endp->Assign(5, make_intrusive<StringVal>(fmt_mac(orig_l2_addr, l2_len)));
 
-		RecordVal* resp_endp = new RecordVal(endpoint);
+		auto resp_endp = make_intrusive<RecordVal>(endpoint);
 		resp_endp->Assign(0, val_mgr->GetCount(0));
 		resp_endp->Assign(1, val_mgr->GetCount(0));
 		resp_endp->Assign(4, val_mgr->GetCount(resp_flow_label));
 
 		if ( memcmp(&resp_l2_addr, &null, l2_len) != 0 )
-			resp_endp->Assign(5, new StringVal(fmt_mac(resp_l2_addr, l2_len)));
+			resp_endp->Assign(5, make_intrusive<StringVal>(fmt_mac(resp_l2_addr, l2_len)));
 
-		conn_val->Assign(0, id_val);
+		conn_val->Assign(0, std::move(id_val));
-		conn_val->Assign(1, orig_endp);
+		conn_val->Assign(1, std::move(orig_endp));
-		conn_val->Assign(2, resp_endp);
+		conn_val->Assign(2, std::move(resp_endp));
 		// 3 and 4 are set below.
-		conn_val->Assign(5, new TableVal(string_set));	// service
+		conn_val->Assign(5, make_intrusive<TableVal>(string_set));	// service
 		conn_val->Assign(6, val_mgr->GetEmptyString());	// history
 
 		if ( ! uid )
 			uid.Set(bits_per_uid);
 
-		conn_val->Assign(7, new StringVal(uid.Base62("C").c_str()));
+		conn_val->Assign(7, make_intrusive<StringVal>(uid.Base62("C").c_str()));
 
 		if ( encapsulation && encapsulation->Depth() > 0 )
 			conn_val->Assign(8, encapsulation->GetVectorVal());
@@ -388,9 +388,9 @@ RecordVal* Connection::BuildConnVal()
 	if ( root_analyzer )
 		root_analyzer->UpdateConnVal(conn_val);
 
-	conn_val->Assign(3, new Val(start_time, TYPE_TIME));	// ###
+	conn_val->Assign(3, make_intrusive<Val>(start_time, TYPE_TIME));	// ###
-	conn_val->Assign(4, new Val(last_time - start_time, TYPE_INTERVAL));
+	conn_val->Assign(4, make_intrusive<Val>(last_time - start_time, TYPE_INTERVAL));
-	conn_val->Assign(6, new StringVal(history.c_str()));
+	conn_val->Assign(6, make_intrusive<StringVal>(history.c_str()));
 	conn_val->Assign(11, val_mgr->GetBool(is_successful));
 
 	conn_val->SetOrigin(this);
@@ -422,7 +422,7 @@ void Connection::AppendAddl(const char* str)
 	const char* old = conn_val->Lookup(6)->AsString()->CheckString();
 	const char* format = *old ? "%s %s" : "%s%s";
 
-	conn_val->Assign(6, new StringVal(fmt(format, old, str)));
+	conn_val->Assign(6, make_intrusive<StringVal>(fmt(format, old, str)));
 	}
 
 // Returns true if the character at s separates a version number.

src/DNS_Mgr.cc

@@ -745,9 +745,9 @@ Val* DNS_Mgr::BuildMappingVal(DNS_Mapping* dm)
 	{
 	RecordVal* r = new RecordVal(dm_rec);
 
-	r->Assign(0, new Val(dm->CreationTime(), TYPE_TIME));
+	r->Assign(0, make_intrusive<Val>(dm->CreationTime(), TYPE_TIME));
-	r->Assign(1, new StringVal(dm->ReqHost() ? dm->ReqHost() : ""));
+	r->Assign(1, make_intrusive<StringVal>(dm->ReqHost() ? dm->ReqHost() : ""));
-	r->Assign(2, new AddrVal(dm->ReqAddr()));
+	r->Assign(2, make_intrusive<AddrVal>(dm->ReqAddr()));
 	r->Assign(3, val_mgr->GetBool(dm->Valid()));
 
 	Val* h = dm->Host();

src/EventHandler.cc

@@ -140,13 +140,13 @@ void EventHandler::NewEvent(val_list* vl)
 		BroType* ftype = args->FieldType(i);
 		Val* fdefault = args->FieldDefault(i);
 
-		RecordVal* rec = new RecordVal(call_argument);
+		auto rec = make_intrusive<RecordVal>(call_argument);
-		rec->Assign(0, new StringVal(fname));
+		rec->Assign(0, make_intrusive<StringVal>(fname));
 
 		ODesc d;
 		d.SetShort();
 		ftype->Describe(&d);
-		rec->Assign(1, new StringVal(d.Description()));
+		rec->Assign(1, make_intrusive<StringVal>(d.Description()));
 
 		if ( fdefault )
 			{
@@ -161,7 +161,7 @@ void EventHandler::NewEvent(val_list* vl)
 			rec->Assign(3, val);
 			}
 
-		vargs->Assign(i, rec);
+		vargs->Assign(i, std::move(rec));
 		}
 
 	Event* ev = new Event(new_event, {

src/Expr.cc

@@ -365,7 +365,7 @@ IntrusivePtr<Val> UnaryExpr::Eval(Frame* f) const
 		for ( unsigned int i = 0; i < v_op->Size(); ++i )
 			{
 			Val* v_i = v_op->Lookup(i);
-			result->Assign(i, v_i ? Fold(v_i).release() : 0);
+			result->Assign(i, v_i ? Fold(v_i) : nullptr);
 			}
 
 		return result;
@@ -460,7 +460,7 @@ IntrusivePtr<Val> BinaryExpr::Eval(Frame* f) const
 			if ( v_op1->Lookup(i) && v_op2->Lookup(i) )
 				v_result->Assign(i,
 						 Fold(v_op1->Lookup(i),
-						      v_op2->Lookup(i)).release());
+						      v_op2->Lookup(i)));
 			else
 				v_result->Assign(i, nullptr);
 			// SetError("undefined element in vector operation");
@@ -479,8 +479,8 @@ IntrusivePtr<Val> BinaryExpr::Eval(Frame* f) const
 			Val* vv_i = vv->Lookup(i);
 			if ( vv_i )
 				v_result->Assign(i, is_vec1 ?
-				    Fold(vv_i, v2.get()).release() :
+				    Fold(vv_i, v2.get()) :
-				    Fold(v1.get(), vv_i).release());
+				    Fold(v1.get(), vv_i));
 			else
 				v_result->Assign(i, nullptr);
 
@@ -981,7 +981,7 @@ IntrusivePtr<Val> IncrExpr::Eval(Frame* f) const
 			Val* elt = v_vec->Lookup(i);
 
 			if ( elt )
-				v_vec->Assign(i, DoSingleEval(f, elt).release());
+				v_vec->Assign(i, DoSingleEval(f, elt));
 			else
 				v_vec->Assign(i, nullptr);
 			}
@@ -1259,7 +1259,7 @@ IntrusivePtr<Val> AddToExpr::Eval(Frame* f) const
 		{
 		VectorVal* vv = v1->AsVectorVal();
 
-		if ( ! vv->Assign(vv->Size(), v2.release()) )
+		if ( ! vv->Assign(vv->Size(), v2) )
 			RuntimeError("type-checking failed in vector append");
 
 		return v1;
@@ -2332,7 +2332,7 @@ void AssignExpr::EvalIntoAggregate(const BroType* t, Val* aggr, Frame* f) const
 		auto v = op2->Eval(f);
 
 		if ( v )
-			aggr_r->Assign(field, v.release());
+			aggr_r->Assign(field, std::move(v));
 
 		return;
 		}
@@ -2348,7 +2348,7 @@ void AssignExpr::EvalIntoAggregate(const BroType* t, Val* aggr, Frame* f) const
 	if ( ! index || ! v )
 		return;
 
-	if ( ! tv->Assign(index.get(), v.release()) )
+	if ( ! tv->Assign(index.get(), std::move(v)) )
 		RuntimeError("type clash in table assignment");
 	}
 
@@ -2392,7 +2392,7 @@ IntrusivePtr<Val> AssignExpr::InitVal(const BroType* t, IntrusivePtr<Val> aggr)
 		if ( ! v )
 			return nullptr;
 
-		aggr_r->Assign(field, v->Ref());
+		aggr_r->Assign(field, v);
 		return v;
 		}
 
@@ -2789,7 +2789,7 @@ void IndexExpr::Assign(Frame* f, IntrusivePtr<Val> v)
 			for ( auto idx = 0u; idx < v_vect->Size(); idx++, first++ )
 				v1_vect->Insert(first, v_vect->Lookup(idx)->Ref());
 			}
-		else if ( ! v1_vect->Assign(v2.get(), v.release()) )
+		else if ( ! v1_vect->Assign(v2.get(), std::move(v)) )
 			{
 			v = std::move(v_extra);
 
@@ -2811,7 +2811,7 @@ void IndexExpr::Assign(Frame* f, IntrusivePtr<Val> v)
 		}
 
 	case TYPE_TABLE:
-		if ( ! v1->AsTableVal()->Assign(v2.get(), v.release()) )
+		if ( ! v1->AsTableVal()->Assign(v2.get(), std::move(v)) )
 			{
 			v = std::move(v_extra);
 
@@ -2919,7 +2919,7 @@ void FieldExpr::Assign(Frame* f, IntrusivePtr<Val> v)
 	if ( op_v )
 		{
 		RecordVal* r = op_v->AsRecordVal();
-		r->Assign(field, v.release());
+		r->Assign(field, std::move(v));
 		}
 	}
 
@@ -3378,9 +3378,8 @@ IntrusivePtr<Val> VectorConstructorExpr::Eval(Frame* f) const
 	loop_over_list(exprs, i)
 		{
 		Expr* e = exprs[i];
-		auto v = e->Eval(f);
 
-		if ( ! vec->Assign(i, v.release()) )
+		if ( ! vec->Assign(i, e->Eval(f)) )
 			{
 			RuntimeError(fmt("type mismatch at index %d", i));
 			return nullptr;
@@ -3406,7 +3405,7 @@ IntrusivePtr<Val> VectorConstructorExpr::InitVal(const BroType* t, IntrusivePtr<
 		Expr* e = exprs[i];
 		auto v = check_and_promote(e->Eval(nullptr), t->YieldType(), 1);
 
-		if ( ! v || ! vec->Assign(i, v.release()) )
+		if ( ! v || ! vec->Assign(i, std::move(v)) )
 			{
 			Error(fmt("initialization type mismatch at index %d", i), e);
 			return nullptr;
@@ -3448,7 +3447,7 @@ void FieldAssignExpr::EvalIntoAggregate(const BroType* t, Val* aggr, Frame* f)
 			reporter->InternalError("Missing record field: %s",
 			                        field_name.c_str());
 
-		rec->Assign(idx, v.release());
+		rec->Assign(idx, std::move(v));
 		}
 	}
 
@@ -3542,7 +3541,7 @@ IntrusivePtr<Val> ArithCoerceExpr::Fold(Val* v) const
 		{
 		Val* elt = vv->Lookup(i);
 		if ( elt )
-			result->Assign(i, FoldSingleVal(elt, t).release());
+			result->Assign(i, FoldSingleVal(elt, t));
 		else
 			result->Assign(i, 0);
 		}
@@ -3733,7 +3732,7 @@ IntrusivePtr<Val> RecordCoerceExpr::Fold(Val* v) const
 					RuntimeError("Failed type conversion");
 				}
 
-			val->Assign(i, rhs.release());
+			val->Assign(i, std::move(rhs));
 			}
 		else
 			{
@@ -3757,7 +3756,7 @@ IntrusivePtr<Val> RecordCoerceExpr::Fold(Val* v) const
 						def_val = {AdoptRef{}, tmp};
 					}
 
-				val->Assign(i, def_val.release());
+				val->Assign(i, std::move(def_val));
 				}
 			else
 				val->Assign(i, 0);
@@ -4680,7 +4679,7 @@ IntrusivePtr<Val> ListExpr::InitVal(const BroType* t, IntrusivePtr<Val> aggr) co
 			check_and_promote_expr(e, vec->Type()->AsVectorType()->YieldType());
 			auto v = e->Eval(nullptr);
 
-			if ( ! vec->Assign(i, v.release()) )
+			if ( ! vec->Assign(i, std::move(v)) )
 				{
 				e->Error(fmt("type mismatch at index %d", i));
 				return nullptr;

src/File.cc

@@ -286,7 +286,7 @@ RecordVal* BroFile::Rotate()
 		return 0;
 		}
 
-	info->Assign(2, new Val(open_time, TYPE_TIME));
+	info->Assign(2, make_intrusive<Val>(open_time, TYPE_TIME));
 
 	Unlink();
 

src/IP.cc

@@ -65,7 +65,7 @@ static VectorVal* BuildOptionsVal(const u_char* data, int len)
 			// PadN or other option
 			uint16_t off = 2 * sizeof(uint8_t);
 			rv->Assign(1, val_mgr->GetCount(opt->ip6o_len));
-			rv->Assign(2, new StringVal(
+			rv->Assign(2, make_intrusive<StringVal>(
 			        new BroString(data + off, opt->ip6o_len, 1)));
 			data += opt->ip6o_len + off;
 			len -= opt->ip6o_len + off;
@@ -91,8 +91,8 @@ RecordVal* IPv6_Hdr::BuildRecordVal(VectorVal* chain) const
 		rv->Assign(2, val_mgr->GetCount(ntohs(ip6->ip6_plen)));
 		rv->Assign(3, val_mgr->GetCount(ip6->ip6_nxt));
 		rv->Assign(4, val_mgr->GetCount(ip6->ip6_hlim));
-		rv->Assign(5, new AddrVal(IPAddr(ip6->ip6_src)));
+		rv->Assign(5, make_intrusive<AddrVal>(IPAddr(ip6->ip6_src)));
-		rv->Assign(6, new AddrVal(IPAddr(ip6->ip6_dst)));
+		rv->Assign(6, make_intrusive<AddrVal>(IPAddr(ip6->ip6_dst)));
 		if ( ! chain )
 			chain = new VectorVal(
 			    internal_type("ip6_ext_hdr_chain")->AsVectorType());
@@ -132,7 +132,7 @@ RecordVal* IPv6_Hdr::BuildRecordVal(VectorVal* chain) const
 		rv->Assign(2, val_mgr->GetCount(rt->ip6r_type));
 		rv->Assign(3, val_mgr->GetCount(rt->ip6r_segleft));
 		uint16_t off = 4 * sizeof(uint8_t);
-		rv->Assign(4, new StringVal(new BroString(data + off, Length() - off, 1)));
+		rv->Assign(4, make_intrusive<StringVal>(new BroString(data + off, Length() - off, 1)));
 		}
 		break;
 
@@ -163,7 +163,7 @@ RecordVal* IPv6_Hdr::BuildRecordVal(VectorVal* chain) const
 			// Payload Len was non-zero for this header.
 			rv->Assign(4, val_mgr->GetCount(ntohl(((uint32_t*)data)[2])));
 			uint16_t off = 3 * sizeof(uint32_t);
-			rv->Assign(5, new StringVal(new BroString(data + off, Length() - off, 1)));
+			rv->Assign(5, make_intrusive<StringVal>(new BroString(data + off, Length() - off, 1)));
 			}
 		}
 		break;
@@ -284,7 +284,7 @@ RecordVal* IPv6_Hdr::BuildRecordVal(VectorVal* chain) const
 			RecordVal* m = new RecordVal(hdrType(ip6_mob_brr_type, "ip6_mobility_be"));
 			m->Assign(0, val_mgr->GetCount(*((uint8_t*)msg_data)));
 			const in6_addr* hoa = (const in6_addr*)(msg_data + sizeof(uint16_t));
-			m->Assign(1, new AddrVal(IPAddr(*hoa)));
+			m->Assign(1, make_intrusive<AddrVal>(IPAddr(*hoa)));
 			off += sizeof(uint16_t) + sizeof(in6_addr);
 			m->Assign(2, BuildOptionsVal(data + off, Length() - off));
 			msg->Assign(8, m);
@@ -341,8 +341,8 @@ RecordVal* IP_Hdr::BuildIPHdrVal() const
 		rval->Assign(3, val_mgr->GetCount(ntohs(ip4->ip_id)));
 		rval->Assign(4, val_mgr->GetCount(ip4->ip_ttl));
 		rval->Assign(5, val_mgr->GetCount(ip4->ip_p));
-		rval->Assign(6, new AddrVal(ip4->ip_src.s_addr));
+		rval->Assign(6, make_intrusive<AddrVal>(ip4->ip_src.s_addr));
-		rval->Assign(7, new AddrVal(ip4->ip_dst.s_addr));
+		rval->Assign(7, make_intrusive<AddrVal>(ip4->ip_dst.s_addr));
 		}
 	else
 		{

src/OpaqueVal.cc

@@ -1043,7 +1043,7 @@ IntrusivePtr<VectorVal> ParaglobVal::Get(StringVal* &pattern)
 
 	std::vector<std::string> matches = this->internal_paraglob->get(string_pattern);
 	for (unsigned int i = 0; i < matches.size(); i++)
-		rval->Assign(i, new StringVal(matches.at(i)));
+		rval->Assign(i, make_intrusive<StringVal>(matches.at(i)));
 
 	return rval;
 	}

src/RuleMatcher.cc

@@ -78,7 +78,7 @@ Val* RuleMatcher::BuildRuleStateValue(const Rule* rule,
 					const RuleEndpointState* state) const
 	{
 	RecordVal* val = new RecordVal(signature_state);
-	val->Assign(0, new StringVal(rule->ID()));
+	val->Assign(0, make_intrusive<StringVal>(rule->ID()));
 	val->Assign(1, state->GetAnalyzer()->BuildConnVal());
 	val->Assign(2, val_mgr->GetBool(state->is_orig));
 	val->Assign(3, val_mgr->GetCount(state->payload_size));

src/SmithWaterman.cc

@@ -84,25 +84,25 @@ VectorVal* BroSubstring::VecToPolicy(Vec* vec)
 			{
 			BroSubstring* bst = (*vec)[i];
 
-			RecordVal* st_val = new RecordVal(sw_substring_type);
+			auto st_val = make_intrusive<RecordVal>(sw_substring_type);
-			st_val->Assign(0, new StringVal(new BroString(*bst)));
+			st_val->Assign(0, make_intrusive<StringVal>(new BroString(*bst)));
 
-			VectorVal* aligns = new VectorVal(sw_align_vec_type);
+			auto aligns = make_intrusive<VectorVal>(sw_align_vec_type);
 
 			for ( unsigned int j = 0; j < bst->GetNumAlignments(); ++j )
 				{
 				const BSSAlign& align = (bst->GetAlignments())[j];
 
-				RecordVal* align_val = new RecordVal(sw_align_type);
+				auto align_val = make_intrusive<RecordVal>(sw_align_type);
-				align_val->Assign(0, new StringVal(new BroString(*align.string)));
+				align_val->Assign(0, make_intrusive<StringVal>(new BroString(*align.string)));
 				align_val->Assign(1, val_mgr->GetCount(align.index));
 
-				aligns->Assign(j+1, align_val);
+				aligns->Assign(j+1, std::move(align_val));
 				}
 
-			st_val->Assign(1, aligns);
+			st_val->Assign(1, std::move(aligns));
 			st_val->Assign(2, val_mgr->GetBool(bst->IsNewAlignment()));
-			result->Assign(i+1, st_val);
+			result->Assign(i+1, std::move(st_val));
 			}
 		}
 

src/Stmt.cc

@@ -217,11 +217,11 @@ static void print_log(val_list* vals)
 		{
 		ODesc d(DESC_READABLE);
 		val->Describe(&d);
-		vec->Assign(vec->Size(), new StringVal(d.Description()));
+		vec->Assign(vec->Size(), make_intrusive<StringVal>(d.Description()));
 		}
 
-	record->Assign(0, new Val(current_time(), TYPE_TIME));
+	record->Assign(0, make_intrusive<Val>(current_time(), TYPE_TIME));
-	record->Assign(1, vec.release());
+	record->Assign(1, std::move(vec));
 	log_mgr->Write(plval.get(), record.get());
 	}
 

src/TunnelEncapsulation.cc

@@ -20,15 +20,15 @@ RecordVal* EncapsulatingConn::GetRecordVal() const
 	{
 	RecordVal *rv = new RecordVal(BifType::Record::Tunnel::EncapsulatingConn);
 
-	RecordVal* id_val = new RecordVal(conn_id);
+	auto id_val = make_intrusive<RecordVal>(conn_id);
-	id_val->Assign(0, new AddrVal(src_addr));
+	id_val->Assign(0, make_intrusive<AddrVal>(src_addr));
 	id_val->Assign(1, val_mgr->GetPort(ntohs(src_port), proto));
-	id_val->Assign(2, new AddrVal(dst_addr));
+	id_val->Assign(2, make_intrusive<AddrVal>(dst_addr));
 	id_val->Assign(3, val_mgr->GetPort(ntohs(dst_port), proto));
-	rv->Assign(0, id_val);
+	rv->Assign(0, std::move(id_val));
 	rv->Assign(1, BifType::Enum::Tunnel::Type->GetVal(type));
 
-	rv->Assign(2, new StringVal(uid.Base62("C").c_str()));
+	rv->Assign(2, make_intrusive<StringVal>(uid.Base62("C").c_str()));
 
 	return rv;
 	}

src/Type.cc

@@ -824,15 +824,15 @@ TableVal* RecordType::GetRecordFieldsVal(const RecordVal* rv) const
 
 		bool logged = (fd->attrs && fd->FindAttr(ATTR_LOG) != 0);
 
-		RecordVal* nr = new RecordVal(internal_type("record_field")->AsRecordType());
+		auto nr = make_intrusive<RecordVal>(internal_type("record_field")->AsRecordType());
 
 		string s = container_type_name(ft);
-		nr->Assign(0, new StringVal(s));
+		nr->Assign(0, make_intrusive<StringVal>(s));
 		nr->Assign(1, val_mgr->GetBool(logged));
 		nr->Assign(2, fv);
 		nr->Assign(3, FieldDefault(i));
 		Val* field_name = new StringVal(FieldName(i));
-		rval->Assign(field_name, nr);
+		rval->Assign(field_name, std::move(nr));
 		Unref(field_name);
 		}
 

src/Val.cc

@@ -1437,27 +1437,31 @@ void TableVal::CheckExpireAttr(attr_tag at)
 		}
 	}
 
-int TableVal::Assign(Val* index, Val* new_val)
+int TableVal::Assign(Val* index, IntrusivePtr<Val> new_val)
 	{
 	HashKey* k = ComputeHash(index);
 	if ( ! k )
 		{
-		Unref(new_val);
 		index->Error("index type doesn't match table", table_type->Indices());
 		return 0;
 		}
 
-	return Assign(index, k, new_val);
+	return Assign(index, k, std::move(new_val));
 	}
 
-int TableVal::Assign(Val* index, HashKey* k, Val* new_val)
+int TableVal::Assign(Val* index, Val* new_val)
+	{
+	return Assign(index, {AdoptRef{}, new_val});
+	}
+
+int TableVal::Assign(Val* index, HashKey* k, IntrusivePtr<Val> new_val)
 	{
 	int is_set = table_type->IsSet();
 
 	if ( (is_set && new_val) || (! is_set && ! new_val) )
 		InternalWarning("bad set/table in TableVal::Assign");
 
-	TableEntryVal* new_entry_val = new TableEntryVal(new_val);
+	TableEntryVal* new_entry_val = new TableEntryVal(IntrusivePtr{new_val}.release());
 	HashKey k_copy(k->Key(), k->Size(), k->Hash());
 	TableEntryVal* old_entry_val = AsNonConstTable()->Insert(k, new_entry_val);
 
@@ -1488,7 +1492,7 @@ int TableVal::Assign(Val* index, HashKey* k, Val* new_val)
 	if ( change_func )
 		{
 		Val* change_index = index ? index->Ref() : RecoverIndex(&k_copy);
-		Val* v = old_entry_val ? old_entry_val->Value() : new_val;
+		Val* v = old_entry_val ? old_entry_val->Value() : new_val.get();
 		CallChangeFunc(change_index, v, old_entry_val ? ELEMENT_CHANGED : ELEMENT_NEW);
 		Unref(change_index);
 		}
@@ -1502,6 +1506,11 @@ int TableVal::Assign(Val* index, HashKey* k, Val* new_val)
 	return 1;
 	}
 
+int TableVal::Assign(Val* index, HashKey* k, Val* new_val)
+	{
+	return Assign(index, k, {AdoptRef{}, new_val});
+	}
+
 int TableVal::AddTo(Val* val, int is_first_init) const
 	{
 	return AddTo(val, is_first_init, true);
@@ -1875,10 +1884,7 @@ VectorVal* TableVal::LookupSubnets(const SubNetVal* search)
 
 	auto matches = subnets->FindAll(search);
 	for ( auto element : matches )
-		{
+		result->Assign(result->Size(), make_intrusive<SubNetVal>(get<0>(element)));
-		SubNetVal* s = new SubNetVal(get<0>(element));
-		result->Assign(result->Size(), s);
-		}
 
 	return result;
 	}
@@ -1897,7 +1903,7 @@ TableVal* TableVal::LookupSubnetValues(const SubNetVal* search)
 		TableEntryVal* entry = reinterpret_cast<TableEntryVal*>(get<1>(element));
 
 		if ( entry && entry->Value() )
-			nt->Assign(s, entry->Value()->Ref());
+			nt->Assign(s, {NewRef{}, entry->Value()});
 		else
 			nt->Assign(s, 0); // set
 
@@ -2223,7 +2229,7 @@ int TableVal::CheckAndAssign(Val* index, IntrusivePtr<Val> new_val)
 	if ( v )
 		index->Warn("multiple initializations for index");
 
-	return Assign(index, new_val.release());
+	return Assign(index, std::move(new_val));
 	}
 
 void TableVal::InitDefaultFunc(Frame* f)
@@ -2600,13 +2606,18 @@ RecordVal::~RecordVal()
 	delete_vals(AsNonConstRecord());
 	}
 
-void RecordVal::Assign(int field, Val* new_val)
+void RecordVal::Assign(int field, IntrusivePtr<Val> new_val)
 	{
-	Val* old_val = AsNonConstRecord()->replace(field, new_val);
+	Val* old_val = AsNonConstRecord()->replace(field, new_val.release());
 	Unref(old_val);
 	Modified();
 	}
 
+void RecordVal::Assign(int field, Val* new_val)
+	{
+	Assign(field, {AdoptRef{}, new_val});
+	}
+
 Val* RecordVal::Lookup(int field) const
 	{
 	return (*AsRecord())[field];
@@ -2698,11 +2709,11 @@ RecordVal* RecordVal::CoerceTo(const RecordType* t, Val* aggr, bool allow_orphan
 			auto rhs = make_intrusive<ConstExpr>(IntrusivePtr{NewRef{}, v});
 			auto e = make_intrusive<RecordCoerceExpr>(std::move(rhs),
 			        IntrusivePtr{NewRef{}, ar_t->FieldType(t_i)->AsRecordType()});
-			ar->Assign(t_i, e->Eval(nullptr).release());
+			ar->Assign(t_i, e->Eval(nullptr));
 			continue;
 			}
 
-		ar->Assign(t_i, v->Ref());
+		ar->Assign(t_i, {NewRef{}, v});
 		}
 
 	for ( i = 0; i < ar_t->NumFields(); ++i )
@@ -2866,14 +2877,11 @@ VectorVal::~VectorVal()
 	delete val.vector_val;
 	}
 
-bool VectorVal::Assign(unsigned int index, Val* element)
+bool VectorVal::Assign(unsigned int index, IntrusivePtr<Val> element)
 	{
 	if ( element &&
 	     ! same_type(element->Type(), vector_type->YieldType(), 0) )
-		{
-		Unref(element);
 		return false;
-		}
 
 	Val* val_at_index = 0;
 
@@ -2887,19 +2895,24 @@ bool VectorVal::Assign(unsigned int index, Val* element)
 	// Note: we do *not* Ref() the element, if any, at this point.
 	// AssignExpr::Eval() already does this; other callers must remember
 	// to do it similarly.
-	(*val.vector_val)[index] = element;
+	(*val.vector_val)[index] = element.release();
 
 	Modified();
 	return true;
 	}
 
+bool VectorVal::Assign(unsigned int index, Val* element)
+	{
+	return Assign(index, {AdoptRef{}, element});
+	}
+
 bool VectorVal::AssignRepeat(unsigned int index, unsigned int how_many,
 				Val* element)
 	{
 	ResizeAtLeast(index + how_many);
 
 	for ( unsigned int i = index; i < index + how_many; ++i )
-		if ( ! Assign(i, element->Ref() ) )
+		if ( ! Assign(i, {NewRef{}, element}) )
 			return false;
 
 	return true;
@@ -2963,7 +2976,7 @@ int VectorVal::AddTo(Val* val, int /* is_first_init */) const
 	auto last_idx = v->Size();
 
 	for ( auto i = 0u; i < Size(); ++i )
-		v->Assign(last_idx++, Lookup(i)->Ref());
+		v->Assign(last_idx++, {NewRef{}, Lookup(i)});
 
 	return 1;
 	}

src/Val.h

@@ -715,7 +715,9 @@ public:
 	// version takes a HashKey and Unref()'s it when done. If we're a
 	// set, new_val has to be nil. If we aren't a set, index may be nil
 	// in the second version.
+	int Assign(Val* index, IntrusivePtr<Val> new_val);
 	int Assign(Val* index, Val* new_val);
+	int Assign(Val* index, HashKey* k, IntrusivePtr<Val> new_val);
 	int Assign(Val* index, HashKey* k, Val* new_val);
 
 	Val* SizeVal() const override	{ return val_mgr->GetCount(Size()); }
@@ -875,6 +877,7 @@ public:
 	Val* SizeVal() const override
 		{ return val_mgr->GetCount(Type()->AsRecordType()->NumFields()); }
 
+	void Assign(int field, IntrusivePtr<Val> new_val);
 	void Assign(int field, Val* new_val);
 	Val* Lookup(int field) const;	// Does not Ref() value.
 	Val* LookupWithDefault(int field) const;	// Does Ref() value.
@@ -965,11 +968,14 @@ public:
 	// Note: does NOT Ref() the element! Remember to do so unless
 	//       the element was just created and thus has refcount 1.
 	//
+	bool Assign(unsigned int index, IntrusivePtr<Val> element);
 	bool Assign(unsigned int index, Val* element);
-	bool Assign(Val* index, Val* element)
+
+	template<typename E>
+	bool Assign(Val* index, E&& element)
 		{
 		return Assign(index->AsListVal()->Index(0)->CoerceToUnsigned(),
-				element);
+		              std::forward<E>(element));
 		}
 
 	// Assigns the value to how_many locations starting at index.

src/analyzer/protocol/bittorrent/BitTorrentTracker.cc

@@ -481,7 +481,7 @@ void BitTorrentTracker_Analyzer::ResponseBenc(int name_len, char* name,
 			uint16_t pt = ntohs((value[4] << 8) | value[5]);
 
 			RecordVal* peer = new RecordVal(bittorrent_peer);
-			peer->Assign(0, new AddrVal(ad));
+			peer->Assign(0, make_intrusive<AddrVal>(ad));
 			peer->Assign(1, val_mgr->GetPort(pt, TRANSPORT_TCP));
 			res_val_peers->Assign(peer, 0);
 
@@ -491,9 +491,9 @@ void BitTorrentTracker_Analyzer::ResponseBenc(int name_len, char* name,
 	else
 		{
 		StringVal* name_ = new StringVal(name_len, name);
-		RecordVal* benc_value = new RecordVal(bittorrent_benc_value);
+		auto benc_value = make_intrusive<RecordVal>(bittorrent_benc_value);
-		benc_value->Assign(type, new StringVal(value_len, value));
+		benc_value->Assign(type, make_intrusive<StringVal>(value_len, value));
-		res_val_benc->Assign(name_, benc_value);
+		res_val_benc->Assign(name_, std::move(benc_value));
 
 		Unref(name_);
 		}

src/analyzer/protocol/dhcp/dhcp-analyzer.pac

@@ -61,13 +61,13 @@ refine flow DHCP_Flow += {
 			dhcp_msg_val->Assign(0, val_mgr->GetCount(${msg.op}));
 			dhcp_msg_val->Assign(1, val_mgr->GetCount(${msg.type}));
 			dhcp_msg_val->Assign(2, val_mgr->GetCount(${msg.xid}));
-			dhcp_msg_val->Assign(3, new Val(secs, TYPE_INTERVAL));
+			dhcp_msg_val->Assign(3, make_intrusive<Val>(secs, TYPE_INTERVAL));
 			dhcp_msg_val->Assign(4, val_mgr->GetCount(${msg.flags}));
-			dhcp_msg_val->Assign(5, new AddrVal(htonl(${msg.ciaddr})));
+			dhcp_msg_val->Assign(5, make_intrusive<AddrVal>(htonl(${msg.ciaddr})));
-			dhcp_msg_val->Assign(6, new AddrVal(htonl(${msg.yiaddr})));
+			dhcp_msg_val->Assign(6, make_intrusive<AddrVal>(htonl(${msg.yiaddr})));
-			dhcp_msg_val->Assign(7, new AddrVal(htonl(${msg.siaddr})));
+			dhcp_msg_val->Assign(7, make_intrusive<AddrVal>(htonl(${msg.siaddr})));
-			dhcp_msg_val->Assign(8, new AddrVal(htonl(${msg.giaddr})));
+			dhcp_msg_val->Assign(8, make_intrusive<AddrVal>(htonl(${msg.giaddr})));
-			dhcp_msg_val->Assign(9, new StringVal(mac_str));
+			dhcp_msg_val->Assign(9, make_intrusive<StringVal>(mac_str));
 
 			int last_non_null = 0;
 
@@ -78,8 +78,8 @@ refine flow DHCP_Flow += {
 				}
 
 			if ( last_non_null > 0 )
-				dhcp_msg_val->Assign(10, new StringVal(last_non_null + 1,
+				dhcp_msg_val->Assign(10, make_intrusive<StringVal>(last_non_null + 1,
-				                                       reinterpret_cast<const char*>(${msg.sname}.begin())));
+				                                                   reinterpret_cast<const char*>(${msg.sname}.begin())));
 
 			last_non_null = 0;
 
@@ -90,8 +90,8 @@ refine flow DHCP_Flow += {
 				}
 
 			if ( last_non_null > 0 )
-				dhcp_msg_val->Assign(11, new StringVal(last_non_null + 1,
+				dhcp_msg_val->Assign(11, make_intrusive<StringVal>(last_non_null + 1,
-				                                       reinterpret_cast<const char*>(${msg.file_n}.begin())));
+				                                                   reinterpret_cast<const char*>(${msg.file_n}.begin())));
 
 			init_options();
 

src/analyzer/protocol/dhcp/dhcp-options.pac

@@ -11,7 +11,7 @@ refine casetype OptionValue += {
 refine flow DHCP_Flow += {
 	function process_subnet_option(v: OptionValue): bool
 		%{
-		${context.flow}->options->Assign(1, new AddrVal(htonl(${v.subnet})));
+		${context.flow}->options->Assign(1, make_intrusive<AddrVal>(htonl(${v.subnet})));
 		return true;
 		%}
 };
@@ -64,7 +64,7 @@ refine flow DHCP_Flow += {
 		for ( int i = 0; i < num_routers; ++i )
 			{
 			uint32 raddr = (*rlist)[i];
-			router_list->Assign(i, new AddrVal(htonl(raddr)));
+			router_list->Assign(i, make_intrusive<AddrVal>(htonl(raddr)));
 			}
 
 		${context.flow}->options->Assign(2, router_list);
@@ -98,7 +98,7 @@ refine flow DHCP_Flow += {
 		for ( int i = 0; i < num_servers; ++i )
 			{
 			uint32 raddr = (*rlist)[i];
-			timeserver_list->Assign(i, new AddrVal(htonl(raddr)));
+			timeserver_list->Assign(i, make_intrusive<AddrVal>(htonl(raddr)));
 			}
 
 		${context.flow}->options->Assign(26, timeserver_list);
@@ -132,7 +132,7 @@ refine flow DHCP_Flow += {
 		for ( int i = 0; i < num_servers; ++i )
 			{
 			uint32 raddr = (*rlist)[i];
-			nameserver_list->Assign(i, new AddrVal(htonl(raddr)));
+			nameserver_list->Assign(i, make_intrusive<AddrVal>(htonl(raddr)));
 			}
 
 		${context.flow}->options->Assign(27, nameserver_list);
@@ -166,7 +166,7 @@ refine flow DHCP_Flow += {
 		for ( int i = 0; i < num_servers; ++i )
 			{
 			uint32 raddr = (*rlist)[i];
-			server_list->Assign(i, new AddrVal(htonl(raddr)));
+			server_list->Assign(i, make_intrusive<AddrVal>(htonl(raddr)));
 			}
 
 		${context.flow}->options->Assign(3, server_list);
@@ -192,7 +192,7 @@ refine casetype OptionValue += {
 refine flow DHCP_Flow += {
 	function process_host_name_option(v: OptionValue): bool
 		%{
-		${context.flow}->options->Assign(4, new StringVal(${v.host_name}.length(),
+		${context.flow}->options->Assign(4, make_intrusive<StringVal>(${v.host_name}.length(),
 		                                                  reinterpret_cast<const char*>(${v.host_name}.begin())));
 
 		return true;
@@ -225,7 +225,7 @@ refine flow DHCP_Flow += {
 				last_non_null = i;
 			}
 
-		${context.flow}->options->Assign(5, new StringVal(last_non_null == 0 ? 0 : last_non_null + 1,
+		${context.flow}->options->Assign(5, make_intrusive<StringVal>(last_non_null == 0 ? 0 : last_non_null + 1,
 		                                                  reinterpret_cast<const char*>(${v.domain_name}.begin())));
 
 		return true;
@@ -274,7 +274,7 @@ refine casetype OptionValue += {
 refine flow DHCP_Flow += {
 	function process_broadcast_address_option(v: OptionValue): bool
 		%{
-		${context.flow}->options->Assign(7, new AddrVal(htonl(${v.broadcast_address})));
+		${context.flow}->options->Assign(7, make_intrusive<AddrVal>(htonl(${v.broadcast_address})));
 
 		return true;
 		%}
@@ -305,7 +305,7 @@ refine flow DHCP_Flow += {
 		for ( int i = 0; i < num_servers; ++i )
 			{
 			uint32 raddr = (*rlist)[i];
-			ntpserver_list->Assign(i, new AddrVal(htonl(raddr)));
+			ntpserver_list->Assign(i, make_intrusive<AddrVal>(htonl(raddr)));
 			}
 
 		${context.flow}->options->Assign(28, ntpserver_list);
@@ -331,7 +331,7 @@ refine casetype OptionValue += {
 refine flow DHCP_Flow += {
 	function process_vendor_specific_option(v: OptionValue): bool
 		%{
-		${context.flow}->options->Assign(8, new StringVal(${v.vendor_specific}.length(),
+		${context.flow}->options->Assign(8, make_intrusive<StringVal>(${v.vendor_specific}.length(),
 		                                                  reinterpret_cast<const char*>(${v.vendor_specific}.begin())));
 
 		return true;
@@ -363,7 +363,7 @@ refine flow DHCP_Flow += {
 		for ( int i = 0; i < num_servers; ++i )
 			{
 			uint32 raddr = (*rlist)[i];
-			server_list->Assign(i, new AddrVal(htonl(raddr)));
+			server_list->Assign(i, make_intrusive<AddrVal>(htonl(raddr)));
 			}
 
 		${context.flow}->options->Assign(9, server_list);
@@ -389,7 +389,7 @@ refine casetype OptionValue += {
 refine flow DHCP_Flow += {
 	function process_addr_request_option(v: OptionValue): bool
 		%{
-		${context.flow}->options->Assign(10, new AddrVal(htonl(${v.addr_request})));
+		${context.flow}->options->Assign(10, make_intrusive<AddrVal>(htonl(${v.addr_request})));
 
 		return true;
 		%}
@@ -414,7 +414,7 @@ refine flow DHCP_Flow += {
 	function process_lease_option(v: OptionValue): bool
 		%{
 		double lease = static_cast<double>(${v.lease});
-		${context.flow}->options->Assign(11, new Val(lease, TYPE_INTERVAL));
+		${context.flow}->options->Assign(11, make_intrusive<Val>(lease, TYPE_INTERVAL));
 
 		return true;
 		%}
@@ -438,7 +438,7 @@ refine casetype OptionValue += {
 refine flow DHCP_Flow += {
 	function process_serv_id_option(v: OptionValue): bool
 		%{
-		${context.flow}->options->Assign(12, new AddrVal(htonl(${v.serv_addr})));
+		${context.flow}->options->Assign(12, make_intrusive<AddrVal>(htonl(${v.serv_addr})));
 
 		return true;
 		%}
@@ -496,7 +496,7 @@ refine casetype OptionValue += {
 refine flow DHCP_Flow += {
 	function process_message_option(v: OptionValue): bool
 		%{
-		${context.flow}->options->Assign(14, new StringVal(${v.message}.length(), 
+		${context.flow}->options->Assign(14, make_intrusive<StringVal>(${v.message}.length(), 
 		                                                   reinterpret_cast<const char*>(${v.message}.begin())));
 
 		return true;
@@ -546,7 +546,7 @@ refine flow DHCP_Flow += {
 	function process_renewal_time_option(v: OptionValue): bool
 		%{
 		double renewal_time = static_cast<double>(${v.renewal_time});
-		${context.flow}->options->Assign(16, new Val(renewal_time, TYPE_INTERVAL));
+		${context.flow}->options->Assign(16, make_intrusive<Val>(renewal_time, TYPE_INTERVAL));
 
 		return true;
 		%}
@@ -571,7 +571,7 @@ refine flow DHCP_Flow += {
 	function process_rebinding_time_option(v: OptionValue): bool
 		%{
 		double rebinding_time = static_cast<double>(${v.rebinding_time});
-		${context.flow}->options->Assign(17, new Val(rebinding_time, TYPE_INTERVAL));
+		${context.flow}->options->Assign(17, make_intrusive<Val>(rebinding_time, TYPE_INTERVAL));
 
 		return true;
 		%}
@@ -595,7 +595,7 @@ refine casetype OptionValue += {
 refine flow DHCP_Flow += {
 	function process_vendor_class_option(v: OptionValue): bool
 		%{
-		${context.flow}->options->Assign(18, new StringVal(${v.vendor_class}.length(),
+		${context.flow}->options->Assign(18, make_intrusive<StringVal>(${v.vendor_class}.length(),
 		                                                   reinterpret_cast<const char*>(${v.vendor_class}.begin())));
 
 		return true;
@@ -627,7 +627,7 @@ refine flow DHCP_Flow += {
 		%{
 		RecordVal* client_id = new RecordVal(BifType::Record::DHCP::ClientID);
 		client_id->Assign(0, val_mgr->GetCount(${v.client_id.hwtype}));
-		client_id->Assign(1, new StringVal(fmt_mac(${v.client_id.hwaddr}.begin(), ${v.client_id.hwaddr}.length())));
+		client_id->Assign(1, make_intrusive<StringVal>(fmt_mac(${v.client_id.hwaddr}.begin(), ${v.client_id.hwaddr}.length())));
 
 		${context.flow}->options->Assign(19, client_id);
 
@@ -653,7 +653,7 @@ refine casetype OptionValue += {
 refine flow DHCP_Flow += {
 	function process_user_class_option(v: OptionValue): bool
 		%{
-		${context.flow}->options->Assign(20, new StringVal(${v.user_class}.length(),
+		${context.flow}->options->Assign(20, make_intrusive<StringVal>(${v.user_class}.length(),
 		                                                   reinterpret_cast<const char*>(${v.user_class}.begin())));
 
 		return true;
@@ -690,7 +690,7 @@ refine flow DHCP_Flow += {
 		client_fqdn->Assign(1, val_mgr->GetCount(${v.client_fqdn.rcode1}));
 		client_fqdn->Assign(2, val_mgr->GetCount(${v.client_fqdn.rcode2}));
 		const char* domain_name = reinterpret_cast<const char*>(${v.client_fqdn.domain_name}.begin());
-		client_fqdn->Assign(3, new StringVal(${v.client_fqdn.domain_name}.length(), domain_name));
+		client_fqdn->Assign(3, make_intrusive<StringVal>(${v.client_fqdn.domain_name}.length(), domain_name));
 
 		${context.flow}->options->Assign(21, client_fqdn);
 
@@ -809,7 +809,7 @@ refine flow DHCP_Flow += {
 
 		if ( string_len == 0 )
 			{
-			${context.flow}->options->Assign(24, new StringVal(0, ""));
+			${context.flow}->options->Assign(24, make_intrusive<StringVal>(0, ""));
 			return true;
 			}
 
@@ -821,7 +821,7 @@ refine flow DHCP_Flow += {
 		if ( has_newline )
 			--string_len;
 
-		${context.flow}->options->Assign(24, new StringVal(string_len,
+		${context.flow}->options->Assign(24, make_intrusive<StringVal>(string_len,
 		                                                   reinterpret_cast<const char*>(${v.auto_proxy_config}.begin())));
 
 		return true;

src/analyzer/protocol/dns/DNS.cc

@@ -603,13 +603,13 @@ int DNS_Interpreter::ParseRR_SOA(DNS_MsgInfo* msg,
 	if ( dns_SOA_reply && ! msg->skip_event )
 		{
 		RecordVal* r = new RecordVal(dns_soa);
-		r->Assign(0, new StringVal(new BroString(mname, mname_end - mname, 1)));
+		r->Assign(0, make_intrusive<StringVal>(new BroString(mname, mname_end - mname, 1)));
-		r->Assign(1, new StringVal(new BroString(rname, rname_end - rname, 1)));
+		r->Assign(1, make_intrusive<StringVal>(new BroString(rname, rname_end - rname, 1)));
 		r->Assign(2, val_mgr->GetCount(serial));
-		r->Assign(3, new IntervalVal(double(refresh), Seconds));
+		r->Assign(3, make_intrusive<IntervalVal>(double(refresh), Seconds));
-		r->Assign(4, new IntervalVal(double(retry), Seconds));
+		r->Assign(4, make_intrusive<IntervalVal>(double(retry), Seconds));
-		r->Assign(5, new IntervalVal(double(expire), Seconds));
+		r->Assign(5, make_intrusive<IntervalVal>(double(expire), Seconds));
-		r->Assign(6, new IntervalVal(double(minimum), Seconds));
+		r->Assign(6, make_intrusive<IntervalVal>(double(minimum), Seconds));
 
 		analyzer->ConnectionEventFast(dns_SOA_reply, {
 			analyzer->BuildConnVal(),
@@ -1029,7 +1029,7 @@ int DNS_Interpreter::ParseRR_NSEC(DNS_MsgInfo* msg,
 			}
 
 		BroString* bitmap = ExtractStream(data, len, bmlen);
-		char_strings->Assign(char_strings->Size(), new StringVal(bitmap));
+		char_strings->Assign(char_strings->Size(), make_intrusive<StringVal>(bitmap));
 		typebitmaps_len = typebitmaps_len - (2 + bmlen);
 		}
 
@@ -1106,7 +1106,7 @@ int DNS_Interpreter::ParseRR_NSEC3(DNS_MsgInfo* msg,
 			}
 
 		BroString* bitmap = ExtractStream(data, len, bmlen);
-		char_strings->Assign(char_strings->Size(), new StringVal(bitmap));
+		char_strings->Assign(char_strings->Size(), make_intrusive<StringVal>(bitmap));
 		typebitmaps_len = typebitmaps_len - (2 + bmlen);
 		}
 
@@ -1496,7 +1496,7 @@ Val* DNS_MsgInfo::BuildAnswerVal()
 	r->Assign(1, query_name);
 	r->Assign(2, val_mgr->GetCount(atype));
 	r->Assign(3, val_mgr->GetCount(aclass));
-	r->Assign(4, new IntervalVal(double(ttl), Seconds));
+	r->Assign(4, make_intrusive<IntervalVal>(double(ttl), Seconds));
 
 	return r;
 	}
@@ -1531,7 +1531,7 @@ Val* DNS_MsgInfo::BuildEDNS_Val()
 	r->Assign(4, val_mgr->GetCount(return_error));
 	r->Assign(5, val_mgr->GetCount(version));
 	r->Assign(6, val_mgr->GetCount(z));
-	r->Assign(7, new IntervalVal(double(ttl), Seconds));
+	r->Assign(7, make_intrusive<IntervalVal>(double(ttl), Seconds));
 	r->Assign(8, val_mgr->GetCount(is_query));
 
 	return r;
@@ -1546,10 +1546,10 @@ Val* DNS_MsgInfo::BuildTSIG_Val(struct TSIG_DATA* tsig)
 	// r->Assign(0, val_mgr->GetCount(int(answer_type)));
 	r->Assign(0, query_name);
 	r->Assign(1, val_mgr->GetCount(int(answer_type)));
-	r->Assign(2, new StringVal(tsig->alg_name));
+	r->Assign(2, make_intrusive<StringVal>(tsig->alg_name));
-	r->Assign(3, new StringVal(tsig->sig));
+	r->Assign(3, make_intrusive<StringVal>(tsig->sig));
-	r->Assign(4, new Val(rtime, TYPE_TIME));
+	r->Assign(4, make_intrusive<Val>(rtime, TYPE_TIME));
-	r->Assign(5, new Val(double(tsig->fudge), TYPE_TIME));
+	r->Assign(5, make_intrusive<Val>(double(tsig->fudge), TYPE_TIME));
 	r->Assign(6, val_mgr->GetCount(tsig->orig_id));
 	r->Assign(7, val_mgr->GetCount(tsig->rr_error));
 	r->Assign(8, val_mgr->GetCount(is_query));
@@ -1567,12 +1567,12 @@ Val* DNS_MsgInfo::BuildRRSIG_Val(RRSIG_DATA* rrsig)
 	r->Assign(2, val_mgr->GetCount(rrsig->type_covered));
 	r->Assign(3, val_mgr->GetCount(rrsig->algorithm));
 	r->Assign(4, val_mgr->GetCount(rrsig->labels));
-	r->Assign(5, new IntervalVal(double(rrsig->orig_ttl), Seconds));
+	r->Assign(5, make_intrusive<IntervalVal>(double(rrsig->orig_ttl), Seconds));
-	r->Assign(6, new Val(double(rrsig->sig_exp), TYPE_TIME));
+	r->Assign(6, make_intrusive<Val>(double(rrsig->sig_exp), TYPE_TIME));
-	r->Assign(7, new Val(double(rrsig->sig_incep), TYPE_TIME));
+	r->Assign(7, make_intrusive<Val>(double(rrsig->sig_incep), TYPE_TIME));
 	r->Assign(8, val_mgr->GetCount(rrsig->key_tag));
-	r->Assign(9, new StringVal(rrsig->signer_name));
+	r->Assign(9, make_intrusive<StringVal>(rrsig->signer_name));
-	r->Assign(10, new StringVal(rrsig->signature));
+	r->Assign(10, make_intrusive<StringVal>(rrsig->signature));
 	r->Assign(11, val_mgr->GetCount(is_query));
 
 	return r;
@@ -1588,7 +1588,7 @@ Val* DNS_MsgInfo::BuildDNSKEY_Val(DNSKEY_DATA* dnskey)
 	r->Assign(2, val_mgr->GetCount(dnskey->dflags));
 	r->Assign(3, val_mgr->GetCount(dnskey->dprotocol));
 	r->Assign(4, val_mgr->GetCount(dnskey->dalgorithm));
-	r->Assign(5, new StringVal(dnskey->public_key));
+	r->Assign(5, make_intrusive<StringVal>(dnskey->public_key));
 	r->Assign(6, val_mgr->GetCount(is_query));
 
 	return r;
@@ -1605,9 +1605,9 @@ Val* DNS_MsgInfo::BuildNSEC3_Val(NSEC3_DATA* nsec3)
 	r->Assign(3, val_mgr->GetCount(nsec3->nsec_hash_algo));
 	r->Assign(4, val_mgr->GetCount(nsec3->nsec_iter));
 	r->Assign(5, val_mgr->GetCount(nsec3->nsec_salt_len));
-	r->Assign(6, new StringVal(nsec3->nsec_salt));
+	r->Assign(6, make_intrusive<StringVal>(nsec3->nsec_salt));
 	r->Assign(7, val_mgr->GetCount(nsec3->nsec_hlen));
-	r->Assign(8, new StringVal(nsec3->nsec_hash));
+	r->Assign(8, make_intrusive<StringVal>(nsec3->nsec_hash));
 	r->Assign(9, nsec3->bitmaps);
 	r->Assign(10, val_mgr->GetCount(is_query));
 
@@ -1624,7 +1624,7 @@ Val* DNS_MsgInfo::BuildDS_Val(DS_DATA* ds)
 	r->Assign(2, val_mgr->GetCount(ds->key_tag));
 	r->Assign(3, val_mgr->GetCount(ds->algorithm));
 	r->Assign(4, val_mgr->GetCount(ds->digest_type));
-	r->Assign(5, new StringVal(ds->digest_val));
+	r->Assign(5, make_intrusive<StringVal>(ds->digest_val));
 	r->Assign(6, val_mgr->GetCount(is_query));
 
 	return r;

src/analyzer/protocol/ftp/functions.bif

@@ -33,13 +33,13 @@ static Val* parse_port(const char* line)
 			good = 0;
 			}
 
-		r->Assign(0, new AddrVal(htonl(addr)));
+		r->Assign(0, make_intrusive<AddrVal>(htonl(addr)));
 		r->Assign(1, val_mgr->GetPort(port, TRANSPORT_TCP));
 		r->Assign(2, val_mgr->GetBool(good));
 		}
 	else
 		{
-		r->Assign(0, new AddrVal(uint32_t(0)));
+		r->Assign(0, make_intrusive<AddrVal>(uint32_t(0)));
 		r->Assign(1, val_mgr->GetPort(0, TRANSPORT_TCP));
 		r->Assign(2, val_mgr->GetBool(0));
 		}
@@ -109,7 +109,7 @@ static Val* parse_eftp(const char* line)
 
 		}
 
-	r->Assign(0, new AddrVal(addr));
+	r->Assign(0, make_intrusive<AddrVal>(addr));
 	r->Assign(1, val_mgr->GetPort(port, TRANSPORT_TCP));
 	r->Assign(2, val_mgr->GetBool(good));
 

src/analyzer/protocol/gtpv1/gtpv1-analyzer.pac

@@ -97,15 +97,15 @@ Val* BuildEndUserAddr(const InformationElement* ie)
 
 		switch ( ie->end_user_addr()->pdp_type_num() ) {
 		case 0x21:
-			ev->Assign(2, new AddrVal(
+			ev->Assign(2, make_intrusive<AddrVal>(
 			  IPAddr(IPv4, (const uint32*) d, IPAddr::Network)));
 			break;
 		case 0x57:
-			ev->Assign(2, new AddrVal(
+			ev->Assign(2, make_intrusive<AddrVal>(
 			  IPAddr(IPv6, (const uint32*) d, IPAddr::Network)));
 			break;
 		default:
-			ev->Assign(3, new StringVal(
+			ev->Assign(3, make_intrusive<StringVal>(
 			  new BroString((const u_char*) d, len, 0)));
 			break;
 		}
@@ -136,13 +136,13 @@ Val* BuildGSN_Addr(const InformationElement* ie)
 	const uint8* d = ie->gsn_addr()->value().data();
 
 	if ( len == 4 )
-		ev->Assign(0, new AddrVal(
+		ev->Assign(0, make_intrusive<AddrVal>(
 		  IPAddr(IPv4, (const uint32*) d, IPAddr::Network)));
 	else if ( len == 16 )
-		ev->Assign(0, new AddrVal(
+		ev->Assign(0, make_intrusive<AddrVal>(
 		  IPAddr(IPv6, (const uint32*) d, IPAddr::Network)));
 	else
-		ev->Assign(1, new StringVal(new BroString((const u_char*) d, len, 0)));
+		ev->Assign(1, make_intrusive<StringVal>(new BroString((const u_char*) d, len, 0)));
 
 	return ev;
 	}
@@ -162,7 +162,7 @@ Val* BuildQoS_Profile(const InformationElement* ie)
 	int len = ie->qos_profile()->data().length();
 
 	ev->Assign(0, val_mgr->GetCount(ie->qos_profile()->alloc_retention_priority()));
-	ev->Assign(1, new StringVal(new BroString(d, len, 0)));
+	ev->Assign(1, make_intrusive<StringVal>(new BroString(d, len, 0)));
 
 	return ev;
 	}
@@ -196,7 +196,7 @@ Val* BuildPrivateExt(const InformationElement* ie)
 	int len = ie->private_ext()->value().length();
 
 	ev->Assign(0, val_mgr->GetCount(ie->private_ext()->id()));
-	ev->Assign(1, new StringVal(new BroString((const u_char*) d, len, 0)));
+	ev->Assign(1, make_intrusive<StringVal>(new BroString((const u_char*) d, len, 0)));
 
 	return ev;
 	}

src/analyzer/protocol/http/HTTP.cc

@@ -617,9 +617,9 @@ Val* HTTP_Message::BuildMessageStat(const int interrupted, const char* msg)
 	{
 	RecordVal* stat = new RecordVal(http_message_stat);
 	int field = 0;
-	stat->Assign(field++, new Val(start_time, TYPE_TIME));
+	stat->Assign(field++, make_intrusive<Val>(start_time, TYPE_TIME));
 	stat->Assign(field++, val_mgr->GetBool(interrupted));
-	stat->Assign(field++, new StringVal(msg));
+	stat->Assign(field++, make_intrusive<StringVal>(msg));
 	stat->Assign(field++, val_mgr->GetCount(body_length));
 	stat->Assign(field++, val_mgr->GetCount(content_gap_length));
 	stat->Assign(field++, val_mgr->GetCount(header_length));
@@ -1185,8 +1185,8 @@ void HTTP_Analyzer::GenStats()
 		RecordVal* r = new RecordVal(http_stats_rec);
 		r->Assign(0, val_mgr->GetCount(num_requests));
 		r->Assign(1, val_mgr->GetCount(num_replies));
-		r->Assign(2, new Val(request_version.ToDouble(), TYPE_DOUBLE));
+		r->Assign(2, make_intrusive<Val>(request_version.ToDouble(), TYPE_DOUBLE));
-		r->Assign(3, new Val(reply_version.ToDouble(), TYPE_DOUBLE));
+		r->Assign(3, make_intrusive<Val>(reply_version.ToDouble(), TYPE_DOUBLE));
 
 		// DEBUG_MSG("%.6f http_stats\n", network_time);
 		ConnectionEventFast(http_stats, {BuildConnVal(), r});

src/analyzer/protocol/icmp/ICMP.cc

@@ -228,8 +228,8 @@ RecordVal* ICMP_Analyzer::BuildICMPVal(const struct icmp* icmpp, int len,
 		{
 		icmp_conn_val = new RecordVal(icmp_conn);
 
-		icmp_conn_val->Assign(0, new AddrVal(Conn()->OrigAddr()));
+		icmp_conn_val->Assign(0, make_intrusive<AddrVal>(Conn()->OrigAddr()));
-		icmp_conn_val->Assign(1, new AddrVal(Conn()->RespAddr()));
+		icmp_conn_val->Assign(1, make_intrusive<AddrVal>(Conn()->RespAddr()));
 		icmp_conn_val->Assign(2, val_mgr->GetCount(icmpp->icmp_type));
 		icmp_conn_val->Assign(3, val_mgr->GetCount(icmpp->icmp_code));
 		icmp_conn_val->Assign(4, val_mgr->GetCount(len));
@@ -356,9 +356,9 @@ RecordVal* ICMP_Analyzer::ExtractICMP4Context(int len, const u_char*& data)
 	RecordVal* iprec = new RecordVal(icmp_context);
 	RecordVal* id_val = new RecordVal(conn_id);
 
-	id_val->Assign(0, new AddrVal(src_addr));
+	id_val->Assign(0, make_intrusive<AddrVal>(src_addr));
 	id_val->Assign(1, val_mgr->GetPort(src_port, proto));
-	id_val->Assign(2, new AddrVal(dst_addr));
+	id_val->Assign(2, make_intrusive<AddrVal>(dst_addr));
 	id_val->Assign(3, val_mgr->GetPort(dst_port, proto));
 
 	iprec->Assign(0, id_val);
@@ -415,9 +415,9 @@ RecordVal* ICMP_Analyzer::ExtractICMP6Context(int len, const u_char*& data)
 	RecordVal* iprec = new RecordVal(icmp_context);
 	RecordVal* id_val = new RecordVal(conn_id);
 
-	id_val->Assign(0, new AddrVal(src_addr));
+	id_val->Assign(0, make_intrusive<AddrVal>(src_addr));
 	id_val->Assign(1, val_mgr->GetPort(src_port, proto));
-	id_val->Assign(2, new AddrVal(dst_addr));
+	id_val->Assign(2, make_intrusive<AddrVal>(dst_addr));
 	id_val->Assign(3, val_mgr->GetPort(dst_port, proto));
 
 	iprec->Assign(0, id_val);
@@ -778,7 +778,7 @@ VectorVal* ICMP_Analyzer::BuildNDOptionsVal(int caplen, const u_char* data)
 			if ( caplen >= length )
 				{
 				BroString* link_addr = new BroString(data, length, 0);
-				rv->Assign(2, new StringVal(link_addr));
+				rv->Assign(2, make_intrusive<StringVal>(link_addr));
 				}
 			else
 				set_payload_field = true;
@@ -801,9 +801,9 @@ VectorVal* ICMP_Analyzer::BuildNDOptionsVal(int caplen, const u_char* data)
 				info->Assign(0, val_mgr->GetCount(prefix_len));
 				info->Assign(1, val_mgr->GetBool(L_flag));
 				info->Assign(2, val_mgr->GetBool(A_flag));
-				info->Assign(3, new IntervalVal((double)ntohl(valid_life), Seconds));
+				info->Assign(3, make_intrusive<IntervalVal>((double)ntohl(valid_life), Seconds));
-				info->Assign(4, new IntervalVal((double)ntohl(prefer_life), Seconds));
+				info->Assign(4, make_intrusive<IntervalVal>((double)ntohl(prefer_life), Seconds));
-				info->Assign(5, new AddrVal(IPAddr(prefix)));
+				info->Assign(5, make_intrusive<AddrVal>(IPAddr(prefix)));
 				rv->Assign(3, info);
 				}
 
@@ -849,7 +849,7 @@ VectorVal* ICMP_Analyzer::BuildNDOptionsVal(int caplen, const u_char* data)
 			{
 			BroString* payload =
 			        new BroString(data, min((int)length, caplen), 0);
-			rv->Assign(6, new StringVal(payload));
+			rv->Assign(6, make_intrusive<StringVal>(payload));
 			}
 
 		data += length;

src/analyzer/protocol/imap/imap-analyzer.pac

@@ -63,7 +63,7 @@ refine connection IMAP_Conn += {
 		for ( unsigned int i = 0; i< capabilities->size(); i++ )
 			{
 			const bytestring& capability = (*capabilities)[i]->cap();
-			capv->Assign(i, new StringVal(capability.length(), (const char*)capability.data()));
+			capv->Assign(i, make_intrusive<StringVal>(capability.length(), (const char*)capability.data()));
 			}
 
 		BifEvent::generate_imap_capabilities(bro_analyzer(), bro_analyzer()->Conn(), capv);

src/analyzer/protocol/irc/IRC.cc

@@ -853,14 +853,14 @@ void IRC_Analyzer::DeliverStream(int length, const u_char* line, bool orig)
 		for ( unsigned int i = 0; i < channels.size(); ++i )
 			{
 			RecordVal* info = new RecordVal(irc_join_info);
-			info->Assign(0, new StringVal(nickname.c_str()));
+			info->Assign(0, make_intrusive<StringVal>(nickname.c_str()));
-			info->Assign(1, new StringVal(channels[i].c_str()));
+			info->Assign(1, make_intrusive<StringVal>(channels[i].c_str()));
 			if ( i < passwords.size() )
-				info->Assign(2, new StringVal(passwords[i].c_str()));
+				info->Assign(2, make_intrusive<StringVal>(passwords[i].c_str()));
 			else
-				info->Assign(2, new StringVal(empty_string.c_str()));
+				info->Assign(2, make_intrusive<StringVal>(empty_string.c_str()));
 			// User mode.
-			info->Assign(3, new StringVal(empty_string.c_str()));
+			info->Assign(3, make_intrusive<StringVal>(empty_string.c_str()));
 			list->Assign(info, 0);
 			Unref(info);
 			}
@@ -916,12 +916,12 @@ void IRC_Analyzer::DeliverStream(int length, const u_char* line, bool orig)
 				mode = "voice";
 				}
 
-			info->Assign(0, new StringVal(nick.c_str()));
+			info->Assign(0, make_intrusive<StringVal>(nick.c_str()));
-			info->Assign(1, new StringVal(channel.c_str()));
+			info->Assign(1, make_intrusive<StringVal>(channel.c_str()));
 			// Password:
-			info->Assign(2, new StringVal(empty_string.c_str()));
+			info->Assign(2, make_intrusive<StringVal>(empty_string.c_str()));
 			// User mode:
-			info->Assign(3, new StringVal(mode.c_str()));
+			info->Assign(3, make_intrusive<StringVal>(mode.c_str()));
 			list->Assign(info, 0);
 			Unref(info);
 			}

src/analyzer/protocol/krb/krb-types.pac

@@ -61,7 +61,7 @@ RecordVal* proc_host_address(const BroAnalyzer a, const KRB_Host_Address* addr)
 				}
 
 			auto bytes = reinterpret_cast<const uint32_t*>(addr_bytes.data());
-			rv->Assign(0, new AddrVal(IPAddr(IPv4, bytes, IPAddr::Network)));
+			rv->Assign(0, make_intrusive<AddrVal>(IPAddr(IPv4, bytes, IPAddr::Network)));
 			return rv;
 			}
 		case 24:
@@ -73,7 +73,7 @@ RecordVal* proc_host_address(const BroAnalyzer a, const KRB_Host_Address* addr)
 				}
 
 			auto bytes = reinterpret_cast<const uint32_t*>(addr_bytes.data());
-			rv->Assign(0, new AddrVal(IPAddr(IPv6, bytes, IPAddr::Network)));
+			rv->Assign(0, make_intrusive<AddrVal>(IPAddr(IPv6, bytes, IPAddr::Network)));
 			return rv;
 			}
 		case 20:

src/analyzer/protocol/mqtt/commands/connect.pac

@@ -45,12 +45,12 @@ refine flow MQTT_Flow += {
 		if ( mqtt_connect )
 			{
 			auto m = new RecordVal(BifType::Record::MQTT::ConnectMsg);
-			m->Assign(0, new StringVal(${msg.protocol_name.str}.length(),
+			m->Assign(0, make_intrusive<StringVal>(${msg.protocol_name.str}.length(),
 			                           reinterpret_cast<const char*>(${msg.protocol_name.str}.begin())));
 			m->Assign(1, val_mgr->GetCount(${msg.protocol_version}));
-			m->Assign(2, new StringVal(${msg.client_id.str}.length(),
+			m->Assign(2, make_intrusive<StringVal>(${msg.client_id.str}.length(),
 			                           reinterpret_cast<const char*>(${msg.client_id.str}.begin())));
-			m->Assign(3, new IntervalVal(double(${msg.keep_alive}), Seconds));
+			m->Assign(3, make_intrusive<IntervalVal>(double(${msg.keep_alive}), Seconds));
 
 			m->Assign(4, val_mgr->GetBool(${msg.clean_session}));
 			m->Assign(5, val_mgr->GetBool(${msg.will_retain}));
@@ -58,20 +58,20 @@ refine flow MQTT_Flow += {
 
 			if ( ${msg.will_flag} )
 				{
-				m->Assign(7, new StringVal(${msg.will.topic.str}.length(),
+				m->Assign(7, make_intrusive<StringVal>(${msg.will.topic.str}.length(),
 				                           reinterpret_cast<const char*>(${msg.will.topic.str}.begin())));
-				m->Assign(8, new StringVal(${msg.will.msg.str}.length(),
+				m->Assign(8, make_intrusive<StringVal>(${msg.will.msg.str}.length(),
 				                           reinterpret_cast<const char*>(${msg.will.msg.str}.begin())));
 				}
 
 			if ( ${msg.username} )
 				{
-				m->Assign(9, new StringVal(${msg.uname.str}.length(),
+				m->Assign(9, make_intrusive<StringVal>(${msg.uname.str}.length(),
 				                           reinterpret_cast<const char*>(${msg.uname.str}.begin())));
 				}
 			if ( ${msg.password} )
 				{
-				m->Assign(10, new StringVal(${msg.pass.str}.length(),
+				m->Assign(10, make_intrusive<StringVal>(${msg.pass.str}.length(),
 				                            reinterpret_cast<const char*>(${msg.pass.str}.begin())));
 				}
 

src/analyzer/protocol/mysql/mysql-analyzer.pac

@@ -87,7 +87,7 @@ refine flow MySQL_Flow += {
 
 		auto& bstring = ${msg.row.first_field.val};
 		auto ptr = reinterpret_cast<const char*>(bstring.data());
-		vv->Assign(vv->Size(), new StringVal(bstring.length(), ptr));
+		vv->Assign(vv->Size(), make_intrusive<StringVal>(bstring.length(), ptr));
 
 		auto& fields = *${msg.row.fields};
 
@@ -95,7 +95,7 @@ refine flow MySQL_Flow += {
 			{
 			auto& bstring = f->val();
 			auto ptr = reinterpret_cast<const char*>(bstring.data());
-			vv->Assign(vv->Size(), new StringVal(bstring.length(), ptr));
+			vv->Assign(vv->Size(), make_intrusive<StringVal>(bstring.length(), ptr));
 			}
 
 		BifEvent::generate_mysql_result_row(connection()->bro_analyzer(),

src/analyzer/protocol/ntp/ntp-analyzer.pac

@@ -38,8 +38,8 @@ refine flow NTP_Flow += {
 		RecordVal* rv = new RecordVal(BifType::Record::NTP::StandardMessage);
 
 		rv->Assign(0, val_mgr->GetCount(${nsm.stratum}));
-		rv->Assign(1, new Val(pow(2, ${nsm.poll}), TYPE_INTERVAL));
+		rv->Assign(1, make_intrusive<Val>(pow(2, ${nsm.poll}), TYPE_INTERVAL));
-		rv->Assign(2, new Val(pow(2, ${nsm.precision}), TYPE_INTERVAL));
+		rv->Assign(2, make_intrusive<Val>(pow(2, ${nsm.precision}), TYPE_INTERVAL));
 		rv->Assign(3, proc_ntp_short(${nsm.root_delay}));
 		rv->Assign(4, proc_ntp_short(${nsm.root_dispersion}));
 
@@ -55,7 +55,7 @@ refine flow NTP_Flow += {
 		default:
 			{
 			const uint8* d = ${nsm.reference_id}.data();
-			rv->Assign(7, new AddrVal(IPAddr(IPv4, (const uint32*) d, IPAddr::Network)));
+			rv->Assign(7, make_intrusive<AddrVal>(IPAddr(IPv4, (const uint32*) d, IPAddr::Network)));
 			}
 			break;
 		}

src/analyzer/protocol/rpc/MOUNT.cc

@@ -201,16 +201,16 @@ val_list MOUNT_Interp::event_common_vl(RPC_CallInfo *c,
 	RecordVal* info = new RecordVal(BifType::Record::MOUNT3::info_t);
 	info->Assign(0, BifType::Enum::rpc_status->GetVal(rpc_status));
 	info->Assign(1, BifType::Enum::MOUNT3::status_t->GetVal(mount_status));
-	info->Assign(2, new Val(c->StartTime(), TYPE_TIME));
+	info->Assign(2, make_intrusive<Val>(c->StartTime(), TYPE_TIME));
-	info->Assign(3, new Val(c->LastTime() - c->StartTime(), TYPE_INTERVAL));
+	info->Assign(3, make_intrusive<Val>(c->LastTime() - c->StartTime(), TYPE_INTERVAL));
 	info->Assign(4, val_mgr->GetCount(c->RPCLen()));
-	info->Assign(5, new Val(rep_start_time, TYPE_TIME));
+	info->Assign(5, make_intrusive<Val>(rep_start_time, TYPE_TIME));
-	info->Assign(6, new Val(rep_last_time - rep_start_time, TYPE_INTERVAL));
+	info->Assign(6, make_intrusive<Val>(rep_last_time - rep_start_time, TYPE_INTERVAL));
 	info->Assign(7, val_mgr->GetCount(reply_len));
 	info->Assign(8, val_mgr->GetCount(c->Uid()));
 	info->Assign(9, val_mgr->GetCount(c->Gid()));
 	info->Assign(10, val_mgr->GetCount(c->Stamp()));
-	info->Assign(11, new StringVal(c->MachineName()));
+	info->Assign(11, make_intrusive<StringVal>(c->MachineName()));
 	info->Assign(12, auxgids);
 
 	vl.push_back(info);

src/analyzer/protocol/rpc/NFS.cc

@@ -335,16 +335,16 @@ val_list NFS_Interp::event_common_vl(RPC_CallInfo *c, BifEnum::rpc_status rpc_st
 	RecordVal *info = new RecordVal(BifType::Record::NFS3::info_t);
 	info->Assign(0, BifType::Enum::rpc_status->GetVal(rpc_status));
 	info->Assign(1, BifType::Enum::NFS3::status_t->GetVal(nfs_status));
-	info->Assign(2, new Val(c->StartTime(), TYPE_TIME));
+	info->Assign(2, make_intrusive<Val>(c->StartTime(), TYPE_TIME));
-	info->Assign(3, new Val(c->LastTime()-c->StartTime(), TYPE_INTERVAL));
+	info->Assign(3, make_intrusive<Val>(c->LastTime()-c->StartTime(), TYPE_INTERVAL));
 	info->Assign(4, val_mgr->GetCount(c->RPCLen()));
-	info->Assign(5, new Val(rep_start_time, TYPE_TIME));
+	info->Assign(5, make_intrusive<Val>(rep_start_time, TYPE_TIME));
-	info->Assign(6, new Val(rep_last_time-rep_start_time, TYPE_INTERVAL));
+	info->Assign(6, make_intrusive<Val>(rep_last_time-rep_start_time, TYPE_INTERVAL));
 	info->Assign(7, val_mgr->GetCount(reply_len));
 	info->Assign(8, val_mgr->GetCount(c->Uid()));
 	info->Assign(9, val_mgr->GetCount(c->Gid()));
 	info->Assign(10, val_mgr->GetCount(c->Stamp()));
-	info->Assign(11, new StringVal(c->MachineName()));
+	info->Assign(11, make_intrusive<StringVal>(c->MachineName()));
 	info->Assign(12, auxgids);
 
 	vl.push_back(info);

src/analyzer/protocol/socks/socks-analyzer.pac

@@ -25,7 +25,7 @@ refine connection SOCKS_Conn += {
 		if ( socks_request )
 			{
 			RecordVal* sa = new RecordVal(socks_address);
-			sa->Assign(0, new AddrVal(htonl(${request.addr})));
+			sa->Assign(0, make_intrusive<AddrVal>(htonl(${request.addr})));
 
 			if ( ${request.v4a} )
 				sa->Assign(1, array_to_string(${request.name}));
@@ -49,7 +49,7 @@ refine connection SOCKS_Conn += {
 		if ( socks_reply )
 			{
 			RecordVal* sa = new RecordVal(socks_address);
-			sa->Assign(0, new AddrVal(htonl(${reply.addr})));
+			sa->Assign(0, make_intrusive<AddrVal>(htonl(${reply.addr})));
 
 			BifEvent::generate_socks_reply(bro_analyzer(),
 			                               bro_analyzer()->Conn(),
@@ -86,16 +86,16 @@ refine connection SOCKS_Conn += {
 		switch ( ${request.remote_name.addr_type} )
 			{
 			case 1:
-				sa->Assign(0, new AddrVal(htonl(${request.remote_name.ipv4})));
+				sa->Assign(0, make_intrusive<AddrVal>(htonl(${request.remote_name.ipv4})));
 				break;
 
 			case 3:
-				sa->Assign(1, new StringVal(${request.remote_name.domain_name.name}.length(),
+				sa->Assign(1, make_intrusive<StringVal>(${request.remote_name.domain_name.name}.length(),
 				                         (const char*) ${request.remote_name.domain_name.name}.data()));
 				break;
 
 			case 4:
-				sa->Assign(0, new AddrVal(IPAddr(IPv6, (const uint32_t*) ${request.remote_name.ipv6}, IPAddr::Network)));
+				sa->Assign(0, make_intrusive<AddrVal>(IPAddr(IPv6, (const uint32_t*) ${request.remote_name.ipv6}, IPAddr::Network)));
 				break;
 
 			default:
@@ -128,16 +128,16 @@ refine connection SOCKS_Conn += {
 		switch ( ${reply.bound.addr_type} )
 			{
 			case 1:
-				sa->Assign(0, new AddrVal(htonl(${reply.bound.ipv4})));
+				sa->Assign(0, make_intrusive<AddrVal>(htonl(${reply.bound.ipv4})));
 				break;
 
 			case 3:
-				sa->Assign(1, new StringVal(${reply.bound.domain_name.name}.length(),
+				sa->Assign(1, make_intrusive<StringVal>(${reply.bound.domain_name.name}.length(),
 				                         (const char*) ${reply.bound.domain_name.name}.data()));
 				break;
 
 			case 4:
-				sa->Assign(0, new AddrVal(IPAddr(IPv6, (const uint32_t*) ${reply.bound.ipv6}, IPAddr::Network)));
+				sa->Assign(0, make_intrusive<AddrVal>(IPAddr(IPv6, (const uint32_t*) ${reply.bound.ipv6}, IPAddr::Network)));
 				break;
 
 			default:

src/analyzer/protocol/ssh/ssh-analyzer.pac

@@ -32,7 +32,7 @@ VectorVal* name_list_to_vector(const bytestring& nl)
 		{
 		word = name_list.substr(start, split_pos - start);
 		if ( word.size() > 0 && word[0] != ',' )
-			vv->Assign(vv->Size(), new StringVal(word));
+			vv->Assign(vv->Size(), make_intrusive<StringVal>(word));
 
 		start = split_pos + 1;
 		}
@@ -41,7 +41,7 @@ VectorVal* name_list_to_vector(const bytestring& nl)
 	if ( start < name_list.size() )
 		{
 		word = name_list.substr(start, name_list.size() - start);
-		vv->Assign(vv->Size(), new StringVal(word));
+		vv->Assign(vv->Size(), make_intrusive<StringVal>(word));
 		}
 	return vv;
 	}

src/analyzer/protocol/ssl/tls-handshake-analyzer.pac

@@ -183,7 +183,7 @@ refine connection Handshake_Conn += {
 		if ( protocols )
 			{
 			for ( unsigned int i = 0; i < protocols->size(); ++i )
-				plist->Assign(i, new StringVal((*protocols)[i]->name().length(), (const char*) (*protocols)[i]->name().data()));
+				plist->Assign(i, make_intrusive<StringVal>((*protocols)[i]->name().length(), (const char*) (*protocols)[i]->name().data()));
 			}
 
 		BifEvent::generate_ssl_extension_application_layer_protocol_negotiation(bro_analyzer(), bro_analyzer()->Conn(),
@@ -208,7 +208,7 @@ refine connection Handshake_Conn += {
 					}
 
 				if ( servername->host_name() )
-					servers->Assign(j++, new StringVal(servername->host_name()->host_name().length(), (const char*) servername->host_name()->host_name().data()));
+					servers->Assign(j++, make_intrusive<StringVal>(servername->host_name()->host_name().length(), (const char*) servername->host_name()->host_name().data()));
 				else
 					bro_analyzer()->Weird("Empty server_name extension in ssl connection");
 				}
@@ -487,7 +487,7 @@ refine connection Handshake_Conn += {
 			for ( auto&& identity : *(identities->identities()) )
 				{
 				RecordVal* el = new RecordVal(BifType::Record::SSL::PSKIdentity);
-				el->Assign(0, new StringVal(identity->identity().length(), (const char*) identity->identity().data()));
+				el->Assign(0, make_intrusive<StringVal>(identity->identity().length(), (const char*) identity->identity().data()));
 				el->Assign(1, val_mgr->GetCount(identity->obfuscated_ticket_age()));
 				slist->Assign(slist->Size(), el);
 				}
@@ -497,7 +497,7 @@ refine connection Handshake_Conn += {
 		if ( binders && binders->binders() )
 			{
 			for ( auto&& binder : *(binders->binders()) )
-				blist->Assign(blist->Size(), new StringVal(binder->binder().length(), (const char*) binder->binder().data()));
+				blist->Assign(blist->Size(), make_intrusive<StringVal>(binder->binder().length(), (const char*) binder->binder().data()));
 			}
 
 		BifEvent::generate_ssl_extension_pre_shared_key_client_hello(bro_analyzer(), bro_analyzer()->Conn(),

src/analyzer/protocol/tcp/TCP.cc

@@ -1366,7 +1366,7 @@ int TCP_Analyzer::ParseTCPOptions(const struct tcphdr* tcp, bool is_orig)
 
 			auto data_len = olen - 2;
 			auto data = reinterpret_cast<const char*>(odata + 2);
-			rv->Assign(2, new StringVal(data_len, data));
+			rv->Assign(2, make_intrusive<StringVal>(data_len, data));
 			};
 
 		for ( const auto& o : opts )

src/analyzer/protocol/teredo/Teredo.cc

@@ -118,9 +118,9 @@ RecordVal* TeredoEncapsulation::BuildVal(const IP_Hdr* inner) const
 		uint8_t au_len = *((uint8_t*)(auth + 3));
 		uint64_t nonce = ntohll(*((uint64_t*)(auth + 4 + id_len + au_len)));
 		uint8_t conf = *((uint8_t*)(auth + 4 + id_len + au_len + 8));
-		teredo_auth->Assign(0, new StringVal(
+		teredo_auth->Assign(0, make_intrusive<StringVal>(
 		    new BroString(auth + 4, id_len, 1)));
-		teredo_auth->Assign(1, new StringVal(
+		teredo_auth->Assign(1, make_intrusive<StringVal>(
 		    new BroString(auth + 4 + id_len, au_len, 1)));
 		teredo_auth->Assign(2, val_mgr->GetCount(nonce));
 		teredo_auth->Assign(3, val_mgr->GetCount(conf));
@@ -133,7 +133,7 @@ RecordVal* TeredoEncapsulation::BuildVal(const IP_Hdr* inner) const
 		uint16_t port = ntohs(*((uint16_t*)(origin_indication + 2))) ^ 0xFFFF;
 		uint32_t addr = ntohl(*((uint32_t*)(origin_indication + 4))) ^ 0xFFFFFFFF;
 		teredo_origin->Assign(0, val_mgr->GetPort(port, TRANSPORT_UDP));
-		teredo_origin->Assign(1, new AddrVal(htonl(addr)));
+		teredo_origin->Assign(1, make_intrusive<AddrVal>(htonl(addr)));
 		teredo_hdr->Assign(1, teredo_origin);
 		}
 

src/broker/Data.cc

@@ -321,7 +321,7 @@ struct val_converter {
 			if ( ! value_val )
 				return nullptr;
 
-			rval->Assign(list_val.get(), value_val.release());
+			rval->Assign(list_val.get(), std::move(value_val));
 			}
 
 		return rval.release();
@@ -341,7 +341,7 @@ struct val_converter {
 				if ( ! item_val )
 					return nullptr;
 
-				rval->Assign(rval->Size(), item_val.release());
+				rval->Assign(rval->Size(), std::move(item_val));
 				}
 
 			return rval.release();
@@ -410,7 +410,7 @@ struct val_converter {
 				if ( ! item_val )
 					return nullptr;
 
-				rval->Assign(i, item_val.release());
+				rval->Assign(i, std::move(item_val));
 				++idx;
 				}
 
@@ -1040,7 +1040,7 @@ RecordVal* bro_broker::make_data_val(Val* v)
 	auto data = val_to_data(v);
 
 	if  ( data )
-		rval->Assign(0, new DataVal(move(*data)));
+		rval->Assign(0, make_intrusive<DataVal>(move(*data)));
 	else
 		reporter->Warning("did not get a value from val_to_data");
 
@@ -1050,7 +1050,7 @@ RecordVal* bro_broker::make_data_val(Val* v)
 RecordVal* bro_broker::make_data_val(broker::data d)
 	{
 	auto rval = new RecordVal(BifType::Record::Broker::Data);
-	rval->Assign(0, new DataVal(move(d)));
+	rval->Assign(0, make_intrusive<DataVal>(move(d)));
 	return rval;
 	}
 

src/broker/Manager.cc

@@ -733,7 +733,7 @@ RecordVal* Manager::MakeEvent(val_list* args, Frame* frame)
 				return rval;
 				}
 
-			rval->Assign(0, new StringVal(func->Name()));
+			rval->Assign(0, make_intrusive<StringVal>(func->Name()));
 			continue;
 			}
 
@@ -1251,24 +1251,24 @@ void Manager::ProcessStatus(broker::status stat)
 
 	if ( ctx )
 		{
-		endpoint_info->Assign(0, new StringVal(to_string(ctx->node)));
+		endpoint_info->Assign(0, make_intrusive<StringVal>(to_string(ctx->node)));
 		auto ni = internal_type("Broker::NetworkInfo")->AsRecordType();
-		auto network_info = new RecordVal(ni);
+		auto network_info = make_intrusive<RecordVal>(ni);
 
 		if ( ctx->network )
 			{
-			network_info->Assign(0, new StringVal(ctx->network->address.data()));
+			network_info->Assign(0, make_intrusive<StringVal>(ctx->network->address.data()));
 			network_info->Assign(1, val_mgr->GetPort(ctx->network->port, TRANSPORT_TCP));
 			}
 		else
 			{
 			// TODO: are there any status messages where the ctx->network
 			// is not set and actually could be?
-			network_info->Assign(0, new StringVal("<unknown>"));
+			network_info->Assign(0, make_intrusive<StringVal>("<unknown>"));
 			network_info->Assign(1, val_mgr->GetPort(0, TRANSPORT_TCP));
 			}
 
-		endpoint_info->Assign(1, network_info);
+		endpoint_info->Assign(1, std::move(network_info));
 		}
 
 	auto str = stat.message();

src/broker/Store.h

@@ -28,7 +28,7 @@ inline RecordVal* query_result()
 	{
 	auto rval = new RecordVal(BifType::Record::Broker::QueryResult);
 	rval->Assign(0, query_status(false));
-	rval->Assign(1, new RecordVal(BifType::Record::Broker::Data));
+	rval->Assign(1, make_intrusive<RecordVal>(BifType::Record::Broker::Data));
 	return rval;
 	}
 

src/broker/comm.bif

@@ -109,16 +109,16 @@ function Broker::__peers%(%): PeerInfos
 
 		if ( n )
 			{
-			network_info->Assign(0, new AddrVal(IPAddr(n->address)));
+			network_info->Assign(0, make_intrusive<AddrVal>(IPAddr(n->address)));
 			network_info->Assign(1, val_mgr->GetPort(n->port, TRANSPORT_TCP));
 			}
 		else
 			{
-			network_info->Assign(0, new AddrVal("0.0.0.0"));
+			network_info->Assign(0, make_intrusive<AddrVal>("0.0.0.0"));
 			network_info->Assign(1, val_mgr->GetPort(0, TRANSPORT_TCP));
 			}
 
-		endpoint_info->Assign(0, new StringVal(to_string(p.peer.node)));
+		endpoint_info->Assign(0, make_intrusive<StringVal>(to_string(p.peer.node)));
 		endpoint_info->Assign(1, network_info);
 
 		auto ps = (BifEnum::Broker::PeerStatus)p.status;

src/broker/data.bif

@@ -154,7 +154,7 @@ function Broker::__set_iterator_value%(it: opaque of Broker::SetIterator%): Brok
 		return rval;
 		}
 
-	rval->Assign(0, new bro_broker::DataVal(*set_it->it));
+	rval->Assign(0, make_intrusive<bro_broker::DataVal>(*set_it->it));
 	return rval;
 	%}
 
@@ -312,8 +312,8 @@ function Broker::__table_iterator_value%(it: opaque of Broker::TableIterator%):
 		return rval;
 		}
 
-	key_val->Assign(0, new bro_broker::DataVal(ti->it->first));
+	key_val->Assign(0, make_intrusive<bro_broker::DataVal>(ti->it->first));
-	val_val->Assign(0, new bro_broker::DataVal(ti->it->second));
+	val_val->Assign(0, make_intrusive<bro_broker::DataVal>(ti->it->second));
 	return rval;
 	%}
 
@@ -431,7 +431,7 @@ function Broker::__vector_iterator_value%(it: opaque of Broker::VectorIterator%)
 		return rval;
 		}
 
-	rval->Assign(0, new bro_broker::DataVal(*vi->it));
+	rval->Assign(0, make_intrusive<bro_broker::DataVal>(*vi->it));
 	return rval;
 	%}
 
@@ -513,6 +513,6 @@ function Broker::__record_iterator_value%(it: opaque of Broker::RecordIterator%)
 	if ( caf::get_if<broker::none>(&(*ri->it)) )
 		return rval; // field isn't set
 
-	rval->Assign(0, new bro_broker::DataVal(*ri->it));
+	rval->Assign(0, make_intrusive<bro_broker::DataVal>(*ri->it));
 	return rval;
 	%}

src/file_analysis/File.cc

@@ -34,9 +34,9 @@ static Val* empty_connection_table()
 static RecordVal* get_conn_id_val(const Connection* conn)
 	{
 	RecordVal* v = new RecordVal(conn_id);
-	v->Assign(0, new AddrVal(conn->OrigAddr()));
+	v->Assign(0, make_intrusive<AddrVal>(conn->OrigAddr()));
 	v->Assign(1, val_mgr->GetPort(ntohs(conn->OrigPort()), conn->ConnTransport()));
-	v->Assign(2, new AddrVal(conn->RespAddr()));
+	v->Assign(2, make_intrusive<AddrVal>(conn->RespAddr()));
 	v->Assign(3, val_mgr->GetPort(ntohs(conn->RespPort()), conn->ConnTransport()));
 	return v;
 	}
@@ -93,7 +93,7 @@ File::File(const string& file_id, const string& source_name, Connection* conn,
 	DBG_LOG(DBG_FILE_ANALYSIS, "[%s] Creating new File object", file_id.c_str());
 
 	val = new RecordVal(fa_file_type);
-	val->Assign(id_idx, new StringVal(file_id.c_str()));
+	val->Assign(id_idx, make_intrusive<StringVal>(file_id.c_str()));
 	SetSource(source_name);
 
 	if ( conn )
@@ -117,7 +117,7 @@ File::~File()
 
 void File::UpdateLastActivityTime()
 	{
-	val->Assign(last_active_idx, new Val(network_time, TYPE_TIME));
+	val->Assign(last_active_idx, make_intrusive<Val>(network_time, TYPE_TIME));
 	}
 
 double File::GetLastActivityTime() const
@@ -199,7 +199,7 @@ string File::GetSource() const
 
 void File::SetSource(const string& source)
 	{
-	val->Assign(source_idx, new StringVal(source.c_str()));
+	val->Assign(source_idx, make_intrusive<StringVal>(source.c_str()));
 	}
 
 double File::GetTimeoutInterval() const
@@ -209,7 +209,7 @@ double File::GetTimeoutInterval() const
 
 void File::SetTimeoutInterval(double interval)
 	{
-	val->Assign(timeout_interval_idx, new Val(interval, TYPE_INTERVAL));
+	val->Assign(timeout_interval_idx, make_intrusive<Val>(interval, TYPE_INTERVAL));
 	}
 
 bool File::SetExtractionLimit(RecordVal* args, uint64_t bytes)
@@ -305,7 +305,7 @@ bool File::SetMime(const string& mime_type)
 		return false;
 
 	RecordVal* meta = new RecordVal(fa_metadata_type);
-	meta->Assign(meta_mime_type_idx, new StringVal(mime_type));
+	meta->Assign(meta_mime_type_idx, make_intrusive<StringVal>(mime_type));
 	meta->Assign(meta_inferred_idx, val_mgr->GetBool(0));
 
 	FileEvent(file_sniff, {val->Ref(), meta});
@@ -369,7 +369,7 @@ bool File::BufferBOF(const u_char* data, uint64_t len)
 	if ( bof_buffer.size > 0 )
 		{
 		BroString* bs = concatenate(bof_buffer.chunks);
-		val->Assign(bof_buffer_idx, new StringVal(bs));
+		val->Assign(bof_buffer_idx, make_intrusive<StringVal>(bs));
 		}
 
 	return false;

src/file_analysis/Manager.cc

@@ -528,7 +528,7 @@ VectorVal* file_analysis::GenMIMEMatchesVal(const RuleMatcher::MIME_Matches& m)
 		      it2 != it->second.end(); ++it2 )
 			{
 			element->Assign(0, val_mgr->GetInt(it->first));
-			element->Assign(1, new StringVal(*it2));
+			element->Assign(1, make_intrusive<StringVal>(*it2));
 			}
 
 		rval->Assign(rval->Size(), element);

src/file_analysis/analyzer/entropy/Entropy.cc

@@ -61,11 +61,11 @@ void Entropy::Finalize()
 	entropy->Get(&ent, &chisq, &mean, &montepi, &scc);
 
 	RecordVal* ent_result = new RecordVal(entropy_test_result);
-	ent_result->Assign(0, new Val(ent,     TYPE_DOUBLE));
+	ent_result->Assign(0, make_intrusive<Val>(ent,     TYPE_DOUBLE));
-	ent_result->Assign(1, new Val(chisq,   TYPE_DOUBLE));
+	ent_result->Assign(1, make_intrusive<Val>(chisq,   TYPE_DOUBLE));
-	ent_result->Assign(2, new Val(mean,    TYPE_DOUBLE));
+	ent_result->Assign(2, make_intrusive<Val>(mean,    TYPE_DOUBLE));
-	ent_result->Assign(3, new Val(montepi, TYPE_DOUBLE));
+	ent_result->Assign(3, make_intrusive<Val>(montepi, TYPE_DOUBLE));
-	ent_result->Assign(4, new Val(scc,     TYPE_DOUBLE));
+	ent_result->Assign(4, make_intrusive<Val>(scc,     TYPE_DOUBLE));
 
 	mgr.QueueEventFast(file_entropy, {
 		GetFile()->GetVal()->Ref(),

src/file_analysis/analyzer/pe/pe-analyzer.pac

@@ -43,7 +43,7 @@ refine flow File += {
 		if ( pe_dos_header )
 			{
 			RecordVal* dh = new RecordVal(BifType::Record::PE::DOSHeader);
-			dh->Assign(0, new StringVal(${h.signature}.length(), (const char*) ${h.signature}.data()));
+			dh->Assign(0, make_intrusive<StringVal>(${h.signature}.length(), (const char*) ${h.signature}.data()));
 			dh->Assign(1, val_mgr->GetCount(${h.UsedBytesInTheLastPage}));
 			dh->Assign(2, val_mgr->GetCount(${h.FileSizeInPages}));
 			dh->Assign(3, val_mgr->GetCount(${h.NumberOfRelocationItems}));
@@ -97,7 +97,7 @@ refine flow File += {
 			{
 			RecordVal* fh = new RecordVal(BifType::Record::PE::FileHeader);
 			fh->Assign(0, val_mgr->GetCount(${h.Machine}));
-			fh->Assign(1, new Val(static_cast<double>(${h.TimeDateStamp}), TYPE_TIME));
+			fh->Assign(1, make_intrusive<Val>(static_cast<double>(${h.TimeDateStamp}), TYPE_TIME));
 			fh->Assign(2, val_mgr->GetCount(${h.PointerToSymbolTable}));
 			fh->Assign(3, val_mgr->GetCount(${h.NumberOfSymbols}));
 			fh->Assign(4, val_mgr->GetCount(${h.SizeOfOptionalHeader}));
@@ -176,7 +176,7 @@ refine flow File += {
 				name_len = ${h.name}.length();
 			else
 				name_len = first_null - ${h.name}.data();
-			section_header->Assign(0, new StringVal(name_len, (const char*) ${h.name}.data()));
+			section_header->Assign(0, make_intrusive<StringVal>(name_len, (const char*) ${h.name}.data()));
 
 			section_header->Assign(1, val_mgr->GetCount(${h.virtual_size}));
 			section_header->Assign(2, val_mgr->GetCount(${h.virtual_addr}));

src/file_analysis/analyzer/unified2/unified2-analyzer.pac

@@ -69,7 +69,7 @@ refine flow Flow += {
 			RecordVal* ids_event = new RecordVal(BifType::Record::Unified2::IDSEvent);
 			ids_event->Assign(0, val_mgr->GetCount(${ev.sensor_id}));
 			ids_event->Assign(1, val_mgr->GetCount(${ev.event_id}));
-			ids_event->Assign(2, new Val(ts_to_double(${ev.ts}), TYPE_TIME));
+			ids_event->Assign(2, make_intrusive<Val>(ts_to_double(${ev.ts}), TYPE_TIME));
 			ids_event->Assign(3, val_mgr->GetCount(${ev.signature_id}));
 			ids_event->Assign(4, val_mgr->GetCount(${ev.generator_id}));
 			ids_event->Assign(5, val_mgr->GetCount(${ev.signature_revision}));
@@ -97,7 +97,7 @@ refine flow Flow += {
 			RecordVal* ids_event = new RecordVal(BifType::Record::Unified2::IDSEvent);
 			ids_event->Assign(0, val_mgr->GetCount(${ev.sensor_id}));
 			ids_event->Assign(1, val_mgr->GetCount(${ev.event_id}));
-			ids_event->Assign(2, new Val(ts_to_double(${ev.ts}), TYPE_TIME));
+			ids_event->Assign(2, make_intrusive<Val>(ts_to_double(${ev.ts}), TYPE_TIME));
 			ids_event->Assign(3, val_mgr->GetCount(${ev.signature_id}));
 			ids_event->Assign(4, val_mgr->GetCount(${ev.generator_id}));
 			ids_event->Assign(5, val_mgr->GetCount(${ev.signature_revision}));
@@ -131,7 +131,7 @@ refine flow Flow += {
 			packet->Assign(0, val_mgr->GetCount(${pkt.sensor_id}));
 			packet->Assign(1, val_mgr->GetCount(${pkt.event_id}));
 			packet->Assign(2, val_mgr->GetCount(${pkt.event_second}));
-			packet->Assign(3, new Val(ts_to_double(${pkt.packet_ts}), TYPE_TIME));
+			packet->Assign(3, make_intrusive<Val>(ts_to_double(${pkt.packet_ts}), TYPE_TIME));
 			packet->Assign(4, val_mgr->GetCount(${pkt.link_type}));
 			packet->Assign(5, bytestring_to_val(${pkt.packet_data}));
 

src/file_analysis/analyzer/x509/OCSP.cc

@@ -624,7 +624,7 @@ void file_analysis::OCSP::ParseResponse(OCSP_RESPONSE *resp)
 
 	//i2a_ASN1_OBJECT(bio, basic_resp->signature);
 	//len = BIO_read(bio, buf, sizeof(buf));
-	//ocsp_resp_record->Assign(7, new StringVal(len, buf));
+	//ocsp_resp_record->Assign(7, make_intrusive<StringVal>(len, buf));
 	//BIO_reset(bio);
 
 	certs_vector = new VectorVal(internal_type("x509_opaque_vector")->AsVectorType());
@@ -644,7 +644,7 @@ void file_analysis::OCSP::ParseResponse(OCSP_RESPONSE *resp)
 			::X509 *this_cert = X509_dup(helper_sk_X509_value(certs, i));
 			//::X509 *this_cert = X509_dup(sk_X509_value(certs, i));
 			if (this_cert)
-				certs_vector->Assign(i, new file_analysis::X509Val(this_cert));
+				certs_vector->Assign(i, make_intrusive<file_analysis::X509Val>(this_cert));
 			else
 				reporter->Weird("OpenSSL returned null certificate");
 			}

src/file_analysis/analyzer/x509/X509.cc

@@ -104,12 +104,12 @@ RecordVal* file_analysis::X509::ParseCertificate(X509Val* cert_val, File* f)
 	pX509Cert->Assign(0, val_mgr->GetCount((uint64_t) X509_get_version(ssl_cert) + 1));
 	i2a_ASN1_INTEGER(bio, X509_get_serialNumber(ssl_cert));
 	int len = BIO_read(bio, buf, sizeof(buf));
-	pX509Cert->Assign(1, new StringVal(len, buf));
+	pX509Cert->Assign(1, make_intrusive<StringVal>(len, buf));
 	BIO_reset(bio);
 
 	X509_NAME_print_ex(bio, X509_get_subject_name(ssl_cert), 0, XN_FLAG_RFC2253);
 	len = BIO_gets(bio, buf, sizeof(buf));
-	pX509Cert->Assign(2, new StringVal(len, buf));
+	pX509Cert->Assign(2, make_intrusive<StringVal>(len, buf));
 	BIO_reset(bio);
 
 	X509_NAME *subject_name = X509_get_subject_name(ssl_cert);
@@ -129,17 +129,17 @@ RecordVal* file_analysis::X509::ParseCertificate(X509Val* cert_val, File* f)
 		// we found a common name
 		ASN1_STRING_print(bio, X509_NAME_ENTRY_get_data(X509_NAME_get_entry(subject_name, namepos)));
 		len = BIO_gets(bio, buf, sizeof(buf));
-		pX509Cert->Assign(4, new StringVal(len, buf));
+		pX509Cert->Assign(4, make_intrusive<StringVal>(len, buf));
 		BIO_reset(bio);
 		}
 
 	X509_NAME_print_ex(bio, X509_get_issuer_name(ssl_cert), 0, XN_FLAG_RFC2253);
 	len = BIO_gets(bio, buf, sizeof(buf));
-	pX509Cert->Assign(3, new StringVal(len, buf));
+	pX509Cert->Assign(3, make_intrusive<StringVal>(len, buf));
 	BIO_free(bio);
 
-	pX509Cert->Assign(5, new Val(GetTimeFromAsn1(X509_get_notBefore(ssl_cert), f, reporter), TYPE_TIME));
+	pX509Cert->Assign(5, make_intrusive<Val>(GetTimeFromAsn1(X509_get_notBefore(ssl_cert), f, reporter), TYPE_TIME));
-	pX509Cert->Assign(6, new Val(GetTimeFromAsn1(X509_get_notAfter(ssl_cert), f, reporter), TYPE_TIME));
+	pX509Cert->Assign(6, make_intrusive<Val>(GetTimeFromAsn1(X509_get_notAfter(ssl_cert), f, reporter), TYPE_TIME));
 
 	// we only read 255 bytes because byte 256 is always 0.
 	// if the string is longer than 255, that will be our null-termination,
@@ -149,7 +149,7 @@ RecordVal* file_analysis::X509::ParseCertificate(X509Val* cert_val, File* f)
 	if ( ! i2t_ASN1_OBJECT(buf, 255, algorithm) )
 		buf[0] = 0;
 
-	pX509Cert->Assign(7, new StringVal(buf));
+	pX509Cert->Assign(7, make_intrusive<StringVal>(buf));
 
 	// Special case for RDP server certificates. For some reason some (all?) RDP server
 	// certificates like to specify their key algorithm as md5WithRSAEncryption, which
@@ -171,25 +171,25 @@ RecordVal* file_analysis::X509::ParseCertificate(X509Val* cert_val, File* f)
 	if ( ! i2t_ASN1_OBJECT(buf, 255, OBJ_nid2obj(X509_get_signature_nid(ssl_cert))) )
 		buf[0] = 0;
 
-	pX509Cert->Assign(8, new StringVal(buf));
+	pX509Cert->Assign(8, make_intrusive<StringVal>(buf));
 
 	// Things we can do when we have the key...
 	EVP_PKEY *pkey = X509_extract_key(ssl_cert);
 	if ( pkey != NULL )
 		{
 		if ( EVP_PKEY_base_id(pkey) == EVP_PKEY_DSA )
-			pX509Cert->Assign(9, new StringVal("dsa"));
+			pX509Cert->Assign(9, make_intrusive<StringVal>("dsa"));
 
 		else if ( EVP_PKEY_base_id(pkey) == EVP_PKEY_RSA )
 			{
-			pX509Cert->Assign(9, new StringVal("rsa"));
+			pX509Cert->Assign(9, make_intrusive<StringVal>("rsa"));
 
 			const BIGNUM *e;
 			RSA_get0_key(EVP_PKEY_get0_RSA(pkey), NULL, &e, NULL);
 			char *exponent = BN_bn2dec(e);
 			if ( exponent != NULL )
 				{
-				pX509Cert->Assign(11, new StringVal(exponent));
+				pX509Cert->Assign(11, make_intrusive<StringVal>(exponent));
 				OPENSSL_free(exponent);
 				exponent = NULL;
 				}
@@ -197,7 +197,7 @@ RecordVal* file_analysis::X509::ParseCertificate(X509Val* cert_val, File* f)
 #ifndef OPENSSL_NO_EC
 		else if ( EVP_PKEY_base_id(pkey) == EVP_PKEY_EC )
 			{
-			pX509Cert->Assign(9, new StringVal("ecdsa"));
+			pX509Cert->Assign(9, make_intrusive<StringVal>("ecdsa"));
 			pX509Cert->Assign(12, KeyCurve(pkey));
 			}
 #endif
@@ -379,10 +379,10 @@ void file_analysis::X509::ParseSAN(X509_EXTENSION* ext)
 				uint32_t* addr = (uint32_t*) gen->d.ip->data;
 
 				if( gen->d.ip->length == 4 )
-					ips->Assign(ips->Size(), new AddrVal(*addr));
+					ips->Assign(ips->Size(), make_intrusive<AddrVal>(*addr));
 
 				else if ( gen->d.ip->length == 16 )
-					ips->Assign(ips->Size(), new AddrVal(addr));
+					ips->Assign(ips->Size(), make_intrusive<AddrVal>(addr));
 
 				else
 					{

src/file_analysis/analyzer/x509/X509Common.cc

@@ -263,12 +263,12 @@ void file_analysis::X509Common::ParseExtension(X509_EXTENSION* ex, const EventHa
 		ext_val = new StringVal(0, "");
 
 	RecordVal* pX509Ext = new RecordVal(BifType::Record::X509::Extension);
-	pX509Ext->Assign(0, new StringVal(name));
+	pX509Ext->Assign(0, make_intrusive<StringVal>(name));
 
 	if ( short_name and strlen(short_name) > 0 )
-		pX509Ext->Assign(1, new StringVal(short_name));
+		pX509Ext->Assign(1, make_intrusive<StringVal>(short_name));
 
-	pX509Ext->Assign(2, new StringVal(oid));
+	pX509Ext->Assign(2, make_intrusive<StringVal>(oid));
 	pX509Ext->Assign(3, val_mgr->GetBool(critical));
 	pX509Ext->Assign(4, ext_val);
 

src/file_analysis/analyzer/x509/functions.bif

@@ -16,7 +16,7 @@ RecordVal* x509_result_record(uint64_t num, const char* reason, Val* chainVector
 	RecordVal* rrecord = new RecordVal(BifType::Record::X509::Result);
 
 	rrecord->Assign(0, val_mgr->GetInt(num));
-	rrecord->Assign(1, new StringVal(reason));
+	rrecord->Assign(1, make_intrusive<StringVal>(reason));
 	if ( chainVector )
 		rrecord->Assign(2, chainVector);
 
@@ -564,7 +564,7 @@ function x509_verify%(certs: x509_opaque_vector, root_certs: table_string_of_str
 
 			if ( currcert )
 				// X509Val takes ownership of currcert.
-				chainVector->Assign(i, new file_analysis::X509Val(currcert));
+				chainVector->Assign(i, make_intrusive<file_analysis::X509Val>(currcert));
 			else
 				{
 				reporter->InternalWarning("OpenSSL returned null certificate");

src/logging/Manager.cc

@@ -1544,10 +1544,10 @@ bool Manager::FinishedRotation(WriterFrontend* writer, const char* new_name, con
 	// Create the RotationInfo record.
 	RecordVal* info = new RecordVal(BifType::Record::Log::RotationInfo);
 	info->Assign(0, winfo->type->Ref());
-	info->Assign(1, new StringVal(new_name));
+	info->Assign(1, make_intrusive<StringVal>(new_name));
-	info->Assign(2, new StringVal(winfo->writer->Info().path));
+	info->Assign(2, make_intrusive<StringVal>(winfo->writer->Info().path));
-	info->Assign(3, new Val(open, TYPE_TIME));
+	info->Assign(3, make_intrusive<Val>(open, TYPE_TIME));
-	info->Assign(4, new Val(close, TYPE_TIME));
+	info->Assign(4, make_intrusive<Val>(close, TYPE_TIME));
 	info->Assign(5, val_mgr->GetBool(terminating));
 
 	Func* func = winfo->postprocessor;

src/stats.bif

@@ -152,11 +152,11 @@ function get_proc_stats%(%): ProcStats
 	r->Assign(n++, val_mgr->GetCount(0));
 #endif
 
-	r->Assign(n++, new Val(bro_start_time, TYPE_TIME));
+	r->Assign(n++, make_intrusive<Val>(bro_start_time, TYPE_TIME));
 
-	r->Assign(n++, new IntervalVal(elapsed_time, Seconds));
+	r->Assign(n++, make_intrusive<IntervalVal>(elapsed_time, Seconds));
-	r->Assign(n++, new IntervalVal(user_time, Seconds));
+	r->Assign(n++, make_intrusive<IntervalVal>(user_time, Seconds));
-	r->Assign(n++, new IntervalVal(system_time, Seconds));
+	r->Assign(n++, make_intrusive<IntervalVal>(system_time, Seconds));
 
 	uint64_t total_mem;
 	get_memory_usage(&total_mem, NULL);

src/strings.bif

@@ -106,7 +106,7 @@ int vs_to_string_array(vector<const BroString*>& vs, TableVal* tbl,
 	for ( int i = start, j = 0; i <= end; ++i, ++j )
 		{
 		Val* ind = val_mgr->GetCount(i);
-		tbl->Assign(ind, new StringVal(vs[j]->Len(),
+		tbl->Assign(ind, make_intrusive<StringVal>(vs[j]->Len(),
 						(const char *)vs[j]->Bytes()));
 		Unref(ind);
 		}
@@ -266,7 +266,7 @@ VectorVal* do_split_string(StringVal* str_val, RE_Matcher* re, int incl_sep,
 			n=0;
 			}
 
-		rval->Assign(num++, new StringVal(offset, (const char*) s));
+		rval->Assign(num++, make_intrusive<StringVal>(offset, (const char*) s));
 
 		// No more separators will be needed if this is the end of string.
 		if ( n <= 0 )
@@ -274,7 +274,7 @@ VectorVal* do_split_string(StringVal* str_val, RE_Matcher* re, int incl_sep,
 
 		if ( incl_sep )
 			{ // including the part that matches the pattern
-			rval->Assign(num++, new StringVal(end_of_match, (const char*) s+offset));
+			rval->Assign(num++, make_intrusive<StringVal>(end_of_match, (const char*) s+offset));
 			}
 
 		if ( max_num_sep && num_sep >= max_num_sep )
@@ -322,7 +322,7 @@ Val* do_split(StringVal* str_val, RE_Matcher* re, int incl_sep, int max_num_sep)
 			}
 
 		Val* ind = val_mgr->GetCount(++num);
-		a->Assign(ind, new StringVal(offset, (const char*) s));
+		a->Assign(ind, make_intrusive<StringVal>(offset, (const char*) s));
 		Unref(ind);
 
 		// No more separators will be needed if this is the end of string.
@@ -332,7 +332,7 @@ Val* do_split(StringVal* str_val, RE_Matcher* re, int incl_sep, int max_num_sep)
 		if ( incl_sep )
 			{ // including the part that matches the pattern
 			ind = val_mgr->GetCount(++num);
-			a->Assign(ind, new StringVal(end_of_match, (const char*) s+offset));
+			a->Assign(ind, make_intrusive<StringVal>(end_of_match, (const char*) s+offset));
 			Unref(ind);
 			}
 
@@ -759,7 +759,7 @@ function str_split%(s: string, idx: index_vec%): string_vec
 
 		for ( BroString::VecIt it = result->begin();
 		      it != result->end(); ++it, ++i )
-			result_v->Assign(i, new StringVal(*it));
+			result_v->Assign(i, make_intrusive<StringVal>(*it));
 			// StringVal now possesses string.
 
 		delete result;

src/supervisor/Supervisor.cc

@@ -1109,19 +1109,19 @@ IntrusivePtr<RecordVal> Supervisor::NodeConfig::ToRecord() const
 	{
 	auto rt = BifType::Record::Supervisor::NodeConfig;
 	auto rval = make_intrusive<RecordVal>(rt);
-	rval->Assign(rt->FieldOffset("name"), new StringVal(name));
+	rval->Assign(rt->FieldOffset("name"), make_intrusive<StringVal>(name));
 
 	if ( interface )
-		rval->Assign(rt->FieldOffset("interface"), new StringVal(*interface));
+		rval->Assign(rt->FieldOffset("interface"), make_intrusive<StringVal>(*interface));
 
 	if ( directory )
-		rval->Assign(rt->FieldOffset("directory"), new StringVal(*directory));
+		rval->Assign(rt->FieldOffset("directory"), make_intrusive<StringVal>(*directory));
 
 	if ( stdout_file )
-		rval->Assign(rt->FieldOffset("stdout_file"), new StringVal(*stdout_file));
+		rval->Assign(rt->FieldOffset("stdout_file"), make_intrusive<StringVal>(*stdout_file));
 
 	if ( stderr_file )
-		rval->Assign(rt->FieldOffset("stderr_file"), new StringVal(*stderr_file));
+		rval->Assign(rt->FieldOffset("stderr_file"), make_intrusive<StringVal>(*stderr_file));
 
 	if ( cpu_affinity )
 		rval->Assign(rt->FieldOffset("cpu_affinity"), val_mgr->GetInt(*cpu_affinity));
@@ -1131,7 +1131,7 @@ IntrusivePtr<RecordVal> Supervisor::NodeConfig::ToRecord() const
 	rval->Assign(rt->FieldOffset("scripts"), scripts_val);
 
 	for ( const auto& s : scripts )
-		scripts_val->Assign(scripts_val->Size(), new StringVal(s));
+		scripts_val->Assign(scripts_val->Size(), make_intrusive<StringVal>(s));
 
 	auto tt = BifType::Record::Supervisor::NodeConfig->FieldType("cluster");
 	auto cluster_val = new TableVal(tt->AsTableType());
@@ -1146,13 +1146,13 @@ IntrusivePtr<RecordVal> Supervisor::NodeConfig::ToRecord() const
 		auto val = make_intrusive<RecordVal>(ept);
 
 		val->Assign(ept->FieldOffset("role"), BifType::Enum::Supervisor::ClusterRole->GetVal(ep.role));
-		val->Assign(ept->FieldOffset("host"), new AddrVal(ep.host));
+		val->Assign(ept->FieldOffset("host"), make_intrusive<AddrVal>(ep.host));
 		val->Assign(ept->FieldOffset("p"), val_mgr->GetPort(ep.port, TRANSPORT_TCP));
 
 		if ( ep.interface )
-			val->Assign(ept->FieldOffset("interface"), new StringVal(*ep.interface));
+			val->Assign(ept->FieldOffset("interface"), make_intrusive<StringVal>(*ep.interface));
 
-		cluster_val->Assign(key.get(), val.release());
+		cluster_val->Assign(key.get(), std::move(val));
 		}
 
 	return rval;
@@ -1163,7 +1163,7 @@ IntrusivePtr<RecordVal> Supervisor::Node::ToRecord() const
 	auto rt = BifType::Record::Supervisor::NodeStatus;
 	auto rval = make_intrusive<RecordVal>(rt);
 
-	rval->Assign(rt->FieldOffset("node"), config.ToRecord().release());
+	rval->Assign(rt->FieldOffset("node"), config.ToRecord());
 
 	if ( pid )
 		rval->Assign(rt->FieldOffset("pid"), val_mgr->GetInt(pid));
@@ -1219,18 +1219,18 @@ bool Supervisor::SupervisedNode::InitCluster() const
 
 		auto node_type = supervisor_role_to_cluster_node_type(ep.role);
 		val->Assign(cluster_node_type->FieldOffset("node_type"), node_type);
-		val->Assign(cluster_node_type->FieldOffset("ip"), new AddrVal(ep.host));
+		val->Assign(cluster_node_type->FieldOffset("ip"), make_intrusive<AddrVal>(ep.host));
 		val->Assign(cluster_node_type->FieldOffset("p"), val_mgr->GetPort(ep.port, TRANSPORT_TCP));
 
 		if ( ep.interface )
 			val->Assign(cluster_node_type->FieldOffset("interface"),
-			            new StringVal(*ep.interface));
+			            make_intrusive<StringVal>(*ep.interface));
 
 		if ( manager_name && ep.role != BifEnum::Supervisor::MANAGER )
 			val->Assign(cluster_node_type->FieldOffset("manager"),
-			            new StringVal(*manager_name));
+			            make_intrusive<StringVal>(*manager_name));
 
-		cluster_nodes->Assign(key.get(), val.release());
+		cluster_nodes->Assign(key.get(), std::move(val));
 		}
 
 	cluster_manager_is_logger_id->SetVal({AdoptRef{}, val_mgr->GetBool(! has_logger)});
@@ -1329,7 +1329,7 @@ RecordVal* Supervisor::Status(std::string_view node_name)
 			const auto& node = n.second;
 			auto key = make_intrusive<StringVal>(name);
 			auto val = node.ToRecord();
-			node_table_val->Assign(key.get(), val.release());
+			node_table_val->Assign(key.get(), std::move(val));
 			}
 		}
 	else
@@ -1343,7 +1343,7 @@ RecordVal* Supervisor::Status(std::string_view node_name)
 		const auto& node = it->second;
 		auto key = make_intrusive<StringVal>(name);
 		auto val = node.ToRecord();
-		node_table_val->Assign(key.get(), val.release());
+		node_table_val->Assign(key.get(), std::move(val));
 		}
 
 	return rval;

src/zeek.bif

@@ -1051,11 +1051,11 @@ function find_entropy%(data: string%): entropy_test_result
 	e.Get(&ent, &chisq, &mean, &montepi, &scc);
 
 	RecordVal* ent_result = new RecordVal(entropy_test_result);
-	ent_result->Assign(0, new Val(ent,     TYPE_DOUBLE));
+	ent_result->Assign(0, make_intrusive<Val>(ent,     TYPE_DOUBLE));
-	ent_result->Assign(1, new Val(chisq,   TYPE_DOUBLE));
+	ent_result->Assign(1, make_intrusive<Val>(chisq,   TYPE_DOUBLE));
-	ent_result->Assign(2, new Val(mean,    TYPE_DOUBLE));
+	ent_result->Assign(2, make_intrusive<Val>(mean,    TYPE_DOUBLE));
-	ent_result->Assign(3, new Val(montepi, TYPE_DOUBLE));
+	ent_result->Assign(3, make_intrusive<Val>(montepi, TYPE_DOUBLE));
-	ent_result->Assign(4, new Val(scc,     TYPE_DOUBLE));
+	ent_result->Assign(4, make_intrusive<Val>(scc,     TYPE_DOUBLE));
 	return ent_result;
 	%}
 
@@ -1102,11 +1102,11 @@ function entropy_test_finish%(handle: opaque of entropy%): entropy_test_result
 	static_cast<EntropyVal*>(handle)->Get(&ent, &chisq, &mean, &montepi, &scc);
 
 	RecordVal* ent_result = new RecordVal(entropy_test_result);
-	ent_result->Assign(0, new Val(ent,     TYPE_DOUBLE));
+	ent_result->Assign(0, make_intrusive<Val>(ent,     TYPE_DOUBLE));
-	ent_result->Assign(1, new Val(chisq,   TYPE_DOUBLE));
+	ent_result->Assign(1, make_intrusive<Val>(chisq,   TYPE_DOUBLE));
-	ent_result->Assign(2, new Val(mean,    TYPE_DOUBLE));
+	ent_result->Assign(2, make_intrusive<Val>(mean,    TYPE_DOUBLE));
-	ent_result->Assign(3, new Val(montepi, TYPE_DOUBLE));
+	ent_result->Assign(3, make_intrusive<Val>(montepi, TYPE_DOUBLE));
-	ent_result->Assign(4, new Val(scc,     TYPE_DOUBLE));
+	ent_result->Assign(4, make_intrusive<Val>(scc,     TYPE_DOUBLE));
 	return ent_result;
 	%}
 
@@ -1833,10 +1833,7 @@ function record_type_to_vector%(rt: string%): string_vec
 	if ( type )
 		{
 		for ( int i = 0; i < type->NumFields(); ++i )
-			{
+			result->Assign(i+1, make_intrusive<StringVal>(type->FieldName(i)));
-			StringVal* val = new StringVal(type->FieldName(i));
-			result->Assign(i+1, val);
-			}
 		}
 
 	return result;
@@ -1865,7 +1862,7 @@ function zeek_args%(%): string_vec
 	auto rval = make_intrusive<VectorVal>(sv);
 
 	for ( auto i = 0; i < bro_argc; ++i )
-		rval->Assign(rval->Size(), new StringVal(bro_argv[i]));
+		rval->Assign(rval->Size(), make_intrusive<StringVal>(bro_argv[i]));
 
 	return rval.release();
 	%}
@@ -1906,7 +1903,7 @@ function packet_source%(%): PacketSource
         if ( ps )
 		{
 		r->Assign(0, val_mgr->GetBool(ps->IsLive()));
-		r->Assign(1, new StringVal(ps->Path()));
+		r->Assign(1, make_intrusive<StringVal>(ps->Path()));
 		r->Assign(2, val_mgr->GetInt(ps->LinkType()));
 		r->Assign(3, val_mgr->GetCount(ps->Netmask()));
 		}
@@ -1956,8 +1953,8 @@ function global_ids%(%): id_table
 	for ( const auto& global : globals )
 		{
 		ID* id = global.second;
-		RecordVal* rec = new RecordVal(script_id);
+		auto rec = make_intrusive<RecordVal>(script_id);
-		rec->Assign(0, new StringVal(type_name(id->Type()->Tag())));
+		rec->Assign(0, make_intrusive<StringVal>(type_name(id->Type()->Tag())));
 		rec->Assign(1, val_mgr->GetBool(id->IsExport()));
 		rec->Assign(2, val_mgr->GetBool(id->IsConst()));
 		rec->Assign(3, val_mgr->GetBool(id->IsEnumConst()));
@@ -1971,9 +1968,8 @@ function global_ids%(%): id_table
 			rec->Assign(6, val);
 			}
 
-		Val* id_name = new StringVal(id->Name());
+		auto id_name = make_intrusive<StringVal>(id->Name());
-		ids->Assign(id_name, rec);
+		ids->Assign(id_name.get(), std::move(rec));
-		Unref(id_name);
 		}
 
 	return ids;
@@ -2212,7 +2208,7 @@ function routing0_data_to_addrs%(s: string%): addr_vec
 	while ( len > 0 )
 		{
 		IPAddr a(IPv6, (const uint32_t*) bytes, IPAddr::Network);
-		rval->Assign(rval->Size(), new AddrVal(a));
+		rval->Assign(rval->Size(), make_intrusive<AddrVal>(a));
 		bytes += 16;
 		len -= 16;
 		}
@@ -3316,26 +3312,26 @@ function lookup_connection%(cid: conn_id%): connection
 	RecordVal* c = new RecordVal(connection_type);
 
 	RecordVal* id_val = new RecordVal(conn_id);
-	id_val->Assign(0, new AddrVal((unsigned int) 0));
+	id_val->Assign(0, make_intrusive<AddrVal>((unsigned int) 0));
 	id_val->Assign(1, val_mgr->GetPort(ntohs(0), TRANSPORT_UDP));
-	id_val->Assign(2, new AddrVal((unsigned int) 0));
+	id_val->Assign(2, make_intrusive<AddrVal>((unsigned int) 0));
 	id_val->Assign(3, val_mgr->GetPort(ntohs(0), TRANSPORT_UDP));
 	c->Assign(0, id_val);
 
-	RecordVal* orig_endp = new RecordVal(endpoint);
+	auto orig_endp = make_intrusive<RecordVal>(endpoint);
 	orig_endp->Assign(0, val_mgr->GetCount(0));
 	orig_endp->Assign(1, val_mgr->GetCount(int(0)));
 
-	RecordVal* resp_endp = new RecordVal(endpoint);
+	auto resp_endp = make_intrusive<RecordVal>(endpoint);
 	resp_endp->Assign(0, val_mgr->GetCount(0));
 	resp_endp->Assign(1, val_mgr->GetCount(int(0)));
 
-	c->Assign(1, orig_endp);
+	c->Assign(1, std::move(orig_endp));
-	c->Assign(2, resp_endp);
+	c->Assign(2, std::move(resp_endp));
 
-	c->Assign(3, new Val(network_time, TYPE_TIME));
+	c->Assign(3, make_intrusive<Val>(network_time, TYPE_TIME));
-	c->Assign(4, new Val(0.0, TYPE_INTERVAL));
+	c->Assign(4, make_intrusive<Val>(0.0, TYPE_INTERVAL));
-	c->Assign(5, new TableVal(string_set));	// service
+	c->Assign(5, make_intrusive<TableVal>(string_set));	// service
 	c->Assign(6, val_mgr->GetEmptyString());	// history
 
 	return c;
@@ -3416,7 +3412,7 @@ function get_current_packet%(%) : pcap_packet
 	pkt->Assign(1, val_mgr->GetCount(uint32_t(p->ts.tv_usec)));
 	pkt->Assign(2, val_mgr->GetCount(p->cap_len));
 	pkt->Assign(3, val_mgr->GetCount(p->len));
-	pkt->Assign(4, new StringVal(p->cap_len, (const char*)p->data));
+	pkt->Assign(4, make_intrusive<StringVal>(p->cap_len, (const char*)p->data));
 	pkt->Assign(5, BifType::Enum::link_encap->GetVal(p->link_type));
 
 	return pkt;
@@ -4617,8 +4613,8 @@ function rotate_file%(f: file%): rotate_info
 	info = new RecordVal(rotate_info);
 	info->Assign(0, val_mgr->GetEmptyString());
 	info->Assign(1, val_mgr->GetEmptyString());
-	info->Assign(2, new Val(0.0, TYPE_TIME));
+	info->Assign(2, make_intrusive<Val>(0.0, TYPE_TIME));
-	info->Assign(3, new Val(0.0, TYPE_TIME));
+	info->Assign(3, make_intrusive<Val>(0.0, TYPE_TIME));
 
 	return info;
 	%}
@@ -4658,8 +4654,8 @@ function rotate_file_by_name%(f: string%): rotate_info
 		// Record indicating error.
 		info->Assign(0, val_mgr->GetEmptyString());
 		info->Assign(1, val_mgr->GetEmptyString());
-		info->Assign(2, new Val(0.0, TYPE_TIME));
+		info->Assign(2, make_intrusive<Val>(0.0, TYPE_TIME));
-		info->Assign(3, new Val(0.0, TYPE_TIME));
+		info->Assign(3, make_intrusive<Val>(0.0, TYPE_TIME));
 		return info;
 		}
 
@@ -4667,12 +4663,12 @@ function rotate_file_by_name%(f: string%): rotate_info
 
 	if ( is_pkt_dumper )
 		{
-		info->Assign(2, new Val(pkt_dumper->OpenTime(), TYPE_TIME));
+		info->Assign(2, make_intrusive<Val>(pkt_dumper->OpenTime(), TYPE_TIME));
 		pkt_dumper->Open();
 		}
 
 	if ( is_addl_pkt_dumper )
-		info->Assign(2, new Val(addl_pkt_dumper->OpenTime(), TYPE_TIME));
+		info->Assign(2, make_intrusive<Val>(addl_pkt_dumper->OpenTime(), TYPE_TIME));
 
 	return info;
 	%}