Mercurial > hg > CbC > CbC_llvm

comparison lib/Transforms/Scalar/LowerAtomic.cpp @ 120:1172e4bd9c6f

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
update 4.0.0
author mir3636
date Fri, 25 Nov 2016 19:14:25 +0900
parents 7d135dc70f03
children 803732b1fca8
comparison
equal deleted inserted replaced
101:34baf5011add 120:1172e4bd9c6f
10 // This pass lowers atomic intrinsics to non-atomic form for use in a known 10 // This pass lowers atomic intrinsics to non-atomic form for use in a known
11 // non-preemptible environment. 11 // non-preemptible environment.
12 // 12 //
13 //===----------------------------------------------------------------------===// 13 //===----------------------------------------------------------------------===//
14 14
15 #include "llvm/Transforms/Scalar.h" 15 #include "llvm/Transforms/Scalar/LowerAtomic.h"
16 #include "llvm/IR/Function.h" 16 #include "llvm/IR/Function.h"
17 #include "llvm/IR/IRBuilder.h" 17 #include "llvm/IR/IRBuilder.h"
18 #include "llvm/IR/IntrinsicInst.h" 18 #include "llvm/IR/IntrinsicInst.h"
19 #include "llvm/Pass.h" 19 #include "llvm/Pass.h"
20 #include "llvm/Transforms/Scalar.h"
20 using namespace llvm; 21 using namespace llvm;
21 22
22 #define DEBUG_TYPE "loweratomic" 23 #define DEBUG_TYPE "loweratomic"
23 24
24 static bool LowerAtomicCmpXchgInst(AtomicCmpXchgInst *CXI) { 25 static bool LowerAtomicCmpXchgInst(AtomicCmpXchgInst *CXI) {
98 FI->eraseFromParent(); 99 FI->eraseFromParent();
99 return true; 100 return true;
100 } 101 }
101 102
102 static bool LowerLoadInst(LoadInst *LI) { 103 static bool LowerLoadInst(LoadInst *LI) {
103 LI->setAtomic(NotAtomic); 104 LI->setAtomic(AtomicOrdering::NotAtomic);
104 return true; 105 return true;
105 } 106 }
106 107
107 static bool LowerStoreInst(StoreInst *SI) { 108 static bool LowerStoreInst(StoreInst *SI) {
108 SI->setAtomic(NotAtomic); 109 SI->setAtomic(AtomicOrdering::NotAtomic);
109 return true; 110 return true;
110 } 111 }
111 112
113 static bool runOnBasicBlock(BasicBlock &BB) {
114 bool Changed = false;
115 for (BasicBlock::iterator DI = BB.begin(), DE = BB.end(); DI != DE;) {
116 Instruction *Inst = &*DI++;
117 if (FenceInst *FI = dyn_cast<FenceInst>(Inst))
118 Changed |= LowerFenceInst(FI);
119 else if (AtomicCmpXchgInst *CXI = dyn_cast<AtomicCmpXchgInst>(Inst))
120 Changed |= LowerAtomicCmpXchgInst(CXI);
121 else if (AtomicRMWInst *RMWI = dyn_cast<AtomicRMWInst>(Inst))
122 Changed |= LowerAtomicRMWInst(RMWI);
123 else if (LoadInst *LI = dyn_cast<LoadInst>(Inst)) {
124 if (LI->isAtomic())
125 LowerLoadInst(LI);
126 } else if (StoreInst *SI = dyn_cast<StoreInst>(Inst)) {
127 if (SI->isAtomic())
128 LowerStoreInst(SI);
129 }
130 }
131 return Changed;
132 }
133
134 static bool lowerAtomics(Function &F) {
135 bool Changed = false;
136 for (BasicBlock &BB : F) {
137 Changed |= runOnBasicBlock(BB);
138 }
139 return Changed;
140 }
141
142 PreservedAnalyses LowerAtomicPass::run(Function &F, FunctionAnalysisManager &) {
143 if (lowerAtomics(F))
144 return PreservedAnalyses::none();
145 return PreservedAnalyses::all();
146 }
147
112 namespace { 148 namespace {
113 struct LowerAtomic : public BasicBlockPass { 149 class LowerAtomicLegacyPass : public FunctionPass {
114 static char ID; 150 public:
115 LowerAtomic() : BasicBlockPass(ID) { 151 static char ID;
116 initializeLowerAtomicPass(*PassRegistry::getPassRegistry()); 152
117 } 153 LowerAtomicLegacyPass() : FunctionPass(ID) {
118 bool runOnBasicBlock(BasicBlock &BB) override { 154 initializeLowerAtomicLegacyPassPass(*PassRegistry::getPassRegistry());
119 if (skipOptnoneFunction(BB)) 155 }
120 return false; 156
121 bool Changed = false; 157 bool runOnFunction(Function &F) override {
122 for (BasicBlock::iterator DI = BB.begin(), DE = BB.end(); DI != DE; ) { 158 if (skipFunction(F))
123 Instruction *Inst = &*DI++; 159 return false;
124 if (FenceInst *FI = dyn_cast<FenceInst>(Inst)) 160 FunctionAnalysisManager DummyFAM;
125 Changed |= LowerFenceInst(FI); 161 auto PA = Impl.run(F, DummyFAM);
126 else if (AtomicCmpXchgInst *CXI = dyn_cast<AtomicCmpXchgInst>(Inst)) 162 return !PA.areAllPreserved();
127 Changed |= LowerAtomicCmpXchgInst(CXI); 163 }
128 else if (AtomicRMWInst *RMWI = dyn_cast<AtomicRMWInst>(Inst)) 164
129 Changed |= LowerAtomicRMWInst(RMWI); 165 private:
130 else if (LoadInst *LI = dyn_cast<LoadInst>(Inst)) { 166 LowerAtomicPass Impl;
131 if (LI->isAtomic())
132 LowerLoadInst(LI);
133 } else if (StoreInst *SI = dyn_cast<StoreInst>(Inst)) {
134 if (SI->isAtomic())
135 LowerStoreInst(SI);
136 }
137 }
138 return Changed;
139 }
140 }; 167 };
141 } 168 }
142 169
143 char LowerAtomic::ID = 0; 170 char LowerAtomicLegacyPass::ID = 0;
144 INITIALIZE_PASS(LowerAtomic, "loweratomic", 171 INITIALIZE_PASS(LowerAtomicLegacyPass, "loweratomic",
145 "Lower atomic intrinsics to non-atomic form", 172 "Lower atomic intrinsics to non-atomic form", false, false)
146 false, false)
147 173
148 Pass *llvm::createLowerAtomicPass() { return new LowerAtomic(); } 174 Pass *llvm::createLowerAtomicPass() { return new LowerAtomicLegacyPass(); }