LLVM 19.0.0git
WebAssemblyOptimizeReturned.cpp
Go to the documentation of this file.
1//===-- WebAssemblyOptimizeReturned.cpp - Optimize "returned" attributes --===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8///
9/// \file
10/// Optimize calls with "returned" attributes for WebAssembly.
11///
12//===----------------------------------------------------------------------===//
13
14#include "WebAssembly.h"
15#include "llvm/IR/Dominators.h"
16#include "llvm/IR/InstVisitor.h"
17#include "llvm/Support/Debug.h"
19using namespace llvm;
20
21#define DEBUG_TYPE "wasm-optimize-returned"
22
23namespace {
24class OptimizeReturned final : public FunctionPass,
25 public InstVisitor<OptimizeReturned> {
26 StringRef getPassName() const override {
27 return "WebAssembly Optimize Returned";
28 }
29
30 void getAnalysisUsage(AnalysisUsage &AU) const override {
31 AU.setPreservesCFG();
35 }
36
37 bool runOnFunction(Function &F) override;
38
39 DominatorTree *DT = nullptr;
40
41public:
42 static char ID;
43 OptimizeReturned() : FunctionPass(ID) {}
44
45 void visitCallBase(CallBase &CB);
46};
47} // End anonymous namespace
48
49char OptimizeReturned::ID = 0;
50INITIALIZE_PASS(OptimizeReturned, DEBUG_TYPE,
51 "Optimize calls with \"returned\" attributes for WebAssembly",
52 false, false)
53
55 return new OptimizeReturned();
56}
57
58void OptimizeReturned::visitCallBase(CallBase &CB) {
59 for (unsigned I = 0, E = CB.arg_size(); I < E; ++I)
60 if (CB.paramHasAttr(I, Attribute::Returned)) {
61 Value *Arg = CB.getArgOperand(I);
62 // Ignore constants, globals, undef, etc.
63 if (isa<Constant>(Arg))
64 continue;
65 // Like replaceDominatedUsesWith but using Instruction/Use dominance.
66 Arg->replaceUsesWithIf(&CB,
67 [&](Use &U) { return DT->dominates(&CB, U); });
68 }
69}
70
71bool OptimizeReturned::runOnFunction(Function &F) {
72 LLVM_DEBUG(dbgs() << "********** Optimize returned Attributes **********\n"
73 "********** Function: "
74 << F.getName() << '\n');
75
76 DT = &getAnalysis<DominatorTreeWrapperPass>().getDomTree();
77 visit(F);
78 return true;
79}
#define LLVM_DEBUG(X)
Definition: Debug.h:101
#define F(x, y, z)
Definition: MD5.cpp:55
#define I(x, y, z)
Definition: MD5.cpp:58
#define INITIALIZE_PASS(passName, arg, name, cfg, analysis)
Definition: PassSupport.h:38
#define DEBUG_TYPE
This file contains the entry points for global functions defined in the LLVM WebAssembly back-end.
Represent the analysis usage information of a pass.
AnalysisUsage & addRequired()
AnalysisUsage & addPreserved()
Add the specified Pass class to the set of analyses preserved by this pass.
void setPreservesCFG()
This function should be called by the pass, iff they do not:
Definition: Pass.cpp:269
Base class for all callable instructions (InvokeInst and CallInst) Holds everything related to callin...
Definition: InstrTypes.h:1461
bool paramHasAttr(unsigned ArgNo, Attribute::AttrKind Kind) const
Determine whether the argument or parameter has the given attribute.
Value * getArgOperand(unsigned i) const
Definition: InstrTypes.h:1654
unsigned arg_size() const
Definition: InstrTypes.h:1652
Legacy analysis pass which computes a DominatorTree.
Definition: Dominators.h:317
Concrete subclass of DominatorTreeBase that is used to compute a normal dominator tree.
Definition: Dominators.h:162
FunctionPass class - This class is used to implement most global optimizations.
Definition: Pass.h:311
virtual bool runOnFunction(Function &F)=0
runOnFunction - Virtual method overriden by subclasses to do the per-function processing of the pass.
Base class for instruction visitors.
Definition: InstVisitor.h:78
RetTy visitCallBase(CallBase &I)
Definition: InstVisitor.h:267
virtual void getAnalysisUsage(AnalysisUsage &) const
getAnalysisUsage - This function should be overriden by passes that need analysis information to do t...
Definition: Pass.cpp:98
virtual StringRef getPassName() const
getPassName - Return a nice clean name for a pass.
Definition: Pass.cpp:81
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:50
A Use represents the edge between a Value definition and its users.
Definition: Use.h:43
LLVM Value Representation.
Definition: Value.h:74
void replaceUsesWithIf(Value *New, llvm::function_ref< bool(Use &U)> ShouldReplace)
Go through the uses list for this definition and make each use point to "V" if the callback ShouldRep...
Definition: Value.cpp:542
unsigned ID
LLVM IR allows to use arbitrary numbers as calling convention identifiers.
Definition: CallingConv.h:24
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
Definition: Debug.cpp:163
FunctionPass * createWebAssemblyOptimizeReturned()