---

yaml
---
r: 349220
b: refs/heads/master-next
c: c6d51a9
h: refs/heads/master

Author: CodaFi

[refs]

@@ -1,6 +1,6 @@
 ---
 refs/heads/master: 3574c513bbc5578dd9346b4ea9ab5995c5927bb5
-refs/heads/master-next: 233f8645d1f8b82827278b2c8dfff902c2645765
+refs/heads/master-next: c6d51a975c1f68731da57fc5e893fccd3c4dfef2
 refs/tags/osx-passed: b6b74147ef8a386f532cf9357a1bde006e552c54
 refs/tags/swift-2.2-SNAPSHOT-2015-12-01-a: 6bb18e013c2284f2b45f5f84f2df2887dc0f7dea
 refs/tags/swift-2.2-SNAPSHOT-2015-12-01-b: 66d897bfcf64a82cb9a87f5e663d889189d06d07

branches/master-next/cmake/modules/SwiftSource.cmake

@@ -326,8 +326,6 @@ function(_compile_swift_files
     set(sib_file "${module_base}.Onone.sib")
     set(sibopt_file "${module_base}.O.sib")
     set(sibgen_file "${module_base}.sibgen")
-    list(APPEND swift_module_flags
-         "-emit-module-source-info-path" "${source_info_file}")
 
     if(SWIFT_ENABLE_MODULE_INTERFACES)
       set(interface_file "${module_base}.swiftinterface")
@@ -501,6 +499,7 @@ function(_compile_swift_files
         COMMAND
           "${PYTHON_EXECUTABLE}" "${line_directive_tool}" "@${file_path}" --
           "${swift_compiler_tool}" "-emit-module" "-o" "${module_file}"
+          "-emit-module-source-info-path" "${source_info_file}"
           ${swift_flags} ${swift_module_flags} "@${file_path}"
         ${command_touch_module_outputs}
         OUTPUT ${module_outputs}

branches/master-next/include/swift/AST/Decl.h

@@ -5689,7 +5689,8 @@ class AbstractFunctionDecl : public GenericContext, public ValueDecl {
   /// Note that a true return value does not imply that the body was actually
   /// parsed.
   bool hasBody() const {
-    return getBodyKind() != BodyKind::None;
+    return getBodyKind() != BodyKind::None &&
+           getBodyKind() != BodyKind::Skipped;
   }
 
   /// Returns true if the text of this function's body can be retrieved either
@@ -5716,14 +5717,22 @@ class AbstractFunctionDecl : public GenericContext, public ValueDecl {
   /// Note that the body was skipped for this function.  Function body
   /// cannot be attached after this call.
   void setBodySkipped(SourceRange bodyRange) {
-    assert(getBodyKind() == BodyKind::None);
+    // FIXME: Remove 'Parsed' from this once we can delay parsing function
+    //        bodies. Right now -experimental-skip-non-inlinable-function-bodies
+    //        requires being able to change the state from Parsed to Skipped,
+    //        because we're still eagerly parsing function bodies.
+    assert(getBodyKind() == BodyKind::None ||
+           getBodyKind() == BodyKind::Unparsed ||
+           getBodyKind() == BodyKind::Parsed);
+    assert(bodyRange.isValid());
     BodyRange = bodyRange;
     setBodyKind(BodyKind::Skipped);
   }
 
   /// Note that parsing for the body was delayed.
   void setBodyDelayed(SourceRange bodyRange) {
     assert(getBodyKind() == BodyKind::None);
+    assert(bodyRange.isValid());
     BodyRange = bodyRange;
     setBodyKind(BodyKind::Unparsed);
   }
@@ -5769,6 +5778,10 @@ class AbstractFunctionDecl : public GenericContext, public ValueDecl {
     return getBodyKind() == BodyKind::TypeChecked;
   }
 
+  bool isBodySkipped() const {
+    return getBodyKind() == BodyKind::Skipped;
+  }
+
   bool isMemberwiseInitializer() const {
     return getBodyKind() == BodyKind::MemberwiseInitializer;
   }

branches/master-next/include/swift/AST/DeclContext.h

@@ -409,6 +409,15 @@ class alignas(1 << DeclContextAlignInBits) DeclContext {
         const_cast<DeclContext *>(this)->getInnermostDeclarationDeclContext();
   }
 
+  /// Returns the innermost context that is an AbstractFunctionDecl whose
+  /// body has been skipped.
+  LLVM_READONLY
+  DeclContext *getInnermostSkippedFunctionContext();
+  const DeclContext *getInnermostSkippedFunctionContext() const {
+    return
+        const_cast<DeclContext *>(this)->getInnermostSkippedFunctionContext();
+  }
+
   /// Returns the semantic parent of this context.  A context has a
   /// parent if and only if it is not a module context.
   DeclContext *getParent() const {

branches/master-next/include/swift/AST/DiagnosticsFrontend.def

@@ -128,6 +128,9 @@ ERROR(error_mode_cannot_emit_module_source_info,none,
       "this mode does not support emitting module source info files", ())
 ERROR(error_mode_cannot_emit_interface,none,
       "this mode does not support emitting module interface files", ())
+ERROR(cannot_emit_ir_skipping_function_bodies,none,
+      "-experimental-skip-non-inlinable-function-bodies does not support "
+      "emitting IR", ())
 
 WARNING(emit_reference_dependencies_without_primary_file,none,
   "ignoring -emit-reference-dependencies (requires -primary-file)", ())

branches/master-next/include/swift/AST/SILOptions.h

@@ -70,6 +70,9 @@ class SILOptions {
   /// Whether to stop the optimization pipeline after serializing SIL.
   bool StopOptimizationAfterSerialization = false;
 
+  /// Whether to skip emitting non-inlinable function bodies.
+  bool SkipNonInlinableFunctionBodies = false;
+
   /// Optimization mode being used.
   OptimizationMode OptMode = OptimizationMode::NotSet;
 

branches/master-next/include/swift/Frontend/FrontendOptions.h

@@ -180,6 +180,8 @@ class FrontendOptions {
   /// \sa swift::SharedTimer
   bool DebugTimeCompilation = false;
 
+  bool SkipNonInlinableFunctionBodies = false;
+
   /// The path to which we should output statistics files.
   std::string StatsOutputDir;
 
@@ -339,6 +341,7 @@ class FrontendOptions {
 
 public:
   static bool doesActionGenerateSIL(ActionType);
+  static bool doesActionGenerateIR(ActionType);
   static bool doesActionProduceOutput(ActionType);
   static bool doesActionProduceTextualOutput(ActionType);
   static bool needsProperModuleName(ActionType);

branches/master-next/include/swift/Option/Options.td

@@ -254,6 +254,10 @@ def stats_output_dir: Separate<["-"], "stats-output-dir">,
 def trace_stats_events: Flag<["-"], "trace-stats-events">,
   Flags<[FrontendOption, HelpHidden]>,
   HelpText<"Trace changes to stats in -stats-output-dir">;
+def experimental_skip_non_inlinable_function_bodies:
+  Flag<["-"], "experimental-skip-non-inlinable-function-bodies">,
+  Flags<[FrontendOption, HelpHidden]>,
+  HelpText<"Skip type-checking and SIL generation for non-inlinable function bodies">;
 def profile_stats_events: Flag<["-"], "profile-stats-events">,
   Flags<[FrontendOption, HelpHidden]>,
   HelpText<"Profile changes to stats in -stats-output-dir">;

branches/master-next/include/swift/Reflection/ReflectionContext.h

@@ -107,9 +107,8 @@ class ReflectionContext
   using typename super::StoredPointer;
 
   explicit ReflectionContext(std::shared_ptr<MemoryReader> reader)
-    : super(std::move(reader)) {
-    getBuilder().setMetadataReader(*this);
-  }
+    : super(std::move(reader), *this)
+  {}
 
   ReflectionContext(const ReflectionContext &other) = delete;
   ReflectionContext &operator=(const ReflectionContext &other) = delete;

branches/master-next/include/swift/Reflection/TypeRefBuilder.h

@@ -65,6 +65,21 @@ class ReflectionSection {
   size_t size() const {
     return Size;
   }
+  
+  bool containsRemoteAddress(uint64_t remoteAddr,
+                             uint64_t size) const {
+    return Start.getAddressData() <= remoteAddr
+      && remoteAddr + size <= Start.getAddressData() + Size;
+  }
+  
+  template<typename U>
+  RemoteRef<U> getRemoteRef(uint64_t remoteAddr) const {
+    assert(containsRemoteAddress(remoteAddr, sizeof(U)));
+    auto localAddr = (uint64_t)(uintptr_t)Start.getLocalBuffer()
+      + (remoteAddr - Start.getAddressData());
+    
+    return RemoteRef<U>(remoteAddr, (const U*)localAddr);
+  }
 };
 
 template<typename Self, typename Descriptor>
@@ -239,17 +254,12 @@ class TypeRefBuilder {
   using BuiltTypeDecl = Optional<std::string>;
   using BuiltProtocolDecl = Optional<std::pair<std::string, bool /*isObjC*/>>;
 
-  TypeRefBuilder();
-
   TypeRefBuilder(const TypeRefBuilder &other) = delete;
   TypeRefBuilder &operator=(const TypeRefBuilder &other) = delete;
 
 private:
   Demangle::Demangler Dem;
 
-  std::function<const TypeRef* (const void*, unsigned)>
-    OpaqueUnderlyingTypeReader;
-  
   /// Makes sure dynamically allocated TypeRefs stick around for the life of
   /// this TypeRefBuilder and are automatically released.
   std::vector<std::unique_ptr<const TypeRef>> TypeRefPool;
@@ -555,106 +565,66 @@ class TypeRefBuilder {
     return ReflectionInfos;
   }
 
+public:
+  enum ForTesting_t { ForTesting };
+  
+  // Only for testing. A TypeRefBuilder built this way will not be able to
+  // decode records in remote memory.
+  explicit TypeRefBuilder(ForTesting_t) : TC(*this) {}
+
 private:
   std::vector<ReflectionInfo> ReflectionInfos;
-  
-  uint64_t getRemoteAddrOfTypeRefPointer(const void *pointer);
-  
-  std::function<auto (SymbolicReferenceKind kind,
-                      Directness directness,
-                      int32_t offset, const void *base) -> Demangle::Node *>
-    SymbolicReferenceResolver;
-  
+    
   std::string normalizeReflectionName(RemoteRef<char> name);
   bool reflectionNameMatches(RemoteRef<char> reflectionName,
                              StringRef searchName);
 
 public:
+  RemoteRef<char> readTypeRef(uint64_t remoteAddr);
+  
   template<typename Record, typename Field>
   RemoteRef<char> readTypeRef(RemoteRef<Record> record,
                               const Field &field) {
     uint64_t remoteAddr = record.resolveRelativeFieldData(field);
-    // TODO: This assumes the remote and local buffer addresses are contiguous,
-    // which should not be a guarantee that MemoryReaders need to maintain.
-    // Ultimately this should use the MemoryReader to read the string.
-    auto localAddr = (uint64_t)(uintptr_t)record.getLocalBuffer()
-      + (int64_t)(remoteAddr - record.getAddressData());
-    
-    // Skip the mangling prefix, if any.
-    auto localPtr = (const char *)localAddr;
-    if (localPtr[0] == '$' && localPtr[1] == 's') {
-      remoteAddr += 2;
-      localPtr += 2;
-    }
 
-    return RemoteRef<char>(remoteAddr, localPtr);
+    return readTypeRef(remoteAddr);
   }
-  
+
   StringRef getTypeRefString(RemoteRef<char> record) {
     return Demangle::makeSymbolicMangledNameStringRef(record.getLocalBuffer());
   }
 
-  Demangle::Node *demangleTypeRef(RemoteRef<char> string) {
-    // TODO: Use the remote addr in the RemoteRef to resolve and read from
-    // remote addresses in the resolver function.
-    return Dem.demangleType(getTypeRefString(string),
-                            SymbolicReferenceResolver);
-  }
+private:
+  // These fields are captured from the MetadataReader template passed into the
+  // TypeRefBuilder struct, to isolate its template-ness from the rest of
+  // TypeRefBuilder.
+  unsigned PointerSize;
+  std::function<Demangle::Node * (RemoteRef<char>)>
+    TypeRefDemangler;
+  std::function<const TypeRef* (const void*, unsigned)>
+    OpaqueUnderlyingTypeReader;
 
+public:
   template<typename Runtime>
-  void setMetadataReader(
-                      remote::MetadataReader<Runtime, TypeRefBuilder> &reader) {
-    // Have the TypeRefBuilder demangle symbolic references by reading their
-    // demangling out of the referenced context descriptors in the target
-    // process.
-    SymbolicReferenceResolver =
-    [this, &reader](SymbolicReferenceKind kind,
-                    Directness directness,
-                    int32_t offset, const void *base) -> Demangle::Node * {
-      // Resolve the reference to a remote address.
-      auto remoteAddress = getRemoteAddrOfTypeRefPointer(base);
-      if (remoteAddress == 0)
-        return nullptr;
-      
-      auto address = remoteAddress + offset;
-      if (directness == Directness::Indirect) {
-        if (auto indirectAddress = reader.readPointerValue(address)) {
-          address = *indirectAddress;
-        } else {
-          return nullptr;
-        }
-      }
-      
-      switch (kind) {
-      case Demangle::SymbolicReferenceKind::Context: {
-        auto context = reader.readContextDescriptor(address);
-        if (!context)
-          return nullptr;
-        // Try to preserve a reference to an OpaqueTypeDescriptor symbolically,
-        // since we'd like to read out and resolve the type ref to the
-        // underlying type if available.
-        if (context->getKind() == ContextDescriptorKind::OpaqueType) {
-          return Dem.createNode(
-                            Node::Kind::OpaqueTypeDescriptorSymbolicReference,
-                            context.getAddressData());
-        }
-          
-        return reader.buildContextMangling(context, Dem);
-      }
-      case Demangle::SymbolicReferenceKind::AccessorFunctionReference:
-        // The symbolic reference points at a resolver function, but we can't
-        // execute code in the target process to resolve it from here.
-        return nullptr;
-      }
-      
-      return nullptr;
-    };
-    
-    OpaqueUnderlyingTypeReader =
-    [&reader](const void *descriptor, unsigned ordinal) -> const TypeRef* {
-      auto context = (typename Runtime::StoredPointer)descriptor;
-      return reader.readUnderlyingTypeForOpaqueTypeDescriptor(context, ordinal);
-    };
+  TypeRefBuilder(remote::MetadataReader<Runtime, TypeRefBuilder> &reader)
+    : TC(*this),
+      PointerSize(sizeof(typename Runtime::StoredPointer)),
+      TypeRefDemangler(
+      [this, &reader](RemoteRef<char> string) -> Demangle::Node * {
+        return reader.demangle(string,
+                               remote::MangledNameKind::Type,
+                               Dem, /*useOpaqueTypeSymbolicReferences*/ true);
+      }),
+      OpaqueUnderlyingTypeReader(
+      [&reader](const void *descriptor, unsigned ordinal) -> const TypeRef* {
+        auto context = (typename Runtime::StoredPointer)descriptor;
+        return reader.readUnderlyingTypeForOpaqueTypeDescriptor(context,
+                                                                ordinal);
+      })
+  {}
+
+  Demangle::Node *demangleTypeRef(RemoteRef<char> string) {
+    return TypeRefDemangler(string);
   }
 
   TypeConverter &getTypeConverter() { return TC; }