LLVM  10.0.0svn
MsgPackWriter.cpp
Go to the documentation of this file.
1 //===- MsgPackWriter.cpp - Simple MsgPack writer ----------------*- 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 /// This file implements a MessagePack writer.
11 ///
12 //===----------------------------------------------------------------------===//
13 
16 
17 using namespace llvm;
18 using namespace msgpack;
19 
20 Writer::Writer(raw_ostream &OS, bool Compatible)
21  : EW(OS, Endianness), Compatible(Compatible) {}
22 
23 void Writer::writeNil() { EW.write(FirstByte::Nil); }
24 
25 void Writer::write(bool b) { EW.write(b ? FirstByte::True : FirstByte::False); }
26 
27 void Writer::write(int64_t i) {
28  if (i >= 0) {
29  write(static_cast<uint64_t>(i));
30  return;
31  }
32 
33  if (i >= FixMin::NegativeInt) {
34  EW.write(static_cast<int8_t>(i));
35  return;
36  }
37 
38  if (i >= INT8_MIN) {
39  EW.write(FirstByte::Int8);
40  EW.write(static_cast<int8_t>(i));
41  return;
42  }
43 
44  if (i >= INT16_MIN) {
45  EW.write(FirstByte::Int16);
46  EW.write(static_cast<int16_t>(i));
47  return;
48  }
49 
50  if (i >= INT32_MIN) {
51  EW.write(FirstByte::Int32);
52  EW.write(static_cast<int32_t>(i));
53  return;
54  }
55 
56  EW.write(FirstByte::Int64);
57  EW.write(i);
58 }
59 
60 void Writer::write(uint64_t u) {
61  if (u <= FixMax::PositiveInt) {
62  EW.write(static_cast<uint8_t>(u));
63  return;
64  }
65 
66  if (u <= UINT8_MAX) {
67  EW.write(FirstByte::UInt8);
68  EW.write(static_cast<uint8_t>(u));
69  return;
70  }
71 
72  if (u <= UINT16_MAX) {
73  EW.write(FirstByte::UInt16);
74  EW.write(static_cast<uint16_t>(u));
75  return;
76  }
77 
78  if (u <= UINT32_MAX) {
79  EW.write(FirstByte::UInt32);
80  EW.write(static_cast<uint32_t>(u));
81  return;
82  }
83 
84  EW.write(FirstByte::UInt64);
85  EW.write(u);
86 }
87 
88 void Writer::write(double d) {
89  // If no loss of precision, encode as a Float32.
90  double a = std::fabs(d);
91  if (a >= std::numeric_limits<float>::min() &&
93  EW.write(FirstByte::Float32);
94  EW.write(static_cast<float>(d));
95  } else {
96  EW.write(FirstByte::Float64);
97  EW.write(d);
98  }
99 }
100 
102  size_t Size = s.size();
103 
104  if (Size <= FixMax::String)
105  EW.write(static_cast<uint8_t>(FixBits::String | Size));
106  else if (!Compatible && Size <= UINT8_MAX) {
107  EW.write(FirstByte::Str8);
108  EW.write(static_cast<uint8_t>(Size));
109  } else if (Size <= UINT16_MAX) {
110  EW.write(FirstByte::Str16);
111  EW.write(static_cast<uint16_t>(Size));
112  } else {
113  assert(Size <= UINT32_MAX && "String object too long to be encoded");
114  EW.write(FirstByte::Str32);
115  EW.write(static_cast<uint32_t>(Size));
116  }
117 
118  EW.OS << s;
119 }
120 
122  assert(!Compatible && "Attempt to write Bin format in compatible mode");
123 
124  size_t Size = Buffer.getBufferSize();
125 
126  if (Size <= UINT8_MAX) {
127  EW.write(FirstByte::Bin8);
128  EW.write(static_cast<uint8_t>(Size));
129  } else if (Size <= UINT16_MAX) {
130  EW.write(FirstByte::Bin16);
131  EW.write(static_cast<uint16_t>(Size));
132  } else {
133  assert(Size <= UINT32_MAX && "Binary object too long to be encoded");
134  EW.write(FirstByte::Bin32);
135  EW.write(static_cast<uint32_t>(Size));
136  }
137 
138  EW.OS.write(Buffer.getBufferStart(), Size);
139 }
140 
142  if (Size <= FixMax::Array) {
143  EW.write(static_cast<uint8_t>(FixBits::Array | Size));
144  return;
145  }
146 
147  if (Size <= UINT16_MAX) {
148  EW.write(FirstByte::Array16);
149  EW.write(static_cast<uint16_t>(Size));
150  return;
151  }
152 
153  EW.write(FirstByte::Array32);
154  EW.write(Size);
155 }
156 
158  if (Size <= FixMax::Map) {
159  EW.write(static_cast<uint8_t>(FixBits::Map | Size));
160  return;
161  }
162 
163  if (Size <= UINT16_MAX) {
164  EW.write(FirstByte::Map16);
165  EW.write(static_cast<uint16_t>(Size));
166  return;
167  }
168 
169  EW.write(FirstByte::Map32);
170  EW.write(Size);
171 }
172 
173 void Writer::writeExt(int8_t Type, MemoryBufferRef Buffer) {
174  size_t Size = Buffer.getBufferSize();
175 
176  switch (Size) {
177  case FixLen::Ext1:
178  EW.write(FirstByte::FixExt1);
179  break;
180  case FixLen::Ext2:
181  EW.write(FirstByte::FixExt2);
182  break;
183  case FixLen::Ext4:
184  EW.write(FirstByte::FixExt4);
185  break;
186  case FixLen::Ext8:
187  EW.write(FirstByte::FixExt8);
188  break;
189  case FixLen::Ext16:
190  EW.write(FirstByte::FixExt16);
191  break;
192  default:
193  if (Size <= UINT8_MAX) {
194  EW.write(FirstByte::Ext8);
195  EW.write(static_cast<uint8_t>(Size));
196  } else if (Size <= UINT16_MAX) {
197  EW.write(FirstByte::Ext16);
198  EW.write(static_cast<uint16_t>(Size));
199  } else {
200  assert(Size <= UINT32_MAX && "Ext size too large to be encoded");
201  EW.write(FirstByte::Ext32);
202  EW.write(static_cast<uint32_t>(Size));
203  }
204  }
205 
206  EW.write(Type);
207  EW.OS.write(Buffer.getBufferStart(), Size);
208 }
Type
MessagePack types as defined in the standard, with the exception of Integer being divided into a sign...
Definition: MsgPackReader.h:48
GCNRegPressure max(const GCNRegPressure &P1, const GCNRegPressure &P2)
This class represents lattice values for constants.
Definition: AllocatorList.h:23
void writeExt(int8_t Type, MemoryBufferRef Buffer)
Write a typed memory buffer (an extension type) to the output stream.
constexpr support::endianness Endianness
The endianness of all multi-byte encoded values in MessagePack.
Definition: MsgPack.h:24
void writeMapSize(uint32_t Size)
Write the header for a Map of the given size.
Writer(raw_ostream &OS, bool Compatible=false)
Construct a writer, optionally enabling "Compatibility Mode" as defined in the MessagePack specificat...
LLVM_NODISCARD size_t size() const
size - Get the string size.
Definition: StringRef.h:130
void writeNil()
Write a Nil to the output stream.
size_t getBufferSize() const
Definition: MemoryBuffer.h:278
void writeArraySize(uint32_t Size)
Write the header for an Array of the given size.
static void write(bool isBE, void *P, T V)
void write(bool b)
Write a Boolean to the output stream.
uint32_t Size
Definition: Profile.cpp:46
This file contains constants used for implementing MessagePack support.
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
const char * getBufferStart() const
Definition: MemoryBuffer.h:276
This class implements an extremely fast bulk output stream that can only output to a stream...
Definition: raw_ostream.h:45
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:48
This file contains a MessagePack writer.