| /external/llvm/include/llvm/CodeGen/ |
| GCMetadata.h | 19 // - Stack offsets for GC roots, as specified by calls to llvm.gcroot
21 // As a refinement, liveness analysis calculates the set of live roots at each
23 // generator, so all roots are assumed live.
83 std::vector<GCRoot> Roots;
93 // The bit vector is the more compact representation where >3.2% of roots
112 Roots.push_back(GCRoot(Num, Metadata));
117 return Roots.erase(position);
138 /// roots_begin/roots_end - Iterators for all roots in the function.
140 roots_iterator roots_begin() { return Roots.begin(); }
141 roots_iterator roots_end() { return Roots.end();
[all...] |
| MachineDominators.h | 29 this->Roots.push_back(MBB);
|
| /external/llvm/include/llvm/Analysis/ |
| DominanceFrontier.h | 41 std::vector<BlockT *> Roots;
52 return Roots;
56 assert(Roots.size() == 1 && "Should always have entry node!");
57 return Roots[0];
127 this->Roots = DT.getRoots();
128 assert(this->Roots.size() == 1 &&
130 calculate(DT, DT[this->Roots[0]]);
|
| /external/llvm/lib/CodeGen/ |
| ShadowStackGCLowering.cpp | 31 /// roots.
39 /// Roots - GC roots in the current function. Each is a pair of the
41 std::vector<std::pair<CallInst *, AllocaInst *>> Roots;
198 for (unsigned I = 0; I != Roots.size(); ++I) {
199 Constant *C = cast<Constant>(Roots[I].first->getArgOperand(1));
209 ConstantInt::get(Int32Ty, Roots.size(), false),
249 for (size_t I = 0; I != Roots.size(); I++)
250 EltTys.push_back(Roots[I].second->getAllocatedType());
269 // int32_t NumRoots; // Number of roots in stack frame
[all...] |
| TargetRegisterInfo.cpp | 70 MCRegUnitRootIterator Roots(Unit, TRI);
71 assert(Roots.isValid() && "Unit has no roots.");
72 OS << TRI->getName(*Roots);
73 for (++Roots; Roots.isValid(); ++Roots)
74 OS << '~' << TRI->getName(*Roots);
|
| GCRootLowering.cpp | 108 // action. The default for roots is no action.
152 static bool InsertRootInitializers(Function &F, AllocaInst **Roots,
170 for (AllocaInst **I = Roots, **E = Roots + Count; I != E; ++I)
206 SmallVector<AllocaInst *, 32> Roots;
236 Roots.push_back(
249 if (Roots.size())
250 MadeChange |= InsertRootInitializers(F, Roots.begin(), Roots.size());
350 // Find the concrete stack offsets for all roots (stack slots
[all...] |
| LiveIntervalAnalysis.cpp | 255 // The physregs aliasing Unit are the roots and their super-registers.
256 // Create all values as dead defs before extending to uses. Note that roots
258 // idempotent. It is very rare for a register unit to have multiple roots, so
260 for (MCRegUnitRootIterator Roots(Unit, TRI); Roots.isValid(); ++Roots) {
261 for (MCSuperRegIterator Supers(*Roots, TRI, /*IncludeSelf=*/true);
270 for (MCRegUnitRootIterator Roots(Unit, TRI); Roots.isValid(); ++Roots) {
[all...] |
| /external/llvm/lib/Transforms/Scalar/ |
| Float2Int.cpp | 65 void findRoots(Function &F, SmallPtrSet<Instruction*,8> &Roots);
70 void walkBackwards(const SmallPtrSetImpl<Instruction*> &Roots);
77 SmallPtrSet<Instruction*,8> Roots;
125 // Find the roots - instructions that convert from the FP domain to
127 void Float2Int::findRoots(Function &F, SmallPtrSet<Instruction*,8> &Roots) {
133 Roots.insert(&I);
138 Roots.insert(&I);
172 // the roots. Populate "SeenInsts" with interesting
181 void Float2Int::walkBackwards(const SmallPtrSetImpl<Instruction*> &Roots) {
182 std::deque<Instruction*> Worklist(Roots.begin(), Roots.end())
[all...] |
| LoopRerollPass.cpp | 341 // ST[y1] +1 +2 <-- Roots
359 SmallInstructionVector Roots;
364 // The set of all DAG roots, and state tracking of all roots
372 /// Stage 1: Find all the DAG roots for the induction variable.
374 /// Stage 2: Validate if the found roots are valid.
388 std::map<int64_t,Instruction*> &Roots);
391 void collectInLoopUserSet(const SmallInstructionVector &Roots,
425 // The roots themselves.
615 const SmallInstructionVector &Roots,
[all...] |
| /external/llvm/utils/TableGen/ |
| CodeGenRegisters.h | 444 const CodeGenRegister *Roots[2];
451 Roots[0] = Roots[1] = nullptr;
455 assert(!(Roots[1] && !Roots[0]) && "Invalid roots array");
456 return makeArrayRef(Roots, !!Roots[0] + !!Roots[1]);
622 RegUnits.back().Roots[0] = R0
[all...] |
| RegisterInfoEmitter.cpp | [all...] |
| CodeGenRegisters.cpp | [all...] |
| /external/clang/include/clang/StaticAnalyzer/Core/PathSensitive/ |
| ExplodedGraph.h | 254 /// The roots of the simulation graph. Usually there will be only
257 /// different roots reach the same state at the same program location.
258 NodeVector Roots;
302 /// addRoot - Add an untyped node to the set of roots.
304 Roots.push_back(V);
318 unsigned num_roots() const { return Roots.size(); }
342 roots_iterator roots_begin() { return Roots.begin(); }
344 roots_iterator roots_end() { return Roots.end(); }
346 const_roots_iterator roots_begin() const { return Roots.begin(); }
348 const_roots_iterator roots_end() const { return Roots.end();
[all...] |
| /external/llvm/lib/Support/ |
| DAGDeltaAlgorithm.cpp | 66 std::vector<change_ty> Roots;
195 // Compute the roots.
199 Roots.push_back(*it);
202 std::vector<change_ty> Worklist(Roots.begin(), Roots.end());
247 llvm::errs() << "Roots: [";
248 for (std::vector<change_ty>::const_iterator it = Roots.begin(),
249 ie = Roots.end(); it != ie; ++it) {
250 if (it != Roots.begin()) llvm::errs() << ", ";
303 // The current set of changes we are minimizing, starting at the roots
[all...] |
| /external/llvm/include/llvm/Support/ |
| GenericDomTreeConstruction.h | 40 InfoRec &VInfo = DT.Info[DT.Roots[i]];
156 bool MultipleRoots = (DT.Roots.size() > 1);
168 for (unsigned i = 0, e = static_cast<unsigned>(DT.Roots.size());
170 N = DFSPass<GraphT>(DT, DT.Roots[i], N);
246 if (DT.Roots.empty()) return;
252 typename GraphT::NodeType* Root = !MultipleRoots ? DT.Roots[0] : nullptr;
|
| GenericDomTree.h | 37 std::vector<NodeT *> Roots;
40 : Roots(), IsPostDominators(isPostDom) {}
42 : Roots(std::move(Arg.Roots)),
44 Arg.Roots.clear();
47 Roots = std::move(RHS.Roots);
49 RHS.Roots.clear();
58 const std::vector<NodeT *> &getRoots() const { return Roots; }
243 this->Roots.clear()
[all...] |
| /external/eigen/bench/ |
| eig33.cpp | 48 template<typename Matrix, typename Roots>
49 inline void computeRoots(const Matrix& m, Roots& roots)
56 // eigenvalues are the roots to this equation, all guaranteed to be
62 // Construct the parameters used in classifying the roots of the equation
63 // and in solving the equation for the roots in closed form.
75 // Compute the eigenvalues by solving for the roots of the polynomial.
80 roots(0) = c2_over_3 + Scalar(2)*rho*cos_theta;
81 roots(1) = c2_over_3 - rho*(cos_theta + s_sqrt3*sin_theta);
82 roots(2) = c2_over_3 - rho*(cos_theta - s_sqrt3*sin_theta)
[all...] |
| /external/clang/lib/Basic/ |
| VirtualFileSystem.cpp | 422 /// 'roots': [
466 std::vector<Entry *> Roots; ///< The root(s) of the virtual file system.
489 /// \brief Looks up \p Path in \c Roots.
778 KeyStatusPair("roots", true),
784 // Parse configuration and 'roots'
795 if (Key == "roots") {
796 yaml::SequenceNode *Roots = dyn_cast<yaml::SequenceNode>(I->getValue());
797 if (!Roots) {
802 for (yaml::SequenceNode::iterator I = Roots->begin(), E = Roots->end()
[all...] |
| /external/llvm/lib/Transforms/Vectorize/ |
| SLPVectorizer.cpp | 366 /// Construct a vectorizable tree that starts at \p Roots, ignoring users for
368 void buildTree(ArrayRef<Value *> Roots,
403 void buildTree_rec(ArrayRef<Value *> Roots, unsigned Depth);
429 /// roots. This method calculates the cost of extracting the values.
896 void BoUpSLP::buildTree(ArrayRef<Value *> Roots,
900 if (!getSameType(Roots))
902 buildTree_rec(Roots, 0);
[all...] |
| /external/llvm/lib/Analysis/ |
| ScalarEvolution.cpp | [all...] |
