Lines Matching defs:Proposed

180 ///    'Proposed'.
321   /// In theory @p Existing and @p Proposed are symmetric, but the
323   /// Existing must have #Unused defined (use case 1) and @p Proposed must have
331   /// @param Proposed One of the knowledges with #Occupied defined.
338                             const Knowledge &Proposed,
342     assert(!Proposed.Occupied.is_null());
345     if (!Existing.Occupied.is_null() && !Proposed.Unused.is_null()) {
347       auto ProposedUniverse = Proposed.Occupied.unite(Proposed.Unused);
353     // Do the Existing and Proposed lifetimes conflict?
373     // Proposed.Known and Existing.Unused such that they match as a common known
375     // Existing.Unused may match with an unknown Proposed.Occupied because these
377     auto ProposedOccupiedAnyVal = makeUnknownForDomain(Proposed.Occupied);
378     auto ProposedValues = Proposed.Known.unite(ProposedOccupiedAnyVal);
386     // Any Proposed.Occupied must either have a match between the known values
389     if (!Proposed.Occupied.is_subset(Matches)) {
391         auto Conflicting = Proposed.Occupied.subtract(Matches);
395             Proposed.Known.intersect_domain(Conflicting);
397         OS->indent(Indent) << "Proposed lifetime conflicting with Existing's\n";
404               << "Proposed Known:       " << ProposedConflictingKnown << "\n";
409     // Do the writes in Existing conflict with occupied values in Proposed?
413     // Proposed.Unused (they never conflict) and then see whether the written
414     // value is already in Proposed.Known. If there are multiple known values
429         convertZoneToTimepoints(Proposed.Occupied, true, false);
431         convertZoneToTimepoints(Proposed.Known, isl::dim::in, true, false);
449             << "Proposed a lifetime where there is an Existing write into it\n";
454               << "Proposed conflicting known:  " << ProposedConflictingKnown
460     // Do the writes in Proposed conflict with occupied values in Existing?
466     auto ProposedWrittenDomain = Proposed.Written.domain();
467     auto KnownIdentical = ExistingKnownDefs.intersect(Proposed.Written);
476             Proposed.Written.intersect_domain(Conflicting);
478         OS->indent(Indent) << "Proposed writes into range used by Existing\n";
479         OS->indent(Indent) << "Proposed conflicting writes: "
489     // Does Proposed write at the same time as Existing already does (order of
493         Existing.Written.domain().intersect(Proposed.Written.domain());
495     auto ProposedKnownWritten = filterKnownValInst(Proposed.Written);
505             Proposed.Written.intersect_domain(Conflicting);
507         OS->indent(Indent) << "Proposed writes at the same time as an already "
515               << "Proposed write:     " << ProposedConflictingWritten << "\n";
550   bool isConflicting(const Knowledge &Proposed) {
553     return Knowledge::isConflicting(Zone, Proposed, OS, 4);
739     Knowledge Proposed(EltZone, {}, filterKnownValInst(EltKnown), DefEltSched);
740     if (isConflicting(Proposed))
747              std::move(Lifetime), std::move(Proposed));
752   void applyLifetime(Knowledge Proposed) {
753     Zone.learnFrom(std::move(Proposed));
769   /// @param Proposed  Mapping constraints for reporting.
772                 Knowledge Proposed) {
788     applyLifetime(Proposed);
950     Knowledge Proposed(Occupied, {}, EltLifetimeInst, Written);
951     if (isConflicting(Proposed))
955            std::move(Lifetime), std::move(Proposed));
972   /// @param Proposed    Mapping constraints for reporting.
975               Knowledge Proposed) {
997     applyLifetime(Proposed);
1524   Knowledge Proposed(std::move(ProposedOccupied), std::move(ProposedUnused),
1527   return Knowledge::isConflicting(Existing, Proposed, OS, Indent);