Bug Summary

File:lib/ObjectYAML/CodeViewYAMLTypes.cpp
Warning:line 773, column 3
The left operand of '==' is a garbage value

Annotated Source Code

Press '?' to see keyboard shortcuts

clang -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name CodeViewYAMLTypes.cpp -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-eagerly-assume -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -mrelocation-model pic -pic-level 2 -mthread-model posix -fmath-errno -masm-verbose -mconstructor-aliases -munwind-tables -fuse-init-array -target-cpu x86-64 -dwarf-column-info -debugger-tuning=gdb -momit-leaf-frame-pointer -ffunction-sections -fdata-sections -resource-dir /usr/lib/llvm-7/lib/clang/7.0.0 -D _DEBUG -D _GNU_SOURCE -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D __STDC_LIMIT_MACROS -I /build/llvm-toolchain-snapshot-7~svn326551/build-llvm/lib/ObjectYAML -I /build/llvm-toolchain-snapshot-7~svn326551/lib/ObjectYAML -I /build/llvm-toolchain-snapshot-7~svn326551/build-llvm/include -I /build/llvm-toolchain-snapshot-7~svn326551/include -U NDEBUG -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/7.3.0/../../../../include/c++/7.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/7.3.0/../../../../include/x86_64-linux-gnu/c++/7.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/7.3.0/../../../../include/x86_64-linux-gnu/c++/7.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/7.3.0/../../../../include/c++/7.3.0/backward -internal-isystem /usr/include/clang/7.0.0/include/ -internal-isystem /usr/local/include -internal-isystem /usr/lib/llvm-7/lib/clang/7.0.0/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -O2 -Wno-unused-parameter -Wwrite-strings -Wno-missing-field-initializers -Wno-long-long -Wno-maybe-uninitialized -Wno-comment -std=c++11 -fdeprecated-macro -fdebug-compilation-dir /build/llvm-toolchain-snapshot-7~svn326551/build-llvm/lib/ObjectYAML -ferror-limit 19 -fmessage-length 0 -fvisibility-inlines-hidden -fobjc-runtime=gcc -fdiagnostics-show-option -vectorize-loops -vectorize-slp -analyzer-checker optin.performance.Padding -analyzer-output=html -analyzer-config stable-report-filename=true -o /tmp/scan-build-2018-03-02-155150-1477-1 -x c++ /build/llvm-toolchain-snapshot-7~svn326551/lib/ObjectYAML/CodeViewYAMLTypes.cpp

/build/llvm-toolchain-snapshot-7~svn326551/lib/ObjectYAML/CodeViewYAMLTypes.cpp

1//===- CodeViewYAMLTypes.cpp - CodeView YAMLIO types implementation -------===//
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 classes for handling the YAML representation of CodeView
11// Debug Info.
12//
13//===----------------------------------------------------------------------===//
14
15#include "llvm/ObjectYAML/CodeViewYAMLTypes.h"
16#include "llvm/ADT/APSInt.h"
17#include "llvm/ADT/ArrayRef.h"
18#include "llvm/ADT/StringRef.h"
19#include "llvm/BinaryFormat/COFF.h"
20#include "llvm/DebugInfo/CodeView/AppendingTypeTableBuilder.h"
21#include "llvm/DebugInfo/CodeView/CVTypeVisitor.h"
22#include "llvm/DebugInfo/CodeView/CodeView.h"
23#include "llvm/DebugInfo/CodeView/CodeViewError.h"
24#include "llvm/DebugInfo/CodeView/ContinuationRecordBuilder.h"
25#include "llvm/DebugInfo/CodeView/TypeDeserializer.h"
26#include "llvm/DebugInfo/CodeView/TypeIndex.h"
27#include "llvm/DebugInfo/CodeView/TypeVisitorCallbacks.h"
28#include "llvm/Support/Allocator.h"
29#include "llvm/Support/BinaryStreamReader.h"
30#include "llvm/Support/BinaryStreamWriter.h"
31#include "llvm/Support/Endian.h"
32#include "llvm/Support/Error.h"
33#include "llvm/Support/ErrorHandling.h"
34#include "llvm/Support/YAMLTraits.h"
35#include "llvm/Support/raw_ostream.h"
36#include <algorithm>
37#include <cassert>
38#include <cstdint>
39#include <vector>
40
41using namespace llvm;
42using namespace llvm::codeview;
43using namespace llvm::CodeViewYAML;
44using namespace llvm::CodeViewYAML::detail;
45using namespace llvm::yaml;
46
47LLVM_YAML_IS_SEQUENCE_VECTOR(OneMethodRecord)namespace llvm { namespace yaml { static_assert( !std::is_fundamental
<OneMethodRecord>::value && !std::is_same<OneMethodRecord
, std::string>::value && !std::is_same<OneMethodRecord
, llvm::StringRef>::value, "only use LLVM_YAML_IS_SEQUENCE_VECTOR for types you control"
); template <> struct SequenceElementTraits<OneMethodRecord
> { static const bool flow = false; }; } }
48LLVM_YAML_IS_SEQUENCE_VECTOR(VFTableSlotKind)namespace llvm { namespace yaml { static_assert( !std::is_fundamental
<VFTableSlotKind>::value && !std::is_same<VFTableSlotKind
, std::string>::value && !std::is_same<VFTableSlotKind
, llvm::StringRef>::value, "only use LLVM_YAML_IS_SEQUENCE_VECTOR for types you control"
); template <> struct SequenceElementTraits<VFTableSlotKind
> { static const bool flow = false; }; } }
49LLVM_YAML_IS_FLOW_SEQUENCE_VECTOR(TypeIndex)namespace llvm { namespace yaml { static_assert( !std::is_fundamental
<TypeIndex>::value && !std::is_same<TypeIndex
, std::string>::value && !std::is_same<TypeIndex
, llvm::StringRef>::value, "only use LLVM_YAML_IS_SEQUENCE_VECTOR for types you control"
); template <> struct SequenceElementTraits<TypeIndex
> { static const bool flow = true; }; } }
50
51LLVM_YAML_DECLARE_SCALAR_TRAITS(TypeIndex, QuotingType::None)namespace llvm { namespace yaml { template <> struct ScalarTraits
<TypeIndex> { static void output(const TypeIndex &Value
, void *ctx, raw_ostream &Out); static StringRef input(StringRef
Scalar, void *ctxt, TypeIndex &Value); static QuotingType
mustQuote(StringRef) { return QuotingType::None; } }; } }
52LLVM_YAML_DECLARE_SCALAR_TRAITS(APSInt, QuotingType::None)namespace llvm { namespace yaml { template <> struct ScalarTraits
<APSInt> { static void output(const APSInt &Value, void
*ctx, raw_ostream &Out); static StringRef input(StringRef
Scalar, void *ctxt, APSInt &Value); static QuotingType mustQuote
(StringRef) { return QuotingType::None; } }; } }
53
54LLVM_YAML_DECLARE_ENUM_TRAITS(TypeLeafKind)namespace llvm { namespace yaml { template <> struct ScalarEnumerationTraits
<TypeLeafKind> { static void enumeration(IO &io, TypeLeafKind
&Value); }; } }
55LLVM_YAML_DECLARE_ENUM_TRAITS(PointerToMemberRepresentation)namespace llvm { namespace yaml { template <> struct ScalarEnumerationTraits
<PointerToMemberRepresentation> { static void enumeration
(IO &io, PointerToMemberRepresentation &Value); }; } }
56LLVM_YAML_DECLARE_ENUM_TRAITS(VFTableSlotKind)namespace llvm { namespace yaml { template <> struct ScalarEnumerationTraits
<VFTableSlotKind> { static void enumeration(IO &io,
VFTableSlotKind &Value); }; } }
57LLVM_YAML_DECLARE_ENUM_TRAITS(CallingConvention)namespace llvm { namespace yaml { template <> struct ScalarEnumerationTraits
<CallingConvention> { static void enumeration(IO &io
, CallingConvention &Value); }; } }
58LLVM_YAML_DECLARE_ENUM_TRAITS(PointerKind)namespace llvm { namespace yaml { template <> struct ScalarEnumerationTraits
<PointerKind> { static void enumeration(IO &io, PointerKind
&Value); }; } }
59LLVM_YAML_DECLARE_ENUM_TRAITS(PointerMode)namespace llvm { namespace yaml { template <> struct ScalarEnumerationTraits
<PointerMode> { static void enumeration(IO &io, PointerMode
&Value); }; } }
60LLVM_YAML_DECLARE_ENUM_TRAITS(HfaKind)namespace llvm { namespace yaml { template <> struct ScalarEnumerationTraits
<HfaKind> { static void enumeration(IO &io, HfaKind
&Value); }; } }
61LLVM_YAML_DECLARE_ENUM_TRAITS(MemberAccess)namespace llvm { namespace yaml { template <> struct ScalarEnumerationTraits
<MemberAccess> { static void enumeration(IO &io, MemberAccess
&Value); }; } }
62LLVM_YAML_DECLARE_ENUM_TRAITS(MethodKind)namespace llvm { namespace yaml { template <> struct ScalarEnumerationTraits
<MethodKind> { static void enumeration(IO &io, MethodKind
&Value); }; } }
63LLVM_YAML_DECLARE_ENUM_TRAITS(WindowsRTClassKind)namespace llvm { namespace yaml { template <> struct ScalarEnumerationTraits
<WindowsRTClassKind> { static void enumeration(IO &
io, WindowsRTClassKind &Value); }; } }
64LLVM_YAML_DECLARE_ENUM_TRAITS(LabelType)namespace llvm { namespace yaml { template <> struct ScalarEnumerationTraits
<LabelType> { static void enumeration(IO &io, LabelType
&Value); }; } }
65
66LLVM_YAML_DECLARE_BITSET_TRAITS(PointerOptions)namespace llvm { namespace yaml { template <> struct ScalarBitSetTraits
<PointerOptions> { static void bitset(IO &IO, PointerOptions
&Options); }; } }
67LLVM_YAML_DECLARE_BITSET_TRAITS(ModifierOptions)namespace llvm { namespace yaml { template <> struct ScalarBitSetTraits
<ModifierOptions> { static void bitset(IO &IO, ModifierOptions
&Options); }; } }
68LLVM_YAML_DECLARE_BITSET_TRAITS(FunctionOptions)namespace llvm { namespace yaml { template <> struct ScalarBitSetTraits
<FunctionOptions> { static void bitset(IO &IO, FunctionOptions
&Options); }; } }
69LLVM_YAML_DECLARE_BITSET_TRAITS(ClassOptions)namespace llvm { namespace yaml { template <> struct ScalarBitSetTraits
<ClassOptions> { static void bitset(IO &IO, ClassOptions
&Options); }; } }
70LLVM_YAML_DECLARE_BITSET_TRAITS(MethodOptions)namespace llvm { namespace yaml { template <> struct ScalarBitSetTraits
<MethodOptions> { static void bitset(IO &IO, MethodOptions
&Options); }; } }
71
72LLVM_YAML_DECLARE_MAPPING_TRAITS(OneMethodRecord)namespace llvm { namespace yaml { template <> struct MappingTraits
<OneMethodRecord> { static void mapping(IO &IO, OneMethodRecord
&Obj); }; } }
73LLVM_YAML_DECLARE_MAPPING_TRAITS(MemberPointerInfo)namespace llvm { namespace yaml { template <> struct MappingTraits
<MemberPointerInfo> { static void mapping(IO &IO, MemberPointerInfo
&Obj); }; } }
74
75namespace llvm {
76namespace CodeViewYAML {
77namespace detail {
78
79struct LeafRecordBase {
80 TypeLeafKind Kind;
81
82 explicit LeafRecordBase(TypeLeafKind K) : Kind(K) {}
83 virtual ~LeafRecordBase() = default;
84
85 virtual void map(yaml::IO &io) = 0;
86 virtual CVType toCodeViewRecord(AppendingTypeTableBuilder &TS) const = 0;
87 virtual Error fromCodeViewRecord(CVType Type) = 0;
88};
89
90template <typename T> struct LeafRecordImpl : public LeafRecordBase {
91 explicit LeafRecordImpl(TypeLeafKind K)
92 : LeafRecordBase(K), Record(static_cast<TypeRecordKind>(K)) {}
93
94 void map(yaml::IO &io) override;
95
96 Error fromCodeViewRecord(CVType Type) override {
97 return TypeDeserializer::deserializeAs<T>(Type, Record);
98 }
99
100 CVType toCodeViewRecord(AppendingTypeTableBuilder &TS) const override {
101 TS.writeLeafType(Record);
102 return CVType(Kind, TS.records().back());
103 }
104
105 mutable T Record;
106};
107
108template <> struct LeafRecordImpl<FieldListRecord> : public LeafRecordBase {
109 explicit LeafRecordImpl(TypeLeafKind K) : LeafRecordBase(K) {}
110
111 void map(yaml::IO &io) override;
112 CVType toCodeViewRecord(AppendingTypeTableBuilder &TS) const override;
113 Error fromCodeViewRecord(CVType Type) override;
114
115 std::vector<MemberRecord> Members;
116};
117
118struct MemberRecordBase {
119 TypeLeafKind Kind;
120
121 explicit MemberRecordBase(TypeLeafKind K) : Kind(K) {}
122 virtual ~MemberRecordBase() = default;
123
124 virtual void map(yaml::IO &io) = 0;
125 virtual void writeTo(ContinuationRecordBuilder &CRB) = 0;
126};
127
128template <typename T> struct MemberRecordImpl : public MemberRecordBase {
129 explicit MemberRecordImpl(TypeLeafKind K)
130 : MemberRecordBase(K), Record(static_cast<TypeRecordKind>(K)) {}
131
132 void map(yaml::IO &io) override;
133
134 void writeTo(ContinuationRecordBuilder &CRB) override {
135 CRB.writeMemberType(Record);
136 }
137
138 mutable T Record;
139};
140
141} // end namespace detail
142} // end namespace CodeViewYAML
143} // end namespace llvm
144
145void ScalarTraits<GUID>::output(const GUID &G, void *, llvm::raw_ostream &OS) {
146 OS << G;
147}
148
149StringRef ScalarTraits<GUID>::input(StringRef Scalar, void *Ctx, GUID &S) {
150 if (Scalar.size() != 38)
151 return "GUID strings are 38 characters long";
152 if (Scalar[0] != '{' || Scalar[37] != '}')
153 return "GUID is not enclosed in {}";
154 if (Scalar[9] != '-' || Scalar[14] != '-' || Scalar[19] != '-' ||
155 Scalar[24] != '-')
156 return "GUID sections are not properly delineated with dashes";
157
158 uint8_t *OutBuffer = S.Guid;
159 for (auto Iter = Scalar.begin(); Iter != Scalar.end();) {
160 if (*Iter == '-' || *Iter == '{' || *Iter == '}') {
161 ++Iter;
162 continue;
163 }
164 uint8_t Value = (llvm::hexDigitValue(*Iter++) << 4);
165 Value |= llvm::hexDigitValue(*Iter++);
166 *OutBuffer++ = Value;
167 }
168
169 return "";
170}
171
172void ScalarTraits<TypeIndex>::output(const TypeIndex &S, void *,
173 raw_ostream &OS) {
174 OS << S.getIndex();
175}
176
177StringRef ScalarTraits<TypeIndex>::input(StringRef Scalar, void *Ctx,
178 TypeIndex &S) {
179 uint32_t I;
180 StringRef Result = ScalarTraits<uint32_t>::input(Scalar, Ctx, I);
181 S.setIndex(I);
182 return Result;
183}
184
185void ScalarTraits<APSInt>::output(const APSInt &S, void *, raw_ostream &OS) {
186 S.print(OS, S.isSigned());
187}
188
189StringRef ScalarTraits<APSInt>::input(StringRef Scalar, void *Ctx, APSInt &S) {
190 S = APSInt(Scalar);
191 return "";
192}
193
194void ScalarEnumerationTraits<TypeLeafKind>::enumeration(IO &io,
195 TypeLeafKind &Value) {
196#define CV_TYPE(name, val) io.enumCase(Value, #name, name);
197#include "llvm/DebugInfo/CodeView/CodeViewTypes.def"
198#undef CV_TYPE
199}
200
201void ScalarEnumerationTraits<PointerToMemberRepresentation>::enumeration(
202 IO &IO, PointerToMemberRepresentation &Value) {
203 IO.enumCase(Value, "Unknown", PointerToMemberRepresentation::Unknown);
204 IO.enumCase(Value, "SingleInheritanceData",
205 PointerToMemberRepresentation::SingleInheritanceData);
206 IO.enumCase(Value, "MultipleInheritanceData",
207 PointerToMemberRepresentation::MultipleInheritanceData);
208 IO.enumCase(Value, "VirtualInheritanceData",
209 PointerToMemberRepresentation::VirtualInheritanceData);
210 IO.enumCase(Value, "GeneralData", PointerToMemberRepresentation::GeneralData);
211 IO.enumCase(Value, "SingleInheritanceFunction",
212 PointerToMemberRepresentation::SingleInheritanceFunction);
213 IO.enumCase(Value, "MultipleInheritanceFunction",
214 PointerToMemberRepresentation::MultipleInheritanceFunction);
215 IO.enumCase(Value, "VirtualInheritanceFunction",
216 PointerToMemberRepresentation::VirtualInheritanceFunction);
217 IO.enumCase(Value, "GeneralFunction",
218 PointerToMemberRepresentation::GeneralFunction);
219}
220
221void ScalarEnumerationTraits<VFTableSlotKind>::enumeration(
222 IO &IO, VFTableSlotKind &Kind) {
223 IO.enumCase(Kind, "Near16", VFTableSlotKind::Near16);
224 IO.enumCase(Kind, "Far16", VFTableSlotKind::Far16);
225 IO.enumCase(Kind, "This", VFTableSlotKind::This);
226 IO.enumCase(Kind, "Outer", VFTableSlotKind::Outer);
227 IO.enumCase(Kind, "Meta", VFTableSlotKind::Meta);
228 IO.enumCase(Kind, "Near", VFTableSlotKind::Near);
229 IO.enumCase(Kind, "Far", VFTableSlotKind::Far);
230}
231
232void ScalarEnumerationTraits<CallingConvention>::enumeration(
233 IO &IO, CallingConvention &Value) {
234 IO.enumCase(Value, "NearC", CallingConvention::NearC);
235 IO.enumCase(Value, "FarC", CallingConvention::FarC);
236 IO.enumCase(Value, "NearPascal", CallingConvention::NearPascal);
237 IO.enumCase(Value, "FarPascal", CallingConvention::FarPascal);
238 IO.enumCase(Value, "NearFast", CallingConvention::NearFast);
239 IO.enumCase(Value, "FarFast", CallingConvention::FarFast);
240 IO.enumCase(Value, "NearStdCall", CallingConvention::NearStdCall);
241 IO.enumCase(Value, "FarStdCall", CallingConvention::FarStdCall);
242 IO.enumCase(Value, "NearSysCall", CallingConvention::NearSysCall);
243 IO.enumCase(Value, "FarSysCall", CallingConvention::FarSysCall);
244 IO.enumCase(Value, "ThisCall", CallingConvention::ThisCall);
245 IO.enumCase(Value, "MipsCall", CallingConvention::MipsCall);
246 IO.enumCase(Value, "Generic", CallingConvention::Generic);
247 IO.enumCase(Value, "AlphaCall", CallingConvention::AlphaCall);
248 IO.enumCase(Value, "PpcCall", CallingConvention::PpcCall);
249 IO.enumCase(Value, "SHCall", CallingConvention::SHCall);
250 IO.enumCase(Value, "ArmCall", CallingConvention::ArmCall);
251 IO.enumCase(Value, "AM33Call", CallingConvention::AM33Call);
252 IO.enumCase(Value, "TriCall", CallingConvention::TriCall);
253 IO.enumCase(Value, "SH5Call", CallingConvention::SH5Call);
254 IO.enumCase(Value, "M32RCall", CallingConvention::M32RCall);
255 IO.enumCase(Value, "ClrCall", CallingConvention::ClrCall);
256 IO.enumCase(Value, "Inline", CallingConvention::Inline);
257 IO.enumCase(Value, "NearVector", CallingConvention::NearVector);
258}
259
260void ScalarEnumerationTraits<PointerKind>::enumeration(IO &IO,
261 PointerKind &Kind) {
262 IO.enumCase(Kind, "Near16", PointerKind::Near16);
263 IO.enumCase(Kind, "Far16", PointerKind::Far16);
264 IO.enumCase(Kind, "Huge16", PointerKind::Huge16);
265 IO.enumCase(Kind, "BasedOnSegment", PointerKind::BasedOnSegment);
266 IO.enumCase(Kind, "BasedOnValue", PointerKind::BasedOnValue);
267 IO.enumCase(Kind, "BasedOnSegmentValue", PointerKind::BasedOnSegmentValue);
268 IO.enumCase(Kind, "BasedOnAddress", PointerKind::BasedOnAddress);
269 IO.enumCase(Kind, "BasedOnSegmentAddress",
270 PointerKind::BasedOnSegmentAddress);
271 IO.enumCase(Kind, "BasedOnType", PointerKind::BasedOnType);
272 IO.enumCase(Kind, "BasedOnSelf", PointerKind::BasedOnSelf);
273 IO.enumCase(Kind, "Near32", PointerKind::Near32);
274 IO.enumCase(Kind, "Far32", PointerKind::Far32);
275 IO.enumCase(Kind, "Near64", PointerKind::Near64);
276}
277
278void ScalarEnumerationTraits<PointerMode>::enumeration(IO &IO,
279 PointerMode &Mode) {
280 IO.enumCase(Mode, "Pointer", PointerMode::Pointer);
281 IO.enumCase(Mode, "LValueReference", PointerMode::LValueReference);
282 IO.enumCase(Mode, "PointerToDataMember", PointerMode::PointerToDataMember);
283 IO.enumCase(Mode, "PointerToMemberFunction",
284 PointerMode::PointerToMemberFunction);
285 IO.enumCase(Mode, "RValueReference", PointerMode::RValueReference);
286}
287
288void ScalarEnumerationTraits<HfaKind>::enumeration(IO &IO, HfaKind &Value) {
289 IO.enumCase(Value, "None", HfaKind::None);
290 IO.enumCase(Value, "Float", HfaKind::Float);
291 IO.enumCase(Value, "Double", HfaKind::Double);
292 IO.enumCase(Value, "Other", HfaKind::Other);
293}
294
295void ScalarEnumerationTraits<MemberAccess>::enumeration(IO &IO,
296 MemberAccess &Access) {
297 IO.enumCase(Access, "None", MemberAccess::None);
298 IO.enumCase(Access, "Private", MemberAccess::Private);
299 IO.enumCase(Access, "Protected", MemberAccess::Protected);
300 IO.enumCase(Access, "Public", MemberAccess::Public);
301}
302
303void ScalarEnumerationTraits<MethodKind>::enumeration(IO &IO,
304 MethodKind &Kind) {
305 IO.enumCase(Kind, "Vanilla", MethodKind::Vanilla);
306 IO.enumCase(Kind, "Virtual", MethodKind::Virtual);
307 IO.enumCase(Kind, "Static", MethodKind::Static);
308 IO.enumCase(Kind, "Friend", MethodKind::Friend);
309 IO.enumCase(Kind, "IntroducingVirtual", MethodKind::IntroducingVirtual);
310 IO.enumCase(Kind, "PureVirtual", MethodKind::PureVirtual);
311 IO.enumCase(Kind, "PureIntroducingVirtual",
312 MethodKind::PureIntroducingVirtual);
313}
314
315void ScalarEnumerationTraits<WindowsRTClassKind>::enumeration(
316 IO &IO, WindowsRTClassKind &Value) {
317 IO.enumCase(Value, "None", WindowsRTClassKind::None);
318 IO.enumCase(Value, "Ref", WindowsRTClassKind::RefClass);
319 IO.enumCase(Value, "Value", WindowsRTClassKind::ValueClass);
320 IO.enumCase(Value, "Interface", WindowsRTClassKind::Interface);
321}
322
323void ScalarEnumerationTraits<LabelType>::enumeration(IO &IO, LabelType &Value) {
324 IO.enumCase(Value, "Near", LabelType::Near);
325 IO.enumCase(Value, "Far", LabelType::Far);
326}
327
328void ScalarBitSetTraits<PointerOptions>::bitset(IO &IO,
329 PointerOptions &Options) {
330 IO.bitSetCase(Options, "None", PointerOptions::None);
331 IO.bitSetCase(Options, "Flat32", PointerOptions::Flat32);
332 IO.bitSetCase(Options, "Volatile", PointerOptions::Volatile);
333 IO.bitSetCase(Options, "Const", PointerOptions::Const);
334 IO.bitSetCase(Options, "Unaligned", PointerOptions::Unaligned);
335 IO.bitSetCase(Options, "Restrict", PointerOptions::Restrict);
336 IO.bitSetCase(Options, "WinRTSmartPointer",
337 PointerOptions::WinRTSmartPointer);
338}
339
340void ScalarBitSetTraits<ModifierOptions>::bitset(IO &IO,
341 ModifierOptions &Options) {
342 IO.bitSetCase(Options, "None", ModifierOptions::None);
343 IO.bitSetCase(Options, "Const", ModifierOptions::Const);
344 IO.bitSetCase(Options, "Volatile", ModifierOptions::Volatile);
345 IO.bitSetCase(Options, "Unaligned", ModifierOptions::Unaligned);
346}
347
348void ScalarBitSetTraits<FunctionOptions>::bitset(IO &IO,
349 FunctionOptions &Options) {
350 IO.bitSetCase(Options, "None", FunctionOptions::None);
351 IO.bitSetCase(Options, "CxxReturnUdt", FunctionOptions::CxxReturnUdt);
352 IO.bitSetCase(Options, "Constructor", FunctionOptions::Constructor);
353 IO.bitSetCase(Options, "ConstructorWithVirtualBases",
354 FunctionOptions::ConstructorWithVirtualBases);
355}
356
357void ScalarBitSetTraits<ClassOptions>::bitset(IO &IO, ClassOptions &Options) {
358 IO.bitSetCase(Options, "None", ClassOptions::None);
359 IO.bitSetCase(Options, "HasConstructorOrDestructor",
360 ClassOptions::HasConstructorOrDestructor);
361 IO.bitSetCase(Options, "HasOverloadedOperator",
362 ClassOptions::HasOverloadedOperator);
363 IO.bitSetCase(Options, "Nested", ClassOptions::Nested);
364 IO.bitSetCase(Options, "ContainsNestedClass",
365 ClassOptions::ContainsNestedClass);
366 IO.bitSetCase(Options, "HasOverloadedAssignmentOperator",
367 ClassOptions::HasOverloadedAssignmentOperator);
368 IO.bitSetCase(Options, "HasConversionOperator",
369 ClassOptions::HasConversionOperator);
370 IO.bitSetCase(Options, "ForwardReference", ClassOptions::ForwardReference);
371 IO.bitSetCase(Options, "Scoped", ClassOptions::Scoped);
372 IO.bitSetCase(Options, "HasUniqueName", ClassOptions::HasUniqueName);
373 IO.bitSetCase(Options, "Sealed", ClassOptions::Sealed);
374 IO.bitSetCase(Options, "Intrinsic", ClassOptions::Intrinsic);
375}
376
377void ScalarBitSetTraits<MethodOptions>::bitset(IO &IO, MethodOptions &Options) {
378 IO.bitSetCase(Options, "None", MethodOptions::None);
379 IO.bitSetCase(Options, "Pseudo", MethodOptions::Pseudo);
380 IO.bitSetCase(Options, "NoInherit", MethodOptions::NoInherit);
381 IO.bitSetCase(Options, "NoConstruct", MethodOptions::NoConstruct);
382 IO.bitSetCase(Options, "CompilerGenerated", MethodOptions::CompilerGenerated);
383 IO.bitSetCase(Options, "Sealed", MethodOptions::Sealed);
384}
385
386void MappingTraits<MemberPointerInfo>::mapping(IO &IO, MemberPointerInfo &MPI) {
387 IO.mapRequired("ContainingType", MPI.ContainingType);
388 IO.mapRequired("Representation", MPI.Representation);
389}
390
391namespace llvm {
392namespace CodeViewYAML {
393namespace detail {
394
395template <> void LeafRecordImpl<ModifierRecord>::map(IO &IO) {
396 IO.mapRequired("ModifiedType", Record.ModifiedType);
397 IO.mapRequired("Modifiers", Record.Modifiers);
398}
399
400template <> void LeafRecordImpl<ProcedureRecord>::map(IO &IO) {
401 IO.mapRequired("ReturnType", Record.ReturnType);
402 IO.mapRequired("CallConv", Record.CallConv);
403 IO.mapRequired("Options", Record.Options);
404 IO.mapRequired("ParameterCount", Record.ParameterCount);
405 IO.mapRequired("ArgumentList", Record.ArgumentList);
406}
407
408template <> void LeafRecordImpl<MemberFunctionRecord>::map(IO &IO) {
409 IO.mapRequired("ReturnType", Record.ReturnType);
410 IO.mapRequired("ClassType", Record.ClassType);
411 IO.mapRequired("ThisType", Record.ThisType);
412 IO.mapRequired("CallConv", Record.CallConv);
413 IO.mapRequired("Options", Record.Options);
414 IO.mapRequired("ParameterCount", Record.ParameterCount);
415 IO.mapRequired("ArgumentList", Record.ArgumentList);
416 IO.mapRequired("ThisPointerAdjustment", Record.ThisPointerAdjustment);
417}
418
419template <> void LeafRecordImpl<LabelRecord>::map(IO &IO) {
420 IO.mapRequired("Mode", Record.Mode);
421}
422
423template <> void LeafRecordImpl<MemberFuncIdRecord>::map(IO &IO) {
424 IO.mapRequired("ClassType", Record.ClassType);
425 IO.mapRequired("FunctionType", Record.FunctionType);
426 IO.mapRequired("Name", Record.Name);
427}
428
429template <> void LeafRecordImpl<ArgListRecord>::map(IO &IO) {
430 IO.mapRequired("ArgIndices", Record.ArgIndices);
431}
432
433template <> void LeafRecordImpl<StringListRecord>::map(IO &IO) {
434 IO.mapRequired("StringIndices", Record.StringIndices);
435}
436
437template <> void LeafRecordImpl<PointerRecord>::map(IO &IO) {
438 IO.mapRequired("ReferentType", Record.ReferentType);
439 IO.mapRequired("Attrs", Record.Attrs);
440 IO.mapOptional("MemberInfo", Record.MemberInfo);
441}
442
443template <> void LeafRecordImpl<ArrayRecord>::map(IO &IO) {
444 IO.mapRequired("ElementType", Record.ElementType);
445 IO.mapRequired("IndexType", Record.IndexType);
446 IO.mapRequired("Size", Record.Size);
447 IO.mapRequired("Name", Record.Name);
448}
449
450void LeafRecordImpl<FieldListRecord>::map(IO &IO) {
451 IO.mapRequired("FieldList", Members);
452}
453
454} // end namespace detail
455} // end namespace CodeViewYAML
456} // end namespace llvm
457
458namespace {
459
460class MemberRecordConversionVisitor : public TypeVisitorCallbacks {
461public:
462 explicit MemberRecordConversionVisitor(std::vector<MemberRecord> &Records)
463 : Records(Records) {}
464
465#define TYPE_RECORD(EnumName, EnumVal, Name)
466#define MEMBER_RECORD(EnumName, EnumVal, Name) \
467 Error visitKnownMember(CVMemberRecord &CVR, Name##Record &Record) override { \
468 return visitKnownMemberImpl(Record); \
469 }
470#define TYPE_RECORD_ALIAS(EnumName, EnumVal, Name, AliasName)
471#define MEMBER_RECORD_ALIAS(EnumName, EnumVal, Name, AliasName)
472#include "llvm/DebugInfo/CodeView/CodeViewTypes.def"
473private:
474 template <typename T> Error visitKnownMemberImpl(T &Record) {
475 TypeLeafKind K = static_cast<TypeLeafKind>(Record.getKind());
476 auto Impl = std::make_shared<MemberRecordImpl<T>>(K);
477 Impl->Record = Record;
478 Records.push_back(MemberRecord{Impl});
479 return Error::success();
480 }
481
482 std::vector<MemberRecord> &Records;
483};
484
485} // end anonymous namespace
486
487Error LeafRecordImpl<FieldListRecord>::fromCodeViewRecord(CVType Type) {
488 MemberRecordConversionVisitor V(Members);
489 return visitMemberRecordStream(Type.content(), V);
490}
491
492CVType LeafRecordImpl<FieldListRecord>::toCodeViewRecord(
493 AppendingTypeTableBuilder &TS) const {
494 ContinuationRecordBuilder CRB;
495 CRB.begin(ContinuationRecordKind::FieldList);
496 for (const auto &Member : Members) {
497 Member.Member->writeTo(CRB);
498 }
499 TS.insertRecord(CRB);
500 return CVType(Kind, TS.records().back());
501}
502
503void MappingTraits<OneMethodRecord>::mapping(IO &io, OneMethodRecord &Record) {
504 io.mapRequired("Type", Record.Type);
505 io.mapRequired("Attrs", Record.Attrs.Attrs);
506 io.mapRequired("VFTableOffset", Record.VFTableOffset);
507 io.mapRequired("Name", Record.Name);
508}
509
510namespace llvm {
511namespace CodeViewYAML {
512namespace detail {
513
514template <> void LeafRecordImpl<ClassRecord>::map(IO &IO) {
515 IO.mapRequired("MemberCount", Record.MemberCount);
516 IO.mapRequired("Options", Record.Options);
517 IO.mapRequired("FieldList", Record.FieldList);
518 IO.mapRequired("Name", Record.Name);
519 IO.mapRequired("UniqueName", Record.UniqueName);
520 IO.mapRequired("DerivationList", Record.DerivationList);
521 IO.mapRequired("VTableShape", Record.VTableShape);
522 IO.mapRequired("Size", Record.Size);
523}
524
525template <> void LeafRecordImpl<UnionRecord>::map(IO &IO) {
526 IO.mapRequired("MemberCount", Record.MemberCount);
527 IO.mapRequired("Options", Record.Options);
528 IO.mapRequired("FieldList", Record.FieldList);
529 IO.mapRequired("Name", Record.Name);
530 IO.mapRequired("UniqueName", Record.UniqueName);
531 IO.mapRequired("Size", Record.Size);
532}
533
534template <> void LeafRecordImpl<EnumRecord>::map(IO &IO) {
535 IO.mapRequired("NumEnumerators", Record.MemberCount);
536 IO.mapRequired("Options", Record.Options);
537 IO.mapRequired("FieldList", Record.FieldList);
538 IO.mapRequired("Name", Record.Name);
539 IO.mapRequired("UniqueName", Record.UniqueName);
540 IO.mapRequired("UnderlyingType", Record.UnderlyingType);
541}
542
543template <> void LeafRecordImpl<BitFieldRecord>::map(IO &IO) {
544 IO.mapRequired("Type", Record.Type);
545 IO.mapRequired("BitSize", Record.BitSize);
546 IO.mapRequired("BitOffset", Record.BitOffset);
547}
548
549template <> void LeafRecordImpl<VFTableShapeRecord>::map(IO &IO) {
550 IO.mapRequired("Slots", Record.Slots);
551}
552
553template <> void LeafRecordImpl<TypeServer2Record>::map(IO &IO) {
554 IO.mapRequired("Guid", Record.Guid);
555 IO.mapRequired("Age", Record.Age);
556 IO.mapRequired("Name", Record.Name);
557}
558
559template <> void LeafRecordImpl<StringIdRecord>::map(IO &IO) {
560 IO.mapRequired("Id", Record.Id);
561 IO.mapRequired("String", Record.String);
562}
563
564template <> void LeafRecordImpl<FuncIdRecord>::map(IO &IO) {
565 IO.mapRequired("ParentScope", Record.ParentScope);
566 IO.mapRequired("FunctionType", Record.FunctionType);
567 IO.mapRequired("Name", Record.Name);
568}
569
570template <> void LeafRecordImpl<UdtSourceLineRecord>::map(IO &IO) {
571 IO.mapRequired("UDT", Record.UDT);
572 IO.mapRequired("SourceFile", Record.SourceFile);
573 IO.mapRequired("LineNumber", Record.LineNumber);
574}
575
576template <> void LeafRecordImpl<UdtModSourceLineRecord>::map(IO &IO) {
577 IO.mapRequired("UDT", Record.UDT);
578 IO.mapRequired("SourceFile", Record.SourceFile);
579 IO.mapRequired("LineNumber", Record.LineNumber);
580 IO.mapRequired("Module", Record.Module);
581}
582
583template <> void LeafRecordImpl<BuildInfoRecord>::map(IO &IO) {
584 IO.mapRequired("ArgIndices", Record.ArgIndices);
585}
586
587template <> void LeafRecordImpl<VFTableRecord>::map(IO &IO) {
588 IO.mapRequired("CompleteClass", Record.CompleteClass);
589 IO.mapRequired("OverriddenVFTable", Record.OverriddenVFTable);
590 IO.mapRequired("VFPtrOffset", Record.VFPtrOffset);
591 IO.mapRequired("MethodNames", Record.MethodNames);
592}
593
594template <> void LeafRecordImpl<MethodOverloadListRecord>::map(IO &IO) {
595 IO.mapRequired("Methods", Record.Methods);
596}
597
598template <> void MemberRecordImpl<OneMethodRecord>::map(IO &IO) {
599 MappingTraits<OneMethodRecord>::mapping(IO, Record);
600}
601
602template <> void MemberRecordImpl<OverloadedMethodRecord>::map(IO &IO) {
603 IO.mapRequired("NumOverloads", Record.NumOverloads);
604 IO.mapRequired("MethodList", Record.MethodList);
605 IO.mapRequired("Name", Record.Name);
606}
607
608template <> void MemberRecordImpl<NestedTypeRecord>::map(IO &IO) {
609 IO.mapRequired("Type", Record.Type);
610 IO.mapRequired("Name", Record.Name);
611}
612
613template <> void MemberRecordImpl<DataMemberRecord>::map(IO &IO) {
614 IO.mapRequired("Attrs", Record.Attrs.Attrs);
615 IO.mapRequired("Type", Record.Type);
616 IO.mapRequired("FieldOffset", Record.FieldOffset);
617 IO.mapRequired("Name", Record.Name);
618}
619
620template <> void MemberRecordImpl<StaticDataMemberRecord>::map(IO &IO) {
621 IO.mapRequired("Attrs", Record.Attrs.Attrs);
622 IO.mapRequired("Type", Record.Type);
623 IO.mapRequired("Name", Record.Name);
624}
625
626template <> void MemberRecordImpl<EnumeratorRecord>::map(IO &IO) {
627 IO.mapRequired("Attrs", Record.Attrs.Attrs);
628 IO.mapRequired("Value", Record.Value);
629 IO.mapRequired("Name", Record.Name);
630}
631
632template <> void MemberRecordImpl<VFPtrRecord>::map(IO &IO) {
633 IO.mapRequired("Type", Record.Type);
634}
635
636template <> void MemberRecordImpl<BaseClassRecord>::map(IO &IO) {
637 IO.mapRequired("Attrs", Record.Attrs.Attrs);
638 IO.mapRequired("Type", Record.Type);
639 IO.mapRequired("Offset", Record.Offset);
640}
641
642template <> void MemberRecordImpl<VirtualBaseClassRecord>::map(IO &IO) {
643 IO.mapRequired("Attrs", Record.Attrs.Attrs);
644 IO.mapRequired("BaseType", Record.BaseType);
645 IO.mapRequired("VBPtrType", Record.VBPtrType);
646 IO.mapRequired("VBPtrOffset", Record.VBPtrOffset);
647 IO.mapRequired("VTableIndex", Record.VTableIndex);
648}
649
650template <> void MemberRecordImpl<ListContinuationRecord>::map(IO &IO) {
651 IO.mapRequired("ContinuationIndex", Record.ContinuationIndex);
652}
653
654} // end namespace detail
655} // end namespace CodeViewYAML
656} // end namespace llvm
657
658template <typename T>
659static inline Expected<LeafRecord> fromCodeViewRecordImpl(CVType Type) {
660 LeafRecord Result;
661
662 auto Impl = std::make_shared<LeafRecordImpl<T>>(Type.kind());
663 if (auto EC = Impl->fromCodeViewRecord(Type))
664 return std::move(EC);
665 Result.Leaf = Impl;
666 return Result;
667}
668
669Expected<LeafRecord> LeafRecord::fromCodeViewRecord(CVType Type) {
670#define TYPE_RECORD(EnumName, EnumVal, ClassName) \
671 case EnumName: \
672 return fromCodeViewRecordImpl<ClassName##Record>(Type);
673#define TYPE_RECORD_ALIAS(EnumName, EnumVal, AliasName, ClassName) \
674 TYPE_RECORD(EnumName, EnumVal, ClassName)
675#define MEMBER_RECORD(EnumName, EnumVal, ClassName)
676#define MEMBER_RECORD_ALIAS(EnumName, EnumVal, AliasName, ClassName)
677 switch (Type.kind()) {
678#include "llvm/DebugInfo/CodeView/CodeViewTypes.def"
679 default:
680 llvm_unreachable("Unknown leaf kind!")::llvm::llvm_unreachable_internal("Unknown leaf kind!", "/build/llvm-toolchain-snapshot-7~svn326551/lib/ObjectYAML/CodeViewYAMLTypes.cpp"
, 680)
;
681 }
682 return make_error<CodeViewError>(cv_error_code::corrupt_record);
683}
684
685CVType
686LeafRecord::toCodeViewRecord(AppendingTypeTableBuilder &Serializer) const {
687 return Leaf->toCodeViewRecord(Serializer);
688}
689
690namespace llvm {
691namespace yaml {
692
693template <> struct MappingTraits<LeafRecordBase> {
694 static void mapping(IO &io, LeafRecordBase &Record) { Record.map(io); }
695};
696
697template <> struct MappingTraits<MemberRecordBase> {
698 static void mapping(IO &io, MemberRecordBase &Record) { Record.map(io); }
699};
700
701} // end namespace yaml
702} // end namespace llvm
703
704template <typename ConcreteType>
705static void mapLeafRecordImpl(IO &IO, const char *Class, TypeLeafKind Kind,
706 LeafRecord &Obj) {
707 if (!IO.outputting())
708 Obj.Leaf = std::make_shared<LeafRecordImpl<ConcreteType>>(Kind);
709
710 if (Kind == LF_FIELDLIST)
711 Obj.Leaf->map(IO);
712 else
713 IO.mapRequired(Class, *Obj.Leaf);
714}
715
716void MappingTraits<LeafRecord>::mapping(IO &IO, LeafRecord &Obj) {
717 TypeLeafKind Kind;
718 if (IO.outputting())
719 Kind = Obj.Leaf->Kind;
720 IO.mapRequired("Kind", Kind);
721
722#define TYPE_RECORD(EnumName, EnumVal, ClassName) \
723 case EnumName: \
724 mapLeafRecordImpl<ClassName##Record>(IO, #ClassName, Kind, Obj); \
725 break;
726#define TYPE_RECORD_ALIAS(EnumName, EnumVal, AliasName, ClassName) \
727 TYPE_RECORD(EnumName, EnumVal, ClassName)
728#define MEMBER_RECORD(EnumName, EnumVal, ClassName)
729#define MEMBER_RECORD_ALIAS(EnumName, EnumVal, AliasName, ClassName)
730 switch (Kind) {
731#include "llvm/DebugInfo/CodeView/CodeViewTypes.def"
732 default: { llvm_unreachable("Unknown leaf kind!")::llvm::llvm_unreachable_internal("Unknown leaf kind!", "/build/llvm-toolchain-snapshot-7~svn326551/lib/ObjectYAML/CodeViewYAMLTypes.cpp"
, 732)
; }
733 }
734}
735
736template <typename ConcreteType>
737static void mapMemberRecordImpl(IO &IO, const char *Class, TypeLeafKind Kind,
738 MemberRecord &Obj) {
739 if (!IO.outputting())
740 Obj.Member = std::make_shared<MemberRecordImpl<ConcreteType>>(Kind);
741
742 IO.mapRequired(Class, *Obj.Member);
743}
744
745void MappingTraits<MemberRecord>::mapping(IO &IO, MemberRecord &Obj) {
746 TypeLeafKind Kind;
747 if (IO.outputting())
748 Kind = Obj.Member->Kind;
749 IO.mapRequired("Kind", Kind);
750
751#define MEMBER_RECORD(EnumName, EnumVal, ClassName) \
752 case EnumName: \
753 mapMemberRecordImpl<ClassName##Record>(IO, #ClassName, Kind, Obj); \
754 break;
755#define MEMBER_RECORD_ALIAS(EnumName, EnumVal, AliasName, ClassName) \
756 MEMBER_RECORD(EnumName, EnumVal, ClassName)
757#define TYPE_RECORD(EnumName, EnumVal, ClassName)
758#define TYPE_RECORD_ALIAS(EnumName, EnumVal, AliasName, ClassName)
759 switch (Kind) {
760#include "llvm/DebugInfo/CodeView/CodeViewTypes.def"
761 default: { llvm_unreachable("Unknown member kind!")::llvm::llvm_unreachable_internal("Unknown member kind!", "/build/llvm-toolchain-snapshot-7~svn326551/lib/ObjectYAML/CodeViewYAMLTypes.cpp"
, 761)
; }
762 }
763}
764
765std::vector<LeafRecord>
766llvm::CodeViewYAML::fromDebugT(ArrayRef<uint8_t> DebugT) {
767 ExitOnError Err("Invalid .debug$T section!");
768 BinaryStreamReader Reader(DebugT, support::little);
769 CVTypeArray Types;
770 uint32_t Magic;
1
'Magic' declared without an initial value
771
772 Err(Reader.readInteger(Magic));
2
Calling 'BinaryStreamReader::readInteger'
73
Returning from 'BinaryStreamReader::readInteger'
773 assert(Magic == COFF::DEBUG_SECTION_MAGIC && "Invalid .debug$T section!")(static_cast <bool> (Magic == COFF::DEBUG_SECTION_MAGIC
&& "Invalid .debug$T section!") ? void (0) : __assert_fail
("Magic == COFF::DEBUG_SECTION_MAGIC && \"Invalid .debug$T section!\""
, "/build/llvm-toolchain-snapshot-7~svn326551/lib/ObjectYAML/CodeViewYAMLTypes.cpp"
, 773, __extension__ __PRETTY_FUNCTION__))
;
74
Within the expansion of the macro 'assert':
a
The left operand of '==' is a garbage value
774
775 std::vector<LeafRecord> Result;
776 Err(Reader.readArray(Types, Reader.bytesRemaining()));
777 for (const auto &T : Types) {
778 auto CVT = Err(LeafRecord::fromCodeViewRecord(T));
779 Result.push_back(CVT);
780 }
781 return Result;
782}
783
784ArrayRef<uint8_t> llvm::CodeViewYAML::toDebugT(ArrayRef<LeafRecord> Leafs,
785 BumpPtrAllocator &Alloc) {
786 AppendingTypeTableBuilder TS(Alloc);
787 uint32_t Size = sizeof(uint32_t);
788 for (const auto &Leaf : Leafs) {
789 CVType T = Leaf.Leaf->toCodeViewRecord(TS);
790 Size += T.length();
791 assert(T.length() % 4 == 0 && "Improper type record alignment!")(static_cast <bool> (T.length() % 4 == 0 && "Improper type record alignment!"
) ? void (0) : __assert_fail ("T.length() % 4 == 0 && \"Improper type record alignment!\""
, "/build/llvm-toolchain-snapshot-7~svn326551/lib/ObjectYAML/CodeViewYAMLTypes.cpp"
, 791, __extension__ __PRETTY_FUNCTION__))
;
792 }
793 uint8_t *ResultBuffer = Alloc.Allocate<uint8_t>(Size);
794 MutableArrayRef<uint8_t> Output(ResultBuffer, Size);
795 BinaryStreamWriter Writer(Output, support::little);
796 ExitOnError Err("Error writing type record to .debug$T section");
797 Err(Writer.writeInteger<uint32_t>(COFF::DEBUG_SECTION_MAGIC));
798 for (const auto &R : TS.records()) {
799 Err(Writer.writeBytes(R));
800 }
801 assert(Writer.bytesRemaining() == 0 && "Didn't write all type record bytes!")(static_cast <bool> (Writer.bytesRemaining() == 0 &&
"Didn't write all type record bytes!") ? void (0) : __assert_fail
("Writer.bytesRemaining() == 0 && \"Didn't write all type record bytes!\""
, "/build/llvm-toolchain-snapshot-7~svn326551/lib/ObjectYAML/CodeViewYAMLTypes.cpp"
, 801, __extension__ __PRETTY_FUNCTION__))
;
802 return Output;
803}

/build/llvm-toolchain-snapshot-7~svn326551/include/llvm/Support/BinaryStreamReader.h

1//===- BinaryStreamReader.h - Reads objects from a binary stream *- 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#ifndef LLVM_SUPPORT_BINARYSTREAMREADER_H
11#define LLVM_SUPPORT_BINARYSTREAMREADER_H
12
13#include "llvm/ADT/ArrayRef.h"
14#include "llvm/ADT/STLExtras.h"
15#include "llvm/Support/BinaryStreamArray.h"
16#include "llvm/Support/BinaryStreamRef.h"
17#include "llvm/Support/ConvertUTF.h"
18#include "llvm/Support/Endian.h"
19#include "llvm/Support/Error.h"
20#include "llvm/Support/type_traits.h"
21
22#include <string>
23#include <type_traits>
24
25namespace llvm {
26
27/// \brief Provides read only access to a subclass of `BinaryStream`. Provides
28/// bounds checking and helpers for writing certain common data types such as
29/// null-terminated strings, integers in various flavors of endianness, etc.
30/// Can be subclassed to provide reading of custom datatypes, although no
31/// are overridable.
32class BinaryStreamReader {
33public:
34 BinaryStreamReader() = default;
35 explicit BinaryStreamReader(BinaryStreamRef Ref);
36 explicit BinaryStreamReader(BinaryStream &Stream);
37 explicit BinaryStreamReader(ArrayRef<uint8_t> Data,
38 llvm::support::endianness Endian);
39 explicit BinaryStreamReader(StringRef Data, llvm::support::endianness Endian);
40
41 BinaryStreamReader(const BinaryStreamReader &Other)
42 : Stream(Other.Stream), Offset(Other.Offset) {}
43
44 BinaryStreamReader &operator=(const BinaryStreamReader &Other) {
45 Stream = Other.Stream;
46 Offset = Other.Offset;
47 return *this;
48 }
49
50 virtual ~BinaryStreamReader() {}
51
52 /// Read as much as possible from the underlying string at the current offset
53 /// without invoking a copy, and set \p Buffer to the resulting data slice.
54 /// Updates the stream's offset to point after the newly read data.
55 ///
56 /// \returns a success error code if the data was successfully read, otherwise
57 /// returns an appropriate error code.
58 Error readLongestContiguousChunk(ArrayRef<uint8_t> &Buffer);
59
60 /// Read \p Size bytes from the underlying stream at the current offset and
61 /// and set \p Buffer to the resulting data slice. Whether a copy occurs
62 /// depends on the implementation of the underlying stream. Updates the
63 /// stream's offset to point after the newly read data.
64 ///
65 /// \returns a success error code if the data was successfully read, otherwise
66 /// returns an appropriate error code.
67 Error readBytes(ArrayRef<uint8_t> &Buffer, uint32_t Size);
68
69 /// Read an integer of the specified endianness into \p Dest and update the
70 /// stream's offset. The data is always copied from the stream's underlying
71 /// buffer into \p Dest. Updates the stream's offset to point after the newly
72 /// read data.
73 ///
74 /// \returns a success error code if the data was successfully read, otherwise
75 /// returns an appropriate error code.
76 template <typename T> Error readInteger(T &Dest) {
77 static_assert(std::is_integral<T>::value,
78 "Cannot call readInteger with non-integral value!");
79
80 ArrayRef<uint8_t> Bytes;
81 if (auto EC = readBytes(Bytes, sizeof(T)))
3
Calling move constructor for 'Error'
27
Returning from move constructor for 'Error'
28
Calling 'Error::operator bool'
37
Returning from 'Error::operator bool'
38
Taking true branch
82 return EC;
39
Calling move constructor for 'Error'
63
Returning from move constructor for 'Error'
64
Calling '~Error'
71
Returning from '~Error'
83
84 Dest = llvm::support::endian::read<T, llvm::support::unaligned>(
85 Bytes.data(), Stream.getEndian());
86 return Error::success();
87 }
72
Returning without writing to 'Dest'
88
89 /// Similar to readInteger.
90 template <typename T> Error readEnum(T &Dest) {
91 static_assert(std::is_enum<T>::value,
92 "Cannot call readEnum with non-enum value!");
93 typename std::underlying_type<T>::type N;
94 if (auto EC = readInteger(N))
95 return EC;
96 Dest = static_cast<T>(N);
97 return Error::success();
98 }
99
100 /// Read a null terminated string from \p Dest. Whether a copy occurs depends
101 /// on the implementation of the underlying stream. Updates the stream's
102 /// offset to point after the newly read data.
103 ///
104 /// \returns a success error code if the data was successfully read, otherwise
105 /// returns an appropriate error code.
106 Error readCString(StringRef &Dest);
107
108 /// Similar to readCString, however read a null-terminated UTF16 string
109 /// instead.
110 ///
111 /// \returns a success error code if the data was successfully read, otherwise
112 /// returns an appropriate error code.
113 Error readWideString(ArrayRef<UTF16> &Dest);
114
115 /// Read a \p Length byte string into \p Dest. Whether a copy occurs depends
116 /// on the implementation of the underlying stream. Updates the stream's
117 /// offset to point after the newly read data.
118 ///
119 /// \returns a success error code if the data was successfully read, otherwise
120 /// returns an appropriate error code.
121 Error readFixedString(StringRef &Dest, uint32_t Length);
122
123 /// Read the entire remainder of the underlying stream into \p Ref. This is
124 /// equivalent to calling getUnderlyingStream().slice(Offset). Updates the
125 /// stream's offset to point to the end of the stream. Never causes a copy.
126 ///
127 /// \returns a success error code if the data was successfully read, otherwise
128 /// returns an appropriate error code.
129 Error readStreamRef(BinaryStreamRef &Ref);
130
131 /// Read \p Length bytes from the underlying stream into \p Ref. This is
132 /// equivalent to calling getUnderlyingStream().slice(Offset, Length).
133 /// Updates the stream's offset to point after the newly read object. Never
134 /// causes a copy.
135 ///
136 /// \returns a success error code if the data was successfully read, otherwise
137 /// returns an appropriate error code.
138 Error readStreamRef(BinaryStreamRef &Ref, uint32_t Length);
139
140 /// Read \p Length bytes from the underlying stream into \p Stream. This is
141 /// equivalent to calling getUnderlyingStream().slice(Offset, Length).
142 /// Updates the stream's offset to point after the newly read object. Never
143 /// causes a copy.
144 ///
145 /// \returns a success error code if the data was successfully read, otherwise
146 /// returns an appropriate error code.
147 Error readSubstream(BinarySubstreamRef &Stream, uint32_t Size);
148
149 /// Get a pointer to an object of type T from the underlying stream, as if by
150 /// memcpy, and store the result into \p Dest. It is up to the caller to
151 /// ensure that objects of type T can be safely treated in this manner.
152 /// Updates the stream's offset to point after the newly read object. Whether
153 /// a copy occurs depends upon the implementation of the underlying
154 /// stream.
155 ///
156 /// \returns a success error code if the data was successfully read, otherwise
157 /// returns an appropriate error code.
158 template <typename T> Error readObject(const T *&Dest) {
159 ArrayRef<uint8_t> Buffer;
160 if (auto EC = readBytes(Buffer, sizeof(T)))
161 return EC;
162 Dest = reinterpret_cast<const T *>(Buffer.data());
163 return Error::success();
164 }
165
166 /// Get a reference to a \p NumElements element array of objects of type T
167 /// from the underlying stream as if by memcpy, and store the resulting array
168 /// slice into \p array. It is up to the caller to ensure that objects of
169 /// type T can be safely treated in this manner. Updates the stream's offset
170 /// to point after the newly read object. Whether a copy occurs depends upon
171 /// the implementation of the underlying stream.
172 ///
173 /// \returns a success error code if the data was successfully read, otherwise
174 /// returns an appropriate error code.
175 template <typename T>
176 Error readArray(ArrayRef<T> &Array, uint32_t NumElements) {
177 ArrayRef<uint8_t> Bytes;
178 if (NumElements == 0) {
179 Array = ArrayRef<T>();
180 return Error::success();
181 }
182
183 if (NumElements > UINT32_MAX(4294967295U) / sizeof(T))
184 return make_error<BinaryStreamError>(
185 stream_error_code::invalid_array_size);
186
187 if (auto EC = readBytes(Bytes, NumElements * sizeof(T)))
188 return EC;
189
190 assert(alignmentAdjustment(Bytes.data(), alignof(T)) == 0 &&(static_cast <bool> (alignmentAdjustment(Bytes.data(), alignof
(T)) == 0 && "Reading at invalid alignment!") ? void (
0) : __assert_fail ("alignmentAdjustment(Bytes.data(), alignof(T)) == 0 && \"Reading at invalid alignment!\""
, "/build/llvm-toolchain-snapshot-7~svn326551/include/llvm/Support/BinaryStreamReader.h"
, 191, __extension__ __PRETTY_FUNCTION__))
191 "Reading at invalid alignment!")(static_cast <bool> (alignmentAdjustment(Bytes.data(), alignof
(T)) == 0 && "Reading at invalid alignment!") ? void (
0) : __assert_fail ("alignmentAdjustment(Bytes.data(), alignof(T)) == 0 && \"Reading at invalid alignment!\""
, "/build/llvm-toolchain-snapshot-7~svn326551/include/llvm/Support/BinaryStreamReader.h"
, 191, __extension__ __PRETTY_FUNCTION__))
;
192
193 Array = ArrayRef<T>(reinterpret_cast<const T *>(Bytes.data()), NumElements);
194 return Error::success();
195 }
196
197 /// Read a VarStreamArray of size \p Size bytes and store the result into
198 /// \p Array. Updates the stream's offset to point after the newly read
199 /// array. Never causes a copy (although iterating the elements of the
200 /// VarStreamArray may, depending upon the implementation of the underlying
201 /// stream).
202 ///
203 /// \returns a success error code if the data was successfully read, otherwise
204 /// returns an appropriate error code.
205 template <typename T, typename U>
206 Error readArray(VarStreamArray<T, U> &Array, uint32_t Size) {
207 BinaryStreamRef S;
208 if (auto EC = readStreamRef(S, Size))
209 return EC;
210 Array.setUnderlyingStream(S);
211 return Error::success();
212 }
213
214 /// Read a FixedStreamArray of \p NumItems elements and store the result into
215 /// \p Array. Updates the stream's offset to point after the newly read
216 /// array. Never causes a copy (although iterating the elements of the
217 /// FixedStreamArray may, depending upon the implementation of the underlying
218 /// stream).
219 ///
220 /// \returns a success error code if the data was successfully read, otherwise
221 /// returns an appropriate error code.
222 template <typename T>
223 Error readArray(FixedStreamArray<T> &Array, uint32_t NumItems) {
224 if (NumItems == 0) {
225 Array = FixedStreamArray<T>();
226 return Error::success();
227 }
228
229 if (NumItems > UINT32_MAX(4294967295U) / sizeof(T))
230 return make_error<BinaryStreamError>(
231 stream_error_code::invalid_array_size);
232
233 BinaryStreamRef View;
234 if (auto EC = readStreamRef(View, NumItems * sizeof(T)))
235 return EC;
236
237 Array = FixedStreamArray<T>(View);
238 return Error::success();
239 }
240
241 bool empty() const { return bytesRemaining() == 0; }
242 void setOffset(uint32_t Off) { Offset = Off; }
243 uint32_t getOffset() const { return Offset; }
244 uint32_t getLength() const { return Stream.getLength(); }
245 uint32_t bytesRemaining() const { return getLength() - getOffset(); }
246
247 /// Advance the stream's offset by \p Amount bytes.
248 ///
249 /// \returns a success error code if at least \p Amount bytes remain in the
250 /// stream, otherwise returns an appropriate error code.
251 Error skip(uint32_t Amount);
252
253 /// Examine the next byte of the underlying stream without advancing the
254 /// stream's offset. If the stream is empty the behavior is undefined.
255 ///
256 /// \returns the next byte in the stream.
257 uint8_t peek() const;
258
259 Error padToAlignment(uint32_t Align);
260
261 std::pair<BinaryStreamReader, BinaryStreamReader>
262 split(uint32_t Offset) const;
263
264private:
265 BinaryStreamRef Stream;
266 uint32_t Offset = 0;
267};
268} // namespace llvm
269
270#endif // LLVM_SUPPORT_BINARYSTREAMREADER_H

/build/llvm-toolchain-snapshot-7~svn326551/include/llvm/Support/Error.h

1//===- llvm/Support/Error.h - Recoverable error handling --------*- 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 an API used to report recoverable errors.
11//
12//===----------------------------------------------------------------------===//
13
14#ifndef LLVM_SUPPORT_ERROR_H
15#define LLVM_SUPPORT_ERROR_H
16
17#include "llvm/ADT/SmallVector.h"
18#include "llvm/ADT/STLExtras.h"
19#include "llvm/ADT/StringExtras.h"
20#include "llvm/ADT/Twine.h"
21#include "llvm/Config/abi-breaking.h"
22#include "llvm/Support/AlignOf.h"
23#include "llvm/Support/Compiler.h"
24#include "llvm/Support/Debug.h"
25#include "llvm/Support/ErrorHandling.h"
26#include "llvm/Support/ErrorOr.h"
27#include "llvm/Support/raw_ostream.h"
28#include <algorithm>
29#include <cassert>
30#include <cstdint>
31#include <cstdlib>
32#include <functional>
33#include <memory>
34#include <new>
35#include <string>
36#include <system_error>
37#include <type_traits>
38#include <utility>
39#include <vector>
40
41namespace llvm {
42
43class ErrorSuccess;
44
45/// Base class for error info classes. Do not extend this directly: Extend
46/// the ErrorInfo template subclass instead.
47class ErrorInfoBase {
48public:
49 virtual ~ErrorInfoBase() = default;
50
51 /// Print an error message to an output stream.
52 virtual void log(raw_ostream &OS) const = 0;
53
54 /// Return the error message as a string.
55 virtual std::string message() const {
56 std::string Msg;
57 raw_string_ostream OS(Msg);
58 log(OS);
59 return OS.str();
60 }
61
62 /// Convert this error to a std::error_code.
63 ///
64 /// This is a temporary crutch to enable interaction with code still
65 /// using std::error_code. It will be removed in the future.
66 virtual std::error_code convertToErrorCode() const = 0;
67
68 // Returns the class ID for this type.
69 static const void *classID() { return &ID; }
70
71 // Returns the class ID for the dynamic type of this ErrorInfoBase instance.
72 virtual const void *dynamicClassID() const = 0;
73
74 // Check whether this instance is a subclass of the class identified by
75 // ClassID.
76 virtual bool isA(const void *const ClassID) const {
77 return ClassID == classID();
78 }
79
80 // Check whether this instance is a subclass of ErrorInfoT.
81 template <typename ErrorInfoT> bool isA() const {
82 return isA(ErrorInfoT::classID());
83 }
84
85private:
86 virtual void anchor();
87
88 static char ID;
89};
90
91/// Lightweight error class with error context and mandatory checking.
92///
93/// Instances of this class wrap a ErrorInfoBase pointer. Failure states
94/// are represented by setting the pointer to a ErrorInfoBase subclass
95/// instance containing information describing the failure. Success is
96/// represented by a null pointer value.
97///
98/// Instances of Error also contains a 'Checked' flag, which must be set
99/// before the destructor is called, otherwise the destructor will trigger a
100/// runtime error. This enforces at runtime the requirement that all Error
101/// instances be checked or returned to the caller.
102///
103/// There are two ways to set the checked flag, depending on what state the
104/// Error instance is in. For Error instances indicating success, it
105/// is sufficient to invoke the boolean conversion operator. E.g.:
106///
107/// @code{.cpp}
108/// Error foo(<...>);
109///
110/// if (auto E = foo(<...>))
111/// return E; // <- Return E if it is in the error state.
112/// // We have verified that E was in the success state. It can now be safely
113/// // destroyed.
114/// @endcode
115///
116/// A success value *can not* be dropped. For example, just calling 'foo(<...>)'
117/// without testing the return value will raise a runtime error, even if foo
118/// returns success.
119///
120/// For Error instances representing failure, you must use either the
121/// handleErrors or handleAllErrors function with a typed handler. E.g.:
122///
123/// @code{.cpp}
124/// class MyErrorInfo : public ErrorInfo<MyErrorInfo> {
125/// // Custom error info.
126/// };
127///
128/// Error foo(<...>) { return make_error<MyErrorInfo>(...); }
129///
130/// auto E = foo(<...>); // <- foo returns failure with MyErrorInfo.
131/// auto NewE =
132/// handleErrors(E,
133/// [](const MyErrorInfo &M) {
134/// // Deal with the error.
135/// },
136/// [](std::unique_ptr<OtherError> M) -> Error {
137/// if (canHandle(*M)) {
138/// // handle error.
139/// return Error::success();
140/// }
141/// // Couldn't handle this error instance. Pass it up the stack.
142/// return Error(std::move(M));
143/// );
144/// // Note - we must check or return NewE in case any of the handlers
145/// // returned a new error.
146/// @endcode
147///
148/// The handleAllErrors function is identical to handleErrors, except
149/// that it has a void return type, and requires all errors to be handled and
150/// no new errors be returned. It prevents errors (assuming they can all be
151/// handled) from having to be bubbled all the way to the top-level.
152///
153/// *All* Error instances must be checked before destruction, even if
154/// they're moved-assigned or constructed from Success values that have already
155/// been checked. This enforces checking through all levels of the call stack.
156class LLVM_NODISCARD[[clang::warn_unused_result]] Error {
157 // ErrorList needs to be able to yank ErrorInfoBase pointers out of this
158 // class to add to the error list.
159 friend class ErrorList;
160
161 // handleErrors needs to be able to set the Checked flag.
162 template <typename... HandlerTs>
163 friend Error handleErrors(Error E, HandlerTs &&... Handlers);
164
165 // Expected<T> needs to be able to steal the payload when constructed from an
166 // error.
167 template <typename T> friend class Expected;
168
169protected:
170 /// Create a success value. Prefer using 'Error::success()' for readability
171 Error() {
172 setPtr(nullptr);
173 setChecked(false);
174 }
175
176public:
177 /// Create a success value.
178 static ErrorSuccess success();
179
180 // Errors are not copy-constructable.
181 Error(const Error &Other) = delete;
182
183 /// Move-construct an error value. The newly constructed error is considered
184 /// unchecked, even if the source error had been checked. The original error
185 /// becomes a checked Success value, regardless of its original state.
186 Error(Error &&Other) {
187 setChecked(true);
4
Calling 'Error::setChecked'
6
Returning from 'Error::setChecked'
40
Calling 'Error::setChecked'
42
Returning from 'Error::setChecked'
188 *this = std::move(Other);
7
Calling 'move'
8
Returning from 'move'
9
Calling move assignment operator for 'Error'
26
Returning from move assignment operator for 'Error'
43
Calling 'move'
44
Returning from 'move'
45
Calling move assignment operator for 'Error'
62
Returning from move assignment operator for 'Error'
189 }
190
191 /// Create an error value. Prefer using the 'make_error' function, but
192 /// this constructor can be useful when "re-throwing" errors from handlers.
193 Error(std::unique_ptr<ErrorInfoBase> Payload) {
194 setPtr(Payload.release());
195 setChecked(false);
196 }
197
198 // Errors are not copy-assignable.
199 Error &operator=(const Error &Other) = delete;
200
201 /// Move-assign an error value. The current error must represent success, you
202 /// you cannot overwrite an unhandled error. The current error is then
203 /// considered unchecked. The source error becomes a checked success value,
204 /// regardless of its original state.
205 Error &operator=(Error &&Other) {
206 // Don't allow overwriting of unchecked values.
207 assertIsChecked();
10
Calling 'Error::assertIsChecked'
13
Returning from 'Error::assertIsChecked'
46
Calling 'Error::assertIsChecked'
49
Returning from 'Error::assertIsChecked'
208 setPtr(Other.getPtr());
14
Calling 'Error::getPtr'
15
Returning from 'Error::getPtr'
16
Calling 'Error::setPtr'
17
Returning from 'Error::setPtr'
50
Calling 'Error::getPtr'
51
Returning from 'Error::getPtr'
52
Calling 'Error::setPtr'
53
Returning from 'Error::setPtr'
209
210 // This Error is unchecked, even if the source error was checked.
211 setChecked(false);
18
Calling 'Error::setChecked'
20
Returning from 'Error::setChecked'
54
Calling 'Error::setChecked'
56
Returning from 'Error::setChecked'
212
213 // Null out Other's payload and set its checked bit.
214 Other.setPtr(nullptr);
21
Calling 'Error::setPtr'
22
Returning from 'Error::setPtr'
57
Calling 'Error::setPtr'
58
Returning from 'Error::setPtr'
215 Other.setChecked(true);
23
Calling 'Error::setChecked'
25
Returning from 'Error::setChecked'
59
Calling 'Error::setChecked'
61
Returning from 'Error::setChecked'
216
217 return *this;
218 }
219
220 /// Destroy a Error. Fails with a call to abort() if the error is
221 /// unchecked.
222 ~Error() {
223 assertIsChecked();
65
Calling 'Error::assertIsChecked'
68
Returning from 'Error::assertIsChecked'
224 delete getPtr();
69
Calling 'Error::getPtr'
70
Returning from 'Error::getPtr'
225 }
226
227 /// Bool conversion. Returns true if this Error is in a failure state,
228 /// and false if it is in an accept state. If the error is in a Success state
229 /// it will be considered checked.
230 explicit operator bool() {
231 setChecked(getPtr() == nullptr);
29
Calling 'Error::getPtr'
30
Returning from 'Error::getPtr'
31
Calling 'Error::setChecked'
34
Returning from 'Error::setChecked'
232 return getPtr() != nullptr;
35
Calling 'Error::getPtr'
36
Returning from 'Error::getPtr'
233 }
234
235 /// Check whether one error is a subclass of another.
236 template <typename ErrT> bool isA() const {
237 return getPtr() && getPtr()->isA(ErrT::classID());
238 }
239
240 /// Returns the dynamic class id of this error, or null if this is a success
241 /// value.
242 const void* dynamicClassID() const {
243 if (!getPtr())
244 return nullptr;
245 return getPtr()->dynamicClassID();
246 }
247
248private:
249#if LLVM_ENABLE_ABI_BREAKING_CHECKS1
250 // assertIsChecked() happens very frequently, but under normal circumstances
251 // is supposed to be a no-op. So we want it to be inlined, but having a bunch
252 // of debug prints can cause the function to be too large for inlining. So
253 // it's important that we define this function out of line so that it can't be
254 // inlined.
255 LLVM_ATTRIBUTE_NORETURN__attribute__((noreturn))
256 void fatalUncheckedError() const;
257#endif
258
259 void assertIsChecked() {
260#if LLVM_ENABLE_ABI_BREAKING_CHECKS1
261 if (LLVM_UNLIKELY(!getChecked() || getPtr())__builtin_expect((bool)(!getChecked() || getPtr()), false))
11
Within the expansion of the macro 'LLVM_UNLIKELY':
a
Calling 'Error::getChecked'
b
Returning from 'Error::getChecked'
c
Calling 'Error::getPtr'
d
Returning from 'Error::getPtr'
12
Taking false branch
47
Within the expansion of the macro 'LLVM_UNLIKELY':
a
Calling 'Error::getChecked'
b
Returning from 'Error::getChecked'
c
Calling 'Error::getPtr'
d
Returning from 'Error::getPtr'
48
Taking false branch
66
Within the expansion of the macro 'LLVM_UNLIKELY':
a
Calling 'Error::getChecked'
b
Returning from 'Error::getChecked'
67
Taking false branch
262 fatalUncheckedError();
263#endif
264 }
265
266 ErrorInfoBase *getPtr() const {
267 return reinterpret_cast<ErrorInfoBase*>(
268 reinterpret_cast<uintptr_t>(Payload) &
269 ~static_cast<uintptr_t>(0x1));
270 }
271
272 void setPtr(ErrorInfoBase *EI) {
273#if LLVM_ENABLE_ABI_BREAKING_CHECKS1
274 Payload = reinterpret_cast<ErrorInfoBase*>(
275 (reinterpret_cast<uintptr_t>(EI) &
276 ~static_cast<uintptr_t>(0x1)) |
277 (reinterpret_cast<uintptr_t>(Payload) & 0x1));
278#else
279 Payload = EI;
280#endif
281 }
282
283 bool getChecked() const {
284#if LLVM_ENABLE_ABI_BREAKING_CHECKS1
285 return (reinterpret_cast<uintptr_t>(Payload) & 0x1) == 0;
286#else
287 return true;
288#endif
289 }
290
291 void setChecked(bool V) {
292 Payload = reinterpret_cast<ErrorInfoBase*>(
293 (reinterpret_cast<uintptr_t>(Payload) &
294 ~static_cast<uintptr_t>(0x1)) |
295 (V ? 0 : 1));
5
'?' condition is true
19
'?' condition is false
24
'?' condition is true
32
Assuming 'V' is 0
33
'?' condition is false
41
'?' condition is true
55
'?' condition is false
60
'?' condition is true
296 }
297
298 std::unique_ptr<ErrorInfoBase> takePayload() {
299 std::unique_ptr<ErrorInfoBase> Tmp(getPtr());
300 setPtr(nullptr);
301 setChecked(true);
302 return Tmp;
303 }
304
305 ErrorInfoBase *Payload = nullptr;
306};
307
308/// Subclass of Error for the sole purpose of identifying the success path in
309/// the type system. This allows to catch invalid conversion to Expected<T> at
310/// compile time.
311class ErrorSuccess : public Error {};
312
313inline ErrorSuccess Error::success() { return ErrorSuccess(); }
314
315/// Make a Error instance representing failure using the given error info
316/// type.
317template <typename ErrT, typename... ArgTs> Error make_error(ArgTs &&... Args) {
318 return Error(llvm::make_unique<ErrT>(std::forward<ArgTs>(Args)...));
319}
320
321/// Base class for user error types. Users should declare their error types
322/// like:
323///
324/// class MyError : public ErrorInfo<MyError> {
325/// ....
326/// };
327///
328/// This class provides an implementation of the ErrorInfoBase::kind
329/// method, which is used by the Error RTTI system.
330template <typename ThisErrT, typename ParentErrT = ErrorInfoBase>
331class ErrorInfo : public ParentErrT {
332public:
333 static const void *classID() { return &ThisErrT::ID; }
334
335 const void *dynamicClassID() const override { return &ThisErrT::ID; }
336
337 bool isA(const void *const ClassID) const override {
338 return ClassID == classID() || ParentErrT::isA(ClassID);
339 }
340};
341
342/// Special ErrorInfo subclass representing a list of ErrorInfos.
343/// Instances of this class are constructed by joinError.
344class ErrorList final : public ErrorInfo<ErrorList> {
345 // handleErrors needs to be able to iterate the payload list of an
346 // ErrorList.
347 template <typename... HandlerTs>
348 friend Error handleErrors(Error E, HandlerTs &&... Handlers);
349
350 // joinErrors is implemented in terms of join.
351 friend Error joinErrors(Error, Error);
352
353public:
354 void log(raw_ostream &OS) const override {
355 OS << "Multiple errors:\n";
356 for (auto &ErrPayload : Payloads) {
357 ErrPayload->log(OS);
358 OS << "\n";
359 }
360 }
361
362 std::error_code convertToErrorCode() const override;
363
364 // Used by ErrorInfo::classID.
365 static char ID;
366
367private:
368 ErrorList(std::unique_ptr<ErrorInfoBase> Payload1,
369 std::unique_ptr<ErrorInfoBase> Payload2) {
370 assert(!Payload1->isA<ErrorList>() && !Payload2->isA<ErrorList>() &&(static_cast <bool> (!Payload1->isA<ErrorList>
() && !Payload2->isA<ErrorList>() &&
"ErrorList constructor payloads should be singleton errors")
? void (0) : __assert_fail ("!Payload1->isA<ErrorList>() && !Payload2->isA<ErrorList>() && \"ErrorList constructor payloads should be singleton errors\""
, "/build/llvm-toolchain-snapshot-7~svn326551/include/llvm/Support/Error.h"
, 371, __extension__ __PRETTY_FUNCTION__))
371 "ErrorList constructor payloads should be singleton errors")(static_cast <bool> (!Payload1->isA<ErrorList>
() && !Payload2->isA<ErrorList>() &&
"ErrorList constructor payloads should be singleton errors")
? void (0) : __assert_fail ("!Payload1->isA<ErrorList>() && !Payload2->isA<ErrorList>() && \"ErrorList constructor payloads should be singleton errors\""
, "/build/llvm-toolchain-snapshot-7~svn326551/include/llvm/Support/Error.h"
, 371, __extension__ __PRETTY_FUNCTION__))
;
372 Payloads.push_back(std::move(Payload1));
373 Payloads.push_back(std::move(Payload2));
374 }
375
376 static Error join(Error E1, Error E2) {
377 if (!E1)
378 return E2;
379 if (!E2)
380 return E1;
381 if (E1.isA<ErrorList>()) {
382 auto &E1List = static_cast<ErrorList &>(*E1.getPtr());
383 if (E2.isA<ErrorList>()) {
384 auto E2Payload = E2.takePayload();
385 auto &E2List = static_cast<ErrorList &>(*E2Payload);
386 for (auto &Payload : E2List.Payloads)
387 E1List.Payloads.push_back(std::move(Payload));
388 } else
389 E1List.Payloads.push_back(E2.takePayload());
390
391 return E1;
392 }
393 if (E2.isA<ErrorList>()) {
394 auto &E2List = static_cast<ErrorList &>(*E2.getPtr());
395 E2List.Payloads.insert(E2List.Payloads.begin(), E1.takePayload());
396 return E2;
397 }
398 return Error(std::unique_ptr<ErrorList>(
399 new ErrorList(E1.takePayload(), E2.takePayload())));
400 }
401
402 std::vector<std::unique_ptr<ErrorInfoBase>> Payloads;
403};
404
405/// Concatenate errors. The resulting Error is unchecked, and contains the
406/// ErrorInfo(s), if any, contained in E1, followed by the
407/// ErrorInfo(s), if any, contained in E2.
408inline Error joinErrors(Error E1, Error E2) {
409 return ErrorList::join(std::move(E1), std::move(E2));
410}
411
412/// Tagged union holding either a T or a Error.
413///
414/// This class parallels ErrorOr, but replaces error_code with Error. Since
415/// Error cannot be copied, this class replaces getError() with
416/// takeError(). It also adds an bool errorIsA<ErrT>() method for testing the
417/// error class type.
418template <class T> class LLVM_NODISCARD[[clang::warn_unused_result]] Expected {
419 template <class T1> friend class ExpectedAsOutParameter;
420 template <class OtherT> friend class Expected;
421
422 static const bool isRef = std::is_reference<T>::value;
423
424 using wrap = ReferenceStorage<typename std::remove_reference<T>::type>;
425
426 using error_type = std::unique_ptr<ErrorInfoBase>;
427
428public:
429 using storage_type = typename std::conditional<isRef, wrap, T>::type;
430 using value_type = T;
431
432private:
433 using reference = typename std::remove_reference<T>::type &;
434 using const_reference = const typename std::remove_reference<T>::type &;
435 using pointer = typename std::remove_reference<T>::type *;
436 using const_pointer = const typename std::remove_reference<T>::type *;
437
438public:
439 /// Create an Expected<T> error value from the given Error.
440 Expected(Error Err)
441 : HasError(true)
442#if LLVM_ENABLE_ABI_BREAKING_CHECKS1
443 // Expected is unchecked upon construction in Debug builds.
444 , Unchecked(true)
445#endif
446 {
447 assert(Err && "Cannot create Expected<T> from Error success value.")(static_cast <bool> (Err && "Cannot create Expected<T> from Error success value."
) ? void (0) : __assert_fail ("Err && \"Cannot create Expected<T> from Error success value.\""
, "/build/llvm-toolchain-snapshot-7~svn326551/include/llvm/Support/Error.h"
, 447, __extension__ __PRETTY_FUNCTION__))
;
448 new (getErrorStorage()) error_type(Err.takePayload());
449 }
450
451 /// Forbid to convert from Error::success() implicitly, this avoids having
452 /// Expected<T> foo() { return Error::success(); } which compiles otherwise
453 /// but triggers the assertion above.
454 Expected(ErrorSuccess) = delete;
455
456 /// Create an Expected<T> success value from the given OtherT value, which
457 /// must be convertible to T.
458 template <typename OtherT>
459 Expected(OtherT &&Val,
460 typename std::enable_if<std::is_convertible<OtherT, T>::value>::type
461 * = nullptr)
462 : HasError(false)
463#if LLVM_ENABLE_ABI_BREAKING_CHECKS1
464 // Expected is unchecked upon construction in Debug builds.
465 , Unchecked(true)
466#endif
467 {
468 new (getStorage()) storage_type(std::forward<OtherT>(Val));
469 }
470
471 /// Move construct an Expected<T> value.
472 Expected(Expected &&Other) { moveConstruct(std::move(Other)); }
473
474 /// Move construct an Expected<T> value from an Expected<OtherT>, where OtherT
475 /// must be convertible to T.
476 template <class OtherT>
477 Expected(Expected<OtherT> &&Other,
478 typename std::enable_if<std::is_convertible<OtherT, T>::value>::type
479 * = nullptr) {
480 moveConstruct(std::move(Other));
481 }
482
483 /// Move construct an Expected<T> value from an Expected<OtherT>, where OtherT
484 /// isn't convertible to T.
485 template <class OtherT>
486 explicit Expected(
487 Expected<OtherT> &&Other,
488 typename std::enable_if<!std::is_convertible<OtherT, T>::value>::type * =
489 nullptr) {
490 moveConstruct(std::move(Other));
491 }
492
493 /// Move-assign from another Expected<T>.
494 Expected &operator=(Expected &&Other) {
495 moveAssign(std::move(Other));
496 return *this;
497 }
498
499 /// Destroy an Expected<T>.
500 ~Expected() {
501 assertIsChecked();
502 if (!HasError)
503 getStorage()->~storage_type();
504 else
505 getErrorStorage()->~error_type();
506 }
507
508 /// \brief Return false if there is an error.
509 explicit operator bool() {
510#if LLVM_ENABLE_ABI_BREAKING_CHECKS1
511 Unchecked = HasError;
512#endif
513 return !HasError;
514 }
515
516 /// \brief Returns a reference to the stored T value.
517 reference get() {
518 assertIsChecked();
519 return *getStorage();
520 }
521
522 /// \brief Returns a const reference to the stored T value.
523 const_reference get() const {
524 assertIsChecked();
525 return const_cast<Expected<T> *>(this)->get();
526 }
527
528 /// \brief Check that this Expected<T> is an error of type ErrT.
529 template <typename ErrT> bool errorIsA() const {
530 return HasError && (*getErrorStorage())->template isA<ErrT>();
531 }
532
533 /// \brief Take ownership of the stored error.
534 /// After calling this the Expected<T> is in an indeterminate state that can
535 /// only be safely destructed. No further calls (beside the destructor) should
536 /// be made on the Expected<T> vaule.
537 Error takeError() {
538#if LLVM_ENABLE_ABI_BREAKING_CHECKS1
539 Unchecked = false;
540#endif
541 return HasError ? Error(std::move(*getErrorStorage())) : Error::success();
542 }
543
544 /// \brief Returns a pointer to the stored T value.
545 pointer operator->() {
546 assertIsChecked();
547 return toPointer(getStorage());
548 }
549
550 /// \brief Returns a const pointer to the stored T value.
551 const_pointer operator->() const {
552 assertIsChecked();
553 return toPointer(getStorage());
554 }
555
556 /// \brief Returns a reference to the stored T value.
557 reference operator*() {
558 assertIsChecked();
559 return *getStorage();
560 }
561
562 /// \brief Returns a const reference to the stored T value.
563 const_reference operator*() const {
564 assertIsChecked();
565 return *getStorage();
566 }
567
568private:
569 template <class T1>
570 static bool compareThisIfSameType(const T1 &a, const T1 &b) {
571 return &a == &b;
572 }
573
574 template <class T1, class T2>
575 static bool compareThisIfSameType(const T1 &a, const T2 &b) {
576 return false;
577 }
578
579 template <class OtherT> void moveConstruct(Expected<OtherT> &&Other) {
580 HasError = Other.HasError;
581#if LLVM_ENABLE_ABI_BREAKING_CHECKS1
582 Unchecked = true;
583 Other.Unchecked = false;
584#endif
585
586 if (!HasError)
587 new (getStorage()) storage_type(std::move(*Other.getStorage()));
588 else
589 new (getErrorStorage()) error_type(std::move(*Other.getErrorStorage()));
590 }
591
592 template <class OtherT> void moveAssign(Expected<OtherT> &&Other) {
593 assertIsChecked();
594
595 if (compareThisIfSameType(*this, Other))
596 return;
597
598 this->~Expected();
599 new (this) Expected(std::move(Other));
600 }
601
602 pointer toPointer(pointer Val) { return Val; }
603
604 const_pointer toPointer(const_pointer Val) const { return Val; }
605
606 pointer toPointer(wrap *Val) { return &Val->get(); }
607
608 const_pointer toPointer(const wrap *Val) const { return &Val->get(); }
609
610 storage_type *getStorage() {
611 assert(!HasError && "Cannot get value when an error exists!")(static_cast <bool> (!HasError && "Cannot get value when an error exists!"
) ? void (0) : __assert_fail ("!HasError && \"Cannot get value when an error exists!\""
, "/build/llvm-toolchain-snapshot-7~svn326551/include/llvm/Support/Error.h"
, 611, __extension__ __PRETTY_FUNCTION__))
;
612 return reinterpret_cast<storage_type *>(TStorage.buffer);
613 }
614
615 const storage_type *getStorage() const {
616 assert(!HasError && "Cannot get value when an error exists!")(static_cast <bool> (!HasError && "Cannot get value when an error exists!"
) ? void (0) : __assert_fail ("!HasError && \"Cannot get value when an error exists!\""
, "/build/llvm-toolchain-snapshot-7~svn326551/include/llvm/Support/Error.h"
, 616, __extension__ __PRETTY_FUNCTION__))
;
617 return reinterpret_cast<const storage_type *>(TStorage.buffer);
618 }
619
620 error_type *getErrorStorage() {
621 assert(HasError && "Cannot get error when a value exists!")(static_cast <bool> (HasError && "Cannot get error when a value exists!"
) ? void (0) : __assert_fail ("HasError && \"Cannot get error when a value exists!\""
, "/build/llvm-toolchain-snapshot-7~svn326551/include/llvm/Support/Error.h"
, 621, __extension__ __PRETTY_FUNCTION__))
;
622 return reinterpret_cast<error_type *>(ErrorStorage.buffer);
623 }
624
625 const error_type *getErrorStorage() const {
626 assert(HasError && "Cannot get error when a value exists!")(static_cast <bool> (HasError && "Cannot get error when a value exists!"
) ? void (0) : __assert_fail ("HasError && \"Cannot get error when a value exists!\""
, "/build/llvm-toolchain-snapshot-7~svn326551/include/llvm/Support/Error.h"
, 626, __extension__ __PRETTY_FUNCTION__))
;
627 return reinterpret_cast<const error_type *>(ErrorStorage.buffer);
628 }
629
630 // Used by ExpectedAsOutParameter to reset the checked flag.
631 void setUnchecked() {
632#if LLVM_ENABLE_ABI_BREAKING_CHECKS1
633 Unchecked = true;
634#endif
635 }
636
637#if LLVM_ENABLE_ABI_BREAKING_CHECKS1
638 LLVM_ATTRIBUTE_NORETURN__attribute__((noreturn))
639 LLVM_ATTRIBUTE_NOINLINE__attribute__((noinline))
640 void fatalUncheckedExpected() const {
641 dbgs() << "Expected<T> must be checked before access or destruction.\n";
642 if (HasError) {
643 dbgs() << "Unchecked Expected<T> contained error:\n";
644 (*getErrorStorage())->log(dbgs());
645 } else
646 dbgs() << "Expected<T> value was in success state. (Note: Expected<T> "
647 "values in success mode must still be checked prior to being "
648 "destroyed).\n";
649 abort();
650 }
651#endif
652
653 void assertIsChecked() {
654#if LLVM_ENABLE_ABI_BREAKING_CHECKS1
655 if (LLVM_UNLIKELY(Unchecked)__builtin_expect((bool)(Unchecked), false))
656 fatalUncheckedExpected();
657#endif
658 }
659
660 union {
661 AlignedCharArrayUnion<storage_type> TStorage;
662 AlignedCharArrayUnion<error_type> ErrorStorage;
663 };
664 bool HasError : 1;
665#if LLVM_ENABLE_ABI_BREAKING_CHECKS1
666 bool Unchecked : 1;
667#endif
668};
669
670/// Report a serious error, calling any installed error handler. See
671/// ErrorHandling.h.
672LLVM_ATTRIBUTE_NORETURN__attribute__((noreturn)) void report_fatal_error(Error Err,
673 bool gen_crash_diag = true);
674
675/// Report a fatal error if Err is a failure value.
676///
677/// This function can be used to wrap calls to fallible functions ONLY when it
678/// is known that the Error will always be a success value. E.g.
679///
680/// @code{.cpp}
681/// // foo only attempts the fallible operation if DoFallibleOperation is
682/// // true. If DoFallibleOperation is false then foo always returns
683/// // Error::success().
684/// Error foo(bool DoFallibleOperation);
685///
686/// cantFail(foo(false));
687/// @endcode
688inline void cantFail(Error Err, const char *Msg = nullptr) {
689 if (Err) {
690 if (!Msg)
691 Msg = "Failure value returned from cantFail wrapped call";
692 llvm_unreachable(Msg)::llvm::llvm_unreachable_internal(Msg, "/build/llvm-toolchain-snapshot-7~svn326551/include/llvm/Support/Error.h"
, 692)
;
693 }
694}
695
696/// Report a fatal error if ValOrErr is a failure value, otherwise unwraps and
697/// returns the contained value.
698///
699/// This function can be used to wrap calls to fallible functions ONLY when it
700/// is known that the Error will always be a success value. E.g.
701///
702/// @code{.cpp}
703/// // foo only attempts the fallible operation if DoFallibleOperation is
704/// // true. If DoFallibleOperation is false then foo always returns an int.
705/// Expected<int> foo(bool DoFallibleOperation);
706///
707/// int X = cantFail(foo(false));
708/// @endcode
709template <typename T>
710T cantFail(Expected<T> ValOrErr, const char *Msg = nullptr) {
711 if (ValOrErr)
712 return std::move(*ValOrErr);
713 else {
714 if (!Msg)
715 Msg = "Failure value returned from cantFail wrapped call";
716 llvm_unreachable(Msg)::llvm::llvm_unreachable_internal(Msg, "/build/llvm-toolchain-snapshot-7~svn326551/include/llvm/Support/Error.h"
, 716)
;
717 }
718}
719
720/// Report a fatal error if ValOrErr is a failure value, otherwise unwraps and
721/// returns the contained reference.
722///
723/// This function can be used to wrap calls to fallible functions ONLY when it
724/// is known that the Error will always be a success value. E.g.
725///
726/// @code{.cpp}
727/// // foo only attempts the fallible operation if DoFallibleOperation is
728/// // true. If DoFallibleOperation is false then foo always returns a Bar&.
729/// Expected<Bar&> foo(bool DoFallibleOperation);
730///
731/// Bar &X = cantFail(foo(false));
732/// @endcode
733template <typename T>
734T& cantFail(Expected<T&> ValOrErr, const char *Msg = nullptr) {
735 if (ValOrErr)
736 return *ValOrErr;
737 else {
738 if (!Msg)
739 Msg = "Failure value returned from cantFail wrapped call";
740 llvm_unreachable(Msg)::llvm::llvm_unreachable_internal(Msg, "/build/llvm-toolchain-snapshot-7~svn326551/include/llvm/Support/Error.h"
, 740)
;
741 }
742}
743
744/// Helper for testing applicability of, and applying, handlers for
745/// ErrorInfo types.
746template <typename HandlerT>
747class ErrorHandlerTraits
748 : public ErrorHandlerTraits<decltype(
749 &std::remove_reference<HandlerT>::type::operator())> {};
750
751// Specialization functions of the form 'Error (const ErrT&)'.
752template <typename ErrT> class ErrorHandlerTraits<Error (&)(ErrT &)> {
753public:
754 static bool appliesTo(const ErrorInfoBase &E) {
755 return E.template isA<ErrT>();
756 }
757
758 template <typename HandlerT>
759 static Error apply(HandlerT &&H, std::unique_ptr<ErrorInfoBase> E) {
760 assert(appliesTo(*E) && "Applying incorrect handler")(static_cast <bool> (appliesTo(*E) && "Applying incorrect handler"
) ? void (0) : __assert_fail ("appliesTo(*E) && \"Applying incorrect handler\""
, "/build/llvm-toolchain-snapshot-7~svn326551/include/llvm/Support/Error.h"
, 760, __extension__ __PRETTY_FUNCTION__))
;
761 return H(static_cast<ErrT &>(*E));
762 }
763};
764
765// Specialization functions of the form 'void (const ErrT&)'.
766template <typename ErrT> class ErrorHandlerTraits<void (&)(ErrT &)> {
767public:
768 static bool appliesTo(const ErrorInfoBase &E) {
769 return E.template isA<ErrT>();
770 }
771
772 template <typename HandlerT>
773 static Error apply(HandlerT &&H, std::unique_ptr<ErrorInfoBase> E) {
774 assert(appliesTo(*E) && "Applying incorrect handler")(static_cast <bool> (appliesTo(*E) && "Applying incorrect handler"
) ? void (0) : __assert_fail ("appliesTo(*E) && \"Applying incorrect handler\""
, "/build/llvm-toolchain-snapshot-7~svn326551/include/llvm/Support/Error.h"
, 774, __extension__ __PRETTY_FUNCTION__))
;
775 H(static_cast<ErrT &>(*E));
776 return Error::success();
777 }
778};
779
780/// Specialization for functions of the form 'Error (std::unique_ptr<ErrT>)'.
781template <typename ErrT>
782class ErrorHandlerTraits<Error (&)(std::unique_ptr<ErrT>)> {
783public:
784 static bool appliesTo(const ErrorInfoBase &E) {
785 return E.template isA<ErrT>();
786 }
787
788 template <typename HandlerT>
789 static Error apply(HandlerT &&H, std::unique_ptr<ErrorInfoBase> E) {
790 assert(appliesTo(*E) && "Applying incorrect handler")(static_cast <bool> (appliesTo(*E) && "Applying incorrect handler"
) ? void (0) : __assert_fail ("appliesTo(*E) && \"Applying incorrect handler\""
, "/build/llvm-toolchain-snapshot-7~svn326551/include/llvm/Support/Error.h"
, 790, __extension__ __PRETTY_FUNCTION__))
;
791 std::unique_ptr<ErrT> SubE(static_cast<ErrT *>(E.release()));
792 return H(std::move(SubE));
793 }
794};
795
796/// Specialization for functions of the form 'void (std::unique_ptr<ErrT>)'.
797template <typename ErrT>
798class ErrorHandlerTraits<void (&)(std::unique_ptr<ErrT>)> {
799public:
800 static bool appliesTo(const ErrorInfoBase &E) {
801 return E.template isA<ErrT>();
802 }
803
804 template <typename HandlerT>
805 static Error apply(HandlerT &&H, std::unique_ptr<ErrorInfoBase> E) {
806 assert(appliesTo(*E) && "Applying incorrect handler")(static_cast <bool> (appliesTo(*E) && "Applying incorrect handler"
) ? void (0) : __assert_fail ("appliesTo(*E) && \"Applying incorrect handler\""
, "/build/llvm-toolchain-snapshot-7~svn326551/include/llvm/Support/Error.h"
, 806, __extension__ __PRETTY_FUNCTION__))
;
807 std::unique_ptr<ErrT> SubE(static_cast<ErrT *>(E.release()));
808 H(std::move(SubE));
809 return Error::success();
810 }
811};
812
813// Specialization for member functions of the form 'RetT (const ErrT&)'.
814template <typename C, typename RetT, typename ErrT>
815class ErrorHandlerTraits<RetT (C::*)(ErrT &)>
816 : public ErrorHandlerTraits<RetT (&)(ErrT &)> {};
817
818// Specialization for member functions of the form 'RetT (const ErrT&) const'.
819template <typename C, typename RetT, typename ErrT>
820class ErrorHandlerTraits<RetT (C::*)(ErrT &) const>
821 : public ErrorHandlerTraits<RetT (&)(ErrT &)> {};
822
823// Specialization for member functions of the form 'RetT (const ErrT&)'.
824template <typename C, typename RetT, typename ErrT>
825class ErrorHandlerTraits<RetT (C::*)(const ErrT &)>
826 : public ErrorHandlerTraits<RetT (&)(ErrT &)> {};
827
828// Specialization for member functions of the form 'RetT (const ErrT&) const'.
829template <typename C, typename RetT, typename ErrT>
830class ErrorHandlerTraits<RetT (C::*)(const ErrT &) const>
831 : public ErrorHandlerTraits<RetT (&)(ErrT &)> {};
832
833/// Specialization for member functions of the form
834/// 'RetT (std::unique_ptr<ErrT>)'.
835template <typename C, typename RetT, typename ErrT>
836class ErrorHandlerTraits<RetT (C::*)(std::unique_ptr<ErrT>)>
837 : public ErrorHandlerTraits<RetT (&)(std::unique_ptr<ErrT>)> {};
838
839/// Specialization for member functions of the form
840/// 'RetT (std::unique_ptr<ErrT>) const'.
841template <typename C, typename RetT, typename ErrT>
842class ErrorHandlerTraits<RetT (C::*)(std::unique_ptr<ErrT>) const>
843 : public ErrorHandlerTraits<RetT (&)(std::unique_ptr<ErrT>)> {};
844
845inline Error handleErrorImpl(std::unique_ptr<ErrorInfoBase> Payload) {
846 return Error(std::move(Payload));
847}
848
849template <typename HandlerT, typename... HandlerTs>
850Error handleErrorImpl(std::unique_ptr<ErrorInfoBase> Payload,
851 HandlerT &&Handler, HandlerTs &&... Handlers) {
852 if (ErrorHandlerTraits<HandlerT>::appliesTo(*Payload))
853 return ErrorHandlerTraits<HandlerT>::apply(std::forward<HandlerT>(Handler),
854 std::move(Payload));
855 return handleErrorImpl(std::move(Payload),
856 std::forward<HandlerTs>(Handlers)...);
857}
858
859/// Pass the ErrorInfo(s) contained in E to their respective handlers. Any
860/// unhandled errors (or Errors returned by handlers) are re-concatenated and
861/// returned.
862/// Because this function returns an error, its result must also be checked
863/// or returned. If you intend to handle all errors use handleAllErrors
864/// (which returns void, and will abort() on unhandled errors) instead.
865template <typename... HandlerTs>
866Error handleErrors(Error E, HandlerTs &&... Hs) {
867 if (!E)
868 return Error::success();
869
870 std::unique_ptr<ErrorInfoBase> Payload = E.takePayload();
871
872 if (Payload->isA<ErrorList>()) {
873 ErrorList &List = static_cast<ErrorList &>(*Payload);
874 Error R;
875 for (auto &P : List.Payloads)
876 R = ErrorList::join(
877 std::move(R),
878 handleErrorImpl(std::move(P), std::forward<HandlerTs>(Hs)...));
879 return R;
880 }
881
882 return handleErrorImpl(std::move(Payload), std::forward<HandlerTs>(Hs)...);
883}
884
885/// Behaves the same as handleErrors, except that by contract all errors
886/// *must* be handled by the given handlers (i.e. there must be no remaining
887/// errors after running the handlers, or llvm_unreachable is called).
888template <typename... HandlerTs>
889void handleAllErrors(Error E, HandlerTs &&... Handlers) {
890 cantFail(handleErrors(std::move(E), std::forward<HandlerTs>(Handlers)...));
891}
892
893/// Check that E is a non-error, then drop it.
894/// If E is an error, llvm_unreachable will be called.
895inline void handleAllErrors(Error E) {
896 cantFail(std::move(E));
897}
898
899/// Handle any errors (if present) in an Expected<T>, then try a recovery path.
900///
901/// If the incoming value is a success value it is returned unmodified. If it
902/// is a failure value then it the contained error is passed to handleErrors.
903/// If handleErrors is able to handle the error then the RecoveryPath functor
904/// is called to supply the final result. If handleErrors is not able to
905/// handle all errors then the unhandled errors are returned.
906///
907/// This utility enables the follow pattern:
908///
909/// @code{.cpp}
910/// enum FooStrategy { Aggressive, Conservative };
911/// Expected<Foo> foo(FooStrategy S);
912///
913/// auto ResultOrErr =
914/// handleExpected(
915/// foo(Aggressive),
916/// []() { return foo(Conservative); },
917/// [](AggressiveStrategyError&) {
918/// // Implicitly conusme this - we'll recover by using a conservative
919/// // strategy.
920/// });
921///
922/// @endcode
923template <typename T, typename RecoveryFtor, typename... HandlerTs>
924Expected<T> handleExpected(Expected<T> ValOrErr, RecoveryFtor &&RecoveryPath,
925 HandlerTs &&... Handlers) {
926 if (ValOrErr)
927 return ValOrErr;
928
929 if (auto Err = handleErrors(ValOrErr.takeError(),
930 std::forward<HandlerTs>(Handlers)...))
931 return std::move(Err);
932
933 return RecoveryPath();
934}
935
936/// Log all errors (if any) in E to OS. If there are any errors, ErrorBanner
937/// will be printed before the first one is logged. A newline will be printed
938/// after each error.
939///
940/// This is useful in the base level of your program to allow clean termination
941/// (allowing clean deallocation of resources, etc.), while reporting error
942/// information to the user.
943void logAllUnhandledErrors(Error E, raw_ostream &OS, Twine ErrorBanner);
944
945/// Write all error messages (if any) in E to a string. The newline character
946/// is used to separate error messages.
947inline std::string toString(Error E) {
948 SmallVector<std::string, 2> Errors;
949 handleAllErrors(std::move(E), [&Errors](const ErrorInfoBase &EI) {
950 Errors.push_back(EI.message());
951 });
952 return join(Errors.begin(), Errors.end(), "\n");
953}
954
955/// Consume a Error without doing anything. This method should be used
956/// only where an error can be considered a reasonable and expected return
957/// value.
958///
959/// Uses of this method are potentially indicative of design problems: If it's
960/// legitimate to do nothing while processing an "error", the error-producer
961/// might be more clearly refactored to return an Optional<T>.
962inline void consumeError(Error Err) {
963 handleAllErrors(std::move(Err), [](const ErrorInfoBase &) {});
964}
965
966/// Helper for converting an Error to a bool.
967///
968/// This method returns true if Err is in an error state, or false if it is
969/// in a success state. Puts Err in a checked state in both cases (unlike
970/// Error::operator bool(), which only does this for success states).
971inline bool errorToBool(Error Err) {
972 bool IsError = static_cast<bool>(Err);
973 if (IsError)
974 consumeError(std::move(Err));
975 return IsError;
976}
977
978/// Helper for Errors used as out-parameters.
979///
980/// This helper is for use with the Error-as-out-parameter idiom, where an error
981/// is passed to a function or method by reference, rather than being returned.
982/// In such cases it is helpful to set the checked bit on entry to the function
983/// so that the error can be written to (unchecked Errors abort on assignment)
984/// and clear the checked bit on exit so that clients cannot accidentally forget
985/// to check the result. This helper performs these actions automatically using
986/// RAII:
987///
988/// @code{.cpp}
989/// Result foo(Error &Err) {
990/// ErrorAsOutParameter ErrAsOutParam(&Err); // 'Checked' flag set
991/// // <body of foo>
992/// // <- 'Checked' flag auto-cleared when ErrAsOutParam is destructed.
993/// }
994/// @endcode
995///
996/// ErrorAsOutParameter takes an Error* rather than Error& so that it can be
997/// used with optional Errors (Error pointers that are allowed to be null). If
998/// ErrorAsOutParameter took an Error reference, an instance would have to be
999/// created inside every condition that verified that Error was non-null. By
1000/// taking an Error pointer we can just create one instance at the top of the
1001/// function.
1002class ErrorAsOutParameter {
1003public:
1004 ErrorAsOutParameter(Error *Err) : Err(Err) {
1005 // Raise the checked bit if Err is success.
1006 if (Err)
1007 (void)!!*Err;
1008 }
1009
1010 ~ErrorAsOutParameter() {
1011 // Clear the checked bit.
1012 if (Err && !*Err)
1013 *Err = Error::success();
1014 }
1015
1016private:
1017 Error *Err;
1018};
1019
1020/// Helper for Expected<T>s used as out-parameters.
1021///
1022/// See ErrorAsOutParameter.
1023template <typename T>
1024class ExpectedAsOutParameter {
1025public:
1026 ExpectedAsOutParameter(Expected<T> *ValOrErr)
1027 : ValOrErr(ValOrErr) {
1028 if (ValOrErr)
1029 (void)!!*ValOrErr;
1030 }
1031
1032 ~ExpectedAsOutParameter() {
1033 if (ValOrErr)
1034 ValOrErr->setUnchecked();
1035 }
1036
1037private:
1038 Expected<T> *ValOrErr;
1039};
1040
1041/// This class wraps a std::error_code in a Error.
1042///
1043/// This is useful if you're writing an interface that returns a Error
1044/// (or Expected) and you want to call code that still returns
1045/// std::error_codes.
1046class ECError : public ErrorInfo<ECError> {
1047 friend Error errorCodeToError(std::error_code);
1048
1049public:
1050 void setErrorCode(std::error_code EC) { this->EC = EC; }
1051 std::error_code convertToErrorCode() const override { return EC; }
1052 void log(raw_ostream &OS) const override { OS << EC.message(); }
1053
1054 // Used by ErrorInfo::classID.
1055 static char ID;
1056
1057protected:
1058 ECError() = default;
1059 ECError(std::error_code EC) : EC(EC) {}
1060
1061 std::error_code EC;
1062};
1063
1064/// The value returned by this function can be returned from convertToErrorCode
1065/// for Error values where no sensible translation to std::error_code exists.
1066/// It should only be used in this situation, and should never be used where a
1067/// sensible conversion to std::error_code is available, as attempts to convert
1068/// to/from this error will result in a fatal error. (i.e. it is a programmatic
1069///error to try to convert such a value).
1070std::error_code inconvertibleErrorCode();
1071
1072/// Helper for converting an std::error_code to a Error.
1073Error errorCodeToError(std::error_code EC);
1074
1075/// Helper for converting an ECError to a std::error_code.
1076///
1077/// This method requires that Err be Error() or an ECError, otherwise it
1078/// will trigger a call to abort().
1079std::error_code errorToErrorCode(Error Err);
1080
1081/// Convert an ErrorOr<T> to an Expected<T>.
1082template <typename T> Expected<T> errorOrToExpected(ErrorOr<T> &&EO) {
1083 if (auto EC = EO.getError())
1084 return errorCodeToError(EC);
1085 return std::move(*EO);
1086}
1087
1088/// Convert an Expected<T> to an ErrorOr<T>.
1089template <typename T> ErrorOr<T> expectedToErrorOr(Expected<T> &&E) {
1090 if (auto Err = E.takeError())
1091 return errorToErrorCode(std::move(Err));
1092 return std::move(*E);
1093}
1094
1095/// This class wraps a string in an Error.
1096///
1097/// StringError is useful in cases where the client is not expected to be able
1098/// to consume the specific error message programmatically (for example, if the
1099/// error message is to be presented to the user).
1100class StringError : public ErrorInfo<StringError> {
1101public:
1102 static char ID;
1103
1104 StringError(const Twine &S, std::error_code EC);
1105
1106 void log(raw_ostream &OS) const override;
1107 std::error_code convertToErrorCode() const override;
1108
1109 const std::string &getMessage() const { return Msg; }
1110
1111private:
1112 std::string Msg;
1113 std::error_code EC;
1114};
1115
1116/// Helper for check-and-exit error handling.
1117///
1118/// For tool use only. NOT FOR USE IN LIBRARY CODE.
1119///
1120class ExitOnError {
1121public:
1122 /// Create an error on exit helper.
1123 ExitOnError(std::string Banner = "", int DefaultErrorExitCode = 1)
1124 : Banner(std::move(Banner)),
1125 GetExitCode([=](const Error &) { return DefaultErrorExitCode; }) {}
1126
1127 /// Set the banner string for any errors caught by operator().
1128 void setBanner(std::string Banner) { this->Banner = std::move(Banner); }
1129
1130 /// Set the exit-code mapper function.
1131 void setExitCodeMapper(std::function<int(const Error &)> GetExitCode) {
1132 this->GetExitCode = std::move(GetExitCode);
1133 }
1134
1135 /// Check Err. If it's in a failure state log the error(s) and exit.
1136 void operator()(Error Err) const { checkError(std::move(Err)); }
1137
1138 /// Check E. If it's in a success state then return the contained value. If
1139 /// it's in a failure state log the error(s) and exit.
1140 template <typename T> T operator()(Expected<T> &&E) const {
1141 checkError(E.takeError());
1142 return std::move(*E);
1143 }
1144
1145 /// Check E. If it's in a success state then return the contained reference. If
1146 /// it's in a failure state log the error(s) and exit.
1147 template <typename T> T& operator()(Expected<T&> &&E) const {
1148 checkError(E.takeError());
1149 return *E;
1150 }
1151
1152private:
1153 void checkError(Error Err) const {
1154 if (Err) {
1155 int ExitCode = GetExitCode(Err);
1156 logAllUnhandledErrors(std::move(Err), errs(), Banner);
1157 exit(ExitCode);
1158 }
1159 }
1160
1161 std::string Banner;
1162 std::function<int(const Error &)> GetExitCode;
1163};
1164
1165} // end namespace llvm
1166
1167#endif // LLVM_SUPPORT_ERROR_H