1//== PrintfFormatString.cpp - Analysis of printf format strings --*- C++ -*-==//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9// Handling of format string in printf and friends. The structure of format
10// strings for fprintf() are described in C99 7.19.6.1.
11//
12//===----------------------------------------------------------------------===//
13
14#include "FormatStringParsing.h"
15#include "clang/AST/FormatString.h"
16#include "clang/AST/OSLog.h"
17#include "clang/Basic/TargetInfo.h"
18#include "llvm/Support/Regex.h"
19
20using clang::analyze_format_string::ArgType;
21using clang::analyze_format_string::ConversionSpecifier;
22using clang::analyze_format_string::FormatStringHandler;
23using clang::analyze_format_string::LengthModifier;
24using clang::analyze_format_string::OptionalAmount;
25using clang::analyze_printf::PrintfSpecifier;
26
27using namespace clang;
28
29typedef clang::analyze_format_string::SpecifierResult<PrintfSpecifier>
30 PrintfSpecifierResult;
31
32namespace {
33
34class PrintfFormatStringParser : analyze_format_string::FormatStringParser {
35public:
36 PrintfFormatStringParser(FormatStringHandler &H, const LangOptions &LO,
37 const TargetInfo &Target, bool Warn,
38 bool IsFreeBSDKPrintf)
39 : FormatStringParser(H, LO, Target, /*IsScanf=*/false), Warn(Warn),
40 IsFreeBSDKPrintf(IsFreeBSDKPrintf) {}
41
42 PrintfSpecifierResult parseSpecifier(const char *&Beg, const char *E,
43 unsigned &argIndex) const;
44
45private:
46 bool parsePrecision(PrintfSpecifier &FS, const char *Start, const char *&Beg,
47 const char *E, unsigned *argIndex) const;
48
49 bool parseObjCFlags(PrintfSpecifier &FS, const char *FlagBeg,
50 const char *E) const;
51
52 bool Warn;
53 bool IsFreeBSDKPrintf;
54};
55
56} // namespace
57
58bool PrintfFormatStringParser::parsePrecision(PrintfSpecifier &FS,
59 const char *Start,
60 const char *&Beg, const char *E,
61 unsigned *argIndex) const {
62 if (argIndex) {
63 FS.setPrecision(parseNonPositionAmount(Beg, E, argIndex&: *argIndex));
64 } else {
65 const OptionalAmount Amt =
66 parsePositionAmount(Start, Beg, E, p: analyze_format_string::PrecisionPos);
67 if (Amt.isInvalid())
68 return true;
69 FS.setPrecision(Amt);
70 }
71 return false;
72}
73
74bool PrintfFormatStringParser::parseObjCFlags(PrintfSpecifier &FS,
75 const char *FlagBeg,
76 const char *E) const {
77 StringRef Flag(FlagBeg, E - FlagBeg);
78 // Currently there is only one flag.
79 if (Flag == "tt") {
80 FS.setHasObjCTechnicalTerm(FlagBeg);
81 return false;
82 }
83 // Handle either the case of no flag or an invalid flag.
84 if (Warn) {
85 if (Flag == "")
86 H.HandleEmptyObjCModifierFlag(startFlags: FlagBeg, flagsLen: E - FlagBeg);
87 else
88 H.HandleInvalidObjCModifierFlag(startFlag: FlagBeg, flagLen: E - FlagBeg);
89 }
90 return true;
91}
92
93PrintfSpecifierResult
94PrintfFormatStringParser::parseSpecifier(const char *&Beg, const char *E,
95 unsigned &argIndex) const {
96 using namespace clang::analyze_format_string;
97 using namespace clang::analyze_printf;
98
99 const char *I = Beg;
100 const char *Start = nullptr;
101 UpdateOnReturn<const char *> UpdateBeg(Beg, I);
102
103 // Look for a '%' character that indicates the start of a format specifier.
104 for (; I != E; ++I) {
105 char c = *I;
106 if (c == '\0') {
107 // Detect spurious null characters, which are likely errors.
108 H.HandleNullChar(nullCharacter: I);
109 return true;
110 }
111 if (c == '%') {
112 Start = I++; // Record the start of the format specifier.
113 break;
114 }
115 }
116
117 // No format specifier found?
118 if (!Start)
119 return false;
120
121 if (I == E) {
122 // No more characters left?
123 if (Warn)
124 H.HandleIncompleteSpecifier(startSpecifier: Start, specifierLen: E - Start);
125 return true;
126 }
127
128 PrintfSpecifier FS;
129 if (parseArgPosition(CS&: FS, Start, Beg&: I, E))
130 return true;
131
132 if (I == E) {
133 // No more characters left?
134 if (Warn)
135 H.HandleIncompleteSpecifier(startSpecifier: Start, specifierLen: E - Start);
136 return true;
137 }
138
139 if (*I == '{') {
140 ++I;
141 unsigned char PrivacyFlags = 0;
142 StringRef MatchedStr;
143
144 do {
145 StringRef Str(I, E - I);
146 std::string Match = "^[[:space:]]*"
147 "(private|public|sensitive|mask\\.[^[:space:],}]*)"
148 "[[:space:]]*(,|})";
149 llvm::Regex R(Match);
150 SmallVector<StringRef, 2> Matches;
151
152 if (R.match(String: Str, Matches: &Matches)) {
153 MatchedStr = Matches[1];
154 I += Matches[0].size();
155
156 // Set the privacy flag if the privacy annotation in the
157 // comma-delimited segment is at least as strict as the privacy
158 // annotations in previous comma-delimited segments.
159 if (MatchedStr.starts_with(Prefix: "mask")) {
160 StringRef MaskType = MatchedStr.substr(Start: sizeof("mask.") - 1);
161 unsigned Size = MaskType.size();
162 if (Warn && (Size == 0 || Size > 8))
163 H.handleInvalidMaskType(MaskType);
164 FS.setMaskType(MaskType);
165 } else if (MatchedStr == "sensitive")
166 PrivacyFlags = clang::analyze_os_log::OSLogBufferItem::IsSensitive;
167 else if (PrivacyFlags !=
168 clang::analyze_os_log::OSLogBufferItem::IsSensitive &&
169 MatchedStr == "private")
170 PrivacyFlags = clang::analyze_os_log::OSLogBufferItem::IsPrivate;
171 else if (PrivacyFlags == 0 && MatchedStr == "public")
172 PrivacyFlags = clang::analyze_os_log::OSLogBufferItem::IsPublic;
173 } else {
174 size_t CommaOrBracePos =
175 Str.find_if(F: [](char c) { return c == ',' || c == '}'; });
176
177 if (CommaOrBracePos == StringRef::npos) {
178 // Neither a comma nor the closing brace was found.
179 if (Warn)
180 H.HandleIncompleteSpecifier(startSpecifier: Start, specifierLen: E - Start);
181 return true;
182 }
183
184 I += CommaOrBracePos + 1;
185 }
186 // Continue until the closing brace is found.
187 } while (*(I - 1) == ',');
188
189 // Set the privacy flag.
190 switch (PrivacyFlags) {
191 case 0:
192 break;
193 case clang::analyze_os_log::OSLogBufferItem::IsPrivate:
194 FS.setIsPrivate(MatchedStr.data());
195 break;
196 case clang::analyze_os_log::OSLogBufferItem::IsPublic:
197 FS.setIsPublic(MatchedStr.data());
198 break;
199 case clang::analyze_os_log::OSLogBufferItem::IsSensitive:
200 FS.setIsSensitive(MatchedStr.data());
201 break;
202 default:
203 llvm_unreachable("Unexpected privacy flag value");
204 }
205 }
206
207 // Look for flags (if any).
208 bool hasMore = true;
209 for (; I != E; ++I) {
210 switch (*I) {
211 default:
212 hasMore = false;
213 break;
214 case '\'':
215 // FIXME: POSIX specific. Always accept?
216 FS.setHasThousandsGrouping(I);
217 break;
218 case '-':
219 FS.setIsLeftJustified(I);
220 break;
221 case '+':
222 FS.setHasPlusPrefix(I);
223 break;
224 case ' ':
225 FS.setHasSpacePrefix(I);
226 break;
227 case '#':
228 FS.setHasAlternativeForm(I);
229 break;
230 case '0':
231 FS.setHasLeadingZeros(I);
232 break;
233 }
234 if (!hasMore)
235 break;
236 }
237
238 if (I == E) {
239 // No more characters left?
240 if (Warn)
241 H.HandleIncompleteSpecifier(startSpecifier: Start, specifierLen: E - Start);
242 return true;
243 }
244
245 // Look for the field width (if any).
246 if (parseFieldWidth(CS&: FS, Start, Beg&: I, E,
247 argIndex: FS.usesPositionalArg() ? nullptr : &argIndex))
248 return true;
249
250 if (I == E) {
251 // No more characters left?
252 if (Warn)
253 H.HandleIncompleteSpecifier(startSpecifier: Start, specifierLen: E - Start);
254 return true;
255 }
256
257 // Look for the precision (if any).
258 if (*I == '.') {
259 ++I;
260 if (I == E) {
261 if (Warn)
262 H.HandleIncompleteSpecifier(startSpecifier: Start, specifierLen: E - Start);
263 return true;
264 }
265
266 if (parsePrecision(FS, Start, Beg&: I, E,
267 argIndex: FS.usesPositionalArg() ? nullptr : &argIndex))
268 return true;
269
270 if (I == E) {
271 // No more characters left?
272 if (Warn)
273 H.HandleIncompleteSpecifier(startSpecifier: Start, specifierLen: E - Start);
274 return true;
275 }
276 }
277
278 if (parseVectorModifier(FS, Beg&: I, E))
279 return true;
280
281 // Look for the length modifier.
282 if (parseLengthModifier(FS, Beg&: I, E) && I == E) {
283 // No more characters left?
284 if (Warn)
285 H.HandleIncompleteSpecifier(startSpecifier: Start, specifierLen: E - Start);
286 return true;
287 }
288
289 // Look for the Objective-C modifier flags, if any.
290 // We parse these here, even if they don't apply to
291 // the conversion specifier, and then emit an error
292 // later if the conversion specifier isn't '@'. This
293 // enables better recovery, and we don't know if
294 // these flags are applicable until later.
295 const char *ObjCModifierFlagsStart = nullptr, *ObjCModifierFlagsEnd = nullptr;
296 if (*I == '[') {
297 ObjCModifierFlagsStart = I;
298 ++I;
299 auto flagStart = I;
300 for (;; ++I) {
301 ObjCModifierFlagsEnd = I;
302 if (I == E) {
303 if (Warn)
304 H.HandleIncompleteSpecifier(startSpecifier: Start, specifierLen: E - Start);
305 return true;
306 }
307 // Did we find the closing ']'?
308 if (*I == ']') {
309 if (parseObjCFlags(FS, FlagBeg: flagStart, E: I))
310 return true;
311 ++I;
312 break;
313 }
314 // There are no separators defined yet for multiple
315 // Objective-C modifier flags. When those are
316 // defined, this is the place to check.
317 }
318 }
319
320 if (*I == '\0') {
321 // Detect spurious null characters, which are likely errors.
322 H.HandleNullChar(nullCharacter: I);
323 return true;
324 }
325
326 // Finally, look for the conversion specifier.
327 const char *conversionPosition = I++;
328 ConversionSpecifier::Kind k = ConversionSpecifier::InvalidSpecifier;
329 switch (*conversionPosition) {
330 default:
331 break;
332 // C99: 7.19.6.1 (section 8).
333 case '%':
334 k = ConversionSpecifier::PercentArg;
335 break;
336 case 'A':
337 k = ConversionSpecifier::AArg;
338 break;
339 case 'E':
340 k = ConversionSpecifier::EArg;
341 break;
342 case 'F':
343 k = ConversionSpecifier::FArg;
344 break;
345 case 'G':
346 k = ConversionSpecifier::GArg;
347 break;
348 case 'X':
349 k = ConversionSpecifier::XArg;
350 break;
351 case 'a':
352 k = ConversionSpecifier::aArg;
353 break;
354 case 'c':
355 k = ConversionSpecifier::cArg;
356 break;
357 case 'd':
358 k = ConversionSpecifier::dArg;
359 break;
360 case 'e':
361 k = ConversionSpecifier::eArg;
362 break;
363 case 'f':
364 k = ConversionSpecifier::fArg;
365 break;
366 case 'g':
367 k = ConversionSpecifier::gArg;
368 break;
369 case 'i':
370 k = ConversionSpecifier::iArg;
371 break;
372 case 'n':
373 // Not handled, but reserved in OpenCL.
374 if (!LO.OpenCL)
375 k = ConversionSpecifier::nArg;
376 break;
377 case 'o':
378 k = ConversionSpecifier::oArg;
379 break;
380 case 'p':
381 k = ConversionSpecifier::pArg;
382 break;
383 case 's':
384 k = ConversionSpecifier::sArg;
385 break;
386 case 'u':
387 k = ConversionSpecifier::uArg;
388 break;
389 case 'x':
390 k = ConversionSpecifier::xArg;
391 break;
392 // C23.
393 case 'b':
394 if (IsFreeBSDKPrintf)
395 k = ConversionSpecifier::FreeBSDbArg; // int followed by char *
396 else
397 k = ConversionSpecifier::bArg;
398 break;
399 case 'B':
400 k = ConversionSpecifier::BArg;
401 break;
402 // POSIX specific.
403 case 'C':
404 k = ConversionSpecifier::CArg;
405 break;
406 case 'S':
407 k = ConversionSpecifier::SArg;
408 break;
409 // Apple extension for os_log
410 case 'P':
411 k = ConversionSpecifier::PArg;
412 break;
413 // Objective-C.
414 case '@':
415 k = ConversionSpecifier::ObjCObjArg;
416 break;
417 // Glibc specific.
418 case 'm':
419 k = ConversionSpecifier::PrintErrno;
420 break;
421 case 'r':
422 if (IsFreeBSDKPrintf)
423 k = ConversionSpecifier::FreeBSDrArg; // int
424 else if (LO.FixedPoint)
425 k = ConversionSpecifier::rArg;
426 break;
427 case 'y':
428 if (IsFreeBSDKPrintf)
429 k = ConversionSpecifier::FreeBSDyArg; // int
430 break;
431 // Apple-specific.
432 case 'D':
433 if (IsFreeBSDKPrintf)
434 k = ConversionSpecifier::FreeBSDDArg; // void * followed by char *
435 else if (Target.getTriple().isOSDarwin())
436 k = ConversionSpecifier::DArg;
437 break;
438 case 'O':
439 if (Target.getTriple().isOSDarwin())
440 k = ConversionSpecifier::OArg;
441 break;
442 case 'U':
443 if (Target.getTriple().isOSDarwin())
444 k = ConversionSpecifier::UArg;
445 break;
446 // MS specific.
447 case 'Z':
448 if (Target.getTriple().isOSMSVCRT())
449 k = ConversionSpecifier::ZArg;
450 break;
451 // ISO/IEC TR 18037 (fixed-point) specific.
452 // NOTE: 'r' is handled up above since FreeBSD also supports %r.
453 case 'k':
454 if (LO.FixedPoint)
455 k = ConversionSpecifier::kArg;
456 break;
457 case 'K':
458 if (LO.FixedPoint)
459 k = ConversionSpecifier::KArg;
460 break;
461 case 'R':
462 if (LO.FixedPoint)
463 k = ConversionSpecifier::RArg;
464 break;
465 }
466
467 // Check to see if we used the Objective-C modifier flags with
468 // a conversion specifier other than '@'.
469 if (k != ConversionSpecifier::ObjCObjArg &&
470 k != ConversionSpecifier::InvalidSpecifier && ObjCModifierFlagsStart) {
471 H.HandleObjCFlagsWithNonObjCConversion(
472 flagsStart: ObjCModifierFlagsStart, flagsEnd: ObjCModifierFlagsEnd + 1, conversionPosition);
473 return true;
474 }
475
476 PrintfConversionSpecifier CS(conversionPosition, k);
477 FS.setConversionSpecifier(CS);
478 if (CS.consumesDataArgument() && !FS.usesPositionalArg())
479 FS.setArgIndex(argIndex++);
480 // FreeBSD kernel specific.
481 if (k == ConversionSpecifier::FreeBSDbArg ||
482 k == ConversionSpecifier::FreeBSDDArg)
483 argIndex++;
484
485 if (k == ConversionSpecifier::InvalidSpecifier) {
486 unsigned Len = I - Start;
487 if (parseUTF8InvalidSpecifier(SpecifierBegin: Start, FmtStrEnd: E, Len)) {
488 CS.setEndScanList(Start + Len);
489 FS.setConversionSpecifier(CS);
490 }
491 // Assume the conversion takes one argument.
492 return !H.HandleInvalidPrintfConversionSpecifier(FS, startSpecifier: Start, specifierLen: Len);
493 }
494 return PrintfSpecifierResult(Start, FS);
495}
496
497bool clang::analyze_format_string::ParsePrintfString(
498 FormatStringHandler &H, const char *I, const char *E, const LangOptions &LO,
499 const TargetInfo &Target, bool isFreeBSDKPrintf) {
500
501 unsigned argIndex = 0;
502
503 // Keep looking for a format specifier until we have exhausted the string.
504 PrintfFormatStringParser P(H, LO, Target, /*Warn=*/true, isFreeBSDKPrintf);
505 while (I != E) {
506 const PrintfSpecifierResult &FSR = P.parseSpecifier(Beg&: I, E, argIndex);
507 // Did a fail-stop error of any kind occur when parsing the specifier?
508 // If so, don't do any more processing.
509 if (FSR.shouldStop())
510 return true;
511 // Did we exhaust the string or encounter an error that
512 // we can recover from?
513 if (!FSR.hasValue())
514 continue;
515 // We have a format specifier. Pass it to the callback.
516 if (!H.HandlePrintfSpecifier(FS: FSR.getValue(), startSpecifier: FSR.getStart(),
517 specifierLen: I - FSR.getStart(), Target))
518 return true;
519 }
520 assert(I == E && "Format string not exhausted");
521 return false;
522}
523
524bool clang::analyze_format_string::ParseFormatStringHasSArg(
525 const char *I, const char *E, const LangOptions &LO,
526 const TargetInfo &Target) {
527
528 unsigned argIndex = 0;
529
530 // Keep looking for a %s format specifier until we have exhausted the string.
531 FormatStringHandler H;
532 PrintfFormatStringParser P(H, LO, Target, /*Warn=*/false,
533 /*IsFreeBSDKPrintf=*/false);
534 while (I != E) {
535 const PrintfSpecifierResult &FSR = P.parseSpecifier(Beg&: I, E, argIndex);
536 // Did a fail-stop error of any kind occur when parsing the specifier?
537 // If so, don't do any more processing.
538 if (FSR.shouldStop())
539 return false;
540 // Did we exhaust the string or encounter an error that
541 // we can recover from?
542 if (!FSR.hasValue())
543 continue;
544 const analyze_printf::PrintfSpecifier &FS = FSR.getValue();
545 // Return true if this a %s format specifier.
546 if (FS.getConversionSpecifier().getKind() ==
547 ConversionSpecifier::Kind::sArg)
548 return true;
549 }
550 return false;
551}
552
553bool clang::analyze_format_string::parseFormatStringHasFormattingSpecifiers(
554 const char *Begin, const char *End, const LangOptions &LO,
555 const TargetInfo &Target) {
556 unsigned ArgIndex = 0;
557 // Keep looking for a formatting specifier until we have exhausted the string.
558 FormatStringHandler H;
559 PrintfFormatStringParser P(H, LO, Target, /*Warn=*/false,
560 /*IsFreeBSDKPrintf=*/false);
561 while (Begin != End) {
562 const PrintfSpecifierResult &FSR = P.parseSpecifier(Beg&: Begin, E: End, argIndex&: ArgIndex);
563 if (FSR.shouldStop())
564 break;
565 if (FSR.hasValue())
566 return true;
567 }
568 return false;
569}
570
571//===----------------------------------------------------------------------===//
572// Methods on PrintfSpecifier.
573//===----------------------------------------------------------------------===//
574
575ArgType PrintfSpecifier::getScalarArgType(ASTContext &Ctx,
576 bool IsObjCLiteral) const {
577 if (CS.getKind() == ConversionSpecifier::cArg)
578 switch (LM.getKind()) {
579 case LengthModifier::None:
580 return Ctx.IntTy;
581 case LengthModifier::AsLong:
582 case LengthModifier::AsWide:
583 return ArgType(ArgType::WIntTy, "wint_t");
584 case LengthModifier::AsShort:
585 if (Ctx.getTargetInfo().getTriple().isOSMSVCRT())
586 return Ctx.IntTy;
587 [[fallthrough]];
588 default:
589 return ArgType::Invalid();
590 }
591
592 if (CS.isIntArg())
593 switch (LM.getKind()) {
594 case LengthModifier::AsLongDouble:
595 // GNU extension.
596 return Ctx.LongLongTy;
597 case LengthModifier::None:
598 case LengthModifier::AsShortLong:
599 return Ctx.IntTy;
600 case LengthModifier::AsInt32:
601 return ArgType(Ctx.IntTy, "__int32");
602 case LengthModifier::AsChar:
603 return ArgType::AnyCharTy;
604 case LengthModifier::AsShort:
605 return Ctx.ShortTy;
606 case LengthModifier::AsLong:
607 return Ctx.LongTy;
608 case LengthModifier::AsLongLong:
609 case LengthModifier::AsQuad:
610 return Ctx.LongLongTy;
611 case LengthModifier::AsInt64:
612 return ArgType(Ctx.LongLongTy, "__int64");
613 case LengthModifier::AsIntMax:
614 return ArgType(Ctx.getIntMaxType(), "intmax_t");
615 case LengthModifier::AsSizeT:
616 return ArgType::makeSizeT(
617 A: ArgType(Ctx.getSignedSizeType(), "signed size_t"));
618 case LengthModifier::AsInt3264:
619 return Ctx.getTargetInfo().getTriple().isArch64Bit()
620 ? ArgType(Ctx.LongLongTy, "__int64")
621 : ArgType(Ctx.IntTy, "__int32");
622 case LengthModifier::AsPtrDiff:
623 return ArgType::makePtrdiffT(
624 A: ArgType(Ctx.getPointerDiffType(), "ptrdiff_t"));
625 case LengthModifier::AsIntN:
626 case LengthModifier::AsFastIntN:
627 return ArgType::makeIntNType(Ctx, LengthMod: LM,
628 Signed: CS.getKind() != ConversionSpecifier::bArg &&
629 CS.getKind() !=
630 ConversionSpecifier::BArg);
631 case LengthModifier::AsAllocate:
632 case LengthModifier::AsMAllocate:
633 case LengthModifier::AsWide:
634 case LengthModifier::AsDecimal32:
635 case LengthModifier::AsDecimal64:
636 case LengthModifier::AsDecimal128:
637 return ArgType::Invalid();
638 }
639
640 if (CS.isUIntArg())
641 switch (LM.getKind()) {
642 case LengthModifier::AsLongDouble:
643 // GNU extension.
644 return Ctx.UnsignedLongLongTy;
645 case LengthModifier::None:
646 case LengthModifier::AsShortLong:
647 return Ctx.UnsignedIntTy;
648 case LengthModifier::AsInt32:
649 return ArgType(Ctx.UnsignedIntTy, "unsigned __int32");
650 case LengthModifier::AsChar:
651 return Ctx.UnsignedCharTy;
652 case LengthModifier::AsShort:
653 return Ctx.UnsignedShortTy;
654 case LengthModifier::AsLong:
655 return Ctx.UnsignedLongTy;
656 case LengthModifier::AsLongLong:
657 case LengthModifier::AsQuad:
658 return Ctx.UnsignedLongLongTy;
659 case LengthModifier::AsInt64:
660 return ArgType(Ctx.UnsignedLongLongTy, "unsigned __int64");
661 case LengthModifier::AsIntMax:
662 return ArgType(Ctx.getUIntMaxType(), "uintmax_t");
663 case LengthModifier::AsSizeT:
664 return ArgType::makeSizeT(A: ArgType(Ctx.getSizeType(), "size_t"));
665 case LengthModifier::AsInt3264:
666 return Ctx.getTargetInfo().getTriple().isArch64Bit()
667 ? ArgType(Ctx.UnsignedLongLongTy, "unsigned __int64")
668 : ArgType(Ctx.UnsignedIntTy, "unsigned __int32");
669 case LengthModifier::AsPtrDiff:
670 return ArgType::makePtrdiffT(
671 A: ArgType(Ctx.getUnsignedPointerDiffType(), "unsigned ptrdiff_t"));
672 case LengthModifier::AsIntN:
673 case LengthModifier::AsFastIntN:
674 return ArgType::makeIntNType(Ctx, LengthMod: LM, /*Signed=*/false);
675 case LengthModifier::AsAllocate:
676 case LengthModifier::AsMAllocate:
677 case LengthModifier::AsWide:
678 case LengthModifier::AsDecimal32:
679 case LengthModifier::AsDecimal64:
680 case LengthModifier::AsDecimal128:
681 return ArgType::Invalid();
682 }
683
684 if (CS.isDoubleArg()) {
685 if (!VectorNumElts.isInvalid()) {
686 switch (LM.getKind()) {
687 case LengthModifier::AsShort:
688 return Ctx.HalfTy;
689 case LengthModifier::AsShortLong:
690 return Ctx.FloatTy;
691 case LengthModifier::AsLong:
692 default:
693 return Ctx.DoubleTy;
694 }
695 }
696
697 switch (LM.getKind()) {
698 case LengthModifier::AsLongDouble:
699 return Ctx.LongDoubleTy;
700 case LengthModifier::AsDecimal32:
701 return ArgType::Unsupported(N: "_Decimal32");
702 case LengthModifier::AsDecimal64:
703 return ArgType::Unsupported(N: "_Decimal64");
704 case LengthModifier::AsDecimal128:
705 return ArgType::Unsupported(N: "_Decimal128");
706 default:
707 return Ctx.DoubleTy;
708 }
709 }
710
711 if (CS.getKind() == ConversionSpecifier::nArg) {
712 switch (LM.getKind()) {
713 case LengthModifier::None:
714 return ArgType::PtrTo(A: Ctx.IntTy);
715 case LengthModifier::AsChar:
716 return ArgType::PtrTo(A: Ctx.SignedCharTy);
717 case LengthModifier::AsShort:
718 return ArgType::PtrTo(A: Ctx.ShortTy);
719 case LengthModifier::AsLong:
720 return ArgType::PtrTo(A: Ctx.LongTy);
721 case LengthModifier::AsLongLong:
722 case LengthModifier::AsQuad:
723 return ArgType::PtrTo(A: Ctx.LongLongTy);
724 case LengthModifier::AsIntMax:
725 return ArgType::PtrTo(A: ArgType(Ctx.getIntMaxType(), "intmax_t"));
726 case LengthModifier::AsSizeT:
727 return ArgType::PtrTo(A: ArgType::makeSizeT(
728 A: ArgType(Ctx.getSignedSizeType(), "signed size_t")));
729 case LengthModifier::AsPtrDiff:
730 return ArgType::PtrTo(A: ArgType::makePtrdiffT(
731 A: ArgType(Ctx.getPointerDiffType(), "ptrdiff_t")));
732 case LengthModifier::AsIntN:
733 case LengthModifier::AsFastIntN:
734 return ArgType::PtrTo(A: ArgType::makeIntNType(Ctx, LengthMod: LM, /*Signed=*/true));
735 case LengthModifier::AsLongDouble:
736 return ArgType(); // FIXME: Is this a known extension?
737 case LengthModifier::AsAllocate:
738 case LengthModifier::AsMAllocate:
739 case LengthModifier::AsInt32:
740 case LengthModifier::AsInt3264:
741 case LengthModifier::AsInt64:
742 case LengthModifier::AsWide:
743 case LengthModifier::AsDecimal32:
744 case LengthModifier::AsDecimal64:
745 case LengthModifier::AsDecimal128:
746 return ArgType::Invalid();
747 case LengthModifier::AsShortLong:
748 llvm_unreachable("only used for OpenCL which doesn not handle nArg");
749 }
750 }
751
752 if (CS.isFixedPointArg() && !Ctx.getLangOpts().FixedPoint)
753 return ArgType::Invalid();
754
755 switch (CS.getKind()) {
756 case ConversionSpecifier::sArg:
757 if (LM.getKind() == LengthModifier::AsWideChar) {
758 if (IsObjCLiteral)
759 return ArgType(Ctx.getPointerType(T: Ctx.UnsignedShortTy.withConst()),
760 "const unichar *");
761 return ArgType(ArgType::WCStrTy, "wchar_t *");
762 }
763 if (LM.getKind() == LengthModifier::AsWide)
764 return ArgType(ArgType::WCStrTy, "wchar_t *");
765 return ArgType::CStrTy;
766 case ConversionSpecifier::SArg:
767 if (IsObjCLiteral)
768 return ArgType(Ctx.getPointerType(T: Ctx.UnsignedShortTy.withConst()),
769 "const unichar *");
770 if (Ctx.getTargetInfo().getTriple().isOSMSVCRT() &&
771 LM.getKind() == LengthModifier::AsShort)
772 return ArgType::CStrTy;
773 return ArgType(ArgType::WCStrTy, "wchar_t *");
774 case ConversionSpecifier::CArg:
775 if (IsObjCLiteral)
776 return ArgType(Ctx.UnsignedShortTy, "unichar");
777 if (Ctx.getTargetInfo().getTriple().isOSMSVCRT() &&
778 LM.getKind() == LengthModifier::AsShort)
779 return Ctx.IntTy;
780 return ArgType(Ctx.WideCharTy, "wchar_t");
781 case ConversionSpecifier::pArg:
782 case ConversionSpecifier::PArg:
783 return ArgType::CPointerTy;
784 case ConversionSpecifier::ObjCObjArg:
785 return ArgType::ObjCPointerTy;
786 case ConversionSpecifier::kArg:
787 switch (LM.getKind()) {
788 case LengthModifier::None:
789 return Ctx.AccumTy;
790 case LengthModifier::AsShort:
791 return Ctx.ShortAccumTy;
792 case LengthModifier::AsLong:
793 return Ctx.LongAccumTy;
794 default:
795 return ArgType::Invalid();
796 }
797 case ConversionSpecifier::KArg:
798 switch (LM.getKind()) {
799 case LengthModifier::None:
800 return Ctx.UnsignedAccumTy;
801 case LengthModifier::AsShort:
802 return Ctx.UnsignedShortAccumTy;
803 case LengthModifier::AsLong:
804 return Ctx.UnsignedLongAccumTy;
805 default:
806 return ArgType::Invalid();
807 }
808 case ConversionSpecifier::rArg:
809 switch (LM.getKind()) {
810 case LengthModifier::None:
811 return Ctx.FractTy;
812 case LengthModifier::AsShort:
813 return Ctx.ShortFractTy;
814 case LengthModifier::AsLong:
815 return Ctx.LongFractTy;
816 default:
817 return ArgType::Invalid();
818 }
819 case ConversionSpecifier::RArg:
820 switch (LM.getKind()) {
821 case LengthModifier::None:
822 return Ctx.UnsignedFractTy;
823 case LengthModifier::AsShort:
824 return Ctx.UnsignedShortFractTy;
825 case LengthModifier::AsLong:
826 return Ctx.UnsignedLongFractTy;
827 default:
828 return ArgType::Invalid();
829 }
830 default:
831 break;
832 }
833
834 // FIXME: Handle other cases.
835 return ArgType();
836}
837
838ArgType PrintfSpecifier::getArgType(ASTContext &Ctx, bool IsObjCLiteral) const {
839 const PrintfConversionSpecifier &CS = getConversionSpecifier();
840
841 if (!CS.consumesDataArgument())
842 return ArgType::Invalid();
843
844 ArgType ScalarTy = getScalarArgType(Ctx, IsObjCLiteral);
845 if (!ScalarTy.isValid() || VectorNumElts.isInvalid())
846 return ScalarTy;
847
848 return ScalarTy.makeVectorType(C&: Ctx, NumElts: VectorNumElts.getConstantAmount());
849}
850
851bool PrintfSpecifier::fixType(QualType QT, const LangOptions &LangOpt,
852 ASTContext &Ctx, bool IsObjCLiteral) {
853 // %n is different from other conversion specifiers; don't try to fix it.
854 if (CS.getKind() == ConversionSpecifier::nArg)
855 return false;
856
857 // Handle Objective-C objects first. Note that while the '%@' specifier will
858 // not warn for structure pointer or void pointer arguments (because that's
859 // how CoreFoundation objects are implemented), we only show a fixit for '%@'
860 // if we know it's an object (block, id, class, or __attribute__((NSObject))).
861 if (QT->isObjCRetainableType()) {
862 if (!IsObjCLiteral)
863 return false;
864
865 CS.setKind(ConversionSpecifier::ObjCObjArg);
866
867 // Disable irrelevant flags
868 HasThousandsGrouping = false;
869 HasPlusPrefix = false;
870 HasSpacePrefix = false;
871 HasAlternativeForm = false;
872 HasLeadingZeroes = false;
873 Precision.setHowSpecified(OptionalAmount::NotSpecified);
874 LM.setKind(LengthModifier::None);
875
876 return true;
877 }
878
879 // Handle strings next (char *, wchar_t *)
880 if (QT->isPointerType() && (QT->getPointeeType()->isAnyCharacterType())) {
881 CS.setKind(ConversionSpecifier::sArg);
882
883 // Disable irrelevant flags
884 HasAlternativeForm = false;
885 HasLeadingZeroes = false;
886
887 // Set the long length modifier for wide characters
888 if (QT->getPointeeType()->isWideCharType())
889 LM.setKind(LengthModifier::AsWideChar);
890 else
891 LM.setKind(LengthModifier::None);
892
893 return true;
894 }
895
896 // If it's an enum, get its underlying type.
897 if (const auto *ED = QT->getAsEnumDecl())
898 QT = ED->getIntegerType();
899
900 const BuiltinType *BT = QT->getAs<BuiltinType>();
901 if (!BT) {
902 const VectorType *VT = QT->getAs<VectorType>();
903 if (VT) {
904 QT = VT->getElementType();
905 BT = QT->getAs<BuiltinType>();
906 VectorNumElts = OptionalAmount(VT->getNumElements());
907 }
908 }
909
910 // We can only work with builtin types.
911 if (!BT)
912 return false;
913
914 // Set length modifier
915 switch (BT->getKind()) {
916 case BuiltinType::Bool:
917 case BuiltinType::WChar_U:
918 case BuiltinType::WChar_S:
919 case BuiltinType::Char8: // FIXME: Treat like 'char'?
920 case BuiltinType::Char16:
921 case BuiltinType::Char32:
922 case BuiltinType::UInt128:
923 case BuiltinType::Int128:
924 case BuiltinType::Half:
925 case BuiltinType::BFloat16:
926 case BuiltinType::Float16:
927 case BuiltinType::Float128:
928 case BuiltinType::Ibm128:
929 case BuiltinType::ShortAccum:
930 case BuiltinType::Accum:
931 case BuiltinType::LongAccum:
932 case BuiltinType::UShortAccum:
933 case BuiltinType::UAccum:
934 case BuiltinType::ULongAccum:
935 case BuiltinType::ShortFract:
936 case BuiltinType::Fract:
937 case BuiltinType::LongFract:
938 case BuiltinType::UShortFract:
939 case BuiltinType::UFract:
940 case BuiltinType::ULongFract:
941 case BuiltinType::SatShortAccum:
942 case BuiltinType::SatAccum:
943 case BuiltinType::SatLongAccum:
944 case BuiltinType::SatUShortAccum:
945 case BuiltinType::SatUAccum:
946 case BuiltinType::SatULongAccum:
947 case BuiltinType::SatShortFract:
948 case BuiltinType::SatFract:
949 case BuiltinType::SatLongFract:
950 case BuiltinType::SatUShortFract:
951 case BuiltinType::SatUFract:
952 case BuiltinType::SatULongFract:
953 // Various types which are non-trivial to correct.
954 return false;
955
956#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
957 case BuiltinType::Id:
958#include "clang/Basic/OpenCLImageTypes.def"
959
960#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) case BuiltinType::Id:
961#include "clang/Basic/OpenCLExtensionTypes.def"
962
963#define SVE_TYPE(Name, Id, SingletonId) case BuiltinType::Id:
964#include "clang/Basic/AArch64ACLETypes.def"
965
966#define PPC_VECTOR_TYPE(Name, Id, Size) case BuiltinType::Id:
967#include "clang/Basic/PPCTypes.def"
968
969#define RVV_TYPE(Name, Id, SingletonId) case BuiltinType::Id:
970#include "clang/Basic/RISCVVTypes.def"
971
972#define WASM_TYPE(Name, Id, SingletonId) case BuiltinType::Id:
973#include "clang/Basic/WebAssemblyReferenceTypes.def"
974
975#define AMDGPU_TYPE(Name, Id, SingletonId, Width, Align) case BuiltinType::Id:
976#include "clang/Basic/AMDGPUTypes.def"
977
978#define HLSL_INTANGIBLE_TYPE(Name, Id, SingletonId) case BuiltinType::Id:
979#include "clang/Basic/HLSLIntangibleTypes.def"
980
981#define HLSL_PACKED_TYPE(Name, Id, SingletonId) case BuiltinType::Id:
982#include "clang/Basic/HLSLPackedTypes.def"
983
984#define SPIRV_TYPE(Name, Id, SingletonId) case BuiltinType::Id:
985#include "clang/Basic/SPIRVTypes.def"
986
987#define SIGNED_TYPE(Id, SingletonId)
988#define UNSIGNED_TYPE(Id, SingletonId)
989#define FLOATING_TYPE(Id, SingletonId)
990#define BUILTIN_TYPE(Id, SingletonId) case BuiltinType::Id:
991#include "clang/AST/BuiltinTypes.def"
992
993 // Misc other stuff which doesn't make sense here.
994 return false;
995
996 case BuiltinType::UInt:
997 case BuiltinType::Int:
998 case BuiltinType::Float:
999 LM.setKind(VectorNumElts.isInvalid() ? LengthModifier::None
1000 : LengthModifier::AsShortLong);
1001 break;
1002 case BuiltinType::Double:
1003 LM.setKind(VectorNumElts.isInvalid() ? LengthModifier::None
1004 : LengthModifier::AsLong);
1005 break;
1006 case BuiltinType::Char_U:
1007 case BuiltinType::UChar:
1008 case BuiltinType::Char_S:
1009 case BuiltinType::SChar:
1010 LM.setKind(LengthModifier::AsChar);
1011 break;
1012
1013 case BuiltinType::Short:
1014 case BuiltinType::UShort:
1015 LM.setKind(LengthModifier::AsShort);
1016 break;
1017
1018 case BuiltinType::Long:
1019 case BuiltinType::ULong:
1020 LM.setKind(LengthModifier::AsLong);
1021 break;
1022
1023 case BuiltinType::LongLong:
1024 case BuiltinType::ULongLong:
1025 LM.setKind(LengthModifier::AsLongLong);
1026 break;
1027
1028 case BuiltinType::LongDouble:
1029 LM.setKind(LengthModifier::AsLongDouble);
1030 break;
1031 }
1032
1033 // Handle size_t, ptrdiff_t, etc. that have dedicated length modifiers in C99.
1034 if (LangOpt.C99 || LangOpt.CPlusPlus11)
1035 namedTypeToLengthModifier(Ctx, QT, LM);
1036
1037 // If fixing the length modifier was enough, we might be done.
1038 if (hasValidLengthModifier(Target: Ctx.getTargetInfo(), LO: LangOpt)) {
1039 // If we're going to offer a fix anyway, make sure the sign matches.
1040 switch (CS.getKind()) {
1041 case ConversionSpecifier::uArg:
1042 case ConversionSpecifier::UArg:
1043 if (QT->isSignedIntegerType())
1044 CS.setKind(clang::analyze_format_string::ConversionSpecifier::dArg);
1045 break;
1046 case ConversionSpecifier::dArg:
1047 case ConversionSpecifier::DArg:
1048 case ConversionSpecifier::iArg:
1049 if (QT->isUnsignedIntegerType() && !HasPlusPrefix)
1050 CS.setKind(clang::analyze_format_string::ConversionSpecifier::uArg);
1051 break;
1052 default:
1053 // Other specifiers do not have signed/unsigned variants.
1054 break;
1055 }
1056
1057 const analyze_printf::ArgType &ATR = getArgType(Ctx, IsObjCLiteral);
1058 if (ATR.isValid() && ATR.matchesType(C&: Ctx, argTy: QT))
1059 return true;
1060 }
1061
1062 // Set conversion specifier and disable any flags which do not apply to it.
1063 // Let typedefs to char fall through to int, as %c is silly for uint8_t.
1064 if (!QT->getAs<TypedefType>() && QT->isCharType()) {
1065 CS.setKind(ConversionSpecifier::cArg);
1066 LM.setKind(LengthModifier::None);
1067 Precision.setHowSpecified(OptionalAmount::NotSpecified);
1068 HasAlternativeForm = false;
1069 HasLeadingZeroes = false;
1070 HasPlusPrefix = false;
1071 }
1072 // Test for Floating type first as LongDouble can pass isUnsignedIntegerType
1073 else if (QT->isRealFloatingType()) {
1074 CS.setKind(ConversionSpecifier::fArg);
1075 } else if (QT->isSignedIntegerType()) {
1076 CS.setKind(ConversionSpecifier::dArg);
1077 HasAlternativeForm = false;
1078 } else if (QT->isUnsignedIntegerType()) {
1079 CS.setKind(ConversionSpecifier::uArg);
1080 HasAlternativeForm = false;
1081 HasPlusPrefix = false;
1082 } else {
1083 llvm_unreachable("Unexpected type");
1084 }
1085
1086 return true;
1087}
1088
1089void PrintfSpecifier::toString(raw_ostream &os) const {
1090 // Whilst some features have no defined order, we are using the order
1091 // appearing in the C99 standard (ISO/IEC 9899:1999 (E) 7.19.6.1)
1092 os << "%";
1093
1094 // Positional args
1095 if (usesPositionalArg()) {
1096 os << getPositionalArgIndex() << "$";
1097 }
1098
1099 // Conversion flags
1100 if (IsLeftJustified)
1101 os << "-";
1102 if (HasPlusPrefix)
1103 os << "+";
1104 if (HasSpacePrefix)
1105 os << " ";
1106 if (HasAlternativeForm)
1107 os << "#";
1108 if (HasLeadingZeroes)
1109 os << "0";
1110
1111 // Minimum field width
1112 FieldWidth.toString(os);
1113 // Precision
1114 Precision.toString(os);
1115
1116 // Vector modifier
1117 if (!VectorNumElts.isInvalid())
1118 os << 'v' << VectorNumElts.getConstantAmount();
1119
1120 // Length modifier
1121 os << LM.toString();
1122 // Conversion specifier
1123 os << CS.toString();
1124}
1125
1126bool PrintfSpecifier::hasValidPlusPrefix() const {
1127 if (!HasPlusPrefix)
1128 return true;
1129
1130 // The plus prefix only makes sense for signed conversions
1131 switch (CS.getKind()) {
1132 case ConversionSpecifier::dArg:
1133 case ConversionSpecifier::DArg:
1134 case ConversionSpecifier::iArg:
1135 case ConversionSpecifier::fArg:
1136 case ConversionSpecifier::FArg:
1137 case ConversionSpecifier::eArg:
1138 case ConversionSpecifier::EArg:
1139 case ConversionSpecifier::gArg:
1140 case ConversionSpecifier::GArg:
1141 case ConversionSpecifier::aArg:
1142 case ConversionSpecifier::AArg:
1143 case ConversionSpecifier::FreeBSDrArg:
1144 case ConversionSpecifier::FreeBSDyArg:
1145 case ConversionSpecifier::rArg:
1146 case ConversionSpecifier::kArg:
1147 return true;
1148
1149 default:
1150 return false;
1151 }
1152}
1153
1154bool PrintfSpecifier::hasValidAlternativeForm() const {
1155 if (!HasAlternativeForm)
1156 return true;
1157
1158 // Alternate form flag only valid with the bBoxXaAeEfFgGrRkK conversions
1159 switch (CS.getKind()) {
1160 case ConversionSpecifier::bArg:
1161 case ConversionSpecifier::BArg:
1162 case ConversionSpecifier::oArg:
1163 case ConversionSpecifier::OArg:
1164 case ConversionSpecifier::xArg:
1165 case ConversionSpecifier::XArg:
1166 case ConversionSpecifier::aArg:
1167 case ConversionSpecifier::AArg:
1168 case ConversionSpecifier::eArg:
1169 case ConversionSpecifier::EArg:
1170 case ConversionSpecifier::fArg:
1171 case ConversionSpecifier::FArg:
1172 case ConversionSpecifier::gArg:
1173 case ConversionSpecifier::GArg:
1174 case ConversionSpecifier::FreeBSDrArg:
1175 case ConversionSpecifier::FreeBSDyArg:
1176 case ConversionSpecifier::rArg:
1177 case ConversionSpecifier::RArg:
1178 case ConversionSpecifier::kArg:
1179 case ConversionSpecifier::KArg:
1180 return true;
1181
1182 default:
1183 return false;
1184 }
1185}
1186
1187bool PrintfSpecifier::hasValidLeadingZeros() const {
1188 if (!HasLeadingZeroes)
1189 return true;
1190
1191 // Leading zeroes flag only valid with the bBdiouxXaAeEfFgGrRkK conversions
1192 switch (CS.getKind()) {
1193 case ConversionSpecifier::bArg:
1194 case ConversionSpecifier::BArg:
1195 case ConversionSpecifier::dArg:
1196 case ConversionSpecifier::DArg:
1197 case ConversionSpecifier::iArg:
1198 case ConversionSpecifier::oArg:
1199 case ConversionSpecifier::OArg:
1200 case ConversionSpecifier::uArg:
1201 case ConversionSpecifier::UArg:
1202 case ConversionSpecifier::xArg:
1203 case ConversionSpecifier::XArg:
1204 case ConversionSpecifier::aArg:
1205 case ConversionSpecifier::AArg:
1206 case ConversionSpecifier::eArg:
1207 case ConversionSpecifier::EArg:
1208 case ConversionSpecifier::fArg:
1209 case ConversionSpecifier::FArg:
1210 case ConversionSpecifier::gArg:
1211 case ConversionSpecifier::GArg:
1212 case ConversionSpecifier::FreeBSDrArg:
1213 case ConversionSpecifier::FreeBSDyArg:
1214 case ConversionSpecifier::rArg:
1215 case ConversionSpecifier::RArg:
1216 case ConversionSpecifier::kArg:
1217 case ConversionSpecifier::KArg:
1218 return true;
1219
1220 default:
1221 return false;
1222 }
1223}
1224
1225bool PrintfSpecifier::hasValidSpacePrefix() const {
1226 if (!HasSpacePrefix)
1227 return true;
1228
1229 // The space prefix only makes sense for signed conversions
1230 switch (CS.getKind()) {
1231 case ConversionSpecifier::dArg:
1232 case ConversionSpecifier::DArg:
1233 case ConversionSpecifier::iArg:
1234 case ConversionSpecifier::fArg:
1235 case ConversionSpecifier::FArg:
1236 case ConversionSpecifier::eArg:
1237 case ConversionSpecifier::EArg:
1238 case ConversionSpecifier::gArg:
1239 case ConversionSpecifier::GArg:
1240 case ConversionSpecifier::aArg:
1241 case ConversionSpecifier::AArg:
1242 case ConversionSpecifier::FreeBSDrArg:
1243 case ConversionSpecifier::FreeBSDyArg:
1244 case ConversionSpecifier::rArg:
1245 case ConversionSpecifier::kArg:
1246 return true;
1247
1248 default:
1249 return false;
1250 }
1251}
1252
1253bool PrintfSpecifier::hasValidLeftJustified() const {
1254 if (!IsLeftJustified)
1255 return true;
1256
1257 // The left justified flag is valid for all conversions except n
1258 switch (CS.getKind()) {
1259 case ConversionSpecifier::nArg:
1260 return false;
1261
1262 default:
1263 return true;
1264 }
1265}
1266
1267bool PrintfSpecifier::hasValidThousandsGroupingPrefix() const {
1268 if (!HasThousandsGrouping)
1269 return true;
1270
1271 switch (CS.getKind()) {
1272 case ConversionSpecifier::dArg:
1273 case ConversionSpecifier::DArg:
1274 case ConversionSpecifier::iArg:
1275 case ConversionSpecifier::uArg:
1276 case ConversionSpecifier::UArg:
1277 case ConversionSpecifier::fArg:
1278 case ConversionSpecifier::FArg:
1279 case ConversionSpecifier::gArg:
1280 case ConversionSpecifier::GArg:
1281 return true;
1282 default:
1283 return false;
1284 }
1285}
1286
1287bool PrintfSpecifier::hasValidPrecision() const {
1288 if (Precision.getHowSpecified() == OptionalAmount::NotSpecified)
1289 return true;
1290
1291 // Precision is only valid with the bBdiouxXaAeEfFgGsPrRkK conversions
1292 switch (CS.getKind()) {
1293 case ConversionSpecifier::bArg:
1294 case ConversionSpecifier::BArg:
1295 case ConversionSpecifier::dArg:
1296 case ConversionSpecifier::DArg:
1297 case ConversionSpecifier::iArg:
1298 case ConversionSpecifier::oArg:
1299 case ConversionSpecifier::OArg:
1300 case ConversionSpecifier::uArg:
1301 case ConversionSpecifier::UArg:
1302 case ConversionSpecifier::xArg:
1303 case ConversionSpecifier::XArg:
1304 case ConversionSpecifier::aArg:
1305 case ConversionSpecifier::AArg:
1306 case ConversionSpecifier::eArg:
1307 case ConversionSpecifier::EArg:
1308 case ConversionSpecifier::fArg:
1309 case ConversionSpecifier::FArg:
1310 case ConversionSpecifier::gArg:
1311 case ConversionSpecifier::GArg:
1312 case ConversionSpecifier::sArg:
1313 case ConversionSpecifier::FreeBSDrArg:
1314 case ConversionSpecifier::FreeBSDyArg:
1315 case ConversionSpecifier::PArg:
1316 case ConversionSpecifier::rArg:
1317 case ConversionSpecifier::RArg:
1318 case ConversionSpecifier::kArg:
1319 case ConversionSpecifier::KArg:
1320 return true;
1321
1322 default:
1323 return false;
1324 }
1325}
1326bool PrintfSpecifier::hasValidFieldWidth() const {
1327 if (FieldWidth.getHowSpecified() == OptionalAmount::NotSpecified)
1328 return true;
1329
1330 // The field width is valid for all conversions except n
1331 switch (CS.getKind()) {
1332 case ConversionSpecifier::nArg:
1333 return false;
1334
1335 default:
1336 return true;
1337 }
1338}
1339