---

yaml
---
r: 344639
b: refs/heads/master
c: 233f864
h: refs/heads/master
i:
  344637: 94a336e
  344635: dc1b11d
  344631: 4dadcc5
  344623: 01fcb9c
  344607: 35f2bb3
  344575: 14c44e4

Author: CodaFi

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: e5b31c4e1ec5986ae9aadad6297b1eb62af29bf2
+refs/heads/master: 233f8645d1f8b82827278b2c8dfff902c2645765
 refs/heads/master-next: 203b3026584ecad859eb328b2e12490099409cd5
 refs/tags/osx-passed: b6b74147ef8a386f532cf9357a1bde006e552c54
 refs/tags/swift-2.2-SNAPSHOT-2015-12-01-a: 6bb18e013c2284f2b45f5f84f2df2887dc0f7dea

trunk/cmake/modules/SwiftSource.cmake

@@ -326,6 +326,8 @@ 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")
@@ -499,7 +501,6 @@ 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}

trunk/include/swift/AST/Decl.h

@@ -5689,8 +5689,7 @@ 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 &&
-           getBodyKind() != BodyKind::Skipped;
+    return getBodyKind() != BodyKind::None;
   }
 
   /// Returns true if the text of this function's body can be retrieved either
@@ -5717,22 +5716,14 @@ 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) {
-    // 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());
+    assert(getBodyKind() == BodyKind::None);
     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);
   }
@@ -5778,10 +5769,6 @@ class AbstractFunctionDecl : public GenericContext, public ValueDecl {
     return getBodyKind() == BodyKind::TypeChecked;
   }
 
-  bool isBodySkipped() const {
-    return getBodyKind() == BodyKind::Skipped;
-  }
-
   bool isMemberwiseInitializer() const {
     return getBodyKind() == BodyKind::MemberwiseInitializer;
   }

trunk/include/swift/AST/DeclContext.h

@@ -409,15 +409,6 @@ 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 {

trunk/include/swift/AST/DiagnosticsFrontend.def

@@ -128,9 +128,6 @@ 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)", ())

trunk/include/swift/AST/SILOptions.h

@@ -70,9 +70,6 @@ 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;
 

trunk/include/swift/Frontend/FrontendOptions.h

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

trunk/include/swift/Option/Options.td

@@ -254,10 +254,6 @@ 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">;

trunk/include/swift/Reflection/ReflectionContext.h

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

trunk/include/swift/Reflection/TypeRefBuilder.h

@@ -65,21 +65,6 @@ 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>
@@ -254,12 +239,17 @@ 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;
@@ -565,66 +555,106 @@ 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 readTypeRef(remoteAddr);
+    return RemoteRef<char>(remoteAddr, localPtr);
   }
-
+  
   StringRef getTypeRefString(RemoteRef<char> record) {
     return Demangle::makeSymbolicMangledNameStringRef(record.getLocalBuffer());
   }
 
-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;
+  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);
+  }
 
-public:
   template<typename Runtime>
-  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);
+  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);
+    };
   }
 
   TypeConverter &getTypeConverter() { return TC; }