| Message ID | 5243A96B.1010703@redhat.com |
|---|---|
| State | New |
| Headers | show |
On Thu, Sep 26, 2013 at 04:26:35AM +0100, Jeff Law wrote: > Bootstrapped and regression tested on x86_64-unknown-linux-gnu. > Installed on trunk. Hi Jeff, This patch caused a regression on Arm and AArch64 in: PASS->FAIL: gcc.c-torture/execute/memcpy-2.c execution, -O3 -fomit-frame-pointer From what I can see, the only place the behaviour of the threader has changed is in this hunk: On Thu, Sep 26, 2013 at 04:26:35AM +0100, Jeff Law wrote: > diff --git a/gcc/tree-ssa-threadupdate.c b/gcc/tree-ssa-threadupdate.c > index fd5234c..75273ca 100644 > --- a/gcc/tree-ssa-threadupdate.c > +++ b/gcc/tree-ssa-threadupdate.c > + With upcoming improvements, we're going to be holding onto the entire > + path, so we'll be able to clean this wart up shortly. */ > + if (path[1]->type == EDGE_COPY_SRC_JOINER_BLOCK) > + { > + threaded_edges.safe_push (path[1]->e); > + threaded_edges.safe_push (path.last ()->e); > + } > + else > + { > + threaded_edges.safe_push (path.last ()->e); > + threaded_edges.safe_push (NULL); > + } Where, to match the old behaviour, the else condition should read: @@ -1463,7 +1463,7 @@ register_jump_thread (vec<jump_thread_edge *> path) } else { - threaded_edges.safe_push (path.last ()->e); + threaded_edges.safe_push (path[1]->e); threaded_edges.safe_push (NULL); } } But I've almost certainly missed something here. I've attached the logs for dom1 if that helps. It seems we start erroneously destroying blocks we shouldn't be touching. Thanks, James ;; Function main (main, funcdef_no=0, decl_uid=2879, symbol_order=2) (executed once) Pass statistics: ---------------- ;; 8 loops found ;; ;; Loop 0 ;; header 0, latch 1 ;; depth 0, outer -1 ;; nodes: 0 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 ;; ;; Loop 1 ;; header 4, latch 44 ;; depth 1, outer 0 ;; nodes: 4 44 43 41 39 6 42 5 37 36 35 34 33 32 31 30 29 27 26 25 24 23 22 16 14 12 8 40 7 11 10 13 9 19 21 17 18 ;; ;; Loop 2 ;; header 6, latch 42 ;; depth 2, outer 1 ;; nodes: 6 42 41 39 37 36 35 34 33 32 31 30 29 27 26 25 24 23 22 16 14 12 8 40 7 11 10 13 9 19 21 17 18 ;; ;; Loop 3 ;; header 8, latch 40 ;; depth 3, outer 2 ;; nodes: 8 40 39 37 36 35 34 33 32 31 30 29 27 26 25 24 23 22 16 14 12 11 10 13 9 19 21 17 18 ;; ;; Loop 6 ;; header 25, latch 24 ;; depth 4, outer 3 ;; nodes: 25 24 29 27 26 ;; ;; Loop 5 ;; header 22, latch 19 ;; depth 4, outer 3 ;; nodes: 22 19 18 ;; ;; Loop 4 ;; header 10, latch 13 ;; depth 4, outer 3 ;; nodes: 10 13 12 11 ;; 2 succs { 3 45 } ;; 3 succs { 4 } ;; 4 succs { 5 43 } ;; 5 succs { 6 } ;; 6 succs { 7 41 } ;; 7 succs { 8 } ;; 8 succs { 9 14 } ;; 9 succs { 10 } ;; 10 succs { 12 11 } ;; 11 succs { 12 } ;; 12 succs { 13 14 } ;; 13 succs { 10 } ;; 14 succs { 15 16 } ;; 15 succs { } ;; 16 succs { 17 23 } ;; 17 succs { 20 21 } ;; 18 succs { 20 19 } ;; 19 succs { 22 } ;; 20 succs { } ;; 21 succs { 22 } ;; 22 succs { 18 23 } ;; 23 succs { 25 } ;; 24 succs { 25 } ;; 25 succs { 27 26 } ;; 26 succs { 27 } ;; 27 succs { 28 29 } ;; 28 succs { } ;; 29 succs { 24 30 } ;; 30 succs { 38 31 } ;; 31 succs { 38 32 } ;; 32 succs { 38 33 } ;; 33 succs { 38 34 } ;; 34 succs { 38 35 } ;; 35 succs { 38 36 } ;; 36 succs { 38 37 } ;; 37 succs { 38 39 } ;; 38 succs { } ;; 39 succs { 40 41 } ;; 40 succs { 8 } ;; 41 succs { 42 43 } ;; 42 succs { 6 } ;; 43 succs { 44 45 } ;; 44 succs { 4 } ;; 45 succs { } Optimizing block #0 Optimizing block #2 Optimizing statement off1.5_92 = 0; LKUP STMT off1.5_92 = 0 off1.5_92 = 0; ==== ASGN off1.5_92 = 0 Optimizing statement if (off1.5_92 != 8) Replaced 'off1.5_92' with constant '0' Folded to: if (1 != 0) LKUP STMT 1 ne_expr 0 if (1 != 0) Optimizing block #3 1>>> COND 1 = 1 ne_expr 0 1>>> COND 0 = 1 eq_expr 0 Optimizing block #4 LKUP STMT off1_93 = PHI <off1_50, 0> off1_93 = PHI <off1_50(44), 0(3)> 2>>> STMT off1_93 = PHI <off1_50, 0> off1_93 = PHI <off1_50(44), 0(3)> LKUP STMT .MEM_67 = PHI <.MEM_69, .MEM_19(D)> .MEM_67 = PHI <.MEM_69(44), .MEM_19(D)(3)> 2>>> STMT .MEM_67 = PHI <.MEM_69, .MEM_19(D)> .MEM_67 = PHI <.MEM_69(44), .MEM_19(D)(3)> <<<< STMT .MEM_67 = PHI <.MEM_69, .MEM_19(D)> .MEM_67 = PHI <.MEM_69(44), .MEM_19(D)(3)> <<<< STMT off1_93 = PHI <off1_50, 0> off1_93 = PHI <off1_50(44), 0(3)> Optimizing statement off2.4_86 = 0; LKUP STMT off2.4_86 = 0 off2.4_86 = 0; ==== ASGN off2.4_86 = 0 Optimizing statement if (off2.4_86 != 8) Replaced 'off2.4_86' with constant '0' Folded to: if (1 != 0) LKUP STMT 1 ne_expr 0 if (1 != 0) FIND: 1 Replaced redundant expr '1 != 0' with '1' Optimizing block #5 Optimizing block #6 LKUP STMT off2_91 = PHI <off2_49, 0> off2_91 = PHI <off2_49(42), 0(5)> 2>>> STMT off2_91 = PHI <off2_49, 0> off2_91 = PHI <off2_49(42), 0(5)> LKUP STMT .MEM_71 = PHI <.MEM_73, .MEM_67> .MEM_71 = PHI <.MEM_73(42), .MEM_67(5)> 2>>> STMT .MEM_71 = PHI <.MEM_73, .MEM_67> .MEM_71 = PHI <.MEM_73(42), .MEM_67(5)> <<<< STMT .MEM_71 = PHI <.MEM_73, .MEM_67> .MEM_71 = PHI <.MEM_73(42), .MEM_67(5)> <<<< STMT off2_91 = PHI <off2_49, 0> off2_91 = PHI <off2_49(42), 0(5)> Optimizing statement len.3_62 = 1; LKUP STMT len.3_62 = 1 len.3_62 = 1; ==== ASGN len.3_62 = 1 Optimizing statement if (len.3_62 != 80) Replaced 'len.3_62' with constant '1' Folded to: if (1 != 0) LKUP STMT 1 ne_expr 0 if (1 != 0) FIND: 1 Replaced redundant expr '1 != 0' with '1' Optimizing block #7 Optimizing block #8 LKUP STMT len_89 = PHI <len_48, 1> len_89 = PHI <len_48(40), 1(7)> 2>>> STMT len_89 = PHI <len_48, 1> len_89 = PHI <len_48(40), 1(7)> LKUP STMT .MEM_75 = PHI <.MEM_33, .MEM_71> .MEM_75 = PHI <.MEM_33(40), .MEM_71(7)> 2>>> STMT .MEM_75 = PHI <.MEM_33, .MEM_71> .MEM_75 = PHI <.MEM_33(40), .MEM_71(7)> <<<< STMT .MEM_75 = PHI <.MEM_33, .MEM_71> .MEM_75 = PHI <.MEM_33(40), .MEM_71(7)> <<<< STMT len_89 = PHI <len_48, 1> len_89 = PHI <len_48(40), 1(7)> Optimizing statement i.1_95 = 0; LKUP STMT i.1_95 = 0 i.1_95 = 0; ==== ASGN i.1_95 = 0 Optimizing statement if (i.1_95 != 96) Replaced 'i.1_95' with constant '0' Folded to: if (1 != 0) LKUP STMT 1 ne_expr 0 if (1 != 0) FIND: 1 Replaced redundant expr '1 != 0' with '1' Optimizing block #9 Optimizing block #10 LKUP STMT i_87 = PHI <i_26, 0> i_87 = PHI <i_26(13), 0(9)> 2>>> STMT i_87 = PHI <i_26, 0> i_87 = PHI <i_26(13), 0(9)> LKUP STMT c_81 = PHI <c_27, 65> c_81 = PHI <c_27(13), 65(9)> 2>>> STMT c_81 = PHI <c_27, 65> c_81 = PHI <c_27(13), 65(9)> LKUP STMT .MEM_79 = PHI <.MEM_25, .MEM_75> .MEM_79 = PHI <.MEM_25(13), .MEM_75(9)> 2>>> STMT .MEM_79 = PHI <.MEM_25, .MEM_75> .MEM_79 = PHI <.MEM_25(13), .MEM_75(9)> <<<< STMT .MEM_79 = PHI <.MEM_25, .MEM_75> .MEM_79 = PHI <.MEM_25(13), .MEM_75(9)> <<<< STMT c_81 = PHI <c_27, 65> c_81 = PHI <c_27(13), 65(9)> <<<< STMT i_87 = PHI <i_26, 0> i_87 = PHI <i_26(13), 0(9)> Optimizing statement u1.buf[i_87] = 97; LKUP STMT u1.buf[i_87] = 97 u1.buf[i_87] = 97; LKUP STMT 97 = u1.buf[i_87] 97 = u1.buf[i_87]; LKUP STMT 97 = u1.buf[i_87] 97 = u1.buf[i_87]; 2>>> STMT 97 = u1.buf[i_87] 97 = u1.buf[i_87]; Optimizing statement if (c_81 > 95) LKUP STMT c_81 gt_expr 95 if (c_81 > 95) Optimizing block #11 1>>> COND 1 = c_81 le_expr 95 1>>> COND 0 = c_81 gt_expr 95 LKUP STMT i_26 = i_87 plus_expr 1 i_26 = i_87 + 1; LKUP STMT c_27 = c_81 plus_expr 1 c_27 = c_81 + 1; LKUP STMT i.1_23 = nop_expr i_26 i.1_23 = (unsigned int) i_26; LKUP STMT i.1_23 ne_expr 96 if (i.1_23 != 96) <<<< COND 0 = c_81 gt_expr 95 <<<< COND 1 = c_81 le_expr 95 Optimizing block #12 LKUP STMT c_11 = PHI <c_81, 65> c_11 = PHI <c_81(11), 65(10)> 2>>> STMT c_11 = PHI <c_81, 65> c_11 = PHI <c_81(11), 65(10)> <<<< STMT c_11 = PHI <c_81, 65> c_11 = PHI <c_81(11), 65(10)> Optimizing statement u2.buf[i_87] = c_11; LKUP STMT u2.buf[i_87] = c_11 u2.buf[i_87] = c_11; LKUP STMT c_11 = u2.buf[i_87] c_11 = u2.buf[i_87]; LKUP STMT c_11 = u2.buf[i_87] c_11 = u2.buf[i_87]; 2>>> STMT c_11 = u2.buf[i_87] c_11 = u2.buf[i_87]; Optimizing statement i_26 = i_87 + 1; LKUP STMT i_26 = i_87 plus_expr 1 i_26 = i_87 + 1; Optimizing statement c_27 = c_11 + 1; LKUP STMT c_27 = c_11 plus_expr 1 c_27 = c_11 + 1; 2>>> STMT c_27 = c_11 plus_expr 1 c_27 = c_11 + 1; Optimizing statement i.1_23 = (unsigned int) i_26; LKUP STMT i.1_23 = nop_expr i_26 i.1_23 = (unsigned int) i_26; 2>>> STMT i.1_23 = nop_expr i_26 i.1_23 = (unsigned int) i_26; Optimizing statement if (i.1_23 != 96) LKUP STMT i.1_23 ne_expr 96 if (i.1_23 != 96) 0>>> COPY i.1_23 = 96 <<<< COPY i.1_23 = 96 Optimizing block #13 1>>> COND 1 = i.1_23 ne_expr 96 1>>> COND 0 = i.1_23 eq_expr 96 LKUP STMT c_27 gt_expr 95 if (c_27 > 95) <<<< COND 0 = i.1_23 eq_expr 96 <<<< COND 1 = i.1_23 ne_expr 96 0>>> COPY i.1_23 = 96 1>>> COND 1 = i.1_23 le_expr 96 1>>> COND 1 = i.1_23 ge_expr 96 1>>> COND 1 = i.1_23 eq_expr 96 1>>> COND 0 = i.1_23 ne_expr 96 LKUP STMT _28 = nop_expr off1_93 _28 = (sizetype) off1_93; LKUP STMT _29 = &u1.buf[_28] _29 = &u1.buf[_28]; LKUP STMT _30 = nop_expr off2_91 _30 = (sizetype) off2_91; LKUP STMT _31 = &u2.buf[_30] _31 = &u2.buf[_30]; LKUP STMT _32 = nop_expr len_89 _32 = (long unsigned int) len_89; LKUP STMT p_34 = memcpy (_29, _31, _32) p_34 = memcpy (_29, _31, _32); LKUP STMT _29 ne_expr p_34 if (_29 != p_34) <<<< COND 0 = i.1_23 ne_expr 96 <<<< COND 1 = i.1_23 eq_expr 96 <<<< COND 1 = i.1_23 ge_expr 96 <<<< COND 1 = i.1_23 le_expr 96 <<<< STMT i.1_23 = nop_expr i_26 i.1_23 = (unsigned int) i_26; <<<< STMT c_27 = c_11 plus_expr 1 c_27 = c_11 + 1; <<<< STMT c_11 = u2.buf[i_87] c_11 = u2.buf[i_87]; 1>>> COND 1 = c_81 ge_expr 95 1>>> COND 1 = c_81 ne_expr 95 1>>> COND 1 = c_81 gt_expr 95 1>>> COND 0 = c_81 le_expr 95 LKUP STMT i_26 = i_87 plus_expr 1 i_26 = i_87 + 1; LKUP STMT i.1_23 = nop_expr i_26 i.1_23 = (unsigned int) i_26; LKUP STMT i.1_23 ne_expr 96 if (i.1_23 != 96) <<<< COND 0 = c_81 le_expr 95 <<<< COND 1 = c_81 gt_expr 95 <<<< COND 1 = c_81 ne_expr 95 <<<< COND 1 = c_81 ge_expr 95 <<<< STMT 97 = u1.buf[i_87] 97 = u1.buf[i_87]; Registering jump thread : (9, 10); (10, 11); (11, 12); Optimizing block #14 LKUP STMT .MEM_77 = PHI <.MEM_25, .MEM_75> .MEM_77 = PHI <.MEM_25(12), .MEM_75(8)> 2>>> STMT .MEM_77 = PHI <.MEM_25, .MEM_75> .MEM_77 = PHI <.MEM_25(12), .MEM_75(8)> <<<< STMT .MEM_77 = PHI <.MEM_25, .MEM_75> .MEM_77 = PHI <.MEM_25(12), .MEM_75(8)> Optimizing statement _28 = (sizetype) off1_93; LKUP STMT _28 = nop_expr off1_93 _28 = (sizetype) off1_93; 2>>> STMT _28 = nop_expr off1_93 _28 = (sizetype) off1_93; Optimizing statement _29 = &u1.buf[_28]; LKUP STMT _29 = &u1.buf[_28] _29 = &u1.buf[_28]; 2>>> STMT _29 = &u1.buf[_28] _29 = &u1.buf[_28]; Optimizing statement _30 = (sizetype) off2_91; LKUP STMT _30 = nop_expr off2_91 _30 = (sizetype) off2_91; 2>>> STMT _30 = nop_expr off2_91 _30 = (sizetype) off2_91; Optimizing statement _31 = &u2.buf[_30]; LKUP STMT _31 = &u2.buf[_30] _31 = &u2.buf[_30]; 2>>> STMT _31 = &u2.buf[_30] _31 = &u2.buf[_30]; Optimizing statement _32 = (long unsigned int) len_89; LKUP STMT _32 = nop_expr len_89 _32 = (long unsigned int) len_89; 2>>> STMT _32 = nop_expr len_89 _32 = (long unsigned int) len_89; Optimizing statement p_34 = memcpy (_29, _31, _32); Optimizing statement if (_29 != p_34) LKUP STMT _29 ne_expr p_34 if (_29 != p_34) 0>>> COPY _29 = p_34 <<<< COPY _29 = p_34 Optimizing block #16 0>>> COPY p_34 = _29 1>>> COND 1 = _29 le_expr p_34 1>>> COND 1 = _29 ge_expr p_34 1>>> COND 1 = _29 eq_expr p_34 1>>> COND 0 = _29 ne_expr p_34 LKUP STMT i_45 = PHI <0> i_45 = PHI <0(14)> 2>>> STMT i_45 = PHI <0> i_45 = PHI <0(14)> LKUP STMT q_46 = PHI <&u1.buf> q_46 = PHI <&u1.buf(14)> 2>>> STMT q_46 = PHI <&u1.buf> q_46 = PHI <&u1.buf(14)> <<<< STMT q_46 = PHI <&u1.buf> q_46 = PHI <&u1.buf(14)> <<<< STMT i_45 = PHI <0> i_45 = PHI <0(14)> Optimizing statement if (i_45 < off1_93) Replaced 'i_45' with constant '0' Folded to: if (off1_93 > 0) LKUP STMT off1_93 gt_expr 0 if (off1_93 > 0) Optimizing block #17 1>>> COND 1 = off1_93 ge_expr 0 1>>> COND 1 = off1_93 ne_expr 0 1>>> COND 1 = off1_93 gt_expr 0 1>>> COND 0 = off1_93 le_expr 0 Optimizing statement _47 = *q_46; Replaced 'q_46' with constant '&u1D.2877.bufD.2874' Folded to: _47 = MEM[(char *)&u1]; LKUP STMT _47 = MEM[(char *)&u1] _47 = MEM[(char *)&u1]; 2>>> STMT _47 = MEM[(char *)&u1] _47 = MEM[(char *)&u1]; Optimizing statement if (_47 != 97) LKUP STMT _47 ne_expr 97 if (_47 != 97) Optimizing block #21 0>>> COPY _47 = 97 1>>> COND 1 = _47 le_expr 97 1>>> COND 1 = _47 ge_expr 97 1>>> COND 1 = _47 eq_expr 97 1>>> COND 0 = _47 ne_expr 97 Optimizing block #22 LKUP STMT i_85 = PHI <i_36, 0> i_85 = PHI <i_36(19), 0(21)> 2>>> STMT i_85 = PHI <i_36, 0> i_85 = PHI <i_36(19), 0(21)> LKUP STMT q_83 = PHI <q_37, &u1.buf> q_83 = PHI <q_37(19), &u1.buf(21)> 2>>> STMT q_83 = PHI <q_37, &u1.buf> q_83 = PHI <q_37(19), &u1.buf(21)> <<<< STMT q_83 = PHI <q_37, &u1.buf> q_83 = PHI <q_37(19), &u1.buf(21)> <<<< STMT i_85 = PHI <i_36, 0> i_85 = PHI <i_36(19), 0(21)> Optimizing statement i_36 = i_85 + 1; LKUP STMT i_36 = i_85 plus_expr 1 i_36 = i_85 + 1; Optimizing statement q_37 = q_83 + 1; LKUP STMT q_37 = q_83 pointer_plus_expr 1 q_37 = q_83 + 1; Optimizing statement if (i_36 < off1_93) LKUP STMT i_36 lt_expr off1_93 if (i_36 < off1_93) Optimizing block #18 1>>> COND 1 = i_36 le_expr off1_93 1>>> COND 1 = i_36 ne_expr off1_93 1>>> COND 1 = i_36 lt_expr off1_93 1>>> COND 0 = i_36 ge_expr off1_93 Optimizing statement _35 = *q_37; LKUP STMT _35 = *q_37 _35 = *q_37; 2>>> STMT _35 = *q_37 _35 = *q_37; Optimizing statement if (_35 != 97) LKUP STMT _35 ne_expr 97 if (_35 != 97) Optimizing block #19 0>>> COPY _35 = 97 1>>> COND 1 = _35 le_expr 97 1>>> COND 1 = _35 ge_expr 97 1>>> COND 1 = _35 eq_expr 97 1>>> COND 0 = _35 ne_expr 97 <<<< COND 0 = _35 ne_expr 97 <<<< COND 1 = _35 eq_expr 97 <<<< COND 1 = _35 ge_expr 97 <<<< COND 1 = _35 le_expr 97 <<<< COPY _35 = 97 <<<< STMT _35 = *q_37 _35 = *q_37; <<<< COND 0 = i_36 ge_expr off1_93 <<<< COND 1 = i_36 lt_expr off1_93 <<<< COND 1 = i_36 ne_expr off1_93 <<<< COND 1 = i_36 le_expr off1_93 LKUP STMT off1_93 gt_expr 1 if (off1_93 > 1) <<<< COND 0 = _47 ne_expr 97 <<<< COND 1 = _47 eq_expr 97 <<<< COND 1 = _47 ge_expr 97 <<<< COND 1 = _47 le_expr 97 <<<< COPY _47 = 97 Optimizing block #20 Optimizing statement abort (); <<<< STMT _47 = MEM[(char *)&u1] _47 = MEM[(char *)&u1]; <<<< COND 0 = off1_93 le_expr 0 <<<< COND 1 = off1_93 gt_expr 0 <<<< COND 1 = off1_93 ne_expr 0 <<<< COND 1 = off1_93 ge_expr 0 Optimizing block #23 LKUP STMT q_56 = PHI <q_37, &u1.buf> q_56 = PHI <q_37(22), &u1.buf(16)> 2>>> STMT q_56 = PHI <q_37, &u1.buf> q_56 = PHI <q_37(22), &u1.buf(16)> <<<< STMT q_56 = PHI <q_37, &u1.buf> q_56 = PHI <q_37(22), &u1.buf(16)> Optimizing statement _38 = (char) off2_91; LKUP STMT _38 = convert_expr off2_91 _38 = (char) off2_91; 2>>> STMT _38 = convert_expr off2_91 _38 = (char) off2_91; Optimizing statement c_39 = _38 + 65; LKUP STMT c_39 = _38 plus_expr 65 c_39 = _38 + 65; 2>>> STMT c_39 = _38 plus_expr 65 c_39 = _38 + 65; Optimizing block #25 LKUP STMT i_94 = PHI <i_41, 0> i_94 = PHI <i_41(24), 0(23)> 2>>> STMT i_94 = PHI <i_41, 0> i_94 = PHI <i_41(24), 0(23)> LKUP STMT q_70 = PHI <q_42, q_56> q_70 = PHI <q_42(24), q_56(23)> 2>>> STMT q_70 = PHI <q_42, q_56> q_70 = PHI <q_42(24), q_56(23)> LKUP STMT c_64 = PHI <c_43, c_39> c_64 = PHI <c_43(24), c_39(23)> 2>>> STMT c_64 = PHI <c_43, c_39> c_64 = PHI <c_43(24), c_39(23)> <<<< STMT c_64 = PHI <c_43, c_39> c_64 = PHI <c_43(24), c_39(23)> <<<< STMT q_70 = PHI <q_42, q_56> q_70 = PHI <q_42(24), q_56(23)> <<<< STMT i_94 = PHI <i_41, 0> i_94 = PHI <i_41(24), 0(23)> Optimizing statement if (c_64 > 95) LKUP STMT c_64 gt_expr 95 if (c_64 > 95) Optimizing block #26 1>>> COND 1 = c_64 le_expr 95 1>>> COND 0 = c_64 gt_expr 95 LKUP STMT _40 = *q_70 _40 = *q_70; LKUP STMT _40 ne_expr c_64 if (_40 != c_64) <<<< COND 0 = c_64 gt_expr 95 <<<< COND 1 = c_64 le_expr 95 Optimizing block #27 LKUP STMT c_13 = PHI <c_64, 65> c_13 = PHI <c_64(26), 65(25)> 2>>> STMT c_13 = PHI <c_64, 65> c_13 = PHI <c_64(26), 65(25)> <<<< STMT c_13 = PHI <c_64, 65> c_13 = PHI <c_64(26), 65(25)> Optimizing statement _40 = *q_70; LKUP STMT _40 = *q_70 _40 = *q_70; 2>>> STMT _40 = *q_70 _40 = *q_70; Optimizing statement if (_40 != c_13) LKUP STMT _40 ne_expr c_13 if (_40 != c_13) Optimizing block #29 0>>> COPY c_13 = _40 1>>> COND 1 = _40 le_expr c_13 1>>> COND 1 = _40 ge_expr c_13 1>>> COND 1 = _40 eq_expr c_13 1>>> COND 0 = _40 ne_expr c_13 Optimizing statement i_41 = i_94 + 1; LKUP STMT i_41 = i_94 plus_expr 1 i_41 = i_94 + 1; Optimizing statement q_42 = q_70 + 1; LKUP STMT q_42 = q_70 pointer_plus_expr 1 q_42 = q_70 + 1; Optimizing statement c_43 = c_13 + 1; Replaced 'c_13' with variable '_40' LKUP STMT c_43 = _40 plus_expr 1 c_43 = _40 + 1; 2>>> STMT c_43 = _40 plus_expr 1 c_43 = _40 + 1; Optimizing statement if (i_41 < len_89) LKUP STMT i_41 lt_expr len_89 if (i_41 < len_89) Optimizing block #24 1>>> COND 1 = i_41 le_expr len_89 1>>> COND 1 = i_41 ne_expr len_89 1>>> COND 1 = i_41 lt_expr len_89 1>>> COND 0 = i_41 ge_expr len_89 LKUP STMT c_43 gt_expr 95 if (c_43 > 95) <<<< COND 0 = i_41 ge_expr len_89 <<<< COND 1 = i_41 lt_expr len_89 <<<< COND 1 = i_41 ne_expr len_89 <<<< COND 1 = i_41 le_expr len_89 Optimizing block #30 1>>> COND 1 = i_41 ge_expr len_89 1>>> COND 0 = i_41 lt_expr len_89 LKUP STMT q_52 = PHI <q_42> q_52 = PHI <q_42(29)> 2>>> STMT q_52 = PHI <q_42> q_52 = PHI <q_42(29)> <<<< STMT q_52 = PHI <q_42> q_52 = PHI <q_42(29)> Optimizing statement _54 = *q_52; LKUP STMT _54 = *q_52 _54 = *q_52; 2>>> STMT _54 = *q_52 _54 = *q_52; Optimizing statement if (_54 != 97) LKUP STMT _54 ne_expr 97 if (_54 != 97) Optimizing block #31 0>>> COPY _54 = 97 1>>> COND 1 = _54 le_expr 97 1>>> COND 1 = _54 ge_expr 97 1>>> COND 1 = _54 eq_expr 97 1>>> COND 0 = _54 ne_expr 97 Optimizing statement _60 = MEM[(char *)q_52 + 1B]; LKUP STMT _60 = MEM[(char *)q_52 + 1B] _60 = MEM[(char *)q_52 + 1B]; 2>>> STMT _60 = MEM[(char *)q_52 + 1B] _60 = MEM[(char *)q_52 + 1B]; Optimizing statement if (_60 != 97) LKUP STMT _60 ne_expr 97 if (_60 != 97) Optimizing block #32 0>>> COPY _60 = 97 1>>> COND 1 = _60 le_expr 97 1>>> COND 1 = _60 ge_expr 97 1>>> COND 1 = _60 eq_expr 97 1>>> COND 0 = _60 ne_expr 97 Optimizing statement _66 = MEM[(char *)q_52 + 2B]; LKUP STMT _66 = MEM[(char *)q_52 + 2B] _66 = MEM[(char *)q_52 + 2B]; 2>>> STMT _66 = MEM[(char *)q_52 + 2B] _66 = MEM[(char *)q_52 + 2B]; Optimizing statement if (_66 != 97) LKUP STMT _66 ne_expr 97 if (_66 != 97) Optimizing block #33 0>>> COPY _66 = 97 1>>> COND 1 = _66 le_expr 97 1>>> COND 1 = _66 ge_expr 97 1>>> COND 1 = _66 eq_expr 97 1>>> COND 0 = _66 ne_expr 97 Optimizing statement _72 = MEM[(char *)q_52 + 3B]; LKUP STMT _72 = MEM[(char *)q_52 + 3B] _72 = MEM[(char *)q_52 + 3B]; 2>>> STMT _72 = MEM[(char *)q_52 + 3B] _72 = MEM[(char *)q_52 + 3B]; Optimizing statement if (_72 != 97) LKUP STMT _72 ne_expr 97 if (_72 != 97) Optimizing block #34 0>>> COPY _72 = 97 1>>> COND 1 = _72 le_expr 97 1>>> COND 1 = _72 ge_expr 97 1>>> COND 1 = _72 eq_expr 97 1>>> COND 0 = _72 ne_expr 97 Optimizing statement _78 = MEM[(char *)q_52 + 4B]; LKUP STMT _78 = MEM[(char *)q_52 + 4B] _78 = MEM[(char *)q_52 + 4B]; 2>>> STMT _78 = MEM[(char *)q_52 + 4B] _78 = MEM[(char *)q_52 + 4B]; Optimizing statement if (_78 != 97) LKUP STMT _78 ne_expr 97 if (_78 != 97) Optimizing block #35 0>>> COPY _78 = 97 1>>> COND 1 = _78 le_expr 97 1>>> COND 1 = _78 ge_expr 97 1>>> COND 1 = _78 eq_expr 97 1>>> COND 0 = _78 ne_expr 97 Optimizing statement _84 = MEM[(char *)q_52 + 5B]; LKUP STMT _84 = MEM[(char *)q_52 + 5B] _84 = MEM[(char *)q_52 + 5B]; 2>>> STMT _84 = MEM[(char *)q_52 + 5B] _84 = MEM[(char *)q_52 + 5B]; Optimizing statement if (_84 != 97) LKUP STMT _84 ne_expr 97 if (_84 != 97) Optimizing block #36 0>>> COPY _84 = 97 1>>> COND 1 = _84 le_expr 97 1>>> COND 1 = _84 ge_expr 97 1>>> COND 1 = _84 eq_expr 97 1>>> COND 0 = _84 ne_expr 97 Optimizing statement _90 = MEM[(char *)q_52 + 6B]; LKUP STMT _90 = MEM[(char *)q_52 + 6B] _90 = MEM[(char *)q_52 + 6B]; 2>>> STMT _90 = MEM[(char *)q_52 + 6B] _90 = MEM[(char *)q_52 + 6B]; Optimizing statement if (_90 != 97) LKUP STMT _90 ne_expr 97 if (_90 != 97) Optimizing block #37 0>>> COPY _90 = 97 1>>> COND 1 = _90 le_expr 97 1>>> COND 1 = _90 ge_expr 97 1>>> COND 1 = _90 eq_expr 97 1>>> COND 0 = _90 ne_expr 97 Optimizing statement _96 = MEM[(char *)q_52 + 7B]; LKUP STMT _96 = MEM[(char *)q_52 + 7B] _96 = MEM[(char *)q_52 + 7B]; 2>>> STMT _96 = MEM[(char *)q_52 + 7B] _96 = MEM[(char *)q_52 + 7B]; Optimizing statement if (_96 != 97) LKUP STMT _96 ne_expr 97 if (_96 != 97) Optimizing block #39 0>>> COPY _96 = 97 1>>> COND 1 = _96 le_expr 97 1>>> COND 1 = _96 ge_expr 97 1>>> COND 1 = _96 eq_expr 97 1>>> COND 0 = _96 ne_expr 97 Optimizing statement len_48 = len_89 + 1; LKUP STMT len_48 = len_89 plus_expr 1 len_48 = len_89 + 1; Optimizing statement len.3_22 = (unsigned int) len_48; LKUP STMT len.3_22 = nop_expr len_48 len.3_22 = (unsigned int) len_48; 2>>> STMT len.3_22 = nop_expr len_48 len.3_22 = (unsigned int) len_48; Optimizing statement if (len.3_22 != 80) LKUP STMT len.3_22 ne_expr 80 if (len.3_22 != 80) 0>>> COPY len.3_22 = 80 <<<< COPY len.3_22 = 80 Optimizing block #40 1>>> COND 1 = len.3_22 ne_expr 80 1>>> COND 0 = len.3_22 eq_expr 80 Registering jump thread : (40, 8); (8, 9); (9, 10); <<<< COND 0 = len.3_22 eq_expr 80 <<<< COND 1 = len.3_22 ne_expr 80 0>>> COPY len.3_22 = 80 1>>> COND 1 = len.3_22 le_expr 80 1>>> COND 1 = len.3_22 ge_expr 80 1>>> COND 1 = len.3_22 eq_expr 80 1>>> COND 0 = len.3_22 ne_expr 80 LKUP STMT off2_49 = off2_91 plus_expr 1 off2_49 = off2_91 + 1; LKUP STMT off2.4_21 = nop_expr off2_49 off2.4_21 = (unsigned int) off2_49; LKUP STMT off2.4_21 ne_expr 8 if (off2.4_21 != 8) <<<< COND 0 = len.3_22 ne_expr 80 <<<< COND 1 = len.3_22 eq_expr 80 <<<< COND 1 = len.3_22 ge_expr 80 <<<< COND 1 = len.3_22 le_expr 80 <<<< STMT len.3_22 = nop_expr len_48 len.3_22 = (unsigned int) len_48; <<<< COND 0 = _96 ne_expr 97 <<<< COND 1 = _96 eq_expr 97 <<<< COND 1 = _96 ge_expr 97 <<<< COND 1 = _96 le_expr 97 <<<< COPY _96 = 97 <<<< STMT _96 = MEM[(char *)q_52 + 7B] _96 = MEM[(char *)q_52 + 7B]; <<<< COND 0 = _90 ne_expr 97 <<<< COND 1 = _90 eq_expr 97 <<<< COND 1 = _90 ge_expr 97 <<<< COND 1 = _90 le_expr 97 <<<< COPY _90 = 97 <<<< STMT _90 = MEM[(char *)q_52 + 6B] _90 = MEM[(char *)q_52 + 6B]; <<<< COND 0 = _84 ne_expr 97 <<<< COND 1 = _84 eq_expr 97 <<<< COND 1 = _84 ge_expr 97 <<<< COND 1 = _84 le_expr 97 <<<< COPY _84 = 97 <<<< STMT _84 = MEM[(char *)q_52 + 5B] _84 = MEM[(char *)q_52 + 5B]; <<<< COND 0 = _78 ne_expr 97 <<<< COND 1 = _78 eq_expr 97 <<<< COND 1 = _78 ge_expr 97 <<<< COND 1 = _78 le_expr 97 <<<< COPY _78 = 97 <<<< STMT _78 = MEM[(char *)q_52 + 4B] _78 = MEM[(char *)q_52 + 4B]; <<<< COND 0 = _72 ne_expr 97 <<<< COND 1 = _72 eq_expr 97 <<<< COND 1 = _72 ge_expr 97 <<<< COND 1 = _72 le_expr 97 <<<< COPY _72 = 97 <<<< STMT _72 = MEM[(char *)q_52 + 3B] _72 = MEM[(char *)q_52 + 3B]; <<<< COND 0 = _66 ne_expr 97 <<<< COND 1 = _66 eq_expr 97 <<<< COND 1 = _66 ge_expr 97 <<<< COND 1 = _66 le_expr 97 <<<< COPY _66 = 97 <<<< STMT _66 = MEM[(char *)q_52 + 2B] _66 = MEM[(char *)q_52 + 2B]; <<<< COND 0 = _60 ne_expr 97 <<<< COND 1 = _60 eq_expr 97 <<<< COND 1 = _60 ge_expr 97 <<<< COND 1 = _60 le_expr 97 <<<< COPY _60 = 97 <<<< STMT _60 = MEM[(char *)q_52 + 1B] _60 = MEM[(char *)q_52 + 1B]; <<<< COND 0 = _54 ne_expr 97 <<<< COND 1 = _54 eq_expr 97 <<<< COND 1 = _54 ge_expr 97 <<<< COND 1 = _54 le_expr 97 <<<< COPY _54 = 97 Optimizing block #38 Optimizing statement abort (); <<<< STMT _54 = *q_52 _54 = *q_52; <<<< COND 0 = i_41 lt_expr len_89 <<<< COND 1 = i_41 ge_expr len_89 <<<< STMT c_43 = _40 plus_expr 1 c_43 = _40 + 1; <<<< COND 0 = _40 ne_expr c_13 <<<< COND 1 = _40 eq_expr c_13 <<<< COND 1 = _40 ge_expr c_13 <<<< COND 1 = _40 le_expr c_13 <<<< COPY c_13 = _40 Optimizing block #28 1>>> COND 1 = _40 ne_expr c_13 1>>> COND 0 = _40 eq_expr c_13 Optimizing statement abort (); <<<< COND 0 = _40 eq_expr c_13 <<<< COND 1 = _40 ne_expr c_13 <<<< STMT _40 = *q_70 _40 = *q_70; 1>>> COND 1 = c_64 ge_expr 95 1>>> COND 1 = c_64 ne_expr 95 1>>> COND 1 = c_64 gt_expr 95 1>>> COND 0 = c_64 le_expr 95 LKUP STMT _40 = *q_70 _40 = *q_70; LKUP STMT _40 ne_expr 65 if (_40 != 65) <<<< COND 0 = c_64 le_expr 95 <<<< COND 1 = c_64 gt_expr 95 <<<< COND 1 = c_64 ne_expr 95 <<<< COND 1 = c_64 ge_expr 95 LKUP STMT c_39 gt_expr 95 if (c_39 > 95) <<<< STMT c_39 = _38 plus_expr 65 c_39 = _38 + 65; <<<< STMT _38 = convert_expr off2_91 _38 = (char) off2_91; <<<< COND 0 = _29 ne_expr p_34 <<<< COND 1 = _29 eq_expr p_34 <<<< COND 1 = _29 ge_expr p_34 <<<< COND 1 = _29 le_expr p_34 <<<< COPY p_34 = _29 Optimizing block #15 1>>> COND 1 = _29 ne_expr p_34 1>>> COND 0 = _29 eq_expr p_34 Optimizing statement abort (); <<<< COND 0 = _29 eq_expr p_34 <<<< COND 1 = _29 ne_expr p_34 <<<< STMT _32 = nop_expr len_89 _32 = (long unsigned int) len_89; <<<< STMT _31 = &u2.buf[_30] _31 = &u2.buf[_30]; <<<< STMT _30 = nop_expr off2_91 _30 = (sizetype) off2_91; <<<< STMT _29 = &u1.buf[_28] _29 = &u1.buf[_28]; <<<< STMT _28 = nop_expr off1_93 _28 = (sizetype) off1_93; 1>>> COND 1 = 1 le_expr 0 1>>> COND 1 = 1 ge_expr 0 LKUP STMT _28 = nop_expr off1_93 _28 = (sizetype) off1_93; LKUP STMT _29 = &u1.buf[_28] _29 = &u1.buf[_28]; LKUP STMT _30 = nop_expr off2_91 _30 = (sizetype) off2_91; LKUP STMT _31 = &u2.buf[_30] _31 = &u2.buf[_30]; LKUP STMT _32 = nop_expr len_89 _32 = (long unsigned int) len_89; LKUP STMT p_34 = memcpy (_29, _31, _32) p_34 = memcpy (_29, _31, _32); LKUP STMT _29 ne_expr p_34 if (_29 != p_34) <<<< COND 1 = 1 ge_expr 0 <<<< COND 1 = 1 le_expr 0 Registering jump thread : (7, 8); (8, 9); (9, 10); Optimizing block #41 LKUP STMT .MEM_73 = PHI <.MEM_33, .MEM_71> .MEM_73 = PHI <.MEM_33(39), .MEM_71(6)> 2>>> STMT .MEM_73 = PHI <.MEM_33, .MEM_71> .MEM_73 = PHI <.MEM_33(39), .MEM_71(6)> <<<< STMT .MEM_73 = PHI <.MEM_33, .MEM_71> .MEM_73 = PHI <.MEM_33(39), .MEM_71(6)> Optimizing statement off2_49 = off2_91 + 1; LKUP STMT off2_49 = off2_91 plus_expr 1 off2_49 = off2_91 + 1; Optimizing statement off2.4_21 = (unsigned int) off2_49; LKUP STMT off2.4_21 = nop_expr off2_49 off2.4_21 = (unsigned int) off2_49; 2>>> STMT off2.4_21 = nop_expr off2_49 off2.4_21 = (unsigned int) off2_49; Optimizing statement if (off2.4_21 != 8) LKUP STMT off2.4_21 ne_expr 8 if (off2.4_21 != 8) 0>>> COPY off2.4_21 = 8 <<<< COPY off2.4_21 = 8 Optimizing block #42 1>>> COND 1 = off2.4_21 ne_expr 8 1>>> COND 0 = off2.4_21 eq_expr 8 Registering jump thread : (42, 6); (6, 7); (7, 8); <<<< COND 0 = off2.4_21 eq_expr 8 <<<< COND 1 = off2.4_21 ne_expr 8 0>>> COPY off2.4_21 = 8 1>>> COND 1 = off2.4_21 le_expr 8 1>>> COND 1 = off2.4_21 ge_expr 8 1>>> COND 1 = off2.4_21 eq_expr 8 1>>> COND 0 = off2.4_21 ne_expr 8 LKUP STMT off1_50 = off1_93 plus_expr 1 off1_50 = off1_93 + 1; LKUP STMT off1.5_20 = nop_expr off1_50 off1.5_20 = (unsigned int) off1_50; LKUP STMT off1.5_20 ne_expr 8 if (off1.5_20 != 8) <<<< COND 0 = off2.4_21 ne_expr 8 <<<< COND 1 = off2.4_21 eq_expr 8 <<<< COND 1 = off2.4_21 ge_expr 8 <<<< COND 1 = off2.4_21 le_expr 8 <<<< STMT off2.4_21 = nop_expr off2_49 off2.4_21 = (unsigned int) off2_49; 1>>> COND 1 = 1 le_expr 0 1>>> COND 1 = 1 ge_expr 0 LKUP STMT off2_49 = off2_91 plus_expr 1 off2_49 = off2_91 + 1; LKUP STMT off2.4_21 = nop_expr off2_49 off2.4_21 = (unsigned int) off2_49; LKUP STMT off2.4_21 ne_expr 8 if (off2.4_21 != 8) <<<< COND 1 = 1 ge_expr 0 <<<< COND 1 = 1 le_expr 0 Registering jump thread : (5, 6); (6, 7); (7, 8); Optimizing block #43 LKUP STMT .MEM_69 = PHI <.MEM_73, .MEM_67> .MEM_69 = PHI <.MEM_73(41), .MEM_67(4)> 2>>> STMT .MEM_69 = PHI <.MEM_73, .MEM_67> .MEM_69 = PHI <.MEM_73(41), .MEM_67(4)> <<<< STMT .MEM_69 = PHI <.MEM_73, .MEM_67> .MEM_69 = PHI <.MEM_73(41), .MEM_67(4)> Optimizing statement off1_50 = off1_93 + 1; LKUP STMT off1_50 = off1_93 plus_expr 1 off1_50 = off1_93 + 1; Optimizing statement off1.5_20 = (unsigned int) off1_50; LKUP STMT off1.5_20 = nop_expr off1_50 off1.5_20 = (unsigned int) off1_50; 2>>> STMT off1.5_20 = nop_expr off1_50 off1.5_20 = (unsigned int) off1_50; Optimizing statement if (off1.5_20 != 8) LKUP STMT off1.5_20 ne_expr 8 if (off1.5_20 != 8) 0>>> COPY off1.5_20 = 8 <<<< COPY off1.5_20 = 8 Optimizing block #44 1>>> COND 1 = off1.5_20 ne_expr 8 1>>> COND 0 = off1.5_20 eq_expr 8 Registering jump thread : (44, 4); (4, 5); (5, 6); <<<< COND 0 = off1.5_20 eq_expr 8 <<<< COND 1 = off1.5_20 ne_expr 8 <<<< STMT off1.5_20 = nop_expr off1_50 off1.5_20 = (unsigned int) off1_50; 1>>> COND 1 = 1 le_expr 0 1>>> COND 1 = 1 ge_expr 0 LKUP STMT off1_50 = off1_93 plus_expr 1 off1_50 = off1_93 + 1; LKUP STMT off1.5_20 = nop_expr off1_50 off1.5_20 = (unsigned int) off1_50; LKUP STMT off1.5_20 ne_expr 8 if (off1.5_20 != 8) <<<< COND 1 = 1 ge_expr 0 <<<< COND 1 = 1 le_expr 0 Registering jump thread : (3, 4); (4, 5); (5, 6); <<<< COND 0 = 1 eq_expr 0 <<<< COND 1 = 1 ne_expr 0 Optimizing block #45 LKUP STMT .MEM_65 = PHI <.MEM_69, .MEM_19(D)> .MEM_65 = PHI <.MEM_69(43), .MEM_19(D)(2)> 2>>> STMT .MEM_65 = PHI <.MEM_69, .MEM_19(D)> .MEM_65 = PHI <.MEM_69(43), .MEM_19(D)(2)> <<<< STMT .MEM_65 = PHI <.MEM_69, .MEM_19(D)> .MEM_65 = PHI <.MEM_69(43), .MEM_19(D)(2)> Optimizing statement exit (0); Total number of statements: 69 Exprs considered for dominator optimizations: 87 Hash table statistics: avail_exprs: size 2039, 0 elements, 0.112500 collision/search ratio Pass statistics: ---------------- Copies propagated: 1 Constants propagated: 6 Redundant expressions eliminated: 3 Merging blocks 2 and 3 Merging blocks 4 and 5 Merging blocks 6 and 7 Merging blocks 8 and 9 main () { charD.8 cD.2887; charD.8 * qD.2886; charD.8 * pD.2885; intD.7 iD.2884; intD.7 lenD.2883; intD.7 off2D.2882; intD.7 off1D.2881; unsigned intD.10 off1.5_20; unsigned intD.10 off2.4_21; unsigned intD.10 len.3_22; unsigned intD.10 i.1_23; sizetype _28; charD.8 * _29; sizetype _30; charD.8 * _31; long unsigned intD.11 _32; charD.8 _35; charD.8 _38; charD.8 _40; charD.8 _47; charD.8 _54; charD.8 _60; unsigned intD.10 len.3_62; charD.8 _66; charD.8 _72; charD.8 _78; charD.8 _84; unsigned intD.10 off2.4_86; charD.8 _90; unsigned intD.10 off1.5_92; unsigned intD.10 i.1_95; charD.8 _96; ;; basic block 2, loop depth 0, count 0, freq 95, maybe hot ;; prev block 0, next block 3, flags: (NEW, REACHABLE) ;; pred: ENTRY [100.0%] (FALLTHRU,EXECUTABLE) # RANGE [0, 8] off1.5_92 = 0; ;; succ: 3 [100.0%] (FALLTHRU) ;; basic block 3, loop depth 1, count 0, freq 94, maybe hot ;; prev block 2, next block 4, flags: (NEW, REACHABLE) ;; pred: 40 [100.0%] (FALLTHRU,DFS_BACK) ;; 2 [100.0%] (FALLTHRU) # # RANGE [0, 8] off1_93 = PHI <off1_50(40), 0(2)> # .MEM_67 = PHI <.MEM_69(40), .MEM_19(D)(2)> # RANGE [0, 8] off2.4_86 = 0; ;; succ: 4 [100.0%] (FALLTHRU) ;; basic block 4, loop depth 2, count 0, freq 85, maybe hot ;; prev block 3, next block 5, flags: (NEW, REACHABLE) ;; pred: 38 [100.0%] (FALLTHRU,DFS_BACK) ;; 3 [100.0%] (FALLTHRU) # # RANGE [0, 8] off2_91 = PHI <off2_49(38), 0(3)> # .MEM_71 = PHI <.MEM_73(38), .MEM_67(3)> # RANGE [1, 80] len.3_62 = 1; ;; succ: 5 [100.0%] (FALLTHRU) ;; basic block 5, loop depth 3, count 0, freq 103, maybe hot ;; prev block 4, next block 6, flags: (NEW, REACHABLE) ;; pred: 36 [100.0%] (FALLTHRU,DFS_BACK) ;; 4 [100.0%] (FALLTHRU) # # RANGE [1, 80] len_89 = PHI <len_48(36), 1(4)> # .MEM_75 = PHI <.MEM_33(36), .MEM_71(4)> # RANGE [0, 96] i.1_95 = 0; ;; succ: 6 [100.0%] (FALLTHRU) ;; basic block 6, loop depth 4, count 0, freq 9897, maybe hot ;; prev block 5, next block 7, flags: (NEW, REACHABLE) ;; pred: 9 [100.0%] (FALLTHRU,DFS_BACK) ;; 5 [100.0%] (FALLTHRU) # # RANGE [0, 96] i_87 = PHI <i_26(9), 0(5)> # c_81 = PHI <c_27(9), 65(5)> # .MEM_79 = PHI <.MEM_25(9), .MEM_75(5)> # .MEM_24 = VDEF <.MEM_79> u1D.2877.bufD.2874[i_87] = 97; if (c_81 > 95) goto <bb 8>; else goto <bb 7>; ;; succ: 8 [50.0%] (TRUE_VALUE,EXECUTABLE) ;; 7 [50.0%] (FALSE_VALUE,EXECUTABLE) ;; basic block 7, loop depth 4, count 0, freq 4949, maybe hot ;; prev block 6, next block 8, flags: (NEW, REACHABLE) ;; pred: 6 [50.0%] (FALSE_VALUE,EXECUTABLE) ;; succ: 8 [100.0%] (FALLTHRU,EXECUTABLE) ;; basic block 8, loop depth 4, count 0, freq 9897, maybe hot ;; prev block 7, next block 9, flags: (NEW, REACHABLE) ;; pred: 7 [100.0%] (FALLTHRU,EXECUTABLE) ;; 6 [50.0%] (TRUE_VALUE,EXECUTABLE) # c_11 = PHI <c_81(7), 65(6)> # .MEM_25 = VDEF <.MEM_24> u2D.2878.bufD.2874[i_87] = c_11; # RANGE [1, 96] i_26 = i_87 + 1; # RANGE [0, 255] c_27 = c_11 + 1; # RANGE [0, 96] i.1_23 = (unsigned intD.10) i_26; if (i.1_23 != 96) goto <bb 9>; else goto <bb 10>; ;; succ: 9 [99.0%] (TRUE_VALUE,EXECUTABLE) ;; 10 [1.0%] (FALSE_VALUE,EXECUTABLE) ;; basic block 9, loop depth 4, count 0, freq 9798, maybe hot ;; prev block 8, next block 10, flags: (NEW, REACHABLE) ;; pred: 8 [99.0%] (TRUE_VALUE,EXECUTABLE) goto <bb 6>; ;; succ: 6 [100.0%] (FALLTHRU,DFS_BACK) ;; basic block 10, loop depth 3, count 0, freq 103, maybe hot ;; prev block 9, next block 11, flags: (NEW, REACHABLE) ;; pred: 8 [1.0%] (FALSE_VALUE,EXECUTABLE) # .MEM_77 = PHI <.MEM_25(8)> # RANGE [0, 7] _28 = (sizetype) off1_93; PT = { D.2877 } (glob) # _29 = &u1D.2877.bufD.2874[_28]; # RANGE [0, 7] _30 = (sizetype) off2_91; PT = { D.2878 } (glob) # _31 = &u2D.2878.bufD.2874[_30]; # RANGE [1, 79] _32 = (long unsigned intD.11) len_89; # .MEM_33 = VDEF <.MEM_77> PT = { D.2877 } (glob) # # USE = nonlocal null # CLB = nonlocal null p_34 = memcpyD.684 (_29, _31, _32); if (_29 != p_34) goto <bb 11>; else goto <bb 12>; ;; succ: 11 [2.0%] (TRUE_VALUE,EXECUTABLE) ;; 12 [98.0%] (FALSE_VALUE,EXECUTABLE) ;; basic block 11, loop depth 0, count 0, freq 2 ;; prev block 10, next block 12, flags: (NEW, REACHABLE) ;; pred: 10 [2.0%] (TRUE_VALUE,EXECUTABLE) # VUSE <.MEM_33> # USE = nonlocal null # CLB = nonlocal null abortD.848 (); ;; succ: ;; basic block 12, loop depth 3, count 0, freq 101, maybe hot ;; prev block 11, next block 13, flags: (NEW, REACHABLE) ;; pred: 10 [98.0%] (FALSE_VALUE,EXECUTABLE) # # RANGE [0, 2147483647] i_45 = PHI <0(10)> # PT = { D.2877 } (glob) # q_46 = PHI <&u1D.2877.bufD.2874(10)> if (off1_93 > 0) goto <bb 13>; else goto <bb 19>; ;; succ: 13 [95.5%] (TRUE_VALUE,EXECUTABLE) ;; 19 [4.5%] (FALSE_VALUE,EXECUTABLE) ;; basic block 13, loop depth 3, count 0, freq 96, maybe hot ;; prev block 12, next block 14, flags: (NEW, REACHABLE) ;; pred: 12 [95.5%] (TRUE_VALUE,EXECUTABLE) # VUSE <.MEM_33> _47 = MEM[(charD.8 *)&u1D.2877]; if (_47 != 97) goto <bb 16>; else goto <bb 17>; ;; succ: 16 [4.5%] (TRUE_VALUE,EXECUTABLE) ;; 17 [95.5%] (FALSE_VALUE,EXECUTABLE) ;; basic block 14, loop depth 4, count 0, freq 1000, maybe hot ;; prev block 13, next block 15, flags: (NEW, REACHABLE) ;; pred: 18 [95.5%] (TRUE_VALUE,EXECUTABLE) # VUSE <.MEM_33> _35 = *q_37; if (_35 != 97) goto <bb 16>; else goto <bb 15>; ;; succ: 16 [4.5%] (TRUE_VALUE,EXECUTABLE) ;; 15 [95.5%] (FALSE_VALUE,EXECUTABLE) ;; basic block 15, loop depth 4, count 0, freq 955, maybe hot ;; prev block 14, next block 16, flags: (NEW, REACHABLE) ;; pred: 14 [95.5%] (FALSE_VALUE,EXECUTABLE) goto <bb 18>; ;; succ: 18 [100.0%] (FALLTHRU,DFS_BACK) ;; basic block 16, loop depth 0, count 0, freq 49 ;; prev block 15, next block 17, flags: (NEW, REACHABLE) ;; pred: 14 [4.5%] (TRUE_VALUE,EXECUTABLE) ;; 13 [4.5%] (TRUE_VALUE,EXECUTABLE) # VUSE <.MEM_33> # USE = nonlocal null # CLB = nonlocal null abortD.848 (); ;; succ: ;; basic block 17, loop depth 3, count 0, freq 92, maybe hot ;; prev block 16, next block 18, flags: (NEW, REACHABLE) ;; pred: 13 [95.5%] (FALSE_VALUE,EXECUTABLE) ;; succ: 18 [100.0%] (FALLTHRU) ;; basic block 18, loop depth 4, count 0, freq 1046, maybe hot ;; prev block 17, next block 19, flags: (NEW, REACHABLE) ;; pred: 15 [100.0%] (FALLTHRU,DFS_BACK) ;; 17 [100.0%] (FALLTHRU) # # RANGE [0, 2147483647] i_85 = PHI <i_36(15), 0(17)> # PT = { D.2877 } (glob) # q_83 = PHI <q_37(15), &u1D.2877.bufD.2874(17)> # RANGE [1, 7] i_36 = i_85 + 1; PT = { D.2877 } (glob) # q_37 = q_83 + 1; if (i_36 < off1_93) goto <bb 14>; else goto <bb 19>; ;; succ: 14 [95.5%] (TRUE_VALUE,EXECUTABLE) ;; 19 [4.5%] (FALSE_VALUE,EXECUTABLE) ;; basic block 19, loop depth 3, count 0, freq 52 ;; prev block 18, next block 20, flags: (NEW, REACHABLE) ;; pred: 18 [4.5%] (FALSE_VALUE,EXECUTABLE) ;; 12 [4.5%] (FALSE_VALUE,EXECUTABLE) # PT = { D.2877 } (glob) # q_56 = PHI <q_37(18), &u1D.2877.bufD.2874(12)> # RANGE [0, 7] _38 = (charD.8) off2_91; # RANGE [65, 72] c_39 = _38 + 65; goto <bb 21>; ;; succ: 21 [100.0%] (FALLTHRU) ;; basic block 20, loop depth 4, count 0, freq 508, maybe hot ;; prev block 19, next block 21, flags: (NEW, REACHABLE) ;; pred: 25 [95.1%] (TRUE_VALUE,EXECUTABLE) ;; succ: 21 [100.0%] (FALLTHRU,DFS_BACK) ;; basic block 21, loop depth 4, count 0, freq 560, maybe hot ;; prev block 20, next block 22, flags: (NEW, REACHABLE) ;; pred: 20 [100.0%] (FALLTHRU,DFS_BACK) ;; 19 [100.0%] (FALLTHRU) # # RANGE [0, 2147483647] i_94 = PHI <i_41(20), 0(19)> # PT = { D.2877 } (glob) # q_70 = PHI <q_42(20), q_56(19)> # c_64 = PHI <c_43(20), c_39(19)> if (c_64 > 95) goto <bb 23>; else goto <bb 22>; ;; succ: 23 [50.0%] (TRUE_VALUE,EXECUTABLE) ;; 22 [50.0%] (FALSE_VALUE,EXECUTABLE) ;; basic block 22, loop depth 4, count 0, freq 280, maybe hot ;; prev block 21, next block 23, flags: (NEW, REACHABLE) ;; pred: 21 [50.0%] (FALSE_VALUE,EXECUTABLE) ;; succ: 23 [100.0%] (FALLTHRU,EXECUTABLE) ;; basic block 23, loop depth 4, count 0, freq 560, maybe hot ;; prev block 22, next block 24, flags: (NEW, REACHABLE) ;; pred: 22 [100.0%] (FALLTHRU,EXECUTABLE) ;; 21 [50.0%] (TRUE_VALUE,EXECUTABLE) # c_13 = PHI <c_64(22), 65(21)> # VUSE <.MEM_33> _40 = *q_70; if (_40 != c_13) goto <bb 24>; else goto <bb 25>; ;; succ: 24 [4.5%] (TRUE_VALUE,EXECUTABLE) ;; 25 [95.5%] (FALSE_VALUE,EXECUTABLE) ;; basic block 24, loop depth 0, count 0, freq 25 ;; prev block 23, next block 25, flags: (NEW, REACHABLE) ;; pred: 23 [4.5%] (TRUE_VALUE,EXECUTABLE) # VUSE <.MEM_33> # USE = nonlocal null # CLB = nonlocal null abortD.848 (); ;; succ: ;; basic block 25, loop depth 4, count 0, freq 535, maybe hot ;; prev block 24, next block 26, flags: (NEW, REACHABLE) ;; pred: 23 [95.5%] (FALSE_VALUE,EXECUTABLE) # RANGE [1, 79] i_41 = i_94 + 1; PT = { D.2877 } (glob) # q_42 = q_70 + 1; # RANGE [0, 255] c_43 = _40 + 1; if (i_41 < len_89) goto <bb 20>; else goto <bb 26>; ;; succ: 20 [95.1%] (TRUE_VALUE,EXECUTABLE) ;; 26 [4.9%] (FALSE_VALUE,EXECUTABLE) ;; basic block 26, loop depth 3, count 0, freq 26 ;; prev block 25, next block 27, flags: (NEW, REACHABLE) ;; pred: 25 [4.9%] (FALSE_VALUE,EXECUTABLE) # PT = { D.2877 } (glob) # q_52 = PHI <q_42(25)> # VUSE <.MEM_33> _54 = *q_52; if (_54 != 97) goto <bb 34>; else goto <bb 27>; ;; succ: 34 [4.5%] (TRUE_VALUE,EXECUTABLE) ;; 27 [95.5%] (FALSE_VALUE,EXECUTABLE) ;; basic block 27, loop depth 3, count 0, freq 25 ;; prev block 26, next block 28, flags: (NEW, REACHABLE) ;; pred: 26 [95.5%] (FALSE_VALUE,EXECUTABLE) # VUSE <.MEM_33> _60 = MEM[(charD.8 *)q_52 + 1B]; if (_60 != 97) goto <bb 34>; else goto <bb 28>; ;; succ: 34 [4.5%] (TRUE_VALUE,EXECUTABLE) ;; 28 [95.5%] (FALSE_VALUE,EXECUTABLE) ;; basic block 28, loop depth 3, count 0, freq 24 ;; prev block 27, next block 29, flags: (NEW, REACHABLE) ;; pred: 27 [95.5%] (FALSE_VALUE,EXECUTABLE) # VUSE <.MEM_33> _66 = MEM[(charD.8 *)q_52 + 2B]; if (_66 != 97) goto <bb 34>; else goto <bb 29>; ;; succ: 34 [4.5%] (TRUE_VALUE,EXECUTABLE) ;; 29 [95.5%] (FALSE_VALUE,EXECUTABLE) ;; basic block 29, loop depth 3, count 0, freq 23 ;; prev block 28, next block 30, flags: (NEW, REACHABLE) ;; pred: 28 [95.5%] (FALSE_VALUE,EXECUTABLE) # VUSE <.MEM_33> _72 = MEM[(charD.8 *)q_52 + 3B]; if (_72 != 97) goto <bb 34>; else goto <bb 30>; ;; succ: 34 [4.5%] (TRUE_VALUE,EXECUTABLE) ;; 30 [95.5%] (FALSE_VALUE,EXECUTABLE) ;; basic block 30, loop depth 3, count 0, freq 22 ;; prev block 29, next block 31, flags: (NEW, REACHABLE) ;; pred: 29 [95.5%] (FALSE_VALUE,EXECUTABLE) # VUSE <.MEM_33> _78 = MEM[(charD.8 *)q_52 + 4B]; if (_78 != 97) goto <bb 34>; else goto <bb 31>; ;; succ: 34 [4.5%] (TRUE_VALUE,EXECUTABLE) ;; 31 [95.5%] (FALSE_VALUE,EXECUTABLE) ;; basic block 31, loop depth 3, count 0, freq 21 ;; prev block 30, next block 32, flags: (NEW, REACHABLE) ;; pred: 30 [95.5%] (FALSE_VALUE,EXECUTABLE) # VUSE <.MEM_33> _84 = MEM[(charD.8 *)q_52 + 5B]; if (_84 != 97) goto <bb 34>; else goto <bb 32>; ;; succ: 34 [4.5%] (TRUE_VALUE,EXECUTABLE) ;; 32 [95.5%] (FALSE_VALUE,EXECUTABLE) ;; basic block 32, loop depth 3, count 0, freq 20 ;; prev block 31, next block 33, flags: (NEW, REACHABLE) ;; pred: 31 [95.5%] (FALSE_VALUE,EXECUTABLE) # VUSE <.MEM_33> _90 = MEM[(charD.8 *)q_52 + 6B]; if (_90 != 97) goto <bb 34>; else goto <bb 33>; ;; succ: 34 [4.5%] (TRUE_VALUE,EXECUTABLE) ;; 33 [95.5%] (FALSE_VALUE,EXECUTABLE) ;; basic block 33, loop depth 3, count 0, freq 19 ;; prev block 32, next block 34, flags: (NEW, REACHABLE) ;; pred: 32 [95.5%] (FALSE_VALUE,EXECUTABLE) # VUSE <.MEM_33> _96 = MEM[(charD.8 *)q_52 + 7B]; if (_96 != 97) goto <bb 34>; else goto <bb 35>; ;; succ: 34 [4.5%] (TRUE_VALUE,EXECUTABLE) ;; 35 [95.5%] (FALSE_VALUE,EXECUTABLE) ;; basic block 34, loop depth 0, count 0, freq 7 ;; prev block 33, next block 35, flags: (NEW, REACHABLE) ;; pred: 33 [4.5%] (TRUE_VALUE,EXECUTABLE) ;; 26 [4.5%] (TRUE_VALUE,EXECUTABLE) ;; 27 [4.5%] (TRUE_VALUE,EXECUTABLE) ;; 28 [4.5%] (TRUE_VALUE,EXECUTABLE) ;; 29 [4.5%] (TRUE_VALUE,EXECUTABLE) ;; 30 [4.5%] (TRUE_VALUE,EXECUTABLE) ;; 31 [4.5%] (TRUE_VALUE,EXECUTABLE) ;; 32 [4.5%] (TRUE_VALUE,EXECUTABLE) # VUSE <.MEM_33> # USE = nonlocal null # CLB = nonlocal null abortD.848 (); ;; succ: ;; basic block 35, loop depth 3, count 0, freq 19 ;; prev block 34, next block 36, flags: (NEW, REACHABLE) ;; pred: 33 [95.5%] (FALSE_VALUE,EXECUTABLE) # RANGE [2, 80] len_48 = len_89 + 1; # RANGE [1, 80] len.3_22 = (unsigned intD.10) len_48; if (len.3_22 != 80) goto <bb 36>; else goto <bb 37>; ;; succ: 36 [98.8%] (TRUE_VALUE,EXECUTABLE) ;; 37 [1.2%] (FALSE_VALUE,EXECUTABLE) ;; basic block 36, loop depth 3, count 0, freq 19 ;; prev block 35, next block 37, flags: (NEW, REACHABLE) ;; pred: 35 [98.8%] (TRUE_VALUE,EXECUTABLE) goto <bb 5>; ;; succ: 5 [100.0%] (FALLTHRU,DFS_BACK) ;; basic block 37, loop depth 2, count 0, freq 1 ;; prev block 36, next block 38, flags: (NEW, REACHABLE) ;; pred: 35 [1.2%] (FALSE_VALUE,EXECUTABLE) # .MEM_73 = PHI <.MEM_33(35)> # RANGE [1, 8] off2_49 = off2_91 + 1; # RANGE [0, 8] off2.4_21 = (unsigned intD.10) off2_49; if (off2.4_21 != 8) goto <bb 38>; else goto <bb 39>; ;; succ: 38 [88.9%] (TRUE_VALUE,EXECUTABLE) ;; 39 [11.1%] (FALSE_VALUE,EXECUTABLE) ;; basic block 38, loop depth 2, count 0, freq 1 ;; prev block 37, next block 39, flags: (NEW, REACHABLE) ;; pred: 37 [88.9%] (TRUE_VALUE,EXECUTABLE) goto <bb 4>; ;; succ: 4 [100.0%] (FALLTHRU,DFS_BACK) ;; basic block 39, loop depth 1, count 0, freq 11 ;; prev block 38, next block 40, flags: (NEW, REACHABLE) ;; pred: 37 [11.1%] (FALSE_VALUE,EXECUTABLE) # .MEM_69 = PHI <.MEM_73(37)> # RANGE [1, 8] off1_50 = off1_93 + 1; # RANGE [0, 8] off1.5_20 = (unsigned intD.10) off1_50; if (off1.5_20 != 8) goto <bb 40>; else goto <bb 41>; ;; succ: 40 [88.9%] (TRUE_VALUE,EXECUTABLE) ;; 41 [11.1%] (FALSE_VALUE,EXECUTABLE) ;; basic block 40, loop depth 1, count 0, freq 10 ;; prev block 39, next block 41, flags: (NEW, REACHABLE) ;; pred: 39 [88.9%] (TRUE_VALUE,EXECUTABLE) goto <bb 3>; ;; succ: 3 [100.0%] (FALLTHRU,DFS_BACK) ;; basic block 41, loop depth 0, count 0, freq 12 ;; prev block 40, next block 1, flags: (NEW, REACHABLE) ;; pred: 39 [11.1%] (FALSE_VALUE,EXECUTABLE) # .MEM_65 = PHI <.MEM_69(39)> # VUSE <.MEM_65> # USE = nonlocal null # CLB = nonlocal null exitD.898 (0); ;; succ: } ;; Function main (main, funcdef_no=0, decl_uid=2879, symbol_order=2) (executed once) Pass statistics: ---------------- ;; 8 loops found ;; ;; Loop 0 ;; header 0, latch 1 ;; depth 0, outer -1 ;; nodes: 0 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 ;; ;; Loop 1 ;; header 4, latch 44 ;; depth 1, outer 0 ;; nodes: 4 44 43 41 39 6 42 5 37 36 35 34 33 32 31 30 29 27 26 25 24 23 22 16 14 12 8 40 7 11 10 13 9 19 21 17 18 ;; ;; Loop 2 ;; header 6, latch 42 ;; depth 2, outer 1 ;; nodes: 6 42 41 39 37 36 35 34 33 32 31 30 29 27 26 25 24 23 22 16 14 12 8 40 7 11 10 13 9 19 21 17 18 ;; ;; Loop 3 ;; header 8, latch 40 ;; depth 3, outer 2 ;; nodes: 8 40 39 37 36 35 34 33 32 31 30 29 27 26 25 24 23 22 16 14 12 11 10 13 9 19 21 17 18 ;; ;; Loop 6 ;; header 25, latch 24 ;; depth 4, outer 3 ;; nodes: 25 24 29 27 26 ;; ;; Loop 5 ;; header 22, latch 19 ;; depth 4, outer 3 ;; nodes: 22 19 18 ;; ;; Loop 4 ;; header 10, latch 13 ;; depth 4, outer 3 ;; nodes: 10 13 12 11 ;; 2 succs { 3 45 } ;; 3 succs { 4 } ;; 4 succs { 5 43 } ;; 5 succs { 6 } ;; 6 succs { 7 41 } ;; 7 succs { 8 } ;; 8 succs { 9 14 } ;; 9 succs { 10 } ;; 10 succs { 12 11 } ;; 11 succs { 12 } ;; 12 succs { 13 14 } ;; 13 succs { 10 } ;; 14 succs { 15 16 } ;; 15 succs { } ;; 16 succs { 17 23 } ;; 17 succs { 20 21 } ;; 18 succs { 20 19 } ;; 19 succs { 22 } ;; 20 succs { } ;; 21 succs { 22 } ;; 22 succs { 18 23 } ;; 23 succs { 25 } ;; 24 succs { 25 } ;; 25 succs { 27 26 } ;; 26 succs { 27 } ;; 27 succs { 28 29 } ;; 28 succs { } ;; 29 succs { 24 30 } ;; 30 succs { 38 31 } ;; 31 succs { 38 32 } ;; 32 succs { 38 33 } ;; 33 succs { 38 34 } ;; 34 succs { 38 35 } ;; 35 succs { 38 36 } ;; 36 succs { 38 37 } ;; 37 succs { 38 39 } ;; 38 succs { } ;; 39 succs { 40 41 } ;; 40 succs { 8 } ;; 41 succs { 42 43 } ;; 42 succs { 6 } ;; 43 succs { 44 45 } ;; 44 succs { 4 } ;; 45 succs { } Optimizing block #0 Optimizing block #2 Optimizing statement off1.5_92 = 0; LKUP STMT off1.5_92 = 0 off1.5_92 = 0; ==== ASGN off1.5_92 = 0 Optimizing statement if (off1.5_92 != 8) Replaced 'off1.5_92' with constant '0' Folded to: if (1 != 0) LKUP STMT 1 ne_expr 0 if (1 != 0) Optimizing block #3 1>>> COND 1 = 1 ne_expr 0 1>>> COND 0 = 1 eq_expr 0 Optimizing block #4 LKUP STMT off1_93 = PHI <off1_50, 0> off1_93 = PHI <off1_50(44), 0(3)> 2>>> STMT off1_93 = PHI <off1_50, 0> off1_93 = PHI <off1_50(44), 0(3)> LKUP STMT .MEM_67 = PHI <.MEM_69, .MEM_19(D)> .MEM_67 = PHI <.MEM_69(44), .MEM_19(D)(3)> 2>>> STMT .MEM_67 = PHI <.MEM_69, .MEM_19(D)> .MEM_67 = PHI <.MEM_69(44), .MEM_19(D)(3)> <<<< STMT .MEM_67 = PHI <.MEM_69, .MEM_19(D)> .MEM_67 = PHI <.MEM_69(44), .MEM_19(D)(3)> <<<< STMT off1_93 = PHI <off1_50, 0> off1_93 = PHI <off1_50(44), 0(3)> Optimizing statement off2.4_86 = 0; LKUP STMT off2.4_86 = 0 off2.4_86 = 0; ==== ASGN off2.4_86 = 0 Optimizing statement if (off2.4_86 != 8) Replaced 'off2.4_86' with constant '0' Folded to: if (1 != 0) LKUP STMT 1 ne_expr 0 if (1 != 0) FIND: 1 Replaced redundant expr '1 != 0' with '1' Optimizing block #5 Optimizing block #6 LKUP STMT off2_91 = PHI <off2_49, 0> off2_91 = PHI <off2_49(42), 0(5)> 2>>> STMT off2_91 = PHI <off2_49, 0> off2_91 = PHI <off2_49(42), 0(5)> LKUP STMT .MEM_71 = PHI <.MEM_73, .MEM_67> .MEM_71 = PHI <.MEM_73(42), .MEM_67(5)> 2>>> STMT .MEM_71 = PHI <.MEM_73, .MEM_67> .MEM_71 = PHI <.MEM_73(42), .MEM_67(5)> <<<< STMT .MEM_71 = PHI <.MEM_73, .MEM_67> .MEM_71 = PHI <.MEM_73(42), .MEM_67(5)> <<<< STMT off2_91 = PHI <off2_49, 0> off2_91 = PHI <off2_49(42), 0(5)> Optimizing statement len.3_62 = 1; LKUP STMT len.3_62 = 1 len.3_62 = 1; ==== ASGN len.3_62 = 1 Optimizing statement if (len.3_62 != 80) Replaced 'len.3_62' with constant '1' Folded to: if (1 != 0) LKUP STMT 1 ne_expr 0 if (1 != 0) FIND: 1 Replaced redundant expr '1 != 0' with '1' Optimizing block #7 Optimizing block #8 LKUP STMT len_89 = PHI <len_48, 1> len_89 = PHI <len_48(40), 1(7)> 2>>> STMT len_89 = PHI <len_48, 1> len_89 = PHI <len_48(40), 1(7)> LKUP STMT .MEM_75 = PHI <.MEM_33, .MEM_71> .MEM_75 = PHI <.MEM_33(40), .MEM_71(7)> 2>>> STMT .MEM_75 = PHI <.MEM_33, .MEM_71> .MEM_75 = PHI <.MEM_33(40), .MEM_71(7)> <<<< STMT .MEM_75 = PHI <.MEM_33, .MEM_71> .MEM_75 = PHI <.MEM_33(40), .MEM_71(7)> <<<< STMT len_89 = PHI <len_48, 1> len_89 = PHI <len_48(40), 1(7)> Optimizing statement i.1_95 = 0; LKUP STMT i.1_95 = 0 i.1_95 = 0; ==== ASGN i.1_95 = 0 Optimizing statement if (i.1_95 != 96) Replaced 'i.1_95' with constant '0' Folded to: if (1 != 0) LKUP STMT 1 ne_expr 0 if (1 != 0) FIND: 1 Replaced redundant expr '1 != 0' with '1' Optimizing block #9 Optimizing block #10 LKUP STMT i_87 = PHI <i_26, 0> i_87 = PHI <i_26(13), 0(9)> 2>>> STMT i_87 = PHI <i_26, 0> i_87 = PHI <i_26(13), 0(9)> LKUP STMT c_81 = PHI <c_27, 65> c_81 = PHI <c_27(13), 65(9)> 2>>> STMT c_81 = PHI <c_27, 65> c_81 = PHI <c_27(13), 65(9)> LKUP STMT .MEM_79 = PHI <.MEM_25, .MEM_75> .MEM_79 = PHI <.MEM_25(13), .MEM_75(9)> 2>>> STMT .MEM_79 = PHI <.MEM_25, .MEM_75> .MEM_79 = PHI <.MEM_25(13), .MEM_75(9)> <<<< STMT .MEM_79 = PHI <.MEM_25, .MEM_75> .MEM_79 = PHI <.MEM_25(13), .MEM_75(9)> <<<< STMT c_81 = PHI <c_27, 65> c_81 = PHI <c_27(13), 65(9)> <<<< STMT i_87 = PHI <i_26, 0> i_87 = PHI <i_26(13), 0(9)> Optimizing statement u1.buf[i_87] = 97; LKUP STMT u1.buf[i_87] = 97 u1.buf[i_87] = 97; LKUP STMT 97 = u1.buf[i_87] 97 = u1.buf[i_87]; LKUP STMT 97 = u1.buf[i_87] 97 = u1.buf[i_87]; 2>>> STMT 97 = u1.buf[i_87] 97 = u1.buf[i_87]; Optimizing statement if (c_81 > 95) LKUP STMT c_81 gt_expr 95 if (c_81 > 95) Optimizing block #11 1>>> COND 1 = c_81 le_expr 95 1>>> COND 0 = c_81 gt_expr 95 LKUP STMT i_26 = i_87 plus_expr 1 i_26 = i_87 + 1; LKUP STMT c_27 = c_81 plus_expr 1 c_27 = c_81 + 1; LKUP STMT i.1_23 = nop_expr i_26 i.1_23 = (unsigned int) i_26; LKUP STMT i.1_23 ne_expr 96 if (i.1_23 != 96) <<<< COND 0 = c_81 gt_expr 95 <<<< COND 1 = c_81 le_expr 95 Optimizing block #12 LKUP STMT c_11 = PHI <c_81, 65> c_11 = PHI <c_81(11), 65(10)> 2>>> STMT c_11 = PHI <c_81, 65> c_11 = PHI <c_81(11), 65(10)> <<<< STMT c_11 = PHI <c_81, 65> c_11 = PHI <c_81(11), 65(10)> Optimizing statement u2.buf[i_87] = c_11; LKUP STMT u2.buf[i_87] = c_11 u2.buf[i_87] = c_11; LKUP STMT c_11 = u2.buf[i_87] c_11 = u2.buf[i_87]; LKUP STMT c_11 = u2.buf[i_87] c_11 = u2.buf[i_87]; 2>>> STMT c_11 = u2.buf[i_87] c_11 = u2.buf[i_87]; Optimizing statement i_26 = i_87 + 1; LKUP STMT i_26 = i_87 plus_expr 1 i_26 = i_87 + 1; Optimizing statement c_27 = c_11 + 1; LKUP STMT c_27 = c_11 plus_expr 1 c_27 = c_11 + 1; 2>>> STMT c_27 = c_11 plus_expr 1 c_27 = c_11 + 1; Optimizing statement i.1_23 = (unsigned int) i_26; LKUP STMT i.1_23 = nop_expr i_26 i.1_23 = (unsigned int) i_26; 2>>> STMT i.1_23 = nop_expr i_26 i.1_23 = (unsigned int) i_26; Optimizing statement if (i.1_23 != 96) LKUP STMT i.1_23 ne_expr 96 if (i.1_23 != 96) 0>>> COPY i.1_23 = 96 <<<< COPY i.1_23 = 96 Optimizing block #13 1>>> COND 1 = i.1_23 ne_expr 96 1>>> COND 0 = i.1_23 eq_expr 96 LKUP STMT c_27 gt_expr 95 if (c_27 > 95) <<<< COND 0 = i.1_23 eq_expr 96 <<<< COND 1 = i.1_23 ne_expr 96 0>>> COPY i.1_23 = 96 1>>> COND 1 = i.1_23 le_expr 96 1>>> COND 1 = i.1_23 ge_expr 96 1>>> COND 1 = i.1_23 eq_expr 96 1>>> COND 0 = i.1_23 ne_expr 96 LKUP STMT _28 = nop_expr off1_93 _28 = (sizetype) off1_93; LKUP STMT _29 = &u1.buf[_28] _29 = &u1.buf[_28]; LKUP STMT _30 = nop_expr off2_91 _30 = (sizetype) off2_91; LKUP STMT _31 = &u2.buf[_30] _31 = &u2.buf[_30]; LKUP STMT _32 = nop_expr len_89 _32 = (long unsigned int) len_89; LKUP STMT p_34 = memcpy (_29, _31, _32) p_34 = memcpy (_29, _31, _32); LKUP STMT _29 ne_expr p_34 if (_29 != p_34) <<<< COND 0 = i.1_23 ne_expr 96 <<<< COND 1 = i.1_23 eq_expr 96 <<<< COND 1 = i.1_23 ge_expr 96 <<<< COND 1 = i.1_23 le_expr 96 <<<< STMT i.1_23 = nop_expr i_26 i.1_23 = (unsigned int) i_26; <<<< STMT c_27 = c_11 plus_expr 1 c_27 = c_11 + 1; <<<< STMT c_11 = u2.buf[i_87] c_11 = u2.buf[i_87]; 1>>> COND 1 = c_81 ge_expr 95 1>>> COND 1 = c_81 ne_expr 95 1>>> COND 1 = c_81 gt_expr 95 1>>> COND 0 = c_81 le_expr 95 LKUP STMT i_26 = i_87 plus_expr 1 i_26 = i_87 + 1; LKUP STMT i.1_23 = nop_expr i_26 i.1_23 = (unsigned int) i_26; LKUP STMT i.1_23 ne_expr 96 if (i.1_23 != 96) <<<< COND 0 = c_81 le_expr 95 <<<< COND 1 = c_81 gt_expr 95 <<<< COND 1 = c_81 ne_expr 95 <<<< COND 1 = c_81 ge_expr 95 <<<< STMT 97 = u1.buf[i_87] 97 = u1.buf[i_87]; Registering jump thread: (9, 10) incoming edge; (10, 11) normal; (11, 12) nocopy; Optimizing block #14 LKUP STMT .MEM_77 = PHI <.MEM_25, .MEM_75> .MEM_77 = PHI <.MEM_25(12), .MEM_75(8)> 2>>> STMT .MEM_77 = PHI <.MEM_25, .MEM_75> .MEM_77 = PHI <.MEM_25(12), .MEM_75(8)> <<<< STMT .MEM_77 = PHI <.MEM_25, .MEM_75> .MEM_77 = PHI <.MEM_25(12), .MEM_75(8)> Optimizing statement _28 = (sizetype) off1_93; LKUP STMT _28 = nop_expr off1_93 _28 = (sizetype) off1_93; 2>>> STMT _28 = nop_expr off1_93 _28 = (sizetype) off1_93; Optimizing statement _29 = &u1.buf[_28]; LKUP STMT _29 = &u1.buf[_28] _29 = &u1.buf[_28]; 2>>> STMT _29 = &u1.buf[_28] _29 = &u1.buf[_28]; Optimizing statement _30 = (sizetype) off2_91; LKUP STMT _30 = nop_expr off2_91 _30 = (sizetype) off2_91; 2>>> STMT _30 = nop_expr off2_91 _30 = (sizetype) off2_91; Optimizing statement _31 = &u2.buf[_30]; LKUP STMT _31 = &u2.buf[_30] _31 = &u2.buf[_30]; 2>>> STMT _31 = &u2.buf[_30] _31 = &u2.buf[_30]; Optimizing statement _32 = (long unsigned int) len_89; LKUP STMT _32 = nop_expr len_89 _32 = (long unsigned int) len_89; 2>>> STMT _32 = nop_expr len_89 _32 = (long unsigned int) len_89; Optimizing statement p_34 = memcpy (_29, _31, _32); Optimizing statement if (_29 != p_34) LKUP STMT _29 ne_expr p_34 if (_29 != p_34) 0>>> COPY _29 = p_34 <<<< COPY _29 = p_34 Optimizing block #16 0>>> COPY p_34 = _29 1>>> COND 1 = _29 le_expr p_34 1>>> COND 1 = _29 ge_expr p_34 1>>> COND 1 = _29 eq_expr p_34 1>>> COND 0 = _29 ne_expr p_34 LKUP STMT i_45 = PHI <0> i_45 = PHI <0(14)> 2>>> STMT i_45 = PHI <0> i_45 = PHI <0(14)> LKUP STMT q_46 = PHI <&u1.buf> q_46 = PHI <&u1.buf(14)> 2>>> STMT q_46 = PHI <&u1.buf> q_46 = PHI <&u1.buf(14)> <<<< STMT q_46 = PHI <&u1.buf> q_46 = PHI <&u1.buf(14)> <<<< STMT i_45 = PHI <0> i_45 = PHI <0(14)> Optimizing statement if (i_45 < off1_93) Replaced 'i_45' with constant '0' Folded to: if (off1_93 > 0) LKUP STMT off1_93 gt_expr 0 if (off1_93 > 0) Optimizing block #17 1>>> COND 1 = off1_93 ge_expr 0 1>>> COND 1 = off1_93 ne_expr 0 1>>> COND 1 = off1_93 gt_expr 0 1>>> COND 0 = off1_93 le_expr 0 Optimizing statement _47 = *q_46; Replaced 'q_46' with constant '&u1D.2877.bufD.2874' Folded to: _47 = MEM[(char *)&u1]; LKUP STMT _47 = MEM[(char *)&u1] _47 = MEM[(char *)&u1]; 2>>> STMT _47 = MEM[(char *)&u1] _47 = MEM[(char *)&u1]; Optimizing statement if (_47 != 97) LKUP STMT _47 ne_expr 97 if (_47 != 97) Optimizing block #21 0>>> COPY _47 = 97 1>>> COND 1 = _47 le_expr 97 1>>> COND 1 = _47 ge_expr 97 1>>> COND 1 = _47 eq_expr 97 1>>> COND 0 = _47 ne_expr 97 Optimizing block #22 LKUP STMT i_85 = PHI <i_36, 0> i_85 = PHI <i_36(19), 0(21)> 2>>> STMT i_85 = PHI <i_36, 0> i_85 = PHI <i_36(19), 0(21)> LKUP STMT q_83 = PHI <q_37, &u1.buf> q_83 = PHI <q_37(19), &u1.buf(21)> 2>>> STMT q_83 = PHI <q_37, &u1.buf> q_83 = PHI <q_37(19), &u1.buf(21)> <<<< STMT q_83 = PHI <q_37, &u1.buf> q_83 = PHI <q_37(19), &u1.buf(21)> <<<< STMT i_85 = PHI <i_36, 0> i_85 = PHI <i_36(19), 0(21)> Optimizing statement i_36 = i_85 + 1; LKUP STMT i_36 = i_85 plus_expr 1 i_36 = i_85 + 1; Optimizing statement q_37 = q_83 + 1; LKUP STMT q_37 = q_83 pointer_plus_expr 1 q_37 = q_83 + 1; Optimizing statement if (i_36 < off1_93) LKUP STMT i_36 lt_expr off1_93 if (i_36 < off1_93) Optimizing block #18 1>>> COND 1 = i_36 le_expr off1_93 1>>> COND 1 = i_36 ne_expr off1_93 1>>> COND 1 = i_36 lt_expr off1_93 1>>> COND 0 = i_36 ge_expr off1_93 Optimizing statement _35 = *q_37; LKUP STMT _35 = *q_37 _35 = *q_37; 2>>> STMT _35 = *q_37 _35 = *q_37; Optimizing statement if (_35 != 97) LKUP STMT _35 ne_expr 97 if (_35 != 97) Optimizing block #19 0>>> COPY _35 = 97 1>>> COND 1 = _35 le_expr 97 1>>> COND 1 = _35 ge_expr 97 1>>> COND 1 = _35 eq_expr 97 1>>> COND 0 = _35 ne_expr 97 <<<< COND 0 = _35 ne_expr 97 <<<< COND 1 = _35 eq_expr 97 <<<< COND 1 = _35 ge_expr 97 <<<< COND 1 = _35 le_expr 97 <<<< COPY _35 = 97 <<<< STMT _35 = *q_37 _35 = *q_37; <<<< COND 0 = i_36 ge_expr off1_93 <<<< COND 1 = i_36 lt_expr off1_93 <<<< COND 1 = i_36 ne_expr off1_93 <<<< COND 1 = i_36 le_expr off1_93 LKUP STMT off1_93 gt_expr 1 if (off1_93 > 1) <<<< COND 0 = _47 ne_expr 97 <<<< COND 1 = _47 eq_expr 97 <<<< COND 1 = _47 ge_expr 97 <<<< COND 1 = _47 le_expr 97 <<<< COPY _47 = 97 Optimizing block #20 Optimizing statement abort (); <<<< STMT _47 = MEM[(char *)&u1] _47 = MEM[(char *)&u1]; <<<< COND 0 = off1_93 le_expr 0 <<<< COND 1 = off1_93 gt_expr 0 <<<< COND 1 = off1_93 ne_expr 0 <<<< COND 1 = off1_93 ge_expr 0 Optimizing block #23 LKUP STMT q_56 = PHI <q_37, &u1.buf> q_56 = PHI <q_37(22), &u1.buf(16)> 2>>> STMT q_56 = PHI <q_37, &u1.buf> q_56 = PHI <q_37(22), &u1.buf(16)> <<<< STMT q_56 = PHI <q_37, &u1.buf> q_56 = PHI <q_37(22), &u1.buf(16)> Optimizing statement _38 = (char) off2_91; LKUP STMT _38 = convert_expr off2_91 _38 = (char) off2_91; 2>>> STMT _38 = convert_expr off2_91 _38 = (char) off2_91; Optimizing statement c_39 = _38 + 65; LKUP STMT c_39 = _38 plus_expr 65 c_39 = _38 + 65; 2>>> STMT c_39 = _38 plus_expr 65 c_39 = _38 + 65; Optimizing block #25 LKUP STMT i_94 = PHI <i_41, 0> i_94 = PHI <i_41(24), 0(23)> 2>>> STMT i_94 = PHI <i_41, 0> i_94 = PHI <i_41(24), 0(23)> LKUP STMT q_70 = PHI <q_42, q_56> q_70 = PHI <q_42(24), q_56(23)> 2>>> STMT q_70 = PHI <q_42, q_56> q_70 = PHI <q_42(24), q_56(23)> LKUP STMT c_64 = PHI <c_43, c_39> c_64 = PHI <c_43(24), c_39(23)> 2>>> STMT c_64 = PHI <c_43, c_39> c_64 = PHI <c_43(24), c_39(23)> <<<< STMT c_64 = PHI <c_43, c_39> c_64 = PHI <c_43(24), c_39(23)> <<<< STMT q_70 = PHI <q_42, q_56> q_70 = PHI <q_42(24), q_56(23)> <<<< STMT i_94 = PHI <i_41, 0> i_94 = PHI <i_41(24), 0(23)> Optimizing statement if (c_64 > 95) LKUP STMT c_64 gt_expr 95 if (c_64 > 95) Optimizing block #26 1>>> COND 1 = c_64 le_expr 95 1>>> COND 0 = c_64 gt_expr 95 LKUP STMT _40 = *q_70 _40 = *q_70; LKUP STMT _40 ne_expr c_64 if (_40 != c_64) <<<< COND 0 = c_64 gt_expr 95 <<<< COND 1 = c_64 le_expr 95 Optimizing block #27 LKUP STMT c_13 = PHI <c_64, 65> c_13 = PHI <c_64(26), 65(25)> 2>>> STMT c_13 = PHI <c_64, 65> c_13 = PHI <c_64(26), 65(25)> <<<< STMT c_13 = PHI <c_64, 65> c_13 = PHI <c_64(26), 65(25)> Optimizing statement _40 = *q_70; LKUP STMT _40 = *q_70 _40 = *q_70; 2>>> STMT _40 = *q_70 _40 = *q_70; Optimizing statement if (_40 != c_13) LKUP STMT _40 ne_expr c_13 if (_40 != c_13) Optimizing block #29 0>>> COPY c_13 = _40 1>>> COND 1 = _40 le_expr c_13 1>>> COND 1 = _40 ge_expr c_13 1>>> COND 1 = _40 eq_expr c_13 1>>> COND 0 = _40 ne_expr c_13 Optimizing statement i_41 = i_94 + 1; LKUP STMT i_41 = i_94 plus_expr 1 i_41 = i_94 + 1; Optimizing statement q_42 = q_70 + 1; LKUP STMT q_42 = q_70 pointer_plus_expr 1 q_42 = q_70 + 1; Optimizing statement c_43 = c_13 + 1; Replaced 'c_13' with variable '_40' LKUP STMT c_43 = _40 plus_expr 1 c_43 = _40 + 1; 2>>> STMT c_43 = _40 plus_expr 1 c_43 = _40 + 1; Optimizing statement if (i_41 < len_89) LKUP STMT i_41 lt_expr len_89 if (i_41 < len_89) Optimizing block #24 1>>> COND 1 = i_41 le_expr len_89 1>>> COND 1 = i_41 ne_expr len_89 1>>> COND 1 = i_41 lt_expr len_89 1>>> COND 0 = i_41 ge_expr len_89 LKUP STMT c_43 gt_expr 95 if (c_43 > 95) <<<< COND 0 = i_41 ge_expr len_89 <<<< COND 1 = i_41 lt_expr len_89 <<<< COND 1 = i_41 ne_expr len_89 <<<< COND 1 = i_41 le_expr len_89 Optimizing block #30 1>>> COND 1 = i_41 ge_expr len_89 1>>> COND 0 = i_41 lt_expr len_89 LKUP STMT q_52 = PHI <q_42> q_52 = PHI <q_42(29)> 2>>> STMT q_52 = PHI <q_42> q_52 = PHI <q_42(29)> <<<< STMT q_52 = PHI <q_42> q_52 = PHI <q_42(29)> Optimizing statement _54 = *q_52; LKUP STMT _54 = *q_52 _54 = *q_52; 2>>> STMT _54 = *q_52 _54 = *q_52; Optimizing statement if (_54 != 97) LKUP STMT _54 ne_expr 97 if (_54 != 97) Optimizing block #31 0>>> COPY _54 = 97 1>>> COND 1 = _54 le_expr 97 1>>> COND 1 = _54 ge_expr 97 1>>> COND 1 = _54 eq_expr 97 1>>> COND 0 = _54 ne_expr 97 Optimizing statement _60 = MEM[(char *)q_52 + 1B]; LKUP STMT _60 = MEM[(char *)q_52 + 1B] _60 = MEM[(char *)q_52 + 1B]; 2>>> STMT _60 = MEM[(char *)q_52 + 1B] _60 = MEM[(char *)q_52 + 1B]; Optimizing statement if (_60 != 97) LKUP STMT _60 ne_expr 97 if (_60 != 97) Optimizing block #32 0>>> COPY _60 = 97 1>>> COND 1 = _60 le_expr 97 1>>> COND 1 = _60 ge_expr 97 1>>> COND 1 = _60 eq_expr 97 1>>> COND 0 = _60 ne_expr 97 Optimizing statement _66 = MEM[(char *)q_52 + 2B]; LKUP STMT _66 = MEM[(char *)q_52 + 2B] _66 = MEM[(char *)q_52 + 2B]; 2>>> STMT _66 = MEM[(char *)q_52 + 2B] _66 = MEM[(char *)q_52 + 2B]; Optimizing statement if (_66 != 97) LKUP STMT _66 ne_expr 97 if (_66 != 97) Optimizing block #33 0>>> COPY _66 = 97 1>>> COND 1 = _66 le_expr 97 1>>> COND 1 = _66 ge_expr 97 1>>> COND 1 = _66 eq_expr 97 1>>> COND 0 = _66 ne_expr 97 Optimizing statement _72 = MEM[(char *)q_52 + 3B]; LKUP STMT _72 = MEM[(char *)q_52 + 3B] _72 = MEM[(char *)q_52 + 3B]; 2>>> STMT _72 = MEM[(char *)q_52 + 3B] _72 = MEM[(char *)q_52 + 3B]; Optimizing statement if (_72 != 97) LKUP STMT _72 ne_expr 97 if (_72 != 97) Optimizing block #34 0>>> COPY _72 = 97 1>>> COND 1 = _72 le_expr 97 1>>> COND 1 = _72 ge_expr 97 1>>> COND 1 = _72 eq_expr 97 1>>> COND 0 = _72 ne_expr 97 Optimizing statement _78 = MEM[(char *)q_52 + 4B]; LKUP STMT _78 = MEM[(char *)q_52 + 4B] _78 = MEM[(char *)q_52 + 4B]; 2>>> STMT _78 = MEM[(char *)q_52 + 4B] _78 = MEM[(char *)q_52 + 4B]; Optimizing statement if (_78 != 97) LKUP STMT _78 ne_expr 97 if (_78 != 97) Optimizing block #35 0>>> COPY _78 = 97 1>>> COND 1 = _78 le_expr 97 1>>> COND 1 = _78 ge_expr 97 1>>> COND 1 = _78 eq_expr 97 1>>> COND 0 = _78 ne_expr 97 Optimizing statement _84 = MEM[(char *)q_52 + 5B]; LKUP STMT _84 = MEM[(char *)q_52 + 5B] _84 = MEM[(char *)q_52 + 5B]; 2>>> STMT _84 = MEM[(char *)q_52 + 5B] _84 = MEM[(char *)q_52 + 5B]; Optimizing statement if (_84 != 97) LKUP STMT _84 ne_expr 97 if (_84 != 97) Optimizing block #36 0>>> COPY _84 = 97 1>>> COND 1 = _84 le_expr 97 1>>> COND 1 = _84 ge_expr 97 1>>> COND 1 = _84 eq_expr 97 1>>> COND 0 = _84 ne_expr 97 Optimizing statement _90 = MEM[(char *)q_52 + 6B]; LKUP STMT _90 = MEM[(char *)q_52 + 6B] _90 = MEM[(char *)q_52 + 6B]; 2>>> STMT _90 = MEM[(char *)q_52 + 6B] _90 = MEM[(char *)q_52 + 6B]; Optimizing statement if (_90 != 97) LKUP STMT _90 ne_expr 97 if (_90 != 97) Optimizing block #37 0>>> COPY _90 = 97 1>>> COND 1 = _90 le_expr 97 1>>> COND 1 = _90 ge_expr 97 1>>> COND 1 = _90 eq_expr 97 1>>> COND 0 = _90 ne_expr 97 Optimizing statement _96 = MEM[(char *)q_52 + 7B]; LKUP STMT _96 = MEM[(char *)q_52 + 7B] _96 = MEM[(char *)q_52 + 7B]; 2>>> STMT _96 = MEM[(char *)q_52 + 7B] _96 = MEM[(char *)q_52 + 7B]; Optimizing statement if (_96 != 97) LKUP STMT _96 ne_expr 97 if (_96 != 97) Optimizing block #39 0>>> COPY _96 = 97 1>>> COND 1 = _96 le_expr 97 1>>> COND 1 = _96 ge_expr 97 1>>> COND 1 = _96 eq_expr 97 1>>> COND 0 = _96 ne_expr 97 Optimizing statement len_48 = len_89 + 1; LKUP STMT len_48 = len_89 plus_expr 1 len_48 = len_89 + 1; Optimizing statement len.3_22 = (unsigned int) len_48; LKUP STMT len.3_22 = nop_expr len_48 len.3_22 = (unsigned int) len_48; 2>>> STMT len.3_22 = nop_expr len_48 len.3_22 = (unsigned int) len_48; Optimizing statement if (len.3_22 != 80) LKUP STMT len.3_22 ne_expr 80 if (len.3_22 != 80) 0>>> COPY len.3_22 = 80 <<<< COPY len.3_22 = 80 Optimizing block #40 1>>> COND 1 = len.3_22 ne_expr 80 1>>> COND 0 = len.3_22 eq_expr 80 Registering jump thread: (40, 8) incoming edge; (8, 9) normal; (9, 10) nocopy; <<<< COND 0 = len.3_22 eq_expr 80 <<<< COND 1 = len.3_22 ne_expr 80 0>>> COPY len.3_22 = 80 1>>> COND 1 = len.3_22 le_expr 80 1>>> COND 1 = len.3_22 ge_expr 80 1>>> COND 1 = len.3_22 eq_expr 80 1>>> COND 0 = len.3_22 ne_expr 80 LKUP STMT off2_49 = off2_91 plus_expr 1 off2_49 = off2_91 + 1; LKUP STMT off2.4_21 = nop_expr off2_49 off2.4_21 = (unsigned int) off2_49; LKUP STMT off2.4_21 ne_expr 8 if (off2.4_21 != 8) <<<< COND 0 = len.3_22 ne_expr 80 <<<< COND 1 = len.3_22 eq_expr 80 <<<< COND 1 = len.3_22 ge_expr 80 <<<< COND 1 = len.3_22 le_expr 80 <<<< STMT len.3_22 = nop_expr len_48 len.3_22 = (unsigned int) len_48; <<<< COND 0 = _96 ne_expr 97 <<<< COND 1 = _96 eq_expr 97 <<<< COND 1 = _96 ge_expr 97 <<<< COND 1 = _96 le_expr 97 <<<< COPY _96 = 97 <<<< STMT _96 = MEM[(char *)q_52 + 7B] _96 = MEM[(char *)q_52 + 7B]; <<<< COND 0 = _90 ne_expr 97 <<<< COND 1 = _90 eq_expr 97 <<<< COND 1 = _90 ge_expr 97 <<<< COND 1 = _90 le_expr 97 <<<< COPY _90 = 97 <<<< STMT _90 = MEM[(char *)q_52 + 6B] _90 = MEM[(char *)q_52 + 6B]; <<<< COND 0 = _84 ne_expr 97 <<<< COND 1 = _84 eq_expr 97 <<<< COND 1 = _84 ge_expr 97 <<<< COND 1 = _84 le_expr 97 <<<< COPY _84 = 97 <<<< STMT _84 = MEM[(char *)q_52 + 5B] _84 = MEM[(char *)q_52 + 5B]; <<<< COND 0 = _78 ne_expr 97 <<<< COND 1 = _78 eq_expr 97 <<<< COND 1 = _78 ge_expr 97 <<<< COND 1 = _78 le_expr 97 <<<< COPY _78 = 97 <<<< STMT _78 = MEM[(char *)q_52 + 4B] _78 = MEM[(char *)q_52 + 4B]; <<<< COND 0 = _72 ne_expr 97 <<<< COND 1 = _72 eq_expr 97 <<<< COND 1 = _72 ge_expr 97 <<<< COND 1 = _72 le_expr 97 <<<< COPY _72 = 97 <<<< STMT _72 = MEM[(char *)q_52 + 3B] _72 = MEM[(char *)q_52 + 3B]; <<<< COND 0 = _66 ne_expr 97 <<<< COND 1 = _66 eq_expr 97 <<<< COND 1 = _66 ge_expr 97 <<<< COND 1 = _66 le_expr 97 <<<< COPY _66 = 97 <<<< STMT _66 = MEM[(char *)q_52 + 2B] _66 = MEM[(char *)q_52 + 2B]; <<<< COND 0 = _60 ne_expr 97 <<<< COND 1 = _60 eq_expr 97 <<<< COND 1 = _60 ge_expr 97 <<<< COND 1 = _60 le_expr 97 <<<< COPY _60 = 97 <<<< STMT _60 = MEM[(char *)q_52 + 1B] _60 = MEM[(char *)q_52 + 1B]; <<<< COND 0 = _54 ne_expr 97 <<<< COND 1 = _54 eq_expr 97 <<<< COND 1 = _54 ge_expr 97 <<<< COND 1 = _54 le_expr 97 <<<< COPY _54 = 97 Optimizing block #38 Optimizing statement abort (); <<<< STMT _54 = *q_52 _54 = *q_52; <<<< COND 0 = i_41 lt_expr len_89 <<<< COND 1 = i_41 ge_expr len_89 <<<< STMT c_43 = _40 plus_expr 1 c_43 = _40 + 1; <<<< COND 0 = _40 ne_expr c_13 <<<< COND 1 = _40 eq_expr c_13 <<<< COND 1 = _40 ge_expr c_13 <<<< COND 1 = _40 le_expr c_13 <<<< COPY c_13 = _40 Optimizing block #28 1>>> COND 1 = _40 ne_expr c_13 1>>> COND 0 = _40 eq_expr c_13 Optimizing statement abort (); <<<< COND 0 = _40 eq_expr c_13 <<<< COND 1 = _40 ne_expr c_13 <<<< STMT _40 = *q_70 _40 = *q_70; 1>>> COND 1 = c_64 ge_expr 95 1>>> COND 1 = c_64 ne_expr 95 1>>> COND 1 = c_64 gt_expr 95 1>>> COND 0 = c_64 le_expr 95 LKUP STMT _40 = *q_70 _40 = *q_70; LKUP STMT _40 ne_expr 65 if (_40 != 65) <<<< COND 0 = c_64 le_expr 95 <<<< COND 1 = c_64 gt_expr 95 <<<< COND 1 = c_64 ne_expr 95 <<<< COND 1 = c_64 ge_expr 95 LKUP STMT c_39 gt_expr 95 if (c_39 > 95) <<<< STMT c_39 = _38 plus_expr 65 c_39 = _38 + 65; <<<< STMT _38 = convert_expr off2_91 _38 = (char) off2_91; <<<< COND 0 = _29 ne_expr p_34 <<<< COND 1 = _29 eq_expr p_34 <<<< COND 1 = _29 ge_expr p_34 <<<< COND 1 = _29 le_expr p_34 <<<< COPY p_34 = _29 Optimizing block #15 1>>> COND 1 = _29 ne_expr p_34 1>>> COND 0 = _29 eq_expr p_34 Optimizing statement abort (); <<<< COND 0 = _29 eq_expr p_34 <<<< COND 1 = _29 ne_expr p_34 <<<< STMT _32 = nop_expr len_89 _32 = (long unsigned int) len_89; <<<< STMT _31 = &u2.buf[_30] _31 = &u2.buf[_30]; <<<< STMT _30 = nop_expr off2_91 _30 = (sizetype) off2_91; <<<< STMT _29 = &u1.buf[_28] _29 = &u1.buf[_28]; <<<< STMT _28 = nop_expr off1_93 _28 = (sizetype) off1_93; 1>>> COND 1 = 1 le_expr 0 1>>> COND 1 = 1 ge_expr 0 LKUP STMT _28 = nop_expr off1_93 _28 = (sizetype) off1_93; LKUP STMT _29 = &u1.buf[_28] _29 = &u1.buf[_28]; LKUP STMT _30 = nop_expr off2_91 _30 = (sizetype) off2_91; LKUP STMT _31 = &u2.buf[_30] _31 = &u2.buf[_30]; LKUP STMT _32 = nop_expr len_89 _32 = (long unsigned int) len_89; LKUP STMT p_34 = memcpy (_29, _31, _32) p_34 = memcpy (_29, _31, _32); LKUP STMT _29 ne_expr p_34 if (_29 != p_34) <<<< COND 1 = 1 ge_expr 0 <<<< COND 1 = 1 le_expr 0 Registering jump thread: (7, 8) incoming edge; (8, 9) normal; (9, 10) nocopy; Optimizing block #41 LKUP STMT .MEM_73 = PHI <.MEM_33, .MEM_71> .MEM_73 = PHI <.MEM_33(39), .MEM_71(6)> 2>>> STMT .MEM_73 = PHI <.MEM_33, .MEM_71> .MEM_73 = PHI <.MEM_33(39), .MEM_71(6)> <<<< STMT .MEM_73 = PHI <.MEM_33, .MEM_71> .MEM_73 = PHI <.MEM_33(39), .MEM_71(6)> Optimizing statement off2_49 = off2_91 + 1; LKUP STMT off2_49 = off2_91 plus_expr 1 off2_49 = off2_91 + 1; Optimizing statement off2.4_21 = (unsigned int) off2_49; LKUP STMT off2.4_21 = nop_expr off2_49 off2.4_21 = (unsigned int) off2_49; 2>>> STMT off2.4_21 = nop_expr off2_49 off2.4_21 = (unsigned int) off2_49; Optimizing statement if (off2.4_21 != 8) LKUP STMT off2.4_21 ne_expr 8 if (off2.4_21 != 8) 0>>> COPY off2.4_21 = 8 <<<< COPY off2.4_21 = 8 Optimizing block #42 1>>> COND 1 = off2.4_21 ne_expr 8 1>>> COND 0 = off2.4_21 eq_expr 8 Registering jump thread: (42, 6) incoming edge; (6, 7) normal; (7, 8) nocopy; <<<< COND 0 = off2.4_21 eq_expr 8 <<<< COND 1 = off2.4_21 ne_expr 8 0>>> COPY off2.4_21 = 8 1>>> COND 1 = off2.4_21 le_expr 8 1>>> COND 1 = off2.4_21 ge_expr 8 1>>> COND 1 = off2.4_21 eq_expr 8 1>>> COND 0 = off2.4_21 ne_expr 8 LKUP STMT off1_50 = off1_93 plus_expr 1 off1_50 = off1_93 + 1; LKUP STMT off1.5_20 = nop_expr off1_50 off1.5_20 = (unsigned int) off1_50; LKUP STMT off1.5_20 ne_expr 8 if (off1.5_20 != 8) <<<< COND 0 = off2.4_21 ne_expr 8 <<<< COND 1 = off2.4_21 eq_expr 8 <<<< COND 1 = off2.4_21 ge_expr 8 <<<< COND 1 = off2.4_21 le_expr 8 <<<< STMT off2.4_21 = nop_expr off2_49 off2.4_21 = (unsigned int) off2_49; 1>>> COND 1 = 1 le_expr 0 1>>> COND 1 = 1 ge_expr 0 LKUP STMT off2_49 = off2_91 plus_expr 1 off2_49 = off2_91 + 1; LKUP STMT off2.4_21 = nop_expr off2_49 off2.4_21 = (unsigned int) off2_49; LKUP STMT off2.4_21 ne_expr 8 if (off2.4_21 != 8) <<<< COND 1 = 1 ge_expr 0 <<<< COND 1 = 1 le_expr 0 Registering jump thread: (5, 6) incoming edge; (6, 7) normal; (7, 8) nocopy; Optimizing block #43 LKUP STMT .MEM_69 = PHI <.MEM_73, .MEM_67> .MEM_69 = PHI <.MEM_73(41), .MEM_67(4)> 2>>> STMT .MEM_69 = PHI <.MEM_73, .MEM_67> .MEM_69 = PHI <.MEM_73(41), .MEM_67(4)> <<<< STMT .MEM_69 = PHI <.MEM_73, .MEM_67> .MEM_69 = PHI <.MEM_73(41), .MEM_67(4)> Optimizing statement off1_50 = off1_93 + 1; LKUP STMT off1_50 = off1_93 plus_expr 1 off1_50 = off1_93 + 1; Optimizing statement off1.5_20 = (unsigned int) off1_50; LKUP STMT off1.5_20 = nop_expr off1_50 off1.5_20 = (unsigned int) off1_50; 2>>> STMT off1.5_20 = nop_expr off1_50 off1.5_20 = (unsigned int) off1_50; Optimizing statement if (off1.5_20 != 8) LKUP STMT off1.5_20 ne_expr 8 if (off1.5_20 != 8) 0>>> COPY off1.5_20 = 8 <<<< COPY off1.5_20 = 8 Optimizing block #44 1>>> COND 1 = off1.5_20 ne_expr 8 1>>> COND 0 = off1.5_20 eq_expr 8 Registering jump thread: (44, 4) incoming edge; (4, 5) normal; (5, 6) nocopy; <<<< COND 0 = off1.5_20 eq_expr 8 <<<< COND 1 = off1.5_20 ne_expr 8 <<<< STMT off1.5_20 = nop_expr off1_50 off1.5_20 = (unsigned int) off1_50; 1>>> COND 1 = 1 le_expr 0 1>>> COND 1 = 1 ge_expr 0 LKUP STMT off1_50 = off1_93 plus_expr 1 off1_50 = off1_93 + 1; LKUP STMT off1.5_20 = nop_expr off1_50 off1.5_20 = (unsigned int) off1_50; LKUP STMT off1.5_20 ne_expr 8 if (off1.5_20 != 8) <<<< COND 1 = 1 ge_expr 0 <<<< COND 1 = 1 le_expr 0 Registering jump thread: (3, 4) incoming edge; (4, 5) normal; (5, 6) nocopy; <<<< COND 0 = 1 eq_expr 0 <<<< COND 1 = 1 ne_expr 0 Optimizing block #45 LKUP STMT .MEM_65 = PHI <.MEM_69, .MEM_19(D)> .MEM_65 = PHI <.MEM_69(43), .MEM_19(D)(2)> 2>>> STMT .MEM_65 = PHI <.MEM_69, .MEM_19(D)> .MEM_65 = PHI <.MEM_69(43), .MEM_19(D)(2)> <<<< STMT .MEM_65 = PHI <.MEM_69, .MEM_19(D)> .MEM_65 = PHI <.MEM_69(43), .MEM_19(D)(2)> Optimizing statement exit (0); Threaded jump 9 --> 10 to 46 Total number of statements: 69 Exprs considered for dominator optimizations: 87 Hash table statistics: avail_exprs: size 2039, 0 elements, 0.112500 collision/search ratio Pass statistics: ---------------- Copies propagated: 1 Constants propagated: 6 Redundant expressions eliminated: 3 Jumps threaded: 1 Merging blocks 2 and 3 Merging blocks 4 and 5 Merging blocks 6 and 7 Merging blocks 8 and 9 Removing basic block 13 ;; basic block 13, loop depth 4, count 0, freq 9798, maybe hot ;; Invalid sum of incoming frequencies 0, should be 9798 ;; prev block 47, next block 14, flags: (NEW, REACHABLE) ;; pred: goto <bb 10>; ;; succ: 10 [100.0%] (FALLTHRU,DFS_BACK) Updating SSA: creating PHI node in block #9 for .MEM_24 creating PHI node in block #9 for i_87 Registering new PHI nodes in block #42 Updating SSA information for statement u1.buf[i_87] = 97; Registering new PHI nodes in block #9 Updating SSA information for statement u2.buf[i_87] = c_11; Updating SSA information for statement i_26 = i_87 + 1; Registering new PHI nodes in block #6 Updating SSA information for statement u1.buf[i_87] = 97; Updating SSA information for statement if (c_81 > 95) Registering new PHI nodes in block #7 Registering new PHI nodes in block #8 Registering new PHI nodes in block #10 Registering new PHI nodes in block #12 Registering new PHI nodes in block #13 Registering new PHI nodes in block #17 Registering new PHI nodes in block #18 Registering new PHI nodes in block #14 Registering new PHI nodes in block #15 Registering new PHI nodes in block #16 Registering new PHI nodes in block #19 Registering new PHI nodes in block #21 Registering new PHI nodes in block #22 Registering new PHI nodes in block #23 Registering new PHI nodes in block #25 Registering new PHI nodes in block #20 Registering new PHI nodes in block #26 Registering new PHI nodes in block #27 Registering new PHI nodes in block #28 Registering new PHI nodes in block #29 Registering new PHI nodes in block #30 Registering new PHI nodes in block #31 Registering new PHI nodes in block #32 Registering new PHI nodes in block #33 Registering new PHI nodes in block #35 Registering new PHI nodes in block #36 Registering new PHI nodes in block #37 Registering new PHI nodes in block #38 Registering new PHI nodes in block #39 Registering new PHI nodes in block #40 Registering new PHI nodes in block #41 Registering new PHI nodes in block #34 Registering new PHI nodes in block #24 Registering new PHI nodes in block #11 DFA Statistics for main --------------------------------------------------------- Number of Memory instances used --------------------------------------------------------- USE operands 63 504b DEF operands 37 296b VUSE operands 20 160b VDEF operands 4 32b PHI nodes 30 3120b PHI arguments 47 2256b --------------------------------------------------------- Total memory used by DFA/SSA data 6368b --------------------------------------------------------- Average number of arguments per PHI node: 1.6 (max: 2) SSA replacement table N_i -> { O_1 ... O_j } means that N_i replaces O_1, ..., O_j c_1 -> { c_81 } .MEM_2 -> { .MEM_24 } .MEM_3 -> { .MEM_24 } i_14 -> { i_87 } .MEM_17 -> { .MEM_79 } i_18 -> { i_87 } Incremental SSA update started at block: 42 Number of blocks in CFG: 43 Number of blocks to update: 5 ( 12%) Affected blocks: 6 7 8 9 42 main () { charD.8 cD.2887; charD.8 * qD.2886; charD.8 * pD.2885; intD.7 iD.2884; intD.7 lenD.2883; intD.7 off2D.2882; intD.7 off1D.2881; unsigned intD.10 off1.5D.2936; unsigned intD.10 off2.4D.2935; unsigned intD.10 len.3D.2934; unsigned intD.10 i.1D.2915; sizetype _28; charD.8 * _29; sizetype _30; charD.8 * _31; long unsigned intD.11 _32; charD.8 _35; charD.8 _38; charD.8 _40; charD.8 _47; charD.8 _54; charD.8 _60; charD.8 _66; charD.8 _72; charD.8 _78; charD.8 _84; charD.8 _90; charD.8 _96; ;; basic block 2, loop depth 0, count 0, freq 95, maybe hot ;; prev block 0, next block 3, flags: (NEW, REACHABLE) ;; pred: ENTRY [100.0%] (FALLTHRU,EXECUTABLE) # RANGE [0, 8] off1.5_92 = 0; ;; succ: 3 [100.0%] (FALLTHRU) ;; basic block 3, loop depth 1, count 0, freq 94, maybe hot ;; prev block 2, next block 4, flags: (NEW, REACHABLE) ;; pred: 40 [100.0%] (FALLTHRU,DFS_BACK) ;; 2 [100.0%] (FALLTHRU) # # RANGE [0, 8] off1_93 = PHI <off1_50(40), 0(2)> # .MEM_67 = PHI <.MEM_69(40), .MEM_19(D)(2)> # RANGE [0, 8] off2.4_86 = 0; ;; succ: 4 [100.0%] (FALLTHRU) ;; basic block 4, loop depth 2, count 0, freq 85, maybe hot ;; prev block 3, next block 5, flags: (NEW, REACHABLE) ;; pred: 38 [100.0%] (FALLTHRU,DFS_BACK) ;; 3 [100.0%] (FALLTHRU) # # RANGE [0, 8] off2_91 = PHI <off2_49(38), 0(3)> # .MEM_71 = PHI <.MEM_73(38), .MEM_67(3)> # RANGE [1, 80] len.3_62 = 1; ;; succ: 5 [100.0%] (FALLTHRU) ;; basic block 5, loop depth 3, count 0, freq 103, maybe hot ;; prev block 4, next block 6, flags: (NEW, REACHABLE) ;; pred: 36 [100.0%] (FALLTHRU,DFS_BACK) ;; 4 [100.0%] (FALLTHRU) # # RANGE [1, 80] len_89 = PHI <len_48(36), 1(4)> # .MEM_75 = PHI <.MEM_33(36), .MEM_71(4)> # RANGE [0, 96] i.1_95 = 0; goto <bb 42>; ;; succ: 42 [100.0%] (FALLTHRU) ;; basic block 6, loop depth 4, count 0, freq 9897, maybe hot ;; Invalid sum of incoming frequencies 9795, should be 9897 ;; prev block 5, next block 7, flags: (NEW, REACHABLE) ;; pred: 9 [99.0%] (TRUE_VALUE,EXECUTABLE) # # RANGE [0, 96] i_87 = PHI <i_26(9)> # c_81 = PHI <c_27(9)> # .MEM_79 = PHI <.MEM_25(9)> # .MEM_24 = VDEF <.MEM_79> u1D.2877.bufD.2874[i_87] = 97; if (c_81 > 95) goto <bb 8>; else goto <bb 7>; ;; succ: 8 [50.0%] (TRUE_VALUE,EXECUTABLE) ;; 7 [50.0%] (FALSE_VALUE,EXECUTABLE) ;; basic block 7, loop depth 4, count 0, freq 4949, maybe hot ;; prev block 6, next block 8, flags: (NEW, REACHABLE) ;; pred: 6 [50.0%] (FALSE_VALUE,EXECUTABLE) ;; succ: 8 [100.0%] (FALLTHRU,EXECUTABLE) ;; basic block 8, loop depth 4, count 0, freq 9798, maybe hot ;; prev block 7, next block 9, flags: (NEW, REACHABLE) ;; pred: 7 [100.0%] (FALLTHRU,EXECUTABLE) ;; 6 [50.0%] (TRUE_VALUE,EXECUTABLE) # c_16 = PHI <c_81(7), 65(6)> ;; succ: 9 [100.0%] (FALLTHRU) ;; basic block 9, loop depth 4, count 0, freq 9897, maybe hot ;; prev block 8, next block 10, flags: (NEW, REACHABLE) ;; pred: 8 [100.0%] (FALLTHRU) ;; 42 [100.0%] (FALLTHRU) # c_11 = PHI <c_16(8), c_1(42)> # .MEM_3 = PHI <.MEM_24(8), .MEM_2(42)> # # RANGE [0, 96] i_14 = PHI <i_87(8), i_18(42)> # .MEM_25 = VDEF <.MEM_3> u2D.2878.bufD.2874[i_14] = c_11; # RANGE [1, 96] i_26 = i_14 + 1; # RANGE [0, 255] c_27 = c_11 + 1; # RANGE [0, 96] i.1_23 = (unsigned intD.10) i_26; if (i.1_23 != 96) goto <bb 6>; else goto <bb 10>; ;; succ: 6 [99.0%] (TRUE_VALUE,EXECUTABLE) ;; 10 [1.0%] (FALSE_VALUE,EXECUTABLE) ;; basic block 10, loop depth 3, count 0, freq 103, maybe hot ;; prev block 9, next block 11, flags: (NEW, REACHABLE) ;; pred: 9 [1.0%] (FALSE_VALUE,EXECUTABLE) # .MEM_77 = PHI <.MEM_25(9)> # RANGE [0, 7] _28 = (sizetype) off1_93; PT = { D.2877 } (glob) # _29 = &u1D.2877.bufD.2874[_28]; # RANGE [0, 7] _30 = (sizetype) off2_91; PT = { D.2878 } (glob) # _31 = &u2D.2878.bufD.2874[_30]; # RANGE [1, 79] _32 = (long unsigned intD.11) len_89; # .MEM_33 = VDEF <.MEM_77> PT = { D.2877 } (glob) # # USE = nonlocal null # CLB = nonlocal null p_34 = memcpyD.684 (_29, _31, _32); if (_29 != p_34) goto <bb 11>; else goto <bb 12>; ;; succ: 11 [2.0%] (TRUE_VALUE,EXECUTABLE) ;; 12 [98.0%] (FALSE_VALUE,EXECUTABLE) ;; basic block 11, loop depth 0, count 0, freq 2 ;; prev block 10, next block 12, flags: (NEW, REACHABLE) ;; pred: 10 [2.0%] (TRUE_VALUE,EXECUTABLE) # VUSE <.MEM_33> # USE = nonlocal null # CLB = nonlocal null abortD.848 (); ;; succ: ;; basic block 12, loop depth 3, count 0, freq 101, maybe hot ;; prev block 11, next block 13, flags: (NEW, REACHABLE) ;; pred: 10 [98.0%] (FALSE_VALUE,EXECUTABLE) # # RANGE [0, 2147483647] i_45 = PHI <0(10)> # PT = { D.2877 } (glob) # q_46 = PHI <&u1D.2877.bufD.2874(10)> if (off1_93 > 0) goto <bb 13>; else goto <bb 19>; ;; succ: 13 [95.5%] (TRUE_VALUE,EXECUTABLE) ;; 19 [4.5%] (FALSE_VALUE,EXECUTABLE) ;; basic block 13, loop depth 3, count 0, freq 96, maybe hot ;; prev block 12, next block 14, flags: (NEW, REACHABLE) ;; pred: 12 [95.5%] (TRUE_VALUE,EXECUTABLE) # VUSE <.MEM_33> _47 = MEM[(charD.8 *)&u1D.2877]; if (_47 != 97) goto <bb 16>; else goto <bb 17>; ;; succ: 16 [4.5%] (TRUE_VALUE,EXECUTABLE) ;; 17 [95.5%] (FALSE_VALUE,EXECUTABLE) ;; basic block 14, loop depth 4, count 0, freq 1000, maybe hot ;; prev block 13, next block 15, flags: (NEW, REACHABLE) ;; pred: 18 [95.5%] (TRUE_VALUE,EXECUTABLE) # VUSE <.MEM_33> _35 = *q_37; if (_35 != 97) goto <bb 16>; else goto <bb 15>; ;; succ: 16 [4.5%] (TRUE_VALUE,EXECUTABLE) ;; 15 [95.5%] (FALSE_VALUE,EXECUTABLE) ;; basic block 15, loop depth 4, count 0, freq 955, maybe hot ;; prev block 14, next block 16, flags: (NEW, REACHABLE) ;; pred: 14 [95.5%] (FALSE_VALUE,EXECUTABLE) goto <bb 18>; ;; succ: 18 [100.0%] (FALLTHRU,DFS_BACK) ;; basic block 16, loop depth 0, count 0, freq 49 ;; prev block 15, next block 17, flags: (NEW, REACHABLE) ;; pred: 14 [4.5%] (TRUE_VALUE,EXECUTABLE) ;; 13 [4.5%] (TRUE_VALUE,EXECUTABLE) # VUSE <.MEM_33> # USE = nonlocal null # CLB = nonlocal null abortD.848 (); ;; succ: ;; basic block 17, loop depth 3, count 0, freq 92, maybe hot ;; prev block 16, next block 18, flags: (NEW, REACHABLE) ;; pred: 13 [95.5%] (FALSE_VALUE,EXECUTABLE) ;; succ: 18 [100.0%] (FALLTHRU) ;; basic block 18, loop depth 4, count 0, freq 1046, maybe hot ;; prev block 17, next block 19, flags: (NEW, REACHABLE) ;; pred: 15 [100.0%] (FALLTHRU,DFS_BACK) ;; 17 [100.0%] (FALLTHRU) # # RANGE [0, 2147483647] i_85 = PHI <i_36(15), 0(17)> # PT = { D.2877 } (glob) # q_83 = PHI <q_37(15), &u1D.2877.bufD.2874(17)> # RANGE [1, 7] i_36 = i_85 + 1; PT = { D.2877 } (glob) # q_37 = q_83 + 1; if (i_36 < off1_93) goto <bb 14>; else goto <bb 19>; ;; succ: 14 [95.5%] (TRUE_VALUE,EXECUTABLE) ;; 19 [4.5%] (FALSE_VALUE,EXECUTABLE) ;; basic block 19, loop depth 3, count 0, freq 52 ;; prev block 18, next block 20, flags: (NEW, REACHABLE) ;; pred: 18 [4.5%] (FALSE_VALUE,EXECUTABLE) ;; 12 [4.5%] (FALSE_VALUE,EXECUTABLE) # PT = { D.2877 } (glob) # q_56 = PHI <q_37(18), &u1D.2877.bufD.2874(12)> # RANGE [0, 7] _38 = (charD.8) off2_91; # RANGE [65, 72] c_39 = _38 + 65; goto <bb 21>; ;; succ: 21 [100.0%] (FALLTHRU) ;; basic block 20, loop depth 4, count 0, freq 508, maybe hot ;; prev block 19, next block 21, flags: (NEW, REACHABLE) ;; pred: 25 [95.1%] (TRUE_VALUE,EXECUTABLE) ;; succ: 21 [100.0%] (FALLTHRU,DFS_BACK) ;; basic block 21, loop depth 4, count 0, freq 560, maybe hot ;; prev block 20, next block 22, flags: (NEW, REACHABLE) ;; pred: 20 [100.0%] (FALLTHRU,DFS_BACK) ;; 19 [100.0%] (FALLTHRU) # # RANGE [0, 2147483647] i_94 = PHI <i_41(20), 0(19)> # PT = { D.2877 } (glob) # q_70 = PHI <q_42(20), q_56(19)> # c_64 = PHI <c_43(20), c_39(19)> if (c_64 > 95) goto <bb 23>; else goto <bb 22>; ;; succ: 23 [50.0%] (TRUE_VALUE,EXECUTABLE) ;; 22 [50.0%] (FALSE_VALUE,EXECUTABLE) ;; basic block 22, loop depth 4, count 0, freq 280, maybe hot ;; prev block 21, next block 23, flags: (NEW, REACHABLE) ;; pred: 21 [50.0%] (FALSE_VALUE,EXECUTABLE) ;; succ: 23 [100.0%] (FALLTHRU,EXECUTABLE) ;; basic block 23, loop depth 4, count 0, freq 560, maybe hot ;; prev block 22, next block 24, flags: (NEW, REACHABLE) ;; pred: 22 [100.0%] (FALLTHRU,EXECUTABLE) ;; 21 [50.0%] (TRUE_VALUE,EXECUTABLE) # c_13 = PHI <c_64(22), 65(21)> # VUSE <.MEM_33> _40 = *q_70; if (_40 != c_13) goto <bb 24>; else goto <bb 25>; ;; succ: 24 [4.5%] (TRUE_VALUE,EXECUTABLE) ;; 25 [95.5%] (FALSE_VALUE,EXECUTABLE) ;; basic block 24, loop depth 0, count 0, freq 25 ;; prev block 23, next block 25, flags: (NEW, REACHABLE) ;; pred: 23 [4.5%] (TRUE_VALUE,EXECUTABLE) # VUSE <.MEM_33> # USE = nonlocal null # CLB = nonlocal null abortD.848 (); ;; succ: ;; basic block 25, loop depth 4, count 0, freq 535, maybe hot ;; prev block 24, next block 26, flags: (NEW, REACHABLE) ;; pred: 23 [95.5%] (FALSE_VALUE,EXECUTABLE) # RANGE [1, 79] i_41 = i_94 + 1; PT = { D.2877 } (glob) # q_42 = q_70 + 1; # RANGE [0, 255] c_43 = _40 + 1; if (i_41 < len_89) goto <bb 20>; else goto <bb 26>; ;; succ: 20 [95.1%] (TRUE_VALUE,EXECUTABLE) ;; 26 [4.9%] (FALSE_VALUE,EXECUTABLE) ;; basic block 26, loop depth 3, count 0, freq 26 ;; prev block 25, next block 27, flags: (NEW, REACHABLE) ;; pred: 25 [4.9%] (FALSE_VALUE,EXECUTABLE) # PT = { D.2877 } (glob) # q_52 = PHI <q_42(25)> # VUSE <.MEM_33> _54 = *q_52; if (_54 != 97) goto <bb 34>; else goto <bb 27>; ;; succ: 34 [4.5%] (TRUE_VALUE,EXECUTABLE) ;; 27 [95.5%] (FALSE_VALUE,EXECUTABLE) ;; basic block 27, loop depth 3, count 0, freq 25 ;; prev block 26, next block 28, flags: (NEW, REACHABLE) ;; pred: 26 [95.5%] (FALSE_VALUE,EXECUTABLE) # VUSE <.MEM_33> _60 = MEM[(charD.8 *)q_52 + 1B]; if (_60 != 97) goto <bb 34>; else goto <bb 28>; ;; succ: 34 [4.5%] (TRUE_VALUE,EXECUTABLE) ;; 28 [95.5%] (FALSE_VALUE,EXECUTABLE) ;; basic block 28, loop depth 3, count 0, freq 24 ;; prev block 27, next block 29, flags: (NEW, REACHABLE) ;; pred: 27 [95.5%] (FALSE_VALUE,EXECUTABLE) # VUSE <.MEM_33> _66 = MEM[(charD.8 *)q_52 + 2B]; if (_66 != 97) goto <bb 34>; else goto <bb 29>; ;; succ: 34 [4.5%] (TRUE_VALUE,EXECUTABLE) ;; 29 [95.5%] (FALSE_VALUE,EXECUTABLE) ;; basic block 29, loop depth 3, count 0, freq 23 ;; prev block 28, next block 30, flags: (NEW, REACHABLE) ;; pred: 28 [95.5%] (FALSE_VALUE,EXECUTABLE) # VUSE <.MEM_33> _72 = MEM[(charD.8 *)q_52 + 3B]; if (_72 != 97) goto <bb 34>; else goto <bb 30>; ;; succ: 34 [4.5%] (TRUE_VALUE,EXECUTABLE) ;; 30 [95.5%] (FALSE_VALUE,EXECUTABLE) ;; basic block 30, loop depth 3, count 0, freq 22 ;; prev block 29, next block 31, flags: (NEW, REACHABLE) ;; pred: 29 [95.5%] (FALSE_VALUE,EXECUTABLE) # VUSE <.MEM_33> _78 = MEM[(charD.8 *)q_52 + 4B]; if (_78 != 97) goto <bb 34>; else goto <bb 31>; ;; succ: 34 [4.5%] (TRUE_VALUE,EXECUTABLE) ;; 31 [95.5%] (FALSE_VALUE,EXECUTABLE) ;; basic block 31, loop depth 3, count 0, freq 21 ;; prev block 30, next block 32, flags: (NEW, REACHABLE) ;; pred: 30 [95.5%] (FALSE_VALUE,EXECUTABLE) # VUSE <.MEM_33> _84 = MEM[(charD.8 *)q_52 + 5B]; if (_84 != 97) goto <bb 34>; else goto <bb 32>; ;; succ: 34 [4.5%] (TRUE_VALUE,EXECUTABLE) ;; 32 [95.5%] (FALSE_VALUE,EXECUTABLE) ;; basic block 32, loop depth 3, count 0, freq 20 ;; prev block 31, next block 33, flags: (NEW, REACHABLE) ;; pred: 31 [95.5%] (FALSE_VALUE,EXECUTABLE) # VUSE <.MEM_33> _90 = MEM[(charD.8 *)q_52 + 6B]; if (_90 != 97) goto <bb 34>; else goto <bb 33>; ;; succ: 34 [4.5%] (TRUE_VALUE,EXECUTABLE) ;; 33 [95.5%] (FALSE_VALUE,EXECUTABLE) ;; basic block 33, loop depth 3, count 0, freq 19 ;; prev block 32, next block 34, flags: (NEW, REACHABLE) ;; pred: 32 [95.5%] (FALSE_VALUE,EXECUTABLE) # VUSE <.MEM_33> _96 = MEM[(charD.8 *)q_52 + 7B]; if (_96 != 97) goto <bb 34>; else goto <bb 35>; ;; succ: 34 [4.5%] (TRUE_VALUE,EXECUTABLE) ;; 35 [95.5%] (FALSE_VALUE,EXECUTABLE) ;; basic block 34, loop depth 0, count 0, freq 7 ;; prev block 33, next block 35, flags: (NEW, REACHABLE) ;; pred: 33 [4.5%] (TRUE_VALUE,EXECUTABLE) ;; 26 [4.5%] (TRUE_VALUE,EXECUTABLE) ;; 27 [4.5%] (TRUE_VALUE,EXECUTABLE) ;; 28 [4.5%] (TRUE_VALUE,EXECUTABLE) ;; 29 [4.5%] (TRUE_VALUE,EXECUTABLE) ;; 30 [4.5%] (TRUE_VALUE,EXECUTABLE) ;; 31 [4.5%] (TRUE_VALUE,EXECUTABLE) ;; 32 [4.5%] (TRUE_VALUE,EXECUTABLE) # VUSE <.MEM_33> # USE = nonlocal null # CLB = nonlocal null abortD.848 (); ;; succ: ;; basic block 35, loop depth 3, count 0, freq 19 ;; prev block 34, next block 36, flags: (NEW, REACHABLE) ;; pred: 33 [95.5%] (FALSE_VALUE,EXECUTABLE) # RANGE [2, 80] len_48 = len_89 + 1; # RANGE [1, 80] len.3_22 = (unsigned intD.10) len_48; if (len.3_22 != 80) goto <bb 36>; else goto <bb 37>; ;; succ: 36 [98.8%] (TRUE_VALUE,EXECUTABLE) ;; 37 [1.2%] (FALSE_VALUE,EXECUTABLE) ;; basic block 36, loop depth 3, count 0, freq 19 ;; prev block 35, next block 37, flags: (NEW, REACHABLE) ;; pred: 35 [98.8%] (TRUE_VALUE,EXECUTABLE) goto <bb 5>; ;; succ: 5 [100.0%] (FALLTHRU,DFS_BACK) ;; basic block 37, loop depth 2, count 0, freq 1 ;; prev block 36, next block 38, flags: (NEW, REACHABLE) ;; pred: 35 [1.2%] (FALSE_VALUE,EXECUTABLE) # .MEM_73 = PHI <.MEM_33(35)> # RANGE [1, 8] off2_49 = off2_91 + 1; # RANGE [0, 8] off2.4_21 = (unsigned intD.10) off2_49; if (off2.4_21 != 8) goto <bb 38>; else goto <bb 39>; ;; succ: 38 [88.9%] (TRUE_VALUE,EXECUTABLE) ;; 39 [11.1%] (FALSE_VALUE,EXECUTABLE) ;; basic block 38, loop depth 2, count 0, freq 1 ;; prev block 37, next block 39, flags: (NEW, REACHABLE) ;; pred: 37 [88.9%] (TRUE_VALUE,EXECUTABLE) goto <bb 4>; ;; succ: 4 [100.0%] (FALLTHRU,DFS_BACK) ;; basic block 39, loop depth 1, count 0, freq 11 ;; prev block 38, next block 40, flags: (NEW, REACHABLE) ;; pred: 37 [11.1%] (FALSE_VALUE,EXECUTABLE) # .MEM_69 = PHI <.MEM_73(37)> # RANGE [1, 8] off1_50 = off1_93 + 1; # RANGE [0, 8] off1.5_20 = (unsigned intD.10) off1_50; if (off1.5_20 != 8) goto <bb 40>; else goto <bb 41>; ;; succ: 40 [88.9%] (TRUE_VALUE,EXECUTABLE) ;; 41 [11.1%] (FALSE_VALUE,EXECUTABLE) ;; basic block 40, loop depth 1, count 0, freq 10 ;; prev block 39, next block 41, flags: (NEW, REACHABLE) ;; pred: 39 [88.9%] (TRUE_VALUE,EXECUTABLE) goto <bb 3>; ;; succ: 3 [100.0%] (FALLTHRU,DFS_BACK) ;; basic block 41, loop depth 0, count 0, freq 12 ;; prev block 40, next block 42, flags: (NEW, REACHABLE) ;; pred: 39 [11.1%] (FALSE_VALUE,EXECUTABLE) # .MEM_65 = PHI <.MEM_69(39)> # VUSE <.MEM_65> # USE = nonlocal null # CLB = nonlocal null exitD.898 (0); ;; succ: ;; basic block 42, loop depth 3, count 0, freq 99, maybe hot ;; prev block 41, next block 1, flags: (NEW, REACHABLE) ;; pred: 5 [100.0%] (FALLTHRU) # # RANGE [0, 96] i_18 = PHI <0(5)> # c_1 = PHI <65(5)> # .MEM_17 = PHI <.MEM_75(5)> # .MEM_2 = VDEF <.MEM_17> u1D.2877.bufD.2874[i_18] = 97; goto <bb 9>; ;; succ: 9 [100.0%] (FALLTHRU) }
On 09/27/2013 08:42 AM, James Greenhalgh wrote: > On Thu, Sep 26, 2013 at 04:26:35AM +0100, Jeff Law wrote: >> Bootstrapped and regression tested on x86_64-unknown-linux-gnu. >> Installed on trunk. > > Hi Jeff, > > This patch caused a regression on Arm and AArch64 in: > > PASS->FAIL: gcc.c-torture/execute/memcpy-2.c execution, -O3 -fomit-frame-pointer > > From what I can see, the only place the behaviour of the threader has > changed is in this hunk: Yes. The old code was dropping the tail off the thread path; if we're seeing failures on the ARM port as a result of fixing that goof we obviously need to address them. Let me take a looksie :-) If you could pass along a .i file it'd be helpful in case I want to look at something under the debugger. jeff
On Fri, Sep 27, 2013 at 04:32:10PM +0100, Jeff Law wrote: > If you could pass along a .i file it'd be helpful in case I want to look > at something under the debugger. I've opened http://gcc.gnu.org/bugzilla/show_bug.cgi?id=58553 to save everyone's inboxes. Let me know if I can do anything else to help. Cheers, James
On 09/27/2013 10:48 AM, James Greenhalgh wrote: > On Fri, Sep 27, 2013 at 04:32:10PM +0100, Jeff Law wrote: >> If you could pass along a .i file it'd be helpful in case I want to look >> at something under the debugger. > > I've opened http://gcc.gnu.org/bugzilla/show_bug.cgi?id=58553 to save > everyone's inboxes. > > Let me know if I can do anything else to help. THanks. I'm investigating. jeff
diff --git a/gcc/ChangeLog b/gcc/ChangeLog index 5adbaeb..8871aca 100644 --- a/gcc/ChangeLog +++ b/gcc/ChangeLog @@ -1,3 +1,26 @@ +2013-09-25 Jeff Law <law@redhat.com> + + * tree-flow.h (thread_through_all_blocks): Prototype moved into + tree-ssa-threadupdate.h. + (register_jump_thread): Similarly. + * tree-ssa-threadupdate.h: New header file. + * tree-ssa-dom.c: Include tree-ssa-threadupdate.h. + * tree-vrp.c: Likewise. + * tree-ssa-threadedge.c: Include tree-ssa-threadupdate.h. + (thread_around_empty_blocks): Change type of path vector argument to + an edge,type pair from just an edge. Initialize both elements when + appending to a jump threading path. Tweak references to elements + appropriately. + (thread_across_edge): Similarly. Release memory for the elements + as needed. + * tree-ssa-threadupdate.c: Include tree-ssa-threadupdate.h. + (dump_jump_thread_path): New function broken out from + register_jump_thread. + (register_jump_thread): Use dump_jump_thread_path. Change type of + path vector entries. Search the path for NULL edges and dump + the path if one is found. Tweak the conversion of path to 3-edge + form to use the block copy type information embedded in the path. + 2013-09-25 Yvan Roux <yvan.roux@linaro.org> * lra.c (update_inc_notes): Remove all REG_DEAD and REG_UNUSED notes. diff --git a/gcc/testsuite/ChangeLog b/gcc/testsuite/ChangeLog index 634e747..a264056 100644 --- a/gcc/testsuite/ChangeLog +++ b/gcc/testsuite/ChangeLog @@ -1,3 +1,6 @@ +2013-09-25 Jeff Law <law@redhat.com> + + * gcc.dg/tree-ssa/ssa-dom-thread-3.c: Update expected output. 2013-09-25 Tobias Burnus <burnus@net-b.de> PR fortran/58436 diff --git a/gcc/testsuite/gcc.dg/tree-ssa/ssa-dom-thread-3.c b/gcc/testsuite/gcc.dg/tree-ssa/ssa-dom-thread-3.c index d2a1fbb..222a97b 100644 --- a/gcc/testsuite/gcc.dg/tree-ssa/ssa-dom-thread-3.c +++ b/gcc/testsuite/gcc.dg/tree-ssa/ssa-dom-thread-3.c @@ -43,7 +43,6 @@ expand_one_var (tree var, unsigned char toplevel, unsigned char really_expand) } /* We should thread the jump, through an intermediate block. */ /* { dg-final { scan-tree-dump-times "Threaded" 1 "dom1"} } */ -/* { dg-final { scan-tree-dump-times "Registering jump thread .through joiner block.: \\(.*\\); \\(.*\\); \\(.*\\);" 1 "dom1"} } */ - +/* { dg-final { scan-tree-dump-times "Registering jump thread: \\(.*\\) incoming edge; \\(.*\\) joiner; \\(.*\\) nocopy;" 1 "dom1"} } */ /* { dg-final { cleanup-tree-dump "dom1" } } */ diff --git a/gcc/tree-flow.h b/gcc/tree-flow.h index 2f64abc..ee69179 100644 --- a/gcc/tree-flow.h +++ b/gcc/tree-flow.h @@ -641,10 +641,6 @@ bool multiplier_allowed_in_address_p (HOST_WIDE_INT, enum machine_mode, addr_space_t); bool may_be_nonaddressable_p (tree expr); -/* In tree-ssa-threadupdate.c. */ -extern bool thread_through_all_blocks (bool); -extern void register_jump_thread (vec<edge>, bool); - /* In gimplify.c */ tree force_gimple_operand_1 (tree, gimple_seq *, gimple_predicate, tree); tree force_gimple_operand (tree, gimple_seq *, bool, tree); diff --git a/gcc/tree-ssa-dom.c b/gcc/tree-ssa-dom.c index f0cc0ee..81119c3 100644 --- a/gcc/tree-ssa-dom.c +++ b/gcc/tree-ssa-dom.c @@ -34,6 +34,7 @@ along with GCC; see the file COPYING3. If not see #include "domwalk.h" #include "tree-pass.h" #include "tree-ssa-propagate.h" +#include "tree-ssa-threadupdate.h" #include "langhooks.h" #include "params.h" diff --git a/gcc/tree-ssa-threadedge.c b/gcc/tree-ssa-threadedge.c index 2ca56342..467d982 100644 --- a/gcc/tree-ssa-threadedge.c +++ b/gcc/tree-ssa-threadedge.c @@ -32,6 +32,7 @@ along with GCC; see the file COPYING3. If not see #include "dumpfile.h" #include "tree-ssa.h" #include "tree-ssa-propagate.h" +#include "tree-ssa-threadupdate.h" #include "langhooks.h" #include "params.h" @@ -753,7 +754,7 @@ thread_around_empty_blocks (edge taken_edge, bool handle_dominating_asserts, tree (*simplify) (gimple, gimple), bitmap visited, - vec<edge> *path) + vec<jump_thread_edge *> *path) { basic_block bb = taken_edge->dest; gimple_stmt_iterator gsi; @@ -791,8 +792,10 @@ thread_around_empty_blocks (edge taken_edge, if ((taken_edge->flags & EDGE_DFS_BACK) == 0 && !bitmap_bit_p (visited, taken_edge->dest->index)) { + jump_thread_edge *x + = new jump_thread_edge (taken_edge, EDGE_NO_COPY_SRC_BLOCK); + path->safe_push (x); bitmap_set_bit (visited, taken_edge->dest->index); - path->safe_push (taken_edge); return thread_around_empty_blocks (taken_edge, dummy_cond, handle_dominating_asserts, @@ -828,7 +831,11 @@ thread_around_empty_blocks (edge taken_edge, if (bitmap_bit_p (visited, taken_edge->dest->index)) return false; bitmap_set_bit (visited, taken_edge->dest->index); - path->safe_push (taken_edge); + + jump_thread_edge *x + = new jump_thread_edge (taken_edge, EDGE_NO_COPY_SRC_BLOCK); + path->safe_push (x); + thread_around_empty_blocks (taken_edge, dummy_cond, handle_dominating_asserts, @@ -922,9 +929,13 @@ thread_across_edge (gimple dummy_cond, if (dest == NULL || dest == e->dest) goto fail; - vec<edge> path = vNULL; - path.safe_push (e); - path.safe_push (taken_edge); + vec<jump_thread_edge *> path = vNULL; + jump_thread_edge *x + = new jump_thread_edge (e, EDGE_START_JUMP_THREAD); + path.safe_push (x); + + x = new jump_thread_edge (taken_edge, EDGE_COPY_SRC_BLOCK); + path.safe_push (x); /* See if we can thread through DEST as well, this helps capture secondary effects of threading without having to re-run DOM or @@ -947,8 +958,11 @@ thread_across_edge (gimple dummy_cond, } remove_temporary_equivalences (stack); - propagate_threaded_block_debug_into (path.last ()->dest, e->dest); - register_jump_thread (path, false); + propagate_threaded_block_debug_into (path.last ()->e->dest, + e->dest); + register_jump_thread (path); + for (unsigned int i = 0; i < path.length (); i++) + delete path[i]; path.release (); return; } @@ -978,15 +992,18 @@ thread_across_edge (gimple dummy_cond, bitmap_clear (visited); bitmap_set_bit (visited, taken_edge->dest->index); bitmap_set_bit (visited, e->dest->index); - vec<edge> path = vNULL; + vec<jump_thread_edge *> path = vNULL; /* Record whether or not we were able to thread through a successor of E->dest. */ - path.safe_push (e); - path.safe_push (taken_edge); + jump_thread_edge *x = new jump_thread_edge (e, EDGE_START_JUMP_THREAD); + path.safe_push (x); + + x = new jump_thread_edge (taken_edge, EDGE_COPY_SRC_JOINER_BLOCK); + path.safe_push (x); found = false; if ((e->flags & EDGE_DFS_BACK) == 0 - || ! cond_arg_set_in_bb (path.last (), e->dest)) + || ! cond_arg_set_in_bb (path.last ()->e, e->dest)) found = thread_around_empty_blocks (taken_edge, dummy_cond, handle_dominating_asserts, @@ -998,11 +1015,13 @@ thread_across_edge (gimple dummy_cond, record the jump threading opportunity. */ if (found) { - propagate_threaded_block_debug_into (path.last ()->dest, + propagate_threaded_block_debug_into (path.last ()->e->dest, taken_edge->dest); - register_jump_thread (path, true); + register_jump_thread (path); } + for (unsigned int i = 0; i < path.length (); i++) + delete path[i]; path.release(); } BITMAP_FREE (visited); diff --git a/gcc/tree-ssa-threadupdate.c b/gcc/tree-ssa-threadupdate.c index fd5234c..75273ca 100644 --- a/gcc/tree-ssa-threadupdate.c +++ b/gcc/tree-ssa-threadupdate.c @@ -27,6 +27,7 @@ along with GCC; see the file COPYING3. If not see #include "basic-block.h" #include "function.h" #include "tree-ssa.h" +#include "tree-ssa-threadupdate.h" #include "dumpfile.h" #include "cfgloop.h" #include "hash-table.h" @@ -1380,6 +1381,39 @@ thread_through_all_blocks (bool may_peel_loop_headers) return retval; } +/* Dump a jump threading path, including annotations about each + edge in the path. */ + +static void +dump_jump_thread_path (FILE *dump_file, vec<jump_thread_edge *> path) +{ + fprintf (dump_file, + " Registering jump thread: (%d, %d) incoming edge; ", + path[0]->e->src->index, path[0]->e->dest->index); + + for (unsigned int i = 1; i < path.length (); i++) + { + /* We can get paths with a NULL edge when the final destination + of a jump thread turns out to be a constant address. We dump + those paths when debugging, so we have to be prepared for that + possibility here. */ + if (path[i]->e == NULL) + continue; + + if (path[i]->type == EDGE_COPY_SRC_JOINER_BLOCK) + fprintf (dump_file, " (%d, %d) joiner; ", + path[i]->e->src->index, path[i]->e->dest->index); + if (path[i]->type == EDGE_COPY_SRC_BLOCK) + fprintf (dump_file, " (%d, %d) normal;", + path[i]->e->src->index, path[i]->e->dest->index); + if (path[i]->type == EDGE_NO_COPY_SRC_BLOCK) + fprintf (dump_file, " (%d, %d) nocopy;", + path[i]->e->src->index, path[i]->e->dest->index); + } + fputc ('\n', dump_file); +} + + /* Register a jump threading opportunity. We queue up all the jump threading opportunities discovered by a pass and update the CFG and SSA form all at once. @@ -1389,43 +1423,47 @@ thread_through_all_blocks (bool may_peel_loop_headers) after fixing the SSA graph. */ void -register_jump_thread (vec<edge> path, bool through_joiner) +register_jump_thread (vec<jump_thread_edge *> path) { - /* Convert PATH into 3 edge representation we've been using. This - is temporary until we convert this file to use a path representation - throughout. */ - edge e = path[0]; - edge e2 = path[1]; - edge e3; - - if (!through_joiner) - e3 = NULL; - else - e3 = path.last (); + /* First make sure there are no NULL outgoing edges on the jump threading + path. That can happen for jumping to a constant address. */ + for (unsigned int i = 0; i < path.length (); i++) + if (path[i]->e == NULL) + { + if (dump_file && (dump_flags & TDF_DETAILS)) + { + fprintf (dump_file, + "Found NULL edge in jump threading path. Cancelling jump thread:\n"); + dump_jump_thread_path (dump_file, path); + } + return; + } - /* This can occur if we're jumping to a constant address or - or something similar. Just get out now. */ - if (e2 == NULL) - return; + if (!threaded_edges.exists ()) + threaded_edges.create (15); if (dump_file && (dump_flags & TDF_DETAILS)) - { - unsigned int i; + dump_jump_thread_path (dump_file, path); - fprintf (dump_file, - " Registering jump thread %s:", - through_joiner ? "(through joiner block)" : ""); + /* The first entry in the vector is always the start of the + jump threading path. */ + threaded_edges.safe_push (path[0]->e); - for (i = 0; i < path.length (); i++) - fprintf (dump_file, " (%d, %d); ", - path[i]->src->index, path[i]->dest->index); - fputc ('\n', dump_file); - } - - if (!threaded_edges.exists ()) - threaded_edges.create (15); + /* In our 3-edge representation, the joiner, if it exists is always the + 2nd edge and the final block on the path is the 3rd edge. If no + jointer exists, then the final block on the path is the 2nd edge + and the 3rd edge is NULL. - threaded_edges.safe_push (e); - threaded_edges.safe_push (e2); - threaded_edges.safe_push (e3); + With upcoming improvements, we're going to be holding onto the entire + path, so we'll be able to clean this wart up shortly. */ + if (path[1]->type == EDGE_COPY_SRC_JOINER_BLOCK) + { + threaded_edges.safe_push (path[1]->e); + threaded_edges.safe_push (path.last ()->e); + } + else + { + threaded_edges.safe_push (path.last ()->e); + threaded_edges.safe_push (NULL); + } } diff --git a/gcc/tree-ssa-threadupdate.h b/gcc/tree-ssa-threadupdate.h new file mode 100644 index 0000000..723f5bb --- /dev/null +++ b/gcc/tree-ssa-threadupdate.h @@ -0,0 +1,45 @@ +/* Communication between registering jump thread requests and + updating the SSA/CFG for jump threading. + Copyright (C) 2013 Free Software Foundation, Inc. + +This file is part of GCC. + +GCC is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 3, or (at your option) +any later version. + +GCC is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GCC; see the file COPYING3. If not see +<http://www.gnu.org/licenses/>. */ + +#ifndef _TREE_SSA_THREADUPDATE_H +#define _TREE_SSA_THREADUPDATE_H 1 + +/* In tree-ssa-threadupdate.c. */ +extern bool thread_through_all_blocks (bool); +enum jump_thread_edge_type +{ + EDGE_START_JUMP_THREAD, + EDGE_COPY_SRC_BLOCK, + EDGE_COPY_SRC_JOINER_BLOCK, + EDGE_NO_COPY_SRC_BLOCK +}; + +class jump_thread_edge +{ +public: + jump_thread_edge (edge e, enum jump_thread_edge_type type) + : e (e), type (type) {} + + edge e; + enum jump_thread_edge_type type; +}; + +extern void register_jump_thread (vec<class jump_thread_edge *>); +#endif diff --git a/gcc/tree-vrp.c b/gcc/tree-vrp.c index 0d50af7..1600724 100644 --- a/gcc/tree-vrp.c +++ b/gcc/tree-vrp.c @@ -36,6 +36,7 @@ along with GCC; see the file COPYING3. If not see #include "tree-scalar-evolution.h" #include "tree-ssa-propagate.h" #include "tree-chrec.h" +#include "tree-ssa-threadupdate.h" #include "gimple-fold.h" #include "expr.h" #include "optabs.h"