clang  6.0.0svn
OSLog.h
Go to the documentation of this file.
1 //= OSLog.h - Analysis of calls to os_log builtins --*- 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 // This file defines APIs for determining the layout of the data buffer for
11 // os_log() and os_trace().
12 //
13 //===----------------------------------------------------------------------===//
14 
15 #ifndef LLVM_CLANG_ANALYSIS_ANALYSES_OSLOG_H
16 #define LLVM_CLANG_ANALYSIS_ANALYSES_OSLOG_H
17 
18 #include "clang/AST/ASTContext.h"
19 #include "clang/AST/Expr.h"
20 
21 namespace clang {
22 namespace analyze_os_log {
23 
24 /// An OSLogBufferItem represents a single item in the data written by a call
25 /// to os_log() or os_trace().
27 public:
28  enum Kind {
29  // The item is a scalar (int, float, raw pointer, etc.). No further copying
30  // is required. This is the only kind allowed by os_trace().
32 
33  // The item is a count, which describes the length of the following item to
34  // be copied. A count may only be followed by an item of kind StringKind,
35  // WideStringKind, or PointerKind.
37 
38  // The item is a pointer to a C string. If preceded by a count 'n',
39  // os_log() will copy at most 'n' bytes from the pointer.
41 
42  // The item is a pointer to a block of raw data. This item must be preceded
43  // by a count 'n'. os_log() will copy exactly 'n' bytes from the pointer.
45 
46  // The item is a pointer to an Objective-C object. os_log() may retain the
47  // object for later processing.
49 
50  // The item is a pointer to wide-char string.
52 
53  // The item is corresponding to the '%m' format specifier, no value is
54  // populated in the buffer and the runtime is loading the errno value.
56  };
57 
58  enum {
59  // The item is marked "private" in the format string.
60  IsPrivate = 0x1,
61 
62  // The item is marked "public" in the format string.
63  IsPublic = 0x2
64  };
65 
66 private:
67  Kind TheKind = ScalarKind;
68  const Expr *TheExpr = nullptr;
69  CharUnits ConstValue;
70  CharUnits Size; // size of the data, not including the header bytes
71  unsigned Flags = 0;
72 
73 public:
74  OSLogBufferItem(Kind kind, const Expr *expr, CharUnits size, unsigned flags)
75  : TheKind(kind), TheExpr(expr), Size(size), Flags(flags) {}
76 
77  OSLogBufferItem(ASTContext &Ctx, CharUnits value, unsigned flags)
78  : TheKind(CountKind), ConstValue(value),
79  Size(Ctx.getTypeSizeInChars(Ctx.IntTy)), Flags(flags) {}
80 
81  unsigned char getDescriptorByte() const {
82  unsigned char result = 0;
83  if (getIsPrivate())
84  result |= IsPrivate;
85  if (getIsPublic())
86  result |= IsPublic;
87  result |= ((unsigned)getKind()) << 4;
88  return result;
89  }
90 
91  unsigned char getSizeByte() const { return size().getQuantity(); }
92 
93  Kind getKind() const { return TheKind; }
94  bool getIsPrivate() const { return (Flags & IsPrivate) != 0; }
95  bool getIsPublic() const { return (Flags & IsPublic) != 0; }
96 
97  const Expr *getExpr() const { return TheExpr; }
98  CharUnits getConstValue() const { return ConstValue; }
99  CharUnits size() const { return Size; }
100 };
101 
103 public:
105 
106  enum Flags { HasPrivateItems = 1, HasNonScalarItems = 1 << 1 };
107 
108  CharUnits size() const {
109  CharUnits result;
110  result += CharUnits::fromQuantity(2); // summary byte, num-args byte
111  for (auto &item : Items) {
112  // descriptor byte, size byte
113  result += item.size() + CharUnits::fromQuantity(2);
114  }
115  return result;
116  }
117 
118  bool hasPrivateItems() const {
119  return llvm::any_of(
120  Items, [](const OSLogBufferItem &Item) { return Item.getIsPrivate(); });
121  }
122 
123  bool hasPublicItems() const {
124  return llvm::any_of(
125  Items, [](const OSLogBufferItem &Item) { return Item.getIsPublic(); });
126  }
127 
128  bool hasNonScalar() const {
129  return llvm::any_of(Items, [](const OSLogBufferItem &Item) {
130  return Item.getKind() != OSLogBufferItem::ScalarKind;
131  });
132  }
133 
134  unsigned char getSummaryByte() const {
135  unsigned char result = 0;
136  if (hasPrivateItems())
137  result |= HasPrivateItems;
138  if (hasNonScalar())
139  result |= HasNonScalarItems;
140  return result;
141  }
142 
143  unsigned char getNumArgsByte() const { return Items.size(); }
144 };
145 
146 // Given a call 'E' to one of the builtins __builtin_os_log_format() or
147 // __builtin_os_log_format_buffer_size(), compute the layout of the buffer that
148 // the call will write into and store it in 'layout'. Returns 'false' if there
149 // was some error encountered while computing the layout, and 'true' otherwise.
151  OSLogBufferLayout &layout);
152 
153 } // namespace analyze_os_log
154 } // namespace clang
155 #endif
Defines the clang::ASTContext interface.
const internal::VariadicDynCastAllOfMatcher< Stmt, Expr > expr
Matches expressions.
Definition: ASTMatchers.h:1538
unsigned char getDescriptorByte() const
Definition: OSLog.h:81
unsigned char getSummaryByte() const
Definition: OSLog.h:134
OSLogBufferItem(ASTContext &Ctx, CharUnits value, unsigned flags)
Definition: OSLog.h:77
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
Definition: ASTContext.h:128
const Expr * getExpr() const
Definition: OSLog.h:97
unsigned char getNumArgsByte() const
Definition: OSLog.h:143
CharUnits - This is an opaque type for sizes expressed in character units.
Definition: CharUnits.h:38
bool computeOSLogBufferLayout(clang::ASTContext &Ctx, const clang::CallExpr *E, OSLogBufferLayout &layout)
Definition: OSLog.cpp:171
An OSLogBufferItem represents a single item in the data written by a call to os_log() or os_trace()...
Definition: OSLog.h:26
QuantityType getQuantity() const
getQuantity - Get the raw integer representation of this quantity.
Definition: CharUnits.h:179
Expr - This represents one expression.
Definition: Expr.h:106
unsigned char getSizeByte() const
Definition: OSLog.h:91
static CharUnits fromQuantity(QuantityType Quantity)
fromQuantity - Construct a CharUnits quantity from a raw integer type.
Definition: CharUnits.h:63
CharUnits getConstValue() const
Definition: OSLog.h:98
Dataflow Directional Tag Classes.
SmallVector< OSLogBufferItem, 4 > Items
Definition: OSLog.h:104
unsigned kind
All of the diagnostics that can be emitted by the frontend.
Definition: DiagnosticIDs.h:61
CallExpr - Represents a function call (C99 6.5.2.2, C++ [expr.call]).
Definition: Expr.h:2209
OSLogBufferItem(Kind kind, const Expr *expr, CharUnits size, unsigned flags)
Definition: OSLog.h:74