Moving deglobalization to single flag

[mcornelius]

Accidentally created multiple diff revisions, closing.

llvm/lib/Transforms/IPO/AttributorAttributes.cpp

 
 static cl::opt<unsigned, true> MaxPotentialValues(
     "attributor-max-potential-values", cl::Hidden,
     cl::desc("Maximum number of potential values to be "
              "tracked for each position."),
     cl::location(llvm::PotentialConstantIntValuesState::MaxPotentialValues),
     cl::init(7));
 
-// TODO turn this into one flag not two
-static cl::opt<bool> DisableOpenMPOptDeglobalization2(
-    "openmp-opt-disable-deglobalization2", cl::ZeroOrMore,
-    cl::desc("Disable OpenMP optimizations involving deglobalization 2 of 2."),
-    cl::Hidden, cl::init(false));
-
 STATISTIC(NumAAs, "Number of abstract attributes created");
 
 // Some helper macros to deal with statistics tracking.
 //
 // Usage:
 // For simple IR attribute tracking overload trackStatistics in the abstract
 // attribute and choose the right STATS_DECLTRACK_********* macro,
 // e.g.,:
~AAHeapToStackFunction() {
     // sets.
     for (auto &It : AllocationInfos)
       It.getSecond()->~AllocationInfo();
     for (auto &It : DeallocationInfos)
       It.getSecond()->~DeallocationInfo();
   }
 
   void initialize(Attributor &A) override {
-    // If we have disabled deglobalization, stop
-    // TODO need to make these into one flag
-    if (DisableOpenMPOptDeglobalization2)
-      indicatePessimisticFixpoint();
-
     AAHeapToStack::initialize(A);
 
     const Function *F = getAnchorScope();
     const auto *TLI = A.getInfoCache().getTargetLibraryInfoForFunction(*F);
 
     auto AllocationIdentifierCB = [&](Instruction &I) {
       CallBase *CB = dyn_cast<CallBase>(&I);
       if (!CB)

llvm/lib/Transforms/IPO/OpenMPOpt.cpp

 
 static cl::opt<bool> HideMemoryTransferLatency(
     "openmp-hide-memory-transfer-latency",
     cl::desc("[WIP] Tries to hide the latency of host to device memory"
              " transfers"),
     cl::Hidden, cl::init(false));
 
 // TODO turn this into one flag
-static cl::opt<bool> DisableOpenMPOptDeglobalization1(
-    "openmp-opt-disable-deglobalization1", cl::ZeroOrMore,
+static cl::opt<bool> DisableOpenMPOptDeglobalization(
+    "openmp-opt-disable-deglobalization", cl::ZeroOrMore,
     cl::desc("Disable OpenMP optimizations involving deglobalization 1 if 2."),
     cl::Hidden, cl::init(false));
 
 static cl::opt<bool> DisableOpenMPOptSPMDization(
     "openmp-opt-disable-spmdization", cl::ZeroOrMore,
     cl::desc("Disable OpenMP optimizations involving SPMD-ization."),
     cl::Hidden, cl::init(false));
 
for (CallBase *CB : MallocCalls) {
       if (FreeCalls.size() != 1)
         continue;
 
       PotentialRemovedFreeCalls.insert(FreeCalls.front());
     }
   }
 
   void initialize(Attributor &A) override {
-    // If deglobalization disabled, do not init
-    if (DisableOpenMPOptDeglobalization1)
-      indicatePessimisticFixpoint();
-
     auto &OMPInfoCache = static_cast<OMPInformationCache &>(A.getInfoCache());
     auto &RFI = OMPInfoCache.RFIs[OMPRTL___kmpc_alloc_shared];
 
     for (User *U : RFI.Declaration->users())
       if (CallBase *CB = dyn_cast<CallBase>(U))
         MallocCalls.insert(CB);
 
     findPotentialRemovedFreeCalls(A);
for (int Idx = 0; Idx < OMPInfoCache.ICVs.size() - 1; ++Idx) {
 
     GetterRFI.foreachUse(SCC, CreateAA);
   }
   auto &GlobalizationRFI = OMPInfoCache.RFIs[OMPRTL___kmpc_alloc_shared];
   auto CreateAA = [&](Use &U, Function &F) {
     A.getOrCreateAAFor<AAHeapToShared>(IRPosition::function(F));
     return false;
   };
+  // If we have disabled deglobalization, do not create HeapToShared AA
+  if (!DisableOpenMPOptDeglobalization)
     GlobalizationRFI.foreachUse(SCC, CreateAA);
 
   // Create an ExecutionDomain AA for every function and a HeapToStack AA for
   // every function if there is a device kernel.
+  // If we have disabled deglobalization, skip making a HeapToStack AA
   for (auto *F : SCC) {
     if (!F->isDeclaration())
       A.getOrCreateAAFor<AAExecutionDomain>(IRPosition::function(*F));
-    if (isOpenMPDevice(M))
+    if (isOpenMPDevice(M) && !DisableOpenMPOptDeglobalization)
       A.getOrCreateAAFor<AAHeapToStack>(IRPosition::function(*F));
   }
 }
 
 const char AAICVTracker::ID = 0;
 const char AAKernelInfo::ID = 0;
 const char AAExecutionDomain::ID = 0;
 const char AAHeapToShared::ID = 0;