return false; // B has fewer elements than A.
if (AIt.start() != BIt.start() || AIt.stop() != BIt.stop())
return false; // Interval is different.
- if (AIt.value() != BIt.value())
+ if (*AIt != *BIt)
return false; // Value at interval is different.
}
// AIt == AEnd. Check BIt is also now at end.
// [ r ]
LLVM_DEBUG(dbgs() << "- a is contained within "
<< toString(FirstOverlap));
- if (AIt.value() && AIt.value() == FirstOverlap.value())
- Result.insert(AIt.start(), AIt.stop(), AIt.value());
+ if (*AIt && *AIt == *FirstOverlap)
+ Result.insert(AIt.start(), AIt.stop(), *AIt);
} else {
// There's an overlap but `a` is not fully contained within
// `b`. Shorten any end-point intersections.
if (IntersectStart) {
LLVM_DEBUG(dbgs() << "- insert intersection of a and "
<< toString(FirstOverlap));
- if (AIt.value() && AIt.value() == FirstOverlap.value())
- Result.insert(AIt.start(), FirstOverlap.stop(), AIt.value());
+ if (*AIt && *AIt == *FirstOverlap)
+ Result.insert(AIt.start(), FirstOverlap.stop(), *AIt);
++Next;
}
// [ - a - ]
if (IntersectEnd) {
LLVM_DEBUG(dbgs() << "- insert intersection of a and "
<< toString(LastOverlap));
- if (AIt.value() && AIt.value() == LastOverlap.value())
- Result.insert(LastOverlap.start(), AIt.stop(), AIt.value());
+ if (*AIt && *AIt == *LastOverlap)
+ Result.insert(LastOverlap.start(), AIt.stop(), *AIt);
}
// Insert all intervals in map `B` that are contained within interval
Next.stop() <= AIt.stop()) {
LLVM_DEBUG(dbgs()
<< "- insert intersection of a and " << toString(Next));
- if (AIt.value() && AIt.value() == Next.value())
- Result.insert(Next.start(), Next.stop(), Next.value());
+ if (*AIt && *AIt == *Next)
+ Result.insert(Next.start(), Next.stop(), *Next);
++Next;
}
}
auto EndBitOfOverlap = FirstOverlap.stop();
FirstOverlap.setStop(StartBit);
insertMemLoc(BB, Before, Var, FirstOverlap.start(), StartBit,
- FirstOverlap.value(), VarLoc.DL);
+ *FirstOverlap, VarLoc.DL);
// Insert a new interval to represent the end part.
- FragMap.insert(EndBit, EndBitOfOverlap, FirstOverlap.value());
- insertMemLoc(BB, Before, Var, EndBit, EndBitOfOverlap,
- FirstOverlap.value(), VarLoc.DL);
+ FragMap.insert(EndBit, EndBitOfOverlap, *FirstOverlap);
+ insertMemLoc(BB, Before, Var, EndBit, EndBitOfOverlap, *FirstOverlap,
+ VarLoc.DL);
// Insert the new (middle) fragment now there is space.
FragMap.insert(StartBit, EndBit, Base);
// Split off at the intersection.
FirstOverlap.setStop(StartBit);
insertMemLoc(BB, Before, Var, FirstOverlap.start(), StartBit,
- FirstOverlap.value(), VarLoc.DL);
+ *FirstOverlap, VarLoc.DL);
}
// [ - f - ]
// [ - i - ]
LLVM_DEBUG(dbgs() << "- Intersect interval at end\n");
// Split off at the intersection.
LastOverlap.setStart(EndBit);
- insertMemLoc(BB, Before, Var, EndBit, LastOverlap.stop(),
- LastOverlap.value(), VarLoc.DL);
+ insertMemLoc(BB, Before, Var, EndBit, LastOverlap.stop(), *LastOverlap,
+ VarLoc.DL);
}
LLVM_DEBUG(dbgs() << "- Erase intervals contained within\n");
// Copy the fragment info over from the value-expression to the new
// DIExpression.
if (auto OptFragInfo = Source->getExpression()->getFragmentInfo()) {
- auto FragInfo = OptFragInfo.value();
+ auto FragInfo = *OptFragInfo;
Expr = *DIExpression::createFragmentExpression(
Expr, FragInfo.OffsetInBits, FragInfo.SizeInBits);
}
auto R = DIExpression::createFragmentExpression(DIE, Frag->OffsetInBits,
Frag->SizeInBits);
assert(R && "unexpected createFragmentExpression failure");
- DIE = R.value();
+ DIE = *R;
}
SmallVector<uint64_t, 3> Ops;
if (Info.OffsetInBits)
StoreInst *NewStore =
Builder.CreateStore(DataParam, PtrParam, /*IsVolatile*/ false);
if (AlignOpt.has_value())
- NewStore->setAlignment(AlignOpt.value());
+ NewStore->setAlignment(*AlignOpt);
NewMemoryInst = NewStore;
} else
NewMemoryInst = Builder.CreateMaskedStore(
LoadInst *NewLoad =
Builder.CreateLoad(VPI.getType(), PtrParam, /*IsVolatile*/ false);
if (AlignOpt.has_value())
- NewLoad->setAlignment(AlignOpt.value());
+ NewLoad->setAlignment(*AlignOpt);
NewMemoryInst = NewLoad;
} else
NewMemoryInst = Builder.CreateMaskedLoad(
if (IrrLoopHeaderWeight && IsStandalone) {
if (Indexes) OS << '\t';
- OS.indent(2) << "; Irreducible loop header weight: "
- << IrrLoopHeaderWeight.value() << '\n';
+ OS.indent(2) << "; Irreducible loop header weight: " << *IrrLoopHeaderWeight
+ << '\n';
}
}
// We don't want to proceed further for cold functions
// or functions of unknown hotness. Lukewarm functions have no prefix.
std::optional<StringRef> SectionPrefix = MF.getFunction().getSectionPrefix();
- if (SectionPrefix && (SectionPrefix.value().equals("unlikely") ||
- SectionPrefix.value().equals("unknown"))) {
+ if (SectionPrefix &&
+ (*SectionPrefix == "unlikely" || *SectionPrefix == "unknown")) {
return false;
}
const TargetRegisterClass *RC) {
// If the init register is not undef, try and find an existing phi.
if (InitReg) {
- auto I = Phis.find({LoopReg, InitReg.value()});
+ auto I = Phis.find({LoopReg, *InitReg});
if (I != Phis.end())
return I->second;
} else {
return R;
// Found a phi taking undef as input, so rewrite it to take InitReg.
MachineInstr *MI = MRI.getVRegDef(R);
- MI->getOperand(1).setReg(InitReg.value());
- Phis.insert({{LoopReg, InitReg.value()}, R});
+ MI->getOperand(1).setReg(*InitReg);
+ Phis.insert({{LoopReg, *InitReg}, R});
const TargetRegisterClass *ConstrainRegClass =
- MRI.constrainRegClass(R, MRI.getRegClass(InitReg.value()));
+ MRI.constrainRegClass(R, MRI.getRegClass(*InitReg));
assert(ConstrainRegClass && "Expected a valid constrained register class!");
(void)ConstrainRegClass;
UndefPhis.erase(I);
EmitAndPrintRemark(ORE, ORmissL);
return false;
}
- IPredCost += Scaled64::get(ILatency.value());
- INonPredCost += Scaled64::get(ILatency.value());
+ IPredCost += Scaled64::get(*ILatency);
+ INonPredCost += Scaled64::get(*ILatency);
// For a select that can be converted to branch,
// compute its cost as a branch (non-predicated cost).
assert(areOpcodesEqualOrInverse(Root.getOpcode(), Prev.getOpcode()) &&
"Incorrectly matched pattern");
unsigned AssocCommutOpcode = Root.getOpcode();
- unsigned InverseOpcode = getInverseOpcode(Root.getOpcode()).value();
+ unsigned InverseOpcode = *getInverseOpcode(Root.getOpcode());
if (!AssocCommutRoot)
std::swap(AssocCommutOpcode, InverseOpcode);
C2->ConstInt->getValue(), ConstCand->ConstInt->getValue());
if (Diff) {
const InstructionCost ImmCosts =
- TTI->getIntImmCodeSizeCost(Opcode, OpndIdx, Diff.value(), Ty);
+ TTI->getIntImmCodeSizeCost(Opcode, OpndIdx, *Diff, Ty);
Cost -= ImmCosts;
- LLVM_DEBUG(dbgs() << "Offset " << Diff.value() << " "
+ LLVM_DEBUG(dbgs() << "Offset " << *Diff << " "
<< "has penalty: " << ImmCosts << "\n"
<< "Adjusted cost: " << Cost << "\n");
}
OS << "<";
if (Options.AllowPRE != std::nullopt)
- OS << (Options.AllowPRE.value() ? "" : "no-") << "pre;";
+ OS << (*Options.AllowPRE ? "" : "no-") << "pre;";
if (Options.AllowLoadPRE != std::nullopt)
- OS << (Options.AllowLoadPRE.value() ? "" : "no-") << "load-pre;";
+ OS << (*Options.AllowLoadPRE ? "" : "no-") << "load-pre;";
if (Options.AllowLoadPRESplitBackedge != std::nullopt)
- OS << (Options.AllowLoadPRESplitBackedge.value() ? "" : "no-")
+ OS << (*Options.AllowLoadPRESplitBackedge ? "" : "no-")
<< "split-backedge-load-pre;";
if (Options.AllowMemDep != std::nullopt)
- OS << (Options.AllowMemDep.value() ? "" : "no-") << "memdep";
+ OS << (*Options.AllowMemDep ? "" : "no-") << "memdep";
OS << ">";
}
return std::nullopt;
if (!R1)
return R2;
- auto &R1Value = R1.value();
+ auto &R1Value = *R1;
// We never return empty ranges from this function, and R1 is supposed to be
// a result of intersection. Thus, R1 is never empty.
assert(!R1Value.isEmpty(SE, /* IsSigned */ true) &&
return std::nullopt;
if (!R1)
return R2;
- auto &R1Value = R1.value();
+ auto &R1Value = *R1;
// We never return empty ranges from this function, and R1 is supposed to be
// a result of intersection. Thus, R1 is never empty.
assert(!R1Value.isEmpty(SE, /* IsSigned */ false) &&
auto Result = IRC.computeSafeIterationSpace(SE, IndVar,
LS.IsSignedPredicate);
if (Result) {
- auto MaybeSafeIterRange =
- IntersectRange(SE, SafeIterRange, Result.value());
+ auto MaybeSafeIterRange = IntersectRange(SE, SafeIterRange, *Result);
if (MaybeSafeIterRange) {
- assert(!MaybeSafeIterRange.value().isEmpty(SE, LS.IsSignedPredicate) &&
+ assert(!MaybeSafeIterRange->isEmpty(SE, LS.IsSignedPredicate) &&
"We should never return empty ranges!");
RangeChecksToEliminate.push_back(IRC);
- SafeIterRange = MaybeSafeIterRange.value();
+ SafeIterRange = *MaybeSafeIterRange;
}
}
}
if (!SafeIterRange)
return false;
- LoopConstrainer LC(*L, LI, LPMAddNewLoop, LS, SE, DT, SafeIterRange.value());
+ LoopConstrainer LC(*L, LI, LPMAddNewLoop, LS, SE, DT, *SafeIterRange);
bool Changed = LC.run();
if (Changed) {
: LLVMLoopDistributeFollowupCoincident});
if (PartitionID) {
Loop *NewLoop = Part->getDistributedLoop();
- NewLoop->setLoopID(PartitionID.value());
+ NewLoop->setLoopID(*PartitionID);
}
}
};
// The unversioned loop will not be changed, so we inherit all attributes
// from the original loop, but remove the loop distribution metadata to
// avoid to distribute it again.
- MDNode *UnversionedLoopID =
- makeFollowupLoopID(OrigLoopID,
- {LLVMLoopDistributeFollowupAll,
- LLVMLoopDistributeFollowupFallback},
- "llvm.loop.distribute.", true)
- .value();
+ MDNode *UnversionedLoopID = *makeFollowupLoopID(
+ OrigLoopID,
+ {LLVMLoopDistributeFollowupAll, LLVMLoopDistributeFollowupFallback},
+ "llvm.loop.distribute.", true);
LVer.getNonVersionedLoop()->setLoopID(UnversionedLoopID);
}
// anything where the alignment isn't at least the element size.
assert((StoreAlign && LoadAlign) &&
"Expect unordered load/store to have align.");
- if (StoreAlign.value() < StoreSize || LoadAlign.value() < StoreSize)
+ if (*StoreAlign < StoreSize || *LoadAlign < StoreSize)
return Changed;
// If the element.atomic memcpy is not lowered into explicit
// Note that unordered atomic loads/stores are *required* by the spec to
// have an alignment but non-atomic loads/stores may not.
NewCall = Builder.CreateElementUnorderedAtomicMemCpy(
- StoreBasePtr, StoreAlign.value(), LoadBasePtr, LoadAlign.value(),
- NumBytes, StoreSize, AATags.TBAA, AATags.TBAAStruct, AATags.Scope,
- AATags.NoAlias);
+ StoreBasePtr, *StoreAlign, LoadBasePtr, *LoadAlign, NumBytes, StoreSize,
+ AATags.TBAA, AATags.TBAAStruct, AATags.Scope, AATags.NoAlias);
}
NewCall->setDebugLoc(TheStore->getDebugLoc());
// less DWARF ops than an iteration count-based expression.
if (std::optional<APInt> Offset =
SE.computeConstantDifference(DVIRec.SCEVs[i], SCEVInductionVar)) {
- if (Offset.value().getMinSignedBits() <= 64)
- SalvageExpr->createOffsetExpr(Offset.value().getSExtValue(),
- LSRInductionVar);
+ if (Offset->getMinSignedBits() <= 64)
+ SalvageExpr->createOffsetExpr(Offset->getSExtValue(), LSRInductionVar);
} else if (!SalvageExpr->createIterCountExpr(DVIRec.SCEVs[i], IterCountExpr,
SE))
return false;
OrigOuterLoopID, {LLVMLoopUnrollAndJamFollowupAll,
LLVMLoopUnrollAndJamFollowupRemainderInner});
if (NewInnerEpilogueLoopID)
- SubLoop->setLoopID(NewInnerEpilogueLoopID.value());
+ SubLoop->setLoopID(*NewInnerEpilogueLoopID);
// Find trip count and trip multiple
BasicBlock *Latch = L->getLoopLatch();
OrigOuterLoopID, {LLVMLoopUnrollAndJamFollowupAll,
LLVMLoopUnrollAndJamFollowupRemainderOuter});
if (NewOuterEpilogueLoopID)
- EpilogueOuterLoop->setLoopID(NewOuterEpilogueLoopID.value());
+ EpilogueOuterLoop->setLoopID(*NewOuterEpilogueLoopID);
}
std::optional<MDNode *> NewInnerLoopID =
makeFollowupLoopID(OrigOuterLoopID, {LLVMLoopUnrollAndJamFollowupAll,
LLVMLoopUnrollAndJamFollowupInner});
if (NewInnerLoopID)
- SubLoop->setLoopID(NewInnerLoopID.value());
+ SubLoop->setLoopID(*NewInnerLoopID);
else
SubLoop->setLoopID(OrigSubLoopID);
OrigOuterLoopID,
{LLVMLoopUnrollAndJamFollowupAll, LLVMLoopUnrollAndJamFollowupOuter});
if (NewOuterLoopID) {
- L->setLoopID(NewOuterLoopID.value());
+ L->setLoopID(*NewOuterLoopID);
// Do not setLoopAlreadyUnrolled if a followup was given.
return UnrollResult;
makeFollowupLoopID(OrigLoopID, {LLVMLoopUnrollFollowupAll,
LLVMLoopUnrollFollowupRemainder});
if (RemainderLoopID)
- RemainderLoop->setLoopID(RemainderLoopID.value());
+ RemainderLoop->setLoopID(*RemainderLoopID);
}
if (UnrollResult != LoopUnrollResult::FullyUnrolled) {
makeFollowupLoopID(OrigLoopID, {LLVMLoopUnrollFollowupAll,
LLVMLoopUnrollFollowupUnrolled});
if (NewLoopID) {
- L->setLoopID(NewLoopID.value());
+ L->setLoopID(*NewLoopID);
// Do not setLoopAlreadyUnrolled if loop attributes have been specified
// explicitly.
OS, MapClassName2PassName);
OS << "<";
if (UnrollOpts.AllowPartial != std::nullopt)
- OS << (UnrollOpts.AllowPartial.value() ? "" : "no-") << "partial;";
+ OS << (*UnrollOpts.AllowPartial ? "" : "no-") << "partial;";
if (UnrollOpts.AllowPeeling != std::nullopt)
- OS << (UnrollOpts.AllowPeeling.value() ? "" : "no-") << "peeling;";
+ OS << (*UnrollOpts.AllowPeeling ? "" : "no-") << "peeling;";
if (UnrollOpts.AllowRuntime != std::nullopt)
- OS << (UnrollOpts.AllowRuntime.value() ? "" : "no-") << "runtime;";
+ OS << (*UnrollOpts.AllowRuntime ? "" : "no-") << "runtime;";
if (UnrollOpts.AllowUpperBound != std::nullopt)
- OS << (UnrollOpts.AllowUpperBound.value() ? "" : "no-") << "upperbound;";
+ OS << (*UnrollOpts.AllowUpperBound ? "" : "no-") << "upperbound;";
if (UnrollOpts.AllowProfileBasedPeeling != std::nullopt)
- OS << (UnrollOpts.AllowProfileBasedPeeling.value() ? "" : "no-")
+ OS << (*UnrollOpts.AllowProfileBasedPeeling ? "" : "no-")
<< "profile-peeling;";
if (UnrollOpts.FullUnrollMaxCount != std::nullopt)
OS << "full-unroll-max=" << UnrollOpts.FullUnrollMaxCount << ";";