[SwiftCompilerSources] Bridged in-IR testing.

nate-chandler · nate-chandler · commit dab8c146a620 · 2023-09-28T11:33:50.000-07:00
Added the bridging types involved and the basic functionality.
diff --git a/SwiftCompilerSources/Sources/Optimizer/PassManager/PassRegistration.swift b/SwiftCompilerSources/Sources/Optimizer/PassManager/PassRegistration.swift
@@ -20,6 +20,7 @@ public func initializeSwiftModules() {
   registerSwiftAnalyses()
   registerSwiftPasses()
   initializeSwiftParseModules()
+  registerSILTests()
 }
 
 private func registerPass(
diff --git a/SwiftCompilerSources/Sources/SIL/CMakeLists.txt b/SwiftCompilerSources/Sources/SIL/CMakeLists.txt
@@ -23,6 +23,7 @@ add_swift_compiler_module(SIL
     Registration.swift
     SmallProjectionPath.swift
     SubstitutionMap.swift
+    Test.swift
     Type.swift
     Utils.swift
     Value.swift
diff --git a/SwiftCompilerSources/Sources/SIL/Test.swift b/SwiftCompilerSources/Sources/SIL/Test.swift
@@ -0,0 +1,151 @@
+//===----------- Test.swift - In-IR tests from Swift source ---------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2023 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
+//
+//===----------------------------------------------------------------------===//
+//
+// TO ADD A NEW TEST, just add a new FunctionTest instance.
+// - In the source file containing the functionality you want to test:
+//       let myNewTest = 
+//       FunctionTest("my_new_test") { function, arguments, context in
+//       }
+// - In SwiftCompilerSources/Sources/SIL/Test.swift's registerSILTests function,
+//   register the new test:
+//       registerFunctionTest(myNewTest, implementation: { myNewTest.run($0, $1, $2) })
+//
+//===----------------------------------------------------------------------===//
+//
+// Provides a mechanism for writing tests against compiler code in the context
+// of a function.  The goal is to get the same effect as calling a function and
+// checking its output.
+//
+// This is done via the specify_test instruction.  Using one or more instances
+// of it in your test case's SIL function, you can specify which test (instance
+// of FunctionTest) should be run and what arguments should be provided to it.
+// The test grabs the arguments it expects out of the TestArguments instance
+// it is provided.  It calls some function or functions.  It then prints out
+// interesting results.  These results can then be FileCheck'd.
+//
+// CASE STUDY:
+// Here's an example of how it works:
+// 0) A source file, NeatUtils.cpp contains
+//
+//    fileprivate func myNeatoUtility(int: Int, value: Value, function: Function) { ... }
+//
+//    and
+//
+//    let myNeatoUtilityTest = 
+//    FunctionTest("my_neato_utility") { function, arguments, test in
+//         // The code here is described in detail below.
+//         // See 4).
+//         let count = arguments.takeInt()
+//         let target = arguments.takeValue()
+//         let callee = arguments.takeFunction()
+//         // See 5)
+//         myNeatoUtility(int: count, value: target, function: callee)
+//         // See 6)
+//         print(function)
+//      }
+// 1) A test test/SILOptimizer/interesting_functionality_unit.sil runs the
+//    TestRunner pass:
+//     // RUN: %target-sil-opt -test-runner %s -o /dev/null 2>&1 | %FileCheck %s
+// 2) A function in interesting_functionality_unit.sil contains the
+//    specify_test instruction.
+//      sil @f : $() -> () {
+//      ...
+//      specify_test "my_neato_utility 43 %2 @function[other_fun]"
+//      ...
+//      }
+// 3) TestRunner finds the FunctionTest instance myNeatoUtilityTest registered
+//    under the name "my_neato_utility", and calls run() on it, passing the
+//    passing first the function, last the FunctionTest instance, AND in the
+//    middle, most importantly a TestArguments instance that contains
+//
+//      (43 : Int, someValue : Value, other_fun : Function)
+//
+// 4) myNeatoUtilityTest calls takeUInt(), takeValue(), and takeFunction() on
+//    the test::Arguments instance.
+//      let count = arguments.takeInt()
+//      let target = arguments.takeValue()
+//      let callee = arguments.takeFunction()
+// 5) myNeatoUtilityTest calls myNeatoUtility, passing these values along.
+//      myNeatoUtility(int: count, value: target, function: callee)
+// 6) myNeatoUtilityTest then dumps out the current function, which was modified
+//    in the process.
+//      print(function)
+// 7) The test file test/SILOptimizer/interesting_functionality_unit.sil matches
+// the
+//    expected contents of the modified function:
+//    // CHECK-LABEL: sil @f
+//    // CHECK-NOT:     function_ref @other_fun
+//
+//===----------------------------------------------------------------------===//
+
+import Basic
+import SILBridging
+
+public struct FunctionTest {
+  public var name: String
+  public typealias FunctionTestImplementation = (Function, TestArguments, TestContext) -> ()
+  private var implementation: FunctionTestImplementation
+  init(name: String, implementation: @escaping FunctionTestImplementation) {
+    self.name = name
+    self.implementation = implementation
+  }
+  fileprivate func run(
+    _ function: BridgedFunction, 
+    _ arguments: BridgedTestArguments, 
+    _ test: BridgedTestContext) {
+    implementation(function.function, arguments.native, test.native)
+  }
+}
+
+public struct TestArguments {
+  public var bridged: BridgedTestArguments
+  fileprivate init(bridged: BridgedTestArguments) {
+    self.bridged = bridged
+  }
+
+  public var hasUntaken: Bool { bridged.hasUntaken() }
+  public func takeString() -> StringRef { StringRef(bridged: bridged.takeString()) }
+  public func takeBool() -> Bool { bridged.takeBool() }
+  public func takeInt() -> Int { bridged.takeInt() }
+  public func takeOperand() -> Operand { Operand(bridged: bridged.takeOperand()) }
+  public func takeValue() -> Value { bridged.takeValue().value }
+  public func takeInstruction() -> Instruction { bridged.takeInstruction().instruction }
+  public func takeArgument() -> Argument { bridged.takeArgument().argument }
+  public func takeBlock() -> BasicBlock { bridged.takeBlock().block }
+  public func takeFunction() -> Function { bridged.takeFunction().function }
+}
+
+extension BridgedTestArguments {
+  public var native: TestArguments { TestArguments(bridged: self) }
+}
+
+public struct TestContext {
+  public var bridged: BridgedTestContext
+  fileprivate init(bridged: BridgedTestContext) {
+    self.bridged = bridged
+  }
+}
+
+extension BridgedTestContext {
+  public var native: TestContext { TestContext(bridged: self) }
+}
+
+private func registerFunctionTest(
+  _ test: FunctionTest,
+  implementation: BridgedFunctionTestThunk) {
+  test.name._withStringRef { ref in
+    registerFunctionTest(ref, implementation)
+  }
+}
+
+public func registerSILTests() {
+}
diff --git a/include/swift/SIL/SILBridging.h b/include/swift/SIL/SILBridging.h
@@ -1522,6 +1522,50 @@ BridgedBasicBlock BridgedArgument::getParent() const {
   return {getArgument()->getParent()};
 }
 
+namespace swift::test {
+struct Arguments;
+class FunctionTest;
+} // namespace swift::test
+
+struct BridgedTestArguments {
+  swift::test::Arguments *_Nonnull arguments;
+
+  bool hasUntaken() const;
+
+  SWIFT_IMPORT_UNSAFE
+  llvm::StringRef takeString() const;
+
+  bool takeBool() const;
+
+  SwiftInt takeInt() const;
+
+  SWIFT_IMPORT_UNSAFE
+  BridgedOperand takeOperand() const;
+
+  SWIFT_IMPORT_UNSAFE
+  BridgedValue takeValue() const;
+
+  SWIFT_IMPORT_UNSAFE
+  BridgedInstruction takeInstruction() const;
+
+  SWIFT_IMPORT_UNSAFE
+  BridgedArgument takeArgument() const;
+
+  SWIFT_IMPORT_UNSAFE
+  BridgedBasicBlock takeBlock() const;
+
+  SWIFT_IMPORT_UNSAFE
+  BridgedFunction takeFunction() const;
+};
+
+struct BridgedTestContext {
+  swift::SwiftPassInvocation *_Nonnull invocation;
+};
+
+typedef void (*_Nonnull BridgedFunctionTestThunk)(BridgedFunction,
+                                                  BridgedTestArguments,
+                                                  BridgedTestContext);
+void registerFunctionTest(llvm::StringRef, BridgedFunctionTestThunk thunk);
 
 SWIFT_END_NULLABILITY_ANNOTATIONS
 
diff --git a/include/swift/SIL/Test.h b/include/swift/SIL/Test.h
@@ -98,6 +98,7 @@
 #define SWIFT_SIL_TEST_H
 
 #include "swift/SIL/ParseTestSpecification.h"
+#include "swift/SIL/SILBridging.h"
 
 namespace swift {
 
@@ -129,9 +130,12 @@ class FunctionTest final {
   ///                    values such as the results of analyses
   using Invocation = void (*)(SILFunction &, Arguments &, FunctionTest &);
 
+  using InvocationWithContext = void (*)(SILFunction &, Arguments &,
+                                         FunctionTest &, void *);
+
 private:
   /// The lambda to be run.
-  Invocation invocation;
+  TaggedUnion<Invocation, std::pair<InvocationWithContext, void *>> invocation;
 
 public:
   /// Creates a test that will run \p invocation and stores it in the global
@@ -147,6 +151,8 @@ class FunctionTest final {
   ///     } // end namespace swift::test
   FunctionTest(StringRef name, Invocation invocation);
 
+  FunctionTest(StringRef name, void *context, InvocationWithContext invocation);
+
   /// Computes and returns the function's dominance tree.
   DominanceInfo *getDominanceInfo();
 
@@ -161,6 +167,8 @@ class FunctionTest final {
   template <typename Analysis, typename Transform = SILFunctionTransform>
   Analysis *getAnalysis();
 
+  BridgedTestContext getContext();
+
 //===----------------------------------------------------------------------===//
 //=== MARK: Implementation Details                                         ===
 //===----------------------------------------------------------------------===//
@@ -239,6 +247,7 @@ class FunctionTest final {
   struct Dependencies {
     virtual DominanceInfo *getDominanceInfo() = 0;
     virtual SILPassManager *getPassManager() = 0;
+    virtual SwiftPassInvocation *getInvocation() = 0;
     virtual ~Dependencies(){};
   };
 
diff --git a/lib/SIL/Utils/SILBridging.cpp b/lib/SIL/Utils/SILBridging.cpp
@@ -10,15 +10,17 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "swift/Basic/BridgingUtils.h"
+#include "swift/SIL/SILBridging.h"
 #include "swift/AST/Attr.h"
 #include "swift/AST/SemanticAttrs.h"
-#include "swift/SIL/SILNode.h"
+#include "swift/Basic/BridgingUtils.h"
 #include "swift/SIL/ApplySite.h"
-#include "swift/SIL/SILBridging.h"
-#include "swift/SIL/SILGlobalVariable.h"
-#include "swift/SIL/SILBuilder.h"
 #include "swift/SIL/MemAccessUtils.h"
+#include "swift/SIL/ParseTestSpecification.h"
+#include "swift/SIL/SILBuilder.h"
+#include "swift/SIL/SILGlobalVariable.h"
+#include "swift/SIL/SILNode.h"
+#include "swift/SIL/Test.h"
 #include <string>
 
 using namespace swift;
@@ -127,6 +129,56 @@ void registerBridgedClass(StringRef className, SwiftMetatype metatype) {
   nodeMetatypes[(unsigned)kind] = metatype;
 }
 
+//===----------------------------------------------------------------------===//
+//                                Test
+//===----------------------------------------------------------------------===//
+
+void registerFunctionTest(llvm::StringRef name,
+                          BridgedFunctionTestThunk thunk) {
+  new swift::test::FunctionTest(
+      name, reinterpret_cast<void *>(thunk),
+      [](auto &function, auto &args, auto &test, void *ctx) {
+        auto thunk = reinterpret_cast<BridgedFunctionTestThunk>(ctx);
+        thunk({&function}, {&args}, test.getContext());
+      });
+}
+
+bool BridgedTestArguments::hasUntaken() const {
+  return arguments->hasUntaken();
+}
+
+llvm::StringRef BridgedTestArguments::takeString() const {
+  return arguments->takeString();
+}
+
+bool BridgedTestArguments::takeBool() const { return arguments->takeBool(); }
+
+SwiftInt BridgedTestArguments::takeInt() const { return arguments->takeUInt(); }
+
+BridgedOperand BridgedTestArguments::takeOperand() const {
+  return {arguments->takeOperand()};
+}
+
+BridgedValue BridgedTestArguments::takeValue() const {
+  return {arguments->takeValue()};
+}
+
+BridgedInstruction BridgedTestArguments::takeInstruction() const {
+  return {arguments->takeInstruction()->asSILNode()};
+}
+
+BridgedArgument BridgedTestArguments::takeArgument() const {
+  return {arguments->takeBlockArgument()};
+}
+
+BridgedBasicBlock BridgedTestArguments::takeBlock() const {
+  return {arguments->takeBlock()};
+}
+
+BridgedFunction BridgedTestArguments::takeFunction() const {
+  return {arguments->takeFunction()};
+}
+
 //===----------------------------------------------------------------------===//
 //                                SILFunction
 //===----------------------------------------------------------------------===//
diff --git a/lib/SIL/Utils/Test.cpp b/lib/SIL/Utils/Test.cpp
@@ -67,6 +67,12 @@ FunctionTest::FunctionTest(StringRef name, Invocation invocation)
       dependencies(nullptr) {
   Registry::get().registerFunctionTest(this, name);
 }
+FunctionTest::FunctionTest(StringRef name, void *context,
+                           InvocationWithContext invocation)
+    : invocation(std::make_pair(invocation, context)), pass(nullptr),
+      function(nullptr), dependencies(nullptr) {
+  Registry::get().registerFunctionTest(this, name);
+}
 
 FunctionTest *FunctionTest::get(StringRef name) {
   return Registry::get().getFunctionTest(name);
@@ -77,7 +83,13 @@ void FunctionTest::run(SILFunction &function, Arguments &arguments,
   this->pass = &pass;
   this->function = &function;
   this->dependencies = &dependencies;
-  invocation(function, arguments, *this);
+  if (invocation.isa<Invocation>()) {
+    auto fn = this->invocation.get<Invocation>();
+    fn(function, arguments, *this);
+  } else {
+    auto pair = invocation.get<std::pair<InvocationWithContext, void *>>();
+    pair.first(function, arguments, *this, pair.second);
+  }
   this->pass = nullptr;
   this->function = nullptr;
   this->dependencies = nullptr;
@@ -90,3 +102,7 @@ DominanceInfo *FunctionTest::getDominanceInfo() {
 SILPassManager *FunctionTest::getPassManager() {
   return dependencies->getPassManager();
 }
+
+BridgedTestContext FunctionTest::getContext() {
+  return BridgedTestContext{dependencies->getInvocation()};
+}
diff --git a/lib/SILOptimizer/UtilityPasses/TestRunner.cpp b/lib/SILOptimizer/UtilityPasses/TestRunner.cpp
@@ -60,12 +60,14 @@ class TestRunner : public SILFunctionTransform {
       : public test::FunctionTest::Dependencies {
     TestRunner *pass;
     SILFunction *function;
+    SwiftPassInvocation invocation;
     FunctionTestDependenciesImpl(TestRunner *pass, SILFunction *function)
-        : pass(pass), function(function) {}
+        : pass(pass), function(function), invocation(pass->getPassManager()) {}
     DominanceInfo *getDominanceInfo() override {
       auto *dominanceAnalysis = pass->getAnalysis<DominanceAnalysis>();
       return dominanceAnalysis->get(function);
     }
+    SwiftPassInvocation *getInvocation() override { return &invocation; }
     SILPassManager *getPassManager() override { return pass->getPassManager(); }
     ~FunctionTestDependenciesImpl() {}
   };

Original file line number	Diff line number	Diff line change
`@@ -20,6 +20,7 @@ public func initializeSwiftModules() {`
`20`	`20`	`registerSwiftAnalyses()`
`21`	`21`	`registerSwiftPasses()`
`22`	`22`	`initializeSwiftParseModules()`
	`23`	`+ registerSILTests()`
`23`	`24`	`}`
`24`	`25`
`25`	`26`	`private func registerPass(`