Skip to content

Commit 5996aad

Browse files
author
Sriya Pratipati
committed
Merge branch 'main' into mbsrtowcs-implementation
2 parents 73083e4 + bd86fc9 commit 5996aad

File tree

56 files changed

+1003
-222
lines changed

Some content is hidden

Large Commits have some content hidden by default. Use the searchbox below for content that may be hidden.

56 files changed

+1003
-222
lines changed

‎clang/include/clang/Basic/BuiltinsAMDGPU.def‎

Lines changed: 3 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -642,5 +642,8 @@ TARGET_BUILTIN(__builtin_amdgcn_cvt_sr_f16_f32, "V2hV2hfUiIb", "nc", "f32-to-f16
642642

643643
TARGET_BUILTIN(__builtin_amdgcn_s_setprio_inc_wg, "vIs", "n", "setprio-inc-wg-inst")
644644

645+
TARGET_BUILTIN(__builtin_amdgcn_cvt_pk_f16_fp8, "V2hs", "nc", "gfx1250-insts")
646+
TARGET_BUILTIN(__builtin_amdgcn_cvt_pk_f16_bf8, "V2hs", "nc", "gfx1250-insts")
647+
645648
#undef BUILTIN
646649
#undef TARGET_BUILTIN

‎clang/test/CodeGenOpenCL/builtins-amdgcn-gfx1250.cl‎

Lines changed: 44 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -2,6 +2,10 @@
22
// RUN: %clang_cc1 -cl-std=CL2.0 -O0 -triple amdgcn-unknown-unknown -target-cpu gfx1250 -emit-llvm -o - %s | FileCheck %s
33
// REQUIRES: amdgpu-registered-target
44

5+
#pragma OPENCL EXTENSION cl_khr_fp16 : enable
6+
7+
typedef half __attribute__((ext_vector_type(2))) half2;
8+
59
// CHECK-LABEL: @test_setprio_inc_wg(
610
// CHECK-NEXT: entry:
711
// CHECK-NEXT: call void @llvm.amdgcn.s.setprio.inc.wg(i16 10)
@@ -10,3 +14,43 @@
1014
void test_setprio_inc_wg() {
1115
__builtin_amdgcn_s_setprio_inc_wg(10);
1216
}
17+
18+
// CHECK-LABEL: @test_cvt_pk_f16_fp8(
19+
// CHECK-NEXT: entry:
20+
// CHECK-NEXT: [[OUT_ADDR:%.*]] = alloca ptr addrspace(1), align 8, addrspace(5)
21+
// CHECK-NEXT: [[A_ADDR:%.*]] = alloca i16, align 2, addrspace(5)
22+
// CHECK-NEXT: [[OUT_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[OUT_ADDR]] to ptr
23+
// CHECK-NEXT: [[A_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[A_ADDR]] to ptr
24+
// CHECK-NEXT: store ptr addrspace(1) [[OUT:%.*]], ptr [[OUT_ADDR_ASCAST]], align 8
25+
// CHECK-NEXT: store i16 [[A:%.*]], ptr [[A_ADDR_ASCAST]], align 2
26+
// CHECK-NEXT: [[TMP0:%.*]] = load i16, ptr [[A_ADDR_ASCAST]], align 2
27+
// CHECK-NEXT: [[TMP1:%.*]] = call <2 x half> @llvm.amdgcn.cvt.pk.f16.fp8(i16 [[TMP0]])
28+
// CHECK-NEXT: [[TMP2:%.*]] = load ptr addrspace(1), ptr [[OUT_ADDR_ASCAST]], align 8
29+
// CHECK-NEXT: [[ARRAYIDX:%.*]] = getelementptr inbounds <2 x half>, ptr addrspace(1) [[TMP2]], i64 0
30+
// CHECK-NEXT: store <2 x half> [[TMP1]], ptr addrspace(1) [[ARRAYIDX]], align 4
31+
// CHECK-NEXT: ret void
32+
//
33+
void test_cvt_pk_f16_fp8(global half2* out, short a)
34+
{
35+
out[0] = __builtin_amdgcn_cvt_pk_f16_fp8(a);
36+
}
37+
38+
// CHECK-LABEL: @test_cvt_pk_f16_bf8(
39+
// CHECK-NEXT: entry:
40+
// CHECK-NEXT: [[OUT_ADDR:%.*]] = alloca ptr addrspace(1), align 8, addrspace(5)
41+
// CHECK-NEXT: [[A_ADDR:%.*]] = alloca i16, align 2, addrspace(5)
42+
// CHECK-NEXT: [[OUT_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[OUT_ADDR]] to ptr
43+
// CHECK-NEXT: [[A_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[A_ADDR]] to ptr
44+
// CHECK-NEXT: store ptr addrspace(1) [[OUT:%.*]], ptr [[OUT_ADDR_ASCAST]], align 8
45+
// CHECK-NEXT: store i16 [[A:%.*]], ptr [[A_ADDR_ASCAST]], align 2
46+
// CHECK-NEXT: [[TMP0:%.*]] = load i16, ptr [[A_ADDR_ASCAST]], align 2
47+
// CHECK-NEXT: [[TMP1:%.*]] = call <2 x half> @llvm.amdgcn.cvt.pk.f16.bf8(i16 [[TMP0]])
48+
// CHECK-NEXT: [[TMP2:%.*]] = load ptr addrspace(1), ptr [[OUT_ADDR_ASCAST]], align 8
49+
// CHECK-NEXT: [[ARRAYIDX:%.*]] = getelementptr inbounds <2 x half>, ptr addrspace(1) [[TMP2]], i64 0
50+
// CHECK-NEXT: store <2 x half> [[TMP1]], ptr addrspace(1) [[ARRAYIDX]], align 4
51+
// CHECK-NEXT: ret void
52+
//
53+
void test_cvt_pk_f16_bf8(global half2* out, short a)
54+
{
55+
out[0] = __builtin_amdgcn_cvt_pk_f16_bf8(a);
56+
}

‎libc/src/__support/wchar/CMakeLists.txt‎

Lines changed: 2 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -27,6 +27,7 @@ add_object_library(
2727
SRCS
2828
wcrtomb.cpp
2929
DEPENDS
30+
libc.hdr.errno_macros
3031
libc.hdr.types.char32_t
3132
libc.hdr.types.size_t
3233
libc.hdr.types.wchar_t
@@ -43,6 +44,7 @@ add_object_library(
4344
SRCS
4445
mbrtowc.cpp
4546
DEPENDS
47+
libc.hdr.errno_macros
4648
libc.hdr.types.wchar_t
4749
libc.hdr.types.size_t
4850
libc.src.__support.common

‎libc/src/__support/wchar/mbrtowc.cpp‎

Lines changed: 4 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -7,6 +7,7 @@
77
//===----------------------------------------------------------------------===//
88

99
#include "src/__support/wchar/mbrtowc.h"
10+
#include "hdr/errno_macros.h"
1011
#include "hdr/types/mbstate_t.h"
1112
#include "hdr/types/size_t.h"
1213
#include "hdr/types/wchar_t.h"
@@ -22,6 +23,8 @@ namespace internal {
2223
ErrorOr<size_t> mbrtowc(wchar_t *__restrict pwc, const char *__restrict s,
2324
size_t n, mbstate *__restrict ps) {
2425
CharacterConverter char_conv(ps);
26+
if (!char_conv.isValidState())
27+
return Error(EINVAL);
2528
if (s == nullptr)
2629
return 0;
2730
size_t i = 0;
@@ -30,7 +33,7 @@ ErrorOr<size_t> mbrtowc(wchar_t *__restrict pwc, const char *__restrict s,
3033
int err = char_conv.push(static_cast<char8_t>(s[i]));
3134
// Encoding error
3235
if (err == -1)
33-
return Error(-1);
36+
return Error(EILSEQ);
3437
}
3538
auto wc = char_conv.pop_utf32();
3639
if (wc.has_value()) {

‎libc/src/__support/wchar/wcrtomb.cpp‎

Lines changed: 6 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -11,6 +11,7 @@
1111
#include "src/__support/wchar/character_converter.h"
1212
#include "src/__support/wchar/mbstate.h"
1313

14+
#include "hdr/errno_macros.h"
1415
#include "hdr/types/char32_t.h"
1516
#include "hdr/types/size_t.h"
1617
#include "hdr/types/wchar_t.h"
@@ -26,12 +27,15 @@ ErrorOr<size_t> wcrtomb(char *__restrict s, wchar_t wc,
2627

2728
CharacterConverter cr(ps);
2829

30+
if (!cr.isValidState())
31+
return Error(EINVAL);
32+
2933
if (s == nullptr)
30-
return Error(-1);
34+
return Error(EILSEQ);
3135

3236
int status = cr.push(static_cast<char32_t>(wc));
3337
if (status != 0)
34-
return Error(status);
38+
return Error(EILSEQ);
3539

3640
size_t count = 0;
3741
while (!cr.isEmpty()) {

‎libc/src/wchar/mbrtowc.cpp‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -29,7 +29,7 @@ LLVM_LIBC_FUNCTION(size_t, mbrtowc,
2929
: reinterpret_cast<internal::mbstate *>(ps));
3030
if (!ret.has_value()) {
3131
// Encoding failure
32-
libc_errno = EILSEQ;
32+
libc_errno = ret.error();
3333
return -1;
3434
}
3535
return ret.value();

‎libc/src/wchar/wcrtomb.cpp‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -35,7 +35,7 @@ LLVM_LIBC_FUNCTION(size_t, wcrtomb,
3535
: reinterpret_cast<internal::mbstate *>(ps));
3636

3737
if (!result.has_value()) {
38-
libc_errno = EILSEQ;
38+
libc_errno = result.error();
3939
return -1;
4040
}
4141

‎libc/test/src/wchar/CMakeLists.txt‎

Lines changed: 4 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -31,10 +31,12 @@ add_libc_test(
3131
mbrtowc_test.cpp
3232
DEPENDS
3333
libc.src.__support.libc_errno
34+
libc.src.__support.wchar.mbstate
3435
libc.src.string.memset
3536
libc.src.wchar.mbrtowc
3637
libc.hdr.types.mbstate_t
3738
libc.hdr.types.wchar_t
39+
libc.test.UnitTest.ErrnoCheckingTest
3840
)
3941

4042
add_libc_test(
@@ -86,6 +88,8 @@ add_libc_test(
8688
libc.hdr.types.wchar_t
8789
libc.hdr.types.mbstate_t
8890
libc.src.__support.libc_errno
91+
libc.src.__support.wchar.mbstate
92+
libc.test.UnitTest.ErrnoCheckingTest
8993
)
9094

9195
add_libc_test(

‎libc/test/src/wchar/mbrtowc_test.cpp‎

Lines changed: 48 additions & 15 deletions
Original file line numberDiff line numberDiff line change
@@ -9,25 +9,31 @@
99
#include "hdr/types/mbstate_t.h"
1010
#include "hdr/types/wchar_t.h"
1111
#include "src/__support/libc_errno.h"
12+
#include "src/__support/wchar/mbstate.h"
1213
#include "src/string/memset.h"
1314
#include "src/wchar/mbrtowc.h"
15+
#include "test/UnitTest/ErrnoCheckingTest.h"
1416
#include "test/UnitTest/Test.h"
1517

16-
TEST(LlvmLibcMBRToWC, OneByte) {
18+
using LlvmLibcMBRToWCTest = LIBC_NAMESPACE::testing::ErrnoCheckingTest;
19+
20+
TEST_F(LlvmLibcMBRToWCTest, OneByte) {
1721
const char *ch = "A";
1822
wchar_t dest[2];
1923
// Testing if it works with nullptr mbstate_t
2024
mbstate_t *mb = nullptr;
2125
size_t n = LIBC_NAMESPACE::mbrtowc(dest, ch, 1, mb);
2226
ASSERT_EQ(static_cast<char>(*dest), 'A');
2327
ASSERT_EQ(static_cast<int>(n), 1);
28+
ASSERT_ERRNO_SUCCESS();
2429

2530
// Should fail since we have not read enough
2631
n = LIBC_NAMESPACE::mbrtowc(dest, ch, 0, mb);
2732
ASSERT_EQ(static_cast<int>(n), -2);
33+
ASSERT_ERRNO_SUCCESS();
2834
}
2935

30-
TEST(LlvmLibcMBRToWC, TwoByte) {
36+
TEST_F(LlvmLibcMBRToWCTest, TwoByte) {
3137
const char ch[2] = {static_cast<char>(0xC2),
3238
static_cast<char>(0x8E)}; // Ž car symbol
3339
wchar_t dest[2];
@@ -36,6 +42,7 @@ TEST(LlvmLibcMBRToWC, TwoByte) {
3642
size_t n = LIBC_NAMESPACE::mbrtowc(dest, ch, 2, mb);
3743
ASSERT_EQ(static_cast<int>(*dest), 142);
3844
ASSERT_EQ(static_cast<int>(n), 2);
45+
ASSERT_ERRNO_SUCCESS();
3946

4047
// Should fail since we have not read enough
4148
n = LIBC_NAMESPACE::mbrtowc(dest, ch, 1, mb);
@@ -44,9 +51,10 @@ TEST(LlvmLibcMBRToWC, TwoByte) {
4451
n = LIBC_NAMESPACE::mbrtowc(dest, ch + 1, 1, mb);
4552
ASSERT_EQ(static_cast<int>(n), 1);
4653
ASSERT_EQ(static_cast<int>(*dest), 142);
54+
ASSERT_ERRNO_SUCCESS();
4755
}
4856

49-
TEST(LlvmLibcMBRToWC, ThreeByte) {
57+
TEST_F(LlvmLibcMBRToWCTest, ThreeByte) {
5058
const char ch[3] = {static_cast<char>(0xE2), static_cast<char>(0x88),
5159
static_cast<char>(0x91)}; // ∑ sigma symbol
5260
wchar_t dest[2];
@@ -55,17 +63,20 @@ TEST(LlvmLibcMBRToWC, ThreeByte) {
5563
size_t n = LIBC_NAMESPACE::mbrtowc(dest, ch, 3, mb);
5664
ASSERT_EQ(static_cast<int>(*dest), 8721);
5765
ASSERT_EQ(static_cast<int>(n), 3);
66+
ASSERT_ERRNO_SUCCESS();
5867

5968
// Should fail since we have not read enough
6069
n = LIBC_NAMESPACE::mbrtowc(dest, ch, 1, mb);
6170
ASSERT_EQ(static_cast<int>(n), -2);
71+
ASSERT_ERRNO_SUCCESS();
6272
// Should pass after reading two more bytes
6373
n = LIBC_NAMESPACE::mbrtowc(dest, ch + 1, 2, mb);
6474
ASSERT_EQ(static_cast<int>(n), 2);
6575
ASSERT_EQ(static_cast<int>(*dest), 8721);
76+
ASSERT_ERRNO_SUCCESS();
6677
}
6778

68-
TEST(LlvmLibcMBRToWC, FourByte) {
79+
TEST_F(LlvmLibcMBRToWCTest, FourByte) {
6980
const char ch[4] = {static_cast<char>(0xF0), static_cast<char>(0x9F),
7081
static_cast<char>(0xA4),
7182
static_cast<char>(0xA1)}; // 🤡 clown emoji
@@ -75,27 +86,29 @@ TEST(LlvmLibcMBRToWC, FourByte) {
7586
size_t n = LIBC_NAMESPACE::mbrtowc(dest, ch, 4, mb);
7687
ASSERT_EQ(static_cast<int>(*dest), 129313);
7788
ASSERT_EQ(static_cast<int>(n), 4);
78-
89+
ASSERT_ERRNO_SUCCESS();
7990
// Should fail since we have not read enough
8091
n = LIBC_NAMESPACE::mbrtowc(dest, ch, 2, mb);
8192
ASSERT_EQ(static_cast<int>(n), -2);
93+
ASSERT_ERRNO_SUCCESS();
8294
// Should pass after reading two more bytes
8395
n = LIBC_NAMESPACE::mbrtowc(dest, ch + 2, 2, mb);
8496
ASSERT_EQ(static_cast<int>(n), 2);
8597
ASSERT_EQ(static_cast<int>(*dest), 129313);
98+
ASSERT_ERRNO_SUCCESS();
8699
}
87100

88-
TEST(LlvmLibcMBRToWC, InvalidByte) {
101+
TEST_F(LlvmLibcMBRToWCTest, InvalidByte) {
89102
const char ch[1] = {static_cast<char>(0x80)};
90103
wchar_t dest[2];
91104
mbstate_t *mb;
92105
LIBC_NAMESPACE::memset(&mb, 0, sizeof(mbstate_t));
93106
size_t n = LIBC_NAMESPACE::mbrtowc(dest, ch, 1, mb);
94107
ASSERT_EQ(static_cast<int>(n), -1);
95-
ASSERT_EQ(static_cast<int>(libc_errno), EILSEQ);
108+
ASSERT_ERRNO_EQ(EILSEQ);
96109
}
97110

98-
TEST(LlvmLibcMBRToWC, InvalidMultiByte) {
111+
TEST_F(LlvmLibcMBRToWCTest, InvalidMultiByte) {
99112
const char ch[4] = {static_cast<char>(0x80), static_cast<char>(0x00),
100113
static_cast<char>(0x80),
101114
static_cast<char>(0x00)}; // invalid sequence of bytes
@@ -105,18 +118,19 @@ TEST(LlvmLibcMBRToWC, InvalidMultiByte) {
105118
// Trying to push all 4 should error
106119
size_t n = LIBC_NAMESPACE::mbrtowc(dest, ch, 4, mb);
107120
ASSERT_EQ(static_cast<int>(n), -1);
108-
ASSERT_EQ(static_cast<int>(libc_errno), EILSEQ);
121+
ASSERT_ERRNO_EQ(EILSEQ);
109122
// Trying to push just the first one should error
110123
n = LIBC_NAMESPACE::mbrtowc(dest, ch, 1, mb);
111124
ASSERT_EQ(static_cast<int>(n), -1);
112-
ASSERT_EQ(static_cast<int>(libc_errno), EILSEQ);
125+
ASSERT_ERRNO_EQ(EILSEQ);
113126
// Trying to push the second and third should correspond to null wc
114127
n = LIBC_NAMESPACE::mbrtowc(dest, ch + 1, 2, mb);
115128
ASSERT_EQ(static_cast<int>(n), 0);
116129
ASSERT_TRUE(*dest == L'\0');
130+
ASSERT_ERRNO_SUCCESS();
117131
}
118132

119-
TEST(LlvmLibcMBRToWC, InvalidLastByte) {
133+
TEST_F(LlvmLibcMBRToWCTest, InvalidLastByte) {
120134
// Last byte is invalid since it does not have correct starting sequence.
121135
// 0xC0 --> 11000000 starting sequence should be 10xxxxxx
122136
const char ch[4] = {static_cast<char>(0xF1), static_cast<char>(0x80),
@@ -127,10 +141,10 @@ TEST(LlvmLibcMBRToWC, InvalidLastByte) {
127141
// Trying to push all 4 should error
128142
size_t n = LIBC_NAMESPACE::mbrtowc(dest, ch, 4, mb);
129143
ASSERT_EQ(static_cast<int>(n), -1);
130-
ASSERT_EQ(static_cast<int>(libc_errno), EILSEQ);
144+
ASSERT_ERRNO_EQ(EILSEQ);
131145
}
132146

133-
TEST(LlvmLibcMBRToWC, ValidTwoByteWithExtraRead) {
147+
TEST_F(LlvmLibcMBRToWCTest, ValidTwoByteWithExtraRead) {
134148
const char ch[3] = {static_cast<char>(0xC2), static_cast<char>(0x8E),
135149
static_cast<char>(0x80)};
136150
wchar_t dest[2];
@@ -140,9 +154,10 @@ TEST(LlvmLibcMBRToWC, ValidTwoByteWithExtraRead) {
140154
size_t n = LIBC_NAMESPACE::mbrtowc(dest, ch, 3, mb);
141155
ASSERT_EQ(static_cast<int>(n), 2);
142156
ASSERT_EQ(static_cast<int>(*dest), 142);
157+
ASSERT_ERRNO_SUCCESS();
143158
}
144159

145-
TEST(LlvmLibcMBRToWC, TwoValidTwoBytes) {
160+
TEST_F(LlvmLibcMBRToWCTest, TwoValidTwoBytes) {
146161
const char ch[4] = {static_cast<char>(0xC2), static_cast<char>(0x8E),
147162
static_cast<char>(0xC7), static_cast<char>(0x8C)};
148163
wchar_t dest[2];
@@ -152,21 +167,39 @@ TEST(LlvmLibcMBRToWC, TwoValidTwoBytes) {
152167
size_t n = LIBC_NAMESPACE::mbrtowc(dest, ch, 2, mb);
153168
ASSERT_EQ(static_cast<int>(n), 2);
154169
ASSERT_EQ(static_cast<int>(*dest), 142);
170+
ASSERT_ERRNO_SUCCESS();
155171
n = LIBC_NAMESPACE::mbrtowc(dest + 1, ch + 2, 2, mb);
156172
ASSERT_EQ(static_cast<int>(n), 2);
157173
ASSERT_EQ(static_cast<int>(*(dest + 1)), 460);
174+
ASSERT_ERRNO_SUCCESS();
158175
}
159176

160-
TEST(LlvmLibcMBRToWC, NullString) {
177+
TEST_F(LlvmLibcMBRToWCTest, NullString) {
161178
wchar_t dest[2] = {L'O', L'K'};
162179
mbstate_t *mb;
163180
LIBC_NAMESPACE::memset(&mb, 0, sizeof(mbstate_t));
164181
// reading on nullptr should return 0
165182
size_t n = LIBC_NAMESPACE::mbrtowc(dest, nullptr, 2, mb);
166183
ASSERT_EQ(static_cast<int>(n), 0);
167184
ASSERT_TRUE(dest[0] == L'O');
185+
ASSERT_ERRNO_SUCCESS();
168186
// reading a null terminator should return 0
169187
const char *ch = "\0";
170188
n = LIBC_NAMESPACE::mbrtowc(dest, ch, 1, mb);
171189
ASSERT_EQ(static_cast<int>(n), 0);
190+
ASSERT_ERRNO_SUCCESS();
191+
}
192+
193+
TEST_F(LlvmLibcMBRToWCTest, InvalidMBState) {
194+
const char ch[4] = {static_cast<char>(0xC2), static_cast<char>(0x8E),
195+
static_cast<char>(0xC7), static_cast<char>(0x8C)};
196+
wchar_t dest[2] = {L'O', L'K'};
197+
mbstate_t *mb;
198+
LIBC_NAMESPACE::internal::mbstate inv;
199+
inv.total_bytes = 6;
200+
mb = reinterpret_cast<mbstate_t *>(&inv);
201+
// invalid mbstate should error
202+
size_t n = LIBC_NAMESPACE::mbrtowc(dest, ch, 2, mb);
203+
ASSERT_EQ(static_cast<int>(n), -1);
204+
ASSERT_ERRNO_EQ(EINVAL);
172205
}

0 commit comments

Comments
 (0)