LLVM  6.0.0svn
WebAssemblyOptimizeReturned.cpp
Go to the documentation of this file.
1 //===-- WebAssemblyOptimizeReturned.cpp - Optimize "returned" attributes --===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 ///
10 /// \file
11 /// \brief Optimize calls with "returned" attributes for WebAssembly.
12 ///
13 //===----------------------------------------------------------------------===//
14 
15 #include "WebAssembly.h"
16 #include "llvm/IR/Dominators.h"
17 #include "llvm/IR/InstVisitor.h"
18 #include "llvm/Support/Debug.h"
20 using namespace llvm;
21 
22 #define DEBUG_TYPE "wasm-optimize-returned"
23 
24 namespace {
25 class OptimizeReturned final : public FunctionPass,
26  public InstVisitor<OptimizeReturned> {
27  StringRef getPassName() const override {
28  return "WebAssembly Optimize Returned";
29  }
30 
31  void getAnalysisUsage(AnalysisUsage &AU) const override {
32  AU.setPreservesCFG();
36  }
37 
38  bool runOnFunction(Function &F) override;
39 
40  DominatorTree *DT;
41 
42 public:
43  static char ID;
44  OptimizeReturned() : FunctionPass(ID), DT(nullptr) {}
45 
46  void visitCallSite(CallSite CS);
47 };
48 } // End anonymous namespace
49 
50 char OptimizeReturned::ID = 0;
52  return new OptimizeReturned();
53 }
54 
55 void OptimizeReturned::visitCallSite(CallSite CS) {
56  for (unsigned i = 0, e = CS.getNumArgOperands(); i < e; ++i)
57  if (CS.paramHasAttr(i, Attribute::Returned)) {
58  Instruction *Inst = CS.getInstruction();
59  Value *Arg = CS.getArgOperand(i);
60  // Ignore constants, globals, undef, etc.
61  if (isa<Constant>(Arg))
62  continue;
63  // Like replaceDominatedUsesWith but using Instruction/Use dominance.
64  for (auto UI = Arg->use_begin(), UE = Arg->use_end(); UI != UE;) {
65  Use &U = *UI++;
66  if (DT->dominates(Inst, U))
67  U.set(Inst);
68  }
69  }
70 }
71 
73  DT = &getAnalysis<DominatorTreeWrapperPass>().getDomTree();
74  visit(F);
75  return true;
76 }
use_iterator use_end()
Definition: Value.h:348
AnalysisUsage & addPreserved()
Add the specified Pass class to the set of analyses preserved by this pass.
Base class for instruction visitors.
Definition: InstVisitor.h:81
Compute iterated dominance frontiers using a linear time algorithm.
Definition: AllocatorList.h:24
F(f)
This file contains the entry points for global functions defined in the LLVM WebAssembly back-end...
AnalysisUsage & addRequired()
A Use represents the edge between a Value definition and its users.
Definition: Use.h:56
InstrTy * getInstruction() const
Definition: CallSite.h:92
virtual void getAnalysisUsage(AnalysisUsage &) const
getAnalysisUsage - This function should be overriden by passes that need analysis information to do t...
Definition: Pass.cpp:91
ValTy * getArgOperand(unsigned i) const
Definition: CallSite.h:297
bool paramHasAttr(unsigned ArgNo, Attribute::AttrKind Kind) const
Return true if the call or the callee has the given attribute.
Definition: CallSite.h:377
Concrete subclass of DominatorTreeBase that is used to compute a normal dominator tree...
Definition: Dominators.h:140
static bool runOnFunction(Function &F, bool PostInlining)
void set(Value *Val)
Definition: Value.h:677
Represent the analysis usage information of a pass.
FunctionPass class - This class is used to implement most global optimizations.
Definition: Pass.h:285
unsigned getNumArgOperands() const
Definition: CallSite.h:293
void setPreservesCFG()
This function should be called by the pass, iff they do not:
Definition: Pass.cpp:285
amdgpu Simplify well known AMD library false Value Value * Arg
use_iterator use_begin()
Definition: Value.h:340
LLVM Value Representation.
Definition: Value.h:73
FunctionPass * createWebAssemblyOptimizeReturned()
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:49
Legacy analysis pass which computes a DominatorTree.
Definition: Dominators.h:267