Create local config file for subzero reader tests.

tests_lit/parse_errs/insertextract-err.ll

-; Tests insertelement and extractelement vector instructions report
-; errors when malformed. Note: We can only test literal indexing since
-; llvm-as will not allow other bad forms of these instructions.
+; Tests malformed insertelement and extractelement vector instructions.
 
-; REQUIRES: allow_dump
-; RUN: llvm-as < %s | pnacl-freeze \
-; RUN:   | not %llvm2ice -notranslate -build-on-read \
-; RUN:     -allow-pnacl-reader-error-recovery | FileCheck %s
+; RUN: %if --need=allow_dump --command llvm-as < %s \
+; RUN:   | %if --need=allow_dump --command pnacl-freeze \
+; RUN:   | %if --need=allow_dump --command not %llvm2ice -notranslate \
+; RUN:     -build-on-read -allow-pnacl-reader-error-recovery \
+; RUN:   | %if --need=allow_dump --command FileCheck %s
+
+; RUN: %if --need=no_dump --command llvm-as < %s \
+; RUN:   | %if --need=no_dump --command pnacl-freeze \
+; RUN:   | %if --need=no_dump --command not %llvm2ice -notranslate \
+; RUN:     -build-on-read -allow-pnacl-reader-error-recovery \
+; RUN:   | %if --need=no_dump --command FileCheck %s --check-prefix=MIN
 
 define void @ExtractV4xi1(<4 x i1> %v, i32 %i) {
   %e0 = extractelement <4 x i1> %v, i32 %i
 ; CHECK: Error: {{.*}} not {{.*}} constant
+; MIN: Error: {{.*}} Invalid function record: <6 4 3>

[jvoung (off chromium), 2014/11/19 19:57:55]

Hmm it wasn't clear to me what the first {{.*}} was, so I tried the patch =)

I don't think people will be able to do much with:

MIN: Error: (512:0) Invalid function record: <6 4 3>

This is contrast to:

CHECK: Error: (512:0) Vector index not integer constant: extractelement <4 x i1>
%__0, i32 %__1

=============

Can we try to make the two more similar?

CHECK: Error in function foo (512:0) Vector index not integer constant in
extractelement instruction: <4 x i1> %__0, i32 %__1

MIN: Error in function foo (512:0) Vector index not integer constant in
extractelement instruction.

Then the minimal version might omit the Instruction and operands dump, but allow
the dumpVectorIndexCheckValue. Then the context is the same and has the
containing function, the type of the inst record, and the reason, so is pretty
close to the full thing.

Other ideas? Other ways of formatting it? Recommend that people run
pnacl-abicheck (the in-browser error messages are pretty short)?

[Jim Stichnoth, 2014/11/19 23:30:36]

One thing Karl mentioned offline is that if the minimal build makes it hard to
debug, you can switch to a non-minimal build.  Does that address part of your
question?

That would be the cheap solution here.  Otherwise, some effort will be needed to
cleanly generate well-formatted messages without an over-abundance of "if
(ALLOW_DUMP) {...}" tests.

[jvoung (off chromium), 2014/11/19 23:59:51]

The cheap solution would be fine for development.

I'm trying to see what we want in the future in-browser translator, and I
imagined the minimal build is what we would use.

Right now with the in-browser pnacl-llc, we don't have very useful
*translation-time* error messages in the browser console, and an outside
developer would need to run some other tools to get more information.

E.g., see "[native-client-discuss] PNaCl ABI verification failed", or 
([native-client-discuss] (SIMD) Error reading bitcode file: Invalid argument):
https://code.google.com/p/nativeclient/issues/detail?id=3953.

Maybe this isn't a real problem, since the the linker is supposed to run ABI
verification after linking. However, some things seem to slip through sometimes
so maybe there is bug somewhere. Then we should focus on figuring out how things
slip through from build-time error to browser-translation-time error.


Either that or we can change the browser console message to say "please run
pnacl-abicheck for more details", so that it's more self-documenting?

[Karl, 2014/11/20 17:32:09]

I'm not sure that asking to run pnacl-abicheck is (necessarily) the  right
answer. That assumes that there wasn't a bug in the PNaCl bitcode file, so that
LLVM IR can be built.

Remember that (as in GO) there are now bitcode generators that may  have bugs in
them. These bugs may generate parsing error messages.

In any case, If I have read Jan's comments correctly, I assume that the current
solution is acceptable?

[jvoung (off chromium), 2014/11/20 18:14:43]

That's a good point. The errors can be for any number of reasons (ABI issues,
bitcode parsing issues, or maybe hitting something unexpected somewhere in a
later phase)... So is the solution then to ship a non-minimal commandline
version in the SDK, but a minimal browser version, and direct people to the
commandline version in the browser console? That could also be true for
pnacl-llc, so people may need to decide between running llvm2ice or pnacl-llc.
The in-browser-tool would know which it is, and could tell people which
commandline tool to run perhaps. Currently the message that shows up in the
browser is the message sent to report_fatal_error() in pnacl-llc, I believe.
Sure, this is okay for now. I just wanted to be sure
https://code.google.com/p/nativeclient/issues/detail?id=3953 is on the radar and
we consider that.

   %e1 = extractelement <4 x i1> %v, i32 4
 ; CHECK: Error: {{.*}} not in range
+; MIN: Error: {{.*}} Invalid function record: <6 5 3>
   %e2 = extractelement <4 x i1> %v, i32 9
 ; CHECK: Error: {{.*}} not in range
+; MIN: Error: {{.*}} Invalid function record:  <6 6 3>
   ret void
 }
 
 define void @ExtractV8xi1(<8 x i1> %v, i32 %i) {
   %e0 = extractelement <8 x i1> %v, i32 %i
 ; CHECK: Error: {{.*}} not {{.*}} constant
+; MIN: Error: {{.*}} Invalid function record: <6 4 3>
   %e1 = extractelement <8 x i1> %v, i32 8;
 ; CHECK: Error: {{.*}} not in range
+; MIN: Error: {{.*}} Invalid function record: <6 5 3>
   %e2 = extractelement <8 x i1> %v, i32 9;
 ; CHECK: Error: {{.*}} not in range
+; MIN: Error: {{.*}} Invalid function record: <6 6 3>
   ret void
 }
 
 define void @ExtractV16xi1(<16 x i1> %v, i32 %i) {
   %e0 = extractelement <16 x i1> %v, i32 %i
 ; CHECK: Error: {{.*}} not {{.*}} constant
+; MIN: Error: {{.*}} Invalid function record: <6 4 3>
   %e1 = extractelement <16 x i1> %v, i32 16
 ; CHECK: Error: {{.*}} not in range
+; MIN: Error: {{.*}} Invalid function record: <6 5 3>
   %e2 = extractelement <16 x i1> %v, i32 24
 ; CHECK: Error: {{.*}} not in range
+; MIN: Error: {{.*}} Invalid function record: <6 6 3>
   ret void
 }
 
 define void @ExtractV16xi8(<16 x i8> %v, i32 %i) {
   %e0 = extractelement <16 x i8> %v, i32 %i
 ; CHECK: Error: {{.*}} not {{.*}} constant
+; MIN: Error: {{.*}} Invalid function record: <6 4 3>
   %e1 = extractelement <16 x i8> %v, i32 16
 ; CHECK: Error: {{.*}} not in range
+; MIN: Error: {{.*}} Invalid function record: <6 5 3>
   %e2 = extractelement <16 x i8> %v, i32 71
 ; CHECK: Error: {{.*}} not in range
+; MIN: Error: {{.*}} Invalid function record: <6 6 3>
   ret void
 }
 
 define void @ExtractV8xi16(<8 x i16> %v, i32 %i) {
   %e0 = extractelement <8 x i16> %v, i32 %i
 ; CHECK: Error: {{.*}} not {{.*}} constant
+; MIN: Error: {{.*}} Invalid function record: <6 4 3>
   %e1 = extractelement <8 x i16> %v, i32 8
 ; CHECK: Error: {{.*}} not in range
+; MIN: Error: {{.*}} Invalid function record: <6 5 3>
   %e2 = extractelement <8 x i16> %v, i32 15
 ; CHECK: Error: {{.*}} not in range
+; MIN: Error: {{.*}} Invalid function record: <6 6 3>
   ret void
 }
 
 define i32 @ExtractV4xi32(<4 x i32> %v, i32 %i) {
   %e0 = extractelement <4 x i32> %v, i32 %i
 ; CHECK: Error: {{.*}} not {{.*}} constant
+; MIN: Error: {{.*}} Invalid function record: <6 4 3>
   %e1 = extractelement <4 x i32> %v, i32 4
 ; CHECK: Error: {{.*}} not in range
+; MIN: Error: {{.*}} Invalid function record: <6 5 3>
   %e2 = extractelement <4 x i32> %v, i32 17
 ; CHECK: Error: {{.*}} not in range
+; MIN: Error: {{.*}} Invalid function record: <6 6 3>
   ret i32 %e0
 }
 
 define float @ExtractV4xfloat(<4 x float> %v, i32 %i) {
   %e0 = extractelement <4 x float> %v, i32 %i
 ; CHECK: Error: {{.*}} not {{.*}} constant
+; MIN: Error: {{.*}} Invalid function record: <6 3 2>
   %e1 = extractelement <4 x float> %v, i32 4
 ; CHECK: Error: {{.*}} not in range
+; MIN: Error: {{.*}} Invalid function record: <6 4 2>
   %e2 = extractelement <4 x float> %v, i32 4
 ; CHECK: Error: {{.*}} not in range
+; MIN: Error: {{.*}} Invalid function record: <6 5 3>
   ret float %e2
 }
 
 define <4 x i1> @InsertV4xi1(<4 x i1> %v, i32 %i) {
   %r0 = insertelement <4 x i1> %v, i1 1, i32 %i
 ; CHECK: Error: {{.*}} not {{.*}} constant
+; MIN: Error: {{.*}} Invalid function record: <7 5 1 4>
   %r1 = insertelement <4 x i1> %v, i1 1, i32 4
 ; CHECK: Error: {{.*}} not in range
+; MIN: Error: {{.*}} Invalid function record: <7 6 2 4>
   %r2 = insertelement <4 x i1> %v, i1 1, i32 7
 ; CHECK: Error: {{.*}} not in range
+; MIN: Error: {{.*}} Invalid function record: <7 7 3 4>
   ret <4 x i1> %r2
 }
 
 define <8 x i1> @InsertV8xi1(<8 x i1> %v, i32 %i) {
   %r0 = insertelement <8 x i1> %v, i1 0, i32 %i
 ; CHECK: Error: {{.*}} not {{.*}} constant
+; MIN: Error: {{.*}} Invalid function record: <7 5 1 4>
   %r1 = insertelement <8 x i1> %v, i1 0, i32 8
 ; CHECK: Error: {{.*}} not in range
+; MIN: Error: {{.*}} Invalid function record: <7 6 2 4>
   %r2 = insertelement <8 x i1> %v, i1 0, i32 88
 ; CHECK: Error: {{.*}} not in range
+; MIN: Error: {{.*}} Invalid function record: <7 7 3 4>
   ret <8 x i1> %r2
 }
 
 define <16 x i1> @InsertV16xi1(<16 x i1> %v, i32 %i) {
   %r = insertelement <16 x i1> %v, i1 1, i32 %i
 ; CHECK: Error: {{.*}} not {{.*}} constant
+; MIN: Error: {{.*}} Invalid function record: <7 5 1 4>
   ret <16 x i1> %r
   %r1 = insertelement <16 x i1> %v, i1 1, i32 16
 ; CHECK: Error: {{.*}} not in range
+; MIN: Error: {{.*}} Invalid function record: <7 6 2 4>
   %r2 = insertelement <16 x i1> %v, i1 1, i32 31
 ; CHECK: Error: {{.*}} not in range
+; MIN: Error: {{.*}} Invalid function record: <7 7 3 4>
   ret <16 x i1> %r2
 }
 
 define <16 x i8> @InsertV16xi8(<16 x i8> %v, i32 %i) {
   %r0 = insertelement <16 x i8> %v, i8 34, i32 %i
 ; CHECK: Error: {{.*}} not {{.*}} constant
+; MIN: Error: {{.*}} Invalid function record: <7 5 1 4>
   %r1 = insertelement <16 x i8> %v, i8 34, i32 16
 ; CHECK: Error: {{.*}} not in range
+; MIN: Error: {{.*}} Invalid function record: <7 6 2 4>
   %r2 = insertelement <16 x i8> %v, i8 34, i32 19
 ; CHECK: Error: {{.*}} not in range
+; MIN: Error: {{.*}} Invalid function record: <7 7 3 4>
   ret <16 x i8> %r0
 }
 
 define <8 x i16> @InsertV8xi16(<8 x i16> %v, i32 %i) {
   %r0 = insertelement <8 x i16> %v, i16 289, i32 %i
 ; CHECK: Error: {{.*}} not {{.*}} constant
+; MIN: Error: {{.*}} Invalid function record: <7 5 1 4>
   %r1 = insertelement <8 x i16> %v, i16 289, i32 8
 ; CHECK: Error: {{.*}} not in range
+; MIN: Error: {{.*}} Invalid function record: <7 6 2 4>
   %r2 = insertelement <8 x i16> %v, i16 289, i32 19
 ; CHECK: Error: {{.*}} not in range
+; MIN: Error: {{.*}} Invalid function record: <7 7 3 4>
   ret <8 x i16> %r1
 }
 
 define <4 x i32> @InsertV4xi32(<4 x i32> %v, i32 %i) {
   %r0 = insertelement <4 x i32> %v, i32 54545454, i32 %i
 ; CHECK: Error: {{.*}} not {{.*}} constant
+; MIN: Error: {{.*}} Invalid function record: <7 5 3 4>
   %r1 = insertelement <4 x i32> %v, i32 54545454, i32 4
 ; CHECK: Error: {{.*}} not in range
+; MIN: Error: {{.*}} Invalid function record: <7 6 4 3>
   %r2 = insertelement <4 x i32> %v, i32 54545454, i32 9
 ; CHECK: Error: {{.*}} not in range
+; MIN: Error: {{.*}} Invalid function record: <7 7 5 3>
   ret <4 x i32> %r2
 }
 
 define <4 x float> @InsertV4xfloat(<4 x float> %v, i32 %i) {
   %r0 = insertelement <4 x float> %v, float 3.0, i32 %i
 ; CHECK: Error: {{.*}} not {{.*}} constant
+; MIN: Error: {{.*}} Invalid function record: <7 5 1 4>
   %r1 = insertelement <4 x float> %v, float 3.0, i32 4
 ; CHECK: Error: {{.*}} not in range
+; MIN: Error: {{.*}} Invalid function record: <7 6 2 4>
   %r2 = insertelement <4 x float> %v, float 3.0, i32 44
 ; CHECK: Error: {{.*}} not in range
+; MIN: Error: {{.*}} Invalid function record: <7 7 3 4>
   ret <4 x float> %r2
 }