PrintfFormatString.cpp revision a792aff1c7de253b89c473fdb7eef4a5bba83aec 
1//== PrintfFormatString.cpp - Analysis of printf format strings --*- C++ -*-==//
2//
3//                     The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9//
10// Handling of format string in printf and friends.  The structure of format
11// strings for fprintf() are described in C99 7.19.6.1.
12//
13//===----------------------------------------------------------------------===//
14
15#include "clang/Analysis/Analyses/FormatString.h"
16#include "FormatStringParsing.h"
17
18using clang::analyze_format_string::ArgTypeResult;
19using clang::analyze_format_string::FormatStringHandler;
20using clang::analyze_format_string::LengthModifier;
21using clang::analyze_format_string::OptionalAmount;
22using clang::analyze_format_string::ConversionSpecifier;
23using clang::analyze_printf::PrintfSpecifier;
24
25using namespace clang;
26
27typedef clang::analyze_format_string::SpecifierResult<PrintfSpecifier>
28        PrintfSpecifierResult;
29
30//===----------------------------------------------------------------------===//
31// Methods for parsing format strings.
32//===----------------------------------------------------------------------===//
33
34using analyze_format_string::ParseNonPositionAmount;
35
36static bool ParsePrecision(FormatStringHandler &H, PrintfSpecifier &FS,
37                           const char *Start, const char *&Beg, const char *E,
38                           unsigned *argIndex) {
39  if (argIndex) {
40    FS.setPrecision(ParseNonPositionAmount(Beg, E, *argIndex));
41  } else {
42    const OptionalAmount Amt = ParsePositionAmount(H, Start, Beg, E,
43                                           analyze_format_string::PrecisionPos);
44    if (Amt.isInvalid())
45      return true;
46    FS.setPrecision(Amt);
47  }
48  return false;
49}
50
51static PrintfSpecifierResult ParsePrintfSpecifier(FormatStringHandler &H,
52                                                  const char *&Beg,
53                                                  const char *E,
54                                                  unsigned &argIndex) {
55
56  using namespace clang::analyze_format_string;
57  using namespace clang::analyze_printf;
58
59  const char *I = Beg;
60  const char *Start = 0;
61  UpdateOnReturn <const char*> UpdateBeg(Beg, I);
62
63  // Look for a '%' character that indicates the start of a format specifier.
64  for ( ; I != E ; ++I) {
65    char c = *I;
66    if (c == '\0') {
67      // Detect spurious null characters, which are likely errors.
68      H.HandleNullChar(I);
69      return true;
70    }
71    if (c == '%') {
72      Start = I++;  // Record the start of the format specifier.
73      break;
74    }
75  }
76
77  // No format specifier found?
78  if (!Start)
79    return false;
80
81  if (I == E) {
82    // No more characters left?
83    H.HandleIncompleteSpecifier(Start, E - Start);
84    return true;
85  }
86
87  PrintfSpecifier FS;
88  if (ParseArgPosition(H, FS, Start, I, E))
89    return true;
90
91  if (I == E) {
92    // No more characters left?
93    H.HandleIncompleteSpecifier(Start, E - Start);
94    return true;
95  }
96
97  // Look for flags (if any).
98  bool hasMore = true;
99  for ( ; I != E; ++I) {
100    switch (*I) {
101      default: hasMore = false; break;
102      case '\'':
103        // FIXME: POSIX specific.  Always accept?
104        FS.setHasThousandsGrouping(I);
105        break;
106      case '-': FS.setIsLeftJustified(I); break;
107      case '+': FS.setHasPlusPrefix(I); break;
108      case ' ': FS.setHasSpacePrefix(I); break;
109      case '#': FS.setHasAlternativeForm(I); break;
110      case '0': FS.setHasLeadingZeros(I); break;
111    }
112    if (!hasMore)
113      break;
114  }
115
116  if (I == E) {
117    // No more characters left?
118    H.HandleIncompleteSpecifier(Start, E - Start);
119    return true;
120  }
121
122  // Look for the field width (if any).
123  if (ParseFieldWidth(H, FS, Start, I, E,
124                      FS.usesPositionalArg() ? 0 : &argIndex))
125    return true;
126
127  if (I == E) {
128    // No more characters left?
129    H.HandleIncompleteSpecifier(Start, E - Start);
130    return true;
131  }
132
133  // Look for the precision (if any).
134  if (*I == '.') {
135    ++I;
136    if (I == E) {
137      H.HandleIncompleteSpecifier(Start, E - Start);
138      return true;
139    }
140
141    if (ParsePrecision(H, FS, Start, I, E,
142                       FS.usesPositionalArg() ? 0 : &argIndex))
143      return true;
144
145    if (I == E) {
146      // No more characters left?
147      H.HandleIncompleteSpecifier(Start, E - Start);
148      return true;
149    }
150  }
151
152  // Look for the length modifier.
153  if (ParseLengthModifier(FS, I, E) && I == E) {
154    // No more characters left?
155    H.HandleIncompleteSpecifier(Start, E - Start);
156    return true;
157  }
158
159  if (*I == '\0') {
160    // Detect spurious null characters, which are likely errors.
161    H.HandleNullChar(I);
162    return true;
163  }
164
165  // Finally, look for the conversion specifier.
166  const char *conversionPosition = I++;
167  ConversionSpecifier::Kind k = ConversionSpecifier::InvalidSpecifier;
168  switch (*conversionPosition) {
169    default:
170      break;
171    // C99: 7.19.6.1 (section 8).
172    case '%': k = ConversionSpecifier::PercentArg;   break;
173    case 'A': k = ConversionSpecifier::AArg; break;
174    case 'E': k = ConversionSpecifier::EArg; break;
175    case 'F': k = ConversionSpecifier::FArg; break;
176    case 'G': k = ConversionSpecifier::GArg; break;
177    case 'X': k = ConversionSpecifier::XArg; break;
178    case 'a': k = ConversionSpecifier::aArg; break;
179    case 'c': k = ConversionSpecifier::cArg; break;
180    case 'd': k = ConversionSpecifier::dArg; break;
181    case 'e': k = ConversionSpecifier::eArg; break;
182    case 'f': k = ConversionSpecifier::fArg; break;
183    case 'g': k = ConversionSpecifier::gArg; break;
184    case 'i': k = ConversionSpecifier::iArg; break;
185    case 'n': k = ConversionSpecifier::nArg; break;
186    case 'o': k = ConversionSpecifier::oArg; break;
187    case 'p': k = ConversionSpecifier::pArg;   break;
188    case 's': k = ConversionSpecifier::sArg;      break;
189    case 'u': k = ConversionSpecifier::uArg; break;
190    case 'x': k = ConversionSpecifier::xArg; break;
191    // POSIX specific.
192    case 'C': k = ConversionSpecifier::CArg; break;
193    case 'S': k = ConversionSpecifier::SArg; break;
194    // Objective-C.
195    case '@': k = ConversionSpecifier::ObjCObjArg; break;
196    // Glibc specific.
197    case 'm': k = ConversionSpecifier::PrintErrno; break;
198  }
199  PrintfConversionSpecifier CS(conversionPosition, k);
200  FS.setConversionSpecifier(CS);
201  if (CS.consumesDataArgument() && !FS.usesPositionalArg())
202    FS.setArgIndex(argIndex++);
203
204  if (k == ConversionSpecifier::InvalidSpecifier) {
205    // Assume the conversion takes one argument.
206    return !H.HandleInvalidPrintfConversionSpecifier(FS, Start, I - Start);
207  }
208  return PrintfSpecifierResult(Start, FS);
209}
210
211bool clang::analyze_format_string::ParsePrintfString(FormatStringHandler &H,
212                                                     const char *I,
213                                                     const char *E) {
214
215  unsigned argIndex = 0;
216
217  // Keep looking for a format specifier until we have exhausted the string.
218  while (I != E) {
219    const PrintfSpecifierResult &FSR = ParsePrintfSpecifier(H, I, E, argIndex);
220    // Did a fail-stop error of any kind occur when parsing the specifier?
221    // If so, don't do any more processing.
222    if (FSR.shouldStop())
223      return true;;
224    // Did we exhaust the string or encounter an error that
225    // we can recover from?
226    if (!FSR.hasValue())
227      continue;
228    // We have a format specifier.  Pass it to the callback.
229    if (!H.HandlePrintfSpecifier(FSR.getValue(), FSR.getStart(),
230                                 I - FSR.getStart()))
231      return true;
232  }
233  assert(I == E && "Format string not exhausted");
234  return false;
235}
236
237//===----------------------------------------------------------------------===//
238// Methods on ConversionSpecifier.
239//===----------------------------------------------------------------------===//
240const char *ConversionSpecifier::toString() const {
241  switch (kind) {
242  case dArg: return "d";
243  case iArg: return "i";
244  case oArg: return "o";
245  case uArg: return "u";
246  case xArg: return "x";
247  case XArg: return "X";
248  case fArg: return "f";
249  case FArg: return "F";
250  case eArg: return "e";
251  case EArg: return "E";
252  case gArg: return "g";
253  case GArg: return "G";
254  case aArg: return "a";
255  case AArg: return "A";
256  case cArg: return "c";
257  case sArg: return "s";
258  case pArg: return "p";
259  case nArg: return "n";
260  case PercentArg:  return "%";
261  case ScanListArg: return "[";
262  case InvalidSpecifier: return NULL;
263
264  // MacOS X unicode extensions.
265  case CArg: return "C";
266  case SArg: return "S";
267
268  // Objective-C specific specifiers.
269  case ObjCObjArg: return "@";
270
271  // GlibC specific specifiers.
272  case PrintErrno: return "m";
273  }
274  return NULL;
275}
276
277//===----------------------------------------------------------------------===//
278// Methods on PrintfSpecifier.
279//===----------------------------------------------------------------------===//
280
281ArgTypeResult PrintfSpecifier::getArgType(ASTContext &Ctx) const {
282  const PrintfConversionSpecifier &CS = getConversionSpecifier();
283
284  if (!CS.consumesDataArgument())
285    return ArgTypeResult::Invalid();
286
287  if (CS.getKind() == ConversionSpecifier::cArg)
288    switch (LM.getKind()) {
289      case LengthModifier::None: return Ctx.IntTy;
290      case LengthModifier::AsLong: return ArgTypeResult::WIntTy;
291      default:
292        return ArgTypeResult::Invalid();
293    }
294
295  if (CS.isIntArg())
296    switch (LM.getKind()) {
297      case LengthModifier::AsLongDouble:
298        return ArgTypeResult::Invalid();
299      case LengthModifier::None: return Ctx.IntTy;
300      case LengthModifier::AsChar: return ArgTypeResult::AnyCharTy;
301      case LengthModifier::AsShort: return Ctx.ShortTy;
302      case LengthModifier::AsLong: return Ctx.LongTy;
303      case LengthModifier::AsLongLong: return Ctx.LongLongTy;
304      case LengthModifier::AsIntMax:
305        return ArgTypeResult(Ctx.getIntMaxType(), "intmax_t");
306      case LengthModifier::AsSizeT:
307        // FIXME: How to get the corresponding signed version of size_t?
308        return ArgTypeResult();
309      case LengthModifier::AsPtrDiff:
310        return ArgTypeResult(Ctx.getPointerDiffType(), "ptrdiff_t");
311    }
312
313  if (CS.isUIntArg())
314    switch (LM.getKind()) {
315      case LengthModifier::AsLongDouble:
316        return ArgTypeResult::Invalid();
317      case LengthModifier::None: return Ctx.UnsignedIntTy;
318      case LengthModifier::AsChar: return Ctx.UnsignedCharTy;
319      case LengthModifier::AsShort: return Ctx.UnsignedShortTy;
320      case LengthModifier::AsLong: return Ctx.UnsignedLongTy;
321      case LengthModifier::AsLongLong: return Ctx.UnsignedLongLongTy;
322      case LengthModifier::AsIntMax:
323        return ArgTypeResult(Ctx.getUIntMaxType(), "uintmax_t");
324      case LengthModifier::AsSizeT:
325        return ArgTypeResult(Ctx.getSizeType(), "size_t");
326      case LengthModifier::AsPtrDiff:
327        // FIXME: How to get the corresponding unsigned
328        // version of ptrdiff_t?
329        return ArgTypeResult();
330    }
331
332  if (CS.isDoubleArg()) {
333    if (LM.getKind() == LengthModifier::AsLongDouble)
334      return Ctx.LongDoubleTy;
335    return Ctx.DoubleTy;
336  }
337
338  switch (CS.getKind()) {
339    case ConversionSpecifier::sArg:
340      return ArgTypeResult(LM.getKind() == LengthModifier::AsWideChar ?
341          ArgTypeResult::WCStrTy : ArgTypeResult::CStrTy);
342    case ConversionSpecifier::SArg:
343      // FIXME: This appears to be Mac OS X specific.
344      return ArgTypeResult::WCStrTy;
345    case ConversionSpecifier::CArg:
346      return Ctx.WCharTy;
347    case ConversionSpecifier::pArg:
348      return ArgTypeResult::CPointerTy;
349    default:
350      break;
351  }
352
353  // FIXME: Handle other cases.
354  return ArgTypeResult();
355}
356
357bool PrintfSpecifier::fixType(QualType QT, const LangOptions &LangOpt) {
358  // Handle strings first (char *, wchar_t *)
359  if (QT->isPointerType() && (QT->getPointeeType()->isAnyCharacterType())) {
360    CS.setKind(ConversionSpecifier::sArg);
361
362    // Disable irrelevant flags
363    HasAlternativeForm = 0;
364    HasLeadingZeroes = 0;
365
366    // Set the long length modifier for wide characters
367    if (QT->getPointeeType()->isWideCharType())
368      LM.setKind(LengthModifier::AsWideChar);
369
370    return true;
371  }
372
373  // We can only work with builtin types.
374  const BuiltinType *BT = QT->getAs<BuiltinType>();
375  if (!BT)
376    return false;
377
378  // Set length modifier
379  switch (BT->getKind()) {
380  case BuiltinType::Bool:
381  case BuiltinType::WChar_U:
382  case BuiltinType::WChar_S:
383  case BuiltinType::Char16:
384  case BuiltinType::Char32:
385  case BuiltinType::UInt128:
386  case BuiltinType::Int128:
387  case BuiltinType::Half:
388    // Various types which are non-trivial to correct.
389    return false;
390
391#define SIGNED_TYPE(Id, SingletonId)
392#define UNSIGNED_TYPE(Id, SingletonId)
393#define FLOATING_TYPE(Id, SingletonId)
394#define BUILTIN_TYPE(Id, SingletonId) \
395  case BuiltinType::Id:
396#include "clang/AST/BuiltinTypes.def"
397    // Misc other stuff which doesn't make sense here.
398    return false;
399
400  case BuiltinType::UInt:
401  case BuiltinType::Int:
402  case BuiltinType::Float:
403  case BuiltinType::Double:
404    LM.setKind(LengthModifier::None);
405    break;
406
407  case BuiltinType::Char_U:
408  case BuiltinType::UChar:
409  case BuiltinType::Char_S:
410  case BuiltinType::SChar:
411    LM.setKind(LengthModifier::AsChar);
412    break;
413
414  case BuiltinType::Short:
415  case BuiltinType::UShort:
416    LM.setKind(LengthModifier::AsShort);
417    break;
418
419  case BuiltinType::Long:
420  case BuiltinType::ULong:
421    LM.setKind(LengthModifier::AsLong);
422    break;
423
424  case BuiltinType::LongLong:
425  case BuiltinType::ULongLong:
426    LM.setKind(LengthModifier::AsLongLong);
427    break;
428
429  case BuiltinType::LongDouble:
430    LM.setKind(LengthModifier::AsLongDouble);
431    break;
432  }
433
434  // Handle size_t, ptrdiff_t, etc. that have dedicated length modifiers in C99.
435  if (isa<TypedefType>(QT) && (LangOpt.C99 || LangOpt.CPlusPlus0x)) {
436    const IdentifierInfo *Identifier = QT.getBaseTypeIdentifier();
437    if (Identifier->getName() == "size_t") {
438      LM.setKind(LengthModifier::AsSizeT);
439    } else if (Identifier->getName() == "ssize_t") {
440      // Not C99, but common in Unix.
441      LM.setKind(LengthModifier::AsSizeT);
442    } else if (Identifier->getName() == "intmax_t") {
443      LM.setKind(LengthModifier::AsIntMax);
444    } else if (Identifier->getName() == "uintmax_t") {
445      LM.setKind(LengthModifier::AsIntMax);
446    } else if (Identifier->getName() == "ptrdiff_t") {
447      LM.setKind(LengthModifier::AsPtrDiff);
448    }
449  }
450
451  // Set conversion specifier and disable any flags which do not apply to it.
452  // Let typedefs to char fall through to int, as %c is silly for uint8_t.
453  if (isa<TypedefType>(QT) && QT->isAnyCharacterType()) {
454    CS.setKind(ConversionSpecifier::cArg);
455    LM.setKind(LengthModifier::None);
456    Precision.setHowSpecified(OptionalAmount::NotSpecified);
457    HasAlternativeForm = 0;
458    HasLeadingZeroes = 0;
459    HasPlusPrefix = 0;
460  }
461  // Test for Floating type first as LongDouble can pass isUnsignedIntegerType
462  else if (QT->isRealFloatingType()) {
463    CS.setKind(ConversionSpecifier::fArg);
464  }
465  else if (QT->isSignedIntegerType()) {
466    CS.setKind(ConversionSpecifier::dArg);
467    HasAlternativeForm = 0;
468  }
469  else if (QT->isUnsignedIntegerType()) {
470    // Preserve the original formatting, e.g. 'X', 'o'.
471    if (!cast<PrintfConversionSpecifier>(CS).isUIntArg())
472      CS.setKind(ConversionSpecifier::uArg);
473    HasAlternativeForm = 0;
474    HasPlusPrefix = 0;
475  } else {
476    llvm_unreachable("Unexpected type");
477  }
478
479  return true;
480}
481
482void PrintfSpecifier::toString(raw_ostream &os) const {
483  // Whilst some features have no defined order, we are using the order
484  // appearing in the C99 standard (ISO/IEC 9899:1999 (E) 7.19.6.1)
485  os << "%";
486
487  // Positional args
488  if (usesPositionalArg()) {
489    os << getPositionalArgIndex() << "$";
490  }
491
492  // Conversion flags
493  if (IsLeftJustified)    os << "-";
494  if (HasPlusPrefix)      os << "+";
495  if (HasSpacePrefix)     os << " ";
496  if (HasAlternativeForm) os << "#";
497  if (HasLeadingZeroes)   os << "0";
498
499  // Minimum field width
500  FieldWidth.toString(os);
501  // Precision
502  Precision.toString(os);
503  // Length modifier
504  os << LM.toString();
505  // Conversion specifier
506  os << CS.toString();
507}
508
509bool PrintfSpecifier::hasValidPlusPrefix() const {
510  if (!HasPlusPrefix)
511    return true;
512
513  // The plus prefix only makes sense for signed conversions
514  switch (CS.getKind()) {
515  case ConversionSpecifier::dArg:
516  case ConversionSpecifier::iArg:
517  case ConversionSpecifier::fArg:
518  case ConversionSpecifier::FArg:
519  case ConversionSpecifier::eArg:
520  case ConversionSpecifier::EArg:
521  case ConversionSpecifier::gArg:
522  case ConversionSpecifier::GArg:
523  case ConversionSpecifier::aArg:
524  case ConversionSpecifier::AArg:
525    return true;
526
527  default:
528    return false;
529  }
530}
531
532bool PrintfSpecifier::hasValidAlternativeForm() const {
533  if (!HasAlternativeForm)
534    return true;
535
536  // Alternate form flag only valid with the oxXaAeEfFgG conversions
537  switch (CS.getKind()) {
538  case ConversionSpecifier::oArg:
539  case ConversionSpecifier::xArg:
540  case ConversionSpecifier::XArg:
541  case ConversionSpecifier::aArg:
542  case ConversionSpecifier::AArg:
543  case ConversionSpecifier::eArg:
544  case ConversionSpecifier::EArg:
545  case ConversionSpecifier::fArg:
546  case ConversionSpecifier::FArg:
547  case ConversionSpecifier::gArg:
548  case ConversionSpecifier::GArg:
549    return true;
550
551  default:
552    return false;
553  }
554}
555
556bool PrintfSpecifier::hasValidLeadingZeros() const {
557  if (!HasLeadingZeroes)
558    return true;
559
560  // Leading zeroes flag only valid with the diouxXaAeEfFgG conversions
561  switch (CS.getKind()) {
562  case ConversionSpecifier::dArg:
563  case ConversionSpecifier::iArg:
564  case ConversionSpecifier::oArg:
565  case ConversionSpecifier::uArg:
566  case ConversionSpecifier::xArg:
567  case ConversionSpecifier::XArg:
568  case ConversionSpecifier::aArg:
569  case ConversionSpecifier::AArg:
570  case ConversionSpecifier::eArg:
571  case ConversionSpecifier::EArg:
572  case ConversionSpecifier::fArg:
573  case ConversionSpecifier::FArg:
574  case ConversionSpecifier::gArg:
575  case ConversionSpecifier::GArg:
576    return true;
577
578  default:
579    return false;
580  }
581}
582
583bool PrintfSpecifier::hasValidSpacePrefix() const {
584  if (!HasSpacePrefix)
585    return true;
586
587  // The space prefix only makes sense for signed conversions
588  switch (CS.getKind()) {
589  case ConversionSpecifier::dArg:
590  case ConversionSpecifier::iArg:
591  case ConversionSpecifier::fArg:
592  case ConversionSpecifier::FArg:
593  case ConversionSpecifier::eArg:
594  case ConversionSpecifier::EArg:
595  case ConversionSpecifier::gArg:
596  case ConversionSpecifier::GArg:
597  case ConversionSpecifier::aArg:
598  case ConversionSpecifier::AArg:
599    return true;
600
601  default:
602    return false;
603  }
604}
605
606bool PrintfSpecifier::hasValidLeftJustified() const {
607  if (!IsLeftJustified)
608    return true;
609
610  // The left justified flag is valid for all conversions except n
611  switch (CS.getKind()) {
612  case ConversionSpecifier::nArg:
613    return false;
614
615  default:
616    return true;
617  }
618}
619
620bool PrintfSpecifier::hasValidThousandsGroupingPrefix() const {
621  if (!HasThousandsGrouping)
622    return true;
623
624  switch (CS.getKind()) {
625    case ConversionSpecifier::dArg:
626    case ConversionSpecifier::iArg:
627    case ConversionSpecifier::uArg:
628    case ConversionSpecifier::fArg:
629    case ConversionSpecifier::FArg:
630    case ConversionSpecifier::gArg:
631    case ConversionSpecifier::GArg:
632      return true;
633    default:
634      return false;
635  }
636}
637
638bool PrintfSpecifier::hasValidPrecision() const {
639  if (Precision.getHowSpecified() == OptionalAmount::NotSpecified)
640    return true;
641
642  // Precision is only valid with the diouxXaAeEfFgGs conversions
643  switch (CS.getKind()) {
644  case ConversionSpecifier::dArg:
645  case ConversionSpecifier::iArg:
646  case ConversionSpecifier::oArg:
647  case ConversionSpecifier::uArg:
648  case ConversionSpecifier::xArg:
649  case ConversionSpecifier::XArg:
650  case ConversionSpecifier::aArg:
651  case ConversionSpecifier::AArg:
652  case ConversionSpecifier::eArg:
653  case ConversionSpecifier::EArg:
654  case ConversionSpecifier::fArg:
655  case ConversionSpecifier::FArg:
656  case ConversionSpecifier::gArg:
657  case ConversionSpecifier::GArg:
658  case ConversionSpecifier::sArg:
659    return true;
660
661  default:
662    return false;
663  }
664}
665bool PrintfSpecifier::hasValidFieldWidth() const {
666  if (FieldWidth.getHowSpecified() == OptionalAmount::NotSpecified)
667      return true;
668
669  // The field width is valid for all conversions except n
670  switch (CS.getKind()) {
671  case ConversionSpecifier::nArg:
672    return false;
673
674  default:
675    return true;
676  }
677}
678