HomeSort by: relevance | last modified time | path
    Searched refs:Dependence (Results 1 - 16 of 16) sorted by relevancy

  /src/external/apache2/llvm/dist/clang/include/clang/AST/
DependenceFlags.h 104 // A combined space of all dependence concepts for all node types.
105 // Used when aggregating dependence of nodes of different types.
106 class Dependence {
131 // Dependence that is propagated syntactically, regardless of semantics.
137 Dependence() : V(None) {}
139 Dependence(TypeDependence D)
146 Dependence(ExprDependence D)
153 Dependence(NestedNameSpecifierDependence D) :
159 Dependence(TemplateArgumentDependence D)
165 Dependence(TemplateNameDependence D
    [all...]
Type.h 1504 unsigned Dependence : llvm::BitWidth<TypeDependence>;
1818 Type(TypeClass tc, QualType canon, TypeDependence Dependence)
1826 TypeBits.Dependence = static_cast<unsigned>(Dependence);
1837 TypeBits.Dependence = static_cast<unsigned>(D);
2158 return static_cast<TypeDependence>(TypeBits.Dependence);
3801 TypeDependence Dependence, ExtInfo Info)
3802 : Type(tc, Canonical, Dependence), ResultType(res) {
5360 QualType Canonical, TypeDependence Dependence)
5361 : Type(tc, Canonical, Dependence) {
    [all...]
  /src/external/apache2/llvm/dist/llvm/include/llvm/Analysis/
DependenceAnalysis.h 12 // Practical Dependence Testing
16 // There's a single entry point that analyzes the dependence between a pair
17 // of memory references in a function, returning either NULL, for no dependence,
18 // or a more-or-less detailed description of the dependence between them.
21 // passes because there's a useful separation of concerns. A dependence exists
34 // Return a set of more precise dependences instead of just one dependence
57 /// Dependence - This class represents a dependence between two memory
60 /// determine anything beyond the existence of a dependence; that is, it
61 /// represents a confused dependence (see also FullDependence). In mos
    [all...]
LoopAccessAnalysis.h 9 // This file defines the interface for the loop memory dependence framework that
57 /// Note: This class will compute a conservative dependence for access to
94 /// Type to keep track of the status of the dependence check. The order of
108 struct Dependence {
109 /// The type of the dependence.
111 // No dependence.
118 // read and write of A[i]), LAA will locally deem the dependence "safe"
123 // queried and the dependence list is complete.
140 /// Index of the source of the dependence in the InstMap vector.
142 /// Index of the destination of the dependence in the InstMap vector
    [all...]
DDG.h 9 // This file defines the Data-Dependence Graph (DDG).
31 /// Data Dependence Graph Node
216 /// a memory dependence based on the result of DependenceAnalysis.
252 /// Return true if this is a memory dependence edge, and false otherwise.
264 /// variations of data dependence graphs.
267 using DependenceList = SmallVector<std::unique_ptr<Dependence>, 1>;
289 /// if a dependence exists, and false otherwise.
293 /// Return a string representing the type of dependence that the dependence
295 /// that there is a memory dependence between the given two nodes
    [all...]
  /src/external/apache2/llvm/dist/llvm/lib/Analysis/
DependenceAnalysis.cpp 13 // Practical Dependence Testing
17 // There's a single entry point that analyzes the dependence between a pair
18 // of memory references in a function, returning either NULL, for no dependence,
19 // or a more-or-less detailed description of the dependence between them.
26 // Since Clang linearizes some array subscripts, the dependence
119 "dependence vectors for languages that allow the subscript of one "
136 "Dependence Analysis", true, true)
140 INITIALIZE_PASS_END(DependenceAnalysisWrapperPass, "da", "Dependence Analysis",
173 // Used to test the dependence analyzer.
212 OS << "'Dependence Analysis' for function '" << F.getName() << "':\n"
    [all...]
LoopAccessAnalysis.cpp 9 // The implementation for the loop memory dependence that was originally
342 // dependence. Not grouping the checks for a[i] and a[i + 9000] allows
501 /// dependence checking.
533 /// If we can check this access, this also adds it to a dependence set and
567 /// We decided that no dependence analysis would be used. Reset the state.
588 /// List of accesses that need a further dependence check.
602 /// dependence check.
678 // The id of the dependence set.
688 // Each access has its own dependence set.
720 // We assign consecutive id to access from different dependence sets
    [all...]
DependenceGraphBuilder.cpp 9 // of dependence graphs such as DDG and PDG.
23 STATISTIC(TotalGraphs, "Number of dependence graphs created.");
25 STATISTIC(TotalMemoryEdges, "Number of memory dependence edges created.");
31 "Number of times the source and sink of dependence was reversed to "
303 // If we have a dependence with its left-most non-'=' direction
305 // the source of the dependence cannot occur after the sink. For
343 if (D->getDirection(Level) == Dependence::DVEntry::EQ)
345 else if (D->getDirection(Level) == Dependence::DVEntry::GT) {
350 } else if (D->getDirection(Level) == Dependence::DVEntry::LT)
LoopCacheAnalysis.cpp 218 std::unique_ptr<Dependence> D =
222 LLVM_DEBUG(dbgs().indent(2) << "No temporal reuse: no dependence\n");
231 // Check the dependence distance at every loop level. There is temporal reuse
  /src/external/apache2/llvm/dist/llvm/lib/Transforms/Utils/
LoopUnrollAndJam.cpp 658 bool Sequentialized, Dependence *D) {
664 if (JammedDir == Dependence::DVEntry::LT)
667 if (JammedDir & Dependence::DVEntry::GT)
676 bool Sequentialized, Dependence *D) {
681 if (JammedDir == Dependence::DVEntry::GT)
684 if (JammedDir & Dependence::DVEntry::LT)
717 // iteration of the chosen unroll level. That is, a GT dependence becomes a GE
718 // dependence (or EQ, if we fully unrolled the loop) at the loop's position:
722 std::unique_ptr<Dependence> D = DI.depends(Src, Dst, true);
739 if (!(D->getDirection(CurLoopDepth) & Dependence::DVEntry::EQ)
    [all...]
  /src/external/apache2/llvm/dist/llvm/lib/CodeGen/
ImplicitNullChecks.cpp 210 /// instructions in \p InstsSeenSoFar to before them. Set \p Dependence to a
214 MachineBasicBlock *NullSucc, MachineInstr *&Dependence);
509 // The dependence does not clobber live-ins in NullSucc block.
516 MachineInstr *&Dependence) {
522 Dependence = nullptr;
547 Dependence = DependenceMI;
684 MachineInstr *Dependence;
689 canHoistInst(&MI, InstsSeenSoFar, NullSucc, Dependence)) {
691 NullSucc, Dependence);
  /src/external/apache2/llvm/dist/llvm/lib/Target/Hexagon/
HexagonVLIWPacketizer.cpp 15 // prune the dependence.
225 // These instructions confuse the dependence analysis. Consider:
229 // Here, Insn 1 will result in the dependence graph not emitting an output
230 // dependence between Insn 0 and Insn 2. This can lead to incorrect
306 // Check for LR dependence.
532 // That is, ignore anti dependences, and make sure the only data dependence
770 if (&TempMI == &PacketMI) // We don't want to check PacketMI for dependence.
1035 Dependence = false;
1202 // The dependence graph may not include edges between dead definitions,
1335 Dependence = hasDeadDependence(I, J) || hasControlDependence(I, J)
    [all...]
HexagonVLIWPacketizer.h 43 // Check if there is a dependence between some instruction already in this
45 bool Dependence;
47 // Only check for dependence if there are resources available to
53 // Track MIs with ignored dependence.
  /src/external/apache2/llvm/dist/llvm/lib/Transforms/Scalar/
LoopInterchange.cpp 156 if (Dir == Dependence::DVEntry::LT ||
157 Dir == Dependence::DVEntry::LE)
159 else if (Dir == Dependence::DVEntry::GT ||
160 Dir == Dependence::DVEntry::GE)
162 else if (Dir == Dependence::DVEntry::EQ)
186 // A loop is moved from index 'from' to an index 'to'. Update the Dependence
194 // Checks if outermost non '=','S'or'I' dependence in the dependence matrix is
208 // Checks if no dependence exist in the dependency matrix in Row before Column.
475 // on the dependence matrix. Currently we select the innermost loop
    [all...]
LoopDistribute.cpp 10 // distribute loops that cannot be vectorized due to dependence cycles. It
14 // For dependence analysis, the pass uses the LoopVectorizer's
136 /// Returns whether this partition contains a dependence cycle.
160 // FIXME: We currently don't use control-dependence but simply include all
256 /// Whether this partition contains a dependence cycle.
299 /// dependence cycles.
616 /// number, we know whether any unsafe dependence crosses over a program point.
618 using Dependence = MemoryDepChecker::Dependence;
635 const SmallVectorImpl<Dependence> &Dependences)
    [all...]
LoopLoadElimination.cpp 96 /// Return true if the dependence from the store to the load has a
108 "Should be a known dependence");
112 // the dependence distance.
124 // dependence wouldn't be valid if these weren't monotonic accesses.
194 if (Dep.Type == MemoryDepChecker::Dependence::Unknown) {
208 assert(Dep.isForward() && "Needs to be a forward dependence");
256 /// LAA will perform dependence analysis here because there are two
280 // long as they both have a dependence distance of one to the load.

Completed in 60 milliseconds