[TSAR, Analysis] Fix CallsToPtrArgumentsMemorySources, passes queue.

Author: VolandTymim

lib/Analysis/Memory/RestrictionArgumentsPass.cpp

@@ -13,6 +13,8 @@
 #include <llvm/Analysis/CallGraphSCCPass.h>
 #include <llvm/ADT/SCCIterator.h>
 #include <llvm/InitializePasses.h>
+#include <llvm/IR/GetElementPtrTypeIterator.h>
+#include <llvm/IR/Operator.h>
 
 using namespace tsar;
 using namespace llvm;
@@ -136,20 +138,15 @@ DenseMap<CallInst*, FunctionCallWithMemorySources> fillCallsToPtrArgumentsMemory
         auto& memorySources = WorkPair.mMemorySources;
         workList.pop_back();
         for (auto* U : I->users()) {
-            if (auto* GepU = dyn_cast<GetElementPtrInst>(U)) {
+            if (auto* GepU = dyn_cast<GEPOperator>(U)) {
                 workList.push_back(ValueWithMemorySources(GepU, memorySources));
-            }
-            if (auto* CastI = dyn_cast<CastInst>(U)) {
+            } else if (auto* CastI = dyn_cast<CastInst>(U)) {
                 workList.push_back(ValueWithMemorySources(CastI, memorySources));
-            }
-            if (auto* SelectI = dyn_cast<SelectInst>(U)) {
+            } else if (auto* SelectI = dyn_cast<SelectInst>(U)) {
                 workList.push_back(ValueWithMemorySources(SelectI, memorySources));
-            }
-            // for the new malloc behaviour
-            if (auto* LoadI = dyn_cast<LoadInst>(U)) {
+            } else if (auto* LoadI = dyn_cast<LoadInst>(U)) {
               workList.push_back(ValueWithMemorySources(LoadI, memorySources));
-            }
-            if (auto* CallI = dyn_cast<CallInst>(U)) {
+            } else if (auto* CallI = dyn_cast<CallInst>(U)) {
                 if (TargetFunctionsCalls.count(CallI)) {
                     LLVM_DEBUG(
                         dbgs() << "\tFound CallInst in TargetCalls: ";

lib/Core/Query.cpp

@@ -143,6 +143,7 @@ void addAfterSROAAnalysis(const GlobalOptions &GO, const DataLayout &DL,
   Passes.add(createGlobalLiveMemoryPass());
   Passes.add(createFunctionMemoryAttrsAnalysis());
   Passes.add(createDIDependencyAnalysisPass());
+  Passes.add(createRestrictionArgumentsPass());
 }
 
 void addAfterLoopRotateAnalysis(legacy::PassManager &Passes) {
@@ -270,7 +271,6 @@ void DefaultQueryManager::run(llvm::Module *M, TransformationContext *Ctx) {
   // avoid dangling handles. So, we add pool before environment in the manager.
   Passes.add(createDIMemoryTraitPoolStorage());
   Passes.add(createDIMemoryEnvironmentStorage());
-  Passes.add(createRestrictionArgumentsPass());
 #ifdef APC_FOUND
   Passes.add(createAPCContextStorage());
   addIfNecessary(createAPCLoopInfoBasePass(), mPrintPasses,

test/analysis/restriction_arguments/problematic/test2_global.c renamed to test/analysis/restriction_arguments/global/test1_global.c

@@ -1,12 +1,12 @@
 #include <stdlib.h>
 
-int b[10][20];
+int b[10];
 
 int foo(int *a, int* b) {
 	return a[0] + b[0];
 }
 
 int main(int argc, char const *argv[]) {
 	int *a = malloc(sizeof(int) * 5);
-	return foo(a, b[0]);
+	return foo(a[2], b);
 }

test/analysis/restriction_arguments/global/test2_global.c

@@ -0,0 +1,12 @@
+#include <stdlib.h>
+
+int b[10];
+
+int foo(int *a, int* b) {
+	return a[0] + b[0];
+}
+
+int main(int argc, char const *argv[]) {
+	int (*a)[10] = malloc(sizeof(int) * 10 * 20);
+	return foo(a[2], b);
+}

test/analysis/restriction_arguments/global/test3_global.c

@@ -0,0 +1,13 @@
+#include <stdlib.h>
+
+int b[10][20];
+
+int foo(int *a, int* b) {
+	return a[0] + b[0];
+}
+
+int main(int argc, char const *argv[]) {
+	int *a1 = malloc(sizeof(int) * 5);
+	int (*a2)[10] = malloc(sizeof(int) * 10 * 20);
+	return foo(a1, b) + foo(a2[2], b);
+}

test/analysis/restriction_arguments/global/test4_global.c

@@ -0,0 +1,17 @@
+#include <stdlib.h>
+
+int (*b)[10];
+
+int foo(int *a, int* b) {
+	return a[0] + bar(a, b);
+}
+
+int bar(int *a, int* b) {
+	return a[5] + 5 + b[7];
+}
+
+int main(int argc, char const *argv[]) {
+	int (*a)[10] = malloc(sizeof(int) * 10 * 20);
+	b = malloc(sizeof(int) * 10 * 20);
+	return foo(a[2], b[3]);
+}

test/analysis/restriction_arguments/global/test5_global.c

@@ -0,0 +1,20 @@
+#include <stdlib.h>
+
+int (*b)[10];
+int *a1;
+int (*a2)[10];
+
+int foo(int *a, int* b) {
+	return a[0] + bar(a, b);
+}
+
+int bar(int *a, int* b) {
+	return a[5] + 5 + b[7];
+}
+
+int main(int argc, char const *argv[]) {
+	a1 = malloc(sizeof(int) * 5);
+	a2 = malloc(sizeof(int) * 10 * 20);
+	b = malloc(sizeof(int) * 10 * 20);
+	return foo(a1, b[3]) + foo(a2[2], b[3]);
+}

test/analysis/restriction_arguments/problematic/test10.c

@@ -0,0 +1,29 @@
+#include <stdlib.h>
+
+int f2(char *a, char* b) {
+	return a[0] + b[0] + 2;
+}
+
+int foo(char *a, char* b, char* c) {
+	return f2(a, c) + f2(b, c);
+}
+
+char *bar() {
+	return "BARRRR";
+}
+
+char *yaf() {
+	return "YAFFFF";
+}
+
+int main(int argc, char const *argv[]) {
+	char *a = bar();
+
+	char *b = bar();
+
+	char *c = yaf();
+	//Not restrict calls:
+	int r1 = foo(a, b, c);
+
+	return r1;
+}

test/analysis/restriction_arguments/problematic/test9_non.c

@@ -0,0 +1,26 @@
+#include <stdlib.h>
+
+int f2(int *a, int* b) {
+	return a[0] + b[0] + 2;
+}
+
+int* f3(int *a, int* b) {
+	return a + 1;
+}
+
+int f1(int *a, int* b) {
+	return f2(f3(a, b), a);
+}
+
+int main(int argc, char const *argv[]) {
+	int *a = malloc(sizeof(int) * 5);
+	int b[10];
+	a[0] = 5;
+	a[1] = 6;
+	a[2] = 7;
+	b[0] = 10;
+	b[1] = 20;
+	b[2] = 30;
+
+	return f1(a, b);
+}