Merge pull request #61551 from nate-chandler/siloptimizer-unittests

[SILOptimizer] Add faux unit testing mechanism.

Author: nate-chandler

docs/SIL.rst

@@ -3924,6 +3924,52 @@ SIL DIExpression can have elements with various types, like AST nodes or strings
 
 The ``[trace]`` flag is available for compiler unit testing. It is not produced during normal compilation. It is used combination with internal logging and optimization controls to select specific values to trace or to transform. For example, liveness analysis combines all "traced" values into a single live range with multiple definitions. This exposes corner cases that cannot be represented by passing valid SIL through the pipeline.
 
+Testing
+~~~~~~~
+
+test_specification
+``````````````````
+::
+
+  sil-instruction ::= 'test_specification' string-literal
+
+  test_specification "parsing @trace[3] @function[other].block[2].instruction[1]"
+
+Exists only for writing FileCheck tests.  Specifies a list of test arguments
+which should be used in order to run a particular test "in the context" of the
+function containing the instruction.
+
+Parsing of these test arguments is done via ``parseTestArgumentsFromSpecification``.
+
+The following types of test arguments are supported:
+
+- boolean: true false
+- unsigned integer: 0...ULONG_MAX
+- string
+- function: @function <-- the current function
+            @function[uint] <-- function at index ``uint``
+            @function[name] <-- function named ``name``
+- block: @block <-- the first 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[uint] <-- the instruction at index ``uint``
+               @{function}.{instruction} <-- the indicated instruction in the indicated function
+               Example: @function[baz].instruction[19]
+               @{block}.{instruction} <-- the indicated instruction in the indicated block
+               Example: @function[bam].block.instruction
+- operand: @operand <-- the first operand
+           @operand[uint] <-- the operand at index ``uint``
+           @{instruction}.{operand} <-- the indicated operand of the indicated instruction
+           Example: @block[19].instruction[2].operand[3]
+           Example: @function[2].instruction.operand
+
+
 Profiling
 ~~~~~~~~~
 

include/swift/AST/DiagnosticsParse.def

@@ -539,6 +539,8 @@ ERROR(expected_sil_profiler_counter_total,none,
       "expected profiler counter total", ())
 ERROR(expected_sil_profiler_counter_hash,none,
       "expected profiler counter hash", ())
+ERROR(expected_sil_test_specification_body,none,
+      "expected a string consisting of the space-separated test arguments", ())
 
 // SIL Values
 ERROR(sil_value_redefinition,none,

include/swift/SIL/SILBuilder.h

@@ -988,6 +988,13 @@ class SILBuilder {
     return createDebugValue(Loc, src, Var);
   }
 
+  TestSpecificationInst *
+  createTestSpecificationInst(SILLocation Loc,
+                              StringRef ArgumentsSpecification) {
+    return insert(TestSpecificationInst::create(
+        getSILDebugLocation(Loc), ArgumentsSpecification, getModule()));
+  }
+
 #define NEVER_LOADABLE_CHECKED_REF_STORAGE(Name, ...) \
   Load##Name##Inst *createLoad##Name(SILLocation Loc, \
                                      SILValue src, \

include/swift/SIL/SILCloner.h

@@ -2631,6 +2631,15 @@ void SILCloner<ImplClass>::visitIncrementProfilerCounterInst(
                               Inst->getNumCounters(), Inst->getPGOFuncHash()));
 }
 
+template <typename ImplClass>
+void SILCloner<ImplClass>::visitTestSpecificationInst(
+    TestSpecificationInst *Inst) {
+  getBuilder().setCurrentDebugScope(getOpScope(Inst->getDebugScope()));
+  recordClonedInstruction(Inst, getBuilder().createTestSpecificationInst(
+                                    getOpLocation(Inst->getLoc()),
+                                    Inst->getArgumentsSpecification()));
+}
+
 template<typename ImplClass>
 void
 SILCloner<ImplClass>::visitIndexAddrInst(IndexAddrInst *Inst) {

include/swift/SIL/SILInstruction.h

@@ -4933,6 +4933,32 @@ class DebugValueInst final
   }
 };
 
+class TestSpecificationInst final
+    : public InstructionBase<SILInstructionKind::TestSpecificationInst,
+                             NonValueInstruction>,
+      private llvm::TrailingObjects<TestSpecificationInst, char> {
+  friend TrailingObjects;
+  friend SILBuilder;
+
+  unsigned ArgumentsSpecificationLength;
+
+  TestSpecificationInst(SILDebugLocation Loc,
+                        unsigned ArgumentsSpecificationLength)
+      : InstructionBase(Loc),
+        ArgumentsSpecificationLength(ArgumentsSpecificationLength) {}
+
+  static TestSpecificationInst *
+  create(SILDebugLocation Loc, StringRef argumentsSpecification, SILModule &M);
+
+public:
+  StringRef getArgumentsSpecification() const {
+    return StringRef(getTrailingObjects<char>(), ArgumentsSpecificationLength);
+  }
+
+  ArrayRef<Operand> getAllOperands() const { return {}; }
+  MutableArrayRef<Operand> getAllOperands() { return {}; }
+};
+
 /// An abstract class representing a load from some kind of reference storage.
 template <SILInstructionKind K>
 class LoadReferenceInstBase

include/swift/SIL/SILNodes.def

@@ -765,6 +765,8 @@ NON_VALUE_INST(MarkFunctionEscapeInst, mark_function_escape,
                SILInstruction, None, DoesNotRelease)
 NON_VALUE_INST(DebugValueInst, debug_value,
                SILInstruction, None, DoesNotRelease)
+NON_VALUE_INST(TestSpecificationInst, test_specification,
+               SILInstruction, None, DoesNotRelease)
 #define NEVER_OR_SOMETIMES_LOADABLE_CHECKED_REF_STORAGE(Name, name, ...) \
   NON_VALUE_INST(Store##Name##Inst, store_##name, \
                  SILInstruction, MayWrite, DoesNotRelease)

include/swift/SILOptimizer/PassManager/Passes.def

@@ -445,6 +445,8 @@ PASS(SimplifyUnreachableContainingBlocks, "simplify-unreachable-containing-block
      "Utility pass. Removes all non-term insts from blocks with unreachable terms")
 PASS(SerializeSILPass, "serialize-sil",
      "Utility pass. Serializes the current SILModule")
+PASS(UnitTestRunner, "unit-test-runner",
+     "Utility pass.  Parses arguments and runs code with them.")
 PASS(YieldOnceCheck, "yield-once-check",
     "Check correct usage of yields in yield-once coroutines")
 PASS(OSLogOptimization, "os-log-optimization", "Optimize os log calls")

include/swift/SILOptimizer/Utils/ParseTestSpecification.h

@@ -0,0 +1,169 @@
+//===- ParseTestSpecification.h - Parsing for test instructions -*- C++ -*-===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2022 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+//
+// This file defines Test::Argument.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SWIFT_SIL_PARSETESTSPECIFICATION
+#define SWIFT_SIL_PARSETESTSPECIFICATION
+
+#include "swift/Basic/TaggedUnion.h"
+#include "swift/SIL/SILValue.h"
+#include "llvm/ADT/StringRef.h"
+
+namespace llvm {
+template <class T>
+class SmallVectorImpl;
+}
+using llvm::StringRef;
+
+namespace swift {
+
+class SILFunction;
+
+namespace test {
+
+struct Argument {
+  enum class Kind {
+    String,
+    Bool,
+    UInt,
+    Value,
+    Operand,
+    Instruction,
+    Block,
+    Function,
+  };
+  using Union = TaggedUnion<StringRef,          // StringArgument
+                            bool,               // BoolArgument
+                            unsigned long long, // UIntArgument
+                            SILValue,           // ValueArgument
+                            Operand *,          // OperandArgument
+                            SILInstruction *,   // InstructionArgument
+                            SILBasicBlock *,    // BlockArgument
+                            SILFunction *       // FunctionArgument
+                            >;
+
+private:
+  Kind kind;
+
+protected:
+  Argument(Union storage, Kind kind) : kind(kind), storage(storage) {}
+  Union storage;
+
+public:
+  Kind getKind() const { return kind; }
+};
+
+template <typename Stored, Argument::Kind TheKind>
+struct ConcreteArgument : Argument {
+  using Super = ConcreteArgument<Stored, TheKind>;
+  ConcreteArgument(Stored stored) : Argument(Union{stored}, TheKind) {}
+  Stored getValue() { return storage.get<Stored>(); }
+  static bool classof(const Argument *argument) {
+    return argument->getKind() == TheKind;
+  }
+};
+
+struct ValueArgument : ConcreteArgument<SILValue, Argument::Kind::Value> {
+  ValueArgument(SILValue stored) : Super(stored) {}
+};
+
+struct OperandArgument : ConcreteArgument<Operand *, Argument::Kind::Operand> {
+  OperandArgument(Operand *stored) : Super(stored) {}
+};
+
+struct InstructionArgument
+    : ConcreteArgument<SILInstruction *, Argument::Kind::Instruction> {
+  InstructionArgument(SILInstruction *stored) : Super(stored) {}
+};
+
+struct BlockArgument
+    : ConcreteArgument<SILBasicBlock *, Argument::Kind::Block> {
+  BlockArgument(SILBasicBlock *stored) : Super(stored) {}
+};
+
+struct FunctionArgument
+    : ConcreteArgument<SILFunction *, Argument::Kind::Function> {
+  FunctionArgument(SILFunction *stored) : Super(stored) {}
+};
+
+struct BoolArgument : ConcreteArgument<bool, Argument::Kind::Bool> {
+  BoolArgument(bool stored) : Super(stored) {}
+};
+
+struct UIntArgument
+    : ConcreteArgument<unsigned long long, Argument::Kind::UInt> {
+  UIntArgument(unsigned long long stored) : Super(stored) {}
+};
+
+struct StringArgument : ConcreteArgument<StringRef, Argument::Kind::String> {
+  StringArgument(StringRef stored) : Super(stored) {}
+};
+
+struct Arguments {
+  llvm::SmallVector<Argument, 8> storage;
+  unsigned untakenIndex = 0;
+
+  void assertUsed() {
+    assert(untakenIndex == storage.size() && "arguments remain!");
+  }
+
+  void clear() {
+    assertUsed();
+    storage.clear();
+    untakenIndex = 0;
+  }
+
+  Arguments() {}
+  Arguments(Arguments const &) = delete;
+  Arguments &operator=(Arguments const &) = delete;
+  ~Arguments() { assertUsed(); }
+  Argument &takeArgument() { return storage[untakenIndex++]; }
+  StringRef takeString() {
+    return cast<StringArgument>(takeArgument()).getValue();
+  }
+  bool takeBool() { return cast<BoolArgument>(takeArgument()).getValue(); }
+  unsigned long long takeUInt() {
+    return cast<UIntArgument>(takeArgument()).getValue();
+  }
+  SILValue takeValue() {
+    return cast<ValueArgument>(takeArgument()).getValue();
+  }
+  Operand *takeOperand() {
+    return cast<OperandArgument>(takeArgument()).getValue();
+  }
+  SILInstruction *takeInstruction() {
+    return cast<InstructionArgument>(takeArgument()).getValue();
+  }
+  SILBasicBlock *takeBlock() {
+    return cast<BlockArgument>(takeArgument()).getValue();
+  }
+  SILFunction *takeFunction() {
+    return cast<FunctionArgument>(takeArgument()).getValue();
+  }
+};
+
+/// 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 parseTestArgumentsFromSpecification(
+    SILFunction *, StringRef specification, Arguments &arguments,
+    SmallVectorImpl<StringRef> &argumentStrings);
+
+} // namespace test
+} // namespace swift
+
+#endif

lib/IRGen/IRGenSIL.cpp

@@ -1384,6 +1384,9 @@ class IRGenSILFunction :
   void visitLinearFunctionExtractInst(LinearFunctionExtractInst *i);
   void visitDifferentiabilityWitnessFunctionInst(
       DifferentiabilityWitnessFunctionInst *i);
+  void visitTestSpecificationInst(TestSpecificationInst *i) {
+    llvm_unreachable("test-only instruction in Lowered SIL?!");
+  }
 
 #define LOADABLE_REF_STORAGE_HELPER(Name)                                      \
   void visitRefTo##Name##Inst(RefTo##Name##Inst *i);                           \

lib/SIL/IR/OperandOwnership.cpp

@@ -120,6 +120,7 @@ SHOULD_NEVER_VISIT_INST(ReleaseValueAddr)
 SHOULD_NEVER_VISIT_INST(StrongRelease)
 SHOULD_NEVER_VISIT_INST(GetAsyncContinuation)
 SHOULD_NEVER_VISIT_INST(IncrementProfilerCounter)
+SHOULD_NEVER_VISIT_INST(TestSpecification)
 
 #define ALWAYS_OR_SOMETIMES_LOADABLE_CHECKED_REF_STORAGE(Name, ...)            \
   SHOULD_NEVER_VISIT_INST(StrongRetain##Name)                                  \