r310401 - PR19668, PR23034: Fix handling of move constructors and deleted copy
Vassil Vassilev via cfe-commits
cfe-commits at lists.llvm.org
Mon Aug 14 08:06:51 PDT 2017
On 14/08/17 15:59, Diana Picus wrote:
> No, the buildbots don't build with -O0 (at least not the ones that broke).
>
> The command line for that particular object is:
> build/./bin/clang -fPIC -fvisibility-inlines-hidden -Werror=date-time
> -std=c++11 -Wall -W -Wno-unused-parameter -Wwrite-strings -Wcast-qual
> -Wmissing-field-initializers -pedantic -Wno-long-long
> -Wcovered-switch-default -Wnon-virtual-dtor -Wdelete-non-virtual-dtor
> -Wstring-conversion -fcolor-diagnostics -ffunction-sections
> -fdata-sections -Wall -std=c++11 -Wno-unused-parameter
> -Wno-unknown-warning-option -Wno-covered-switch-default
> -DGTEST_NO_LLVM_RAW_OSTREAM=1 -DGTEST_HAS_RTTI=0
> -I$LLVM_SRC/llvm/utils/unittest/googletest/include
> -I/home/diana.picus/linaro-scripts/bisect/llvm/utils/unittest/googletest
> -I$LLVM_SRC/llvm/projects/compiler-rt/include
> -I$LLVM_SRC/llvm/projects/compiler-rt/lib
> -I$LLVM_SRC/llvm/projects/compiler-rt/lib/asan
> -I$LLVM_SRC/llvm/projects/compiler-rt/lib/sanitizer_common/tests
> -fno-rtti -O2 -Wno-format -Werror=sign-compare -Wno-non-virtual-dtor
> -Wno-variadic-macros -gline-tables-only -DASAN_HAS_BLACKLIST=1
> -DASAN_HAS_EXCEPTIONS=1 -DASAN_UAR=0 -fsanitize=address
> -fsanitize-blacklist=$LLVM_SRC/llvm/projects/compiler-rt/lib/asan/tests/asan_test.ignore
> -mllvm -asan-instrumentation-with-call-threshold=0 -march=armv7-a
> -mfloat-abi=hard -c -o
> ASAN_INST_TEST_OBJECTS.asan_test.cc.armhf-with-calls.o
> $LLVM_SRC/compiler-rt/lib/asan/tests/asan_test.cc
Could you try to reproduce the issue with O0? This would rule out the
optimizer. Could you resend the O0 ll file, maybe I could find something
out. IIUC, the gtest version is 1.8.0?
>
> Why would it contain gtest.cc? It seems to contain gtest.h and a bunch
> of other internal gtest headers...
>
>
> On 14 August 2017 at 16:51, Vassil Vassilev <v.g.vassilev at gmail.com> wrote:
>> On 14/08/17 15:08, Vassil Vassilev wrote:
>>> On 14/08/17 13:04, Diana Picus wrote:
>>>> See attached.
>>> Thanks! It looks like asan_test.i doesn't have gtest.cc which appears in
>>> the stack trace. Am I missing something?
>> Could you paste the compiler invocation. Are we building with -O0 (I see
>> quite a lot of things inline). Could it be an optimizer problem?
>>
>>>> On 14 August 2017 at 13:30, Vassil Vassilev <v.g.vassilev at gmail.com>
>>>> wrote:
>>>>> On 14/08/17 11:27, Diana Picus wrote:
>>>>>> Hi,
>>>>>>
>>>>>> Strangely enough, it turns out that if I run
>>>>>> Asan-armhf-with-calls-Noinst-Test on the command line it fails,
>>>>>> although it doesn't fail when run with lit. I've attached the stack
>>>>>> trace from gdb. It looks like some trouble passing down va_arg
>>>>>> parameters, but I haven't looked into too much details. The segfault
>>>>>> happens when we try to do a ldrb r3, [r0, r1], with r1 set to 0 by
>>>>>> the current function and r0 passed down from the caller. I'm not sure
>>>>>> if this is the exact same problem as the other tests, but feel free to
>>>>>> have a look at that code.
>>>>>>
>>>>>> Meanwhile, I've removed some clutter from Asan-armhf-with-calls-Test
>>>>>> (which is the original failure that we were seeing) and left only one
>>>>>> failing test that seemed small enough. I'll try to look at the
>>>>>> disassembly before/after the patch and maybe even run valgrind on it
>>>>>> (running it on the original binary naturally takes forever).
>>>>>>
>>>>>> Let me know if there's anything else I could try. I can also send you
>>>>>> disassembly or even LLVM IR for the Asan-armhf-with-calls-Noinst-Test
>>>>>> if you think it helps.
>>>>> disassembly and LLVM will greatly help as well.
>>>>>
>>>>>> Cheers,
>>>>>> Diana
>>>>>>
>>>>>> On 11 August 2017 at 15:34, Diana Picus <diana.picus at linaro.org> wrote:
>>>>>>> Well, these are ASAN tests, I'm not sure how that would interact with
>>>>>>> Valgrind.
>>>>>>> Anyway, I'll try to reproduce the environment, I'm guessing it would
>>>>>>> be best to catch this in gdb so I can actually see what's going on.
>>>>>>>
>>>>>>> On 11 August 2017 at 15:21, Vassil Vassilev <v.g.vassilev at gmail.com>
>>>>>>> wrote:
>>>>>>>> That's really strange. It looks like some random behavior. Did you
>>>>>>>> run
>>>>>>>> some memory checker like valgrind?
>>>>>>>>
>>>>>>>> Do the environment provided by the test runner and yours match?
>>>>>>>>
>>>>>>>> Sent from my phone. Please excuse my brevity.
>>>>>>>>
>>>>>>>>> On 11 Aug 2017, at 15:58, Diana Picus <diana.picus at linaro.org>
>>>>>>>>> wrote:
>>>>>>>>>
>>>>>>>>> Hi again,
>>>>>>>>>
>>>>>>>>> I finally got the debug build, but unfortunately the stack traces
>>>>>>>>> that
>>>>>>>>> the tests print look the same. My suspicion is that this is because
>>>>>>>>> the addresses printed by the tests are funny (i.e. odd numbers
>>>>>>>>> instead
>>>>>>>>> of divisible by 4). I tried to follow those addresses in an objdump
>>>>>>>>> of
>>>>>>>>> the executable, but I didn't have much success since most of them
>>>>>>>>> weren't really pointing to call instructions.
>>>>>>>>>
>>>>>>>>> When I try to run the tests manually in the shell or in gdb, they
>>>>>>>>> pass.
>>>>>>>>>
>>>>>>>>> I'm not sure what else to try. Thoughts?
>>>>>>>>>
>>>>>>>>> Thanks,
>>>>>>>>> Diana
>>>>>>>>>
>>>>>>>>>> On 11 August 2017 at 11:14, Diana Picus <diana.picus at linaro.org>
>>>>>>>>>> wrote:
>>>>>>>>>> Hi guys,
>>>>>>>>>>
>>>>>>>>>> I'm SO sorry about the delays. I've been having all sorts of
>>>>>>>>>> trouble
>>>>>>>>>> getting that debug build on the board (from ld running out of
>>>>>>>>>> memory
>>>>>>>>>> to the board just crashing on me, in which case I need to ask
>>>>>>>>>> someone
>>>>>>>>>> else to reboot it because I can't power cycle it remotely). I can
>>>>>>>>>> assure you this is one of my top priorities, I'll get those stack
>>>>>>>>>> traces as soon as I can.
>>>>>>>>>>
>>>>>>>>>> Thanks for your patience and sorry again,
>>>>>>>>>> Diana
>>>>>>>>>>
>>>>>>>>>>> On 10 August 2017 at 22:55, Richard Smith <richard at metafoo.co.uk>
>>>>>>>>>>> wrote:
>>>>>>>>>>> Any news on this? We want this change in Clang 5, so the sooner we
>>>>>>>>>>> can
>>>>>>>>>>> understand and fix this regression the better...
>>>>>>>>>>>
>>>>>>>>>>> On 10 August 2017 at 01:28, Diana Picus via cfe-commits
>>>>>>>>>>> <cfe-commits at lists.llvm.org> wrote:
>>>>>>>>>>>> Hi Vassil,
>>>>>>>>>>>>
>>>>>>>>>>>> My build is in progress, but since it's a full build it's
>>>>>>>>>>>> probably
>>>>>>>>>>>> going to take another couple of hours to complete. I'll let you
>>>>>>>>>>>> know
>>>>>>>>>>>> when it's done.
>>>>>>>>>>>>
>>>>>>>>>>>> Thanks,
>>>>>>>>>>>> Diana
>>>>>>>>>>>>
>>>>>>>>>>>> On 10 August 2017 at 10:09, Vassil Vassilev
>>>>>>>>>>>> <v.g.vassilev at gmail.com>
>>>>>>>>>>>> wrote:
>>>>>>>>>>>>> It looks like I can not reproduce it on osx (non-arm)... :(
>>>>>>>>>>>>>> On 09/08/17 22:54, Diana Picus wrote:
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Reverting this also fixed the selfhost bots:
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> http://lab.llvm.org:8011/builders/clang-cmake-thumbv7-a15-full-sh/builds/2142
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> http://lab.llvm.org:8011/builders/clang-cmake-armv7-a15-selfhost/builds/2309
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> http://lab.llvm.org:8011/builders/clang-cmake-armv7-a15-selfhost-neon/builds/1819
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> I'm afraid the logs for those look even less helpful.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> On 9 August 2017 at 16:17, Diana Picus
>>>>>>>>>>>>>>> <diana.picus at linaro.org>
>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Hi,
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> See attached. FWIW, when I ran this on a very similar machine,
>>>>>>>>>>>>>>> I
>>>>>>>>>>>>>>> got
>>>>>>>>>>>>>>> 194 failures, all of which went away after reverting. So there
>>>>>>>>>>>>>>> might
>>>>>>>>>>>>>>> be something fishy going on.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Regards,
>>>>>>>>>>>>>>> Diana
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> On 9 August 2017 at 15:02, Vassil Vassilev
>>>>>>>>>>>>>>> <v.g.vassilev at gmail.com>
>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>> Hi Diana,
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> It seems the service is down. Could you send us the
>>>>>>>>>>>>>>>> details
>>>>>>>>>>>>>>>> of the
>>>>>>>>>>>>>>>> failures (incl stack traces if any)
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Many thanks,
>>>>>>>>>>>>>>>> Vassil
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> On 09/08/17 15:27, Diana Picus via cfe-commits wrote:
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Hi Richard,
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> I'm sorry but I've reverted this in r310464 because it was
>>>>>>>>>>>>>>>>> breaking
>>>>>>>>>>>>>>>>> some ASAN tests on this bot:
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> http://lab.llvm.org:8011/builders/clang-cmake-armv7-a15-full/builds/9452
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Please let me know if I can help debug this.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Cheers,
>>>>>>>>>>>>>>>>> Diana
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> On 8 August 2017 at 21:14, Richard Smith via cfe-commits
>>>>>>>>>>>>>>>>> <cfe-commits at lists.llvm.org> wrote:
>>>>>>>>>>>>>>>>>> I forgot to say:
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Based on a patch by Vassil Vassilev, which was based on a
>>>>>>>>>>>>>>>>>> patch by
>>>>>>>>>>>>>>>>>> Bernd
>>>>>>>>>>>>>>>>>> Schmidt, which was based on a patch by Reid Kleckner.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> On 8 August 2017 at 12:12, Richard Smith via cfe-commits
>>>>>>>>>>>>>>>>>> <cfe-commits at lists.llvm.org> wrote:
>>>>>>>>>>>>>>>>>>> Author: rsmith
>>>>>>>>>>>>>>>>>>> Date: Tue Aug 8 12:12:28 2017
>>>>>>>>>>>>>>>>>>> New Revision: 310401
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> URL:
>>>>>>>>>>>>>>>>>>> http://llvm.org/viewvc/llvm-project?rev=310401&view=rev
>>>>>>>>>>>>>>>>>>> Log:
>>>>>>>>>>>>>>>>>>> PR19668, PR23034: Fix handling of move constructors and
>>>>>>>>>>>>>>>>>>> deleted
>>>>>>>>>>>>>>>>>>> copy
>>>>>>>>>>>>>>>>>>> constructors when deciding whether classes should be
>>>>>>>>>>>>>>>>>>> passed
>>>>>>>>>>>>>>>>>>> indirectly.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> This fixes ABI differences between Clang and GCC:
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> * Previously, Clang ignored the move constructor when
>>>>>>>>>>>>>>>>>>> making
>>>>>>>>>>>>>>>>>>> this
>>>>>>>>>>>>>>>>>>> determination. It now takes the move constructor
>>>>>>>>>>>>>>>>>>> into
>>>>>>>>>>>>>>>>>>> account,
>>>>>>>>>>>>>>>>>>> per
>>>>>>>>>>>>>>>>>>> https://github.com/itanium-cxx-abi/cxx-abi/pull/17 (this
>>>>>>>>>>>>>>>>>>> change
>>>>>>>>>>>>>>>>>>> may
>>>>>>>>>>>>>>>>>>> seem recent, but the ABI change was agreed on the
>>>>>>>>>>>>>>>>>>> Itanium C++
>>>>>>>>>>>>>>>>>>> ABI
>>>>>>>>>>>>>>>>>>> list a long time ago).
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> * Previously, Clang's behavior when the copy
>>>>>>>>>>>>>>>>>>> constructor
>>>>>>>>>>>>>>>>>>> was
>>>>>>>>>>>>>>>>>>> deleted
>>>>>>>>>>>>>>>>>>> was unstable -- depending on whether the lazy
>>>>>>>>>>>>>>>>>>> declaration of
>>>>>>>>>>>>>>>>>>> the
>>>>>>>>>>>>>>>>>>> copy constructor had been triggered, you might get
>>>>>>>>>>>>>>>>>>> different
>>>>>>>>>>>>>>>>>>> behavior.
>>>>>>>>>>>>>>>>>>> We now eagerly declare the copy constructor whenever
>>>>>>>>>>>>>>>>>>> its
>>>>>>>>>>>>>>>>>>> deletedness
>>>>>>>>>>>>>>>>>>> is unclear, and ignore deleted copy/move
>>>>>>>>>>>>>>>>>>> constructors
>>>>>>>>>>>>>>>>>>> when
>>>>>>>>>>>>>>>>>>> looking
>>>>>>>>>>>>>>>>>>> for
>>>>>>>>>>>>>>>>>>> a trivial such constructor.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> This also fixes an ABI difference between Clang and MSVC:
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> * If the copy constructor would be implicitly deleted
>>>>>>>>>>>>>>>>>>> (but
>>>>>>>>>>>>>>>>>>> has
>>>>>>>>>>>>>>>>>>> not
>>>>>>>>>>>>>>>>>>> been
>>>>>>>>>>>>>>>>>>> lazily declared yet), for instance because the class
>>>>>>>>>>>>>>>>>>> has
>>>>>>>>>>>>>>>>>>> an
>>>>>>>>>>>>>>>>>>> rvalue
>>>>>>>>>>>>>>>>>>> reference member, we would pass it directly. We now
>>>>>>>>>>>>>>>>>>> pass
>>>>>>>>>>>>>>>>>>> such
>>>>>>>>>>>>>>>>>>> a
>>>>>>>>>>>>>>>>>>> class
>>>>>>>>>>>>>>>>>>> indirectly, matching MSVC.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Modified:
>>>>>>>>>>>>>>>>>>> cfe/trunk/include/clang/AST/DeclCXX.h
>>>>>>>>>>>>>>>>>>> cfe/trunk/lib/AST/ASTImporter.cpp
>>>>>>>>>>>>>>>>>>> cfe/trunk/lib/AST/DeclCXX.cpp
>>>>>>>>>>>>>>>>>>> cfe/trunk/lib/CodeGen/CGCXXABI.cpp
>>>>>>>>>>>>>>>>>>> cfe/trunk/lib/CodeGen/ItaniumCXXABI.cpp
>>>>>>>>>>>>>>>>>>> cfe/trunk/lib/CodeGen/MicrosoftCXXABI.cpp
>>>>>>>>>>>>>>>>>>> cfe/trunk/lib/Sema/SemaDeclCXX.cpp
>>>>>>>>>>>>>>>>>>> cfe/trunk/lib/Serialization/ASTReaderDecl.cpp
>>>>>>>>>>>>>>>>>>> cfe/trunk/lib/Serialization/ASTWriter.cpp
>>>>>>>>>>>>>>>>>>> cfe/trunk/test/CodeGenCXX/uncopyable-args.cpp
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> cfe/trunk/unittests/ASTMatchers/ASTMatchersNarrowingTest.cpp
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Modified: cfe/trunk/include/clang/AST/DeclCXX.h
>>>>>>>>>>>>>>>>>>> URL:
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> http://llvm.org/viewvc/llvm-project/cfe/trunk/include/clang/AST/DeclCXX.h?rev=310401&r1=310400&r2=310401&view=diff
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> ==============================================================================
>>>>>>>>>>>>>>>>>>> --- cfe/trunk/include/clang/AST/DeclCXX.h (original)
>>>>>>>>>>>>>>>>>>> +++ cfe/trunk/include/clang/AST/DeclCXX.h Tue Aug 8
>>>>>>>>>>>>>>>>>>> 12:12:28
>>>>>>>>>>>>>>>>>>> 2017
>>>>>>>>>>>>>>>>>>> @@ -375,6 +375,7 @@ class CXXRecordDecl : public
>>>>>>>>>>>>>>>>>>> RecordDecl
>>>>>>>>>>>>>>>>>>> /// \brief These flags are \c true if a defaulted
>>>>>>>>>>>>>>>>>>> corresponding
>>>>>>>>>>>>>>>>>>> special
>>>>>>>>>>>>>>>>>>> /// member can't be fully analyzed without
>>>>>>>>>>>>>>>>>>> performing
>>>>>>>>>>>>>>>>>>> overload
>>>>>>>>>>>>>>>>>>> resolution.
>>>>>>>>>>>>>>>>>>> /// @{
>>>>>>>>>>>>>>>>>>> + unsigned NeedOverloadResolutionForCopyConstructor :
>>>>>>>>>>>>>>>>>>> 1;
>>>>>>>>>>>>>>>>>>> unsigned NeedOverloadResolutionForMoveConstructor
>>>>>>>>>>>>>>>>>>> : 1;
>>>>>>>>>>>>>>>>>>> unsigned NeedOverloadResolutionForMoveAssignment :
>>>>>>>>>>>>>>>>>>> 1;
>>>>>>>>>>>>>>>>>>> unsigned NeedOverloadResolutionForDestructor : 1;
>>>>>>>>>>>>>>>>>>> @@ -383,6 +384,7 @@ class CXXRecordDecl : public
>>>>>>>>>>>>>>>>>>> RecordDecl
>>>>>>>>>>>>>>>>>>> /// \brief These flags are \c true if an implicit
>>>>>>>>>>>>>>>>>>> defaulted
>>>>>>>>>>>>>>>>>>> corresponding
>>>>>>>>>>>>>>>>>>> /// special member would be defined as deleted.
>>>>>>>>>>>>>>>>>>> /// @{
>>>>>>>>>>>>>>>>>>> + unsigned DefaultedCopyConstructorIsDeleted : 1;
>>>>>>>>>>>>>>>>>>> unsigned DefaultedMoveConstructorIsDeleted : 1;
>>>>>>>>>>>>>>>>>>> unsigned DefaultedMoveAssignmentIsDeleted : 1;
>>>>>>>>>>>>>>>>>>> unsigned DefaultedDestructorIsDeleted : 1;
>>>>>>>>>>>>>>>>>>> @@ -415,6 +417,12 @@ class CXXRecordDecl : public
>>>>>>>>>>>>>>>>>>> RecordDecl
>>>>>>>>>>>>>>>>>>> /// constructor.
>>>>>>>>>>>>>>>>>>> unsigned HasDefaultedDefaultConstructor : 1;
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> + /// \brief True if this class can be passed in a
>>>>>>>>>>>>>>>>>>> non-address-preserving
>>>>>>>>>>>>>>>>>>> + /// fashion (such as in registers) according to the
>>>>>>>>>>>>>>>>>>> C++
>>>>>>>>>>>>>>>>>>> language
>>>>>>>>>>>>>>>>>>> rules.
>>>>>>>>>>>>>>>>>>> + /// This does not imply anything about how the ABI in
>>>>>>>>>>>>>>>>>>> use
>>>>>>>>>>>>>>>>>>> will
>>>>>>>>>>>>>>>>>>> actually
>>>>>>>>>>>>>>>>>>> + /// pass an object of this class.
>>>>>>>>>>>>>>>>>>> + unsigned CanPassInRegisters : 1;
>>>>>>>>>>>>>>>>>>> +
>>>>>>>>>>>>>>>>>>> /// \brief True if a defaulted default constructor
>>>>>>>>>>>>>>>>>>> for
>>>>>>>>>>>>>>>>>>> this
>>>>>>>>>>>>>>>>>>> class
>>>>>>>>>>>>>>>>>>> would
>>>>>>>>>>>>>>>>>>> /// be constexpr.
>>>>>>>>>>>>>>>>>>> unsigned DefaultedDefaultConstructorIsConstexpr :
>>>>>>>>>>>>>>>>>>> 1;
>>>>>>>>>>>>>>>>>>> @@ -811,18 +819,50 @@ public:
>>>>>>>>>>>>>>>>>>> return data().FirstFriend.isValid();
>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> + /// \brief \c true if a defaulted copy constructor for
>>>>>>>>>>>>>>>>>>> this
>>>>>>>>>>>>>>>>>>> class
>>>>>>>>>>>>>>>>>>> would
>>>>>>>>>>>>>>>>>>> be
>>>>>>>>>>>>>>>>>>> + /// deleted.
>>>>>>>>>>>>>>>>>>> + bool defaultedCopyConstructorIsDeleted() const {
>>>>>>>>>>>>>>>>>>> + assert((!needsOverloadResolutionForCopyConstructor() ||
>>>>>>>>>>>>>>>>>>> + (data().DeclaredSpecialMembers &
>>>>>>>>>>>>>>>>>>> SMF_CopyConstructor))
>>>>>>>>>>>>>>>>>>> &&
>>>>>>>>>>>>>>>>>>> + "this property has not yet been computed by
>>>>>>>>>>>>>>>>>>> Sema");
>>>>>>>>>>>>>>>>>>> + return data().DefaultedCopyConstructorIsDeleted;
>>>>>>>>>>>>>>>>>>> + }
>>>>>>>>>>>>>>>>>>> +
>>>>>>>>>>>>>>>>>>> + /// \brief \c true if a defaulted move constructor for
>>>>>>>>>>>>>>>>>>> this
>>>>>>>>>>>>>>>>>>> class
>>>>>>>>>>>>>>>>>>> would
>>>>>>>>>>>>>>>>>>> be
>>>>>>>>>>>>>>>>>>> + /// deleted.
>>>>>>>>>>>>>>>>>>> + bool defaultedMoveConstructorIsDeleted() const {
>>>>>>>>>>>>>>>>>>> + assert((!needsOverloadResolutionForMoveConstructor() ||
>>>>>>>>>>>>>>>>>>> + (data().DeclaredSpecialMembers &
>>>>>>>>>>>>>>>>>>> SMF_MoveConstructor))
>>>>>>>>>>>>>>>>>>> &&
>>>>>>>>>>>>>>>>>>> + "this property has not yet been computed by
>>>>>>>>>>>>>>>>>>> Sema");
>>>>>>>>>>>>>>>>>>> + return data().DefaultedMoveConstructorIsDeleted;
>>>>>>>>>>>>>>>>>>> + }
>>>>>>>>>>>>>>>>>>> +
>>>>>>>>>>>>>>>>>>> + /// \brief \c true if a defaulted destructor for this
>>>>>>>>>>>>>>>>>>> class
>>>>>>>>>>>>>>>>>>> would
>>>>>>>>>>>>>>>>>>> be
>>>>>>>>>>>>>>>>>>> deleted.
>>>>>>>>>>>>>>>>>>> + bool defaultedDestructorIsDeleted() const {
>>>>>>>>>>>>>>>>>>> + return !data().DefaultedDestructorIsDeleted;
>>>>>>>>>>>>>>>>>>> + }
>>>>>>>>>>>>>>>>>>> +
>>>>>>>>>>>>>>>>>>> + /// \brief \c true if we know for sure that this class
>>>>>>>>>>>>>>>>>>> has
>>>>>>>>>>>>>>>>>>> a
>>>>>>>>>>>>>>>>>>> single,
>>>>>>>>>>>>>>>>>>> + /// accessible, unambiguous copy constructor that is
>>>>>>>>>>>>>>>>>>> not
>>>>>>>>>>>>>>>>>>> deleted.
>>>>>>>>>>>>>>>>>>> + bool hasSimpleCopyConstructor() const {
>>>>>>>>>>>>>>>>>>> + return !hasUserDeclaredCopyConstructor() &&
>>>>>>>>>>>>>>>>>>> + !data().DefaultedCopyConstructorIsDeleted;
>>>>>>>>>>>>>>>>>>> + }
>>>>>>>>>>>>>>>>>>> +
>>>>>>>>>>>>>>>>>>> /// \brief \c true if we know for sure that this
>>>>>>>>>>>>>>>>>>> class
>>>>>>>>>>>>>>>>>>> has a
>>>>>>>>>>>>>>>>>>> single,
>>>>>>>>>>>>>>>>>>> /// accessible, unambiguous move constructor that is
>>>>>>>>>>>>>>>>>>> not
>>>>>>>>>>>>>>>>>>> deleted.
>>>>>>>>>>>>>>>>>>> bool hasSimpleMoveConstructor() const {
>>>>>>>>>>>>>>>>>>> return !hasUserDeclaredMoveConstructor() &&
>>>>>>>>>>>>>>>>>>> hasMoveConstructor()
>>>>>>>>>>>>>>>>>>> &&
>>>>>>>>>>>>>>>>>>> !data().DefaultedMoveConstructorIsDeleted;
>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>> +
>>>>>>>>>>>>>>>>>>> /// \brief \c true if we know for sure that this
>>>>>>>>>>>>>>>>>>> class
>>>>>>>>>>>>>>>>>>> has a
>>>>>>>>>>>>>>>>>>> single,
>>>>>>>>>>>>>>>>>>> /// accessible, unambiguous move assignment operator
>>>>>>>>>>>>>>>>>>> that is
>>>>>>>>>>>>>>>>>>> not
>>>>>>>>>>>>>>>>>>> deleted.
>>>>>>>>>>>>>>>>>>> bool hasSimpleMoveAssignment() const {
>>>>>>>>>>>>>>>>>>> return !hasUserDeclaredMoveAssignment() &&
>>>>>>>>>>>>>>>>>>> hasMoveAssignment()
>>>>>>>>>>>>>>>>>>> &&
>>>>>>>>>>>>>>>>>>> !data().DefaultedMoveAssignmentIsDeleted;
>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>> +
>>>>>>>>>>>>>>>>>>> /// \brief \c true if we know for sure that this
>>>>>>>>>>>>>>>>>>> class
>>>>>>>>>>>>>>>>>>> has an
>>>>>>>>>>>>>>>>>>> accessible
>>>>>>>>>>>>>>>>>>> /// destructor that is not deleted.
>>>>>>>>>>>>>>>>>>> bool hasSimpleDestructor() const {
>>>>>>>>>>>>>>>>>>> @@ -878,7 +918,16 @@ public:
>>>>>>>>>>>>>>>>>>> /// \brief Determine whether we need to eagerly
>>>>>>>>>>>>>>>>>>> declare
>>>>>>>>>>>>>>>>>>> a
>>>>>>>>>>>>>>>>>>> defaulted
>>>>>>>>>>>>>>>>>>> copy
>>>>>>>>>>>>>>>>>>> /// constructor for this class.
>>>>>>>>>>>>>>>>>>> bool needsOverloadResolutionForCopyConstructor()
>>>>>>>>>>>>>>>>>>> const {
>>>>>>>>>>>>>>>>>>> - return data().HasMutableFields;
>>>>>>>>>>>>>>>>>>> + // C++17 [class.copy.ctor]p6:
>>>>>>>>>>>>>>>>>>> + // If the class definition declares a move
>>>>>>>>>>>>>>>>>>> constructor
>>>>>>>>>>>>>>>>>>> or
>>>>>>>>>>>>>>>>>>> move
>>>>>>>>>>>>>>>>>>> assignment
>>>>>>>>>>>>>>>>>>> + // operator, the implicitly declared copy
>>>>>>>>>>>>>>>>>>> constructor
>>>>>>>>>>>>>>>>>>> is
>>>>>>>>>>>>>>>>>>> defined
>>>>>>>>>>>>>>>>>>> as
>>>>>>>>>>>>>>>>>>> + // deleted.
>>>>>>>>>>>>>>>>>>> + // In MSVC mode, sometimes a declared move assignment
>>>>>>>>>>>>>>>>>>> does
>>>>>>>>>>>>>>>>>>> not
>>>>>>>>>>>>>>>>>>> delete
>>>>>>>>>>>>>>>>>>> an
>>>>>>>>>>>>>>>>>>> + // implicit copy constructor, so defer this choice to
>>>>>>>>>>>>>>>>>>> Sema.
>>>>>>>>>>>>>>>>>>> + if (data().UserDeclaredSpecialMembers &
>>>>>>>>>>>>>>>>>>> + (SMF_MoveConstructor | SMF_MoveAssignment))
>>>>>>>>>>>>>>>>>>> + return true;
>>>>>>>>>>>>>>>>>>> + return
>>>>>>>>>>>>>>>>>>> data().NeedOverloadResolutionForCopyConstructor;
>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> /// \brief Determine whether an implicit copy
>>>>>>>>>>>>>>>>>>> constructor for
>>>>>>>>>>>>>>>>>>> this
>>>>>>>>>>>>>>>>>>> type
>>>>>>>>>>>>>>>>>>> @@ -919,7 +968,16 @@ public:
>>>>>>>>>>>>>>>>>>> needsImplicitMoveConstructor();
>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> - /// \brief Set that we attempted to declare an
>>>>>>>>>>>>>>>>>>> implicitly
>>>>>>>>>>>>>>>>>>> move
>>>>>>>>>>>>>>>>>>> + /// \brief Set that we attempted to declare an implicit
>>>>>>>>>>>>>>>>>>> copy
>>>>>>>>>>>>>>>>>>> + /// constructor, but overload resolution failed so we
>>>>>>>>>>>>>>>>>>> deleted
>>>>>>>>>>>>>>>>>>> it.
>>>>>>>>>>>>>>>>>>> + void setImplicitCopyConstructorIsDeleted() {
>>>>>>>>>>>>>>>>>>> + assert((data().DefaultedCopyConstructorIsDeleted ||
>>>>>>>>>>>>>>>>>>> + needsOverloadResolutionForCopyConstructor()) &&
>>>>>>>>>>>>>>>>>>> + "Copy constructor should not be deleted");
>>>>>>>>>>>>>>>>>>> + data().DefaultedCopyConstructorIsDeleted = true;
>>>>>>>>>>>>>>>>>>> + }
>>>>>>>>>>>>>>>>>>> +
>>>>>>>>>>>>>>>>>>> + /// \brief Set that we attempted to declare an implicit
>>>>>>>>>>>>>>>>>>> move
>>>>>>>>>>>>>>>>>>> /// constructor, but overload resolution failed so
>>>>>>>>>>>>>>>>>>> we
>>>>>>>>>>>>>>>>>>> deleted
>>>>>>>>>>>>>>>>>>> it.
>>>>>>>>>>>>>>>>>>> void setImplicitMoveConstructorIsDeleted() {
>>>>>>>>>>>>>>>>>>> assert((data().DefaultedMoveConstructorIsDeleted ||
>>>>>>>>>>>>>>>>>>> @@ -1316,6 +1374,18 @@ public:
>>>>>>>>>>>>>>>>>>> return data().HasIrrelevantDestructor;
>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> + /// \brief Determine whether this class has at least
>>>>>>>>>>>>>>>>>>> one
>>>>>>>>>>>>>>>>>>> trivial,
>>>>>>>>>>>>>>>>>>> non-deleted
>>>>>>>>>>>>>>>>>>> + /// copy or move constructor.
>>>>>>>>>>>>>>>>>>> + bool canPassInRegisters() const {
>>>>>>>>>>>>>>>>>>> + return data().CanPassInRegisters;
>>>>>>>>>>>>>>>>>>> + }
>>>>>>>>>>>>>>>>>>> +
>>>>>>>>>>>>>>>>>>> + /// \brief Set that we can pass this RecordDecl in
>>>>>>>>>>>>>>>>>>> registers.
>>>>>>>>>>>>>>>>>>> + // FIXME: This should be set as part of
>>>>>>>>>>>>>>>>>>> completeDefinition.
>>>>>>>>>>>>>>>>>>> + void setCanPassInRegisters(bool CanPass) {
>>>>>>>>>>>>>>>>>>> + data().CanPassInRegisters = CanPass;
>>>>>>>>>>>>>>>>>>> + }
>>>>>>>>>>>>>>>>>>> +
>>>>>>>>>>>>>>>>>>> /// \brief Determine whether this class has a
>>>>>>>>>>>>>>>>>>> non-literal or/
>>>>>>>>>>>>>>>>>>> volatile
>>>>>>>>>>>>>>>>>>> type
>>>>>>>>>>>>>>>>>>> /// non-static data member or base class.
>>>>>>>>>>>>>>>>>>> bool hasNonLiteralTypeFieldsOrBases() const {
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Modified: cfe/trunk/lib/AST/ASTImporter.cpp
>>>>>>>>>>>>>>>>>>> URL:
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/AST/ASTImporter.cpp?rev=310401&r1=310400&r2=310401&view=diff
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> ==============================================================================
>>>>>>>>>>>>>>>>>>> --- cfe/trunk/lib/AST/ASTImporter.cpp (original)
>>>>>>>>>>>>>>>>>>> +++ cfe/trunk/lib/AST/ASTImporter.cpp Tue Aug 8 12:12:28
>>>>>>>>>>>>>>>>>>> 2017
>>>>>>>>>>>>>>>>>>> @@ -956,12 +956,16 @@ bool
>>>>>>>>>>>>>>>>>>> ASTNodeImporter::ImportDefinition(R
>>>>>>>>>>>>>>>>>>> ToData.HasUninitializedFields =
>>>>>>>>>>>>>>>>>>> FromData.HasUninitializedFields;
>>>>>>>>>>>>>>>>>>> ToData.HasInheritedConstructor =
>>>>>>>>>>>>>>>>>>> FromData.HasInheritedConstructor;
>>>>>>>>>>>>>>>>>>> ToData.HasInheritedAssignment =
>>>>>>>>>>>>>>>>>>> FromData.HasInheritedAssignment;
>>>>>>>>>>>>>>>>>>> + ToData.NeedOverloadResolutionForCopyConstructor
>>>>>>>>>>>>>>>>>>> + =
>>>>>>>>>>>>>>>>>>> FromData.NeedOverloadResolutionForCopyConstructor;
>>>>>>>>>>>>>>>>>>> ToData.NeedOverloadResolutionForMoveConstructor
>>>>>>>>>>>>>>>>>>> =
>>>>>>>>>>>>>>>>>>> FromData.NeedOverloadResolutionForMoveConstructor;
>>>>>>>>>>>>>>>>>>> ToData.NeedOverloadResolutionForMoveAssignment
>>>>>>>>>>>>>>>>>>> =
>>>>>>>>>>>>>>>>>>> FromData.NeedOverloadResolutionForMoveAssignment;
>>>>>>>>>>>>>>>>>>> ToData.NeedOverloadResolutionForDestructor
>>>>>>>>>>>>>>>>>>> = FromData.NeedOverloadResolutionForDestructor;
>>>>>>>>>>>>>>>>>>> + ToData.DefaultedCopyConstructorIsDeleted
>>>>>>>>>>>>>>>>>>> + = FromData.DefaultedCopyConstructorIsDeleted;
>>>>>>>>>>>>>>>>>>> ToData.DefaultedMoveConstructorIsDeleted
>>>>>>>>>>>>>>>>>>> = FromData.DefaultedMoveConstructorIsDeleted;
>>>>>>>>>>>>>>>>>>> ToData.DefaultedMoveAssignmentIsDeleted
>>>>>>>>>>>>>>>>>>> @@ -973,6 +977,7 @@ bool
>>>>>>>>>>>>>>>>>>> ASTNodeImporter::ImportDefinition(R
>>>>>>>>>>>>>>>>>>> = FromData.HasConstexprNonCopyMoveConstructor;
>>>>>>>>>>>>>>>>>>> ToData.HasDefaultedDefaultConstructor
>>>>>>>>>>>>>>>>>>> = FromData.HasDefaultedDefaultConstructor;
>>>>>>>>>>>>>>>>>>> + ToData.CanPassInRegisters =
>>>>>>>>>>>>>>>>>>> FromData.CanPassInRegisters;
>>>>>>>>>>>>>>>>>>> ToData.DefaultedDefaultConstructorIsConstexpr
>>>>>>>>>>>>>>>>>>> =
>>>>>>>>>>>>>>>>>>> FromData.DefaultedDefaultConstructorIsConstexpr;
>>>>>>>>>>>>>>>>>>> ToData.HasConstexprDefaultConstructor
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Modified: cfe/trunk/lib/AST/DeclCXX.cpp
>>>>>>>>>>>>>>>>>>> URL:
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/AST/DeclCXX.cpp?rev=310401&r1=310400&r2=310401&view=diff
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> ==============================================================================
>>>>>>>>>>>>>>>>>>> --- cfe/trunk/lib/AST/DeclCXX.cpp (original)
>>>>>>>>>>>>>>>>>>> +++ cfe/trunk/lib/AST/DeclCXX.cpp Tue Aug 8 12:12:28 2017
>>>>>>>>>>>>>>>>>>> @@ -55,15 +55,18 @@
>>>>>>>>>>>>>>>>>>> CXXRecordDecl::DefinitionData::Definitio
>>>>>>>>>>>>>>>>>>> HasOnlyCMembers(true),
>>>>>>>>>>>>>>>>>>> HasInClassInitializer(false),
>>>>>>>>>>>>>>>>>>> HasUninitializedReferenceMember(false),
>>>>>>>>>>>>>>>>>>> HasUninitializedFields(false),
>>>>>>>>>>>>>>>>>>> HasInheritedConstructor(false),
>>>>>>>>>>>>>>>>>>> HasInheritedAssignment(false),
>>>>>>>>>>>>>>>>>>> + NeedOverloadResolutionForCopyConstructor(false),
>>>>>>>>>>>>>>>>>>> NeedOverloadResolutionForMoveConstructor(false),
>>>>>>>>>>>>>>>>>>> NeedOverloadResolutionForMoveAssignment(false),
>>>>>>>>>>>>>>>>>>> NeedOverloadResolutionForDestructor(false),
>>>>>>>>>>>>>>>>>>> + DefaultedCopyConstructorIsDeleted(false),
>>>>>>>>>>>>>>>>>>> DefaultedMoveConstructorIsDeleted(false),
>>>>>>>>>>>>>>>>>>> DefaultedMoveAssignmentIsDeleted(false),
>>>>>>>>>>>>>>>>>>> DefaultedDestructorIsDeleted(false),
>>>>>>>>>>>>>>>>>>> HasTrivialSpecialMembers(SMF_All),
>>>>>>>>>>>>>>>>>>> DeclaredNonTrivialSpecialMembers(0),
>>>>>>>>>>>>>>>>>>> HasIrrelevantDestructor(true),
>>>>>>>>>>>>>>>>>>> HasConstexprNonCopyMoveConstructor(false),
>>>>>>>>>>>>>>>>>>> HasDefaultedDefaultConstructor(false),
>>>>>>>>>>>>>>>>>>> + CanPassInRegisters(false),
>>>>>>>>>>>>>>>>>>> DefaultedDefaultConstructorIsConstexpr(true),
>>>>>>>>>>>>>>>>>>> HasConstexprDefaultConstructor(false),
>>>>>>>>>>>>>>>>>>> HasNonLiteralTypeFieldsOrBases(false),
>>>>>>>>>>>>>>>>>>> ComputedVisibleConversions(false),
>>>>>>>>>>>>>>>>>>> @@ -352,8 +355,10 @@
>>>>>>>>>>>>>>>>>>> CXXRecordDecl::setBases(CXXBaseSpecifier
>>>>>>>>>>>>>>>>>>> setHasVolatileMember(true);
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> // Keep track of the presence of mutable fields.
>>>>>>>>>>>>>>>>>>> - if (BaseClassDecl->hasMutableFields())
>>>>>>>>>>>>>>>>>>> + if (BaseClassDecl->hasMutableFields()) {
>>>>>>>>>>>>>>>>>>> data().HasMutableFields = true;
>>>>>>>>>>>>>>>>>>> + data().NeedOverloadResolutionForCopyConstructor =
>>>>>>>>>>>>>>>>>>> true;
>>>>>>>>>>>>>>>>>>> + }
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> if
>>>>>>>>>>>>>>>>>>> (BaseClassDecl->hasUninitializedReferenceMember())
>>>>>>>>>>>>>>>>>>> data().HasUninitializedReferenceMember = true;
>>>>>>>>>>>>>>>>>>> @@ -406,6 +411,8 @@ void
>>>>>>>>>>>>>>>>>>> CXXRecordDecl::addedClassSubobject(
>>>>>>>>>>>>>>>>>>> // -- a direct or virtual base class B that
>>>>>>>>>>>>>>>>>>> cannot be
>>>>>>>>>>>>>>>>>>> copied/moved
>>>>>>>>>>>>>>>>>>> [...]
>>>>>>>>>>>>>>>>>>> // -- a non-static data member of class type M
>>>>>>>>>>>>>>>>>>> (or
>>>>>>>>>>>>>>>>>>> array
>>>>>>>>>>>>>>>>>>> thereof)
>>>>>>>>>>>>>>>>>>> // that cannot be copied or moved [...]
>>>>>>>>>>>>>>>>>>> + if (!Subobj->hasSimpleCopyConstructor())
>>>>>>>>>>>>>>>>>>> + data().NeedOverloadResolutionForCopyConstructor = true;
>>>>>>>>>>>>>>>>>>> if (!Subobj->hasSimpleMoveConstructor())
>>>>>>>>>>>>>>>>>>> data().NeedOverloadResolutionForMoveConstructor =
>>>>>>>>>>>>>>>>>>> true;
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> @@ -426,6 +433,7 @@ void
>>>>>>>>>>>>>>>>>>> CXXRecordDecl::addedClassSubobject(
>>>>>>>>>>>>>>>>>>> // -- any non-static data member has a type with
>>>>>>>>>>>>>>>>>>> a
>>>>>>>>>>>>>>>>>>> destructor
>>>>>>>>>>>>>>>>>>> // that is deleted or inaccessible from the
>>>>>>>>>>>>>>>>>>> defaulted
>>>>>>>>>>>>>>>>>>> [ctor or
>>>>>>>>>>>>>>>>>>> dtor].
>>>>>>>>>>>>>>>>>>> if (!Subobj->hasSimpleDestructor()) {
>>>>>>>>>>>>>>>>>>> + data().NeedOverloadResolutionForCopyConstructor = true;
>>>>>>>>>>>>>>>>>>> data().NeedOverloadResolutionForMoveConstructor =
>>>>>>>>>>>>>>>>>>> true;
>>>>>>>>>>>>>>>>>>> data().NeedOverloadResolutionForDestructor = true;
>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>> @@ -711,8 +719,10 @@ void CXXRecordDecl::addedMember(Decl
>>>>>>>>>>>>>>>>>>> *D)
>>>>>>>>>>>>>>>>>>> data().IsStandardLayout = false;
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> // Keep track of the presence of mutable fields.
>>>>>>>>>>>>>>>>>>> - if (Field->isMutable())
>>>>>>>>>>>>>>>>>>> + if (Field->isMutable()) {
>>>>>>>>>>>>>>>>>>> data().HasMutableFields = true;
>>>>>>>>>>>>>>>>>>> + data().NeedOverloadResolutionForCopyConstructor =
>>>>>>>>>>>>>>>>>>> true;
>>>>>>>>>>>>>>>>>>> + }
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> // C++11 [class.union]p8, DR1460:
>>>>>>>>>>>>>>>>>>> // If X is a union, a non-static data member of
>>>>>>>>>>>>>>>>>>> X
>>>>>>>>>>>>>>>>>>> that is
>>>>>>>>>>>>>>>>>>> not an
>>>>>>>>>>>>>>>>>>> anonymous
>>>>>>>>>>>>>>>>>>> @@ -756,6 +766,12 @@ void CXXRecordDecl::addedMember(Decl
>>>>>>>>>>>>>>>>>>> *D)
>>>>>>>>>>>>>>>>>>> // A standard-layout class is a class that:
>>>>>>>>>>>>>>>>>>> // -- has no non-static data members of type
>>>>>>>>>>>>>>>>>>> [...]
>>>>>>>>>>>>>>>>>>> reference,
>>>>>>>>>>>>>>>>>>> data().IsStandardLayout = false;
>>>>>>>>>>>>>>>>>>> +
>>>>>>>>>>>>>>>>>>> + // C++1z [class.copy.ctor]p10:
>>>>>>>>>>>>>>>>>>> + // A defaulted copy constructor for a class X is
>>>>>>>>>>>>>>>>>>> defined
>>>>>>>>>>>>>>>>>>> as
>>>>>>>>>>>>>>>>>>> deleted if X has:
>>>>>>>>>>>>>>>>>>> + // -- a non-static data member of rvalue
>>>>>>>>>>>>>>>>>>> reference
>>>>>>>>>>>>>>>>>>> type
>>>>>>>>>>>>>>>>>>> + if (T->isRValueReferenceType())
>>>>>>>>>>>>>>>>>>> + data().DefaultedCopyConstructorIsDeleted = true;
>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> if (!Field->hasInClassInitializer() &&
>>>>>>>>>>>>>>>>>>> !Field->isMutable())
>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>> @@ -809,6 +825,10 @@ void CXXRecordDecl::addedMember(Decl
>>>>>>>>>>>>>>>>>>> *D)
>>>>>>>>>>>>>>>>>>> // We may need to perform overload resolution
>>>>>>>>>>>>>>>>>>> to
>>>>>>>>>>>>>>>>>>> determine
>>>>>>>>>>>>>>>>>>> whether a
>>>>>>>>>>>>>>>>>>> // field can be moved if it's const or
>>>>>>>>>>>>>>>>>>> volatile
>>>>>>>>>>>>>>>>>>> qualified.
>>>>>>>>>>>>>>>>>>> if (T.getCVRQualifiers() & (Qualifiers::Const
>>>>>>>>>>>>>>>>>>> |
>>>>>>>>>>>>>>>>>>> Qualifiers::Volatile)) {
>>>>>>>>>>>>>>>>>>> + // We need to care about 'const' for the copy
>>>>>>>>>>>>>>>>>>> constructor
>>>>>>>>>>>>>>>>>>> because an
>>>>>>>>>>>>>>>>>>> + // implicit copy constructor might be declared
>>>>>>>>>>>>>>>>>>> with a
>>>>>>>>>>>>>>>>>>> non-const
>>>>>>>>>>>>>>>>>>> + // parameter.
>>>>>>>>>>>>>>>>>>> + data().NeedOverloadResolutionForCopyConstructor =
>>>>>>>>>>>>>>>>>>> true;
>>>>>>>>>>>>>>>>>>> data().NeedOverloadResolutionForMoveConstructor
>>>>>>>>>>>>>>>>>>> =
>>>>>>>>>>>>>>>>>>> true;
>>>>>>>>>>>>>>>>>>> data().NeedOverloadResolutionForMoveAssignment =
>>>>>>>>>>>>>>>>>>> true;
>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>> @@ -819,6 +839,8 @@ void CXXRecordDecl::addedMember(Decl
>>>>>>>>>>>>>>>>>>> *D)
>>>>>>>>>>>>>>>>>>> // -- X is a union-like class that has a
>>>>>>>>>>>>>>>>>>> variant
>>>>>>>>>>>>>>>>>>> member
>>>>>>>>>>>>>>>>>>> with a
>>>>>>>>>>>>>>>>>>> // non-trivial [corresponding special
>>>>>>>>>>>>>>>>>>> member]
>>>>>>>>>>>>>>>>>>> if (isUnion()) {
>>>>>>>>>>>>>>>>>>> + if (FieldRec->hasNonTrivialCopyConstructor())
>>>>>>>>>>>>>>>>>>> + data().DefaultedCopyConstructorIsDeleted = true;
>>>>>>>>>>>>>>>>>>> if
>>>>>>>>>>>>>>>>>>> (FieldRec->hasNonTrivialMoveConstructor())
>>>>>>>>>>>>>>>>>>> data().DefaultedMoveConstructorIsDeleted =
>>>>>>>>>>>>>>>>>>> true;
>>>>>>>>>>>>>>>>>>> if (FieldRec->hasNonTrivialMoveAssignment())
>>>>>>>>>>>>>>>>>>> @@ -830,6 +852,8 @@ void CXXRecordDecl::addedMember(Decl
>>>>>>>>>>>>>>>>>>> *D)
>>>>>>>>>>>>>>>>>>> // For an anonymous union member, our overload
>>>>>>>>>>>>>>>>>>> resolution
>>>>>>>>>>>>>>>>>>> will
>>>>>>>>>>>>>>>>>>> perform
>>>>>>>>>>>>>>>>>>> // overload resolution for its members.
>>>>>>>>>>>>>>>>>>> if (Field->isAnonymousStructOrUnion()) {
>>>>>>>>>>>>>>>>>>> + data().NeedOverloadResolutionForCopyConstructor |=
>>>>>>>>>>>>>>>>>>> +
>>>>>>>>>>>>>>>>>>> FieldRec->data().NeedOverloadResolutionForCopyConstructor;
>>>>>>>>>>>>>>>>>>> data().NeedOverloadResolutionForMoveConstructor
>>>>>>>>>>>>>>>>>>> |=
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> FieldRec->data().NeedOverloadResolutionForMoveConstructor;
>>>>>>>>>>>>>>>>>>> data().NeedOverloadResolutionForMoveAssignment
>>>>>>>>>>>>>>>>>>> |=
>>>>>>>>>>>>>>>>>>> @@ -915,8 +939,10 @@ void CXXRecordDecl::addedMember(Decl
>>>>>>>>>>>>>>>>>>> *D)
>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> // Keep track of the presence of mutable
>>>>>>>>>>>>>>>>>>> fields.
>>>>>>>>>>>>>>>>>>> - if (FieldRec->hasMutableFields())
>>>>>>>>>>>>>>>>>>> + if (FieldRec->hasMutableFields()) {
>>>>>>>>>>>>>>>>>>> data().HasMutableFields = true;
>>>>>>>>>>>>>>>>>>> + data().NeedOverloadResolutionForCopyConstructor =
>>>>>>>>>>>>>>>>>>> true;
>>>>>>>>>>>>>>>>>>> + }
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> // C++11 [class.copy]p13:
>>>>>>>>>>>>>>>>>>> // If the implicitly-defined constructor
>>>>>>>>>>>>>>>>>>> would
>>>>>>>>>>>>>>>>>>> satisfy
>>>>>>>>>>>>>>>>>>> the
>>>>>>>>>>>>>>>>>>> @@ -1450,7 +1476,7 @@ void
>>>>>>>>>>>>>>>>>>> CXXRecordDecl::completeDefinition()
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> void
>>>>>>>>>>>>>>>>>>> CXXRecordDecl::completeDefinition(CXXFinalOverriderMap
>>>>>>>>>>>>>>>>>>> *FinalOverriders) {
>>>>>>>>>>>>>>>>>>> RecordDecl::completeDefinition();
>>>>>>>>>>>>>>>>>>> -
>>>>>>>>>>>>>>>>>>> +
>>>>>>>>>>>>>>>>>>> // If the class may be abstract (but hasn't been
>>>>>>>>>>>>>>>>>>> marked
>>>>>>>>>>>>>>>>>>> as
>>>>>>>>>>>>>>>>>>> such),
>>>>>>>>>>>>>>>>>>> check
>>>>>>>>>>>>>>>>>>> for
>>>>>>>>>>>>>>>>>>> // any pure final overriders.
>>>>>>>>>>>>>>>>>>> if (mayBeAbstract()) {
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Modified: cfe/trunk/lib/CodeGen/CGCXXABI.cpp
>>>>>>>>>>>>>>>>>>> URL:
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/CodeGen/CGCXXABI.cpp?rev=310401&r1=310400&r2=310401&view=diff
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> ==============================================================================
>>>>>>>>>>>>>>>>>>> --- cfe/trunk/lib/CodeGen/CGCXXABI.cpp (original)
>>>>>>>>>>>>>>>>>>> +++ cfe/trunk/lib/CodeGen/CGCXXABI.cpp Tue Aug 8 12:12:28
>>>>>>>>>>>>>>>>>>> 2017
>>>>>>>>>>>>>>>>>>> @@ -30,38 +30,9 @@ void
>>>>>>>>>>>>>>>>>>> CGCXXABI::ErrorUnsupportedABI(CodeG
>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> bool CGCXXABI::canCopyArgument(const CXXRecordDecl
>>>>>>>>>>>>>>>>>>> *RD)
>>>>>>>>>>>>>>>>>>> const {
>>>>>>>>>>>>>>>>>>> - // If RD has a non-trivial move or copy constructor, we
>>>>>>>>>>>>>>>>>>> cannot
>>>>>>>>>>>>>>>>>>> copy
>>>>>>>>>>>>>>>>>>> the
>>>>>>>>>>>>>>>>>>> - // argument.
>>>>>>>>>>>>>>>>>>> - if (RD->hasNonTrivialCopyConstructor() ||
>>>>>>>>>>>>>>>>>>> RD->hasNonTrivialMoveConstructor())
>>>>>>>>>>>>>>>>>>> - return false;
>>>>>>>>>>>>>>>>>>> -
>>>>>>>>>>>>>>>>>>> - // If RD has a non-trivial destructor, we cannot copy
>>>>>>>>>>>>>>>>>>> the
>>>>>>>>>>>>>>>>>>> argument.
>>>>>>>>>>>>>>>>>>> - if (RD->hasNonTrivialDestructor())
>>>>>>>>>>>>>>>>>>> - return false;
>>>>>>>>>>>>>>>>>>> -
>>>>>>>>>>>>>>>>>>> // We can only copy the argument if there exists at
>>>>>>>>>>>>>>>>>>> least one
>>>>>>>>>>>>>>>>>>> trivial,
>>>>>>>>>>>>>>>>>>> // non-deleted copy or move constructor.
>>>>>>>>>>>>>>>>>>> - // FIXME: This assumes that all lazily declared copy
>>>>>>>>>>>>>>>>>>> and
>>>>>>>>>>>>>>>>>>> move
>>>>>>>>>>>>>>>>>>> constructors are
>>>>>>>>>>>>>>>>>>> - // not deleted. This assumption might not be true in
>>>>>>>>>>>>>>>>>>> some
>>>>>>>>>>>>>>>>>>> corner
>>>>>>>>>>>>>>>>>>> cases.
>>>>>>>>>>>>>>>>>>> - bool CopyDeleted = false;
>>>>>>>>>>>>>>>>>>> - bool MoveDeleted = false;
>>>>>>>>>>>>>>>>>>> - for (const CXXConstructorDecl *CD : RD->ctors()) {
>>>>>>>>>>>>>>>>>>> - if (CD->isCopyConstructor() ||
>>>>>>>>>>>>>>>>>>> CD->isMoveConstructor())
>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>> - assert(CD->isTrivial());
>>>>>>>>>>>>>>>>>>> - // We had at least one undeleted trivial copy or
>>>>>>>>>>>>>>>>>>> move
>>>>>>>>>>>>>>>>>>> ctor.
>>>>>>>>>>>>>>>>>>> Return
>>>>>>>>>>>>>>>>>>> - // directly.
>>>>>>>>>>>>>>>>>>> - if (!CD->isDeleted())
>>>>>>>>>>>>>>>>>>> - return true;
>>>>>>>>>>>>>>>>>>> - if (CD->isCopyConstructor())
>>>>>>>>>>>>>>>>>>> - CopyDeleted = true;
>>>>>>>>>>>>>>>>>>> - else
>>>>>>>>>>>>>>>>>>> - MoveDeleted = true;
>>>>>>>>>>>>>>>>>>> - }
>>>>>>>>>>>>>>>>>>> - }
>>>>>>>>>>>>>>>>>>> -
>>>>>>>>>>>>>>>>>>> - // If all trivial copy and move constructors are
>>>>>>>>>>>>>>>>>>> deleted,
>>>>>>>>>>>>>>>>>>> we
>>>>>>>>>>>>>>>>>>> cannot
>>>>>>>>>>>>>>>>>>> copy the
>>>>>>>>>>>>>>>>>>> - // argument.
>>>>>>>>>>>>>>>>>>> - return !(CopyDeleted && MoveDeleted);
>>>>>>>>>>>>>>>>>>> + return RD->canPassInRegisters();
>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> llvm::Constant
>>>>>>>>>>>>>>>>>>> *CGCXXABI::GetBogusMemberPointer(QualType
>>>>>>>>>>>>>>>>>>> T) {
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Modified: cfe/trunk/lib/CodeGen/ItaniumCXXABI.cpp
>>>>>>>>>>>>>>>>>>> URL:
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/CodeGen/ItaniumCXXABI.cpp?rev=310401&r1=310400&r2=310401&view=diff
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> ==============================================================================
>>>>>>>>>>>>>>>>>>> --- cfe/trunk/lib/CodeGen/ItaniumCXXABI.cpp (original)
>>>>>>>>>>>>>>>>>>> +++ cfe/trunk/lib/CodeGen/ItaniumCXXABI.cpp Tue Aug 8
>>>>>>>>>>>>>>>>>>> 12:12:28
>>>>>>>>>>>>>>>>>>> 2017
>>>>>>>>>>>>>>>>>>> @@ -63,11 +63,8 @@ public:
>>>>>>>>>>>>>>>>>>> bool classifyReturnType(CGFunctionInfo &FI) const
>>>>>>>>>>>>>>>>>>> override;
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> RecordArgABI getRecordArgABI(const CXXRecordDecl
>>>>>>>>>>>>>>>>>>> *RD)
>>>>>>>>>>>>>>>>>>> const
>>>>>>>>>>>>>>>>>>> override
>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>> - // Structures with either a non-trivial destructor or
>>>>>>>>>>>>>>>>>>> a
>>>>>>>>>>>>>>>>>>> non-trivial
>>>>>>>>>>>>>>>>>>> - // copy constructor are always indirect.
>>>>>>>>>>>>>>>>>>> - // FIXME: Use canCopyArgument() when it is fixed to
>>>>>>>>>>>>>>>>>>> handle
>>>>>>>>>>>>>>>>>>> lazily
>>>>>>>>>>>>>>>>>>> declared
>>>>>>>>>>>>>>>>>>> - // special members.
>>>>>>>>>>>>>>>>>>> - if (RD->hasNonTrivialDestructor() ||
>>>>>>>>>>>>>>>>>>> RD->hasNonTrivialCopyConstructor())
>>>>>>>>>>>>>>>>>>> + // If C++ prohibits us from making a copy, pass by
>>>>>>>>>>>>>>>>>>> address.
>>>>>>>>>>>>>>>>>>> + if (!canCopyArgument(RD))
>>>>>>>>>>>>>>>>>>> return RAA_Indirect;
>>>>>>>>>>>>>>>>>>> return RAA_Default;
>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>> @@ -1014,10 +1011,8 @@ bool
>>>>>>>>>>>>>>>>>>> ItaniumCXXABI::classifyReturnType(C
>>>>>>>>>>>>>>>>>>> if (!RD)
>>>>>>>>>>>>>>>>>>> return false;
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> - // Return indirectly if we have a non-trivial copy ctor
>>>>>>>>>>>>>>>>>>> or
>>>>>>>>>>>>>>>>>>> non-trivial
>>>>>>>>>>>>>>>>>>> dtor.
>>>>>>>>>>>>>>>>>>> - // FIXME: Use canCopyArgument() when it is fixed to
>>>>>>>>>>>>>>>>>>> handle
>>>>>>>>>>>>>>>>>>> lazily
>>>>>>>>>>>>>>>>>>> declared
>>>>>>>>>>>>>>>>>>> - // special members.
>>>>>>>>>>>>>>>>>>> - if (RD->hasNonTrivialDestructor() ||
>>>>>>>>>>>>>>>>>>> RD->hasNonTrivialCopyConstructor()) {
>>>>>>>>>>>>>>>>>>> + // If C++ prohibits us from making a copy, return by
>>>>>>>>>>>>>>>>>>> address.
>>>>>>>>>>>>>>>>>>> + if (!canCopyArgument(RD)) {
>>>>>>>>>>>>>>>>>>> auto Align =
>>>>>>>>>>>>>>>>>>> CGM.getContext().getTypeAlignInChars(FI.getReturnType());
>>>>>>>>>>>>>>>>>>> FI.getReturnInfo() =
>>>>>>>>>>>>>>>>>>> ABIArgInfo::getIndirect(Align,
>>>>>>>>>>>>>>>>>>> /*ByVal=*/false);
>>>>>>>>>>>>>>>>>>> return true;
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Modified: cfe/trunk/lib/CodeGen/MicrosoftCXXABI.cpp
>>>>>>>>>>>>>>>>>>> URL:
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/CodeGen/MicrosoftCXXABI.cpp?rev=310401&r1=310400&r2=310401&view=diff
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> ==============================================================================
>>>>>>>>>>>>>>>>>>> --- cfe/trunk/lib/CodeGen/MicrosoftCXXABI.cpp (original)
>>>>>>>>>>>>>>>>>>> +++ cfe/trunk/lib/CodeGen/MicrosoftCXXABI.cpp Tue Aug 8
>>>>>>>>>>>>>>>>>>> 12:12:28
>>>>>>>>>>>>>>>>>>> 2017
>>>>>>>>>>>>>>>>>>> @@ -819,46 +819,44 @@
>>>>>>>>>>>>>>>>>>> MicrosoftCXXABI::getRecordArgABI(const
>>>>>>>>>>>>>>>>>>> C
>>>>>>>>>>>>>>>>>>> return RAA_Default;
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> case llvm::Triple::x86_64:
>>>>>>>>>>>>>>>>>>> - // Win64 passes objects with non-trivial copy ctors
>>>>>>>>>>>>>>>>>>> indirectly.
>>>>>>>>>>>>>>>>>>> - if (RD->hasNonTrivialCopyConstructor())
>>>>>>>>>>>>>>>>>>> - return RAA_Indirect;
>>>>>>>>>>>>>>>>>>> -
>>>>>>>>>>>>>>>>>>> - // If an object has a destructor, we'd really like to
>>>>>>>>>>>>>>>>>>> pass it
>>>>>>>>>>>>>>>>>>> indirectly
>>>>>>>>>>>>>>>>>>> + // If a class has a destructor, we'd really like to
>>>>>>>>>>>>>>>>>>> pass
>>>>>>>>>>>>>>>>>>> it
>>>>>>>>>>>>>>>>>>> indirectly
>>>>>>>>>>>>>>>>>>> // because it allows us to elide copies.
>>>>>>>>>>>>>>>>>>> Unfortunately,
>>>>>>>>>>>>>>>>>>> MSVC
>>>>>>>>>>>>>>>>>>> makes
>>>>>>>>>>>>>>>>>>> that
>>>>>>>>>>>>>>>>>>> // impossible for small types, which it will pass
>>>>>>>>>>>>>>>>>>> in a
>>>>>>>>>>>>>>>>>>> single
>>>>>>>>>>>>>>>>>>> register or
>>>>>>>>>>>>>>>>>>> // stack slot. Most objects with dtors are
>>>>>>>>>>>>>>>>>>> large-ish,
>>>>>>>>>>>>>>>>>>> so
>>>>>>>>>>>>>>>>>>> handle
>>>>>>>>>>>>>>>>>>> that
>>>>>>>>>>>>>>>>>>> early.
>>>>>>>>>>>>>>>>>>> // We can't call out all large objects as being
>>>>>>>>>>>>>>>>>>> indirect
>>>>>>>>>>>>>>>>>>> because
>>>>>>>>>>>>>>>>>>> there are
>>>>>>>>>>>>>>>>>>> // multiple x64 calling conventions and the C++
>>>>>>>>>>>>>>>>>>> ABI
>>>>>>>>>>>>>>>>>>> code
>>>>>>>>>>>>>>>>>>> shouldn't
>>>>>>>>>>>>>>>>>>> dictate
>>>>>>>>>>>>>>>>>>> // how we pass large POD types.
>>>>>>>>>>>>>>>>>>> + //
>>>>>>>>>>>>>>>>>>> + // Note: This permits small classes with nontrivial
>>>>>>>>>>>>>>>>>>> destructors
>>>>>>>>>>>>>>>>>>> to
>>>>>>>>>>>>>>>>>>> be
>>>>>>>>>>>>>>>>>>> + // passed in registers, which is non-conforming.
>>>>>>>>>>>>>>>>>>> if (RD->hasNonTrivialDestructor() &&
>>>>>>>>>>>>>>>>>>> getContext().getTypeSize(RD->getTypeForDecl()) >
>>>>>>>>>>>>>>>>>>> 64)
>>>>>>>>>>>>>>>>>>> return RAA_Indirect;
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> - // If this is true, the implicit copy constructor
>>>>>>>>>>>>>>>>>>> that
>>>>>>>>>>>>>>>>>>> Sema
>>>>>>>>>>>>>>>>>>> would
>>>>>>>>>>>>>>>>>>> have
>>>>>>>>>>>>>>>>>>> - // created would not be deleted. FIXME: We should
>>>>>>>>>>>>>>>>>>> provide a
>>>>>>>>>>>>>>>>>>> more
>>>>>>>>>>>>>>>>>>> direct way
>>>>>>>>>>>>>>>>>>> - // for CodeGen to ask whether the constructor was
>>>>>>>>>>>>>>>>>>> deleted.
>>>>>>>>>>>>>>>>>>> - if (!RD->hasUserDeclaredCopyConstructor() &&
>>>>>>>>>>>>>>>>>>> - !RD->hasUserDeclaredMoveConstructor() &&
>>>>>>>>>>>>>>>>>>> - !RD->needsOverloadResolutionForMoveConstructor() &&
>>>>>>>>>>>>>>>>>>> - !RD->hasUserDeclaredMoveAssignment() &&
>>>>>>>>>>>>>>>>>>> - !RD->needsOverloadResolutionForMoveAssignment())
>>>>>>>>>>>>>>>>>>> - return RAA_Default;
>>>>>>>>>>>>>>>>>>> -
>>>>>>>>>>>>>>>>>>> - // Otherwise, Sema should have created an implicit
>>>>>>>>>>>>>>>>>>> copy
>>>>>>>>>>>>>>>>>>> constructor
>>>>>>>>>>>>>>>>>>> if
>>>>>>>>>>>>>>>>>>> - // needed.
>>>>>>>>>>>>>>>>>>> - assert(!RD->needsImplicitCopyConstructor());
>>>>>>>>>>>>>>>>>>> -
>>>>>>>>>>>>>>>>>>> - // We have to make sure the trivial copy constructor
>>>>>>>>>>>>>>>>>>> isn't
>>>>>>>>>>>>>>>>>>> deleted.
>>>>>>>>>>>>>>>>>>> - for (const CXXConstructorDecl *CD : RD->ctors()) {
>>>>>>>>>>>>>>>>>>> - if (CD->isCopyConstructor()) {
>>>>>>>>>>>>>>>>>>> - assert(CD->isTrivial());
>>>>>>>>>>>>>>>>>>> - // We had at least one undeleted trivial copy
>>>>>>>>>>>>>>>>>>> ctor.
>>>>>>>>>>>>>>>>>>> Return
>>>>>>>>>>>>>>>>>>> directly.
>>>>>>>>>>>>>>>>>>> - if (!CD->isDeleted())
>>>>>>>>>>>>>>>>>>> - return RAA_Default;
>>>>>>>>>>>>>>>>>>> + // If a class has at least one non-deleted, trivial
>>>>>>>>>>>>>>>>>>> copy
>>>>>>>>>>>>>>>>>>> constructor,
>>>>>>>>>>>>>>>>>>> it
>>>>>>>>>>>>>>>>>>> + // is passed according to the C ABI. Otherwise, it is
>>>>>>>>>>>>>>>>>>> passed
>>>>>>>>>>>>>>>>>>> indirectly.
>>>>>>>>>>>>>>>>>>> + //
>>>>>>>>>>>>>>>>>>> + // Note: This permits classes with non-trivial copy
>>>>>>>>>>>>>>>>>>> or
>>>>>>>>>>>>>>>>>>> move
>>>>>>>>>>>>>>>>>>> ctors
>>>>>>>>>>>>>>>>>>> to
>>>>>>>>>>>>>>>>>>> be
>>>>>>>>>>>>>>>>>>> + // passed in registers, so long as they *also* have a
>>>>>>>>>>>>>>>>>>> trivial
>>>>>>>>>>>>>>>>>>> copy
>>>>>>>>>>>>>>>>>>> ctor,
>>>>>>>>>>>>>>>>>>> + // which is non-conforming.
>>>>>>>>>>>>>>>>>>> + if (RD->needsImplicitCopyConstructor()) {
>>>>>>>>>>>>>>>>>>> + // If the copy ctor has not yet been declared, we
>>>>>>>>>>>>>>>>>>> can
>>>>>>>>>>>>>>>>>>> read
>>>>>>>>>>>>>>>>>>> its
>>>>>>>>>>>>>>>>>>> triviality
>>>>>>>>>>>>>>>>>>> + // off the AST.
>>>>>>>>>>>>>>>>>>> + if (!RD->defaultedCopyConstructorIsDeleted() &&
>>>>>>>>>>>>>>>>>>> + RD->hasTrivialCopyConstructor())
>>>>>>>>>>>>>>>>>>> + return RAA_Default;
>>>>>>>>>>>>>>>>>>> + } else {
>>>>>>>>>>>>>>>>>>> + // Otherwise, we need to find the copy
>>>>>>>>>>>>>>>>>>> constructor(s)
>>>>>>>>>>>>>>>>>>> and
>>>>>>>>>>>>>>>>>>> ask.
>>>>>>>>>>>>>>>>>>> + for (const CXXConstructorDecl *CD : RD->ctors()) {
>>>>>>>>>>>>>>>>>>> + if (CD->isCopyConstructor()) {
>>>>>>>>>>>>>>>>>>> + // We had at least one nondeleted trivial copy
>>>>>>>>>>>>>>>>>>> ctor.
>>>>>>>>>>>>>>>>>>> Return
>>>>>>>>>>>>>>>>>>> directly.
>>>>>>>>>>>>>>>>>>> + if (!CD->isDeleted() && CD->isTrivial())
>>>>>>>>>>>>>>>>>>> + return RAA_Default;
>>>>>>>>>>>>>>>>>>> + }
>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> - // The trivial copy constructor was deleted. Return
>>>>>>>>>>>>>>>>>>> indirectly.
>>>>>>>>>>>>>>>>>>> + // We have no trivial, non-deleted copy constructor.
>>>>>>>>>>>>>>>>>>> return RAA_Indirect;
>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Modified: cfe/trunk/lib/Sema/SemaDeclCXX.cpp
>>>>>>>>>>>>>>>>>>> URL:
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/Sema/SemaDeclCXX.cpp?rev=310401&r1=310400&r2=310401&view=diff
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> ==============================================================================
>>>>>>>>>>>>>>>>>>> --- cfe/trunk/lib/Sema/SemaDeclCXX.cpp (original)
>>>>>>>>>>>>>>>>>>> +++ cfe/trunk/lib/Sema/SemaDeclCXX.cpp Tue Aug 8 12:12:28
>>>>>>>>>>>>>>>>>>> 2017
>>>>>>>>>>>>>>>>>>> @@ -5726,6 +5726,53 @@ static void
>>>>>>>>>>>>>>>>>>> DefineImplicitSpecialMember(
>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> +/// Determine whether a type is permitted to be passed or
>>>>>>>>>>>>>>>>>>> returned
>>>>>>>>>>>>>>>>>>> in
>>>>>>>>>>>>>>>>>>> +/// registers, per C++ [class.temporary]p3.
>>>>>>>>>>>>>>>>>>> +static bool computeCanPassInRegisters(Sema &S,
>>>>>>>>>>>>>>>>>>> CXXRecordDecl
>>>>>>>>>>>>>>>>>>> *D)
>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>> + if (D->isDependentType() || D->isInvalidDecl())
>>>>>>>>>>>>>>>>>>> + return false;
>>>>>>>>>>>>>>>>>>> +
>>>>>>>>>>>>>>>>>>> + // Per C++ [class.temporary]p3, the relevant condition
>>>>>>>>>>>>>>>>>>> is:
>>>>>>>>>>>>>>>>>>> + // each copy constructor, move constructor, and
>>>>>>>>>>>>>>>>>>> destructor of
>>>>>>>>>>>>>>>>>>> X
>>>>>>>>>>>>>>>>>>> is
>>>>>>>>>>>>>>>>>>> + // either trivial or deleted, and X has at least one
>>>>>>>>>>>>>>>>>>> non-deleted
>>>>>>>>>>>>>>>>>>> copy
>>>>>>>>>>>>>>>>>>> + // or move constructor
>>>>>>>>>>>>>>>>>>> + bool HasNonDeletedCopyOrMove = false;
>>>>>>>>>>>>>>>>>>> +
>>>>>>>>>>>>>>>>>>> + if (D->needsImplicitCopyConstructor() &&
>>>>>>>>>>>>>>>>>>> + !D->defaultedCopyConstructorIsDeleted()) {
>>>>>>>>>>>>>>>>>>> + if (!D->hasTrivialCopyConstructor())
>>>>>>>>>>>>>>>>>>> + return false;
>>>>>>>>>>>>>>>>>>> + HasNonDeletedCopyOrMove = true;
>>>>>>>>>>>>>>>>>>> + }
>>>>>>>>>>>>>>>>>>> +
>>>>>>>>>>>>>>>>>>> + if (S.getLangOpts().CPlusPlus11 &&
>>>>>>>>>>>>>>>>>>> D->needsImplicitMoveConstructor()
>>>>>>>>>>>>>>>>>>> &&
>>>>>>>>>>>>>>>>>>> + !D->defaultedMoveConstructorIsDeleted()) {
>>>>>>>>>>>>>>>>>>> + if (!D->hasTrivialMoveConstructor())
>>>>>>>>>>>>>>>>>>> + return false;
>>>>>>>>>>>>>>>>>>> + HasNonDeletedCopyOrMove = true;
>>>>>>>>>>>>>>>>>>> + }
>>>>>>>>>>>>>>>>>>> +
>>>>>>>>>>>>>>>>>>> + if (D->needsImplicitDestructor() &&
>>>>>>>>>>>>>>>>>>> !D->defaultedDestructorIsDeleted()
>>>>>>>>>>>>>>>>>>> &&
>>>>>>>>>>>>>>>>>>> + !D->hasTrivialDestructor())
>>>>>>>>>>>>>>>>>>> + return false;
>>>>>>>>>>>>>>>>>>> +
>>>>>>>>>>>>>>>>>>> + for (const CXXMethodDecl *MD : D->methods()) {
>>>>>>>>>>>>>>>>>>> + if (MD->isDeleted())
>>>>>>>>>>>>>>>>>>> + continue;
>>>>>>>>>>>>>>>>>>> +
>>>>>>>>>>>>>>>>>>> + auto *CD = dyn_cast<CXXConstructorDecl>(MD);
>>>>>>>>>>>>>>>>>>> + if (CD && CD->isCopyOrMoveConstructor())
>>>>>>>>>>>>>>>>>>> + HasNonDeletedCopyOrMove = true;
>>>>>>>>>>>>>>>>>>> + else if (!isa<CXXDestructorDecl>(MD))
>>>>>>>>>>>>>>>>>>> + continue;
>>>>>>>>>>>>>>>>>>> +
>>>>>>>>>>>>>>>>>>> + if (!MD->isTrivial())
>>>>>>>>>>>>>>>>>>> + return false;
>>>>>>>>>>>>>>>>>>> + }
>>>>>>>>>>>>>>>>>>> +
>>>>>>>>>>>>>>>>>>> + return HasNonDeletedCopyOrMove;
>>>>>>>>>>>>>>>>>>> +}
>>>>>>>>>>>>>>>>>>> +
>>>>>>>>>>>>>>>>>>> /// \brief Perform semantic checks on a class
>>>>>>>>>>>>>>>>>>> definition
>>>>>>>>>>>>>>>>>>> that
>>>>>>>>>>>>>>>>>>> has
>>>>>>>>>>>>>>>>>>> been
>>>>>>>>>>>>>>>>>>> /// completing, introducing implicitly-declared
>>>>>>>>>>>>>>>>>>> members,
>>>>>>>>>>>>>>>>>>> checking
>>>>>>>>>>>>>>>>>>> for
>>>>>>>>>>>>>>>>>>> /// abstract types, etc.
>>>>>>>>>>>>>>>>>>> @@ -5870,6 +5917,8 @@ void
>>>>>>>>>>>>>>>>>>> Sema::CheckCompletedCXXClass(CXXRec
>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> checkClassLevelDLLAttribute(Record);
>>>>>>>>>>>>>>>>>>> +
>>>>>>>>>>>>>>>>>>> +
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Record->setCanPassInRegisters(computeCanPassInRegisters(*this,
>>>>>>>>>>>>>>>>>>> Record));
>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> /// Look up the special member function that would be
>>>>>>>>>>>>>>>>>>> called by
>>>>>>>>>>>>>>>>>>> a
>>>>>>>>>>>>>>>>>>> special
>>>>>>>>>>>>>>>>>>> @@ -7496,8 +7545,7 @@ void
>>>>>>>>>>>>>>>>>>> Sema::ActOnFinishCXXMemberSpecifica
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> reinterpret_cast<Decl**>(FieldCollector->getCurFields()),
>>>>>>>>>>>>>>>>>>> FieldCollector->getCurNumFields()), LBrac,
>>>>>>>>>>>>>>>>>>> RBrac,
>>>>>>>>>>>>>>>>>>> AttrList);
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> - CheckCompletedCXXClass(
>>>>>>>>>>>>>>>>>>> -
>>>>>>>>>>>>>>>>>>> dyn_cast_or_null<CXXRecordDecl>(TagDecl));
>>>>>>>>>>>>>>>>>>> +
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> CheckCompletedCXXClass(dyn_cast_or_null<CXXRecordDecl>(TagDecl));
>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> /// AddImplicitlyDeclaredMembersToClass - Adds any
>>>>>>>>>>>>>>>>>>> implicitly-declared
>>>>>>>>>>>>>>>>>>> @@ -11929,8 +11977,10 @@ CXXConstructorDecl
>>>>>>>>>>>>>>>>>>> *Sema::DeclareImplici
>>>>>>>>>>>>>>>>>>> Scope *S = getScopeForContext(ClassDecl);
>>>>>>>>>>>>>>>>>>> CheckImplicitSpecialMemberDeclaration(S,
>>>>>>>>>>>>>>>>>>> CopyConstructor);
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> - if (ShouldDeleteSpecialMember(CopyConstructor,
>>>>>>>>>>>>>>>>>>> CXXCopyConstructor))
>>>>>>>>>>>>>>>>>>> + if (ShouldDeleteSpecialMember(CopyConstructor,
>>>>>>>>>>>>>>>>>>> CXXCopyConstructor)) {
>>>>>>>>>>>>>>>>>>> + ClassDecl->setImplicitCopyConstructorIsDeleted();
>>>>>>>>>>>>>>>>>>> SetDeclDeleted(CopyConstructor, ClassLoc);
>>>>>>>>>>>>>>>>>>> + }
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> if (S)
>>>>>>>>>>>>>>>>>>> PushOnScopeChains(CopyConstructor, S, false);
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Modified: cfe/trunk/lib/Serialization/ASTReaderDecl.cpp
>>>>>>>>>>>>>>>>>>> URL:
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/Serialization/ASTReaderDecl.cpp?rev=310401&r1=310400&r2=310401&view=diff
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> ==============================================================================
>>>>>>>>>>>>>>>>>>> --- cfe/trunk/lib/Serialization/ASTReaderDecl.cpp
>>>>>>>>>>>>>>>>>>> (original)
>>>>>>>>>>>>>>>>>>> +++ cfe/trunk/lib/Serialization/ASTReaderDecl.cpp Tue Aug
>>>>>>>>>>>>>>>>>>> 8
>>>>>>>>>>>>>>>>>>> 12:12:28
>>>>>>>>>>>>>>>>>>> 2017
>>>>>>>>>>>>>>>>>>> @@ -1559,9 +1559,11 @@ void
>>>>>>>>>>>>>>>>>>> ASTDeclReader::ReadCXXDefinitionDat
>>>>>>>>>>>>>>>>>>> Data.HasUninitializedFields = Record.readInt();
>>>>>>>>>>>>>>>>>>> Data.HasInheritedConstructor = Record.readInt();
>>>>>>>>>>>>>>>>>>> Data.HasInheritedAssignment = Record.readInt();
>>>>>>>>>>>>>>>>>>> + Data.NeedOverloadResolutionForCopyConstructor =
>>>>>>>>>>>>>>>>>>> Record.readInt();
>>>>>>>>>>>>>>>>>>> Data.NeedOverloadResolutionForMoveConstructor =
>>>>>>>>>>>>>>>>>>> Record.readInt();
>>>>>>>>>>>>>>>>>>> Data.NeedOverloadResolutionForMoveAssignment =
>>>>>>>>>>>>>>>>>>> Record.readInt();
>>>>>>>>>>>>>>>>>>> Data.NeedOverloadResolutionForDestructor =
>>>>>>>>>>>>>>>>>>> Record.readInt();
>>>>>>>>>>>>>>>>>>> + Data.DefaultedCopyConstructorIsDeleted =
>>>>>>>>>>>>>>>>>>> Record.readInt();
>>>>>>>>>>>>>>>>>>> Data.DefaultedMoveConstructorIsDeleted =
>>>>>>>>>>>>>>>>>>> Record.readInt();
>>>>>>>>>>>>>>>>>>> Data.DefaultedMoveAssignmentIsDeleted =
>>>>>>>>>>>>>>>>>>> Record.readInt();
>>>>>>>>>>>>>>>>>>> Data.DefaultedDestructorIsDeleted = Record.readInt();
>>>>>>>>>>>>>>>>>>> @@ -1570,6 +1572,7 @@ void
>>>>>>>>>>>>>>>>>>> ASTDeclReader::ReadCXXDefinitionDat
>>>>>>>>>>>>>>>>>>> Data.HasIrrelevantDestructor = Record.readInt();
>>>>>>>>>>>>>>>>>>> Data.HasConstexprNonCopyMoveConstructor =
>>>>>>>>>>>>>>>>>>> Record.readInt();
>>>>>>>>>>>>>>>>>>> Data.HasDefaultedDefaultConstructor = Record.readInt();
>>>>>>>>>>>>>>>>>>> + Data.CanPassInRegisters = Record.readInt();
>>>>>>>>>>>>>>>>>>> Data.DefaultedDefaultConstructorIsConstexpr =
>>>>>>>>>>>>>>>>>>> Record.readInt();
>>>>>>>>>>>>>>>>>>> Data.HasConstexprDefaultConstructor = Record.readInt();
>>>>>>>>>>>>>>>>>>> Data.HasNonLiteralTypeFieldsOrBases = Record.readInt();
>>>>>>>>>>>>>>>>>>> @@ -1697,9 +1700,11 @@ void
>>>>>>>>>>>>>>>>>>> ASTDeclReader::MergeDefinitionData(
>>>>>>>>>>>>>>>>>>> MATCH_FIELD(HasUninitializedFields)
>>>>>>>>>>>>>>>>>>> MATCH_FIELD(HasInheritedConstructor)
>>>>>>>>>>>>>>>>>>> MATCH_FIELD(HasInheritedAssignment)
>>>>>>>>>>>>>>>>>>> + MATCH_FIELD(NeedOverloadResolutionForCopyConstructor)
>>>>>>>>>>>>>>>>>>> MATCH_FIELD(NeedOverloadResolutionForMoveConstructor)
>>>>>>>>>>>>>>>>>>> MATCH_FIELD(NeedOverloadResolutionForMoveAssignment)
>>>>>>>>>>>>>>>>>>> MATCH_FIELD(NeedOverloadResolutionForDestructor)
>>>>>>>>>>>>>>>>>>> + MATCH_FIELD(DefaultedCopyConstructorIsDeleted)
>>>>>>>>>>>>>>>>>>> MATCH_FIELD(DefaultedMoveConstructorIsDeleted)
>>>>>>>>>>>>>>>>>>> MATCH_FIELD(DefaultedMoveAssignmentIsDeleted)
>>>>>>>>>>>>>>>>>>> MATCH_FIELD(DefaultedDestructorIsDeleted)
>>>>>>>>>>>>>>>>>>> @@ -1708,6 +1713,7 @@ void
>>>>>>>>>>>>>>>>>>> ASTDeclReader::MergeDefinitionData(
>>>>>>>>>>>>>>>>>>> MATCH_FIELD(HasIrrelevantDestructor)
>>>>>>>>>>>>>>>>>>> OR_FIELD(HasConstexprNonCopyMoveConstructor)
>>>>>>>>>>>>>>>>>>> OR_FIELD(HasDefaultedDefaultConstructor)
>>>>>>>>>>>>>>>>>>> + MATCH_FIELD(CanPassInRegisters)
>>>>>>>>>>>>>>>>>>> MATCH_FIELD(DefaultedDefaultConstructorIsConstexpr)
>>>>>>>>>>>>>>>>>>> OR_FIELD(HasConstexprDefaultConstructor)
>>>>>>>>>>>>>>>>>>> MATCH_FIELD(HasNonLiteralTypeFieldsOrBases)
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Modified: cfe/trunk/lib/Serialization/ASTWriter.cpp
>>>>>>>>>>>>>>>>>>> URL:
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/Serialization/ASTWriter.cpp?rev=310401&r1=310400&r2=310401&view=diff
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> ==============================================================================
>>>>>>>>>>>>>>>>>>> --- cfe/trunk/lib/Serialization/ASTWriter.cpp (original)
>>>>>>>>>>>>>>>>>>> +++ cfe/trunk/lib/Serialization/ASTWriter.cpp Tue Aug 8
>>>>>>>>>>>>>>>>>>> 12:12:28
>>>>>>>>>>>>>>>>>>> 2017
>>>>>>>>>>>>>>>>>>> @@ -5875,9 +5875,11 @@ void
>>>>>>>>>>>>>>>>>>> ASTRecordWriter::AddCXXDefinitionDa
>>>>>>>>>>>>>>>>>>> Record->push_back(Data.HasUninitializedFields);
>>>>>>>>>>>>>>>>>>> Record->push_back(Data.HasInheritedConstructor);
>>>>>>>>>>>>>>>>>>> Record->push_back(Data.HasInheritedAssignment);
>>>>>>>>>>>>>>>>>>> +
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Record->push_back(Data.NeedOverloadResolutionForCopyConstructor);
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Record->push_back(Data.NeedOverloadResolutionForMoveConstructor);
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Record->push_back(Data.NeedOverloadResolutionForMoveAssignment);
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Record->push_back(Data.NeedOverloadResolutionForDestructor);
>>>>>>>>>>>>>>>>>>> +
>>>>>>>>>>>>>>>>>>> Record->push_back(Data.DefaultedCopyConstructorIsDeleted);
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Record->push_back(Data.DefaultedMoveConstructorIsDeleted);
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Record->push_back(Data.DefaultedMoveAssignmentIsDeleted);
>>>>>>>>>>>>>>>>>>> Record->push_back(Data.DefaultedDestructorIsDeleted);
>>>>>>>>>>>>>>>>>>> @@ -5886,6 +5888,7 @@ void
>>>>>>>>>>>>>>>>>>> ASTRecordWriter::AddCXXDefinitionDa
>>>>>>>>>>>>>>>>>>> Record->push_back(Data.HasIrrelevantDestructor);
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Record->push_back(Data.HasConstexprNonCopyMoveConstructor);
>>>>>>>>>>>>>>>>>>> Record->push_back(Data.HasDefaultedDefaultConstructor);
>>>>>>>>>>>>>>>>>>> + Record->push_back(Data.CanPassInRegisters);
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Record->push_back(Data.DefaultedDefaultConstructorIsConstexpr);
>>>>>>>>>>>>>>>>>>> Record->push_back(Data.HasConstexprDefaultConstructor);
>>>>>>>>>>>>>>>>>>> Record->push_back(Data.HasNonLiteralTypeFieldsOrBases);
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Modified: cfe/trunk/test/CodeGenCXX/uncopyable-args.cpp
>>>>>>>>>>>>>>>>>>> URL:
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> http://llvm.org/viewvc/llvm-project/cfe/trunk/test/CodeGenCXX/uncopyable-args.cpp?rev=310401&r1=310400&r2=310401&view=diff
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> ==============================================================================
>>>>>>>>>>>>>>>>>>> --- cfe/trunk/test/CodeGenCXX/uncopyable-args.cpp
>>>>>>>>>>>>>>>>>>> (original)
>>>>>>>>>>>>>>>>>>> +++ cfe/trunk/test/CodeGenCXX/uncopyable-args.cpp Tue Aug
>>>>>>>>>>>>>>>>>>> 8
>>>>>>>>>>>>>>>>>>> 12:12:28
>>>>>>>>>>>>>>>>>>> 2017
>>>>>>>>>>>>>>>>>>> @@ -1,5 +1,6 @@
>>>>>>>>>>>>>>>>>>> // RUN: %clang_cc1 -std=c++11 -triple
>>>>>>>>>>>>>>>>>>> x86_64-unknown-unknown
>>>>>>>>>>>>>>>>>>> -emit-llvm
>>>>>>>>>>>>>>>>>>> -o - %s | FileCheck %s
>>>>>>>>>>>>>>>>>>> -// RUN: %clang_cc1 -std=c++11 -triple x86_64-windows-msvc
>>>>>>>>>>>>>>>>>>> -emit-llvm
>>>>>>>>>>>>>>>>>>> -o
>>>>>>>>>>>>>>>>>>> -
>>>>>>>>>>>>>>>>>>> %s | FileCheck %s -check-prefix=WIN64
>>>>>>>>>>>>>>>>>>> +// RUN: %clang_cc1 -std=c++11 -triple x86_64-windows-msvc
>>>>>>>>>>>>>>>>>>> -emit-llvm
>>>>>>>>>>>>>>>>>>> -o
>>>>>>>>>>>>>>>>>>> -
>>>>>>>>>>>>>>>>>>> %s -fms-compatibility -fms-compatibility-version=18 |
>>>>>>>>>>>>>>>>>>> FileCheck %s
>>>>>>>>>>>>>>>>>>> -check-prefix=WIN64 -check-prefix=WIN64-18
>>>>>>>>>>>>>>>>>>> +// RUN: %clang_cc1 -std=c++11 -triple x86_64-windows-msvc
>>>>>>>>>>>>>>>>>>> -emit-llvm
>>>>>>>>>>>>>>>>>>> -o
>>>>>>>>>>>>>>>>>>> -
>>>>>>>>>>>>>>>>>>> %s -fms-compatibility -fms-compatibility-version=19 |
>>>>>>>>>>>>>>>>>>> FileCheck %s
>>>>>>>>>>>>>>>>>>> -check-prefix=WIN64 -check-prefix=WIN64-19
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> namespace trivial {
>>>>>>>>>>>>>>>>>>> // Trivial structs should be passed directly.
>>>>>>>>>>>>>>>>>>> @@ -52,12 +53,11 @@ void foo(A);
>>>>>>>>>>>>>>>>>>> void bar() {
>>>>>>>>>>>>>>>>>>> foo({});
>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>> -// FIXME: The copy ctor is implicitly deleted.
>>>>>>>>>>>>>>>>>>> -// CHECK-DISABLED-LABEL: define void
>>>>>>>>>>>>>>>>>>> @_ZN9move_ctor3barEv()
>>>>>>>>>>>>>>>>>>> -// CHECK-DISABLED: call void @_Z{{.*}}C1Ev(
>>>>>>>>>>>>>>>>>>> -// CHECK-DISABLED-NOT: call
>>>>>>>>>>>>>>>>>>> -// CHECK-DISABLED: call void
>>>>>>>>>>>>>>>>>>> @_ZN9move_ctor3fooENS_1AE(%"struct.move_ctor::A"* %{{.*}})
>>>>>>>>>>>>>>>>>>> -// CHECK-DISABLED-LABEL: declare void
>>>>>>>>>>>>>>>>>>> @_ZN9move_ctor3fooENS_1AE(%"struct.move_ctor::A"*)
>>>>>>>>>>>>>>>>>>> +// CHECK-LABEL: define void @_ZN9move_ctor3barEv()
>>>>>>>>>>>>>>>>>>> +// CHECK: call void @_Z{{.*}}C1Ev(
>>>>>>>>>>>>>>>>>>> +// CHECK-NOT: call
>>>>>>>>>>>>>>>>>>> +// CHECK: call void
>>>>>>>>>>>>>>>>>>> @_ZN9move_ctor3fooENS_1AE(%"struct.move_ctor::A"*
>>>>>>>>>>>>>>>>>>> %{{.*}})
>>>>>>>>>>>>>>>>>>> +// CHECK-LABEL: declare void
>>>>>>>>>>>>>>>>>>> @_ZN9move_ctor3fooENS_1AE(%"struct.move_ctor::A"*)
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> // WIN64-LABEL: declare void
>>>>>>>>>>>>>>>>>>> @"\01?foo at move_ctor@@YAXUA at 1@@Z"(%"struct.move_ctor::A"*)
>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>> @@ -73,12 +73,11 @@ void foo(A);
>>>>>>>>>>>>>>>>>>> void bar() {
>>>>>>>>>>>>>>>>>>> foo({});
>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>> -// FIXME: The copy ctor is deleted.
>>>>>>>>>>>>>>>>>>> -// CHECK-DISABLED-LABEL: define void
>>>>>>>>>>>>>>>>>>> @_ZN11all_deleted3barEv()
>>>>>>>>>>>>>>>>>>> -// CHECK-DISABLED: call void @_Z{{.*}}C1Ev(
>>>>>>>>>>>>>>>>>>> -// CHECK-DISABLED-NOT: call
>>>>>>>>>>>>>>>>>>> -// CHECK-DISABLED: call void
>>>>>>>>>>>>>>>>>>> @_ZN11all_deleted3fooENS_1AE(%"struct.all_deleted::A"*
>>>>>>>>>>>>>>>>>>> %{{.*}})
>>>>>>>>>>>>>>>>>>> -// CHECK-DISABLED-LABEL: declare void
>>>>>>>>>>>>>>>>>>> @_ZN11all_deleted3fooENS_1AE(%"struct.all_deleted::A"*)
>>>>>>>>>>>>>>>>>>> +// CHECK-LABEL: define void @_ZN11all_deleted3barEv()
>>>>>>>>>>>>>>>>>>> +// CHECK: call void @_Z{{.*}}C1Ev(
>>>>>>>>>>>>>>>>>>> +// CHECK-NOT: call
>>>>>>>>>>>>>>>>>>> +// CHECK: call void
>>>>>>>>>>>>>>>>>>> @_ZN11all_deleted3fooENS_1AE(%"struct.all_deleted::A"*
>>>>>>>>>>>>>>>>>>> %{{.*}})
>>>>>>>>>>>>>>>>>>> +// CHECK-LABEL: declare void
>>>>>>>>>>>>>>>>>>> @_ZN11all_deleted3fooENS_1AE(%"struct.all_deleted::A"*)
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> // WIN64-LABEL: declare void
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> @"\01?foo at all_deleted@@YAXUA at 1@@Z"(%"struct.all_deleted::A"*)
>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>> @@ -93,14 +92,15 @@ void foo(A);
>>>>>>>>>>>>>>>>>>> void bar() {
>>>>>>>>>>>>>>>>>>> foo({});
>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>> -// FIXME: The copy and move ctors are implicitly deleted.
>>>>>>>>>>>>>>>>>>> -// CHECK-DISABLED-LABEL: define void
>>>>>>>>>>>>>>>>>>> @_ZN18implicitly_deleted3barEv()
>>>>>>>>>>>>>>>>>>> -// CHECK-DISABLED: call void @_Z{{.*}}C1Ev(
>>>>>>>>>>>>>>>>>>> -// CHECK-DISABLED-NOT: call
>>>>>>>>>>>>>>>>>>> -// CHECK-DISABLED: call void
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> @_ZN18implicitly_deleted3fooENS_1AE(%"struct.implicitly_deleted::A"*
>>>>>>>>>>>>>>>>>>> %{{.*}})
>>>>>>>>>>>>>>>>>>> -// CHECK-DISABLED-LABEL: declare void
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> @_ZN18implicitly_deleted3fooENS_1AE(%"struct.implicitly_deleted::A"*)
>>>>>>>>>>>>>>>>>>> -
>>>>>>>>>>>>>>>>>>> -// WIN64-LABEL: declare void
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> @"\01?foo at implicitly_deleted@@YAXUA at 1@@Z"(%"struct.implicitly_deleted::A"*)
>>>>>>>>>>>>>>>>>>> +// CHECK-LABEL: define void
>>>>>>>>>>>>>>>>>>> @_ZN18implicitly_deleted3barEv()
>>>>>>>>>>>>>>>>>>> +// CHECK: call void @_Z{{.*}}C1Ev(
>>>>>>>>>>>>>>>>>>> +// CHECK-NOT: call
>>>>>>>>>>>>>>>>>>> +// CHECK: call void
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> @_ZN18implicitly_deleted3fooENS_1AE(%"struct.implicitly_deleted::A"*
>>>>>>>>>>>>>>>>>>> %{{.*}})
>>>>>>>>>>>>>>>>>>> +// CHECK-LABEL: declare void
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> @_ZN18implicitly_deleted3fooENS_1AE(%"struct.implicitly_deleted::A"*)
>>>>>>>>>>>>>>>>>>> +
>>>>>>>>>>>>>>>>>>> +// In MSVC 2013, the copy ctor is not deleted by a move
>>>>>>>>>>>>>>>>>>> assignment.
>>>>>>>>>>>>>>>>>>> In
>>>>>>>>>>>>>>>>>>> MSVC 2015, it is.
>>>>>>>>>>>>>>>>>>> +// WIN64-18-LABEL: declare void
>>>>>>>>>>>>>>>>>>> @"\01?foo at implicitly_deleted@@YAXUA at 1@@Z"(i64
>>>>>>>>>>>>>>>>>>> +// WIN64-19-LABEL: declare void
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> @"\01?foo at implicitly_deleted@@YAXUA at 1@@Z"(%"struct.implicitly_deleted::A"*)
>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> namespace one_deleted {
>>>>>>>>>>>>>>>>>>> @@ -113,12 +113,11 @@ void foo(A);
>>>>>>>>>>>>>>>>>>> void bar() {
>>>>>>>>>>>>>>>>>>> foo({});
>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>> -// FIXME: The copy constructor is implicitly deleted.
>>>>>>>>>>>>>>>>>>> -// CHECK-DISABLED-LABEL: define void
>>>>>>>>>>>>>>>>>>> @_ZN11one_deleted3barEv()
>>>>>>>>>>>>>>>>>>> -// CHECK-DISABLED: call void @_Z{{.*}}C1Ev(
>>>>>>>>>>>>>>>>>>> -// CHECK-DISABLED-NOT: call
>>>>>>>>>>>>>>>>>>> -// CHECK-DISABLED: call void
>>>>>>>>>>>>>>>>>>> @_ZN11one_deleted3fooENS_1AE(%"struct.one_deleted::A"*
>>>>>>>>>>>>>>>>>>> %{{.*}})
>>>>>>>>>>>>>>>>>>> -// CHECK-DISABLED-LABEL: declare void
>>>>>>>>>>>>>>>>>>> @_ZN11one_deleted3fooENS_1AE(%"struct.one_deleted::A"*)
>>>>>>>>>>>>>>>>>>> +// CHECK-LABEL: define void @_ZN11one_deleted3barEv()
>>>>>>>>>>>>>>>>>>> +// CHECK: call void @_Z{{.*}}C1Ev(
>>>>>>>>>>>>>>>>>>> +// CHECK-NOT: call
>>>>>>>>>>>>>>>>>>> +// CHECK: call void
>>>>>>>>>>>>>>>>>>> @_ZN11one_deleted3fooENS_1AE(%"struct.one_deleted::A"*
>>>>>>>>>>>>>>>>>>> %{{.*}})
>>>>>>>>>>>>>>>>>>> +// CHECK-LABEL: declare void
>>>>>>>>>>>>>>>>>>> @_ZN11one_deleted3fooENS_1AE(%"struct.one_deleted::A"*)
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> // WIN64-LABEL: declare void
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> @"\01?foo at one_deleted@@YAXUA at 1@@Z"(%"struct.one_deleted::A"*)
>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>> @@ -195,12 +194,10 @@ void foo(B);
>>>>>>>>>>>>>>>>>>> void bar() {
>>>>>>>>>>>>>>>>>>> foo({});
>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>> -// FIXME: This class has a non-trivial copy ctor and a
>>>>>>>>>>>>>>>>>>> trivial
>>>>>>>>>>>>>>>>>>> copy
>>>>>>>>>>>>>>>>>>> ctor.
>>>>>>>>>>>>>>>>>>> It's
>>>>>>>>>>>>>>>>>>> -// not clear whether we should pass by address or in
>>>>>>>>>>>>>>>>>>> registers.
>>>>>>>>>>>>>>>>>>> -// CHECK-DISABLED-LABEL: define void
>>>>>>>>>>>>>>>>>>> @_ZN14two_copy_ctors3barEv()
>>>>>>>>>>>>>>>>>>> -// CHECK-DISABLED: call void @_Z{{.*}}C1Ev(
>>>>>>>>>>>>>>>>>>> -// CHECK-DISABLED: call void
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> @_ZN14two_copy_ctors3fooENS_1BE(%"struct.two_copy_ctors::B"*
>>>>>>>>>>>>>>>>>>> %{{.*}})
>>>>>>>>>>>>>>>>>>> -// CHECK-DISABLED-LABEL: declare void
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> @_ZN14two_copy_ctors3fooENS_1BE(%"struct.two_copy_ctors::B"*)
>>>>>>>>>>>>>>>>>>> +// CHECK-LABEL: define void @_ZN14two_copy_ctors3barEv()
>>>>>>>>>>>>>>>>>>> +// CHECK: call void @_Z{{.*}}C1Ev(
>>>>>>>>>>>>>>>>>>> +// CHECK: call void
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> @_ZN14two_copy_ctors3fooENS_1BE(%"struct.two_copy_ctors::B"*
>>>>>>>>>>>>>>>>>>> %{{.*}})
>>>>>>>>>>>>>>>>>>> +// CHECK-LABEL: declare void
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> @_ZN14two_copy_ctors3fooENS_1BE(%"struct.two_copy_ctors::B"*)
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> // WIN64-LABEL: declare void
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> @"\01?foo at two_copy_ctors@@YAXUB at 1@@Z"(%"struct.two_copy_ctors::B"*)
>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>> @@ -212,6 +209,7 @@ struct A {
>>>>>>>>>>>>>>>>>>> void *p;
>>>>>>>>>>>>>>>>>>> };
>>>>>>>>>>>>>>>>>>> void *foo(A a) { return a.p; }
>>>>>>>>>>>>>>>>>>> +// CHECK-LABEL: define i8*
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> @_ZN15definition_only3fooENS_1AE(%"struct.definition_only::A"*
>>>>>>>>>>>>>>>>>>> // WIN64-LABEL: define i8*
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> @"\01?foo at definition_only@@YAPEAXUA at 1@@Z"(%"struct.definition_only::A"*
>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> @@ -226,6 +224,7 @@ struct A {
>>>>>>>>>>>>>>>>>>> B b;
>>>>>>>>>>>>>>>>>>> };
>>>>>>>>>>>>>>>>>>> void *foo(A a) { return a.b.p; }
>>>>>>>>>>>>>>>>>>> +// CHECK-LABEL: define i8*
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> @_ZN17deleted_by_member3fooENS_1AE(%"struct.deleted_by_member::A"*
>>>>>>>>>>>>>>>>>>> // WIN64-LABEL: define i8*
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> @"\01?foo at deleted_by_member@@YAPEAXUA at 1@@Z"(%"struct.deleted_by_member::A"*
>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> @@ -239,6 +238,7 @@ struct A : B {
>>>>>>>>>>>>>>>>>>> A();
>>>>>>>>>>>>>>>>>>> };
>>>>>>>>>>>>>>>>>>> void *foo(A a) { return a.p; }
>>>>>>>>>>>>>>>>>>> +// CHECK-LABEL: define i8*
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> @_ZN15deleted_by_base3fooENS_1AE(%"struct.deleted_by_base::A"*
>>>>>>>>>>>>>>>>>>> // WIN64-LABEL: define i8*
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> @"\01?foo at deleted_by_base@@YAPEAXUA at 1@@Z"(%"struct.deleted_by_base::A"*
>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> @@ -253,6 +253,7 @@ struct A {
>>>>>>>>>>>>>>>>>>> B b;
>>>>>>>>>>>>>>>>>>> };
>>>>>>>>>>>>>>>>>>> void *foo(A a) { return a.b.p; }
>>>>>>>>>>>>>>>>>>> +// CHECK-LABEL: define i8*
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> @_ZN22deleted_by_member_copy3fooENS_1AE(%"struct.deleted_by_member_copy::A"*
>>>>>>>>>>>>>>>>>>> // WIN64-LABEL: define i8*
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> @"\01?foo at deleted_by_member_copy@@YAPEAXUA at 1@@Z"(%"struct.deleted_by_member_copy::A"*
>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> @@ -266,6 +267,7 @@ struct A : B {
>>>>>>>>>>>>>>>>>>> A();
>>>>>>>>>>>>>>>>>>> };
>>>>>>>>>>>>>>>>>>> void *foo(A a) { return a.p; }
>>>>>>>>>>>>>>>>>>> +// CHECK-LABEL: define i8*
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> @_ZN20deleted_by_base_copy3fooENS_1AE(%"struct.deleted_by_base_copy::A"*
>>>>>>>>>>>>>>>>>>> // WIN64-LABEL: define i8*
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> @"\01?foo at deleted_by_base_copy@@YAPEAXUA at 1@@Z"(%"struct.deleted_by_base_copy::A"*
>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> @@ -275,6 +277,75 @@ struct A {
>>>>>>>>>>>>>>>>>>> A(const A &o) = delete;
>>>>>>>>>>>>>>>>>>> void *p;
>>>>>>>>>>>>>>>>>>> };
>>>>>>>>>>>>>>>>>>> +// CHECK-LABEL: define i8*
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> @_ZN15explicit_delete3fooENS_1AE(%"struct.explicit_delete::A"*
>>>>>>>>>>>>>>>>>>> // WIN64-LABEL: define i8*
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> @"\01?foo at explicit_delete@@YAPEAXUA at 1@@Z"(%"struct.explicit_delete::A"*
>>>>>>>>>>>>>>>>>>> void *foo(A a) { return a.p; }
>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>> +
>>>>>>>>>>>>>>>>>>> +namespace implicitly_deleted_copy_ctor {
>>>>>>>>>>>>>>>>>>> +struct A {
>>>>>>>>>>>>>>>>>>> + // No move ctor due to copy assignment.
>>>>>>>>>>>>>>>>>>> + A &operator=(const A&);
>>>>>>>>>>>>>>>>>>> + // Deleted copy ctor due to rvalue ref member.
>>>>>>>>>>>>>>>>>>> + int &&ref;
>>>>>>>>>>>>>>>>>>> +};
>>>>>>>>>>>>>>>>>>> +// CHECK-LABEL: define {{.*}}
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> @_ZN28implicitly_deleted_copy_ctor3fooENS_1AE(%"struct.implicitly_deleted_copy_ctor::A"*
>>>>>>>>>>>>>>>>>>> +// WIN64-LABEL: define {{.*}}
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> @"\01?foo at implicitly_deleted_copy_ctor@@YAAEAHUA at 1@@Z"(%"struct.implicitly_deleted_copy_ctor::A"*
>>>>>>>>>>>>>>>>>>> +int &foo(A a) { return a.ref; }
>>>>>>>>>>>>>>>>>>> +
>>>>>>>>>>>>>>>>>>> +struct B {
>>>>>>>>>>>>>>>>>>> + // Passed direct: has non-deleted trivial copy ctor.
>>>>>>>>>>>>>>>>>>> + B &operator=(const B&);
>>>>>>>>>>>>>>>>>>> + int &ref;
>>>>>>>>>>>>>>>>>>> +};
>>>>>>>>>>>>>>>>>>> +int &foo(B b) { return b.ref; }
>>>>>>>>>>>>>>>>>>> +// CHECK-LABEL: define {{.*}}
>>>>>>>>>>>>>>>>>>> @_ZN28implicitly_deleted_copy_ctor3fooENS_1BE(i32*
>>>>>>>>>>>>>>>>>>> +// WIN64-LABEL: define {{.*}}
>>>>>>>>>>>>>>>>>>> @"\01?foo at implicitly_deleted_copy_ctor@@YAAEAHUB at 1@@Z"(i64
>>>>>>>>>>>>>>>>>>> +
>>>>>>>>>>>>>>>>>>> +struct X { X(const X&); };
>>>>>>>>>>>>>>>>>>> +struct Y { Y(const Y&) = default; };
>>>>>>>>>>>>>>>>>>> +
>>>>>>>>>>>>>>>>>>> +union C {
>>>>>>>>>>>>>>>>>>> + C &operator=(const C&);
>>>>>>>>>>>>>>>>>>> + // Passed indirect: copy ctor deleted due to variant
>>>>>>>>>>>>>>>>>>> member
>>>>>>>>>>>>>>>>>>> with
>>>>>>>>>>>>>>>>>>> nontrivial copy ctor.
>>>>>>>>>>>>>>>>>>> + X x;
>>>>>>>>>>>>>>>>>>> + int n;
>>>>>>>>>>>>>>>>>>> +};
>>>>>>>>>>>>>>>>>>> +int foo(C c) { return c.n; }
>>>>>>>>>>>>>>>>>>> +// CHECK-LABEL: define {{.*}}
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> @_ZN28implicitly_deleted_copy_ctor3fooENS_1CE(%"union.implicitly_deleted_copy_ctor::C"*
>>>>>>>>>>>>>>>>>>> +// WIN64-LABEL: define {{.*}}
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> @"\01?foo at implicitly_deleted_copy_ctor@@YAHTC at 1@@Z"(%"union.implicitly_deleted_copy_ctor::C"*
>>>>>>>>>>>>>>>>>>> +
>>>>>>>>>>>>>>>>>>> +struct D {
>>>>>>>>>>>>>>>>>>> + D &operator=(const D&);
>>>>>>>>>>>>>>>>>>> + // Passed indirect: copy ctor deleted due to variant
>>>>>>>>>>>>>>>>>>> member
>>>>>>>>>>>>>>>>>>> with
>>>>>>>>>>>>>>>>>>> nontrivial copy ctor.
>>>>>>>>>>>>>>>>>>> + union {
>>>>>>>>>>>>>>>>>>> + X x;
>>>>>>>>>>>>>>>>>>> + int n;
>>>>>>>>>>>>>>>>>>> + };
>>>>>>>>>>>>>>>>>>> +};
>>>>>>>>>>>>>>>>>>> +int foo(D d) { return d.n; }
>>>>>>>>>>>>>>>>>>> +// CHECK-LABEL: define {{.*}}
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> @_ZN28implicitly_deleted_copy_ctor3fooENS_1DE(%"struct.implicitly_deleted_copy_ctor::D"*
>>>>>>>>>>>>>>>>>>> +// WIN64-LABEL: define {{.*}}
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> @"\01?foo at implicitly_deleted_copy_ctor@@YAHUD at 1@@Z"(%"struct.implicitly_deleted_copy_ctor::D"*
>>>>>>>>>>>>>>>>>>> +
>>>>>>>>>>>>>>>>>>> +union E {
>>>>>>>>>>>>>>>>>>> + // Passed direct: has non-deleted trivial copy ctor.
>>>>>>>>>>>>>>>>>>> + E &operator=(const E&);
>>>>>>>>>>>>>>>>>>> + Y y;
>>>>>>>>>>>>>>>>>>> + int n;
>>>>>>>>>>>>>>>>>>> +};
>>>>>>>>>>>>>>>>>>> +int foo(E e) { return e.n; }
>>>>>>>>>>>>>>>>>>> +// CHECK-LABEL: define {{.*}}
>>>>>>>>>>>>>>>>>>> @_ZN28implicitly_deleted_copy_ctor3fooENS_1EE(i32
>>>>>>>>>>>>>>>>>>> +// WIN64-LABEL: define {{.*}}
>>>>>>>>>>>>>>>>>>> @"\01?foo at implicitly_deleted_copy_ctor@@YAHTE at 1@@Z"(i32
>>>>>>>>>>>>>>>>>>> +
>>>>>>>>>>>>>>>>>>> +struct F {
>>>>>>>>>>>>>>>>>>> + // Passed direct: has non-deleted trivial copy ctor.
>>>>>>>>>>>>>>>>>>> + F &operator=(const F&);
>>>>>>>>>>>>>>>>>>> + union {
>>>>>>>>>>>>>>>>>>> + Y y;
>>>>>>>>>>>>>>>>>>> + int n;
>>>>>>>>>>>>>>>>>>> + };
>>>>>>>>>>>>>>>>>>> +};
>>>>>>>>>>>>>>>>>>> +int foo(F f) { return f.n; }
>>>>>>>>>>>>>>>>>>> +// CHECK-LABEL: define {{.*}}
>>>>>>>>>>>>>>>>>>> @_ZN28implicitly_deleted_copy_ctor3fooENS_1FE(i32
>>>>>>>>>>>>>>>>>>> +// WIN64-LABEL: define {{.*}}
>>>>>>>>>>>>>>>>>>> @"\01?foo at implicitly_deleted_copy_ctor@@YAHUF at 1@@Z"(i32
>>>>>>>>>>>>>>>>>>> +}
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Modified:
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> cfe/trunk/unittests/ASTMatchers/ASTMatchersNarrowingTest.cpp
>>>>>>>>>>>>>>>>>>> URL:
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> http://llvm.org/viewvc/llvm-project/cfe/trunk/unittests/ASTMatchers/ASTMatchersNarrowingTest.cpp?rev=310401&r1=310400&r2=310401&view=diff
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> ==============================================================================
>>>>>>>>>>>>>>>>>>> ---
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> cfe/trunk/unittests/ASTMatchers/ASTMatchersNarrowingTest.cpp
>>>>>>>>>>>>>>>>>>> (original)
>>>>>>>>>>>>>>>>>>> +++
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> cfe/trunk/unittests/ASTMatchers/ASTMatchersNarrowingTest.cpp
>>>>>>>>>>>>>>>>>>> Tue
>>>>>>>>>>>>>>>>>>> Aug
>>>>>>>>>>>>>>>>>>> 8 12:12:28 2017
>>>>>>>>>>>>>>>>>>> @@ -1108,26 +1108,35 @@ TEST(ConstructorDeclaration,
>>>>>>>>>>>>>>>>>>> IsExplicit)
>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> TEST(ConstructorDeclaration, Kinds) {
>>>>>>>>>>>>>>>>>>> - EXPECT_TRUE(matches("struct S { S(); };",
>>>>>>>>>>>>>>>>>>> -
>>>>>>>>>>>>>>>>>>> cxxConstructorDecl(isDefaultConstructor())));
>>>>>>>>>>>>>>>>>>> - EXPECT_TRUE(notMatches("struct S { S(); };",
>>>>>>>>>>>>>>>>>>> -
>>>>>>>>>>>>>>>>>>> cxxConstructorDecl(isCopyConstructor())));
>>>>>>>>>>>>>>>>>>> - EXPECT_TRUE(notMatches("struct S { S(); };",
>>>>>>>>>>>>>>>>>>> -
>>>>>>>>>>>>>>>>>>> cxxConstructorDecl(isMoveConstructor())));
>>>>>>>>>>>>>>>>>>> + EXPECT_TRUE(matches(
>>>>>>>>>>>>>>>>>>> + "struct S { S(); };",
>>>>>>>>>>>>>>>>>>> + cxxConstructorDecl(isDefaultConstructor(),
>>>>>>>>>>>>>>>>>>> unless(isImplicit()))));
>>>>>>>>>>>>>>>>>>> + EXPECT_TRUE(notMatches(
>>>>>>>>>>>>>>>>>>> + "struct S { S(); };",
>>>>>>>>>>>>>>>>>>> + cxxConstructorDecl(isCopyConstructor(),
>>>>>>>>>>>>>>>>>>> unless(isImplicit()))));
>>>>>>>>>>>>>>>>>>> + EXPECT_TRUE(notMatches(
>>>>>>>>>>>>>>>>>>> + "struct S { S(); };",
>>>>>>>>>>>>>>>>>>> + cxxConstructorDecl(isMoveConstructor(),
>>>>>>>>>>>>>>>>>>> unless(isImplicit()))));
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> - EXPECT_TRUE(notMatches("struct S { S(const S&); };",
>>>>>>>>>>>>>>>>>>> -
>>>>>>>>>>>>>>>>>>> cxxConstructorDecl(isDefaultConstructor())));
>>>>>>>>>>>>>>>>>>> - EXPECT_TRUE(matches("struct S { S(const S&); };",
>>>>>>>>>>>>>>>>>>> -
>>>>>>>>>>>>>>>>>>> cxxConstructorDecl(isCopyConstructor())));
>>>>>>>>>>>>>>>>>>> - EXPECT_TRUE(notMatches("struct S { S(const S&); };",
>>>>>>>>>>>>>>>>>>> -
>>>>>>>>>>>>>>>>>>> cxxConstructorDecl(isMoveConstructor())));
>>>>>>>>>>>>>>>>>>> + EXPECT_TRUE(notMatches(
>>>>>>>>>>>>>>>>>>> + "struct S { S(const S&); };",
>>>>>>>>>>>>>>>>>>> + cxxConstructorDecl(isDefaultConstructor(),
>>>>>>>>>>>>>>>>>>> unless(isImplicit()))));
>>>>>>>>>>>>>>>>>>> + EXPECT_TRUE(matches(
>>>>>>>>>>>>>>>>>>> + "struct S { S(const S&); };",
>>>>>>>>>>>>>>>>>>> + cxxConstructorDecl(isCopyConstructor(),
>>>>>>>>>>>>>>>>>>> unless(isImplicit()))));
>>>>>>>>>>>>>>>>>>> + EXPECT_TRUE(notMatches(
>>>>>>>>>>>>>>>>>>> + "struct S { S(const S&); };",
>>>>>>>>>>>>>>>>>>> + cxxConstructorDecl(isMoveConstructor(),
>>>>>>>>>>>>>>>>>>> unless(isImplicit()))));
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> - EXPECT_TRUE(notMatches("struct S { S(S&&); };",
>>>>>>>>>>>>>>>>>>> -
>>>>>>>>>>>>>>>>>>> cxxConstructorDecl(isDefaultConstructor())));
>>>>>>>>>>>>>>>>>>> - EXPECT_TRUE(notMatches("struct S { S(S&&); };",
>>>>>>>>>>>>>>>>>>> -
>>>>>>>>>>>>>>>>>>> cxxConstructorDecl(isCopyConstructor())));
>>>>>>>>>>>>>>>>>>> - EXPECT_TRUE(matches("struct S { S(S&&); };",
>>>>>>>>>>>>>>>>>>> -
>>>>>>>>>>>>>>>>>>> cxxConstructorDecl(isMoveConstructor())));
>>>>>>>>>>>>>>>>>>> + EXPECT_TRUE(notMatches(
>>>>>>>>>>>>>>>>>>> + "struct S { S(S&&); };",
>>>>>>>>>>>>>>>>>>> + cxxConstructorDecl(isDefaultConstructor(),
>>>>>>>>>>>>>>>>>>> unless(isImplicit()))));
>>>>>>>>>>>>>>>>>>> + EXPECT_TRUE(notMatches(
>>>>>>>>>>>>>>>>>>> + "struct S { S(S&&); };",
>>>>>>>>>>>>>>>>>>> + cxxConstructorDecl(isCopyConstructor(),
>>>>>>>>>>>>>>>>>>> unless(isImplicit()))));
>>>>>>>>>>>>>>>>>>> + EXPECT_TRUE(matches(
>>>>>>>>>>>>>>>>>>> + "struct S { S(S&&); };",
>>>>>>>>>>>>>>>>>>> + cxxConstructorDecl(isMoveConstructor(),
>>>>>>>>>>>>>>>>>>> unless(isImplicit()))));
>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> TEST(ConstructorDeclaration, IsUserProvided) {
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> _______________________________________________
>>>>>>>>>>>>>>>>>>> cfe-commits mailing list
>>>>>>>>>>>>>>>>>>> cfe-commits at lists.llvm.org
>>>>>>>>>>>>>>>>>>> http://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> _______________________________________________
>>>>>>>>>>>>>>>>>> cfe-commits mailing list
>>>>>>>>>>>>>>>>>> cfe-commits at lists.llvm.org
>>>>>>>>>>>>>>>>>> http://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> _______________________________________________
>>>>>>>>>>>>>>>>> cfe-commits mailing list
>>>>>>>>>>>>>>>>> cfe-commits at lists.llvm.org
>>>>>>>>>>>>>>>>> http://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>> _______________________________________________
>>>>>>>>>>>> cfe-commits mailing list
>>>>>>>>>>>> cfe-commits at lists.llvm.org
>>>>>>>>>>>> http://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
>>>>>>>>>>>
More information about the cfe-commits
mailing list