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