Running `compiler.VectorReduction2.WithSuperword.intAddSimple` I've realised that the loop is not vectorized:
```
@Benchmark
public void intAddSimple(Blackhole bh) {
    int acc = 0; // neutral element
    for (int i = 0; i < SIZE; i++) {
        int val = in1I[i];
        acc += val;
    }
    bh.consume(acc);
}
```

Here's the assembly on an x64 AVX2 machine:
```
             0x00007f4090020d5e: nop ;*aload_0 {reexecute=0 rethrow=0 return_oop=0}
                                                                       ; - org.openjdk.bench.vm.compiler.VectorReduction2::intAddSimple@12 (line 811)
                                                                       ; - org.openjdk.bench.vm.compiler.jmh_generated.VectorReduction2_WithSuperword_intAddSimple_jmhTest::intAddSimple_avgt_jmhStub@17 (line 190)
          ↗ 0x00007f4090020d60: addl 0x10(%r14, %rcx, 4), %edx ; add the value of the 1st element
   5.55% │ 0x00007f4090020d65: addl 0x14(%r14, %rcx, 4), %edx
   4.76% │ 0x00007f4090020d6a: addl 0x18(%r14, %rcx, 4), %edx
   7.55% │ 0x00007f4090020d6f: addl 0x1c(%r14, %rcx, 4), %edx
   6.70% │ 0x00007f4090020d74: addl 0x20(%r14, %rcx, 4), %edx
   5.55% │ 0x00007f4090020d79: addl 0x24(%r14, %rcx, 4), %edx
   5.21% │ 0x00007f4090020d7e: addl 0x28(%r14, %rcx, 4), %edx
   6.51% │ 0x00007f4090020d83: addl 0x2c(%r14, %rcx, 4), %edx
   5.51% │ 0x00007f4090020d88: addl 0x30(%r14, %rcx, 4), %edx
   5.66% │ 0x00007f4090020d8d: addl 0x34(%r14, %rcx, 4), %edx
   4.69% │ 0x00007f4090020d92: addl 0x38(%r14, %rcx, 4), %edx
   6.51% │ 0x00007f4090020d97: addl 0x3c(%r14, %rcx, 4), %edx
   5.51% │ 0x00007f4090020d9c: addl 0x40(%r14, %rcx, 4), %edx
   7.22% │ 0x00007f4090020da1: addl 0x44(%r14, %rcx, 4), %edx
   5.62% │ 0x00007f4090020da6: addl 0x48(%r14, %rcx, 4), %edx
   5.14% │ 0x00007f4090020dab: addl 0x4c(%r14, %rcx, 4), %edx;*iadd {reexecute=0 rethrow=0 return_oop=0}
          │ ; - org.openjdk.bench.vm.compiler.VectorReduction2::intAddSimple@23 (line 812)
          │ ; - org.openjdk.bench.vm.compiler.jmh_generated.VectorReduction2_WithSuperword_intAddSimple_jmhTest::intAddSimple_avgt_jmhStub@17 (line 190)
   6.07% │ 0x00007f4090020db0: addl $0x10, %ecx ;*iinc {reexecute=0 rethrow=0 return_oop=0}
          │ ; - org.openjdk.bench.vm.compiler.VectorReduction2::intAddSimple@25 (line 810)
          │ ; - org.openjdk.bench.vm.compiler.jmh_generated.VectorReduction2_WithSuperword_intAddSimple_jmhTest::intAddSimple_avgt_jmhStub@17 (line 190)
          │ 0x00007f4090020db3: cmpl %eax, %ecx
   0.04% ╰ 0x00007f4090020db5: jl 0x7f4090020d60 ;*if_icmpge {reexecute=0 rethrow=0 return_oop=0}
```

However, if you multiply the value before summing it, then vectorization kicks in. So, something like this:
```
@Benchmark
public void intAddSimpleWithMultiply(Blackhole bh) {
    int acc = 0; // neutral element
    for (int i = 0; i < SIZE; i++) {
        int val = 11 * in1I[i];
        acc += val;
    }
    bh.consume(acc);
}
```

Here's the assembly
```
   0.16% 0x00007f1190021e93: addl %r11d, %edi
             0x00007f1190021e96: nopw (%rax, %rax) ;*bipush {reexecute=0 rethrow=0 return_oop=0}
                                                                       ; - org.openjdk.bench.vm.compiler.VectorReduction2::intAddSimpleWithMultiply@12 (line 821)
                                                                       ; - org.openjdk.bench.vm.compiler.jmh_generated.VectorReduction2_WithSuperword_intAddSimpleWithMultiply_jmhTest::intAddSimpleWithMultiply_avgt_jmhStub@17 (line 190)
          ↗ 0x00007f1190021ea0: vpmulld 0xf0(%r8, %r11, 4), %ymm5, %ymm7
          │ 0x00007f1190021eaa: vpmulld 0xd0(%r8, %r11, 4), %ymm5, %ymm8
          │ 0x00007f1190021eb4: vpmulld 0x10(%r8, %r11, 4), %ymm5, %ymm3
   6.17% │ 0x00007f1190021ebb: vpmulld 0x30(%r8, %r11, 4), %ymm5, %ymm6
  11.30% │ 0x00007f1190021ec2: vpmulld 0xb0(%r8, %r11, 4), %ymm5, %ymm9
          │ ; {no_reloc}
  11.63% │ 0x00007f1190021ecc: vpmulld 0x50(%r8, %r11, 4), %ymm5, %ymm12
  10.64% │ 0x00007f1190021ed3: vpmulld 0x70(%r8, %r11, 4), %ymm5, %ymm11
  11.69% │ 0x00007f1190021eda: vpmulld 0x90(%r8, %r11, 4), %ymm5, %ymm10
  10.80% │ 0x00007f1190021ee4: vpaddd %ymm3, %ymm13, %ymm3
          │ 0x00007f1190021ee8: vpaddd %ymm6, %ymm3, %ymm3
          │ 0x00007f1190021eec: vpaddd %ymm12, %ymm3, %ymm3
          │ 0x00007f1190021ef1: vpaddd %ymm11, %ymm3, %ymm3
          │ 0x00007f1190021ef6: vpaddd %ymm10, %ymm3, %ymm3
  10.71% │ 0x00007f1190021efb: vpaddd %ymm9, %ymm3, %ymm3
   4.83% │ 0x00007f1190021f00: vpaddd %ymm8, %ymm3, %ymm3
   7.42% │ 0x00007f1190021f05: vpaddd %ymm7, %ymm3, %ymm13;*iadd {reexecute=0 rethrow=0 return_oop=0}
          │ ; - org.openjdk.bench.vm.compiler.VectorReduction2::intAddSimpleWithMultiply@26 (line 822)
          │ ; - org.openjdk.bench.vm.compiler.jmh_generated.VectorReduction2_WithSuperword_intAddSimpleWithMultiply_jmhTest::intAddSimpleWithMultiply_avgt_jmhStub@17 (line 190)
   5.52% │ 0x00007f1190021f09: addl $0x40, %r11d ;*iinc {reexecute=0 rethrow=0 return_oop=0}
          │ ; - org.openjdk.bench.vm.compiler.VectorReduction2::intAddSimpleWithMultiply@28 (line 820)
          │ ; - org.openjdk.bench.vm.compiler.jmh_generated.VectorReduction2_WithSuperword_intAddSimpleWithMultiply_jmhTest::intAddSimpleWithMultiply_avgt_jmhStub@17 (line 190)
          │ 0x00007f1190021f0d: cmpl %edi, %r11d
          ╰ 0x00007f1190021f10: jl 0x7f1190021ea0 ;*if_icmpge {reexecute=0 rethrow=0 return_oop=0}
                                                                       ; - org.openjdk.bench.vm.compiler.VectorReduction2::intAddSimpleWithMultiply@9 (line 820)
                                                                       ; - org.openjdk.bench.vm.compiler.jmh_generated.VectorReduction2_WithSuperword_intAddSimpleWithMultiply_jmhTest::intAddSimpleWithMultiply_avgt_jmhStub@17 (line 190)
```

Here are the performance of both benchmarks compared:
```
Benchmark (SIZE) (seed) Mode Cnt Score Error Units
VectorReduction2.WithSuperword.intAddSimple 2048 0 avgt 3 552.308 ± 1.333 ns/op
VectorReduction2.WithSuperword.intAddSimpleWithMultiply 2048 0 avgt 3 141.707 ± 1.827 ns/op
```

This should be working as per JDK-7192383 and JDK-8074981, but couldn't see any bugs related to this. I've replicated this in master branch.