llvm-project/clang/test/CodeGenCXX/copy-assign-synthesis-3.cpp

// RUN: %clang_cc1 -emit-llvm-only -verify %s

struct A {
  A& operator=(A&);
};

struct B {
  void operator=(B);
};

struct C {
  A a;
  B b;
  float c;
  int (A::*d)();
  _Complex float e;
  int f[10];
  A g[2];
  B h[2];
};
void a(C& x, C& y) {
  x = y;
}
Update tests to use %clang_cc1 instead of 'clang-cc' or 'clang -cc1'. - This is designed to make it obvious that %clang_cc1 is a "test variable" which is substituted. It is '%clang_cc1' instead of '%clang -cc1' because it can be useful to redefine what gets run as 'clang -cc1' (for example, to set a default target). llvm-svn: 91446 2009-12-16 04:14:24 +08:00			`// RUN: %clang_cc1 -emit-llvm-only -verify %s`
Make copy assignment operator synthesis not explode for classes with complex or non-record aggregate members. It might be worth spending some time to optimize this code (and the parallel code for copy constructors) to memcpy in larger chunks, rather than copying one member at a time. Not sure exactly how beneficial that would be, but it seems like could help for large classes with, for example, a vtable pointer forcing the generation of a copy constructor. llvm-svn: 90823 2009-12-08 09:57:53 +08:00
			`struct A {`
Fix a couple bugs in copy assignment operator synthesis. llvm-svn: 93546 2010-01-16 04:06:11 +08:00			`A& operator=(A&);`
Make copy assignment operator synthesis not explode for classes with complex or non-record aggregate members. It might be worth spending some time to optimize this code (and the parallel code for copy constructors) to memcpy in larger chunks, rather than copying one member at a time. Not sure exactly how beneficial that would be, but it seems like could help for large classes with, for example, a vtable pointer forcing the generation of a copy constructor. llvm-svn: 90823 2009-12-08 09:57:53 +08:00			`};`

			`struct B {`
Fix a couple bugs in copy assignment operator synthesis. llvm-svn: 93546 2010-01-16 04:06:11 +08:00			`void operator=(B);`
			`};`

			`struct C {`
Make copy assignment operator synthesis not explode for classes with complex or non-record aggregate members. It might be worth spending some time to optimize this code (and the parallel code for copy constructors) to memcpy in larger chunks, rather than copying one member at a time. Not sure exactly how beneficial that would be, but it seems like could help for large classes with, for example, a vtable pointer forcing the generation of a copy constructor. llvm-svn: 90823 2009-12-08 09:57:53 +08:00			`A a;`
Fix a couple bugs in copy assignment operator synthesis. llvm-svn: 93546 2010-01-16 04:06:11 +08:00			`B b;`
			`float c;`
			`int (A::*d)();`
			`_Complex float e;`
			`int f[10];`
			`A g[2];`
			`B h[2];`
Make copy assignment operator synthesis not explode for classes with complex or non-record aggregate members. It might be worth spending some time to optimize this code (and the parallel code for copy constructors) to memcpy in larger chunks, rather than copying one member at a time. Not sure exactly how beneficial that would be, but it seems like could help for large classes with, for example, a vtable pointer forcing the generation of a copy constructor. llvm-svn: 90823 2009-12-08 09:57:53 +08:00			`};`
Fix a couple bugs in copy assignment operator synthesis. llvm-svn: 93546 2010-01-16 04:06:11 +08:00			`void a(C& x, C& y) {`
Make copy assignment operator synthesis not explode for classes with complex or non-record aggregate members. It might be worth spending some time to optimize this code (and the parallel code for copy constructors) to memcpy in larger chunks, rather than copying one member at a time. Not sure exactly how beneficial that would be, but it seems like could help for large classes with, for example, a vtable pointer forcing the generation of a copy constructor. llvm-svn: 90823 2009-12-08 09:57:53 +08:00			`x = y;`
			`}`