[PATCH 4/4] Un-XFAIL ssa-dom-cse-2.c for most platforms

Dominik Vogt vogt@linux.vnet.ibm.com
Thu Feb 4 09:53:00 GMT 2016


On Wed, Feb 03, 2016 at 11:41:02AM +0000, Alan Lawrence wrote:
> On 26/01/16 12:23, Dominik Vogt wrote:
> >On Mon, Dec 21, 2015 at 01:13:28PM +0000, Alan Lawrence wrote:
> >>...the test passes with --param sra-max-scalarization-size-Ospeed.
> >>
> >>Verified on aarch64 and with stage1 compiler for hppa, powerpc, sparc, s390.
> >
> >How did you test this on s390?  For me, the test still fails
> >unless I add -march=z13 (s390x).
> 
> Sorry for the slow response, was away last week. On x86 host, I built a compiler
> 
> configure --enable-languages=c,c++,lto --target=s390-none-linux-gnu
                                                  ^^^^
Looks like the test fails only on s390x (64-Bit ) without
-march=z13 but works on s390 (31-Bit).

> I speculate that perhaps the -march=z13 is default for s390 *linux* ???

No.

> If you can send me alternative configury,

Just replacing the --target option with

  --target=s390x-none-linux-gnu

should do this.  (You have to remove the "dg-additional-options"
that adds -march=z13 from the testcase in the upstream code.)

> or dumps from your failing
> compiler (dom{2,3}-details, optimized), I can take a look.

Thanks; the dumps are attached to this message.

Ciao

Dominik ^_^  ^_^

-- 

Dominik Vogt
IBM Germany
-------------- next part --------------

;; Function foo (foo, funcdef_no=0, decl_uid=1972, cgraph_uid=0, symbol_order=0)

Created preheader block for loop 1
;; 2 loops found
;;
;; Loop 0
;;  header 0, latch 1
;;  depth 0, outer -1
;;  nodes: 0 1 2 3 5 6 4
;;
;; Loop 1
;;  header 5, latch 6
;;  depth 1, outer 0
;;  nodes: 5 6
;; 2 succs { 3 4 }
;; 3 succs { 5 }
;; 5 succs { 6 4 }
;; 6 succs { 5 }
;; 4 succs { 1 }


Optimizing block #0



Optimizing block #2

Optimizing statement MEM[(int[8] *)&a] = 0;
LKUP STMT MEM[(int[8] *)&a] = 0 with .MEM_3(D)
LKUP STMT 0 = MEM[(int[8] *)&a] with .MEM_3(D)
LKUP STMT 0 = MEM[(int[8] *)&a] with .MEM_17
2>>> STMT 0 = MEM[(int[8] *)&a] with .MEM_17
Optimizing statement MEM[(int[8] *)&a + 4B] = 1;
LKUP STMT MEM[(int[8] *)&a + 4B] = 1 with .MEM_17
LKUP STMT 1 = MEM[(int[8] *)&a + 4B] with .MEM_17
LKUP STMT 1 = MEM[(int[8] *)&a + 4B] with .MEM_18
2>>> STMT 1 = MEM[(int[8] *)&a + 4B] with .MEM_18
Optimizing statement MEM[(int[8] *)&a + 8B] = 2;
LKUP STMT MEM[(int[8] *)&a + 8B] = 2 with .MEM_18
LKUP STMT 2 = MEM[(int[8] *)&a + 8B] with .MEM_18
LKUP STMT 2 = MEM[(int[8] *)&a + 8B] with .MEM_19
2>>> STMT 2 = MEM[(int[8] *)&a + 8B] with .MEM_19
Optimizing statement MEM[(int[8] *)&a + 12B] = 3;
LKUP STMT MEM[(int[8] *)&a + 12B] = 3 with .MEM_19
LKUP STMT 3 = MEM[(int[8] *)&a + 12B] with .MEM_19
LKUP STMT 3 = MEM[(int[8] *)&a + 12B] with .MEM_20
2>>> STMT 3 = MEM[(int[8] *)&a + 12B] with .MEM_20
Optimizing statement MEM[(int[8] *)&a + 16B] = 4;
LKUP STMT MEM[(int[8] *)&a + 16B] = 4 with .MEM_20
LKUP STMT 4 = MEM[(int[8] *)&a + 16B] with .MEM_20
LKUP STMT 4 = MEM[(int[8] *)&a + 16B] with .MEM_21
2>>> STMT 4 = MEM[(int[8] *)&a + 16B] with .MEM_21
Optimizing statement MEM[(int[8] *)&a + 20B] = 5;
LKUP STMT MEM[(int[8] *)&a + 20B] = 5 with .MEM_21
LKUP STMT 5 = MEM[(int[8] *)&a + 20B] with .MEM_21
LKUP STMT 5 = MEM[(int[8] *)&a + 20B] with .MEM_22
2>>> STMT 5 = MEM[(int[8] *)&a + 20B] with .MEM_22
Optimizing statement MEM[(int[8] *)&a + 24B] = 6;
LKUP STMT MEM[(int[8] *)&a + 24B] = 6 with .MEM_22
LKUP STMT 6 = MEM[(int[8] *)&a + 24B] with .MEM_22
LKUP STMT 6 = MEM[(int[8] *)&a + 24B] with .MEM_23
2>>> STMT 6 = MEM[(int[8] *)&a + 24B] with .MEM_23
Optimizing statement MEM[(int[8] *)&a + 28B] = 7;
LKUP STMT MEM[(int[8] *)&a + 28B] = 7 with .MEM_23
LKUP STMT 7 = MEM[(int[8] *)&a + 28B] with .MEM_23
LKUP STMT 7 = MEM[(int[8] *)&a + 28B] with .MEM_24
2>>> STMT 7 = MEM[(int[8] *)&a + 28B] with .MEM_24
Optimizing statement i.0_10 = 0;
LKUP STMT i.0_10 = 0
==== ASGN i.0_10 = 0
Optimizing statement if (i.0_10 != 8)
  Replaced 'i.0_10' with constant '0'
gimple_simplified to if (1 != 0)
  Folded to: if (1 != 0)
LKUP STMT 1 ne_expr 0


Optimizing block #3

1>>> STMT 1 = 1 ne_expr 0
1>>> STMT 0 = 1 eq_expr 0
LKUP STMT i_2 = PHI <0>
2>>> STMT i_2 = PHI <0>
LKUP STMT sum_1 = PHI <0>
FIND: 0
0>>> COPY sum_1 = 0
<<<< STMT i_2 = PHI <0>


Optimizing block #5

LKUP STMT i_12 = PHI <0, i_9>
2>>> STMT i_12 = PHI <0, i_9>
LKUP STMT sum_13 = PHI <0, sum_8>
2>>> STMT sum_13 = PHI <0, sum_8>
<<<< STMT sum_13 = PHI <0, sum_8>
<<<< STMT i_12 = PHI <0, i_9>
Optimizing statement _7 = a[i_12];
LKUP STMT _7 = a[i_12] with .MEM_24
2>>> STMT _7 = a[i_12] with .MEM_24
Optimizing statement sum_8 = sum_13 + _7;
LKUP STMT sum_8 = sum_13 plus_expr _7
Optimizing statement i_9 = i_12 + 1;
LKUP STMT i_9 = i_12 plus_expr 1
Optimizing statement i.0_6 = (unsigned int) i_9;
LKUP STMT i.0_6 = nop_expr i_9
2>>> STMT i.0_6 = nop_expr i_9
Optimizing statement if (i.0_6 != 8)
LKUP STMT i.0_6 ne_expr 8
0>>> COPY i.0_6 = 8
<<<< COPY i.0_6 = 8


Optimizing block #6

1>>> STMT 1 = i.0_6 ne_expr 8
1>>> STMT 0 = i.0_6 eq_expr 8
<<<< STMT 0 = i.0_6 eq_expr 8
<<<< STMT 1 = i.0_6 ne_expr 8
<<<< STMT i.0_6 = nop_expr i_9
<<<< STMT _7 = a[i_12] with .MEM_24
0>>> COPY i_12 = 0
0>>> COPY sum_13 = 0
LKUP STMT _7 = a[0] with .MEM_24
FIND: 0
0>>> COPY _7 = 0
Match-and-simplified sum_13 + _7 to 0
0>>> COPY sum_8 = 0
Match-and-simplified i_12 + 1 to 1
0>>> COPY i_9 = 1
Match-and-simplified (unsigned int) i_9 to 1
0>>> COPY i.0_6 = 1
<<<< COPY i.0_6 = 1
<<<< COPY i_9 = 1
<<<< COPY sum_8 = 0
<<<< COPY _7 = 0
<<<< COPY sum_13 = 0
<<<< COPY i_12 = 0
  Registering jump thread: (3, 5) incoming edge;  (5, 6) normal;
<<<< STMT 0 = 1 eq_expr 0
<<<< STMT 1 = 1 ne_expr 0
<<<< COPY sum_1 = 0


Optimizing block #4

LKUP STMT sum_14 = PHI <sum_8, 0>
2>>> STMT sum_14 = PHI <sum_8, 0>
<<<< STMT sum_14 = PHI <sum_8, 0>
Optimizing statement a ={v} {CLOBBER};
Optimizing statement return sum_14;
  Replaced 'sum_14' with variable 'sum_8'
1>>> STMT 1 = 1 ne_expr 0
1>>> STMT 0 = 1 eq_expr 0
0>>> COPY i_2 = 0
0>>> COPY sum_1 = 0
0>>> COPY i_12 = 0
0>>> COPY sum_13 = 0
LKUP STMT _7 = a[0] with .MEM_24
FIND: 0
0>>> COPY _7 = 0
Match-and-simplified sum_13 + _7 to 0
0>>> COPY sum_8 = 0
Match-and-simplified i_12 + 1 to 1
0>>> COPY i_9 = 1
Match-and-simplified (unsigned int) i_9 to 1
0>>> COPY i.0_6 = 1
  Registering jump thread: (2, 3) incoming edge;  (3, 5) joiner;  (5, 6) normal;
<<<< COPY i.0_6 = 1
<<<< COPY i_9 = 1
<<<< COPY sum_8 = 0
<<<< COPY _7 = 0
<<<< COPY sum_13 = 0
<<<< COPY i_12 = 0
<<<< COPY sum_1 = 0
<<<< COPY i_2 = 0
<<<< STMT 0 = 1 eq_expr 0
<<<< STMT 1 = 1 ne_expr 0
<<<< STMT 7 = MEM[(int[8] *)&a + 28B] with .MEM_24
<<<< STMT 6 = MEM[(int[8] *)&a + 24B] with .MEM_23
<<<< STMT 5 = MEM[(int[8] *)&a + 20B] with .MEM_22
<<<< STMT 4 = MEM[(int[8] *)&a + 16B] with .MEM_21
<<<< STMT 3 = MEM[(int[8] *)&a + 12B] with .MEM_20
<<<< STMT 2 = MEM[(int[8] *)&a + 8B] with .MEM_19
<<<< STMT 1 = MEM[(int[8] *)&a + 4B] with .MEM_18
<<<< STMT 0 = MEM[(int[8] *)&a] with .MEM_17
Merging blocks 2 and 3
Removing basic block 6
basic block 6, loop depth 1
 pred:      
goto <bb 5>;
 succ:       5


fix_loop_structure: fixing up loops for function
foo ()
{
  const int SR.8;
  const int SR.7;
  const int SR.6;
  const int SR.5;
  const int SR.4;
  const int SR.3;
  const int SR.2;
  const int SR.1;
  int sum;
  int i;
  const int a[8];
  unsigned int i.0_6;
  int _7;
  unsigned int i.0_10;

  <bb 2>:
  MEM[(int[8] *)&a] = 0;
  MEM[(int[8] *)&a + 4B] = 1;
  MEM[(int[8] *)&a + 8B] = 2;
  MEM[(int[8] *)&a + 12B] = 3;
  MEM[(int[8] *)&a + 16B] = 4;
  MEM[(int[8] *)&a + 20B] = 5;
  MEM[(int[8] *)&a + 24B] = 6;
  MEM[(int[8] *)&a + 28B] = 7;
  i.0_10 = 0;

  <bb 3>:
  # i_12 = PHI <0(2), i_9(3)>
  # sum_13 = PHI <0(2), sum_8(3)>
  _7 = a[i_12];
  sum_8 = sum_13 + _7;
  i_9 = i_12 + 1;
  i.0_6 = (unsigned int) i_9;
  if (i.0_6 != 8)
    goto <bb 3>;
  else
    goto <bb 4>;

  <bb 4>:
  # sum_14 = PHI <sum_8(3)>
  a ={v} {CLOBBER};
  return sum_8;

}


-------------- next part --------------

;; Function foo (foo, funcdef_no=0, decl_uid=1972, cgraph_uid=0, symbol_order=0)

;; 2 loops found
;;
;; Loop 0
;;  header 0, latch 1
;;  depth 0, outer -1
;;  nodes: 0 1 2
;; 2 succs { 1 }


Optimizing block #0



Optimizing block #2

Optimizing statement vect_cst__12 = { 0, 1 };
LKUP STMT vect_cst__12 = { 0, 1 }
==== ASGN vect_cst__12 = { 0, 1 }
Optimizing statement vect_cst__13 = { 2, 3 };
LKUP STMT vect_cst__13 = { 2, 3 }
==== ASGN vect_cst__13 = { 2, 3 }
Optimizing statement vect_cst__6 = { 4, 5 };
LKUP STMT vect_cst__6 = { 4, 5 }
==== ASGN vect_cst__6 = { 4, 5 }
Optimizing statement vect_cst__10 = { 6, 7 };
LKUP STMT vect_cst__10 = { 6, 7 }
==== ASGN vect_cst__10 = { 6, 7 }
Optimizing statement MEM[(int[8] *)&a] = vect_cst__12;
  Replaced 'vect_cst__12' with constant '{ 0, 1 }'
LKUP STMT MEM[(int[8] *)&a] = { 0, 1 } with .MEM_3(D)
LKUP STMT { 0, 1 } = MEM[(int[8] *)&a] with .MEM_3(D)
LKUP STMT { 0, 1 } = MEM[(int[8] *)&a] with .MEM_63
2>>> STMT { 0, 1 } = MEM[(int[8] *)&a] with .MEM_63
Optimizing statement _62 = &MEM[(int[8] *)&a] + 8;
LKUP STMT _62 = &MEM[(int[8] *)&a] pointer_plus_expr 8
2>>> STMT _62 = &MEM[(int[8] *)&a] pointer_plus_expr 8
==== ASGN _62 = &MEM[(void *)&a + 8B]
Optimizing statement MEM[(int[8] *)_62] = vect_cst__13;
  Replaced '_62' with constant '&MEM[(void *)&a + 8B]'
  Replaced 'vect_cst__13' with constant '{ 2, 3 }'
  Folded to: MEM[(int[8] *)&a + 8B] = { 2, 3 };
LKUP STMT MEM[(int[8] *)&a + 8B] = { 2, 3 } with .MEM_63
LKUP STMT { 2, 3 } = MEM[(int[8] *)&a + 8B] with .MEM_63
LKUP STMT { 2, 3 } = MEM[(int[8] *)&a + 8B] with .MEM_61
2>>> STMT { 2, 3 } = MEM[(int[8] *)&a + 8B] with .MEM_61
Optimizing statement _56 = _62 + 8;
  Replaced '_62' with constant '&MEM[(void *)&a + 8B]'
LKUP STMT _56 = &MEM[(void *)&a + 8B] pointer_plus_expr 8
2>>> STMT _56 = &MEM[(void *)&a + 8B] pointer_plus_expr 8
==== ASGN _56 = &MEM[(void *)&a + 16B]
Optimizing statement MEM[(int[8] *)_56] = vect_cst__6;
  Replaced '_56' with constant '&MEM[(void *)&a + 16B]'
  Replaced 'vect_cst__6' with constant '{ 4, 5 }'
  Folded to: MEM[(int[8] *)&a + 16B] = { 4, 5 };
LKUP STMT MEM[(int[8] *)&a + 16B] = { 4, 5 } with .MEM_61
LKUP STMT { 4, 5 } = MEM[(int[8] *)&a + 16B] with .MEM_61
LKUP STMT { 4, 5 } = MEM[(int[8] *)&a + 16B] with .MEM_55
2>>> STMT { 4, 5 } = MEM[(int[8] *)&a + 16B] with .MEM_55
Optimizing statement _54 = _56 + 8;
  Replaced '_56' with constant '&MEM[(void *)&a + 16B]'
LKUP STMT _54 = &MEM[(void *)&a + 16B] pointer_plus_expr 8
2>>> STMT _54 = &MEM[(void *)&a + 16B] pointer_plus_expr 8
==== ASGN _54 = &MEM[(void *)&a + 24B]
Optimizing statement MEM[(int[8] *)_54] = vect_cst__10;
  Replaced '_54' with constant '&MEM[(void *)&a + 24B]'
  Replaced 'vect_cst__10' with constant '{ 6, 7 }'
  Folded to: MEM[(int[8] *)&a + 24B] = { 6, 7 };
LKUP STMT MEM[(int[8] *)&a + 24B] = { 6, 7 } with .MEM_55
LKUP STMT { 6, 7 } = MEM[(int[8] *)&a + 24B] with .MEM_55
LKUP STMT { 6, 7 } = MEM[(int[8] *)&a + 24B] with .MEM_49
2>>> STMT { 6, 7 } = MEM[(int[8] *)&a + 24B] with .MEM_49
Optimizing statement _4 = a[0];
LKUP STMT _4 = a[0] with .MEM_49
2>>> STMT _4 = a[0] with .MEM_49
Optimizing statement sum_15 = _4;
LKUP STMT sum_15 = _4
==== ASGN sum_15 = _4
Optimizing statement i_16 = 1;
LKUP STMT i_16 = 1
==== ASGN i_16 = 1
Optimizing statement ivtmp_25 = 7;
LKUP STMT ivtmp_25 = 7
==== ASGN ivtmp_25 = 7
Optimizing statement _29 = a[i_16];
  Replaced 'i_16' with constant '1'
LKUP STMT _29 = a[1] with .MEM_49
2>>> STMT _29 = a[1] with .MEM_49
Optimizing statement sum_30 = sum_15 + _29;
  Replaced 'sum_15' with variable '_4'
LKUP STMT sum_30 = _4 plus_expr _29
2>>> STMT sum_30 = _4 plus_expr _29
Optimizing statement i_31 = i_16 + 1;
  Replaced 'i_16' with constant '1'
gimple_simplified to i_31 = 2;
  Folded to: i_31 = 2;
LKUP STMT i_31 = 2
==== ASGN i_31 = 2
Optimizing statement _36 = a[i_31];
  Replaced 'i_31' with constant '2'
LKUP STMT _36 = a[2] with .MEM_49
2>>> STMT _36 = a[2] with .MEM_49
Optimizing statement sum_37 = sum_30 + _36;
LKUP STMT sum_37 = sum_30 plus_expr _36
2>>> STMT sum_37 = sum_30 plus_expr _36
Optimizing statement i_38 = i_31 + 1;
  Replaced 'i_31' with constant '2'
gimple_simplified to i_38 = 3;
  Folded to: i_38 = 3;
LKUP STMT i_38 = 3
==== ASGN i_38 = 3
Optimizing statement _43 = a[i_38];
  Replaced 'i_38' with constant '3'
LKUP STMT _43 = a[3] with .MEM_49
2>>> STMT _43 = a[3] with .MEM_49
Optimizing statement sum_44 = sum_37 + _43;
LKUP STMT sum_44 = sum_37 plus_expr _43
2>>> STMT sum_44 = sum_37 plus_expr _43
Optimizing statement i_45 = i_38 + 1;
  Replaced 'i_38' with constant '3'
gimple_simplified to i_45 = 4;
  Folded to: i_45 = 4;
LKUP STMT i_45 = 4
==== ASGN i_45 = 4
Optimizing statement _50 = a[i_45];
  Replaced 'i_45' with constant '4'
LKUP STMT _50 = a[4] with .MEM_49
2>>> STMT _50 = a[4] with .MEM_49
Optimizing statement sum_51 = sum_44 + _50;
LKUP STMT sum_51 = sum_44 plus_expr _50
2>>> STMT sum_51 = sum_44 plus_expr _50
Optimizing statement i_52 = i_45 + 1;
  Replaced 'i_45' with constant '4'
gimple_simplified to i_52 = 5;
  Folded to: i_52 = 5;
LKUP STMT i_52 = 5
==== ASGN i_52 = 5
Optimizing statement _57 = a[i_52];
  Replaced 'i_52' with constant '5'
LKUP STMT _57 = a[5] with .MEM_49
2>>> STMT _57 = a[5] with .MEM_49
Optimizing statement sum_58 = sum_51 + _57;
LKUP STMT sum_58 = sum_51 plus_expr _57
2>>> STMT sum_58 = sum_51 plus_expr _57
Optimizing statement i_59 = i_52 + 1;
  Replaced 'i_52' with constant '5'
gimple_simplified to i_59 = 6;
  Folded to: i_59 = 6;
LKUP STMT i_59 = 6
==== ASGN i_59 = 6
Optimizing statement _64 = a[i_59];
  Replaced 'i_59' with constant '6'
LKUP STMT _64 = a[6] with .MEM_49
2>>> STMT _64 = a[6] with .MEM_49
Optimizing statement sum_65 = sum_58 + _64;
LKUP STMT sum_65 = sum_58 plus_expr _64
2>>> STMT sum_65 = sum_58 plus_expr _64
Optimizing statement i_66 = i_59 + 1;
  Replaced 'i_59' with constant '6'
gimple_simplified to i_66 = 7;
  Folded to: i_66 = 7;
LKUP STMT i_66 = 7
==== ASGN i_66 = 7
Optimizing statement ivtmp_67 = ivtmp_25 + 4294967290;
  Replaced 'ivtmp_25' with constant '7'
gimple_simplified to ivtmp_67 = 1;
  Folded to: ivtmp_67 = 1;
LKUP STMT ivtmp_67 = 1
==== ASGN ivtmp_67 = 1
Optimizing statement _7 = a[i_66];
  Replaced 'i_66' with constant '7'
LKUP STMT _7 = a[7] with .MEM_49
2>>> STMT _7 = a[7] with .MEM_49
Optimizing statement sum_8 = _7 + sum_65;
LKUP STMT sum_8 = _7 plus_expr sum_65
2>>> STMT sum_8 = _7 plus_expr sum_65
Optimizing statement i_9 = i_66 + 1;
  Replaced 'i_66' with constant '7'
gimple_simplified to i_9 = 8;
  Folded to: i_9 = 8;
LKUP STMT i_9 = 8
==== ASGN i_9 = 8
Optimizing statement ivtmp_14 = ivtmp_67 + 4294967295;
  Replaced 'ivtmp_67' with constant '1'
gimple_simplified to ivtmp_14 = 0;
  Folded to: ivtmp_14 = 0;
LKUP STMT ivtmp_14 = 0
==== ASGN ivtmp_14 = 0
Optimizing statement a ={v} {CLOBBER};
Optimizing statement return sum_8;
<<<< STMT sum_8 = _7 plus_expr sum_65
<<<< STMT _7 = a[7] with .MEM_49
<<<< STMT sum_65 = sum_58 plus_expr _64
<<<< STMT _64 = a[6] with .MEM_49
<<<< STMT sum_58 = sum_51 plus_expr _57
<<<< STMT _57 = a[5] with .MEM_49
<<<< STMT sum_51 = sum_44 plus_expr _50
<<<< STMT _50 = a[4] with .MEM_49
<<<< STMT sum_44 = sum_37 plus_expr _43
<<<< STMT _43 = a[3] with .MEM_49
<<<< STMT sum_37 = sum_30 plus_expr _36
<<<< STMT _36 = a[2] with .MEM_49
<<<< STMT sum_30 = _4 plus_expr _29
<<<< STMT _29 = a[1] with .MEM_49
<<<< STMT _4 = a[0] with .MEM_49
<<<< STMT { 6, 7 } = MEM[(int[8] *)&a + 24B] with .MEM_49
<<<< STMT _54 = &MEM[(void *)&a + 16B] pointer_plus_expr 8
<<<< STMT { 4, 5 } = MEM[(int[8] *)&a + 16B] with .MEM_55
<<<< STMT _56 = &MEM[(void *)&a + 8B] pointer_plus_expr 8
<<<< STMT { 2, 3 } = MEM[(int[8] *)&a + 8B] with .MEM_61
<<<< STMT _62 = &MEM[(int[8] *)&a] pointer_plus_expr 8
<<<< STMT { 0, 1 } = MEM[(int[8] *)&a] with .MEM_63
foo ()
{
  const vector(2) int * vectp.10;
  const vector(2) int * vectp_a.9;
  const int SR.8;
  const int SR.7;
  const int SR.6;
  const int SR.5;
  const int SR.4;
  const int SR.3;
  const int SR.2;
  const int SR.1;
  int sum;
  int i;
  const int a[8];
  int _4;
  vector(2) int vect_cst__6;
  int _7;
  vector(2) int vect_cst__10;
  vector(2) int vect_cst__12;
  vector(2) int vect_cst__13;
  unsigned int ivtmp_14;
  unsigned int ivtmp_25;
  int _29;
  int _36;
  int _43;
  int _50;
  const int * _54;
  const int * _56;
  int _57;
  const int * _62;
  int _64;
  unsigned int ivtmp_67;

  <bb 2>:
  vect_cst__12 = { 0, 1 };
  vect_cst__13 = { 2, 3 };
  vect_cst__6 = { 4, 5 };
  vect_cst__10 = { 6, 7 };
  MEM[(int[8] *)&a] = { 0, 1 };
  _62 = &MEM[(int[8] *)&a] + 8;
  MEM[(int[8] *)&a + 8B] = { 2, 3 };
  _56 = &MEM[(void *)&a + 8B] + 8;
  MEM[(int[8] *)&a + 16B] = { 4, 5 };
  _54 = &MEM[(void *)&a + 16B] + 8;
  MEM[(int[8] *)&a + 24B] = { 6, 7 };
  _4 = a[0];
  sum_15 = _4;
  i_16 = 1;
  ivtmp_25 = 7;
  _29 = a[1];
  sum_30 = _4 + _29;
  i_31 = 2;
  _36 = a[2];
  sum_37 = sum_30 + _36;
  i_38 = 3;
  _43 = a[3];
  sum_44 = sum_37 + _43;
  i_45 = 4;
  _50 = a[4];
  sum_51 = sum_44 + _50;
  i_52 = 5;
  _57 = a[5];
  sum_58 = sum_51 + _57;
  i_59 = 6;
  _64 = a[6];
  sum_65 = sum_58 + _64;
  i_66 = 7;
  ivtmp_67 = 1;
  _7 = a[7];
  sum_8 = _7 + sum_65;
  i_9 = 8;
  ivtmp_14 = 0;
  a ={v} {CLOBBER};
  return sum_8;

}


-------------- next part --------------

;; Function foo (foo, funcdef_no=0, decl_uid=1972, cgraph_uid=0, symbol_order=0)

Scope blocks after cleanups:

{ Scope block #0 
  const int a[8];
  int sum;

}
foo ()
{
  int sum;
  const int a[8];
  int _4;
  int _7;
  int _29;
  int _36;
  int _43;
  int _50;
  int _57;
  int _64;

  <bb 2>:
  MEM[(int[8] *)&a] = { 0, 1 };
  MEM[(int[8] *)&a + 8B] = { 2, 3 };
  MEM[(int[8] *)&a + 16B] = { 4, 5 };
  MEM[(int[8] *)&a + 24B] = { 6, 7 };
  _4 = a[0];
  _29 = a[1];
  sum_30 = _4 + _29;
  _36 = a[2];
  sum_37 = sum_30 + _36;
  _43 = a[3];
  sum_44 = sum_37 + _43;
  _50 = a[4];
  sum_51 = sum_44 + _50;
  _57 = a[5];
  sum_58 = sum_51 + _57;
  _64 = a[6];
  sum_65 = sum_58 + _64;
  _7 = a[7];
  sum_8 = _7 + sum_65;
  a ={v} {CLOBBER};
  return sum_8;

}




More information about the Gcc-patches mailing list