class for tracking the "reach" of variable/field definitions

src/script_opt/ReachingDefs.h

@@ -0,0 +1,248 @@
+// See the file "COPYING" in the main distribution directory for copyright.
+
+#pragma once
+
+#include "zeek/script_opt/DefItem.h"
+
+
+namespace zeek::detail {
+
+
+// Maps a DefinitionItem (i.e., a variable or a record field within a
+// DefinitionItem) to a list of all the points where the item is defined.
+//
+// Those points are specific to a given location in a script (see
+// AnalyInfo below).  For example, right after an assignment to a variable,
+// it will have exactly one associated point (the assignment).  But at
+// other points there can be more than one reaching definition; for example,
+// a variable defined in both branches of an if-else will cause the location
+// in the script after the if-else statement to have both of those definitions
+// as (maximally) reaching.
+
+typedef List<DefinitionPoint> DefPoints;
+typedef std::unordered_map<const DefinitionItem*, DefPoints*> ReachingDefsMap;
+
+
+// The ReachingDefs class tracks all of the RDs associated with a given
+// AST node.  Often these are the same as for the node's predecessor, so
+// the class allows for either have a distinct set of RDs or instead
+// pointing to the predecessor's RDs.
+
+class ReachingDefs;
+class ReachingDefSet;
+using RDPtr = IntrusivePtr<ReachingDefs>;
+using RDSetPtr = IntrusivePtr<ReachingDefSet>;
+
+class ReachingDefs : public Obj {
+public:
+	// Create a new object from scratch.
+	ReachingDefs();
+
+	// Create a new object, using the RDs from another object.
+	ReachingDefs(RDPtr& rd);
+
+	~ReachingDefs();
+
+	// Add in all the definition points from rd into our set, if
+	// we don't already have them.
+	void AddRDs(const RDPtr& rd)	{ AddRDs(rd->RDMap()); }
+
+	// Add in a single definition pair, creating the entry for
+	// the item if necessary.
+	void AddRD(const DefinitionItem* di, const DefinitionPoint& dp);
+
+	// Add a single definition pair, if missing.  If present,
+	// replace everything currently associated with new definition.
+	void AddOrFullyReplace(const DefinitionItem* di,
+				const DefinitionPoint& dp);
+
+	// True if the given definition item is present in our RDs.
+	bool HasDI(const DefinitionItem* di) const
+		{
+		auto map = RDMap();
+		return map->find(di) != map->end();
+		}
+
+	// For the given definition item, returns all of its definition
+	// points at our location in the AST.
+	DefPoints* GetDefPoints(const DefinitionItem* di)
+		{
+		auto map = RDMap();
+		auto dps = map->find(di);
+		return dps == map->end() ? nullptr : dps->second;
+		}
+
+	// Returns true if two sets of definition points are equivalent,
+	// *including ordering*.
+	bool SameDefPoints(const DefPoints* dp1, const DefPoints* dp2) const
+		{
+		if ( ! dp1 || ! dp2 )
+			return ! dp1 && ! dp2;
+
+		if ( dp1->length() != dp2->length() )
+			return false;
+
+		for ( auto i = 0; i < dp1->length(); ++i )
+			if ( ! (*dp1)[i].SameAs((*dp2)[i]) )
+				return false;
+
+		return true;
+		}
+
+	// Return a new object representing the intersection/union of
+	// this object's RDs and those of another.
+	RDPtr Intersect(const RDPtr& r) const;
+	RDPtr Union(const RDPtr& r) const;
+
+	// The following intersects this RD with another, but for
+	// DefinitionItem's that have different DefPoints, rather than
+	// just fully omitting them (which is what Intersect() will do),
+	// creates a joint entry with a special DefinitionPoint
+	// corresponding to "multiple definitions".  This allows
+	// minimal RDs to capture the notions (1) "yes, that value will
+	// be defined at this point", but also (2) "however, we can't
+	// rely on which definition reaches".
+	//
+	// We also do this for items *not* present in r.  The reason is
+	// that this method is only called (1) when we know that the items
+	// in r have control flow to di, and (2) for "this" being minimal
+	// RDs that were present going into the block that resulted in r.
+	// Thus, those minimal values will always be present at di; they
+	// might not be in r due to the way that r is computed.  (For
+	// example, computing them correctly for "for" loop bodies is
+	// messy, and irrevant in terms of actually having the correct
+	// values for them.)
+	RDPtr IntersectWithConsolidation(const RDPtr& r,
+					const DefinitionPoint& di) const;
+
+	int Size() const	{ return RDMap()->size(); }
+
+	// Print out the RDs, for debugging purposes.
+	void Dump() const;
+	void DumpMap(const ReachingDefsMap* map) const;
+
+protected:
+	// True if our RDs include the given definition item, defined at
+	// the given definition point.
+	bool HasPair(const DefinitionItem* di, const DefinitionPoint& dp) const;
+
+	// Adds in the given RDs if we don't already have them.
+	void AddRDs(const ReachingDefsMap* rd_m);
+
+	const ReachingDefsMap* RDMap() const
+		{ return my_rd_map ? my_rd_map : const_rd_map->RDMap(); }
+
+	// If we don't already have our own map, copy the one we're using
+	// so that we then do.
+	void CopyMapIfNeeded();
+
+	void PrintRD(const DefinitionItem* di, const DefPoints* dp) const;
+	void PrintRD(const DefinitionItem* di, const DefinitionPoint& dp) const;
+
+	// If my_rd_map is non-nil, then we use that map.  Otherwise,
+	// we use the map that const_rd_map points to.
+	RDPtr const_rd_map;
+	ReachingDefsMap* my_rd_map;
+};
+
+
+// Maps script locations (which are represented by their underlying Obj
+// pointers) to the reaching definitions for that particular point.
+//
+// In spirit, the inverse of ReachingDefsMap.
+typedef std::unordered_map<const Obj*, RDPtr> AnalyInfo;
+
+
+// Reaching definitions associated with a collection of Obj's.
+class ReachingDefSet : public Obj {
+public:
+	ReachingDefSet(DefItemMap& _item_map) : item_map(_item_map)
+		{
+		a_i = new AnalyInfo;
+		}
+
+	~ReachingDefSet()
+		{
+		delete a_i;
+		}
+
+	// Whether in our collection we have RDs associated with the
+	// given AST node.
+	bool HasRDs(const Obj* o) const	{ return a_i->count(o) > 0; }
+
+	// Whether in our collection we have RDs associated with the
+	// given variable.
+	bool HasRD(const Obj* o, const ID* id) const
+		{ return HasRD(o, item_map.GetConstID_DI(id)); }
+
+	// Whether the given variable has a single = unambiguous RD
+	// at the given AST node.
+	bool HasSingleRD(const Obj* o, const ID* id) const
+		{
+		auto RDs = a_i->find(o);
+		if ( RDs == a_i->end() )
+			return false;
+
+		auto di = item_map.GetConstID_DI(id);
+		auto dps = RDs->second->GetDefPoints(di);
+
+		if ( ! dps || dps->length() != 1 )
+			return false;
+
+		return (*dps)[0].Tag() != NO_DEF;
+		}
+
+	// Whether the given definition item has an RD at the given
+	// AST node.
+	bool HasRD(const Obj* o, const DefinitionItem* di) const
+		{
+		auto RDs = a_i->find(o);
+		if ( RDs == a_i->end() )
+			return false;
+
+		return RDs->second->HasDI(di);
+		}
+
+	// Returns the RDs associated with a given AST node, if any.
+	// If none are, returns an empty ReachingDef object.
+	RDPtr& FindRDs(const Obj* o) const;
+
+	// Associates the given RDs with the given AST node.
+	void SetRDs(const Obj* o, RDPtr& rd)
+		{
+		auto new_rd = make_intrusive<ReachingDefs>(rd);
+		(*a_i)[o] = new_rd;
+		}
+
+	// If the given di is new, add this definition.  If it
+	// already exists, replace *all* of its reaching definitions
+	// with this new one.
+	void AddOrReplace(const Obj* o, const DefinitionItem* di,
+				const DefinitionPoint& dp);
+
+	// Add the given RDs to those associated with the AST node 'o'.
+	void AddRDs(const Obj* o, const RDPtr& rd)
+		{
+		if ( HasRDs(o) )
+			MergeRDs(o, rd);
+		else
+			(*a_i)[o] = rd;
+		}
+
+protected:
+	// Merge in the given RDs with those associated with o's.
+	//
+	// The caller needs to ensure that we're already tracking the
+	// RDs of 'o'.
+	void MergeRDs(const Obj* o, const RDPtr& rd)
+		{
+		auto curr_rds = a_i->find(o)->second;
+		curr_rds->AddRDs(rd);
+		}
+
+	AnalyInfo* a_i;
+	DefItemMap& item_map;
+};
+
+
+} // zeek::detail