From 76735c28708f3974e90756ba690e9fd71f9302e5 Mon Sep 17 00:00:00 2001
From: Jan Rochel <jan.rochel@cea.fr>
Date: Thu, 29 Feb 2024 11:20:04 +0100
Subject: [PATCH] [alias] disable printing of graphs for tests

The next commit reworks the graph structure completely. For its
correctness only the alias sets are relevant. So we temporarily disable
graph output such that the diff of the next commit only includes changes
to the alias sets.
---
 .../tests/basic/oracle/addrof.res.oracle      |  22 --
 .../tests/basic/oracle/assignment1.res.oracle |  15 --
 .../tests/basic/oracle/assignment2.res.oracle |  20 --
 .../tests/basic/oracle/assignment3.res.oracle |  14 --
 .../tests/basic/oracle/assignment4.res.oracle |  23 --
 .../tests/basic/oracle/assignment5.res.oracle |  23 --
 .../alias/tests/basic/oracle/cast1.res.oracle |  15 --
 .../basic/oracle/conditional1.res.oracle      |  14 --
 .../basic/oracle/conditional2.res.oracle      |  20 --
 .../basic/oracle/conditional3.res.oracle      |  34 ---
 .../tests/basic/oracle/function1.res.oracle   |  32 ---
 .../tests/basic/oracle/function2.res.oracle   |  25 ---
 .../tests/basic/oracle/function3.res.oracle   |  30 ---
 .../tests/basic/oracle/function4.res.oracle   |  19 --
 .../tests/basic/oracle/function5.res.oracle   |  23 --
 .../tests/basic/oracle/function6.res.oracle   |  24 ---
 .../tests/basic/oracle/globctr.res.oracle     |  15 --
 .../alias/tests/basic/oracle/loop.res.oracle  |  19 --
 .../tests/basic/oracle/steensgaard.res.oracle |  24 ---
 .../tests/basic/oracle/switch1.res.oracle     |  17 --
 .../tests/basic/oracle/switch2.res.oracle     |  19 --
 .../tests/basic/oracle/while_for1.res.oracle  |  13 --
 .../tests/basic/oracle/while_for2.res.oracle  |  11 -
 .../tests/basic/oracle/while_for3.res.oracle  |  14 --
 .../fixed_bugs/oracle/empty_nodes.res.oracle  |  21 --
 .../fixed_bugs/oracle/gzip124.res.oracle      |  15 --
 .../tests/fixed_bugs/oracle/origin.res.oracle |  11 -
 .../fixed_bugs/oracle/origin_simpl.res.oracle |   7 -
 .../tests/fixed_bugs/oracle/semver.res.oracle |  10 -
 .../tests/fixed_bugs/oracle/tkn-2.res.oracle  |   9 -
 .../fixed_bugs/oracle/union_vmap.res.oracle   |  24 ---
 .../tests/offsets/oracle/array1.res.oracle    |  17 --
 .../tests/offsets/oracle/array2.res.oracle    |  14 --
 .../tests/offsets/oracle/array3.res.oracle    |  17 --
 .../tests/offsets/oracle/collapse1.res.oracle |  14 --
 .../tests/offsets/oracle/collapse2.res.oracle |  12 --
 .../tests/offsets/oracle/collapse3.res.oracle |  12 --
 .../offsets/oracle/jfla_running_ex.res.oracle |  82 --------
 .../tests/offsets/oracle/nested1.res.oracle   |  75 -------
 .../tests/offsets/oracle/nested2.res.oracle   |  39 ----
 .../offsets/oracle/structure1.res.oracle      |  20 --
 .../offsets/oracle/structure2.res.oracle      |  17 --
 .../offsets/oracle/structure3.res.oracle      |  29 ---
 .../offsets/oracle/structure4.res.oracle      |  22 --
 .../offsets/oracle/structure5.res.oracle      |  41 ----
 .../real_world/oracle/example1.res.oracle     | 178 ----------------
 .../real_world/oracle/example2.res.oracle     | 198 ------------------
 .../real_world/oracle/function1_v2.res.oracle |  25 ---
 src/plugins/alias/tests/test_config           |   2 +-
 49 files changed, 1 insertion(+), 1395 deletions(-)

diff --git a/src/plugins/alias/tests/basic/oracle/addrof.res.oracle b/src/plugins/alias/tests/basic/oracle/addrof.res.oracle
index c2b1c63088a..c721b21001c 100644
--- a/src/plugins/alias/tests/basic/oracle/addrof.res.oracle
+++ b/src/plugins/alias/tests/basic/oracle/addrof.res.oracle
@@ -2,38 +2,16 @@
 [alias] analysing function: main
 [alias] analysing instruction: a = & x;
 [alias] May-aliases after instruction  a = & x;  are  { *a; x }
-[alias] May-alias graph after instruction  a = & x;  is
-  0:{ a } â†’ 1:{ x }   1:{ x } â†’ 3:{  }
 [alias] analysing instruction: b = & y;
 [alias] May-aliases after instruction  b = & y;  are  { *a; x }  { *b; y }
-[alias] May-alias graph after instruction  b = & y;  is
-  0:{ a } â†’ 1:{ x }   1:{ x } â†’ 3:{  }   5:{ b } â†’ 6:{ y }
-  6:{ y } â†’ 8:{  }
 [alias] analysing instruction: y = & z;
 [alias] May-aliases after instruction  y = & z;  are
   { *a; x }  { *b; y }  { *(*b); *y; z }
-[alias] May-alias graph after instruction  y = & z;  is
-  0:{ a } â†’ 1:{ x }   1:{ x } â†’ 3:{  }   5:{ b } â†’ 6:{ y }
-  6:{ y } â†’ 8:{ z }   8:{ z } â†’ 11:{  }
 [alias] analysing instruction: *y = x;
 [alias] May-aliases after instruction  *y = x;  are
   { *(*b); *a; *y; x }  { *b; a; y }
-[alias] May-alias graph after instruction  *y = x;  is
-  0:{ a } â†’ 8:{ *y; x }   5:{ b } â†’ 6:{ y }   6:{ y } â†’ 8:{ *y; x }
-  8:{ *y; x } â†’ 3:{  }
 [alias] analysing instruction: __retres = 0;
 [alias] May-aliases after instruction  __retres = 0;  are
   { *b; a; y }  { *(*b); *a; *y; x; z }
-[alias] May-alias graph after instruction  __retres = 0;  is
-  0:{ a } â†’ 1:{ *y; x; z }   1:{ *y; x; z } â†’ 3:{  }
-  5:{ b } â†’ 6:{ y }   6:{ y } â†’ 1:{ *y; x; z }
 [alias] May-aliases at the end of function main:
   { *b; a; y }  { *(*b); *a; *y; x; z }
-[alias] May-alias graph at the end of function main:
-  0:{ a } â†’ 1:{ *y; x; z }   1:{ *y; x; z } â†’ 3:{  }
-  5:{ b } â†’ 6:{ y }   6:{ y } â†’ 1:{ *y; x; z }
-[alias] Summary of function main:
-  formals: 
-  locals: aâ†’{ *y; x; z }  bâ†’{ y }  yâ†’{ *y; x; z }  x  z  p  __retres
-  returns: __retres    state: { *b; a; y }  { *(*b); *a; *y; x; z }
-[alias] Analysis complete
diff --git a/src/plugins/alias/tests/basic/oracle/assignment1.res.oracle b/src/plugins/alias/tests/basic/oracle/assignment1.res.oracle
index 4c31afc87e8..0a62f46e5b1 100644
--- a/src/plugins/alias/tests/basic/oracle/assignment1.res.oracle
+++ b/src/plugins/alias/tests/basic/oracle/assignment1.res.oracle
@@ -2,33 +2,18 @@
 [alias] analysing function: main
 [alias] analysing instruction: int *a = (int *)0;
 [alias] May-aliases after instruction  int *a = (int *)0;  are  <none>
-[alias] May-alias graph after instruction  int *a = (int *)0;  is    <empty>
 [alias] analysing instruction: int *b = (int *)0;
 [alias] May-aliases after instruction  int *b = (int *)0;  are  <none>
-[alias] May-alias graph after instruction  int *b = (int *)0;  is    <empty>
 [alias] analysing instruction: int *c = (int *)0;
 [alias] May-aliases after instruction  int *c = (int *)0;  are  <none>
-[alias] May-alias graph after instruction  int *c = (int *)0;  is    <empty>
 [alias] analysing instruction: int *d = (int *)0;
 [alias] May-aliases after instruction  int *d = (int *)0;  are  <none>
-[alias] May-alias graph after instruction  int *d = (int *)0;  is    <empty>
 [alias] analysing instruction: a = b;
 [alias] May-aliases after instruction  a = b;  are  { a; b }
-[alias] May-alias graph after instruction  a = b;  is    0:{ a; b } â†’ 1:{  }
 [alias] analysing instruction: b = c;
 [alias] May-aliases after instruction  b = c;  are  { a; b; c }
-[alias] May-alias graph after instruction  b = c;  is    0:{ a; b; c } â†’ 1:{  }
 [alias] analysing instruction: a = d;
 [alias] May-aliases after instruction  a = d;  are  { a; b; c; d }
-[alias] May-alias graph after instruction  a = d;  is    0:{ a; b; c; d } â†’ 1:{  }
 [alias] analysing instruction: __retres = 0;
 [alias] May-aliases after instruction  __retres = 0;  are  { a; b; c; d }
-[alias] May-alias graph after instruction  __retres = 0;  is
-  0:{ a; b; c; d } â†’ 1:{  }
 [alias] May-aliases at the end of function main: { a; b; c; d }
-[alias] May-alias graph at the end of function main:
-  0:{ a; b; c; d } â†’ 1:{  }
-[alias] Summary of function main:
-  formals:     locals: a  b  c  d  __retres    returns: __retres
-  state: { a; b; c; d }
-[alias] Analysis complete
diff --git a/src/plugins/alias/tests/basic/oracle/assignment2.res.oracle b/src/plugins/alias/tests/basic/oracle/assignment2.res.oracle
index 1481782c779..02b7661040b 100644
--- a/src/plugins/alias/tests/basic/oracle/assignment2.res.oracle
+++ b/src/plugins/alias/tests/basic/oracle/assignment2.res.oracle
@@ -2,38 +2,18 @@
 [alias] analysing function: main
 [alias] analysing instruction: int **a = (int **)0;
 [alias] May-aliases after instruction  int **a = (int **)0;  are  <none>
-[alias] May-alias graph after instruction  int **a = (int **)0;  is    <empty>
 [alias] analysing instruction: int *b = (int *)0;
 [alias] May-aliases after instruction  int *b = (int *)0;  are  <none>
-[alias] May-alias graph after instruction  int *b = (int *)0;  is    <empty>
 [alias] analysing instruction: int **c = (int **)0;
 [alias] May-aliases after instruction  int **c = (int **)0;  are  <none>
-[alias] May-alias graph after instruction  int **c = (int **)0;  is    <empty>
 [alias] analysing instruction: int *d = (int *)0;
 [alias] May-aliases after instruction  int *d = (int *)0;  are  <none>
-[alias] May-alias graph after instruction  int *d = (int *)0;  is    <empty>
 [alias] analysing instruction: *a = b;
 [alias] May-aliases after instruction  *a = b;  are  { *a; b }
-[alias] May-alias graph after instruction  *a = b;  is
-  0:{ a } â†’ 1:{ *a; b }   1:{ *a; b } â†’ 3:{  }
 [alias] analysing instruction: *c = d;
 [alias] May-aliases after instruction  *c = d;  are  { *a; b }  { *c; d }
-[alias] May-alias graph after instruction  *c = d;  is
-  0:{ a } â†’ 1:{ *a; b }   1:{ *a; b } â†’ 3:{  }   4:{ c } â†’ 5:{ *c; d }
-  5:{ *c; d } â†’ 7:{  }
 [alias] analysing instruction: a = c;
 [alias] May-aliases after instruction  a = c;  are  { a; c }  { *a; *c; b; d }
-[alias] May-alias graph after instruction  a = c;  is
-  0:{ a; c } â†’ 1:{ *a; *c; b; d }   1:{ *a; *c; b; d } â†’ 3:{  }
 [alias] analysing instruction: __retres = 0;
 [alias] May-aliases after instruction  __retres = 0;  are  { a; c }  { *a; *c; b; d }
-[alias] May-alias graph after instruction  __retres = 0;  is
-  0:{ a; c } â†’ 1:{ *a; *c; b; d }   1:{ *a; *c; b; d } â†’ 3:{  }
 [alias] May-aliases at the end of function main: { a; c }  { *a; *c; b; d }
-[alias] May-alias graph at the end of function main:
-  0:{ a; c } â†’ 1:{ *a; *c; b; d }   1:{ *a; *c; b; d } â†’ 3:{  }
-[alias] Summary of function main:
-  formals: 
-  locals: aâ†’{ *a; *c; b; d }  b  câ†’{ *a; *c; b; d }  d  __retres
-  returns: __retres    state: { a; c }  { *a; *c; b; d }
-[alias] Analysis complete
diff --git a/src/plugins/alias/tests/basic/oracle/assignment3.res.oracle b/src/plugins/alias/tests/basic/oracle/assignment3.res.oracle
index 1a83b4c75ed..38afe15b985 100644
--- a/src/plugins/alias/tests/basic/oracle/assignment3.res.oracle
+++ b/src/plugins/alias/tests/basic/oracle/assignment3.res.oracle
@@ -2,28 +2,14 @@
 [alias] analysing function: main
 [alias] analysing instruction: int *a = (int *)0;
 [alias] May-aliases after instruction  int *a = (int *)0;  are  <none>
-[alias] May-alias graph after instruction  int *a = (int *)0;  is    <empty>
 [alias] analysing instruction: int b = 0;
 [alias] May-aliases after instruction  int b = 0;  are  <none>
-[alias] May-alias graph after instruction  int b = 0;  is    <empty>
 [alias] analysing instruction: int *c = (int *)0;
 [alias] May-aliases after instruction  int *c = (int *)0;  are  <none>
-[alias] May-alias graph after instruction  int *c = (int *)0;  is    <empty>
 [alias] analysing instruction: a = & b;
 [alias] May-aliases after instruction  a = & b;  are  <none>
-[alias] May-alias graph after instruction  a = & b;  is    0:{ a } â†’ 1:{ b }
 [alias] analysing instruction: c = & b;
 [alias] May-aliases after instruction  c = & b;  are  { a; c }
-[alias] May-alias graph after instruction  c = & b;  is
-  0:{ a } â†’ 5:{ b }   4:{ c } â†’ 5:{ b }
 [alias] analysing instruction: __retres = 0;
 [alias] May-aliases after instruction  __retres = 0;  are  { a; c }
-[alias] May-alias graph after instruction  __retres = 0;  is
-  0:{ a } â†’ 5:{ b }   4:{ c } â†’ 5:{ b }
 [alias] May-aliases at the end of function main: { a; c }
-[alias] May-alias graph at the end of function main:
-  0:{ a } â†’ 5:{ b }   4:{ c } â†’ 5:{ b }
-[alias] Summary of function main:
-  formals:     locals: aâ†’{ b }  b  câ†’{ b }  __retres
-  returns: __retres    state: { a; c }
-[alias] Analysis complete
diff --git a/src/plugins/alias/tests/basic/oracle/assignment4.res.oracle b/src/plugins/alias/tests/basic/oracle/assignment4.res.oracle
index e526142c5b4..8d9d3556197 100644
--- a/src/plugins/alias/tests/basic/oracle/assignment4.res.oracle
+++ b/src/plugins/alias/tests/basic/oracle/assignment4.res.oracle
@@ -2,41 +2,18 @@
 [alias] analysing function: main
 [alias] analysing instruction: int **a = (int **)0;
 [alias] May-aliases after instruction  int **a = (int **)0;  are  <none>
-[alias] May-alias graph after instruction  int **a = (int **)0;  is    <empty>
 [alias] analysing instruction: int *b = (int *)0;
 [alias] May-aliases after instruction  int *b = (int *)0;  are  <none>
-[alias] May-alias graph after instruction  int *b = (int *)0;  is    <empty>
 [alias] analysing instruction: int **c = (int **)0;
 [alias] May-aliases after instruction  int **c = (int **)0;  are  <none>
-[alias] May-alias graph after instruction  int **c = (int **)0;  is    <empty>
 [alias] analysing instruction: int *d = (int *)0;
 [alias] May-aliases after instruction  int *d = (int *)0;  are  <none>
-[alias] May-alias graph after instruction  int *d = (int *)0;  is    <empty>
 [alias] analysing instruction: *a = b;
 [alias] May-aliases after instruction  *a = b;  are  { *a; b }
-[alias] May-alias graph after instruction  *a = b;  is
-  0:{ a } â†’ 1:{ *a; b }   1:{ *a; b } â†’ 3:{  }
 [alias] analysing instruction: *c = d;
 [alias] May-aliases after instruction  *c = d;  are  { *a; b }  { *c; d }
-[alias] May-alias graph after instruction  *c = d;  is
-  0:{ a } â†’ 1:{ *a; b }   1:{ *a; b } â†’ 3:{  }   4:{ c } â†’ 5:{ *c; d }
-  5:{ *c; d } â†’ 7:{  }
 [alias] analysing instruction: b = d;
 [alias] May-aliases after instruction  b = d;  are  { a; c }  { *a; *c; b; d }
-[alias] May-alias graph after instruction  b = d;  is
-  0:{ a } â†’ 1:{ *a; *c; b; d }   1:{ *a; *c; b; d } â†’ 3:{  }
-  4:{ c } â†’ 1:{ *a; *c; b; d }
 [alias] analysing instruction: __retres = 0;
 [alias] May-aliases after instruction  __retres = 0;  are  { a; c }  { *a; *c; b; d }
-[alias] May-alias graph after instruction  __retres = 0;  is
-  0:{ a } â†’ 1:{ *a; *c; b; d }   1:{ *a; *c; b; d } â†’ 3:{  }
-  4:{ c } â†’ 1:{ *a; *c; b; d }
 [alias] May-aliases at the end of function main: { a; c }  { *a; *c; b; d }
-[alias] May-alias graph at the end of function main:
-  0:{ a } â†’ 1:{ *a; *c; b; d }   1:{ *a; *c; b; d } â†’ 3:{  }
-  4:{ c } â†’ 1:{ *a; *c; b; d }
-[alias] Summary of function main:
-  formals: 
-  locals: aâ†’{ *a; *c; b; d }  b  câ†’{ *a; *c; b; d }  d  __retres
-  returns: __retres    state: { a; c }  { *a; *c; b; d }
-[alias] Analysis complete
diff --git a/src/plugins/alias/tests/basic/oracle/assignment5.res.oracle b/src/plugins/alias/tests/basic/oracle/assignment5.res.oracle
index dbf7dc9fa16..023e852d039 100644
--- a/src/plugins/alias/tests/basic/oracle/assignment5.res.oracle
+++ b/src/plugins/alias/tests/basic/oracle/assignment5.res.oracle
@@ -2,43 +2,20 @@
 [alias] analysing function: main
 [alias] analysing instruction: int ***a = (int ***)0;
 [alias] May-aliases after instruction  int ***a = (int ***)0;  are  <none>
-[alias] May-alias graph after instruction  int ***a = (int ***)0;  is    <empty>
 [alias] analysing instruction: int **b = (int **)0;
 [alias] May-aliases after instruction  int **b = (int **)0;  are  <none>
-[alias] May-alias graph after instruction  int **b = (int **)0;  is    <empty>
 [alias] analysing instruction: int *c = (int *)0;
 [alias] May-aliases after instruction  int *c = (int *)0;  are  <none>
-[alias] May-alias graph after instruction  int *c = (int *)0;  is    <empty>
 [alias] analysing instruction: int *d = (int *)0;
 [alias] May-aliases after instruction  int *d = (int *)0;  are  <none>
-[alias] May-alias graph after instruction  int *d = (int *)0;  is    <empty>
 [alias] analysing instruction: *a = b;
 [alias] May-aliases after instruction  *a = b;  are  { *a; b }
-[alias] May-alias graph after instruction  *a = b;  is
-  0:{ a } â†’ 1:{ *a; b }   1:{ *a; b } â†’ 3:{  }
 [alias] analysing instruction: *b = c;
 [alias] May-aliases after instruction  *b = c;  are  { *a; b }  { *(*a); *b; c }
-[alias] May-alias graph after instruction  *b = c;  is
-  0:{ a } â†’ 1:{ *a; b }   1:{ *a; b } â†’ 3:{ *b; c }
-  3:{ *b; c } â†’ 5:{  }
 [alias] analysing instruction: d = *(*a);
 [alias] May-aliases after instruction  d = *(*a);  are
   { *a; b }  { *(*a); *b; c; d }
-[alias] May-alias graph after instruction  d = *(*a);  is
-  0:{ a } â†’ 1:{ *a; b }   1:{ *a; b } â†’ 6:{ *(*a); *b; c; d }
-  6:{ *(*a); *b; c; d } â†’ 7:{  }
 [alias] analysing instruction: __retres = 0;
 [alias] May-aliases after instruction  __retres = 0;  are
   { *a; b }  { *(*a); *b; c; d }
-[alias] May-alias graph after instruction  __retres = 0;  is
-  0:{ a } â†’ 1:{ *a; b }   1:{ *a; b } â†’ 6:{ *(*a); *b; c; d }
-  6:{ *(*a); *b; c; d } â†’ 7:{  }
 [alias] May-aliases at the end of function main: { *a; b }  { *(*a); *b; c; d }
-[alias] May-alias graph at the end of function main:
-  0:{ a } â†’ 1:{ *a; b }   1:{ *a; b } â†’ 6:{ *(*a); *b; c; d }
-  6:{ *(*a); *b; c; d } â†’ 7:{  }
-[alias] Summary of function main:
-  formals: 
-  locals: aâ†’{ *a; b }  bâ†’{ *(*a); *b; c; d }  c  d  __retres
-  returns: __retres    state: { *a; b }  { *(*a); *b; c; d }
-[alias] Analysis complete
diff --git a/src/plugins/alias/tests/basic/oracle/cast1.res.oracle b/src/plugins/alias/tests/basic/oracle/cast1.res.oracle
index 2ff8f37ad86..8a1dd1b9c58 100644
--- a/src/plugins/alias/tests/basic/oracle/cast1.res.oracle
+++ b/src/plugins/alias/tests/basic/oracle/cast1.res.oracle
@@ -2,33 +2,18 @@
 [alias] analysing function: main
 [alias] analysing instruction: int *a = (int *)0;
 [alias] May-aliases after instruction  int *a = (int *)0;  are  <none>
-[alias] May-alias graph after instruction  int *a = (int *)0;  is    <empty>
 [alias] analysing instruction: int *b = (int *)0;
 [alias] May-aliases after instruction  int *b = (int *)0;  are  <none>
-[alias] May-alias graph after instruction  int *b = (int *)0;  is    <empty>
 [alias] analysing instruction: float *c = (float *)0;
 [alias] May-aliases after instruction  float *c = (float *)0;  are  <none>
-[alias] May-alias graph after instruction  float *c = (float *)0;  is    <empty>
 [alias] analysing instruction: float *d = (float *)0;
 [alias] May-aliases after instruction  float *d = (float *)0;  are  <none>
-[alias] May-alias graph after instruction  float *d = (float *)0;  is    <empty>
 [alias] analysing instruction: a = (int *)c;
 [alias:unsafe-cast] cast1.c:10: Warning: unsafe cast from float * to int *
 [alias] May-aliases after instruction  a = (int *)c;  are  { a; c }
-[alias] May-alias graph after instruction  a = (int *)c;  is    0:{ a; c } â†’ 1:{  }
 [alias] analysing instruction: d = (float *)b;
 [alias:unsafe-cast] cast1.c:11: Warning: unsafe cast from int * to float *
 [alias] May-aliases after instruction  d = (float *)b;  are  { a; c }  { b; d }
-[alias] May-alias graph after instruction  d = (float *)b;  is
-  0:{ a; c } â†’ 1:{  }   4:{ b; d } â†’ 5:{  }
 [alias] analysing instruction: __retres = 0;
 [alias] May-aliases after instruction  __retres = 0;  are  { a; c }  { b; d }
-[alias] May-alias graph after instruction  __retres = 0;  is
-  0:{ a; c } â†’ 1:{  }   4:{ b; d } â†’ 5:{  }
 [alias] May-aliases at the end of function main: { a; c }  { b; d }
-[alias] May-alias graph at the end of function main:
-  0:{ a; c } â†’ 1:{  }   4:{ b; d } â†’ 5:{  }
-[alias] Summary of function main:
-  formals:     locals: a  b  c  d  __retres    returns: __retres
-  state: { a; c }  { b; d }
-[alias] Analysis complete
diff --git a/src/plugins/alias/tests/basic/oracle/conditional1.res.oracle b/src/plugins/alias/tests/basic/oracle/conditional1.res.oracle
index ede3b2e36f8..878ffd6070b 100644
--- a/src/plugins/alias/tests/basic/oracle/conditional1.res.oracle
+++ b/src/plugins/alias/tests/basic/oracle/conditional1.res.oracle
@@ -2,30 +2,16 @@
 [alias] analysing function: main
 [alias] analysing instruction: int *a = (int *)0;
 [alias] May-aliases after instruction  int *a = (int *)0;  are  <none>
-[alias] May-alias graph after instruction  int *a = (int *)0;  is    <empty>
 [alias] analysing instruction: int *b = (int *)0;
 [alias] May-aliases after instruction  int *b = (int *)0;  are  <none>
-[alias] May-alias graph after instruction  int *b = (int *)0;  is    <empty>
 [alias] analysing instruction: int *c = (int *)0;
 [alias] May-aliases after instruction  int *c = (int *)0;  are  <none>
-[alias] May-alias graph after instruction  int *c = (int *)0;  is    <empty>
 [alias] analysing instruction: a = b;
 [alias] May-aliases after instruction  a = b;  are  { a; b }
-[alias] May-alias graph after instruction  a = b;  is    0:{ a; b } â†’ 1:{  }
 [alias] analysing instruction: a = c;
 [alias] May-aliases after instruction  a = c;  are  { a; c }
-[alias] May-alias graph after instruction  a = c;  is    4:{ a; c } â†’ 5:{  }
 [alias] analysing instruction: *a = 4;
 [alias] May-aliases after instruction  *a = 4;  are  { a; b; c }
-[alias] May-alias graph after instruction  *a = 4;  is    0:{ a; b; c } â†’ 1:{  }
 [alias] analysing instruction: __retres = 0;
 [alias] May-aliases after instruction  __retres = 0;  are  { a; b; c }
-[alias] May-alias graph after instruction  __retres = 0;  is
-  0:{ a; b; c } â†’ 1:{  }
 [alias] May-aliases at the end of function main: { a; b; c }
-[alias] May-alias graph at the end of function main:
-  0:{ a; b; c } â†’ 1:{  }
-[alias] Summary of function main:
-  formals:     locals: a  b  c  __retres    returns: __retres
-  state: { a; b; c }
-[alias] Analysis complete
diff --git a/src/plugins/alias/tests/basic/oracle/conditional2.res.oracle b/src/plugins/alias/tests/basic/oracle/conditional2.res.oracle
index e89a21d4d30..74a6ebea0fc 100644
--- a/src/plugins/alias/tests/basic/oracle/conditional2.res.oracle
+++ b/src/plugins/alias/tests/basic/oracle/conditional2.res.oracle
@@ -2,38 +2,18 @@
 [alias] analysing function: main
 [alias] analysing instruction: b = & c;
 [alias] May-aliases after instruction  b = & c;  are  { *b; c }
-[alias] May-alias graph after instruction  b = & c;  is
-  0:{ b } â†’ 1:{ c }   1:{ c } â†’ 3:{  }
 [alias] analysing instruction: c = & d;
 [alias] May-aliases after instruction  c = & d;  are  { *b; c }  { *(*b); *c; d }
-[alias] May-alias graph after instruction  c = & d;  is
-  0:{ b } â†’ 1:{ c }   1:{ c } â†’ 3:{ d }   3:{ d } â†’ 6:{  }
 [alias] analysing instruction: d = & e;
 [alias] May-aliases after instruction  d = & e;  are  { *b; c }  { *(*b); *c; d }
-[alias] May-alias graph after instruction  d = & e;  is
-  0:{ b } â†’ 1:{ c }   1:{ c } â†’ 3:{ d }   3:{ d } â†’ 6:{ e }
 [alias] analysing instruction: a = b;
 [alias] May-aliases after instruction  a = b;  are
   { *a; *b; c }  { *(*a); *(*b); *c; d }  { a; b }
-[alias] May-alias graph after instruction  a = b;  is
-  3:{ d } â†’ 6:{ e }   10:{ a; b } â†’ 11:{ c }   11:{ c } â†’ 3:{ d }
 [alias] analysing instruction: a = & c;
 [alias] May-aliases after instruction  a = & c;  are
   { *a; *b; c }  { *(*a); *(*b); *c; d }  { a; b }
-[alias] May-alias graph after instruction  a = & c;  is
-  0:{ b } â†’ 13:{ c }   3:{ d } â†’ 6:{ e }   12:{ a } â†’ 13:{ c }
-  13:{ c } â†’ 3:{ d }
 [alias] analysing instruction: __retres = 0;
 [alias] May-aliases after instruction  __retres = 0;  are
   { *a; *b; c }  { *(*a); *(*b); *c; d }  { a; b }
-[alias] May-alias graph after instruction  __retres = 0;  is
-  3:{ d } â†’ 6:{ e }   10:{ a; b } â†’ 11:{ c }   11:{ c } â†’ 3:{ d }
 [alias] May-aliases at the end of function main:
   { *a; *b; c }  { *(*a); *(*b); *c; d }  { a; b }
-[alias] May-alias graph at the end of function main:
-  3:{ d } â†’ 6:{ e }   10:{ a; b } â†’ 11:{ c }   11:{ c } â†’ 3:{ d }
-[alias] Summary of function main:
-  formals: 
-  locals: aâ†’{ c }  bâ†’{ c }  câ†’{ d }  dâ†’{ e }  e  __retres
-  returns: __retres    state: { *a; *b; c }  { *(*a); *(*b); *c; d }  { a; b }
-[alias] Analysis complete
diff --git a/src/plugins/alias/tests/basic/oracle/conditional3.res.oracle b/src/plugins/alias/tests/basic/oracle/conditional3.res.oracle
index 8cc6d480f52..d91937c0431 100644
--- a/src/plugins/alias/tests/basic/oracle/conditional3.res.oracle
+++ b/src/plugins/alias/tests/basic/oracle/conditional3.res.oracle
@@ -2,68 +2,34 @@
 [alias] analysing function: main
 [alias] analysing instruction: a = b;
 [alias] May-aliases after instruction  a = b;  are  { a; b }
-[alias] May-alias graph after instruction  a = b;  is    0:{ a; b } â†’ 1:{  }
 [alias] analysing instruction: b = & i;
 [alias] May-aliases after instruction  b = & i;  are  { a; b }  { *a; *b; i }
-[alias] May-alias graph after instruction  b = & i;  is
-  0:{ a; b } â†’ 1:{ i }   1:{ i } â†’ 5:{  }
 [alias] analysing instruction: i = & x;
 [alias] May-aliases after instruction  i = & x;  are
   { a; b }  { *a; *b; i }  { *(*a); *(*b); *i; x }
-[alias] May-alias graph after instruction  i = & x;  is
-  0:{ a; b } â†’ 1:{ i }   1:{ i } â†’ 5:{ x }   5:{ x } â†’ 8:{  }
 [alias] analysing instruction: x = & t;
 [alias] May-aliases after instruction  x = & t;  are
   { a; b }  { *a; *b; i }  { *(*a); *(*b); *i; x }
   { *(*(*a)); *(*(*b)); *(*i); *x; t }
-[alias] May-alias graph after instruction  x = & t;  is
-  0:{ a; b } â†’ 1:{ i }   1:{ i } â†’ 5:{ x }   5:{ x } â†’ 8:{ t }
-  8:{ t } â†’ 11:{  }
 [alias] analysing instruction: a = c;
 [alias] May-aliases after instruction  a = c;  are  { a; c }
-[alias] May-alias graph after instruction  a = c;  is    13:{ a; c } â†’ 14:{  }
 [alias] analysing instruction: c = & j;
 [alias] May-aliases after instruction  c = & j;  are  { a; c }  { *a; *c; j }
-[alias] May-alias graph after instruction  c = & j;  is
-  13:{ a; c } â†’ 14:{ j }   14:{ j } â†’ 18:{  }
 [alias] analysing instruction: j = & y;
 [alias] May-aliases after instruction  j = & y;  are
   { a; c }  { *a; *c; j }  { *(*a); *(*c); *j; y }
-[alias] May-alias graph after instruction  j = & y;  is
-  13:{ a; c } â†’ 14:{ j }   14:{ j } â†’ 18:{ y }   18:{ y } â†’ 21:{  }
 [alias] analysing instruction: y = & u;
 [alias] May-aliases after instruction  y = & u;  are
   { a; c }  { *a; *c; j }  { *(*a); *(*c); *j; y }
   { *(*(*a)); *(*(*c)); *(*j); *y; u }
-[alias] May-alias graph after instruction  y = & u;  is
-  13:{ a; c } â†’ 14:{ j }   14:{ j } â†’ 18:{ y }   18:{ y } â†’ 21:{ u }
-  21:{ u } â†’ 24:{  }
 [alias] analysing instruction: p = 0;
 [alias] May-aliases after instruction  p = 0;  are
   { a; b; c }  { *a; *b; *c; i; j }  { *(*a); *(*b); *(*c); *i; *j; x; y }
   { *(*(*a)); *(*(*b)); *(*(*c)); *(*i); *(*j); *x; *y; t; u }
-[alias] May-alias graph after instruction  p = 0;  is
-  0:{ a; b; c } â†’ 1:{ i; j }   1:{ i; j } â†’ 5:{ x; y }
-  5:{ x; y } â†’ 8:{ t; u }   8:{ t; u } â†’ 11:{  }
 [alias] analysing instruction: __retres = 0;
 [alias] May-aliases after instruction  __retres = 0;  are
   { a; b; c }  { *a; *b; *c; i; j }  { *(*a); *(*b); *(*c); *i; *j; x; y }
   { *(*(*a)); *(*(*b)); *(*(*c)); *(*i); *(*j); *x; *y; t; u }
-[alias] May-alias graph after instruction  __retres = 0;  is
-  0:{ a; b; c } â†’ 1:{ i; j }   1:{ i; j } â†’ 5:{ x; y }
-  5:{ x; y } â†’ 8:{ t; u }   8:{ t; u } â†’ 11:{  }
 [alias] May-aliases at the end of function main:
   { a; b; c }  { *a; *b; *c; i; j }  { *(*a); *(*b); *(*c); *i; *j; x; y }
   { *(*(*a)); *(*(*b)); *(*(*c)); *(*i); *(*j); *x; *y; t; u }
-[alias] May-alias graph at the end of function main:
-  0:{ a; b; c } â†’ 1:{ i; j }   1:{ i; j } â†’ 5:{ x; y }
-  5:{ x; y } â†’ 8:{ t; u }   8:{ t; u } â†’ 11:{  }
-[alias] Summary of function main:
-  formals: 
-  locals: aâ†’{ i; j }  bâ†’{ i; j }  câ†’{ i; j }  iâ†’{ x; y }  jâ†’{ x; y }
-           xâ†’{ t; u }  yâ†’{ t; u }  t  u  p  __retres
-  returns: __retres
-  state: { a; b; c }  { *a; *b; *c; i; j }
-         { *(*a); *(*b); *(*c); *i; *j; x; y }
-         { *(*(*a)); *(*(*b)); *(*(*c)); *(*i); *(*j); *x; *y; t; u }
-[alias] Analysis complete
diff --git a/src/plugins/alias/tests/basic/oracle/function1.res.oracle b/src/plugins/alias/tests/basic/oracle/function1.res.oracle
index 53a681adaf7..d97b433f717 100644
--- a/src/plugins/alias/tests/basic/oracle/function1.res.oracle
+++ b/src/plugins/alias/tests/basic/oracle/function1.res.oracle
@@ -2,62 +2,30 @@
 [alias] analysing function: main
 [alias] analysing instruction: int *a = (int *)0;
 [alias] May-aliases after instruction  int *a = (int *)0;  are  <none>
-[alias] May-alias graph after instruction  int *a = (int *)0;  is    <empty>
 [alias] analysing instruction: int *b = (int *)0;
 [alias] May-aliases after instruction  int *b = (int *)0;  are  <none>
-[alias] May-alias graph after instruction  int *b = (int *)0;  is    <empty>
 [alias] analysing instruction: int *c = (int *)0;
 [alias] May-aliases after instruction  int *c = (int *)0;  are  <none>
-[alias] May-alias graph after instruction  int *c = (int *)0;  is    <empty>
 [alias] analysing instruction: int *d = (int *)0;
 [alias] May-aliases after instruction  int *d = (int *)0;  are  <none>
-[alias] May-alias graph after instruction  int *d = (int *)0;  is    <empty>
 [alias] analysing instruction: swap(a,b);
 [alias] analysing function: swap
 [alias] analysing instruction: int *z = (int *)0;
 [alias] May-aliases after instruction  int *z = (int *)0;  are  <none>
-[alias] May-alias graph after instruction  int *z = (int *)0;  is    <empty>
 [alias] analysing instruction: z = x;
 [alias] May-aliases after instruction  z = x;  are  { x; z }
-[alias] May-alias graph after instruction  z = x;  is    0:{ x; z } â†’ 1:{  }
 [alias] analysing instruction: x = y;
 [alias] May-aliases after instruction  x = y;  are  { x; y; z }
-[alias] May-alias graph after instruction  x = y;  is    0:{ x; y; z } â†’ 1:{  }
 [alias] analysing instruction: y = z;
 [alias] May-aliases after instruction  y = z;  are  { x; y; z }
-[alias] May-alias graph after instruction  y = z;  is    0:{ x; y; z } â†’ 1:{  }
 [alias] May-aliases at the end of function swap: { x; y; z }
-[alias] May-alias graph at the end of function swap:
-  0:{ x; y; z } â†’ 1:{  }
-[alias] Summary of function swap:
-  formals: x  y    locals: z    returns: <none>    state: { x; y; z }
 [alias] May-aliases after instruction  swap(a,b);  are  { a; b }
-[alias] May-alias graph after instruction  swap(a,b);  is
-  8:{ a } â†’ 7:{  }   10:{ b } â†’ 7:{  }
 [alias] analysing instruction: swap(c,d);
 [alias] May-aliases after instruction  swap(c,d);  are  { a; b }  { c; d }
-[alias] May-alias graph after instruction  swap(c,d);  is
-  8:{ a } â†’ 7:{  }   10:{ b } â†’ 7:{  }   14:{ c } â†’ 13:{  }
-  16:{ d } â†’ 13:{  }
 [alias] analysing instruction: __retres = 0;
 [alias] May-aliases after instruction  __retres = 0;  are  { a; b }  { c; d }
-[alias] May-alias graph after instruction  __retres = 0;  is
-  8:{ a } â†’ 7:{  }   10:{ b } â†’ 7:{  }   14:{ c } â†’ 13:{  }
-  16:{ d } â†’ 13:{  }
 [alias] May-aliases at the end of function main: { a; b }  { c; d }
-[alias] May-alias graph at the end of function main:
-  8:{ a } â†’ 7:{  }   10:{ b } â†’ 7:{  }   14:{ c } â†’ 13:{  }
-  16:{ d } â†’ 13:{  }
-[alias] Summary of function main:
-  formals:     locals: a  b  c  d  __retres    returns: __retres
-  state: { a; b }  { c; d }
 [alias] analysing function: swap
 [alias] analysing instruction: int *z = (int *)0;
 [alias] May-aliases after instruction  int *z = (int *)0;  are  <none>
-[alias] May-alias graph after instruction  int *z = (int *)0;  is    <empty>
 [alias] May-aliases at the end of function swap: { x; y; z }
-[alias] May-alias graph at the end of function swap:
-  0:{ x; y; z } â†’ 1:{  }
-[alias] Summary of function swap:
-  formals: x  y    locals: z    returns: <none>    state: { x; y; z }
-[alias] Analysis complete
diff --git a/src/plugins/alias/tests/basic/oracle/function2.res.oracle b/src/plugins/alias/tests/basic/oracle/function2.res.oracle
index 8a156f682a6..1a770ac5390 100644
--- a/src/plugins/alias/tests/basic/oracle/function2.res.oracle
+++ b/src/plugins/alias/tests/basic/oracle/function2.res.oracle
@@ -2,48 +2,23 @@
 [alias] analysing function: main
 [alias] analysing instruction: int *a = (int *)0;
 [alias] May-aliases after instruction  int *a = (int *)0;  are  <none>
-[alias] May-alias graph after instruction  int *a = (int *)0;  is    <empty>
 [alias] analysing instruction: int *b = (int *)0;
 [alias] May-aliases after instruction  int *b = (int *)0;  are  <none>
-[alias] May-alias graph after instruction  int *b = (int *)0;  is    <empty>
 [alias] analysing instruction: a = my_malloc(2);
 [alias] analysing function: my_malloc
 [alias] analysing instruction: int *res = (int *)0;
 [alias] May-aliases after instruction  int *res = (int *)0;  are  <none>
-[alias] May-alias graph after instruction  int *res = (int *)0;  is    <empty>
 [alias] analysing instruction: res = (int *)malloc((size_t)size);
 [alias] May-aliases after instruction  res = (int *)malloc((size_t)size);  are
   <none>
-[alias] May-alias graph after instruction  res = (int *)malloc((size_t)size);  is
-  0:{ res } â†’ 1:{  }
 [alias] May-aliases at the end of function my_malloc: <none>
-[alias] May-alias graph at the end of function my_malloc:
-  0:{ res } â†’ 1:{  }
-[alias] Summary of function my_malloc:
-  formals: size    locals: res    returns: res    state: <none>
 [alias] May-aliases after instruction  a = my_malloc(2);  are  <none>
-[alias] May-alias graph after instruction  a = my_malloc(2);  is
-  4:{ a } â†’ 3:{  }
 [alias] analysing instruction: b = my_malloc(3);
 [alias] May-aliases after instruction  b = my_malloc(3);  are  <none>
-[alias] May-alias graph after instruction  b = my_malloc(3);  is
-  4:{ a } â†’ 3:{  }   8:{ b } â†’ 7:{  }
 [alias] analysing instruction: __retres = 0;
 [alias] May-aliases after instruction  __retres = 0;  are  <none>
-[alias] May-alias graph after instruction  __retres = 0;  is
-  4:{ a } â†’ 3:{  }   8:{ b } â†’ 7:{  }
 [alias] May-aliases at the end of function main: <none>
-[alias] May-alias graph at the end of function main:
-  4:{ a } â†’ 3:{  }   8:{ b } â†’ 7:{  }
-[alias] Summary of function main:
-  formals:     locals: a  b  __retres    returns: __retres    state: <none>
 [alias] analysing function: my_malloc
 [alias] analysing instruction: int *res = (int *)0;
 [alias] May-aliases after instruction  int *res = (int *)0;  are  <none>
-[alias] May-alias graph after instruction  int *res = (int *)0;  is    <empty>
 [alias] May-aliases at the end of function my_malloc: <none>
-[alias] May-alias graph at the end of function my_malloc:
-  0:{ res } â†’ 1:{  }
-[alias] Summary of function my_malloc:
-  formals: size    locals: res    returns: res    state: <none>
-[alias] Analysis complete
diff --git a/src/plugins/alias/tests/basic/oracle/function3.res.oracle b/src/plugins/alias/tests/basic/oracle/function3.res.oracle
index 4acd7896168..b45284aa949 100644
--- a/src/plugins/alias/tests/basic/oracle/function3.res.oracle
+++ b/src/plugins/alias/tests/basic/oracle/function3.res.oracle
@@ -2,56 +2,26 @@
 [alias] analysing function: f1
 [alias] analysing instruction: int *tmp = x;
 [alias] May-aliases after instruction  int *tmp = x;  are  { x; tmp }
-[alias] May-alias graph after instruction  int *tmp = x;  is
-  0:{ x; tmp } â†’ 1:{  }
 [alias] analysing instruction: x = y;
 [alias] May-aliases after instruction  x = y;  are  { x; y; tmp }
-[alias] May-alias graph after instruction  x = y;  is    0:{ x; y; tmp } â†’ 1:{  }
 [alias] analysing instruction: y = tmp;
 [alias] May-aliases after instruction  y = tmp;  are  { x; y; tmp }
-[alias] May-alias graph after instruction  y = tmp;  is    0:{ x; y; tmp } â†’ 1:{  }
 [alias] analysing instruction: __retres = (void *)0;
 [alias] May-aliases after instruction  __retres = (void *)0;  are  { x; y; tmp }
-[alias] May-alias graph after instruction  __retres = (void *)0;  is
-  0:{ x; y; tmp } â†’ 1:{  }
 [alias] May-aliases at the end of function f1: { x; y; tmp }
-[alias] May-alias graph at the end of function f1:
-  0:{ x; y; tmp } â†’ 1:{  }
-[alias] Summary of function f1:
-  formals: x  y    locals: tmp  __retres    returns: __retres
-  state: { x; y; tmp }
 [alias] analysing function: main
 [alias] analysing instruction: int *a = (int *)0;
 [alias] May-aliases after instruction  int *a = (int *)0;  are  <none>
-[alias] May-alias graph after instruction  int *a = (int *)0;  is    <empty>
 [alias] analysing instruction: int *b = (int *)0;
 [alias] May-aliases after instruction  int *b = (int *)0;  are  <none>
-[alias] May-alias graph after instruction  int *b = (int *)0;  is    <empty>
 [alias] analysing instruction: int *c = (int *)0;
 [alias] May-aliases after instruction  int *c = (int *)0;  are  <none>
-[alias] May-alias graph after instruction  int *c = (int *)0;  is    <empty>
 [alias] analysing instruction: int *d = (int *)0;
 [alias] May-aliases after instruction  int *d = (int *)0;  are  <none>
-[alias] May-alias graph after instruction  int *d = (int *)0;  is    <empty>
 [alias] analysing instruction: f1(a,b);
 [alias] May-aliases after instruction  f1(a,b);  are  { a; b }
-[alias] May-alias graph after instruction  f1(a,b);  is
-  16:{ a } â†’ 9:{  }   18:{ b } â†’ 9:{  }
 [alias] analysing instruction: f1(c,d);
 [alias] May-aliases after instruction  f1(c,d);  are  { a; b }  { c; d }
-[alias] May-alias graph after instruction  f1(c,d);  is
-  16:{ a } â†’ 9:{  }   18:{ b } â†’ 9:{  }   28:{ c } â†’ 21:{  }
-  30:{ d } â†’ 21:{  }
 [alias] analysing instruction: __retres = 0;
 [alias] May-aliases after instruction  __retres = 0;  are  { a; b }  { c; d }
-[alias] May-alias graph after instruction  __retres = 0;  is
-  16:{ a } â†’ 9:{  }   18:{ b } â†’ 9:{  }   28:{ c } â†’ 21:{  }
-  30:{ d } â†’ 21:{  }
 [alias] May-aliases at the end of function main: { a; b }  { c; d }
-[alias] May-alias graph at the end of function main:
-  16:{ a } â†’ 9:{  }   18:{ b } â†’ 9:{  }   28:{ c } â†’ 21:{  }
-  30:{ d } â†’ 21:{  }
-[alias] Summary of function main:
-  formals:     locals: a  b  c  d  __retres    returns: __retres
-  state: { a; b }  { c; d }
-[alias] Analysis complete
diff --git a/src/plugins/alias/tests/basic/oracle/function4.res.oracle b/src/plugins/alias/tests/basic/oracle/function4.res.oracle
index 8dbe90ab465..fb629f9683c 100644
--- a/src/plugins/alias/tests/basic/oracle/function4.res.oracle
+++ b/src/plugins/alias/tests/basic/oracle/function4.res.oracle
@@ -1,36 +1,17 @@
 [kernel] Parsing function4.c (with preprocessing)
 [alias] analysing function: addr
 [alias] May-aliases at the end of function addr: <none>
-[alias] May-alias graph at the end of function addr:
-  <empty>
-[alias] Summary of function addr:
-  formals: x    locals:     returns: x    state: <none>
 [alias] analysing function: main
 [alias] analysing instruction: int *a = (int *)0;
 [alias] May-aliases after instruction  int *a = (int *)0;  are  <none>
-[alias] May-alias graph after instruction  int *a = (int *)0;  is    <empty>
 [alias] analysing instruction: int *b = (int *)0;
 [alias] May-aliases after instruction  int *b = (int *)0;  are  <none>
-[alias] May-alias graph after instruction  int *b = (int *)0;  is    <empty>
 [alias] analysing instruction: int c = 0;
 [alias] May-aliases after instruction  int c = 0;  are  <none>
-[alias] May-alias graph after instruction  int c = 0;  is    <empty>
 [alias] analysing instruction: a = addr(& c);
 [alias] May-aliases after instruction  a = addr(& c);  are  <none>
-[alias] May-alias graph after instruction  a = addr(& c);  is
-  4:{ a } â†’ 3:{ c }   7:{  } â†’ 3:{ c }
 [alias] analysing instruction: b = & c;
 [alias] May-aliases after instruction  b = & c;  are  { a; b }
-[alias] May-alias graph after instruction  b = & c;  is
-  4:{ a } â†’ 9:{ c }   7:{  } â†’ 9:{ c }   8:{ b } â†’ 9:{ c }
 [alias] analysing instruction: __retres = 0;
 [alias] May-aliases after instruction  __retres = 0;  are  { a; b }
-[alias] May-alias graph after instruction  __retres = 0;  is
-  4:{ a } â†’ 9:{ c }   7:{  } â†’ 9:{ c }   8:{ b } â†’ 9:{ c }
 [alias] May-aliases at the end of function main: { a; b }
-[alias] May-alias graph at the end of function main:
-  4:{ a } â†’ 9:{ c }   7:{  } â†’ 9:{ c }   8:{ b } â†’ 9:{ c }
-[alias] Summary of function main:
-  formals:     locals: aâ†’{ c }  bâ†’{ c }  c  __retres
-  returns: __retres    state: { a; b }
-[alias] Analysis complete
diff --git a/src/plugins/alias/tests/basic/oracle/function5.res.oracle b/src/plugins/alias/tests/basic/oracle/function5.res.oracle
index c7d33151e1a..53362c373d1 100644
--- a/src/plugins/alias/tests/basic/oracle/function5.res.oracle
+++ b/src/plugins/alias/tests/basic/oracle/function5.res.oracle
@@ -2,43 +2,20 @@
 [alias] analysing function: choice
 [alias] analysing instruction: int c = 0;
 [alias] May-aliases after instruction  int c = 0;  are  <none>
-[alias] May-alias graph after instruction  int c = 0;  is    <empty>
 [alias] analysing instruction: __retres = x;
 [alias] May-aliases after instruction  __retres = x;  are  { x; __retres }
-[alias] May-alias graph after instruction  __retres = x;  is
-  0:{ x; __retres } â†’ 1:{  }
 [alias] analysing instruction: __retres = y;
 [alias] May-aliases after instruction  __retres = y;  are  { y; __retres }
-[alias] May-alias graph after instruction  __retres = y;  is
-  4:{ y; __retres } â†’ 5:{  }
 [alias] May-aliases at the end of function choice: { x; y; __retres }
-[alias] May-alias graph at the end of function choice:
-  0:{ x; y; __retres } â†’ 1:{  }
-[alias] Summary of function choice:
-  formals: x  y    locals: c  __retres    returns: __retres
-  state: { x; y; __retres }
 [alias] analysing function: main
 [alias] analysing instruction: int *a = (int *)0;
 [alias] May-aliases after instruction  int *a = (int *)0;  are  <none>
-[alias] May-alias graph after instruction  int *a = (int *)0;  is    <empty>
 [alias] analysing instruction: int *b = (int *)0;
 [alias] May-aliases after instruction  int *b = (int *)0;  are  <none>
-[alias] May-alias graph after instruction  int *b = (int *)0;  is    <empty>
 [alias] analysing instruction: int *c = (int *)0;
 [alias] May-aliases after instruction  int *c = (int *)0;  are  <none>
-[alias] May-alias graph after instruction  int *c = (int *)0;  is    <empty>
 [alias] analysing instruction: c = choice(a,b);
 [alias] May-aliases after instruction  c = choice(a,b);  are  { a; b; c }
-[alias] May-alias graph after instruction  c = choice(a,b);  is
-  10:{ c } â†’ 9:{  }   12:{ a } â†’ 9:{  }   14:{ b } â†’ 9:{  }
 [alias] analysing instruction: __retres = 0;
 [alias] May-aliases after instruction  __retres = 0;  are  { a; b; c }
-[alias] May-alias graph after instruction  __retres = 0;  is
-  10:{ c } â†’ 9:{  }   12:{ a } â†’ 9:{  }   14:{ b } â†’ 9:{  }
 [alias] May-aliases at the end of function main: { a; b; c }
-[alias] May-alias graph at the end of function main:
-  10:{ c } â†’ 9:{  }   12:{ a } â†’ 9:{  }   14:{ b } â†’ 9:{  }
-[alias] Summary of function main:
-  formals:     locals: a  b  c  __retres    returns: __retres
-  state: { a; b; c }
-[alias] Analysis complete
diff --git a/src/plugins/alias/tests/basic/oracle/function6.res.oracle b/src/plugins/alias/tests/basic/oracle/function6.res.oracle
index 74f1dd62b95..4d8f8fa4a01 100644
--- a/src/plugins/alias/tests/basic/oracle/function6.res.oracle
+++ b/src/plugins/alias/tests/basic/oracle/function6.res.oracle
@@ -2,54 +2,30 @@
 [alias] analysing function: main
 [alias] analysing instruction: int *a = (int *)0;
 [alias] May-aliases after instruction  int *a = (int *)0;  are  <none>
-[alias] May-alias graph after instruction  int *a = (int *)0;  is    <empty>
 [alias] analysing instruction: int *b = (int *)0;
 [alias] May-aliases after instruction  int *b = (int *)0;  are  <none>
-[alias] May-alias graph after instruction  int *b = (int *)0;  is    <empty>
 [alias] analysing instruction: int *c = (int *)0;
 [alias] May-aliases after instruction  int *c = (int *)0;  are  <none>
-[alias] May-alias graph after instruction  int *c = (int *)0;  is    <empty>
 [alias] analysing instruction: int *d = (int *)0;
 [alias] May-aliases after instruction  int *d = (int *)0;  are  <none>
-[alias] May-alias graph after instruction  int *d = (int *)0;  is    <empty>
 [alias] analysing instruction: swap(a,b);
 [alias] analysing function: swap
 [alias] analysing instruction: int z = 0;
 [alias] May-aliases after instruction  int z = 0;  are  <none>
-[alias] May-alias graph after instruction  int z = 0;  is    <empty>
 [alias] analysing instruction: z = *x;
 [alias] May-aliases after instruction  z = *x;  are  <none>
-[alias] May-alias graph after instruction  z = *x;  is    <empty>
 [alias] analysing instruction: *x = *y;
 [alias] May-aliases after instruction  *x = *y;  are  <none>
-[alias] May-alias graph after instruction  *x = *y;  is    <empty>
 [alias] analysing instruction: *y = z;
 [alias] May-aliases after instruction  *y = z;  are  <none>
-[alias] May-alias graph after instruction  *y = z;  is    <empty>
 [alias] May-aliases at the end of function swap: <none>
-[alias] May-alias graph at the end of function swap:
-  <empty>
-[alias] Summary of function swap:
 [alias] May-aliases after instruction  swap(a,b);  are  <none>
-[alias] May-alias graph after instruction  swap(a,b);  is    <empty>
 [alias] analysing instruction: swap(c,d);
 [alias] May-aliases after instruction  swap(c,d);  are  <none>
-[alias] May-alias graph after instruction  swap(c,d);  is    <empty>
 [alias] analysing instruction: __retres = 0;
 [alias] May-aliases after instruction  __retres = 0;  are  <none>
-[alias] May-alias graph after instruction  __retres = 0;  is    <empty>
 [alias] May-aliases at the end of function main: <none>
-[alias] May-alias graph at the end of function main:
-  <empty>
-[alias] Summary of function main:
-  formals:     locals: a  b  c  d  __retres    returns: __retres
-  state: <none>
 [alias] analysing function: swap
 [alias] analysing instruction: int z = 0;
 [alias] May-aliases after instruction  int z = 0;  are  <none>
-[alias] May-alias graph after instruction  int z = 0;  is    <empty>
 [alias] May-aliases at the end of function swap: <none>
-[alias] May-alias graph at the end of function swap:
-  <empty>
-[alias] Summary of function swap:
-[alias] Analysis complete
diff --git a/src/plugins/alias/tests/basic/oracle/globctr.res.oracle b/src/plugins/alias/tests/basic/oracle/globctr.res.oracle
index e5df545b132..64f2826db29 100644
--- a/src/plugins/alias/tests/basic/oracle/globctr.res.oracle
+++ b/src/plugins/alias/tests/basic/oracle/globctr.res.oracle
@@ -2,33 +2,18 @@
 [alias] analysing function: f
 [alias] analysing instruction: int y = 0;
 [alias] May-aliases after instruction  int y = 0;  are  <none>
-[alias] May-alias graph after instruction  int y = 0;  is    <empty>
 [alias] analysing instruction: *x = y;
 [alias] May-aliases after instruction  *x = y;  are  <none>
-[alias] May-alias graph after instruction  *x = y;  is    <empty>
 [alias] May-aliases at the end of function f: <none>
-[alias] May-alias graph at the end of function f:
-  <empty>
-[alias] Summary of function f:
 [alias] analysing function: main
 [alias] analysing instruction: int *a = (int *)0;
 [alias] May-aliases after instruction  int *a = (int *)0;  are  <none>
-[alias] May-alias graph after instruction  int *a = (int *)0;  is    <empty>
 [alias] analysing instruction: int *b = (int *)0;
 [alias] May-aliases after instruction  int *b = (int *)0;  are  <none>
-[alias] May-alias graph after instruction  int *b = (int *)0;  is    <empty>
 [alias] analysing instruction: f(a);
 [alias] May-aliases after instruction  f(a);  are  <none>
-[alias] May-alias graph after instruction  f(a);  is    <empty>
 [alias] analysing instruction: f(b);
 [alias] May-aliases after instruction  f(b);  are  <none>
-[alias] May-alias graph after instruction  f(b);  is    <empty>
 [alias] analysing instruction: __retres = 0;
 [alias] May-aliases after instruction  __retres = 0;  are  <none>
-[alias] May-alias graph after instruction  __retres = 0;  is    <empty>
 [alias] May-aliases at the end of function main: <none>
-[alias] May-alias graph at the end of function main:
-  <empty>
-[alias] Summary of function main:
-  formals:     locals: a  b  __retres    returns: __retres    state: <none>
-[alias] Analysis complete
diff --git a/src/plugins/alias/tests/basic/oracle/loop.res.oracle b/src/plugins/alias/tests/basic/oracle/loop.res.oracle
index 3bc56d48778..9ef827f6daf 100644
--- a/src/plugins/alias/tests/basic/oracle/loop.res.oracle
+++ b/src/plugins/alias/tests/basic/oracle/loop.res.oracle
@@ -2,37 +2,18 @@
 [alias] analysing function: main
 [alias] analysing instruction: int l[1] = {0};
 [alias] May-aliases after instruction  int l[1] = {0};  are  <none>
-[alias] May-alias graph after instruction  int l[1] = {0};  is    <empty>
 [alias] analysing instruction: int *n_0 = & l[1];
 [alias] May-aliases after instruction  int *n_0 = & l[1];  are  <none>
-[alias] May-alias graph after instruction  int *n_0 = & l[1];  is
-  0:{ n_0 } â†’ 1:{ l[0..] }
 [alias] analysing instruction: n_0 = & l[1] + 0;
 [alias] May-aliases after instruction  n_0 = & l[1] + 0;  are  <none>
-[alias] May-alias graph after instruction  n_0 = & l[1] + 0;  is
-  0:{ n_0 } â†’ 1:{ l[0..] }
 [alias] analysing instruction: int w = 0;
 [alias] May-aliases after instruction  int w = 0;  are  <none>
-[alias] May-alias graph after instruction  int w = 0;  is
-  0:{ n_0 } â†’ 1:{ l[0..] }
 [alias] analysing instruction: l[0] = *(& l[1] + 0);
 [alias] May-aliases after instruction  l[0] = *(& l[1] + 0);  are  <none>
-[alias] May-alias graph after instruction  l[0] = *(& l[1] + 0);  is
-  0:{ n_0 } â†’ 1:{ l[0..] }
 [alias] analysing instruction: int l[1] = {0};
 [alias] May-aliases after instruction  int l[1] = {0};  are  <none>
-[alias] May-alias graph after instruction  int l[1] = {0};  is
-  0:{ n_0 } â†’ 1:{ l[0..] }
 [alias] analysing instruction: int *n_0 = & l[1];
 [alias] May-aliases after instruction  int *n_0 = & l[1];  are  <none>
-[alias] May-alias graph after instruction  int *n_0 = & l[1];  is
-  0:{ n_0 } â†’ 1:{ l[0..] }
 [alias:no-return] loop.c:4: Warning: 
   function main does not return; analysis may be unsound
 [alias] May-aliases at the end of function main: <none>
-[alias] May-alias graph at the end of function main:
-  <empty>
-[alias] Summary of function main:
-  formals:     locals: l  n_0  w  __retres    returns: __retres
-  state: <none>
-[alias] Analysis complete
diff --git a/src/plugins/alias/tests/basic/oracle/steensgaard.res.oracle b/src/plugins/alias/tests/basic/oracle/steensgaard.res.oracle
index fd9b99fe183..fdb1f8f1ce3 100644
--- a/src/plugins/alias/tests/basic/oracle/steensgaard.res.oracle
+++ b/src/plugins/alias/tests/basic/oracle/steensgaard.res.oracle
@@ -2,40 +2,16 @@
 [alias] analysing function: main
 [alias] analysing instruction: a = & x;
 [alias] May-aliases after instruction  a = & x;  are  <none>
-[alias] May-alias graph after instruction  a = & x;  is    0:{ a } â†’ 1:{ x }
 [alias] analysing instruction: b = & y;
 [alias] May-aliases after instruction  b = & y;  are  { *b; y }
-[alias] May-alias graph after instruction  b = & y;  is
-  0:{ a } â†’ 1:{ x }   4:{ b } â†’ 5:{ y }   5:{ y } â†’ 7:{  }
 [alias] analysing instruction: y = & z;
 [alias] May-aliases after instruction  y = & z;  are  { *b; y }
-[alias] May-alias graph after instruction  y = & z;  is
-  0:{ a } â†’ 1:{ x }   4:{ b } â†’ 5:{ y }   5:{ y } â†’ 7:{ z }
 [alias] analysing instruction: y = & x;
 [alias] May-aliases after instruction  y = & x;  are  { *b; a; y }
-[alias] May-alias graph after instruction  y = & x;  is
-  0:{ a } â†’ 7:{ x }   4:{ b } â†’ 5:{ y }   5:{ y } â†’ 7:{ x }
 [alias] analysing instruction: c = & y;
 [alias] May-aliases after instruction  c = & y;  are  { *b; *c; a; y }  { b; c }
-[alias] May-alias graph after instruction  c = & y;  is
-  0:{ a } â†’ 1:{ x; z }   4:{ b } â†’ 13:{ y }   12:{ c } â†’ 13:{ y }
-  13:{ y } â†’ 1:{ x; z }
 [alias] analysing instruction: *y = 4;
 [alias] May-aliases after instruction  *y = 4;  are  { *b; *c; a; y }  { b; c }
-[alias] May-alias graph after instruction  *y = 4;  is
-  0:{ a } â†’ 1:{ x; z }   4:{ b } â†’ 13:{ y }   12:{ c } â†’ 13:{ y }
-  13:{ y } â†’ 1:{ x; z }
 [alias] analysing instruction: __retres = 0;
 [alias] May-aliases after instruction  __retres = 0;  are  { *b; *c; a; y }  { b; c }
-[alias] May-alias graph after instruction  __retres = 0;  is
-  0:{ a } â†’ 1:{ x; z }   4:{ b } â†’ 13:{ y }   12:{ c } â†’ 13:{ y }
-  13:{ y } â†’ 1:{ x; z }
 [alias] May-aliases at the end of function main: { *b; *c; a; y }  { b; c }
-[alias] May-alias graph at the end of function main:
-  0:{ a } â†’ 1:{ x; z }   4:{ b } â†’ 13:{ y }   12:{ c } â†’ 13:{ y }
-  13:{ y } â†’ 1:{ x; z }
-[alias] Summary of function main:
-  formals: 
-  locals: aâ†’{ x; z }  bâ†’{ y }  câ†’{ y }  yâ†’{ x; z }  x  z  p  __retres
-  returns: __retres    state: { *b; *c; a; y }  { b; c }
-[alias] Analysis complete
diff --git a/src/plugins/alias/tests/basic/oracle/switch1.res.oracle b/src/plugins/alias/tests/basic/oracle/switch1.res.oracle
index 5d4e7565c29..1d3c1881fa9 100644
--- a/src/plugins/alias/tests/basic/oracle/switch1.res.oracle
+++ b/src/plugins/alias/tests/basic/oracle/switch1.res.oracle
@@ -2,35 +2,18 @@
 [alias] analysing function: main
 [alias] analysing instruction: int *a = (int *)0;
 [alias] May-aliases after instruction  int *a = (int *)0;  are  <none>
-[alias] May-alias graph after instruction  int *a = (int *)0;  is    <empty>
 [alias] analysing instruction: int *b = (int *)0;
 [alias] May-aliases after instruction  int *b = (int *)0;  are  <none>
-[alias] May-alias graph after instruction  int *b = (int *)0;  is    <empty>
 [alias] analysing instruction: int *c = (int *)0;
 [alias] May-aliases after instruction  int *c = (int *)0;  are  <none>
-[alias] May-alias graph after instruction  int *c = (int *)0;  is    <empty>
 [alias] analysing instruction: int *d = (int *)0;
 [alias] May-aliases after instruction  int *d = (int *)0;  are  <none>
-[alias] May-alias graph after instruction  int *d = (int *)0;  is    <empty>
 [alias] analysing instruction: int e = 0;
 [alias] May-aliases after instruction  int e = 0;  are  <none>
-[alias] May-alias graph after instruction  int e = 0;  is    <empty>
 [alias] analysing instruction: case 1: a = d;
 [alias] May-aliases after instruction  case 1: a = d;  are  { a; d }
-[alias] May-alias graph after instruction  case 1: a = d;  is
-  0:{ a; d } â†’ 1:{  }
 [alias] analysing instruction: case 2: b = d;
 [alias] May-aliases after instruction  case 2: b = d;  are  { b; d }
-[alias] May-alias graph after instruction  case 2: b = d;  is
-  4:{ b; d } â†’ 5:{  }
 [alias] analysing instruction: __retres = 0;
 [alias] May-aliases after instruction  __retres = 0;  are  { a; b; d }
-[alias] May-alias graph after instruction  __retres = 0;  is
-  0:{ a; b; d } â†’ 1:{  }
 [alias] May-aliases at the end of function main: { a; b; d }
-[alias] May-alias graph at the end of function main:
-  0:{ a; b; d } â†’ 1:{  }
-[alias] Summary of function main:
-  formals:     locals: a  b  c  d  e  __retres    returns: __retres
-  state: { a; b; d }
-[alias] Analysis complete
diff --git a/src/plugins/alias/tests/basic/oracle/switch2.res.oracle b/src/plugins/alias/tests/basic/oracle/switch2.res.oracle
index 35c8cb7b5d7..8097b1a0db5 100644
--- a/src/plugins/alias/tests/basic/oracle/switch2.res.oracle
+++ b/src/plugins/alias/tests/basic/oracle/switch2.res.oracle
@@ -2,39 +2,20 @@
 [alias] analysing function: main
 [alias] analysing instruction: int *a = (int *)0;
 [alias] May-aliases after instruction  int *a = (int *)0;  are  <none>
-[alias] May-alias graph after instruction  int *a = (int *)0;  is    <empty>
 [alias] analysing instruction: int *b = (int *)0;
 [alias] May-aliases after instruction  int *b = (int *)0;  are  <none>
-[alias] May-alias graph after instruction  int *b = (int *)0;  is    <empty>
 [alias] analysing instruction: int *c = (int *)0;
 [alias] May-aliases after instruction  int *c = (int *)0;  are  <none>
-[alias] May-alias graph after instruction  int *c = (int *)0;  is    <empty>
 [alias] analysing instruction: int *d = (int *)0;
 [alias] May-aliases after instruction  int *d = (int *)0;  are  <none>
-[alias] May-alias graph after instruction  int *d = (int *)0;  is    <empty>
 [alias] analysing instruction: int e = 0;
 [alias] May-aliases after instruction  int e = 0;  are  <none>
-[alias] May-alias graph after instruction  int e = 0;  is    <empty>
 [alias] analysing instruction: case 1: a = d;
 [alias] May-aliases after instruction  case 1: a = d;  are  { a; d }
-[alias] May-alias graph after instruction  case 1: a = d;  is
-  0:{ a; d } â†’ 1:{  }
 [alias] analysing instruction: case 2: b = d;
 [alias] May-aliases after instruction  case 2: b = d;  are  { b; d }
-[alias] May-alias graph after instruction  case 2: b = d;  is
-  4:{ b; d } â†’ 5:{  }
 [alias] analysing instruction: default: c = d;
 [alias] May-aliases after instruction  default: c = d;  are  { c; d }
-[alias] May-alias graph after instruction  default: c = d;  is
-  8:{ c; d } â†’ 9:{  }
 [alias] analysing instruction: __retres = 0;
 [alias] May-aliases after instruction  __retres = 0;  are  { a; b; c; d }
-[alias] May-alias graph after instruction  __retres = 0;  is
-  0:{ a; b; c; d } â†’ 1:{  }
 [alias] May-aliases at the end of function main: { a; b; c; d }
-[alias] May-alias graph at the end of function main:
-  0:{ a; b; c; d } â†’ 1:{  }
-[alias] Summary of function main:
-  formals:     locals: a  b  c  d  e  __retres    returns: __retres
-  state: { a; b; c; d }
-[alias] Analysis complete
diff --git a/src/plugins/alias/tests/basic/oracle/while_for1.res.oracle b/src/plugins/alias/tests/basic/oracle/while_for1.res.oracle
index c389176d8e7..aa1b0b711b2 100644
--- a/src/plugins/alias/tests/basic/oracle/while_for1.res.oracle
+++ b/src/plugins/alias/tests/basic/oracle/while_for1.res.oracle
@@ -2,27 +2,14 @@
 [alias] analysing function: main
 [alias] analysing instruction: int *s = (int *)0;
 [alias] May-aliases after instruction  int *s = (int *)0;  are  <none>
-[alias] May-alias graph after instruction  int *s = (int *)0;  is    <empty>
 [alias] analysing instruction: int idx = 0;
 [alias] May-aliases after instruction  int idx = 0;  are  <none>
-[alias] May-alias graph after instruction  int idx = 0;  is    <empty>
 [alias] analysing instruction: s = (int *)malloc((size_t)idx);
 [alias] May-aliases after instruction  s = (int *)malloc((size_t)idx);  are  <none>
-[alias] May-alias graph after instruction  s = (int *)malloc((size_t)idx);  is
-  0:{ s } â†’ 1:{  }
 [alias] analysing instruction: idx ++;
 [alias] May-aliases after instruction  idx ++;  are  <none>
-[alias] May-alias graph after instruction  idx ++;  is    0:{ s } â†’ 1:{  }
 [alias] analysing instruction: s = (int *)malloc((size_t)idx);
 [alias] May-aliases after instruction  s = (int *)malloc((size_t)idx);  are  <none>
-[alias] May-alias graph after instruction  s = (int *)malloc((size_t)idx);  is
-  0:{ s } â†’ 1:{  }
 [alias] analysing instruction: __retres = 0;
 [alias] May-aliases after instruction  __retres = 0;  are  <none>
-[alias] May-alias graph after instruction  __retres = 0;  is    0:{ s } â†’ 1:{  }
 [alias] May-aliases at the end of function main: <none>
-[alias] May-alias graph at the end of function main:
-  0:{ s } â†’ 1:{  }
-[alias] Summary of function main:
-  formals:     locals: s  idx  __retres    returns: __retres    state: <none>
-[alias] Analysis complete
diff --git a/src/plugins/alias/tests/basic/oracle/while_for2.res.oracle b/src/plugins/alias/tests/basic/oracle/while_for2.res.oracle
index d6cd6b220b4..c7c4c865fea 100644
--- a/src/plugins/alias/tests/basic/oracle/while_for2.res.oracle
+++ b/src/plugins/alias/tests/basic/oracle/while_for2.res.oracle
@@ -2,23 +2,12 @@
 [alias] analysing function: main
 [alias] analysing instruction: int *a = (int *)0;
 [alias] May-aliases after instruction  int *a = (int *)0;  are  <none>
-[alias] May-alias graph after instruction  int *a = (int *)0;  is    <empty>
 [alias] analysing instruction: int *b = (int *)0;
 [alias] May-aliases after instruction  int *b = (int *)0;  are  <none>
-[alias] May-alias graph after instruction  int *b = (int *)0;  is    <empty>
 [alias] analysing instruction: int *c = (int *)0;
 [alias] May-aliases after instruction  int *c = (int *)0;  are  <none>
-[alias] May-alias graph after instruction  int *c = (int *)0;  is    <empty>
 [alias] analysing instruction: a = b;
 [alias] May-aliases after instruction  a = b;  are  { a; b }
-[alias] May-alias graph after instruction  a = b;  is    0:{ a; b } â†’ 1:{  }
 [alias] analysing instruction: __retres = 0;
 [alias] May-aliases after instruction  __retres = 0;  are  { a; b }
-[alias] May-alias graph after instruction  __retres = 0;  is    0:{ a; b } â†’ 1:{  }
 [alias] May-aliases at the end of function main: { a; b }
-[alias] May-alias graph at the end of function main:
-  0:{ a; b } â†’ 1:{  }
-[alias] Summary of function main:
-  formals:     locals: a  b  c  __retres    returns: __retres
-  state: { a; b }
-[alias] Analysis complete
diff --git a/src/plugins/alias/tests/basic/oracle/while_for3.res.oracle b/src/plugins/alias/tests/basic/oracle/while_for3.res.oracle
index 24560b86f6e..40720eb3def 100644
--- a/src/plugins/alias/tests/basic/oracle/while_for3.res.oracle
+++ b/src/plugins/alias/tests/basic/oracle/while_for3.res.oracle
@@ -2,32 +2,18 @@
 [alias] analysing function: main
 [alias] analysing instruction: int *a = (int *)0;
 [alias] May-aliases after instruction  int *a = (int *)0;  are  <none>
-[alias] May-alias graph after instruction  int *a = (int *)0;  is    <empty>
 [alias] analysing instruction: int *b = (int *)0;
 [alias] May-aliases after instruction  int *b = (int *)0;  are  <none>
-[alias] May-alias graph after instruction  int *b = (int *)0;  is    <empty>
 [alias] analysing instruction: int *c = (int *)0;
 [alias] May-aliases after instruction  int *c = (int *)0;  are  <none>
-[alias] May-alias graph after instruction  int *c = (int *)0;  is    <empty>
 [alias] analysing instruction: int i = 0;
 [alias] May-aliases after instruction  int i = 0;  are  <none>
-[alias] May-alias graph after instruction  int i = 0;  is    <empty>
 [alias] analysing instruction: a = b;
 [alias] May-aliases after instruction  a = b;  are  { a; b }
-[alias] May-alias graph after instruction  a = b;  is    0:{ a; b } â†’ 1:{  }
 [alias] analysing instruction: __Cont: i ++;
 [alias] May-aliases after instruction  __Cont: i ++;  are  { a; b }
-[alias] May-alias graph after instruction  __Cont: i ++;  is    0:{ a; b } â†’ 1:{  }
 [alias] analysing instruction: a = b;
 [alias] May-aliases after instruction  a = b;  are  { a; b }
-[alias] May-alias graph after instruction  a = b;  is    0:{ a; b } â†’ 1:{  }
 [alias] analysing instruction: __retres = 0;
 [alias] May-aliases after instruction  __retres = 0;  are  { a; b }
-[alias] May-alias graph after instruction  __retres = 0;  is    0:{ a; b } â†’ 1:{  }
 [alias] May-aliases at the end of function main: { a; b }
-[alias] May-alias graph at the end of function main:
-  0:{ a; b } â†’ 1:{  }
-[alias] Summary of function main:
-  formals:     locals: a  b  c  i  __retres    returns: __retres
-  state: { a; b }
-[alias] Analysis complete
diff --git a/src/plugins/alias/tests/fixed_bugs/oracle/empty_nodes.res.oracle b/src/plugins/alias/tests/fixed_bugs/oracle/empty_nodes.res.oracle
index 443ae47d142..3f911591f73 100644
--- a/src/plugins/alias/tests/fixed_bugs/oracle/empty_nodes.res.oracle
+++ b/src/plugins/alias/tests/fixed_bugs/oracle/empty_nodes.res.oracle
@@ -2,34 +2,13 @@
 [alias] analysing function: f
 [alias] analysing instruction: *y = t + (*y - *x);
 [alias] May-aliases after instruction  *y = t + (*y - *x);  are  { *y; t }
-[alias] May-alias graph after instruction  *y = t + (*y - *x);  is
-  0:{ y } â†’ 1:{ *y; t }   1:{ *y; t } â†’ 3:{  }
 [alias] analysing instruction: *z = t + (*z - *x);
 [alias] May-aliases after instruction  *z = t + (*z - *x);  are
   { *y; *z; t }  { y; z }
-[alias] May-alias graph after instruction  *z = t + (*z - *x);  is
-  0:{ y } â†’ 5:{ *y; *z; t }   4:{ z } â†’ 5:{ *y; *z; t }
-  5:{ *y; *z; t } â†’ 3:{  }
 [alias] analysing instruction: *x = t;
 [alias] May-aliases after instruction  *x = t;  are  { *x; *y; *z; t }  { x; y; z }
-[alias] May-alias graph after instruction  *x = t;  is
-  0:{ y } â†’ 7:{ *x; *y; *z; t }   4:{ z } â†’ 7:{ *x; *y; *z; t }
-  6:{ x } â†’ 7:{ *x; *y; *z; t }   7:{ *x; *y; *z; t } â†’ 3:{  }
 [alias] May-aliases at the end of function f: { *x; *y; *z; t }  { x; y; z }
-[alias] May-alias graph at the end of function f:
-  0:{ y } â†’ 7:{ *x; *y; *z; t }   4:{ z } â†’ 7:{ *x; *y; *z; t }
-  6:{ x } â†’ 7:{ *x; *y; *z; t }   7:{ *x; *y; *z; t } â†’ 3:{  }
-[alias] Summary of function f:
-  formals: xâ†’{ *x; *y; *z; t }  yâ†’{ *x; *y; *z; t }  zâ†’{ *x; *y; *z; t }
-  locals: t    returns: <none>    state: { *x; *y; *z; t }  { x; y; z }
 [alias] analysing function: g
 [alias] analysing instruction: f(a,a,a);
 [alias] May-aliases after instruction  f(a,a,a);  are  <none>
-[alias] May-alias graph after instruction  f(a,a,a);  is
-  15:{  } â†’ 11:{  }   16:{ a } â†’ 15:{  }
 [alias] May-aliases at the end of function g: <none>
-[alias] May-alias graph at the end of function g:
-  15:{  } â†’ 11:{  }   16:{ a } â†’ 15:{  }
-[alias] Summary of function g:
-  formals: a    locals:     returns: <none>    state: <none>
-[alias] Analysis complete
diff --git a/src/plugins/alias/tests/fixed_bugs/oracle/gzip124.res.oracle b/src/plugins/alias/tests/fixed_bugs/oracle/gzip124.res.oracle
index e612a89c586..fd9878fef65 100644
--- a/src/plugins/alias/tests/fixed_bugs/oracle/gzip124.res.oracle
+++ b/src/plugins/alias/tests/fixed_bugs/oracle/gzip124.res.oracle
@@ -2,29 +2,14 @@
 [alias] analysing function: main
 [alias] analysing instruction: short tmp_0 = (short)0;
 [alias] May-aliases after instruction  short tmp_0 = (short)0;  are  <none>
-[alias] May-alias graph after instruction  short tmp_0 = (short)0;  is    <empty>
 [alias] analysing instruction: *(& prev[1] + 0) = tmp_0;
 [alias] May-aliases after instruction  *(& prev[1] + 0) = tmp_0;  are  <none>
-[alias] May-alias graph after instruction  *(& prev[1] + 0) = tmp_0;  is    <empty>
 [alias] analysing instruction: prev[0] = (short)0;
 [alias] May-aliases after instruction  prev[0] = (short)0;  are  <none>
-[alias] May-alias graph after instruction  prev[0] = (short)0;  is    <empty>
 [alias] analysing instruction: p = & prev[1] + (int)*p;
 [alias] May-aliases after instruction  p = & prev[1] + (int)*p;  are  <none>
-[alias] May-alias graph after instruction  p = & prev[1] + (int)*p;  is
-  0:{ p } â†’ 1:{ prev[0..] }
 [alias] analysing instruction: p = & prev[*p];
 [alias] May-aliases after instruction  p = & prev[*p];  are  <none>
-[alias] May-alias graph after instruction  p = & prev[*p];  is
-  4:{ p } â†’ 5:{ prev[0..] }
 [alias] analysing instruction: __retres = 0;
 [alias] May-aliases after instruction  __retres = 0;  are  <none>
-[alias] May-alias graph after instruction  __retres = 0;  is
-  0:{ p } â†’ 1:{ prev[0..] }
 [alias] May-aliases at the end of function main: <none>
-[alias] May-alias graph at the end of function main:
-  0:{ p } â†’ 1:{ prev[0..] }
-[alias] Summary of function main:
-  formals:     locals: __retres  prev  pâ†’{ prev[0..] }  tmp_0
-  returns: __retres    state: <none>
-[alias] Analysis complete
diff --git a/src/plugins/alias/tests/fixed_bugs/oracle/origin.res.oracle b/src/plugins/alias/tests/fixed_bugs/oracle/origin.res.oracle
index 3b78e81856d..5804eca90b4 100644
--- a/src/plugins/alias/tests/fixed_bugs/oracle/origin.res.oracle
+++ b/src/plugins/alias/tests/fixed_bugs/oracle/origin.res.oracle
@@ -4,22 +4,11 @@
 [alias] analysing function: f
 [alias] analysing instruction: tmp = & f;
 [alias] May-aliases after instruction  tmp = & f;  are  <none>
-[alias] May-alias graph after instruction  tmp = & f;  is    0:{ tmp } â†’ 1:{ f }
 [alias] analysing instruction: tmp = (void (*)(void))*((char *)(v.t));
 [alias:unsafe-cast] origin.c:8: Warning: unsafe cast from char to void (*)(void)
 [alias:unsafe-cast] origin.c:8: Warning: unsafe cast from int * to char *
 [alias] May-aliases after instruction  tmp = (void (*)(void))*((char *)(v.t));  are
   { v.t; tmp }
-[alias] May-alias graph after instruction  tmp = (void (*)(void))*((char *)(v.t));
-  is    0:{ v.t; tmp } â†’ 1:{ f }
 [alias] analysing instruction: int g = (int)tmp;
 [alias] May-aliases after instruction  int g = (int)tmp;  are  { v.t; tmp }
-[alias] May-alias graph after instruction  int g = (int)tmp;  is
-  0:{ v.t; tmp } â†’ 1:{ f }
 [alias] May-aliases at the end of function f: { v.t; tmp }
-[alias] May-alias graph at the end of function f:
-  0:{ v.t; tmp } â†’ 1:{ f }
-[alias] Summary of function f:
-  formals:     locals: g  tmpâ†’{ f }    returns: <none>
-  state: { v.t; tmp }
-[alias] Analysis complete
diff --git a/src/plugins/alias/tests/fixed_bugs/oracle/origin_simpl.res.oracle b/src/plugins/alias/tests/fixed_bugs/oracle/origin_simpl.res.oracle
index cc580d0c444..e0e7350e8bb 100644
--- a/src/plugins/alias/tests/fixed_bugs/oracle/origin_simpl.res.oracle
+++ b/src/plugins/alias/tests/fixed_bugs/oracle/origin_simpl.res.oracle
@@ -4,11 +4,4 @@
 [alias:unsafe-cast] origin_simpl.c:9: Warning: unsafe cast from int to void *
 [alias:unsafe-cast] origin_simpl.c:9: Warning: unsafe cast from char * to int *
 [alias] May-aliases after instruction  tmp = (void *)*((int *)(t));  are  { t; tmp }
-[alias] May-alias graph after instruction  tmp = (void *)*((int *)(t));  is
-  0:{ t; tmp } â†’ 1:{  }
 [alias] May-aliases at the end of function f: { t; tmp }
-[alias] May-alias graph at the end of function f:
-  0:{ t; tmp } â†’ 1:{  }
-[alias] Summary of function f:
-  formals:     locals: tmp    returns: <none>    state: { t; tmp }
-[alias] Analysis complete
diff --git a/src/plugins/alias/tests/fixed_bugs/oracle/semver.res.oracle b/src/plugins/alias/tests/fixed_bugs/oracle/semver.res.oracle
index 14786295a9e..bdc3f9de654 100644
--- a/src/plugins/alias/tests/fixed_bugs/oracle/semver.res.oracle
+++ b/src/plugins/alias/tests/fixed_bugs/oracle/semver.res.oracle
@@ -1,22 +1,12 @@
 [kernel] Parsing semver.c (with preprocessing)
 [alias] analysing function: f
 [alias] May-aliases at the end of function f: <none>
-[alias] May-alias graph at the end of function f:
-  <empty>
-[alias] Summary of function f:
 [alias] analysing function: main
 [alias] analysing instruction: f((int *)*("1" + 2));
 [alias:unsafe-cast] semver.c:6: Warning: unsafe cast from char to int *
 [alias:unsupported:addr] semver.c:6: Warning: 
   unsupported feature: explicit pointer address: (int *)*("1" + 2); analysis may be unsound
 [alias] May-aliases after instruction  f((int *)*("1" + 2));  are  <none>
-[alias] May-alias graph after instruction  f((int *)*("1" + 2));  is    <empty>
 [alias] analysing instruction: __retres = 0;
 [alias] May-aliases after instruction  __retres = 0;  are  <none>
-[alias] May-alias graph after instruction  __retres = 0;  is    <empty>
 [alias] May-aliases at the end of function main: <none>
-[alias] May-alias graph at the end of function main:
-  <empty>
-[alias] Summary of function main:
-  formals:     locals: __retres    returns: __retres    state: <none>
-[alias] Analysis complete
diff --git a/src/plugins/alias/tests/fixed_bugs/oracle/tkn-2.res.oracle b/src/plugins/alias/tests/fixed_bugs/oracle/tkn-2.res.oracle
index 6718bf0c370..7843cab1557 100644
--- a/src/plugins/alias/tests/fixed_bugs/oracle/tkn-2.res.oracle
+++ b/src/plugins/alias/tests/fixed_bugs/oracle/tkn-2.res.oracle
@@ -4,15 +4,6 @@
 [alias:unsafe-cast] tkn-2.c:6: Warning: unsafe cast from int ** to int *
 [alias] tkn-2.c:6: Warning: ignoring assignment of the form: a = (int *)(& a)
 [alias] May-aliases after instruction  a = (int *)(& a);  are  <none>
-[alias] May-alias graph after instruction  a = (int *)(& a);  is
-  0:{ a } â†’ 1:{  }   2:{  } â†’ 0:{ a }
 [alias] analysing instruction: __retres = *a;
 [alias] May-aliases after instruction  __retres = *a;  are  <none>
-[alias] May-alias graph after instruction  __retres = *a;  is
-  0:{ a } â†’ 1:{  }   2:{  } â†’ 0:{ a }
 [alias] May-aliases at the end of function main: <none>
-[alias] May-alias graph at the end of function main:
-  0:{ a } â†’ 1:{  }   2:{  } â†’ 0:{ a }
-[alias] Summary of function main:
-  formals:     locals: a  __retres    returns: __retres    state: <none>
-[alias] Analysis complete
diff --git a/src/plugins/alias/tests/fixed_bugs/oracle/union_vmap.res.oracle b/src/plugins/alias/tests/fixed_bugs/oracle/union_vmap.res.oracle
index 901bb8dd000..7ea35d5b5b0 100644
--- a/src/plugins/alias/tests/fixed_bugs/oracle/union_vmap.res.oracle
+++ b/src/plugins/alias/tests/fixed_bugs/oracle/union_vmap.res.oracle
@@ -3,43 +3,19 @@
 [alias] analysing instruction: char *s2 = CPS_SplitWord((char *)"a");
 [alias] analysing function: CPS_SplitWord
 [alias] May-aliases at the end of function CPS_SplitWord: <none>
-[alias] May-alias graph at the end of function CPS_SplitWord:
-  <empty>
-[alias] Summary of function CPS_SplitWord:
-  formals: line    locals:     returns: line    state: <none>
 [alias:unsafe-cast] union_vmap.c:11: Warning: 
   unsafe cast from char const * to char *
 [alias] May-aliases after instruction  char *s2 = CPS_SplitWord((char *)"a");  are
   <none>
-[alias] May-alias graph after instruction  char *s2 = CPS_SplitWord((char *)"a");
-  is    4:{ s2 } â†’ 3:{  }
 [alias] analysing instruction: char *s3 = CPS_SplitWord((char *)"b");
 [alias:unsafe-cast] union_vmap.c:12: Warning: 
   unsafe cast from char const * to char *
 [alias] May-aliases after instruction  char *s3 = CPS_SplitWord((char *)"b");  are
   <none>
-[alias] May-alias graph after instruction  char *s3 = CPS_SplitWord((char *)"b");
-  is    4:{ s2 } â†’ 3:{  }   8:{ s3 } â†’ 7:{  }
 [alias] analysing instruction: *key = s3;
 [alias] May-aliases after instruction  *key = s3;  are  { *key; s3 }
-[alias] May-alias graph after instruction  *key = s3;  is
-  4:{ s2 } â†’ 3:{  }   10:{ key } â†’ 11:{ *key; s3 }
-  11:{ *key; s3 } â†’ 7:{  }
 [alias] analysing instruction: *key = s2;
 [alias] May-aliases after instruction  *key = s2;  are  { *key; s2 }
-[alias] May-alias graph after instruction  *key = s2;  is
-  8:{ s3 } â†’ 7:{  }   12:{ key } â†’ 13:{ *key; s2 }
-  13:{ *key; s2 } â†’ 3:{  }
 [alias] May-aliases at the end of function CPS_ParseKey: { *key; s2; s3 }
-[alias] May-alias graph at the end of function CPS_ParseKey:
-  4:{ *key; s2; s3 } â†’ 3:{  }   10:{ key } â†’ 4:{ *key; s2; s3 }
-[alias] Summary of function CPS_ParseKey:
-  formals:     locals: keyâ†’{ *key; s2; s3 }  s2  s3    returns: <none>
-  state: { *key; s2; s3 }
 [alias] analysing function: CPS_SplitWord
 [alias] May-aliases at the end of function CPS_SplitWord: <none>
-[alias] May-alias graph at the end of function CPS_SplitWord:
-  <empty>
-[alias] Summary of function CPS_SplitWord:
-  formals: line    locals:     returns: line    state: <none>
-[alias] Analysis complete
diff --git a/src/plugins/alias/tests/offsets/oracle/array1.res.oracle b/src/plugins/alias/tests/offsets/oracle/array1.res.oracle
index c821849b395..d49ca85c658 100644
--- a/src/plugins/alias/tests/offsets/oracle/array1.res.oracle
+++ b/src/plugins/alias/tests/offsets/oracle/array1.res.oracle
@@ -2,33 +2,16 @@
 [alias] analysing function: main
 [alias] analysing instruction: tab[0] = 0;
 [alias] May-aliases after instruction  tab[0] = 0;  are  <none>
-[alias] May-alias graph after instruction  tab[0] = 0;  is    <empty>
 [alias] analysing instruction: tab[1] = 1;
 [alias] May-aliases after instruction  tab[1] = 1;  are  <none>
-[alias] May-alias graph after instruction  tab[1] = 1;  is    <empty>
 [alias] analysing instruction: tab[2] = tab[1] + 1;
 [alias] May-aliases after instruction  tab[2] = tab[1] + 1;  are  <none>
-[alias] May-alias graph after instruction  tab[2] = tab[1] + 1;  is    <empty>
 [alias] analysing instruction: int *x = & tab[1];
 [alias] May-aliases after instruction  int *x = & tab[1];  are  <none>
-[alias] May-alias graph after instruction  int *x = & tab[1];  is
-  0:{ x } â†’ 1:{ tab[0..] }
 [alias] analysing instruction: int *y = & tab[2];
 [alias] May-aliases after instruction  int *y = & tab[2];  are  { x; y }
-[alias] May-alias graph after instruction  int *y = & tab[2];  is
-  0:{ x } â†’ 5:{ tab[0..] }   4:{ y } â†’ 5:{ tab[0..] }
 [alias] analysing instruction: tab[3] = *x + *y;
 [alias] May-aliases after instruction  tab[3] = *x + *y;  are  { x; y }
-[alias] May-alias graph after instruction  tab[3] = *x + *y;  is
-  0:{ x } â†’ 5:{ tab[0..] }   4:{ y } â†’ 5:{ tab[0..] }
 [alias] analysing instruction: __retres = 0;
 [alias] May-aliases after instruction  __retres = 0;  are  { x; y }
-[alias] May-alias graph after instruction  __retres = 0;  is
-  0:{ x } â†’ 5:{ tab[0..] }   4:{ y } â†’ 5:{ tab[0..] }
 [alias] May-aliases at the end of function main: { x; y }
-[alias] May-alias graph at the end of function main:
-  0:{ x } â†’ 5:{ tab[0..] }   4:{ y } â†’ 5:{ tab[0..] }
-[alias] Summary of function main:
-  formals:     locals: tab  xâ†’{ tab[0..] }  yâ†’{ tab[0..] }  __retres
-  returns: __retres    state: { x; y }
-[alias] Analysis complete
diff --git a/src/plugins/alias/tests/offsets/oracle/array2.res.oracle b/src/plugins/alias/tests/offsets/oracle/array2.res.oracle
index bd04a4dd06d..69f16a022f8 100644
--- a/src/plugins/alias/tests/offsets/oracle/array2.res.oracle
+++ b/src/plugins/alias/tests/offsets/oracle/array2.res.oracle
@@ -2,26 +2,12 @@
 [alias] analysing function: main
 [alias] analysing instruction: mat[0][0] = 0;
 [alias] May-aliases after instruction  mat[0][0] = 0;  are  <none>
-[alias] May-alias graph after instruction  mat[0][0] = 0;  is    <empty>
 [alias] analysing instruction: mat[0][1] = 1;
 [alias] May-aliases after instruction  mat[0][1] = 1;  are  <none>
-[alias] May-alias graph after instruction  mat[0][1] = 1;  is    <empty>
 [alias] analysing instruction: *x = mat[1];
 [alias] May-aliases after instruction  *x = mat[1];  are  <none>
-[alias] May-alias graph after instruction  *x = mat[1];  is
-  0:{ x } â†’ 1:{ *x }   1:{ *x } â†’ 2:{ mat[0..] }
 [alias] analysing instruction: *y = *(*(x + 0));
 [alias] May-aliases after instruction  *y = *(*(x + 0));  are  <none>
-[alias] May-alias graph after instruction  *y = *(*(x + 0));  is
-  0:{ x } â†’ 1:{ *x }   1:{ *x } â†’ 2:{ mat[0..] }
 [alias] analysing instruction: __retres = 0;
 [alias] May-aliases after instruction  __retres = 0;  are  <none>
-[alias] May-alias graph after instruction  __retres = 0;  is
-  0:{ x } â†’ 1:{ *x }   1:{ *x } â†’ 2:{ mat[0..] }
 [alias] May-aliases at the end of function main: <none>
-[alias] May-alias graph at the end of function main:
-  0:{ x } â†’ 1:{ *x }   1:{ *x } â†’ 2:{ mat[0..] }
-[alias] Summary of function main:
-  formals:     locals: mat  xâ†’{ *x }  y  __retres    returns: __retres
-  state: <none>
-[alias] Analysis complete
diff --git a/src/plugins/alias/tests/offsets/oracle/array3.res.oracle b/src/plugins/alias/tests/offsets/oracle/array3.res.oracle
index 91e72cbb2e6..86668cf8314 100644
--- a/src/plugins/alias/tests/offsets/oracle/array3.res.oracle
+++ b/src/plugins/alias/tests/offsets/oracle/array3.res.oracle
@@ -3,30 +3,13 @@
 [alias] analysing instruction: int *x = malloc((unsigned long)4 * sizeof(int));
 [alias] May-aliases after instruction
   int *x = malloc((unsigned long)4 * sizeof(int));  are  <none>
-[alias] May-alias graph after instruction
-  int *x = malloc((unsigned long)4 * sizeof(int));  is    0:{ x } â†’ 1:{  }
 [alias] analysing instruction: int *y = malloc((unsigned long)4 * sizeof(int));
 [alias] May-aliases after instruction
   int *y = malloc((unsigned long)4 * sizeof(int));  are  <none>
-[alias] May-alias graph after instruction
-  int *y = malloc((unsigned long)4 * sizeof(int));  is
-  0:{ x } â†’ 1:{  }   2:{ y } â†’ 3:{  }
 [alias] analysing instruction: x = mat[0];
 [alias] May-aliases after instruction  x = mat[0];  are  <none>
-[alias] May-alias graph after instruction  x = mat[0];  is
-  0:{ x } â†’ 1:{ mat[0..] }   2:{ y } â†’ 3:{  }
 [alias] analysing instruction: y = mat[1];
 [alias] May-aliases after instruction  y = mat[1];  are  { x; y }
-[alias] May-alias graph after instruction  y = mat[1];  is
-  0:{ x } â†’ 3:{ mat[0..] }   2:{ y } â†’ 3:{ mat[0..] }
 [alias] analysing instruction: __retres = 0;
 [alias] May-aliases after instruction  __retres = 0;  are  { x; y }
-[alias] May-alias graph after instruction  __retres = 0;  is
-  0:{ x } â†’ 3:{ mat[0..] }   2:{ y } â†’ 3:{ mat[0..] }
 [alias] May-aliases at the end of function main: { x; y }
-[alias] May-alias graph at the end of function main:
-  0:{ x } â†’ 3:{ mat[0..] }   2:{ y } â†’ 3:{ mat[0..] }
-[alias] Summary of function main:
-  formals:     locals: mat  xâ†’{ mat[0..] }  yâ†’{ mat[0..] }  __retres
-  returns: __retres    state: { x; y }
-[alias] Analysis complete
diff --git a/src/plugins/alias/tests/offsets/oracle/collapse1.res.oracle b/src/plugins/alias/tests/offsets/oracle/collapse1.res.oracle
index e4249a441ad..9b588f2f8f2 100644
--- a/src/plugins/alias/tests/offsets/oracle/collapse1.res.oracle
+++ b/src/plugins/alias/tests/offsets/oracle/collapse1.res.oracle
@@ -2,32 +2,18 @@
 [alias] analysing function: main
 [alias] analysing instruction: tab[0] = 0;
 [alias] May-aliases after instruction  tab[0] = 0;  are  <none>
-[alias] May-alias graph after instruction  tab[0] = 0;  is    <empty>
 [alias] analysing instruction: tab[1] = 1;
 [alias] May-aliases after instruction  tab[1] = 1;  are  <none>
-[alias] May-alias graph after instruction  tab[1] = 1;  is    <empty>
 [alias] analysing instruction: tab[2] = tab[1] + 1;
 [alias] May-aliases after instruction  tab[2] = tab[1] + 1;  are  <none>
-[alias] May-alias graph after instruction  tab[2] = tab[1] + 1;  is    <empty>
 [alias] analysing instruction: int x = 0;
 [alias] May-aliases after instruction  int x = 0;  are  <none>
-[alias] May-alias graph after instruction  int x = 0;  is    <empty>
 [alias] analysing instruction: int i = 0;
 [alias] May-aliases after instruction  int i = 0;  are  <none>
-[alias] May-alias graph after instruction  int i = 0;  is    <empty>
 [alias] analysing instruction: x = tab[i];
 [alias] May-aliases after instruction  x = tab[i];  are  <none>
-[alias] May-alias graph after instruction  x = tab[i];  is    <empty>
 [alias] analysing instruction: i ++;
 [alias] May-aliases after instruction  i ++;  are  <none>
-[alias] May-alias graph after instruction  i ++;  is    <empty>
 [alias] analysing instruction: __retres = 0;
 [alias] May-aliases after instruction  __retres = 0;  are  <none>
-[alias] May-alias graph after instruction  __retres = 0;  is    <empty>
 [alias] May-aliases at the end of function main: <none>
-[alias] May-alias graph at the end of function main:
-  <empty>
-[alias] Summary of function main:
-  formals:     locals: tab  x  i  __retres    returns: __retres
-  state: <none>
-[alias] Analysis complete
diff --git a/src/plugins/alias/tests/offsets/oracle/collapse2.res.oracle b/src/plugins/alias/tests/offsets/oracle/collapse2.res.oracle
index 07d8fde2b7c..34b8bd11975 100644
--- a/src/plugins/alias/tests/offsets/oracle/collapse2.res.oracle
+++ b/src/plugins/alias/tests/offsets/oracle/collapse2.res.oracle
@@ -2,28 +2,16 @@
 [alias] analysing function: main
 [alias] analysing instruction: mat[0][0] = 0;
 [alias] May-aliases after instruction  mat[0][0] = 0;  are  <none>
-[alias] May-alias graph after instruction  mat[0][0] = 0;  is    <empty>
 [alias] analysing instruction: mat[0][1] = 1;
 [alias] May-aliases after instruction  mat[0][1] = 1;  are  <none>
-[alias] May-alias graph after instruction  mat[0][1] = 1;  is    <empty>
 [alias] analysing instruction: int i = 2;
 [alias] May-aliases after instruction  int i = 2;  are  <none>
-[alias] May-alias graph after instruction  int i = 2;  is    <empty>
 [alias] analysing instruction: mat[1][i] = i;
 [alias] May-aliases after instruction  mat[1][i] = i;  are  <none>
-[alias] May-alias graph after instruction  mat[1][i] = i;  is    <empty>
 [alias] analysing instruction: i ++;
 [alias] May-aliases after instruction  i ++;  are  <none>
-[alias] May-alias graph after instruction  i ++;  is    <empty>
 [alias] analysing instruction: mat[1][i] = 2;
 [alias] May-aliases after instruction  mat[1][i] = 2;  are  <none>
-[alias] May-alias graph after instruction  mat[1][i] = 2;  is    <empty>
 [alias] analysing instruction: __retres = 0;
 [alias] May-aliases after instruction  __retres = 0;  are  <none>
-[alias] May-alias graph after instruction  __retres = 0;  is    <empty>
 [alias] May-aliases at the end of function main: <none>
-[alias] May-alias graph at the end of function main:
-  <empty>
-[alias] Summary of function main:
-  formals:     locals: mat  i  __retres    returns: __retres    state: <none>
-[alias] Analysis complete
diff --git a/src/plugins/alias/tests/offsets/oracle/collapse3.res.oracle b/src/plugins/alias/tests/offsets/oracle/collapse3.res.oracle
index 225de1d3417..4193c3f90a2 100644
--- a/src/plugins/alias/tests/offsets/oracle/collapse3.res.oracle
+++ b/src/plugins/alias/tests/offsets/oracle/collapse3.res.oracle
@@ -2,28 +2,16 @@
 [alias] analysing function: main
 [alias] analysing instruction: mat[0][0] = 0;
 [alias] May-aliases after instruction  mat[0][0] = 0;  are  <none>
-[alias] May-alias graph after instruction  mat[0][0] = 0;  is    <empty>
 [alias] analysing instruction: mat[0][1] = 1;
 [alias] May-aliases after instruction  mat[0][1] = 1;  are  <none>
-[alias] May-alias graph after instruction  mat[0][1] = 1;  is    <empty>
 [alias] analysing instruction: int i = 2;
 [alias] May-aliases after instruction  int i = 2;  are  <none>
-[alias] May-alias graph after instruction  int i = 2;  is    <empty>
 [alias] analysing instruction: mat[i][1] = i;
 [alias] May-aliases after instruction  mat[i][1] = i;  are  <none>
-[alias] May-alias graph after instruction  mat[i][1] = i;  is    <empty>
 [alias] analysing instruction: i ++;
 [alias] May-aliases after instruction  i ++;  are  <none>
-[alias] May-alias graph after instruction  i ++;  is    <empty>
 [alias] analysing instruction: mat[i][1] = 2;
 [alias] May-aliases after instruction  mat[i][1] = 2;  are  <none>
-[alias] May-alias graph after instruction  mat[i][1] = 2;  is    <empty>
 [alias] analysing instruction: __retres = 0;
 [alias] May-aliases after instruction  __retres = 0;  are  <none>
-[alias] May-alias graph after instruction  __retres = 0;  is    <empty>
 [alias] May-aliases at the end of function main: <none>
-[alias] May-alias graph at the end of function main:
-  <empty>
-[alias] Summary of function main:
-  formals:     locals: mat  i  __retres    returns: __retres    state: <none>
-[alias] Analysis complete
diff --git a/src/plugins/alias/tests/offsets/oracle/jfla_running_ex.res.oracle b/src/plugins/alias/tests/offsets/oracle/jfla_running_ex.res.oracle
index 028cc235d21..03bb4fa391e 100644
--- a/src/plugins/alias/tests/offsets/oracle/jfla_running_ex.res.oracle
+++ b/src/plugins/alias/tests/offsets/oracle/jfla_running_ex.res.oracle
@@ -2,134 +2,52 @@
 [alias] analysing function: jfla
 [alias] analysing instruction: *snd = *fst;
 [alias] May-aliases after instruction  *snd = *fst;  are  <none>
-[alias] May-alias graph after instruction  *snd = *fst;  is    <empty>
 [alias] analysing instruction: fst = *i1;
 [alias] May-aliases after instruction  fst = *i1;  are  { *i1; fst }
-[alias] May-alias graph after instruction  fst = *i1;  is
-  0:{ *i1; fst } â†’ 1:{  }   2:{ i1 } â†’ 0:{ *i1; fst }
 [alias] analysing instruction: __retres = *i2;
 [alias] May-aliases after instruction  __retres = *i2;  are
   { *i1; fst }  { *i2; __retres }
-[alias] May-alias graph after instruction  __retres = *i2;  is
-  0:{ *i1; fst } â†’ 1:{  }   2:{ i1 } â†’ 0:{ *i1; fst }
-  4:{ *i2; __retres } â†’ 5:{  }   6:{ i2 } â†’ 4:{ *i2; __retres }
 [alias] analysing instruction: fst = *i2;
 [alias] May-aliases after instruction  fst = *i2;  are  { *i2; fst }
-[alias] May-alias graph after instruction  fst = *i2;  is
-  8:{ *i2; fst } â†’ 9:{  }   10:{ i2 } â†’ 8:{ *i2; fst }
 [alias] analysing instruction: __retres = *i1;
 [alias] May-aliases after instruction  __retres = *i1;  are
   { *i2; fst }  { *i1; __retres }
-[alias] May-alias graph after instruction  __retres = *i1;  is
-  8:{ *i2; fst } â†’ 9:{  }   10:{ i2 } â†’ 8:{ *i2; fst }
-  12:{ *i1; __retres } â†’ 13:{  }   14:{ i1 } â†’ 12:{ *i1; __retres }
 [alias] May-aliases at the end of function jfla:
   { i1; i2 }  { *i1; *i2; fst; __retres }
-[alias] May-alias graph at the end of function jfla:
-  0:{ *i1; *i2; fst; __retres } â†’ 1:{  }
-  2:{ i1 } â†’ 0:{ *i1; *i2; fst; __retres }
-  6:{ i2 } â†’ 0:{ *i1; *i2; fst; __retres }
-[alias] Summary of function jfla:
-  formals: fst  snd  i1â†’{ *i1; *i2; fst; __retres }
-            i2â†’{ *i1; *i2; fst; __retres }  bo
-  locals: __retres    returns: __retres
-  state: { i1; i2 }  { *i1; *i2; fst; __retres }
 [alias] analysing function: main
 [alias] analysing instruction: int u = 11;
 [alias] May-aliases after instruction  int u = 11;  are  <none>
-[alias] May-alias graph after instruction  int u = 11;  is    <empty>
 [alias] analysing instruction: int v = 12;
 [alias] May-aliases after instruction  int v = 12;  are  <none>
-[alias] May-alias graph after instruction  int v = 12;  is    <empty>
 [alias] analysing instruction: int t[3] = {0, 1, 2};
 [alias] May-aliases after instruction  int t[3] = {0, 1, 2};  are  <none>
-[alias] May-alias graph after instruction  int t[3] = {0, 1, 2};  is    <empty>
 [alias] analysing instruction: int *a = & t[1];
 [alias] May-aliases after instruction  int *a = & t[1];  are  <none>
-[alias] May-alias graph after instruction  int *a = & t[1];  is
-  16:{ a } â†’ 17:{ t[0..] }
 [alias] analysing instruction: int *b = & u;
 [alias] May-aliases after instruction  int *b = & u;  are  <none>
-[alias] May-alias graph after instruction  int *b = & u;  is
-  16:{ a } â†’ 17:{ t[0..] }   20:{ b } â†’ 21:{ u }
 [alias] analysing instruction: int *c = & v;
 [alias] May-aliases after instruction  int *c = & v;  are  <none>
-[alias] May-alias graph after instruction  int *c = & v;  is
-  16:{ a } â†’ 17:{ t[0..] }   20:{ b } â†’ 21:{ u }   24:{ c } â†’ 25:{ v }
 [alias] analysing instruction: int **x = & a;
 [alias] May-aliases after instruction  int **x = & a;  are  { *x; a }
-[alias] May-alias graph after instruction  int **x = & a;  is
-  20:{ b } â†’ 21:{ u }   24:{ c } â†’ 25:{ v }   28:{ x } â†’ 29:{ a }
-  29:{ a } â†’ 17:{ t[0..] }
 [alias] analysing instruction: int **y = & b;
 [alias] May-aliases after instruction  int **y = & b;  are  { *x; a }  { *y; b }
-[alias] May-alias graph after instruction  int **y = & b;  is
-  24:{ c } â†’ 25:{ v }   28:{ x } â†’ 29:{ a }   29:{ a } â†’ 17:{ t[0..] }
-  31:{ y } â†’ 32:{ b }   32:{ b } â†’ 21:{ u }
 [alias] analysing instruction: int **z = & c;
 [alias] May-aliases after instruction  int **z = & c;  are
   { *x; a }  { *y; b }  { *z; c }
-[alias] May-alias graph after instruction  int **z = & c;  is
-  28:{ x } â†’ 29:{ a }   29:{ a } â†’ 17:{ t[0..] }   31:{ y } â†’ 32:{ b }
-  32:{ b } â†’ 21:{ u }   34:{ z } â†’ 35:{ c }   35:{ c } â†’ 25:{ v }
 [alias] analysing instruction: struct str_t s = {.fst = c, .snd = t};
 [alias] May-aliases after instruction  struct str_t s = {.fst = c, .snd = t};  are
   { *x; a }  { *y; b }  { *z; c; s.fst }
-[alias] May-alias graph after instruction  struct str_t s = {.fst = c, .snd = t};
-  is
-  28:{ x } â†’ 29:{ a }   29:{ a } â†’ 17:{ t[0..] }   31:{ y } â†’ 32:{ b }
-  32:{ b } â†’ 21:{ u }   34:{ z } â†’ 37:{ c; s.fst }
-  37:{ c; s.fst } â†’ 25:{ v }   38:{ s.snd } â†’ 39:{ t }
 [alias] analysing instruction: struct str_t *s1 = & s;
 [alias] May-aliases after instruction  struct str_t *s1 = & s;  are
   { *x; a }  { *y; b }  { *z; c; s.fst }
-[alias] May-alias graph after instruction  struct str_t *s1 = & s;  is
-  28:{ x } â†’ 29:{ a }   29:{ a } â†’ 17:{ t[0..] }   31:{ y } â†’ 32:{ b }
-  32:{ b } â†’ 21:{ u }   34:{ z } â†’ 37:{ c; s.fst }
-  37:{ c; s.fst } â†’ 25:{ v }   38:{ s.snd } â†’ 39:{ t }
-  41:{ s1 } â†’ 42:{ s }
 [alias] analysing instruction: struct str_t *s2 = & s;
 [alias] May-aliases after instruction  struct str_t *s2 = & s;  are
   { *x; a }  { *y; b }  { *z; c; s.fst }  { s1; s2 }
-[alias] May-alias graph after instruction  struct str_t *s2 = & s;  is
-  28:{ x } â†’ 29:{ a }   29:{ a } â†’ 17:{ t[0..] }   31:{ y } â†’ 32:{ b }
-  32:{ b } â†’ 21:{ u }   34:{ z } â†’ 37:{ c; s.fst }
-  37:{ c; s.fst } â†’ 25:{ v }   38:{ s.snd } â†’ 39:{ t }
-  41:{ s1 } â†’ 46:{ s }   45:{ s2 } â†’ 46:{ s }
 [alias] analysing instruction: c = jfla(s1->fst,s1->snd,x,y,0);
 [alias] May-aliases after instruction  c = jfla(s1->fst,s1->snd,x,y,0);  are
   { *x; *y; *z; s1->fst; a; b; c; s.fst }  { x; y }  { s1; s2 }
-[alias] May-alias graph after instruction  c = jfla(s1->fst,s1->snd,x,y,0);  is
-  28:{ x } â†’ 29:{ a; b }   29:{ a; b } â†’ 17:{ u; v; t[0..] }
-  31:{ y } â†’ 29:{ a; b }   34:{ z } â†’ 37:{ c; s.fst }
-  37:{ c; s.fst } â†’ 17:{ u; v; t[0..] }   38:{ s.snd } â†’ 39:{ t }
-  41:{ s1 } â†’ 46:{ s }   45:{ s2 } â†’ 46:{ s }
-  55:{ s1->fst } â†’ 17:{ u; v; t[0..] }
 [alias] analysing instruction: a = jfla(s2->fst,s2->snd,y,z,1);
 [alias] May-aliases after instruction  a = jfla(s2->fst,s2->snd,y,z,1);  are
   { *x; *y; *z; s1->fst; s2->fst; a; b; c; s.fst }  { x; y; z }  { s1; s2 }
-[alias] May-alias graph after instruction  a = jfla(s2->fst,s2->snd,y,z,1);  is
-  28:{ x } â†’ 29:{ a; b; c; s.fst }
-  29:{ a; b; c; s.fst } â†’ 17:{ u; v; t[0..] }
-  31:{ y } â†’ 29:{ a; b; c; s.fst }   34:{ z } â†’ 29:{ a; b; c; s.fst }
-  38:{ s.snd } â†’ 39:{ t }   41:{ s1 } â†’ 46:{ s }   45:{ s2 } â†’ 46:{ s }
-  55:{ s1->fst } â†’ 17:{ u; v; t[0..] }
-  63:{ s2->fst } â†’ 17:{ u; v; t[0..] }
 [alias] May-aliases at the end of function main:
   { *x; *y; *z; s1->fst; s2->fst; a; b; c; s.fst }  { x; y; z }  { s1; s2 }
-[alias] May-alias graph at the end of function main:
-  28:{ x } â†’ 29:{ a; b; c; s.fst }
-  29:{ a; b; c; s.fst } â†’ 17:{ u; v; t[0..] }
-  31:{ y } â†’ 29:{ a; b; c; s.fst }   34:{ z } â†’ 29:{ a; b; c; s.fst }
-  38:{ s.snd } â†’ 39:{ t }   41:{ s1 } â†’ 46:{ s }   45:{ s2 } â†’ 46:{ s }
-  55:{ s1->fst } â†’ 17:{ u; v; t[0..] }
-  63:{ s2->fst } â†’ 17:{ u; v; t[0..] }
-[alias] Summary of function main:
-  formals: 
-  locals: u  v  t  aâ†’{ u; v; t[0..] }  bâ†’{ u; v; t[0..] }
-           câ†’{ u; v; t[0..] }  xâ†’{ a; b; c; s.fst }  yâ†’{ a; b; c; s.fst }
-           zâ†’{ a; b; c; s.fst }  s  s1â†’{ s }  s2â†’{ s }
-  returns: <none>
-  state: { *x; *y; *z; s1->fst; s2->fst; a; b; c; s.fst }  { x; y; z }
-         { s1; s2 }
-[alias] Analysis complete
diff --git a/src/plugins/alias/tests/offsets/oracle/nested1.res.oracle b/src/plugins/alias/tests/offsets/oracle/nested1.res.oracle
index 87b1ce12e31..b4f23332d9c 100644
--- a/src/plugins/alias/tests/offsets/oracle/nested1.res.oracle
+++ b/src/plugins/alias/tests/offsets/oracle/nested1.res.oracle
@@ -2,130 +2,55 @@
 [alias] analysing function: main
 [alias] analysing instruction: st_1_t x1 = {.a = 0, .b = 1};
 [alias] May-aliases after instruction  st_1_t x1 = {.a = 0, .b = 1};  are  <none>
-[alias] May-alias graph after instruction  st_1_t x1 = {.a = 0, .b = 1};  is
-  <empty>
 [alias] analysing instruction: st_1_t x2 = {.a = 1, .b = 2};
 [alias] May-aliases after instruction  st_1_t x2 = {.a = 1, .b = 2};  are  <none>
-[alias] May-alias graph after instruction  st_1_t x2 = {.a = 1, .b = 2};  is
-  <empty>
 [alias] analysing instruction: tab_y[0] = & x1;
 [alias] May-aliases after instruction  tab_y[0] = & x1;  are  <none>
-[alias] May-alias graph after instruction  tab_y[0] = & x1;  is
-  0:{ tab_y[0..] } â†’ 1:{ x1 }
 [alias] analysing instruction: tab_y[1] = & x2;
 [alias] May-aliases after instruction  tab_y[1] = & x2;  are  <none>
-[alias] May-alias graph after instruction  tab_y[1] = & x2;  is
-  0:{ tab_y[0..] } â†’ 1:{ x1; x2 }
 [alias] analysing instruction: st_2_t *z1 = malloc(sizeof(st_2_t));
 [alias] May-aliases after instruction  st_2_t *z1 = malloc(sizeof(st_2_t));  are
   <none>
-[alias] May-alias graph after instruction  st_2_t *z1 = malloc(sizeof(st_2_t));
-  is    0:{ tab_y[0..] } â†’ 1:{ x1; x2 }   5:{ z1 } â†’ 6:{  }
 [alias] analysing instruction: st_2_t *z2 = malloc(sizeof(st_2_t));
 [alias] May-aliases after instruction  st_2_t *z2 = malloc(sizeof(st_2_t));  are
   <none>
-[alias] May-alias graph after instruction  st_2_t *z2 = malloc(sizeof(st_2_t));
-  is
-  0:{ tab_y[0..] } â†’ 1:{ x1; x2 }   5:{ z1 } â†’ 6:{  }   7:{ z2 } â†’ 8:{  }
 [alias] analysing instruction: st_3_t *t = malloc(sizeof(st_3_t));
 [alias] May-aliases after instruction  st_3_t *t = malloc(sizeof(st_3_t));  are
   <none>
-[alias] May-alias graph after instruction  st_3_t *t = malloc(sizeof(st_3_t));  is
-  0:{ tab_y[0..] } â†’ 1:{ x1; x2 }   5:{ z1 } â†’ 6:{  }
-  7:{ z2 } â†’ 8:{  }   9:{ t } â†’ 10:{  }
 [alias] analysing instruction: int *a = malloc(sizeof(int));
 [alias] May-aliases after instruction  int *a = malloc(sizeof(int));  are  <none>
-[alias] May-alias graph after instruction  int *a = malloc(sizeof(int));  is
-  0:{ tab_y[0..] } â†’ 1:{ x1; x2 }   5:{ z1 } â†’ 6:{  }
-  7:{ z2 } â†’ 8:{  }   9:{ t } â†’ 10:{  }   11:{ a } â†’ 12:{  }
 [alias] analysing instruction: int *b = malloc(sizeof(int));
 [alias] May-aliases after instruction  int *b = malloc(sizeof(int));  are  <none>
-[alias] May-alias graph after instruction  int *b = malloc(sizeof(int));  is
-  0:{ tab_y[0..] } â†’ 1:{ x1; x2 }   5:{ z1 } â†’ 6:{  }
-  7:{ z2 } â†’ 8:{  }   9:{ t } â†’ 10:{  }   11:{ a } â†’ 12:{  }
-  13:{ b } â†’ 14:{  }
 [alias] analysing instruction: *a = 0;
 [alias] May-aliases after instruction  *a = 0;  are  <none>
-[alias] May-alias graph after instruction  *a = 0;  is
-  0:{ tab_y[0..] } â†’ 1:{ x1; x2 }   5:{ z1 } â†’ 6:{  }
-  7:{ z2 } â†’ 8:{  }   9:{ t } â†’ 10:{  }   11:{ a } â†’ 12:{  }
-  13:{ b } â†’ 14:{  }
 [alias] analysing instruction: *b = 5;
 [alias] May-aliases after instruction  *b = 5;  are  <none>
-[alias] May-alias graph after instruction  *b = 5;  is
-  0:{ tab_y[0..] } â†’ 1:{ x1; x2 }   5:{ z1 } â†’ 6:{  }
-  7:{ z2 } â†’ 8:{  }   9:{ t } â†’ 10:{  }   11:{ a } â†’ 12:{  }
-  13:{ b } â†’ 14:{  }
 [alias] analysing instruction: z1->s = (struct struct_1_t *)tab_y[0];
 [alias:unsafe-cast] nested1.c:47: Warning: 
   unsafe cast from st_1_t * to struct struct_1_t *
 [alias] May-aliases after instruction  z1->s = (struct struct_1_t *)tab_y[0];  are
   { z1->s; tab_y[0..] }
-[alias] May-alias graph after instruction  z1->s = (struct struct_1_t *)tab_y[0];
-  is
-  5:{ z1 } â†’ 6:{  }   7:{ z2 } â†’ 8:{  }   9:{ t } â†’ 10:{  }
-  11:{ a } â†’ 12:{  }   13:{ b } â†’ 14:{  }
-  15:{ z1->s; tab_y[0..] } â†’ 1:{ x1; x2 }
 [alias] analysing instruction: z2->s = (struct struct_1_t *)tab_y[1];
 [alias:unsafe-cast] nested1.c:48: Warning: 
   unsafe cast from st_1_t * to struct struct_1_t *
 [alias] May-aliases after instruction  z2->s = (struct struct_1_t *)tab_y[1];  are
   { z1->s; z2->s; tab_y[0..] }
-[alias] May-alias graph after instruction  z2->s = (struct struct_1_t *)tab_y[1];
-  is
-  5:{ z1 } â†’ 6:{  }   7:{ z2 } â†’ 8:{  }   9:{ t } â†’ 10:{  }
-  11:{ a } â†’ 12:{  }   13:{ b } â†’ 14:{  }
-  16:{ z1->s; z2->s; tab_y[0..] } â†’ 1:{ x1; x2 }
 [alias] analysing instruction: z1->c = a;
 [alias] May-aliases after instruction  z1->c = a;  are
   { z1->s; z2->s; tab_y[0..] }  { z1->c; a }
-[alias] May-alias graph after instruction  z1->c = a;  is
-  5:{ z1 } â†’ 6:{  }   7:{ z2 } â†’ 8:{  }   9:{ t } â†’ 10:{  }
-  13:{ b } â†’ 14:{  }   16:{ z1->s; z2->s; tab_y[0..] } â†’ 1:{ x1; x2 }
-  17:{ z1->c; a } â†’ 12:{  }
 [alias] analysing instruction: z2->c = b;
 [alias] May-aliases after instruction  z2->c = b;  are
   { z1->s; z2->s; tab_y[0..] }  { z1->c; a }  { z2->c; b }
-[alias] May-alias graph after instruction  z2->c = b;  is
-  5:{ z1 } â†’ 6:{  }   7:{ z2 } â†’ 8:{  }   9:{ t } â†’ 10:{  }
-  16:{ z1->s; z2->s; tab_y[0..] } â†’ 1:{ x1; x2 }
-  17:{ z1->c; a } â†’ 12:{  }   18:{ z2->c; b } â†’ 14:{  }
 [alias] analysing instruction: t->t = (struct struct_2_t *)z1;
 [alias:unsafe-cast] nested1.c:51: Warning: 
   unsafe cast from st_2_t * to struct struct_2_t *
 [alias] May-aliases after instruction  t->t = (struct struct_2_t *)z1;  are
   { z1->s; z2->s; tab_y[0..] }  { t->t; z1 }  { z1->c; a }  { z2->c; b }
-[alias] May-alias graph after instruction  t->t = (struct struct_2_t *)z1;  is
-  7:{ z2 } â†’ 8:{  }   9:{ t } â†’ 10:{  }
-  16:{ z1->s; z2->s; tab_y[0..] } â†’ 1:{ x1; x2 }
-  17:{ z1->c; a } â†’ 12:{  }   18:{ z2->c; b } â†’ 14:{  }
-  19:{ t->t; z1 } â†’ 6:{  }
 [alias] analysing instruction: t->d = a;
 [alias] May-aliases after instruction  t->d = a;  are
   { z1->s; z2->s; tab_y[0..] }  { t->t; z1 }  { z1->c; t->d; a }  { z2->c; b }
-[alias] May-alias graph after instruction  t->d = a;  is
-  7:{ z2 } â†’ 8:{  }   9:{ t } â†’ 10:{  }
-  16:{ z1->s; z2->s; tab_y[0..] } â†’ 1:{ x1; x2 }
-  18:{ z2->c; b } â†’ 14:{  }   19:{ t->t; z1 } â†’ 6:{  }
-  20:{ z1->c; t->d; a } â†’ 12:{  }
 [alias] analysing instruction: __retres = 0;
 [alias] May-aliases after instruction  __retres = 0;  are
   { z1->s; z2->s; tab_y[0..] }  { t->t; z1 }  { z1->c; t->d; a }  { z2->c; b }
-[alias] May-alias graph after instruction  __retres = 0;  is
-  7:{ z2 } â†’ 8:{  }   9:{ t } â†’ 10:{  }
-  16:{ z1->s; z2->s; tab_y[0..] } â†’ 1:{ x1; x2 }
-  18:{ z2->c; b } â†’ 14:{  }   19:{ t->t; z1 } â†’ 6:{  }
-  20:{ z1->c; t->d; a } â†’ 12:{  }
 [alias] May-aliases at the end of function main:
   { z1->s; z2->s; tab_y[0..] }  { t->t; z1 }  { z1->c; t->d; a }  { z2->c; b }
-[alias] May-alias graph at the end of function main:
-  7:{ z2 } â†’ 8:{  }   9:{ t } â†’ 10:{  }
-  16:{ z1->s; z2->s; tab_y[0..] } â†’ 1:{ x1; x2 }
-  18:{ z2->c; b } â†’ 14:{  }   19:{ t->t; z1 } â†’ 6:{  }
-  20:{ z1->c; t->d; a } â†’ 12:{  }
-[alias] Summary of function main:
-  formals:     locals: x1  x2  tab_y  z1  z2  t  a  b  __retres
-  returns: __retres
-  state: { z1->s; z2->s; tab_y[0..] }  { t->t; z1 }  { z1->c; t->d; a }
-         { z2->c; b }
-[alias] Analysis complete
diff --git a/src/plugins/alias/tests/offsets/oracle/nested2.res.oracle b/src/plugins/alias/tests/offsets/oracle/nested2.res.oracle
index 7c472531448..c7e1e4080be 100644
--- a/src/plugins/alias/tests/offsets/oracle/nested2.res.oracle
+++ b/src/plugins/alias/tests/offsets/oracle/nested2.res.oracle
@@ -2,78 +2,39 @@
 [alias] analysing function: main
 [alias] analysing instruction: st_1_t x1 = {.a = 0, .b = 1};
 [alias] May-aliases after instruction  st_1_t x1 = {.a = 0, .b = 1};  are  <none>
-[alias] May-alias graph after instruction  st_1_t x1 = {.a = 0, .b = 1};  is
-  <empty>
 [alias] analysing instruction: st_1_t x2 = {.a = 2, .b = 3};
 [alias] May-aliases after instruction  st_1_t x2 = {.a = 2, .b = 3};  are  <none>
-[alias] May-alias graph after instruction  st_1_t x2 = {.a = 2, .b = 3};  is
-  <empty>
 [alias] analysing instruction: st_2_t *z1 = malloc(sizeof(st_2_t));
 [alias] May-aliases after instruction  st_2_t *z1 = malloc(sizeof(st_2_t));  are
   <none>
-[alias] May-alias graph after instruction  st_2_t *z1 = malloc(sizeof(st_2_t));
-  is    0:{ z1 } â†’ 1:{  }
 [alias] analysing instruction: st_3_t *t = malloc(sizeof(st_3_t));
 [alias] May-aliases after instruction  st_3_t *t = malloc(sizeof(st_3_t));  are
   <none>
-[alias] May-alias graph after instruction  st_3_t *t = malloc(sizeof(st_3_t));  is
-  0:{ z1 } â†’ 1:{  }   2:{ t } â†’ 3:{  }
 [alias] analysing instruction: int *a = malloc(sizeof(int));
 [alias] May-aliases after instruction  int *a = malloc(sizeof(int));  are  <none>
-[alias] May-alias graph after instruction  int *a = malloc(sizeof(int));  is
-  0:{ z1 } â†’ 1:{  }   2:{ t } â†’ 3:{  }   4:{ a } â†’ 5:{  }
 [alias] analysing instruction: *a = 0;
 [alias] May-aliases after instruction  *a = 0;  are  <none>
-[alias] May-alias graph after instruction  *a = 0;  is
-  0:{ z1 } â†’ 1:{  }   2:{ t } â†’ 3:{  }   4:{ a } â†’ 5:{  }
 [alias] analysing instruction: z1->s[0] = (struct struct_1_t *)(& x1);
 [alias:unsafe-cast] nested2.c:42: Warning: 
   unsafe cast from st_1_t * to struct struct_1_t *
 [alias] May-aliases after instruction  z1->s[0] = (struct struct_1_t *)(& x1);  are
   <none>
-[alias] May-alias graph after instruction  z1->s[0] = (struct struct_1_t *)(& x1);
-  is
-  0:{ z1 } â†’ 1:{  }   2:{ t } â†’ 3:{  }   4:{ a } â†’ 5:{  }
-  6:{ z1->s[0..] } â†’ 7:{ x1 }
 [alias] analysing instruction: z1->s[1] = (struct struct_1_t *)(& x2);
 [alias:unsafe-cast] nested2.c:43: Warning: 
   unsafe cast from st_1_t * to struct struct_1_t *
 [alias] May-aliases after instruction  z1->s[1] = (struct struct_1_t *)(& x2);  are
   <none>
-[alias] May-alias graph after instruction  z1->s[1] = (struct struct_1_t *)(& x2);
-  is
-  0:{ z1 } â†’ 1:{  }   2:{ t } â†’ 3:{  }   4:{ a } â†’ 5:{  }
-  6:{ z1->s[0..] } â†’ 7:{ x1; x2 }
 [alias] analysing instruction: z1->c = a;
 [alias] May-aliases after instruction  z1->c = a;  are  { z1->c; a }
-[alias] May-alias graph after instruction  z1->c = a;  is
-  0:{ z1 } â†’ 1:{  }   2:{ t } â†’ 3:{  }
-  6:{ z1->s[0..] } â†’ 7:{ x1; x2 }   11:{ z1->c; a } â†’ 5:{  }
 [alias] analysing instruction: t->t = (struct struct_2_t *)z1;
 [alias:unsafe-cast] nested2.c:45: Warning: 
   unsafe cast from st_2_t * to struct struct_2_t *
 [alias] May-aliases after instruction  t->t = (struct struct_2_t *)z1;  are
   { t->t; z1 }  { z1->c; a }
-[alias] May-alias graph after instruction  t->t = (struct struct_2_t *)z1;  is
-  2:{ t } â†’ 3:{  }   6:{ z1->s[0..] } â†’ 7:{ x1; x2 }
-  11:{ z1->c; a } â†’ 5:{  }   12:{ t->t; z1 } â†’ 1:{  }
 [alias] analysing instruction: t->d = a;
 [alias] May-aliases after instruction  t->d = a;  are
   { t->t; z1 }  { z1->c; t->d; a }
-[alias] May-alias graph after instruction  t->d = a;  is
-  2:{ t } â†’ 3:{  }   6:{ z1->s[0..] } â†’ 7:{ x1; x2 }
-  12:{ t->t; z1 } â†’ 1:{  }   13:{ z1->c; t->d; a } â†’ 5:{  }
 [alias] analysing instruction: __retres = 0;
 [alias] May-aliases after instruction  __retres = 0;  are
   { t->t; z1 }  { z1->c; t->d; a }
-[alias] May-alias graph after instruction  __retres = 0;  is
-  2:{ t } â†’ 3:{  }   6:{ z1->s[0..] } â†’ 7:{ x1; x2 }
-  12:{ t->t; z1 } â†’ 1:{  }   13:{ z1->c; t->d; a } â†’ 5:{  }
 [alias] May-aliases at the end of function main: { t->t; z1 }  { z1->c; t->d; a }
-[alias] May-alias graph at the end of function main:
-  2:{ t } â†’ 3:{  }   6:{ z1->s[0..] } â†’ 7:{ x1; x2 }
-  12:{ t->t; z1 } â†’ 1:{  }   13:{ z1->c; t->d; a } â†’ 5:{  }
-[alias] Summary of function main:
-  formals:     locals: x1  x2  z1  t  a  __retres    returns: __retres
-  state: { t->t; z1 }  { z1->c; t->d; a }
-[alias] Analysis complete
diff --git a/src/plugins/alias/tests/offsets/oracle/structure1.res.oracle b/src/plugins/alias/tests/offsets/oracle/structure1.res.oracle
index 668bf60c584..b325558af32 100644
--- a/src/plugins/alias/tests/offsets/oracle/structure1.res.oracle
+++ b/src/plugins/alias/tests/offsets/oracle/structure1.res.oracle
@@ -2,38 +2,18 @@
 [alias] analysing function: main
 [alias] analysing instruction: st_1_t x = {.a = 0, .b = 1};
 [alias] May-aliases after instruction  st_1_t x = {.a = 0, .b = 1};  are  <none>
-[alias] May-alias graph after instruction  st_1_t x = {.a = 0, .b = 1};  is
-  <empty>
 [alias] analysing instruction: st_2_t y = {.a = 3, .c = 4};
 [alias] May-aliases after instruction  st_2_t y = {.a = 3, .c = 4};  are  <none>
-[alias] May-alias graph after instruction  st_2_t y = {.a = 3, .c = 4};  is
-  <empty>
 [alias] analysing instruction: st_1_t *p_x = & x;
 [alias] May-aliases after instruction  st_1_t *p_x = & x;  are  <none>
-[alias] May-alias graph after instruction  st_1_t *p_x = & x;  is
-  0:{ p_x } â†’ 1:{ x }
 [alias] analysing instruction: st_2_t *p_y = & y;
 [alias] May-aliases after instruction  st_2_t *p_y = & y;  are  <none>
-[alias] May-alias graph after instruction  st_2_t *p_y = & y;  is
-  0:{ p_x } â†’ 1:{ x }   4:{ p_y } â†’ 5:{ y }
 [alias] analysing instruction: p_x->a = 3;
 [alias] May-aliases after instruction  p_x->a = 3;  are  <none>
-[alias] May-alias graph after instruction  p_x->a = 3;  is
-  0:{ p_x } â†’ 1:{ x }   4:{ p_y } â†’ 5:{ y }
 [alias] analysing instruction: p_x = (st_1_t *)p_y;
 [alias:unsafe-cast] structure1.c:28: Warning: 
   unsafe cast from st_2_t * to st_1_t *
 [alias] May-aliases after instruction  p_x = (st_1_t *)p_y;  are  { p_x; p_y }
-[alias] May-alias graph after instruction  p_x = (st_1_t *)p_y;  is
-  0:{ p_x; p_y } â†’ 1:{ x; y }
 [alias] analysing instruction: __retres = 0;
 [alias] May-aliases after instruction  __retres = 0;  are  { p_x; p_y }
-[alias] May-alias graph after instruction  __retres = 0;  is
-  0:{ p_x; p_y } â†’ 1:{ x; y }
 [alias] May-aliases at the end of function main: { p_x; p_y }
-[alias] May-alias graph at the end of function main:
-  0:{ p_x; p_y } â†’ 1:{ x; y }
-[alias] Summary of function main:
-  formals:     locals: x  y  p_xâ†’{ x; y }  p_yâ†’{ x; y }  __retres
-  returns: __retres    state: { p_x; p_y }
-[alias] Analysis complete
diff --git a/src/plugins/alias/tests/offsets/oracle/structure2.res.oracle b/src/plugins/alias/tests/offsets/oracle/structure2.res.oracle
index 6d772d05177..2b2f7ecd4e5 100644
--- a/src/plugins/alias/tests/offsets/oracle/structure2.res.oracle
+++ b/src/plugins/alias/tests/offsets/oracle/structure2.res.oracle
@@ -2,35 +2,18 @@
 [alias] analysing function: main
 [alias] analysing instruction: st_1_t x1 = {.a = 0, .b = 1};
 [alias] May-aliases after instruction  st_1_t x1 = {.a = 0, .b = 1};  are  <none>
-[alias] May-alias graph after instruction  st_1_t x1 = {.a = 0, .b = 1};  is
-  <empty>
 [alias] analysing instruction: st_1_t x2 = {.a = 1, .b = 2};
 [alias] May-aliases after instruction  st_1_t x2 = {.a = 1, .b = 2};  are  <none>
-[alias] May-alias graph after instruction  st_1_t x2 = {.a = 1, .b = 2};  is
-  <empty>
 [alias] analysing instruction: st_2_t y = {.s = (struct struct_1_t *)(& x1), .c = 4};
 [alias:unsafe-cast] structure2.c:21: Warning: 
   unsafe cast from st_1_t * to struct struct_1_t *
 [alias] May-aliases after instruction
   st_2_t y = {.s = (struct struct_1_t *)(& x1), .c = 4};  are  <none>
-[alias] May-alias graph after instruction
-  st_2_t y = {.s = (struct struct_1_t *)(& x1), .c = 4};  is
-  0:{ y.s } â†’ 1:{ x1 }
 [alias] analysing instruction: y.s = (struct struct_1_t *)(& x2);
 [alias:unsafe-cast] structure2.c:23: Warning: 
   unsafe cast from st_1_t * to struct struct_1_t *
 [alias] May-aliases after instruction  y.s = (struct struct_1_t *)(& x2);  are
   <none>
-[alias] May-alias graph after instruction  y.s = (struct struct_1_t *)(& x2);  is
-  0:{ y.s } â†’ 1:{ x1; x2 }
 [alias] analysing instruction: __retres = 0;
 [alias] May-aliases after instruction  __retres = 0;  are  <none>
-[alias] May-alias graph after instruction  __retres = 0;  is
-  0:{ y.s } â†’ 1:{ x1; x2 }
 [alias] May-aliases at the end of function main: <none>
-[alias] May-alias graph at the end of function main:
-  0:{ y.s } â†’ 1:{ x1; x2 }
-[alias] Summary of function main:
-  formals:     locals: x1  x2  y  __retres    returns: __retres
-  state: <none>
-[alias] Analysis complete
diff --git a/src/plugins/alias/tests/offsets/oracle/structure3.res.oracle b/src/plugins/alias/tests/offsets/oracle/structure3.res.oracle
index 6c9609a49da..7ec86d402cb 100644
--- a/src/plugins/alias/tests/offsets/oracle/structure3.res.oracle
+++ b/src/plugins/alias/tests/offsets/oracle/structure3.res.oracle
@@ -2,61 +2,32 @@
 [alias] analysing function: main
 [alias] analysing instruction: st_1_t x1 = {.a = 0, .b = 1};
 [alias] May-aliases after instruction  st_1_t x1 = {.a = 0, .b = 1};  are  <none>
-[alias] May-alias graph after instruction  st_1_t x1 = {.a = 0, .b = 1};  is
-  <empty>
 [alias] analysing instruction: st_1_t x2 = {.a = 1, .b = 2};
 [alias] May-aliases after instruction  st_1_t x2 = {.a = 1, .b = 2};  are  <none>
-[alias] May-alias graph after instruction  st_1_t x2 = {.a = 1, .b = 2};  is
-  <empty>
 [alias] analysing instruction:
   st_2_t y1 = {.s = (struct struct_1_t *)(& x1), .c = 3};
 [alias:unsafe-cast] structure3.c:31: Warning: 
   unsafe cast from st_1_t * to struct struct_1_t *
 [alias] May-aliases after instruction
   st_2_t y1 = {.s = (struct struct_1_t *)(& x1), .c = 3};  are  <none>
-[alias] May-alias graph after instruction
-  st_2_t y1 = {.s = (struct struct_1_t *)(& x1), .c = 3};  is
-  0:{ y1.s } â†’ 1:{ x1 }
 [alias] analysing instruction:
   st_2_t y2 = {.s = (struct struct_1_t *)(& x2), .c = 4};
 [alias:unsafe-cast] structure3.c:32: Warning: 
   unsafe cast from st_1_t * to struct struct_1_t *
 [alias] May-aliases after instruction
   st_2_t y2 = {.s = (struct struct_1_t *)(& x2), .c = 4};  are  <none>
-[alias] May-alias graph after instruction
-  st_2_t y2 = {.s = (struct struct_1_t *)(& x2), .c = 4};  is
-  0:{ y1.s } â†’ 1:{ x1 }   3:{ y2.s } â†’ 4:{ x2 }
 [alias] analysing instruction: st_3_t z = {.t = (struct struct_2_t *)(& y1), .d = 5};
 [alias:unsafe-cast] structure3.c:33: Warning: 
   unsafe cast from st_2_t * to struct struct_2_t *
 [alias] May-aliases after instruction
   st_3_t z = {.t = (struct struct_2_t *)(& y1), .d = 5};  are  <none>
-[alias] May-alias graph after instruction
-  st_3_t z = {.t = (struct struct_2_t *)(& y1), .d = 5};  is
-  0:{ y1.s } â†’ 1:{ x1 }   3:{ y2.s } â†’ 4:{ x2 }   6:{ z.t } â†’ 7:{ y1 }
 [alias] analysing instruction: z.t = (struct struct_2_t *)(& y2);
 [alias:unsafe-cast] structure3.c:35: Warning: 
   unsafe cast from st_2_t * to struct struct_2_t *
 [alias] May-aliases after instruction  z.t = (struct struct_2_t *)(& y2);  are
   <none>
-[alias] May-alias graph after instruction  z.t = (struct struct_2_t *)(& y2);  is
-  0:{ y1.s } â†’ 1:{ x1 }   3:{ y2.s } â†’ 4:{ x2 }
-  6:{ z.t } â†’ 7:{ y1; y2 }
 [alias] analysing instruction: y1.c = z.d;
 [alias] May-aliases after instruction  y1.c = z.d;  are  <none>
-[alias] May-alias graph after instruction  y1.c = z.d;  is
-  0:{ y1.s } â†’ 1:{ x1 }   3:{ y2.s } â†’ 4:{ x2 }
-  6:{ z.t } â†’ 7:{ y1; y2 }
 [alias] analysing instruction: __retres = 0;
 [alias] May-aliases after instruction  __retres = 0;  are  <none>
-[alias] May-alias graph after instruction  __retres = 0;  is
-  0:{ y1.s } â†’ 1:{ x1 }   3:{ y2.s } â†’ 4:{ x2 }
-  6:{ z.t } â†’ 7:{ y1; y2 }
 [alias] May-aliases at the end of function main: <none>
-[alias] May-alias graph at the end of function main:
-  0:{ y1.s } â†’ 1:{ x1 }   3:{ y2.s } â†’ 4:{ x2 }
-  6:{ z.t } â†’ 7:{ y1; y2 }
-[alias] Summary of function main:
-  formals:     locals: x1  x2  y1  y2  z  __retres    returns: __retres
-  state: <none>
-[alias] Analysis complete
diff --git a/src/plugins/alias/tests/offsets/oracle/structure4.res.oracle b/src/plugins/alias/tests/offsets/oracle/structure4.res.oracle
index f9ca72c149d..f4bf90f2a09 100644
--- a/src/plugins/alias/tests/offsets/oracle/structure4.res.oracle
+++ b/src/plugins/alias/tests/offsets/oracle/structure4.res.oracle
@@ -2,45 +2,23 @@
 [alias] analysing function: main
 [alias] analysing instruction: st_1_t x1 = {.a = 0, .b = 1};
 [alias] May-aliases after instruction  st_1_t x1 = {.a = 0, .b = 1};  are  <none>
-[alias] May-alias graph after instruction  st_1_t x1 = {.a = 0, .b = 1};  is
-  <empty>
 [alias] analysing instruction: st_1_t x2 = {.a = 1, .b = 2};
 [alias] May-aliases after instruction  st_1_t x2 = {.a = 1, .b = 2};  are  <none>
-[alias] May-alias graph after instruction  st_1_t x2 = {.a = 1, .b = 2};  is
-  <empty>
 [alias] analysing instruction: st_1_t *y1 = malloc(sizeof(st_1_t));
 [alias] May-aliases after instruction  st_1_t *y1 = malloc(sizeof(st_1_t));  are
   <none>
-[alias] May-alias graph after instruction  st_1_t *y1 = malloc(sizeof(st_1_t));
-  is    0:{ y1 } â†’ 1:{  }
 [alias] analysing instruction: st_2_t *z = malloc(sizeof(st_2_t));
 [alias] May-aliases after instruction  st_2_t *z = malloc(sizeof(st_2_t));  are
   <none>
-[alias] May-alias graph after instruction  st_2_t *z = malloc(sizeof(st_2_t));  is
-  0:{ y1 } â†’ 1:{  }   2:{ z } â†’ 3:{  }
 [alias] analysing instruction: y1 = & x1;
 [alias] May-aliases after instruction  y1 = & x1;  are  <none>
-[alias] May-alias graph after instruction  y1 = & x1;  is
-  0:{ y1 } â†’ 1:{ x1 }   2:{ z } â†’ 3:{  }
 [alias] analysing instruction: z->s = (struct struct_1_t *)y1;
 [alias:unsafe-cast] structure4.c:37: Warning: 
   unsafe cast from st_1_t * to struct struct_1_t *
 [alias] May-aliases after instruction  z->s = (struct struct_1_t *)y1;  are
   { z->s; y1 }
-[alias] May-alias graph after instruction  z->s = (struct struct_1_t *)y1;  is
-  2:{ z } â†’ 3:{  }   6:{ z->s; y1 } â†’ 1:{ x1 }
 [alias] analysing instruction: z->c = 6;
 [alias] May-aliases after instruction  z->c = 6;  are  { z->s; y1 }
-[alias] May-alias graph after instruction  z->c = 6;  is
-  2:{ z } â†’ 3:{  }   6:{ z->s; y1 } â†’ 1:{ x1 }
 [alias] analysing instruction: __retres = 0;
 [alias] May-aliases after instruction  __retres = 0;  are  { z->s; y1 }
-[alias] May-alias graph after instruction  __retres = 0;  is
-  2:{ z } â†’ 3:{  }   6:{ z->s; y1 } â†’ 1:{ x1 }
 [alias] May-aliases at the end of function main: { z->s; y1 }
-[alias] May-alias graph at the end of function main:
-  2:{ z } â†’ 3:{  }   6:{ z->s; y1 } â†’ 1:{ x1 }
-[alias] Summary of function main:
-  formals:     locals: x1  x2  y1â†’{ x1 }  z  __retres    returns: __retres
-  state: { z->s; y1 }
-[alias] Analysis complete
diff --git a/src/plugins/alias/tests/offsets/oracle/structure5.res.oracle b/src/plugins/alias/tests/offsets/oracle/structure5.res.oracle
index b7ff584de85..a1ddf765fe0 100644
--- a/src/plugins/alias/tests/offsets/oracle/structure5.res.oracle
+++ b/src/plugins/alias/tests/offsets/oracle/structure5.res.oracle
@@ -2,81 +2,40 @@
 [alias] analysing function: main
 [alias] analysing instruction: st_1_t x1 = {.a = 0, .b = 1};
 [alias] May-aliases after instruction  st_1_t x1 = {.a = 0, .b = 1};  are  <none>
-[alias] May-alias graph after instruction  st_1_t x1 = {.a = 0, .b = 1};  is
-  <empty>
 [alias] analysing instruction: st_1_t x2 = {.a = 1, .b = 2};
 [alias] May-aliases after instruction  st_1_t x2 = {.a = 1, .b = 2};  are  <none>
-[alias] May-alias graph after instruction  st_1_t x2 = {.a = 1, .b = 2};  is
-  <empty>
 [alias] analysing instruction: st_1_t *y1 = malloc(sizeof(st_1_t));
 [alias] May-aliases after instruction  st_1_t *y1 = malloc(sizeof(st_1_t));  are
   <none>
-[alias] May-alias graph after instruction  st_1_t *y1 = malloc(sizeof(st_1_t));
-  is    0:{ y1 } â†’ 1:{  }
 [alias] analysing instruction: st_2_t *z = malloc(sizeof(st_2_t));
 [alias] May-aliases after instruction  st_2_t *z = malloc(sizeof(st_2_t));  are
   <none>
-[alias] May-alias graph after instruction  st_2_t *z = malloc(sizeof(st_2_t));  is
-  0:{ y1 } â†’ 1:{  }   2:{ z } â†’ 3:{  }
 [alias] analysing instruction: st_3_t *t = malloc(sizeof(st_3_t));
 [alias] May-aliases after instruction  st_3_t *t = malloc(sizeof(st_3_t));  are
   <none>
-[alias] May-alias graph after instruction  st_3_t *t = malloc(sizeof(st_3_t));  is
-  0:{ y1 } â†’ 1:{  }   2:{ z } â†’ 3:{  }   4:{ t } â†’ 5:{  }
 [alias] analysing instruction: int *a = malloc(sizeof(int));
 [alias] May-aliases after instruction  int *a = malloc(sizeof(int));  are  <none>
-[alias] May-alias graph after instruction  int *a = malloc(sizeof(int));  is
-  0:{ y1 } â†’ 1:{  }   2:{ z } â†’ 3:{  }   4:{ t } â†’ 5:{  }
-  6:{ a } â†’ 7:{  }
 [alias] analysing instruction: *a = 0;
 [alias] May-aliases after instruction  *a = 0;  are  <none>
-[alias] May-alias graph after instruction  *a = 0;  is
-  0:{ y1 } â†’ 1:{  }   2:{ z } â†’ 3:{  }   4:{ t } â†’ 5:{  }
-  6:{ a } â†’ 7:{  }
 [alias] analysing instruction: y1 = & x1;
 [alias] May-aliases after instruction  y1 = & x1;  are  <none>
-[alias] May-alias graph after instruction  y1 = & x1;  is
-  0:{ y1 } â†’ 1:{ x1 }   2:{ z } â†’ 3:{  }   4:{ t } â†’ 5:{  }
-  6:{ a } â†’ 7:{  }
 [alias] analysing instruction: z->s = (struct struct_1_t *)y1;
 [alias:unsafe-cast] structure5.c:41: Warning: 
   unsafe cast from st_1_t * to struct struct_1_t *
 [alias] May-aliases after instruction  z->s = (struct struct_1_t *)y1;  are
   { z->s; y1 }
-[alias] May-alias graph after instruction  z->s = (struct struct_1_t *)y1;  is
-  2:{ z } â†’ 3:{  }   4:{ t } â†’ 5:{  }   6:{ a } â†’ 7:{  }
-  10:{ z->s; y1 } â†’ 1:{ x1 }
 [alias] analysing instruction: z->c = a;
 [alias] May-aliases after instruction  z->c = a;  are  { z->s; y1 }  { z->c; a }
-[alias] May-alias graph after instruction  z->c = a;  is
-  2:{ z } â†’ 3:{  }   4:{ t } â†’ 5:{  }   10:{ z->s; y1 } â†’ 1:{ x1 }
-  11:{ z->c; a } â†’ 7:{  }
 [alias] analysing instruction: t->t = (struct struct_2_t *)z;
 [alias:unsafe-cast] structure5.c:43: Warning: 
   unsafe cast from st_2_t * to struct struct_2_t *
 [alias] May-aliases after instruction  t->t = (struct struct_2_t *)z;  are
   { z->s; y1 }  { t->t; z }  { z->c; a }
-[alias] May-alias graph after instruction  t->t = (struct struct_2_t *)z;  is
-  4:{ t } â†’ 5:{  }   10:{ z->s; y1 } â†’ 1:{ x1 }
-  11:{ z->c; a } â†’ 7:{  }   12:{ t->t; z } â†’ 3:{  }
 [alias] analysing instruction: t->d = a;
 [alias] May-aliases after instruction  t->d = a;  are
   { z->s; y1 }  { t->t; z }  { z->c; t->d; a }
-[alias] May-alias graph after instruction  t->d = a;  is
-  4:{ t } â†’ 5:{  }   10:{ z->s; y1 } â†’ 1:{ x1 }
-  12:{ t->t; z } â†’ 3:{  }   13:{ z->c; t->d; a } â†’ 7:{  }
 [alias] analysing instruction: __retres = 0;
 [alias] May-aliases after instruction  __retres = 0;  are
   { z->s; y1 }  { t->t; z }  { z->c; t->d; a }
-[alias] May-alias graph after instruction  __retres = 0;  is
-  4:{ t } â†’ 5:{  }   10:{ z->s; y1 } â†’ 1:{ x1 }
-  12:{ t->t; z } â†’ 3:{  }   13:{ z->c; t->d; a } â†’ 7:{  }
 [alias] May-aliases at the end of function main:
   { z->s; y1 }  { t->t; z }  { z->c; t->d; a }
-[alias] May-alias graph at the end of function main:
-  4:{ t } â†’ 5:{  }   10:{ z->s; y1 } â†’ 1:{ x1 }
-  12:{ t->t; z } â†’ 3:{  }   13:{ z->c; t->d; a } â†’ 7:{  }
-[alias] Summary of function main:
-  formals:     locals: x1  x2  y1â†’{ x1 }  z  t  a  __retres
-  returns: __retres    state: { z->s; y1 }  { t->t; z }  { z->c; t->d; a }
-[alias] Analysis complete
diff --git a/src/plugins/alias/tests/real_world/oracle/example1.res.oracle b/src/plugins/alias/tests/real_world/oracle/example1.res.oracle
index 8dba09dab09..87ce913aa06 100644
--- a/src/plugins/alias/tests/real_world/oracle/example1.res.oracle
+++ b/src/plugins/alias/tests/real_world/oracle/example1.res.oracle
@@ -2,340 +2,162 @@
 [alias] analysing function: f1
 [alias] analysing instruction: ty *tmp = x;
 [alias] May-aliases after instruction  ty *tmp = x;  are  { x; tmp }
-[alias] May-alias graph after instruction  ty *tmp = x;  is
-  0:{ x; tmp } â†’ 1:{  }
 [alias] analysing instruction:
   idata = (double *)malloc((unsigned long)10 * sizeof(double));
 [alias] May-aliases after instruction
   idata = (double *)malloc((unsigned long)10 * sizeof(double));  are
   { x; tmp }
-[alias] May-alias graph after instruction
-  idata = (double *)malloc((unsigned long)10 * sizeof(double));  is
-  0:{ x; tmp } â†’ 1:{  }   4:{ idata } â†’ 5:{  }
 [alias] analysing instruction: idata = tmp->t2[*(tmp->n2)];
 [alias] May-aliases after instruction  idata = tmp->t2[*(tmp->n2)];  are
   { x; tmp }  { tmp->t2[0..]; idata }
-[alias] May-alias graph after instruction  idata = tmp->t2[*(tmp->n2)];  is
-  0:{ x; tmp } â†’ 1:{  }   4:{ tmp->t2[0..]; idata } â†’ 5:{  }
 [alias] analysing instruction: odata = tmp->t1[*(tmp->n1)];
 [alias] May-aliases after instruction  odata = tmp->t1[*(tmp->n1)];  are
   { x; tmp }  { tmp->t2[0..]; idata }  { tmp->t1[0..]; odata }
-[alias] May-alias graph after instruction  odata = tmp->t1[*(tmp->n1)];  is
-  0:{ x; tmp } â†’ 1:{  }   4:{ tmp->t2[0..]; idata } â†’ 5:{  }
-  7:{ tmp->t1[0..]; odata } â†’ 8:{  }
 [alias] analysing instruction: idx = 0;
 [alias] May-aliases after instruction  idx = 0;  are
   { x; tmp }  { tmp->t2[0..]; idata }  { tmp->t1[0..]; odata }
-[alias] May-alias graph after instruction  idx = 0;  is
-  0:{ x; tmp } â†’ 1:{  }   4:{ tmp->t2[0..]; idata } â†’ 5:{  }
-  7:{ tmp->t1[0..]; odata } â†’ 8:{  }
 [alias] analysing instruction: tmp_1 = sin(*(idata + idx));
 [alias:undefined:fn] example1.c:45: Warning: function sin has no definition
 [alias] May-aliases after instruction  tmp_1 = sin(*(idata + idx));  are
   { x; tmp }  { tmp->t2[0..]; idata }  { tmp->t1[0..]; odata }
-[alias] May-alias graph after instruction  tmp_1 = sin(*(idata + idx));  is
-  0:{ x; tmp } â†’ 1:{  }   4:{ tmp->t2[0..]; idata } â†’ 5:{  }
-  7:{ tmp->t1[0..]; odata } â†’ 8:{  }
 [alias] analysing instruction: *(odata + idx) = 0.5 * tmp_1;
 [alias] May-aliases after instruction  *(odata + idx) = 0.5 * tmp_1;  are
   { x; tmp }  { tmp->t2[0..]; idata }  { tmp->t1[0..]; odata }
-[alias] May-alias graph after instruction  *(odata + idx) = 0.5 * tmp_1;  is
-  0:{ x; tmp } â†’ 1:{  }   4:{ tmp->t2[0..]; idata } â†’ 5:{  }
-  7:{ tmp->t1[0..]; odata } â†’ 8:{  }
 [alias] analysing instruction: idx ++;
 [alias] May-aliases after instruction  idx ++;  are
   { x; tmp }  { tmp->t2[0..]; idata }  { tmp->t1[0..]; odata }
-[alias] May-alias graph after instruction  idx ++;  is
-  0:{ x; tmp } â†’ 1:{  }   4:{ tmp->t2[0..]; idata } â†’ 5:{  }
-  7:{ tmp->t1[0..]; odata } â†’ 8:{  }
 [alias] analysing instruction: swap(tmp->n1);
 [alias] analysing function: swap
 [alias] analysing instruction: *n = 0;
 [alias] May-aliases after instruction  *n = 0;  are  <none>
-[alias] May-alias graph after instruction  *n = 0;  is    <empty>
 [alias] analysing instruction: (*n) ++;
 [alias] May-aliases after instruction  (*n) ++;  are  <none>
-[alias] May-alias graph after instruction  (*n) ++;  is    <empty>
 [alias] May-aliases at the end of function swap: <none>
-[alias] May-alias graph at the end of function swap:
-  <empty>
-[alias] Summary of function swap:
 [alias] May-aliases after instruction  swap(tmp->n1);  are
   { x; tmp }  { tmp->t2[0..]; idata }  { tmp->t1[0..]; odata }
-[alias] May-alias graph after instruction  swap(tmp->n1);  is
-  0:{ x; tmp } â†’ 1:{  }   4:{ tmp->t2[0..]; idata } â†’ 5:{  }
-  7:{ tmp->t1[0..]; odata } â†’ 8:{  }
 [alias] analysing instruction: idata = tmp->t2[*(tmp->n2)];
 [alias] May-aliases after instruction  idata = tmp->t2[*(tmp->n2)];  are
   { x; tmp }  { tmp->t2[0..]; idata }  { tmp->t1[0..]; odata }
-[alias] May-alias graph after instruction  idata = tmp->t2[*(tmp->n2)];  is
-  0:{ x; tmp } â†’ 1:{  }   4:{ tmp->t2[0..]; idata } â†’ 5:{  }
-  7:{ tmp->t1[0..]; odata } â†’ 8:{  }
 [alias] analysing instruction: odata = tmp->t1[*(tmp->n1)];
 [alias] May-aliases after instruction  odata = tmp->t1[*(tmp->n1)];  are
   { x; tmp }  { tmp->t2[0..]; idata }  { tmp->t1[0..]; odata }
-[alias] May-alias graph after instruction  odata = tmp->t1[*(tmp->n1)];  is
-  0:{ x; tmp } â†’ 1:{  }   4:{ tmp->t2[0..]; idata } â†’ 5:{  }
-  7:{ tmp->t1[0..]; odata } â†’ 8:{  }
 [alias:no-return] example1.c:29: Warning: 
   function f1 does not return; analysis may be unsound
 [alias] May-aliases at the end of function f1: <none>
-[alias] May-alias graph at the end of function f1:
-  <empty>
-[alias] Summary of function f1:
-  formals: x    locals: tmp  idata  odata  idx  tmp_1  __retres
-  returns: __retres    state: <none>
 [alias] analysing function: f2
 [alias] analysing instruction: ty *tmp = x;
 [alias] May-aliases after instruction  ty *tmp = x;  are  { x; tmp }
-[alias] May-alias graph after instruction  ty *tmp = x;  is
-  12:{ x; tmp } â†’ 13:{  }
 [alias] analysing instruction:
   idata = (double *)malloc((unsigned long)10 * sizeof(double));
 [alias] May-aliases after instruction
   idata = (double *)malloc((unsigned long)10 * sizeof(double));  are
   { x; tmp }
-[alias] May-alias graph after instruction
-  idata = (double *)malloc((unsigned long)10 * sizeof(double));  is
-  12:{ x; tmp } â†’ 13:{  }   16:{ idata } â†’ 17:{  }
 [alias] analysing instruction: idata = tmp->t1[*(tmp->n1)];
 [alias] May-aliases after instruction  idata = tmp->t1[*(tmp->n1)];  are
   { x; tmp }  { tmp->t1[0..]; idata }
-[alias] May-alias graph after instruction  idata = tmp->t1[*(tmp->n1)];  is
-  12:{ x; tmp } â†’ 13:{  }   16:{ tmp->t1[0..]; idata } â†’ 17:{  }
 [alias] analysing instruction: odata = tmp->t2[*(tmp->n2)];
 [alias] May-aliases after instruction  odata = tmp->t2[*(tmp->n2)];  are
   { x; tmp }  { tmp->t1[0..]; idata }  { tmp->t2[0..]; odata }
-[alias] May-alias graph after instruction  odata = tmp->t2[*(tmp->n2)];  is
-  12:{ x; tmp } â†’ 13:{  }   16:{ tmp->t1[0..]; idata } â†’ 17:{  }
-  19:{ tmp->t2[0..]; odata } â†’ 20:{  }
 [alias] analysing instruction: idx = 0;
 [alias] May-aliases after instruction  idx = 0;  are
   { x; tmp }  { tmp->t1[0..]; idata }  { tmp->t2[0..]; odata }
-[alias] May-alias graph after instruction  idx = 0;  is
-  12:{ x; tmp } â†’ 13:{  }   16:{ tmp->t1[0..]; idata } â†’ 17:{  }
-  19:{ tmp->t2[0..]; odata } â†’ 20:{  }
 [alias] analysing instruction:
   *(odata + idx) = (double)3 * *(idata + idx) + (double)1;
 [alias] May-aliases after instruction
   *(odata + idx) = (double)3 * *(idata + idx) + (double)1;  are
   { x; tmp }  { tmp->t1[0..]; idata }  { tmp->t2[0..]; odata }
-[alias] May-alias graph after instruction
-  *(odata + idx) = (double)3 * *(idata + idx) + (double)1;  is
-  12:{ x; tmp } â†’ 13:{  }   16:{ tmp->t1[0..]; idata } â†’ 17:{  }
-  19:{ tmp->t2[0..]; odata } â†’ 20:{  }
 [alias] analysing instruction: idx ++;
 [alias] May-aliases after instruction  idx ++;  are
   { x; tmp }  { tmp->t1[0..]; idata }  { tmp->t2[0..]; odata }
-[alias] May-alias graph after instruction  idx ++;  is
-  12:{ x; tmp } â†’ 13:{  }   16:{ tmp->t1[0..]; idata } â†’ 17:{  }
-  19:{ tmp->t2[0..]; odata } â†’ 20:{  }
 [alias] analysing instruction: swap(tmp->n2);
 [alias] May-aliases after instruction  swap(tmp->n2);  are
   { x; tmp }  { tmp->t1[0..]; idata }  { tmp->t2[0..]; odata }
-[alias] May-alias graph after instruction  swap(tmp->n2);  is
-  12:{ x; tmp } â†’ 13:{  }   16:{ tmp->t1[0..]; idata } â†’ 17:{  }
-  19:{ tmp->t2[0..]; odata } â†’ 20:{  }
 [alias] analysing instruction: idata = tmp->t1[*(tmp->n1)];
 [alias] May-aliases after instruction  idata = tmp->t1[*(tmp->n1)];  are
   { x; tmp }  { tmp->t1[0..]; idata }  { tmp->t2[0..]; odata }
-[alias] May-alias graph after instruction  idata = tmp->t1[*(tmp->n1)];  is
-  12:{ x; tmp } â†’ 13:{  }   16:{ tmp->t1[0..]; idata } â†’ 17:{  }
-  19:{ tmp->t2[0..]; odata } â†’ 20:{  }
 [alias] analysing instruction: odata = tmp->t2[*(tmp->n2)];
 [alias] May-aliases after instruction  odata = tmp->t2[*(tmp->n2)];  are
   { x; tmp }  { tmp->t1[0..]; idata }  { tmp->t2[0..]; odata }
-[alias] May-alias graph after instruction  odata = tmp->t2[*(tmp->n2)];  is
-  12:{ x; tmp } â†’ 13:{  }   16:{ tmp->t1[0..]; idata } â†’ 17:{  }
-  19:{ tmp->t2[0..]; odata } â†’ 20:{  }
 [alias:no-return] example1.c:53: Warning: 
   function f2 does not return; analysis may be unsound
 [alias] May-aliases at the end of function f2: <none>
-[alias] May-alias graph at the end of function f2:
-  <empty>
-[alias] Summary of function f2:
-  formals: x    locals: tmp  idx  idata  odata  __retres
-  returns: __retres    state: <none>
 [alias] analysing function: main
 [alias] analysing instruction: a = (ty *)malloc(sizeof(ty));
 [alias] May-aliases after instruction  a = (ty *)malloc(sizeof(ty));  are  <none>
-[alias] May-alias graph after instruction  a = (ty *)malloc(sizeof(ty));  is
-  24:{ a } â†’ 25:{  }
 [alias] analysing instruction: b = (ty *)malloc(sizeof(ty));
 [alias] May-aliases after instruction  b = (ty *)malloc(sizeof(ty));  are  <none>
-[alias] May-alias graph after instruction  b = (ty *)malloc(sizeof(ty));  is
-  24:{ a } â†’ 25:{  }   26:{ b } â†’ 27:{  }
 [alias] analysing instruction: i = 0;
 [alias] May-aliases after instruction  i = 0;  are  <none>
-[alias] May-alias graph after instruction  i = 0;  is
-  24:{ a } â†’ 25:{  }   26:{ b } â†’ 27:{  }
 [alias] analysing instruction:
   a->t1[i] = (double *)malloc((unsigned long)10 * sizeof(double));
 [alias] May-aliases after instruction
   a->t1[i] = (double *)malloc((unsigned long)10 * sizeof(double));  are  
   <none>
-[alias] May-alias graph after instruction
-  a->t1[i] = (double *)malloc((unsigned long)10 * sizeof(double));  is
-  24:{ a } â†’ 25:{  }   26:{ b } â†’ 27:{  }   28:{ a->t1[0..] } â†’ 29:{  }
 [alias] analysing instruction:
   a->t2[i] = (double *)malloc((unsigned long)10 * sizeof(double));
 [alias] May-aliases after instruction
   a->t2[i] = (double *)malloc((unsigned long)10 * sizeof(double));  are  
   <none>
-[alias] May-alias graph after instruction
-  a->t2[i] = (double *)malloc((unsigned long)10 * sizeof(double));  is
-  24:{ a } â†’ 25:{  }   26:{ b } â†’ 27:{  }   28:{ a->t1[0..] } â†’ 29:{  }
-  30:{ a->t2[0..] } â†’ 31:{  }
 [alias] analysing instruction: i ++;
 [alias] May-aliases after instruction  i ++;  are  <none>
-[alias] May-alias graph after instruction  i ++;  is
-  24:{ a } â†’ 25:{  }   26:{ b } â†’ 27:{  }   28:{ a->t1[0..] } â†’ 29:{  }
-  30:{ a->t2[0..] } â†’ 31:{  }
 [alias] analysing instruction:
   a->t1[i] = (double *)malloc((unsigned long)10 * sizeof(double));
 [alias] May-aliases after instruction
   a->t1[i] = (double *)malloc((unsigned long)10 * sizeof(double));  are  
   <none>
-[alias] May-alias graph after instruction
-  a->t1[i] = (double *)malloc((unsigned long)10 * sizeof(double));  is
-  24:{ a } â†’ 25:{  }   26:{ b } â†’ 27:{  }   28:{ a->t1[0..] } â†’ 29:{  }
-  30:{ a->t2[0..] } â†’ 31:{  }
 [alias] analysing instruction:
   a->t2[i] = (double *)malloc((unsigned long)10 * sizeof(double));
 [alias] May-aliases after instruction
   a->t2[i] = (double *)malloc((unsigned long)10 * sizeof(double));  are  
   <none>
-[alias] May-alias graph after instruction
-  a->t2[i] = (double *)malloc((unsigned long)10 * sizeof(double));  is
-  24:{ a } â†’ 25:{  }   26:{ b } â†’ 27:{  }   28:{ a->t1[0..] } â†’ 29:{  }
-  30:{ a->t2[0..] } â†’ 31:{  }
 [alias] analysing instruction: a->n1 = (int *)malloc(sizeof(int));
 [alias] May-aliases after instruction  a->n1 = (int *)malloc(sizeof(int));  are
   <none>
-[alias] May-alias graph after instruction  a->n1 = (int *)malloc(sizeof(int));  is
-  24:{ a } â†’ 25:{  }   26:{ b } â†’ 27:{  }   28:{ a->t1[0..] } â†’ 29:{  }
-  30:{ a->t2[0..] } â†’ 31:{  }   32:{ a->n1 } â†’ 33:{  }
 [alias] analysing instruction: a->n2 = (int *)malloc(sizeof(int));
 [alias] May-aliases after instruction  a->n2 = (int *)malloc(sizeof(int));  are
   <none>
-[alias] May-alias graph after instruction  a->n2 = (int *)malloc(sizeof(int));  is
-  24:{ a } â†’ 25:{  }   26:{ b } â†’ 27:{  }   28:{ a->t1[0..] } â†’ 29:{  }
-  30:{ a->t2[0..] } â†’ 31:{  }   32:{ a->n1 } â†’ 33:{  }
-  34:{ a->n2 } â†’ 35:{  }
 [alias] analysing instruction: *(a->n1) = 1;
 [alias] May-aliases after instruction  *(a->n1) = 1;  are  <none>
-[alias] May-alias graph after instruction  *(a->n1) = 1;  is
-  24:{ a } â†’ 25:{  }   26:{ b } â†’ 27:{  }   28:{ a->t1[0..] } â†’ 29:{  }
-  30:{ a->t2[0..] } â†’ 31:{  }   32:{ a->n1 } â†’ 33:{  }
-  34:{ a->n2 } â†’ 35:{  }
 [alias] analysing instruction: *(a->n2) = 1;
 [alias] May-aliases after instruction  *(a->n2) = 1;  are  <none>
-[alias] May-alias graph after instruction  *(a->n2) = 1;  is
-  24:{ a } â†’ 25:{  }   26:{ b } â†’ 27:{  }   28:{ a->t1[0..] } â†’ 29:{  }
-  30:{ a->t2[0..] } â†’ 31:{  }   32:{ a->n1 } â†’ 33:{  }
-  34:{ a->n2 } â†’ 35:{  }
 [alias] analysing instruction: i = 0;
 [alias] May-aliases after instruction  i = 0;  are  <none>
-[alias] May-alias graph after instruction  i = 0;  is
-  24:{ a } â†’ 25:{  }   26:{ b } â†’ 27:{  }   28:{ a->t1[0..] } â†’ 29:{  }
-  30:{ a->t2[0..] } â†’ 31:{  }   32:{ a->n1 } â†’ 33:{  }
-  34:{ a->n2 } â†’ 35:{  }
 [alias] analysing instruction: b->t1[i] = a->t1[i];
 [alias] May-aliases after instruction  b->t1[i] = a->t1[i];  are
   { a->t1[0..]; b->t1[0..] }
-[alias] May-alias graph after instruction  b->t1[i] = a->t1[i];  is
-  24:{ a } â†’ 25:{  }   26:{ b } â†’ 27:{  }   30:{ a->t2[0..] } â†’ 31:{  }
-  32:{ a->n1 } â†’ 33:{  }   34:{ a->n2 } â†’ 35:{  }
-  36:{ a->t1[0..]; b->t1[0..] } â†’ 29:{  }
 [alias] analysing instruction: b->t2[i] = a->t2[i];
 [alias] May-aliases after instruction  b->t2[i] = a->t2[i];  are
   { a->t1[0..]; b->t1[0..] }  { a->t2[0..]; b->t2[0..] }
-[alias] May-alias graph after instruction  b->t2[i] = a->t2[i];  is
-  24:{ a } â†’ 25:{  }   26:{ b } â†’ 27:{  }   32:{ a->n1 } â†’ 33:{  }
-  34:{ a->n2 } â†’ 35:{  }   36:{ a->t1[0..]; b->t1[0..] } â†’ 29:{  }
-  37:{ a->t2[0..]; b->t2[0..] } â†’ 31:{  }
 [alias] analysing instruction: i ++;
 [alias] May-aliases after instruction  i ++;  are
   { a->t1[0..]; b->t1[0..] }  { a->t2[0..]; b->t2[0..] }
-[alias] May-alias graph after instruction  i ++;  is
-  24:{ a } â†’ 25:{  }   26:{ b } â†’ 27:{  }   32:{ a->n1 } â†’ 33:{  }
-  34:{ a->n2 } â†’ 35:{  }   36:{ a->t1[0..]; b->t1[0..] } â†’ 29:{  }
-  37:{ a->t2[0..]; b->t2[0..] } â†’ 31:{  }
 [alias] analysing instruction: b->t1[i] = a->t1[i];
 [alias] May-aliases after instruction  b->t1[i] = a->t1[i];  are
   { a->t1[0..]; b->t1[0..] }  { a->t2[0..]; b->t2[0..] }
-[alias] May-alias graph after instruction  b->t1[i] = a->t1[i];  is
-  24:{ a } â†’ 25:{  }   26:{ b } â†’ 27:{  }
-  28:{ a->t1[0..]; b->t1[0..] } â†’ 29:{  }
-  30:{ a->t2[0..]; b->t2[0..] } â†’ 31:{  }   32:{ a->n1 } â†’ 33:{  }
-  34:{ a->n2 } â†’ 35:{  }
 [alias] analysing instruction: b->t2[i] = a->t2[i];
 [alias] May-aliases after instruction  b->t2[i] = a->t2[i];  are
   { a->t1[0..]; b->t1[0..] }  { a->t2[0..]; b->t2[0..] }
-[alias] May-alias graph after instruction  b->t2[i] = a->t2[i];  is
-  24:{ a } â†’ 25:{  }   26:{ b } â†’ 27:{  }
-  28:{ a->t1[0..]; b->t1[0..] } â†’ 29:{  }
-  30:{ a->t2[0..]; b->t2[0..] } â†’ 31:{  }   32:{ a->n1 } â†’ 33:{  }
-  34:{ a->n2 } â†’ 35:{  }
 [alias] analysing instruction: b->n1 = a->n1;
 [alias] May-aliases after instruction  b->n1 = a->n1;  are
   { a->t1[0..]; b->t1[0..] }  { a->t2[0..]; b->t2[0..] }  { a->n1; b->n1 }
-[alias] May-alias graph after instruction  b->n1 = a->n1;  is
-  24:{ a } â†’ 25:{  }   26:{ b } â†’ 27:{  }
-  28:{ a->t1[0..]; b->t1[0..] } â†’ 29:{  }
-  30:{ a->t2[0..]; b->t2[0..] } â†’ 31:{  }   34:{ a->n2 } â†’ 35:{  }
-  38:{ a->n1; b->n1 } â†’ 33:{  }
 [alias] analysing instruction: b->n2 = a->n2;
 [alias] May-aliases after instruction  b->n2 = a->n2;  are
   { a->t1[0..]; b->t1[0..] }  { a->t2[0..]; b->t2[0..] }  { a->n1; b->n1 }
   { a->n2; b->n2 }
-[alias] May-alias graph after instruction  b->n2 = a->n2;  is
-  24:{ a } â†’ 25:{  }   26:{ b } â†’ 27:{  }
-  28:{ a->t1[0..]; b->t1[0..] } â†’ 29:{  }
-  30:{ a->t2[0..]; b->t2[0..] } â†’ 31:{  }   38:{ a->n1; b->n1 } â†’ 33:{  }
-  39:{ a->n2; b->n2 } â†’ 35:{  }
 [alias] analysing instruction: f1(a);
 [alias] May-aliases after instruction  f1(a);  are
   { a->t1[0..]; b->t1[0..] }  { a->t2[0..]; b->t2[0..] }  { a->n1; b->n1 }
   { a->n2; b->n2 }
-[alias] May-alias graph after instruction  f1(a);  is
-  24:{ a } â†’ 25:{  }   26:{ b } â†’ 27:{  }
-  28:{ a->t1[0..]; b->t1[0..] } â†’ 29:{  }
-  30:{ a->t2[0..]; b->t2[0..] } â†’ 31:{  }   38:{ a->n1; b->n1 } â†’ 33:{  }
-  39:{ a->n2; b->n2 } â†’ 35:{  }
 [alias] analysing instruction: f2(b);
 [alias] May-aliases after instruction  f2(b);  are
   { a->t1[0..]; b->t1[0..] }  { a->t2[0..]; b->t2[0..] }  { a->n1; b->n1 }
   { a->n2; b->n2 }
-[alias] May-alias graph after instruction  f2(b);  is
-  24:{ a } â†’ 25:{  }   26:{ b } â†’ 27:{  }
-  28:{ a->t1[0..]; b->t1[0..] } â†’ 29:{  }
-  30:{ a->t2[0..]; b->t2[0..] } â†’ 31:{  }   38:{ a->n1; b->n1 } â†’ 33:{  }
-  39:{ a->n2; b->n2 } â†’ 35:{  }
 [alias] analysing instruction: __retres = 0;
 [alias] May-aliases after instruction  __retres = 0;  are
   { a->t1[0..]; b->t1[0..] }  { a->t2[0..]; b->t2[0..] }  { a->n1; b->n1 }
   { a->n2; b->n2 }
-[alias] May-alias graph after instruction  __retres = 0;  is
-  24:{ a } â†’ 25:{  }   26:{ b } â†’ 27:{  }
-  28:{ a->t1[0..]; b->t1[0..] } â†’ 29:{  }
-  30:{ a->t2[0..]; b->t2[0..] } â†’ 31:{  }   38:{ a->n1; b->n1 } â†’ 33:{  }
-  39:{ a->n2; b->n2 } â†’ 35:{  }
 [alias] May-aliases at the end of function main:
   { a->t1[0..]; b->t1[0..] }  { a->t2[0..]; b->t2[0..] }  { a->n1; b->n1 }
   { a->n2; b->n2 }
-[alias] May-alias graph at the end of function main:
-  24:{ a } â†’ 25:{  }   26:{ b } â†’ 27:{  }
-  28:{ a->t1[0..]; b->t1[0..] } â†’ 29:{  }
-  30:{ a->t2[0..]; b->t2[0..] } â†’ 31:{  }   38:{ a->n1; b->n1 } â†’ 33:{  }
-  39:{ a->n2; b->n2 } â†’ 35:{  }
-[alias] Summary of function main:
-  formals:     locals: a  b  i  __retres    returns: __retres
-  state: { a->t1[0..]; b->t1[0..] }  { a->t2[0..]; b->t2[0..] }
-         { a->n1; b->n1 }  { a->n2; b->n2 }
 [alias] analysing function: swap
 [alias] May-aliases at the end of function swap: <none>
-[alias] May-alias graph at the end of function swap:
-  <empty>
-[alias] Summary of function swap:
-[alias] Analysis complete
diff --git a/src/plugins/alias/tests/real_world/oracle/example2.res.oracle b/src/plugins/alias/tests/real_world/oracle/example2.res.oracle
index 0ef7ddca0a1..b2e81e566d0 100644
--- a/src/plugins/alias/tests/real_world/oracle/example2.res.oracle
+++ b/src/plugins/alias/tests/real_world/oracle/example2.res.oracle
@@ -2,374 +2,176 @@
 [alias] analysing function: f1
 [alias] analysing instruction: ty *tmp = x;
 [alias] May-aliases after instruction  ty *tmp = x;  are  { x; tmp }
-[alias] May-alias graph after instruction  ty *tmp = x;  is
-  0:{ x; tmp } â†’ 1:{  }
 [alias] analysing instruction:
   idata = (double *)malloc((unsigned long)10 * sizeof(double));
 [alias] May-aliases after instruction
   idata = (double *)malloc((unsigned long)10 * sizeof(double));  are
   { x; tmp }
-[alias] May-alias graph after instruction
-  idata = (double *)malloc((unsigned long)10 * sizeof(double));  is
-  0:{ x; tmp } â†’ 1:{  }   4:{ idata } â†’ 5:{  }
 [alias] analysing instruction: int i = 0;
 [alias] May-aliases after instruction  int i = 0;  are  { x; tmp }
-[alias] May-alias graph after instruction  int i = 0;  is
-  0:{ x; tmp } â†’ 1:{  }   4:{ idata } â†’ 5:{  }
 [alias] analysing instruction: idata = tmp->t2[*(tmp->n2)];
 [alias] May-aliases after instruction  idata = tmp->t2[*(tmp->n2)];  are
   { x; tmp }  { tmp->t2[0..]; idata }
-[alias] May-alias graph after instruction  idata = tmp->t2[*(tmp->n2)];  is
-  0:{ x; tmp } â†’ 1:{  }   4:{ tmp->t2[0..]; idata } â†’ 5:{  }
 [alias] analysing instruction: odata = tmp->t1[*(tmp->n1)];
 [alias] May-aliases after instruction  odata = tmp->t1[*(tmp->n1)];  are
   { x; tmp }  { tmp->t2[0..]; idata }  { tmp->t1[0..]; odata }
-[alias] May-alias graph after instruction  odata = tmp->t1[*(tmp->n1)];  is
-  0:{ x; tmp } â†’ 1:{  }   4:{ tmp->t2[0..]; idata } â†’ 5:{  }
-  7:{ tmp->t1[0..]; odata } â†’ 8:{  }
 [alias] analysing instruction: idx = 0;
 [alias] May-aliases after instruction  idx = 0;  are
   { x; tmp }  { tmp->t2[0..]; idata }  { tmp->t1[0..]; odata }
-[alias] May-alias graph after instruction  idx = 0;  is
-  0:{ x; tmp } â†’ 1:{  }   4:{ tmp->t2[0..]; idata } â†’ 5:{  }
-  7:{ tmp->t1[0..]; odata } â†’ 8:{  }
 [alias] analysing instruction: tmp_1 = sin(*(idata + idx));
 [alias:undefined:fn] example2.c:45: Warning: function sin has no definition
 [alias] May-aliases after instruction  tmp_1 = sin(*(idata + idx));  are
   { x; tmp }  { tmp->t2[0..]; idata }  { tmp->t1[0..]; odata }
-[alias] May-alias graph after instruction  tmp_1 = sin(*(idata + idx));  is
-  0:{ x; tmp } â†’ 1:{  }   4:{ tmp->t2[0..]; idata } â†’ 5:{  }
-  7:{ tmp->t1[0..]; odata } â†’ 8:{  }
 [alias] analysing instruction: *(odata + idx) = 0.5 * tmp_1;
 [alias] May-aliases after instruction  *(odata + idx) = 0.5 * tmp_1;  are
   { x; tmp }  { tmp->t2[0..]; idata }  { tmp->t1[0..]; odata }
-[alias] May-alias graph after instruction  *(odata + idx) = 0.5 * tmp_1;  is
-  0:{ x; tmp } â†’ 1:{  }   4:{ tmp->t2[0..]; idata } â†’ 5:{  }
-  7:{ tmp->t1[0..]; odata } â†’ 8:{  }
 [alias] analysing instruction: idx ++;
 [alias] May-aliases after instruction  idx ++;  are
   { x; tmp }  { tmp->t2[0..]; idata }  { tmp->t1[0..]; odata }
-[alias] May-alias graph after instruction  idx ++;  is
-  0:{ x; tmp } â†’ 1:{  }   4:{ tmp->t2[0..]; idata } â†’ 5:{  }
-  7:{ tmp->t1[0..]; odata } â†’ 8:{  }
 [alias] analysing instruction: swap(tmp->n1);
 [alias] analysing function: swap
 [alias] analysing instruction: *n = 0;
 [alias] May-aliases after instruction  *n = 0;  are  <none>
-[alias] May-alias graph after instruction  *n = 0;  is    <empty>
 [alias] analysing instruction: (*n) ++;
 [alias] May-aliases after instruction  (*n) ++;  are  <none>
-[alias] May-alias graph after instruction  (*n) ++;  is    <empty>
 [alias] May-aliases at the end of function swap: <none>
-[alias] May-alias graph at the end of function swap:
-  <empty>
-[alias] Summary of function swap:
 [alias] May-aliases after instruction  swap(tmp->n1);  are
   { x; tmp }  { tmp->t2[0..]; idata }  { tmp->t1[0..]; odata }
-[alias] May-alias graph after instruction  swap(tmp->n1);  is
-  0:{ x; tmp } â†’ 1:{  }   4:{ tmp->t2[0..]; idata } â†’ 5:{  }
-  7:{ tmp->t1[0..]; odata } â†’ 8:{  }
 [alias] analysing instruction: i ++;
 [alias] May-aliases after instruction  i ++;  are
   { x; tmp }  { tmp->t2[0..]; idata }  { tmp->t1[0..]; odata }
-[alias] May-alias graph after instruction  i ++;  is
-  0:{ x; tmp } â†’ 1:{  }   4:{ tmp->t2[0..]; idata } â†’ 5:{  }
-  7:{ tmp->t1[0..]; odata } â†’ 8:{  }
 [alias] analysing instruction: idata = tmp->t2[*(tmp->n2)];
 [alias] May-aliases after instruction  idata = tmp->t2[*(tmp->n2)];  are
   { x; tmp }  { tmp->t2[0..]; idata }  { tmp->t1[0..]; odata }
-[alias] May-alias graph after instruction  idata = tmp->t2[*(tmp->n2)];  is
-  0:{ x; tmp } â†’ 1:{  }   4:{ tmp->t2[0..]; idata } â†’ 5:{  }
-  7:{ tmp->t1[0..]; odata } â†’ 8:{  }
 [alias] analysing instruction: odata = tmp->t1[*(tmp->n1)];
 [alias] May-aliases after instruction  odata = tmp->t1[*(tmp->n1)];  are
   { x; tmp }  { tmp->t2[0..]; idata }  { tmp->t1[0..]; odata }
-[alias] May-alias graph after instruction  odata = tmp->t1[*(tmp->n1)];  is
-  0:{ x; tmp } â†’ 1:{  }   4:{ tmp->t2[0..]; idata } â†’ 5:{  }
-  7:{ tmp->t1[0..]; odata } â†’ 8:{  }
 [alias] analysing instruction: __retres = (void *)0;
 [alias] May-aliases after instruction  __retres = (void *)0;  are
   { x; tmp }  { tmp->t2[0..]; idata }  { tmp->t1[0..]; odata }
-[alias] May-alias graph after instruction  __retres = (void *)0;  is
-  0:{ x; tmp } â†’ 1:{  }   4:{ tmp->t2[0..]; idata } â†’ 5:{  }
-  7:{ tmp->t1[0..]; odata } â†’ 8:{  }
 [alias] May-aliases at the end of function f1:
   { x; tmp }  { tmp->t2[0..]; idata }  { tmp->t1[0..]; odata }
-[alias] May-alias graph at the end of function f1:
-  0:{ x; tmp } â†’ 1:{  }   4:{ tmp->t2[0..]; idata } â†’ 5:{  }
-  7:{ tmp->t1[0..]; odata } â†’ 8:{  }
-[alias] Summary of function f1:
-  formals: x    locals: tmp  idata  odata  idx  i  tmp_1  __retres
-  returns: __retres
-  state: { x; tmp }  { tmp->t2[0..]; idata }  { tmp->t1[0..]; odata }
 [alias] analysing function: f2
 [alias] analysing instruction: ty *tmp = x;
 [alias] May-aliases after instruction  ty *tmp = x;  are  { x; tmp }
-[alias] May-alias graph after instruction  ty *tmp = x;  is
-  12:{ x; tmp } â†’ 13:{  }
 [alias] analysing instruction:
   idata = (double *)malloc((unsigned long)10 * sizeof(double));
 [alias] May-aliases after instruction
   idata = (double *)malloc((unsigned long)10 * sizeof(double));  are
   { x; tmp }
-[alias] May-alias graph after instruction
-  idata = (double *)malloc((unsigned long)10 * sizeof(double));  is
-  12:{ x; tmp } â†’ 13:{  }   16:{ idata } â†’ 17:{  }
 [alias] analysing instruction: int i = 0;
 [alias] May-aliases after instruction  int i = 0;  are  { x; tmp }
-[alias] May-alias graph after instruction  int i = 0;  is
-  12:{ x; tmp } â†’ 13:{  }   16:{ idata } â†’ 17:{  }
 [alias] analysing instruction: idata = tmp->t1[*(tmp->n1)];
 [alias] May-aliases after instruction  idata = tmp->t1[*(tmp->n1)];  are
   { x; tmp }  { tmp->t1[0..]; idata }
-[alias] May-alias graph after instruction  idata = tmp->t1[*(tmp->n1)];  is
-  12:{ x; tmp } â†’ 13:{  }   16:{ tmp->t1[0..]; idata } â†’ 17:{  }
 [alias] analysing instruction: odata = tmp->t2[*(tmp->n2)];
 [alias] May-aliases after instruction  odata = tmp->t2[*(tmp->n2)];  are
   { x; tmp }  { tmp->t1[0..]; idata }  { tmp->t2[0..]; odata }
-[alias] May-alias graph after instruction  odata = tmp->t2[*(tmp->n2)];  is
-  12:{ x; tmp } â†’ 13:{  }   16:{ tmp->t1[0..]; idata } â†’ 17:{  }
-  19:{ tmp->t2[0..]; odata } â†’ 20:{  }
 [alias] analysing instruction: idx = 0;
 [alias] May-aliases after instruction  idx = 0;  are
   { x; tmp }  { tmp->t1[0..]; idata }  { tmp->t2[0..]; odata }
-[alias] May-alias graph after instruction  idx = 0;  is
-  12:{ x; tmp } â†’ 13:{  }   16:{ tmp->t1[0..]; idata } â†’ 17:{  }
-  19:{ tmp->t2[0..]; odata } â†’ 20:{  }
 [alias] analysing instruction:
   *(odata + idx) = (double)3 * *(idata + idx) + (double)1;
 [alias] May-aliases after instruction
   *(odata + idx) = (double)3 * *(idata + idx) + (double)1;  are
   { x; tmp }  { tmp->t1[0..]; idata }  { tmp->t2[0..]; odata }
-[alias] May-alias graph after instruction
-  *(odata + idx) = (double)3 * *(idata + idx) + (double)1;  is
-  12:{ x; tmp } â†’ 13:{  }   16:{ tmp->t1[0..]; idata } â†’ 17:{  }
-  19:{ tmp->t2[0..]; odata } â†’ 20:{  }
 [alias] analysing instruction: idx ++;
 [alias] May-aliases after instruction  idx ++;  are
   { x; tmp }  { tmp->t1[0..]; idata }  { tmp->t2[0..]; odata }
-[alias] May-alias graph after instruction  idx ++;  is
-  12:{ x; tmp } â†’ 13:{  }   16:{ tmp->t1[0..]; idata } â†’ 17:{  }
-  19:{ tmp->t2[0..]; odata } â†’ 20:{  }
 [alias] analysing instruction: swap(tmp->n2);
 [alias] May-aliases after instruction  swap(tmp->n2);  are
   { x; tmp }  { tmp->t1[0..]; idata }  { tmp->t2[0..]; odata }
-[alias] May-alias graph after instruction  swap(tmp->n2);  is
-  12:{ x; tmp } â†’ 13:{  }   16:{ tmp->t1[0..]; idata } â†’ 17:{  }
-  19:{ tmp->t2[0..]; odata } â†’ 20:{  }
 [alias] analysing instruction: i ++;
 [alias] May-aliases after instruction  i ++;  are
   { x; tmp }  { tmp->t1[0..]; idata }  { tmp->t2[0..]; odata }
-[alias] May-alias graph after instruction  i ++;  is
-  12:{ x; tmp } â†’ 13:{  }   16:{ tmp->t1[0..]; idata } â†’ 17:{  }
-  19:{ tmp->t2[0..]; odata } â†’ 20:{  }
 [alias] analysing instruction: idata = tmp->t1[*(tmp->n1)];
 [alias] May-aliases after instruction  idata = tmp->t1[*(tmp->n1)];  are
   { x; tmp }  { tmp->t1[0..]; idata }  { tmp->t2[0..]; odata }
-[alias] May-alias graph after instruction  idata = tmp->t1[*(tmp->n1)];  is
-  12:{ x; tmp } â†’ 13:{  }   16:{ tmp->t1[0..]; idata } â†’ 17:{  }
-  19:{ tmp->t2[0..]; odata } â†’ 20:{  }
 [alias] analysing instruction: odata = tmp->t2[*(tmp->n2)];
 [alias] May-aliases after instruction  odata = tmp->t2[*(tmp->n2)];  are
   { x; tmp }  { tmp->t1[0..]; idata }  { tmp->t2[0..]; odata }
-[alias] May-alias graph after instruction  odata = tmp->t2[*(tmp->n2)];  is
-  12:{ x; tmp } â†’ 13:{  }   16:{ tmp->t1[0..]; idata } â†’ 17:{  }
-  19:{ tmp->t2[0..]; odata } â†’ 20:{  }
 [alias] analysing instruction: __retres = (void *)0;
 [alias] May-aliases after instruction  __retres = (void *)0;  are
   { x; tmp }  { tmp->t1[0..]; idata }  { tmp->t2[0..]; odata }
-[alias] May-alias graph after instruction  __retres = (void *)0;  is
-  12:{ x; tmp } â†’ 13:{  }   16:{ tmp->t1[0..]; idata } â†’ 17:{  }
-  19:{ tmp->t2[0..]; odata } â†’ 20:{  }
 [alias] May-aliases at the end of function f2:
   { x; tmp }  { tmp->t1[0..]; idata }  { tmp->t2[0..]; odata }
-[alias] May-alias graph at the end of function f2:
-  12:{ x; tmp } â†’ 13:{  }   16:{ tmp->t1[0..]; idata } â†’ 17:{  }
-  19:{ tmp->t2[0..]; odata } â†’ 20:{  }
-[alias] Summary of function f2:
-  formals: x    locals: tmp  idx  idata  odata  i  __retres
-  returns: __retres
-  state: { x; tmp }  { tmp->t1[0..]; idata }  { tmp->t2[0..]; odata }
 [alias] analysing function: main
 [alias] analysing instruction: a = (ty *)malloc(sizeof(ty));
 [alias] May-aliases after instruction  a = (ty *)malloc(sizeof(ty));  are  <none>
-[alias] May-alias graph after instruction  a = (ty *)malloc(sizeof(ty));  is
-  24:{ a } â†’ 25:{  }
 [alias] analysing instruction: b = (ty *)malloc(sizeof(ty));
 [alias] May-aliases after instruction  b = (ty *)malloc(sizeof(ty));  are  <none>
-[alias] May-alias graph after instruction  b = (ty *)malloc(sizeof(ty));  is
-  24:{ a } â†’ 25:{  }   26:{ b } â†’ 27:{  }
 [alias] analysing instruction: i = 0;
 [alias] May-aliases after instruction  i = 0;  are  <none>
-[alias] May-alias graph after instruction  i = 0;  is
-  24:{ a } â†’ 25:{  }   26:{ b } â†’ 27:{  }
 [alias] analysing instruction:
   a->t1[i] = (double *)malloc((unsigned long)10 * sizeof(double));
 [alias] May-aliases after instruction
   a->t1[i] = (double *)malloc((unsigned long)10 * sizeof(double));  are  
   <none>
-[alias] May-alias graph after instruction
-  a->t1[i] = (double *)malloc((unsigned long)10 * sizeof(double));  is
-  24:{ a } â†’ 25:{  }   26:{ b } â†’ 27:{  }   28:{ a->t1[0..] } â†’ 29:{  }
 [alias] analysing instruction:
   a->t2[i] = (double *)malloc((unsigned long)10 * sizeof(double));
 [alias] May-aliases after instruction
   a->t2[i] = (double *)malloc((unsigned long)10 * sizeof(double));  are  
   <none>
-[alias] May-alias graph after instruction
-  a->t2[i] = (double *)malloc((unsigned long)10 * sizeof(double));  is
-  24:{ a } â†’ 25:{  }   26:{ b } â†’ 27:{  }   28:{ a->t1[0..] } â†’ 29:{  }
-  30:{ a->t2[0..] } â†’ 31:{  }
 [alias] analysing instruction: i ++;
 [alias] May-aliases after instruction  i ++;  are  <none>
-[alias] May-alias graph after instruction  i ++;  is
-  24:{ a } â†’ 25:{  }   26:{ b } â†’ 27:{  }   28:{ a->t1[0..] } â†’ 29:{  }
-  30:{ a->t2[0..] } â†’ 31:{  }
 [alias] analysing instruction:
   a->t1[i] = (double *)malloc((unsigned long)10 * sizeof(double));
 [alias] May-aliases after instruction
   a->t1[i] = (double *)malloc((unsigned long)10 * sizeof(double));  are  
   <none>
-[alias] May-alias graph after instruction
-  a->t1[i] = (double *)malloc((unsigned long)10 * sizeof(double));  is
-  24:{ a } â†’ 25:{  }   26:{ b } â†’ 27:{  }   28:{ a->t1[0..] } â†’ 29:{  }
-  30:{ a->t2[0..] } â†’ 31:{  }
 [alias] analysing instruction:
   a->t2[i] = (double *)malloc((unsigned long)10 * sizeof(double));
 [alias] May-aliases after instruction
   a->t2[i] = (double *)malloc((unsigned long)10 * sizeof(double));  are  
   <none>
-[alias] May-alias graph after instruction
-  a->t2[i] = (double *)malloc((unsigned long)10 * sizeof(double));  is
-  24:{ a } â†’ 25:{  }   26:{ b } â†’ 27:{  }   28:{ a->t1[0..] } â†’ 29:{  }
-  30:{ a->t2[0..] } â†’ 31:{  }
 [alias] analysing instruction: a->n1 = (int *)malloc(sizeof(int));
 [alias] May-aliases after instruction  a->n1 = (int *)malloc(sizeof(int));  are
   <none>
-[alias] May-alias graph after instruction  a->n1 = (int *)malloc(sizeof(int));  is
-  24:{ a } â†’ 25:{  }   26:{ b } â†’ 27:{  }   28:{ a->t1[0..] } â†’ 29:{  }
-  30:{ a->t2[0..] } â†’ 31:{  }   32:{ a->n1 } â†’ 33:{  }
 [alias] analysing instruction: a->n2 = (int *)malloc(sizeof(int));
 [alias] May-aliases after instruction  a->n2 = (int *)malloc(sizeof(int));  are
   <none>
-[alias] May-alias graph after instruction  a->n2 = (int *)malloc(sizeof(int));  is
-  24:{ a } â†’ 25:{  }   26:{ b } â†’ 27:{  }   28:{ a->t1[0..] } â†’ 29:{  }
-  30:{ a->t2[0..] } â†’ 31:{  }   32:{ a->n1 } â†’ 33:{  }
-  34:{ a->n2 } â†’ 35:{  }
 [alias] analysing instruction: *(a->n1) = 1;
 [alias] May-aliases after instruction  *(a->n1) = 1;  are  <none>
-[alias] May-alias graph after instruction  *(a->n1) = 1;  is
-  24:{ a } â†’ 25:{  }   26:{ b } â†’ 27:{  }   28:{ a->t1[0..] } â†’ 29:{  }
-  30:{ a->t2[0..] } â†’ 31:{  }   32:{ a->n1 } â†’ 33:{  }
-  34:{ a->n2 } â†’ 35:{  }
 [alias] analysing instruction: *(a->n2) = 1;
 [alias] May-aliases after instruction  *(a->n2) = 1;  are  <none>
-[alias] May-alias graph after instruction  *(a->n2) = 1;  is
-  24:{ a } â†’ 25:{  }   26:{ b } â†’ 27:{  }   28:{ a->t1[0..] } â†’ 29:{  }
-  30:{ a->t2[0..] } â†’ 31:{  }   32:{ a->n1 } â†’ 33:{  }
-  34:{ a->n2 } â†’ 35:{  }
 [alias] analysing instruction: i = 0;
 [alias] May-aliases after instruction  i = 0;  are  <none>
-[alias] May-alias graph after instruction  i = 0;  is
-  24:{ a } â†’ 25:{  }   26:{ b } â†’ 27:{  }   28:{ a->t1[0..] } â†’ 29:{  }
-  30:{ a->t2[0..] } â†’ 31:{  }   32:{ a->n1 } â†’ 33:{  }
-  34:{ a->n2 } â†’ 35:{  }
 [alias] analysing instruction: b->t1[i] = a->t1[i];
 [alias] May-aliases after instruction  b->t1[i] = a->t1[i];  are
   { a->t1[0..]; b->t1[0..] }
-[alias] May-alias graph after instruction  b->t1[i] = a->t1[i];  is
-  24:{ a } â†’ 25:{  }   26:{ b } â†’ 27:{  }   30:{ a->t2[0..] } â†’ 31:{  }
-  32:{ a->n1 } â†’ 33:{  }   34:{ a->n2 } â†’ 35:{  }
-  36:{ a->t1[0..]; b->t1[0..] } â†’ 29:{  }
 [alias] analysing instruction: b->t2[i] = a->t2[i];
 [alias] May-aliases after instruction  b->t2[i] = a->t2[i];  are
   { a->t1[0..]; b->t1[0..] }  { a->t2[0..]; b->t2[0..] }
-[alias] May-alias graph after instruction  b->t2[i] = a->t2[i];  is
-  24:{ a } â†’ 25:{  }   26:{ b } â†’ 27:{  }   32:{ a->n1 } â†’ 33:{  }
-  34:{ a->n2 } â†’ 35:{  }   36:{ a->t1[0..]; b->t1[0..] } â†’ 29:{  }
-  37:{ a->t2[0..]; b->t2[0..] } â†’ 31:{  }
 [alias] analysing instruction: i ++;
 [alias] May-aliases after instruction  i ++;  are
   { a->t1[0..]; b->t1[0..] }  { a->t2[0..]; b->t2[0..] }
-[alias] May-alias graph after instruction  i ++;  is
-  24:{ a } â†’ 25:{  }   26:{ b } â†’ 27:{  }   32:{ a->n1 } â†’ 33:{  }
-  34:{ a->n2 } â†’ 35:{  }   36:{ a->t1[0..]; b->t1[0..] } â†’ 29:{  }
-  37:{ a->t2[0..]; b->t2[0..] } â†’ 31:{  }
 [alias] analysing instruction: b->t1[i] = a->t1[i];
 [alias] May-aliases after instruction  b->t1[i] = a->t1[i];  are
   { a->t1[0..]; b->t1[0..] }  { a->t2[0..]; b->t2[0..] }
-[alias] May-alias graph after instruction  b->t1[i] = a->t1[i];  is
-  24:{ a } â†’ 25:{  }   26:{ b } â†’ 27:{  }
-  28:{ a->t1[0..]; b->t1[0..] } â†’ 29:{  }
-  30:{ a->t2[0..]; b->t2[0..] } â†’ 31:{  }   32:{ a->n1 } â†’ 33:{  }
-  34:{ a->n2 } â†’ 35:{  }
 [alias] analysing instruction: b->t2[i] = a->t2[i];
 [alias] May-aliases after instruction  b->t2[i] = a->t2[i];  are
   { a->t1[0..]; b->t1[0..] }  { a->t2[0..]; b->t2[0..] }
-[alias] May-alias graph after instruction  b->t2[i] = a->t2[i];  is
-  24:{ a } â†’ 25:{  }   26:{ b } â†’ 27:{  }
-  28:{ a->t1[0..]; b->t1[0..] } â†’ 29:{  }
-  30:{ a->t2[0..]; b->t2[0..] } â†’ 31:{  }   32:{ a->n1 } â†’ 33:{  }
-  34:{ a->n2 } â†’ 35:{  }
 [alias] analysing instruction: b->n1 = a->n1;
 [alias] May-aliases after instruction  b->n1 = a->n1;  are
   { a->t1[0..]; b->t1[0..] }  { a->t2[0..]; b->t2[0..] }  { a->n1; b->n1 }
-[alias] May-alias graph after instruction  b->n1 = a->n1;  is
-  24:{ a } â†’ 25:{  }   26:{ b } â†’ 27:{  }
-  28:{ a->t1[0..]; b->t1[0..] } â†’ 29:{  }
-  30:{ a->t2[0..]; b->t2[0..] } â†’ 31:{  }   34:{ a->n2 } â†’ 35:{  }
-  38:{ a->n1; b->n1 } â†’ 33:{  }
 [alias] analysing instruction: b->n2 = a->n2;
 [alias] May-aliases after instruction  b->n2 = a->n2;  are
   { a->t1[0..]; b->t1[0..] }  { a->t2[0..]; b->t2[0..] }  { a->n1; b->n1 }
   { a->n2; b->n2 }
-[alias] May-alias graph after instruction  b->n2 = a->n2;  is
-  24:{ a } â†’ 25:{  }   26:{ b } â†’ 27:{  }
-  28:{ a->t1[0..]; b->t1[0..] } â†’ 29:{  }
-  30:{ a->t2[0..]; b->t2[0..] } â†’ 31:{  }   38:{ a->n1; b->n1 } â†’ 33:{  }
-  39:{ a->n2; b->n2 } â†’ 35:{  }
 [alias] analysing instruction: f1(a);
 [alias] May-aliases after instruction  f1(a);  are
   { a->t1[0..]; b->t1[0..] }  { a->t2[0..]; b->t2[0..] }  { a->n1; b->n1 }
   { a->n2; b->n2 }
-[alias] May-alias graph after instruction  f1(a);  is
-  24:{ a } â†’ 25:{  }   26:{ b } â†’ 27:{  }
-  28:{ a->t1[0..]; b->t1[0..] } â†’ 29:{  }
-  30:{ a->t2[0..]; b->t2[0..] } â†’ 31:{  }   38:{ a->n1; b->n1 } â†’ 33:{  }
-  39:{ a->n2; b->n2 } â†’ 35:{  }
 [alias] analysing instruction: f2(b);
 [alias] May-aliases after instruction  f2(b);  are
   { a->t1[0..]; b->t1[0..] }  { a->t2[0..]; b->t2[0..] }  { a->n1; b->n1 }
   { a->n2; b->n2 }
-[alias] May-alias graph after instruction  f2(b);  is
-  24:{ a } â†’ 25:{  }   26:{ b } â†’ 27:{  }
-  28:{ a->t1[0..]; b->t1[0..] } â†’ 29:{  }
-  30:{ a->t2[0..]; b->t2[0..] } â†’ 31:{  }   38:{ a->n1; b->n1 } â†’ 33:{  }
-  39:{ a->n2; b->n2 } â†’ 35:{  }
 [alias] analysing instruction: __retres = 0;
 [alias] May-aliases after instruction  __retres = 0;  are
   { a->t1[0..]; b->t1[0..] }  { a->t2[0..]; b->t2[0..] }  { a->n1; b->n1 }
   { a->n2; b->n2 }
-[alias] May-alias graph after instruction  __retres = 0;  is
-  24:{ a } â†’ 25:{  }   26:{ b } â†’ 27:{  }
-  28:{ a->t1[0..]; b->t1[0..] } â†’ 29:{  }
-  30:{ a->t2[0..]; b->t2[0..] } â†’ 31:{  }   38:{ a->n1; b->n1 } â†’ 33:{  }
-  39:{ a->n2; b->n2 } â†’ 35:{  }
 [alias] May-aliases at the end of function main:
   { a->t1[0..]; b->t1[0..] }  { a->t2[0..]; b->t2[0..] }  { a->n1; b->n1 }
   { a->n2; b->n2 }
-[alias] May-alias graph at the end of function main:
-  24:{ a } â†’ 25:{  }   26:{ b } â†’ 27:{  }
-  28:{ a->t1[0..]; b->t1[0..] } â†’ 29:{  }
-  30:{ a->t2[0..]; b->t2[0..] } â†’ 31:{  }   38:{ a->n1; b->n1 } â†’ 33:{  }
-  39:{ a->n2; b->n2 } â†’ 35:{  }
-[alias] Summary of function main:
-  formals:     locals: a  b  i  __retres    returns: __retres
-  state: { a->t1[0..]; b->t1[0..] }  { a->t2[0..]; b->t2[0..] }
-         { a->n1; b->n1 }  { a->n2; b->n2 }
 [alias] analysing function: swap
 [alias] May-aliases at the end of function swap: <none>
-[alias] May-alias graph at the end of function swap:
-  <empty>
-[alias] Summary of function swap:
-[alias] Analysis complete
diff --git a/src/plugins/alias/tests/real_world/oracle/function1_v2.res.oracle b/src/plugins/alias/tests/real_world/oracle/function1_v2.res.oracle
index f1ed57eb726..db7c9c9b91f 100644
--- a/src/plugins/alias/tests/real_world/oracle/function1_v2.res.oracle
+++ b/src/plugins/alias/tests/real_world/oracle/function1_v2.res.oracle
@@ -2,45 +2,20 @@
 [alias] analysing function: alias
 [alias] analysing instruction: *x = *y;
 [alias] May-aliases after instruction  *x = *y;  are  { x; y }
-[alias] May-alias graph after instruction  *x = *y;  is
-  0:{ x } â†’ 1:{ *x; *y }   2:{ y } â†’ 1:{ *x; *y }
 [alias] May-aliases at the end of function alias: { x; y }
-[alias] May-alias graph at the end of function alias:
-  0:{ x } â†’ 1:{ *x; *y }   2:{ y } â†’ 1:{ *x; *y }
-[alias] Summary of function alias:
-  formals: xâ†’{ *x; *y }  yâ†’{ *x; *y }    locals:     returns: <none>
-  state: { x; y }
 [alias] analysing function: main
 [alias] analysing instruction: int *a = malloc(sizeof(int));
 [alias] May-aliases after instruction  int *a = malloc(sizeof(int));  are  <none>
-[alias] May-alias graph after instruction  int *a = malloc(sizeof(int));  is
-  4:{ a } â†’ 5:{  }
 [alias] analysing instruction: *a = 0;
 [alias] May-aliases after instruction  *a = 0;  are  <none>
-[alias] May-alias graph after instruction  *a = 0;  is    4:{ a } â†’ 5:{  }
 [alias] analysing instruction: int *b = malloc(sizeof(int));
 [alias] May-aliases after instruction  int *b = malloc(sizeof(int));  are  <none>
-[alias] May-alias graph after instruction  int *b = malloc(sizeof(int));  is
-  4:{ a } â†’ 5:{  }   6:{ b } â†’ 7:{  }
 [alias] analysing instruction: *b = 42;
 [alias] May-aliases after instruction  *b = 42;  are  <none>
-[alias] May-alias graph after instruction  *b = 42;  is
-  4:{ a } â†’ 5:{  }   6:{ b } â†’ 7:{  }
 [alias] analysing instruction: alias(& a,& b);
 [alias] May-aliases after instruction  alias(& a,& b);  are  { a; b }
-[alias] May-alias graph after instruction  alias(& a,& b);  is
-  4:{ a; b } â†’ 5:{  }   11:{  } â†’ 4:{ a; b }   12:{  } â†’ 4:{ a; b }
 [alias] analysing instruction: *a = 7;
 [alias] May-aliases after instruction  *a = 7;  are  { a; b }
-[alias] May-alias graph after instruction  *a = 7;  is
-  4:{ a; b } â†’ 5:{  }   11:{  } â†’ 4:{ a; b }   12:{  } â†’ 4:{ a; b }
 [alias] analysing instruction: __retres = 0;
 [alias] May-aliases after instruction  __retres = 0;  are  { a; b }
-[alias] May-alias graph after instruction  __retres = 0;  is
-  4:{ a; b } â†’ 5:{  }   11:{  } â†’ 4:{ a; b }   12:{  } â†’ 4:{ a; b }
 [alias] May-aliases at the end of function main: { a; b }
-[alias] May-alias graph at the end of function main:
-  4:{ a; b } â†’ 5:{  }   11:{  } â†’ 4:{ a; b }   12:{  } â†’ 4:{ a; b }
-[alias] Summary of function main:
-  formals:     locals: a  b  __retres    returns: __retres    state: { a; b }
-[alias] Analysis complete
diff --git a/src/plugins/alias/tests/test_config b/src/plugins/alias/tests/test_config
index 80976f50aac..e14c0a6d247 100644
--- a/src/plugins/alias/tests/test_config
+++ b/src/plugins/alias/tests/test_config
@@ -1,2 +1,2 @@
 PLUGIN: alias
-OPT: -alias -alias-verbose 3 -alias-debug 3
+OPT: -alias -alias-verbose 3
-- 
GitLab