swiftlang · jckarter · Mar 9, 2017 · Mar 7, 2017
diff --git a/include/swift/AST/Builtins.def b/include/swift/AST/Builtins.def
@@ -179,9 +179,14 @@ BUILTIN_SIL_OPERATION(Load, "load", Special)
 
 /// LoadRaw has type (Builtin.RawPointer) -> T
 /// This is a load of T from raw memory.
-/// It's address does not adhere to strict aliasing.
+/// Its address does not adhere to strict aliasing.
 BUILTIN_SIL_OPERATION(LoadRaw, "loadRaw", Special)
 
+/// LoadInvariant has type (Builtin.RawPointer) -> T
+/// This is a load of T from raw memory.
+/// The load is marked as invariant.
+BUILTIN_SIL_OPERATION(LoadInvariant, "loadInvariant", Special)
+
 /// Take has type (Builtin.RawPointer) -> T
 BUILTIN_SIL_OPERATION(Take, "take", Special)
 

diff --git a/include/swift/SIL/SILBuilder.h b/include/swift/SIL/SILBuilder.h
@@ -657,9 +657,11 @@ class SILBuilder {
   }
 
   PointerToAddressInst *createPointerToAddress(SILLocation Loc, SILValue Op,
-                                               SILType Ty, bool isStrict) {
+                                               SILType Ty,
+                                               bool isStrict,
+                                               bool isInvariant = false){
     return insert(new (F.getModule()) PointerToAddressInst(
-                    getSILDebugLocation(Loc), Op, Ty, isStrict));
+                    getSILDebugLocation(Loc), Op, Ty, isStrict, isInvariant));
   }
 
   UncheckedRefCastInst *createUncheckedRefCast(SILLocation Loc, SILValue Op,

diff --git a/include/swift/SIL/SILCloner.h b/include/swift/SIL/SILCloner.h
@@ -937,7 +937,8 @@ SILCloner<ImplClass>::visitPointerToAddressInst(PointerToAddressInst *Inst) {
     getBuilder().createPointerToAddress(getOpLocation(Inst->getLoc()),
                                         getOpValue(Inst->getOperand()),
                                         getOpType(Inst->getType()),
-                                        Inst->isStrict()));
+                                        Inst->isStrict(),
+                                        Inst->isInvariant()));
 }
 
 template<typename ImplClass>

diff --git a/include/swift/SIL/SILInstruction.h b/include/swift/SIL/SILInstruction.h
@@ -2416,17 +2416,22 @@ class PointerToAddressInst
 {
   friend SILBuilder;
 
-  bool IsStrict;
+  bool IsStrict, IsInvariant;
 
   PointerToAddressInst(SILDebugLocation DebugLoc, SILValue Operand, SILType Ty,
-                       bool IsStrict)
-    : UnaryInstructionBase(DebugLoc, Operand, Ty), IsStrict(IsStrict) {}
+                       bool IsStrict, bool IsInvariant)
+    : UnaryInstructionBase(DebugLoc, Operand, Ty),
+      IsStrict(IsStrict), IsInvariant(IsInvariant) {}
 
 public:
   /// Whether the returned address adheres to strict aliasing.
   /// If true, then the type of each memory access dependent on
   /// this address must be consistent with the memory's bound type.
   bool isStrict() const { return IsStrict; }
+  /// Whether the returned address is invariant.
+  /// If true, then loading from an address derived from this pointer always
+  /// produces the same value.
+  bool isInvariant() const { return IsInvariant; }
 };
 
 /// Convert a heap object reference to a different type without any runtime

diff --git a/include/swift/Serialization/ModuleFormat.h b/include/swift/Serialization/ModuleFormat.h
@@ -54,7 +54,7 @@ const uint16_t VERSION_MAJOR = 0;
 /// in source control, you should also update the comment to briefly
 /// describe what change you made. The content of this comment isn't important;
 /// it just ensures a conflict if two people change the module format.
-const uint16_t VERSION_MINOR = 325; // Last change: unchecked_ownership_conver
+const uint16_t VERSION_MINOR = 326; // Last change: invariant bit on pointer_to_address
 
 using DeclID = PointerEmbeddedInt<unsigned, 31>;
 using DeclIDField = BCFixed<31>;

diff --git a/lib/AST/Builtins.cpp b/lib/AST/Builtins.cpp
@@ -1602,6 +1602,7 @@ ValueDecl *swift::getBuiltinValueDecl(ASTContext &Context, Identifier Id) {
 
   case BuiltinValueKind::Load:
   case BuiltinValueKind::LoadRaw:
+  case BuiltinValueKind::LoadInvariant:
   case BuiltinValueKind::Take:
     if (!Types.empty()) return nullptr;
     return getLoadOperation(Context, Id);

diff --git a/lib/IRGen/IRGenSIL.cpp b/lib/IRGen/IRGenSIL.cpp
@@ -3200,6 +3200,18 @@ void IRGenSILFunction::visitRefTailAddrInst(RefTailAddrInst *i) {
   setLoweredAddress(i, TailAddr);
 }
 
+static bool isInvariantAddress(SILValue v) {
+  auto root = getUnderlyingAddressRoot(v);
+  if (auto ptrRoot = dyn_cast<PointerToAddressInst>(root)) {
+    return ptrRoot->isInvariant();
+  }
+  // TODO: We could be more aggressive about considering addresses based on
+  // `let` variables as invariant when the type of the address is known not to
+  // have any sharably-mutable interior storage (in other words, no weak refs,
+  // atomics, etc.)
+  return false;
+}
+
 void IRGenSILFunction::visitLoadInst(swift::LoadInst *i) {
   Explosion lowered;
   Address source = getLoweredAddress(i->getOperand());
@@ -3216,7 +3228,13 @@ void IRGenSILFunction::visitLoadInst(swift::LoadInst *i) {
     typeInfo.loadAsCopy(*this, source, lowered);
     break;
   }
-
+
+  if (isInvariantAddress(i->getOperand())) {
+    // It'd be better to push this down into `loadAs` methods, perhaps...
+    for (auto value : lowered.getAll())
+      if (auto load = dyn_cast<llvm::LoadInst>(value))
+        setInvariantLoad(load);
+  }
   setLoweredExplosion(i, lowered);
 }
 

diff --git a/lib/Parse/ParseSIL.cpp b/lib/Parse/ParseSIL.cpp
@@ -2377,21 +2377,27 @@ bool SILParser::parseSILInstruction(SILBasicBlock *BB, SILBuilder &B) {
     SILType Ty;
     Identifier ToToken;
     SourceLoc ToLoc;
-    bool isStrict = false;
+    StringRef attr;
     if (parseTypedValueRef(Val, B) ||
         parseSILIdentifier(ToToken, ToLoc,
-                           diag::expected_tok_in_sil_instr, "to") ||
-        parseSILOptional(isStrict, *this, "strict") ||
-        parseSILType(Ty) ||
+                           diag::expected_tok_in_sil_instr, "to"))
+      return true;
+    if (parseSILOptional(attr, *this) && attr.empty())
+      return true;
+    if (parseSILType(Ty) ||
         parseSILDebugLocation(InstLoc, B))
       return true;
 
+    bool isStrict = attr.equals("strict");
+    bool isInvariant = attr.equals("invariant");
+
     if (ToToken.str() != "to") {
       P.diagnose(ToLoc, diag::expected_tok_in_sil_instr, "to");
       return true;
     }
 
-    ResultVal = B.createPointerToAddress(InstLoc, Val, Ty, isStrict);
+    ResultVal = B.createPointerToAddress(InstLoc, Val, Ty,
+                                         isStrict, isInvariant);
     break;
   }
   case ValueKind::RefToBridgeObjectInst: {

diff --git a/lib/SIL/SILOwnershipVerifier.cpp b/lib/SIL/SILOwnershipVerifier.cpp
@@ -1110,6 +1110,7 @@ BUILTINS_THAT_SHOULD_HAVE_BEEN_LOWERED_TO_SILINSTS(TryPin)
 BUILTINS_THAT_SHOULD_HAVE_BEEN_LOWERED_TO_SILINSTS(Unpin)
 BUILTINS_THAT_SHOULD_HAVE_BEEN_LOWERED_TO_SILINSTS(Load)
 BUILTINS_THAT_SHOULD_HAVE_BEEN_LOWERED_TO_SILINSTS(LoadRaw)
+BUILTINS_THAT_SHOULD_HAVE_BEEN_LOWERED_TO_SILINSTS(LoadInvariant)
 BUILTINS_THAT_SHOULD_HAVE_BEEN_LOWERED_TO_SILINSTS(Take)
 BUILTINS_THAT_SHOULD_HAVE_BEEN_LOWERED_TO_SILINSTS(Destroy)
 BUILTINS_THAT_SHOULD_HAVE_BEEN_LOWERED_TO_SILINSTS(Assign)

diff --git a/lib/SIL/SILPrinter.cpp b/lib/SIL/SILPrinter.cpp
@@ -1266,6 +1266,8 @@ class SILPrinter : public SILVisitor<SILPrinter> {
     *this << getIDAndType(CI->getOperand()) << " to ";
     if (CI->isStrict())
       *this << "[strict] ";
+    if (CI->isInvariant())
+      *this << "[invariant] ";
     *this << CI->getType();
   }
   void visitUncheckedRefCastInst(UncheckedRefCastInst *CI) {

diff --git a/lib/SIL/SILValue.cpp b/lib/SIL/SILValue.cpp
@@ -661,6 +661,7 @@ CONSTANT_OWNERSHIP_BUILTIN(Trivial, IntToPtr)
 CONSTANT_OWNERSHIP_BUILTIN(Trivial, LShr)
 CONSTANT_OWNERSHIP_BUILTIN(Trivial, Load)
 CONSTANT_OWNERSHIP_BUILTIN(Trivial, LoadRaw)
+CONSTANT_OWNERSHIP_BUILTIN(Trivial, LoadInvariant)
 CONSTANT_OWNERSHIP_BUILTIN(Trivial, Mul)
 CONSTANT_OWNERSHIP_BUILTIN(Trivial, Or)
 CONSTANT_OWNERSHIP_BUILTIN(Trivial, PtrToInt)

diff --git a/lib/SILGen/SILGenApply.cpp b/lib/SILGen/SILGenApply.cpp
@@ -5289,7 +5289,9 @@ emitMaterializeForSetAccessor(SILLocation loc, SILDeclRef materializeForSet,
   // materialize for set is strictly typed, whether it is the local buffer or
   // stored property.
   SILValue address = results[0].getUnmanagedValue();
-  address = B.createPointerToAddress(loc, address, buffer->getType(), /*isStrict*/ true);
+  address = B.createPointerToAddress(loc, address, buffer->getType(),
+                                     /*isStrict*/ true,
+                                     /*isInvariant*/ false);
 
   // Project out the optional callback.
   SILValue optionalCallback = results[1].getUnmanagedValue();
@@ -5391,7 +5393,9 @@ emitAddressorAccessor(SILLocation loc, SILDeclRef addressor,
                                   SILType::getRawPointerType(getASTContext()));
 
   // Convert to the appropriate address type and return.
-  SILValue address = B.createPointerToAddress(loc, pointer, addressType, /*isStrict*/ true);
+  SILValue address = B.createPointerToAddress(loc, pointer, addressType,
+                                              /*isStrict*/ true,
+                                              /*isInvariant*/ false);
 
   // Mark dependence as necessary.
   switch (cast<FuncDecl>(addressor.getDecl())->getAddressorKind()) {

diff --git a/lib/SILGen/SILGenBuiltin.cpp b/lib/SILGen/SILGenBuiltin.cpp
@@ -160,7 +160,8 @@ static ManagedValue emitBuiltinLoadOrTake(SILGenFunction &gen,
                                           CanFunctionType formalApplyType,
                                           SGFContext C,
                                           IsTake_t isTake,
-                                          bool isStrict) {
+                                          bool isStrict,
+                                          bool isInvariant) {
   assert(substitutions.size() == 1 && "load should have single substitution");
   assert(args.size() == 1 && "load should have a single argument");
 
@@ -173,7 +174,7 @@ static ManagedValue emitBuiltinLoadOrTake(SILGenFunction &gen,
   // Convert the pointer argument to a SIL address.
   SILValue addr = gen.B.createPointerToAddress(loc, args[0].getUnmanagedValue(),
                                                loadedType.getAddressType(),
-                                               isStrict);
+                                               isStrict, isInvariant);
   // Perform the load.
   return gen.emitLoad(loc, addr, rvalueTL, C, isTake);
 }
@@ -186,7 +187,7 @@ static ManagedValue emitBuiltinLoad(SILGenFunction &gen,
                                     SGFContext C) {
   return emitBuiltinLoadOrTake(gen, loc, substitutions, args,
                                formalApplyType, C, IsNotTake,
-                               /*isStrict*/ true);
+                               /*isStrict*/ true, /*isInvariant*/ false);
 }
 
 static ManagedValue emitBuiltinLoadRaw(SILGenFunction &gen,
@@ -197,7 +198,17 @@ static ManagedValue emitBuiltinLoadRaw(SILGenFunction &gen,
                                        SGFContext C) {
   return emitBuiltinLoadOrTake(gen, loc, substitutions, args,
                                formalApplyType, C, IsNotTake,
-                               /*isStrict*/ false);
+                               /*isStrict*/ false, /*isInvariant*/ false);
+}
+static ManagedValue emitBuiltinLoadInvariant(SILGenFunction &gen,
+                                             SILLocation loc,
+                                             SubstitutionList substitutions,
+                                             ArrayRef<ManagedValue> args,
+                                             CanFunctionType formalApplyType,
+                                             SGFContext C) {
+  return emitBuiltinLoadOrTake(gen, loc, substitutions, args,
+                               formalApplyType, C, IsNotTake,
+                               /*isStrict*/ false, /*isInvariant*/ true);
 }
 
 static ManagedValue emitBuiltinTake(SILGenFunction &gen,
@@ -207,7 +218,8 @@ static ManagedValue emitBuiltinTake(SILGenFunction &gen,
                                     CanFunctionType formalApplyType,
                                     SGFContext C) {
   return emitBuiltinLoadOrTake(gen, loc, substitutions, args,
-                               formalApplyType, C, IsTake, /*isStrict*/ true);
+                               formalApplyType, C, IsTake,
+                               /*isStrict*/ true, /*isInvariant*/ false);
 }
 
 /// Specialized emitter for Builtin.destroy.
@@ -233,7 +245,8 @@ static ManagedValue emitBuiltinDestroy(SILGenFunction &gen,
   SILValue addr =
     gen.B.createPointerToAddress(loc, args[1].getUnmanagedValue(),
                                  destroyType.getAddressType(),
-                                 /*isStrict*/ true);
+                                 /*isStrict*/ true,
+                                 /*isInvariant*/ false);
 
   // Destroy the value indirectly. Canonicalization will promote to loads
   // and releases if appropriate.
@@ -260,7 +273,8 @@ static ManagedValue emitBuiltinAssign(SILGenFunction &gen,
   SILValue addr = gen.B.createPointerToAddress(loc,
                                                args.back().getUnmanagedValue(),
                                                assignType.getAddressType(),
-                                               /*isStrict*/ true);
+                                               /*isStrict*/ true,
+                                               /*isInvariant*/ false);
 
   // Build the value to be assigned, reconstructing tuples if needed.
   auto src = RValue::withPreExplodedElements(args.slice(0, args.size() - 1),
@@ -287,7 +301,8 @@ static ManagedValue emitBuiltinInit(SILGenFunction &gen,
   SILValue addr = gen.emitRValueAsSingleValue(args[1]).getUnmanagedValue();
   addr = gen.B.createPointerToAddress(
     loc, addr, formalTL.getLoweredType().getAddressType(),
-    /*isStrict*/ true);
+    /*isStrict*/ true,
+    /*isInvariant*/ false);
 
   TemporaryInitialization init(addr, CleanupHandle::invalid());
   gen.emitExprInto(args[0], &init);
@@ -508,7 +523,9 @@ static ManagedValue emitBuiltinGep(SILGenFunction &gen,
   SILType ElemTy = gen.getLoweredType(substitutions[0].getReplacement());
   SILType RawPtrType = args[0].getUnmanagedValue()->getType();
   SILValue addr = gen.B.createPointerToAddress(loc, args[0].getUnmanagedValue(),
-                                               ElemTy.getAddressType(), true);
+                                               ElemTy.getAddressType(),
+                                               /*strict*/ true,
+                                               /*invariant*/ false);
   addr = gen.B.createIndexAddr(loc, addr, args[1].getUnmanagedValue());
   addr = gen.B.createAddressToPointer(loc, addr, RawPtrType);
 
@@ -529,7 +546,9 @@ static ManagedValue emitBuiltinGetTailAddr(SILGenFunction &gen,
   SILType TailTy = gen.getLoweredType(substitutions[1].getReplacement());
   SILType RawPtrType = args[0].getUnmanagedValue()->getType();
   SILValue addr = gen.B.createPointerToAddress(loc, args[0].getUnmanagedValue(),
-                                               ElemTy.getAddressType(), true);
+                                               ElemTy.getAddressType(),
+                                               /*strict*/ true,
+                                               /*invariant*/ false);
   addr = gen.B.createTailAddr(loc, addr, args[1].getUnmanagedValue(),
                               TailTy.getAddressType());
   addr = gen.B.createAddressToPointer(loc, addr, RawPtrType);

diff --git a/lib/SILGen/SILGenExpr.cpp b/lib/SILGen/SILGenExpr.cpp
@@ -1796,7 +1796,9 @@ VarargsInfo Lowering::emitBeginVarargs(SILGenFunction &gen, SILLocation loc,
 
   // Turn the pointer into an address.
   basePtr = gen.B.createPointerToAddress(
-    loc, basePtr, baseTL.getLoweredType().getAddressType(), /*isStrict*/ true);
+    loc, basePtr, baseTL.getLoweredType().getAddressType(),
+    /*isStrict*/ true,
+    /*isInvariant*/ false);
 
   return VarargsInfo(array, abortCleanup, basePtr, baseTL, baseAbstraction);
 }

diff --git a/lib/SILGen/SILGenGlobalVariable.cpp b/lib/SILGen/SILGenGlobalVariable.cpp
@@ -108,7 +108,7 @@ SILGenFunction::emitGlobalVariableRef(SILLocation loc, VarDecl *var) {
     // address.
     addr = B.createPointerToAddress(
       loc, addr, getLoweredType(var->getInterfaceType()).getAddressType(),
-      /*isStrict*/ true);
+      /*isStrict*/ true, /*isInvariant*/ false);
     return ManagedValue::forLValue(addr);
   }
 

diff --git a/lib/SILGen/SILGenMaterializeForSet.cpp b/lib/SILGen/SILGenMaterializeForSet.cpp
@@ -860,7 +860,8 @@ MaterializeForSetEmitter::emitUsingGetterSetter(SILGenFunction &gen,
   resultBuffer =
     gen.B.createPointerToAddress(loc, resultBuffer,
                                  RequirementStorageType.getAddressType(),
-                                 /*isStrict*/ true);
+                                 /*isStrict*/ true,
+                                 /*isInvariant*/ false);
   TemporaryInitialization init(resultBuffer, CleanupHandle::invalid());
 
   // Evaluate the getter into the result buffer.
@@ -943,7 +944,8 @@ MaterializeForSetEmitter::createSetterCallback(SILFunction &F,
     // The callback gets the value at +1.
     auto &valueTL = gen.getTypeLowering(lvalue.getTypeOfRValue());
     value = gen.B.createPointerToAddress(
-      loc, value, valueTL.getLoweredType().getAddressType(), /*isStrict*/ true);
+      loc, value, valueTL.getLoweredType().getAddressType(),
+      /*isStrict*/ true, /*isInvariant*/ false);
     if (valueTL.isLoadable() || !gen.silConv.useLoweredAddresses())
       value = valueTL.emitLoad(gen.B, loc, value, LoadOwnershipQualifier::Take);
     ManagedValue mValue = gen.emitManagedRValueWithCleanup(value, valueTL);

diff --git a/lib/SILOptimizer/SILCombiner/SILCombinerBuiltinVisitors.cpp b/lib/SILOptimizer/SILCombiner/SILCombinerBuiltinVisitors.cpp
@@ -289,7 +289,8 @@ static SILInstruction *createIndexAddrFrom(IndexRawPointerInst *I,
 
   // index_raw_pointer's address type is currently always strict.
   auto *NewPTAI = Builder.createPointerToAddress(
-    I->getLoc(), Ptr, InstanceType.getAddressType(), /*isStrict*/ true);
+    I->getLoc(), Ptr, InstanceType.getAddressType(),
+    /*isStrict*/ true, /*isInvariant*/ false);
 
   auto *DistanceAsWord =
       Builder.createBuiltin(I->getLoc(), TruncOrBitCast->getName(),

diff --git a/lib/SILOptimizer/SILCombiner/SILCombinerCastVisitors.cpp b/lib/SILOptimizer/SILCombiner/SILCombinerCastVisitors.cpp
@@ -140,7 +140,8 @@ visitPointerToAddressInst(PointerToAddressInst *PTAI) {
 
         auto *NewPTAI = Builder.createPointerToAddress(PTAI->getLoc(), Ptr,
                                                        PTAI->getType(),
-                                                       PTAI->isStrict());
+                                                       PTAI->isStrict(),
+                                                       PTAI->isInvariant());
         auto DistanceAsWord = Builder.createBuiltin(
             PTAI->getLoc(), Trunc->getName(), Trunc->getType(), {}, Distance);
 
@@ -181,7 +182,7 @@ visitPointerToAddressInst(PointerToAddressInst *PTAI) {
       SILValue Distance = Bytes->getArguments()[0];
       auto *NewPTAI =
         Builder.createPointerToAddress(PTAI->getLoc(), Ptr, PTAI->getType(),
-                                       PTAI->isStrict());
+                                       PTAI->isStrict(), PTAI->isInvariant());
       return Builder.createIndexAddr(PTAI->getLoc(), NewPTAI, Distance);
     }
   }

diff --git a/lib/Serialization/DeserializeSIL.cpp b/lib/Serialization/DeserializeSIL.cpp
@@ -913,12 +913,13 @@ bool SILDeserializer::readSILInstruction(SILFunction *Fn, SILBasicBlock *BB,
     assert(RecordKind == SIL_ONE_TYPE_ONE_OPERAND &&
            "Layout should be OneTypeOneOperand.");
     bool isStrict = Attr & 0x01;
+    bool isInvariant = Attr & 0x02;
     ResultVal = Builder.createPointerToAddress(
       Loc,
       getLocalValue(ValID, getSILType(MF->getType(TyID2),
                                       (SILValueCategory)TyCategory2)),
       getSILType(MF->getType(TyID), (SILValueCategory)TyCategory),
-      isStrict);
+      isStrict, isInvariant);
     break;
   }
   case ValueKind::DeallocExistentialBoxInst: {