74625 2011-12-15 10:45:55 -0800 Clang doesn't optimize away undefined OwnPtr copy constructor 2012-09-11 10:38:52 -0700 1 1 1 Unclassified WebKit Web Template Framework 528+ (Nightly build) Unspecified Unspecified RESOLVED FIXED P2 Normal --- 1 enne enne adamk andersca benjamin cc-bugs darin enne gustavo jamesr mrowe rniwa sam thakis tkent webkit.review.bot xan.lopez oldest_to_newest 522043 0 enne 2011-12-15 10:45:55 -0800 Clang doesn't optimize away undefined OwnPtr copy constructor 522049 1 119460 enne 2011-12-15 10:48:56 -0800 Created attachment 119460 Patch 522055 2 119460 thakis 2011-12-15 10:51:33 -0800 Comment on attachment 119460 Patch This won't work, clang sets GCC. Declaring but not defining this destructor is a bug, and from what I can tell not necessary for recent-ish gccs. Can you try just removing that whole block? 522072 3 enne 2011-12-15 10:58:02 -0800 (In reply to comment #2) > (From update of attachment 119460 [details]) > This won't work, clang sets GCC. > > Declaring but not defining this destructor is a bug, and from what I can tell not necessary for recent-ish gccs. Can you try just removing that whole block? Removing the whole block works fine and fixes the Clang errors. However, I think it's still useful to have this public declared-but-not-defined copy constructor for gcc, because it makes it impossible to call it explicitly without getting link errors. Ideally, you'd make OwnPtr WTF_MAKE_NONCOPYABLE, but because the copy constructor gets called implicitly you can't do that. I think having that function there is the next best thing. 522073 4 119465 enne 2011-12-15 11:00:53 -0800 Created attachment 119465 Change #if to !Clang 522146 5 andersca 2011-12-15 12:39:11 -0800 Adding an OwnPtr copy constructor is bad and will lead to memory corruption - do we know where clang is generating calls to the copy constructor? 522164 6 119465 andersca 2011-12-15 12:52:51 -0800 Comment on attachment 119465 Change #if to !Clang I'll r- this so it won't be landed by accident and possibly break the world :) 522165 7 thakis 2011-12-15 12:53:58 -0800 > However, I think it's still useful to have this public declared-but-not-defined copy constructor for gcc, because it makes it impossible to call it explicitly without getting link errors. If you remove it, it's impossible to call it without getting compile errors. I don't understand why this can't be removed. It was added as a workaround to make this compile with some old gcc (I'd guess pre 4.0?) 522243 8 enne 2011-12-15 14:43:00 -0800 (In reply to comment #5) > Adding an OwnPtr copy constructor is bad and will lead to memory corruption - do we know where clang is generating calls to the copy constructor? I'm not adding--I'm compiling out its declaration on Clang. Both gcc and Clang generate implicit calls to the OwnPtr copy constructor when you assign and initialize a stack-based OwnPtr, e.g. OwnPtr<T> local = adoptPtr(SomeClass::create()); You can see this locally if you move the existing copy constructor behind a private visibility modifier, build with gcc, and watch the compiler errors fly. gcc optimizes these function calls out but Clang doesn't, so Clang's build fails with link errors because the copy constructor only has a declaration and not a definition. I would love if somebody could make this function call not be transitively generated, but doing so myself is beyond my ken. (In reply to comment #7) > > However, I think it's still useful to have this public declared-but-not-defined copy constructor for gcc, because it makes it impossible to call it explicitly without getting link errors. > > If you remove it, it's impossible to call it without getting compile errors. I don't understand why this can't be removed. It was added as a workaround to make this compile with some old gcc (I'd guess pre 4.0?) Not true. Copy constructors are one of the special member functions that C++ will happily provide public versions of for you if you don't declare them in some other way. Here's some example code: OwnPtr<T> ptr1; OwnPtr<T> ptr2(ptr1); I believe this code should be invalid and should ideally cause a compiler error. I suspect this is also andersca's worry. With the copy constructor still defined as in the patch above, the above code continues to be a link error for gcc. With it removed as you propose, the above code compiles and links, with ptr1.get() == ptr2.get(). 522283 9 darin 2011-12-15 15:53:28 -0800 (In reply to comment #2) > Declaring but not defining this constructor is a bug, and from what I can tell not necessary for recent-ish gccs. Can you try just removing that whole block? We need to make sure that the OwnPtr copy constructor is never actually called. It’s impossible to copy one of these safely. Declaring and not defining it is not a bug, but rather a well-known and understood technique. We need to carefully study any specific places where the call to the copy constructor is being generated to see what possible safe solutions to the problem are. Anders is well suited to helping us diagnose this since he has done quite a bit of work on clang and is a C++ expert. 524860 10 enne 2011-12-20 15:06:43 -0800 (In reply to comment #9) > (In reply to comment #2) > > Declaring but not defining this constructor is a bug, and from what I can tell not necessary for recent-ish gccs. Can you try just removing that whole block? > > We need to make sure that the OwnPtr copy constructor is never actually called. It’s impossible to copy one of these safely. Declaring and not defining it is not a bug, but rather a well-known and understood technique. "Declaring and not defining" also usually involves that declaration having a private visibility modifier and doesn't involve that function being implicitly defined but then compiled away so that explicit uses fail at link time. Usually the function doesn't get used, period. I'm not saying we shouldn't use this approach, but it's not fair to paint this as any sort of common case. > We need to carefully study any specific places where the call to the copy constructor is being generated to see what possible safe solutions to the problem are. Anders is well suited to helping us diagnose this since he has done quite a bit of work on clang and is a C++ expert. I apologize for the length of this comment, but I spent a long time staring at this and there seems to be a lot of confusion on this issue. Here's my analysis: the copy constructor is primarily being generated as a part of copy-initialization, often in a codesite that looks something like this: OwnPtr<SomeClass> local = adoptPtr(SomeClass::create()); The C++ standard requires the copy constructor to be optimized away during copy-initialization by calling a constructor instead in some special cases, such as when both types are identical or the source is derived from the destination. Unfortunately, PassOwnPtr and OwnPtr have no such relationship, so the non-explicit OwnPtr<T>(const PassOwnPtr<U>&) constructor is used as an implicit conversion followed by the copy constructor in order to copy-initialize this object. More specifically, the reason this was failing in my hash table (see bug 74154) is because I was using a std::pair<int, int> as the key, but with emptyValueIsZero = false, because (0, 0) is a valid index for my use case. However, the storage in a hash table is a std::pair<key, value>. Since OwnPtr's emptyValue() gets passed as a full OwnPtr to the std::pair<key, value> constructor, the copy constructor gets called implicitly. Oops. In both of these cases, gcc optimizes these copy constructor usages away, but Clang doesn't manage to in as many cases (although it clearly does in some), so we need to sort out how to accommodate them both compilers. Personally, I find failing at link time on only one compiler for perfectly safe code to be a really poor experience as a developer. In my opinion, it would be excellent to have all compilers fail only on improper OwnPtr usage at compile time. I think we can do this. Small Question #1: What to do about my HashTable problem? I can easily work around it in this specific case by offsetting all indices by one so that the combined key/value hash trait can be memset to zero. There may be some more elegant way to fix this at the hash table level, but I'm willing to punt. Big Question #2: What to do about other implicit copy constructor uses? The quick solution is my original patch, which would let gcc continue to catch explicit use of the copy constructor at link time, even if Clang doesn't. This would prevent future issues where Clang failed to compile on code that gcc was happy with, while still being safe. However, this still leaves us in a bad state where developers building with Clang might break gcc code unknowingly. A better solution would be to have PassOwnPtr (non-publicly) inherit from OwnPtr. This sounds awkward at first blush, but they have the same underlying storage and behave identically during destruction, so it's not as strange as it first seems. This approach would allow all copy-initialization of OwnPtr via PassOwnPtr to call the OwnPtr(PassOwnPtr) constructor rather than the OwnPtr(OwnPtr) copy constructor. And, in doing so, we could properly make the OwnPtr copy constructor private, just like WTF_MAKE_NONCOPYABLE does. Sounds great so far, right? Unfortunately, there's a catch--in doing this, you lose the ability to copy-initialize an OwnPtr with a PassOwnPtr of a derived type: class Base; class Derived : public Base; OwnPtr<Base> local = adoptPtr(new Derived); // Note: "OwnPtr<Base> local(adoptPtr(new Derived));" will still compile Because PassOwnPtr<Derived> and OwnPtr<Base> are of different types, copy-initialize still uses OwnPtr<T>(PassOwnPtr<U>) for implicit conversion and so we're right back into the original problem with the OwnPtr<T> copy constructor getting called. As I understand it, the PassOwnPtr type is already resolved prior to considering OwnPtr constructors, so a conversion operator on PassOwnPtr can't fix this problem. However, in building Chromium's chrome, webkit_unit_tests, and DumpRenderTree targets I only found 6 places with this derived copy-initialization behavior. All of these codesites are easily fixed by changing "T x = y" copy-initialization to "T x(y)" direct-initialization. There might be more in other ports or targets, but I think that's a reasonable estimate for how small this problem is. Having PassOwnPtr derive from OwnPtr isn't a perfect solution, but I find the minor tradeoff of not being able to do derived copy-initialization an acceptable loss for being able to have all compilers fail at compile time on unsafe code and none fail at link time on safe code. In summary, my proposal is: * have PassOwnPtr non-publicly derive from OwnPtr * make OwnPtr truly noncopyable by making its copy constructor private * fix up these six codesites using derived copy-initialization * fix up any other breakages on other ports or targets * add a comment to OwnPtr's now-private copy constructor explaining to developers why their compile fails and that they should switch copy-initialization to direct-initialization If this sounds palatable, I'll clean up my work-in-progress patch and put it up for review. 525324 11 darin 2011-12-21 10:28:24 -0800 (In reply to comment #10) > A better solution would be to have PassOwnPtr (non-publicly) inherit from OwnPtr. That sounds fine if we can make it work. > Unfortunately, there's a catch--in doing this, you lose the ability to copy-initialize an OwnPtr with a PassOwnPtr of a derived type: > > class Base; > class Derived : public Base; > OwnPtr<Base> local = adoptPtr(new Derived); > // Note: "OwnPtr<Base> local(adoptPtr(new Derived));" will still compile We don’t want to lose that. > Having PassOwnPtr derive from OwnPtr isn't a perfect solution, but I find the minor tradeoff of not being able to do derived copy-initialization an acceptable loss for being able to have all compilers fail at compile time on unsafe code and none fail at link time on safe code. I’m not sure I agree about that tradeoff. You mentioned the 6 places where we use polymorphic types with OwnPtr, but I think that’s an important idiom. Probably more important than hash maps with non-zero key values and OwnPtr mapped values. I think we may want to keep looking for even better solution before doing anything here. Anders, what do you think? 526645 12 120413 enne 2011-12-22 16:56:00 -0800 Created attachment 120413 Make PassOwnPtr derive from OwnPtr 526666 13 120413 webkit-ews 2011-12-22 17:41:10 -0800 Comment on attachment 120413 Make PassOwnPtr derive from OwnPtr Attachment 120413 did not pass qt-ews (qt): Output: http://queues.webkit.org/results/11018103 526672 14 enne 2011-12-22 17:51:12 -0800 (In reply to comment #12) > Created an attachment (id=120413) [details] > Make PassOwnPtr derive from OwnPtr I just wanted to put up a concrete patch for further discussion. I continue to think that the OwnPtr code as-is is problematic in that safe code can cause link errors for compilers that don't implement the exact same optimizations as gcc. The hashmap issue is entirely secondary--this patch wouldn't solve it, although it would have helped catch its errors before it was committed. 526674 15 120413 gyuyoung.kim 2011-12-22 18:01:21 -0800 Comment on attachment 120413 Make PassOwnPtr derive from OwnPtr Attachment 120413 did not pass efl-ews (efl): Output: http://queues.webkit.org/results/11019101 526675 16 120413 gustavo 2011-12-22 18:02:25 -0800 Comment on attachment 120413 Make PassOwnPtr derive from OwnPtr Attachment 120413 did not pass gtk-ews (gtk): Output: http://queues.webkit.org/results/10939113 529795 17 andersca 2012-01-04 15:03:08 -0800 I don't think we need to/should make PassOwnPtr derive from OwnPtr. Since this error only happens with clang, and since we know clang supports rvalue references as a C++98 extension, it should be possible to add move constructors and move assignment operators to OwnPtr.h. Clang should choose the move constructor instead of the undefined copy constructor when possible. I'll attach a test patch that does this. 529797 18 121166 andersca 2012-01-04 15:04:13 -0800 Created attachment 121166 Patch 529897 19 enne 2012-01-04 17:25:54 -0800 (In reply to comment #18) > Created an attachment (id=121166) [details] > Patch Hmm. This doesn't seem to do the trick for my HashMap case. It still fails with a link error for the copy constructor on Clang, but builds on gcc. It generates the copy constructor in a different way. Here's a log where I made the copy constructor private (along with your patch and the patch from 74154), to demonstrate where it is being implicitly generated: http://build.chromium.org/p/tryserver.chromium/builders/linux_clang/builds/5644/steps/compile/logs/stdio There's also another example I just ran into of Visual Studio failing to perform RVO and requiring an OwnPtr copy constructor. GCC built fine, but Visual Studio failed with a link error. See bug 75557. I think I just want OwnPtr usage to fail consistently across compilers, independent of the optimizations that they perform. 529898 20 jamesr 2012-01-04 17:29:16 -0800 Compile error (that log won't live forever): In file included from third_party/WebKit/Source/WebCore/platform/graphics/chromium/cc/CCLayerTilingData.cpp:31: In file included from third_party/WebKit/Source/WebCore/platform/graphics/chromium/cc/CCLayerTilingData.h:32: In file included from third_party/WebKit/Source/WebCore/platform/graphics/IntRect.h:29: In file included from third_party/WebKit/Source/WebCore/platform/graphics/IntPoint.h:30: In file included from third_party/WebKit/Source/JavaScriptCore/wtf/MathExtras.h:29: In file included from /usr/lib/gcc/x86_64-linux-gnu/4.4/../../../../include/c++/4.4/algorithm:60: In file included from /usr/lib/gcc/x86_64-linux-gnu/4.4/../../../../include/c++/4.4/bits/stl_algobase.h:66: /usr/lib/gcc/x86_64-linux-gnu/4.4/../../../../include/c++/4.4/bits/stl_pair.h:67:12:error: field of type 'WTF::OwnPtr<WebCore::CCLayerTilingData::Tile>' has private copy constructor struct pair ^ third_party/WebKit/Source/JavaScriptCore/wtf/HashTable.h:661:9: note: in instantiation of function template specialization 'WTF::HashTableBucketInitializer<false>::initialize<WTF::PairHashTraits<WebCore::CCLayerTilingData::TileMapKeyTraits, WTF::HashTraits<WTF::OwnPtr<WebCore::CCLayerTilingData::Tile> > >, std::pair<std::pair<int, int>, WTF::OwnPtr<WebCore::CCLayerTilingData::Tile> > >' requested here HashTableBucketInitializer<Traits::emptyValueIsZero>::template initialize<Traits>(bucket); ^ third_party/WebKit/Source/JavaScriptCore/wtf/HashTable.h:724:13: note: in instantiation of member function 'WTF::HashTable<std::pair<int, int>, std::pair<std::pair<int, int>, WTF::OwnPtr<WebCore::CCLayerTilingData::Tile> >, WTF::PairFirstExtractor<std::pair<std::pair<int, int>, WTF::OwnPtr<WebCore::CCLayerTilingData::Tile> > >, WTF::PairHash<int, int>, WTF::PairHashTraits<WebCore::CCLayerTilingData::TileMapKeyTraits, WTF::HashTraits<WTF::OwnPtr<WebCore::CCLayerTilingData::Tile> > >, WebCore::CCLayerTilingData::TileMapKeyTraits>::initializeBucket' requested here initializeBucket(*deletedEntry); ^ third_party/WebKit/Source/JavaScriptCore/wtf/HashMap.h:325:32: note: in instantiation of function template specialization 'WTF::HashTable<std::pair<int, int>, std::pair<std::pair<int, int>, WTF::OwnPtr<WebCore::CCLayerTilingData::Tile> >, WTF::PairFirstExtractor<std::pair<std::pair<int, int>, WTF::OwnPtr<WebCore::CCLayerTilingData::Tile> > >, WTF::PairHash<int, int>, WTF::PairHashTraits<WebCore::CCLayerTilingData::TileMapKeyTraits, WTF::HashTraits<WTF::OwnPtr<WebCore::CCLayerTilingData::Tile> > >, WebCore::CCLayerTilingData::TileMapKeyTraits>::add<WTF::HashMapTranslator<WTF::PairHashTraits<WebCore::CCLayerTilingData::TileMapKeyTraits, WTF::HashTraits<WTF::OwnPtr<WebCore::CCLayerTilingData::Tile> > >, WTF::PairHash<int, int> >, std::pair<int, int>, WTF::PassOwnPtr<WebCore::CCLayerTilingData::Tile> >' requested here return m_impl.template add<HashMapTranslator<ValueTraits, HashFunctions> >(key, mapped); ^ third_party/WebKit/Source/JavaScriptCore/wtf/HashMap.h:352:16: note: in instantiation of member function 'WTF::HashMap<std::pair<int, int>, WTF::OwnPtr<WebCore::CCLayerTilingData::Tile>, WTF::PairHash<int, int>, WebCore::CCLayerTilingData::TileMapKeyTraits, WTF::HashTraits<WTF::OwnPtr<WebCore::CCLayerTilingData::Tile> > >::inlineAdd' requested here return inlineAdd(key, mapped); ^ third_party/WebKit/Source/WebCore/platform/graphics/chromium/cc/CCLayerTilingData.cpp:81:13: note: in instantiation of member function 'WTF::HashMap<std::pair<int, int>, WTF::OwnPtr<WebCore::CCLayerTilingData::Tile>, WTF::PairHash<int, int>, WebCore::CCLayerTilingData::TileMapKeyTraits, WTF::HashTraits<WTF::OwnPtr<WebCore::CCLayerTilingData::Tile> > >::add' requested here m_tiles.add(make_pair(i, j), tile); ^ third_party/WebKit/Source/JavaScriptCore/wtf/OwnPtr.h:90:9: note: declared private here OwnPtr(const OwnPtr<ValueType>&); ^ third_party/WebKit/Source/JavaScriptCore/wtf/HashTable.h:644:36: note: implicit default copy constructor for 'std::pair<std::pair<int, int>, WTF::OwnPtr<WebCore::CCLayerTilingData::Tile> >' first required here new (NotNull, &bucket) Value(Traits::emptyValue()); ^ In file included from third_party/WebKit/Source/WebCore/platform/graphics/chromium/cc/CCLayerTilingData.cpp:31: In file included from third_party/WebKit/Source/WebCore/platform/graphics/chromium/cc/CCLayerTilingData.h:32: In file included from third_party/WebKit/Source/WebCore/platform/graphics/IntRect.h:29: In file included from third_party/WebKit/Source/WebCore/platform/graphics/IntPoint.h:30: In file included from third_party/WebKit/Source/JavaScriptCore/wtf/MathExtras.h:29: In file included from /usr/lib/gcc/x86_64-linux-gnu/4.4/../../../../include/c++/4.4/algorithm:60: In file included from /usr/lib/gcc/x86_64-linux-gnu/4.4/../../../../include/c++/4.4/bits/stl_algobase.h:66: /usr/lib/gcc/x86_64-linux-gnu/4.4/../../../../include/c++/4.4/bits/stl_pair.h:101:4:error: field of type 'WTF::OwnPtr<WebCore::CCLayerTilingData::Tile>' has private copy constructor second(__p.second) { } ^ third_party/WebKit/Source/JavaScriptCore/wtf/HashTraits.h:149:41: note: in instantiation of function template specialization 'std::pair<std::pair<int, int>, WTF::OwnPtr<WebCore::CCLayerTilingData::Tile> >::pair<std::pair<int, int>, WTF::OwnPtr<WebCore::CCLayerTilingData::Tile> >' requested here static TraitType emptyValue() { return make_pair(FirstTraits::emptyValue(), SecondTraits::emptyValue()); } ^ third_party/WebKit/Source/JavaScriptCore/wtf/HashTable.h:644:50: note: in instantiation of member function 'WTF::PairHashTraits<WebCore::CCLayerTilingData::TileMapKeyTraits, WTF::HashTraits<WTF::OwnPtr<WebCore::CCLayerTilingData::Tile> > >::emptyValue' requested here new (NotNull, &bucket) Value(Traits::emptyValue()); ^ third_party/WebKit/Source/JavaScriptCore/wtf/HashTable.h:661:9: note: in instantiation of function template specialization 'WTF::HashTableBucketInitializer<false>::initialize<WTF::PairHashTraits<WebCore::CCLayerTilingData::TileMapKeyTraits, WTF::HashTraits<WTF::OwnPtr<WebCore::CCLayerTilingData::Tile> > >, std::pair<std::pair<int, int>, WTF::OwnPtr<WebCore::CCLayerTilingData::Tile> > >' requested here HashTableBucketInitializer<Traits::emptyValueIsZero>::template initialize<Traits>(bucket); ^ third_party/WebKit/Source/JavaScriptCore/wtf/HashTable.h:724:13: note: in instantiation of member function 'WTF::HashTable<std::pair<int, int>, std::pair<std::pair<int, int>, WTF::OwnPtr<WebCore::CCLayerTilingData::Tile> >, WTF::PairFirstExtractor<std::pair<std::pair<int, int>, WTF::OwnPtr<WebCore::CCLayerTilingData::Tile> > >, WTF::PairHash<int, int>, WTF::PairHashTraits<WebCore::CCLayerTilingData::TileMapKeyTraits, WTF::HashTraits<WTF::OwnPtr<WebCore::CCLayerTilingData::Tile> > >, WebCore::CCLayerTilingData::TileMapKeyTraits>::initializeBucket' requested here initializeBucket(*deletedEntry); ^ third_party/WebKit/Source/JavaScriptCore/wtf/HashMap.h:325:32: note: in instantiation of function template specialization 'WTF::HashTable<std::pair<int, int>, std::pair<std::pair<int, int>, WTF::OwnPtr<WebCore::CCLayerTilingData::Tile> >, WTF::PairFirstExtractor<std::pair<std::pair<int, int>, WTF::OwnPtr<WebCore::CCLayerTilingData::Tile> > >, WTF::PairHash<int, int>, WTF::PairHashTraits<WebCore::CCLayerTilingData::TileMapKeyTraits, WTF::HashTraits<WTF::OwnPtr<WebCore::CCLayerTilingData::Tile> > >, WebCore::CCLayerTilingData::TileMapKeyTraits>::add<WTF::HashMapTranslator<WTF::PairHashTraits<WebCore::CCLayerTilingData::TileMapKeyTraits, WTF::HashTraits<WTF::OwnPtr<WebCore::CCLayerTilingData::Tile> > >, WTF::PairHash<int, int> >, std::pair<int, int>, WTF::PassOwnPtr<WebCore::CCLayerTilingData::Tile> >' requested here return m_impl.template add<HashMapTranslator<ValueTraits, HashFunctions> >(key, mapped); ^ third_party/WebKit/Source/JavaScriptCore/wtf/HashMap.h:352:16: note: in instantiation of member function 'WTF::HashMap<std::pair<int, int>, WTF::OwnPtr<WebCore::CCLayerTilingData::Tile>, WTF::PairHash<int, int>, WebCore::CCLayerTilingData::TileMapKeyTraits, WTF::HashTraits<WTF::OwnPtr<WebCore::CCLayerTilingData::Tile> > >::inlineAdd' requested here return inlineAdd(key, mapped); ^ third_party/WebKit/Source/WebCore/platform/graphics/chromium/cc/CCLayerTilingData.cpp:81:13: note: in instantiation of member function 'WTF::HashMap<std::pair<int, int>, WTF::OwnPtr<WebCore::CCLayerTilingData::Tile>, WTF::PairHash<int, int>, WebCore::CCLayerTilingData::TileMapKeyTraits, WTF::HashTraits<WTF::OwnPtr<WebCore::CCLayerTilingData::Tile> > >::add' requested here m_tiles.add(make_pair(i, j), tile); ^ third_party/WebKit/Source/JavaScriptCore/wtf/OwnPtr.h:90:9: note: declared private here OwnPtr(const OwnPtr<ValueType>&); ^ 2 errors generated. make: *** [out/Debug/obj.target/webcore_platform/third_party/WebKit/Source/WebCore/platform/graphics/chromium/cc/CCLayerTilingData.o] Error 1 539807 21 enne 2012-01-20 14:48:47 -0800 A belated follow-up. As long as we have a public declared-but-not-defined copy constructor, we are always going to depend on inconsistent compiler optimizations, where different platforms may or may not be able to compile and link the same code. It's not just Clang, although Clang seems to be more different more often. andersca's patch to add rvalue reference functions to OwnPtr is great but it only hits one of these optimizations. I think that will be true of any solution that doesn't involve the copy constructor being made private or "= delete". Hypothetically speaking, if every compiler supported rvalue references, then andersca's patch with a follow-up of making the copy constructor private could be workable. However, since they don't, this can't be done. I continue to think that the PassOwnPtr-derives-from-OwnPtr patch has less smell than the current behavior. It may disallow one rarely-used case that should be allowed, but it will always fail all bad cases early and it will always fail consistently across all compilers. darin, andersca: Do you have any thoughts or other proposals? Do you feel like that solution is workable or do you feel like the cure is worse than the disease? 539840 22 darin 2012-01-20 15:22:50 -0800 (In reply to comment #21) > andersca's patch to add rvalue reference functions to OwnPtr is great but it only hits one of these optimizations. I think that will be true of any solution that doesn't involve the copy constructor being made private or "= delete". > > Hypothetically speaking, if every compiler supported rvalue references, then andersca's patch with a follow-up of making the copy constructor private could be workable. However, since they don't, this can't be done. We can make the copy constructor private on any compiler that supports rvalue references. Since clang is such a compiler it will catch mistakes for us. And we haven’t had problems with compilers other than clang yet, so lets not make changes based on fear for the future. That’s what I think we should do. 539856 23 enne 2012-01-20 15:34:45 -0800 (In reply to comment #22) > (In reply to comment #21) > > andersca's patch to add rvalue reference functions to OwnPtr is great but it only hits one of these optimizations. I think that will be true of any solution that doesn't involve the copy constructor being made private or "= delete". > > > > Hypothetically speaking, if every compiler supported rvalue references, then andersca's patch with a follow-up of making the copy constructor private could be workable. However, since they don't, this can't be done. > > We can make the copy constructor private on any compiler that supports rvalue references. Since clang is such a compiler it will catch mistakes for us. And we haven’t had problems with compilers other than clang yet, so lets not make changes based on fear for the future. Unfortunately, that will do nothing for the status quo. Other compilers will continue to successfully compile and link code that will not work for Clang, causing unexpected breakages because that particular compiler doesn't have a private OwnPtr copy constructor. The problem is not improper use of the copy constructor, but the dependency on inconsistent compiler optimizations to remove transient but proper usage. Also, it's not just Clang. In bug 75557, Visual Studio failed to perform named return value optimization and generated an OwnPtr copy constructor. gcc built fine, but Visual Studio failed with a link error. 539872 24 darin 2012-01-20 16:00:41 -0800 (In reply to comment #23) > The problem is not improper use of the copy constructor, but the dependency on inconsistent compiler optimizations to remove transient but proper usage. I don’t agree with this analysis. 539881 25 enne 2012-01-20 16:07:53 -0800 (In reply to comment #24) > (In reply to comment #23) > > The problem is not improper use of the copy constructor, but the dependency on inconsistent compiler optimizations to remove transient but proper usage. > > I don’t agree with this analysis. How would you state the problem? 541932 26 andersca 2012-01-24 18:09:22 -0800 I think that we should treat the current behavior as the legacy behavior, and not spend more time on trying to fix it given that it seems to work well enough. The C++11 way with a move constructor and move assignment operator has well-defined semantics and works on most modern compilers (including VS2010, which we'd have to adopt on Windows). I think the problem in https://bugs.webkit.org/show_bug.cgi?id=74154 is that the traits for the key in HashMap< TileMapKey, OwnPtr<Tile>> specifies emptyValueIsZero = false. This means that the traits for the underlying HashTable will have emptyValueIsZero = false set as well, which causes the emptyValue to be constructed using static TraitType emptyValue() { return make_pair(FirstTraits::emptyValue(), SecondTraits::emptyValue()); } and that's what ends up trying to copy the OwnPtr. 542482 27 enne 2012-01-25 11:25:35 -0800 (In reply to comment #26) > I think that we should treat the current behavior as the legacy behavior, and not spend more time on trying to fix it given that it seems to work well enough. I don't think the current behavior *does* work well enough, because I keep running into cases where different compilers behave differently. However, it's pretty clear that nobody else feels this way. > The C++11 way with a move constructor and move assignment operator has well-defined semantics and works on most modern compilers (including VS2010, which we'd have to adopt on Windows). Is the path to move forward to first land that patch for rvalue references and Clang? Then, make the OwnPtr copy constructor private if that feature is enabled (and fix the build errors that causes.) Then, consider enabling that feature for other compilers on an individual basis? 673210 28 enne 2012-07-18 23:39:42 -0700 The public OwnPtr copy constructor continues to cause ongoing build failures for Chromium: http://build.webkit.org/builders/Chromium%20Mac%20Release/builds/40233/steps/compile-webkit/logs/stdio 695267 29 120413 darin 2012-08-14 12:44:58 -0700 Comment on attachment 120413 Make PassOwnPtr derive from OwnPtr We should fix this using a move constructor. Not by making PassOwnPtr derive from OwnPtr. I suggest starting with Anders’s patch and making it work. 695328 30 enne 2012-08-14 13:28:09 -0700 (In reply to comment #29) > (From update of attachment 120413 [details]) > We should fix this using a move constructor. Not by making PassOwnPtr derive from OwnPtr. I suggest starting with Anders’s patch and making it work. How does the move constructor fix the Visual Studio error mentioned in comment #19? The source of the problem is the public copy constructor. If all WebKit platforms supported the move constructor, then we could remove it, but this doesn't seem to be the case. 702411 31 160019 enne 2012-08-22 15:24:13 -0700 Created attachment 160019 andersca's patch + #if'd out copy constructor 702421 32 webkit.review.bot 2012-08-22 15:27:05 -0700 Attachment 160019 did not pass style-queue: Failed to run "['Tools/Scripts/check-webkit-style', '--diff-files', u'Source/WTF/ChangeLog', u'Source/WTF/wtf/Ow..." exit_code: 1 Source/WTF/wtf/OwnPtr.h:79: Missing spaces around && [whitespace/operators] [3] Source/WTF/wtf/OwnPtr.h:82: Missing spaces around && [whitespace/operators] [3] Total errors found: 2 in 2 files If any of these errors are false positives, please file a bug against check-webkit-style. 702425 33 160019 thakis 2012-08-22 15:27:28 -0700 Comment on attachment 160019 andersca's patch + #if'd out copy constructor View in context: https://bugs.webkit.org/attachment.cgi?id=160019&action=review Not sure if this is something the project cares about: > Source/WTF/wtf/OwnPtr.h:49 > +#if !COMPILER_SUPPORTS(CXX_RVALUE_REFERENCES) Note: All except very recent gdb's (xcode 4.4 on mac, bug not yet fixed for official gdb afaik) can't handle the symbols that recent compilers produce for rvalue references. That's already a bit of a problem and makes it impossible to debug parts of webkit with many toolchains. Making this change would probably mean that all of webkit becomes undebuggable, as OwnPtr is used so widely. 702438 34 enne 2012-08-22 15:31:42 -0700 (In reply to comment #32) > Attachment 160019 [details] did not pass style-queue: > > Failed to run "['Tools/Scripts/check-webkit-style', '--diff-files', u'Source/WTF/ChangeLog', u'Source/WTF/wtf/Ow..." exit_code: 1 > Source/WTF/wtf/OwnPtr.h:79: Missing spaces around && [whitespace/operators] [3] > Source/WTF/wtf/OwnPtr.h:82: Missing spaces around && [whitespace/operators] [3] > Total errors found: 2 in 2 files > > > If any of these errors are false positives, please file a bug against check-webkit-style. Filed bug 94753. 705423 35 enne 2012-08-27 11:19:45 -0700 (In reply to comment #33) > (From update of attachment 160019 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=160019&action=review > > Not sure if this is something the project cares about: > > > Source/WTF/wtf/OwnPtr.h:49 > > +#if !COMPILER_SUPPORTS(CXX_RVALUE_REFERENCES) > > Note: All except very recent gdb's (xcode 4.4 on mac, bug not yet fixed for official gdb afaik) can't handle the symbols that recent compilers produce for rvalue references. That's already a bit of a problem and makes it impossible to debug parts of webkit with many toolchains. Making this change would probably mean that all of webkit becomes undebuggable, as OwnPtr is used so widely. In my own experience, this is already a pervasive issue even before this patch is applied given that rvalue references are already used by RetainPtr, Vector, AtomicString, and WTFString. I wonder if maybe we should not say that the CXX_RVALUE_REFERENCES are supported when compiling with older versions of Xcode, but I also think that it's a separate bug from this one. 706498 36 161011 enne 2012-08-28 10:40:34 -0700 Created attachment 161011 Also make copy constructor private 706501 37 webkit.review.bot 2012-08-28 10:44:52 -0700 Attachment 161011 did not pass style-queue: Failed to run "['Tools/Scripts/check-webkit-style', '--diff-files', u'Source/WTF/ChangeLog', u'Source/WTF/wtf/Ow..." exit_code: 1 Source/WTF/wtf/OwnPtr.h:79: Missing spaces around && [whitespace/operators] [3] Source/WTF/wtf/OwnPtr.h:82: Missing spaces around && [whitespace/operators] [3] Total errors found: 2 in 2 files If any of these errors are false positives, please file a bug against check-webkit-style. 712307 38 enne 2012-09-05 11:00:15 -0700 darin, andersca: review? 716450 39 161011 andersca 2012-09-10 13:38:16 -0700 Comment on attachment 161011 Also make copy constructor private View in context: https://bugs.webkit.org/attachment.cgi?id=161011&action=review > Source/WTF/wtf/OwnPtr.h:91 > + OwnPtr(const OwnPtr<T>&); I don't think the <T> is needed here. We should really add a WTF_MARK_DELETED macro in Compiler.h that expands to "= delete" for compilers that support deleted functions. > Source/WTF/wtf/OwnPtr.h:93 > OwnPtr& operator=(const OwnPtr<T>&); Same comment here (sorta). 716566 40 enne 2012-09-10 15:08:07 -0700 (In reply to comment #39) > (From update of attachment 161011 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=161011&action=review > > > Source/WTF/wtf/OwnPtr.h:91 > > + OwnPtr(const OwnPtr<T>&); > > I don't think the <T> is needed here. > > We should really add a WTF_MARK_DELETED macro in Compiler.h that expands to "= delete" for compilers that support deleted functions. WTF_MAKE_NONCOPYABLE already does that. It makes the #ifdefs look a little weird, but I can do that if rvalue references are supported. I'll put up another patch. Please take a look. :) 716568 41 163220 enne 2012-09-10 15:08:26 -0700 Created attachment 163220 Use Noncopyable 716572 42 webkit.review.bot 2012-09-10 15:10:49 -0700 Attachment 163220 did not pass style-queue: Failed to run "['Tools/Scripts/check-webkit-style', '--diff-files', u'Source/WTF/ChangeLog', u'Source/WTF/wtf/Ow..." exit_code: 1 Source/WTF/wtf/OwnPtr.h:85: Missing spaces around && [whitespace/operators] [3] Source/WTF/wtf/OwnPtr.h:88: Missing spaces around && [whitespace/operators] [3] Total errors found: 2 in 2 files If any of these errors are false positives, please file a bug against check-webkit-style. 717322 43 163220 andersca 2012-09-11 10:09:59 -0700 Comment on attachment 163220 Use Noncopyable Looks great! Thanks for tackling this! 717355 44 163220 webkit.review.bot 2012-09-11 10:38:45 -0700 Comment on attachment 163220 Use Noncopyable Clearing flags on attachment: 163220 Committed r128203: <http://trac.webkit.org/changeset/128203> 717356 45 webkit.review.bot 2012-09-11 10:38:52 -0700 All reviewed patches have been landed. Closing bug. 119460 2011-12-15 10:48:56 -0800 2011-12-15 11:00:50 -0800 Patch bug-74625-20111215104855.patch text/plain 1642 enne U3VidmVyc2lvbiBSZXZpc2lvbjogMTAyODM4CmRpZmYgLS1naXQgYS9Tb3VyY2UvSmF2YVNjcmlw dENvcmUvQ2hhbmdlTG9nIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL0NoYW5nZUxvZwppbmRleCAw YzZiMTRlZjA5YjJiM2Q2YmU0ZWJlMGViZmRkZDNlYTA2MWViYzk0Li4zMDcxN2VlMWJkMTg1Njg5 ZTk2OWQ1NmRlYTE5MWIxNmI3NDZkMzQ4IDEwMDY0NAotLS0gYS9Tb3VyY2UvSmF2YVNjcmlwdENv cmUvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9DaGFuZ2VMb2cKQEAgLTEs MyArMSwxMiBAQAorMjAxMS0xMi0xNSAgQWRyaWVubmUgV2Fsa2VyICA8ZW5uZUBnb29nbGUuY29t PgorCisgICAgICAgIENsYW5nIGRvZXNuJ3Qgb3B0aW1pemUgYXdheSB1bmRlZmluZWQgT3duUHRy IGNvcHkgY29uc3RydWN0b3IKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19i dWcuY2dpP2lkPTc0NjI1CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisK KyAgICAgICAgKiB3dGYvT3duUHRyLmg6CisKIDIwMTEtMTItMTMgIEpvbiBMZWUgIDxqb25sZWVA YXBwbGUuY29tPgogCiAgICAgICAgIEVuYWJsZSBub3RpZmljYXRpb25zIG9uIE1hYy4KZGlmZiAt LWdpdCBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93dGYvT3duUHRyLmggYi9Tb3VyY2UvSmF2YVNj cmlwdENvcmUvd3RmL093blB0ci5oCmluZGV4IDA5Nzk2Nzk2NGNhNjJmMWUzM2JhMTJkODcwYWRi ZDgzOWYyMzlkZTMuLjM0Yzc3YmExYmEwM2IzZjA3MjNmYTlmODc2MzQ2Mzc1OTQxYjk4ZTEgMTAw NjQ0Ci0tLSBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93dGYvT3duUHRyLmgKKysrIGIvU291cmNl L0phdmFTY3JpcHRDb3JlL3d0Zi9Pd25QdHIuaApAQCAtNDYsMTEgKzQ2LDEzIEBAIG5hbWVzcGFj ZSBXVEYgewogICAgICAgICAvLyBTZWUgY29tbWVudCBpbiBQYXNzT3duUHRyLmggZm9yIHdoeSB0 aGlzIHRha2VzIGEgY29uc3QgcmVmZXJlbmNlLgogICAgICAgICB0ZW1wbGF0ZTx0eXBlbmFtZSBV PiBPd25QdHIoY29uc3QgUGFzc093blB0cjxVPiYgbyk7CiAKKyNpZiBDT01QSUxFUihHQ0MpCiAg ICAgICAgIC8vIFRoaXMgY29weSBjb25zdHJ1Y3RvciBpcyB1c2VkIGltcGxpY2l0bHkgYnkgZ2Nj IHdoZW4gaXQgZ2VuZXJhdGVzCiAgICAgICAgIC8vIHRyYW5zaWVudHMgZm9yIGFzc2lnbmluZyBh IFBhc3NPd25QdHI8VD4gb2JqZWN0IHRvIGEgc3RhY2stYWxsb2NhdGVkCi0gICAgICAgIC8vIE93 blB0cjxUPiBvYmplY3QuIEl0IHNob3VsZCBuZXZlciBiZSBjYWxsZWQgZXhwbGljaXRseSBhbmQg Z2NjCi0gICAgICAgIC8vIHNob3VsZCBvcHRpbWl6ZSBhd2F5IHRoZSBjb25zdHJ1Y3RvciB3aGVu IGdlbmVyYXRpbmcgY29kZS4KKyAgICAgICAgLy8gT3duUHRyPFQ+IG9iamVjdC4gSXQncyBub3Qg ZGVmaW5lZCwgc28gaXQgY2FuJ3QgYmUgY2FsbGVkIGV4cGxpY2l0bHkuCisgICAgICAgIC8vIGdj YyB3aWxsIG9wdGltaXplIGF3YXkgdGhlIGNvbnN0cnVjdG9yIHdoZW4gZ2VuZXJhdGluZyBjb2Rl LgogICAgICAgICBPd25QdHIoY29uc3QgT3duUHRyPFZhbHVlVHlwZT4mKTsKKyNlbmRpZgogCiAg ICAgICAgIH5Pd25QdHIoKSB7IGRlbGV0ZU93bmVkUHRyKG1fcHRyKTsgfQogCg== 119465 2011-12-15 11:00:53 -0800 2011-12-22 16:55:56 -0800 Change #if to !Clang bug-74625-20111215110052.patch text/plain 1645 enne U3VidmVyc2lvbiBSZXZpc2lvbjogMTAyODM4CmRpZmYgLS1naXQgYS9Tb3VyY2UvSmF2YVNjcmlw dENvcmUvQ2hhbmdlTG9nIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL0NoYW5nZUxvZwppbmRleCAw YzZiMTRlZjA5YjJiM2Q2YmU0ZWJlMGViZmRkZDNlYTA2MWViYzk0Li4zMDcxN2VlMWJkMTg1Njg5 ZTk2OWQ1NmRlYTE5MWIxNmI3NDZkMzQ4IDEwMDY0NAotLS0gYS9Tb3VyY2UvSmF2YVNjcmlwdENv cmUvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9DaGFuZ2VMb2cKQEAgLTEs MyArMSwxMiBAQAorMjAxMS0xMi0xNSAgQWRyaWVubmUgV2Fsa2VyICA8ZW5uZUBnb29nbGUuY29t PgorCisgICAgICAgIENsYW5nIGRvZXNuJ3Qgb3B0aW1pemUgYXdheSB1bmRlZmluZWQgT3duUHRy IGNvcHkgY29uc3RydWN0b3IKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19i dWcuY2dpP2lkPTc0NjI1CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisK KyAgICAgICAgKiB3dGYvT3duUHRyLmg6CisKIDIwMTEtMTItMTMgIEpvbiBMZWUgIDxqb25sZWVA YXBwbGUuY29tPgogCiAgICAgICAgIEVuYWJsZSBub3RpZmljYXRpb25zIG9uIE1hYy4KZGlmZiAt LWdpdCBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93dGYvT3duUHRyLmggYi9Tb3VyY2UvSmF2YVNj cmlwdENvcmUvd3RmL093blB0ci5oCmluZGV4IDA5Nzk2Nzk2NGNhNjJmMWUzM2JhMTJkODcwYWRi ZDgzOWYyMzlkZTMuLjY2NjYyYzE1NzI0MGZhNmQ1ODcyMzY0MGQyMWFmY2YxZGM5MjAyYWYgMTAw NjQ0Ci0tLSBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93dGYvT3duUHRyLmgKKysrIGIvU291cmNl L0phdmFTY3JpcHRDb3JlL3d0Zi9Pd25QdHIuaApAQCAtNDYsMTEgKzQ2LDEzIEBAIG5hbWVzcGFj ZSBXVEYgewogICAgICAgICAvLyBTZWUgY29tbWVudCBpbiBQYXNzT3duUHRyLmggZm9yIHdoeSB0 aGlzIHRha2VzIGEgY29uc3QgcmVmZXJlbmNlLgogICAgICAgICB0ZW1wbGF0ZTx0eXBlbmFtZSBV PiBPd25QdHIoY29uc3QgUGFzc093blB0cjxVPiYgbyk7CiAKKyNpZiAhQ09NUElMRVIoQ0xBTkcp CiAgICAgICAgIC8vIFRoaXMgY29weSBjb25zdHJ1Y3RvciBpcyB1c2VkIGltcGxpY2l0bHkgYnkg Z2NjIHdoZW4gaXQgZ2VuZXJhdGVzCiAgICAgICAgIC8vIHRyYW5zaWVudHMgZm9yIGFzc2lnbmlu ZyBhIFBhc3NPd25QdHI8VD4gb2JqZWN0IHRvIGEgc3RhY2stYWxsb2NhdGVkCi0gICAgICAgIC8v IE93blB0cjxUPiBvYmplY3QuIEl0IHNob3VsZCBuZXZlciBiZSBjYWxsZWQgZXhwbGljaXRseSBh bmQgZ2NjCi0gICAgICAgIC8vIHNob3VsZCBvcHRpbWl6ZSBhd2F5IHRoZSBjb25zdHJ1Y3RvciB3 aGVuIGdlbmVyYXRpbmcgY29kZS4KKyAgICAgICAgLy8gT3duUHRyPFQ+IG9iamVjdC4gSXQncyBu b3QgZGVmaW5lZCwgc28gaXQgY2FuJ3QgYmUgY2FsbGVkIGV4cGxpY2l0bHkuCisgICAgICAgIC8v IGdjYyB3aWxsIG9wdGltaXplIGF3YXkgdGhlIGNvbnN0cnVjdG9yIHdoZW4gZ2VuZXJhdGluZyBj b2RlLgogICAgICAgICBPd25QdHIoY29uc3QgT3duUHRyPFZhbHVlVHlwZT4mKTsKKyNlbmRpZgog CiAgICAgICAgIH5Pd25QdHIoKSB7IGRlbGV0ZU93bmVkUHRyKG1fcHRyKTsgfQogCg== 120413 2011-12-22 16:56:00 -0800 2012-08-22 15:24:05 -0700 Make PassOwnPtr derive from OwnPtr bug-74625-20111222165559.patch text/plain 15269 enne U3VidmVyc2lvbiBSZXZpc2lvbjogMTAzNTYxCmRpZmYgLS1naXQgYS9Tb3VyY2UvSmF2YVNjcmlw dENvcmUvQ2hhbmdlTG9nIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL0NoYW5nZUxvZwppbmRleCAz YzM2NWIwMzhmOGQ1M2U4ZDc1OGRjZjM2YWVhZjU5ZGVlZjUzYTdmLi4xMjkxOGMyZGQ2YTc1ODhk ZWQxODk4ZDIxOTlhYzA4OGVhZmVjYWRkIDEwMDY0NAotLS0gYS9Tb3VyY2UvSmF2YVNjcmlwdENv cmUvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9DaGFuZ2VMb2cKQEAgLTEs MyArMSwyNCBAQAorMjAxMS0xMi0yMiAgQWRyaWVubmUgV2Fsa2VyICA8ZW5uZUBnb29nbGUuY29t PgorCisgICAgICAgIE1ha2UgT3duUHRyIG5vbmNvcHlhYmxlCisgICAgICAgIGh0dHBzOi8vYnVn cy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD03NDYyNQorCisgICAgICAgIFJldmlld2VkIGJ5 IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIE1ha2UgUGFzc093blB0ciBkZXJpdmUgZnJvbSBP d25QdHIgc28gdGhhdCB0aGUgY29weSBjb25zdHJ1Y3RvciBpcyBub3QKKyAgICAgICAgdXN1YWxs eSByZXF1aXJlZCBmb3IgY29weS1pbml0YWxpemF0aW9uLiBUaGlzIGFsbG93cyB0aGUgY29weQor ICAgICAgICBjb25zdHJ1Y3RvciB0byBiZSBtYWRlIHByaXZhdGUuCisKKyAgICAgICAgQWRkIGEg dmVyc2lvbiB0byBOb25jb3B5YWJsZSBmb3IgdGVtcGxhdGVzIHRoYXQgaGF2ZSBhIHR5cGVuYW1l IHRoYXQKKyAgICAgICAgZGlmZmVycyBmcm9tIHRoZWlyIGNsYXNzbmFtZS4KKworICAgICAgICAq IHd0Zi9Ob25jb3B5YWJsZS5oOgorICAgICAgICAqIHd0Zi9Pd25QdHIuaDoKKyAgICAgICAgKFdU Rjo6T3duUHRyOjpUKToKKyAgICAgICAgKiB3dGYvUGFzc093blB0ci5oOgorICAgICAgICAoV1RG OjpQYXNzT3duUHRyOjpQYXNzT3duUHRyKToKKyAgICAgICAgKFdURjo6OjpsZWFrUHRyKToKKwog MjAxMS0xMi0yMiAgTWFyaXVzeiBHcnplZ29yY3p5ayAgPG1hcml1c3ouZ0BzYW1zdW5nLmNvbT4K IAogICAgICAgICBbRUZMXSBNaXNzaW5nIHBsdWdpbnMgc3VwcG9ydCBmb3IgZWZsIHBvcnQKZGlm ZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZyBiL1NvdXJjZS9XZWJDb3JlL0NoYW5n ZUxvZwppbmRleCBjN2ZlOWQ2MWYxODM1MWIzNTM0ZDI0YWUxZDM5ZTI0ZjBhZmE4Nzc1Li42ODJh Nzg1ZjUxOWMyNTdjODJlNWUxYjRlYjU0ZmViMTE1MTEwNWUwIDEwMDY0NAotLS0gYS9Tb3VyY2Uv V2ViQ29yZS9DaGFuZ2VMb2cKKysrIGIvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCkBAIC0xLDMg KzEsMTkgQEAKKzIwMTEtMTItMjIgIEFkcmllbm5lIFdhbGtlciAgPGVubmVAZ29vZ2xlLmNvbT4K KworICAgICAgICBNYWtlIE93blB0ciBub25jb3B5YWJsZQorICAgICAgICBodHRwczovL2J1Z3Mu d2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9NzQ2MjUKKworICAgICAgICBSZXZpZXdlZCBieSBO T0JPRFkgKE9PUFMhKS4KKworICAgICAgICBDaGFuZ2UgcG9seW1vcnBoaWMgT3duUHRyIGNvcHkt aW5pdGlhbGl6YXRpb24gdG8gZGlyZWN0LWluaXRpYWxpemF0aW9uLgorCisgICAgICAgICogZG9t L0VsZW1lbnQuY3BwOgorICAgICAgICAoV2ViQ29yZTo6RWxlbWVudDo6Y3JlYXRlUmFyZURhdGEp OgorICAgICAgICAqIHBsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL0JpdG1hcFNrUGljdHVyZUNh bnZhc0xheWVyVGV4dHVyZVVwZGF0ZXIuY3BwOgorICAgICAgICAoV2ViQ29yZTo6Qml0bWFwU2tQ aWN0dXJlQ2FudmFzTGF5ZXJUZXh0dXJlVXBkYXRlcjo6VGV4dHVyZTo6cHJlcGFyZVJlY3QpOgor ICAgICAgICAqIHN0b3JhZ2UvSURCTGV2ZWxEQkJhY2tpbmdTdG9yZS5jcHA6CisgICAgICAgIChX ZWJDb3JlOjpJREJMZXZlbERCQmFja2luZ1N0b3JlOjpvcGVuKToKKwogMjAxMS0xMi0yMiAgVnNl dm9sb2QgVmxhc292ICA8dnNldmlrQGNocm9taXVtLm9yZz4KIAogICAgICAgICBXZWIgSW5zcGVj dG9yOiBbUmVncmVzc2lvbl0gTmV0d29yayBpdGVtIHZpZXcgaXMgbm90IGRpc3BsYXllZC4KZGlm ZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vQ2hhbmdlTG9nIGIvU291cmNlL1dlYktp dC9jaHJvbWl1bS9DaGFuZ2VMb2cKaW5kZXggZjQwNzFhMjU3MjExMjhjMGYzZWQ1ZTllMmJkZWI1 YzRjNjJkNTZhMy4uMDdiZDI4M2EwMDM2NjU4ZWFlZDExZGFhMmJiYzYwMmIxYTM1OTE0ZCAxMDA2 NDQKLS0tIGEvU291cmNlL1dlYktpdC9jaHJvbWl1bS9DaGFuZ2VMb2cKKysrIGIvU291cmNlL1dl YktpdC9jaHJvbWl1bS9DaGFuZ2VMb2cKQEAgLTEsMyArMSwxNSBAQAorMjAxMS0xMi0yMiAgQWRy aWVubmUgV2Fsa2VyICA8ZW5uZUBnb29nbGUuY29tPgorCisgICAgICAgIE1ha2UgT3duUHRyIG5v bmNvcHlhYmxlCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9p ZD03NDYyNQorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAg IENoYW5nZSBwb2x5bW9ycGhpYyBPd25QdHIgY29weS1pbml0aWFsaXphdGlvbiB0byBkaXJlY3Qt aW5pdGlhbGl6YXRpb24uCisKKyAgICAgICAgKiB0ZXN0cy9Db21wb3NpdG9yRmFrZUdyYXBoaWNz Q29udGV4dDNELmg6CisgICAgICAgIChXZWJDb3JlOjpjcmVhdGVDb21wb3NpdG9yTW9ja0dyYXBo aWNzQ29udGV4dDNEKToKKwogMjAxMS0xMi0yMSAgUGV0ZXIgS290d2ljeiAgPHBrb3R3aWN6QGdv b2dsZS5jb20+CiAKICAgICAgICAgUGx1bWJzIHJlZnJlc2ggcmF0ZSB0aHJvdWdoIFdlYkxheWVy VHJlZVZpZXc6OlNldHRpbmdzCmRpZmYgLS1naXQgYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd3Rm L05vbmNvcHlhYmxlLmggYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd3RmL05vbmNvcHlhYmxlLmgK aW5kZXggY2M2YmM1NTlhM2MyZjFkNjhhYThkOGRiNGUzOTc1YjVkNmZiYWRkMC4uOGM5OGNlNzRj ZDAxNTE2MzgxYWNhMzZlNGRiMzVlOWNiYzkzZDAxZSAxMDA2NDQKLS0tIGEvU291cmNlL0phdmFT Y3JpcHRDb3JlL3d0Zi9Ob25jb3B5YWJsZS5oCisrKyBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93 dGYvTm9uY29weWFibGUuaApAQCAtMjYsMTkgKzI2LDIyIEBACiAjZW5kaWYKIAogI2lmIF9faGFz X2ZlYXR1cmUoY3h4X2RlbGV0ZWRfZnVuY3Rpb25zKQotICAgICNkZWZpbmUgV1RGX01BS0VfTk9O Q09QWUFCTEUoQ2xhc3NOYW1lKSBcCisgICAgI2RlZmluZSBXVEZfTUFLRV9OT05DT1BZQUJMRV9J TlRFUk5BTChDbGFzc05hbWUsIFR5cGVOYW1lKSBcCiAgICAgICAgIF9QcmFnbWEoImNsYW5nIGRp YWdub3N0aWMgcHVzaCIpIFwKICAgICAgICAgX1ByYWdtYSgiY2xhbmcgZGlhZ25vc3RpYyBpZ25v cmVkIFwiLVd1bmtub3duLXByYWdtYXNcIiIpIFwKICAgICAgICAgX1ByYWdtYSgiY2xhbmcgZGlh Z25vc3RpYyBpZ25vcmVkIFwiLVdjKysweC1leHRlbnNpb25zXCIiKSBcCiAgICAgICAgIHByaXZh dGU6IFwKLSAgICAgICAgICAgIENsYXNzTmFtZShjb25zdCBDbGFzc05hbWUmKSA9IGRlbGV0ZTsg XAotICAgICAgICAgICAgQ2xhc3NOYW1lJiBvcGVyYXRvcj0oY29uc3QgQ2xhc3NOYW1lJikgPSBk ZWxldGU7IFwKKyAgICAgICAgICAgIENsYXNzTmFtZShjb25zdCBUeXBlTmFtZSYpID0gZGVsZXRl OyBcCisgICAgICAgICAgICBDbGFzc05hbWUmIG9wZXJhdG9yPShjb25zdCBUeXBlTmFtZSYpID0g ZGVsZXRlOyBcCiAgICAgICAgIF9QcmFnbWEoImNsYW5nIGRpYWdub3N0aWMgcG9wIikKICNlbHNl Ci0gICAgI2RlZmluZSBXVEZfTUFLRV9OT05DT1BZQUJMRShDbGFzc05hbWUpIFwKKyAgICAjZGVm aW5lIFdURl9NQUtFX05PTkNPUFlBQkxFX0lOVEVSTkFMKENsYXNzTmFtZSwgVHlwZU5hbWUpIFwK ICAgICAgICAgcHJpdmF0ZTogXAotICAgICAgICAgICAgQ2xhc3NOYW1lKGNvbnN0IENsYXNzTmFt ZSYpOyBcCi0gICAgICAgICAgICBDbGFzc05hbWUmIG9wZXJhdG9yPShjb25zdCBDbGFzc05hbWUm KQorICAgICAgICAgICAgQ2xhc3NOYW1lKGNvbnN0IFR5cGVOYW1lJik7IFwKKyAgICAgICAgICAg IENsYXNzTmFtZSYgb3BlcmF0b3I9KGNvbnN0IFR5cGVOYW1lJikKICNlbmRpZgogCisjZGVmaW5l IFdURl9NQUtFX05PTkNPUFlBQkxFKENsYXNzTmFtZSkgV1RGX01BS0VfTk9OQ09QWUFCTEVfSU5U RVJOQUwoQ2xhc3NOYW1lLCBDbGFzc05hbWUpCisjZGVmaW5lIFdURl9NQUtFX05PTkNPUFlBQkxF X1RFTVBMQVRFKENsYXNzTmFtZSwgVHlwZU5hbWUpIFdURl9NQUtFX05PTkNPUFlBQkxFX0lOVEVS TkFMKENsYXNzTmFtZSwgVHlwZU5hbWUpCisKICNlbmRpZiAvLyBXVEZfTm9uY29weWFibGVfaApk aWZmIC0tZ2l0IGEvU291cmNlL0phdmFTY3JpcHRDb3JlL3d0Zi9Pd25QdHIuaCBiL1NvdXJjZS9K YXZhU2NyaXB0Q29yZS93dGYvT3duUHRyLmgKaW5kZXggMDk3OTY3OTY0Y2E2MmYxZTMzYmExMmQ4 NzBhZGJkODM5ZjIzOWRlMy4uY2JkZDVmY2I2MGM1NWVlZjcwZTQxYjZiMWJmNjA0MDdkNmYzNTkw NiAxMDA2NDQKLS0tIGEvU291cmNlL0phdmFTY3JpcHRDb3JlL3d0Zi9Pd25QdHIuaAorKysgYi9T b3VyY2UvSmF2YVNjcmlwdENvcmUvd3RmL093blB0ci5oCkBAIC0yMiw2ICsyMiw3IEBACiAjZGVm aW5lIFdURl9Pd25QdHJfaAogCiAjaW5jbHVkZSAiQXNzZXJ0aW9ucy5oIgorI2luY2x1ZGUgIk5v bmNvcHlhYmxlLmgiCiAjaW5jbHVkZSAiTnVsbFB0ci5oIgogI2luY2x1ZGUgIk93blB0ckNvbW1v bi5oIgogI2luY2x1ZGUgIlR5cGVUcmFpdHMuaCIKQEAgLTM2LDYgKzM3LDcgQEAgbmFtZXNwYWNl IFdURiB7CiAgICAgdGVtcGxhdGU8dHlwZW5hbWUgVD4gUGFzc093blB0cjxUPiBhZG9wdFB0cihU Kik7CiAKICAgICB0ZW1wbGF0ZTx0eXBlbmFtZSBUPiBjbGFzcyBPd25QdHIgeworICAgICAgICBX VEZfTUFLRV9OT05DT1BZQUJMRV9URU1QTEFURShPd25QdHIsIE93blB0cjxUPik7CiAgICAgcHVi bGljOgogICAgICAgICB0eXBlZGVmIHR5cGVuYW1lIFJlbW92ZVBvaW50ZXI8VD46OlR5cGUgVmFs dWVUeXBlOwogICAgICAgICB0eXBlZGVmIFZhbHVlVHlwZSogUHRyVHlwZTsKQEAgLTQ2LDEyICs0 OCw2IEBAIG5hbWVzcGFjZSBXVEYgewogICAgICAgICAvLyBTZWUgY29tbWVudCBpbiBQYXNzT3du UHRyLmggZm9yIHdoeSB0aGlzIHRha2VzIGEgY29uc3QgcmVmZXJlbmNlLgogICAgICAgICB0ZW1w bGF0ZTx0eXBlbmFtZSBVPiBPd25QdHIoY29uc3QgUGFzc093blB0cjxVPiYgbyk7CiAKLSAgICAg ICAgLy8gVGhpcyBjb3B5IGNvbnN0cnVjdG9yIGlzIHVzZWQgaW1wbGljaXRseSBieSBnY2Mgd2hl biBpdCBnZW5lcmF0ZXMKLSAgICAgICAgLy8gdHJhbnNpZW50cyBmb3IgYXNzaWduaW5nIGEgUGFz c093blB0cjxUPiBvYmplY3QgdG8gYSBzdGFjay1hbGxvY2F0ZWQKLSAgICAgICAgLy8gT3duUHRy PFQ+IG9iamVjdC4gSXQgc2hvdWxkIG5ldmVyIGJlIGNhbGxlZCBleHBsaWNpdGx5IGFuZCBnY2MK LSAgICAgICAgLy8gc2hvdWxkIG9wdGltaXplIGF3YXkgdGhlIGNvbnN0cnVjdG9yIHdoZW4gZ2Vu ZXJhdGluZyBjb2RlLgotICAgICAgICBPd25QdHIoY29uc3QgT3duUHRyPFZhbHVlVHlwZT4mKTsK LQogICAgICAgICB+T3duUHRyKCkgeyBkZWxldGVPd25lZFB0cihtX3B0cik7IH0KIAogICAgICAg ICBQdHJUeXBlIGdldCgpIGNvbnN0IHsgcmV0dXJuIG1fcHRyOyB9CkBAIC03Niw4ICs3Miw2IEBA IG5hbWVzcGFjZSBXVEYgewogICAgICAgICB2b2lkIHN3YXAoT3duUHRyJiBvKSB7IHN0ZDo6c3dh cChtX3B0ciwgby5tX3B0cik7IH0KIAogICAgIHByaXZhdGU6Ci0gICAgICAgIE93blB0ciYgb3Bl cmF0b3I9KGNvbnN0IE93blB0cjxUPiYpOwotCiAgICAgICAgIC8vIFdlIHNob3VsZCBuZXZlciBo YXZlIHR3byBPd25QdHJzIGZvciB0aGUgc2FtZSB1bmRlcmx5aW5nIG9iamVjdCAob3RoZXJ3aXNl IHdlJ2xsIGdldAogICAgICAgICAvLyBkb3VibGUtZGVzdHJ1Y3Rpb24pLCBzbyB0aGVzZSBlcXVh bGl0eSBvcGVyYXRvcnMgc2hvdWxkIG5ldmVyIGJlIG5lZWRlZC4KICAgICAgICAgdGVtcGxhdGU8 dHlwZW5hbWUgVT4gYm9vbCBvcGVyYXRvcj09KGNvbnN0IE93blB0cjxVPiYpIHsgQ09NUElMRV9B U1NFUlQoIXNpemVvZihVKiksIE93blB0cnNfc2hvdWxkX25ldmVyX2JlX2VxdWFsKTsgcmV0dXJu IGZhbHNlOyB9CkBAIC04NSw2ICs3OSw5IEBAIG5hbWVzcGFjZSBXVEYgewogICAgICAgICB0ZW1w bGF0ZTx0eXBlbmFtZSBVPiBib29sIG9wZXJhdG9yPT0oY29uc3QgUGFzc093blB0cjxVPiYpIHsg Q09NUElMRV9BU1NFUlQoIXNpemVvZihVKiksIE93blB0cnNfc2hvdWxkX25ldmVyX2JlX2VxdWFs KTsgcmV0dXJuIGZhbHNlOyB9CiAgICAgICAgIHRlbXBsYXRlPHR5cGVuYW1lIFU+IGJvb2wgb3Bl cmF0b3IhPShjb25zdCBQYXNzT3duUHRyPFU+JikgeyBDT01QSUxFX0FTU0VSVCghc2l6ZW9mKFUq KSwgT3duUHRyc19zaG91bGRfbmV2ZXJfYmVfZXF1YWwpOyByZXR1cm4gZmFsc2U7IH0KIAorICAg IHByb3RlY3RlZDoKKyAgICAgICAgZXhwbGljaXQgT3duUHRyPFQ+KFB0clR5cGUgcHRyKSA6IG1f cHRyKHB0cikgeyB9CisKICAgICAgICAgUHRyVHlwZSBtX3B0cjsKICAgICB9OwogCmRpZmYgLS1n aXQgYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd3RmL1Bhc3NPd25QdHIuaCBiL1NvdXJjZS9KYXZh U2NyaXB0Q29yZS93dGYvUGFzc093blB0ci5oCmluZGV4IDI2MmFjM2JmZTYxNTA5OWZiMmE1Y2U5 MTAyZjAwODMwM2Y4M2I5ODQuLjIxMjZiODU2ZTkxODAwOWI2ODdmYzdkMTQzNmEzN2FlMmQ1YThl OWUgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93dGYvUGFzc093blB0ci5oCisr KyBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93dGYvUGFzc093blB0ci5oCkBAIC0yOCw2ICsyOCw3 IEBACiAKICNpbmNsdWRlICJBc3NlcnRpb25zLmgiCiAjaW5jbHVkZSAiTnVsbFB0ci5oIgorI2lu Y2x1ZGUgIk93blB0ci5oIgogI2luY2x1ZGUgIk93blB0ckNvbW1vbi5oIgogI2luY2x1ZGUgIlR5 cGVUcmFpdHMuaCIKIApAQCAtMzUsMjUgKzM2LDIyIEBAIG5hbWVzcGFjZSBXVEYgewogCiAgICAg Ly8gVW5saWtlIG1vc3Qgb2Ygb3VyIHNtYXJ0IHBvaW50ZXJzLCBQYXNzT3duUHRyIGNhbiB0YWtl IGVpdGhlciB0aGUgcG9pbnRlciB0eXBlIG9yIHRoZSBwb2ludGVkLXRvIHR5cGUuCiAKLSAgICB0 ZW1wbGF0ZTx0eXBlbmFtZSBUPiBjbGFzcyBPd25QdHI7CiAgICAgdGVtcGxhdGU8dHlwZW5hbWUg VD4gY2xhc3MgUGFzc093blB0cjsKICAgICB0ZW1wbGF0ZTx0eXBlbmFtZSBUPiBQYXNzT3duUHRy PFQ+IGFkb3B0UHRyKFQqKTsKIAotICAgIHRlbXBsYXRlPHR5cGVuYW1lIFQ+IGNsYXNzIFBhc3NP d25QdHIgeworICAgIHRlbXBsYXRlPHR5cGVuYW1lIFQ+IGNsYXNzIFBhc3NPd25QdHIgOiBwcml2 YXRlIE93blB0cjxUPiB7CiAgICAgcHVibGljOgogICAgICAgICB0eXBlZGVmIHR5cGVuYW1lIFJl bW92ZVBvaW50ZXI8VD46OlR5cGUgVmFsdWVUeXBlOwogICAgICAgICB0eXBlZGVmIFZhbHVlVHlw ZSogUHRyVHlwZTsKIAotICAgICAgICBQYXNzT3duUHRyKCkgOiBtX3B0cigwKSB7IH0KLSAgICAg ICAgUGFzc093blB0cihzdGQ6Om51bGxwdHJfdCkgOiBtX3B0cigwKSB7IH0KKyAgICAgICAgUGFz c093blB0cigpIHsgfQorICAgICAgICBQYXNzT3duUHRyKHN0ZDo6bnVsbHB0cl90KSB7IH0KIAog ICAgICAgICAvLyBJdCBzb21ld2hhdCBicmVha3MgdGhlIHR5cGUgc3lzdGVtIHRvIGFsbG93IHRy YW5zZmVyIG9mIG93bmVyc2hpcCBvdXQgb2YKICAgICAgICAgLy8gYSBjb25zdCBQYXNzT3duUHRy LiBIb3dldmVyLCBpdCBtYWtlcyBpdCBtdWNoIGVhc2llciB0byB3b3JrIHdpdGggUGFzc093blB0 cgogICAgICAgICAvLyB0ZW1wb3JhcmllcywgYW5kIHdlIGRvbid0IGhhdmUgYSBuZWVkIHRvIHVz ZSByZWFsIGNvbnN0IFBhc3NPd25QdHJzIGFueXdheS4KLSAgICAgICAgUGFzc093blB0cihjb25z dCBQYXNzT3duUHRyJiBvKSA6IG1fcHRyKG8ubGVha1B0cigpKSB7IH0KLSAgICAgICAgdGVtcGxh dGU8dHlwZW5hbWUgVT4gUGFzc093blB0cihjb25zdCBQYXNzT3duUHRyPFU+JiBvKSA6IG1fcHRy KG8ubGVha1B0cigpKSB7IH0KLQotICAgICAgICB+UGFzc093blB0cigpIHsgZGVsZXRlT3duZWRQ dHIobV9wdHIpOyB9CisgICAgICAgIFBhc3NPd25QdHIoY29uc3QgUGFzc093blB0ciYgbykgOiBP d25QdHI8VD4obykgeyB9CisgICAgICAgIHRlbXBsYXRlPHR5cGVuYW1lIFU+IFBhc3NPd25QdHIo Y29uc3QgUGFzc093blB0cjxVPiYgbykgOiBPd25QdHI8VD4obykgeyB9CiAKICAgICAgICAgUHRy VHlwZSBnZXQoKSBjb25zdCB7IHJldHVybiBtX3B0cjsgfQogCkBAIC02NSwxNSArNjMsMTQgQEAg bmFtZXNwYWNlIFdURiB7CiAgICAgICAgIGJvb2wgb3BlcmF0b3IhKCkgY29uc3QgeyByZXR1cm4g IW1fcHRyOyB9CiAKICAgICAgICAgLy8gVGhpcyBjb252ZXJzaW9uIG9wZXJhdG9yIGFsbG93cyBp bXBsaWNpdCBjb252ZXJzaW9uIHRvIGJvb2wgYnV0IG5vdCB0byBvdGhlciBpbnRlZ2VyIHR5cGVz LgotICAgICAgICB0eXBlZGVmIFB0clR5cGUgUGFzc093blB0cjo6KlVuc3BlY2lmaWVkQm9vbFR5 cGU7Ci0gICAgICAgIG9wZXJhdG9yIFVuc3BlY2lmaWVkQm9vbFR5cGUoKSBjb25zdCB7IHJldHVy biBtX3B0ciA/ICZQYXNzT3duUHRyOjptX3B0ciA6IDA7IH0KKyAgICAgICAgdXNpbmcgT3duUHRy PFQ+OjpvcGVyYXRvciBQdHJUeXBlIE93blB0cjxUPjo6KjsKIAogICAgICAgICBQYXNzT3duUHRy JiBvcGVyYXRvcj0oY29uc3QgUGFzc093blB0ciYpIHsgQ09NUElMRV9BU1NFUlQoIXNpemVvZihU KiksIFBhc3NPd25QdHJfc2hvdWxkX25ldmVyX2JlX2Fzc2lnbmVkX3RvKTsgcmV0dXJuICp0aGlz OyB9CiAKICAgICAgICAgdGVtcGxhdGU8dHlwZW5hbWUgVT4gZnJpZW5kIFBhc3NPd25QdHI8VT4g YWRvcHRQdHIoVSopOwogCiAgICAgcHJpdmF0ZToKLSAgICAgICAgZXhwbGljaXQgUGFzc093blB0 cihQdHJUeXBlIHB0cikgOiBtX3B0cihwdHIpIHsgfQorICAgICAgICBleHBsaWNpdCBQYXNzT3du UHRyKFB0clR5cGUgcHRyKSA6IE93blB0cjxUPihwdHIpIHsgfQogCiAgICAgICAgIC8vIFdlIHNo b3VsZCBuZXZlciBoYXZlIHR3byBPd25QdHJzIGZvciB0aGUgc2FtZSB1bmRlcmx5aW5nIG9iamVj dCAob3RoZXJ3aXNlIHdlJ2xsIGdldAogICAgICAgICAvLyBkb3VibGUtZGVzdHJ1Y3Rpb24pLCBz byB0aGVzZSBlcXVhbGl0eSBvcGVyYXRvcnMgc2hvdWxkIG5ldmVyIGJlIG5lZWRlZC4KQEAgLTgy LDE0ICs3OSwxMyBAQCBuYW1lc3BhY2UgV1RGIHsKICAgICAgICAgdGVtcGxhdGU8dHlwZW5hbWUg VT4gYm9vbCBvcGVyYXRvcj09KGNvbnN0IE93blB0cjxVPiYpIHsgQ09NUElMRV9BU1NFUlQoIXNp emVvZihVKiksIE93blB0cnNfc2hvdWxkX25ldmVyX2JlX2VxdWFsKTsgcmV0dXJuIGZhbHNlOyB9 CiAgICAgICAgIHRlbXBsYXRlPHR5cGVuYW1lIFU+IGJvb2wgb3BlcmF0b3IhPShjb25zdCBPd25Q dHI8VT4mKSB7IENPTVBJTEVfQVNTRVJUKCFzaXplb2YoVSopLCBPd25QdHJzX3Nob3VsZF9uZXZl cl9iZV9lcXVhbCk7IHJldHVybiBmYWxzZTsgfQogCi0gICAgICAgIG11dGFibGUgUHRyVHlwZSBt X3B0cjsKKyAgICAgICAgdXNpbmcgT3duUHRyPFQ+OjptX3B0cjsKICAgICB9OwogCiAgICAgdGVt cGxhdGU8dHlwZW5hbWUgVD4gaW5saW5lIHR5cGVuYW1lIFBhc3NPd25QdHI8VD46OlB0clR5cGUg UGFzc093blB0cjxUPjo6bGVha1B0cigpIGNvbnN0CiAgICAgewotICAgICAgICBQdHJUeXBlIHB0 ciA9IG1fcHRyOwotICAgICAgICBtX3B0ciA9IDA7Ci0gICAgICAgIHJldHVybiBwdHI7CisgICAg ICAgIC8vIFNlZSBjb21tZW50IGFib3ZlIGFib3V0IGNvbnN0IGNvcnJlY3RuZXNzIGFuZCBQYXNz T3duUHRycy4KKyAgICAgICAgcmV0dXJuIGNvbnN0X2Nhc3Q8UGFzc093blB0cjxUPio+KHRoaXMp LT5Pd25QdHI8VD46OmxlYWtQdHIoKTsKICAgICB9CiAKICAgICB0ZW1wbGF0ZTx0eXBlbmFtZSBU LCB0eXBlbmFtZSBVPiBpbmxpbmUgYm9vbCBvcGVyYXRvcj09KGNvbnN0IFBhc3NPd25QdHI8VD4m IGEsIGNvbnN0IFBhc3NPd25QdHI8VT4mIGIpIApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUv ZG9tL0VsZW1lbnQuY3BwIGIvU291cmNlL1dlYkNvcmUvZG9tL0VsZW1lbnQuY3BwCmluZGV4IDI1 MDUzMWZhMjQ1YWQxMDQ2ZmI3NWJmMTJjY2NmYmU2YjUwOWYyN2EuLjJkMDA1YThmNDUwZjUyYjYw MTBlYjJiOGM0NWJlY2YyZGQ4ZjBlNDcgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL2RvbS9F bGVtZW50LmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9kb20vRWxlbWVudC5jcHAKQEAgLTEzNiw3 ICsxMzYsNyBAQCBpbmxpbmUgRWxlbWVudFJhcmVEYXRhKiBFbGVtZW50OjplbnN1cmVSYXJlRGF0 YSgpCiAgICAgCiBPd25QdHI8Tm9kZVJhcmVEYXRhPiBFbGVtZW50OjpjcmVhdGVSYXJlRGF0YSgp CiB7Ci0gICAgcmV0dXJuIGFkb3B0UHRyKG5ldyBFbGVtZW50UmFyZURhdGEpOworICAgIHJldHVy biBQYXNzT3duUHRyPE5vZGVSYXJlRGF0YT4oYWRvcHRQdHIobmV3IEVsZW1lbnRSYXJlRGF0YSkp OwogfQogCiBERUZJTkVfVklSVFVBTF9BVFRSSUJVVEVfRVZFTlRfTElTVEVORVIoRWxlbWVudCwg Ymx1cik7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJv bWl1bS9CaXRtYXBTa1BpY3R1cmVDYW52YXNMYXllclRleHR1cmVVcGRhdGVyLmNwcCBiL1NvdXJj ZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL0JpdG1hcFNrUGljdHVyZUNhbnZh c0xheWVyVGV4dHVyZVVwZGF0ZXIuY3BwCmluZGV4IDgyMjFkZDJlNTIxYmQ2M2ZlMGU2ZjBmOWQ2 MjI0ZTM4ZGZiMzQyOTguLjk3ZWRlNjAzMzIwNTYxNDdjYmE3ZmE0ODU3OGFhYTBiMTdlYTI1M2Qg MTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL0Jp dG1hcFNrUGljdHVyZUNhbnZhc0xheWVyVGV4dHVyZVVwZGF0ZXIuY3BwCisrKyBiL1NvdXJjZS9X ZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL0JpdG1hcFNrUGljdHVyZUNhbnZhc0xh eWVyVGV4dHVyZVVwZGF0ZXIuY3BwCkBAIC00Nyw3ICs0Nyw3IEBAIHZvaWQgQml0bWFwU2tQaWN0 dXJlQ2FudmFzTGF5ZXJUZXh0dXJlVXBkYXRlcjo6VGV4dHVyZTo6cHJlcGFyZVJlY3QoY29uc3Qg SW50UmVjCiB7CiAgICAgc2l6ZV90IGJ1ZmZlclNpemUgPSBUZXh0dXJlTWFuYWdlcjo6bWVtb3J5 VXNlQnl0ZXMoc291cmNlUmVjdC5zaXplKCksIHRleHR1cmUoKS0+Zm9ybWF0KCkpOwogICAgIG1f cGl4ZWxEYXRhID0gYWRvcHRBcnJheVB0cihuZXcgdWludDhfdFtidWZmZXJTaXplXSk7Ci0gICAg T3duUHRyPFNrQ2FudmFzPiBjYW52YXMgPSBhZG9wdFB0cihuZXcgc2tpYTo6UGxhdGZvcm1DYW52 YXMoc291cmNlUmVjdC53aWR0aCgpLCBzb3VyY2VSZWN0LmhlaWdodCgpLCBmYWxzZSwgbV9waXhl bERhdGEuZ2V0KCkpKTsKKyAgICBPd25QdHI8U2tDYW52YXM+IGNhbnZhcyhhZG9wdFB0cihuZXcg c2tpYTo6UGxhdGZvcm1DYW52YXMoc291cmNlUmVjdC53aWR0aCgpLCBzb3VyY2VSZWN0LmhlaWdo dCgpLCBmYWxzZSwgbV9waXhlbERhdGEuZ2V0KCkpKSk7CiAgICAgdGV4dHVyZVVwZGF0ZXIoKS0+ cGFpbnRDb250ZW50c1JlY3QoY2FudmFzLmdldCgpLCBzb3VyY2VSZWN0KTsKIH0KIApkaWZmIC0t Z2l0IGEvU291cmNlL1dlYkNvcmUvc3RvcmFnZS9JREJMZXZlbERCQmFja2luZ1N0b3JlLmNwcCBi L1NvdXJjZS9XZWJDb3JlL3N0b3JhZ2UvSURCTGV2ZWxEQkJhY2tpbmdTdG9yZS5jcHAKaW5kZXgg OWM0ZDZmMDc0Yjc3YWE5NjI0NjY4YzBkNTU2OThkMDRiMzE5OWZmNy4uMWMxZTczODg1ODRiM2U0 NTkwYzlmMjRmMjc3YmNmODVlYWU3MzUwNSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvc3Rv cmFnZS9JREJMZXZlbERCQmFja2luZ1N0b3JlLmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9zdG9y YWdlL0lEQkxldmVsREJCYWNraW5nU3RvcmUuY3BwCkBAIC0xMzYsNyArMTM2LDcgQEAgUGFzc1Jl ZlB0cjxJREJCYWNraW5nU3RvcmU+IElEQkxldmVsREJCYWNraW5nU3RvcmU6Om9wZW4oU2VjdXJp dHlPcmlnaW4qIHNlY3VyaXQKIHsKICAgICBTdHJpbmcgcGF0aEJhc2UgPSBwYXRoQmFzZUFyZzsK IAotICAgIE93blB0cjxMZXZlbERCQ29tcGFyYXRvcj4gY29tcGFyYXRvciA9IGFkb3B0UHRyKG5l dyBDb21wYXJhdG9yKCkpOworICAgIE93blB0cjxMZXZlbERCQ29tcGFyYXRvcj4gY29tcGFyYXRv cihhZG9wdFB0cihuZXcgQ29tcGFyYXRvcigpKSk7CiAgICAgT3duUHRyPExldmVsREJEYXRhYmFz ZT4gZGI7CiAKICAgICBpZiAocGF0aEJhc2UuaXNFbXB0eSgpKQpkaWZmIC0tZ2l0IGEvU291cmNl L1dlYktpdC9jaHJvbWl1bS90ZXN0cy9Db21wb3NpdG9yRmFrZUdyYXBoaWNzQ29udGV4dDNELmgg Yi9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3Rlc3RzL0NvbXBvc2l0b3JGYWtlR3JhcGhpY3NDb250 ZXh0M0QuaAppbmRleCAxZjA4OTczNDEzM2Q3MzgwYmJmYzdhZjg0NTIxODM0OGZhZDM1OWE4Li5j MDJhZTRhZmQxNTlkYTdiMjcxMDc2YTRlMTlmNTdhMWRmMmNkM2QwIDEwMDY0NAotLS0gYS9Tb3Vy Y2UvV2ViS2l0L2Nocm9taXVtL3Rlc3RzL0NvbXBvc2l0b3JGYWtlR3JhcGhpY3NDb250ZXh0M0Qu aAorKysgYi9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3Rlc3RzL0NvbXBvc2l0b3JGYWtlR3JhcGhp Y3NDb250ZXh0M0QuaApAQCAtMzYsNyArMzYsNyBAQCBzdGF0aWMgUGFzc1JlZlB0cjxHcmFwaGlj c0NvbnRleHQzRD4gY3JlYXRlQ29tcG9zaXRvck1vY2tHcmFwaGljc0NvbnRleHQzRChHcmFwaAog ICAgIFdlYktpdDo6V2ViR3JhcGhpY3NDb250ZXh0M0Q6OkF0dHJpYnV0ZXMgd2ViQXR0cnM7CiAg ICAgd2ViQXR0cnMuYWxwaGEgPSBhdHRycy5hbHBoYTsKIAotICAgIE93blB0cjxXZWJLaXQ6Oldl YkdyYXBoaWNzQ29udGV4dDNEPiB3ZWJDb250ZXh0ID0gV2ViS2l0OjpDb21wb3NpdG9yRmFrZVdl YkdyYXBoaWNzQ29udGV4dDNEOjpjcmVhdGUod2ViQXR0cnMpOworICAgIE93blB0cjxXZWJLaXQ6 OldlYkdyYXBoaWNzQ29udGV4dDNEPiB3ZWJDb250ZXh0KFdlYktpdDo6Q29tcG9zaXRvckZha2VX ZWJHcmFwaGljc0NvbnRleHQzRDo6Y3JlYXRlKHdlYkF0dHJzKSk7CiAgICAgcmV0dXJuIEdyYXBo aWNzQ29udGV4dDNEUHJpdmF0ZTo6Y3JlYXRlR3JhcGhpY3NDb250ZXh0RnJvbVdlYkNvbnRleHQo CiAgICAgICAgIHdlYkNvbnRleHQucmVsZWFzZSgpLCBhdHRycywgMCwKICAgICAgICAgR3JhcGhp Y3NDb250ZXh0M0Q6OlJlbmRlckRpcmVjdGx5VG9Ib3N0V2luZG93LApkaWZmIC0tZ2l0IGEvVG9v bHMvQ2hhbmdlTG9nIGIvVG9vbHMvQ2hhbmdlTG9nCmluZGV4IDlhYzA5OGMzY2ViOTRhNGFkOTUy MDk1YWJlZjg5OGQzNmIxOWU0NzcuLjE4MDMwMjI3MTExNWYyMjBiNjZjNTU3MmYyYWEzMjQ4ODFi NmE0MmUgMTAwNjQ0Ci0tLSBhL1Rvb2xzL0NoYW5nZUxvZworKysgYi9Ub29scy9DaGFuZ2VMb2cK QEAgLTEsMyArMSwxNiBAQAorMjAxMS0xMi0yMiAgQWRyaWVubmUgV2Fsa2VyICA8ZW5uZUBnb29n bGUuY29tPgorCisgICAgICAgIE1ha2UgT3duUHRyIG5vbmNvcHlhYmxlCisgICAgICAgIGh0dHBz Oi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD03NDYyNQorCisgICAgICAgIFJldmll d2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIENoYW5nZSBwb2x5bW9ycGhpYyBPd25Q dHIgY29weS1pbml0aWFsaXphdGlvbiB0byBkaXJlY3QtaW5pdGlhbGl6YXRpb24uCisKKyAgICAg ICAgKiBEdW1wUmVuZGVyVHJlZS9jaHJvbWl1bS9DcHBCb3VuZENsYXNzLmg6CisgICAgICAgIChD cHBCb3VuZENsYXNzOjpiaW5kUHJvcGVydHkpOgorICAgICAgICAoQ3BwQm91bmRDbGFzczo6Ymlu ZEZhbGxiYWNrTWV0aG9kKToKKwogMjAxMS0xMi0yMiAgQWRhbSBSb2JlbiAgPGFyb2JlbkBhcHBs ZS5jb20+CiAKICAgICAgICAgU25vdyBMZW9wYXJkIHRlc3QgZml4CmRpZmYgLS1naXQgYS9Ub29s cy9EdW1wUmVuZGVyVHJlZS9jaHJvbWl1bS9DcHBCb3VuZENsYXNzLmggYi9Ub29scy9EdW1wUmVu ZGVyVHJlZS9jaHJvbWl1bS9DcHBCb3VuZENsYXNzLmgKaW5kZXggNGZiNTM2MWUxYmM4M2RhMGM2 MzVkNDdhMTNmM2E0YTQzZjZiOTQ1Yi4uMTg1ZWIxZGM0MDVlOGI1YzdmYTdmMzZhOGY3MzViMmZi MTc4NzEzYyAxMDA2NDQKLS0tIGEvVG9vbHMvRHVtcFJlbmRlclRyZWUvY2hyb21pdW0vQ3BwQm91 bmRDbGFzcy5oCisrKyBiL1Rvb2xzL0R1bXBSZW5kZXJUcmVlL2Nocm9taXVtL0NwcEJvdW5kQ2xh c3MuaApAQCAtMTcwLDcgKzE3MCw3IEBAIHByb3RlY3RlZDoKICAgICB0ZW1wbGF0ZTxjbGFzcyBU PgogICAgIHZvaWQgYmluZFByb3BlcnR5KGNvbnN0IHN0ZDo6c3RyaW5nJiBuYW1lLCB2b2lkIChU OjoqbWV0aG9kKShDcHBWYXJpYW50KikpCiAgICAgewotICAgICAgICBPd25QdHI8R2V0dGVyQ2Fs bGJhY2s+IGNhbGxiYWNrID0gYWRvcHRQdHIobmV3IE1lbWJlckdldHRlckNhbGxiYWNrPFQ+KHN0 YXRpY19jYXN0PFQqPih0aGlzKSwgbWV0aG9kKSk7CisgICAgICAgIE93blB0cjxHZXR0ZXJDYWxs YmFjaz4gY2FsbGJhY2soYWRvcHRQdHIobmV3IE1lbWJlckdldHRlckNhbGxiYWNrPFQ+KHN0YXRp Y19jYXN0PFQqPih0aGlzKSwgbWV0aG9kKSkpOwogICAgICAgICBiaW5kR2V0dGVyQ2FsbGJhY2so bmFtZSwgY2FsbGJhY2sucmVsZWFzZSgpKTsKICAgICB9CiAKQEAgLTIwNCw3ICsyMDQsNyBAQCBw cm90ZWN0ZWQ6CiAgICAgdm9pZCBiaW5kRmFsbGJhY2tNZXRob2Qodm9pZCAoVDo6Km1ldGhvZCko Y29uc3QgQ3BwQXJndW1lbnRMaXN0JiwgQ3BwVmFyaWFudCopKQogICAgIHsKICAgICAgICAgaWYg KG1ldGhvZCkgewotICAgICAgICAgICAgT3duUHRyPENhbGxiYWNrPiBjYWxsYmFjayA9IGFkb3B0 UHRyKG5ldyBNZW1iZXJDYWxsYmFjazxUPihzdGF0aWNfY2FzdDxUKj4odGhpcyksIG1ldGhvZCkp OworICAgICAgICAgICAgT3duUHRyPENhbGxiYWNrPiBjYWxsYmFjayhhZG9wdFB0cihuZXcgTWVt YmVyQ2FsbGJhY2s8VD4oc3RhdGljX2Nhc3Q8VCo+KHRoaXMpLCBtZXRob2QpKSk7CiAgICAgICAg ICAgICBiaW5kRmFsbGJhY2tDYWxsYmFjayhjYWxsYmFjay5yZWxlYXNlKCkpOwogICAgICAgICB9 IGVsc2UKICAgICAgICAgICAgIGJpbmRGYWxsYmFja0NhbGxiYWNrKG51bGxwdHIpOwo= 121166 2012-01-04 15:04:13 -0800 2012-08-22 15:24:09 -0700 Patch bug-74625-20120104150449.patch text/plain 4031 andersca U3VidmVyc2lvbiBSZXZpc2lvbjogMTA0MDY2CmRpZmYgLS1naXQgYS9Tb3VyY2UvSmF2YVNjcmlw dENvcmUvQ2hhbmdlTG9nIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL0NoYW5nZUxvZwppbmRleCA0 YWRiMjZhMDkzZjc5YTVmOWZmODNjZDQxNTc2Y2IzNzg5YjU4Mzg0Li5iM2NiZjM0ZmI0NWM4Yjc4 NWQzYWQ5MmYwYTNkN2I2YWU3Njg5OTkzIDEwMDY0NAotLS0gYS9Tb3VyY2UvSmF2YVNjcmlwdENv cmUvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9DaGFuZ2VMb2cKQEAgLTEs MyArMSwyMyBAQAorMjAxMi0wMS0wNCAgQW5kZXJzIENhcmxzc29uICA8YW5kZXJzY2FAYXBwbGUu Y29tPgorCisgICAgICAgIENsYW5nIGRvZXNuJ3Qgb3B0aW1pemUgYXdheSB1bmRlZmluZWQgT3du UHRyIGNvcHkgY29uc3RydWN0b3IKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hv d19idWcuY2dpP2lkPTc0NjI1CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISku CisKKyAgICAgICAgQWRkIG1vdmUgY29uc3RydWN0b3JzIGFuZCBtb3ZlIGFzc2lnbm1lbnQgb3Bl cmF0b3JzIHRvIE93blB0ci4gVGhpcyBzaG91bGQgbWFrZSBjbGFuZworICAgICAgICBjaG9vc2Ug dGhlIG1vdmUgY29uc3RydWN0b3Igb3ZlciB0aGUgKHVuZGVmaW5lZCkgY29weSBjb25zdHJ1Y3Rv ciB3aGVuIG90aGVyIGNvbXBpbGVycworICAgICAgICAoc3VjaCBhcyBnY2MpIHdvdWxkIG9wdGlt aXplIGF3YXkgdGhlIGNvcHkgY29uc3RydWN0b3IuCisKKyAgICAgICAgKiB3dGYvQ29tcGlsZXIu aDoKKyAgICAgICAgVXNlIF9faGFzX2V4dGVuc2lvbiBpbnN0ZWFkIG9mIF9faGFzX2ZlYXR1cmUg Zm9yIHRoZSBDKysxMSBmZWF0dXJlcyB3ZSBrbm93IGFyZSBhdmFpbGFibGUKKyAgICAgICAgYXMg ZXh0ZW5zaW9ucyBpbiBDKys5OC4KKworICAgICAgICAqIHd0Zi9Pd25QdHIuaDoKKyAgICAgICAg KFdURjo6OjpPd25QdHIpOgorICAgICAgICAoV1RGOjo6Om9wZXJhdG9yKToKKyAgICAgICAgQWRk IG1vdmUgY29uc3RydWN0b3JzIGFuZCBtb3ZlIGFzc2lnbm1lbnQgb3BlcmF0b3JzLgorCiAyMDEy LTAxLTA0ICBUb3IgQXJuZSBWZXN0YsO4ICA8dG9yLmFybmUudmVzdGJvQG5va2lhLmNvbT4KIAog ICAgICAgICBbUXRdIEludHJvZHVjZSBuZXcgcW1ha2UgdmFyaWFibGUgJ1dFQktJVCcgZm9yIHNp Z25hbGluZyBkZXBlbmRlbmNpZXMKZGlmZiAtLWdpdCBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93 dGYvQ29tcGlsZXIuaCBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93dGYvQ29tcGlsZXIuaAppbmRl eCA5M2QzMzE2YmZiYmNhMWY5ZTcwZWIwYWMyMDRmOWRjODkwOGRhMGVlLi5kNzg4YmJjODZkOWQ1 NWE4YjljYzBkZjM0NzY0YjI2YjU5ZjhhOTQyIDEwMDY0NAotLS0gYS9Tb3VyY2UvSmF2YVNjcmlw dENvcmUvd3RmL0NvbXBpbGVyLmgKKysrIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL3d0Zi9Db21w aWxlci5oCkBAIC00MywxMiArNDMsMTEgQEAKICNlbmRpZgogCiAvKiBTcGVjaWZpYyBjb21waWxl ciBmZWF0dXJlcyAqLwotI2RlZmluZSBXVEZfQ09NUElMRVJfU1VQUE9SVFNfQ1hYX1ZBUklBRElD X1RFTVBMQVRFUyBfX2hhc19mZWF0dXJlKGN4eF92YXJpYWRpY190ZW1wbGF0ZXMpCi0jZGVmaW5l IFdURl9DT01QSUxFUl9TVVBQT1JUU19DWFhfUlZBTFVFX1JFRkVSRU5DRVMgX19oYXNfZmVhdHVy ZShjeHhfcnZhbHVlX3JlZmVyZW5jZXMpCi0jZGVmaW5lIFdURl9DT01QSUxFUl9TVVBQT1JUU19D WFhfREVMRVRFRF9GVU5DVElPTlMgX19oYXNfZmVhdHVyZShjeHhfZGVsZXRlZF9mdW5jdGlvbnMp CisjZGVmaW5lIFdURl9DT01QSUxFUl9TVVBQT1JUU19DWFhfVkFSSUFESUNfVEVNUExBVEVTIF9f aGFzX2V4dGVuc2lvbihjeHhfdmFyaWFkaWNfdGVtcGxhdGVzKQorI2RlZmluZSBXVEZfQ09NUElM RVJfU1VQUE9SVFNfQ1hYX1JWQUxVRV9SRUZFUkVOQ0VTIF9faGFzX2V4dGVuc2lvbihjeHhfcnZh bHVlX3JlZmVyZW5jZXMpCisjZGVmaW5lIFdURl9DT01QSUxFUl9TVVBQT1JUU19DWFhfREVMRVRF RF9GVU5DVElPTlMgX19oYXNfZXh0ZW5zaW9uKGN4eF9kZWxldGVkX2Z1bmN0aW9ucykKICNkZWZp bmUgV1RGX0NPTVBJTEVSX1NVUFBPUlRTX0NYWF9OVUxMUFRSIF9faGFzX2ZlYXR1cmUoY3h4X251 bGxwdHIpCiAjZGVmaW5lIFdURl9DT01QSUxFUl9TVVBQT1JUU19CTE9DS1MgX19oYXNfZmVhdHVy ZShibG9ja3MpCi0KICNlbmRpZgogCiAvKiBDT01QSUxFUihNU1ZDKSAtIE1pY3Jvc29mdCBWaXN1 YWwgQysrICovCmRpZmYgLS1naXQgYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd3RmL093blB0ci5o IGIvU291cmNlL0phdmFTY3JpcHRDb3JlL3d0Zi9Pd25QdHIuaAppbmRleCAwOTc5Njc5NjRjYTYy ZjFlMzNiYTEyZDg3MGFkYmQ4MzlmMjM5ZGUzLi5jNjQwNzhlMTlmNmQyNTlhZGE0YjJjYzcwODg3 Y2M2N2Q4ZTFkY2RhIDEwMDY0NAotLS0gYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd3RmL093blB0 ci5oCisrKyBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93dGYvT3duUHRyLmgKQEAgLTczLDYgKzcz LDE0IEBAIG5hbWVzcGFjZSBXVEYgewogICAgICAgICBPd25QdHImIG9wZXJhdG9yPShzdGQ6Om51 bGxwdHJfdCkgeyBjbGVhcigpOyByZXR1cm4gKnRoaXM7IH0KICAgICAgICAgdGVtcGxhdGU8dHlw ZW5hbWUgVT4gT3duUHRyJiBvcGVyYXRvcj0oY29uc3QgUGFzc093blB0cjxVPiYpOwogCisjaWYg Q09NUElMRVJfU1VQUE9SVFMoQ1hYX1JWQUxVRV9SRUZFUkVOQ0VTKQorICAgICAgICBPd25QdHIo T3duUHRyJiYpOworICAgICAgICB0ZW1wbGF0ZTx0eXBlbmFtZSBVPiBPd25QdHIoT3duUHRyPFU+ JiYpOworCisgICAgICAgIE93blB0ciYgb3BlcmF0b3I9KE93blB0ciYmKTsKKyAgICAgICAgdGVt cGxhdGU8dHlwZW5hbWUgVT4gT3duUHRyJiBvcGVyYXRvcj0oT3duUHRyPFU+JiYpOworI2VuZGlm CisKICAgICAgICAgdm9pZCBzd2FwKE93blB0ciYgbykgeyBzdGQ6OnN3YXAobV9wdHIsIG8ubV9w dHIpOyB9CiAKICAgICBwcml2YXRlOgpAQCAtMTMyLDYgKzE0MCwzOCBAQCBuYW1lc3BhY2UgV1RG IHsKICAgICAgICAgcmV0dXJuICp0aGlzOwogICAgIH0KIAorI2lmIENPTVBJTEVSX1NVUFBPUlRT KENYWF9SVkFMVUVfUkVGRVJFTkNFUykKKyAgICB0ZW1wbGF0ZTx0eXBlbmFtZSBUPiBpbmxpbmUg T3duUHRyPFQ+OjpPd25QdHIoT3duUHRyPFQ+JiYgbykKKyAgICAgICAgOiBtX3B0cihvLmxlYWtQ dHIoKSkKKyAgICB7CisgICAgfQorCisgICAgdGVtcGxhdGU8dHlwZW5hbWUgVD4gdGVtcGxhdGU8 dHlwZW5hbWUgVT4gaW5saW5lIE93blB0cjxUPjo6T3duUHRyKE93blB0cjxVPiYmIG8pCisgICAg ICAgIDogbV9wdHIoby5sZWFrUHRyKCkpCisgICAgeworICAgIH0KKworICAgIHRlbXBsYXRlPHR5 cGVuYW1lIFQ+IGlubGluZSBPd25QdHI8VD4mIE93blB0cjxUPjo6b3BlcmF0b3I9KE93blB0cjxU PiYmIG8pCisgICAgeworICAgICAgICBQdHJUeXBlIHB0ciA9IG1fcHRyOworICAgICAgICBtX3B0 ciA9IG8ubGVha1B0cigpOworICAgICAgICBBU1NFUlQoIXB0ciB8fCBtX3B0ciAhPSBwdHIpOwor ICAgICAgICBkZWxldGVPd25lZFB0cihwdHIpOworCisgICAgICAgIHJldHVybiAqdGhpczsKKyAg ICB9CisKKyAgICB0ZW1wbGF0ZTx0eXBlbmFtZSBUPiB0ZW1wbGF0ZTx0eXBlbmFtZSBVPiBpbmxp bmUgT3duUHRyPFQ+JiBPd25QdHI8VD46Om9wZXJhdG9yPShPd25QdHI8VT4mJiBvKQorICAgIHsK KyAgICAgICAgUHRyVHlwZSBwdHIgPSBtX3B0cjsKKyAgICAgICAgbV9wdHIgPSBvLmxlYWtQdHIo KTsKKyAgICAgICAgQVNTRVJUKCFwdHIgfHwgbV9wdHIgIT0gcHRyKTsKKyAgICAgICAgZGVsZXRl T3duZWRQdHIocHRyKTsKKworICAgICAgICByZXR1cm4gKnRoaXM7CisgICAgfQorI2VuZGlmCisK ICAgICB0ZW1wbGF0ZTx0eXBlbmFtZSBUPiBpbmxpbmUgdm9pZCBzd2FwKE93blB0cjxUPiYgYSwg T3duUHRyPFQ+JiBiKQogICAgIHsKICAgICAgICAgYS5zd2FwKGIpOwo= 160019 2012-08-22 15:24:13 -0700 2012-08-28 10:40:30 -0700 andersca's patch + #if'd out copy constructor bug-74625-20120822152411.patch text/plain 3925 enne U3VidmVyc2lvbiBSZXZpc2lvbjogMTI2MzIzCmRpZmYgLS1naXQgYS9Tb3VyY2UvV1RGL0NoYW5n ZUxvZyBiL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCmluZGV4IDEyMDZiZWUzMTgwY2M0ZWZhODlhMmUy NzEzNDhiOWZiZTg5NjVkMTcuLjQyYTVmMjc0NDYwOWJlYzg4ZmQwYTdkZWEyNWEzOTlkMDQ0YzU4 NDMgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9XVEYvQ2hh bmdlTG9nCkBAIC0xLDMgKzEsMzIgQEAKKzIwMTItMDgtMjIgIEFkcmllbm5lIFdhbGtlciAgPGVu bmVAZ29vZ2xlLmNvbT4KKworICAgICAgICBDbGFuZyBkb2Vzbid0IG9wdGltaXplIGF3YXkgdW5k ZWZpbmVkIE93blB0ciBjb3B5IGNvbnN0cnVjdG9yCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJr aXQub3JnL3Nob3dfYnVnLmNnaT9pZD03NDYyNQorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9E WSAoT09QUyEpLgorCisgICAgICAgIE9yaWdpbmFsIHBhdGNoIGJ5IEFuZGVycyBDYXJsc3Nvbiwg d2l0aCBhIG1pbm9yIGVkaXQuCisKKyAgICAgICAgVGhlIHB1YmxpY2x5IGRlY2xhcmVkLWJ1dC1u b3QtZGVmaW5lZCBjb3B5IGNvbnN0cnVjdG9yIGlzIGEgY29tcGlsZXIKKyAgICAgICAgb3B0aW1p emF0aW9uLWRlcGVuZGVudCBsYW5kbWluZS4gQ2xhbmcgb2Z0ZW4gZmFpbHMgdG8gb3B0aW1pemUg dGhlIHVzZQorICAgICAgICBvZiB0aGlzIGZ1bmN0aW9uIG91dCwgbGVhZGluZyB0byBpbnRlcm5h bCBsaW5rYWdlIGVycm9ycyBmb3IgdGhlIG1pc3NpbmcKKyAgICAgICAgZGVmaW5pdGlvbi4gZ2Nj IGRvZXNuJ3QgaGF2ZSB0aGlzIHByb2JsZW0gYW5kIG9wdGltaXplcyB0aGF0IGZ1bmN0aW9uCisg ICAgICAgIG91dCwgbGVhZGluZyB0byBjb2RlIHRoYXQgaW5jb25zaXN0ZW50bHkgZmFpbHMgdG8g bGluayBhY3Jvc3MgcGxhdGZvcm1zLgorCisgICAgICAgIEFzIGEgcGFydGlhbCBmaXggZm9yIHRo aXMgcHJvYmxlbSwgb24gYW55IGNvbXBpbGVyIHRoYXQgc3VwcG9ydHMgQysrMTEKKyAgICAgICAg bW92ZSBzZW1hbnRpY3MsIHJlcGxhY2UgdGhlIGJvZ3VzIGNvcHkgY29uc3RydWN0b3Igd2l0aCB0 aGUgbW92ZQorICAgICAgICBjb25zdHJ1Y3RvcnMuICBJbiB0aGUgZnV0dXJlLCBpZiBhbGwgY29t cGlsZXJzIHN1cHBvcnQgdGhpcywgdGhlbiB0aGUKKyAgICAgICAgY29weSBjb25zdHJ1Y3RvciBj YW4gYmUgcmVtb3ZlZC4KKworICAgICAgICBUaGlzIHN0aWxsIGxlYXZlcyBvdGhlciBjb21waWxl cnMgdGhhdCBkb24ndCBzdXBwb3J0IG1vdmUgc2VtYW50aWNzCisgICAgICAgIGxpa2UgVmlzdWFs IFN0dWRpbyB2dWxuZXJhYmxlIHRvIGxpbmtpbmcgaW5jb25zaXN0ZW5jaWVzLgorCisgICAgICAg ICogd3RmL093blB0ci5oOgorICAgICAgICAoT3duUHRyKToKKyAgICAgICAgKFdURik6CisgICAg ICAgIChXVEY6Ojo6T3duUHRyKToKKyAgICAgICAgKFdURjo6PSk6CisKIDIwMTItMDgtMjIgIEFs bGFuIFNhbmRmZWxkIEplbnNlbiAgPGFsbGFuLmplbnNlbkBub2tpYS5jb20+CiAKICAgICAgICAg W1F0XSBPcHRpb25hbGx5IHN1cHBvcnQgc21vb3RoLXNjcm9sbGluZyBvbiBhbGwgcGxhdGZvcm1z CmRpZmYgLS1naXQgYS9Tb3VyY2UvV1RGL3d0Zi9Pd25QdHIuaCBiL1NvdXJjZS9XVEYvd3RmL093 blB0ci5oCmluZGV4IDMyNmUzZmQ2MTVmMGEzNzZjNmFlZDJkOTAxZTM0MTY5OTYxYzM2MzguLjQw YTZlOTFhNmUzZjFjZjIxOGM3MGVlNDJlNmQ5NzlkOWFkODJmOWYgMTAwNjQ0Ci0tLSBhL1NvdXJj ZS9XVEYvd3RmL093blB0ci5oCisrKyBiL1NvdXJjZS9XVEYvd3RmL093blB0ci5oCkBAIC00Niwx MSArNDYsMTMgQEAgbmFtZXNwYWNlIFdURiB7CiAgICAgICAgIC8vIFNlZSBjb21tZW50IGluIFBh c3NPd25QdHIuaCBmb3Igd2h5IHRoaXMgdGFrZXMgYSBjb25zdCByZWZlcmVuY2UuCiAgICAgICAg IHRlbXBsYXRlPHR5cGVuYW1lIFU+IE93blB0cihjb25zdCBQYXNzT3duUHRyPFU+JiBvKTsKIAor I2lmICFDT01QSUxFUl9TVVBQT1JUUyhDWFhfUlZBTFVFX1JFRkVSRU5DRVMpCiAgICAgICAgIC8v IFRoaXMgY29weSBjb25zdHJ1Y3RvciBpcyB1c2VkIGltcGxpY2l0bHkgYnkgZ2NjIHdoZW4gaXQg Z2VuZXJhdGVzCiAgICAgICAgIC8vIHRyYW5zaWVudHMgZm9yIGFzc2lnbmluZyBhIFBhc3NPd25Q dHI8VD4gb2JqZWN0IHRvIGEgc3RhY2stYWxsb2NhdGVkCiAgICAgICAgIC8vIE93blB0cjxUPiBv YmplY3QuIEl0IHNob3VsZCBuZXZlciBiZSBjYWxsZWQgZXhwbGljaXRseSBhbmQgZ2NjCiAgICAg ICAgIC8vIHNob3VsZCBvcHRpbWl6ZSBhd2F5IHRoZSBjb25zdHJ1Y3RvciB3aGVuIGdlbmVyYXRp bmcgY29kZS4KICAgICAgICAgT3duUHRyKGNvbnN0IE93blB0cjxWYWx1ZVR5cGU+Jik7CisjZW5k aWYKIAogICAgICAgICB+T3duUHRyKCkgeyBkZWxldGVPd25lZFB0cihtX3B0cik7IH0KIApAQCAt NzMsNiArNzUsMTQgQEAgbmFtZXNwYWNlIFdURiB7CiAgICAgICAgIE93blB0ciYgb3BlcmF0b3I9 KHN0ZDo6bnVsbHB0cl90KSB7IGNsZWFyKCk7IHJldHVybiAqdGhpczsgfQogICAgICAgICB0ZW1w bGF0ZTx0eXBlbmFtZSBVPiBPd25QdHImIG9wZXJhdG9yPShjb25zdCBQYXNzT3duUHRyPFU+Jik7 CiAKKyNpZiBDT01QSUxFUl9TVVBQT1JUUyhDWFhfUlZBTFVFX1JFRkVSRU5DRVMpCisgICAgICAg IE93blB0cihPd25QdHImJik7CisgICAgICAgIHRlbXBsYXRlPHR5cGVuYW1lIFU+IE93blB0cihP d25QdHI8VT4mJik7CisKKyAgICAgICAgT3duUHRyJiBvcGVyYXRvcj0oT3duUHRyJiYpOworICAg ICAgICB0ZW1wbGF0ZTx0eXBlbmFtZSBVPiBPd25QdHImIG9wZXJhdG9yPShPd25QdHI8VT4mJik7 CisjZW5kaWYKKwogICAgICAgICB2b2lkIHN3YXAoT3duUHRyJiBvKSB7IHN0ZDo6c3dhcChtX3B0 ciwgby5tX3B0cik7IH0KIAogICAgIHByaXZhdGU6CkBAIC0xMzIsNiArMTQyLDM4IEBAIG5hbWVz cGFjZSBXVEYgewogICAgICAgICByZXR1cm4gKnRoaXM7CiAgICAgfQogCisjaWYgQ09NUElMRVJf U1VQUE9SVFMoQ1hYX1JWQUxVRV9SRUZFUkVOQ0VTKQorICAgIHRlbXBsYXRlPHR5cGVuYW1lIFQ+ IGlubGluZSBPd25QdHI8VD46Ok93blB0cihPd25QdHI8VD4mJiBvKQorICAgICAgICA6IG1fcHRy KG8ubGVha1B0cigpKQorICAgIHsKKyAgICB9CisKKyAgICB0ZW1wbGF0ZTx0eXBlbmFtZSBUPiB0 ZW1wbGF0ZTx0eXBlbmFtZSBVPiBpbmxpbmUgT3duUHRyPFQ+OjpPd25QdHIoT3duUHRyPFU+JiYg bykKKyAgICAgICAgOiBtX3B0cihvLmxlYWtQdHIoKSkKKyAgICB7CisgICAgfQorCisgICAgdGVt cGxhdGU8dHlwZW5hbWUgVD4gaW5saW5lIE93blB0cjxUPiYgT3duUHRyPFQ+OjpvcGVyYXRvcj0o T3duUHRyPFQ+JiYgbykKKyAgICB7CisgICAgICAgIFB0clR5cGUgcHRyID0gbV9wdHI7CisgICAg ICAgIG1fcHRyID0gby5sZWFrUHRyKCk7CisgICAgICAgIEFTU0VSVCghcHRyIHx8IG1fcHRyICE9 IHB0cik7CisgICAgICAgIGRlbGV0ZU93bmVkUHRyKHB0cik7CisKKyAgICAgICAgcmV0dXJuICp0 aGlzOworICAgIH0KKworICAgIHRlbXBsYXRlPHR5cGVuYW1lIFQ+IHRlbXBsYXRlPHR5cGVuYW1l IFU+IGlubGluZSBPd25QdHI8VD4mIE93blB0cjxUPjo6b3BlcmF0b3I9KE93blB0cjxVPiYmIG8p CisgICAgeworICAgICAgICBQdHJUeXBlIHB0ciA9IG1fcHRyOworICAgICAgICBtX3B0ciA9IG8u bGVha1B0cigpOworICAgICAgICBBU1NFUlQoIXB0ciB8fCBtX3B0ciAhPSBwdHIpOworICAgICAg ICBkZWxldGVPd25lZFB0cihwdHIpOworCisgICAgICAgIHJldHVybiAqdGhpczsKKyAgICB9Cisj ZW5kaWYKKwogICAgIHRlbXBsYXRlPHR5cGVuYW1lIFQ+IGlubGluZSB2b2lkIHN3YXAoT3duUHRy PFQ+JiBhLCBPd25QdHI8VD4mIGIpCiAgICAgewogICAgICAgICBhLnN3YXAoYik7Cg== 161011 2012-08-28 10:40:34 -0700 2012-09-10 15:08:21 -0700 Also make copy constructor private bug-74625-20120828104025.patch text/plain 4208 enne U3VidmVyc2lvbiBSZXZpc2lvbjogMTI2MzQxCmRpZmYgLS1naXQgYS9Tb3VyY2UvV1RGL0NoYW5n ZUxvZyBiL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCmluZGV4IDEyMDZiZWUzMTgwY2M0ZWZhODlhMmUy NzEzNDhiOWZiZTg5NjVkMTcuLjdkODg2NGYxNDE2NDVmMTJjODZiYmZlYzA0MzM5MjZkYzUwNzY0 ZjggMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9XVEYvQ2hh bmdlTG9nCkBAIC0xLDMgKzEsMzIgQEAKKzIwMTItMDgtMjIgIEFkcmllbm5lIFdhbGtlciAgPGVu bmVAZ29vZ2xlLmNvbT4KKworICAgICAgICBDbGFuZyBkb2Vzbid0IG9wdGltaXplIGF3YXkgdW5k ZWZpbmVkIE93blB0ciBjb3B5IGNvbnN0cnVjdG9yCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJr aXQub3JnL3Nob3dfYnVnLmNnaT9pZD03NDYyNQorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9E WSAoT09QUyEpLgorCisgICAgICAgIE9yaWdpbmFsIHBhdGNoIGJ5IEFuZGVycyBDYXJsc3Nvbiwg d2l0aCBhIG1pbm9yIGVkaXQuCisKKyAgICAgICAgVGhlIHB1YmxpY2x5IGRlY2xhcmVkLWJ1dC1u b3QtZGVmaW5lZCBjb3B5IGNvbnN0cnVjdG9yIGlzIGEgY29tcGlsZXIKKyAgICAgICAgb3B0aW1p emF0aW9uLWRlcGVuZGVudCBsYW5kbWluZS4gQ2xhbmcgb2Z0ZW4gZmFpbHMgdG8gb3B0aW1pemUg dGhlIHVzZQorICAgICAgICBvZiB0aGlzIGZ1bmN0aW9uIG91dCwgbGVhZGluZyB0byBpbnRlcm5h bCBsaW5rYWdlIGVycm9ycyBmb3IgdGhlIG1pc3NpbmcKKyAgICAgICAgZGVmaW5pdGlvbi4gZ2Nj IGRvZXNuJ3QgaGF2ZSB0aGlzIHByb2JsZW0gYW5kIG9wdGltaXplcyB0aGF0IGZ1bmN0aW9uCisg ICAgICAgIG91dCwgbGVhZGluZyB0byBjb2RlIHRoYXQgaW5jb25zaXN0ZW50bHkgZmFpbHMgdG8g bGluayBhY3Jvc3MgcGxhdGZvcm1zLgorCisgICAgICAgIEFzIGEgcGFydGlhbCBmaXggZm9yIHRo aXMgcHJvYmxlbSwgb24gYW55IGNvbXBpbGVyIHRoYXQgc3VwcG9ydHMgQysrMTEKKyAgICAgICAg bW92ZSBzZW1hbnRpY3MsIG1ha2UgdGhlIG1vdmUgY29uc3RydWN0b3JzIGF2YWlsYWJsZSBpbnN0 ZWFkIG9mIHRoZQorICAgICAgICBib2d1cyBjb3B5IGNvbnN0cnVjdG9yLiBJbiB0aGUgZnV0dXJl LCBpZiBhbGwgY29tcGlsZXJzIHN1cHBvcnQgdGhpcywKKyAgICAgICAgdGhlbiB0aGUgY29weSBj b25zdHJ1Y3RvciBjYW4gYmUgcmVtb3ZlZC4KKworICAgICAgICBUaGlzIHN0aWxsIGxlYXZlcyBv dGhlciBjb21waWxlcnMgdGhhdCBkb24ndCBzdXBwb3J0IG1vdmUgc2VtYW50aWNzCisgICAgICAg IGxpa2UgVmlzdWFsIFN0dWRpbyB2dWxuZXJhYmxlIHRvIGxpbmtpbmcgaW5jb25zaXN0ZW5jaWVz LgorCisgICAgICAgICogd3RmL093blB0ci5oOgorICAgICAgICAoT3duUHRyKToKKyAgICAgICAg KFdURik6CisgICAgICAgIChXVEY6Ojo6T3duUHRyKToKKyAgICAgICAgKFdURjo6PSk6CisKIDIw MTItMDgtMjIgIEFsbGFuIFNhbmRmZWxkIEplbnNlbiAgPGFsbGFuLmplbnNlbkBub2tpYS5jb20+ CiAKICAgICAgICAgW1F0XSBPcHRpb25hbGx5IHN1cHBvcnQgc21vb3RoLXNjcm9sbGluZyBvbiBh bGwgcGxhdGZvcm1zCmRpZmYgLS1naXQgYS9Tb3VyY2UvV1RGL3d0Zi9Pd25QdHIuaCBiL1NvdXJj ZS9XVEYvd3RmL093blB0ci5oCmluZGV4IDMyNmUzZmQ2MTVmMGEzNzZjNmFlZDJkOTAxZTM0MTY5 OTYxYzM2MzguLjE4YzBiODVjYTUyOTNmZWFmYzBmZmQ4ZmMyNDYyZDFiZDU0MzI5NjkgMTAwNjQ0 Ci0tLSBhL1NvdXJjZS9XVEYvd3RmL093blB0ci5oCisrKyBiL1NvdXJjZS9XVEYvd3RmL093blB0 ci5oCkBAIC00NiwxMSArNDYsMTMgQEAgbmFtZXNwYWNlIFdURiB7CiAgICAgICAgIC8vIFNlZSBj b21tZW50IGluIFBhc3NPd25QdHIuaCBmb3Igd2h5IHRoaXMgdGFrZXMgYSBjb25zdCByZWZlcmVu Y2UuCiAgICAgICAgIHRlbXBsYXRlPHR5cGVuYW1lIFU+IE93blB0cihjb25zdCBQYXNzT3duUHRy PFU+JiBvKTsKIAorI2lmICFDT01QSUxFUl9TVVBQT1JUUyhDWFhfUlZBTFVFX1JFRkVSRU5DRVMp CiAgICAgICAgIC8vIFRoaXMgY29weSBjb25zdHJ1Y3RvciBpcyB1c2VkIGltcGxpY2l0bHkgYnkg Z2NjIHdoZW4gaXQgZ2VuZXJhdGVzCiAgICAgICAgIC8vIHRyYW5zaWVudHMgZm9yIGFzc2lnbmlu ZyBhIFBhc3NPd25QdHI8VD4gb2JqZWN0IHRvIGEgc3RhY2stYWxsb2NhdGVkCiAgICAgICAgIC8v IE93blB0cjxUPiBvYmplY3QuIEl0IHNob3VsZCBuZXZlciBiZSBjYWxsZWQgZXhwbGljaXRseSBh bmQgZ2NjCiAgICAgICAgIC8vIHNob3VsZCBvcHRpbWl6ZSBhd2F5IHRoZSBjb25zdHJ1Y3RvciB3 aGVuIGdlbmVyYXRpbmcgY29kZS4KICAgICAgICAgT3duUHRyKGNvbnN0IE93blB0cjxWYWx1ZVR5 cGU+Jik7CisjZW5kaWYKIAogICAgICAgICB+T3duUHRyKCkgeyBkZWxldGVPd25lZFB0cihtX3B0 cik7IH0KIApAQCAtNzMsOSArNzUsMjEgQEAgbmFtZXNwYWNlIFdURiB7CiAgICAgICAgIE93blB0 ciYgb3BlcmF0b3I9KHN0ZDo6bnVsbHB0cl90KSB7IGNsZWFyKCk7IHJldHVybiAqdGhpczsgfQog ICAgICAgICB0ZW1wbGF0ZTx0eXBlbmFtZSBVPiBPd25QdHImIG9wZXJhdG9yPShjb25zdCBQYXNz T3duUHRyPFU+Jik7CiAKKyNpZiBDT01QSUxFUl9TVVBQT1JUUyhDWFhfUlZBTFVFX1JFRkVSRU5D RVMpCisgICAgICAgIE93blB0cihPd25QdHImJik7CisgICAgICAgIHRlbXBsYXRlPHR5cGVuYW1l IFU+IE93blB0cihPd25QdHI8VT4mJik7CisKKyAgICAgICAgT3duUHRyJiBvcGVyYXRvcj0oT3du UHRyJiYpOworICAgICAgICB0ZW1wbGF0ZTx0eXBlbmFtZSBVPiBPd25QdHImIG9wZXJhdG9yPShP d25QdHI8VT4mJik7CisjZW5kaWYKKwogICAgICAgICB2b2lkIHN3YXAoT3duUHRyJiBvKSB7IHN0 ZDo6c3dhcChtX3B0ciwgby5tX3B0cik7IH0KIAogICAgIHByaXZhdGU6CisgICAgICAgIC8vIE1h a2UgT3duUHRyIG5vbi1jb3B5YWJsZQorI2lmIENPTVBJTEVSX1NVUFBPUlRTKENYWF9SVkFMVUVf UkVGRVJFTkNFUykKKyAgICAgICAgT3duUHRyKGNvbnN0IE93blB0cjxUPiYpOworI2VuZGlmCiAg ICAgICAgIE93blB0ciYgb3BlcmF0b3I9KGNvbnN0IE93blB0cjxUPiYpOwogCiAgICAgICAgIC8v IFdlIHNob3VsZCBuZXZlciBoYXZlIHR3byBPd25QdHJzIGZvciB0aGUgc2FtZSB1bmRlcmx5aW5n IG9iamVjdCAob3RoZXJ3aXNlIHdlJ2xsIGdldApAQCAtMTMyLDYgKzE0NiwzOCBAQCBuYW1lc3Bh Y2UgV1RGIHsKICAgICAgICAgcmV0dXJuICp0aGlzOwogICAgIH0KIAorI2lmIENPTVBJTEVSX1NV UFBPUlRTKENYWF9SVkFMVUVfUkVGRVJFTkNFUykKKyAgICB0ZW1wbGF0ZTx0eXBlbmFtZSBUPiBp bmxpbmUgT3duUHRyPFQ+OjpPd25QdHIoT3duUHRyPFQ+JiYgbykKKyAgICAgICAgOiBtX3B0cihv LmxlYWtQdHIoKSkKKyAgICB7CisgICAgfQorCisgICAgdGVtcGxhdGU8dHlwZW5hbWUgVD4gdGVt cGxhdGU8dHlwZW5hbWUgVT4gaW5saW5lIE93blB0cjxUPjo6T3duUHRyKE93blB0cjxVPiYmIG8p CisgICAgICAgIDogbV9wdHIoby5sZWFrUHRyKCkpCisgICAgeworICAgIH0KKworICAgIHRlbXBs YXRlPHR5cGVuYW1lIFQ+IGlubGluZSBPd25QdHI8VD4mIE93blB0cjxUPjo6b3BlcmF0b3I9KE93 blB0cjxUPiYmIG8pCisgICAgeworICAgICAgICBQdHJUeXBlIHB0ciA9IG1fcHRyOworICAgICAg ICBtX3B0ciA9IG8ubGVha1B0cigpOworICAgICAgICBBU1NFUlQoIXB0ciB8fCBtX3B0ciAhPSBw dHIpOworICAgICAgICBkZWxldGVPd25lZFB0cihwdHIpOworCisgICAgICAgIHJldHVybiAqdGhp czsKKyAgICB9CisKKyAgICB0ZW1wbGF0ZTx0eXBlbmFtZSBUPiB0ZW1wbGF0ZTx0eXBlbmFtZSBV PiBpbmxpbmUgT3duUHRyPFQ+JiBPd25QdHI8VD46Om9wZXJhdG9yPShPd25QdHI8VT4mJiBvKQor ICAgIHsKKyAgICAgICAgUHRyVHlwZSBwdHIgPSBtX3B0cjsKKyAgICAgICAgbV9wdHIgPSBvLmxl YWtQdHIoKTsKKyAgICAgICAgQVNTRVJUKCFwdHIgfHwgbV9wdHIgIT0gcHRyKTsKKyAgICAgICAg ZGVsZXRlT3duZWRQdHIocHRyKTsKKworICAgICAgICByZXR1cm4gKnRoaXM7CisgICAgfQorI2Vu ZGlmCisKICAgICB0ZW1wbGF0ZTx0eXBlbmFtZSBUPiBpbmxpbmUgdm9pZCBzd2FwKE93blB0cjxU PiYgYSwgT3duUHRyPFQ+JiBiKQogICAgIHsKICAgICAgICAgYS5zd2FwKGIpOwo= 163220 2012-09-10 15:08:26 -0700 2012-09-11 10:38:45 -0700 Use Noncopyable bug-74625-20120910150801.patch text/plain 4998 enne U3VidmVyc2lvbiBSZXZpc2lvbjogMTI4MDc3CmRpZmYgLS1naXQgYS9Tb3VyY2UvV1RGL0NoYW5n ZUxvZyBiL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCmluZGV4IGNmNGVhZGE3OGVmNjM1MmExN2RjODRl ZThhZDUzMjhlZGMwMmVjYjkuLjA1N2Q0MDQ4MWM0ZGE2NDRjMDRmZDZmNWE5NzgzYmY4NmVhZDQx NTggMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9XVEYvQ2hh bmdlTG9nCkBAIC0xLDMgKzEsMzIgQEAKKzIwMTItMDktMTAgIEFkcmllbm5lIFdhbGtlciAgPGVu bmVAZ29vZ2xlLmNvbT4KKworICAgICAgICBDbGFuZyBkb2Vzbid0IG9wdGltaXplIGF3YXkgdW5k ZWZpbmVkIE93blB0ciBjb3B5IGNvbnN0cnVjdG9yCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJr aXQub3JnL3Nob3dfYnVnLmNnaT9pZD03NDYyNQorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9E WSAoT09QUyEpLgorCisgICAgICAgIE9yaWdpbmFsIHBhdGNoIGJ5IEFuZGVycyBDYXJsc3Nvbiwg d2l0aCBhIG1pbm9yIGVkaXQuCisKKyAgICAgICAgVGhlIHB1YmxpY2x5IGRlY2xhcmVkLWJ1dC1u b3QtZGVmaW5lZCBjb3B5IGNvbnN0cnVjdG9yIGlzIGEgY29tcGlsZXIKKyAgICAgICAgb3B0aW1p emF0aW9uLWRlcGVuZGVudCBsYW5kbWluZS4gQ2xhbmcgb2Z0ZW4gZmFpbHMgdG8gb3B0aW1pemUg dGhlIHVzZQorICAgICAgICBvZiB0aGlzIGZ1bmN0aW9uIG91dCwgbGVhZGluZyB0byBpbnRlcm5h bCBsaW5rYWdlIGVycm9ycyBmb3IgdGhlIG1pc3NpbmcKKyAgICAgICAgZGVmaW5pdGlvbi4gZ2Nj IGRvZXNuJ3QgaGF2ZSB0aGlzIHByb2JsZW0gYW5kIG9wdGltaXplcyB0aGF0IGZ1bmN0aW9uCisg ICAgICAgIG91dCwgbGVhZGluZyB0byBjb2RlIHRoYXQgaW5jb25zaXN0ZW50bHkgZmFpbHMgdG8g bGluayBhY3Jvc3MgcGxhdGZvcm1zLgorCisgICAgICAgIEFzIGEgcGFydGlhbCBmaXggZm9yIHRo aXMgcHJvYmxlbSwgb24gYW55IGNvbXBpbGVyIHRoYXQgc3VwcG9ydHMgQysrMTEKKyAgICAgICAg bW92ZSBzZW1hbnRpY3MsIHJlcGxhY2UgdGhlIGJvZ3VzIGNvcHkgY29uc3RydWN0b3Igd2l0aCB0 aGUgbW92ZQorICAgICAgICBjb25zdHJ1Y3RvcnMuICBJbiB0aGUgZnV0dXJlLCBpZiBhbGwgY29t cGlsZXJzIHN1cHBvcnQgdGhpcywgdGhlbiB0aGUKKyAgICAgICAgY29weSBjb25zdHJ1Y3RvciBj YW4gYmUgcmVtb3ZlZC4KKworICAgICAgICBUaGlzIHN0aWxsIGxlYXZlcyBvdGhlciBjb21waWxl cnMgdGhhdCBkb24ndCBzdXBwb3J0IG1vdmUgc2VtYW50aWNzCisgICAgICAgIGxpa2UgVmlzdWFs IFN0dWRpbyB2dWxuZXJhYmxlIHRvIGxpbmtpbmcgaW5jb25zaXN0ZW5jaWVzLgorCisgICAgICAg ICogd3RmL093blB0ci5oOgorICAgICAgICAoT3duUHRyKToKKyAgICAgICAgKFdURik6CisgICAg ICAgIChXVEY6Ojo6T3duUHRyKToKKyAgICAgICAgKFdURjo6PSk6CisKIDIwMTItMDktMDkgIE1h cmsgTGFtICA8bWFyay5sYW1AYXBwbGUuY29tPgogCiAgICAgICAgIEZpeGVkIEFTU0VSVCgpIGFu ZCBBU1NFUlRfQVQoKSBtYWNyb3Mgc28gdGhhdCB0aGV5IGNhbiBiZSB1c2VkIGluCmRpZmYgLS1n aXQgYS9Tb3VyY2UvV1RGL3d0Zi9Pd25QdHIuaCBiL1NvdXJjZS9XVEYvd3RmL093blB0ci5oCmlu ZGV4IDMyNmUzZmQ2MTVmMGEzNzZjNmFlZDJkOTAxZTM0MTY5OTYxYzM2MzguLmZhNzlhYTFlM2Fm MmVjNjc1NGVjYTI4YjU3YWI5ZGZlODliNDI4OGQgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XVEYvd3Rm L093blB0ci5oCisrKyBiL1NvdXJjZS9XVEYvd3RmL093blB0ci5oCkBAIC0yMiw2ICsyMiw3IEBA CiAjZGVmaW5lIFdURl9Pd25QdHJfaAogCiAjaW5jbHVkZSA8d3RmL0Fzc2VydGlvbnMuaD4KKyNp bmNsdWRlIDx3dGYvTm9uY29weWFibGUuaD4KICNpbmNsdWRlIDx3dGYvTnVsbFB0ci5oPgogI2lu Y2x1ZGUgPHd0Zi9Pd25QdHJDb21tb24uaD4KICNpbmNsdWRlIDx3dGYvVHlwZVRyYWl0cy5oPgpA QCAtMzYsNiArMzcsMTEgQEAgbmFtZXNwYWNlIFdURiB7CiAgICAgdGVtcGxhdGU8dHlwZW5hbWUg VD4gUGFzc093blB0cjxUPiBhZG9wdFB0cihUKik7CiAKICAgICB0ZW1wbGF0ZTx0eXBlbmFtZSBU PiBjbGFzcyBPd25QdHIgeworI2lmIENPTVBJTEVSX1NVUFBPUlRTKENYWF9SVkFMVUVfUkVGRVJF TkNFUykKKyAgICAgICAgLy8gSWYgcnZhbHVlIHJlZmVyZW5jZXMgYXJlIG5vdCBzdXBwb3J0ZWQs IHRoZSBjb3B5IGNvbnN0cnVjdG9yIGlzCisgICAgICAgIC8vIHB1YmxpYyBzbyBPd25QdHIgY2Fu bm90IGJlIG1hcmtlZCBub25jb3B5YWJsZS4gU2VlIG5vdGUgYmVsb3cuCisgICAgICAgIFdURl9N QUtFX05PTkNPUFlBQkxFKE93blB0cik7CisjZW5kaWYKICAgICBwdWJsaWM6CiAgICAgICAgIHR5 cGVkZWYgdHlwZW5hbWUgUmVtb3ZlUG9pbnRlcjxUPjo6VHlwZSBWYWx1ZVR5cGU7CiAgICAgICAg IHR5cGVkZWYgVmFsdWVUeXBlKiBQdHJUeXBlOwpAQCAtNDYsMTEgKzUyLDEzIEBAIG5hbWVzcGFj ZSBXVEYgewogICAgICAgICAvLyBTZWUgY29tbWVudCBpbiBQYXNzT3duUHRyLmggZm9yIHdoeSB0 aGlzIHRha2VzIGEgY29uc3QgcmVmZXJlbmNlLgogICAgICAgICB0ZW1wbGF0ZTx0eXBlbmFtZSBV PiBPd25QdHIoY29uc3QgUGFzc093blB0cjxVPiYgbyk7CiAKKyNpZiAhQ09NUElMRVJfU1VQUE9S VFMoQ1hYX1JWQUxVRV9SRUZFUkVOQ0VTKQogICAgICAgICAvLyBUaGlzIGNvcHkgY29uc3RydWN0 b3IgaXMgdXNlZCBpbXBsaWNpdGx5IGJ5IGdjYyB3aGVuIGl0IGdlbmVyYXRlcwogICAgICAgICAv LyB0cmFuc2llbnRzIGZvciBhc3NpZ25pbmcgYSBQYXNzT3duUHRyPFQ+IG9iamVjdCB0byBhIHN0 YWNrLWFsbG9jYXRlZAogICAgICAgICAvLyBPd25QdHI8VD4gb2JqZWN0LiBJdCBzaG91bGQgbmV2 ZXIgYmUgY2FsbGVkIGV4cGxpY2l0bHkgYW5kIGdjYwogICAgICAgICAvLyBzaG91bGQgb3B0aW1p emUgYXdheSB0aGUgY29uc3RydWN0b3Igd2hlbiBnZW5lcmF0aW5nIGNvZGUuCiAgICAgICAgIE93 blB0cihjb25zdCBPd25QdHI8VmFsdWVUeXBlPiYpOworI2VuZGlmCiAKICAgICAgICAgfk93blB0 cigpIHsgZGVsZXRlT3duZWRQdHIobV9wdHIpOyB9CiAKQEAgLTczLDEwICs4MSwyMSBAQCBuYW1l c3BhY2UgV1RGIHsKICAgICAgICAgT3duUHRyJiBvcGVyYXRvcj0oc3RkOjpudWxscHRyX3QpIHsg Y2xlYXIoKTsgcmV0dXJuICp0aGlzOyB9CiAgICAgICAgIHRlbXBsYXRlPHR5cGVuYW1lIFU+IE93 blB0ciYgb3BlcmF0b3I9KGNvbnN0IFBhc3NPd25QdHI8VT4mKTsKIAorI2lmIENPTVBJTEVSX1NV UFBPUlRTKENYWF9SVkFMVUVfUkVGRVJFTkNFUykKKyAgICAgICAgT3duUHRyKE93blB0ciYmKTsK KyAgICAgICAgdGVtcGxhdGU8dHlwZW5hbWUgVT4gT3duUHRyKE93blB0cjxVPiYmKTsKKworICAg ICAgICBPd25QdHImIG9wZXJhdG9yPShPd25QdHImJik7CisgICAgICAgIHRlbXBsYXRlPHR5cGVu YW1lIFU+IE93blB0ciYgb3BlcmF0b3I9KE93blB0cjxVPiYmKTsKKyNlbmRpZgorCiAgICAgICAg IHZvaWQgc3dhcChPd25QdHImIG8pIHsgc3RkOjpzd2FwKG1fcHRyLCBvLm1fcHRyKTsgfQogCiAg ICAgcHJpdmF0ZToKLSAgICAgICAgT3duUHRyJiBvcGVyYXRvcj0oY29uc3QgT3duUHRyPFQ+Jik7 CisjaWYgIUNPTVBJTEVSX1NVUFBPUlRTKENYWF9SVkFMVUVfUkVGRVJFTkNFUykKKyAgICAgICAg Ly8gSWYgcnZhbHVlIHJlZmVyZW5jZXMgYXJlIHN1cHBvcnRlZCwgbm9uY29weWFibGUgdGFrZXMg Y2FyZSBvZiB0aGlzLgorICAgICAgICBPd25QdHImIG9wZXJhdG9yPShjb25zdCBPd25QdHImKTsK KyNlbmRpZgogCiAgICAgICAgIC8vIFdlIHNob3VsZCBuZXZlciBoYXZlIHR3byBPd25QdHJzIGZv ciB0aGUgc2FtZSB1bmRlcmx5aW5nIG9iamVjdCAob3RoZXJ3aXNlIHdlJ2xsIGdldAogICAgICAg ICAvLyBkb3VibGUtZGVzdHJ1Y3Rpb24pLCBzbyB0aGVzZSBlcXVhbGl0eSBvcGVyYXRvcnMgc2hv dWxkIG5ldmVyIGJlIG5lZWRlZC4KQEAgLTEzMiw2ICsxNTEsMzggQEAgbmFtZXNwYWNlIFdURiB7 CiAgICAgICAgIHJldHVybiAqdGhpczsKICAgICB9CiAKKyNpZiBDT01QSUxFUl9TVVBQT1JUUyhD WFhfUlZBTFVFX1JFRkVSRU5DRVMpCisgICAgdGVtcGxhdGU8dHlwZW5hbWUgVD4gaW5saW5lIE93 blB0cjxUPjo6T3duUHRyKE93blB0cjxUPiYmIG8pCisgICAgICAgIDogbV9wdHIoby5sZWFrUHRy KCkpCisgICAgeworICAgIH0KKworICAgIHRlbXBsYXRlPHR5cGVuYW1lIFQ+IHRlbXBsYXRlPHR5 cGVuYW1lIFU+IGlubGluZSBPd25QdHI8VD46Ok93blB0cihPd25QdHI8VT4mJiBvKQorICAgICAg ICA6IG1fcHRyKG8ubGVha1B0cigpKQorICAgIHsKKyAgICB9CisKKyAgICB0ZW1wbGF0ZTx0eXBl bmFtZSBUPiBpbmxpbmUgT3duUHRyPFQ+JiBPd25QdHI8VD46Om9wZXJhdG9yPShPd25QdHI8VD4m JiBvKQorICAgIHsKKyAgICAgICAgUHRyVHlwZSBwdHIgPSBtX3B0cjsKKyAgICAgICAgbV9wdHIg PSBvLmxlYWtQdHIoKTsKKyAgICAgICAgQVNTRVJUKCFwdHIgfHwgbV9wdHIgIT0gcHRyKTsKKyAg ICAgICAgZGVsZXRlT3duZWRQdHIocHRyKTsKKworICAgICAgICByZXR1cm4gKnRoaXM7CisgICAg fQorCisgICAgdGVtcGxhdGU8dHlwZW5hbWUgVD4gdGVtcGxhdGU8dHlwZW5hbWUgVT4gaW5saW5l IE93blB0cjxUPiYgT3duUHRyPFQ+OjpvcGVyYXRvcj0oT3duUHRyPFU+JiYgbykKKyAgICB7Cisg ICAgICAgIFB0clR5cGUgcHRyID0gbV9wdHI7CisgICAgICAgIG1fcHRyID0gby5sZWFrUHRyKCk7 CisgICAgICAgIEFTU0VSVCghcHRyIHx8IG1fcHRyICE9IHB0cik7CisgICAgICAgIGRlbGV0ZU93 bmVkUHRyKHB0cik7CisKKyAgICAgICAgcmV0dXJuICp0aGlzOworICAgIH0KKyNlbmRpZgorCiAg ICAgdGVtcGxhdGU8dHlwZW5hbWUgVD4gaW5saW5lIHZvaWQgc3dhcChPd25QdHI8VD4mIGEsIE93 blB0cjxUPiYgYikKICAgICB7CiAgICAgICAgIGEuc3dhcChiKTsK