[PATCH] D126455: [FuncSpec] Make the Function Specializer part of the IPSCCP pass.

Alexandros Lamprineas via Phabricator via llvm-commits llvm-commits at lists.llvm.org
Sun Oct 30 08:52:09 PDT 2022


labrinea added inline comments.


================
Comment at: llvm/lib/Transforms/Scalar/SCCP.cpp:161-172
+  // Record uses of V to avoid visiting irrelevant uses of const later.
+  SmallVector<Instruction *> UseInsts;
+  for (auto *U : V->users())
+    if (auto *I = dyn_cast<Instruction>(U))
+      if (Solver.isBlockExecutable(I->getParent()))
+        UseInsts.push_back(I);
+
----------------
chill wrote:
> labrinea wrote:
> > labrinea wrote:
> > > chill wrote:
> > > > labrinea wrote:
> > > > > Just found that we need to do the same inside `replaceSignedInst()` too. I will move this code a function.
> > > > Would it be possible to call `markUsersAsChanged` here ?
> > > I think we can't because if we replace the uses first then the users of the old value will be empty. Can we markUsersAsChanged before we replaceAllUsesWith the new value? Btw markUsersAsChanged is private for the SCCPInstVisitor, but I suppose I could make it public if need be.
> > Actually I could call markUsersAsChanged on the new Instrcution after replacing the uses of the old Instruction with it.
> OK, let's leave it hanging for now, until I can take a look on top of the latest trunk.
> 
> Ideally, we are trying to avoid changing code until the Solver is done. 
> Here we have found that an instruction has constant lattice value - we should not replace the users' operands
> right away, but notify the Solver. The Solver in turn would add the instructions that need reexamining to the instructions worklist and update their lattice values the next time we invoke `Solvet.solve()`.
> 
> Most likely `SCCPSolver::visit` should become private, the Solver (and the SCCP algorithm in general) is
> driven by its worklists, we should stick to this design: want something done - add it to the worklist.
> 
> 
> 
Update: I tried this. It works for 'some' cases. Instead of replacing values with constants I create mappings from the old to the new value and only after all the solving is done then I replace the uses. The specialization of recursive functions doesn't work because it relies on finding allocas of constant integers. Also the rewriting of callsites doesn't work either if the actual arguments have been constant propagated prior to specialization, but the old value hasn't been replaced yet. In theory I could pass on the mappings from sccp to the specializer but it seems overly complicated to do so.


Repository:
  rG LLVM Github Monorepo

CHANGES SINCE LAST ACTION
  https://reviews.llvm.org/D126455/new/

https://reviews.llvm.org/D126455



More information about the llvm-commits mailing list