instrument volatile loads and stores

[c11llvm.git] / CDSPass.cpp

diff --git a/CDSPass.cpp b/CDSPass.cpp
index eef87699e927fbb820880a6dfddbcceea31a987b..dede6bc6b0652e27aa59524f8b15644568489a1f 100644 (file)
--- a/CDSPass.cpp
+++ b/CDSPass.cpp
@@ -60,7 +60,7 @@ Value *getPosition( Instruction * I, IRBuilder <> IRB, bool print = false)
        }
 
        if (print) {
-               errs() << position_string;
+               errs() << position_string << "\n";
        }
 
        return IRB.CreateGlobalStringPtr (position_string);
@@ -89,6 +89,7 @@ Type * Int64PtrTy;
 Type * VoidTy;
 
 static const size_t kNumberOfAccessSizes = 4;
+static const int volatile_order = 6;
 
 int getAtomicOrderIndex(AtomicOrdering order){
        switch (order) {
@@ -119,6 +120,7 @@ namespace {
        private:
                void initializeCallbacks(Module &M);
                bool instrumentLoadOrStore(Instruction *I, const DataLayout &DL);
+               bool instrumentVolatile(Instruction *I, const DataLayout &DL);
                bool isAtomicCall(Instruction *I);
                bool instrumentAtomic(Instruction *I, const DataLayout &DL);
                bool instrumentAtomicCall(CallInst *CI, const DataLayout &DL);
@@ -134,6 +136,8 @@ namespace {
 
                Constant * CDSLoad[kNumberOfAccessSizes];
                Constant * CDSStore[kNumberOfAccessSizes];
+               Constant * CDSVolatileLoad[kNumberOfAccessSizes];
+               Constant * CDSVolatileStore[kNumberOfAccessSizes];
                Constant * CDSAtomicInit[kNumberOfAccessSizes];
                Constant * CDSAtomicLoad[kNumberOfAccessSizes];
                Constant * CDSAtomicStore[kNumberOfAccessSizes];
@@ -186,12 +190,18 @@ void CDSPass::initializeCallbacks(Module &M) {
                // void cds_atomic_store8 (void * obj, int atomic_index, uint8_t val)
                SmallString<32> LoadName("cds_load" + BitSizeStr);
                SmallString<32> StoreName("cds_store" + BitSizeStr);
+               SmallString<32> VolatileLoadName("cds_volatile_load" + BitSizeStr);
+               SmallString<32> VolatileStoreName("cds_volatile_store" + BitSizeStr);
                SmallString<32> AtomicInitName("cds_atomic_init" + BitSizeStr);
                SmallString<32> AtomicLoadName("cds_atomic_load" + BitSizeStr);
                SmallString<32> AtomicStoreName("cds_atomic_store" + BitSizeStr);
 
                CDSLoad[i]  = M.getOrInsertFunction(LoadName, VoidTy, PtrTy);
                CDSStore[i] = M.getOrInsertFunction(StoreName, VoidTy, PtrTy);
+               CDSVolatileLoad[i]  = M.getOrInsertFunction(VolatileLoadName,
+                                                                       Ty, PtrTy, OrdTy, Int8PtrTy);
+               CDSVolatileStore[i] = M.getOrInsertFunction(VolatileStoreName, 
+                                                                       VoidTy, PtrTy, Ty, OrdTy, Int8PtrTy);
                CDSAtomicInit[i] = M.getOrInsertFunction(AtomicInitName, 
                                                                VoidTy, PtrTy, Ty, Int8PtrTy);
                CDSAtomicLoad[i]  = M.getOrInsertFunction(AtomicLoadName, 
@@ -311,6 +321,7 @@ bool CDSPass::runOnFunction(Function &F) {
 
                SmallVector<Instruction*, 8> AllLoadsAndStores;
                SmallVector<Instruction*, 8> LocalLoadsAndStores;
+               SmallVector<Instruction*, 8> VolatileLoadsAndStores;
                SmallVector<Instruction*, 8> AtomicAccesses;
 
                std::vector<Instruction *> worklist;
@@ -327,7 +338,14 @@ bool CDSPass::runOnFunction(Function &F) {
                                        AtomicAccesses.push_back(&I);
                                        HasAtomic = true;
                                } else if (isa<LoadInst>(I) || isa<StoreInst>(I)) {
-                                       LocalLoadsAndStores.push_back(&I);
+                                       LoadInst *LI = dyn_cast<LoadInst>(&I);
+                                       StoreInst *SI = dyn_cast<StoreInst>(&I);
+                                       bool isVolatile = ( LI ? LI->isVolatile() : SI->isVolatile() );
+
+                                       if (isVolatile)
+                                               VolatileLoadsAndStores.push_back(&I);
+                                       else
+                                               LocalLoadsAndStores.push_back(&I);
                                } else if (isa<CallInst>(I) || isa<InvokeInst>(I)) {
                                        // not implemented yet
                                }
@@ -337,8 +355,11 @@ bool CDSPass::runOnFunction(Function &F) {
                }
 
                for (auto Inst : AllLoadsAndStores) {
-                       // Res |= instrumentLoadOrStore(Inst, DL);
-                       // errs() << "load and store are replaced\n";
+                       Res |= instrumentLoadOrStore(Inst, DL);
+               }
+
+               for (auto Inst : VolatileLoadsAndStores) {
+                       Res |= instrumentVolatile(Inst, DL);
                }
 
                for (auto Inst : AtomicAccesses) {
@@ -348,13 +369,13 @@ bool CDSPass::runOnFunction(Function &F) {
                // only instrument functions that contain atomics
                if (Res && HasAtomic) {
                        IRBuilder<> IRB(F.getEntryBlock().getFirstNonPHI());
+                       /* Unused for now
                        Value *ReturnAddress = IRB.CreateCall(
                                Intrinsic::getDeclaration(F.getParent(), Intrinsic::returnaddress),
                                IRB.getInt32(0));
+                       */
 
                        Value * FuncName = IRB.CreateGlobalStringPtr(F.getName());
-                       
-                       errs() << "function name: " << F.getName() << "\n";
                        IRB.CreateCall(CDSFuncEntry, FuncName);
 
                        EscapeEnumerator EE(F, "cds_cleanup", true);
@@ -364,6 +385,8 @@ bool CDSPass::runOnFunction(Function &F) {
 
                        Res = true;
                }
+
+               F.dump();
        }
 
        return false;
@@ -427,6 +450,8 @@ bool CDSPass::instrumentLoadOrStore(Instruction *I,
        return false;
 
        int Idx = getMemoryAccessFuncIndex(Addr, DL);
+       if (Idx < 0)
+               return false;
 
 //  not supported by CDS yet
 /*  if (IsWrite && isVtableAccess(I)) {
@@ -472,10 +497,42 @@ bool CDSPass::instrumentLoadOrStore(Instruction *I,
        return true;
 }
 
-bool CDSPass::instrumentAtomic(Instruction * I, const DataLayout &DL) {
+bool CDSPass::instrumentVolatile(Instruction * I, const DataLayout &DL) {
        IRBuilder<> IRB(I);
+       Value *position = getPosition(I, IRB);
+
+       if (LoadInst *LI = dyn_cast<LoadInst>(I)) {
+               assert( LI->isVolatile() );
+               Value *Addr = LI->getPointerOperand();
+               int Idx=getMemoryAccessFuncIndex(Addr, DL);
+               if (Idx < 0)
+                       return false;
+
+               Value *order = ConstantInt::get(OrdTy, volatile_order);
+               Value *args[] = {Addr, order, position};
+               Instruction* funcInst=CallInst::Create(CDSVolatileLoad[Idx], args);
+               ReplaceInstWithInst(LI, funcInst);
+       } else if (StoreInst *SI = dyn_cast<StoreInst>(I)) {
+               assert( SI->isVolatile() );
+               Value *Addr = SI->getPointerOperand();
+               int Idx=getMemoryAccessFuncIndex(Addr, DL);
+               if (Idx < 0)
+                       return false;
+
+               Value *val = SI->getValueOperand();
+               Value *order = ConstantInt::get(OrdTy, volatile_order);
+               Value *args[] = {Addr, val, order, position};
+               Instruction* funcInst=CallInst::Create(CDSVolatileStore[Idx], args);
+               ReplaceInstWithInst(SI, funcInst);
+       } else {
+               return false;
+       }
 
-       // errs() << "instrumenting: " << *I << "\n";
+       return true;
+}
+
+bool CDSPass::instrumentAtomic(Instruction * I, const DataLayout &DL) {
+       IRBuilder<> IRB(I);
 
        if (auto *CI = dyn_cast<CallInst>(I)) {
                return instrumentAtomicCall(CI, DL);
@@ -486,6 +543,9 @@ bool CDSPass::instrumentAtomic(Instruction * I, const DataLayout &DL) {
        if (LoadInst *LI = dyn_cast<LoadInst>(I)) {
                Value *Addr = LI->getPointerOperand();
                int Idx=getMemoryAccessFuncIndex(Addr, DL);
+               if (Idx < 0)
+                       return false;
+
                int atomic_order_index = getAtomicOrderIndex(LI->getOrdering());
                Value *order = ConstantInt::get(OrdTy, atomic_order_index);
                Value *args[] = {Addr, order, position};
@@ -494,6 +554,9 @@ bool CDSPass::instrumentAtomic(Instruction * I, const DataLayout &DL) {
        } else if (StoreInst *SI = dyn_cast<StoreInst>(I)) {
                Value *Addr = SI->getPointerOperand();
                int Idx=getMemoryAccessFuncIndex(Addr, DL);
+               if (Idx < 0)
+                       return false;
+
                int atomic_order_index = getAtomicOrderIndex(SI->getOrdering());
                Value *val = SI->getValueOperand();
                Value *order = ConstantInt::get(OrdTy, atomic_order_index);
@@ -503,6 +566,9 @@ bool CDSPass::instrumentAtomic(Instruction * I, const DataLayout &DL) {
        } else if (AtomicRMWInst *RMWI = dyn_cast<AtomicRMWInst>(I)) {
                Value *Addr = RMWI->getPointerOperand();
                int Idx=getMemoryAccessFuncIndex(Addr, DL);
+               if (Idx < 0)
+                       return false;
+
                int atomic_order_index = getAtomicOrderIndex(RMWI->getOrdering());
                Value *val = RMWI->getValOperand();
                Value *order = ConstantInt::get(OrdTy, atomic_order_index);
@@ -514,6 +580,8 @@ bool CDSPass::instrumentAtomic(Instruction * I, const DataLayout &DL) {
 
                Value *Addr = CASI->getPointerOperand();
                int Idx=getMemoryAccessFuncIndex(Addr, DL);
+               if (Idx < 0)
+                       return false;
 
                const unsigned ByteSize = 1U << Idx;
                const unsigned BitSize = ByteSize * 8;
@@ -687,7 +755,7 @@ bool CDSPass::instrumentAtomicCall(CallInst *CI, const DataLayout &DL) {
 
                Value *ptr = IRB.CreatePointerCast(OrigPtr, PtrTy);
                Value *val = IRB.CreatePointerCast(OrigVal, Ty);
-               Value *order = IRB.CreateBitOrPointerCast(parameters[1], OrdTy);
+               Value *order = IRB.CreateBitOrPointerCast(parameters[2], OrdTy);
                Value *args[] = {ptr, val, order, position};
 
                Instruction* funcInst = CallInst::Create(CDSAtomicStore[Idx], args);
@@ -807,7 +875,10 @@ int CDSPass::getMemoryAccessFuncIndex(Value *Addr,
                return -1;
        }
        size_t Idx = countTrailingZeros(TypeSize / 8);
-       assert(Idx < kNumberOfAccessSizes);
+       //assert(Idx < kNumberOfAccessSizes);
+       if (Idx >= kNumberOfAccessSizes) {
+               return -1;
+       }
        return Idx;
 }
 
@@ -819,6 +890,13 @@ static void registerCDSPass(const PassManagerBuilder &,
                                                        legacy::PassManagerBase &PM) {
        PM.add(new CDSPass());
 }
+
+/* Enable the pass when opt level is greater than 0 */
+static RegisterStandardPasses 
+       RegisterMyPass1(PassManagerBuilder::EP_OptimizerLast,
+registerCDSPass);
+
+/* Enable the pass when opt level is 0 */
 static RegisterStandardPasses 
-       RegisterMyPass(PassManagerBuilder::EP_OptimizerLast,
+       RegisterMyPass2(PassManagerBuilder::EP_EnabledOnOptLevel0,
 registerCDSPass);