r310401 - PR19668, PR23034: Fix handling of move constructors and deleted copy
Diana Picus via cfe-commits
cfe-commits at lists.llvm.org
Mon Aug 14 09:21:55 PDT 2017
Hi,
I didn't manage to reproduce this at -O0. Yes, I think the version in
1.8.0, slightly modified (see
llvm/utils/unittest/googletest/README.LLVM)
On 14 August 2017 at 17:06, Vassil Vassilev <v.g.vassilev at gmail.com> wrote:
> 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