contrib/llvm/tools/clang/lib/Analysis/ScanfFormatString.cpp

   1 //= ScanfFormatString.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 scanf and friends.  The structure of format
  11 // strings for fscanf() are described in C99 7.19.6.2.
  12 //
  13 //===----------------------------------------------------------------------===//
  14
  15 #include "clang/Analysis/Analyses/FormatString.h"
  16 #include "FormatStringParsing.h"
  17 #include "clang/Basic/TargetInfo.h"
  18
  19 using clang::analyze_format_string::ArgType;
  20 using clang::analyze_format_string::FormatStringHandler;
  21 using clang::analyze_format_string::LengthModifier;
  22 using clang::analyze_format_string::OptionalAmount;
  23 using clang::analyze_format_string::ConversionSpecifier;
  24 using clang::analyze_scanf::ScanfConversionSpecifier;
  25 using clang::analyze_scanf::ScanfSpecifier;
  26 using clang::UpdateOnReturn;
  27 using namespace clang;
  28
  29 typedef clang::analyze_format_string::SpecifierResult<ScanfSpecifier>
  30         ScanfSpecifierResult;
  31
  32 static bool ParseScanList(FormatStringHandler &H,
  33                           ScanfConversionSpecifier &CS,
  34                           const char *&Beg, const char *E) {
  35   const char *I = Beg;
  36   const char *start = I - 1;
  37   UpdateOnReturn <const char*> UpdateBeg(Beg, I);
  38
  39   // No more characters?
  40   if (I == E) {
  41     H.HandleIncompleteScanList(start, I);
  42     return true;
  43   }
  44
  45   // Special case: ']' is the first character.
  46   if (*I == ']') {
  47     if (++I == E) {
  48       H.HandleIncompleteScanList(start, I - 1);
  49       return true;
  50     }
  51   }
  52
  53   // Special case: "^]" are the first characters.
  54   if (I + 1 != E && I[0] == '^' && I[1] == ']') {
  55     I += 2;
  56     if (I == E) {
  57       H.HandleIncompleteScanList(start, I - 1);
  58       return true;
  59     }
  60   }
  61
  62   // Look for a ']' character which denotes the end of the scan list.
  63   while (*I != ']') {
  64     if (++I == E) {
  65       H.HandleIncompleteScanList(start, I - 1);
  66       return true;
  67     }
  68   }
  69
  70   CS.setEndScanList(I);
  71   return false;
  72 }
  73
  74 // FIXME: Much of this is copy-paste from ParsePrintfSpecifier.
  75 // We can possibly refactor.
  76 static ScanfSpecifierResult ParseScanfSpecifier(FormatStringHandler &H,
  77                                                 const char *&Beg,
  78                                                 const char *E,
  79                                                 unsigned &argIndex,
  80                                                 const LangOptions &LO,
  81                                                 const TargetInfo &Target) {
  82   using namespace clang::analyze_format_string;
  83   using namespace clang::analyze_scanf;
  84   const char *I = Beg;
  85   const char *Start = nullptr;
  86   UpdateOnReturn <const char*> UpdateBeg(Beg, I);
  87
  88     // Look for a '%' character that indicates the start of a format specifier.
  89   for ( ; I != E ; ++I) {
  90     char c = *I;
  91     if (c == '\0') {
  92         // Detect spurious null characters, which are likely errors.
  93       H.HandleNullChar(I);
  94       return true;
  95     }
  96     if (c == '%') {
  97       Start = I++;  // Record the start of the format specifier.
  98       break;
  99     }
 100   }
 101
 102     // No format specifier found?
 103   if (!Start)
 104     return false;
 105
 106   if (I == E) {
 107       // No more characters left?
 108     H.HandleIncompleteSpecifier(Start, E - Start);
 109     return true;
 110   }
 111
 112   ScanfSpecifier FS;
 113   if (ParseArgPosition(H, FS, Start, I, E))
 114     return true;
 115
 116   if (I == E) {
 117       // No more characters left?
 118     H.HandleIncompleteSpecifier(Start, E - Start);
 119     return true;
 120   }
 121
 122   // Look for '*' flag if it is present.
 123   if (*I == '*') {
 124     FS.setSuppressAssignment(I);
 125     if (++I == E) {
 126       H.HandleIncompleteSpecifier(Start, E - Start);
 127       return true;
 128     }
 129   }
 130
 131   // Look for the field width (if any).  Unlike printf, this is either
 132   // a fixed integer or isn't present.
 133   const OptionalAmount &Amt = clang::analyze_format_string::ParseAmount(I, E);
 134   if (Amt.getHowSpecified() != OptionalAmount::NotSpecified) {
 135     assert(Amt.getHowSpecified() == OptionalAmount::Constant);
 136     FS.setFieldWidth(Amt);
 137
 138     if (I == E) {
 139       // No more characters left?
 140       H.HandleIncompleteSpecifier(Start, E - Start);
 141       return true;
 142     }
 143   }
 144
 145   // Look for the length modifier.
 146   if (ParseLengthModifier(FS, I, E, LO, /*scanf=*/true) && I == E) {
 147       // No more characters left?
 148     H.HandleIncompleteSpecifier(Start, E - Start);
 149     return true;
 150   }
 151
 152   // Detect spurious null characters, which are likely errors.
 153   if (*I == '\0') {
 154     H.HandleNullChar(I);
 155     return true;
 156   }
 157
 158   // Finally, look for the conversion specifier.
 159   const char *conversionPosition = I++;
 160   ScanfConversionSpecifier::Kind k = ScanfConversionSpecifier::InvalidSpecifier;
 161   switch (*conversionPosition) {
 162     default:
 163       break;
 164     case '%': k = ConversionSpecifier::PercentArg;   break;
 165     case 'A': k = ConversionSpecifier::AArg; break;
 166     case 'E': k = ConversionSpecifier::EArg; break;
 167     case 'F': k = ConversionSpecifier::FArg; break;
 168     case 'G': k = ConversionSpecifier::GArg; break;
 169     case 'X': k = ConversionSpecifier::XArg; break;
 170     case 'a': k = ConversionSpecifier::aArg; break;
 171     case 'd': k = ConversionSpecifier::dArg; break;
 172     case 'e': k = ConversionSpecifier::eArg; break;
 173     case 'f': k = ConversionSpecifier::fArg; break;
 174     case 'g': k = ConversionSpecifier::gArg; break;
 175     case 'i': k = ConversionSpecifier::iArg; break;
 176     case 'n': k = ConversionSpecifier::nArg; break;
 177     case 'c': k = ConversionSpecifier::cArg; break;
 178     case 'C': k = ConversionSpecifier::CArg; break;
 179     case 'S': k = ConversionSpecifier::SArg; break;
 180     case '[': k = ConversionSpecifier::ScanListArg; break;
 181     case 'u': k = ConversionSpecifier::uArg; break;
 182     case 'x': k = ConversionSpecifier::xArg; break;
 183     case 'o': k = ConversionSpecifier::oArg; break;
 184     case 's': k = ConversionSpecifier::sArg; break;
 185     case 'p': k = ConversionSpecifier::pArg; break;
 186     // Apple extensions
 187       // Apple-specific
 188     case 'D':
 189       if (Target.getTriple().isOSDarwin())
 190         k = ConversionSpecifier::DArg;
 191       break;
 192     case 'O':
 193       if (Target.getTriple().isOSDarwin())
 194         k = ConversionSpecifier::OArg;
 195       break;
 196     case 'U':
 197       if (Target.getTriple().isOSDarwin())
 198         k = ConversionSpecifier::UArg;
 199       break;
 200   }
 201   ScanfConversionSpecifier CS(conversionPosition, k);
 202   if (k == ScanfConversionSpecifier::ScanListArg) {
 203     if (ParseScanList(H, CS, I, E))
 204       return true;
 205   }
 206   FS.setConversionSpecifier(CS);
 207   if (CS.consumesDataArgument() && !FS.getSuppressAssignment()
 208       && !FS.usesPositionalArg())
 209     FS.setArgIndex(argIndex++);
 210
 211   // FIXME: '%' and '*' doesn't make sense.  Issue a warning.
 212   // FIXME: 'ConsumedSoFar' and '*' doesn't make sense.
 213
 214   if (k == ScanfConversionSpecifier::InvalidSpecifier) {
 215     unsigned Len = I - Beg;
 216     if (ParseUTF8InvalidSpecifier(Beg, E, Len)) {
 217       CS.setEndScanList(Beg + Len);
 218       FS.setConversionSpecifier(CS);
 219     }
 220     // Assume the conversion takes one argument.
 221     return !H.HandleInvalidScanfConversionSpecifier(FS, Beg, Len);
 222   }
 223   return ScanfSpecifierResult(Start, FS);
 224 }
 225
 226 ArgType ScanfSpecifier::getArgType(ASTContext &Ctx) const {
 227   const ScanfConversionSpecifier &CS = getConversionSpecifier();
 228
 229   if (!CS.consumesDataArgument())
 230     return ArgType::Invalid();
 231
 232   switch(CS.getKind()) {
 233     // Signed int.
 234     case ConversionSpecifier::dArg:
 235     case ConversionSpecifier::DArg:
 236     case ConversionSpecifier::iArg:
 237       switch (LM.getKind()) {
 238         case LengthModifier::None:
 239           return ArgType::PtrTo(Ctx.IntTy);
 240         case LengthModifier::AsChar:
 241           return ArgType::PtrTo(ArgType::AnyCharTy);
 242         case LengthModifier::AsShort:
 243           return ArgType::PtrTo(Ctx.ShortTy);
 244         case LengthModifier::AsLong:
 245           return ArgType::PtrTo(Ctx.LongTy);
 246         case LengthModifier::AsLongLong:
 247         case LengthModifier::AsQuad:
 248           return ArgType::PtrTo(Ctx.LongLongTy);
 249         case LengthModifier::AsInt64:
 250           return ArgType::PtrTo(ArgType(Ctx.LongLongTy, "__int64"));
 251         case LengthModifier::AsIntMax:
 252           return ArgType::PtrTo(ArgType(Ctx.getIntMaxType(), "intmax_t"));
 253         case LengthModifier::AsSizeT:
 254           // FIXME: ssize_t.
 255           return ArgType();
 256         case LengthModifier::AsPtrDiff:
 257           return ArgType::PtrTo(ArgType(Ctx.getPointerDiffType(), "ptrdiff_t"));
 258         case LengthModifier::AsLongDouble:
 259           // GNU extension.
 260           return ArgType::PtrTo(Ctx.LongLongTy);
 261         case LengthModifier::AsAllocate:
 262         case LengthModifier::AsMAllocate:
 263         case LengthModifier::AsInt32:
 264         case LengthModifier::AsInt3264:
 265         case LengthModifier::AsWide:
 266           return ArgType::Invalid();
 267       }
 268
 269     // Unsigned int.
 270     case ConversionSpecifier::oArg:
 271     case ConversionSpecifier::OArg:
 272     case ConversionSpecifier::uArg:
 273     case ConversionSpecifier::UArg:
 274     case ConversionSpecifier::xArg:
 275     case ConversionSpecifier::XArg:
 276       switch (LM.getKind()) {
 277         case LengthModifier::None:
 278           return ArgType::PtrTo(Ctx.UnsignedIntTy);
 279         case LengthModifier::AsChar:
 280           return ArgType::PtrTo(Ctx.UnsignedCharTy);
 281         case LengthModifier::AsShort:
 282           return ArgType::PtrTo(Ctx.UnsignedShortTy);
 283         case LengthModifier::AsLong:
 284           return ArgType::PtrTo(Ctx.UnsignedLongTy);
 285         case LengthModifier::AsLongLong:
 286         case LengthModifier::AsQuad:
 287           return ArgType::PtrTo(Ctx.UnsignedLongLongTy);
 288         case LengthModifier::AsInt64:
 289           return ArgType::PtrTo(ArgType(Ctx.UnsignedLongLongTy, "unsigned __int64"));
 290         case LengthModifier::AsIntMax:
 291           return ArgType::PtrTo(ArgType(Ctx.getUIntMaxType(), "uintmax_t"));
 292         case LengthModifier::AsSizeT:
 293           return ArgType::PtrTo(ArgType(Ctx.getSizeType(), "size_t"));
 294         case LengthModifier::AsPtrDiff:
 295           // FIXME: Unsigned version of ptrdiff_t?
 296           return ArgType();
 297         case LengthModifier::AsLongDouble:
 298           // GNU extension.
 299           return ArgType::PtrTo(Ctx.UnsignedLongLongTy);
 300         case LengthModifier::AsAllocate:
 301         case LengthModifier::AsMAllocate:
 302         case LengthModifier::AsInt32:
 303         case LengthModifier::AsInt3264:
 304         case LengthModifier::AsWide:
 305           return ArgType::Invalid();
 306       }
 307
 308     // Float.
 309     case ConversionSpecifier::aArg:
 310     case ConversionSpecifier::AArg:
 311     case ConversionSpecifier::eArg:
 312     case ConversionSpecifier::EArg:
 313     case ConversionSpecifier::fArg:
 314     case ConversionSpecifier::FArg:
 315     case ConversionSpecifier::gArg:
 316     case ConversionSpecifier::GArg:
 317       switch (LM.getKind()) {
 318         case LengthModifier::None:
 319           return ArgType::PtrTo(Ctx.FloatTy);
 320         case LengthModifier::AsLong:
 321           return ArgType::PtrTo(Ctx.DoubleTy);
 322         case LengthModifier::AsLongDouble:
 323           return ArgType::PtrTo(Ctx.LongDoubleTy);
 324         default:
 325           return ArgType::Invalid();
 326       }
 327
 328     // Char, string and scanlist.
 329     case ConversionSpecifier::cArg:
 330     case ConversionSpecifier::sArg:
 331     case ConversionSpecifier::ScanListArg:
 332       switch (LM.getKind()) {
 333         case LengthModifier::None:
 334           return ArgType::PtrTo(ArgType::AnyCharTy);
 335         case LengthModifier::AsLong:
 336         case LengthModifier::AsWide:
 337           return ArgType::PtrTo(ArgType(Ctx.getWideCharType(), "wchar_t"));
 338         case LengthModifier::AsAllocate:
 339         case LengthModifier::AsMAllocate:
 340           return ArgType::PtrTo(ArgType::CStrTy);
 341         case LengthModifier::AsShort:
 342           if (Ctx.getTargetInfo().getTriple().isOSMSVCRT())
 343             return ArgType::PtrTo(ArgType::AnyCharTy);
 344           LLVM_FALLTHROUGH;
 345         default:
 346           return ArgType::Invalid();
 347       }
 348     case ConversionSpecifier::CArg:
 349     case ConversionSpecifier::SArg:
 350       // FIXME: Mac OS X specific?
 351       switch (LM.getKind()) {
 352         case LengthModifier::None:
 353         case LengthModifier::AsWide:
 354           return ArgType::PtrTo(ArgType(Ctx.getWideCharType(), "wchar_t"));
 355         case LengthModifier::AsAllocate:
 356         case LengthModifier::AsMAllocate:
 357           return ArgType::PtrTo(ArgType(ArgType::WCStrTy, "wchar_t *"));
 358         case LengthModifier::AsShort:
 359           if (Ctx.getTargetInfo().getTriple().isOSMSVCRT())
 360             return ArgType::PtrTo(ArgType::AnyCharTy);
 361           LLVM_FALLTHROUGH;
 362         default:
 363           return ArgType::Invalid();
 364       }
 365
 366     // Pointer.
 367     case ConversionSpecifier::pArg:
 368       return ArgType::PtrTo(ArgType::CPointerTy);
 369
 370     // Write-back.
 371     case ConversionSpecifier::nArg:
 372       switch (LM.getKind()) {
 373         case LengthModifier::None:
 374           return ArgType::PtrTo(Ctx.IntTy);
 375         case LengthModifier::AsChar:
 376           return ArgType::PtrTo(Ctx.SignedCharTy);
 377         case LengthModifier::AsShort:
 378           return ArgType::PtrTo(Ctx.ShortTy);
 379         case LengthModifier::AsLong:
 380           return ArgType::PtrTo(Ctx.LongTy);
 381         case LengthModifier::AsLongLong:
 382         case LengthModifier::AsQuad:
 383           return ArgType::PtrTo(Ctx.LongLongTy);
 384         case LengthModifier::AsInt64:
 385           return ArgType::PtrTo(ArgType(Ctx.LongLongTy, "__int64"));
 386         case LengthModifier::AsIntMax:
 387           return ArgType::PtrTo(ArgType(Ctx.getIntMaxType(), "intmax_t"));
 388         case LengthModifier::AsSizeT:
 389           return ArgType(); // FIXME: ssize_t
 390         case LengthModifier::AsPtrDiff:
 391           return ArgType::PtrTo(ArgType(Ctx.getPointerDiffType(), "ptrdiff_t"));
 392         case LengthModifier::AsLongDouble:
 393           return ArgType(); // FIXME: Is this a known extension?
 394         case LengthModifier::AsAllocate:
 395         case LengthModifier::AsMAllocate:
 396         case LengthModifier::AsInt32:
 397         case LengthModifier::AsInt3264:
 398         case LengthModifier::AsWide:
 399           return ArgType::Invalid();
 400         }
 401
 402     default:
 403       break;
 404   }
 405
 406   return ArgType();
 407 }
 408
 409 bool ScanfSpecifier::fixType(QualType QT, QualType RawQT,
 410                              const LangOptions &LangOpt,
 411                              ASTContext &Ctx) {
 412
 413   // %n is different from other conversion specifiers; don't try to fix it.
 414   if (CS.getKind() == ConversionSpecifier::nArg)
 415     return false;
 416
 417   if (!QT->isPointerType())
 418     return false;
 419
 420   QualType PT = QT->getPointeeType();
 421
 422   // If it's an enum, get its underlying type.
 423   if (const EnumType *ETy = PT->getAs<EnumType>()) {
 424     // Don't try to fix incomplete enums.
 425     if (!ETy->getDecl()->isComplete())
 426       return false;
 427     PT = ETy->getDecl()->getIntegerType();
 428   }
 429
 430   const BuiltinType *BT = PT->getAs<BuiltinType>();
 431   if (!BT)
 432     return false;
 433
 434   // Pointer to a character.
 435   if (PT->isAnyCharacterType()) {
 436     CS.setKind(ConversionSpecifier::sArg);
 437     if (PT->isWideCharType())
 438       LM.setKind(LengthModifier::AsWideChar);
 439     else
 440       LM.setKind(LengthModifier::None);
 441
 442     // If we know the target array length, we can use it as a field width.
 443     if (const ConstantArrayType *CAT = Ctx.getAsConstantArrayType(RawQT)) {
 444       if (CAT->getSizeModifier() == ArrayType::Normal)
 445         FieldWidth = OptionalAmount(OptionalAmount::Constant,
 446                                     CAT->getSize().getZExtValue() - 1,
 447                                     "", 0, false);
 448
 449     }
 450     return true;
 451   }
 452
 453   // Figure out the length modifier.
 454   switch (BT->getKind()) {
 455     // no modifier
 456     case BuiltinType::UInt:
 457     case BuiltinType::Int:
 458     case BuiltinType::Float:
 459       LM.setKind(LengthModifier::None);
 460       break;
 461
 462     // hh
 463     case BuiltinType::Char_U:
 464     case BuiltinType::UChar:
 465     case BuiltinType::Char_S:
 466     case BuiltinType::SChar:
 467       LM.setKind(LengthModifier::AsChar);
 468       break;
 469
 470     // h
 471     case BuiltinType::Short:
 472     case BuiltinType::UShort:
 473       LM.setKind(LengthModifier::AsShort);
 474       break;
 475
 476     // l
 477     case BuiltinType::Long:
 478     case BuiltinType::ULong:
 479     case BuiltinType::Double:
 480       LM.setKind(LengthModifier::AsLong);
 481       break;
 482
 483     // ll
 484     case BuiltinType::LongLong:
 485     case BuiltinType::ULongLong:
 486       LM.setKind(LengthModifier::AsLongLong);
 487       break;
 488
 489     // L
 490     case BuiltinType::LongDouble:
 491       LM.setKind(LengthModifier::AsLongDouble);
 492       break;
 493
 494     // Don't know.
 495     default:
 496       return false;
 497   }
 498
 499   // Handle size_t, ptrdiff_t, etc. that have dedicated length modifiers in C99.
 500   if (isa<TypedefType>(PT) && (LangOpt.C99 || LangOpt.CPlusPlus11))
 501     namedTypeToLengthModifier(PT, LM);
 502
 503   // If fixing the length modifier was enough, we are done.
 504   if (hasValidLengthModifier(Ctx.getTargetInfo())) {
 505     const analyze_scanf::ArgType &AT = getArgType(Ctx);
 506     if (AT.isValid() && AT.matchesType(Ctx, QT))
 507       return true;
 508   }
 509
 510   // Figure out the conversion specifier.
 511   if (PT->isRealFloatingType())
 512     CS.setKind(ConversionSpecifier::fArg);
 513   else if (PT->isSignedIntegerType())
 514     CS.setKind(ConversionSpecifier::dArg);
 515   else if (PT->isUnsignedIntegerType())
 516     CS.setKind(ConversionSpecifier::uArg);
 517   else
 518     llvm_unreachable("Unexpected type");
 519
 520   return true;
 521 }
 522
 523 void ScanfSpecifier::toString(raw_ostream &os) const {
 524   os << "%";
 525
 526   if (usesPositionalArg())
 527     os << getPositionalArgIndex() << "$";
 528   if (SuppressAssignment)
 529     os << "*";
 530
 531   FieldWidth.toString(os);
 532   os << LM.toString();
 533   os << CS.toString();
 534 }
 535
 536 bool clang::analyze_format_string::ParseScanfString(FormatStringHandler &H,
 537                                                     const char *I,
 538                                                     const char *E,
 539                                                     const LangOptions &LO,
 540                                                     const TargetInfo &Target) {
 541
 542   unsigned argIndex = 0;
 543
 544   // Keep looking for a format specifier until we have exhausted the string.
 545   while (I != E) {
 546     const ScanfSpecifierResult &FSR = ParseScanfSpecifier(H, I, E, argIndex,
 547                                                           LO, Target);
 548     // Did a fail-stop error of any kind occur when parsing the specifier?
 549     // If so, don't do any more processing.
 550     if (FSR.shouldStop())
 551       return true;
 552       // Did we exhaust the string or encounter an error that
 553       // we can recover from?
 554     if (!FSR.hasValue())
 555       continue;
 556       // We have a format specifier.  Pass it to the callback.
 557     if (!H.HandleScanfSpecifier(FSR.getValue(), FSR.getStart(),
 558                                 I - FSR.getStart())) {
 559       return true;
 560     }
 561   }
 562   assert(I == E && "Format string not exhausted");
 563   return false;
 564 }