From c671717c0e406dbeec46a360a5e03238fb933a1f Mon Sep 17 00:00:00 2001 From: Erik Eckstein Date: Mon, 20 Feb 2017 16:38:37 -0800 Subject: [PATCH 1/3] Fix re-mangling of function specialization constant strings which start with a digit. --- lib/Basic/Remangler.cpp | 12 ++++++++++-- test/Demangle/Inputs/manglings.txt | 1 + 2 files changed, 11 insertions(+), 2 deletions(-) diff --git a/lib/Basic/Remangler.cpp b/lib/Basic/Remangler.cpp index 9fd3d28a6acea..3904398047eea 100644 --- a/lib/Basic/Remangler.cpp +++ b/lib/Basic/Remangler.cpp @@ -830,9 +830,17 @@ void Remangler::mangleFunctionSignatureSpecialization(Node *node) { case FunctionSigSpecializationParamKind::ConstantPropGlobal: mangleIdentifier(Param->getChild(1).get()); break; - case FunctionSigSpecializationParamKind::ConstantPropString: - mangleIdentifier(Param->getChild(2).get()); + case FunctionSigSpecializationParamKind::ConstantPropString: { + NodePointer TextNd = Param->getChild(2); + StringRef Text = TextNd->getText(); + if (Text.size() > 0 && (isDigit(Text[0]) || Text[0] == '_')) { + std::string Buffer = "_"; + Buffer.append(Text.data(), Text.size()); + TextNd = NodeFactory::create(Node::Kind::Identifier, Buffer); + } + mangleIdentifier(TextNd.get()); break; + } case FunctionSigSpecializationParamKind::ClosureProp: mangleIdentifier(Param->getChild(1).get()); for (unsigned i = 2, e = Param->getNumChildren(); i != e; ++i) { diff --git a/test/Demangle/Inputs/manglings.txt b/test/Demangle/Inputs/manglings.txt index 0e79701c4ae6a..7f88c120314d3 100644 --- a/test/Demangle/Inputs/manglings.txt +++ b/test/Demangle/Inputs/manglings.txt @@ -239,5 +239,6 @@ _TFVFE15nested_genericsSS3fooFT_T_L_6CheeseCfT8materialx_GS0_x_ ---> (extension _TTWOE5imojiCSo5Imoji14ImojiMatchRankS_9RankValueS_FS2_g9rankValueqq_Ss16RawRepresentable8RawValue ---> _TTWOE5imojiCSo5Imoji14ImojiMatchRankS_9RankValueS_FS2_g9rankValueqq_Ss16RawRepresentable8RawValue _TtFzas4VoidGC16FusionXBaseUtils6FutureQq_ZFVS_7Futures6futureurFFzT_GS0_x_GS0_x__ ---> _TtFzas4VoidGC16FusionXBaseUtils6FutureQq_ZFVS_7Futures6futureurFFzT_GS0_x_GS0_x__ _T0s17MutableCollectionP1asAARzs012RandomAccessB0RzsAA11SubSequences013BidirectionalB0PRpzsAdHRQlE06rotatecD05Indexs01_A9IndexablePQzAM15shiftingToStart_tFAJs01_J4BasePQzAQcfU_ ---> (extension in a):Swift.MutableCollection.(rotateRandomAccess (shiftingToStart : A.Index) -> A.Index).(closure #1) +_T03foo4_123ABTf3psbpsb_n ---> function signature specialization of foo _T04main5innerys5Int32Vz_yADctF25closure_with_box_argumentxz_Bi32__lXXTf1nc_n ---> function signature specialization { var A } ]> of main.inner (inout Swift.Int32, (Swift.Int32) -> ()) -> () From a35cd0e36c456b86215b348a1ede99300e7677d5 Mon Sep 17 00:00:00 2001 From: Erik Eckstein Date: Mon, 20 Feb 2017 15:29:16 -0800 Subject: [PATCH 2/3] Demangler: fix the function specialization de-mangling The order in which the argument parameters were de-mangled was wrong. rdar://problem/30592808 --- include/swift/Basic/Demangler.h | 3 - lib/Basic/Demangler.cpp | 109 +++++++++++++++++------------ test/Demangle/Inputs/manglings.txt | 1 + 3 files changed, 66 insertions(+), 47 deletions(-) diff --git a/include/swift/Basic/Demangler.h b/include/swift/Basic/Demangler.h index 019b29284486d..bf8cda691d50c 100644 --- a/include/swift/Basic/Demangler.h +++ b/include/swift/Basic/Demangler.h @@ -224,9 +224,6 @@ class Demangler { NodePointer demangleGenericSpecialization(Node::Kind SpecKind); NodePointer demangleFunctionSpecialization(); NodePointer demangleFuncSpecParam(Node::IndexType ParamIdx); - NodePointer addFuncSpecParamIdentifier(NodePointer Param, - FunctionSigSpecializationParamKind Kind, - StringRef FirstParam = StringRef()); NodePointer addFuncSpecParamNumber(NodePointer Param, FunctionSigSpecializationParamKind Kind); diff --git a/lib/Basic/Demangler.cpp b/lib/Basic/Demangler.cpp index 957ebc52423cb..cecf966e5df91 100644 --- a/lib/Basic/Demangler.cpp +++ b/lib/Basic/Demangler.cpp @@ -1184,6 +1184,53 @@ NodePointer Demangler::demangleFunctionSpecialization() { } if (!nextIf('n')) Spec = addChild(Spec, demangleFuncSpecParam(Node::IndexType(~0))); + + if (!Spec) + return nullptr; + + // Add the required parameters in reverse order. + for (size_t Idx = 0, Num = Spec->getNumChildren(); Idx < Num; ++Idx) { + NodePointer Param = Spec->getChild(Num - Idx - 1); + if (Param->getKind() != Node::Kind::FunctionSignatureSpecializationParam) + continue; + + if (Param->getNumChildren() == 0) + continue; + NodePointer KindNd = Param->getFirstChild(); + assert(KindNd->getKind() == + Node::Kind::FunctionSignatureSpecializationParamKind); + auto ParamKind = (FunctionSigSpecializationParamKind)KindNd->getIndex(); + switch (ParamKind) { + case FunctionSigSpecializationParamKind::ConstantPropFunction: + case FunctionSigSpecializationParamKind::ConstantPropGlobal: + case FunctionSigSpecializationParamKind::ConstantPropString: + case FunctionSigSpecializationParamKind::ClosureProp: { + std::vector Types; + while (NodePointer Ty = popNode(Node::Kind::Type)) { + assert(ParamKind == FunctionSigSpecializationParamKind::ClosureProp); + Types.push_back(Ty); + } + NodePointer Name = popNode(Node::Kind::Identifier); + if (!Name) + return nullptr; + StringRef Text = Name->getText(); + if (ParamKind == + FunctionSigSpecializationParamKind::ConstantPropString && + Text.size() > 0 && Text[0] == '_') { + // A '_' escapes a leading digit or '_' of a string constant. + Text = Text.drop_front(1); + } + addChild(Param, NodeFactory::create( + Node::Kind::FunctionSignatureSpecializationParamPayload, Text)); + while (NodePointer Ty = pop_back_val(Types)) { + Param = addChild(Param, Ty); + } + break; + } + default: + break; + } + } return Spec; } @@ -1193,26 +1240,24 @@ NodePointer Demangler::demangleFuncSpecParam(Node::IndexType ParamIdx) { switch (nextChar()) { case 'n': return Param; - case 'c': { - std::vector Types; - while (NodePointer Ty = popNode(Node::Kind::Type)) { - Types.push_back(Ty); - } - Param = addFuncSpecParamIdentifier(Param, - swift::Demangle::FunctionSigSpecializationParamKind::ClosureProp); - while (NodePointer Ty = pop_back_val(Types)) { - Param = addChild(Param, Ty); - } - return Param; - } + case 'c': + // Consumes an identifier and multiple type parameters. + // The parameters will be added later. + return addChild(Param, NodeFactory::create( + Node::Kind::FunctionSignatureSpecializationParamKind, + unsigned(FunctionSigSpecializationParamKind::ClosureProp))); case 'p': { switch (nextChar()) { case 'f': - return addFuncSpecParamIdentifier(Param, - FunctionSigSpecializationParamKind::ConstantPropFunction); + // Consumes an identifier parameter, which will be added later. + return addChild(Param, NodeFactory::create( + Node::Kind::FunctionSignatureSpecializationParamKind, + unsigned(FunctionSigSpecializationParamKind::ConstantPropFunction))); case 'g': - return addFuncSpecParamIdentifier(Param, - FunctionSigSpecializationParamKind::ConstantPropGlobal); + // Consumes an identifier parameter, which will be added later. + return addChild(Param, NodeFactory::create( + Node::Kind::FunctionSignatureSpecializationParamKind, + unsigned(FunctionSigSpecializationParamKind::ConstantPropGlobal))); case 'i': return addFuncSpecParamNumber(Param, FunctionSigSpecializationParamKind::ConstantPropInteger); @@ -1220,6 +1265,8 @@ NodePointer Demangler::demangleFuncSpecParam(Node::IndexType ParamIdx) { return addFuncSpecParamNumber(Param, FunctionSigSpecializationParamKind::ConstantPropFloat); case 's': { + // Consumes an identifier parameter (the string constant), + // which will be added later. StringRef Encoding; switch (nextChar()) { case 'b': Encoding = "u8"; break; @@ -1227,23 +1274,13 @@ NodePointer Demangler::demangleFuncSpecParam(Node::IndexType ParamIdx) { case 'c': Encoding = "objc"; break; default: return nullptr; } - NodePointer Str = popNode(Node::Kind::Identifier); - if (!Str) - return nullptr; - StringRef Text = Str->getText(); - if (Text.size() > 0 && Text[0] == '_') - Text = Text.drop_front(1); - - Param->addChild(NodeFactory::create( + addChild(Param, NodeFactory::create( Node::Kind::FunctionSignatureSpecializationParamKind, unsigned(swift::Demangle::FunctionSigSpecializationParamKind:: ConstantPropString))); - Param->addChild(NodeFactory::create( - Node::Kind::FunctionSignatureSpecializationParamPayload, - Encoding)); return addChild(Param, NodeFactory::create( Node::Kind::FunctionSignatureSpecializationParamPayload, - Text)); + Encoding)); } default: return nullptr; @@ -1283,22 +1320,6 @@ NodePointer Demangler::demangleFuncSpecParam(Node::IndexType ParamIdx) { } } -NodePointer Demangler::addFuncSpecParamIdentifier(NodePointer Param, - FunctionSigSpecializationParamKind Kind, - StringRef FirstParam) { - NodePointer Name = popNode(Node::Kind::Identifier); - if (!Name) - return nullptr; - Param->addChild(NodeFactory::create( - Node::Kind::FunctionSignatureSpecializationParamKind, unsigned(Kind))); - if (!FirstParam.empty()) { - Param->addChild(NodeFactory::create( - Node::Kind::FunctionSignatureSpecializationParamPayload, FirstParam)); - } - return addChild(Param, NodeFactory::create( - Node::Kind::FunctionSignatureSpecializationParamPayload, Name->getText())); -} - NodePointer Demangler::addFuncSpecParamNumber(NodePointer Param, FunctionSigSpecializationParamKind Kind) { Param->addChild(NodeFactory::create( diff --git a/test/Demangle/Inputs/manglings.txt b/test/Demangle/Inputs/manglings.txt index 7f88c120314d3..4edae0538f121 100644 --- a/test/Demangle/Inputs/manglings.txt +++ b/test/Demangle/Inputs/manglings.txt @@ -241,4 +241,5 @@ _TtFzas4VoidGC16FusionXBaseUtils6FutureQq_ZFVS_7Futures6futureurFFzT_GS0_x_GS0_x _T0s17MutableCollectionP1asAARzs012RandomAccessB0RzsAA11SubSequences013BidirectionalB0PRpzsAdHRQlE06rotatecD05Indexs01_A9IndexablePQzAM15shiftingToStart_tFAJs01_J4BasePQzAQcfU_ ---> (extension in a):Swift.MutableCollection.(rotateRandomAccess (shiftingToStart : A.Index) -> A.Index).(closure #1) _T03foo4_123ABTf3psbpsb_n ---> function signature specialization of foo _T04main5innerys5Int32Vz_yADctF25closure_with_box_argumentxz_Bi32__lXXTf1nc_n ---> function signature specialization { var A } ]> of main.inner (inout Swift.Int32, (Swift.Int32) -> ()) -> () +_T03foo6testityyyc_yyctF1a1bTf3pfpf_n ---> function signature specialization of foo.testit (() -> (), () -> ()) -> () From 8542e13bf7c52f85f0c97d8713c0a8d2ac60ebd6 Mon Sep 17 00:00:00 2001 From: Erik Eckstein Date: Mon, 20 Feb 2017 15:29:50 -0800 Subject: [PATCH 3/3] Revert "Temporarily disable the re-mangling check." rdar://problem/30592808 is fixed This reverts commit 03a5c2449c3be258c98e8336e0dd045ec877e7ba. --- lib/Basic/Mangler.cpp | 4 ---- 1 file changed, 4 deletions(-) diff --git a/lib/Basic/Mangler.cpp b/lib/Basic/Mangler.cpp index ac4c88f9a26e9..625a4a9ff60fc 100644 --- a/lib/Basic/Mangler.cpp +++ b/lib/Basic/Mangler.cpp @@ -235,16 +235,12 @@ std::string NewMangling::selectMangling(const std::string &Old, NodePointer RemangledNode = demangleSymbolAsNode(Remangled); isEqual = areTreesEqual(NewNode, RemangledNode); } - -// TODO: Check disabled until rdar://problem/30592808 is fixed. -#if 0 if (!isEqual) { llvm::errs() << "Remangling failed at #" << numCmp << ":\n" "original: " << New << "\n" "remangled: " << Remangled << "\n"; assert(false); } -#endif } } }