Fix wasm backend compilation on gcc 5.4: variable name cannot match class

[kripken]

Summary

gcc does not like

const Region *Region;

It wants a different name for the variable.

Is there a better convention for what name to use in such a case?

[sbc100]

Hmm. I don't know the convention. Not a huge and of "The" prefix. LGTM otherwise.

[aheejin]

I'm OK with The. Or how about changing the class name to SortRegion and leave the variable name as is? I like either way.

[aheejin]

I guess I'll just land it..?

[kripken]

Thanks aheejin!

It's been a while since I submitted a patch to LLVM - I'm not sure how landing works? Do I need to do anything?

[aheejin]

Do you have a commit access to LLVM?

[kripken]

No, I think I don't. I think someone else landed the few patches I had a few years ago.

[aheejin]

OK then I'll land this. Thank you!

llvm/trunk/lib/Target/WebAssembly/WebAssemblyCFGSort.cpp

if (!A->isEHPad() && B->isEHPad())
       return true;
 
     return A->getNumber() < B->getNumber();
   }
 };
 /// Bookkeeping for a region to help ensure that we don't mix blocks not
 /// dominated by the its header among its blocks.
 struct Entry {
-  const Region *Region;
+  const Region *TheRegion;
   unsigned NumBlocksLeft;
 
   /// List of blocks not dominated by Loop's header that are deferred until
   /// after all of Loop's blocks have been seen.
   std::vector<MachineBasicBlock *> Deferred;
 
   explicit Entry(const class Region *R)
-      : Region(R), NumBlocksLeft(R->getNumBlocks()) {}
+      : TheRegion(R), NumBlocksLeft(R->getNumBlocks()) {}
 };
 } // end anonymous namespace
 
 /// Sort the blocks, taking special care to make sure that regions are not
 /// interrupted by blocks not dominated by their header.
 /// TODO: There are many opportunities for improving the heuristics here.
 /// Explore them.
 static void SortBlocks(MachineFunction &MF, const MachineLoopInfo &MLI,
if (R) {
       // put any blocks that it doesn't dominate until we see the end of the
       // region.
       if (R->getHeader() == MBB)
         Entries.push_back(Entry(R));
       // For each active region the block is in, decrement the count. If MBB is
       // the last block in an active region, take it off the list and pick up
       // any blocks deferred because the header didn't dominate them.
       for (Entry &E : Entries)
-        if (E.Region->contains(MBB) && --E.NumBlocksLeft == 0)
+        if (E.TheRegion->contains(MBB) && --E.NumBlocksLeft == 0)
           for (auto DeferredBlock : E.Deferred)
             Ready.push(DeferredBlock);
       while (!Entries.empty() && Entries.back().NumBlocksLeft == 0)
         Entries.pop_back();
     }
     // The main topological sort logic.
     for (MachineBasicBlock *Succ : MBB->successors()) {
       // Ignore backedges.
       if (MachineLoop *SuccL = MLI.getLoopFor(Succ))
         if (SuccL->getHeader() == Succ && SuccL->contains(MBB))
           continue;
       // Decrement the predecessor count. If it's now zero, it's ready.
       if (--NumPredsLeft[Succ->getNumber()] == 0)
         Preferred.push(Succ);
     }
     // Determine the block to follow MBB. First try to find a preferred block,
     // to preserve the original block order when possible.
     MachineBasicBlock *Next = nullptr;
     while (!Preferred.empty()) {
       Next = Preferred.top();
       Preferred.pop();
       // If X isn't dominated by the top active region header, defer it until
       // that region is done.
       if (!Entries.empty() &&
-          !MDT.dominates(Entries.back().Region->getHeader(), Next)) {
+          !MDT.dominates(Entries.back().TheRegion->getHeader(), Next)) {
         Entries.back().Deferred.push_back(Next);
         Next = nullptr;
         continue;
       }
       // If Next was originally ordered before MBB, and it isn't because it was
       // loop-rotated above the header, it's not preferred.
       if (Next->getNumber() < MBB->getNumber() &&
           (!R || !R->contains(Next) ||
if (!Next) {
         break;
       }
       for (;;) {
         Next = Ready.top();
         Ready.pop();
         // If Next isn't dominated by the top active region header, defer it
         // until that region is done.
         if (!Entries.empty() &&
-            !MDT.dominates(Entries.back().Region->getHeader(), Next)) {
+            !MDT.dominates(Entries.back().TheRegion->getHeader(), Next)) {
           Entries.back().Deferred.push_back(Next);
           continue;
         }
         break;
       }
     }
     // Move the next block into place and iterate.
     Next->moveAfter(MBB);