Skip to content

Commit 3d7646a

Browse files
slavapestovslavapestov
authored
Merge pull request #15530 from slavapestov/outliner-mangling-fixes
IRGen thunk outlining mangling fixes
2 parents aa10174 + a103186 commit 3d7646a

27 files changed

+233
-250
lines changed

‎lib/Demangling/Demangler.cpp

Lines changed: 68 additions & 47 deletions
Original file line numberDiff line numberDiff line change
@@ -2108,54 +2108,75 @@ NodePointer Demangler::demangleWitness() {
21082108
return createWithChildren(Node::Kind::AssociatedTypeWitnessTableAccessor,
21092109
Conf, AssocTypePath, ProtoTy);
21102110
}
2111-
case 'y': {
2112-
if (auto sig = popNode(Node::Kind::DependentGenericSignature))
2113-
return createWithChildren(Node::Kind::OutlinedCopy,
2114-
popNode(Node::Kind::Type), sig);
2115-
return createWithChild(Node::Kind::OutlinedCopy,
2116-
popNode(Node::Kind::Type));
2117-
}
2118-
case 'e': {
2119-
if (auto sig = popNode(Node::Kind::DependentGenericSignature))
2120-
return createWithChildren(Node::Kind::OutlinedCopy,
2121-
popNode(Node::Kind::Type), sig);
2122-
return createWithChild(Node::Kind::OutlinedConsume,
2123-
popNode(Node::Kind::Type));
2124-
}
2125-
case 'r': {
2126-
return createWithChild(Node::Kind::OutlinedRetain,
2127-
popNode(Node::Kind::Type));
2128-
}
2129-
case 's': {
2130-
return createWithChild(Node::Kind::OutlinedRelease,
2131-
popNode(Node::Kind::Type));
2132-
}
2133-
case 'b': {
2134-
NodePointer IndexChild = demangleIndexAsNode();
2135-
return createWithChildren(Node::Kind::OutlinedInitializeWithTake,
2136-
popNode(Node::Kind::Type), IndexChild);
2137-
}
2138-
case 'c': {
2139-
NodePointer IndexChild = demangleIndexAsNode();
2140-
return createWithChildren(Node::Kind::OutlinedInitializeWithCopy,
2141-
popNode(Node::Kind::Type), IndexChild);
2142-
}
2143-
case 'd': {
2144-
NodePointer IndexChild = demangleIndexAsNode();
2145-
return createWithChildren(Node::Kind::OutlinedAssignWithTake,
2146-
popNode(Node::Kind::Type), IndexChild);
2147-
}
2148-
case 'f': {
2149-
NodePointer IndexChild = demangleIndexAsNode();
2150-
return createWithChildren(Node::Kind::OutlinedAssignWithCopy,
2151-
popNode(Node::Kind::Type), IndexChild);
2152-
}
2153-
case 'h': {
2154-
NodePointer IndexChild = demangleIndexAsNode();
2155-
return createWithChildren(Node::Kind::OutlinedDestroy,
2156-
popNode(Node::Kind::Type), IndexChild);
2111+
case 'O': {
2112+
switch (nextChar()) {
2113+
case 'y': {
2114+
if (auto sig = popNode(Node::Kind::DependentGenericSignature))
2115+
return createWithChildren(Node::Kind::OutlinedCopy,
2116+
popNode(Node::Kind::Type), sig);
2117+
return createWithChild(Node::Kind::OutlinedCopy,
2118+
popNode(Node::Kind::Type));
2119+
}
2120+
case 'e': {
2121+
if (auto sig = popNode(Node::Kind::DependentGenericSignature))
2122+
return createWithChildren(Node::Kind::OutlinedConsume,
2123+
popNode(Node::Kind::Type), sig);
2124+
return createWithChild(Node::Kind::OutlinedConsume,
2125+
popNode(Node::Kind::Type));
2126+
}
2127+
case 'r': {
2128+
if (auto sig = popNode(Node::Kind::DependentGenericSignature))
2129+
return createWithChildren(Node::Kind::OutlinedRetain,
2130+
popNode(Node::Kind::Type), sig);
2131+
return createWithChild(Node::Kind::OutlinedRetain,
2132+
popNode(Node::Kind::Type));
2133+
}
2134+
case 's': {
2135+
if (auto sig = popNode(Node::Kind::DependentGenericSignature))
2136+
return createWithChildren(Node::Kind::OutlinedRelease,
2137+
popNode(Node::Kind::Type), sig);
2138+
return createWithChild(Node::Kind::OutlinedRelease,
2139+
popNode(Node::Kind::Type));
2140+
}
2141+
case 'b': {
2142+
if (auto sig = popNode(Node::Kind::DependentGenericSignature))
2143+
return createWithChildren(Node::Kind::OutlinedInitializeWithTake,
2144+
popNode(Node::Kind::Type), sig);
2145+
return createWithChild(Node::Kind::OutlinedInitializeWithTake,
2146+
popNode(Node::Kind::Type));
2147+
}
2148+
case 'c': {
2149+
if (auto sig = popNode(Node::Kind::DependentGenericSignature))
2150+
return createWithChildren(Node::Kind::OutlinedInitializeWithCopy,
2151+
popNode(Node::Kind::Type), sig);
2152+
return createWithChild(Node::Kind::OutlinedInitializeWithCopy,
2153+
popNode(Node::Kind::Type));
2154+
}
2155+
case 'd': {
2156+
if (auto sig = popNode(Node::Kind::DependentGenericSignature))
2157+
return createWithChildren(Node::Kind::OutlinedAssignWithTake,
2158+
popNode(Node::Kind::Type), sig);
2159+
return createWithChild(Node::Kind::OutlinedAssignWithTake,
2160+
popNode(Node::Kind::Type));
2161+
}
2162+
case 'f': {
2163+
if (auto sig = popNode(Node::Kind::DependentGenericSignature))
2164+
return createWithChildren(Node::Kind::OutlinedAssignWithCopy,
2165+
popNode(Node::Kind::Type), sig);
2166+
return createWithChild(Node::Kind::OutlinedAssignWithCopy,
2167+
popNode(Node::Kind::Type));
2168+
}
2169+
case 'h': {
2170+
if (auto sig = popNode(Node::Kind::DependentGenericSignature))
2171+
return createWithChildren(Node::Kind::OutlinedDestroy,
2172+
popNode(Node::Kind::Type), sig);
2173+
return createWithChild(Node::Kind::OutlinedDestroy,
2174+
popNode(Node::Kind::Type));
2175+
}
2176+
default:
2177+
return nullptr;
2178+
}
21572179
}
2158-
21592180
default:
21602181
return nullptr;
21612182
}

‎lib/Demangling/Remangler.cpp

Lines changed: 16 additions & 21 deletions
Original file line numberDiff line numberDiff line change
@@ -1843,52 +1843,47 @@ void Remangler::mangleVariadicMarker(Node *node) {
18431843

18441844
void Remangler::mangleOutlinedCopy(Node *node) {
18451845
mangleChildNodes(node);
1846-
Buffer << "Wy";
1846+
Buffer << "WOy";
18471847
}
18481848

18491849
void Remangler::mangleOutlinedConsume(Node *node) {
18501850
mangleChildNodes(node);
1851-
Buffer << "We";
1851+
Buffer << "WOe";
18521852
}
18531853

18541854
void Remangler::mangleOutlinedRetain(Node *node) {
1855-
mangleSingleChildNode(node);
1856-
Buffer << "Wr";
1855+
mangleChildNodes(node);
1856+
Buffer << "WOr";
18571857
}
18581858

18591859
void Remangler::mangleOutlinedRelease(Node *node) {
1860-
mangleSingleChildNode(node);
1861-
Buffer << "Ws";
1860+
mangleChildNodes(node);
1861+
Buffer << "WOs";
18621862
}
18631863

18641864
void Remangler::mangleOutlinedInitializeWithTake(Node *node) {
1865-
mangleChildNode(node, 0);
1866-
Buffer << "Wb";
1867-
mangleChildNode(node, 1);
1865+
mangleChildNodes(node);
1866+
Buffer << "WOb";
18681867
}
18691868

18701869
void Remangler::mangleOutlinedInitializeWithCopy(Node *node) {
1871-
mangleChildNode(node, 0);
1872-
Buffer << "Wc";
1873-
mangleChildNode(node, 1);
1870+
mangleChildNodes(node);
1871+
Buffer << "WOc";
18741872
}
18751873

18761874
void Remangler::mangleOutlinedAssignWithTake(Node *node) {
1877-
mangleChildNode(node, 0);
1878-
Buffer << "Wd";
1879-
mangleChildNode(node, 1);
1875+
mangleChildNodes(node);
1876+
Buffer << "WOd";
18801877
}
18811878

18821879
void Remangler::mangleOutlinedAssignWithCopy(Node *node) {
1883-
mangleChildNode(node, 0);
1884-
Buffer << "Wf";
1885-
mangleChildNode(node, 1);
1880+
mangleChildNodes(node);
1881+
Buffer << "WOf";
18861882
}
18871883

18881884
void Remangler::mangleOutlinedDestroy(Node *node) {
1889-
mangleChildNode(node, 0);
1890-
Buffer << "Wh";
1891-
mangleChildNode(node, 1);
1885+
mangleChildNodes(node);
1886+
Buffer << "WOh";
18921887
}
18931888

18941889
void Remangler::mangleOutlinedVariable(Node *node) {

‎lib/IRGen/GenDecl.cpp

Lines changed: 53 additions & 43 deletions
Original file line numberDiff line numberDiff line change
@@ -4231,13 +4231,35 @@ IRGenModule::getOrCreateHelperFunction(StringRef fnName, llvm::Type *resultTy,
42314231
return fn;
42324232
}
42334233

4234+
std::pair<CanType, CanGenericSignature>
4235+
irgen::getTypeAndGenericSignatureForManglingOutlineFunction(SILType type) {
4236+
auto loweredType = type.getSwiftRValueType();
4237+
if (loweredType->hasArchetype()) {
4238+
GenericEnvironment *env = nullptr;
4239+
loweredType.findIf([&env](Type t) -> bool {
4240+
if (auto arch = t->getAs<ArchetypeType>()) {
4241+
env = arch->getGenericEnvironment();
4242+
return true;
4243+
}
4244+
return false;
4245+
});
4246+
assert(env && "has archetype but no archetype?!");
4247+
return {loweredType->mapTypeOutOfContext()->getCanonicalType(),
4248+
env->getGenericSignature()->getCanonicalSignature()};
4249+
}
4250+
return {loweredType, nullptr};
4251+
}
4252+
42344253
llvm::Constant *IRGenModule::getOrCreateRetainFunction(const TypeInfo &objectTI,
4235-
Type t,
4254+
SILType t,
42364255
llvm::Type *llvmType) {
42374256
auto *loadableTI = dyn_cast<LoadableTypeInfo>(&objectTI);
42384257
assert(loadableTI && "Should only be called on Loadable types");
42394258
IRGenMangler mangler;
4240-
std::string funcName = mangler.mangleOutlinedRetainFunction(t);
4259+
auto manglingBits =
4260+
getTypeAndGenericSignatureForManglingOutlineFunction(t);
4261+
auto funcName = mangler.mangleOutlinedRetainFunction(manglingBits.first,
4262+
manglingBits.second);
42414263
llvm::Type *argTys[] = {llvmType};
42424264
return getOrCreateHelperFunction(
42434265
funcName, llvmType, argTys,
@@ -4255,12 +4277,16 @@ llvm::Constant *IRGenModule::getOrCreateRetainFunction(const TypeInfo &objectTI,
42554277
}
42564278

42574279
llvm::Constant *
4258-
IRGenModule::getOrCreateReleaseFunction(const TypeInfo &objectTI, Type t,
4280+
IRGenModule::getOrCreateReleaseFunction(const TypeInfo &objectTI,
4281+
SILType t,
42594282
llvm::Type *llvmType) {
42604283
auto *loadableTI = dyn_cast<LoadableTypeInfo>(&objectTI);
42614284
assert(loadableTI && "Should only be called on Loadable types");
42624285
IRGenMangler mangler;
4263-
std::string funcName = mangler.mangleOutlinedReleaseFunction(t);
4286+
auto manglingBits =
4287+
getTypeAndGenericSignatureForManglingOutlineFunction(t);
4288+
auto funcName = mangler.mangleOutlinedReleaseFunction(manglingBits.first,
4289+
manglingBits.second);
42644290
llvm::Type *argTys[] = {llvmType};
42654291
return getOrCreateHelperFunction(
42664292
funcName, llvmType, argTys,
@@ -4293,9 +4319,6 @@ void IRGenModule::generateCallToOutlinedCopyAddr(
42934319
llvm::Type *llvmType = dest->getType();
42944320
auto *outlinedF =
42954321
(this->*MethodToCall)(objectTI, llvmType, T, typeToMetadataVec);
4296-
llvm::Function *fn = dyn_cast<llvm::Function>(outlinedF);
4297-
assert(fn && "Expected llvm::Function");
4298-
fn->setLinkage(llvm::GlobalValue::InternalLinkage);
42994322
llvm::CallInst *call = IGF.Builder.CreateCall(outlinedF, argsVec);
43004323
call->setCallingConv(DefaultCC);
43014324
}
@@ -4304,8 +4327,10 @@ void IRGenModule::generateCallToOutlinedDestroy(
43044327
IRGenFunction &IGF, const TypeInfo &objectTI, Address addr, SILType T,
43054328
const llvm::MapVector<CanType, llvm::Value *> *typeToMetadataVec) {
43064329
IRGenMangler mangler;
4307-
CanType canType = T.getSwiftRValueType();
4308-
std::string funcName = mangler.mangleOutlinedDestroyFunction(canType, this);
4330+
auto manglingBits =
4331+
getTypeAndGenericSignatureForManglingOutlineFunction(T);
4332+
auto funcName = mangler.mangleOutlinedDestroyFunction(manglingBits.first,
4333+
manglingBits.second);
43094334

43104335
llvm::SmallVector<llvm::Type *, 4> argsTysVec;
43114336
llvm::SmallVector<llvm::Value *, 4> argsVec;
@@ -4339,12 +4364,6 @@ void IRGenModule::generateCallToOutlinedDestroy(
43394364
},
43404365
true /*setIsNoInline*/);
43414366

4342-
if (T.hasArchetype()) {
4343-
llvm::Function *fn = dyn_cast<llvm::Function>(outlinedF);
4344-
assert(fn && "Expected llvm::Function");
4345-
fn->setLinkage(llvm::GlobalValue::InternalLinkage);
4346-
}
4347-
43484367
llvm::CallInst *call = IGF.Builder.CreateCall(outlinedF, argsVec);
43494368
call->setCallingConv(DefaultCC);
43504369
}
@@ -4388,9 +4407,10 @@ llvm::Constant *IRGenModule::getOrCreateOutlinedInitializeWithTakeFunction(
43884407
const TypeInfo &objectTI, llvm::Type *llvmType, SILType addrTy,
43894408
const llvm::MapVector<CanType, llvm::Value *> *typeToMetadataVec) {
43904409
IRGenMangler mangler;
4391-
CanType canType = addrTy.getSwiftRValueType();
4392-
std::string funcName =
4393-
mangler.mangleOutlinedInitializeWithTakeFunction(canType, this);
4410+
auto manglingBits =
4411+
getTypeAndGenericSignatureForManglingOutlineFunction(addrTy);
4412+
auto funcName = mangler.mangleOutlinedInitializeWithTakeFunction(manglingBits.first,
4413+
manglingBits.second);
43944414
auto GenFunc = [](const TypeInfo &objectTI, IRGenFunction &IGF, Address dest,
43954415
Address src, SILType T) {
43964416
objectTI.initializeWithTake(IGF, dest, src, T, true);
@@ -4403,9 +4423,11 @@ llvm::Constant *IRGenModule::getOrCreateOutlinedInitializeWithCopyFunction(
44034423
const TypeInfo &objectTI, llvm::Type *llvmType, SILType addrTy,
44044424
const llvm::MapVector<CanType, llvm::Value *> *typeToMetadataVec) {
44054425
IRGenMangler mangler;
4406-
CanType canType = addrTy.getObjectType().getSwiftRValueType();
4407-
std::string funcName =
4408-
mangler.mangleOutlinedInitializeWithCopyFunction(canType, this);
4426+
auto manglingBits =
4427+
getTypeAndGenericSignatureForManglingOutlineFunction(addrTy);
4428+
auto funcName =
4429+
mangler.mangleOutlinedInitializeWithCopyFunction(manglingBits.first,
4430+
manglingBits.second);
44094431
auto GenFunc = [](const TypeInfo &objectTI, IRGenFunction &IGF, Address dest,
44104432
Address src, SILType T) {
44114433
objectTI.initializeWithCopy(IGF, dest, src, T, true);
@@ -4418,9 +4440,11 @@ llvm::Constant *IRGenModule::getOrCreateOutlinedAssignWithTakeFunction(
44184440
const TypeInfo &objectTI, llvm::Type *llvmType, SILType addrTy,
44194441
const llvm::MapVector<CanType, llvm::Value *> *typeToMetadataVec) {
44204442
IRGenMangler mangler;
4421-
CanType canType = addrTy.getObjectType().getSwiftRValueType();
4422-
std::string funcName =
4423-
mangler.mangleOutlinedAssignWithTakeFunction(canType, this);
4443+
auto manglingBits =
4444+
getTypeAndGenericSignatureForManglingOutlineFunction(addrTy);
4445+
auto funcName =
4446+
mangler.mangleOutlinedAssignWithTakeFunction(manglingBits.first,
4447+
manglingBits.second);
44244448
auto GenFunc = [](const TypeInfo &objectTI, IRGenFunction &IGF, Address dest,
44254449
Address src, SILType T) {
44264450
objectTI.assignWithTake(IGF, dest, src, T, true);
@@ -4433,29 +4457,15 @@ llvm::Constant *IRGenModule::getOrCreateOutlinedAssignWithCopyFunction(
44334457
const TypeInfo &objectTI, llvm::Type *llvmType, SILType addrTy,
44344458
const llvm::MapVector<CanType, llvm::Value *> *typeToMetadataVec) {
44354459
IRGenMangler mangler;
4436-
CanType canType = addrTy.getObjectType().getSwiftRValueType();
4437-
std::string funcName =
4438-
mangler.mangleOutlinedAssignWithCopyFunction(canType, this);
4460+
auto manglingBits =
4461+
getTypeAndGenericSignatureForManglingOutlineFunction(addrTy);
4462+
auto funcName =
4463+
mangler.mangleOutlinedAssignWithCopyFunction(manglingBits.first,
4464+
manglingBits.second);
44394465
auto GenFunc = [](const TypeInfo &objectTI, IRGenFunction &IGF, Address dest,
44404466
Address src, SILType T) {
44414467
objectTI.assignWithCopy(IGF, dest, src, T, true);
44424468
};
44434469
return getOrCreateOutlinedCopyAddrHelperFunction(
44444470
objectTI, llvmType, addrTy, funcName, GenFunc, typeToMetadataVec);
44454471
}
4446-
4447-
// IRGen is only multi-threaded during LLVM part
4448-
// We don't need to be thread safe even
4449-
// We are working on the primary module *before* LLVM
4450-
unsigned IRGenModule::getCanTypeID(const CanType type) {
4451-
if (this != IRGen.getPrimaryIGM()) {
4452-
return IRGen.getPrimaryIGM()->getCanTypeID(type);
4453-
}
4454-
auto it = typeToUniqueID.find(type.getPointer());
4455-
if (it != typeToUniqueID.end()) {
4456-
return it->second;
4457-
}
4458-
++currUniqueID;
4459-
typeToUniqueID[type.getPointer()] = currUniqueID;
4460-
return currUniqueID;
4461-
}

‎lib/IRGen/GenDecl.h

Lines changed: 4 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -53,6 +53,10 @@ namespace irgen {
5353
DebugTypeInfo DebugType=DebugTypeInfo(),
5454
Optional<SILLocation> DebugLoc = None,
5555
StringRef DebugName = StringRef());
56+
57+
std::pair<CanType, CanGenericSignature>
58+
getTypeAndGenericSignatureForManglingOutlineFunction(SILType type);
59+
5660
}
5761
}
5862

0 commit comments

Comments
 (0)