175895 2017-08-23 11:34:08 -0700 [DFG] Add constant folding rule to convert CompareStrictEq(Untyped, Untyped [with non string cell constant]) to CompareEqPtr(Untyped) 2017-08-29 17:31:26 -0700 1 1 1 Unclassified WebKit JavaScriptCore WebKit Nightly Build Unspecified Unspecified RESOLVED FIXED InRadar P2 Normal --- 1 ysuzuki ysuzuki buildbot fpizlo keith_miller mark.lam msaboff saam webkit-bug-importer oldest_to_newest 1341673 0 ysuzuki 2017-08-23 11:34:08 -0700 ... 1341675 1 ysuzuki 2017-08-23 11:35:32 -0700 We start holding map bucket in js property. And we perform CompareSrictEq onto this. Current DFG code looks nice. But we can optimize further by introducing SpecCellOther fixup and CellOtherUse. 1341676 2 ysuzuki 2017-08-23 11:36:34 -0700 Or, we can say NotStringCellUse. 1342643 3 ysuzuki 2017-08-26 02:51:44 -0700 Maybe, this is simpler. 1342644 4 319134 ysuzuki 2017-08-26 03:01:24 -0700 Created attachment 319134 Patch 1342653 5 319134 saam 2017-08-26 09:25:08 -0700 Comment on attachment 319134 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=319134&action=review > Source/JavaScriptCore/dfg/DFGStrengthReductionPhase.cpp:82 > + if (!m_node->isBinaryUseKind(UntypedUse)) Why does this matter? It seems like your rewriting rule should work regardless? Or is this just because of the use kinds CompareEqPtr supports? If so, you can just convert this to a Check and then imagery the CompareEqPtr after that > Source/JavaScriptCore/dfg/DFGStrengthReductionPhase.cpp:88 > + I think AI would be better at proving this than what you’re doing here. Maybe write such a rule in AI/constant folding? 1342683 6 319134 ysuzuki 2017-08-26 17:19:28 -0700 Comment on attachment 319134 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=319134&action=review >> Source/JavaScriptCore/dfg/DFGStrengthReductionPhase.cpp:82 >> + if (!m_node->isBinaryUseKind(UntypedUse)) > > Why does this matter? It seems like your rewriting rule should work regardless? Or is this just because of the use kinds CompareEqPtr supports? If so, you can just convert this to a Check and then imagery the CompareEqPtr after that In the other cases, we do not need to convert CompareStrictEq to CompareEqPtr. It is already fast and optimized enough in DFG speculative JIT. And DFGSpeculativeJIT curretnly only supports CompareEqPtr(Untyped). I do not think CompareEqPtr(VariousType) is worth adding. >> Source/JavaScriptCore/dfg/DFGStrengthReductionPhase.cpp:88 >> + > > I think AI would be better at proving this than what you’re doing here. Maybe write such a rule in AI/constant folding? OK, I'll move this to AI/constant folding. 1342687 7 319144 ysuzuki 2017-08-26 17:50:36 -0700 Created attachment 319144 Patch 1342703 8 319134 saam 2017-08-26 19:40:26 -0700 Comment on attachment 319134 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=319134&action=review >>> Source/JavaScriptCore/dfg/DFGStrengthReductionPhase.cpp:82 >>> + if (!m_node->isBinaryUseKind(UntypedUse)) >> >> Why does this matter? It seems like your rewriting rule should work regardless? Or is this just because of the use kinds CompareEqPtr supports? If so, you can just convert this to a Check and then imagery the CompareEqPtr after that > > In the other cases, we do not need to convert CompareStrictEq to CompareEqPtr. It is already fast and optimized enough in DFG speculative JIT. > And DFGSpeculativeJIT curretnly only supports CompareEqPtr(Untyped). I do not think CompareEqPtr(VariousType) is worth adding. My point was that all you need to do to make this work is keep convert it to a CompareEqPtr and and add a Check right before the CompareEqPtr. Also, it’s worth making sure this doesn’t need to be aware of document.all 1342706 9 319134 ysuzuki 2017-08-26 20:03:47 -0700 Comment on attachment 319134 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=319134&action=review >>>> Source/JavaScriptCore/dfg/DFGStrengthReductionPhase.cpp:82 >>>> + if (!m_node->isBinaryUseKind(UntypedUse)) >>> >>> Why does this matter? It seems like your rewriting rule should work regardless? Or is this just because of the use kinds CompareEqPtr supports? If so, you can just convert this to a Check and then imagery the CompareEqPtr after that >> >> In the other cases, we do not need to convert CompareStrictEq to CompareEqPtr. It is already fast and optimized enough in DFG speculative JIT. >> And DFGSpeculativeJIT curretnly only supports CompareEqPtr(Untyped). I do not think CompareEqPtr(VariousType) is worth adding. > > My point was that all you need to do to make this work is keep convert it to a CompareEqPtr and and add a Check right before the CompareEqPtr. > Also, it’s worth making sure this doesn’t need to be aware of document.all One concern is that it can hurt efficiency in 32bit environment. In 32bit, if we have CompareStrictEq(ObjectType, ObjectConstant), we can perform 32bit pointer comparison. However, if we convert it to Check(Object) and CompareEqPtr(Untyped), it needs to perform 64bit comparison against JSValue. It is efficient in 64bit environment (since we can perform 64bit comparison), but it is not in 32bit environment. I think the current conversion rule is good in efficiency. CompareStrictEq(Untyped, Untyped) anyway needs to perform JSValue comparison. If we can convert it to ComparePtrEq, it is always more efficient than CompareStrictEq. One solution is adding CompareEqPtr(ObjectUse) etc. in 32bit environment (I don't think adding it to 64bit is good, since it can add an additional cell type check that is not necessary right now.) But I do not think it is worth adding. I will add masquarade as undefined check too. 1342707 10 319134 ysuzuki 2017-08-26 20:07:20 -0700 Comment on attachment 319134 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=319134&action=review >>>>> Source/JavaScriptCore/dfg/DFGStrengthReductionPhase.cpp:82 >>>>> + if (!m_node->isBinaryUseKind(UntypedUse)) >>>> >>>> Why does this matter? It seems like your rewriting rule should work regardless? Or is this just because of the use kinds CompareEqPtr supports? If so, you can just convert this to a Check and then imagery the CompareEqPtr after that >>> >>> In the other cases, we do not need to convert CompareStrictEq to CompareEqPtr. It is already fast and optimized enough in DFG speculative JIT. >>> And DFGSpeculativeJIT curretnly only supports CompareEqPtr(Untyped). I do not think CompareEqPtr(VariousType) is worth adding. >> >> My point was that all you need to do to make this work is keep convert it to a CompareEqPtr and and add a Check right before the CompareEqPtr. >> Also, it’s worth making sure this doesn’t need to be aware of document.all > > One concern is that it can hurt efficiency in 32bit environment. In 32bit, if we have CompareStrictEq(ObjectType, ObjectConstant), we can perform 32bit pointer comparison. > However, if we convert it to Check(Object) and CompareEqPtr(Untyped), it needs to perform 64bit comparison against JSValue. It is efficient in 64bit environment (since we can perform 64bit comparison), but it is not in 32bit environment. > I think the current conversion rule is good in efficiency. CompareStrictEq(Untyped, Untyped) anyway needs to perform JSValue comparison. If we can convert it to ComparePtrEq, it is always more efficient than CompareStrictEq. > > One solution is adding CompareEqPtr(ObjectUse) etc. in 32bit environment (I don't think adding it to 64bit is good, since it can add an additional cell type check that is not necessary right now.) But I do not think it is worth adding. > > I will add masquarade as undefined check too. Ah, I do not need to add masquerade as undefined case since it is CompareStrictEq. 1343168 11 319144 saam 2017-08-29 11:37:26 -0700 Comment on attachment 319144 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=319144&action=review r=me > Source/JavaScriptCore/dfg/DFGConstantFoldingPhase.cpp:158 > + if (isNonStringCellConstant(child1Constant)) { > + node->convertToCompareEqPtr(m_graph.freezeStrong(child1Constant.asCell()), node->child2()); > + changed = true; > + } else if (isNonStringCellConstant(child2Constant)) { > + node->convertToCompareEqPtr(m_graph.freezeStrong(child2Constant.asCell()), node->child1()); > + changed = true; > + } When we do BigInt, we need to make sure we change this rule... 1343169 12 saam 2017-08-29 11:38:33 -0700 (In reply to Yusuke Suzuki from comment #9) > Comment on attachment 319134 [details] > Patch > > View in context: > https://bugs.webkit.org/attachment.cgi?id=319134&action=review > > >>>> Source/JavaScriptCore/dfg/DFGStrengthReductionPhase.cpp:82 > >>>> + if (!m_node->isBinaryUseKind(UntypedUse)) > >>> > >>> Why does this matter? It seems like your rewriting rule should work regardless? Or is this just because of the use kinds CompareEqPtr supports? If so, you can just convert this to a Check and then imagery the CompareEqPtr after that > >> > >> In the other cases, we do not need to convert CompareStrictEq to CompareEqPtr. It is already fast and optimized enough in DFG speculative JIT. > >> And DFGSpeculativeJIT curretnly only supports CompareEqPtr(Untyped). I do not think CompareEqPtr(VariousType) is worth adding. > > > > My point was that all you need to do to make this work is keep convert it to a CompareEqPtr and and add a Check right before the CompareEqPtr. > > Also, it’s worth making sure this doesn’t need to be aware of document.all > > One concern is that it can hurt efficiency in 32bit environment. In 32bit, > if we have CompareStrictEq(ObjectType, ObjectConstant), we can perform 32bit > pointer comparison. > However, if we convert it to Check(Object) and CompareEqPtr(Untyped), it > needs to perform 64bit comparison against JSValue. It is efficient in 64bit > environment (since we can perform 64bit comparison), but it is not in 32bit > environment. > I think the current conversion rule is good in efficiency. > CompareStrictEq(Untyped, Untyped) anyway needs to perform JSValue > comparison. If we can convert it to ComparePtrEq, it is always more > efficient than CompareStrictEq. > > One solution is adding CompareEqPtr(ObjectUse) etc. in 32bit environment (I > don't think adding it to 64bit is good, since it can add an additional cell > type check that is not necessary right now.) But I do not think it is worth > adding. > > I will add masquarade as undefined check too. Yeah this makes sense. Also, you're totally right that ComapreStrictEq(ObjectUse:, some other use) is already fast. 1343332 13 319144 ysuzuki 2017-08-29 17:11:40 -0700 Comment on attachment 319144 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=319144&action=review >> Source/JavaScriptCore/dfg/DFGConstantFoldingPhase.cpp:158 >> + } > > When we do BigInt, we need to make sure we change this rule... Yeah. Or we can take the similar approach to the current Symbol: interning BigInt cells by WeakGCMap to ensure the pointer comparison works. 1343336 14 saam 2017-08-29 17:14:52 -0700 (In reply to Yusuke Suzuki from comment #13) > Comment on attachment 319144 [details] > Patch > > View in context: > https://bugs.webkit.org/attachment.cgi?id=319144&action=review > > >> Source/JavaScriptCore/dfg/DFGConstantFoldingPhase.cpp:158 > >> + } > > > > When we do BigInt, we need to make sure we change this rule... > > Yeah. Or we can take the similar approach to the current Symbol: interning > BigInt cells by WeakGCMap to ensure the pointer comparison works. I don't think we'd want to intern these. That'll mean every math operation over them is doing some sort of hash-consing. 1343339 15 319144 ysuzuki 2017-08-29 17:16:56 -0700 Comment on attachment 319144 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=319144&action=review >>>> Source/JavaScriptCore/dfg/DFGConstantFoldingPhase.cpp:158 >>>> + } >>> >>> When we do BigInt, we need to make sure we change this rule... >> >> Yeah. Or we can take the similar approach to the current Symbol: interning BigInt cells by WeakGCMap to ensure the pointer comparison works. > > I don't think we'd want to intern these. That'll mean every math operation over them is doing some sort of hash-consing. OK, I'll add FIXME about it for the future BigInt integration :) 1343343 16 ysuzuki 2017-08-29 17:29:45 -0700 Committed r221328: <http://trac.webkit.org/changeset/221328> 1343344 17 webkit-bug-importer 2017-08-29 17:31:26 -0700 <rdar://problem/34148115> 319134 2017-08-26 03:01:24 -0700 2017-08-26 17:50:34 -0700 Patch bug-175895-20170826190123.patch text/plain 4020 ysuzuki U3VidmVyc2lvbiBSZXZpc2lvbjogMjIxMjI1CmRpZmYgLS1naXQgYS9Tb3VyY2UvSmF2YVNjcmlw dENvcmUvQ2hhbmdlTG9nIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL0NoYW5nZUxvZwppbmRleCAx ZmQ5NWExMGFiNTcwMGVhYmFlMWMxNmZkYzEwZmYyNzhiMzhhMDY1Li5kNWRhZjUyMTA3MmNiMDFi YzIzMTRlNDNlZWU0YThhZWNiODcyOTcwIDEwMDY0NAotLS0gYS9Tb3VyY2UvSmF2YVNjcmlwdENv cmUvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9DaGFuZ2VMb2cKQEAgLTEs NSArMSwzMiBAQAogMjAxNy0wOC0yNiAgWXVzdWtlIFN1enVraSAgPHV0YXRhbmUudGVhQGdtYWls LmNvbT4KIAorICAgICAgICBbREZHXSBBZGQgQ29tcGFyZUVxUHRyIHN0cmVuZ3RoIHJlZHVjdGlv biBmb3IgQ29tcGFyZVN0cmljdEVxKFVudHlwZWQsIFVudHlwZWQpCisgICAgICAgIGh0dHBzOi8v YnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0xNzU4OTUKKworICAgICAgICBSZXZpZXdl ZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBXZSBoYXZlIGBidWNrZXQgPT09IEBzZW50 aW5lbE1hcEJ1Y2tldGAgY29kZSBpbiBidWlsdGluLiBTaW5jZSBAc2VudGluZWxNYXBCdWNrZXQg YW5kIGJ1Y2tldAorICAgICAgICBhcmUgTWFwQnVja2V0IGNlbGwgKFNwZWNDZWxsT3RoZXIpLCB3 ZSBkbyBub3QgaGF2ZSBhbnkgZ29vZCBmaXh1cCBmb3IgQ29tcGFyZVN0cmljdEVxLgorICAgICAg ICBCdXQgcmF0aGVyIHRoYW4gaW50cm9kdWNpbmcgYSBzcGVjaWFsIGZpeHVwIGVkZ2UgKGxpa2Us IE5vblN0cmluZ0NlbGxVc2UpLCBjb252ZXJ0aW5nCisgICAgICAgIENvbXBhcmVTdHJpY3RFcShV bnR5cGVkLCBVbnR5cGVkKSB0byBDb21wYXJlRXFQdHIgaXMgc2ltcGxlci4KKyAgICAgICAgSW4g c3RyZW5ndGggcmVkdWN0aW9uIHBoYXNlLCB3ZSBjb252ZXJ0IENvbXBhcmVTdHJpY3RFcShVbnR5 cGVkLCBVbnR5cGVkKSB0byBDb21wYXJlRXFQdHIoVW50eXBlZCkKKyAgICAgICAgaWYgb25lIHNp ZGUgb2YgdGhlIGNoaWxkcmVuIGlzIGNvbnN0YW50IG5vbiBTdHJpbmcgY2VsbC4KKworICAgICAg ICBUaGlzIHNsaWdodGx5IG9wdGltaXplcyBtYXAvc2V0IGl0ZXJhdGlvbi4KKworICAgICAgICBz ZXQtZm9yLWVhY2ggICAgICAgICAgICAgICA0LjIwNTMrLTAuMzQzMiAgICAgXiAgICAgIDMuNDQx OCstMC4yNTk1ICAgICAgICBeIGRlZmluaXRlbHkgMS4yMjE4eCBmYXN0ZXIKKyAgICAgICAgbGFy Z2UtbWFwLWl0ZXJhdGlvbiAgICAgICA1NS43ODAwKy0yLjIyODEgICAgICAgICAgIDUyLjgyNTQr LTIuMTEzNCAgICAgICAgICBtaWdodCBiZSAxLjA1NTl4IGZhc3RlcgorICAgICAgICBzZXQtZm9y LW9mICAgICAgICAgICAgICAgICA4Ljg2MjcrLTAuNTQ1MyAgICAgICAgICAgIDguMzQyOSstMC40 OTY2ICAgICAgICAgIG1pZ2h0IGJlIDEuMDYyM3ggZmFzdGVyCisgICAgICAgIG1hcC1mb3ItZWFj aCAgICAgICAgICAgICAgIDQuNTcxNystMC4zMjQ4ICAgICBeICAgICAgMy40OTI4Ky0wLjI1MDAg ICAgICAgIF4gZGVmaW5pdGVseSAxLjMwODl4IGZhc3RlcgorICAgICAgICBtYXAtZm9yLW9mICAg ICAgICAgICAgICAgIDEyLjgwNzErLTAuOTY4OSAgICAgPyAgICAgMTIuODE3MSstMC42MjA4ICAg ICAgICA/CisKKyAgICAgICAgKiBkZmcvREZHTm9kZS5oOgorICAgICAgICAoSlNDOjpERkc6Ok5v ZGU6OmNvbnZlcnRUb0NvbXBhcmVFcVB0cik6CisgICAgICAgICogZGZnL0RGR1N0cmVuZ3RoUmVk dWN0aW9uUGhhc2UuY3BwOgorICAgICAgICAoSlNDOjpERkc6OlN0cmVuZ3RoUmVkdWN0aW9uUGhh c2U6OmhhbmRsZU5vZGUpOgorCisyMDE3LTA4LTI2ICBZdXN1a2UgU3V6dWtpICA8dXRhdGFuZS50 ZWFAZ21haWwuY29tPgorCiAgICAgICAgIFVucmV2aWV3ZWQsIHN1cHByZXNzIHdhcm5pbmdzIGlu IEdUSyBwb3J0CiAKICAgICAgICAgVGhlICJibG9jayIgdmFyaWFibGUgaGlkZXMgdGhlIGFyZ3Vt ZW50IHZhcmlhYmxlLgpkaWZmIC0tZ2l0IGEvU291cmNlL0phdmFTY3JpcHRDb3JlL2RmZy9ERkdO b2RlLmggYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvZGZnL0RGR05vZGUuaAppbmRleCBlNzBkYjk2 MTFjNGIwNDI4Mjk1OTYzNDMwMjVhNzMzOTNmMTdjYjE0Li4zZTIzZDA0MzIxZTg1MzYxMTk4MmQ0 MjFmZGEzY2JlNzgxMmFkZmY1IDEwMDY0NAotLS0gYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvZGZn L0RGR05vZGUuaAorKysgYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvZGZnL0RGR05vZGUuaApAQCAt NjgyLDYgKzY4MiwxNSBAQCBzdHJ1Y3QgTm9kZSB7CiAgICAgICAgIEFTU0VSVChtX29wID09IEFy aXRoQWJzICYmIGNoaWxkMSgpLnVzZUtpbmQoKSA9PSBJbnQzMlVzZSk7CiAgICAgICAgIG1fb3Ag PSBBcml0aE5lZ2F0ZTsKICAgICB9CisKKyAgICB2b2lkIGNvbnZlcnRUb0NvbXBhcmVFcVB0cihG cm96ZW5WYWx1ZSogY2VsbCwgRWRnZSBub2RlKQorICAgIHsKKyAgICAgICAgQVNTRVJUKG1fb3Ag PT0gQ29tcGFyZVN0cmljdEVxKTsKKyAgICAgICAgc2V0T3BBbmREZWZhdWx0RmxhZ3MoQ29tcGFy ZUVxUHRyKTsKKyAgICAgICAgY2hpbGRyZW4uc2V0Q2hpbGQxKG5vZGUpOworICAgICAgICBjaGls ZHJlbi5zZXRDaGlsZDIoRWRnZSgpKTsKKyAgICAgICAgbV9vcEluZm8gPSBjZWxsOworICAgIH0K ICAgICAKICAgICB2b2lkIGNvbnZlcnRUb0RpcmVjdENhbGwoRnJvemVuVmFsdWUqKTsKIApkaWZm IC0tZ2l0IGEvU291cmNlL0phdmFTY3JpcHRDb3JlL2RmZy9ERkdTdHJlbmd0aFJlZHVjdGlvblBo YXNlLmNwcCBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9kZmcvREZHU3RyZW5ndGhSZWR1Y3Rpb25Q aGFzZS5jcHAKaW5kZXggNjVhZmI0YWU4OTVhZDQ4N2JmNWZhYmVjZGZlYjU5NzhlY2VjMDA0ZC4u Y2U5OTBhZGI1MDhhOGJhMGY1Y2VmNjIwNzQ4NjZkMzkzNmVmMzA2MCAxMDA2NDQKLS0tIGEvU291 cmNlL0phdmFTY3JpcHRDb3JlL2RmZy9ERkdTdHJlbmd0aFJlZHVjdGlvblBoYXNlLmNwcAorKysg Yi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvZGZnL0RGR1N0cmVuZ3RoUmVkdWN0aW9uUGhhc2UuY3Bw CkBAIC03OCw2ICs3OCwyNCBAQCBjbGFzcyBTdHJlbmd0aFJlZHVjdGlvblBoYXNlIDogcHVibGlj IFBoYXNlIHsKICAgICB2b2lkIGhhbmRsZU5vZGUoKQogICAgIHsKICAgICAgICAgc3dpdGNoICht X25vZGUtPm9wKCkpIHsKKyAgICAgICAgY2FzZSBDb21wYXJlU3RyaWN0RXE6IHsKKyAgICAgICAg ICAgIGlmICghbV9ub2RlLT5pc0JpbmFyeVVzZUtpbmQoVW50eXBlZFVzZSkpCisgICAgICAgICAg ICAgICAgYnJlYWs7CisKKyAgICAgICAgICAgIGF1dG8gaXNOb25TdHJpbmdDZWxsQ29uc3RhbnQg PSBbXSAoRWRnZSYgZWRnZSkgeworICAgICAgICAgICAgICAgIHJldHVybiBlZGdlLT5pc0NlbGxD b25zdGFudCgpICYmICFlZGdlLT5hc0NlbGwoKS0+aXNTdHJpbmcoKTsKKyAgICAgICAgICAgIH07 CisKKyAgICAgICAgICAgIGlmIChpc05vblN0cmluZ0NlbGxDb25zdGFudChtX25vZGUtPmNoaWxk MSgpKSkgeworICAgICAgICAgICAgICAgIG1fbm9kZS0+Y29udmVydFRvQ29tcGFyZUVxUHRyKG1f Z3JhcGguZnJlZXplU3Ryb25nKG1fbm9kZS0+Y2hpbGQxKCktPmFzQ2VsbCgpKSwgbV9ub2RlLT5j aGlsZDIoKSk7CisgICAgICAgICAgICAgICAgbV9jaGFuZ2VkID0gdHJ1ZTsKKyAgICAgICAgICAg IH0gZWxzZSBpZiAoaXNOb25TdHJpbmdDZWxsQ29uc3RhbnQobV9ub2RlLT5jaGlsZDIoKSkpIHsK KyAgICAgICAgICAgICAgICBtX25vZGUtPmNvbnZlcnRUb0NvbXBhcmVFcVB0cihtX2dyYXBoLmZy ZWV6ZVN0cm9uZyhtX25vZGUtPmNoaWxkMigpLT5hc0NlbGwoKSksIG1fbm9kZS0+Y2hpbGQxKCkp OworICAgICAgICAgICAgICAgIG1fY2hhbmdlZCA9IHRydWU7CisgICAgICAgICAgICB9CisgICAg ICAgICAgICBicmVhazsKKyAgICAgICAgfQorCiAgICAgICAgIGNhc2UgQml0T3I6CiAgICAgICAg ICAgICBoYW5kbGVDb21tdXRhdGl2aXR5KCk7CiAK 319144 2017-08-26 17:50:36 -0700 2017-08-29 11:37:26 -0700 Patch bug-175895-20170827095035.patch text/plain 5703 ysuzuki U3VidmVyc2lvbiBSZXZpc2lvbjogMjIxMjMxCmRpZmYgLS1naXQgYS9Tb3VyY2UvSmF2YVNjcmlw dENvcmUvQ2hhbmdlTG9nIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL0NoYW5nZUxvZwppbmRleCAx ZmQ5NWExMGFiNTcwMGVhYmFlMWMxNmZkYzEwZmYyNzhiMzhhMDY1Li45Y2VhZGFkYTU0NDFmNjU3 MjRkMTUzODJmYTY0OTQ2N2EzZmVmZDZmIDEwMDY0NAotLS0gYS9Tb3VyY2UvSmF2YVNjcmlwdENv cmUvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9DaGFuZ2VMb2cKQEAgLTEs NSArMSwzNCBAQAogMjAxNy0wOC0yNiAgWXVzdWtlIFN1enVraSAgPHV0YXRhbmUudGVhQGdtYWls LmNvbT4KIAorICAgICAgICBbREZHXSBBZGQgY29uc3RhbnQgZm9sZGluZyBydWxlIHRvIGNvbnZl cnQgQ29tcGFyZVN0cmljdEVxKFVudHlwZWQsIFVudHlwZWQgW3dpdGggbm9uIHN0cmluZyBjZWxs IGNvbnN0YW50XSkgdG8gQ29tcGFyZUVxUHRyKFVudHlwZWQpCisgICAgICAgIGh0dHBzOi8vYnVn cy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0xNzU4OTUKKworICAgICAgICBSZXZpZXdlZCBi eSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBXZSBoYXZlIGBidWNrZXQgPT09IEBzZW50aW5l bE1hcEJ1Y2tldGAgY29kZSBpbiBidWlsdGluLiBTaW5jZSBAc2VudGluZWxNYXBCdWNrZXQgYW5k IGJ1Y2tldAorICAgICAgICBhcmUgTWFwQnVja2V0IGNlbGwgKFNwZWNDZWxsT3RoZXIpLCB3ZSBk byBub3QgaGF2ZSBhbnkgZ29vZCBmaXh1cCBmb3IgQ29tcGFyZVN0cmljdEVxLgorICAgICAgICBC dXQgcmF0aGVyIHRoYW4gaW50cm9kdWNpbmcgYSBzcGVjaWFsIGZpeHVwIGVkZ2UgKGxpa2UsIE5v blN0cmluZ0NlbGxVc2UpLCBjb252ZXJ0aW5nCisgICAgICAgIENvbXBhcmVTdHJpY3RFcShVbnR5 cGVkLCBVbnR5cGVkKSB0byBDb21wYXJlRXFQdHIgaXMgc2ltcGxlci4KKyAgICAgICAgSW4gY29u c3RhbnQgZm9sZGluZyBwaGFzZSwgd2UgY29udmVydCBDb21wYXJlU3RyaWN0RXEoVW50eXBlZCwg VW50eXBlZCkgdG8gQ29tcGFyZUVxUHRyKFVudHllZCkKKyAgICAgICAgaWYgb25lIHNpZGUgb2Yg dGhlIGNoaWxkcmVuIGlzIGNvbnN0YW50IG5vbiBTdHJpbmcgY2VsbC4KKworICAgICAgICBUaGlz IHNsaWdodGx5IG9wdGltaXplcyBtYXAvc2V0IGl0ZXJhdGlvbi4KKworICAgICAgICBzZXQtZm9y LWVhY2ggICAgICAgICAgNC41MDY0Ky0wLjMwNzIgICAgIF4gICAgICAzLjI4NjIrLTAuMjA5OCAg ICAgICAgXiBkZWZpbml0ZWx5IDEuMzcxM3ggZmFzdGVyCisgICAgICAgIGxhcmdlLW1hcC1pdGVy YXRpb24gIDU2LjI1ODMrLTEuNjY0MCAgICAgICAgICAgNTMuNjc5OCstMi4wMDk3ICAgICAgICAg IG1pZ2h0IGJlIDEuMDQ4MHggZmFzdGVyCisgICAgICAgIHNldC1mb3Itb2YgICAgICAgICAgICA4 LjgwNTgrLTAuNTk1MyAgICAgXiAgICAgIDcuNTgzMistMC4zODA1ICAgICAgICBeIGRlZmluaXRl bHkgMS4xNjEyeCBmYXN0ZXIKKyAgICAgICAgbWFwLWZvci1lYWNoICAgICAgICAgIDQuMjYzMyst MC4yNjk0ICAgICBeICAgICAgMy4zOTY3Ky0wLjMwMTMgICAgICAgIF4gZGVmaW5pdGVseSAxLjI1 NTF4IGZhc3RlcgorICAgICAgICBtYXAtZm9yLW9mICAgICAgICAgICAxMy4xNTU2Ky0wLjU3MDcg ICAgICAgICAgIDEyLjQ5MTErLTAuNjAwNCAgICAgICAgICBtaWdodCBiZSAxLjA1MzJ4IGZhc3Rl cgorCisgICAgICAgICogZGZnL0RGR0Fic3RyYWN0SW50ZXJwcmV0ZXJJbmxpbmVzLmg6CisgICAg ICAgIChKU0M6OkRGRzo6QWJzdHJhY3RJbnRlcnByZXRlcjxBYnN0cmFjdFN0YXRlVHlwZT46OmV4 ZWN1dGVFZmZlY3RzKToKKyAgICAgICAgKiBkZmcvREZHQ29uc3RhbnRGb2xkaW5nUGhhc2UuY3Bw OgorICAgICAgICAoSlNDOjpERkc6OkNvbnN0YW50Rm9sZGluZ1BoYXNlOjpmb2xkQ29uc3RhbnRz KToKKyAgICAgICAgKiBkZmcvREZHTm9kZS5oOgorICAgICAgICAoSlNDOjpERkc6Ok5vZGU6OmNv bnZlcnRUb0NvbXBhcmVFcVB0cik6CisKKzIwMTctMDgtMjYgIFl1c3VrZSBTdXp1a2kgIDx1dGF0 YW5lLnRlYUBnbWFpbC5jb20+CisKICAgICAgICAgVW5yZXZpZXdlZCwgc3VwcHJlc3Mgd2Fybmlu Z3MgaW4gR1RLIHBvcnQKIAogICAgICAgICBUaGUgImJsb2NrIiB2YXJpYWJsZSBoaWRlcyB0aGUg YXJndW1lbnQgdmFyaWFibGUuCmRpZmYgLS1naXQgYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvZGZn L0RGR0Fic3RyYWN0SW50ZXJwcmV0ZXJJbmxpbmVzLmggYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUv ZGZnL0RGR0Fic3RyYWN0SW50ZXJwcmV0ZXJJbmxpbmVzLmgKaW5kZXggYmJhMDZkYWNkZjE5YTNm OTZhMzdiNDk2YjBjMjc4ZGFiMWRhMmU0MS4uZTUyYWU5NDgzYmU4MDI4MGJmYzAzY2U5ZjI4YjBm MWRiOTNlZGJmZiAxMDA2NDQKLS0tIGEvU291cmNlL0phdmFTY3JpcHRDb3JlL2RmZy9ERkdBYnN0 cmFjdEludGVycHJldGVySW5saW5lcy5oCisrKyBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9kZmcv REZHQWJzdHJhY3RJbnRlcnByZXRlcklubGluZXMuaApAQCAtMTQ5OSw2ICsxNDk5LDE4IEBAIGJv b2wgQWJzdHJhY3RJbnRlcnByZXRlcjxBYnN0cmFjdFN0YXRlVHlwZT46OmV4ZWN1dGVFZmZlY3Rz KHVuc2lnbmVkIGNsb2JiZXJMaW1pCiAgICAgICAgICAgICAgICAgYnJlYWs7CiAgICAgICAgICAg ICB9CiAgICAgICAgIH0KKworICAgICAgICBpZiAobm9kZS0+aXNCaW5hcnlVc2VLaW5kKFVudHlw ZWRVc2UpKSB7CisgICAgICAgICAgICBhdXRvIGlzTm9uU3RyaW5nQ2VsbENvbnN0YW50ID0gW10g KEpTVmFsdWUgdmFsdWUpIHsKKyAgICAgICAgICAgICAgICByZXR1cm4gdmFsdWUgJiYgdmFsdWUu aXNDZWxsKCkgJiYgIXZhbHVlLmlzU3RyaW5nKCk7CisgICAgICAgICAgICB9OworCisgICAgICAg ICAgICBpZiAoaXNOb25TdHJpbmdDZWxsQ29uc3RhbnQobGVmdCkgfHwgaXNOb25TdHJpbmdDZWxs Q29uc3RhbnQocmlnaHQpKSB7CisgICAgICAgICAgICAgICAgbV9zdGF0ZS5zZXRGb3VuZENvbnN0 YW50cyh0cnVlKTsKKyAgICAgICAgICAgICAgICBmb3JOb2RlKG5vZGUpLnNldFR5cGUoU3BlY0Jv b2xlYW4pOworICAgICAgICAgICAgICAgIGJyZWFrOworICAgICAgICAgICAgfQorICAgICAgICB9 CiAgICAgICAgIAogICAgICAgICBTcGVjdWxhdGVkVHlwZSBsZWZ0TFVCID0gbGVhc3RVcHBlckJv dW5kT2ZTdHJpY3RseUVxdWl2YWxlbnRTcGVjdWxhdGlvbnMoZm9yTm9kZShsZWZ0Tm9kZSkubV90 eXBlKTsKICAgICAgICAgU3BlY3VsYXRlZFR5cGUgcmlnaHRMVUIgPSBsZWFzdFVwcGVyQm91bmRP ZlN0cmljdGx5RXF1aXZhbGVudFNwZWN1bGF0aW9ucyhmb3JOb2RlKHJpZ2h0Tm9kZSkubV90eXBl KTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9kZmcvREZHQ29uc3RhbnRGb2xk aW5nUGhhc2UuY3BwIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL2RmZy9ERkdDb25zdGFudEZvbGRp bmdQaGFzZS5jcHAKaW5kZXggNzM0NWNkNDA2YzBhNTkyOTNjOWEyOTcyYmQ4N2I2NDU4ODVhMGJl Ny4uNzI2NjdhZDlmNzdiZmIwMjk2MTE2YmFhMDRmY2U5NTk4ODg5ZjY3NiAxMDA2NDQKLS0tIGEv U291cmNlL0phdmFTY3JpcHRDb3JlL2RmZy9ERkdDb25zdGFudEZvbGRpbmdQaGFzZS5jcHAKKysr IGIvU291cmNlL0phdmFTY3JpcHRDb3JlL2RmZy9ERkdDb25zdGFudEZvbGRpbmdQaGFzZS5jcHAK QEAgLTEzOSw2ICsxMzksMjcgQEAgY2xhc3MgQ29uc3RhbnRGb2xkaW5nUGhhc2UgOiBwdWJsaWMg UGhhc2UgewogICAgICAgICAgICAgICAgIC8vIFNlZTogaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcv c2hvd19idWcuY2dpP2lkPTE3NDg0NAogICAgICAgICAgICAgICAgIGJyZWFrOwogICAgICAgICAg ICAgfQorCisgICAgICAgICAgICBjYXNlIENvbXBhcmVTdHJpY3RFcTogeworICAgICAgICAgICAg ICAgIGlmIChub2RlLT5pc0JpbmFyeVVzZUtpbmQoVW50eXBlZFVzZSkpIHsKKyAgICAgICAgICAg ICAgICAgICAgSlNWYWx1ZSBjaGlsZDFDb25zdGFudCA9IG1fc3RhdGUuZm9yTm9kZShub2RlLT5j aGlsZDEoKS5ub2RlKCkpLnZhbHVlKCk7CisgICAgICAgICAgICAgICAgICAgIEpTVmFsdWUgY2hp bGQyQ29uc3RhbnQgPSBtX3N0YXRlLmZvck5vZGUobm9kZS0+Y2hpbGQyKCkubm9kZSgpKS52YWx1 ZSgpOworCisgICAgICAgICAgICAgICAgICAgIGF1dG8gaXNOb25TdHJpbmdDZWxsQ29uc3RhbnQg PSBbXSAoSlNWYWx1ZSB2YWx1ZSkgeworICAgICAgICAgICAgICAgICAgICAgICAgcmV0dXJuIHZh bHVlICYmIHZhbHVlLmlzQ2VsbCgpICYmICF2YWx1ZS5pc1N0cmluZygpOworICAgICAgICAgICAg ICAgICAgICB9OworCisgICAgICAgICAgICAgICAgICAgIGlmIChpc05vblN0cmluZ0NlbGxDb25z dGFudChjaGlsZDFDb25zdGFudCkpIHsKKyAgICAgICAgICAgICAgICAgICAgICAgIG5vZGUtPmNv bnZlcnRUb0NvbXBhcmVFcVB0cihtX2dyYXBoLmZyZWV6ZVN0cm9uZyhjaGlsZDFDb25zdGFudC5h c0NlbGwoKSksIG5vZGUtPmNoaWxkMigpKTsKKyAgICAgICAgICAgICAgICAgICAgICAgIGNoYW5n ZWQgPSB0cnVlOworICAgICAgICAgICAgICAgICAgICB9IGVsc2UgaWYgKGlzTm9uU3RyaW5nQ2Vs bENvbnN0YW50KGNoaWxkMkNvbnN0YW50KSkgeworICAgICAgICAgICAgICAgICAgICAgICAgbm9k ZS0+Y29udmVydFRvQ29tcGFyZUVxUHRyKG1fZ3JhcGguZnJlZXplU3Ryb25nKGNoaWxkMkNvbnN0 YW50LmFzQ2VsbCgpKSwgbm9kZS0+Y2hpbGQxKCkpOworICAgICAgICAgICAgICAgICAgICAgICAg Y2hhbmdlZCA9IHRydWU7CisgICAgICAgICAgICAgICAgICAgIH0KKyAgICAgICAgICAgICAgICB9 CisgICAgICAgICAgICAgICAgYnJlYWs7CisgICAgICAgICAgICB9CisKICAgICAgICAgICAgICAg ICAKICAgICAgICAgICAgIGNhc2UgQ2hlY2tTdHJ1Y3R1cmU6CiAgICAgICAgICAgICBjYXNlIEFy cmF5aWZ5VG9TdHJ1Y3R1cmU6IHsKZGlmZiAtLWdpdCBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9k ZmcvREZHTm9kZS5oIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL2RmZy9ERkdOb2RlLmgKaW5kZXgg ZTcwZGI5NjExYzRiMDQyODI5NTk2MzQzMDI1YTczMzkzZjE3Y2IxNC4uM2UyM2QwNDMyMWU4NTM2 MTE5ODJkNDIxZmRhM2NiZTc4MTJhZGZmNSAxMDA2NDQKLS0tIGEvU291cmNlL0phdmFTY3JpcHRD b3JlL2RmZy9ERkdOb2RlLmgKKysrIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL2RmZy9ERkdOb2Rl LmgKQEAgLTY4Miw2ICs2ODIsMTUgQEAgc3RydWN0IE5vZGUgewogICAgICAgICBBU1NFUlQobV9v cCA9PSBBcml0aEFicyAmJiBjaGlsZDEoKS51c2VLaW5kKCkgPT0gSW50MzJVc2UpOwogICAgICAg ICBtX29wID0gQXJpdGhOZWdhdGU7CiAgICAgfQorCisgICAgdm9pZCBjb252ZXJ0VG9Db21wYXJl RXFQdHIoRnJvemVuVmFsdWUqIGNlbGwsIEVkZ2Ugbm9kZSkKKyAgICB7CisgICAgICAgIEFTU0VS VChtX29wID09IENvbXBhcmVTdHJpY3RFcSk7CisgICAgICAgIHNldE9wQW5kRGVmYXVsdEZsYWdz KENvbXBhcmVFcVB0cik7CisgICAgICAgIGNoaWxkcmVuLnNldENoaWxkMShub2RlKTsKKyAgICAg ICAgY2hpbGRyZW4uc2V0Q2hpbGQyKEVkZ2UoKSk7CisgICAgICAgIG1fb3BJbmZvID0gY2VsbDsK KyAgICB9CiAgICAgCiAgICAgdm9pZCBjb252ZXJ0VG9EaXJlY3RDYWxsKEZyb3plblZhbHVlKik7 CiAK