swiftlang · jckarter · Jun 22, 2018 · Jun 21, 2018
diff --git a/include/swift/AST/Decl.h b/include/swift/AST/Decl.h
@@ -4228,6 +4228,25 @@ class AbstractStorageDecl : public ValueDecl {
     llvm_unreachable("bad storage kind");
   }
 
+  /// \brief Return true if this is a VarDecl that has storage associated with
+  /// it which can be trivially accessed.
+  bool hasTrivialStorage() const {
+    switch (getStorageKind()) {
+    case Stored:
+    case StoredWithTrivialAccessors:
+      return true;
+    case StoredWithObservers:
+    case InheritedWithObservers:
+    case Computed:
+    case ComputedWithMutableAddress:
+    case Addressed:
+    case AddressedWithTrivialAccessors:
+    case AddressedWithObservers:
+      return false;
+    }
+    llvm_unreachable("bad storage kind");
+  }
+
   /// \brief Return true if this object has a getter (and, if mutable,
   /// a setter and a materializeForSet).
   bool hasAccessorFunctions() const {
@@ -4456,7 +4475,8 @@ class AbstractStorageDecl : public ValueDecl {
 
   /// Determine how this storage declaration should actually be accessed.
   AccessStrategy getAccessStrategy(AccessSemantics semantics,
-                                   AccessKind accessKind) const;
+                                   AccessKind accessKind,
+                                   DeclContext *accessFromDC = nullptr) const;
 
   /// \brief Should this declaration behave as if it must be accessed
   /// resiliently, even when we're building a non-resilient module?

diff --git a/include/swift/SIL/SILProperty.h b/include/swift/SIL/SILProperty.h
@@ -42,25 +42,31 @@ class SILProperty : public llvm::ilist_node<SILProperty>,
   AbstractStorageDecl *Decl;
 
   /// The key path component that represents its implementation.
-  KeyPathPatternComponent Component;
+  Optional<KeyPathPatternComponent> Component;
 
   SILProperty(bool Serialized,
               AbstractStorageDecl *Decl,
-              KeyPathPatternComponent Component)
+              Optional<KeyPathPatternComponent> Component)
     : Serialized(Serialized), Decl(Decl), Component(Component)
   {}
 
 public:
   static SILProperty *create(SILModule &M,
                              bool Serialized,
                              AbstractStorageDecl *Decl,
-                             KeyPathPatternComponent Component);
+                             Optional<KeyPathPatternComponent> Component);
 
   bool isSerialized() const { return Serialized; }
 
   AbstractStorageDecl *getDecl() const { return Decl; }
 
-  const KeyPathPatternComponent &getComponent() const { return Component; }
+  bool isTrivial() const {
+    return !Component.hasValue();
+  }
+
+  const Optional<KeyPathPatternComponent> &getComponent() const {
+    return Component;
+  }
 
   void print(SILPrintContext &Ctx) const;
   void dump() const;

diff --git a/include/swift/SIL/TypeLowering.h b/include/swift/SIL/TypeLowering.h
@@ -983,6 +983,8 @@ class TypeConverter {
   CanSILBoxType getBoxTypeForEnumElement(SILType enumType,
                                          EnumElementDecl *elt);
 
+  bool canStorageUseStoredKeyPathComponent(AbstractStorageDecl *decl);
+
 private:
   CanType getLoweredRValueType(AbstractionPattern origType, CanType substType);
 

diff --git a/lib/AST/Decl.cpp b/lib/AST/Decl.cpp
@@ -1414,7 +1414,8 @@ ValueDecl::getAccessSemanticsFromContext(const DeclContext *UseDC,
 
 AccessStrategy
 AbstractStorageDecl::getAccessStrategy(AccessSemantics semantics,
-                                       AccessKind accessKind) const {
+                                       AccessKind accessKind,
+                                       DeclContext *accessFromDC) const {
   switch (semantics) {
   case AccessSemantics::DirectToStorage:
     switch (getStorageKind()) {
@@ -1481,7 +1482,14 @@ AbstractStorageDecl::getAccessStrategy(AccessSemantics semantics,
       // This is done by using DirectToStorage semantics above, with the
       // understanding that the access semantics are with respect to the
       // resilience domain of the accessor's caller.
-      if (isResilient())
+      bool resilient;
+      if (accessFromDC)
+        resilient = isResilient(accessFromDC->getParentModule(),
+                                ResilienceExpansion::Maximal);
+      else
+        resilient = isResilient();
+
+      if (resilient)
         return AccessStrategy::DirectToAccessor;
 
       if (storageKind == StoredWithObservers ||

diff --git a/lib/IRGen/GenKeyPath.cpp b/lib/IRGen/GenKeyPath.cpp
@@ -1218,6 +1218,33 @@ IRGenModule::getAddrOfKeyPathPattern(KeyPathPattern *pattern,
 }
 
 void IRGenModule::emitSILProperty(SILProperty *prop) {
+  if (prop->isTrivial()) {
+    // All trivial property descriptors can share a single definition in the
+    // translation unit.
+    if (!TheTrivialPropertyDescriptor) {
+      // Emit a definition if we don't have one yet.
+      ConstantInitBuilder builder(*this);
+      ConstantStructBuilder fields = builder.beginStruct();
+      fields.addInt32(
+        _SwiftKeyPathComponentHeader_TrivialPropertyDescriptorMarker);
+      auto var = cast<llvm::GlobalVariable>(
+        getAddrOfPropertyDescriptor(prop->getDecl(),
+                                    fields.finishAndCreateFuture()));
+      var->setConstant(true);
+      var->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);
+      var->setAlignment(4);
+
+      TheTrivialPropertyDescriptor = var;
+    } else {
+      auto entity = LinkEntity::forPropertyDescriptor(prop->getDecl());
+      auto linkInfo = LinkInfo::get(*this, entity, ForDefinition);
+      llvm::GlobalAlias::create(linkInfo.getLinkage(),
+                                linkInfo.getName(),
+                                TheTrivialPropertyDescriptor);
+    }
+    return;
+  }
+
   ConstantInitBuilder builder(*this);
   ConstantStructBuilder fields = builder.beginStruct();
   fields.setPacked(true);
@@ -1245,7 +1272,7 @@ void IRGenModule::emitSILProperty(SILProperty *prop) {
       [&](GenericRequirement reqt) { requirements.push_back(reqt); });
   }
 
-  emitKeyPathComponent(*this, fields, prop->getComponent(),
+  emitKeyPathComponent(*this, fields, *prop->getComponent(),
                        isInstantiableInPlace, genericEnv, requirements,
                        prop->getDecl()->getInnermostDeclContext()
                                       ->getInnermostTypeContext()
@@ -1260,6 +1287,7 @@ void IRGenModule::emitSILProperty(SILProperty *prop) {
     getAddrOfPropertyDescriptor(prop->getDecl(),
                                 fields.finishAndCreateFuture()));
   var->setConstant(true);
+  var->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);
   // A simple stored component descriptor can fit in four bytes. Anything else
   // needs pointer alignment.
   if (size <= Size(4))

diff --git a/lib/IRGen/IRGenModule.h b/lib/IRGen/IRGenModule.h
@@ -570,6 +570,8 @@ class IRGenModule {
   llvm::PointerType *OpenedErrorTriplePtrTy; /// { %swift.opaque*, %swift.type*, i8** }*
   llvm::PointerType *WitnessTablePtrPtrTy;   /// i8***
 
+  llvm::GlobalVariable *TheTrivialPropertyDescriptor = nullptr;
+
   /// Used to create unique names for class layout types with tail allocated
   /// elements.
   unsigned TailElemTypeID = 0;

diff --git a/lib/ParseSIL/ParseSIL.cpp b/lib/ParseSIL/ParseSIL.cpp
@@ -5464,19 +5464,26 @@ bool SILParserTUState::parseSILProperty(Parser &P) {
   }
 
   Identifier ComponentKind;
-  KeyPathPatternComponent Component;
+  Optional<KeyPathPatternComponent> Component;
   SourceLoc ComponentLoc;
   SmallVector<SILType, 4> OperandTypes;
 
-  if (P.parseToken(tok::l_paren, diag::expected_tok_in_sil_instr, "(")
-      || P.parseIdentifier(ComponentKind, ComponentLoc,
-                           diag::expected_tok_in_sil_instr, "component kind")
-      || SP.parseKeyPathPatternComponent(Component, OperandTypes,
-               ComponentLoc, ComponentKind, InstLoc,
-               patternEnv)
-      || P.parseToken(tok::r_paren, diag::expected_tok_in_sil_instr, ")"))
+  if (P.parseToken(tok::l_paren, diag::expected_tok_in_sil_instr, "("))
     return true;
 
+  if (!P.consumeIf(tok::r_paren)) {
+    KeyPathPatternComponent parsedComponent;
+    if (P.parseIdentifier(ComponentKind, ComponentLoc,
+                          diag::expected_tok_in_sil_instr, "component kind")
+        || SP.parseKeyPathPatternComponent(parsedComponent, OperandTypes,
+                 ComponentLoc, ComponentKind, InstLoc,
+                 patternEnv)
+        || P.parseToken(tok::r_paren, diag::expected_tok_in_sil_instr, ")"))
+      return true;
+
+    Component = std::move(parsedComponent);
+  }
+
   SILProperty::create(M, Serialized,
                       cast<AbstractStorageDecl>(VD), Component);
   return false;

diff --git a/lib/SIL/SILModule.cpp b/lib/SIL/SILModule.cpp
@@ -849,7 +849,7 @@ void SILModule::setOptRecordStream(
 SILProperty *SILProperty::create(SILModule &M,
                                  bool Serialized,
                                  AbstractStorageDecl *Decl,
-                                 KeyPathPatternComponent Component) {
+                                 Optional<KeyPathPatternComponent> Component) {
   auto prop = new (M) SILProperty(Serialized, Decl, Component);
   M.properties.push_back(prop);
   return prop;

diff --git a/lib/SIL/SILPrinter.cpp b/lib/SIL/SILPrinter.cpp
@@ -2648,10 +2648,10 @@ void SILProperty::print(SILPrintContext &Ctx) const {
   if (auto sig = getDecl()->getInnermostDeclContext()
                           ->getGenericSignatureOfContext()) {
     sig->getCanonicalSignature()->print(OS, Options);
-    OS << ' ';
   }
-  OS << '(';
-  SILPrinter(Ctx).printKeyPathPatternComponent(getComponent());
+  OS << " (";
+  if (auto component = getComponent())
+    SILPrinter(Ctx).printKeyPathPatternComponent(*component);
   OS << ")\n";
 }
 

diff --git a/lib/SIL/SILVerifier.cpp b/lib/SIL/SILVerifier.cpp
@@ -4814,7 +4814,6 @@ void SILProperty::verify(const SILModule &M) const {
 
   auto *decl = getDecl();
   auto *dc = decl->getInnermostDeclContext();
-  auto &component = getComponent();
 
   // TODO: base type for global/static descriptors
   auto sig = dc->getGenericSignatureOfContext();
@@ -4844,21 +4843,22 @@ void SILProperty::verify(const SILModule &M) const {
       }
     };
 
-  verifyKeyPathComponent(const_cast<SILModule&>(M),
-    require,
-    baseTy,
-    leafTy,
-    component,
-    {},
-    canSig,
-    subs,
-    /*property descriptor*/true,
-    hasIndices);
-
-  // verifyKeyPathComponent updates baseTy to be the projected type of the
-  // component, which should be the same as the type of the declared storage
-  require(baseTy == leafTy,
-          "component type of property descriptor should match type of storage");
+  if (auto &component = getComponent()) {
+    verifyKeyPathComponent(const_cast<SILModule&>(M),
+      require,
+      baseTy,
+      leafTy,
+      *component,
+      {},
+      canSig,
+      subs,
+      /*property descriptor*/true,
+      hasIndices);
+    // verifyKeyPathComponent updates baseTy to be the projected type of the
+    // component, which should be the same as the type of the declared storage
+    require(baseTy == leafTy,
+            "component type of property descriptor should match type of storage");
+  }
 }
 
 /// Verify that a vtable follows invariants.