about summary refs log tree commit diff
path: root/tests/mir-opt/gvn.cast_pointer_eq.GVN.panic-unwind.diff
blob: f66aed0f441501804770d17aa837be072f258e3d (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
- // MIR for `cast_pointer_eq` before GVN
+ // MIR for `cast_pointer_eq` after GVN
  
  fn cast_pointer_eq(_1: *mut u8, _2: *mut u32, _3: *mut u32, _4: *mut [u32]) -> () {
      debug p1 => _1;
      debug p2 => _2;
      debug p3 => _3;
      debug p4 => _4;
      let mut _0: ();
      let _5: *const u32;
      let mut _6: *mut u8;
      let mut _8: *const u32;
      let mut _9: *mut u32;
      let mut _11: *const u32;
      let mut _12: *mut u32;
      let mut _14: *mut [u32];
      let mut _16: *const u32;
      let mut _17: *const u32;
      let mut _19: *const u32;
      let mut _20: *const u32;
      let mut _22: *const u32;
      let mut _23: *const u32;
      scope 1 {
          debug m1 => _5;
          let _7: *const u32;
          scope 2 {
              debug m2 => _7;
              let _10: *const u32;
              scope 3 {
                  debug m3 => _10;
                  let _13: *const u32;
                  scope 4 {
                      debug m4 => _13;
                      let _15: bool;
                      scope 5 {
                          debug eq_different_thing => _15;
                          let _18: bool;
                          scope 6 {
                              debug eq_optimize => _18;
                              let _21: bool;
                              scope 7 {
                                  debug eq_thin_fat => _21;
                              }
                          }
                      }
                  }
              }
          }
      }
  
      bb0: {
-         StorageLive(_5);
+         nop;
          StorageLive(_6);
          _6 = copy _1;
-         _5 = move _6 as *const u32 (PtrToPtr);
+         _5 = copy _1 as *const u32 (PtrToPtr);
          StorageDead(_6);
          StorageLive(_7);
-         StorageLive(_8);
+         nop;
          StorageLive(_9);
          _9 = copy _2;
-         _8 = move _9 as *const u32 (PtrToPtr);
+         _8 = copy _2 as *const u32 (PtrToPtr);
          StorageDead(_9);
-         _7 = move _8 as *const u32 (PtrToPtr);
-         StorageDead(_8);
+         _7 = copy _8;
+         nop;
          StorageLive(_10);
-         StorageLive(_11);
+         nop;
          StorageLive(_12);
          _12 = copy _3;
-         _11 = move _12 as *const u32 (PtrToPtr);
+         _11 = copy _3 as *const u32 (PtrToPtr);
          StorageDead(_12);
-         _10 = move _11 as *const u32 (PtrToPtr);
-         StorageDead(_11);
-         StorageLive(_13);
+         _10 = copy _11;
+         nop;
+         nop;
          StorageLive(_14);
          _14 = copy _4;
-         _13 = move _14 as *const u32 (PtrToPtr);
+         _13 = copy _4 as *const u32 (PtrToPtr);
          StorageDead(_14);
          StorageLive(_15);
          StorageLive(_16);
          _16 = copy _5;
          StorageLive(_17);
-         _17 = copy _7;
-         _15 = Eq(move _16, move _17);
+         _17 = copy _8;
+         _15 = Eq(copy _5, copy _8);
          StorageDead(_17);
          StorageDead(_16);
          StorageLive(_18);
          StorageLive(_19);
-         _19 = copy _7;
+         _19 = copy _8;
          StorageLive(_20);
-         _20 = copy _10;
-         _18 = Eq(move _19, move _20);
+         _20 = copy _11;
+         _18 = Eq(copy _2, copy _3);
          StorageDead(_20);
          StorageDead(_19);
          StorageLive(_21);
          StorageLive(_22);
-         _22 = copy _10;
+         _22 = copy _11;
          StorageLive(_23);
          _23 = copy _13;
-         _21 = Eq(move _22, move _23);
+         _21 = Eq(copy _11, copy _13);
          StorageDead(_23);
          StorageDead(_22);
          _0 = const ();
          StorageDead(_21);
          StorageDead(_18);
          StorageDead(_15);
-         StorageDead(_13);
+         nop;
          StorageDead(_10);
          StorageDead(_7);
-         StorageDead(_5);
+         nop;
          return;
      }
  }