Merge branch 'master' of https://github.com/apple/swift

Author: ematejska

benchmark/cmake/modules/AddSwiftBenchmarkSuite.cmake

@@ -166,7 +166,7 @@ macro(configure_sdks)
   endif()
 endmacro()
 
-function (add_swift_benchmark_library objfile_out sibfile_out)
+function (add_swift_benchmark_library objfile_out sibfile_out swiftmodule_out)
   cmake_parse_arguments(BENCHLIB "" "MODULE_PATH;SOURCE_DIR;OBJECT_DIR" "SOURCES;LIBRARY_FLAGS;DEPENDS" ${ARGN})
 
   precondition(BENCHLIB_MODULE_PATH)
@@ -197,6 +197,7 @@ function (add_swift_benchmark_library objfile_out sibfile_out)
       "-o" "${objfile}"
       ${sources})
   set(${objfile_out} "${objfile}" PARENT_SCOPE)
+  set(${swiftmodule_out} "${swiftmodule}" PARENT_SCOPE)
 
   if(SWIFT_BENCHMARK_EMIT_SIB)
     precondition(sibfile_out)
@@ -401,19 +402,21 @@ function (swift_benchmark_compile_archopts)
   endif()
   set(bench_library_objects)
   set(bench_library_sibfiles)
+  set(bench_library_swiftmodules)
   set(opt_view_dirs)
   # Build libraries used by the driver and benchmarks.
   foreach(module_name_path ${BENCH_LIBRARY_MODULES})
     set(sources "${srcdir}/${module_name_path}.swift")
 
-    add_swift_benchmark_library(objfile_out sibfile_out
+    add_swift_benchmark_library(objfile_out sibfile_out swiftmodule_out
       MODULE_PATH "${module_name_path}"
       SOURCE_DIR "${srcdir}"
       OBJECT_DIR "${objdir}"
       SOURCES ${sources}
       LIBRARY_FLAGS ${common_swift4_options})
     precondition(objfile_out)
     list(APPEND bench_library_objects "${objfile_out}")
+    list(APPEND bench_library_swiftmodules "${swiftmodule_out}")
     if (SWIFT_BENCHMARK_EMIT_SIB)
       precondition(sibfile_out)
       list(APPEND bench_library_sibfiles "${sibfile_out}")
@@ -433,7 +436,7 @@ function (swift_benchmark_compile_archopts)
 
     set(objfile_out)
     set(sibfile_out)
-    add_swift_benchmark_library(objfile_out sibfile_out
+    add_swift_benchmark_library(objfile_out sibfile_out swiftmodule_out
       MODULE_PATH "${module_name_path}"
       SOURCE_DIR "${srcdir}"
       OBJECT_DIR "${objdir}"
@@ -442,6 +445,7 @@ function (swift_benchmark_compile_archopts)
       DEPENDS ${bench_library_objects})
     precondition(objfile_out)
     list(APPEND bench_driver_objects "${objfile_out}")
+    list(APPEND bench_library_swiftmodules "${swiftmodule_out}")
     if (SWIFT_BENCHMARK_EMIT_SIB)
       precondition(sibfile_out)
       list(APPEND bench_driver_sibfiles "${sibfile_out}")
@@ -464,6 +468,7 @@ function (swift_benchmark_compile_archopts)
       set(swiftmodule "${objdir}/${module_name}.swiftmodule")
       set(source "${srcdir}/${module_name_path}.swift")
       list(APPEND SWIFT_BENCH_OBJFILES "${objfile}")
+      list(APPEND bench_library_swiftmodules "${swiftmodule}")
 
       if ("${bench_flags}" MATCHES "-whole-module.*")
         set(output_option "-o" "${objfile}")
@@ -622,6 +627,15 @@ function (swift_benchmark_compile_archopts)
     else()
       set(SWIFT_LINK_RPATH "${SWIFT_RPATH_BASE}/${BENCH_COMPILE_ARCHOPTS_PLATFORM}")
     endif()
+
+    # On Darwin, we pass the *.swiftmodule paths transitively referenced by the
+    # driver executable to ld64. ld64 inserts N_AST references to these modules
+    # into the program, for later use by lldb.
+    set(ld64_add_ast_path_opts)
+    foreach(ast_path ${bench_library_swiftmodules})
+      list(APPEND ld64_add_ast_path_opts "-Wl,-add_ast_path,${ast_path}")
+    endforeach()
+
     add_custom_command(
         OUTPUT "${OUTPUT_EXEC}"
         DEPENDS
@@ -647,6 +661,7 @@ function (swift_benchmark_compile_archopts)
           "-Xlinker" "${SWIFT_LINK_RPATH}"
           ${bench_library_objects}
           ${bench_driver_objects}
+          ${ld64_add_ast_path_opts}
           ${SWIFT_BENCH_OBJFILES}
           ${objcfile}
           "-o" "${OUTPUT_EXEC}"

include/swift/AST/AutoDiff.h

@@ -227,6 +227,12 @@ struct AutoDiffConfig {
   SWIFT_DEBUG_DUMP;
 };
 
+inline llvm::raw_ostream &operator<<(llvm::raw_ostream &s,
+                                     const SILAutoDiffIndices &indices) {
+  indices.print(s);
+  return s;
+}
+
 /// A semantic function result type: either a formal function result type or
 /// an `inout` parameter type. Used in derivative function type calculation.
 struct AutoDiffSemanticFunctionResultType {

include/swift/AST/DiagnosticsSIL.def

@@ -445,6 +445,36 @@ ERROR(not_constant_evaluable, none, "not constant evaluable", ())
 ERROR(constexpr_imported_func_not_onone, none, "imported constant evaluable "
       "function '%0' must be annotated '@_optimize(none)'", (StringRef))
 
+// Differentiation transform diagnostics
+ERROR(autodiff_internal_swift_not_imported,none,
+      "Automatic differentiation internal error: the Swift module is not "
+      "imported", ())
+ERROR(autodiff_differentiation_module_not_imported,none,
+      "Automatic differentiation requires the '_Differentiation' module to be "
+      "imported", ())
+ERROR(autodiff_conversion_to_linear_function_not_supported,none,
+      "conversion to '@differentiable(linear)' function type is not yet "
+      "supported", ())
+ERROR(autodiff_function_not_differentiable_error,none,
+      "function is not differentiable", ())
+ERROR(autodiff_expression_not_differentiable_error,none,
+      "expression is not differentiable", ())
+NOTE(autodiff_expression_not_differentiable_note,none,
+     "expression is not differentiable", ())
+NOTE(autodiff_when_differentiating_function_call,none,
+     "when differentiating this function call", ())
+NOTE(autodiff_when_differentiating_function_definition,none,
+     "when differentiating this function definition", ())
+NOTE(autodiff_implicitly_inherited_differentiable_attr_here,none,
+     "differentiability required by the corresponding protocol requirement "
+     "here", ())
+NOTE(autodiff_jvp_control_flow_not_supported,none,
+     "forward-mode differentiation does not yet support control flow", ())
+NOTE(autodiff_control_flow_not_supported,none,
+     "cannot differentiate unsupported control flow", ())
+NOTE(autodiff_missing_return,none,
+     "missing return for differentiation", ())
+
 ERROR(non_physical_addressof,none,
       "addressof only works with purely physical lvalues; "
       "use 'withUnsafePointer' or 'withUnsafeBytes' unless you're implementing "

include/swift/AST/DiagnosticsSema.def

@@ -4342,6 +4342,13 @@ NOTE(objc_ambiguous_inference_candidate,none,
      "%0 (in protocol %1) provides Objective-C name %2",
      (DeclName, DeclName, ObjCSelector))
 
+ERROR(objc_ambiguous_error_convention,none,
+      "%0 overrides or implements protocol requirements for Objective-C "
+      "declarations with incompatible error argument conventions",
+      (DeclName))
+NOTE(objc_ambiguous_error_convention_candidate,none,
+     "%0 provides an error argument here", (DeclName))
+
 ERROR(nonlocal_bridged_to_objc,none,
       "conformance of %0 to %1 can only be written in module %2",
       (Identifier, Identifier, Identifier))

include/swift/AST/ForeignErrorConvention.h

@@ -182,6 +182,16 @@ class ForeignErrorConvention {
            getKind() == NonZeroResult);
     return ResultType;
   }
+  
+  bool operator==(ForeignErrorConvention other) const {
+    return info.TheKind == other.info.TheKind
+      && info.ErrorIsOwned == other.info.ErrorIsOwned
+      && info.ErrorParameterIsReplaced == other.info.ErrorParameterIsReplaced
+      && info.ErrorParameterIndex == other.info.ErrorParameterIndex;
+  }
+  bool operator!=(ForeignErrorConvention other) const {
+    return !(*this == other);
+  }
 };
 
 }

include/swift/Basic/LangOptions.h

@@ -327,6 +327,9 @@ namespace swift {
     /// `@differentiable` declaration attribute, etc.
     bool EnableExperimentalDifferentiableProgramming = false;
 
+    /// Whether to enable forward mode differentiation.
+    bool EnableExperimentalForwardModeDifferentiation = false;
+
     /// Whether to enable experimental `AdditiveArithmetic` derived
     /// conformances.
     bool EnableExperimentalAdditiveArithmeticDerivedConformances = false;

include/swift/Option/Options.td

@@ -498,6 +498,14 @@ def disable_bridging_pch : Flag<["-"], "disable-bridging-pch">,
   HelpText<"Disable automatic generation of bridging PCH files">;
 
 // Experimental feature options
+
+// Note: this flag will be removed when JVP/differential generation in the
+// differentiation transform is robust.
+def enable_experimental_forward_mode_differentiation :
+  Flag<["-"], "enable-experimental-forward-mode-differentiation">,
+  Flags<[FrontendOption]>,
+  HelpText<"Enable experimental forward mode differentiation">;
+
 def enable_experimental_additive_arithmetic_derivation :
   Flag<["-"], "enable-experimental-additive-arithmetic-derivation">,
   Flags<[FrontendOption]>,

include/swift/SIL/MemAccessUtils.h

@@ -78,8 +78,10 @@ SingleValueInstruction *isAccessProjection(SILValue v);
 /// findAccessedStorage() on either \p v or the returned address.
 SILValue getAddressAccess(SILValue v);
 
-/// Convenience for stripAccessMarkers(getAddressAccess(V)).
-SILValue getAccessedAddress(SILValue v);
+/// Convenience for stripAccessMarkers(getAddressAccess(v)).
+inline SILValue getAccessedAddress(SILValue v) {
+  return stripAccessMarkers(getAddressAccess(v));
+}
 
 /// Return true if \p accessedAddress points to a let-variable.
 ///

include/swift/SIL/SILDifferentiabilityWitness.h

@@ -132,6 +132,11 @@ class SILDifferentiabilityWitness
   bool isSerialized() const { return IsSerialized; }
   const DeclAttribute *getAttribute() const { return Attribute; }
 
+  /// Returns the `SILAutoDiffIndices` corresponding to this config's indices.
+  // TODO(TF-893): This is a temporary shim for incremental removal of
+  // `SILAutoDiffIndices`. Eventually remove this.
+  SILAutoDiffIndices getSILAutoDiffIndices() const;
+
   /// Verify that the differentiability witness is well-formed.
   void verify(const SILModule &module) const;
 

include/swift/SILOptimizer/PassManager/Passes.def

@@ -120,6 +120,8 @@ PASS(CopyForwarding, "copy-forwarding",
      "Copy Forwarding to Remove Redundant Copies")
 PASS(CopyPropagation, "copy-propagation",
      "Copy propagation to Remove Redundant SSA Copies")
+PASS(Differentiation, "differentiation",
+     "Automatic Differentiation")
 PASS(EpilogueARCMatcherDumper, "sil-epilogue-arc-dumper",
      "Print Epilogue retains of Returned Values and Argument releases")
 PASS(EpilogueRetainReleaseMatcherDumper, "sil-epilogue-retain-release-dumper",