Debian Codegraph @

libgomp/testsuite/libgomp.c++/target-flex-2003.C

raw
1 /* { dg-additional-options "-std=c++20" } */
2
3 /* bit_cast and memcpy */
4
5 #include <bit>
6 #include <cstring>
7
8 #include "target-flex-common.h"
9
10 struct S0
11 {
12 int _v0;
13 char _v1;
14 long long _v2;
15 };
16
17 struct S1
18 {
19 int _v0;
20 char _v1;
21 long long _v2;
22 };
23
24 bool test_bit_cast(int arg)
25 {
26 bool ok;
27 S1 s1_out;
28 #pragma omp target map(from: ok, s1_out) map(to: arg)
29 {
30 bool inner_ok = true;
31 {
32 long long v = static_cast<long long>(arg + 42ll);
33 S0 s = {arg, 'a', v};
34 VERIFY (std::bit_cast<S1>(s)._v0 == arg);
35 VERIFY (std::bit_cast<S1>(s)._v1 == 'a');
36 VERIFY (std::bit_cast<S1>(s)._v2 == v);
37 s1_out = std::bit_cast<S1>(s);
38 }
39 end:
40 ok = inner_ok;
41 }
42 if (!ok)
43 return false;
44 long long v = static_cast<long long>(arg + 42ll);
45 VERIFY_NON_TARGET (std::bit_cast<S0>(s1_out)._v0 == arg);
46 VERIFY_NON_TARGET (std::bit_cast<S0>(s1_out)._v1 == 'a');
47 VERIFY_NON_TARGET (std::bit_cast<S0>(s1_out)._v2 == v);
48 return true;
49 }
50
51
52 struct OutStruct
53 {
54 std::size_t _id;
55 void *_next;
56 };
57
58 struct Extendable1
59 {
60 std::size_t _id;
61 void *_next;
62 int _v;
63 };
64
65 struct Extendable2
66 {
67 std::size_t _id;
68 void *_next;
69 char _str[256];
70 };
71
72 struct Extendable3
73 {
74 std::size_t _id;
75 void *_next;
76 const int *_nums;
77 std::size_t _size;
78 };
79
80 struct ExtendableUnknown
81 {
82 std::size_t _id;
83 void *_next;
84 };
85
86 template<typename To, std::size_t Id>
87 To *get_extendable(void *p)
88 {
89 while (p != nullptr)
90 {
91 OutStruct out;
92 std::memcpy(&out, p, sizeof(OutStruct));
93 if (out._id == Id)
94 return static_cast<To *>(p);
95 p = out._next;
96 }
97 return nullptr;
98 }
99
100 bool test_memcpy(int arg, const int *nums, std::size_t nums_size)
101 {
102 bool ok;
103 Extendable2 e2_out;
104 #pragma omp target map(from: ok, e2_out) map(to: arg, nums[:nums_size], nums_size)
105 {
106 bool inner_ok = true;
107 {
108 Extendable3 e3 = {3u, nullptr, nums, nums_size};
109 ExtendableUnknown u1 = {100u, &e3};
110 Extendable2 e2 = {2u, &u1, {'H', 'e', 'l', 'l', 'o', '!', '\000'}};
111 ExtendableUnknown u2 = {101u, &e2};
112 ExtendableUnknown u3 = {102u, &u2};
113 ExtendableUnknown u4 = {142u, &u3};
114 Extendable1 e1 = {1u, &u4, arg};
115
116 void *p = &e1;
117 while (p != nullptr)
118 {
119 /* You can always cast a pointer to a struct to a pointer to
120 the type of it's first member. */
121 switch (*static_cast<std::size_t *>(p))
122 {
123 case 1:
124 {
125 Extendable1 *e1_p = static_cast<Extendable1 *>(p);
126 p = e1_p->_next;
127 VERIFY (e1_p->_v == arg);
128 break;
129 }
130 case 2:
131 {
132 Extendable2 *e2_p = static_cast<Extendable2 *>(p);
133 p = e2_p->_next;
134 VERIFY (std::strcmp(e2_p->_str, "Hello!") == 0);
135 break;
136 }
137 case 3:
138 {
139 Extendable3 *e3_p = static_cast<Extendable3 *>(p);
140 p = e3_p->_next;
141 VERIFY (nums == e3_p->_nums);
142 VERIFY (nums_size == e3_p->_size);
143 break;
144 }
145 default:
146 {
147 /* Casting to a pointer to OutStruct invokes undefined
148 behavior though, memcpy is required to extract the _next
149 member. */
150 OutStruct out;
151 std::memcpy(&out, p, sizeof(OutStruct));
152 p = out._next;
153 }
154 }
155 }
156 Extendable2 *e2_p = get_extendable<Extendable2, 2u>(&e1);
157 VERIFY (e2_p != nullptr);
158 e2_out = *e2_p;
159 }
160 end:
161 ok = inner_ok;
162 }
163 if (!ok)
164 return false;
165 VERIFY_NON_TARGET (e2_out._id == 2u);
166 VERIFY_NON_TARGET (std::strcmp(e2_out._str, "Hello!") == 0);
167 return true;
168 }
169
170 int main()
171 {
172 volatile int arg = 42;
173 int arr[8] = {0, 1, 2, 3, 4, 5, 6, 7};
174 return test_bit_cast(arg)
175 && test_memcpy(arg, arr, 8) ? 0 : 1;
176 }