Bug Summary

File:tools/clang/lib/Format/FormatToken.cpp
Location:line 150, column 12
Description:Access to field 'HasUnescapedNewline' results in a dereference of a null pointer (loaded from variable 'ItemBegin')

Annotated Source Code

1//===--- FormatToken.cpp - Format C++ code --------------------------------===//
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/// \file
11/// \brief This file implements specific functions of \c FormatTokens and their
12/// roles.
13///
14//===----------------------------------------------------------------------===//
15
16#include "FormatToken.h"
17#include "ContinuationIndenter.h"
18#include "clang/Format/Format.h"
19#include "llvm/ADT/SmallVector.h"
20#include "llvm/Support/Debug.h"
21
22namespace clang {
23namespace format {
24
25// FIXME: This is copy&pasted from Sema. Put it in a common place and remove
26// duplication.
27bool FormatToken::isSimpleTypeSpecifier() const {
28 switch (Tok.getKind()) {
29 case tok::kw_short:
30 case tok::kw_long:
31 case tok::kw___int64:
32 case tok::kw___int128:
33 case tok::kw_signed:
34 case tok::kw_unsigned:
35 case tok::kw_void:
36 case tok::kw_char:
37 case tok::kw_int:
38 case tok::kw_half:
39 case tok::kw_float:
40 case tok::kw_double:
41 case tok::kw_wchar_t:
42 case tok::kw_bool:
43 case tok::kw___underlying_type:
44 case tok::annot_typename:
45 case tok::kw_char16_t:
46 case tok::kw_char32_t:
47 case tok::kw_typeof:
48 case tok::kw_decltype:
49 return true;
50 default:
51 return false;
52 }
53}
54
55TokenRole::~TokenRole() {}
56
57void TokenRole::precomputeFormattingInfos(const FormatToken *Token) {}
58
59unsigned CommaSeparatedList::formatAfterToken(LineState &State,
60 ContinuationIndenter *Indenter,
61 bool DryRun) {
62 if (!State.NextToken->Previous || !State.NextToken->Previous->Previous)
63 return 0;
64
65 // Ensure that we start on the opening brace.
66 const FormatToken *LBrace = State.NextToken->Previous->Previous;
67 if (LBrace->isNot(tok::l_brace) || LBrace->BlockKind == BK_Block ||
68 LBrace->Type == TT_DictLiteral ||
69 LBrace->Next->Type == TT_DesignatedInitializerPeriod)
70 return 0;
71
72 // Calculate the number of code points we have to format this list. As the
73 // first token is already placed, we have to subtract it.
74 unsigned RemainingCodePoints =
75 Style.ColumnLimit - State.Column + State.NextToken->Previous->ColumnWidth;
76
77 // Find the best ColumnFormat, i.e. the best number of columns to use.
78 const ColumnFormat *Format = getColumnFormat(RemainingCodePoints);
79 // If no ColumnFormat can be used, the braced list would generally be
80 // bin-packed. Add a severe penalty to this so that column layouts are
81 // preferred if possible.
82 if (!Format)
83 return 10000;
84
85 // Format the entire list.
86 unsigned Penalty = 0;
87 unsigned Column = 0;
88 unsigned Item = 0;
89 while (State.NextToken != LBrace->MatchingParen) {
90 bool NewLine = false;
91 unsigned ExtraSpaces = 0;
92
93 // If the previous token was one of our commas, we are now on the next item.
94 if (Item < Commas.size() && State.NextToken->Previous == Commas[Item]) {
95 if (!State.NextToken->isTrailingComment()) {
96 ExtraSpaces += Format->ColumnSizes[Column] - ItemLengths[Item];
97 ++Column;
98 }
99 ++Item;
100 }
101
102 if (Column == Format->Columns || State.NextToken->MustBreakBefore) {
103 Column = 0;
104 NewLine = true;
105 }
106
107 // Place token using the continuation indenter and store the penalty.
108 Penalty += Indenter->addTokenToState(State, NewLine, DryRun, ExtraSpaces);
109 }
110 return Penalty;
111}
112
113unsigned CommaSeparatedList::formatFromToken(LineState &State,
114 ContinuationIndenter *Indenter,
115 bool DryRun) {
116 if (HasNestedBracedList)
117 State.Stack.back().AvoidBinPacking = true;
118 return 0;
119}
120
121// Returns the lengths in code points between Begin and End (both included),
122// assuming that the entire sequence is put on a single line.
123static unsigned CodePointsBetween(const FormatToken *Begin,
124 const FormatToken *End) {
125 assert(End->TotalLength >= Begin->TotalLength)((End->TotalLength >= Begin->TotalLength) ? static_cast
<void> (0) : __assert_fail ("End->TotalLength >= Begin->TotalLength"
, "/tmp/buildd/llvm-toolchain-snapshot-3.6~svn216889/tools/clang/lib/Format/FormatToken.cpp"
, 125, __PRETTY_FUNCTION__));
126 return End->TotalLength - Begin->TotalLength + Begin->ColumnWidth;
127}
128
129void CommaSeparatedList::precomputeFormattingInfos(const FormatToken *Token) {
130 // FIXME: At some point we might want to do this for other lists, too.
131 if (!Token->MatchingParen || Token->isNot(tok::l_brace))
1
Taking false branch
→
132 return;
133
134 // In C++11 braced list style, we should not format in columns unless they
135 // have many items (20 or more) or we allow bin-packing of function
136 // parameters.
137 if (Style.Cpp11BracedListStyle && !Style.BinPackParameters &&
138 Commas.size() < 19)
139 return;
140
141 FormatToken *ItemBegin = Token->Next;
142 SmallVector<bool, 8> MustBreakBeforeItem;
143
144 // The lengths of an item if it is put at the end of the line. This includes
145 // trailing comments which are otherwise ignored for column alignment.
146 SmallVector<unsigned, 8> EndOfLineItemLength;
147
148 for (unsigned i = 0, e = Commas.size() + 1; i != e; ++i) {
2
←
Assuming 'i' is not equal to 'e'
→
3
←
Loop condition is true. Entering loop body
→
9
←
Assuming 'i' is not equal to 'e'
→
10
←
Loop condition is true. Entering loop body
→
149 // Skip comments on their own line.
150 while (ItemBegin->HasUnescapedNewline && ItemBegin->isTrailingComment())
11
←
Access to field 'HasUnescapedNewline' results in a dereference of a null pointer (loaded from variable 'ItemBegin')
151 ItemBegin = ItemBegin->Next;
152
153 MustBreakBeforeItem.push_back(ItemBegin->MustBreakBefore);
154 if (ItemBegin->is(tok::l_brace))
4
←
Taking false branch
→
155 HasNestedBracedList = true;
156 const FormatToken *ItemEnd = nullptr;
157 if (i == Commas.size()) {
5
←
Taking false branch
→
158 ItemEnd = Token->MatchingParen;
159 const FormatToken *NonCommentEnd = ItemEnd->getPreviousNonComment();
160 ItemLengths.push_back(CodePointsBetween(ItemBegin, NonCommentEnd));
161 if (Style.Cpp11BracedListStyle) {
162 // In Cpp11 braced list style, the } and possibly other subsequent
163 // tokens will need to stay on a line with the last element.
164 while (ItemEnd->Next && !ItemEnd->Next->CanBreakBefore)
165 ItemEnd = ItemEnd->Next;
166 } else {
167 // In other braced lists styles, the "}" can be wrapped to the new line.
168 ItemEnd = Token->MatchingParen->Previous;
169 }
170 } else {
171 ItemEnd = Commas[i];
172 // The comma is counted as part of the item when calculating the length.
173 ItemLengths.push_back(CodePointsBetween(ItemBegin, ItemEnd));
174 // Consume trailing comments so the are included in EndOfLineItemLength.
175 if (ItemEnd->Next && !ItemEnd->Next->HasUnescapedNewline &&
6
←
Assuming pointer value is null
→
176 ItemEnd->Next->isTrailingComment())
177 ItemEnd = ItemEnd->Next;
178 }
179 EndOfLineItemLength.push_back(CodePointsBetween(ItemBegin, ItemEnd));
180 // If there is a trailing comma in the list, the next item will start at the
181 // closing brace. Don't create an extra item for this.
182 if (ItemEnd->getNextNonComment() == Token->MatchingParen)
7
←
Taking false branch
→
183 break;
184 ItemBegin = ItemEnd->Next;
8
←
Null pointer value stored to 'ItemBegin'
→
185 }
186
187 // If this doesn't have a nested list, we require at least 6 elements in order
188 // create a column layout. If it has a nested list, column layout ensures one
189 // list element per line.
190 if (HasNestedBracedList || Commas.size() < 5 || Token->NestingLevel != 0)
191 return;
192
193 // We can never place more than ColumnLimit / 3 items in a row (because of the
194 // spaces and the comma).
195 for (unsigned Columns = 1; Columns <= Style.ColumnLimit / 3; ++Columns) {
196 ColumnFormat Format;
197 Format.Columns = Columns;
198 Format.ColumnSizes.resize(Columns);
199 Format.LineCount = 1;
200 bool HasRowWithSufficientColumns = false;
201 unsigned Column = 0;
202 for (unsigned i = 0, e = ItemLengths.size(); i != e; ++i) {
203 assert(i < MustBreakBeforeItem.size())((i < MustBreakBeforeItem.size()) ? static_cast<void>
(0) : __assert_fail ("i < MustBreakBeforeItem.size()", "/tmp/buildd/llvm-toolchain-snapshot-3.6~svn216889/tools/clang/lib/Format/FormatToken.cpp"
, 203, __PRETTY_FUNCTION__));
204 if (MustBreakBeforeItem[i] || Column == Columns) {
205 ++Format.LineCount;
206 Column = 0;
207 }
208 if (Column == Columns - 1)
209 HasRowWithSufficientColumns = true;
210 unsigned length =
211 (Column == Columns - 1) ? EndOfLineItemLength[i] : ItemLengths[i];
212 Format.ColumnSizes[Column] = std::max(Format.ColumnSizes[Column], length);
213 ++Column;
214 }
215 // If all rows are terminated early (e.g. by trailing comments), we don't
216 // need to look further.
217 if (!HasRowWithSufficientColumns)
218 break;
219 Format.TotalWidth = Columns - 1; // Width of the N-1 spaces.
220 for (unsigned i = 0; i < Columns; ++i) {
221 Format.TotalWidth += Format.ColumnSizes[i];
222 }
223
224 // Ignore layouts that are bound to violate the column limit.
225 if (Format.TotalWidth > Style.ColumnLimit)
226 continue;
227
228 Formats.push_back(Format);
229 }
230}
231
232const CommaSeparatedList::ColumnFormat *
233CommaSeparatedList::getColumnFormat(unsigned RemainingCharacters) const {
234 const ColumnFormat *BestFormat = nullptr;
235 for (SmallVector<ColumnFormat, 4>::const_reverse_iterator
236 I = Formats.rbegin(),
237 E = Formats.rend();
238 I != E; ++I) {
239 if (I->TotalWidth <= RemainingCharacters) {
240 if (BestFormat && I->LineCount > BestFormat->LineCount)
241 break;
242 BestFormat = &*I;
243 }
244 }
245 return BestFormat;
246}
247
248} // namespace format
249} // namespace clang