---

yaml
---
r: 323325
b: refs/heads/tensorflow-next
c: 9ddff82
h: refs/heads/master
i:
  323323: 6566d2c

Author: swift-ci

[refs]

@@ -1461,4 +1461,4 @@ refs/heads/master-rebranch: 86e95c23aa0d37f24ec138b7853146c1cead2e40
 refs/heads/rdar-53901732: 9bd06af3284e18a109cdbf9aa59d833b24eeca7b
 refs/heads/revert-26776-subst-always-returns-a-type: 1b8e18fdd391903a348970a4c848995d4cdd789c
 refs/heads/tensorflow-merge: 8b854f62f80d4476cb383d43c4aac2001dde3cec
-refs/heads/tensorflow-next: e619e5f1f695781c718f9f7259ed3c0fb6b43025
+refs/heads/tensorflow-next: 9ddff82d83e3a926b8a19e292627ec30c5639897

branches/tensorflow-next/include/swift/ABI/Metadata.h

@@ -124,9 +124,9 @@ struct External {
 
   template <typename T, bool Nullable = false>
   using RelativeIndirectablePointer = int32_t;
-  
+
   template <typename T, bool Nullable = true>
-  using RelativeDirectPointer = int32_t;
+  using RelativeDirectPointer = RelativeDirectPointer<T, Nullable>;
 };
 
 /// Template for branching on native pointer types versus external ones

branches/tensorflow-next/include/swift/Reflection/MetadataSourceBuilder.h

@@ -18,6 +18,8 @@
 #define SWIFT_REFLECTION_METADATASOURCEBUILDER_H
 
 #include "swift/Reflection/MetadataSource.h"
+#include <memory>
+#include <vector>
 
 namespace swift {
 namespace reflection {

branches/tensorflow-next/include/swift/Reflection/ProtocolConformance.h

@@ -0,0 +1,76 @@
+//===--- ProtocolConformance.h --------------------------------*- C++ -*---===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2019 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
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SWIFT_REFLECTION_PROTOCOLCONFORMANCE_H
+#define SWIFT_REFLECTION_PROTOCOLCONFORMANCE_H
+
+#if !defined(__APPLE__) || !defined(__MACH__)
+// TODO: Implement this.
+#error "Only supported on Darwin now. Do not include this otherwise!"
+#endif
+
+#include "swift/ABI/Metadata.h"
+#include "swift/Basic/LLVM.h"
+#include "swift/Reflection/ReflectionInfo.h"
+
+namespace swift {
+namespace reflection {
+
+template <typename Runtime>
+class ProtocolDescriptorIterator
+    : public std::iterator<std::forward_iterator_tag,
+                           TargetProtocolDescriptor<Runtime>> {
+  // The protocol descriptor section is filled with relative direct
+  // pointers to protocol descriptors.
+  using PointerType = RelativeDirectPointer<TargetProtocolDescriptor<Runtime>>;
+
+public:
+  using ProtocolDescriptor = TargetProtocolDescriptor<Runtime>;
+
+  const void *Cur;
+  const void *const End;
+
+  ProtocolDescriptorIterator(const ReflectionInfo &reflectionInfo)
+      : Cur(reflectionInfo.Protocol.Metadata.getStartAddress()),
+        End(reflectionInfo.Protocol.Metadata.getEndAddress()) {}
+
+  const ProtocolDescriptor &operator*() const { return *curAsPointer(); }
+
+  const ProtocolDescriptor *operator->() const { return curAsPointer(); }
+
+  bool hasNext() const { return Cur < End; }
+
+  ProtocolDescriptorIterator &operator++() {
+    assert(hasNext());
+    const void *Next =
+        reinterpret_cast<const char *>(Cur) + sizeof(PointerType);
+    Cur = Next;
+    return *this;
+  }
+
+  bool operator==(ProtocolDescriptorIterator const &other) const {
+    return Cur == other.Cur && End == other.End;
+  }
+
+  bool operator!=(ProtocolDescriptorIterator const &other) const {
+    return !(*this == other);
+  }
+
+  const ProtocolDescriptor *curAsPointer() const {
+    return static_cast<const PointerType *>(Cur)->get();
+  }
+};
+
+} // namespace reflection
+} // namespace swift
+
+#endif

branches/tensorflow-next/include/swift/Reflection/Records.h

@@ -17,9 +17,11 @@
 #ifndef SWIFT_REFLECTION_RECORDS_H
 #define SWIFT_REFLECTION_RECORDS_H
 
+#include "swift/Basic/LLVM.h"
 #include "swift/Basic/RelativePointer.h"
 #include "swift/Demangling/Demangle.h"
 #include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/StringRef.h"
 
 namespace swift {
 

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

@@ -224,27 +224,26 @@ class ReflectionContext
     auto CaptureSec = findMachOSectionByName("__swift5_capture");
     auto TypeRefMdSec = findMachOSectionByName("__swift5_typeref");
     auto ReflStrMdSec = findMachOSectionByName("__swift5_reflstr");
+    auto ProtocolSec = findMachOSectionByName("__swift5_protos");
 
-    if (FieldMdSec.first == nullptr &&
-        AssocTySec.first == nullptr &&
-        BuiltinTySec.first == nullptr &&
-        CaptureSec.first == nullptr &&
-        TypeRefMdSec.first == nullptr &&
-        ReflStrMdSec.first == nullptr)
+    if (FieldMdSec.first == nullptr && AssocTySec.first == nullptr &&
+        BuiltinTySec.first == nullptr && CaptureSec.first == nullptr &&
+        TypeRefMdSec.first == nullptr && ReflStrMdSec.first == nullptr &&
+        ProtocolSec.first == nullptr)
       return false;
 
     auto LocalStartAddress = reinterpret_cast<uint64_t>(SectBuf.get());
     auto RemoteStartAddress = static_cast<uint64_t>(RangeStart);
 
-    ReflectionInfo info = {
-        {{FieldMdSec.first, FieldMdSec.second}, 0},
-        {{AssocTySec.first, AssocTySec.second}, 0},
-        {{BuiltinTySec.first, BuiltinTySec.second}, 0},
-        {{CaptureSec.first, CaptureSec.second}, 0},
-        {{TypeRefMdSec.first, TypeRefMdSec.second}, 0},
-        {{ReflStrMdSec.first, ReflStrMdSec.second}, 0},
-        LocalStartAddress,
-        RemoteStartAddress};
+    ReflectionInfo info = {{{FieldMdSec.first, FieldMdSec.second}, 0},
+                           {{AssocTySec.first, AssocTySec.second}, 0},
+                           {{BuiltinTySec.first, BuiltinTySec.second}, 0},
+                           {{CaptureSec.first, CaptureSec.second}, 0},
+                           {{TypeRefMdSec.first, TypeRefMdSec.second}, 0},
+                           {{ReflStrMdSec.first, ReflStrMdSec.second}, 0},
+                           {{ProtocolSec.first, ProtocolSec.second}, 0},
+                           LocalStartAddress,
+                           RemoteStartAddress};
 
     this->addReflectionInfo(info);
 

branches/tensorflow-next/include/swift/Reflection/ReflectionInfo.h

@@ -0,0 +1,145 @@
+//===--- ReflectionInfo.h --------------------------------*- C++ -*--------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2019 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
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SWIFT_REFLECTION_REFLECTIONINFO_H
+#define SWIFT_REFLECTION_REFLECTIONINFO_H
+
+#include "swift/Reflection/MetadataSource.h"
+#include "swift/Reflection/Records.h"
+#include "swift/Reflection/TypeRef.h"
+#include "swift/Remote/MetadataReader.h"
+
+namespace swift {
+namespace reflection {
+
+template <typename IteratorTy> class ReflectionSection {
+  using const_iterator = IteratorTy;
+  uintptr_t startAddress;
+  uintptr_t endAddress;
+
+public:
+  ReflectionSection(const void *startAddress, const void *endAddress)
+      : startAddress(uintptr_t(startAddress)),
+        endAddress(uintptr_t(endAddress)) {}
+
+  ReflectionSection(uintptr_t startAddress, uintptr_t endAddress)
+      : startAddress(startAddress), endAddress(endAddress) {}
+
+  void *getStartAddress() { return reinterpret_cast<void *>(startAddress); }
+
+  const void *getStartAddress() const {
+    return reinterpret_cast<const void *>(startAddress);
+  }
+
+  const void *getEndAddress() const {
+    return reinterpret_cast<const void *>(endAddress);
+  }
+
+  const_iterator begin() const {
+    return const_iterator(getStartAddress(), getEndAddress());
+  }
+
+  const_iterator end() const {
+    return const_iterator(getEndAddress(), getEndAddress());
+  }
+
+  size_t size() const { return endAddress - startAddress; }
+};
+
+/// A section of packed void * pointers.
+using GenericSection = ReflectionSection<const void *>;
+
+template <typename Runtime> class ReflectionContext;
+
+using FieldSection = ReflectionSection<FieldDescriptorIterator>;
+using AssociatedTypeSection = ReflectionSection<AssociatedTypeIterator>;
+using BuiltinTypeSection = ReflectionSection<BuiltinTypeDescriptorIterator>;
+using CaptureSection = ReflectionSection<CaptureDescriptorIterator>;
+
+struct ReflectionInfo {
+  struct {
+    FieldSection Metadata;
+    uint64_t SectionOffset;
+  } Field;
+
+  struct {
+    AssociatedTypeSection Metadata;
+    uint64_t SectionOffset;
+  } AssociatedType;
+
+  struct {
+    BuiltinTypeSection Metadata;
+    uint64_t SectionOffset;
+  } Builtin;
+
+  struct {
+    CaptureSection Metadata;
+    uint64_t SectionOffset;
+  } Capture;
+
+  struct {
+    GenericSection Metadata;
+    uint64_t SectionOffset;
+  } TypeReference;
+
+  struct {
+    GenericSection Metadata;
+    uint64_t SectionOffset;
+  } ReflectionString;
+
+#if defined(__APPLE__) && defined(__MACH__)
+  struct {
+    GenericSection Metadata;
+    uint64_t SectionOffset;
+  } Protocol;
+#endif
+
+  uint64_t LocalStartAddress;
+  uint64_t RemoteStartAddress;
+};
+
+struct ClosureContextInfo {
+  std::vector<const TypeRef *> CaptureTypes;
+  std::vector<std::pair<const TypeRef *, const MetadataSource *>>
+      MetadataSources;
+  unsigned NumBindings = 0;
+
+  void dump() const;
+  void dump(std::ostream &OS) const;
+};
+
+struct FieldTypeInfo {
+  std::string Name;
+  const TypeRef *TR;
+  bool Indirect;
+
+  FieldTypeInfo() : Name(""), TR(nullptr), Indirect(false) {}
+  FieldTypeInfo(const std::string &Name, const TypeRef *TR, bool Indirect)
+      : Name(Name), TR(TR), Indirect(Indirect) {}
+
+  static FieldTypeInfo forEmptyCase(std::string Name) {
+    return FieldTypeInfo(Name, nullptr, false);
+  }
+
+  static FieldTypeInfo forIndirectCase(std::string Name, const TypeRef *TR) {
+    return FieldTypeInfo(Name, TR, true);
+  }
+
+  static FieldTypeInfo forField(std::string Name, const TypeRef *TR) {
+    return FieldTypeInfo(Name, TR, false);
+  }
+};
+
+} // namespace reflection
+} // namespace swift
+
+#endif