Run folding pass first without global demotion

Author: arshajii

compiler/sir/analyze/module/side_effect.cpp

@@ -26,12 +26,19 @@ struct SideEfectAnalyzer : public util::ConstVisitor {
   static const std::string NON_PURE_ATTR;
 
   VarUseAnalyzer &vua;
+  bool globalAssignmentHasSideEffects;
   std::unordered_map<id_t, bool> result;
   bool exprSE;
   bool funcSE;
 
-  SideEfectAnalyzer(VarUseAnalyzer &vua)
-      : util::ConstVisitor(), vua(vua), result(), exprSE(true), funcSE(false) {}
+  // We have to sometimes be careful with globals since future
+  // IR passes might introduce globals that we've eliminated
+  // or demoted earlier. Hence the distinction with whether
+  // global assignments are considered to have side effects.
+  SideEfectAnalyzer(VarUseAnalyzer &vua, bool globalAssignmentHasSideEffects)
+      : util::ConstVisitor(), vua(vua),
+        globalAssignmentHasSideEffects(globalAssignmentHasSideEffects), result(),
+        exprSE(true), funcSE(false) {}
 
   template <typename T> bool has(const T *v) {
     return result.find(v->getId()) != result.end();
@@ -174,8 +181,13 @@ struct SideEfectAnalyzer : public util::ConstVisitor {
     auto count1 = (it1 != vua.varCounts.end()) ? it1->second : 0;
     auto count2 = (it2 != vua.varAssignCounts.end()) ? it2->second : 0;
 
+    bool g = v->getLhs()->isGlobal();
     bool s = (count1 != count2);
-    set(v, s | process(v->getRhs()), s & v->getLhs()->isGlobal());
+    if (globalAssignmentHasSideEffects) {
+      set(v, s | g | process(v->getRhs()), g);
+    } else {
+      set(v, s | process(v->getRhs()), s & g);
+    }
   }
 
   void visit(const ExtractInstr *v) override { set(v, process(v->getVal())); }
@@ -257,7 +269,7 @@ bool SideEffectResult::hasSideEffect(Value *v) const {
 std::unique_ptr<Result> SideEffectAnalysis::run(const Module *m) {
   VarUseAnalyzer vua;
   const_cast<Module *>(m)->accept(vua);
-  SideEfectAnalyzer sea(vua);
+  SideEfectAnalyzer sea(vua, globalAssignmentHasSideEffects);
   m->accept(sea);
   return std::make_unique<SideEffectResult>(sea.result);
 }

compiler/sir/analyze/module/side_effect.h

@@ -21,7 +21,19 @@ struct SideEffectResult : public Result {
 };
 
 class SideEffectAnalysis : public Analysis {
+private:
+  /// true if assigning to a global variable automatically has side effects
+  bool globalAssignmentHasSideEffects;
+
+public:
   static const std::string KEY;
+
+  /// Constructs a side effect analysis.
+  /// @param globalAssignmentHasSideEffects true if global variable assignment
+  /// automatically has side effects
+  explicit SideEffectAnalysis(bool globalAssignmentHasSideEffects = true)
+      : Analysis(), globalAssignmentHasSideEffects(globalAssignmentHasSideEffects){};
+
   std::string getKey() const override { return KEY; }
 
   std::unique_ptr<Result> run(const Module *m) override;

compiler/sir/llvm/llvisitor.cpp

@@ -728,7 +728,7 @@ void LLVMVisitor::visit(const Module *x) {
       } else {
         auto *storage = new llvm::GlobalVariable(
             *module, llvmType, /*isConstant=*/false,
-            llvm::GlobalVariable::InternalLinkage,
+            llvm::GlobalVariable::PrivateLinkage,
             llvm::Constant::getNullValue(llvmType), var->getName());
         vars.insert(var, storage);
 

compiler/sir/transform/folding/folding.cpp

@@ -12,7 +12,8 @@ const std::string FoldingPassGroup::KEY = "core-folding-pass-group";
 
 FoldingPassGroup::FoldingPassGroup(const std::string &sideEffectsPass,
                                    const std::string &reachingDefPass,
-                                   const std::string &globalVarPass) {
+                                   const std::string &globalVarPass,
+                                   bool runGlobalDemotion) {
   auto gdUnique = std::make_unique<cleanup::GlobalDemotionPass>();
   auto canonUnique = std::make_unique<cleanup::CanonicalizationPass>(sideEffectsPass);
   auto fpUnique = std::make_unique<FoldingPass>();
@@ -23,7 +24,8 @@ FoldingPassGroup::FoldingPassGroup(const std::string &sideEffectsPass,
   fp = fpUnique.get();
   dce = dceUnique.get();
 
-  push_back(std::move(gdUnique));
+  if (runGlobalDemotion)
+    push_back(std::move(gdUnique));
   push_back(std::make_unique<ConstPropPass>(reachingDefPass, globalVarPass));
   push_back(std::move(canonUnique));
   push_back(std::move(fpUnique));

compiler/sir/transform/folding/folding.h

@@ -29,8 +29,8 @@ class FoldingPassGroup : public PassGroup {
   /// @param reachingDefPass the key of the reaching definitions pass
   /// @param globalVarPass the key of the global variables pass
   FoldingPassGroup(const std::string &sideEffectsPass,
-                   const std::string &reachingDefPass,
-                   const std::string &globalVarPass);
+                   const std::string &reachingDefPass, const std::string &globalVarPass,
+                   bool runGlobalDemotion = true);
 
   bool shouldRepeat() const override;
 };

compiler/sir/transform/manager.cpp

@@ -145,6 +145,7 @@ void PassManager::invalidate(const std::string &key) {
 void PassManager::registerStandardPasses(bool debug) {
   if (debug) {
     registerPass(std::make_unique<lowering::PipelineLowering>());
+    registerPass(std::make_unique<lowering::ImperativeForFlowLowering>());
     registerPass(std::make_unique<parallel::OpenMPPass>());
   } else {
     // Pythonic
@@ -157,19 +158,29 @@ void PassManager::registerStandardPasses(bool debug) {
     registerPass(std::make_unique<lowering::ImperativeForFlowLowering>());
 
     // folding
-    auto seKey =
-        registerAnalysis(std::make_unique<analyze::module::SideEffectAnalysis>());
+    auto seKey1 =
+        registerAnalysis(std::make_unique<analyze::module::SideEffectAnalysis>(
+            /*globalAssignmentHasSideEffects=*/true));
+    auto seKey2 =
+        registerAnalysis(std::make_unique<analyze::module::SideEffectAnalysis>(
+            /*globalAssignmentHasSideEffects=*/false));
     auto cfgKey = registerAnalysis(std::make_unique<analyze::dataflow::CFAnalysis>());
     auto rdKey = registerAnalysis(
         std::make_unique<analyze::dataflow::RDAnalysis>(cfgKey), {cfgKey});
     auto globalKey =
         registerAnalysis(std::make_unique<analyze::module::GlobalVarsAnalyses>());
-    registerPass(std::make_unique<folding::FoldingPassGroup>(seKey, rdKey, globalKey),
-                 /*insertBefore=*/"", {seKey, rdKey, globalKey},
-                 {seKey, rdKey, cfgKey, globalKey});
+    registerPass(std::make_unique<folding::FoldingPassGroup>(
+                     seKey1, rdKey, globalKey, /*runGlobalDemoton=*/false),
+                 /*insertBefore=*/"", {seKey1, rdKey, globalKey},
+                 {seKey1, rdKey, cfgKey, globalKey});
 
     // parallel
     registerPass(std::make_unique<parallel::OpenMPPass>());
+
+    registerPass(std::make_unique<folding::FoldingPassGroup>(seKey2, rdKey, globalKey,
+                                                             /*runGlobalDemoton=*/true),
+                 /*insertBefore=*/"", {seKey2, rdKey, globalKey},
+                 {seKey2, rdKey, cfgKey, globalKey});
   }
 }
 

stdlib/internal/dlopen.seq

@@ -1,4 +1,6 @@
-from C import seq_is_macos() -> bool
+@pure
+@C
+def seq_is_macos() -> bool: pass
 
 # <dlfcn.h>
 from C import dlerror() -> cobj as c_dlerror
@@ -8,7 +10,6 @@ from C import dlclose(cobj) -> i32 as c_dlclose
 RTLD_NOW = 2
 RTLD_GLOBAL = 8 if seq_is_macos() else 256
 
-@pure
 def dlext():
     if seq_is_macos():
         return 'dylib'