Merge pull request #61656 from nate-chandler/test/20221020/1

[Test] Added a few conveniences.

Author: nate-chandler

docs/SIL.rst

@@ -3949,15 +3949,19 @@ The following types of test arguments are supported:
 - function: @function <-- the current function
             @function[uint] <-- function at index ``uint``
             @function[name] <-- function named ``name``
-- block: @block <-- the first block
+- block: @block <-- the block containing the test_specification instruction
+         @block[+uint] <-- the block ``uint`` blocks after the containing block
+         @block[-uint] <-- the block ``uint`` blocks before the containing block
          @block[uint] <-- the block at index ``uint``
          @{function}.{block} <-- the indicated block in the indicated function
          Example: @function[foo].block[2]
 - trace: @trace <-- the first ``debug_value [trace]`` in the current function
          @trace[uint] <-- the ``debug_value [trace]`` at index ``uint``
          @{function}.{trace} <-- the indicated trace in the indicated function
          Example: @function[bar].trace
-- instruction: @instruction <-- the first instruction
+- 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,6 +3973,11 @@ The following types of test arguments are supported:
            Example: @block[19].instruction[2].operand[3]
            Example: @function[2].instruction.operand
 
+* Not counting instructions that are deleted when processing functions for tests.
+  The following instructions currently are deleted:
+    test_specification
+    debug_value [trace]
+
 
 Profiling
 ~~~~~~~~~

include/swift/SILOptimizer/Utils/ParseTestSpecification.h

@@ -18,6 +18,7 @@
 #define SWIFT_SIL_PARSETESTSPECIFICATION
 
 #include "swift/Basic/TaggedUnion.h"
+#include "swift/SIL/SILInstruction.h"
 #include "swift/SIL/SILValue.h"
 #include "llvm/ADT/StringRef.h"
 
@@ -140,7 +141,13 @@ struct Arguments {
     return cast<UIntArgument>(takeArgument()).getValue();
   }
   SILValue takeValue() {
-    return cast<ValueArgument>(takeArgument()).getValue();
+    auto argument = takeArgument();
+    if (isa<InstructionArgument>(argument)) {
+      auto *instruction = cast<InstructionArgument>(argument).getValue();
+      auto *svi = cast<SingleValueInstruction>(instruction);
+      return svi;
+    }
+    return cast<ValueArgument>(argument).getValue();
   }
   Operand *takeOperand() {
     return cast<OperandArgument>(takeArgument()).getValue();
@@ -156,17 +163,32 @@ struct Arguments {
   }
 };
 
+/// The specification for a test which has not yet been parsed.
+struct UnparsedSpecification {
+  /// The string which specifies the test.
+  ///
+  /// Not a StringRef because the TestSpecificationInst whose payload is of
+  /// interest gets deleted.
+  std::string string;
+  /// The next non-debug instruction.
+  ///
+  /// Provides an "anchor" for the specification.  Contextual arguments
+  /// (@instruction, @block, @function) can be parsed in terms of this anchor.
+  SILInstruction *context;
+};
+
 /// Finds and deletes each test_specification instruction in \p function and
 /// appends its string payload to the provided vector.
-void getTestSpecifications(SILFunction *function,
-                           SmallVectorImpl<std::string> &specifications);
+void getTestSpecifications(
+    SILFunction *function,
+    SmallVectorImpl<UnparsedSpecification> &specifications);
 
 /// Given the string \p specification operand of a test_specification
 /// instruction from \p function, parse the arguments which it refers to into
 /// \p arguments and the component strings into \p argumentStrings.
 void parseTestArgumentsFromSpecification(
-    SILFunction *function, StringRef specification, Arguments &arguments,
-    SmallVectorImpl<StringRef> &argumentStrings);
+    SILFunction *function, UnparsedSpecification const &specification,
+    Arguments &arguments, SmallVectorImpl<StringRef> &argumentStrings);
 
 } // namespace test
 } // namespace swift