clang/lib/AST/OSLog.cpp

   1 // TODO: header template
   2
   3 #include "clang/AST/OSLog.h"
   4 #include "clang/AST/Attr.h"
   5 #include "clang/AST/Decl.h"
   6 #include "clang/AST/DeclCXX.h"
   7 #include "clang/AST/ExprObjC.h"
   8 #include "clang/AST/FormatString.h"
   9 #include "clang/Basic/Builtins.h"
  10 #include "llvm/ADT/SmallBitVector.h"
  11 #include <optional>
  12
  13 using namespace clang;
  14
  15 using clang::analyze_os_log::OSLogBufferItem;
  16 using clang::analyze_os_log::OSLogBufferLayout;
  17
  18 namespace {
  19 class OSLogFormatStringHandler
  20     : public analyze_format_string::FormatStringHandler {
  21 private:
  22   struct ArgData {
  23     const Expr *E = nullptr;
  24     std::optional<OSLogBufferItem::Kind> Kind;
  25     std::optional<unsigned> Size;
  26     std::optional<const Expr *> Count;
  27     std::optional<const Expr *> Precision;
  28     std::optional<const Expr *> FieldWidth;
  29     unsigned char Flags = 0;
  30     StringRef MaskType;
  31   };
  32   SmallVector<ArgData, 4> ArgsData;
  33   ArrayRef<const Expr *> Args;
  34
  35   OSLogBufferItem::Kind
  36   getKind(analyze_format_string::ConversionSpecifier::Kind K) {
  37     switch (K) {
  38     case clang::analyze_format_string::ConversionSpecifier::sArg: // "%s"
  39       return OSLogBufferItem::StringKind;
  40     case clang::analyze_format_string::ConversionSpecifier::SArg: // "%S"
  41       return OSLogBufferItem::WideStringKind;
  42     case clang::analyze_format_string::ConversionSpecifier::PArg: { // "%P"
  43       return OSLogBufferItem::PointerKind;
  44     case clang::analyze_format_string::ConversionSpecifier::ObjCObjArg: // "%@"
  45       return OSLogBufferItem::ObjCObjKind;
  46     case clang::analyze_format_string::ConversionSpecifier::PrintErrno: // "%m"
  47       return OSLogBufferItem::ErrnoKind;
  48     default:
  49       return OSLogBufferItem::ScalarKind;
  50     }
  51     }
  52   }
  53
  54 public:
  55   OSLogFormatStringHandler(ArrayRef<const Expr *> Args) : Args(Args) {
  56     ArgsData.reserve(Args.size());
  57   }
  58
  59   bool HandlePrintfSpecifier(const analyze_printf::PrintfSpecifier &FS,
  60                              const char *StartSpecifier, unsigned SpecifierLen,
  61                              const TargetInfo &) override {
  62     if (!FS.consumesDataArgument() &&
  63         FS.getConversionSpecifier().getKind() !=
  64             clang::analyze_format_string::ConversionSpecifier::PrintErrno)
  65       return true;
  66
  67     ArgsData.emplace_back();
  68     unsigned ArgIndex = FS.getArgIndex();
  69     if (ArgIndex < Args.size())
  70       ArgsData.back().E = Args[ArgIndex];
  71
  72     // First get the Kind
  73     ArgsData.back().Kind = getKind(FS.getConversionSpecifier().getKind());
  74     if (ArgsData.back().Kind != OSLogBufferItem::ErrnoKind &&
  75         !ArgsData.back().E) {
  76       // missing argument
  77       ArgsData.pop_back();
  78       return false;
  79     }
  80
  81     switch (FS.getConversionSpecifier().getKind()) {
  82     case clang::analyze_format_string::ConversionSpecifier::sArg:   // "%s"
  83     case clang::analyze_format_string::ConversionSpecifier::SArg: { // "%S"
  84       auto &precision = FS.getPrecision();
  85       switch (precision.getHowSpecified()) {
  86       case clang::analyze_format_string::OptionalAmount::NotSpecified: // "%s"
  87         break;
  88       case clang::analyze_format_string::OptionalAmount::Constant: // "%.16s"
  89         ArgsData.back().Size = precision.getConstantAmount();
  90         break;
  91       case clang::analyze_format_string::OptionalAmount::Arg: // "%.*s"
  92         ArgsData.back().Count = Args[precision.getArgIndex()];
  93         break;
  94       case clang::analyze_format_string::OptionalAmount::Invalid:
  95         return false;
  96       }
  97       break;
  98     }
  99     case clang::analyze_format_string::ConversionSpecifier::PArg: { // "%P"
 100       auto &precision = FS.getPrecision();
 101       switch (precision.getHowSpecified()) {
 102       case clang::analyze_format_string::OptionalAmount::NotSpecified: // "%P"
 103         return false; // length must be supplied with pointer format specifier
 104       case clang::analyze_format_string::OptionalAmount::Constant: // "%.16P"
 105         ArgsData.back().Size = precision.getConstantAmount();
 106         break;
 107       case clang::analyze_format_string::OptionalAmount::Arg: // "%.*P"
 108         ArgsData.back().Count = Args[precision.getArgIndex()];
 109         break;
 110       case clang::analyze_format_string::OptionalAmount::Invalid:
 111         return false;
 112       }
 113       break;
 114     }
 115     default:
 116       if (FS.getPrecision().hasDataArgument()) {
 117         ArgsData.back().Precision = Args[FS.getPrecision().getArgIndex()];
 118       }
 119       break;
 120     }
 121     if (FS.getFieldWidth().hasDataArgument()) {
 122       ArgsData.back().FieldWidth = Args[FS.getFieldWidth().getArgIndex()];
 123     }
 124
 125     if (FS.isSensitive())
 126       ArgsData.back().Flags |= OSLogBufferItem::IsSensitive;
 127     else if (FS.isPrivate())
 128       ArgsData.back().Flags |= OSLogBufferItem::IsPrivate;
 129     else if (FS.isPublic())
 130       ArgsData.back().Flags |= OSLogBufferItem::IsPublic;
 131
 132     ArgsData.back().MaskType = FS.getMaskType();
 133     return true;
 134   }
 135
 136   void computeLayout(ASTContext &Ctx, OSLogBufferLayout &Layout) const {
 137     Layout.Items.clear();
 138     for (auto &Data : ArgsData) {
 139       if (!Data.MaskType.empty()) {
 140         CharUnits Size = CharUnits::fromQuantity(8);
 141         Layout.Items.emplace_back(OSLogBufferItem::MaskKind, nullptr,
 142                                   Size, 0, Data.MaskType);
 143       }
 144
 145       if (Data.FieldWidth) {
 146         CharUnits Size = Ctx.getTypeSizeInChars((*Data.FieldWidth)->getType());
 147         Layout.Items.emplace_back(OSLogBufferItem::ScalarKind, *Data.FieldWidth,
 148                                   Size, 0);
 149       }
 150       if (Data.Precision) {
 151         CharUnits Size = Ctx.getTypeSizeInChars((*Data.Precision)->getType());
 152         Layout.Items.emplace_back(OSLogBufferItem::ScalarKind, *Data.Precision,
 153                                   Size, 0);
 154       }
 155       if (Data.Count) {
 156         // "%.*P" has an extra "count" that we insert before the argument.
 157         CharUnits Size = Ctx.getTypeSizeInChars((*Data.Count)->getType());
 158         Layout.Items.emplace_back(OSLogBufferItem::CountKind, *Data.Count, Size,
 159                                   0);
 160       }
 161       if (Data.Size)
 162         Layout.Items.emplace_back(Ctx, CharUnits::fromQuantity(*Data.Size),
 163                                   Data.Flags);
 164       if (Data.Kind) {
 165         CharUnits Size;
 166         if (*Data.Kind == OSLogBufferItem::ErrnoKind)
 167           Size = CharUnits::Zero();
 168         else
 169           Size = Ctx.getTypeSizeInChars(Data.E->getType());
 170         Layout.Items.emplace_back(*Data.Kind, Data.E, Size, Data.Flags);
 171       } else {
 172         auto Size = Ctx.getTypeSizeInChars(Data.E->getType());
 173         Layout.Items.emplace_back(OSLogBufferItem::ScalarKind, Data.E, Size,
 174                                   Data.Flags);
 175       }
 176     }
 177   }
 178 };
 179 } // end anonymous namespace
 180
 181 bool clang::analyze_os_log::computeOSLogBufferLayout(
 182     ASTContext &Ctx, const CallExpr *E, OSLogBufferLayout &Layout) {
 183   ArrayRef<const Expr *> Args(E->getArgs(), E->getArgs() + E->getNumArgs());
 184
 185   const Expr *StringArg;
 186   ArrayRef<const Expr *> VarArgs;
 187   switch (E->getBuiltinCallee()) {
 188   case Builtin::BI__builtin_os_log_format_buffer_size:
 189     assert(E->getNumArgs() >= 1 &&
 190            "__builtin_os_log_format_buffer_size takes at least 1 argument");
 191     StringArg = E->getArg(0);
 192     VarArgs = Args.slice(1);
 193     break;
 194   case Builtin::BI__builtin_os_log_format:
 195     assert(E->getNumArgs() >= 2 &&
 196            "__builtin_os_log_format takes at least 2 arguments");
 197     StringArg = E->getArg(1);
 198     VarArgs = Args.slice(2);
 199     break;
 200   default:
 201     llvm_unreachable("non-os_log builtin passed to computeOSLogBufferLayout");
 202   }
 203
 204   const StringLiteral *Lit = cast<StringLiteral>(StringArg->IgnoreParenCasts());
 205   assert(Lit && (Lit->isOrdinary() || Lit->isUTF8()));
 206   StringRef Data = Lit->getString();
 207   OSLogFormatStringHandler H(VarArgs);
 208   ParsePrintfString(H, Data.begin(), Data.end(), Ctx.getLangOpts(),
 209                     Ctx.getTargetInfo(), /*isFreeBSDKPrintf*/ false);
 210
 211   H.computeLayout(Ctx, Layout);
 212   return true;
 213 }