Add README file

[c11tester.git] / CDSPass.cpp

diff --git a/CDSPass.cpp b/CDSPass.cpp
index dede6bc6b0652e27aa59524f8b15644568489a1f..432d98f2d0cd0c23e4b31c148f2fc86888320058 100644 (file)
--- a/CDSPass.cpp
+++ b/CDSPass.cpp
@@ -89,7 +89,6 @@ Type * Int64PtrTy;
 Type * VoidTy;
 
 static const size_t kNumberOfAccessSizes = 4;
-static const int volatile_order = 6;
 
 int getAtomicOrderIndex(AtomicOrdering order){
        switch (order) {
@@ -199,9 +198,9 @@ void CDSPass::initializeCallbacks(Module &M) {
                CDSLoad[i]  = M.getOrInsertFunction(LoadName, VoidTy, PtrTy);
                CDSStore[i] = M.getOrInsertFunction(StoreName, VoidTy, PtrTy);
                CDSVolatileLoad[i]  = M.getOrInsertFunction(VolatileLoadName,
-                                                                       Ty, PtrTy, OrdTy, Int8PtrTy);
+                                                                       Ty, PtrTy, Int8PtrTy);
                CDSVolatileStore[i] = M.getOrInsertFunction(VolatileStoreName, 
-                                                                       VoidTy, PtrTy, Ty, OrdTy, Int8PtrTy);
+                                                                       VoidTy, PtrTy, Ty, Int8PtrTy);
                CDSAtomicInit[i] = M.getOrInsertFunction(AtomicInitName, 
                                                                VoidTy, PtrTy, Ty, Int8PtrTy);
                CDSAtomicLoad[i]  = M.getOrInsertFunction(AtomicLoadName, 
@@ -328,6 +327,7 @@ bool CDSPass::runOnFunction(Function &F) {
 
                bool Res = false;
                bool HasAtomic = false;
+               bool HasVolatile = false;
                const DataLayout &DL = F.getParent()->getDataLayout();
 
                // errs() << "--- " << F.getName() << "---\n";
@@ -342,9 +342,10 @@ bool CDSPass::runOnFunction(Function &F) {
                                        StoreInst *SI = dyn_cast<StoreInst>(&I);
                                        bool isVolatile = ( LI ? LI->isVolatile() : SI->isVolatile() );
 
-                                       if (isVolatile)
+                                       if (isVolatile) {
                                                VolatileLoadsAndStores.push_back(&I);
-                                       else
+                                               HasVolatile = true;
+                                       } else
                                                LocalLoadsAndStores.push_back(&I);
                                } else if (isa<CallInst>(I) || isa<InvokeInst>(I)) {
                                        // not implemented yet
@@ -367,7 +368,7 @@ bool CDSPass::runOnFunction(Function &F) {
                }
 
                // only instrument functions that contain atomics
-               if (Res && HasAtomic) {
+               if (Res && ( HasAtomic || HasVolatile) ) {
                        IRBuilder<> IRB(F.getEntryBlock().getFirstNonPHI());
                        /* Unused for now
                        Value *ReturnAddress = IRB.CreateCall(
@@ -385,8 +386,6 @@ bool CDSPass::runOnFunction(Function &F) {
 
                        Res = true;
                }
-
-               F.dump();
        }
 
        return false;
@@ -508,8 +507,7 @@ bool CDSPass::instrumentVolatile(Instruction * I, const DataLayout &DL) {
                if (Idx < 0)
                        return false;
 
-               Value *order = ConstantInt::get(OrdTy, volatile_order);
-               Value *args[] = {Addr, order, position};
+               Value *args[] = {Addr, position};
                Instruction* funcInst=CallInst::Create(CDSVolatileLoad[Idx], args);
                ReplaceInstWithInst(LI, funcInst);
        } else if (StoreInst *SI = dyn_cast<StoreInst>(I)) {
@@ -520,8 +518,7 @@ bool CDSPass::instrumentVolatile(Instruction * I, const DataLayout &DL) {
                        return false;
 
                Value *val = SI->getValueOperand();
-               Value *order = ConstantInt::get(OrdTy, volatile_order);
-               Value *args[] = {Addr, val, order, position};
+               Value *args[] = {Addr, val, position};
                Instruction* funcInst=CallInst::Create(CDSVolatileStore[Idx], args);
                ReplaceInstWithInst(SI, funcInst);
        } else {
@@ -749,7 +746,7 @@ bool CDSPass::instrumentAtomicCall(CallInst *CI, const DataLayout &DL) {
 
                return true;
        } else if (funName.contains("atomic") && 
-                                       funName.contains("EEEE5store") ) {
+                                       funName.contains("store") ) {
                // does this version of call always have an atomic order as an argument?
                Value *OrigVal = parameters[1];