Lines Matching defs:PHI
156 /// MemoryKind::PHI: Models PHI nodes within the SCoP
159 /// llvm::Value dependences described above, PHI nodes require an additional
160 /// memory object of type MemoryKind::PHI to describe the forwarding of values
162 /// the PHI node.
166 /// %PHI = phi float [ %Val1, %IncomingBlock1 ], [ %Val2, %IncomingBlock2 ]
172 /// | %PHI.phiops = alloca float |
178 /// | store float %Val1 %PHI.phiops | | store float %Val2 %PHI.phiops |
185 /// | %PHI = load float, float* PHI.phiops |
188 /// Note that there can also be a scalar write access for %PHI if used in a
189 /// different BasicBlock, i.e. there can be a memory object %PHI.phiops as
190 /// well as a memory object %PHI.s2a.
191 PHI,
193 /// MemoryKind::ExitPHI: Models PHI nodes in the SCoP's exit block
195 /// For PHI nodes in the Scop's exit block a special memory object kind is
196 /// used. The modeling used is identical to MemoryKind::PHI, with the
281 if (Kind == MemoryKind::PHI || Kind == MemoryKind::ExitPHI ||
327 /// Is this array info modeling special PHI node memory?
329 /// During code generation of PHI nodes, there is a need for two kinds of
331 /// where the result of the PHI node is stored and later loaded from as well
332 /// as a second one where the incoming values of the PHI nodes are stored
333 /// into and reloaded when the PHI is executed. As both memories use the
334 /// original PHI node as virtual base pointer, we have this additional
335 /// attribute to distinguish the PHI node specific array modeling from the
337 bool isPHIKind() const { return Kind == MemoryKind::PHI; }
420 /// We distinguish between SCALAR, PHI and ARRAY objects.
538 /// The #BaseAddr of a memory access of kind MemoryKind::PHI or
539 /// MemoryKind::ExitPHI is the PHI node itself.
559 /// For memory accesses of kind MemoryKind::PHI or MemoryKind::ExitPHI the
560 /// access instruction of a load access is the PHI instruction. The access
561 /// instruction of a PHI-store is the incoming's block's terminator
581 /// - For accesses of kind MemoryKind::PHI or MemoryKind::ExitPHI it is the
582 /// PHI node itself (for both, READ and WRITE accesses).
731 /// Add a new incoming block/value pairs for this PHI/ExitPHI access.
733 /// @param IncomingBlock The PHI's incoming block.
734 /// @param IncomingValue The value when reaching the PHI from the @p
742 /// Return the list of possible PHI/ExitPHI values.
745 /// we cannot reliably locate the original PHI node and its incoming values
746 /// anymore. For this reason we remember these explicitly for all PHI-kind
871 /// PHI nodes may not have a unique value available that is stored, as in
960 /// Scalar accesses are accesses to MemoryKind::Value, MemoryKind::PHI or
988 /// Was this MemoryAccess detected as a special PHI node access?
990 return getOriginalKind() == MemoryKind::PHI;
993 /// Is this MemoryAccess modeling special PHI node accesses, also
995 bool isLatestPHIKind() const { return getLatestKind() == MemoryKind::PHI; }
1000 /// Was this MemoryAccess detected as the accesses of a PHI node in the
1006 /// Is this MemoryAccess modeling the accesses of a PHI node in the
1016 /// Was this access detected as one of the two PHI types?
1021 /// Does this access originate from one of the two PHI types? Can be
1225 /// Map from PHI nodes to its incoming value when coming from this
1229 /// blocks of the PHI nodes. This map ensures that there is only one write
1230 /// operation for the complete subregion. A PHI selecting the relevant value
1234 /// Map from PHI nodes to its read access in this statement.
1458 MemoryAccess *lookupPHIReadOf(PHINode *PHI) const {
1459 return PHIReads.lookup(PHI);
1462 /// Return the PHI write MemoryAccess for the incoming values from any
1465 MemoryAccess *lookupPHIWriteOf(PHINode *PHI) const {
1466 assert(isBlockStmt() || R->getExit() == PHI->getParent());
1467 return PHIWrites.lookup(PHI);
1476 /// MemoryKind::PHI if the value is a PHINode in this statement.
1732 /// As PHI nodes may have two array info objects associated, we add a flag
1733 /// that distinguishes between the PHI node specific ArrayInfo object
1857 /// Map of values to the MemoryAccess that reads a PHI.
1864 /// List of all incoming values (write MemoryAccess) of a MemoryKind::PHI or
1981 PHINode *PHI = cast<PHINode>(Access->getAccessInstruction());
1982 assert(!PHIReadAccs.count(PHI) &&
1983 "there can be just one PHI read per PHINode");
1984 PHIReadAccs[PHI] = Access;
2314 /// Get the statement to put a PHI WRITE into.
2323 /// a MemoryKind::PHI WRITE to. For this purpose, it is not strictly required