Merge pull request #5446 from practicalswift/gardening-20161025
diff --git a/include/swift/SIL/SILBuilder.h b/include/swift/SIL/SILBuilder.h
index 51b0276..b19a076 100644
--- a/include/swift/SIL/SILBuilder.h
+++ b/include/swift/SIL/SILBuilder.h
@@ -1489,7 +1489,7 @@
void emitRetainValueOperation(SILLocation Loc, SILValue v) {
assert(!v->getType().isAddress());
auto &lowering = getTypeLowering(v->getType());
- return lowering.emitRetainValue(*this, Loc, v);
+ lowering.emitCopyValue(*this, Loc, v);
}
/// Convenience function for calling TypeLowering.emitRelease on the type
@@ -1497,7 +1497,7 @@
void emitReleaseValueOperation(SILLocation Loc, SILValue v) {
assert(!v->getType().isAddress());
auto &lowering = getTypeLowering(v->getType());
- lowering.emitReleaseValue(*this, Loc, v);
+ lowering.emitDestroyValue(*this, Loc, v);
}
SILValue emitTupleExtract(SILLocation Loc, SILValue Operand, unsigned FieldNo,
diff --git a/include/swift/SIL/TypeLowering.h b/include/swift/SIL/TypeLowering.h
index 57dc571..d6e15be 100644
--- a/include/swift/SIL/TypeLowering.h
+++ b/include/swift/SIL/TypeLowering.h
@@ -238,7 +238,7 @@
/// Emit a lowered 'release_value' operation.
///
/// This type must be loadable.
- virtual void emitLoweredReleaseValue(SILBuilder &B, SILLocation loc,
+ virtual void emitLoweredDestroyValue(SILBuilder &B, SILLocation loc,
SILValue value,
LoweringStyle loweringStyle) const = 0;
@@ -246,24 +246,24 @@
SILValue value,
LoweringStyle loweringStyle) const {
if (loweringStyle != LoweringStyle::Shallow)
- return emitLoweredReleaseValue(B, loc, value, loweringStyle);
- return emitReleaseValue(B, loc, value);
+ return emitLoweredDestroyValue(B, loc, value, loweringStyle);
+ return emitDestroyValue(B, loc, value);
}
/// Emit a lowered 'release_value' operation.
///
/// This type must be loadable.
- void emitLoweredReleaseValueShallow(SILBuilder &B, SILLocation loc,
+ void emitLoweredDestroyValueShallow(SILBuilder &B, SILLocation loc,
SILValue value) const {
- emitLoweredReleaseValue(B, loc, value, LoweringStyle::Shallow);
+ emitLoweredDestroyValue(B, loc, value, LoweringStyle::Shallow);
}
/// Emit a lowered 'release_value' operation.
///
/// This type must be loadable.
- void emitLoweredReleaseValueDeepNoEnum(SILBuilder &B, SILLocation loc,
+ void emitLoweredDestroyValueDeepNoEnum(SILBuilder &B, SILLocation loc,
SILValue value) const {
- emitLoweredReleaseValue(B, loc, value, LoweringStyle::DeepNoEnum);
+ emitLoweredDestroyValue(B, loc, value, LoweringStyle::DeepNoEnum);
}
/// Given a primitively loaded value of this type (which must be
@@ -274,30 +274,30 @@
/// example, it performs an unowned_release on a value of [unknown]
/// type. It is therefore not necessarily the right thing to do on
/// a semantic load.
- virtual void emitReleaseValue(SILBuilder &B, SILLocation loc,
+ virtual void emitDestroyValue(SILBuilder &B, SILLocation loc,
SILValue value) const = 0;
/// Emit a lowered 'retain_value' operation.
///
/// This type must be loadable.
- virtual void emitLoweredRetainValue(SILBuilder &B, SILLocation loc,
+ virtual void emitLoweredCopyValue(SILBuilder &B, SILLocation loc,
SILValue value,
LoweringStyle style) const = 0;
/// Emit a lowered 'retain_value' operation.
///
/// This type must be loadable.
- void emitLoweredRetainValueShallow(SILBuilder &B, SILLocation loc,
+ void emitLoweredCopyValueShallow(SILBuilder &B, SILLocation loc,
SILValue value) const {
- emitLoweredRetainValue(B, loc, value, LoweringStyle::Shallow);
+ emitLoweredCopyValue(B, loc, value, LoweringStyle::Shallow);
}
/// Emit a lowered 'retain_value' operation.
///
/// This type must be loadable.
void emitLoweredRetainValueDeepNoEnum(SILBuilder &B, SILLocation loc,
- SILValue value) const {
- emitLoweredRetainValue(B, loc, value, LoweringStyle::DeepNoEnum);
+ SILValue value) const {
+ emitLoweredCopyValue(B, loc, value, LoweringStyle::DeepNoEnum);
}
/// Given a primitively loaded value of this type (which must be
@@ -307,16 +307,16 @@
/// with exactly the same semantics. For example, it performs an
/// unowned_retain on a value of [unknown] type. It is therefore
/// not necessarily the right thing to do on a semantic load.
- virtual void emitRetainValue(SILBuilder &B, SILLocation loc,
+ virtual void emitCopyValue(SILBuilder &B, SILLocation loc,
SILValue value) const = 0;
void emitLoweredCopyChildValue(SILBuilder &B, SILLocation loc,
SILValue value,
LoweringStyle style) const {
if (style != LoweringStyle::Shallow) {
- emitLoweredRetainValue(B, loc, value, style);
+ emitLoweredCopyValue(B, loc, value, style);
} else {
- emitRetainValue(B, loc, value);
+ emitCopyValue(B, loc, value);
}
}
diff --git a/include/swift/Serialization/ModuleFormat.h b/include/swift/Serialization/ModuleFormat.h
index 8d30b2b..4982edf 100644
--- a/include/swift/Serialization/ModuleFormat.h
+++ b/include/swift/Serialization/ModuleFormat.h
@@ -54,7 +54,7 @@
/// 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 = 279; // Last change: copy_value, destroy_value
+const uint16_t VERSION_MINOR = 280; // Last change: function qualified ownership
using DeclID = PointerEmbeddedInt<unsigned, 31>;
using DeclIDField = BCFixed<31>;
diff --git a/lib/SIL/DynamicCasts.cpp b/lib/SIL/DynamicCasts.cpp
index 5020eac..995a50c 100644
--- a/lib/SIL/DynamicCasts.cpp
+++ b/lib/SIL/DynamicCasts.cpp
@@ -781,7 +781,7 @@
SILValue getOwnedScalar(Source source, const TypeLowering &srcTL) {
assert(!source.isAddress());
if (!source.shouldTake())
- srcTL.emitRetainValue(B, Loc, source.Value);
+ srcTL.emitCopyValue(B, Loc, source.Value);
return source.Value;
}
@@ -1217,7 +1217,7 @@
SILValue succValue =
new (B.getModule()) SILArgument(scalarSuccBB, targetValueType);
if (!shouldTakeOnSuccess(consumption))
- targetTL.emitRetainValue(B, loc, succValue);
+ targetTL.emitCopyValue(B, loc, succValue);
targetTL.emitStoreOfCopy(B, loc, succValue, dest, IsInitialization);
B.createBranch(loc, indirectSuccBB);
}
@@ -1225,7 +1225,7 @@
// Emit the failure block.
if (shouldDestroyOnFailure(consumption)) {
B.setInsertionPoint(scalarFailBB);
- srcTL.emitReleaseValue(B, loc, srcValue);
+ srcTL.emitDestroyValue(B, loc, srcValue);
B.createBranch(loc, indirectFailBB);
}
}
diff --git a/lib/SIL/TypeLowering.cpp b/lib/SIL/TypeLowering.cpp
index 882ba94..ba07be1 100644
--- a/lib/SIL/TypeLowering.cpp
+++ b/lib/SIL/TypeLowering.cpp
@@ -495,12 +495,12 @@
void emitDestroyAddress(SILBuilder &B, SILLocation loc,
SILValue addr) const override {
SILValue value = B.createLoad(loc, addr);
- emitReleaseValue(B, loc, value);
+ emitDestroyValue(B, loc, value);
}
void emitDestroyRValue(SILBuilder &B, SILLocation loc,
SILValue value) const override {
- emitReleaseValue(B, loc, value);
+ emitDestroyValue(B, loc, value);
}
void emitCopyInto(SILBuilder &B, SILLocation loc,
@@ -533,24 +533,22 @@
// Trivial
}
- void emitLoweredReleaseValue(SILBuilder &B, SILLocation loc,
- SILValue value,
+ void emitLoweredDestroyValue(SILBuilder &B, SILLocation loc, SILValue value,
LoweringStyle loweringStyle) const override {
// Trivial
}
- void emitLoweredRetainValue(SILBuilder &B, SILLocation loc,
- SILValue value,
+ void emitLoweredCopyValue(SILBuilder &B, SILLocation loc, SILValue value,
LoweringStyle style) const override {
// Trivial
}
- void emitRetainValue(SILBuilder &B, SILLocation loc,
+ void emitCopyValue(SILBuilder &B, SILLocation loc,
SILValue value) const override {
// Trivial
}
- void emitReleaseValue(SILBuilder &B, SILLocation loc,
+ void emitDestroyValue(SILBuilder &B, SILLocation loc,
SILValue value) const override {
// Trivial
}
@@ -565,7 +563,8 @@
SILValue emitLoadOfCopy(SILBuilder &B, SILLocation loc,
SILValue addr, IsTake_t isTake) const override {
SILValue value = B.createLoad(loc, addr);
- if (!isTake) emitRetainValue(B, loc, value);
+ if (!isTake)
+ emitCopyValue(B, loc, value);
return value;
}
@@ -575,7 +574,8 @@
SILValue oldValue;
if (!isInit) oldValue = B.createLoad(loc, addr);
B.createStore(loc, newValue, addr);
- if (!isInit) emitReleaseValue(B, loc, oldValue);
+ if (!isInit)
+ emitDestroyValue(B, loc, oldValue);
}
};
@@ -657,13 +657,12 @@
});
}
- void emitRetainValue(SILBuilder &B, SILLocation loc,
+ void emitCopyValue(SILBuilder &B, SILLocation loc,
SILValue aggValue) const override {
B.createRetainValue(loc, aggValue, Atomicity::Atomic);
}
- void emitLoweredRetainValue(SILBuilder &B, SILLocation loc,
- SILValue aggValue,
+ void emitLoweredCopyValue(SILBuilder &B, SILLocation loc, SILValue aggValue,
LoweringStyle style) const override {
for (auto &child : getChildren(B.getModule())) {
auto &childLowering = child.getLowering();
@@ -676,22 +675,22 @@
}
}
- void emitReleaseValue(SILBuilder &B, SILLocation loc,
+ void emitDestroyValue(SILBuilder &B, SILLocation loc,
SILValue aggValue) const override {
B.emitReleaseValueAndFold(loc, aggValue);
}
- void emitLoweredReleaseValue(SILBuilder &B, SILLocation loc,
+ void emitLoweredDestroyValue(SILBuilder &B, SILLocation loc,
SILValue aggValue,
LoweringStyle loweringStyle) const override {
SimpleOperationTy Fn;
switch(loweringStyle) {
case LoweringStyle::Shallow:
- Fn = &TypeLowering::emitReleaseValue;
+ Fn = &TypeLowering::emitDestroyValue;
break;
case LoweringStyle::DeepNoEnum:
- Fn = &TypeLowering::emitLoweredReleaseValueDeepNoEnum;
+ Fn = &TypeLowering::emitLoweredDestroyValueDeepNoEnum;
break;
}
@@ -774,24 +773,22 @@
: NonTrivialLoadableTypeLowering(SILType::getPrimitiveObjectType(type),
IsNotReferenceCounted) {}
- void emitRetainValue(SILBuilder &B, SILLocation loc,
+ void emitCopyValue(SILBuilder &B, SILLocation loc,
SILValue value) const override {
B.createRetainValue(loc, value, Atomicity::Atomic);
}
- void emitLoweredRetainValue(SILBuilder &B, SILLocation loc,
- SILValue value,
+ void emitLoweredCopyValue(SILBuilder &B, SILLocation loc, SILValue value,
LoweringStyle style) const override {
B.createRetainValue(loc, value, Atomicity::Atomic);
}
-
- void emitReleaseValue(SILBuilder &B, SILLocation loc,
+
+ void emitDestroyValue(SILBuilder &B, SILLocation loc,
SILValue value) const override {
B.emitReleaseValueAndFold(loc, value);
}
- void emitLoweredReleaseValue(SILBuilder &B, SILLocation loc,
- SILValue value,
+ void emitLoweredDestroyValue(SILBuilder &B, SILLocation loc, SILValue value,
LoweringStyle style) const override {
assert(style != LoweringStyle::Shallow &&
"This method should never be called when performing a shallow "
@@ -805,16 +802,14 @@
LeafLoadableTypeLowering(SILType type, IsReferenceCounted_t isRefCounted)
: NonTrivialLoadableTypeLowering(type, isRefCounted) {}
- void emitLoweredRetainValue(SILBuilder &B, SILLocation loc,
- SILValue value,
+ void emitLoweredCopyValue(SILBuilder &B, SILLocation loc, SILValue value,
LoweringStyle style) const override {
- emitRetainValue(B, loc, value);
+ emitCopyValue(B, loc, value);
}
- void emitLoweredReleaseValue(SILBuilder &B, SILLocation loc,
- SILValue value,
+ void emitLoweredDestroyValue(SILBuilder &B, SILLocation loc, SILValue value,
LoweringStyle style) const override {
- emitReleaseValue(B, loc, value);
+ emitDestroyValue(B, loc, value);
}
};
@@ -825,13 +820,13 @@
ReferenceTypeLowering(SILType type)
: LeafLoadableTypeLowering(type, IsReferenceCounted) {}
- void emitRetainValue(SILBuilder &B, SILLocation loc,
+ void emitCopyValue(SILBuilder &B, SILLocation loc,
SILValue value) const override {
if (!isa<FunctionRefInst>(value))
B.createStrongRetain(loc, value, Atomicity::Atomic);
}
- void emitReleaseValue(SILBuilder &B, SILLocation loc,
+ void emitDestroyValue(SILBuilder &B, SILLocation loc,
SILValue value) const override {
B.emitStrongReleaseAndFold(loc, value);
}
@@ -843,12 +838,12 @@
LoadableUnownedTypeLowering(SILType type)
: LeafLoadableTypeLowering(type, IsReferenceCounted) {}
- void emitRetainValue(SILBuilder &B, SILLocation loc,
+ void emitCopyValue(SILBuilder &B, SILLocation loc,
SILValue value) const override {
B.createUnownedRetain(loc, value, Atomicity::Atomic);
}
- void emitReleaseValue(SILBuilder &B, SILLocation loc,
+ void emitDestroyValue(SILBuilder &B, SILLocation loc,
SILValue value) const override {
B.createUnownedRelease(loc, value, Atomicity::Atomic);
}
@@ -888,24 +883,22 @@
B.emitDestroyAddrAndFold(loc, value);
}
- void emitRetainValue(SILBuilder &B, SILLocation loc,
+ void emitCopyValue(SILBuilder &B, SILLocation loc,
SILValue value) const override {
llvm_unreachable("type is not loadable!");
}
- void emitLoweredRetainValue(SILBuilder &B, SILLocation loc,
- SILValue value,
+ void emitLoweredCopyValue(SILBuilder &B, SILLocation loc, SILValue value,
LoweringStyle style) const override {
llvm_unreachable("type is not loadable!");
}
- void emitReleaseValue(SILBuilder &B, SILLocation loc,
+ void emitDestroyValue(SILBuilder &B, SILLocation loc,
SILValue value) const override {
llvm_unreachable("type is not loadable!");
}
- void emitLoweredReleaseValue(SILBuilder &B, SILLocation loc,
- SILValue value,
+ void emitLoweredDestroyValue(SILBuilder &B, SILLocation loc, SILValue value,
LoweringStyle style) const override {
llvm_unreachable("type is not loadable!");
}
diff --git a/lib/SILGen/ManagedValue.cpp b/lib/SILGen/ManagedValue.cpp
index 8cc6d79..5d4f382 100644
--- a/lib/SILGen/ManagedValue.cpp
+++ b/lib/SILGen/ManagedValue.cpp
@@ -33,7 +33,7 @@
assert(!lowering.isTrivial() && "trivial value has cleanup?");
if (!lowering.isAddressOnly()) {
- lowering.emitRetainValue(gen.B, l, getValue());
+ lowering.emitCopyValue(gen.B, l, getValue());
return gen.emitManagedRValueWithCleanup(getValue(), lowering);
}
@@ -51,7 +51,7 @@
IsNotTake, IsInitialization);
return;
}
- lowering.emitRetainValue(gen.B, L, getValue());
+ lowering.emitCopyValue(gen.B, L, getValue());
gen.B.createStore(L, getValue(), dest);
}
@@ -65,7 +65,7 @@
SILValue result;
if (!lowering.isAddressOnly()) {
- lowering.emitRetainValue(gen.B, loc, getValue());
+ lowering.emitCopyValue(gen.B, loc, getValue());
result = getValue();
} else {
result = gen.emitTemporaryAllocation(loc, getType());
diff --git a/lib/SILGen/SILGenApply.cpp b/lib/SILGen/SILGenApply.cpp
index 4946fa8..ac6686e 100644
--- a/lib/SILGen/SILGenApply.cpp
+++ b/lib/SILGen/SILGenApply.cpp
@@ -2422,7 +2422,7 @@
case ResultConvention::Unowned:
// Unretained. Retain the value.
- resultTL.emitRetainValue(B, loc, result);
+ resultTL.emitCopyValue(B, loc, result);
break;
}
diff --git a/lib/SILGen/SILGenBridging.cpp b/lib/SILGen/SILGenBridging.cpp
index 056877a..9fd2525 100644
--- a/lib/SILGen/SILGenBridging.cpp
+++ b/lib/SILGen/SILGenBridging.cpp
@@ -898,7 +898,7 @@
return tmp;
}
- lowering.emitRetainValue(gen.B, loc, arg);
+ lowering.emitCopyValue(gen.B, loc, arg);
return arg;
}
diff --git a/lib/SILGen/SILGenConstructor.cpp b/lib/SILGen/SILGenConstructor.cpp
index d33606a..d524b71 100644
--- a/lib/SILGen/SILGenConstructor.cpp
+++ b/lib/SILGen/SILGenConstructor.cpp
@@ -279,8 +279,8 @@
selfValue = B.createLoad(cleanupLoc, selfLV);
// Emit a retain of the loaded value, since we return it +1.
- lowering.emitRetainValue(B, cleanupLoc, selfValue);
-
+ lowering.emitCopyValue(B, cleanupLoc, selfValue);
+
// Inject the self value into an optional if the constructor is failable.
if (ctor->getFailability() != OTK_None) {
selfValue = B.createEnum(ctor, selfValue,
diff --git a/lib/SILGen/SILGenDynamicCast.cpp b/lib/SILGen/SILGenDynamicCast.cpp
index 9b4ebcc..ac0f673 100644
--- a/lib/SILGen/SILGenDynamicCast.cpp
+++ b/lib/SILGen/SILGenDynamicCast.cpp
@@ -233,7 +233,7 @@
SGFContext ctx) {
// Retain the result if this is copy-on-success.
if (!shouldTakeOnSuccess(consumption))
- origTargetTL.emitRetainValue(SGF.B, Loc, value);
+ origTargetTL.emitCopyValue(SGF.B, Loc, value);
// Enter a cleanup for the +1 result.
ManagedValue result
diff --git a/lib/SILGen/SILGenExpr.cpp b/lib/SILGen/SILGenExpr.cpp
index 778922c5..4f2af05 100644
--- a/lib/SILGen/SILGenExpr.cpp
+++ b/lib/SILGen/SILGenExpr.cpp
@@ -59,7 +59,7 @@
return ManagedValue::forUnmanaged(v);
assert(!lowering.isAddressOnly() && "cannot retain an unloadable type");
- lowering.emitRetainValue(B, loc, v);
+ lowering.emitCopyValue(B, loc, v);
return emitManagedRValueWithCleanup(v, lowering);
}
@@ -1356,7 +1356,7 @@
// If it's an object, retain and enter a release cleanup.
if (valueTy.isObject()) {
- valueTL.emitRetainValue(B, loc, value.getValue());
+ valueTL.emitCopyValue(B, loc, value.getValue());
return emitManagedRValueWithCleanup(value.getValue(), valueTL);
}
diff --git a/lib/SILGen/SILGenPoly.cpp b/lib/SILGen/SILGenPoly.cpp
index 6a2003d..a851953 100644
--- a/lib/SILGen/SILGenPoly.cpp
+++ b/lib/SILGen/SILGenPoly.cpp
@@ -722,7 +722,7 @@
// must retain them even if we're in a context that can accept a +0 value.
case ParameterConvention::Direct_Unowned:
gen.getTypeLowering(paramValue->getType())
- .emitRetainValue(gen.B, loc, paramValue);
+ .emitCopyValue(gen.B, loc, paramValue);
SWIFT_FALLTHROUGH;
case ParameterConvention::Direct_Owned:
return gen.emitManagedRValueWithCleanup(paramValue);
@@ -2104,7 +2104,7 @@
"reabstraction of returns_inner_pointer function");
SWIFT_FALLTHROUGH;
case ResultConvention::Unowned:
- resultTL.emitRetainValue(Gen.B, Loc, resultValue);
+ resultTL.emitCopyValue(Gen.B, Loc, resultValue);
return Gen.emitManagedRValueWithCleanup(resultValue, resultTL);
}
llvm_unreachable("bad result convention!");
diff --git a/lib/SILOptimizer/Analysis/ArraySemantic.cpp b/lib/SILOptimizer/Analysis/ArraySemantic.cpp
index 36b3ff4..2c36a84 100644
--- a/lib/SILOptimizer/Analysis/ArraySemantic.cpp
+++ b/lib/SILOptimizer/Analysis/ArraySemantic.cpp
@@ -665,7 +665,7 @@
SILBuilderWithScope Builder(SemanticsCall);
auto &ValLowering = Builder.getModule().getTypeLowering(V->getType());
if (hasGetElementDirectResult()) {
- ValLowering.emitRetainValue(Builder, SemanticsCall->getLoc(), V);
+ ValLowering.emitCopyValue(Builder, SemanticsCall->getLoc(), V);
SemanticsCall->replaceAllUsesWith(V);
} else {
auto Dest = SemanticsCall->getArgument(0);
@@ -675,7 +675,7 @@
if (!ASI)
return false;
- ValLowering.emitRetainValue(Builder, SemanticsCall->getLoc(), V);
+ ValLowering.emitCopyValue(Builder, SemanticsCall->getLoc(), V);
ValLowering.emitStoreOfCopy(Builder, SemanticsCall->getLoc(), V, Dest,
IsInitialization_t::IsInitialization);
}
diff --git a/lib/SILOptimizer/IPO/CapturePromotion.cpp b/lib/SILOptimizer/IPO/CapturePromotion.cpp
index b5a2072..71d9b43 100644
--- a/lib/SILOptimizer/IPO/CapturePromotion.cpp
+++ b/lib/SILOptimizer/IPO/CapturePromotion.cpp
@@ -536,7 +536,7 @@
SILFunction &F = getBuilder().getFunction();
auto &typeLowering = F.getModule().getTypeLowering(I->second->getType());
SILBuilderWithPostProcess<ClosureCloner, 1> B(this, Inst);
- typeLowering.emitReleaseValue(B, Inst->getLoc(), I->second);
+ typeLowering.emitDestroyValue(B, Inst->getLoc(), I->second);
return;
}
}
diff --git a/lib/SILOptimizer/Transforms/SILLowerAggregateInstrs.cpp b/lib/SILOptimizer/Transforms/SILLowerAggregateInstrs.cpp
index 998373c..78ca089 100644
--- a/lib/SILOptimizer/Transforms/SILLowerAggregateInstrs.cpp
+++ b/lib/SILOptimizer/Transforms/SILLowerAggregateInstrs.cpp
@@ -107,7 +107,7 @@
// retain_value %new : $*T
IsTake_t IsTake = CA->isTakeOfSrc();
if (IsTake_t::IsNotTake == IsTake) {
- TL.emitLoweredRetainValue(Builder, CA->getLoc(), New,
+ TL.emitLoweredCopyValue(Builder, CA->getLoc(), New,
TypeLowering::LoweringStyle::DeepNoEnum);
}
@@ -116,7 +116,7 @@
// *or*
// release_value %old : $*T
if (Old) {
- TL.emitLoweredReleaseValue(Builder, CA->getLoc(), Old,
+ TL.emitLoweredDestroyValue(Builder, CA->getLoc(), Old,
TypeLowering::LoweringStyle::DeepNoEnum);
}
}
@@ -146,7 +146,7 @@
// If we have a type with reference semantics, emit a load/strong release.
LoadInst *LI = Builder.createLoad(DA->getLoc(), Addr);
auto &TL = Module.getTypeLowering(Type);
- TL.emitLoweredReleaseValue(Builder, DA->getLoc(), LI,
+ TL.emitLoweredDestroyValue(Builder, DA->getLoc(), LI,
TypeLowering::LoweringStyle::DeepNoEnum);
}
@@ -168,7 +168,7 @@
"release_value should never be called on a non-loadable type.");
auto &TL = Module.getTypeLowering(Type);
- TL.emitLoweredReleaseValue(Builder, DV->getLoc(), Value,
+ TL.emitLoweredDestroyValue(Builder, DV->getLoc(), Value,
TypeLowering::LoweringStyle::DeepNoEnum);
DEBUG(llvm::dbgs() << " Expanding Destroy Value: " << *DV);
@@ -191,9 +191,9 @@
"types.");
auto &TL = Module.getTypeLowering(Type);
- TL.emitLoweredRetainValue(Builder, CV->getLoc(), Value,
+ TL.emitLoweredCopyValue(Builder, CV->getLoc(), Value,
TypeLowering::LoweringStyle::DeepNoEnum);
-
+
DEBUG(llvm::dbgs() << " Expanding Copy Value: " << *CV);
++NumExpand;
diff --git a/lib/SILOptimizer/Transforms/SILMem2Reg.cpp b/lib/SILOptimizer/Transforms/SILMem2Reg.cpp
index 1522164..ced42bf 100644
--- a/lib/SILOptimizer/Transforms/SILMem2Reg.cpp
+++ b/lib/SILOptimizer/Transforms/SILMem2Reg.cpp
@@ -347,7 +347,7 @@
auto Ty = DAI->getOperand()->getType();
auto &TL = DAI->getModule().getTypeLowering(Ty);
- TL.emitLoweredReleaseValue(Builder, DAI->getLoc(), NewValue,
+ TL.emitLoweredDestroyValue(Builder, DAI->getLoc(), NewValue,
Lowering::TypeLowering::LoweringStyle::DeepNoEnum);
DAI->eraseFromParent();
}
diff --git a/lib/Serialization/DeserializeSIL.cpp b/lib/Serialization/DeserializeSIL.cpp
index cd81a31..ad7c1b3 100644
--- a/lib/Serialization/DeserializeSIL.cpp
+++ b/lib/Serialization/DeserializeSIL.cpp
@@ -380,13 +380,13 @@
DeclID clangNodeOwnerID;
TypeID funcTyID;
unsigned rawLinkage, isTransparent, isFragile, isThunk, isGlobal,
- inlineStrategy, effect, numSpecAttrs;
+ inlineStrategy, effect, numSpecAttrs, hasQualifiedOwnership;
ArrayRef<uint64_t> SemanticsIDs;
// TODO: read fragile
SILFunctionLayout::readRecord(scratch, rawLinkage, isTransparent, isFragile,
isThunk, isGlobal, inlineStrategy, effect,
- numSpecAttrs, funcTyID, clangNodeOwnerID,
- SemanticsIDs);
+ numSpecAttrs, hasQualifiedOwnership, funcTyID,
+ clangNodeOwnerID, SemanticsIDs);
if (funcTyID == 0) {
DEBUG(llvm::dbgs() << "SILFunction typeID is 0.\n");
@@ -454,6 +454,8 @@
for (auto ID : SemanticsIDs) {
fn->addSemanticsAttr(MF->getIdentifier(ID).str());
}
+ if (!hasQualifiedOwnership)
+ fn->setUnqualifiedOwnership();
if (Callback) Callback->didDeserialize(MF->getAssociatedModule(), fn);
}
@@ -538,7 +540,6 @@
LocalValues.clear();
ForwardLocalValues.clear();
- FunctionOwnershipEvaluator OwnershipEvaluator(fn);
SILOpenedArchetypesTracker OpenedArchetypesTracker(*fn);
SILBuilder Builder(*fn);
// Track the archetypes just like SILGen. This
@@ -572,8 +573,7 @@
return fn;
// Handle a SILInstruction record.
- if (readSILInstruction(fn, CurrentBB, Builder, OwnershipEvaluator, kind,
- scratch)) {
+ if (readSILInstruction(fn, CurrentBB, Builder, kind, scratch)) {
DEBUG(llvm::dbgs() << "readSILInstruction returns error.\n");
MF->error();
return fn;
@@ -659,10 +659,10 @@
return DRef;
}
-bool SILDeserializer::readSILInstruction(
- SILFunction *Fn, SILBasicBlock *BB, SILBuilder &Builder,
- FunctionOwnershipEvaluator &OwnershipEvaluator, unsigned RecordKind,
- SmallVectorImpl<uint64_t> &scratch) {
+bool SILDeserializer::readSILInstruction(SILFunction *Fn, SILBasicBlock *BB,
+ SILBuilder &Builder,
+ unsigned RecordKind,
+ SmallVectorImpl<uint64_t> &scratch) {
// Return error if Basic Block is null.
if (!BB)
return true;
@@ -1900,11 +1900,6 @@
llvm_unreachable("todo");
}
- // Evaluate ResultVal's ownership. If we find that as a result of ResultVal,
- // we are mixing qualified and unqualified ownership instructions, bail.
- if (!OwnershipEvaluator.evaluate(ResultVal))
- return true;
-
if (ResultVal->hasValue()) {
LastValueID = LastValueID + 1;
setLocalValue(ResultVal, LastValueID);
@@ -1973,12 +1968,12 @@
DeclID clangOwnerID;
TypeID funcTyID;
unsigned rawLinkage, isTransparent, isFragile, isThunk, isGlobal,
- inlineStrategy, effect, numSpecAttrs;
+ inlineStrategy, effect, numSpecAttrs, hasQualifiedOwnership;
ArrayRef<uint64_t> SemanticsIDs;
SILFunctionLayout::readRecord(scratch, rawLinkage, isTransparent, isFragile,
isThunk, isGlobal, inlineStrategy, effect,
- numSpecAttrs, funcTyID, clangOwnerID,
- SemanticsIDs);
+ numSpecAttrs, hasQualifiedOwnership, funcTyID,
+ clangOwnerID, SemanticsIDs);
auto linkage = fromStableSILLinkage(rawLinkage);
if (!linkage) {
DEBUG(llvm::dbgs() << "invalid linkage code " << rawLinkage
diff --git a/lib/Serialization/DeserializeSIL.h b/lib/Serialization/DeserializeSIL.h
index 1e06332..9b0cafd 100644
--- a/lib/Serialization/DeserializeSIL.h
+++ b/lib/Serialization/DeserializeSIL.h
@@ -11,7 +11,6 @@
//===----------------------------------------------------------------------===//
#include "SILFormat.h"
-#include "swift/SIL/InstructionUtils.h"
#include "swift/SIL/SILModule.h"
#include "swift/Serialization/ModuleFile.h"
#include "swift/Serialization/SerializedSILLoader.h"
@@ -84,7 +83,6 @@
/// Read a SIL instruction within a given SIL basic block.
bool readSILInstruction(SILFunction *Fn, SILBasicBlock *BB,
SILBuilder &Builder,
- FunctionOwnershipEvaluator &OwnershipEvaluator,
unsigned RecordKind,
SmallVectorImpl<uint64_t> &scratch);
diff --git a/lib/Serialization/SILFormat.h b/lib/Serialization/SILFormat.h
index 3cba3bb..50758ac 100644
--- a/lib/Serialization/SILFormat.h
+++ b/lib/Serialization/SILFormat.h
@@ -238,15 +238,16 @@
using SILFunctionLayout =
BCRecordLayout<SIL_FUNCTION, SILLinkageField,
- BCFixed<1>, // transparent
- BCFixed<1>, // fragile
- BCFixed<2>, // thunk/reabstraction_thunk
- BCFixed<1>, // global_init
- BCFixed<2>, // inlineStrategy
- BCFixed<2>, // side effect info.
- BCFixed<2>, // number of specialize attributes
- TypeIDField,// SILFunctionType
- DeclIDField,// ClangNode owner
+ BCFixed<1>, // transparent
+ BCFixed<1>, // fragile
+ BCFixed<2>, // thunk/reabstraction_thunk
+ BCFixed<1>, // global_init
+ BCFixed<2>, // inlineStrategy
+ BCFixed<2>, // side effect info.
+ BCFixed<2>, // number of specialize attributes
+ BCFixed<1>, // has qualified ownership
+ TypeIDField, // SILFunctionType
+ DeclIDField, // ClangNode owner
BCArray<IdentifierIDField> // Semantics Attribute
// followed by specialize attributes
// followed by generic param list, if any
diff --git a/lib/Serialization/SerializeSIL.cpp b/lib/Serialization/SerializeSIL.cpp
index ed29901..c1bc9e4 100644
--- a/lib/Serialization/SerializeSIL.cpp
+++ b/lib/Serialization/SerializeSIL.cpp
@@ -358,7 +358,8 @@
(unsigned)F.isTransparent(), (unsigned)F.isFragile(),
(unsigned)F.isThunk(), (unsigned)F.isGlobalInit(),
(unsigned)F.getInlineStrategy(), (unsigned)F.getEffectsKind(),
- (unsigned)numSpecAttrs, FnID, clangNodeOwnerID, SemanticsIDs);
+ (unsigned)numSpecAttrs, (unsigned)F.hasQualifiedOwnership(), FnID,
+ clangNodeOwnerID, SemanticsIDs);
if (NoBody)
return;
