mirror of
https://github.com/llvm/llvm-project.git
synced 2025-04-16 17:16:42 +00:00
5bdd67778f
In SemaCUDA all implicit functions were considered host device, this led to
errors such as the following code snippet failing to compile:
struct Copyable {
const Copyable& operator=(const Copyable& x) { return *this; }
};
struct Simple {
Copyable b;
};
void foo() {
Simple a, b;
a = b;
}
Above the implicit copy assignment operator was inferred as host device but
there was only a host assignment copy defined which is an error in device
compilation mode.
Differential Revision: http://reviews.llvm.org/D6565
llvm-svn: 224358
52 lines
1.7 KiB
Plaintext
52 lines
1.7 KiB
Plaintext
// RUN: %clang_cc1 -std=gnu++11 -triple nvptx64-unknown-unknown -fsyntax-only -verify %s
|
|
// RUN: %clang_cc1 -std=gnu++11 -triple nvptx64-unknown-unknown -fcuda-is-device -fsyntax-only -verify %s
|
|
|
|
struct CopyableH {
|
|
const CopyableH& operator=(const CopyableH& x) { return *this; }
|
|
};
|
|
struct CopyableD {
|
|
__attribute__((device)) const CopyableD& operator=(const CopyableD x) { return *this; }
|
|
};
|
|
|
|
struct SimpleH {
|
|
CopyableH b;
|
|
};
|
|
// expected-note@-3 2 {{candidate function (the implicit copy assignment operator) not viable: call to __host__ function from __device__ function}}
|
|
// expected-note@-4 2 {{candidate function (the implicit move assignment operator) not viable: call to __host__ function from __device__ function}}
|
|
|
|
struct SimpleD {
|
|
CopyableD b;
|
|
};
|
|
// expected-note@-3 2 {{candidate function (the implicit copy assignment operator) not viable: call to __device__ function from __host__ function}}
|
|
// expected-note@-4 2 {{candidate function (the implicit move assignment operator) not viable: call to __device__ function from __host__ function}}
|
|
|
|
void foo1hh() {
|
|
SimpleH a, b;
|
|
a = b;
|
|
}
|
|
__attribute__((device)) void foo1hd() {
|
|
SimpleH a, b;
|
|
a = b; // expected-error {{no viable overloaded}}
|
|
}
|
|
void foo1dh() {
|
|
SimpleD a, b;
|
|
a = b; // expected-error {{no viable overloaded}}
|
|
}
|
|
__attribute__((device)) void foo1dd() {
|
|
SimpleD a, b;
|
|
a = b;
|
|
}
|
|
|
|
void foo2hh(SimpleH &a, SimpleH &b) {
|
|
a = b;
|
|
}
|
|
__attribute__((device)) void foo2hd(SimpleH &a, SimpleH &b) {
|
|
a = b; // expected-error {{no viable overloaded}}
|
|
}
|
|
void foo2dh(SimpleD &a, SimpleD &b) {
|
|
a = b; // expected-error {{no viable overloaded}}
|
|
}
|
|
__attribute__((device)) void foo2dd(SimpleD &a, SimpleD &b) {
|
|
a = b;
|
|
}
|