| /src/external/apache2/llvm/dist/llvm/include/llvm/Analysis/ |
| CallGraphSCCPass.h | 90 std::vector<CallGraphNode *> Nodes;
96 Nodes.assign(NewNodes.begin(), NewNodes.end());
99 bool isSingular() const { return Nodes.size() == 1; }
100 unsigned size() const { return Nodes.size(); }
112 iterator begin() const { return Nodes.begin(); }
113 iterator end() const { return Nodes.end(); }
|
| Interval.h | 10 // represents a set of CFG nodes and is a portion of an interval partition.
32 /// Interval Class - An Interval is a set of nodes defined such that every node
48 Nodes.push_back(Header);
53 /// Nodes - The basic blocks in this interval.
54 std::vector<BasicBlock*> Nodes;
56 /// Successors - List of BasicBlocks that are reachable directly from nodes in
58 /// These nodes necessarily must be header nodes for other intervals.
67 for (BasicBlock *Node : Nodes)
72 //return find(Nodes.begin(), Nodes.end(), BB) != Nodes.end()
[all...] |
| LazyCallGraph.h | 193 /// An iterator used for the edges to both entry nodes and child nodes.
311 /// a callee, and facilitate iteration of child nodes in the graph.
337 /// Users rarely interact with nodes in this state and other methods are
378 // stored directly within the node. These are both '-1' when nodes are part
414 /// a collection of call graph nodes. While the order of nodes in the SCC is
426 SmallVector<Node *, 1> Nodes;
429 SCC(RefSCC &OuterRefSCC, NodeRangeT &&Nodes)
430 : OuterRefSCC(&OuterRefSCC), Nodes(std::forward<NodeRangeT>(Nodes)) {
[all...] |
| BlockFrequencyInfoImpl.h | 226 NodeList Nodes; ///< Header and the members of the loop.
232 : Parent(Parent), Nodes(1, Header), BackedgeMass(1) {}
237 : Parent(Parent), Nodes(FirstHeader, LastHeader) {
238 NumHeaders = Nodes.size();
239 Nodes.insert(Nodes.end(), FirstOther, LastOther);
245 return std::binary_search(Nodes.begin(), Nodes.begin() + NumHeaders,
247 return Node == Nodes[0];
250 BlockNode getHeader() const { return Nodes[0];
[all...] |
| /src/external/apache2/llvm/dist/llvm/lib/Transforms/Instrumentation/ |
| CGProfile.cpp | 35 std::vector<Metadata *> Nodes;
42 Nodes.push_back(MDNode::get(Context, Vals));
45 M.addModuleFlag(Module::Append, "CG Profile", MDNode::get(Context, Nodes));
|
| /src/external/apache2/llvm/dist/clang/include/clang/ASTMatchers/ |
| ASTMatchFinder.h | 17 // AST nodes that the subexpressions matched on to output information about
25 // Result.Nodes.GetDeclAs<CXXRecordDecl>("id");
75 MatchResult(const BoundNodes &Nodes, clang::ASTContext *Context);
77 /// Contains the nodes bound on the current match.
79 /// This allows user code to easily extract matched AST nodes.
80 const BoundNodes Nodes;
115 /// the result nodes. This API is temporary to facilitate
287 Nodes.push_back(Result.Nodes);
294 SmallVector<BoundNodes, 1> Nodes;
[all...] |
| /src/external/apache2/llvm/dist/llvm/include/llvm/ADT/ |
| DirectedGraph.h | 115 /// a given pair of nodes.
169 /// The graph is represented by a table of nodes.
182 explicit DirectedGraph(NodeType &N) : Nodes() { addNode(N); }
183 DirectedGraph(const DGraphType &G) : Nodes(G.Nodes) {}
184 DirectedGraph(DGraphType &&RHS) : Nodes(std::move(RHS.Nodes)) {}
186 Nodes = G.Nodes;
190 Nodes = std::move(G.Nodes)
[all...] |
| /src/external/apache2/llvm/dist/llvm/lib/Analysis/ |
| CallGraph.cpp | 49 // Update parent CG for all call graph's nodes.
124 SmallVector<CallGraphNode *, 16> Nodes;
125 Nodes.reserve(FunctionMap.size());
128 Nodes.push_back(I.second.get());
130 llvm::sort(Nodes, [](CallGraphNode *LHS, CallGraphNode *RHS) {
138 for (CallGraphNode *CN : Nodes)
|
| DDG.cpp | 22 "Simplify DDG by merging nodes that have less interesting edges."));
26 cl::desc("Create pi-block nodes."));
89 OS << "--- start of nodes in pi-block ---\n";
90 auto &Nodes = cast<const PiBlockDDGNode>(&N)->getNodes();
92 for (const DDGNode *N : Nodes)
93 OS << *N << (++Count == Nodes.size() ? "" : "\n");
94 OS << "--- end of nodes in pi-block ---\n";
214 for (auto *N : Nodes) {
226 // to add new nodes since they may be unreachable by the root. However,
227 // pi-block nodes need to be added after the root node is linked, and they ar
[all...] |
| LazyCallGraph.cpp | 193 // Now add entry nodes for functions reachable via initializers to globals.
247 assert(!Nodes.empty() && "Can't have an empty SCC!");
249 for (Node *N : Nodes) {
261 // Verify that all nodes in this SCC can reach all other nodes.
272 for (Node *NodeToVisit : Nodes) {
274 "Cannot reach all nodes within SCC");
381 // Verify that all nodes in this RefSCC can reach all other nodes.
382 SmallVector<Node *> Nodes;
[all...] |
| CGSCCPassManager.cpp | 320 // late as it contains the nodes that were actively being
337 // apart, at most converging on a DAG of single nodes.
524 SmallVector<LazyCallGraph::Node *, 4> Nodes;
526 Nodes.push_back(&N);
536 for (LazyCallGraph::Node *N : Nodes) {
537 // Skip nodes from other SCCs. These may have been split out during
538 // processing. We'll eventually visit those SCCs and pick up the nodes
|
| /src/sys/external/bsd/compiler_rt/dist/lib/xray/ |
| xray_function_call_trie.h | 323 NodeArray Nodes;
331 : Nodes(*A.NodeAllocator),
342 : Nodes(std::move(O.Nodes)),
349 Nodes = std::move(O.Nodes);
373 auto *NewRoot = Nodes.AppendEmplace(
378 Nodes.trim(1);
382 Nodes.trim(1);
407 auto* NewNode = Nodes.AppendEmplace
[all...] |
| /src/external/apache2/llvm/dist/clang/include/clang/AST/ |
| ASTImporter.h | 9 // This file defines the ASTImporter class which imports AST nodes from one
88 /// Imports selected nodes from one AST context into another context,
89 /// merging AST nodes where appropriate.
99 // An ImportPath is the list of the AST nodes which we visit during an
112 // The import behaves like a DFS, so we will visit the nodes in this order:
168 // to all nodes which depend on A (this includes C).
180 Nodes.push_back(D);
185 if (Nodes.empty())
187 --Aux[Nodes.back()];
188 Nodes.pop_back()
[all...] |
| /src/external/apache2/llvm/dist/llvm/lib/Support/ |
| ItaniumManglingCanonicalizer.cpp | 86 llvm::FoldingSet<NodeHeader> Nodes;
108 if (NodeHeader *Existing = Nodes.FindNodeOrInsertPos(ID, InsertPos))
120 Nodes.InsertNode(New, InsertPos);
|
| /src/external/apache2/llvm/include/ |
| Makefile | 177 Nodes.td \
216 clang/AST/StmtNodes.inc|-gen-clang-stmt-nodes
223 clang/AST/DeclNodes.inc|-gen-clang-decl-nodes
227 clang/AST/CommentNodes.inc|-gen-clang-comment-nodes
241 CLANG_TABLEGEN_INCLUDES.Nodes.td= -I${CLANG_SRCDIR}/include
242 CLANG_TABLEGEN_OUTPUT.Nodes.td= \
244 clang/Tooling/Syntax/Nodes.inc|-gen-clang-syntax-node-list
247 clang/AST/TypeNodes.inc|-gen-clang-type-nodes
|
| /src/external/apache2/llvm/dist/clang/include/clang/StaticAnalyzer/Core/PathSensitive/ |
| ExplodedGraph.h | 78 /// common case in an ExplodedGraph, where most nodes have only one
82 /// empty and no nodes may be added.
86 // for the nodes in the group.
269 /// Trivial nodes may be skipped while printing exploded graph.
317 /// The nodes in the simulation graph which have been
321 /// Nodes - The nodes in the graph.
322 llvm::FoldingSet<ExplodedNode> Nodes;
324 /// BVC - Allocator and context for allocating nodes and their predecessor
328 /// NumNodes - The number of nodes in the graph
[all...] |
| /src/external/apache2/llvm/dist/llvm/lib/Target/X86/ |
| ImmutableGraph.h | 11 /// implemented as two arrays: one containing nodes, and one containing edges.
14 /// 2. Operations on sets of nodes/edges are efficient, and representations of
69 // Nodes are allocated sequentially. Edges for a node are stored together.
80 ImmutableGraph(std::unique_ptr<Node[]> Nodes, std::unique_ptr<Edge[]> Edges,
82 : Nodes(std::move(Nodes)), Edges(std::move(Edges)), NodesSize(NodesSize),
90 ArrayRef<Node> nodes() const { return makeArrayRef(Nodes.get(), NodesSize); } function in class:llvm::ImmutableGraph
91 const Node *nodes_begin() const { return nodes().begin(); }
92 const Node *nodes_end() const { return nodes().end();
[all...] |
| X86LoadValueInjectionLoadHardening.cpp | 108 typedef int (*OptimizeCutT)(unsigned int *Nodes, unsigned int NodesSize,
123 MachineGadgetGraph(std::unique_ptr<Node[]> Nodes,
126 : GraphT(std::move(Nodes), std::move(Edges), NodesSize, EdgesSize),
360 // each interesting value to `Nodes`
537 LLVM_DEBUG(dbgs() << "Found " << G->nodes_size() << " nodes\n");
562 for (const Node &RootN : G.nodes()) {
566 // Find all of the nodes that are CFG-reachable from RootN using DFS
627 auto Nodes = std::make_unique<unsigned int[]>(Graph->nodes_size() +
632 for (const Node &N : Graph->nodes()) {
633 Nodes[Graph->getNodeIndex(N)] = Graph->getEdgeIndex(*N.edges_begin())
[all...] |
| /src/external/apache2/llvm/dist/llvm/tools/llvm-cfi-verify/lib/ |
| FileAnalysis.cpp | 309 assert(Graph.OrphanedNodes.empty() && "Orphaned nodes should be empty.");
335 std::vector<uint64_t> Nodes = Graph.flattenAddress(Node);
336 for (auto I = Nodes.rbegin() + 1, E = Nodes.rend(); I != E; ++I) {
|
| /src/external/apache2/llvm/dist/llvm/tools/llvm-mca/Views/ |
| BottleneckAnalysis.h | 60 /// A dependency graph is used internally to track dependencies between nodes.
61 /// Nodes of the graph represent instructions from the input assembly sequence,
73 /// At the end of simulation, costs are propagated to nodes through the edges of
75 /// set of nodes with no predecessors) to a leaf node is reported as critical
218 // to guarantee that the graph stays acyclic. To this end, extra nodes are
232 SmallVector<DGNode, 16> Nodes;
250 DependencyGraph(unsigned Size) : Nodes(Size) {}
|
| /src/external/apache2/llvm/dist/clang/lib/ASTMatchers/ |
| ASTMatchFinder.cpp | 9 // Implements an algorithm to efficiently search for matches on AST nodes.
12 // The general idea is to visit all AST nodes with a RecursiveASTVisitor,
57 // bound nodes before the matcher was executed.
59 // We currently only memoize on nodes whose pointers identify the
60 // nodes (\c Stmt and \c Decl, but not \c QualType or \c TypeLoc).
63 // FIXME: Benchmark whether memoization of non-pointer typed nodes
79 // Used to store the result of a match and possibly bound nodes.
82 BoundNodesTreeBuilder Nodes;
138 // It's OK to always overwrite the bound nodes, as if there was
582 // For AST-nodes that don't have an identity, we can't memoize
[all...] |
| /src/external/apache2/llvm/dist/llvm/include/llvm/CodeGen/ |
| MachinePipeliner.h | 35 // 2) Order the nodes (instructions) by priority based upon the heuristics
37 // 3) Attempt to schedule the nodes in the specified order using the MII.
309 /// A NodeSet contains a set of SUnit DAG nodes with additional information
312 SetVector<SUnit *> Nodes;
325 NodeSet(iterator S, iterator E) : Nodes(S, E), HasRecurrence(true) {
327 for (unsigned i = 0, e = Nodes.size(); i < e; ++i) {
329 for (const SDep &Succ : Nodes[i]->Succs) {
331 if (!Nodes.count(SuccSUnit))
345 bool insert(SUnit *SU) { return Nodes.insert(SU); }
347 void insert(iterator S, iterator E) { Nodes.insert(S, E);
[all...] |
| /src/external/apache2/llvm/dist/llvm/lib/Transforms/Scalar/ |
| StructurizeCFG.cpp | 96 // the Nodes set.
101 // This wraps a set of Nodes into the iterator, so we know which edges to
108 SmallDenseSet<RegionNode *> *Nodes;
111 WrappedSuccIterator(BaseSuccIterator It, SmallDenseSet<RegionNode *> *Nodes)
112 : iterator_adaptor_base(It), Nodes(Nodes) {}
114 NodeRef operator*() const { return {*I, Nodes}; }
236 /// consist of a network of PHI nodes where the true incoming values expresses
369 /// Build up the general order of nodes, by performing a topological sort of the
370 /// parent region's nodes, while ensuring that there is no outer cycle nod
[all...] |
| /src/external/apache2/llvm/dist/clang/lib/Tooling/ASTDiff/ |
| ASTDiff.cpp | 31 /// Maps nodes of the left tree to ones on the right, and vice versa.
65 /// Matches nodes one-by-one based on their similarity.
83 // Returns false if the nodes must not be mached.
86 // Returns true if the nodes' parents are matched.
90 // subtrees, but only if both have fewer nodes than MaxSize.
93 // Computes the ratio of common descendants between the two nodes.
103 // Tries to match any yet unmapped nodes, in a bottom-up fashion.
132 /// Nodes in preorder.
133 std::vector<Node> Nodes;
139 int getSize() const { return Nodes.size();
[all...] |
| /src/external/apache2/llvm/dist/clang/lib/Tooling/Syntax/ |
| BuildTree.cpp | 29 #include "clang/Tooling/Syntax/Nodes.h"
317 /// Maintains a mapping from AST to syntax tree nodes. This class will get more
318 /// complicated as we support more kinds of AST nodes, e.g. TypeLocs.
326 bool Added = Nodes.insert({From, To}).second;
340 syntax::Tree *find(ASTPtr P) const { return Nodes.lookup(P); }
347 llvm::DenseMap<ASTPtr, syntax::Tree *> Nodes;
355 /// At each point of the traversal we maintain a list of pending nodes.
356 /// Initially all tokens are added as pending nodes. When processing a clang AST
359 /// - assign roles to all pending child nodes with 'markChild' and
361 /// - replace the child nodes with the new syntax node in the pending lis
[all...] |
