Skip to content

Commit 7e050d1

Browse files
compnerdcompnerd
committed
stdlib: remove usage of GNU extensions in the Darwin os module
Remove the gratuitous use of the GNU extensions to implement the OS logging module. This allows us to enable `-Werror=gnu` globally, even on macOS builds.
1 parent 5f3b1da commit 7e050d1

File tree

3 files changed

+171
-137
lines changed

3 files changed

+171
-137
lines changed

‎CMakeLists.txt

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -455,7 +455,7 @@ if(MSVC OR "${CMAKE_SIMULATE_ID}" STREQUAL MSVC)
455455
include(ClangClCompileRules)
456456
endif()
457457

458-
if(CMAKE_C_COMPILER_ID STREQUAL Clang)
458+
if(CMAKE_C_COMPILER_ID MATCHES Clang)
459459
add_compile_options($<$<OR:$<COMPILE_LANGUAGE:C>,$<COMPILE_LANGUAGE:CXX>>:-Werror=gnu>)
460460
endif()
461461

‎stdlib/public/Darwin/os/format.m

Lines changed: 169 additions & 135 deletions
Original file line numberDiff line numberDiff line change
@@ -10,6 +10,7 @@
1010
//
1111
//===----------------------------------------------------------------------===//
1212

13+
#include <sys/param.h>
1314
#include <Foundation/Foundation.h>
1415
#include "format.h"
1516

@@ -24,15 +25,15 @@
2425
_os_log_encode(char buf[OS_LOG_FMT_BUF_SIZE], const char *format, va_list args,
2526
int saved_errno, os_trace_blob_t ob)
2627
{
27-
os_log_fmt_hdr_s hdr = { };
28+
os_log_fmt_hdr_s hdr = {0};
2829
os_trace_blob_add(ob, &hdr, sizeof(hdr));
2930

3031
const char *percent = strchr(format, '%');
3132

3233
while (percent != NULL) {
3334
++percent;
3435
if (percent[0] != '%') {
35-
os_log_fmt_cmd_s cmd = { };
36+
os_log_fmt_cmd_s cmd = {0};
3637
os_log_count_type_t widtht = T_C_NONE;
3738
os_log_count_type_t prect = T_C_NONE;
3839
os_log_fmt_cmd_flags_t flags = 0;
@@ -99,159 +100,192 @@
99100
}
100101
break;
101102

102-
#define encode_width() ({ \
103-
if (widtht == T_C_DYNAMIC) { \
104-
cmd.cmd_type = OSLF_CMD_TYPE_SCALAR; \
105-
encode(int, 0); \
106-
}})
103+
#define encode_width() \
104+
do { \
105+
if (widtht == T_C_DYNAMIC) { \
106+
cmd.cmd_type = OSLF_CMD_TYPE_SCALAR; \
107+
encode(int, 0); \
108+
} \
109+
} while (0)
107110

108111
// clang inconsistency: static precision counts are still marked with the
109112
// privacy bits of the command they preceed
110-
#define encode_precision(type) ({ \
111-
if (prect != T_C_NONE) { \
112-
cmd.cmd_type = type; \
113-
cmd.cmd_size = sizeof(int); \
114-
if (prect == T_C_STATIC && type == OSLF_CMD_TYPE_COUNT) { \
115-
cmd.cmd_flags = flags; \
116-
} else if (prect == T_C_DYNAMIC) { \
117-
precision = va_arg(args, int); \
118-
} \
119-
_os_log_encode_arg(ob, &cmd, &precision); \
120-
hdr.hdr_cmd_cnt++; \
121-
prect = T_C_NONE; \
122-
}})
113+
#define encode_precision(type) \
114+
do { \
115+
if (prect != T_C_NONE) { \
116+
cmd.cmd_type = type; \
117+
cmd.cmd_size = sizeof(int); \
118+
if (prect == T_C_STATIC && type == OSLF_CMD_TYPE_COUNT) { \
119+
cmd.cmd_flags = flags; \
120+
} else if (prect == T_C_DYNAMIC) { \
121+
precision = va_arg(args, int); \
122+
} \
123+
_os_log_encode_arg(ob, &cmd, &precision); \
124+
hdr.hdr_cmd_cnt++; \
125+
prect = T_C_NONE; \
126+
} \
127+
} while (0)
123128

124129
// scalar data types encode their precision as a scalar
125-
#define encode_scalar_preamble() ({ \
126-
encode_width(); \
127-
if (prect == T_C_DYNAMIC) { \
128-
encode_precision(OSLF_CMD_TYPE_SCALAR); \
129-
}})
130+
#define encode_scalar_preamble() \
131+
do { \
132+
encode_width(); \
133+
if (prect == T_C_DYNAMIC) { \
134+
encode_precision(OSLF_CMD_TYPE_SCALAR); \
135+
} \
136+
} while (0)
130137

131-
#define encode_pointer_preamble() ({ \
132-
encode_width(); \
133-
encode_precision(OSLF_CMD_TYPE_COUNT); \
134-
})
138+
#define encode_pointer_preamble() \
139+
do { \
140+
encode_width(); \
141+
encode_precision(OSLF_CMD_TYPE_COUNT); \
142+
} while (0)
135143

136-
#define encode_nsstring(flags) ({ \
137-
NSString *__arg = va_arg(args, NSString *); \
138-
const char * _Nullable __var = __arg.UTF8String; \
139-
cmd.cmd_flags = flags; \
140-
cmd.cmd_size = sizeof(__var); \
141-
_os_log_encode_arg(ob, &cmd, &__var); \
142-
hdr.hdr_cmd_cnt++; \
143-
})
144+
#define encode_nsstring(flags) \
145+
do { \
146+
NSString *__arg = va_arg(args, NSString *); \
147+
const char *_Nullable __var = __arg.UTF8String; \
148+
cmd.cmd_flags = flags; \
149+
cmd.cmd_size = sizeof(__var); \
150+
_os_log_encode_arg(ob, &cmd, &__var); \
151+
hdr.hdr_cmd_cnt++; \
152+
} while (0)
144153

145-
#define encode_smallint(ty, flags) ({ \
146-
int __var = va_arg(args, int); \
147-
cmd.cmd_flags = flags; \
148-
cmd.cmd_size = sizeof(__var); \
149-
_os_log_encode_arg(ob, &cmd, &__var); \
150-
hdr.hdr_cmd_cnt++; \
151-
})
154+
#define encode_smallint(ty, flags) \
155+
do { \
156+
int __var = va_arg(args, int); \
157+
cmd.cmd_flags = flags; \
158+
cmd.cmd_size = sizeof(__var); \
159+
_os_log_encode_arg(ob, &cmd, &__var); \
160+
hdr.hdr_cmd_cnt++; \
161+
} while (0)
152162

153-
#define encode(ty, flags) ({ \
154-
ty __var = va_arg(args, ty); \
155-
cmd.cmd_flags = flags; \
156-
cmd.cmd_size = sizeof(__var); \
157-
_os_log_encode_arg(ob, &cmd, &__var); \
158-
hdr.hdr_cmd_cnt++; \
159-
})
163+
#define encode(ty, flags) \
164+
do { \
165+
ty __var = va_arg(args, ty); \
166+
cmd.cmd_flags = flags; \
167+
cmd.cmd_size = sizeof(__var); \
168+
_os_log_encode_arg(ob, &cmd, &__var); \
169+
hdr.hdr_cmd_cnt++; \
170+
} while (0)
160171

161-
/* fixed types */
162-
case 'c': // char
163-
case 'd': // integer
164-
case 'i': // integer
165-
case 'o': // octal
166-
case 'u': // unsigned
167-
case 'x': // hex
168-
case 'X': // upper-hex
169-
encode_scalar_preamble();
170-
cmd.cmd_type = OSLF_CMD_TYPE_SCALAR;
171-
switch (type) {
172-
case T_CHAR: encode_smallint(char, flags); break;
173-
case T_SHORT: encode_smallint(short, flags); break;
174-
case T_INT: encode(int, flags); break;
175-
case T_LONG: encode(long, flags); break;
176-
case T_LONGLONG: encode(long long, flags); break;
177-
case T_SIZE: encode(size_t, flags); break;
178-
case T_INTMAX: encode(intmax_t, flags); break;
179-
case T_PTRDIFF: encode(ptrdiff_t, flags); break;
180-
default: return false;
181-
}
182-
done = true;
172+
/* fixed types */
173+
case 'c': // char
174+
case 'd': // integer
175+
case 'i': // integer
176+
case 'o': // octal
177+
case 'u': // unsigned
178+
case 'x': // hex
179+
case 'X': // upper-hex
180+
encode_scalar_preamble();
181+
cmd.cmd_type = OSLF_CMD_TYPE_SCALAR;
182+
switch (type) {
183+
case T_CHAR:
184+
encode_smallint(char, flags);
183185
break;
184-
185-
case 'p': // emit pointers as scalars
186-
cmd.cmd_type = OSLF_CMD_TYPE_SCALAR;
187-
encode(void *, flags);
188-
done = true;
186+
case T_SHORT:
187+
encode_smallint(short, flags);
189188
break;
190-
191-
case 'C': // wchar is treated like %lc
192-
encode_scalar_preamble();
193-
cmd.cmd_type = OSLF_CMD_TYPE_SCALAR;
194-
encode_smallint(wint_t, flags);
195-
done = true;
189+
case T_INT:
190+
encode(int, flags);
196191
break;
197-
198-
case 'P': // pointer data
199-
encode_pointer_preamble();
200-
hdr.hdr_flags |= OSLF_HDR_FLAG_HAS_NON_SCALAR;
201-
cmd.cmd_type = OSLF_CMD_TYPE_DATA;
202-
cmd.cmd_size = sizeof(void *);
203-
encode(void *, flags);
204-
done = true;
192+
case T_LONG:
193+
encode(long, flags);
205194
break;
206-
207-
case 'L': // long double
208-
long_double = true;
195+
case T_LONGLONG:
196+
encode(long long, flags);
209197
break;
210-
211-
case 'a': case 'A': case 'e': case 'E': // floating types
212-
case 'f': case 'F': case 'g': case 'G':
213-
encode_scalar_preamble();
214-
cmd.cmd_type = OSLF_CMD_TYPE_SCALAR;
215-
if (long_double) {
216-
encode(long double, flags);
217-
} else {
218-
encode(double, flags);
219-
}
220-
done = true;
198+
case T_SIZE:
199+
encode(size_t, flags);
221200
break;
222-
223-
case 's': // Strings sent from Swift as NSString objects
224-
encode_pointer_preamble();
225-
hdr.hdr_flags |= OSLF_HDR_FLAG_HAS_NON_SCALAR;
226-
cmd.cmd_type = OSLF_CMD_TYPE_STRING;
227-
encode_nsstring(flags);
228-
done = true;
201+
case T_INTMAX:
202+
encode(intmax_t, flags);
229203
break;
230-
231-
case '@': // CFTypeRef aka NSObject *
232-
// %@ does not support precision
233-
encode_width();
234-
hdr.hdr_flags |= OSLF_HDR_FLAG_HAS_NON_SCALAR;
235-
cmd.cmd_type = OSLF_CMD_TYPE_OBJECT;
236-
encode(void *, flags);
237-
done = true;
204+
case T_PTRDIFF:
205+
encode(ptrdiff_t, flags);
238206
break;
207+
default:
208+
return false;
209+
}
210+
done = true;
211+
break;
239212

240-
case 'm':
241-
cmd.cmd_type = OSLF_CMD_TYPE_SCALAR;
242-
cmd.cmd_size = sizeof(int);
243-
cmd.cmd_flags = flags;
244-
_os_log_encode_arg(ob, &cmd, &saved_errno);
245-
hdr.hdr_cmd_cnt++;
246-
done = true;
247-
break;
213+
case 'p': // emit pointers as scalars
214+
cmd.cmd_type = OSLF_CMD_TYPE_SCALAR;
215+
encode(void *, flags);
216+
done = true;
217+
break;
248218

249-
default:
250-
if (isdigit(ch)) { // [0-9]
251-
continue;
252-
}
253-
done = true;
254-
break;
219+
case 'C': // wchar is treated like %lc
220+
encode_scalar_preamble();
221+
cmd.cmd_type = OSLF_CMD_TYPE_SCALAR;
222+
encode_smallint(wint_t, flags);
223+
done = true;
224+
break;
225+
226+
case 'P': // pointer data
227+
encode_pointer_preamble();
228+
hdr.hdr_flags |= OSLF_HDR_FLAG_HAS_NON_SCALAR;
229+
cmd.cmd_type = OSLF_CMD_TYPE_DATA;
230+
cmd.cmd_size = sizeof(void *);
231+
encode(void *, flags);
232+
done = true;
233+
break;
234+
235+
case 'L': // long double
236+
long_double = true;
237+
break;
238+
239+
case 'a':
240+
case 'A':
241+
case 'e':
242+
case 'E': // floating types
243+
case 'f':
244+
case 'F':
245+
case 'g':
246+
case 'G':
247+
encode_scalar_preamble();
248+
cmd.cmd_type = OSLF_CMD_TYPE_SCALAR;
249+
if (long_double) {
250+
encode(long double, flags);
251+
} else {
252+
encode(double, flags);
253+
}
254+
done = true;
255+
break;
256+
257+
case 's': // Strings sent from Swift as NSString objects
258+
encode_pointer_preamble();
259+
hdr.hdr_flags |= OSLF_HDR_FLAG_HAS_NON_SCALAR;
260+
cmd.cmd_type = OSLF_CMD_TYPE_STRING;
261+
encode_nsstring(flags);
262+
done = true;
263+
break;
264+
265+
case '@': // CFTypeRef aka NSObject *
266+
// %@ does not support precision
267+
encode_width();
268+
hdr.hdr_flags |= OSLF_HDR_FLAG_HAS_NON_SCALAR;
269+
cmd.cmd_type = OSLF_CMD_TYPE_OBJECT;
270+
encode(void *, flags);
271+
done = true;
272+
break;
273+
274+
case 'm':
275+
cmd.cmd_type = OSLF_CMD_TYPE_SCALAR;
276+
cmd.cmd_size = sizeof(int);
277+
cmd.cmd_flags = flags;
278+
_os_log_encode_arg(ob, &cmd, &saved_errno);
279+
hdr.hdr_cmd_cnt++;
280+
done = true;
281+
break;
282+
283+
default:
284+
if (isdigit(ch)) { // [0-9]
285+
continue;
286+
}
287+
done = true;
288+
break;
255289
}
256290

257291
if (done) {

‎stdlib/public/Darwin/os/os.m

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -33,7 +33,7 @@
3333
const void *olp_mh;
3434
const void *olp_pc;
3535
const char *olp_format;
36-
uint8_t olp_data[0];
36+
uint8_t olp_data[];
3737
} os_log_pack_s, *os_log_pack_t;
3838

3939
API_AVAILABLE(macosx(10.12.4), ios(10.3), tvos(10.2), watchos(3.2))

0 commit comments

Comments
 (0)