[rustc.git] / tests / mir-opt / gvn.slices.GVN.panic-unwind.diff

- // MIR for `slices` before GVN
+ // MIR for `slices` after GVN
  
  fn slices() -> () {
      let mut _0: ();
      let _1: &str;
      let _2: ();
      let mut _3: &str;
      let _5: ();
      let mut _6: &str;
      let _7: ();
      let mut _8: (&*const u8, &*const u8);
      let mut _9: &*const u8;
      let _10: *const u8;
      let mut _11: &str;
      let mut _12: &*const u8;
      let _13: *const u8;
      let mut _14: &str;
      let mut _17: bool;
      let mut _18: *const u8;
      let mut _19: *const u8;
      let mut _20: !;
      let _22: !;
      let mut _23: core::panicking::AssertKind;
      let mut _24: &*const u8;
      let _25: &*const u8;
      let mut _26: &*const u8;
      let _27: &*const u8;
      let mut _28: std::option::Option<std::fmt::Arguments<'_>>;
      let mut _30: &str;
      let _31: ();
      let mut _32: &[u8];
      let _33: ();
      let mut _34: (&*const u8, &*const u8);
      let mut _35: &*const u8;
      let _36: *const u8;
      let mut _37: &str;
      let mut _38: &*const u8;
      let _39: *const u8;
      let mut _40: &[u8];
      let mut _43: bool;
      let mut _44: *const u8;
      let mut _45: *const u8;
      let mut _46: !;
      let _48: !;
      let mut _49: core::panicking::AssertKind;
      let mut _50: &*const u8;
      let _51: &*const u8;
      let mut _52: &*const u8;
      let _53: &*const u8;
      let mut _54: std::option::Option<std::fmt::Arguments<'_>>;
      scope 1 {
          debug s => _1;
          let _4: &str;
          scope 2 {
              debug t => _4;
              let _15: &*const u8;
              let _16: &*const u8;
              let _29: &[u8];
              scope 3 {
                  debug left_val => _15;
                  debug right_val => _16;
                  let _21: core::panicking::AssertKind;
                  scope 4 {
                      debug kind => _21;
                  }
              }
              scope 5 {
                  debug u => _29;
                  let _41: &*const u8;
                  let _42: &*const u8;
                  scope 7 {
                      debug left_val => _41;
                      debug right_val => _42;
                      let _47: core::panicking::AssertKind;
                      scope 8 {
                          debug kind => _47;
                      }
                  }
              }
              scope 6 {
              }
          }
      }
  
      bb0: {
-         StorageLive(_1);
+         nop;
          _1 = const "my favourite slice";
          StorageLive(_2);
          StorageLive(_3);
          _3 = _1;
-         _2 = opaque::<&str>(move _3) -> [return: bb1, unwind continue];
+         _2 = opaque::<&str>(_1) -> [return: bb1, unwind continue];
      }
  
      bb1: {
          StorageDead(_3);
          StorageDead(_2);
          StorageLive(_4);
          _4 = _1;
          StorageLive(_5);
          StorageLive(_6);
-         _6 = _4;
-         _5 = opaque::<&str>(move _6) -> [return: bb2, unwind continue];
+         _6 = _1;
+         _5 = opaque::<&str>(_1) -> [return: bb2, unwind continue];
      }
  
      bb2: {
          StorageDead(_6);
          StorageDead(_5);
          StorageLive(_7);
          StorageLive(_8);
-         StorageLive(_9);
+         nop;
          StorageLive(_10);
          StorageLive(_11);
          _11 = &(*_1);
          _10 = core::str::<impl str>::as_ptr(move _11) -> [return: bb3, unwind continue];
      }
  
      bb3: {
          StorageDead(_11);
          _9 = &_10;
-         StorageLive(_12);
+         nop;
          StorageLive(_13);
          StorageLive(_14);
-         _14 = &(*_4);
+         _14 = &(*_1);
          _13 = core::str::<impl str>::as_ptr(move _14) -> [return: bb4, unwind continue];
      }
  
      bb4: {
          StorageDead(_14);
          _12 = &_13;
-         _8 = (move _9, move _12);
-         StorageDead(_12);
-         StorageDead(_9);
+         _8 = (_9, _12);
+         nop;
+         nop;
          StorageLive(_15);
-         _15 = (_8.0: &*const u8);
+         _15 = _9;
          StorageLive(_16);
-         _16 = (_8.1: &*const u8);
+         _16 = _12;
          StorageLive(_17);
          StorageLive(_18);
-         _18 = (*_15);
+         _18 = (*_9);
          StorageLive(_19);
-         _19 = (*_16);
+         _19 = (*_12);
          _17 = Eq(move _18, move _19);
          switchInt(move _17) -> [0: bb6, otherwise: bb5];
      }
  
      bb5: {
          StorageDead(_19);
          StorageDead(_18);
          _7 = const ();
          StorageDead(_17);
          StorageDead(_16);
          StorageDead(_15);
          StorageDead(_13);
          StorageDead(_10);
          StorageDead(_8);
          StorageDead(_7);
-         StorageLive(_29);
+         nop;
          StorageLive(_30);
          _30 = &(*_1);
          _29 = move _30 as &[u8] (Transmute);
          StorageDead(_30);
          StorageLive(_31);
          StorageLive(_32);
          _32 = _29;
-         _31 = opaque::<&[u8]>(move _32) -> [return: bb7, unwind continue];
+         _31 = opaque::<&[u8]>(_29) -> [return: bb7, unwind continue];
      }
  
      bb6: {
          StorageDead(_19);
          StorageDead(_18);
-         StorageLive(_21);
-         _21 = core::panicking::AssertKind::Eq;
+         nop;
+         _21 = const core::panicking::AssertKind::Eq;
          StorageLive(_22);
          StorageLive(_23);
-         _23 = move _21;
+         _23 = const core::panicking::AssertKind::Eq;
          StorageLive(_24);
-         StorageLive(_25);
-         _25 = &(*_15);
+         nop;
+         _25 = &(*_9);
          _24 = &(*_25);
          StorageLive(_26);
-         StorageLive(_27);
-         _27 = &(*_16);
+         nop;
+         _27 = &(*_12);
          _26 = &(*_27);
          StorageLive(_28);
          _28 = Option::<Arguments<'_>>::None;
-         _22 = assert_failed::<*const u8, *const u8>(move _23, move _24, move _26, move _28) -> unwind continue;
+         _22 = assert_failed::<*const u8, *const u8>(const core::panicking::AssertKind::Eq, move _24, move _26, move _28) -> unwind continue;
      }
  
      bb7: {
          StorageDead(_32);
          StorageDead(_31);
          StorageLive(_33);
          StorageLive(_34);
-         StorageLive(_35);
+         nop;
          StorageLive(_36);
          StorageLive(_37);
          _37 = &(*_1);
          _36 = core::str::<impl str>::as_ptr(move _37) -> [return: bb8, unwind continue];
      }
  
      bb8: {
          StorageDead(_37);
          _35 = &_36;
-         StorageLive(_38);
+         nop;
          StorageLive(_39);
          StorageLive(_40);
          _40 = &(*_29);
          _39 = core::slice::<impl [u8]>::as_ptr(move _40) -> [return: bb9, unwind continue];
      }
  
      bb9: {
          StorageDead(_40);
          _38 = &_39;
-         _34 = (move _35, move _38);
-         StorageDead(_38);
-         StorageDead(_35);
+         _34 = (_35, _38);
+         nop;
+         nop;
          StorageLive(_41);
-         _41 = (_34.0: &*const u8);
+         _41 = _35;
          StorageLive(_42);
-         _42 = (_34.1: &*const u8);
+         _42 = _38;
          StorageLive(_43);
          StorageLive(_44);
-         _44 = (*_41);
+         _44 = (*_35);
          StorageLive(_45);
-         _45 = (*_42);
+         _45 = (*_38);
          _43 = Eq(move _44, move _45);
          switchInt(move _43) -> [0: bb11, otherwise: bb10];
      }
  
      bb10: {
          StorageDead(_45);
          StorageDead(_44);
          _33 = const ();
          StorageDead(_43);
          StorageDead(_42);
          StorageDead(_41);
          StorageDead(_39);
          StorageDead(_36);
          StorageDead(_34);
          StorageDead(_33);
          _0 = const ();
-         StorageDead(_29);
+         nop;
          StorageDead(_4);
-         StorageDead(_1);
+         nop;
          return;
      }
  
      bb11: {
          StorageDead(_45);
          StorageDead(_44);
-         StorageLive(_47);
-         _47 = core::panicking::AssertKind::Eq;
+         nop;
+         _47 = const core::panicking::AssertKind::Eq;
          StorageLive(_48);
          StorageLive(_49);
-         _49 = move _47;
+         _49 = const core::panicking::AssertKind::Eq;
          StorageLive(_50);
-         StorageLive(_51);
-         _51 = &(*_41);
+         nop;
+         _51 = &(*_35);
          _50 = &(*_51);
          StorageLive(_52);
-         StorageLive(_53);
-         _53 = &(*_42);
+         nop;
+         _53 = &(*_38);
          _52 = &(*_53);
          StorageLive(_54);
          _54 = Option::<Arguments<'_>>::None;
-         _48 = assert_failed::<*const u8, *const u8>(move _49, move _50, move _52, move _54) -> unwind continue;
+         _48 = assert_failed::<*const u8, *const u8>(const core::panicking::AssertKind::Eq, move _50, move _52, move _54) -> unwind continue;
      }
  }
Commit	Line	Data
781aab86 FG	1	- // MIR for `slices` before GVN
	2	+ // MIR for `slices` after GVN
	3
	4	fn slices() -> () {
	5	let mut _0: ();
	6	let _1: &str;
	7	let _2: ();
	8	let mut _3: &str;
	9	let _5: ();
	10	let mut _6: &str;
	11	let _7: ();
	12	let mut _8: (&const u8, &const u8);
	13	let mut _9: &*const u8;
	14	let _10: *const u8;
	15	let mut _11: &str;
	16	let mut _12: &*const u8;
	17	let _13: *const u8;
	18	let mut _14: &str;
	19	let mut _17: bool;
	20	let mut _18: *const u8;
	21	let mut _19: *const u8;
	22	let mut _20: !;
	23	let _22: !;
	24	let mut _23: core::panicking::AssertKind;
	25	let mut _24: &*const u8;
	26	let _25: &*const u8;
	27	let mut _26: &*const u8;
	28	let _27: &*const u8;
	29	let mut _28: std::option::Option<std::fmt::Arguments<'_>>;
	30	let mut _30: &str;
	31	let _31: ();
	32	let mut _32: &[u8];
	33	let _33: ();
	34	let mut _34: (&const u8, &const u8);
	35	let mut _35: &*const u8;
	36	let _36: *const u8;
	37	let mut _37: &str;
	38	let mut _38: &*const u8;
	39	let _39: *const u8;
	40	let mut _40: &[u8];
	41	let mut _43: bool;
	42	let mut _44: *const u8;
	43	let mut _45: *const u8;
	44	let mut _46: !;
	45	let _48: !;
	46	let mut _49: core::panicking::AssertKind;
	47	let mut _50: &*const u8;
	48	let _51: &*const u8;
	49	let mut _52: &*const u8;
	50	let _53: &*const u8;
	51	let mut _54: std::option::Option<std::fmt::Arguments<'_>>;
	52	scope 1 {
	53	debug s => _1;
	54	let _4: &str;
	55	scope 2 {
	56	debug t => _4;
	57	let _15: &*const u8;
	58	let _16: &*const u8;
	59	let _29: &[u8];
	60	scope 3 {
	61	debug left_val => _15;
	62	debug right_val => _16;
	63	let _21: core::panicking::AssertKind;
	64	scope 4 {
65	debug kind => _21;
66	}
67	}
68	scope 5 {
69	debug u => _29;
70	let _41: &*const u8;
71	let _42: &*const u8;
72	scope 7 {
73	debug left_val => _41;
74	debug right_val => _42;
75	let _47: core::panicking::AssertKind;
76	scope 8 {
77	debug kind => _47;
78	}
79	}
80	}
81	scope 6 {
82	}
83	}
84	}
85
86	bb0: {
87	- StorageLive(_1);
ed00b5ec	88	+ nop;
781aab86 FG	89	_1 = const "my favourite slice";
781aab86 FG	90	StorageLive(_2);
ed00b5ec FG	91	StorageLive(_3);
ed00b5ec FG	92	_3 = _1;
781aab86 FG	93	- _2 = opaque::<&str>(move _3) -> [return: bb1, unwind continue];
	94	+ _2 = opaque::<&str>(_1) -> [return: bb1, unwind continue];
	95	}
	96
	97	bb1: {
ed00b5ec	98	StorageDead(_3);
781aab86 FG	99	StorageDead(_2);
	100	StorageLive(_4);
	101	_4 = _1;
	102	StorageLive(_5);
ed00b5ec	103	StorageLive(_6);
781aab86 FG	104	- _6 = _4;
781aab86 FG	105	- _5 = opaque::<&str>(move _6) -> [return: bb2, unwind continue];
ed00b5ec	106	+ _6 = _1;
781aab86 FG	107	+ _5 = opaque::<&str>(_1) -> [return: bb2, unwind continue];
	108	}
	109
	110	bb2: {
ed00b5ec	111	StorageDead(_6);
781aab86	112	StorageDead(_5);
ed00b5ec	113	StorageLive(_7);
781aab86	114	StorageLive(_8);
ed00b5ec FG	115	- StorageLive(_9);
ed00b5ec FG	116	+ nop;
781aab86 FG	117	StorageLive(_10);
	118	StorageLive(_11);
	119	_11 = &(*_1);
	120	_10 = core::str::<impl str>::as_ptr(move _11) -> [return: bb3, unwind continue];
	121	}
	122
	123	bb3: {
	124	StorageDead(_11);
	125	_9 = &_10;
ed00b5ec FG	126	- StorageLive(_12);
ed00b5ec FG	127	+ nop;
781aab86 FG	128	StorageLive(_13);
781aab86 FG	129	StorageLive(_14);
ed00b5ec FG	130	- _14 = &(*_4);
ed00b5ec FG	131	+ _14 = &(*_1);
781aab86 FG	132	_13 = core::str::<impl str>::as_ptr(move _14) -> [return: bb4, unwind continue];
	133	}
	134
	135	bb4: {
	136	StorageDead(_14);
	137	_12 = &_13;
ed00b5ec FG	138	- _8 = (move _9, move _12);
	139	- StorageDead(_12);
	140	- StorageDead(_9);
	141	+ _8 = (_9, _12);
	142	+ nop;
	143	+ nop;
781aab86	144	StorageLive(_15);
ed00b5ec FG	145	- _15 = (_8.0: &*const u8);
ed00b5ec FG	146	+ _15 = _9;
781aab86	147	StorageLive(_16);
ed00b5ec FG	148	- _16 = (_8.1: &*const u8);
ed00b5ec FG	149	+ _16 = _12;
781aab86 FG	150	StorageLive(_17);
781aab86 FG	151	StorageLive(_18);
ed00b5ec FG	152	- _18 = (*_15);
ed00b5ec FG	153	+ _18 = (*_9);
781aab86	154	StorageLive(_19);
ed00b5ec FG	155	- _19 = (*_16);
ed00b5ec FG	156	+ _19 = (*_12);
781aab86 FG	157	_17 = Eq(move _18, move _19);
	158	switchInt(move _17) -> [0: bb6, otherwise: bb5];
	159	}
	160
	161	bb5: {
	162	StorageDead(_19);
	163	StorageDead(_18);
ed00b5ec	164	_7 = const ();
781aab86 FG	165	StorageDead(_17);
	166	StorageDead(_16);
	167	StorageDead(_15);
	168	StorageDead(_13);
	169	StorageDead(_10);
	170	StorageDead(_8);
ed00b5ec	171	StorageDead(_7);
781aab86	172	- StorageLive(_29);
ed00b5ec	173	+ nop;
781aab86 FG	174	StorageLive(_30);
	175	_30 = &(*_1);
	176	_29 = move _30 as &[u8] (Transmute);
	177	StorageDead(_30);
	178	StorageLive(_31);
ed00b5ec FG	179	StorageLive(_32);
ed00b5ec FG	180	_32 = _29;
781aab86 FG	181	- _31 = opaque::<&[u8]>(move _32) -> [return: bb7, unwind continue];
	182	+ _31 = opaque::<&[u8]>(_29) -> [return: bb7, unwind continue];
	183	}
	184
	185	bb6: {
	186	StorageDead(_19);
	187	StorageDead(_18);
	188	- StorageLive(_21);
ed00b5ec FG	189	- _21 = core::panicking::AssertKind::Eq;
	190	+ nop;
	191	+ _21 = const core::panicking::AssertKind::Eq;
781aab86	192	StorageLive(_22);
ed00b5ec	193	StorageLive(_23);
781aab86	194	- _23 = move _21;
ed00b5ec	195	+ _23 = const core::panicking::AssertKind::Eq;
781aab86	196	StorageLive(_24);
ed00b5ec FG	197	- StorageLive(_25);
	198	- _25 = &(*_15);
	199	+ nop;
	200	+ _25 = &(*_9);
781aab86 FG	201	_24 = &(*_25);
781aab86 FG	202	StorageLive(_26);
ed00b5ec FG	203	- StorageLive(_27);
	204	- _27 = &(*_16);
	205	+ nop;
	206	+ _27 = &(*_12);
781aab86 FG	207	_26 = &(*_27);
	208	StorageLive(_28);
	209	_28 = Option::<Arguments<'_>>::None;
ed00b5ec FG	210	- _22 = assert_failed::<const u8, const u8>(move _23, move _24, move _26, move _28) -> unwind continue;
ed00b5ec FG	211	+ _22 = assert_failed::<const u8, const u8>(const core::panicking::AssertKind::Eq, move _24, move _26, move _28) -> unwind continue;
781aab86 FG	212	}
	213
	214	bb7: {
ed00b5ec	215	StorageDead(_32);
781aab86	216	StorageDead(_31);
ed00b5ec	217	StorageLive(_33);
781aab86	218	StorageLive(_34);
ed00b5ec FG	219	- StorageLive(_35);
ed00b5ec FG	220	+ nop;
781aab86 FG	221	StorageLive(_36);
	222	StorageLive(_37);
	223	_37 = &(*_1);
	224	_36 = core::str::<impl str>::as_ptr(move _37) -> [return: bb8, unwind continue];
	225	}
	226
	227	bb8: {
	228	StorageDead(_37);
	229	_35 = &_36;
ed00b5ec FG	230	- StorageLive(_38);
ed00b5ec FG	231	+ nop;
781aab86 FG	232	StorageLive(_39);
	233	StorageLive(_40);
	234	_40 = &(*_29);
	235	_39 = core::slice::<impl [u8]>::as_ptr(move _40) -> [return: bb9, unwind continue];
	236	}
	237
	238	bb9: {
	239	StorageDead(_40);
	240	_38 = &_39;
ed00b5ec FG	241	- _34 = (move _35, move _38);
	242	- StorageDead(_38);
	243	- StorageDead(_35);
	244	+ _34 = (_35, _38);
	245	+ nop;
	246	+ nop;
781aab86	247	StorageLive(_41);
ed00b5ec FG	248	- _41 = (_34.0: &*const u8);
ed00b5ec FG	249	+ _41 = _35;
781aab86	250	StorageLive(_42);
ed00b5ec FG	251	- _42 = (_34.1: &*const u8);
ed00b5ec FG	252	+ _42 = _38;
781aab86 FG	253	StorageLive(_43);
781aab86 FG	254	StorageLive(_44);
ed00b5ec FG	255	- _44 = (*_41);
ed00b5ec FG	256	+ _44 = (*_35);
781aab86	257	StorageLive(_45);
ed00b5ec FG	258	- _45 = (*_42);
ed00b5ec FG	259	+ _45 = (*_38);
781aab86 FG	260	_43 = Eq(move _44, move _45);
	261	switchInt(move _43) -> [0: bb11, otherwise: bb10];
	262	}
	263
	264	bb10: {
	265	StorageDead(_45);
	266	StorageDead(_44);
ed00b5ec	267	_33 = const ();
781aab86 FG	268	StorageDead(_43);
	269	StorageDead(_42);
	270	StorageDead(_41);
	271	StorageDead(_39);
	272	StorageDead(_36);
	273	StorageDead(_34);
ed00b5ec	274	StorageDead(_33);
781aab86 FG	275	_0 = const ();
781aab86 FG	276	- StorageDead(_29);
ed00b5ec	277	+ nop;
781aab86 FG	278	StorageDead(_4);
781aab86 FG	279	- StorageDead(_1);
ed00b5ec	280	+ nop;
781aab86 FG	281	return;
	282	}
	283
	284	bb11: {
	285	StorageDead(_45);
	286	StorageDead(_44);
	287	- StorageLive(_47);
ed00b5ec FG	288	- _47 = core::panicking::AssertKind::Eq;
	289	+ nop;
	290	+ _47 = const core::panicking::AssertKind::Eq;
781aab86	291	StorageLive(_48);
ed00b5ec	292	StorageLive(_49);
781aab86	293	- _49 = move _47;
ed00b5ec	294	+ _49 = const core::panicking::AssertKind::Eq;
781aab86	295	StorageLive(_50);
ed00b5ec FG	296	- StorageLive(_51);
	297	- _51 = &(*_41);
	298	+ nop;
	299	+ _51 = &(*_35);
781aab86 FG	300	_50 = &(*_51);
781aab86 FG	301	StorageLive(_52);
ed00b5ec FG	302	- StorageLive(_53);
	303	- _53 = &(*_42);
	304	+ nop;
	305	+ _53 = &(*_38);
781aab86 FG	306	_52 = &(*_53);
	307	StorageLive(_54);
	308	_54 = Option::<Arguments<'_>>::None;
ed00b5ec FG	309	- _48 = assert_failed::<const u8, const u8>(move _49, move _50, move _52, move _54) -> unwind continue;
ed00b5ec FG	310	+ _48 = assert_failed::<const u8, const u8>(const core::panicking::AssertKind::Eq, move _50, move _52, move _54) -> unwind continue;
781aab86 FG	311	}
	312	}
	313