[Test] Allow specifying instructions by offset.

Make @Instruction[+1] refer to the instruction after the "current"
instruction, @Instruction[-1] the one before, and so on.

Author: nate-chandler

docs/SIL.rst

@@ -3958,6 +3958,8 @@ The following types of test arguments are supported:
          @{function}.{trace} <-- the indicated trace in the indicated function
          Example: @function[bar].trace
 - instruction: @instruction <-- the instruction after* the test_specification instruction
+               @instruction[+uint] <-- the instruction ``uint`` instructions after* the test_specification instruction
+               @instruction[-uint] <-- the instruction ``uint`` instructions before* the test_specification instruction
                @instruction[uint] <-- the instruction at index ``uint``
                @{function}.{instruction} <-- the indicated instruction in the indicated function
                Example: @function[baz].instruction[19]
@@ -3969,7 +3971,7 @@ The following types of test arguments are supported:
            Example: @block[19].instruction[2].operand[3]
            Example: @function[2].instruction.operand
 
-* The first instruction that isn't deleted when processing functions for tests.
+* Not counting instructions that are deleted when processing functions for tests.
   The following instructions currently are deleted:
     test_specification
     debug_value [trace]

lib/SILOptimizer/UtilityPasses/ParseTestSpecification.cpp

@@ -84,6 +84,40 @@ SILInstruction *getInstruction(SILBasicBlock *block, unsigned long index) {
   llvm_unreachable("bad index!?");
 }
 
+SILInstruction *getInstructionOffsetFrom(SILInstruction *base, long offset) {
+  if (offset == 0) {
+    return base;
+  }
+  if (offset > 0) {
+    Optional<unsigned long> baseIndex;
+    unsigned long index = 0;
+    for (auto &block : *base->getFunction()) {
+      for (auto &other : block) {
+        if (baseIndex && index == (*baseIndex + offset)) {
+          return &other;
+        }
+        if (&other == base) {
+          baseIndex = index;
+        }
+        ++index;
+      }
+    }
+    llvm_unreachable("positive offset outside of function!?");
+  }
+  SmallVector<SILInstruction *, 64> instructions;
+  unsigned long index = 0;
+  for (auto &block : *base->getFunction()) {
+    for (auto &other : block) {
+      instructions.push_back(&other);
+      if (&other == base) {
+        return instructions[index + offset];
+      }
+      ++index;
+    }
+  }
+  llvm_unreachable("never found instruction in its own function!?");
+}
+
 SILBasicBlock *getBlock(SILFunction *function, unsigned long index) {
   auto iterator = function->begin();
   for (unsigned long i = 0; i < index; ++i) {

test/SILOptimizer/unit_test.sil

@@ -98,8 +98,14 @@ bb1:
 // CHECK: tuple
 // CHECK-LABEL: end running test 2 of {{[^,]+}} on test_contextual_arg_parsing: test-specification-parsing
 // CHECK-LABEL: begin running test 3 of {{[^,]+}} on test_contextual_arg_parsing: test-specification-parsing
-// CHECK: function: test_contextual_arg_parsing
+// CHECK: instruction: br bb2
+// CHECK: instruction: {{%[^,]+}} = tuple ()
+// CHECK: instruction: br bb3
+// CHECK: instruction: return
 // CHECK-LABEL: end running test 3 of {{[^,]+}} on test_contextual_arg_parsing: test-specification-parsing
+// CHECK-LABEL: begin running test 4 of {{[^,]+}} on test_contextual_arg_parsing: test-specification-parsing
+// CHECK: function: test_contextual_arg_parsing
+// CHECK-LABEL: end running test 4 of {{[^,]+}} on test_contextual_arg_parsing: test-specification-parsing
 sil [ossa] @test_contextual_arg_parsing : $() -> () {
 entry:
   br one
@@ -108,6 +114,7 @@ one:
   br two
 two:
   test_specification "test-specification-parsing I @instruction"
+  test_specification "test-specification-parsing IIII @instruction[-1] @instruction[+0] @instruction[+1] @instruction[+2]"
   %retval = tuple ()
   br exit
 exit: