Coverage Report

Created: 2019-03-13 16:15

/Users/buildslave/jenkins/workspace/clang-stage2-coverage-R/llvm/lib/BinaryFormat/MsgPackTypes.cpp
Line
Count
Source (jump to first uncovered line)
1
//===- MsgPackTypes.cpp - MsgPack Types -------------------------*- C++ -*-===//
2
//
3
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4
// See https://llvm.org/LICENSE.txt for license information.
5
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6
//
7
//===----------------------------------------------------------------------===//
8
//
9
/// \file
10
/// Implementation of types representing MessagePack "documents".
11
//
12
//===----------------------------------------------------------------------===//
13
14
#include "llvm/BinaryFormat/MsgPackTypes.h"
15
#include "llvm/Support/Error.h"
16
17
using namespace llvm;
18
using namespace msgpack;
19
20
namespace llvm {
21
namespace msgpack {
22
0
void ScalarNode::anchor() {}
23
0
void ArrayNode::anchor() {}
24
0
void MapNode::anchor() {}
25
}
26
}
27
28
275
Expected<OptNodePtr> Node::readArray(Reader &MPReader, size_t Length) {
29
275
  auto A = std::make_shared<ArrayNode>();
30
1.65k
  for (size_t I = 0; I < Length; 
++I1.37k
) {
31
1.37k
    auto OptNodeOrErr = Node::read(MPReader);
32
1.37k
    if (auto Err = OptNodeOrErr.takeError())
33
0
      return std::move(Err);
34
1.37k
    if (!*OptNodeOrErr)
35
0
      return make_error<StringError>(
36
0
          "Insufficient array elements",
37
0
          std::make_error_code(std::errc::invalid_argument));
38
1.37k
    A->push_back(std::move(**OptNodeOrErr));
39
1.37k
  }
40
275
  return OptNodePtr(std::move(A));
41
275
}
42
43
1.12k
Expected<OptNodePtr> Node::readMap(Reader &MPReader, size_t Length) {
44
1.12k
  auto M = std::make_shared<MapNode>();
45
7.94k
  for (size_t I = 0; I < Length; 
++I6.82k
) {
46
6.82k
    auto OptKeyOrErr = Node::read(MPReader);
47
6.82k
    if (auto Err = OptKeyOrErr.takeError())
48
0
      return std::move(Err);
49
6.82k
    if (!*OptKeyOrErr)
50
0
      return make_error<StringError>(
51
0
          "Insufficient map elements",
52
0
          std::make_error_code(std::errc::invalid_argument));
53
6.82k
    auto OptValOrErr = Node::read(MPReader);
54
6.82k
    if (auto Err = OptValOrErr.takeError())
55
0
      return std::move(Err);
56
6.82k
    if (!*OptValOrErr)
57
0
      return make_error<StringError>(
58
0
          "Insufficient map elements",
59
0
          std::make_error_code(std::errc::invalid_argument));
60
6.82k
    auto *Key = dyn_cast<ScalarNode>((*OptKeyOrErr)->get());
61
6.82k
    if (!Key)
62
0
      return make_error<StringError>(
63
0
          "Only string map keys are supported",
64
0
          std::make_error_code(std::errc::invalid_argument));
65
6.82k
    if (Key->getScalarKind() != ScalarNode::SK_String)
66
0
      return make_error<StringError>(
67
0
          "Only string map keys are supported",
68
0
          std::make_error_code(std::errc::invalid_argument));
69
6.82k
    M->try_emplace(Key->getString(), std::move(**OptValOrErr));
70
6.82k
  }
71
1.12k
  return OptNodePtr(std::move(M));
72
1.12k
}
73
74
15.0k
Expected<OptNodePtr> Node::read(Reader &MPReader) {
75
15.0k
  Object Obj;
76
15.0k
77
15.0k
  auto ContinueOrErr = MPReader.read(Obj);
78
15.0k
  if (auto Err = ContinueOrErr.takeError())
79
0
    return std::move(Err);
80
15.0k
  if (!*ContinueOrErr)
81
0
    return None;
82
15.0k
83
15.0k
  switch (Obj.Kind) {
84
15.0k
  case Type::Int:
85
4
    return OptNodePtr(std::make_shared<ScalarNode>(Obj.Int));
86
15.0k
  case Type::UInt:
87
3.46k
    return OptNodePtr(std::make_shared<ScalarNode>(Obj.UInt));
88
15.0k
  case Type::Nil:
89
1
    return OptNodePtr(std::make_shared<ScalarNode>());
90
15.0k
  case Type::Boolean:
91
14
    return OptNodePtr(std::make_shared<ScalarNode>(Obj.Bool));
92
15.0k
  case Type::Float:
93
0
    return OptNodePtr(std::make_shared<ScalarNode>(Obj.Float));
94
15.0k
  case Type::String:
95
10.1k
    return OptNodePtr(std::make_shared<ScalarNode>(Obj.Raw));
96
15.0k
  case Type::Binary:
97
0
    return OptNodePtr(std::make_shared<ScalarNode>(Obj.Raw));
98
15.0k
  case Type::Array:
99
275
    return Node::readArray(MPReader, Obj.Length);
100
15.0k
  case Type::Map:
101
1.12k
    return Node::readMap(MPReader, Obj.Length);
102
15.0k
  case Type::Extension:
103
0
    return make_error<StringError>(
104
0
        "Extension types are not supported",
105
0
        std::make_error_code(std::errc::invalid_argument));
106
0
  }
107
0
  llvm_unreachable("msgpack::Type not handled");
108
0
}
109
110
83.9k
void ScalarNode::destroy() {
111
83.9k
  switch (SKind) {
112
83.9k
  case SK_String:
113
37.5k
  case SK_Binary:
114
37.5k
    StringValue.~basic_string();
115
37.5k
    break;
116
46.4k
  default:
117
46.4k
    // POD types do not require destruction
118
46.4k
    break;
119
83.9k
  }
120
83.9k
}
121
122
ScalarNode::ScalarNode(int64_t IntValue)
123
11
    : Node(NK_Scalar), SKind(SK_Int), IntValue(IntValue) {}
124
125
ScalarNode::ScalarNode(int32_t IntValue)
126
0
    : ScalarNode(static_cast<int64_t>(IntValue)) {}
Unexecuted instantiation: llvm::msgpack::ScalarNode::ScalarNode(int)
Unexecuted instantiation: llvm::msgpack::ScalarNode::ScalarNode(int)
127
128
ScalarNode::ScalarNode(uint64_t UIntValue)
129
37.5k
    : Node(NK_Scalar), SKind(SK_UInt), UIntValue(UIntValue) {}
130
131
ScalarNode::ScalarNode(uint32_t IntValue)
132
23.4k
    : ScalarNode(static_cast<uint64_t>(IntValue)) {}
Unexecuted instantiation: llvm::msgpack::ScalarNode::ScalarNode(unsigned int)
llvm::msgpack::ScalarNode::ScalarNode(unsigned int)
Line
Count
Source
132
23.4k
    : ScalarNode(static_cast<uint64_t>(IntValue)) {}
133
134
5.75k
ScalarNode::ScalarNode() : Node(NK_Scalar), SKind(SK_Nil) {}
135
136
ScalarNode::ScalarNode(bool BoolValue)
137
53
    : Node(NK_Scalar), SKind(SK_Boolean), BoolValue(BoolValue) {}
138
139
ScalarNode::ScalarNode(double FloatValue)
140
0
    : Node(NK_Scalar), SKind(SK_Float), BoolValue(FloatValue) {}
141
142
ScalarNode::ScalarNode(StringRef StringValue)
143
32.6k
    : Node(NK_Scalar), SKind(SK_String) {
144
32.6k
  new (&this->StringValue) std::string(StringValue);
145
32.6k
}
146
147
ScalarNode::ScalarNode(const char *StringValue)
148
219
    : ScalarNode(StringRef(StringValue)) {}
Unexecuted instantiation: llvm::msgpack::ScalarNode::ScalarNode(char const*)
llvm::msgpack::ScalarNode::ScalarNode(char const*)
Line
Count
Source
148
219
    : ScalarNode(StringRef(StringValue)) {}
149
150
ScalarNode::ScalarNode(std::string &&StringValue)
151
2.03k
    : Node(NK_Scalar), SKind(SK_String) {
152
2.03k
  new (&this->StringValue) std::string(StringValue);
153
2.03k
}
154
155
ScalarNode::ScalarNode(MemoryBufferRef BinaryValue)
156
0
    : Node(NK_Scalar), SKind(SK_Binary) {
157
0
  new (&StringValue) std::string(BinaryValue.getBuffer());
158
0
}
159
160
78.0k
ScalarNode::~ScalarNode() { destroy(); }
161
162
5.94k
ScalarNode &ScalarNode::operator=(ScalarNode &&RHS) {
163
5.94k
  destroy();
164
5.94k
  switch (SKind = RHS.SKind) {
165
5.94k
  case SK_Int:
166
0
    IntValue = RHS.IntValue;
167
0
    break;
168
5.94k
  case SK_UInt:
169
3.07k
    UIntValue = RHS.UIntValue;
170
3.07k
    break;
171
5.94k
  case SK_Boolean:
172
12
    BoolValue = RHS.BoolValue;
173
12
    break;
174
5.94k
  case SK_Float:
175
0
    FloatValue = RHS.FloatValue;
176
0
    break;
177
5.94k
  case SK_String:
178
2.86k
  case SK_Binary:
179
2.86k
    new (&StringValue) std::string(std::move(RHS.StringValue));
180
2.86k
    break;
181
2.86k
  case SK_Nil:
182
0
    // pass
183
0
    break;
184
5.94k
  }
185
5.94k
  return *this;
186
5.94k
}
187
188
5.94k
StringRef ScalarNode::inputYAML(StringRef ScalarStr) {
189
5.94k
  switch (SKind) {
190
5.94k
  case SK_Int:
191
0
    return yaml::ScalarTraits<int64_t>::input(ScalarStr, nullptr, IntValue);
192
5.94k
  case SK_UInt:
193
3.07k
    return yaml::ScalarTraits<uint64_t>::input(ScalarStr, nullptr, UIntValue);
194
5.94k
  case SK_Nil:
195
0
    return StringRef();
196
5.94k
  case SK_Boolean:
197
12
    return yaml::ScalarTraits<bool>::input(ScalarStr, nullptr, BoolValue);
198
5.94k
  case SK_Float:
199
0
    return yaml::ScalarTraits<double>::input(ScalarStr, nullptr, FloatValue);
200
5.94k
  case SK_Binary:
201
2.86k
  case SK_String:
202
2.86k
    return yaml::ScalarTraits<std::string>::input(ScalarStr, nullptr,
203
2.86k
                                                  StringValue);
204
0
  }
205
0
  llvm_unreachable("unrecognized ScalarKind");
206
0
}
207
208
105k
void ScalarNode::outputYAML(raw_ostream &OS) const {
209
105k
  switch (SKind) {
210
105k
  case SK_Int:
211
3
    yaml::ScalarTraits<int64_t>::output(IntValue, nullptr, OS);
212
3
    break;
213
105k
  case SK_UInt:
214
61.9k
    yaml::ScalarTraits<uint64_t>::output(UIntValue, nullptr, OS);
215
61.9k
    break;
216
105k
  case SK_Nil:
217
0
    yaml::ScalarTraits<StringRef>::output("", nullptr, OS);
218
0
    break;
219
105k
  case SK_Boolean:
220
53
    yaml::ScalarTraits<bool>::output(BoolValue, nullptr, OS);
221
53
    break;
222
105k
  case SK_Float:
223
0
    yaml::ScalarTraits<double>::output(FloatValue, nullptr, OS);
224
0
    break;
225
105k
  case SK_Binary:
226
43.1k
  case SK_String:
227
43.1k
    yaml::ScalarTraits<std::string>::output(StringValue, nullptr, OS);
228
43.1k
    break;
229
105k
  }
230
105k
}
231
232
105k
yaml::QuotingType ScalarNode::mustQuoteYAML(StringRef ScalarStr) const {
233
105k
  switch (SKind) {
234
105k
  case SK_Int:
235
3
    return yaml::ScalarTraits<int64_t>::mustQuote(ScalarStr);
236
105k
  case SK_UInt:
237
61.9k
    return yaml::ScalarTraits<uint64_t>::mustQuote(ScalarStr);
238
105k
  case SK_Nil:
239
0
    return yaml::ScalarTraits<StringRef>::mustQuote(ScalarStr);
240
105k
  case SK_Boolean:
241
53
    return yaml::ScalarTraits<bool>::mustQuote(ScalarStr);
242
105k
  case SK_Float:
243
0
    return yaml::ScalarTraits<double>::mustQuote(ScalarStr);
244
105k
  case SK_Binary:
245
43.1k
  case SK_String:
246
43.1k
    return yaml::ScalarTraits<std::string>::mustQuote(ScalarStr);
247
0
  }
248
0
  llvm_unreachable("unrecognized ScalarKind");
249
0
}
250
251
const char *ScalarNode::IntTag = "!int";
252
const char *ScalarNode::NilTag = "!nil";
253
const char *ScalarNode::BooleanTag = "!bool";
254
const char *ScalarNode::FloatTag = "!float";
255
const char *ScalarNode::StringTag = "!str";
256
const char *ScalarNode::BinaryTag = "!bin";
257
258
58.1k
StringRef ScalarNode::getYAMLTag() const {
259
58.1k
  switch (SKind) {
260
58.1k
  case SK_Int:
261
3
    return IntTag;
262
58.1k
  case SK_UInt:
263
33.9k
    return IntTag;
264
58.1k
  case SK_Nil:
265
0
    return NilTag;
266
58.1k
  case SK_Boolean:
267
39
    return BooleanTag;
268
58.1k
  case SK_Float:
269
0
    return FloatTag;
270
58.1k
  case SK_String:
271
24.1k
    return StringTag;
272
58.1k
  case SK_Binary:
273
0
    return BinaryTag;
274
0
  }
275
0
  llvm_unreachable("unrecognized ScalarKind");
276
0
}
277
278
12.7k
void ScalarNode::write(Writer &MPWriter) {
279
12.7k
  switch (SKind) {
280
12.7k
  case SK_Int:
281
4
    MPWriter.write(IntValue);
282
4
    break;
283
12.7k
  case SK_UInt:
284
6.61k
    MPWriter.write(UIntValue);
285
6.61k
    break;
286
12.7k
  case SK_Nil:
287
1
    MPWriter.writeNil();
288
1
    break;
289
12.7k
  case SK_Boolean:
290
26
    MPWriter.write(BoolValue);
291
26
    break;
292
12.7k
  case SK_Float:
293
0
    MPWriter.write(FloatValue);
294
0
    break;
295
12.7k
  case SK_String:
296
6.09k
    MPWriter.write(StringValue);
297
6.09k
    break;
298
12.7k
  case SK_Binary:
299
0
    MPWriter.write(MemoryBufferRef(StringValue, ""));
300
0
    break;
301
12.7k
  }
302
12.7k
}