1 //===-- sanitizer_bvgraph.h -------------------------------------*- C++ -*-===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 // 9 // This file is a part of Sanitizer runtime. 10 // BVGraph -- a directed graph. 11 // 12 //===----------------------------------------------------------------------===// 13 14 #ifndef SANITIZER_BVGRAPH_H 15 #define SANITIZER_BVGRAPH_H 16 17 #include "sanitizer_common.h" 18 #include "sanitizer_bitvector.h" 19 20 namespace __sanitizer { 21 22 // Directed graph of fixed size implemented as an array of bit vectors. 23 // Not thread-safe, all accesses should be protected by an external lock. 24 template<class BV> 25 class BVGraph { 26 public: 27 enum SizeEnum : uptr { kSize = BV::kSize }; 28 uptr size() const { return kSize; } 29 // No CTOR. 30 void clear() { 31 for (uptr i = 0; i < size(); i++) 32 v[i].clear(); 33 } 34 35 bool empty() const { 36 for (uptr i = 0; i < size(); i++) 37 if (!v[i].empty()) 38 return false; 39 return true; 40 } 41 42 // Returns true if a new edge was added. 43 bool addEdge(uptr from, uptr to) { 44 check(from, to); 45 return v[from].setBit(to); 46 } 47 48 // Returns true if at least one new edge was added. 49 uptr addEdges(const BV &from, uptr to, uptr added_edges[], 50 uptr max_added_edges) { 51 uptr res = 0; 52 t1.copyFrom(from); 53 while (!t1.empty()) { 54 uptr node = t1.getAndClearFirstOne(); 55 if (v[node].setBit(to)) 56 if (res < max_added_edges) 57 added_edges[res++] = node; 58 } 59 return res; 60 } 61 62 // *EXPERIMENTAL* 63 // Returns true if an edge from=>to exist. 64 // This function does not use any global state except for 'this' itself, 65 // and thus can be called from different threads w/o locking. 66 // This would be racy. 67 // FIXME: investigate how much we can prove about this race being "benign". 68 bool hasEdge(uptr from, uptr to) { return v[from].getBit(to); } 69 70 // Returns true if the edge from=>to was removed. 71 bool removeEdge(uptr from, uptr to) { 72 return v[from].clearBit(to); 73 } 74 75 // Returns true if at least one edge *=>to was removed. 76 bool removeEdgesTo(const BV &to) { 77 bool res = 0; 78 for (uptr from = 0; from < size(); from++) { 79 if (v[from].setDifference(to)) 80 res = true; 81 } 82 return res; 83 } 84 85 // Returns true if at least one edge from=>* was removed. 86 bool removeEdgesFrom(const BV &from) { 87 bool res = false; 88 t1.copyFrom(from); 89 while (!t1.empty()) { 90 uptr idx = t1.getAndClearFirstOne(); 91 if (!v[idx].empty()) { 92 v[idx].clear(); 93 res = true; 94 } 95 } 96 return res; 97 } 98 99 void removeEdgesFrom(uptr from) { 100 return v[from].clear(); 101 } 102 103 bool hasEdge(uptr from, uptr to) const { 104 check(from, to); 105 return v[from].getBit(to); 106 } 107 108 // Returns true if there is a path from the node 'from' 109 // to any of the nodes in 'targets'. 110 bool isReachable(uptr from, const BV &targets) { 111 BV &to_visit = t1, 112 &visited = t2; 113 to_visit.copyFrom(v[from]); 114 visited.clear(); 115 visited.setBit(from); 116 while (!to_visit.empty()) { 117 uptr idx = to_visit.getAndClearFirstOne(); 118 if (visited.setBit(idx)) 119 to_visit.setUnion(v[idx]); 120 } 121 return targets.intersectsWith(visited); 122 } 123 124 // Finds a path from 'from' to one of the nodes in 'target', 125 // stores up to 'path_size' items of the path into 'path', 126 // returns the path length, or 0 if there is no path of size 'path_size'. 127 uptr findPath(uptr from, const BV &targets, uptr *path, uptr path_size) { 128 if (path_size == 0) 129 return 0; 130 path[0] = from; 131 if (targets.getBit(from)) 132 return 1; 133 // The function is recursive, so we don't want to create BV on stack. 134 // Instead of a getAndClearFirstOne loop we use the slower iterator. 135 for (typename BV::Iterator it(v[from]); it.hasNext(); ) { 136 uptr idx = it.next(); 137 if (uptr res = findPath(idx, targets, path + 1, path_size - 1)) 138 return res + 1; 139 } 140 return 0; 141 } 142 143 // Same as findPath, but finds a shortest path. 144 uptr findShortestPath(uptr from, const BV &targets, uptr *path, 145 uptr path_size) { 146 for (uptr p = 1; p <= path_size; p++) 147 if (findPath(from, targets, path, p) == p) 148 return p; 149 return 0; 150 } 151 152 private: 153 void check(uptr idx1, uptr idx2) const { 154 CHECK_LT(idx1, size()); 155 CHECK_LT(idx2, size()); 156 } 157 BV v[kSize]; 158 // Keep temporary vectors here since we can not create large objects on stack. 159 BV t1, t2; 160 }; 161 162 } // namespace __sanitizer 163 164 #endif // SANITIZER_BVGRAPH_H 165