Commit db4fea6689eb34959028cad3b63de45da65683d3 | zig

author	Andrew Kelley <andrew@ziglang.org> 2021-08-28 13:11:47-07:00
committer	Andrew Kelley <andrew@ziglang.org> 2021-08-28 13:11:47-07:00
log	db4fea6689eb34959028cad3b63de45da65683d3
tree	a35545e60b6828c72b3101143834bf3f384921b9
parent	6aeab0f323ff14d7ad248e18c372573f7a5a8cd1

update libcxx, libcxxabi, and C headers to release/13.x branch

upstream commit 9c49fee5e7ac0ca8bc4ec1c3738ca0d83df65852

12 files changed, 476 insertions(+), 190 deletions(-)

lib
- include
  - __clang_cuda_device_functions.h
  - __clang_hip_cmath.h
  - __clang_hip_math.h
  - intrin.h
  - openmp_wrappers
    __clang_openmp_device_functions.h
    cmath
    math.h
- libcxx
  - include
    cwctype
    string
    vector
    wctype.h
- libcxxabi
  - src
    cxa_personality.cpp

lib/include/__clang_cuda_device_functions.h+174-102

...	...	@@ -34,10 +34,12 @@ __DEVICE__ unsigned long long __brevll(unsigned long long __a) {
34	34	return __nv_brevll(__a);
35	35	}
36	36	#if defined(__cplusplus)
37		__DEVICE__ void __brkpt() { asm volatile("brkpt;"); }
	37	__DEVICE__ void __brkpt() { __asm__ __volatile__("brkpt;"); }
38	38	__DEVICE__ void __brkpt(int __a) { __brkpt(); }
39	39	#else
40		__DEVICE__ void __attribute__((overloadable)) __brkpt(void) { asm volatile("brkpt;"); }
	40	__DEVICE__ void __attribute__((overloadable)) __brkpt(void) {
	41	__asm__ __volatile__("brkpt;");
	42	}
41	43	__DEVICE__ void __attribute__((overloadable)) __brkpt(int __a) { __brkpt(); }
42	44	#endif
43	45	__DEVICE__ unsigned int __byte_perm(unsigned int __a, unsigned int __b,
...	...	@@ -507,7 +509,7 @@ __DEVICE__ float __powf(float __a, float __b) {
507	509	}
508	510
509	511	// Parameter must have a known integer value.
510		#define __prof_trigger(__a) asm __volatile__("pmevent \t%0;" ::"i"(__a))
	512	#define __prof_trigger(__a) __asm__ __volatile__("pmevent \t%0;" ::"i"(__a))
511	513	__DEVICE__ int __rhadd(int __a, int __b) { return __nv_rhadd(__a, __b); }
512	514	__DEVICE__ unsigned int __sad(int __a, int __b, unsigned int __c) {
513	515	return __nv_sad(__a, __b, __c);
...	...	@@ -526,7 +528,7 @@ __DEVICE__ float __tanf(float __a) { return __nv_fast_tanf(__a); }
526	528	__DEVICE__ void __threadfence(void) { __nvvm_membar_gl(); }
527	529	__DEVICE__ void __threadfence_block(void) { __nvvm_membar_cta(); };
528	530	__DEVICE__ void __threadfence_system(void) { __nvvm_membar_sys(); };
529		__DEVICE__ void __trap(void) { asm volatile("trap;"); }
	531	__DEVICE__ void __trap(void) { __asm__ __volatile__("trap;"); }
530	532	__DEVICE__ unsigned int __uAtomicAdd(unsigned int *__p, unsigned int __v) {
531	533	return __nvvm_atom_add_gen_i((int *)__p, __v);
532	534	}
...	...	@@ -1051,122 +1053,136 @@ __DEVICE__ unsigned int __bool2mask(unsigned int __a, int shift) {
1051	1053	}
1052	1054	__DEVICE__ unsigned int __vabs2(unsigned int __a) {
1053	1055	unsigned int r;
1054		asm("vabsdiff2.s32.s32.s32 %0,%1,%2,%3;"
1055		: "=r"(r)
1056		: "r"(__a), "r"(0), "r"(0));
	1056	__asm__("vabsdiff2.s32.s32.s32 %0,%1,%2,%3;"
	1057	: "=r"(r)
	1058	: "r"(__a), "r"(0), "r"(0));
1057	1059	return r;
1058	1060	}
1059	1061	__DEVICE__ unsigned int __vabs4(unsigned int __a) {
1060	1062	unsigned int r;
1061		asm("vabsdiff4.s32.s32.s32 %0,%1,%2,%3;"
1062		: "=r"(r)
1063		: "r"(__a), "r"(0), "r"(0));
	1063	__asm__("vabsdiff4.s32.s32.s32 %0,%1,%2,%3;"
	1064	: "=r"(r)
	1065	: "r"(__a), "r"(0), "r"(0));
1064	1066	return r;
1065	1067	}
1066	1068	__DEVICE__ unsigned int __vabsdiffs2(unsigned int __a, unsigned int __b) {
1067	1069	unsigned int r;
1068		asm("vabsdiff2.s32.s32.s32 %0,%1,%2,%3;"
1069		: "=r"(r)
1070		: "r"(__a), "r"(__b), "r"(0));
	1070	__asm__("vabsdiff2.s32.s32.s32 %0,%1,%2,%3;"
	1071	: "=r"(r)
	1072	: "r"(__a), "r"(__b), "r"(0));
1071	1073	return r;
1072	1074	}
1073	1075
1074	1076	__DEVICE__ unsigned int __vabsdiffs4(unsigned int __a, unsigned int __b) {
1075	1077	unsigned int r;
1076		asm("vabsdiff4.s32.s32.s32 %0,%1,%2,%3;"
1077		: "=r"(r)
1078		: "r"(__a), "r"(__b), "r"(0));
	1078	__asm__("vabsdiff4.s32.s32.s32 %0,%1,%2,%3;"
	1079	: "=r"(r)
	1080	: "r"(__a), "r"(__b), "r"(0));
1079	1081	return r;
1080	1082	}
1081	1083	__DEVICE__ unsigned int __vabsdiffu2(unsigned int __a, unsigned int __b) {
1082	1084	unsigned int r;
1083		asm("vabsdiff2.u32.u32.u32 %0,%1,%2,%3;"
1084		: "=r"(r)
1085		: "r"(__a), "r"(__b), "r"(0));
	1085	__asm__("vabsdiff2.u32.u32.u32 %0,%1,%2,%3;"
	1086	: "=r"(r)
	1087	: "r"(__a), "r"(__b), "r"(0));
1086	1088	return r;
1087	1089	}
1088	1090	__DEVICE__ unsigned int __vabsdiffu4(unsigned int __a, unsigned int __b) {
1089	1091	unsigned int r;
1090		asm("vabsdiff4.u32.u32.u32 %0,%1,%2,%3;"
1091		: "=r"(r)
1092		: "r"(__a), "r"(__b), "r"(0));
	1092	__asm__("vabsdiff4.u32.u32.u32 %0,%1,%2,%3;"
	1093	: "=r"(r)
	1094	: "r"(__a), "r"(__b), "r"(0));
1093	1095	return r;
1094	1096	}
1095	1097	__DEVICE__ unsigned int __vabsss2(unsigned int __a) {
1096	1098	unsigned int r;
1097		asm("vabsdiff2.s32.s32.s32.sat %0,%1,%2,%3;"
1098		: "=r"(r)
1099		: "r"(__a), "r"(0), "r"(0));
	1099	__asm__("vabsdiff2.s32.s32.s32.sat %0,%1,%2,%3;"
	1100	: "=r"(r)
	1101	: "r"(__a), "r"(0), "r"(0));
1100	1102	return r;
1101	1103	}
1102	1104	__DEVICE__ unsigned int __vabsss4(unsigned int __a) {
1103	1105	unsigned int r;
1104		asm("vabsdiff4.s32.s32.s32.sat %0,%1,%2,%3;"
1105		: "=r"(r)
1106		: "r"(__a), "r"(0), "r"(0));
	1106	__asm__("vabsdiff4.s32.s32.s32.sat %0,%1,%2,%3;"
	1107	: "=r"(r)
	1108	: "r"(__a), "r"(0), "r"(0));
1107	1109	return r;
1108	1110	}
1109	1111	__DEVICE__ unsigned int __vadd2(unsigned int __a, unsigned int __b) {
1110	1112	unsigned int r;
1111		asm("vadd2.u32.u32.u32 %0,%1,%2,%3;" : "=r"(r) : "r"(__a), "r"(__b), "r"(0));
	1113	__asm__("vadd2.u32.u32.u32 %0,%1,%2,%3;"
	1114	: "=r"(r)
	1115	: "r"(__a), "r"(__b), "r"(0));
1112	1116	return r;
1113	1117	}
1114	1118	__DEVICE__ unsigned int __vadd4(unsigned int __a, unsigned int __b) {
1115	1119	unsigned int r;
1116		asm("vadd4.u32.u32.u32 %0,%1,%2,%3;" : "=r"(r) : "r"(__a), "r"(__b), "r"(0));
	1120	__asm__("vadd4.u32.u32.u32 %0,%1,%2,%3;"
	1121	: "=r"(r)
	1122	: "r"(__a), "r"(__b), "r"(0));
1117	1123	return r;
1118	1124	}
1119	1125	__DEVICE__ unsigned int __vaddss2(unsigned int __a, unsigned int __b) {
1120	1126	unsigned int r;
1121		asm("vadd2.s32.s32.s32.sat %0,%1,%2,%3;"
1122		: "=r"(r)
1123		: "r"(__a), "r"(__b), "r"(0));
	1127	__asm__("vadd2.s32.s32.s32.sat %0,%1,%2,%3;"
	1128	: "=r"(r)
	1129	: "r"(__a), "r"(__b), "r"(0));
1124	1130	return r;
1125	1131	}
1126	1132	__DEVICE__ unsigned int __vaddss4(unsigned int __a, unsigned int __b) {
1127	1133	unsigned int r;
1128		asm("vadd4.s32.s32.s32.sat %0,%1,%2,%3;"
1129		: "=r"(r)
1130		: "r"(__a), "r"(__b), "r"(0));
	1134	__asm__("vadd4.s32.s32.s32.sat %0,%1,%2,%3;"
	1135	: "=r"(r)
	1136	: "r"(__a), "r"(__b), "r"(0));
1131	1137	return r;
1132	1138	}
1133	1139	__DEVICE__ unsigned int __vaddus2(unsigned int __a, unsigned int __b) {
1134	1140	unsigned int r;
1135		asm("vadd2.u32.u32.u32.sat %0,%1,%2,%3;"
1136		: "=r"(r)
1137		: "r"(__a), "r"(__b), "r"(0));
	1141	__asm__("vadd2.u32.u32.u32.sat %0,%1,%2,%3;"
	1142	: "=r"(r)
	1143	: "r"(__a), "r"(__b), "r"(0));
1138	1144	return r;
1139	1145	}
1140	1146	__DEVICE__ unsigned int __vaddus4(unsigned int __a, unsigned int __b) {
1141	1147	unsigned int r;
1142		asm("vadd4.u32.u32.u32.sat %0,%1,%2,%3;"
1143		: "=r"(r)
1144		: "r"(__a), "r"(__b), "r"(0));
	1148	__asm__("vadd4.u32.u32.u32.sat %0,%1,%2,%3;"
	1149	: "=r"(r)
	1150	: "r"(__a), "r"(__b), "r"(0));
1145	1151	return r;
1146	1152	}
1147	1153	__DEVICE__ unsigned int __vavgs2(unsigned int __a, unsigned int __b) {
1148	1154	unsigned int r;
1149		asm("vavrg2.s32.s32.s32 %0,%1,%2,%3;" : "=r"(r) : "r"(__a), "r"(__b), "r"(0));
	1155	__asm__("vavrg2.s32.s32.s32 %0,%1,%2,%3;"
	1156	: "=r"(r)
	1157	: "r"(__a), "r"(__b), "r"(0));
1150	1158	return r;
1151	1159	}
1152	1160	__DEVICE__ unsigned int __vavgs4(unsigned int __a, unsigned int __b) {
1153	1161	unsigned int r;
1154		asm("vavrg4.s32.s32.s32 %0,%1,%2,%3;" : "=r"(r) : "r"(__a), "r"(__b), "r"(0));
	1162	__asm__("vavrg4.s32.s32.s32 %0,%1,%2,%3;"
	1163	: "=r"(r)
	1164	: "r"(__a), "r"(__b), "r"(0));
1155	1165	return r;
1156	1166	}
1157	1167	__DEVICE__ unsigned int __vavgu2(unsigned int __a, unsigned int __b) {
1158	1168	unsigned int r;
1159		asm("vavrg2.u32.u32.u32 %0,%1,%2,%3;" : "=r"(r) : "r"(__a), "r"(__b), "r"(0));
	1169	__asm__("vavrg2.u32.u32.u32 %0,%1,%2,%3;"
	1170	: "=r"(r)
	1171	: "r"(__a), "r"(__b), "r"(0));
1160	1172	return r;
1161	1173	}
1162	1174	__DEVICE__ unsigned int __vavgu4(unsigned int __a, unsigned int __b) {
1163	1175	unsigned int r;
1164		asm("vavrg4.u32.u32.u32 %0,%1,%2,%3;" : "=r"(r) : "r"(__a), "r"(__b), "r"(0));
	1176	__asm__("vavrg4.u32.u32.u32 %0,%1,%2,%3;"
	1177	: "=r"(r)
	1178	: "r"(__a), "r"(__b), "r"(0));
1165	1179	return r;
1166	1180	}
1167	1181	__DEVICE__ unsigned int __vseteq2(unsigned int __a, unsigned int __b) {
1168	1182	unsigned int r;
1169		asm("vset2.u32.u32.eq %0,%1,%2,%3;" : "=r"(r) : "r"(__a), "r"(__b), "r"(0));
	1183	__asm__("vset2.u32.u32.eq %0,%1,%2,%3;"
	1184	: "=r"(r)
	1185	: "r"(__a), "r"(__b), "r"(0));
1170	1186	return r;
1171	1187	}
1172	1188	__DEVICE__ unsigned int __vcmpeq2(unsigned int __a, unsigned int __b) {
...	...	@@ -1174,7 +1190,9 @@ __DEVICE__ unsigned int __vcmpeq2(unsigned int __a, unsigned int __b) {
1174	1190	}
1175	1191	__DEVICE__ unsigned int __vseteq4(unsigned int __a, unsigned int __b) {
1176	1192	unsigned int r;
1177		asm("vset4.u32.u32.eq %0,%1,%2,%3;" : "=r"(r) : "r"(__a), "r"(__b), "r"(0));
	1193	__asm__("vset4.u32.u32.eq %0,%1,%2,%3;"
	1194	: "=r"(r)
	1195	: "r"(__a), "r"(__b), "r"(0));
1178	1196	return r;
1179	1197	}
1180	1198	__DEVICE__ unsigned int __vcmpeq4(unsigned int __a, unsigned int __b) {
...	...	@@ -1182,7 +1200,9 @@ __DEVICE__ unsigned int __vcmpeq4(unsigned int __a, unsigned int __b) {
1182	1200	}
1183	1201	__DEVICE__ unsigned int __vsetges2(unsigned int __a, unsigned int __b) {
1184	1202	unsigned int r;
1185		asm("vset2.s32.s32.ge %0,%1,%2,%3;" : "=r"(r) : "r"(__a), "r"(__b), "r"(0));
	1203	__asm__("vset2.s32.s32.ge %0,%1,%2,%3;"
	1204	: "=r"(r)
	1205	: "r"(__a), "r"(__b), "r"(0));
1186	1206	return r;
1187	1207	}
1188	1208	__DEVICE__ unsigned int __vcmpges2(unsigned int __a, unsigned int __b) {
...	...	@@ -1190,7 +1210,9 @@ __DEVICE__ unsigned int __vcmpges2(unsigned int __a, unsigned int __b) {
1190	1210	}
1191	1211	__DEVICE__ unsigned int __vsetges4(unsigned int __a, unsigned int __b) {
1192	1212	unsigned int r;
1193		asm("vset4.s32.s32.ge %0,%1,%2,%3;" : "=r"(r) : "r"(__a), "r"(__b), "r"(0));
	1213	__asm__("vset4.s32.s32.ge %0,%1,%2,%3;"
	1214	: "=r"(r)
	1215	: "r"(__a), "r"(__b), "r"(0));
1194	1216	return r;
1195	1217	}
1196	1218	__DEVICE__ unsigned int __vcmpges4(unsigned int __a, unsigned int __b) {
...	...	@@ -1198,7 +1220,9 @@ __DEVICE__ unsigned int __vcmpges4(unsigned int __a, unsigned int __b) {
1198	1220	}
1199	1221	__DEVICE__ unsigned int __vsetgeu2(unsigned int __a, unsigned int __b) {
1200	1222	unsigned int r;
1201		asm("vset2.u32.u32.ge %0,%1,%2,%3;" : "=r"(r) : "r"(__a), "r"(__b), "r"(0));
	1223	__asm__("vset2.u32.u32.ge %0,%1,%2,%3;"
	1224	: "=r"(r)
	1225	: "r"(__a), "r"(__b), "r"(0));
1202	1226	return r;
1203	1227	}
1204	1228	__DEVICE__ unsigned int __vcmpgeu2(unsigned int __a, unsigned int __b) {
...	...	@@ -1206,7 +1230,9 @@ __DEVICE__ unsigned int __vcmpgeu2(unsigned int __a, unsigned int __b) {
1206	1230	}
1207	1231	__DEVICE__ unsigned int __vsetgeu4(unsigned int __a, unsigned int __b) {
1208	1232	unsigned int r;
1209		asm("vset4.u32.u32.ge %0,%1,%2,%3;" : "=r"(r) : "r"(__a), "r"(__b), "r"(0));
	1233	__asm__("vset4.u32.u32.ge %0,%1,%2,%3;"
	1234	: "=r"(r)
	1235	: "r"(__a), "r"(__b), "r"(0));
1210	1236	return r;
1211	1237	}
1212	1238	__DEVICE__ unsigned int __vcmpgeu4(unsigned int __a, unsigned int __b) {
...	...	@@ -1214,7 +1240,9 @@ __DEVICE__ unsigned int __vcmpgeu4(unsigned int __a, unsigned int __b) {
1214	1240	}
1215	1241	__DEVICE__ unsigned int __vsetgts2(unsigned int __a, unsigned int __b) {
1216	1242	unsigned int r;
1217		asm("vset2.s32.s32.gt %0,%1,%2,%3;" : "=r"(r) : "r"(__a), "r"(__b), "r"(0));
	1243	__asm__("vset2.s32.s32.gt %0,%1,%2,%3;"
	1244	: "=r"(r)
	1245	: "r"(__a), "r"(__b), "r"(0));
1218	1246	return r;
1219	1247	}
1220	1248	__DEVICE__ unsigned int __vcmpgts2(unsigned int __a, unsigned int __b) {
...	...	@@ -1222,7 +1250,9 @@ __DEVICE__ unsigned int __vcmpgts2(unsigned int __a, unsigned int __b) {
1222	1250	}
1223	1251	__DEVICE__ unsigned int __vsetgts4(unsigned int __a, unsigned int __b) {
1224	1252	unsigned int r;
1225		asm("vset4.s32.s32.gt %0,%1,%2,%3;" : "=r"(r) : "r"(__a), "r"(__b), "r"(0));
	1253	__asm__("vset4.s32.s32.gt %0,%1,%2,%3;"
	1254	: "=r"(r)
	1255	: "r"(__a), "r"(__b), "r"(0));
1226	1256	return r;
1227	1257	}
1228	1258	__DEVICE__ unsigned int __vcmpgts4(unsigned int __a, unsigned int __b) {
...	...	@@ -1230,7 +1260,9 @@ __DEVICE__ unsigned int __vcmpgts4(unsigned int __a, unsigned int __b) {
1230	1260	}
1231	1261	__DEVICE__ unsigned int __vsetgtu2(unsigned int __a, unsigned int __b) {
1232	1262	unsigned int r;
1233		asm("vset2.u32.u32.gt %0,%1,%2,%3;" : "=r"(r) : "r"(__a), "r"(__b), "r"(0));
	1263	__asm__("vset2.u32.u32.gt %0,%1,%2,%3;"
	1264	: "=r"(r)
	1265	: "r"(__a), "r"(__b), "r"(0));
1234	1266	return r;
1235	1267	}
1236	1268	__DEVICE__ unsigned int __vcmpgtu2(unsigned int __a, unsigned int __b) {
...	...	@@ -1238,7 +1270,9 @@ __DEVICE__ unsigned int __vcmpgtu2(unsigned int __a, unsigned int __b) {
1238	1270	}
1239	1271	__DEVICE__ unsigned int __vsetgtu4(unsigned int __a, unsigned int __b) {
1240	1272	unsigned int r;
1241		asm("vset4.u32.u32.gt %0,%1,%2,%3;" : "=r"(r) : "r"(__a), "r"(__b), "r"(0));
	1273	__asm__("vset4.u32.u32.gt %0,%1,%2,%3;"
	1274	: "=r"(r)
	1275	: "r"(__a), "r"(__b), "r"(0));
1242	1276	return r;
1243	1277	}
1244	1278	__DEVICE__ unsigned int __vcmpgtu4(unsigned int __a, unsigned int __b) {
...	...	@@ -1246,7 +1280,9 @@ __DEVICE__ unsigned int __vcmpgtu4(unsigned int __a, unsigned int __b) {
1246	1280	}
1247	1281	__DEVICE__ unsigned int __vsetles2(unsigned int __a, unsigned int __b) {
1248	1282	unsigned int r;
1249		asm("vset2.s32.s32.le %0,%1,%2,%3;" : "=r"(r) : "r"(__a), "r"(__b), "r"(0));
	1283	__asm__("vset2.s32.s32.le %0,%1,%2,%3;"
	1284	: "=r"(r)
	1285	: "r"(__a), "r"(__b), "r"(0));
1250	1286	return r;
1251	1287	}
1252	1288	__DEVICE__ unsigned int __vcmples2(unsigned int __a, unsigned int __b) {
...	...	@@ -1254,7 +1290,9 @@ __DEVICE__ unsigned int __vcmples2(unsigned int __a, unsigned int __b) {
1254	1290	}
1255	1291	__DEVICE__ unsigned int __vsetles4(unsigned int __a, unsigned int __b) {
1256	1292	unsigned int r;
1257		asm("vset4.s32.s32.le %0,%1,%2,%3;" : "=r"(r) : "r"(__a), "r"(__b), "r"(0));
	1293	__asm__("vset4.s32.s32.le %0,%1,%2,%3;"
	1294	: "=r"(r)
	1295	: "r"(__a), "r"(__b), "r"(0));
1258	1296	return r;
1259	1297	}
1260	1298	__DEVICE__ unsigned int __vcmples4(unsigned int __a, unsigned int __b) {
...	...	@@ -1262,7 +1300,9 @@ __DEVICE__ unsigned int __vcmples4(unsigned int __a, unsigned int __b) {
1262	1300	}
1263	1301	__DEVICE__ unsigned int __vsetleu2(unsigned int __a, unsigned int __b) {
1264	1302	unsigned int r;
1265		asm("vset2.u32.u32.le %0,%1,%2,%3;" : "=r"(r) : "r"(__a), "r"(__b), "r"(0));
	1303	__asm__("vset2.u32.u32.le %0,%1,%2,%3;"
	1304	: "=r"(r)
	1305	: "r"(__a), "r"(__b), "r"(0));
1266	1306	return r;
1267	1307	}
1268	1308	__DEVICE__ unsigned int __vcmpleu2(unsigned int __a, unsigned int __b) {
...	...	@@ -1270,7 +1310,9 @@ __DEVICE__ unsigned int __vcmpleu2(unsigned int __a, unsigned int __b) {
1270	1310	}
1271	1311	__DEVICE__ unsigned int __vsetleu4(unsigned int __a, unsigned int __b) {
1272	1312	unsigned int r;
1273		asm("vset4.u32.u32.le %0,%1,%2,%3;" : "=r"(r) : "r"(__a), "r"(__b), "r"(0));
	1313	__asm__("vset4.u32.u32.le %0,%1,%2,%3;"
	1314	: "=r"(r)
	1315	: "r"(__a), "r"(__b), "r"(0));
1274	1316	return r;
1275	1317	}
1276	1318	__DEVICE__ unsigned int __vcmpleu4(unsigned int __a, unsigned int __b) {
...	...	@@ -1278,7 +1320,9 @@ __DEVICE__ unsigned int __vcmpleu4(unsigned int __a, unsigned int __b) {
1278	1320	}
1279	1321	__DEVICE__ unsigned int __vsetlts2(unsigned int __a, unsigned int __b) {
1280	1322	unsigned int r;
1281		asm("vset2.s32.s32.lt %0,%1,%2,%3;" : "=r"(r) : "r"(__a), "r"(__b), "r"(0));
	1323	__asm__("vset2.s32.s32.lt %0,%1,%2,%3;"
	1324	: "=r"(r)
	1325	: "r"(__a), "r"(__b), "r"(0));
1282	1326	return r;
1283	1327	}
1284	1328	__DEVICE__ unsigned int __vcmplts2(unsigned int __a, unsigned int __b) {
...	...	@@ -1286,7 +1330,9 @@ __DEVICE__ unsigned int __vcmplts2(unsigned int __a, unsigned int __b) {
1286	1330	}
1287	1331	__DEVICE__ unsigned int __vsetlts4(unsigned int __a, unsigned int __b) {
1288	1332	unsigned int r;
1289		asm("vset4.s32.s32.lt %0,%1,%2,%3;" : "=r"(r) : "r"(__a), "r"(__b), "r"(0));
	1333	__asm__("vset4.s32.s32.lt %0,%1,%2,%3;"
	1334	: "=r"(r)
	1335	: "r"(__a), "r"(__b), "r"(0));
1290	1336	return r;
1291	1337	}
1292	1338	__DEVICE__ unsigned int __vcmplts4(unsigned int __a, unsigned int __b) {
...	...	@@ -1294,7 +1340,9 @@ __DEVICE__ unsigned int __vcmplts4(unsigned int __a, unsigned int __b) {
1294	1340	}
1295	1341	__DEVICE__ unsigned int __vsetltu2(unsigned int __a, unsigned int __b) {
1296	1342	unsigned int r;
1297		asm("vset2.u32.u32.lt %0,%1,%2,%3;" : "=r"(r) : "r"(__a), "r"(__b), "r"(0));
	1343	__asm__("vset2.u32.u32.lt %0,%1,%2,%3;"
	1344	: "=r"(r)
	1345	: "r"(__a), "r"(__b), "r"(0));
1298	1346	return r;
1299	1347	}
1300	1348	__DEVICE__ unsigned int __vcmpltu2(unsigned int __a, unsigned int __b) {
...	...	@@ -1302,7 +1350,9 @@ __DEVICE__ unsigned int __vcmpltu2(unsigned int __a, unsigned int __b) {
1302	1350	}
1303	1351	__DEVICE__ unsigned int __vsetltu4(unsigned int __a, unsigned int __b) {
1304	1352	unsigned int r;
1305		asm("vset4.u32.u32.lt %0,%1,%2,%3;" : "=r"(r) : "r"(__a), "r"(__b), "r"(0));
	1353	__asm__("vset4.u32.u32.lt %0,%1,%2,%3;"
	1354	: "=r"(r)
	1355	: "r"(__a), "r"(__b), "r"(0));
1306	1356	return r;
1307	1357	}
1308	1358	__DEVICE__ unsigned int __vcmpltu4(unsigned int __a, unsigned int __b) {
...	...	@@ -1310,7 +1360,9 @@ __DEVICE__ unsigned int __vcmpltu4(unsigned int __a, unsigned int __b) {
1310	1360	}
1311	1361	__DEVICE__ unsigned int __vsetne2(unsigned int __a, unsigned int __b) {
1312	1362	unsigned int r;
1313		asm("vset2.u32.u32.ne %0,%1,%2,%3;" : "=r"(r) : "r"(__a), "r"(__b), "r"(0));
	1363	__asm__("vset2.u32.u32.ne %0,%1,%2,%3;"
	1364	: "=r"(r)
	1365	: "r"(__a), "r"(__b), "r"(0));
1314	1366	return r;
1315	1367	}
1316	1368	__DEVICE__ unsigned int __vcmpne2(unsigned int __a, unsigned int __b) {
...	...	@@ -1318,7 +1370,9 @@ __DEVICE__ unsigned int __vcmpne2(unsigned int __a, unsigned int __b) {
1318	1370	}
1319	1371	__DEVICE__ unsigned int __vsetne4(unsigned int __a, unsigned int __b) {
1320	1372	unsigned int r;
1321		asm("vset4.u32.u32.ne %0,%1,%2,%3;" : "=r"(r) : "r"(__a), "r"(__b), "r"(0));
	1373	__asm__("vset4.u32.u32.ne %0,%1,%2,%3;"
	1374	: "=r"(r)
	1375	: "r"(__a), "r"(__b), "r"(0));
1322	1376	return r;
1323	1377	}
1324	1378	__DEVICE__ unsigned int __vcmpne4(unsigned int __a, unsigned int __b) {
...	...	@@ -1345,94 +1399,112 @@ __DEVICE__ unsigned int __vmaxs2(unsigned int __a, unsigned int __b) {
1345	1399	unsigned mask = __vcmpgts2(__a, __b);
1346	1400	r = (__a & mask) \| (__b & ~mask);
1347	1401	} else {
1348		asm("vmax2.s32.s32.s32 %0,%1,%2,%3;"
1349		: "=r"(r)
1350		: "r"(__a), "r"(__b), "r"(0));
	1402	__asm__("vmax2.s32.s32.s32 %0,%1,%2,%3;"
	1403	: "=r"(r)
	1404	: "r"(__a), "r"(__b), "r"(0));
1351	1405	}
1352	1406	return r;
1353	1407	}
1354	1408	__DEVICE__ unsigned int __vmaxs4(unsigned int __a, unsigned int __b) {
1355	1409	unsigned int r;
1356		asm("vmax4.s32.s32.s32 %0,%1,%2,%3;" : "=r"(r) : "r"(__a), "r"(__b), "r"(0));
	1410	__asm__("vmax4.s32.s32.s32 %0,%1,%2,%3;"
	1411	: "=r"(r)
	1412	: "r"(__a), "r"(__b), "r"(0));
1357	1413	return r;
1358	1414	}
1359	1415	__DEVICE__ unsigned int __vmaxu2(unsigned int __a, unsigned int __b) {
1360	1416	unsigned int r;
1361		asm("vmax2.u32.u32.u32 %0,%1,%2,%3;" : "=r"(r) : "r"(__a), "r"(__b), "r"(0));
	1417	__asm__("vmax2.u32.u32.u32 %0,%1,%2,%3;"
	1418	: "=r"(r)
	1419	: "r"(__a), "r"(__b), "r"(0));
1362	1420	return r;
1363	1421	}
1364	1422	__DEVICE__ unsigned int __vmaxu4(unsigned int __a, unsigned int __b) {
1365	1423	unsigned int r;
1366		asm("vmax4.u32.u32.u32 %0,%1,%2,%3;" : "=r"(r) : "r"(__a), "r"(__b), "r"(0));
	1424	__asm__("vmax4.u32.u32.u32 %0,%1,%2,%3;"
	1425	: "=r"(r)
	1426	: "r"(__a), "r"(__b), "r"(0));
1367	1427	return r;
1368	1428	}
1369	1429	__DEVICE__ unsigned int __vmins2(unsigned int __a, unsigned int __b) {
1370	1430	unsigned int r;
1371		asm("vmin2.s32.s32.s32 %0,%1,%2,%3;" : "=r"(r) : "r"(__a), "r"(__b), "r"(0));
	1431	__asm__("vmin2.s32.s32.s32 %0,%1,%2,%3;"
	1432	: "=r"(r)
	1433	: "r"(__a), "r"(__b), "r"(0));
1372	1434	return r;
1373	1435	}
1374	1436	__DEVICE__ unsigned int __vmins4(unsigned int __a, unsigned int __b) {
1375	1437	unsigned int r;
1376		asm("vmin4.s32.s32.s32 %0,%1,%2,%3;" : "=r"(r) : "r"(__a), "r"(__b), "r"(0));
	1438	__asm__("vmin4.s32.s32.s32 %0,%1,%2,%3;"
	1439	: "=r"(r)
	1440	: "r"(__a), "r"(__b), "r"(0));
1377	1441	return r;
1378	1442	}
1379	1443	__DEVICE__ unsigned int __vminu2(unsigned int __a, unsigned int __b) {
1380	1444	unsigned int r;
1381		asm("vmin2.u32.u32.u32 %0,%1,%2,%3;" : "=r"(r) : "r"(__a), "r"(__b), "r"(0));
	1445	__asm__("vmin2.u32.u32.u32 %0,%1,%2,%3;"
	1446	: "=r"(r)
	1447	: "r"(__a), "r"(__b), "r"(0));
1382	1448	return r;
1383	1449	}
1384	1450	__DEVICE__ unsigned int __vminu4(unsigned int __a, unsigned int __b) {
1385	1451	unsigned int r;
1386		asm("vmin4.u32.u32.u32 %0,%1,%2,%3;" : "=r"(r) : "r"(__a), "r"(__b), "r"(0));
	1452	__asm__("vmin4.u32.u32.u32 %0,%1,%2,%3;"
	1453	: "=r"(r)
	1454	: "r"(__a), "r"(__b), "r"(0));
1387	1455	return r;
1388	1456	}
1389	1457	__DEVICE__ unsigned int __vsads2(unsigned int __a, unsigned int __b) {
1390	1458	unsigned int r;
1391		asm("vabsdiff2.s32.s32.s32.add %0,%1,%2,%3;"
1392		: "=r"(r)
1393		: "r"(__a), "r"(__b), "r"(0));
	1459	__asm__("vabsdiff2.s32.s32.s32.add %0,%1,%2,%3;"
	1460	: "=r"(r)
	1461	: "r"(__a), "r"(__b), "r"(0));
1394	1462	return r;
1395	1463	}
1396	1464	__DEVICE__ unsigned int __vsads4(unsigned int __a, unsigned int __b) {
1397	1465	unsigned int r;
1398		asm("vabsdiff4.s32.s32.s32.add %0,%1,%2,%3;"
1399		: "=r"(r)
1400		: "r"(__a), "r"(__b), "r"(0));
	1466	__asm__("vabsdiff4.s32.s32.s32.add %0,%1,%2,%3;"
	1467	: "=r"(r)
	1468	: "r"(__a), "r"(__b), "r"(0));
1401	1469	return r;
1402	1470	}
1403	1471	__DEVICE__ unsigned int __vsadu2(unsigned int __a, unsigned int __b) {
1404	1472	unsigned int r;
1405		asm("vabsdiff2.u32.u32.u32.add %0,%1,%2,%3;"
1406		: "=r"(r)
1407		: "r"(__a), "r"(__b), "r"(0));
	1473	__asm__("vabsdiff2.u32.u32.u32.add %0,%1,%2,%3;"
	1474	: "=r"(r)
	1475	: "r"(__a), "r"(__b), "r"(0));
1408	1476	return r;
1409	1477	}
1410	1478	__DEVICE__ unsigned int __vsadu4(unsigned int __a, unsigned int __b) {
1411	1479	unsigned int r;
1412		asm("vabsdiff4.u32.u32.u32.add %0,%1,%2,%3;"
1413		: "=r"(r)
1414		: "r"(__a), "r"(__b), "r"(0));
	1480	__asm__("vabsdiff4.u32.u32.u32.add %0,%1,%2,%3;"
	1481	: "=r"(r)
	1482	: "r"(__a), "r"(__b), "r"(0));
1415	1483	return r;
1416	1484	}
1417	1485
1418	1486	__DEVICE__ unsigned int __vsub2(unsigned int __a, unsigned int __b) {
1419	1487	unsigned int r;
1420		asm("vsub2.u32.u32.u32 %0,%1,%2,%3;" : "=r"(r) : "r"(__a), "r"(__b), "r"(0));
	1488	__asm__("vsub2.u32.u32.u32 %0,%1,%2,%3;"
	1489	: "=r"(r)
	1490	: "r"(__a), "r"(__b), "r"(0));
1421	1491	return r;
1422	1492	}
1423	1493	__DEVICE__ unsigned int __vneg2(unsigned int __a) { return __vsub2(0, __a); }
1424	1494
1425	1495	__DEVICE__ unsigned int __vsub4(unsigned int __a, unsigned int __b) {
1426	1496	unsigned int r;
1427		asm("vsub4.u32.u32.u32 %0,%1,%2,%3;" : "=r"(r) : "r"(__a), "r"(__b), "r"(0));
	1497	__asm__("vsub4.u32.u32.u32 %0,%1,%2,%3;"
	1498	: "=r"(r)
	1499	: "r"(__a), "r"(__b), "r"(0));
1428	1500	return r;
1429	1501	}
1430	1502	__DEVICE__ unsigned int __vneg4(unsigned int __a) { return __vsub4(0, __a); }
1431	1503	__DEVICE__ unsigned int __vsubss2(unsigned int __a, unsigned int __b) {
1432	1504	unsigned int r;
1433		asm("vsub2.s32.s32.s32.sat %0,%1,%2,%3;"
1434		: "=r"(r)
1435		: "r"(__a), "r"(__b), "r"(0));
	1505	__asm__("vsub2.s32.s32.s32.sat %0,%1,%2,%3;"
	1506	: "=r"(r)
	1507	: "r"(__a), "r"(__b), "r"(0));
1436	1508	return r;
1437	1509	}
1438	1510	__DEVICE__ unsigned int __vnegss2(unsigned int __a) {
...	...	@@ -1440,9 +1512,9 @@ __DEVICE__ unsigned int __vnegss2(unsigned int __a) {
1440	1512	}
1441	1513	__DEVICE__ unsigned int __vsubss4(unsigned int __a, unsigned int __b) {
1442	1514	unsigned int r;
1443		asm("vsub4.s32.s32.s32.sat %0,%1,%2,%3;"
1444		: "=r"(r)
1445		: "r"(__a), "r"(__b), "r"(0));
	1515	__asm__("vsub4.s32.s32.s32.sat %0,%1,%2,%3;"
	1516	: "=r"(r)
	1517	: "r"(__a), "r"(__b), "r"(0));
1446	1518	return r;
1447	1519	}
1448	1520	__DEVICE__ unsigned int __vnegss4(unsigned int __a) {
...	...	@@ -1450,16 +1522,16 @@ __DEVICE__ unsigned int __vnegss4(unsigned int __a) {
1450	1522	}
1451	1523	__DEVICE__ unsigned int __vsubus2(unsigned int __a, unsigned int __b) {
1452	1524	unsigned int r;
1453		asm("vsub2.u32.u32.u32.sat %0,%1,%2,%3;"
1454		: "=r"(r)
1455		: "r"(__a), "r"(__b), "r"(0));
	1525	__asm__("vsub2.u32.u32.u32.sat %0,%1,%2,%3;"
	1526	: "=r"(r)
	1527	: "r"(__a), "r"(__b), "r"(0));
1456	1528	return r;
1457	1529	}
1458	1530	__DEVICE__ unsigned int __vsubus4(unsigned int __a, unsigned int __b) {
1459	1531	unsigned int r;
1460		asm("vsub4.u32.u32.u32.sat %0,%1,%2,%3;"
1461		: "=r"(r)
1462		: "r"(__a), "r"(__b), "r"(0));
	1532	__asm__("vsub4.u32.u32.u32.sat %0,%1,%2,%3;"
	1533	: "=r"(r)
	1534	: "r"(__a), "r"(__b), "r"(0));
1463	1535	return r;
1464	1536	}
1465	1537	#endif // CUDA_VERSION >= 9020

lib/include/__clang_hip_cmath.h+110-78

...	...	@@ -10,7 +10,7 @@
10	10	#ifndef __CLANG_HIP_CMATH_H__
11	11	#define __CLANG_HIP_CMATH_H__
12	12
13		#if !defined(__HIP__)
	13	#if !defined(__HIP__) && !defined(__OPENMP_AMDGCN__)
14	14	#error "This file is for HIP and OpenMP AMDGCN device compilation only."
15	15	#endif
16	16
...	...	@@ -25,31 +25,43 @@
25	25	#endif // !defined(__HIPCC_RTC__)
26	26
27	27	#pragma push_macro("__DEVICE__")
	28	#pragma push_macro("__CONSTEXPR__")
	29	#ifdef __OPENMP_AMDGCN__
	30	#define __DEVICE__ static __attribute__((always_inline, nothrow))
	31	#define __CONSTEXPR__ constexpr
	32	#else
28	33	#define __DEVICE__ static __device__ inline __attribute__((always_inline))
	34	#define __CONSTEXPR__
	35	#endif // __OPENMP_AMDGCN__
29	36
30	37	// Start with functions that cannot be defined by DEF macros below.
31	38	#if defined(__cplusplus)
32		__DEVICE__ double abs(double __x) { return ::fabs(__x); }
33		__DEVICE__ float abs(float __x) { return ::fabsf(__x); }
34		__DEVICE__ long long abs(long long __n) { return ::llabs(__n); }
35		__DEVICE__ long abs(long __n) { return ::labs(__n); }
36		__DEVICE__ float fma(float __x, float __y, float __z) {
	39	#if defined __OPENMP_AMDGCN__
	40	__DEVICE__ __CONSTEXPR__ float fabs(float __x) { return ::fabsf(__x); }
	41	__DEVICE__ __CONSTEXPR__ float sin(float __x) { return ::sinf(__x); }
	42	__DEVICE__ __CONSTEXPR__ float cos(float __x) { return ::cosf(__x); }
	43	#endif
	44	__DEVICE__ __CONSTEXPR__ double abs(double __x) { return ::fabs(__x); }
	45	__DEVICE__ __CONSTEXPR__ float abs(float __x) { return ::fabsf(__x); }
	46	__DEVICE__ __CONSTEXPR__ long long abs(long long __n) { return ::llabs(__n); }
	47	__DEVICE__ __CONSTEXPR__ long abs(long __n) { return ::labs(__n); }
	48	__DEVICE__ __CONSTEXPR__ float fma(float __x, float __y, float __z) {
37	49	return ::fmaf(__x, __y, __z);
38	50	}
39	51	#if !defined(__HIPCC_RTC__)
40	52	// The value returned by fpclassify is platform dependent, therefore it is not
41	53	// supported by hipRTC.
42		__DEVICE__ int fpclassify(float __x) {
	54	__DEVICE__ __CONSTEXPR__ int fpclassify(float __x) {
43	55	return __builtin_fpclassify(FP_NAN, FP_INFINITE, FP_NORMAL, FP_SUBNORMAL,
44	56	FP_ZERO, __x);
45	57	}
46		__DEVICE__ int fpclassify(double __x) {
	58	__DEVICE__ __CONSTEXPR__ int fpclassify(double __x) {
47	59	return __builtin_fpclassify(FP_NAN, FP_INFINITE, FP_NORMAL, FP_SUBNORMAL,
48	60	FP_ZERO, __x);
49	61	}
50	62	#endif // !defined(__HIPCC_RTC__)
51	63
52		__DEVICE__ float frexp(float __arg, int *__exp) {
	64	__DEVICE__ __CONSTEXPR__ float frexp(float __arg, int *__exp) {
53	65	return ::frexpf(__arg, __exp);
54	66	}
55	67
...	...	@@ -71,93 +83,101 @@ __DEVICE__ float frexp(float __arg, int *__exp) {
71	83	// of the variants inside the inner region and avoid the clash.
72	84	#pragma omp begin declare variant match(implementation = {vendor(llvm)})
73	85
74		__DEVICE__ int isinf(float __x) { return ::__isinff(__x); }
75		__DEVICE__ int isinf(double __x) { return ::__isinf(__x); }
76		__DEVICE__ int isfinite(float __x) { return ::__finitef(__x); }
77		__DEVICE__ int isfinite(double __x) { return ::__finite(__x); }
78		__DEVICE__ int isnan(float __x) { return ::__isnanf(__x); }
79		__DEVICE__ int isnan(double __x) { return ::__isnan(__x); }
	86	__DEVICE__ __CONSTEXPR__ int isinf(float __x) { return ::__isinff(__x); }
	87	__DEVICE__ __CONSTEXPR__ int isinf(double __x) { return ::__isinf(__x); }
	88	__DEVICE__ __CONSTEXPR__ int isfinite(float __x) { return ::__finitef(__x); }
	89	__DEVICE__ __CONSTEXPR__ int isfinite(double __x) { return ::__finite(__x); }
	90	__DEVICE__ __CONSTEXPR__ int isnan(float __x) { return ::__isnanf(__x); }
	91	__DEVICE__ __CONSTEXPR__ int isnan(double __x) { return ::__isnan(__x); }
80	92
81	93	#pragma omp end declare variant
82	94	#endif // defined(__OPENMP_AMDGCN__)
83	95
84		__DEVICE__ bool isinf(float __x) { return ::__isinff(__x); }
85		__DEVICE__ bool isinf(double __x) { return ::__isinf(__x); }
86		__DEVICE__ bool isfinite(float __x) { return ::__finitef(__x); }
87		__DEVICE__ bool isfinite(double __x) { return ::__finite(__x); }
88		__DEVICE__ bool isnan(float __x) { return ::__isnanf(__x); }
89		__DEVICE__ bool isnan(double __x) { return ::__isnan(__x); }
	96	__DEVICE__ __CONSTEXPR__ bool isinf(float __x) { return ::__isinff(__x); }
	97	__DEVICE__ __CONSTEXPR__ bool isinf(double __x) { return ::__isinf(__x); }
	98	__DEVICE__ __CONSTEXPR__ bool isfinite(float __x) { return ::__finitef(__x); }
	99	__DEVICE__ __CONSTEXPR__ bool isfinite(double __x) { return ::__finite(__x); }
	100	__DEVICE__ __CONSTEXPR__ bool isnan(float __x) { return ::__isnanf(__x); }
	101	__DEVICE__ __CONSTEXPR__ bool isnan(double __x) { return ::__isnan(__x); }
90	102
91	103	#if defined(__OPENMP_AMDGCN__)
92	104	#pragma omp end declare variant
93	105	#endif // defined(__OPENMP_AMDGCN__)
94	106
95		__DEVICE__ bool isgreater(float __x, float __y) {
	107	__DEVICE__ __CONSTEXPR__ bool isgreater(float __x, float __y) {
96	108	return __builtin_isgreater(__x, __y);
97	109	}
98		__DEVICE__ bool isgreater(double __x, double __y) {
	110	__DEVICE__ __CONSTEXPR__ bool isgreater(double __x, double __y) {
99	111	return __builtin_isgreater(__x, __y);
100	112	}
101		__DEVICE__ bool isgreaterequal(float __x, float __y) {
	113	__DEVICE__ __CONSTEXPR__ bool isgreaterequal(float __x, float __y) {
102	114	return __builtin_isgreaterequal(__x, __y);
103	115	}
104		__DEVICE__ bool isgreaterequal(double __x, double __y) {
	116	__DEVICE__ __CONSTEXPR__ bool isgreaterequal(double __x, double __y) {
105	117	return __builtin_isgreaterequal(__x, __y);
106	118	}
107		__DEVICE__ bool isless(float __x, float __y) {
	119	__DEVICE__ __CONSTEXPR__ bool isless(float __x, float __y) {
108	120	return __builtin_isless(__x, __y);
109	121	}
110		__DEVICE__ bool isless(double __x, double __y) {
	122	__DEVICE__ __CONSTEXPR__ bool isless(double __x, double __y) {
111	123	return __builtin_isless(__x, __y);
112	124	}
113		__DEVICE__ bool islessequal(float __x, float __y) {
	125	__DEVICE__ __CONSTEXPR__ bool islessequal(float __x, float __y) {
114	126	return __builtin_islessequal(__x, __y);
115	127	}
116		__DEVICE__ bool islessequal(double __x, double __y) {
	128	__DEVICE__ __CONSTEXPR__ bool islessequal(double __x, double __y) {
117	129	return __builtin_islessequal(__x, __y);
118	130	}
119		__DEVICE__ bool islessgreater(float __x, float __y) {
	131	__DEVICE__ __CONSTEXPR__ bool islessgreater(float __x, float __y) {
120	132	return __builtin_islessgreater(__x, __y);
121	133	}
122		__DEVICE__ bool islessgreater(double __x, double __y) {
	134	__DEVICE__ __CONSTEXPR__ bool islessgreater(double __x, double __y) {
123	135	return __builtin_islessgreater(__x, __y);
124	136	}
125		__DEVICE__ bool isnormal(float __x) { return __builtin_isnormal(__x); }
126		__DEVICE__ bool isnormal(double __x) { return __builtin_isnormal(__x); }
127		__DEVICE__ bool isunordered(float __x, float __y) {
	137	__DEVICE__ __CONSTEXPR__ bool isnormal(float __x) {
	138	return __builtin_isnormal(__x);
	139	}
	140	__DEVICE__ __CONSTEXPR__ bool isnormal(double __x) {
	141	return __builtin_isnormal(__x);
	142	}
	143	__DEVICE__ __CONSTEXPR__ bool isunordered(float __x, float __y) {
128	144	return __builtin_isunordered(__x, __y);
129	145	}
130		__DEVICE__ bool isunordered(double __x, double __y) {
	146	__DEVICE__ __CONSTEXPR__ bool isunordered(double __x, double __y) {
131	147	return __builtin_isunordered(__x, __y);
132	148	}
133		__DEVICE__ float modf(float __x, float *__iptr) { return ::modff(__x, __iptr); }
134		__DEVICE__ float pow(float __base, int __iexp) {
	149	__DEVICE__ __CONSTEXPR__ float modf(float __x, float *__iptr) {
	150	return ::modff(__x, __iptr);
	151	}
	152	__DEVICE__ __CONSTEXPR__ float pow(float __base, int __iexp) {
135	153	return ::powif(__base, __iexp);
136	154	}
137		__DEVICE__ double pow(double __base, int __iexp) {
	155	__DEVICE__ __CONSTEXPR__ double pow(double __base, int __iexp) {
138	156	return ::powi(__base, __iexp);
139	157	}
140		__DEVICE__ float remquo(float __x, float __y, int *__quo) {
	158	__DEVICE__ __CONSTEXPR__ float remquo(float __x, float __y, int *__quo) {
141	159	return ::remquof(__x, __y, __quo);
142	160	}
143		__DEVICE__ float scalbln(float __x, long int __n) {
	161	__DEVICE__ __CONSTEXPR__ float scalbln(float __x, long int __n) {
144	162	return ::scalblnf(__x, __n);
145	163	}
146		__DEVICE__ bool signbit(float __x) { return ::__signbitf(__x); }
147		__DEVICE__ bool signbit(double __x) { return ::__signbit(__x); }
	164	__DEVICE__ __CONSTEXPR__ bool signbit(float __x) { return ::__signbitf(__x); }
	165	__DEVICE__ __CONSTEXPR__ bool signbit(double __x) { return ::__signbit(__x); }
148	166
149	167	// Notably missing above is nexttoward. We omit it because
150	168	// ocml doesn't provide an implementation, and we don't want to be in the
151	169	// business of implementing tricky libm functions in this header.
152	170
153	171	// Other functions.
154		__DEVICE__ _Float16 fma(_Float16 __x, _Float16 __y, _Float16 __z) {
	172	__DEVICE__ __CONSTEXPR__ _Float16 fma(_Float16 __x, _Float16 __y,
	173	_Float16 __z) {
155	174	return __ocml_fma_f16(__x, __y, __z);
156	175	}
157		__DEVICE__ _Float16 pow(_Float16 __base, int __iexp) {
	176	__DEVICE__ __CONSTEXPR__ _Float16 pow(_Float16 __base, int __iexp) {
158	177	return __ocml_pown_f16(__base, __iexp);
159	178	}
160	179
	180	#ifndef __OPENMP_AMDGCN__
161	181	// BEGIN DEF_FUN and HIP_OVERLOAD
162	182
163	183	// BEGIN DEF_FUN
...	...	@@ -168,18 +188,19 @@ __DEVICE__ _Float16 pow(_Float16 __base, int __iexp) {
168	188
169	189	// Define cmath functions with float argument and returns __retty.
170	190	#define __DEF_FUN1(__retty, __func) \
171		__DEVICE__ \
172		__retty __func(float __x) { return __func##f(__x); }
	191	__DEVICE__ __CONSTEXPR__ __retty __func(float __x) { return __func##f(__x); }
173	192
174	193	// Define cmath functions with two float arguments and returns __retty.
175	194	#define __DEF_FUN2(__retty, __func) \
176		__DEVICE__ \
177		__retty __func(float __x, float __y) { return __func##f(__x, __y); }
	195	__DEVICE__ __CONSTEXPR__ __retty __func(float __x, float __y) { \
	196	return __func##f(__x, __y); \
	197	}
178	198
179	199	// Define cmath functions with a float and an int argument and returns __retty.
180	200	#define __DEF_FUN2_FI(__retty, __func) \
181		__DEVICE__ \
182		__retty __func(float __x, int __y) { return __func##f(__x, __y); }
	201	__DEVICE__ __CONSTEXPR__ __retty __func(float __x, int __y) { \
	202	return __func##f(__x, __y); \
	203	}
183	204
184	205	__DEF_FUN1(float, acos)
185	206	__DEF_FUN1(float, acosh)
...	...	@@ -426,7 +447,7 @@ class __promote : public __promote_imp<_A1, _A2, _A3> {};
426	447	// floor(double).
427	448	#define __HIP_OVERLOAD1(__retty, __fn) \
428	449	template <typename __T> \
429		__DEVICE__ \
	450	__DEVICE__ __CONSTEXPR__ \
430	451	typename __hip_enable_if<__hip::is_integral<__T>::value, __retty>::type \
431	452	__fn(__T __x) { \
432	453	return ::__fn((double)__x); \
...	...	@@ -438,7 +459,7 @@ class __promote : public __promote_imp<_A1, _A2, _A3> {};
438	459	#if __cplusplus >= 201103L
439	460	#define __HIP_OVERLOAD2(__retty, __fn) \
440	461	template <typename __T1, typename __T2> \
441		__DEVICE__ typename __hip_enable_if< \
	462	__DEVICE__ __CONSTEXPR__ typename __hip_enable_if< \
442	463	__hip::is_arithmetic<__T1>::value && __hip::is_arithmetic<__T2>::value, \
443	464	typename __hip::__promote<__T1, __T2>::type>::type \
444	465	__fn(__T1 __x, __T2 __y) { \
...	...	@@ -448,10 +469,11 @@ class __promote : public __promote_imp<_A1, _A2, _A3> {};
448	469	#else
449	470	#define __HIP_OVERLOAD2(__retty, __fn) \
450	471	template <typename __T1, typename __T2> \
451		__DEVICE__ typename __hip_enable_if<__hip::is_arithmetic<__T1>::value && \
452		__hip::is_arithmetic<__T2>::value, \
453		__retty>::type \
454		__fn(__T1 __x, __T2 __y) { \
	472	__DEVICE__ __CONSTEXPR__ \
	473	typename __hip_enable_if<__hip::is_arithmetic<__T1>::value && \
	474	__hip::is_arithmetic<__T2>::value, \
	475	__retty>::type \
	476	__fn(__T1 __x, __T2 __y) { \
455	477	return __fn((double)__x, (double)__y); \
456	478	}
457	479	#endif
...	...	@@ -526,7 +548,7 @@ __HIP_OVERLOAD2(double, min)
526	548	// Additional Overloads that don't quite match HIP_OVERLOAD.
527	549	#if __cplusplus >= 201103L
528	550	template <typename __T1, typename __T2, typename __T3>
529		__DEVICE__ typename __hip_enable_if<
	551	__DEVICE__ __CONSTEXPR__ typename __hip_enable_if<
530	552	__hip::is_arithmetic<__T1>::value && __hip::is_arithmetic<__T2>::value &&
531	553	__hip::is_arithmetic<__T3>::value,
532	554	typename __hip::__promote<__T1, __T2, __T3>::type>::type
...	...	@@ -536,31 +558,32 @@ fma(__T1 __x, __T2 __y, __T3 __z) {
536	558	}
537	559	#else
538	560	template <typename __T1, typename __T2, typename __T3>
539		__DEVICE__ typename __hip_enable_if<__hip::is_arithmetic<__T1>::value &&
540		__hip::is_arithmetic<__T2>::value &&
541		__hip::is_arithmetic<__T3>::value,
542		double>::type
543		fma(__T1 __x, __T2 __y, __T3 __z) {
	561	__DEVICE__ __CONSTEXPR__
	562	typename __hip_enable_if<__hip::is_arithmetic<__T1>::value &&
	563	__hip::is_arithmetic<__T2>::value &&
	564	__hip::is_arithmetic<__T3>::value,
	565	double>::type
	566	fma(__T1 __x, __T2 __y, __T3 __z) {
544	567	return ::fma((double)__x, (double)__y, (double)__z);
545	568	}
546	569	#endif
547	570
548	571	template <typename __T>
549		__DEVICE__
	572	__DEVICE__ __CONSTEXPR__
550	573	typename __hip_enable_if<__hip::is_integral<__T>::value, double>::type
551	574	frexp(__T __x, int *__exp) {
552	575	return ::frexp((double)__x, __exp);
553	576	}
554	577
555	578	template <typename __T>
556		__DEVICE__
	579	__DEVICE__ __CONSTEXPR__
557	580	typename __hip_enable_if<__hip::is_integral<__T>::value, double>::type
558	581	ldexp(__T __x, int __exp) {
559	582	return ::ldexp((double)__x, __exp);
560	583	}
561	584
562	585	template <typename __T>
563		__DEVICE__
	586	__DEVICE__ __CONSTEXPR__
564	587	typename __hip_enable_if<__hip::is_integral<__T>::value, double>::type
565	588	modf(__T __x, double *__exp) {
566	589	return ::modf((double)__x, __exp);
...	...	@@ -568,7 +591,7 @@ __DEVICE__
568	591
569	592	#if __cplusplus >= 201103L
570	593	template <typename __T1, typename __T2>
571		__DEVICE__
	594	__DEVICE__ __CONSTEXPR__
572	595	typename __hip_enable_if<__hip::is_arithmetic<__T1>::value &&
573	596	__hip::is_arithmetic<__T2>::value,
574	597	typename __hip::__promote<__T1, __T2>::type>::type
...	...	@@ -578,23 +601,24 @@ __DEVICE__
578	601	}
579	602	#else
580	603	template <typename __T1, typename __T2>
581		__DEVICE__ typename __hip_enable_if<__hip::is_arithmetic<__T1>::value &&
582		__hip::is_arithmetic<__T2>::value,
583		double>::type
584		remquo(__T1 __x, __T2 __y, int *__quo) {
	604	__DEVICE__ __CONSTEXPR__
	605	typename __hip_enable_if<__hip::is_arithmetic<__T1>::value &&
	606	__hip::is_arithmetic<__T2>::value,
	607	double>::type
	608	remquo(__T1 __x, __T2 __y, int *__quo) {
585	609	return ::remquo((double)__x, (double)__y, __quo);
586	610	}
587	611	#endif
588	612
589	613	template <typename __T>
590		__DEVICE__
	614	__DEVICE__ __CONSTEXPR__
591	615	typename __hip_enable_if<__hip::is_integral<__T>::value, double>::type
592	616	scalbln(__T __x, long int __exp) {
593	617	return ::scalbln((double)__x, __exp);
594	618	}
595	619
596	620	template <typename __T>
597		__DEVICE__
	621	__DEVICE__ __CONSTEXPR__
598	622	typename __hip_enable_if<__hip::is_integral<__T>::value, double>::type
599	623	scalbn(__T __x, int __exp) {
600	624	return ::scalbn((double)__x, __exp);
...	...	@@ -607,8 +631,10 @@ __DEVICE__
607	631
608	632	// END DEF_FUN and HIP_OVERLOAD
609	633
	634	#endif // ifndef __OPENMP_AMDGCN__
610	635	#endif // defined(__cplusplus)
611	636
	637	#ifndef __OPENMP_AMDGCN__
612	638	// Define these overloads inside the namespace our standard library uses.
613	639	#if !defined(__HIPCC_RTC__)
614	640	#ifdef _LIBCPP_BEGIN_NAMESPACE_STD
...	...	@@ -781,22 +807,26 @@ _GLIBCXX_END_NAMESPACE_VERSION
781	807	#if defined(__cplusplus)
782	808	extern "C" {
783	809	#endif // defined(__cplusplus)
784		__DEVICE__ __attribute__((overloadable)) double _Cosh(double x, double y) {
	810	__DEVICE__ __CONSTEXPR__ __attribute__((overloadable)) double _Cosh(double x,
	811	double y) {
785	812	return cosh(x) * y;
786	813	}
787		__DEVICE__ __attribute__((overloadable)) float _FCosh(float x, float y) {
	814	__DEVICE__ __CONSTEXPR__ __attribute__((overloadable)) float _FCosh(float x,
	815	float y) {
788	816	return coshf(x) * y;
789	817	}
790		__DEVICE__ __attribute__((overloadable)) short _Dtest(double *p) {
	818	__DEVICE__ __CONSTEXPR__ __attribute__((overloadable)) short _Dtest(double *p) {
791	819	return fpclassify(*p);
792	820	}
793		__DEVICE__ __attribute__((overloadable)) short _FDtest(float *p) {
	821	__DEVICE__ __CONSTEXPR__ __attribute__((overloadable)) short _FDtest(float *p) {
794	822	return fpclassify(*p);
795	823	}
796		__DEVICE__ __attribute__((overloadable)) double _Sinh(double x, double y) {
	824	__DEVICE__ __CONSTEXPR__ __attribute__((overloadable)) double _Sinh(double x,
	825	double y) {
797	826	return sinh(x) * y;
798	827	}
799		__DEVICE__ __attribute__((overloadable)) float _FSinh(float x, float y) {
	828	__DEVICE__ __CONSTEXPR__ __attribute__((overloadable)) float _FSinh(float x,
	829	float y) {
800	830	return sinhf(x) * y;
801	831	}
802	832	#if defined(__cplusplus)
...	...	@@ -804,7 +834,9 @@ __DEVICE__ __attribute__((overloadable)) float _FSinh(float x, float y) {
804	834	#endif // defined(__cplusplus)
805	835	#endif // defined(_MSC_VER)
806	836	#endif // !defined(__HIPCC_RTC__)
	837	#endif // ifndef __OPENMP_AMDGCN__
807	838
808	839	#pragma pop_macro("__DEVICE__")
	840	#pragma pop_macro("__CONSTEXPR__")
809	841
810	842	#endif // __CLANG_HIP_CMATH_H__

lib/include/__clang_hip_math.h+46-4

...	...	@@ -9,7 +9,7 @@
9	9	#ifndef __CLANG_HIP_MATH_H__
10	10	#define __CLANG_HIP_MATH_H__
11	11
12		#if !defined(__HIP__)
	12	#if !defined(__HIP__) && !defined(__OPENMP_AMDGCN__)
13	13	#error "This file is for HIP and OpenMP AMDGCN device compilation only."
14	14	#endif
15	15
...	...	@@ -19,18 +19,30 @@
19	19	#endif
20	20	#include <limits.h>
21	21	#include <stdint.h>
22		#endif // __HIPCC_RTC__
	22	#ifdef __OPENMP_AMDGCN__
	23	#include <omp.h>
	24	#endif
	25	#endif // !defined(__HIPCC_RTC__)
23	26
24	27	#pragma push_macro("__DEVICE__")
	28
	29	#ifdef __OPENMP_AMDGCN__
	30	#define __DEVICE__ static inline __attribute__((always_inline, nothrow))
	31	#else
25	32	#define __DEVICE__ static __device__ inline __attribute__((always_inline))
	33	#endif
26	34
27	35	// A few functions return bool type starting only in C++11.
28	36	#pragma push_macro("__RETURN_TYPE")
	37	#ifdef __OPENMP_AMDGCN__
	38	#define __RETURN_TYPE int
	39	#else
29	40	#if defined(__cplusplus)
30	41	#define __RETURN_TYPE bool
31	42	#else
32	43	#define __RETURN_TYPE int
33	44	#endif
	45	#endif // __OPENMP_AMDGCN__
34	46
35	47	#if defined (__cplusplus) && __cplusplus < 201103L
36	48	// emulate static_assert on type sizes
...	...	@@ -249,6 +261,9 @@ float fmodf(float __x, float __y) { return __ocml_fmod_f32(__x, __y); }
249	261	__DEVICE__
250	262	float frexpf(float __x, int *__nptr) {
251	263	int __tmp;
	264	#ifdef __OPENMP_AMDGCN__
	265	#pragma omp allocate(__tmp) allocator(omp_thread_mem_alloc)
	266	#endif
252	267	float __r =
253	268	__ocml_frexp_f32(__x, (__attribute__((address_space(5))) int *)&__tmp);
254	269	*__nptr = __tmp;
...	...	@@ -334,6 +349,9 @@ long int lroundf(float __x) { return __ocml_round_f32(__x); }
334	349	__DEVICE__
335	350	float modff(float __x, float *__iptr) {
336	351	float __tmp;
	352	#ifdef __OPENMP_AMDGCN__
	353	#pragma omp allocate(__tmp) allocator(omp_thread_mem_alloc)
	354	#endif
337	355	float __r =
338	356	__ocml_modf_f32(__x, (__attribute__((address_space(5))) float *)&__tmp);
339	357	*__iptr = __tmp;
...	...	@@ -414,6 +432,9 @@ float remainderf(float __x, float __y) {
414	432	__DEVICE__
415	433	float remquof(float __x, float __y, int *__quo) {
416	434	int __tmp;
	435	#ifdef __OPENMP_AMDGCN__
	436	#pragma omp allocate(__tmp) allocator(omp_thread_mem_alloc)
	437	#endif
417	438	float __r = __ocml_remquo_f32(
418	439	__x, __y, (__attribute__((address_space(5))) int *)&__tmp);
419	440	*__quo = __tmp;
...	...	@@ -470,6 +491,9 @@ __RETURN_TYPE __signbitf(float __x) { return __ocml_signbit_f32(__x); }
470	491	__DEVICE__
471	492	void sincosf(float __x, float __sinptr, float __cosptr) {
472	493	float __tmp;
	494	#ifdef __OPENMP_AMDGCN__
	495	#pragma omp allocate(__tmp) allocator(omp_thread_mem_alloc)
	496	#endif
473	497	*__sinptr =
474	498	__ocml_sincos_f32(__x, (__attribute__((address_space(5))) float *)&__tmp);
475	499	*__cosptr = __tmp;
...	...	@@ -478,6 +502,9 @@ void sincosf(float __x, float __sinptr, float __cosptr) {
478	502	__DEVICE__
479	503	void sincospif(float __x, float __sinptr, float __cosptr) {
480	504	float __tmp;
	505	#ifdef __OPENMP_AMDGCN__
	506	#pragma omp allocate(__tmp) allocator(omp_thread_mem_alloc)
	507	#endif
481	508	*__sinptr = __ocml_sincospi_f32(
482	509	__x, (__attribute__((address_space(5))) float *)&__tmp);
483	510	*__cosptr = __tmp;
...	...	@@ -790,6 +817,9 @@ double fmod(double __x, double __y) { return __ocml_fmod_f64(__x, __y); }
790	817	__DEVICE__
791	818	double frexp(double __x, int *__nptr) {
792	819	int __tmp;
	820	#ifdef __OPENMP_AMDGCN__
	821	#pragma omp allocate(__tmp) allocator(omp_thread_mem_alloc)
	822	#endif
793	823	double __r =
794	824	__ocml_frexp_f64(__x, (__attribute__((address_space(5))) int *)&__tmp);
795	825	*__nptr = __tmp;
...	...	@@ -874,6 +904,9 @@ long int lround(double __x) { return __ocml_round_f64(__x); }
874	904	__DEVICE__
875	905	double modf(double __x, double *__iptr) {
876	906	double __tmp;
	907	#ifdef __OPENMP_AMDGCN__
	908	#pragma omp allocate(__tmp) allocator(omp_thread_mem_alloc)
	909	#endif
877	910	double __r =
878	911	__ocml_modf_f64(__x, (__attribute__((address_space(5))) double *)&__tmp);
879	912	*__iptr = __tmp;
...	...	@@ -962,6 +995,9 @@ double remainder(double __x, double __y) {
962	995	__DEVICE__
963	996	double remquo(double __x, double __y, int *__quo) {
964	997	int __tmp;
	998	#ifdef __OPENMP_AMDGCN__
	999	#pragma omp allocate(__tmp) allocator(omp_thread_mem_alloc)
	1000	#endif
965	1001	double __r = __ocml_remquo_f64(
966	1002	__x, __y, (__attribute__((address_space(5))) int *)&__tmp);
967	1003	*__quo = __tmp;
...	...	@@ -1020,6 +1056,9 @@ double sin(double __x) { return __ocml_sin_f64(__x); }
1020	1056	__DEVICE__
1021	1057	void sincos(double __x, double __sinptr, double __cosptr) {
1022	1058	double __tmp;
	1059	#ifdef __OPENMP_AMDGCN__
	1060	#pragma omp allocate(__tmp) allocator(omp_thread_mem_alloc)
	1061	#endif
1023	1062	*__sinptr = __ocml_sincos_f64(
1024	1063	__x, (__attribute__((address_space(5))) double *)&__tmp);
1025	1064	*__cosptr = __tmp;
...	...	@@ -1028,6 +1067,9 @@ void sincos(double __x, double __sinptr, double __cosptr) {
1028	1067	__DEVICE__
1029	1068	void sincospi(double __x, double __sinptr, double __cosptr) {
1030	1069	double __tmp;
	1070	#ifdef __OPENMP_AMDGCN__
	1071	#pragma omp allocate(__tmp) allocator(omp_thread_mem_alloc)
	1072	#endif
1031	1073	*__sinptr = __ocml_sincospi_f64(
1032	1074	__x, (__attribute__((address_space(5))) double *)&__tmp);
1033	1075	*__cosptr = __tmp;
...	...	@@ -1262,7 +1304,7 @@ float min(float __x, float __y) { return fminf(__x, __y); }
1262	1304	__DEVICE__
1263	1305	double min(double __x, double __y) { return fmin(__x, __y); }
1264	1306
1265		#if !defined(__HIPCC_RTC__)
	1307	#if !defined(__HIPCC_RTC__) && !defined(__OPENMP_AMDGCN__)
1266	1308	__host__ inline static int min(int __arg1, int __arg2) {
1267	1309	return std::min(__arg1, __arg2);
1268	1310	}
...	...	@@ -1270,7 +1312,7 @@ __host__ inline static int min(int __arg1, int __arg2) {
1270	1312	__host__ inline static int max(int __arg1, int __arg2) {
1271	1313	return std::max(__arg1, __arg2);
1272	1314	}
1273		#endif // __HIPCC_RTC__
	1315	#endif // !defined(__HIPCC_RTC__) && !defined(__OPENMP_AMDGCN__)
1274	1316	#endif
1275	1317
1276	1318	#pragma pop_macro("__DEVICE__")

lib/include/intrin.h+3

...	...	@@ -574,6 +574,9 @@ void _WriteStatusReg(int, __int64);
574	574	unsigned short __cdecl _byteswap_ushort(unsigned short val);
575	575	unsigned long __cdecl _byteswap_ulong (unsigned long val);
576	576	unsigned __int64 __cdecl _byteswap_uint64(unsigned __int64 val);
	577
	578	__int64 __mulh(__int64 __a, __int64 __b);
	579	unsigned __int64 __umulh(unsigned __int64 __a, unsigned __int64 __b);
577	580	#endif
578	581
579	582	/----------------------------------------------------------------------------\

lib/include/openmp_wrappers/__clang_openmp_device_functions.h+27-5

...	...	@@ -14,13 +14,13 @@
14	14	#error "This file is for OpenMP compilation only."
15	15	#endif
16	16
17		#pragma omp begin declare variant match( \
18		device = {arch(nvptx, nvptx64)}, implementation = {extension(match_any)})
19
20	17	#ifdef __cplusplus
21	18	extern "C" {
22	19	#endif
23	20
	21	#pragma omp begin declare variant match( \
	22	device = {arch(nvptx, nvptx64)}, implementation = {extension(match_any)})
	23
24	24	#define __CUDA__
25	25	#define __OPENMP_NVPTX__
26	26
...	...	@@ -33,11 +33,33 @@ extern "C" {
33	33	#undef __OPENMP_NVPTX__
34	34	#undef __CUDA__
35	35
36		#ifdef __cplusplus
37		} // extern "C"
	36	#pragma omp end declare variant
	37
	38	#ifdef __AMDGCN__
	39	#pragma omp begin declare variant match(device = {arch(amdgcn)})
	40
	41	// Import types which will be used by __clang_hip_libdevice_declares.h
	42	#ifndef __cplusplus
	43	#include <stdbool.h>
	44	#include <stdint.h>
38	45	#endif
39	46
	47	#define __OPENMP_AMDGCN__
	48	#pragma push_macro("__device__")
	49	#define __device__
	50
	51	/// Include declarations for libdevice functions.
	52	#include <__clang_hip_libdevice_declares.h>
	53
	54	#pragma pop_macro("__device__")
	55	#undef __OPENMP_AMDGCN__
	56
40	57	#pragma omp end declare variant
	58	#endif
	59
	60	#ifdef __cplusplus
	61	} // extern "C"
	62	#endif
41	63
42	64	// Ensure we make `_ZdlPv`, aka. `operator delete(void*)` available without the
43	65	// need to `include <new>` in C++ mode.

lib/include/openmp_wrappers/cmath+54

...	...	@@ -75,4 +75,58 @@ __DEVICE__ float tgamma(float __x) { return ::tgammaf(__x); }
75	75
76	76	#pragma omp end declare variant
77	77
	78	#ifdef __AMDGCN__
	79	#pragma omp begin declare variant match(device = {arch(amdgcn)})
	80
	81	#pragma push_macro("__constant__")
	82	#define __constant__ __attribute__((constant))
	83	#define __OPENMP_AMDGCN__
	84
	85	#include <__clang_hip_cmath.h>
	86
	87	#pragma pop_macro("__constant__")
	88	#undef __OPENMP_AMDGCN__
	89
	90	// Define overloads otherwise which are absent
	91	#define __DEVICE__ static constexpr __attribute__((always_inline, nothrow))
	92
	93	__DEVICE__ float acos(float __x) { return ::acosf(__x); }
	94	__DEVICE__ float acosh(float __x) { return ::acoshf(__x); }
	95	__DEVICE__ float asin(float __x) { return ::asinf(__x); }
	96	__DEVICE__ float asinh(float __x) { return ::asinhf(__x); }
	97	__DEVICE__ float atan(float __x) { return ::atanf(__x); }
	98	__DEVICE__ float atan2(float __x, float __y) { return ::atan2f(__x, __y); }
	99	__DEVICE__ float atanh(float __x) { return ::atanhf(__x); }
	100	__DEVICE__ float cbrt(float __x) { return ::cbrtf(__x); }
	101	__DEVICE__ float cosh(float __x) { return ::coshf(__x); }
	102	__DEVICE__ float erf(float __x) { return ::erff(__x); }
	103	__DEVICE__ float erfc(float __x) { return ::erfcf(__x); }
	104	__DEVICE__ float exp2(float __x) { return ::exp2f(__x); }
	105	__DEVICE__ float expm1(float __x) { return ::expm1f(__x); }
	106	__DEVICE__ float fdim(float __x, float __y) { return ::fdimf(__x, __y); }
	107	__DEVICE__ float hypot(float __x, float __y) { return ::hypotf(__x, __y); }
	108	__DEVICE__ int ilogb(float __x) { return ::ilogbf(__x); }
	109	__DEVICE__ float ldexp(float __arg, int __exp) {
	110	return ::ldexpf(__arg, __exp);
	111	}
	112	__DEVICE__ float lgamma(float __x) { return ::lgammaf(__x); }
	113	__DEVICE__ float log1p(float __x) { return ::log1pf(__x); }
	114	__DEVICE__ float logb(float __x) { return ::logbf(__x); }
	115	__DEVICE__ float nextafter(float __x, float __y) {
	116	return ::nextafterf(__x, __y);
	117	}
	118	__DEVICE__ float remainder(float __x, float __y) {
	119	return ::remainderf(__x, __y);
	120	}
	121	__DEVICE__ float scalbn(float __x, int __y) { return ::scalbnf(__x, __y); }
	122	__DEVICE__ float sinh(float __x) { return ::sinhf(__x); }
	123	__DEVICE__ float tan(float __x) { return ::tanf(__x); }
	124	__DEVICE__ float tanh(float __x) { return ::tanhf(__x); }
	125	__DEVICE__ float tgamma(float __x) { return ::tgammaf(__x); }
	126
	127	#undef __DEVICE__
	128
	129	#pragma omp end declare variant
	130	#endif // __AMDGCN__
	131
78	132	#endif

lib/include/openmp_wrappers/math.h+10

...	...	@@ -48,4 +48,14 @@
48	48
49	49	#pragma omp end declare variant
50	50
	51	#ifdef __AMDGCN__
	52	#pragma omp begin declare variant match(device = {arch(amdgcn)})
	53
	54	#define __OPENMP_AMDGCN__
	55	#include <__clang_hip_math.h>
	56	#undef __OPENMP_AMDGCN__
	57
	58	#pragma omp end declare variant
	59	#endif
	60
51	61	#endif

lib/libcxx/include/cwctype+2

...	...	@@ -59,6 +59,7 @@ wctrans_t wctrans(const char* property);
59	59
60	60	_LIBCPP_BEGIN_NAMESPACE_STD
61	61
	62	#if defined(_LIBCPP_INCLUDED_C_LIBRARY_WCTYPE_H)
62	63	using ::wint_t _LIBCPP_USING_IF_EXISTS;
63	64	using ::wctrans_t _LIBCPP_USING_IF_EXISTS;
64	65	using ::wctype_t _LIBCPP_USING_IF_EXISTS;
...	...	@@ -80,6 +81,7 @@ using ::towlower _LIBCPP_USING_IF_EXISTS;
80	81	using ::towupper _LIBCPP_USING_IF_EXISTS;
81	82	using ::towctrans _LIBCPP_USING_IF_EXISTS;
82	83	using ::wctrans _LIBCPP_USING_IF_EXISTS;
	84	#endif // _LIBCPP_INCLUDED_C_LIBRARY_WCTYPE_H
83	85
84	86	_LIBCPP_END_NAMESPACE_STD
85	87

lib/libcxx/include/string+19

...	...	@@ -522,6 +522,7 @@ basic_string<char32_t> operator "" s( const char32_t *str, size_t len ); // C++1
522	522	#include <algorithm>
523	523	#include <compare>
524	524	#include <cstdio> // EOF
	525	#include <cstdlib>
525	526	#include <cstring>
526	527	#include <cwchar>
527	528	#include <initializer_list>
...	...	@@ -1714,6 +1715,24 @@ private:
1714	1715	return data() <= __p && __p <= data() + size();
1715	1716	}
1716	1717
	1718	_LIBCPP_NORETURN _LIBCPP_HIDE_FROM_ABI
	1719	void __throw_length_error() const {
	1720	#ifndef _LIBCPP_NO_EXCEPTIONS
	1721	__basic_string_common<true>::__throw_length_error();
	1722	#else
	1723	_VSTD::abort();
	1724	#endif
	1725	}
	1726
	1727	_LIBCPP_NORETURN _LIBCPP_HIDE_FROM_ABI
	1728	void __throw_out_of_range() const {
	1729	#ifndef _LIBCPP_NO_EXCEPTIONS
	1730	__basic_string_common<true>::__throw_out_of_range();
	1731	#else
	1732	_VSTD::abort();
	1733	#endif
	1734	}
	1735
1717	1736	friend basic_string operator+<>(const basic_string&, const basic_string&);
1718	1737	friend basic_string operator+<>(const value_type*, const basic_string&);
1719	1738	friend basic_string operator+<>(value_type, const basic_string&);

lib/libcxx/include/vector+20

...	...	@@ -281,6 +281,7 @@ erase_if(vector<T, Allocator>& c, Predicate pred); // C++20
281	281	#include <algorithm>
282	282	#include <climits>
283	283	#include <compare>
	284	#include <cstdlib>
284	285	#include <cstring>
285	286	#include <initializer_list>
286	287	#include <iosfwd> // for forward declaration of vector
...	...	@@ -390,6 +391,25 @@ protected:
390	391	is_nothrow_move_assignable<allocator_type>::value)
391	392	{__move_assign_alloc(__c, integral_constant<bool,
392	393	__alloc_traits::propagate_on_container_move_assignment::value>());}
	394
	395	_LIBCPP_NORETURN _LIBCPP_HIDE_FROM_ABI
	396	void __throw_length_error() const {
	397	#ifndef _LIBCPP_NO_EXCEPTIONS
	398	__vector_base_common<true>::__throw_length_error();
	399	#else
	400	_VSTD::abort();
	401	#endif
	402	}
	403
	404	_LIBCPP_NORETURN _LIBCPP_HIDE_FROM_ABI
	405	void __throw_out_of_range() const {
	406	#ifndef _LIBCPP_NO_EXCEPTIONS
	407	__vector_base_common<true>::__throw_out_of_range();
	408	#else
	409	_VSTD::abort();
	410	#endif
	411	}
	412
393	413	private:
394	414	_LIBCPP_INLINE_VISIBILITY
395	415	void __copy_assign_alloc(const __vector_base& __c, true_type)

lib/libcxx/include/wctype.h+10

...	...	@@ -50,8 +50,18 @@ wctrans_t wctrans(const char* property);
50	50	#pragma GCC system_header
51	51	#endif
52	52
	53	// TODO:
	54	// In the future, we should unconditionally include_next <wctype.h> here and instead
	55	// have a mode under which the library does not need libc++'s <wctype.h> or <cwctype>
	56	// at all (i.e. a mode without wchar_t). As it stands, we need to do that to completely
	57	// bypass the using declarations in <cwctype> when we did not include <wctype.h>.
	58	// Otherwise, a using declaration like `using ::wint_t` in <cwctype> will refer to
	59	// nothing (with using_if_exists), and if we include another header that defines one
	60	// of these declarations (e.g. <wchar.h>), the second `using ::wint_t` with using_if_exists
	61	// will fail because it does not refer to the same declaration.
53	62	#if __has_include_next(<wctype.h>)
54	63	# include_next <wctype.h>
	64	# define _LIBCPP_INCLUDED_C_LIBRARY_WCTYPE_H
55	65	#endif
56	66
57	67	#ifdef __cplusplus

lib/libcxxabi/src/cxa_personality.cpp+1-1

...	...	@@ -702,10 +702,10 @@ static void scan_eh_tab(scan_results &results, _Unwind_Action actions,
702	702	return;
703	703	}
704	704	landingPad = (uintptr_t)lpStart + landingPad;
705		results.landingPad = landingPad;
706	705	#else // __USING_SJLJ_EXCEPTIONS__
707	706	++landingPad;
708	707	#endif // __USING_SJLJ_EXCEPTIONS__
	708	results.landingPad = landingPad;
709	709	if (actionEntry == 0)
710	710	{
711	711	// Found a cleanup