Patchwork Make jump thread path carry more information

login
register
mail settings
Submitter Jeff Law
Date Sept. 26, 2013, 3:26 a.m.
Message ID <5243A96B.1010703@redhat.com>
Download mbox | patch
Permalink /patch/278089/
State New
Headers show

Comments

Jeff Law - Sept. 26, 2013, 3:26 a.m.
This patch conveys information about the blocks/edges in a jump 
threading path.  Of particular interest is information about the source 
block in each edge of the path -- the nature of the block determines our 
copy strategy (empty -- no copy, normal copy, joiner copy).

Rather than rediscover the nature of those blocks during the CFG/SSA 
graph updating, it's easier to just attach the information to each edge 
in the path.  That's precisely what this patch does.

The SSA/CFG updating code isn't making much use of this yet, that's a 
follow-on change.  This change is strictly designed to get the 
information into the updating code.


Bootstrapped and regression tested on x86_64-unknown-linux-gnu. 
Installed on trunk.
James Greenhalgh - Sept. 27, 2013, 2:42 p.m.
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)

}
Jeff Law - Sept. 27, 2013, 3:32 p.m.
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
James Greenhalgh - Sept. 27, 2013, 4:48 p.m.
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
Jeff Law - Sept. 27, 2013, 4:52 p.m.
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

Patch

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"