LLVM 17.0.0git
MemCpyOptimizer.h
Go to the documentation of this file.
1//===- MemCpyOptimizer.h - memcpy optimization ------------------*- C++ -*-===//
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// This pass performs various transformations related to eliminating memcpy
10// calls, or transforming sets of stores into memset's.
11//
12//===----------------------------------------------------------------------===//
13
14#ifndef LLVM_TRANSFORMS_SCALAR_MEMCPYOPTIMIZER_H
15#define LLVM_TRANSFORMS_SCALAR_MEMCPYOPTIMIZER_H
16
17#include "llvm/IR/BasicBlock.h"
18#include "llvm/IR/PassManager.h"
19
20namespace llvm {
21
22class AAResults;
23class BatchAAResults;
24class AssumptionCache;
25class CallBase;
26class CallInst;
27class DominatorTree;
28class Function;
29class Instruction;
30class LoadInst;
31class MemCpyInst;
32class MemMoveInst;
33class MemorySSA;
34class MemorySSAUpdater;
35class MemSetInst;
36class StoreInst;
37class TargetLibraryInfo;
38class Value;
39
40class MemCpyOptPass : public PassInfoMixin<MemCpyOptPass> {
41 TargetLibraryInfo *TLI = nullptr;
42 AAResults *AA = nullptr;
43 AssumptionCache *AC = nullptr;
44 DominatorTree *DT = nullptr;
45 MemorySSA *MSSA = nullptr;
46 MemorySSAUpdater *MSSAU = nullptr;
47
48public:
49 MemCpyOptPass() = default;
50
52
53 // Glue for the old PM.
56
57private:
58 // Helper functions
59 bool processStore(StoreInst *SI, BasicBlock::iterator &BBI);
60 bool processStoreOfLoad(StoreInst *SI, LoadInst *LI, const DataLayout &DL,
62 bool processMemSet(MemSetInst *SI, BasicBlock::iterator &BBI);
63 bool processMemCpy(MemCpyInst *M, BasicBlock::iterator &BBI);
64 bool processMemMove(MemMoveInst *M);
65 bool performCallSlotOptzn(Instruction *cpyLoad, Instruction *cpyStore,
66 Value *cpyDst, Value *cpySrc, TypeSize cpyLen,
67 Align cpyAlign, BatchAAResults &BAA,
68 std::function<CallInst *()> GetC);
69 bool processMemCpyMemCpyDependence(MemCpyInst *M, MemCpyInst *MDep,
70 BatchAAResults &BAA);
71 bool processMemSetMemCpyDependence(MemCpyInst *MemCpy, MemSetInst *MemSet,
72 BatchAAResults &BAA);
73 bool performMemCpyToMemSetOptzn(MemCpyInst *MemCpy, MemSetInst *MemSet,
74 BatchAAResults &BAA);
75 bool processByValArgument(CallBase &CB, unsigned ArgNo);
76 Instruction *tryMergingIntoMemset(Instruction *I, Value *StartPtr,
77 Value *ByteVal);
78 bool moveUp(StoreInst *SI, Instruction *P, const LoadInst *LI);
79
80 void eraseInstruction(Instruction *I);
81 bool iterateOnFunction(Function &F);
82};
83
84} // end namespace llvm
85
86#endif // LLVM_TRANSFORMS_SCALAR_MEMCPYOPTIMIZER_H
MachineBasicBlock MachineBasicBlock::iterator DebugLoc DL
early cse Early CSE w MemorySSA
Definition: EarlyCSE.cpp:1831
#define F(x, y, z)
Definition: MD5.cpp:55
#define I(x, y, z)
Definition: MD5.cpp:58
#define P(N)
This header defines various interfaces for pass management in LLVM.
A container for analyses that lazily runs them and caches their results.
Definition: PassManager.h:620
A cache of @llvm.assume calls within a function.
InstListType::iterator iterator
Instruction iterators...
Definition: BasicBlock.h:87
This class is a wrapper over an AAResults, and it is intended to be used only when there are no IR ch...
Base class for all callable instructions (InvokeInst and CallInst) Holds everything related to callin...
Definition: InstrTypes.h:1190
This class represents a function call, abstracting a target machine's calling convention.
A parsed version of the target data layout string in and methods for querying it.
Definition: DataLayout.h:110
Concrete subclass of DominatorTreeBase that is used to compute a normal dominator tree.
Definition: Dominators.h:166
An instruction for reading from memory.
Definition: Instructions.h:177
This class wraps the llvm.memcpy intrinsic.
PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM)
MemCpyOptPass()=default
bool runImpl(Function &F, TargetLibraryInfo *TLI, AAResults *AA, AssumptionCache *AC, DominatorTree *DT, MemorySSA *MSSA)
This class wraps the llvm.memmove intrinsic.
This class wraps the llvm.memset and llvm.memset.inline intrinsics.
Encapsulates MemorySSA, including all data associated with memory accesses.
Definition: MemorySSA.h:700
A set of analyses that are preserved following a run of a transformation pass.
Definition: PassManager.h:152
An instruction for storing to memory.
Definition: Instructions.h:301
Provides information about what library functions are available for the current target.
LLVM Value Representation.
Definition: Value.h:74
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
This struct is a compact representation of a valid (non-zero power of two) alignment.
Definition: Alignment.h:39
A CRTP mix-in to automatically provide informational APIs needed for passes.
Definition: PassManager.h:371