mark remainder loop can be unrolled

llvm/include/llvm/Analysis/LoopInfo.h

public:
   /// Add llvm.loop.unroll.disable to this loop's loop id metadata.
   ///
   /// Remove existing unroll metadata and add unroll disable metadata to
   /// indicate the loop has already been unrolled.  This prevents a loop
   /// from being unrolled more than is directed by a pragma if the loop
   /// unrolling pass is run more than once (which it generally is).
   void setLoopAlreadyUnrolled();
 
+  void setLoopCanBeUnrolled();
+
   /// Add llvm.loop.mustprogress to this loop's loop id metadata.
   void setLoopMustProgress();
 
   void dump() const;
   void dumpVerbose() const;
 
   /// Return the debug location of the start of this loop.
   /// This looks for a BB terminating instruction with a known debug

llvm/lib/Analysis/LoopInfo.cpp

void Loop::setLoopAlreadyUnrolled() {
   MDNode *DisableUnrollMD =
       MDNode::get(Context, MDString::get(Context, "llvm.loop.unroll.disable"));
   MDNode *LoopID = getLoopID();
   MDNode *NewLoopID = makePostTransformationMetadata(
       Context, LoopID, {"llvm.loop.unroll."}, {DisableUnrollMD});
   setLoopID(NewLoopID);
 }
 
+void Loop::setLoopCanBeUnrolled() {
+  LLVMContext &Context = getHeader()->getContext();
+
+  MDNode *EnableUnrollMD =
+      MDNode::get(Context, MDString::get(Context, "llvm.loop.unroll.enable"));
+  MDNode *LoopID = getLoopID();
+  MDNode *NewLoopID = makePostTransformationMetadata(
+      Context, LoopID, {"llvm.loop.unroll."}, {EnableUnrollMD});
+  setLoopID(NewLoopID);
+}
+
 void Loop::setLoopMustProgress() {
   LLVMContext &Context = getHeader()->getContext();
 
   MDNode *MustProgress = findOptionMDForLoop(this, "llvm.loop.mustprogress");
 
   if (MustProgress)
     return;
 

llvm/lib/Transforms/Scalar/LoopUnrollPass.cpp

if (UnrollResult == LoopUnrollResult::Unmodified)
     return LoopUnrollResult::Unmodified;
 
   if (RemainderLoop) {
     std::optional<MDNode *> RemainderLoopID =
         makeFollowupLoopID(OrigLoopID, {LLVMLoopUnrollFollowupAll,
                                         LLVMLoopUnrollFollowupRemainder});
     if (RemainderLoopID)
       RemainderLoop->setLoopID(*RemainderLoopID);
+    RemainderLoop->setLoopCanBeUnrolled();
   }
 
   if (UnrollResult != LoopUnrollResult::FullyUnrolled) {
     std::optional<MDNode *> NewLoopID =
         makeFollowupLoopID(OrigLoopID, {LLVMLoopUnrollFollowupAll,
                                         LLVMLoopUnrollFollowupUnrolled});
     if (NewLoopID) {
       L->setLoopID(*NewLoopID);