Bug Summary

File:include/llvm/Support/Error.h
Warning:line 200, column 5
Potential leak of memory pointed to by 'Payload._M_t._M_head_impl'

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 WasmObjectFile.cpp -analyzer-store=region -analyzer-opt-analyze-nested-blocks -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 -analyzer-config-compatibility-mode=true -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-9/lib/clang/9.0.0 -D _DEBUG -D _GNU_SOURCE -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D __STDC_LIMIT_MACROS -I /build/llvm-toolchain-snapshot-9~svn358520/build-llvm/lib/Object -I /build/llvm-toolchain-snapshot-9~svn358520/lib/Object -I /build/llvm-toolchain-snapshot-9~svn358520/build-llvm/include -I /build/llvm-toolchain-snapshot-9~svn358520/include -U NDEBUG -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/c++/6.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/x86_64-linux-gnu/c++/6.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/x86_64-linux-gnu/c++/6.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/c++/6.3.0/backward -internal-isystem /usr/include/clang/9.0.0/include/ -internal-isystem /usr/local/include -internal-isystem /usr/lib/llvm-9/lib/clang/9.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-9~svn358520/build-llvm/lib/Object -fdebug-prefix-map=/build/llvm-toolchain-snapshot-9~svn358520=. -ferror-limit 19 -fmessage-length 0 -fvisibility-inlines-hidden -stack-protector 2 -fobjc-runtime=gcc -fdiagnostics-show-option -vectorize-loops -vectorize-slp -analyzer-output=html -analyzer-config stable-report-filename=true -o /tmp/scan-build-2019-04-17-050842-1547-1 -x c++ /build/llvm-toolchain-snapshot-9~svn358520/lib/Object/WasmObjectFile.cpp -faddrsig

/build/llvm-toolchain-snapshot-9~svn358520/lib/Object/WasmObjectFile.cpp

1//===- WasmObjectFile.cpp - Wasm object file implementation ---------------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8
9#include "llvm/ADT/ArrayRef.h"
10#include "llvm/ADT/DenseSet.h"
11#include "llvm/ADT/STLExtras.h"
12#include "llvm/ADT/SmallSet.h"
13#include "llvm/ADT/StringRef.h"
14#include "llvm/ADT/StringSet.h"
15#include "llvm/ADT/Triple.h"
16#include "llvm/BinaryFormat/Wasm.h"
17#include "llvm/MC/SubtargetFeature.h"
18#include "llvm/Object/Binary.h"
19#include "llvm/Object/Error.h"
20#include "llvm/Object/ObjectFile.h"
21#include "llvm/Object/SymbolicFile.h"
22#include "llvm/Object/Wasm.h"
23#include "llvm/Support/Endian.h"
24#include "llvm/Support/Error.h"
25#include "llvm/Support/ErrorHandling.h"
26#include "llvm/Support/LEB128.h"
27#include "llvm/Support/ScopedPrinter.h"
28#include <algorithm>
29#include <cassert>
30#include <cstdint>
31#include <cstring>
32#include <system_error>
33
34#define DEBUG_TYPE"wasm-object" "wasm-object"
35
36using namespace llvm;
37using namespace object;
38
39void WasmSymbol::print(raw_ostream &Out) const {
40 Out << "Name=" << Info.Name
41 << ", Kind=" << toString(wasm::WasmSymbolType(Info.Kind))
42 << ", Flags=" << Info.Flags;
43 if (!isTypeData()) {
44 Out << ", ElemIndex=" << Info.ElementIndex;
45 } else if (isDefined()) {
46 Out << ", Segment=" << Info.DataRef.Segment;
47 Out << ", Offset=" << Info.DataRef.Offset;
48 Out << ", Size=" << Info.DataRef.Size;
49 }
50}
51
52#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
53LLVM_DUMP_METHOD__attribute__((noinline)) __attribute__((__used__)) void WasmSymbol::dump() const { print(dbgs()); }
54#endif
55
56Expected<std::unique_ptr<WasmObjectFile>>
57ObjectFile::createWasmObjectFile(MemoryBufferRef Buffer) {
58 Error Err = Error::success();
59 auto ObjectFile = llvm::make_unique<WasmObjectFile>(Buffer, Err);
60 if (Err)
61 return std::move(Err);
62
63 return std::move(ObjectFile);
64}
65
66#define VARINT7_MAX((1 << 7) - 1) ((1 << 7) - 1)
67#define VARINT7_MIN(-(1 << 7)) (-(1 << 7))
68#define VARUINT7_MAX(1 << 7) (1 << 7)
69#define VARUINT1_MAX(1) (1)
70
71static uint8_t readUint8(WasmObjectFile::ReadContext &Ctx) {
72 if (Ctx.Ptr == Ctx.End)
73 report_fatal_error("EOF while reading uint8");
74 return *Ctx.Ptr++;
75}
76
77static uint32_t readUint32(WasmObjectFile::ReadContext &Ctx) {
78 if (Ctx.Ptr + 4 > Ctx.End)
79 report_fatal_error("EOF while reading uint32");
80 uint32_t Result = support::endian::read32le(Ctx.Ptr);
81 Ctx.Ptr += 4;
82 return Result;
83}
84
85static int32_t readFloat32(WasmObjectFile::ReadContext &Ctx) {
86 if (Ctx.Ptr + 4 > Ctx.End)
87 report_fatal_error("EOF while reading float64");
88 int32_t Result = 0;
89 memcpy(&Result, Ctx.Ptr, sizeof(Result));
90 Ctx.Ptr += sizeof(Result);
91 return Result;
92}
93
94static int64_t readFloat64(WasmObjectFile::ReadContext &Ctx) {
95 if (Ctx.Ptr + 8 > Ctx.End)
96 report_fatal_error("EOF while reading float64");
97 int64_t Result = 0;
98 memcpy(&Result, Ctx.Ptr, sizeof(Result));
99 Ctx.Ptr += sizeof(Result);
100 return Result;
101}
102
103static uint64_t readULEB128(WasmObjectFile::ReadContext &Ctx) {
104 unsigned Count;
105 const char *Error = nullptr;
106 uint64_t Result = decodeULEB128(Ctx.Ptr, &Count, Ctx.End, &Error);
107 if (Error)
108 report_fatal_error(Error);
109 Ctx.Ptr += Count;
110 return Result;
111}
112
113static StringRef readString(WasmObjectFile::ReadContext &Ctx) {
114 uint32_t StringLen = readULEB128(Ctx);
115 if (Ctx.Ptr + StringLen > Ctx.End)
116 report_fatal_error("EOF while reading string");
117 StringRef Return =
118 StringRef(reinterpret_cast<const char *>(Ctx.Ptr), StringLen);
119 Ctx.Ptr += StringLen;
120 return Return;
121}
122
123static int64_t readLEB128(WasmObjectFile::ReadContext &Ctx) {
124 unsigned Count;
125 const char *Error = nullptr;
126 uint64_t Result = decodeSLEB128(Ctx.Ptr, &Count, Ctx.End, &Error);
127 if (Error)
128 report_fatal_error(Error);
129 Ctx.Ptr += Count;
130 return Result;
131}
132
133static uint8_t readVaruint1(WasmObjectFile::ReadContext &Ctx) {
134 int64_t Result = readLEB128(Ctx);
135 if (Result > VARUINT1_MAX(1) || Result < 0)
136 report_fatal_error("LEB is outside Varuint1 range");
137 return Result;
138}
139
140static int32_t readVarint32(WasmObjectFile::ReadContext &Ctx) {
141 int64_t Result = readLEB128(Ctx);
142 if (Result > INT32_MAX(2147483647) || Result < INT32_MIN(-2147483647-1))
143 report_fatal_error("LEB is outside Varint32 range");
144 return Result;
145}
146
147static uint32_t readVaruint32(WasmObjectFile::ReadContext &Ctx) {
148 uint64_t Result = readULEB128(Ctx);
149 if (Result > UINT32_MAX(4294967295U))
150 report_fatal_error("LEB is outside Varuint32 range");
151 return Result;
152}
153
154static int64_t readVarint64(WasmObjectFile::ReadContext &Ctx) {
155 return readLEB128(Ctx);
156}
157
158static uint8_t readOpcode(WasmObjectFile::ReadContext &Ctx) {
159 return readUint8(Ctx);
160}
161
162static Error readInitExpr(wasm::WasmInitExpr &Expr,
163 WasmObjectFile::ReadContext &Ctx) {
164 Expr.Opcode = readOpcode(Ctx);
165
166 switch (Expr.Opcode) {
167 case wasm::WASM_OPCODE_I32_CONST:
168 Expr.Value.Int32 = readVarint32(Ctx);
169 break;
170 case wasm::WASM_OPCODE_I64_CONST:
171 Expr.Value.Int64 = readVarint64(Ctx);
172 break;
173 case wasm::WASM_OPCODE_F32_CONST:
174 Expr.Value.Float32 = readFloat32(Ctx);
175 break;
176 case wasm::WASM_OPCODE_F64_CONST:
177 Expr.Value.Float64 = readFloat64(Ctx);
178 break;
179 case wasm::WASM_OPCODE_GLOBAL_GET:
180 Expr.Value.Global = readULEB128(Ctx);
181 break;
182 default:
183 return make_error<GenericBinaryError>("Invalid opcode in init_expr",
184 object_error::parse_failed);
185 }
186
187 uint8_t EndOpcode = readOpcode(Ctx);
188 if (EndOpcode != wasm::WASM_OPCODE_END) {
189 return make_error<GenericBinaryError>("Invalid init_expr",
190 object_error::parse_failed);
191 }
192 return Error::success();
193}
194
195static wasm::WasmLimits readLimits(WasmObjectFile::ReadContext &Ctx) {
196 wasm::WasmLimits Result;
197 Result.Flags = readVaruint32(Ctx);
198 Result.Initial = readVaruint32(Ctx);
199 if (Result.Flags & wasm::WASM_LIMITS_FLAG_HAS_MAX)
200 Result.Maximum = readVaruint32(Ctx);
201 return Result;
202}
203
204static wasm::WasmTable readTable(WasmObjectFile::ReadContext &Ctx) {
205 wasm::WasmTable Table;
206 Table.ElemType = readUint8(Ctx);
207 Table.Limits = readLimits(Ctx);
208 return Table;
209}
210
211static Error readSection(WasmSection &Section, WasmObjectFile::ReadContext &Ctx,
212 WasmSectionOrderChecker &Checker) {
213 Section.Offset = Ctx.Ptr - Ctx.Start;
214 Section.Type = readUint8(Ctx);
215 LLVM_DEBUG(dbgs() << "readSection type=" << Section.Type << "\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("wasm-object")) { dbgs() << "readSection type=" <<
Section.Type << "\n"; } } while (false)
;
216 uint32_t Size = readVaruint32(Ctx);
217 if (Size == 0)
218 return make_error<StringError>("Zero length section",
219 object_error::parse_failed);
220 if (Ctx.Ptr + Size > Ctx.End)
221 return make_error<StringError>("Section too large",
222 object_error::parse_failed);
223 if (Section.Type == wasm::WASM_SEC_CUSTOM) {
224 WasmObjectFile::ReadContext SectionCtx;
225 SectionCtx.Start = Ctx.Ptr;
226 SectionCtx.Ptr = Ctx.Ptr;
227 SectionCtx.End = Ctx.Ptr + Size;
228
229 Section.Name = readString(SectionCtx);
230
231 uint32_t SectionNameSize = SectionCtx.Ptr - SectionCtx.Start;
232 Ctx.Ptr += SectionNameSize;
233 Size -= SectionNameSize;
234 }
235
236 if (!Checker.isValidSectionOrder(Section.Type, Section.Name)) {
237 return make_error<StringError>("Out of order section type: " +
238 llvm::to_string(Section.Type),
239 object_error::parse_failed);
240 }
241
242 Section.Content = ArrayRef<uint8_t>(Ctx.Ptr, Size);
243 Ctx.Ptr += Size;
244 return Error::success();
245}
246
247WasmObjectFile::WasmObjectFile(MemoryBufferRef Buffer, Error &Err)
248 : ObjectFile(Binary::ID_Wasm, Buffer) {
249 ErrorAsOutParameter ErrAsOutParam(&Err);
250 Header.Magic = getData().substr(0, 4);
251 if (Header.Magic != StringRef("\0asm", 4)) {
1
Taking true branch
252 Err =
253 make_error<StringError>("Bad magic number", object_error::parse_failed);
2
Calling 'make_error<llvm::StringError, char const (&)[17], llvm::object::object_error>'
254 return;
255 }
256
257 ReadContext Ctx;
258 Ctx.Start = getData().bytes_begin();
259 Ctx.Ptr = Ctx.Start + 4;
260 Ctx.End = Ctx.Start + getData().size();
261
262 if (Ctx.Ptr + 4 > Ctx.End) {
263 Err = make_error<StringError>("Missing version number",
264 object_error::parse_failed);
265 return;
266 }
267
268 Header.Version = readUint32(Ctx);
269 if (Header.Version != wasm::WasmVersion) {
270 Err = make_error<StringError>("Bad version number",
271 object_error::parse_failed);
272 return;
273 }
274
275 WasmSection Sec;
276 WasmSectionOrderChecker Checker;
277 while (Ctx.Ptr < Ctx.End) {
278 if ((Err = readSection(Sec, Ctx, Checker)))
279 return;
280 if ((Err = parseSection(Sec)))
281 return;
282
283 Sections.push_back(Sec);
284 }
285}
286
287Error WasmObjectFile::parseSection(WasmSection &Sec) {
288 ReadContext Ctx;
289 Ctx.Start = Sec.Content.data();
290 Ctx.End = Ctx.Start + Sec.Content.size();
291 Ctx.Ptr = Ctx.Start;
292 switch (Sec.Type) {
293 case wasm::WASM_SEC_CUSTOM:
294 return parseCustomSection(Sec, Ctx);
295 case wasm::WASM_SEC_TYPE:
296 return parseTypeSection(Ctx);
297 case wasm::WASM_SEC_IMPORT:
298 return parseImportSection(Ctx);
299 case wasm::WASM_SEC_FUNCTION:
300 return parseFunctionSection(Ctx);
301 case wasm::WASM_SEC_TABLE:
302 return parseTableSection(Ctx);
303 case wasm::WASM_SEC_MEMORY:
304 return parseMemorySection(Ctx);
305 case wasm::WASM_SEC_GLOBAL:
306 return parseGlobalSection(Ctx);
307 case wasm::WASM_SEC_EVENT:
308 return parseEventSection(Ctx);
309 case wasm::WASM_SEC_EXPORT:
310 return parseExportSection(Ctx);
311 case wasm::WASM_SEC_START:
312 return parseStartSection(Ctx);
313 case wasm::WASM_SEC_ELEM:
314 return parseElemSection(Ctx);
315 case wasm::WASM_SEC_CODE:
316 return parseCodeSection(Ctx);
317 case wasm::WASM_SEC_DATA:
318 return parseDataSection(Ctx);
319 case wasm::WASM_SEC_DATACOUNT:
320 return parseDataCountSection(Ctx);
321 default:
322 return make_error<GenericBinaryError>("Bad section type",
323 object_error::parse_failed);
324 }
325}
326
327Error WasmObjectFile::parseDylinkSection(ReadContext &Ctx) {
328 // See https://github.com/WebAssembly/tool-conventions/blob/master/DynamicLinking.md
329 HasDylinkSection = true;
330 DylinkInfo.MemorySize = readVaruint32(Ctx);
331 DylinkInfo.MemoryAlignment = readVaruint32(Ctx);
332 DylinkInfo.TableSize = readVaruint32(Ctx);
333 DylinkInfo.TableAlignment = readVaruint32(Ctx);
334 uint32_t Count = readVaruint32(Ctx);
335 while (Count--) {
336 DylinkInfo.Needed.push_back(readString(Ctx));
337 }
338 if (Ctx.Ptr != Ctx.End)
339 return make_error<GenericBinaryError>("dylink section ended prematurely",
340 object_error::parse_failed);
341 return Error::success();
342}
343
344Error WasmObjectFile::parseNameSection(ReadContext &Ctx) {
345 llvm::DenseSet<uint64_t> Seen;
346 if (Functions.size() != FunctionTypes.size()) {
347 return make_error<GenericBinaryError>("Names must come after code section",
348 object_error::parse_failed);
349 }
350
351 while (Ctx.Ptr < Ctx.End) {
352 uint8_t Type = readUint8(Ctx);
353 uint32_t Size = readVaruint32(Ctx);
354 const uint8_t *SubSectionEnd = Ctx.Ptr + Size;
355 switch (Type) {
356 case wasm::WASM_NAMES_FUNCTION: {
357 uint32_t Count = readVaruint32(Ctx);
358 while (Count--) {
359 uint32_t Index = readVaruint32(Ctx);
360 if (!Seen.insert(Index).second)
361 return make_error<GenericBinaryError>("Function named more than once",
362 object_error::parse_failed);
363 StringRef Name = readString(Ctx);
364 if (!isValidFunctionIndex(Index) || Name.empty())
365 return make_error<GenericBinaryError>("Invalid name entry",
366 object_error::parse_failed);
367 DebugNames.push_back(wasm::WasmFunctionName{Index, Name});
368 if (isDefinedFunctionIndex(Index))
369 getDefinedFunction(Index).DebugName = Name;
370 }
371 break;
372 }
373 // Ignore local names for now
374 case wasm::WASM_NAMES_LOCAL:
375 default:
376 Ctx.Ptr += Size;
377 break;
378 }
379 if (Ctx.Ptr != SubSectionEnd)
380 return make_error<GenericBinaryError>(
381 "Name sub-section ended prematurely", object_error::parse_failed);
382 }
383
384 if (Ctx.Ptr != Ctx.End)
385 return make_error<GenericBinaryError>("Name section ended prematurely",
386 object_error::parse_failed);
387 return Error::success();
388}
389
390Error WasmObjectFile::parseLinkingSection(ReadContext &Ctx) {
391 HasLinkingSection = true;
392 if (Functions.size() != FunctionTypes.size()) {
393 return make_error<GenericBinaryError>(
394 "Linking data must come after code section",
395 object_error::parse_failed);
396 }
397
398 LinkingData.Version = readVaruint32(Ctx);
399 if (LinkingData.Version != wasm::WasmMetadataVersion) {
400 return make_error<GenericBinaryError>(
401 "Unexpected metadata version: " + Twine(LinkingData.Version) +
402 " (Expected: " + Twine(wasm::WasmMetadataVersion) + ")",
403 object_error::parse_failed);
404 }
405
406 const uint8_t *OrigEnd = Ctx.End;
407 while (Ctx.Ptr < OrigEnd) {
408 Ctx.End = OrigEnd;
409 uint8_t Type = readUint8(Ctx);
410 uint32_t Size = readVaruint32(Ctx);
411 LLVM_DEBUG(dbgs() << "readSubsection type=" << int(Type) << " size=" << Sizedo { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("wasm-object")) { dbgs() << "readSubsection type=" <<
int(Type) << " size=" << Size << "\n"; } }
while (false)
412 << "\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("wasm-object")) { dbgs() << "readSubsection type=" <<
int(Type) << " size=" << Size << "\n"; } }
while (false)
;
413 Ctx.End = Ctx.Ptr + Size;
414 switch (Type) {
415 case wasm::WASM_SYMBOL_TABLE:
416 if (Error Err = parseLinkingSectionSymtab(Ctx))
417 return Err;
418 break;
419 case wasm::WASM_SEGMENT_INFO: {
420 uint32_t Count = readVaruint32(Ctx);
421 if (Count > DataSegments.size())
422 return make_error<GenericBinaryError>("Too many segment names",
423 object_error::parse_failed);
424 for (uint32_t I = 0; I < Count; I++) {
425 DataSegments[I].Data.Name = readString(Ctx);
426 DataSegments[I].Data.Alignment = readVaruint32(Ctx);
427 DataSegments[I].Data.LinkerFlags = readVaruint32(Ctx);
428 }
429 break;
430 }
431 case wasm::WASM_INIT_FUNCS: {
432 uint32_t Count = readVaruint32(Ctx);
433 LinkingData.InitFunctions.reserve(Count);
434 for (uint32_t I = 0; I < Count; I++) {
435 wasm::WasmInitFunc Init;
436 Init.Priority = readVaruint32(Ctx);
437 Init.Symbol = readVaruint32(Ctx);
438 if (!isValidFunctionSymbol(Init.Symbol))
439 return make_error<GenericBinaryError>("Invalid function symbol: " +
440 Twine(Init.Symbol),
441 object_error::parse_failed);
442 LinkingData.InitFunctions.emplace_back(Init);
443 }
444 break;
445 }
446 case wasm::WASM_COMDAT_INFO:
447 if (Error Err = parseLinkingSectionComdat(Ctx))
448 return Err;
449 break;
450 default:
451 Ctx.Ptr += Size;
452 break;
453 }
454 if (Ctx.Ptr != Ctx.End)
455 return make_error<GenericBinaryError>(
456 "Linking sub-section ended prematurely", object_error::parse_failed);
457 }
458 if (Ctx.Ptr != OrigEnd)
459 return make_error<GenericBinaryError>("Linking section ended prematurely",
460 object_error::parse_failed);
461 return Error::success();
462}
463
464Error WasmObjectFile::parseLinkingSectionSymtab(ReadContext &Ctx) {
465 uint32_t Count = readVaruint32(Ctx);
466 LinkingData.SymbolTable.reserve(Count);
467 Symbols.reserve(Count);
468 StringSet<> SymbolNames;
469
470 std::vector<wasm::WasmImport *> ImportedGlobals;
471 std::vector<wasm::WasmImport *> ImportedFunctions;
472 std::vector<wasm::WasmImport *> ImportedEvents;
473 ImportedGlobals.reserve(Imports.size());
474 ImportedFunctions.reserve(Imports.size());
475 ImportedEvents.reserve(Imports.size());
476 for (auto &I : Imports) {
477 if (I.Kind == wasm::WASM_EXTERNAL_FUNCTION)
478 ImportedFunctions.emplace_back(&I);
479 else if (I.Kind == wasm::WASM_EXTERNAL_GLOBAL)
480 ImportedGlobals.emplace_back(&I);
481 else if (I.Kind == wasm::WASM_EXTERNAL_EVENT)
482 ImportedEvents.emplace_back(&I);
483 }
484
485 while (Count--) {
486 wasm::WasmSymbolInfo Info;
487 const wasm::WasmSignature *Signature = nullptr;
488 const wasm::WasmGlobalType *GlobalType = nullptr;
489 const wasm::WasmEventType *EventType = nullptr;
490
491 Info.Kind = readUint8(Ctx);
492 Info.Flags = readVaruint32(Ctx);
493 bool IsDefined = (Info.Flags & wasm::WASM_SYMBOL_UNDEFINED) == 0;
494
495 switch (Info.Kind) {
496 case wasm::WASM_SYMBOL_TYPE_FUNCTION:
497 Info.ElementIndex = readVaruint32(Ctx);
498 if (!isValidFunctionIndex(Info.ElementIndex) ||
499 IsDefined != isDefinedFunctionIndex(Info.ElementIndex))
500 return make_error<GenericBinaryError>("invalid function symbol index",
501 object_error::parse_failed);
502 if (IsDefined) {
503 Info.Name = readString(Ctx);
504 unsigned FuncIndex = Info.ElementIndex - NumImportedFunctions;
505 Signature = &Signatures[FunctionTypes[FuncIndex]];
506 wasm::WasmFunction &Function = Functions[FuncIndex];
507 if (Function.SymbolName.empty())
508 Function.SymbolName = Info.Name;
509 } else {
510 wasm::WasmImport &Import = *ImportedFunctions[Info.ElementIndex];
511 if ((Info.Flags & wasm::WASM_SYMBOL_EXPLICIT_NAME) != 0)
512 Info.Name = readString(Ctx);
513 else
514 Info.Name = Import.Field;
515 Signature = &Signatures[Import.SigIndex];
516 Info.ImportName = Import.Field;
517 Info.ImportModule = Import.Module;
518 }
519 break;
520
521 case wasm::WASM_SYMBOL_TYPE_GLOBAL:
522 Info.ElementIndex = readVaruint32(Ctx);
523 if (!isValidGlobalIndex(Info.ElementIndex) ||
524 IsDefined != isDefinedGlobalIndex(Info.ElementIndex))
525 return make_error<GenericBinaryError>("invalid global symbol index",
526 object_error::parse_failed);
527 if (!IsDefined && (Info.Flags & wasm::WASM_SYMBOL_BINDING_MASK) ==
528 wasm::WASM_SYMBOL_BINDING_WEAK)
529 return make_error<GenericBinaryError>("undefined weak global symbol",
530 object_error::parse_failed);
531 if (IsDefined) {
532 Info.Name = readString(Ctx);
533 unsigned GlobalIndex = Info.ElementIndex - NumImportedGlobals;
534 wasm::WasmGlobal &Global = Globals[GlobalIndex];
535 GlobalType = &Global.Type;
536 if (Global.SymbolName.empty())
537 Global.SymbolName = Info.Name;
538 } else {
539 wasm::WasmImport &Import = *ImportedGlobals[Info.ElementIndex];
540 if ((Info.Flags & wasm::WASM_SYMBOL_EXPLICIT_NAME) != 0)
541 Info.Name = readString(Ctx);
542 else
543 Info.Name = Import.Field;
544 GlobalType = &Import.Global;
545 Info.ImportName = Import.Field;
546 Info.ImportModule = Import.Module;
547 }
548 break;
549
550 case wasm::WASM_SYMBOL_TYPE_DATA:
551 Info.Name = readString(Ctx);
552 if (IsDefined) {
553 uint32_t Index = readVaruint32(Ctx);
554 if (Index >= DataSegments.size())
555 return make_error<GenericBinaryError>("invalid data symbol index",
556 object_error::parse_failed);
557 uint32_t Offset = readVaruint32(Ctx);
558 uint32_t Size = readVaruint32(Ctx);
559 if (Offset + Size > DataSegments[Index].Data.Content.size())
560 return make_error<GenericBinaryError>("invalid data symbol offset",
561 object_error::parse_failed);
562 Info.DataRef = wasm::WasmDataReference{Index, Offset, Size};
563 }
564 break;
565
566 case wasm::WASM_SYMBOL_TYPE_SECTION: {
567 if ((Info.Flags & wasm::WASM_SYMBOL_BINDING_MASK) !=
568 wasm::WASM_SYMBOL_BINDING_LOCAL)
569 return make_error<GenericBinaryError>(
570 "Section symbols must have local binding",
571 object_error::parse_failed);
572 Info.ElementIndex = readVaruint32(Ctx);
573 // Use somewhat unique section name as symbol name.
574 StringRef SectionName = Sections[Info.ElementIndex].Name;
575 Info.Name = SectionName;
576 break;
577 }
578
579 case wasm::WASM_SYMBOL_TYPE_EVENT: {
580 Info.ElementIndex = readVaruint32(Ctx);
581 if (!isValidEventIndex(Info.ElementIndex) ||
582 IsDefined != isDefinedEventIndex(Info.ElementIndex))
583 return make_error<GenericBinaryError>("invalid event symbol index",
584 object_error::parse_failed);
585 if (!IsDefined && (Info.Flags & wasm::WASM_SYMBOL_BINDING_MASK) ==
586 wasm::WASM_SYMBOL_BINDING_WEAK)
587 return make_error<GenericBinaryError>("undefined weak global symbol",
588 object_error::parse_failed);
589 if (IsDefined) {
590 Info.Name = readString(Ctx);
591 unsigned EventIndex = Info.ElementIndex - NumImportedEvents;
592 wasm::WasmEvent &Event = Events[EventIndex];
593 Signature = &Signatures[Event.Type.SigIndex];
594 EventType = &Event.Type;
595 if (Event.SymbolName.empty())
596 Event.SymbolName = Info.Name;
597
598 } else {
599 wasm::WasmImport &Import = *ImportedEvents[Info.ElementIndex];
600 if ((Info.Flags & wasm::WASM_SYMBOL_EXPLICIT_NAME) != 0)
601 Info.Name = readString(Ctx);
602 else
603 Info.Name = Import.Field;
604 EventType = &Import.Event;
605 Signature = &Signatures[EventType->SigIndex];
606 Info.ImportName = Import.Field;
607 Info.ImportModule = Import.Module;
608 }
609 break;
610 }
611
612 default:
613 return make_error<GenericBinaryError>("Invalid symbol type",
614 object_error::parse_failed);
615 }
616
617 if ((Info.Flags & wasm::WASM_SYMBOL_BINDING_MASK) !=
618 wasm::WASM_SYMBOL_BINDING_LOCAL &&
619 !SymbolNames.insert(Info.Name).second)
620 return make_error<GenericBinaryError>("Duplicate symbol name " +
621 Twine(Info.Name),
622 object_error::parse_failed);
623 LinkingData.SymbolTable.emplace_back(Info);
624 Symbols.emplace_back(LinkingData.SymbolTable.back(), GlobalType, EventType,
625 Signature);
626 LLVM_DEBUG(dbgs() << "Adding symbol: " << Symbols.back() << "\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("wasm-object")) { dbgs() << "Adding symbol: " <<
Symbols.back() << "\n"; } } while (false)
;
627 }
628
629 return Error::success();
630}
631
632Error WasmObjectFile::parseLinkingSectionComdat(ReadContext &Ctx) {
633 uint32_t ComdatCount = readVaruint32(Ctx);
634 StringSet<> ComdatSet;
635 for (unsigned ComdatIndex = 0; ComdatIndex < ComdatCount; ++ComdatIndex) {
636 StringRef Name = readString(Ctx);
637 if (Name.empty() || !ComdatSet.insert(Name).second)
638 return make_error<GenericBinaryError>("Bad/duplicate COMDAT name " +
639 Twine(Name),
640 object_error::parse_failed);
641 LinkingData.Comdats.emplace_back(Name);
642 uint32_t Flags = readVaruint32(Ctx);
643 if (Flags != 0)
644 return make_error<GenericBinaryError>("Unsupported COMDAT flags",
645 object_error::parse_failed);
646
647 uint32_t EntryCount = readVaruint32(Ctx);
648 while (EntryCount--) {
649 unsigned Kind = readVaruint32(Ctx);
650 unsigned Index = readVaruint32(Ctx);
651 switch (Kind) {
652 default:
653 return make_error<GenericBinaryError>("Invalid COMDAT entry type",
654 object_error::parse_failed);
655 case wasm::WASM_COMDAT_DATA:
656 if (Index >= DataSegments.size())
657 return make_error<GenericBinaryError>(
658 "COMDAT data index out of range", object_error::parse_failed);
659 if (DataSegments[Index].Data.Comdat != UINT32_MAX(4294967295U))
660 return make_error<GenericBinaryError>("Data segment in two COMDATs",
661 object_error::parse_failed);
662 DataSegments[Index].Data.Comdat = ComdatIndex;
663 break;
664 case wasm::WASM_COMDAT_FUNCTION:
665 if (!isDefinedFunctionIndex(Index))
666 return make_error<GenericBinaryError>(
667 "COMDAT function index out of range", object_error::parse_failed);
668 if (getDefinedFunction(Index).Comdat != UINT32_MAX(4294967295U))
669 return make_error<GenericBinaryError>("Function in two COMDATs",
670 object_error::parse_failed);
671 getDefinedFunction(Index).Comdat = ComdatIndex;
672 break;
673 }
674 }
675 }
676 return Error::success();
677}
678
679Error WasmObjectFile::parseProducersSection(ReadContext &Ctx) {
680 llvm::SmallSet<StringRef, 3> FieldsSeen;
681 uint32_t Fields = readVaruint32(Ctx);
682 for (size_t I = 0; I < Fields; ++I) {
683 StringRef FieldName = readString(Ctx);
684 if (!FieldsSeen.insert(FieldName).second)
685 return make_error<GenericBinaryError>(
686 "Producers section does not have unique fields",
687 object_error::parse_failed);
688 std::vector<std::pair<std::string, std::string>> *ProducerVec = nullptr;
689 if (FieldName == "language") {
690 ProducerVec = &ProducerInfo.Languages;
691 } else if (FieldName == "processed-by") {
692 ProducerVec = &ProducerInfo.Tools;
693 } else if (FieldName == "sdk") {
694 ProducerVec = &ProducerInfo.SDKs;
695 } else {
696 return make_error<GenericBinaryError>(
697 "Producers section field is not named one of language, processed-by, "
698 "or sdk",
699 object_error::parse_failed);
700 }
701 uint32_t ValueCount = readVaruint32(Ctx);
702 llvm::SmallSet<StringRef, 8> ProducersSeen;
703 for (size_t J = 0; J < ValueCount; ++J) {
704 StringRef Name = readString(Ctx);
705 StringRef Version = readString(Ctx);
706 if (!ProducersSeen.insert(Name).second) {
707 return make_error<GenericBinaryError>(
708 "Producers section contains repeated producer",
709 object_error::parse_failed);
710 }
711 ProducerVec->emplace_back(Name, Version);
712 }
713 }
714 if (Ctx.Ptr != Ctx.End)
715 return make_error<GenericBinaryError>("Producers section ended prematurely",
716 object_error::parse_failed);
717 return Error::success();
718}
719
720Error WasmObjectFile::parseTargetFeaturesSection(ReadContext &Ctx) {
721 llvm::SmallSet<std::string, 8> FeaturesSeen;
722 uint32_t FeatureCount = readVaruint32(Ctx);
723 for (size_t I = 0; I < FeatureCount; ++I) {
724 wasm::WasmFeatureEntry Feature;
725 Feature.Prefix = readUint8(Ctx);
726 switch (Feature.Prefix) {
727 case wasm::WASM_FEATURE_PREFIX_USED:
728 case wasm::WASM_FEATURE_PREFIX_REQUIRED:
729 case wasm::WASM_FEATURE_PREFIX_DISALLOWED:
730 break;
731 default:
732 return make_error<GenericBinaryError>("Unknown feature policy prefix",
733 object_error::parse_failed);
734 }
735 Feature.Name = readString(Ctx);
736 if (!FeaturesSeen.insert(Feature.Name).second)
737 return make_error<GenericBinaryError>(
738 "Target features section contains repeated feature \"" +
739 Feature.Name + "\"",
740 object_error::parse_failed);
741 TargetFeatures.push_back(Feature);
742 }
743 if (Ctx.Ptr != Ctx.End)
744 return make_error<GenericBinaryError>(
745 "Target features section ended prematurely",
746 object_error::parse_failed);
747 return Error::success();
748}
749
750Error WasmObjectFile::parseRelocSection(StringRef Name, ReadContext &Ctx) {
751 uint32_t SectionIndex = readVaruint32(Ctx);
752 if (SectionIndex >= Sections.size())
753 return make_error<GenericBinaryError>("Invalid section index",
754 object_error::parse_failed);
755 WasmSection &Section = Sections[SectionIndex];
756 uint32_t RelocCount = readVaruint32(Ctx);
757 uint32_t EndOffset = Section.Content.size();
758 uint32_t PreviousOffset = 0;
759 while (RelocCount--) {
760 wasm::WasmRelocation Reloc = {};
761 Reloc.Type = readVaruint32(Ctx);
762 Reloc.Offset = readVaruint32(Ctx);
763 if (Reloc.Offset < PreviousOffset)
764 return make_error<GenericBinaryError>("Relocations not in offset order",
765 object_error::parse_failed);
766 PreviousOffset = Reloc.Offset;
767 Reloc.Index = readVaruint32(Ctx);
768 switch (Reloc.Type) {
769 case wasm::R_WASM_FUNCTION_INDEX_LEB:
770 case wasm::R_WASM_TABLE_INDEX_SLEB:
771 case wasm::R_WASM_TABLE_INDEX_I32:
772 case wasm::R_WASM_TABLE_INDEX_REL_SLEB:
773 if (!isValidFunctionSymbol(Reloc.Index))
774 return make_error<GenericBinaryError>("Bad relocation function index",
775 object_error::parse_failed);
776 break;
777 case wasm::R_WASM_TYPE_INDEX_LEB:
778 if (Reloc.Index >= Signatures.size())
779 return make_error<GenericBinaryError>("Bad relocation type index",
780 object_error::parse_failed);
781 break;
782 case wasm::R_WASM_GLOBAL_INDEX_LEB:
783 // R_WASM_GLOBAL_INDEX_LEB are can be used against function and data
784 // symbols to refer to thier GOT enties.
785 if (!isValidGlobalSymbol(Reloc.Index) &&
786 !isValidDataSymbol(Reloc.Index) &&
787 !isValidFunctionSymbol(Reloc.Index))
788 return make_error<GenericBinaryError>("Bad relocation global index",
789 object_error::parse_failed);
790 break;
791 case wasm::R_WASM_EVENT_INDEX_LEB:
792 if (!isValidEventSymbol(Reloc.Index))
793 return make_error<GenericBinaryError>("Bad relocation event index",
794 object_error::parse_failed);
795 break;
796 case wasm::R_WASM_MEMORY_ADDR_LEB:
797 case wasm::R_WASM_MEMORY_ADDR_SLEB:
798 case wasm::R_WASM_MEMORY_ADDR_I32:
799 case wasm::R_WASM_MEMORY_ADDR_REL_SLEB:
800 if (!isValidDataSymbol(Reloc.Index))
801 return make_error<GenericBinaryError>("Bad relocation data index",
802 object_error::parse_failed);
803 Reloc.Addend = readVarint32(Ctx);
804 break;
805 case wasm::R_WASM_FUNCTION_OFFSET_I32:
806 if (!isValidFunctionSymbol(Reloc.Index))
807 return make_error<GenericBinaryError>("Bad relocation function index",
808 object_error::parse_failed);
809 Reloc.Addend = readVarint32(Ctx);
810 break;
811 case wasm::R_WASM_SECTION_OFFSET_I32:
812 if (!isValidSectionSymbol(Reloc.Index))
813 return make_error<GenericBinaryError>("Bad relocation section index",
814 object_error::parse_failed);
815 Reloc.Addend = readVarint32(Ctx);
816 break;
817 default:
818 return make_error<GenericBinaryError>("Bad relocation type: " +
819 Twine(Reloc.Type),
820 object_error::parse_failed);
821 }
822
823 // Relocations must fit inside the section, and must appear in order. They
824 // also shouldn't overlap a function/element boundary, but we don't bother
825 // to check that.
826 uint64_t Size = 5;
827 if (Reloc.Type == wasm::R_WASM_TABLE_INDEX_I32 ||
828 Reloc.Type == wasm::R_WASM_MEMORY_ADDR_I32 ||
829 Reloc.Type == wasm::R_WASM_SECTION_OFFSET_I32 ||
830 Reloc.Type == wasm::R_WASM_FUNCTION_OFFSET_I32)
831 Size = 4;
832 if (Reloc.Offset + Size > EndOffset)
833 return make_error<GenericBinaryError>("Bad relocation offset",
834 object_error::parse_failed);
835
836 Section.Relocations.push_back(Reloc);
837 }
838 if (Ctx.Ptr != Ctx.End)
839 return make_error<GenericBinaryError>("Reloc section ended prematurely",
840 object_error::parse_failed);
841 return Error::success();
842}
843
844Error WasmObjectFile::parseCustomSection(WasmSection &Sec, ReadContext &Ctx) {
845 if (Sec.Name == "dylink") {
846 if (Error Err = parseDylinkSection(Ctx))
847 return Err;
848 } else if (Sec.Name == "name") {
849 if (Error Err = parseNameSection(Ctx))
850 return Err;
851 } else if (Sec.Name == "linking") {
852 if (Error Err = parseLinkingSection(Ctx))
853 return Err;
854 } else if (Sec.Name == "producers") {
855 if (Error Err = parseProducersSection(Ctx))
856 return Err;
857 } else if (Sec.Name == "target_features") {
858 if (Error Err = parseTargetFeaturesSection(Ctx))
859 return Err;
860 } else if (Sec.Name.startswith("reloc.")) {
861 if (Error Err = parseRelocSection(Sec.Name, Ctx))
862 return Err;
863 }
864 return Error::success();
865}
866
867Error WasmObjectFile::parseTypeSection(ReadContext &Ctx) {
868 uint32_t Count = readVaruint32(Ctx);
869 Signatures.reserve(Count);
870 while (Count--) {
871 wasm::WasmSignature Sig;
872 uint8_t Form = readUint8(Ctx);
873 if (Form != wasm::WASM_TYPE_FUNC) {
874 return make_error<GenericBinaryError>("Invalid signature type",
875 object_error::parse_failed);
876 }
877 uint32_t ParamCount = readVaruint32(Ctx);
878 Sig.Params.reserve(ParamCount);
879 while (ParamCount--) {
880 uint32_t ParamType = readUint8(Ctx);
881 Sig.Params.push_back(wasm::ValType(ParamType));
882 }
883 uint32_t ReturnCount = readVaruint32(Ctx);
884 if (ReturnCount) {
885 if (ReturnCount != 1) {
886 return make_error<GenericBinaryError>(
887 "Multiple return types not supported", object_error::parse_failed);
888 }
889 Sig.Returns.push_back(wasm::ValType(readUint8(Ctx)));
890 }
891 Signatures.push_back(std::move(Sig));
892 }
893 if (Ctx.Ptr != Ctx.End)
894 return make_error<GenericBinaryError>("Type section ended prematurely",
895 object_error::parse_failed);
896 return Error::success();
897}
898
899Error WasmObjectFile::parseImportSection(ReadContext &Ctx) {
900 uint32_t Count = readVaruint32(Ctx);
901 Imports.reserve(Count);
902 for (uint32_t I = 0; I < Count; I++) {
903 wasm::WasmImport Im;
904 Im.Module = readString(Ctx);
905 Im.Field = readString(Ctx);
906 Im.Kind = readUint8(Ctx);
907 switch (Im.Kind) {
908 case wasm::WASM_EXTERNAL_FUNCTION:
909 NumImportedFunctions++;
910 Im.SigIndex = readVaruint32(Ctx);
911 break;
912 case wasm::WASM_EXTERNAL_GLOBAL:
913 NumImportedGlobals++;
914 Im.Global.Type = readUint8(Ctx);
915 Im.Global.Mutable = readVaruint1(Ctx);
916 break;
917 case wasm::WASM_EXTERNAL_MEMORY:
918 Im.Memory = readLimits(Ctx);
919 break;
920 case wasm::WASM_EXTERNAL_TABLE:
921 Im.Table = readTable(Ctx);
922 if (Im.Table.ElemType != wasm::WASM_TYPE_FUNCREF)
923 return make_error<GenericBinaryError>("Invalid table element type",
924 object_error::parse_failed);
925 break;
926 case wasm::WASM_EXTERNAL_EVENT:
927 NumImportedEvents++;
928 Im.Event.Attribute = readVarint32(Ctx);
929 Im.Event.SigIndex = readVarint32(Ctx);
930 break;
931 default:
932 return make_error<GenericBinaryError>("Unexpected import kind",
933 object_error::parse_failed);
934 }
935 Imports.push_back(Im);
936 }
937 if (Ctx.Ptr != Ctx.End)
938 return make_error<GenericBinaryError>("Import section ended prematurely",
939 object_error::parse_failed);
940 return Error::success();
941}
942
943Error WasmObjectFile::parseFunctionSection(ReadContext &Ctx) {
944 uint32_t Count = readVaruint32(Ctx);
945 FunctionTypes.reserve(Count);
946 uint32_t NumTypes = Signatures.size();
947 while (Count--) {
948 uint32_t Type = readVaruint32(Ctx);
949 if (Type >= NumTypes)
950 return make_error<GenericBinaryError>("Invalid function type",
951 object_error::parse_failed);
952 FunctionTypes.push_back(Type);
953 }
954 if (Ctx.Ptr != Ctx.End)
955 return make_error<GenericBinaryError>("Function section ended prematurely",
956 object_error::parse_failed);
957 return Error::success();
958}
959
960Error WasmObjectFile::parseTableSection(ReadContext &Ctx) {
961 uint32_t Count = readVaruint32(Ctx);
962 Tables.reserve(Count);
963 while (Count--) {
964 Tables.push_back(readTable(Ctx));
965 if (Tables.back().ElemType != wasm::WASM_TYPE_FUNCREF) {
966 return make_error<GenericBinaryError>("Invalid table element type",
967 object_error::parse_failed);
968 }
969 }
970 if (Ctx.Ptr != Ctx.End)
971 return make_error<GenericBinaryError>("Table section ended prematurely",
972 object_error::parse_failed);
973 return Error::success();
974}
975
976Error WasmObjectFile::parseMemorySection(ReadContext &Ctx) {
977 uint32_t Count = readVaruint32(Ctx);
978 Memories.reserve(Count);
979 while (Count--) {
980 Memories.push_back(readLimits(Ctx));
981 }
982 if (Ctx.Ptr != Ctx.End)
983 return make_error<GenericBinaryError>("Memory section ended prematurely",
984 object_error::parse_failed);
985 return Error::success();
986}
987
988Error WasmObjectFile::parseGlobalSection(ReadContext &Ctx) {
989 GlobalSection = Sections.size();
990 uint32_t Count = readVaruint32(Ctx);
991 Globals.reserve(Count);
992 while (Count--) {
993 wasm::WasmGlobal Global;
994 Global.Index = NumImportedGlobals + Globals.size();
995 Global.Type.Type = readUint8(Ctx);
996 Global.Type.Mutable = readVaruint1(Ctx);
997 if (Error Err = readInitExpr(Global.InitExpr, Ctx))
998 return Err;
999 Globals.push_back(Global);
1000 }
1001 if (Ctx.Ptr != Ctx.End)
1002 return make_error<GenericBinaryError>("Global section ended prematurely",
1003 object_error::parse_failed);
1004 return Error::success();
1005}
1006
1007Error WasmObjectFile::parseEventSection(ReadContext &Ctx) {
1008 EventSection = Sections.size();
1009 uint32_t Count = readVarint32(Ctx);
1010 Events.reserve(Count);
1011 while (Count--) {
1012 wasm::WasmEvent Event;
1013 Event.Index = NumImportedEvents + Events.size();
1014 Event.Type.Attribute = readVaruint32(Ctx);
1015 Event.Type.SigIndex = readVarint32(Ctx);
1016 Events.push_back(Event);
1017 }
1018
1019 if (Ctx.Ptr != Ctx.End)
1020 return make_error<GenericBinaryError>("Event section ended prematurely",
1021 object_error::parse_failed);
1022 return Error::success();
1023}
1024
1025Error WasmObjectFile::parseExportSection(ReadContext &Ctx) {
1026 uint32_t Count = readVaruint32(Ctx);
1027 Exports.reserve(Count);
1028 for (uint32_t I = 0; I < Count; I++) {
1029 wasm::WasmExport Ex;
1030 Ex.Name = readString(Ctx);
1031 Ex.Kind = readUint8(Ctx);
1032 Ex.Index = readVaruint32(Ctx);
1033 switch (Ex.Kind) {
1034 case wasm::WASM_EXTERNAL_FUNCTION:
1035 if (!isValidFunctionIndex(Ex.Index))
1036 return make_error<GenericBinaryError>("Invalid function export",
1037 object_error::parse_failed);
1038 break;
1039 case wasm::WASM_EXTERNAL_GLOBAL:
1040 if (!isValidGlobalIndex(Ex.Index))
1041 return make_error<GenericBinaryError>("Invalid global export",
1042 object_error::parse_failed);
1043 break;
1044 case wasm::WASM_EXTERNAL_EVENT:
1045 if (!isValidEventIndex(Ex.Index))
1046 return make_error<GenericBinaryError>("Invalid event export",
1047 object_error::parse_failed);
1048 break;
1049 case wasm::WASM_EXTERNAL_MEMORY:
1050 case wasm::WASM_EXTERNAL_TABLE:
1051 break;
1052 default:
1053 return make_error<GenericBinaryError>("Unexpected export kind",
1054 object_error::parse_failed);
1055 }
1056 Exports.push_back(Ex);
1057 }
1058 if (Ctx.Ptr != Ctx.End)
1059 return make_error<GenericBinaryError>("Export section ended prematurely",
1060 object_error::parse_failed);
1061 return Error::success();
1062}
1063
1064bool WasmObjectFile::isValidFunctionIndex(uint32_t Index) const {
1065 return Index < NumImportedFunctions + FunctionTypes.size();
1066}
1067
1068bool WasmObjectFile::isDefinedFunctionIndex(uint32_t Index) const {
1069 return Index >= NumImportedFunctions && isValidFunctionIndex(Index);
1070}
1071
1072bool WasmObjectFile::isValidGlobalIndex(uint32_t Index) const {
1073 return Index < NumImportedGlobals + Globals.size();
1074}
1075
1076bool WasmObjectFile::isDefinedGlobalIndex(uint32_t Index) const {
1077 return Index >= NumImportedGlobals && isValidGlobalIndex(Index);
1078}
1079
1080bool WasmObjectFile::isValidEventIndex(uint32_t Index) const {
1081 return Index < NumImportedEvents + Events.size();
1082}
1083
1084bool WasmObjectFile::isDefinedEventIndex(uint32_t Index) const {
1085 return Index >= NumImportedEvents && isValidEventIndex(Index);
1086}
1087
1088bool WasmObjectFile::isValidFunctionSymbol(uint32_t Index) const {
1089 return Index < Symbols.size() && Symbols[Index].isTypeFunction();
1090}
1091
1092bool WasmObjectFile::isValidGlobalSymbol(uint32_t Index) const {
1093 return Index < Symbols.size() && Symbols[Index].isTypeGlobal();
1094}
1095
1096bool WasmObjectFile::isValidEventSymbol(uint32_t Index) const {
1097 return Index < Symbols.size() && Symbols[Index].isTypeEvent();
1098}
1099
1100bool WasmObjectFile::isValidDataSymbol(uint32_t Index) const {
1101 return Index < Symbols.size() && Symbols[Index].isTypeData();
1102}
1103
1104bool WasmObjectFile::isValidSectionSymbol(uint32_t Index) const {
1105 return Index < Symbols.size() && Symbols[Index].isTypeSection();
1106}
1107
1108wasm::WasmFunction &WasmObjectFile::getDefinedFunction(uint32_t Index) {
1109 assert(isDefinedFunctionIndex(Index))((isDefinedFunctionIndex(Index)) ? static_cast<void> (0
) : __assert_fail ("isDefinedFunctionIndex(Index)", "/build/llvm-toolchain-snapshot-9~svn358520/lib/Object/WasmObjectFile.cpp"
, 1109, __PRETTY_FUNCTION__))
;
1110 return Functions[Index - NumImportedFunctions];
1111}
1112
1113const wasm::WasmFunction &
1114WasmObjectFile::getDefinedFunction(uint32_t Index) const {
1115 assert(isDefinedFunctionIndex(Index))((isDefinedFunctionIndex(Index)) ? static_cast<void> (0
) : __assert_fail ("isDefinedFunctionIndex(Index)", "/build/llvm-toolchain-snapshot-9~svn358520/lib/Object/WasmObjectFile.cpp"
, 1115, __PRETTY_FUNCTION__))
;
1116 return Functions[Index - NumImportedFunctions];
1117}
1118
1119wasm::WasmGlobal &WasmObjectFile::getDefinedGlobal(uint32_t Index) {
1120 assert(isDefinedGlobalIndex(Index))((isDefinedGlobalIndex(Index)) ? static_cast<void> (0) :
__assert_fail ("isDefinedGlobalIndex(Index)", "/build/llvm-toolchain-snapshot-9~svn358520/lib/Object/WasmObjectFile.cpp"
, 1120, __PRETTY_FUNCTION__))
;
1121 return Globals[Index - NumImportedGlobals];
1122}
1123
1124wasm::WasmEvent &WasmObjectFile::getDefinedEvent(uint32_t Index) {
1125 assert(isDefinedEventIndex(Index))((isDefinedEventIndex(Index)) ? static_cast<void> (0) :
__assert_fail ("isDefinedEventIndex(Index)", "/build/llvm-toolchain-snapshot-9~svn358520/lib/Object/WasmObjectFile.cpp"
, 1125, __PRETTY_FUNCTION__))
;
1126 return Events[Index - NumImportedEvents];
1127}
1128
1129Error WasmObjectFile::parseStartSection(ReadContext &Ctx) {
1130 StartFunction = readVaruint32(Ctx);
1131 if (!isValidFunctionIndex(StartFunction))
1132 return make_error<GenericBinaryError>("Invalid start function",
1133 object_error::parse_failed);
1134 return Error::success();
1135}
1136
1137Error WasmObjectFile::parseCodeSection(ReadContext &Ctx) {
1138 CodeSection = Sections.size();
1139 uint32_t FunctionCount = readVaruint32(Ctx);
1140 if (FunctionCount != FunctionTypes.size()) {
1141 return make_error<GenericBinaryError>("Invalid function count",
1142 object_error::parse_failed);
1143 }
1144
1145 while (FunctionCount--) {
1146 wasm::WasmFunction Function;
1147 const uint8_t *FunctionStart = Ctx.Ptr;
1148 uint32_t Size = readVaruint32(Ctx);
1149 const uint8_t *FunctionEnd = Ctx.Ptr + Size;
1150
1151 Function.CodeOffset = Ctx.Ptr - FunctionStart;
1152 Function.Index = NumImportedFunctions + Functions.size();
1153 Function.CodeSectionOffset = FunctionStart - Ctx.Start;
1154 Function.Size = FunctionEnd - FunctionStart;
1155
1156 uint32_t NumLocalDecls = readVaruint32(Ctx);
1157 Function.Locals.reserve(NumLocalDecls);
1158 while (NumLocalDecls--) {
1159 wasm::WasmLocalDecl Decl;
1160 Decl.Count = readVaruint32(Ctx);
1161 Decl.Type = readUint8(Ctx);
1162 Function.Locals.push_back(Decl);
1163 }
1164
1165 uint32_t BodySize = FunctionEnd - Ctx.Ptr;
1166 Function.Body = ArrayRef<uint8_t>(Ctx.Ptr, BodySize);
1167 // This will be set later when reading in the linking metadata section.
1168 Function.Comdat = UINT32_MAX(4294967295U);
1169 Ctx.Ptr += BodySize;
1170 assert(Ctx.Ptr == FunctionEnd)((Ctx.Ptr == FunctionEnd) ? static_cast<void> (0) : __assert_fail
("Ctx.Ptr == FunctionEnd", "/build/llvm-toolchain-snapshot-9~svn358520/lib/Object/WasmObjectFile.cpp"
, 1170, __PRETTY_FUNCTION__))
;
1171 Functions.push_back(Function);
1172 }
1173 if (Ctx.Ptr != Ctx.End)
1174 return make_error<GenericBinaryError>("Code section ended prematurely",
1175 object_error::parse_failed);
1176 return Error::success();
1177}
1178
1179Error WasmObjectFile::parseElemSection(ReadContext &Ctx) {
1180 uint32_t Count = readVaruint32(Ctx);
1181 ElemSegments.reserve(Count);
1182 while (Count--) {
1183 wasm::WasmElemSegment Segment;
1184 Segment.TableIndex = readVaruint32(Ctx);
1185 if (Segment.TableIndex != 0) {
1186 return make_error<GenericBinaryError>("Invalid TableIndex",
1187 object_error::parse_failed);
1188 }
1189 if (Error Err = readInitExpr(Segment.Offset, Ctx))
1190 return Err;
1191 uint32_t NumElems = readVaruint32(Ctx);
1192 while (NumElems--) {
1193 Segment.Functions.push_back(readVaruint32(Ctx));
1194 }
1195 ElemSegments.push_back(Segment);
1196 }
1197 if (Ctx.Ptr != Ctx.End)
1198 return make_error<GenericBinaryError>("Elem section ended prematurely",
1199 object_error::parse_failed);
1200 return Error::success();
1201}
1202
1203Error WasmObjectFile::parseDataSection(ReadContext &Ctx) {
1204 DataSection = Sections.size();
1205 uint32_t Count = readVaruint32(Ctx);
1206 if (DataCount && Count != DataCount.getValue())
1207 return make_error<GenericBinaryError>(
1208 "Number of data segments does not match DataCount section");
1209 DataSegments.reserve(Count);
1210 while (Count--) {
1211 WasmSegment Segment;
1212 Segment.Data.InitFlags = readVaruint32(Ctx);
1213 Segment.Data.MemoryIndex = (Segment.Data.InitFlags & wasm::WASM_SEGMENT_HAS_MEMINDEX)
1214 ? readVaruint32(Ctx) : 0;
1215 if ((Segment.Data.InitFlags & wasm::WASM_SEGMENT_IS_PASSIVE) == 0) {
1216 if (Error Err = readInitExpr(Segment.Data.Offset, Ctx))
1217 return Err;
1218 } else {
1219 Segment.Data.Offset.Opcode = wasm::WASM_OPCODE_I32_CONST;
1220 Segment.Data.Offset.Value.Int32 = 0;
1221 }
1222 uint32_t Size = readVaruint32(Ctx);
1223 if (Size > (size_t)(Ctx.End - Ctx.Ptr))
1224 return make_error<GenericBinaryError>("Invalid segment size",
1225 object_error::parse_failed);
1226 Segment.Data.Content = ArrayRef<uint8_t>(Ctx.Ptr, Size);
1227 // The rest of these Data fields are set later, when reading in the linking
1228 // metadata section.
1229 Segment.Data.Alignment = 0;
1230 Segment.Data.LinkerFlags = 0;
1231 Segment.Data.Comdat = UINT32_MAX(4294967295U);
1232 Segment.SectionOffset = Ctx.Ptr - Ctx.Start;
1233 Ctx.Ptr += Size;
1234 DataSegments.push_back(Segment);
1235 }
1236 if (Ctx.Ptr != Ctx.End)
1237 return make_error<GenericBinaryError>("Data section ended prematurely",
1238 object_error::parse_failed);
1239 return Error::success();
1240}
1241
1242Error WasmObjectFile::parseDataCountSection(ReadContext &Ctx) {
1243 DataCount = readVaruint32(Ctx);
1244 return Error::success();
1245}
1246
1247const wasm::WasmObjectHeader &WasmObjectFile::getHeader() const {
1248 return Header;
1249}
1250
1251void WasmObjectFile::moveSymbolNext(DataRefImpl &Symb) const { Symb.d.b++; }
1252
1253uint32_t WasmObjectFile::getSymbolFlags(DataRefImpl Symb) const {
1254 uint32_t Result = SymbolRef::SF_None;
1255 const WasmSymbol &Sym = getWasmSymbol(Symb);
1256
1257 LLVM_DEBUG(dbgs() << "getSymbolFlags: ptr=" << &Sym << " " << Sym << "\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("wasm-object")) { dbgs() << "getSymbolFlags: ptr=" <<
&Sym << " " << Sym << "\n"; } } while (
false)
;
1258 if (Sym.isBindingWeak())
1259 Result |= SymbolRef::SF_Weak;
1260 if (!Sym.isBindingLocal())
1261 Result |= SymbolRef::SF_Global;
1262 if (Sym.isHidden())
1263 Result |= SymbolRef::SF_Hidden;
1264 if (!Sym.isDefined())
1265 Result |= SymbolRef::SF_Undefined;
1266 if (Sym.isTypeFunction())
1267 Result |= SymbolRef::SF_Executable;
1268 return Result;
1269}
1270
1271basic_symbol_iterator WasmObjectFile::symbol_begin() const {
1272 DataRefImpl Ref;
1273 Ref.d.a = 1; // Arbitrary non-zero value so that Ref.p is non-null
1274 Ref.d.b = 0; // Symbol index
1275 return BasicSymbolRef(Ref, this);
1276}
1277
1278basic_symbol_iterator WasmObjectFile::symbol_end() const {
1279 DataRefImpl Ref;
1280 Ref.d.a = 1; // Arbitrary non-zero value so that Ref.p is non-null
1281 Ref.d.b = Symbols.size(); // Symbol index
1282 return BasicSymbolRef(Ref, this);
1283}
1284
1285const WasmSymbol &WasmObjectFile::getWasmSymbol(const DataRefImpl &Symb) const {
1286 return Symbols[Symb.d.b];
1287}
1288
1289const WasmSymbol &WasmObjectFile::getWasmSymbol(const SymbolRef &Symb) const {
1290 return getWasmSymbol(Symb.getRawDataRefImpl());
1291}
1292
1293Expected<StringRef> WasmObjectFile::getSymbolName(DataRefImpl Symb) const {
1294 return getWasmSymbol(Symb).Info.Name;
1295}
1296
1297Expected<uint64_t> WasmObjectFile::getSymbolAddress(DataRefImpl Symb) const {
1298 auto &Sym = getWasmSymbol(Symb);
1299 if (Sym.Info.Kind == wasm::WASM_SYMBOL_TYPE_FUNCTION &&
1300 isDefinedFunctionIndex(Sym.Info.ElementIndex))
1301 return getDefinedFunction(Sym.Info.ElementIndex).CodeSectionOffset;
1302 else
1303 return getSymbolValue(Symb);
1304}
1305
1306uint64_t WasmObjectFile::getWasmSymbolValue(const WasmSymbol &Sym) const {
1307 switch (Sym.Info.Kind) {
1308 case wasm::WASM_SYMBOL_TYPE_FUNCTION:
1309 case wasm::WASM_SYMBOL_TYPE_GLOBAL:
1310 case wasm::WASM_SYMBOL_TYPE_EVENT:
1311 return Sym.Info.ElementIndex;
1312 case wasm::WASM_SYMBOL_TYPE_DATA: {
1313 // The value of a data symbol is the segment offset, plus the symbol
1314 // offset within the segment.
1315 uint32_t SegmentIndex = Sym.Info.DataRef.Segment;
1316 const wasm::WasmDataSegment &Segment = DataSegments[SegmentIndex].Data;
1317 assert(Segment.Offset.Opcode == wasm::WASM_OPCODE_I32_CONST)((Segment.Offset.Opcode == wasm::WASM_OPCODE_I32_CONST) ? static_cast
<void> (0) : __assert_fail ("Segment.Offset.Opcode == wasm::WASM_OPCODE_I32_CONST"
, "/build/llvm-toolchain-snapshot-9~svn358520/lib/Object/WasmObjectFile.cpp"
, 1317, __PRETTY_FUNCTION__))
;
1318 return Segment.Offset.Value.Int32 + Sym.Info.DataRef.Offset;
1319 }
1320 case wasm::WASM_SYMBOL_TYPE_SECTION:
1321 return 0;
1322 }
1323 llvm_unreachable("invalid symbol type")::llvm::llvm_unreachable_internal("invalid symbol type", "/build/llvm-toolchain-snapshot-9~svn358520/lib/Object/WasmObjectFile.cpp"
, 1323)
;
1324}
1325
1326uint64_t WasmObjectFile::getSymbolValueImpl(DataRefImpl Symb) const {
1327 return getWasmSymbolValue(getWasmSymbol(Symb));
1328}
1329
1330uint32_t WasmObjectFile::getSymbolAlignment(DataRefImpl Symb) const {
1331 llvm_unreachable("not yet implemented")::llvm::llvm_unreachable_internal("not yet implemented", "/build/llvm-toolchain-snapshot-9~svn358520/lib/Object/WasmObjectFile.cpp"
, 1331)
;
1332 return 0;
1333}
1334
1335uint64_t WasmObjectFile::getCommonSymbolSizeImpl(DataRefImpl Symb) const {
1336 llvm_unreachable("not yet implemented")::llvm::llvm_unreachable_internal("not yet implemented", "/build/llvm-toolchain-snapshot-9~svn358520/lib/Object/WasmObjectFile.cpp"
, 1336)
;
1337 return 0;
1338}
1339
1340Expected<SymbolRef::Type>
1341WasmObjectFile::getSymbolType(DataRefImpl Symb) const {
1342 const WasmSymbol &Sym = getWasmSymbol(Symb);
1343
1344 switch (Sym.Info.Kind) {
1345 case wasm::WASM_SYMBOL_TYPE_FUNCTION:
1346 return SymbolRef::ST_Function;
1347 case wasm::WASM_SYMBOL_TYPE_GLOBAL:
1348 return SymbolRef::ST_Other;
1349 case wasm::WASM_SYMBOL_TYPE_DATA:
1350 return SymbolRef::ST_Data;
1351 case wasm::WASM_SYMBOL_TYPE_SECTION:
1352 return SymbolRef::ST_Debug;
1353 case wasm::WASM_SYMBOL_TYPE_EVENT:
1354 return SymbolRef::ST_Other;
1355 }
1356
1357 llvm_unreachable("Unknown WasmSymbol::SymbolType")::llvm::llvm_unreachable_internal("Unknown WasmSymbol::SymbolType"
, "/build/llvm-toolchain-snapshot-9~svn358520/lib/Object/WasmObjectFile.cpp"
, 1357)
;
1358 return SymbolRef::ST_Other;
1359}
1360
1361Expected<section_iterator>
1362WasmObjectFile::getSymbolSection(DataRefImpl Symb) const {
1363 const WasmSymbol &Sym = getWasmSymbol(Symb);
1364 if (Sym.isUndefined())
1365 return section_end();
1366
1367 DataRefImpl Ref;
1368 switch (Sym.Info.Kind) {
1369 case wasm::WASM_SYMBOL_TYPE_FUNCTION:
1370 Ref.d.a = CodeSection;
1371 break;
1372 case wasm::WASM_SYMBOL_TYPE_GLOBAL:
1373 Ref.d.a = GlobalSection;
1374 break;
1375 case wasm::WASM_SYMBOL_TYPE_DATA:
1376 Ref.d.a = DataSection;
1377 break;
1378 case wasm::WASM_SYMBOL_TYPE_SECTION:
1379 Ref.d.a = Sym.Info.ElementIndex;
1380 break;
1381 case wasm::WASM_SYMBOL_TYPE_EVENT:
1382 Ref.d.a = EventSection;
1383 break;
1384 default:
1385 llvm_unreachable("Unknown WasmSymbol::SymbolType")::llvm::llvm_unreachable_internal("Unknown WasmSymbol::SymbolType"
, "/build/llvm-toolchain-snapshot-9~svn358520/lib/Object/WasmObjectFile.cpp"
, 1385)
;
1386 }
1387 return section_iterator(SectionRef(Ref, this));
1388}
1389
1390void WasmObjectFile::moveSectionNext(DataRefImpl &Sec) const { Sec.d.a++; }
1391
1392std::error_code WasmObjectFile::getSectionName(DataRefImpl Sec,
1393 StringRef &Res) const {
1394 const WasmSection &S = Sections[Sec.d.a];
1395#define ECase(X) \
1396 case wasm::WASM_SEC_##X: \
1397 Res = #X; \
1398 break
1399 switch (S.Type) {
1400 ECase(TYPE);
1401 ECase(IMPORT);
1402 ECase(FUNCTION);
1403 ECase(TABLE);
1404 ECase(MEMORY);
1405 ECase(GLOBAL);
1406 ECase(EVENT);
1407 ECase(EXPORT);
1408 ECase(START);
1409 ECase(ELEM);
1410 ECase(CODE);
1411 ECase(DATA);
1412 ECase(DATACOUNT);
1413 case wasm::WASM_SEC_CUSTOM:
1414 Res = S.Name;
1415 break;
1416 default:
1417 return object_error::invalid_section_index;
1418 }
1419#undef ECase
1420 return std::error_code();
1421}
1422
1423uint64_t WasmObjectFile::getSectionAddress(DataRefImpl Sec) const { return 0; }
1424
1425uint64_t WasmObjectFile::getSectionIndex(DataRefImpl Sec) const {
1426 return Sec.d.a;
1427}
1428
1429uint64_t WasmObjectFile::getSectionSize(DataRefImpl Sec) const {
1430 const WasmSection &S = Sections[Sec.d.a];
1431 return S.Content.size();
1432}
1433
1434std::error_code WasmObjectFile::getSectionContents(DataRefImpl Sec,
1435 StringRef &Res) const {
1436 const WasmSection &S = Sections[Sec.d.a];
1437 // This will never fail since wasm sections can never be empty (user-sections
1438 // must have a name and non-user sections each have a defined structure).
1439 Res = StringRef(reinterpret_cast<const char *>(S.Content.data()),
1440 S.Content.size());
1441 return std::error_code();
1442}
1443
1444uint64_t WasmObjectFile::getSectionAlignment(DataRefImpl Sec) const {
1445 return 1;
1446}
1447
1448bool WasmObjectFile::isSectionCompressed(DataRefImpl Sec) const {
1449 return false;
1450}
1451
1452bool WasmObjectFile::isSectionText(DataRefImpl Sec) const {
1453 return getWasmSection(Sec).Type == wasm::WASM_SEC_CODE;
1454}
1455
1456bool WasmObjectFile::isSectionData(DataRefImpl Sec) const {
1457 return getWasmSection(Sec).Type == wasm::WASM_SEC_DATA;
1458}
1459
1460bool WasmObjectFile::isSectionBSS(DataRefImpl Sec) const { return false; }
1461
1462bool WasmObjectFile::isSectionVirtual(DataRefImpl Sec) const { return false; }
1463
1464bool WasmObjectFile::isSectionBitcode(DataRefImpl Sec) const { return false; }
1465
1466relocation_iterator WasmObjectFile::section_rel_begin(DataRefImpl Ref) const {
1467 DataRefImpl RelocRef;
1468 RelocRef.d.a = Ref.d.a;
1469 RelocRef.d.b = 0;
1470 return relocation_iterator(RelocationRef(RelocRef, this));
1471}
1472
1473relocation_iterator WasmObjectFile::section_rel_end(DataRefImpl Ref) const {
1474 const WasmSection &Sec = getWasmSection(Ref);
1475 DataRefImpl RelocRef;
1476 RelocRef.d.a = Ref.d.a;
1477 RelocRef.d.b = Sec.Relocations.size();
1478 return relocation_iterator(RelocationRef(RelocRef, this));
1479}
1480
1481void WasmObjectFile::moveRelocationNext(DataRefImpl &Rel) const { Rel.d.b++; }
1482
1483uint64_t WasmObjectFile::getRelocationOffset(DataRefImpl Ref) const {
1484 const wasm::WasmRelocation &Rel = getWasmRelocation(Ref);
1485 return Rel.Offset;
1486}
1487
1488symbol_iterator WasmObjectFile::getRelocationSymbol(DataRefImpl Ref) const {
1489 const wasm::WasmRelocation &Rel = getWasmRelocation(Ref);
1490 if (Rel.Type == wasm::R_WASM_TYPE_INDEX_LEB)
1491 return symbol_end();
1492 DataRefImpl Sym;
1493 Sym.d.a = 1;
1494 Sym.d.b = Rel.Index;
1495 return symbol_iterator(SymbolRef(Sym, this));
1496}
1497
1498uint64_t WasmObjectFile::getRelocationType(DataRefImpl Ref) const {
1499 const wasm::WasmRelocation &Rel = getWasmRelocation(Ref);
1500 return Rel.Type;
1501}
1502
1503void WasmObjectFile::getRelocationTypeName(
1504 DataRefImpl Ref, SmallVectorImpl<char> &Result) const {
1505 const wasm::WasmRelocation &Rel = getWasmRelocation(Ref);
1506 StringRef Res = "Unknown";
1507
1508#define WASM_RELOC(name, value) \
1509 case wasm::name: \
1510 Res = #name; \
1511 break;
1512
1513 switch (Rel.Type) {
1514#include "llvm/BinaryFormat/WasmRelocs.def"
1515 }
1516
1517#undef WASM_RELOC
1518
1519 Result.append(Res.begin(), Res.end());
1520}
1521
1522section_iterator WasmObjectFile::section_begin() const {
1523 DataRefImpl Ref;
1524 Ref.d.a = 0;
1525 return section_iterator(SectionRef(Ref, this));
1526}
1527
1528section_iterator WasmObjectFile::section_end() const {
1529 DataRefImpl Ref;
1530 Ref.d.a = Sections.size();
1531 return section_iterator(SectionRef(Ref, this));
1532}
1533
1534uint8_t WasmObjectFile::getBytesInAddress() const { return 4; }
1535
1536StringRef WasmObjectFile::getFileFormatName() const { return "WASM"; }
1537
1538Triple::ArchType WasmObjectFile::getArch() const { return Triple::wasm32; }
1539
1540SubtargetFeatures WasmObjectFile::getFeatures() const {
1541 return SubtargetFeatures();
1542}
1543
1544bool WasmObjectFile::isRelocatableObject() const { return HasLinkingSection; }
1545
1546bool WasmObjectFile::isSharedObject() const { return HasDylinkSection; }
1547
1548const WasmSection &WasmObjectFile::getWasmSection(DataRefImpl Ref) const {
1549 assert(Ref.d.a < Sections.size())((Ref.d.a < Sections.size()) ? static_cast<void> (0)
: __assert_fail ("Ref.d.a < Sections.size()", "/build/llvm-toolchain-snapshot-9~svn358520/lib/Object/WasmObjectFile.cpp"
, 1549, __PRETTY_FUNCTION__))
;
1550 return Sections[Ref.d.a];
1551}
1552
1553const WasmSection &
1554WasmObjectFile::getWasmSection(const SectionRef &Section) const {
1555 return getWasmSection(Section.getRawDataRefImpl());
1556}
1557
1558const wasm::WasmRelocation &
1559WasmObjectFile::getWasmRelocation(const RelocationRef &Ref) const {
1560 return getWasmRelocation(Ref.getRawDataRefImpl());
1561}
1562
1563const wasm::WasmRelocation &
1564WasmObjectFile::getWasmRelocation(DataRefImpl Ref) const {
1565 assert(Ref.d.a < Sections.size())((Ref.d.a < Sections.size()) ? static_cast<void> (0)
: __assert_fail ("Ref.d.a < Sections.size()", "/build/llvm-toolchain-snapshot-9~svn358520/lib/Object/WasmObjectFile.cpp"
, 1565, __PRETTY_FUNCTION__))
;
1566 const WasmSection &Sec = Sections[Ref.d.a];
1567 assert(Ref.d.b < Sec.Relocations.size())((Ref.d.b < Sec.Relocations.size()) ? static_cast<void>
(0) : __assert_fail ("Ref.d.b < Sec.Relocations.size()", "/build/llvm-toolchain-snapshot-9~svn358520/lib/Object/WasmObjectFile.cpp"
, 1567, __PRETTY_FUNCTION__))
;
1568 return Sec.Relocations[Ref.d.b];
1569}
1570
1571int WasmSectionOrderChecker::getSectionOrder(unsigned ID,
1572 StringRef CustomSectionName) {
1573 switch (ID) {
1574 case wasm::WASM_SEC_CUSTOM:
1575 return StringSwitch<unsigned>(CustomSectionName)
1576 .Case("dylink", WASM_SEC_ORDER_DYLINK)
1577 .Case("linking", WASM_SEC_ORDER_LINKING)
1578 .StartsWith("reloc.", WASM_SEC_ORDER_RELOC)
1579 .Case("name", WASM_SEC_ORDER_NAME)
1580 .Case("producers", WASM_SEC_ORDER_PRODUCERS)
1581 .Case("target_features", WASM_SEC_ORDER_TARGET_FEATURES)
1582 .Default(WASM_SEC_ORDER_NONE);
1583 case wasm::WASM_SEC_TYPE:
1584 return WASM_SEC_ORDER_TYPE;
1585 case wasm::WASM_SEC_IMPORT:
1586 return WASM_SEC_ORDER_IMPORT;
1587 case wasm::WASM_SEC_FUNCTION:
1588 return WASM_SEC_ORDER_FUNCTION;
1589 case wasm::WASM_SEC_TABLE:
1590 return WASM_SEC_ORDER_TABLE;
1591 case wasm::WASM_SEC_MEMORY:
1592 return WASM_SEC_ORDER_MEMORY;
1593 case wasm::WASM_SEC_GLOBAL:
1594 return WASM_SEC_ORDER_GLOBAL;
1595 case wasm::WASM_SEC_EXPORT:
1596 return WASM_SEC_ORDER_EXPORT;
1597 case wasm::WASM_SEC_START:
1598 return WASM_SEC_ORDER_START;
1599 case wasm::WASM_SEC_ELEM:
1600 return WASM_SEC_ORDER_ELEM;
1601 case wasm::WASM_SEC_CODE:
1602 return WASM_SEC_ORDER_CODE;
1603 case wasm::WASM_SEC_DATA:
1604 return WASM_SEC_ORDER_DATA;
1605 case wasm::WASM_SEC_DATACOUNT:
1606 return WASM_SEC_ORDER_DATACOUNT;
1607 case wasm::WASM_SEC_EVENT:
1608 return WASM_SEC_ORDER_EVENT;
1609 default:
1610 llvm_unreachable("invalid section")::llvm::llvm_unreachable_internal("invalid section", "/build/llvm-toolchain-snapshot-9~svn358520/lib/Object/WasmObjectFile.cpp"
, 1610)
;
1611 }
1612}
1613
1614// Represents the edges in a directed graph where any node B reachable from node
1615// A is not allowed to appear before A in the section ordering, but may appear
1616// afterward.
1617int WasmSectionOrderChecker::DisallowedPredecessors[WASM_NUM_SEC_ORDERS][WASM_NUM_SEC_ORDERS] = {
1618 {}, // WASM_SEC_ORDER_NONE
1619 {WASM_SEC_ORDER_TYPE, WASM_SEC_ORDER_IMPORT}, // WASM_SEC_ORDER_TYPE,
1620 {WASM_SEC_ORDER_IMPORT, WASM_SEC_ORDER_FUNCTION}, // WASM_SEC_ORDER_IMPORT,
1621 {WASM_SEC_ORDER_FUNCTION, WASM_SEC_ORDER_TABLE}, // WASM_SEC_ORDER_FUNCTION,
1622 {WASM_SEC_ORDER_TABLE, WASM_SEC_ORDER_MEMORY}, // WASM_SEC_ORDER_TABLE,
1623 {WASM_SEC_ORDER_MEMORY, WASM_SEC_ORDER_GLOBAL}, // WASM_SEC_ORDER_MEMORY,
1624 {WASM_SEC_ORDER_GLOBAL, WASM_SEC_ORDER_EVENT}, // WASM_SEC_ORDER_GLOBAL,
1625 {WASM_SEC_ORDER_EVENT, WASM_SEC_ORDER_EXPORT}, // WASM_SEC_ORDER_EVENT,
1626 {WASM_SEC_ORDER_EXPORT, WASM_SEC_ORDER_START}, // WASM_SEC_ORDER_EXPORT,
1627 {WASM_SEC_ORDER_START, WASM_SEC_ORDER_ELEM}, // WASM_SEC_ORDER_START,
1628 {WASM_SEC_ORDER_ELEM, WASM_SEC_ORDER_DATACOUNT}, // WASM_SEC_ORDER_ELEM,
1629 {WASM_SEC_ORDER_DATACOUNT, WASM_SEC_ORDER_CODE}, // WASM_SEC_ORDER_DATACOUNT,
1630 {WASM_SEC_ORDER_CODE, WASM_SEC_ORDER_DATA}, // WASM_SEC_ORDER_CODE,
1631 {WASM_SEC_ORDER_DATA, WASM_SEC_ORDER_LINKING}, // WASM_SEC_ORDER_DATA,
1632
1633 // Custom Sections
1634 {WASM_SEC_ORDER_DYLINK, WASM_SEC_ORDER_TYPE}, // WASM_SEC_ORDER_DYLINK,
1635 {WASM_SEC_ORDER_LINKING, WASM_SEC_ORDER_RELOC, WASM_SEC_ORDER_NAME}, // WASM_SEC_ORDER_LINKING,
1636 {}, // WASM_SEC_ORDER_RELOC (can be repeated),
1637 {WASM_SEC_ORDER_NAME, WASM_SEC_ORDER_PRODUCERS}, // WASM_SEC_ORDER_NAME,
1638 {WASM_SEC_ORDER_PRODUCERS, WASM_SEC_ORDER_TARGET_FEATURES}, // WASM_SEC_ORDER_PRODUCERS,
1639 {WASM_SEC_ORDER_TARGET_FEATURES} // WASM_SEC_ORDER_TARGET_FEATURES
1640};
1641
1642bool WasmSectionOrderChecker::isValidSectionOrder(unsigned ID,
1643 StringRef CustomSectionName) {
1644 int Order = getSectionOrder(ID, CustomSectionName);
1645 if (Order == WASM_SEC_ORDER_NONE)
1646 return true;
1647
1648 // Disallowed predecessors we need to check for
1649 SmallVector<int, WASM_NUM_SEC_ORDERS> WorkList;
1650
1651 // Keep track of completed checks to avoid repeating work
1652 bool Checked[WASM_NUM_SEC_ORDERS] = {};
1653
1654 int Curr = Order;
1655 while (true) {
1656 // Add new disallowed predecessors to work list
1657 for (size_t I = 0;; ++I) {
1658 int Next = DisallowedPredecessors[Curr][I];
1659 if (Next == WASM_SEC_ORDER_NONE)
1660 break;
1661 if (Checked[Next])
1662 continue;
1663 WorkList.push_back(Next);
1664 Checked[Next] = true;
1665 }
1666
1667 if (WorkList.empty())
1668 break;
1669
1670 // Consider next disallowed predecessor
1671 Curr = WorkList.pop_back_val();
1672 if (Seen[Curr])
1673 return false;
1674 }
1675
1676 // Have not seen any disallowed predecessors
1677 Seen[Order] = true;
1678 return true;
1679}

/build/llvm-toolchain-snapshot-9~svn358520/include/llvm/Support/Error.h

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

/build/llvm-toolchain-snapshot-9~svn358520/include/llvm/ADT/STLExtras.h

1//===- llvm/ADT/STLExtras.h - Useful STL related functions ------*- C++ -*-===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9// This file contains some templates that are useful if you are working with the
10// STL at all.
11//
12// No library is required when using these functions.
13//
14//===----------------------------------------------------------------------===//
15
16#ifndef LLVM_ADT_STLEXTRAS_H
17#define LLVM_ADT_STLEXTRAS_H
18
19#include "llvm/ADT/Optional.h"
20#include "llvm/ADT/SmallVector.h"
21#include "llvm/ADT/iterator.h"
22#include "llvm/ADT/iterator_range.h"
23#include "llvm/Config/abi-breaking.h"
24#include "llvm/Support/ErrorHandling.h"
25#include <algorithm>
26#include <cassert>
27#include <cstddef>
28#include <cstdint>
29#include <cstdlib>
30#include <functional>
31#include <initializer_list>
32#include <iterator>
33#include <limits>
34#include <memory>
35#include <tuple>
36#include <type_traits>
37#include <utility>
38
39#ifdef EXPENSIVE_CHECKS
40#include <random> // for std::mt19937
41#endif
42
43namespace llvm {
44
45// Only used by compiler if both template types are the same. Useful when
46// using SFINAE to test for the existence of member functions.
47template <typename T, T> struct SameType;
48
49namespace detail {
50
51template <typename RangeT>
52using IterOfRange = decltype(std::begin(std::declval<RangeT &>()));
53
54template <typename RangeT>
55using ValueOfRange = typename std::remove_reference<decltype(
56 *std::begin(std::declval<RangeT &>()))>::type;
57
58} // end namespace detail
59
60//===----------------------------------------------------------------------===//
61// Extra additions to <type_traits>
62//===----------------------------------------------------------------------===//
63
64template <typename T>
65struct negation : std::integral_constant<bool, !bool(T::value)> {};
66
67template <typename...> struct conjunction : std::true_type {};
68template <typename B1> struct conjunction<B1> : B1 {};
69template <typename B1, typename... Bn>
70struct conjunction<B1, Bn...>
71 : std::conditional<bool(B1::value), conjunction<Bn...>, B1>::type {};
72
73template <typename T> struct make_const_ptr {
74 using type =
75 typename std::add_pointer<typename std::add_const<T>::type>::type;
76};
77
78template <typename T> struct make_const_ref {
79 using type = typename std::add_lvalue_reference<
80 typename std::add_const<T>::type>::type;
81};
82
83//===----------------------------------------------------------------------===//
84// Extra additions to <functional>
85//===----------------------------------------------------------------------===//
86
87template <class Ty> struct identity {
88 using argument_type = Ty;
89
90 Ty &operator()(Ty &self) const {
91 return self;
92 }
93 const Ty &operator()(const Ty &self) const {
94 return self;
95 }
96};
97
98template <class Ty> struct less_ptr {
99 bool operator()(const Ty* left, const Ty* right) const {
100 return *left < *right;
101 }
102};
103
104template <class Ty> struct greater_ptr {
105 bool operator()(const Ty* left, const Ty* right) const {
106 return *right < *left;
107 }
108};
109
110/// An efficient, type-erasing, non-owning reference to a callable. This is
111/// intended for use as the type of a function parameter that is not used
112/// after the function in question returns.
113///
114/// This class does not own the callable, so it is not in general safe to store
115/// a function_ref.
116template<typename Fn> class function_ref;
117
118template<typename Ret, typename ...Params>
119class function_ref<Ret(Params...)> {
120 Ret (*callback)(intptr_t callable, Params ...params) = nullptr;
121 intptr_t callable;
122
123 template<typename Callable>
124 static Ret callback_fn(intptr_t callable, Params ...params) {
125 return (*reinterpret_cast<Callable*>(callable))(
126 std::forward<Params>(params)...);
127 }
128
129public:
130 function_ref() = default;
131 function_ref(std::nullptr_t) {}
132
133 template <typename Callable>
134 function_ref(Callable &&callable,
135 typename std::enable_if<
136 !std::is_same<typename std::remove_reference<Callable>::type,
137 function_ref>::value>::type * = nullptr)
138 : callback(callback_fn<typename std::remove_reference<Callable>::type>),
139 callable(reinterpret_cast<intptr_t>(&callable)) {}
140
141 Ret operator()(Params ...params) const {
142 return callback(callable, std::forward<Params>(params)...);
143 }
144
145 operator bool() const { return callback; }
146};
147
148// deleter - Very very very simple method that is used to invoke operator
149// delete on something. It is used like this:
150//
151// for_each(V.begin(), B.end(), deleter<Interval>);
152template <class T>
153inline void deleter(T *Ptr) {
154 delete Ptr;
155}
156
157//===----------------------------------------------------------------------===//
158// Extra additions to <iterator>
159//===----------------------------------------------------------------------===//
160
161namespace adl_detail {
162
163using std::begin;
164
165template <typename ContainerTy>
166auto adl_begin(ContainerTy &&container)
167 -> decltype(begin(std::forward<ContainerTy>(container))) {
168 return begin(std::forward<ContainerTy>(container));
169}
170
171using std::end;
172
173template <typename ContainerTy>
174auto adl_end(ContainerTy &&container)
175 -> decltype(end(std::forward<ContainerTy>(container))) {
176 return end(std::forward<ContainerTy>(container));
177}
178
179using std::swap;
180
181template <typename T>
182void adl_swap(T &&lhs, T &&rhs) noexcept(noexcept(swap(std::declval<T>(),
183 std::declval<T>()))) {
184 swap(std::forward<T>(lhs), std::forward<T>(rhs));
185}
186
187} // end namespace adl_detail
188
189template <typename ContainerTy>
190auto adl_begin(ContainerTy &&container)
191 -> decltype(adl_detail::adl_begin(std::forward<ContainerTy>(container))) {
192 return adl_detail::adl_begin(std::forward<ContainerTy>(container));
193}
194
195template <typename ContainerTy>
196auto adl_end(ContainerTy &&container)
197 -> decltype(adl_detail::adl_end(std::forward<ContainerTy>(container))) {
198 return adl_detail::adl_end(std::forward<ContainerTy>(container));
199}
200
201template <typename T>
202void adl_swap(T &&lhs, T &&rhs) noexcept(
203 noexcept(adl_detail::adl_swap(std::declval<T>(), std::declval<T>()))) {
204 adl_detail::adl_swap(std::forward<T>(lhs), std::forward<T>(rhs));
205}
206
207/// Test whether \p RangeOrContainer is empty. Similar to C++17 std::empty.
208template <typename T>
209constexpr bool empty(const T &RangeOrContainer) {
210 return adl_begin(RangeOrContainer) == adl_end(RangeOrContainer);
211}
212
213// mapped_iterator - This is a simple iterator adapter that causes a function to
214// be applied whenever operator* is invoked on the iterator.
215
216template <typename ItTy, typename FuncTy,
217 typename FuncReturnTy =
218 decltype(std::declval<FuncTy>()(*std::declval<ItTy>()))>
219class mapped_iterator
220 : public iterator_adaptor_base<
221 mapped_iterator<ItTy, FuncTy>, ItTy,
222 typename std::iterator_traits<ItTy>::iterator_category,
223 typename std::remove_reference<FuncReturnTy>::type> {
224public:
225 mapped_iterator(ItTy U, FuncTy F)
226 : mapped_iterator::iterator_adaptor_base(std::move(U)), F(std::move(F)) {}
227
228 ItTy getCurrent() { return this->I; }
229
230 FuncReturnTy operator*() { return F(*this->I); }
231
232private:
233 FuncTy F;
234};
235
236// map_iterator - Provide a convenient way to create mapped_iterators, just like
237// make_pair is useful for creating pairs...
238template <class ItTy, class FuncTy>
239inline mapped_iterator<ItTy, FuncTy> map_iterator(ItTy I, FuncTy F) {
240 return mapped_iterator<ItTy, FuncTy>(std::move(I), std::move(F));
241}
242
243/// Helper to determine if type T has a member called rbegin().
244template <typename Ty> class has_rbegin_impl {
245 using yes = char[1];
246 using no = char[2];
247
248 template <typename Inner>
249 static yes& test(Inner *I, decltype(I->rbegin()) * = nullptr);
250
251 template <typename>
252 static no& test(...);
253
254public:
255 static const bool value = sizeof(test<Ty>(nullptr)) == sizeof(yes);
256};
257
258/// Metafunction to determine if T& or T has a member called rbegin().
259template <typename Ty>
260struct has_rbegin : has_rbegin_impl<typename std::remove_reference<Ty>::type> {
261};
262
263// Returns an iterator_range over the given container which iterates in reverse.
264// Note that the container must have rbegin()/rend() methods for this to work.
265template <typename ContainerTy>
266auto reverse(ContainerTy &&C,
267 typename std::enable_if<has_rbegin<ContainerTy>::value>::type * =
268 nullptr) -> decltype(make_range(C.rbegin(), C.rend())) {
269 return make_range(C.rbegin(), C.rend());
270}
271
272// Returns a std::reverse_iterator wrapped around the given iterator.
273template <typename IteratorTy>
274std::reverse_iterator<IteratorTy> make_reverse_iterator(IteratorTy It) {
275 return std::reverse_iterator<IteratorTy>(It);
276}
277
278// Returns an iterator_range over the given container which iterates in reverse.
279// Note that the container must have begin()/end() methods which return
280// bidirectional iterators for this to work.
281template <typename ContainerTy>
282auto reverse(
283 ContainerTy &&C,
284 typename std::enable_if<!has_rbegin<ContainerTy>::value>::type * = nullptr)
285 -> decltype(make_range(llvm::make_reverse_iterator(std::end(C)),
286 llvm::make_reverse_iterator(std::begin(C)))) {
287 return make_range(llvm::make_reverse_iterator(std::end(C)),
288 llvm::make_reverse_iterator(std::begin(C)));
289}
290
291/// An iterator adaptor that filters the elements of given inner iterators.
292///
293/// The predicate parameter should be a callable object that accepts the wrapped
294/// iterator's reference type and returns a bool. When incrementing or
295/// decrementing the iterator, it will call the predicate on each element and
296/// skip any where it returns false.
297///
298/// \code
299/// int A[] = { 1, 2, 3, 4 };
300/// auto R = make_filter_range(A, [](int N) { return N % 2 == 1; });
301/// // R contains { 1, 3 }.
302/// \endcode
303///
304/// Note: filter_iterator_base implements support for forward iteration.
305/// filter_iterator_impl exists to provide support for bidirectional iteration,
306/// conditional on whether the wrapped iterator supports it.
307template <typename WrappedIteratorT, typename PredicateT, typename IterTag>
308class filter_iterator_base
309 : public iterator_adaptor_base<
310 filter_iterator_base<WrappedIteratorT, PredicateT, IterTag>,
311 WrappedIteratorT,
312 typename std::common_type<
313 IterTag, typename std::iterator_traits<
314 WrappedIteratorT>::iterator_category>::type> {
315 using BaseT = iterator_adaptor_base<
316 filter_iterator_base<WrappedIteratorT, PredicateT, IterTag>,
317 WrappedIteratorT,
318 typename std::common_type<
319 IterTag, typename std::iterator_traits<
320 WrappedIteratorT>::iterator_category>::type>;
321
322protected:
323 WrappedIteratorT End;
324 PredicateT Pred;
325
326 void findNextValid() {
327 while (this->I != End && !Pred(*this->I))
328 BaseT::operator++();
329 }
330
331 // Construct the iterator. The begin iterator needs to know where the end
332 // is, so that it can properly stop when it gets there. The end iterator only
333 // needs the predicate to support bidirectional iteration.
334 filter_iterator_base(WrappedIteratorT Begin, WrappedIteratorT End,
335 PredicateT Pred)
336 : BaseT(Begin), End(End), Pred(Pred) {
337 findNextValid();
338 }
339
340public:
341 using BaseT::operator++;
342
343 filter_iterator_base &operator++() {
344 BaseT::operator++();
345 findNextValid();
346 return *this;
347 }
348};
349
350/// Specialization of filter_iterator_base for forward iteration only.
351template <typename WrappedIteratorT, typename PredicateT,
352 typename IterTag = std::forward_iterator_tag>
353class filter_iterator_impl
354 : public filter_iterator_base<WrappedIteratorT, PredicateT, IterTag> {
355 using BaseT = filter_iterator_base<WrappedIteratorT, PredicateT, IterTag>;
356
357public:
358 filter_iterator_impl(WrappedIteratorT Begin, WrappedIteratorT End,
359 PredicateT Pred)
360 : BaseT(Begin, End, Pred) {}
361};
362
363/// Specialization of filter_iterator_base for bidirectional iteration.
364template <typename WrappedIteratorT, typename PredicateT>
365class filter_iterator_impl<WrappedIteratorT, PredicateT,
366 std::bidirectional_iterator_tag>
367 : public filter_iterator_base<WrappedIteratorT, PredicateT,
368 std::bidirectional_iterator_tag> {
369 using BaseT = filter_iterator_base<WrappedIteratorT, PredicateT,
370 std::bidirectional_iterator_tag>;
371 void findPrevValid() {
372 while (!this->Pred(*this->I))
373 BaseT::operator--();
374 }
375
376public:
377 using BaseT::operator--;
378
379 filter_iterator_impl(WrappedIteratorT Begin, WrappedIteratorT End,
380 PredicateT Pred)
381 : BaseT(Begin, End, Pred) {}
382
383 filter_iterator_impl &operator--() {
384 BaseT::operator--();
385 findPrevValid();
386 return *this;
387 }
388};
389
390namespace detail {
391
392template <bool is_bidirectional> struct fwd_or_bidi_tag_impl {
393 using type = std::forward_iterator_tag;
394};
395
396template <> struct fwd_or_bidi_tag_impl<true> {
397 using type = std::bidirectional_iterator_tag;
398};
399
400/// Helper which sets its type member to forward_iterator_tag if the category
401/// of \p IterT does not derive from bidirectional_iterator_tag, and to
402/// bidirectional_iterator_tag otherwise.
403template <typename IterT> struct fwd_or_bidi_tag {
404 using type = typename fwd_or_bidi_tag_impl<std::is_base_of<
405 std::bidirectional_iterator_tag,
406 typename std::iterator_traits<IterT>::iterator_category>::value>::type;
407};
408
409} // namespace detail
410
411/// Defines filter_iterator to a suitable specialization of
412/// filter_iterator_impl, based on the underlying iterator's category.
413template <typename WrappedIteratorT, typename PredicateT>
414using filter_iterator = filter_iterator_impl<
415 WrappedIteratorT, PredicateT,
416 typename detail::fwd_or_bidi_tag<WrappedIteratorT>::type>;
417
418/// Convenience function that takes a range of elements and a predicate,
419/// and return a new filter_iterator range.
420///
421/// FIXME: Currently if RangeT && is a rvalue reference to a temporary, the
422/// lifetime of that temporary is not kept by the returned range object, and the
423/// temporary is going to be dropped on the floor after the make_iterator_range
424/// full expression that contains this function call.
425template <typename RangeT, typename PredicateT>
426iterator_range<filter_iterator<detail::IterOfRange<RangeT>, PredicateT>>
427make_filter_range(RangeT &&Range, PredicateT Pred) {
428 using FilterIteratorT =
429 filter_iterator<detail::IterOfRange<RangeT>, PredicateT>;
430 return make_range(
431 FilterIteratorT(std::begin(std::forward<RangeT>(Range)),
432 std::end(std::forward<RangeT>(Range)), Pred),
433 FilterIteratorT(std::end(std::forward<RangeT>(Range)),
434 std::end(std::forward<RangeT>(Range)), Pred));
435}
436
437/// A pseudo-iterator adaptor that is designed to implement "early increment"
438/// style loops.
439///
440/// This is *not a normal iterator* and should almost never be used directly. It
441/// is intended primarily to be used with range based for loops and some range
442/// algorithms.
443///
444/// The iterator isn't quite an `OutputIterator` or an `InputIterator` but
445/// somewhere between them. The constraints of these iterators are:
446///
447/// - On construction or after being incremented, it is comparable and
448/// dereferencable. It is *not* incrementable.
449/// - After being dereferenced, it is neither comparable nor dereferencable, it
450/// is only incrementable.
451///
452/// This means you can only dereference the iterator once, and you can only
453/// increment it once between dereferences.
454template <typename WrappedIteratorT>
455class early_inc_iterator_impl
456 : public iterator_adaptor_base<early_inc_iterator_impl<WrappedIteratorT>,
457 WrappedIteratorT, std::input_iterator_tag> {
458 using BaseT =
459 iterator_adaptor_base<early_inc_iterator_impl<WrappedIteratorT>,
460 WrappedIteratorT, std::input_iterator_tag>;
461
462 using PointerT = typename std::iterator_traits<WrappedIteratorT>::pointer;
463
464protected:
465#if LLVM_ENABLE_ABI_BREAKING_CHECKS1
466 bool IsEarlyIncremented = false;
467#endif
468
469public:
470 early_inc_iterator_impl(WrappedIteratorT I) : BaseT(I) {}
471
472 using BaseT::operator*;
473 typename BaseT::reference operator*() {
474#if LLVM_ENABLE_ABI_BREAKING_CHECKS1
475 assert(!IsEarlyIncremented && "Cannot dereference twice!")((!IsEarlyIncremented && "Cannot dereference twice!")
? static_cast<void> (0) : __assert_fail ("!IsEarlyIncremented && \"Cannot dereference twice!\""
, "/build/llvm-toolchain-snapshot-9~svn358520/include/llvm/ADT/STLExtras.h"
, 475, __PRETTY_FUNCTION__))
;
476 IsEarlyIncremented = true;
477#endif
478 return *(this->I)++;
479 }
480
481 using BaseT::operator++;
482 early_inc_iterator_impl &operator++() {
483#if LLVM_ENABLE_ABI_BREAKING_CHECKS1
484 assert(IsEarlyIncremented && "Cannot increment before dereferencing!")((IsEarlyIncremented && "Cannot increment before dereferencing!"
) ? static_cast<void> (0) : __assert_fail ("IsEarlyIncremented && \"Cannot increment before dereferencing!\""
, "/build/llvm-toolchain-snapshot-9~svn358520/include/llvm/ADT/STLExtras.h"
, 484, __PRETTY_FUNCTION__))
;
485 IsEarlyIncremented = false;
486#endif
487 return *this;
488 }
489
490 using BaseT::operator==;
491 bool operator==(const early_inc_iterator_impl &RHS) const {
492#if LLVM_ENABLE_ABI_BREAKING_CHECKS1
493 assert(!IsEarlyIncremented && "Cannot compare after dereferencing!")((!IsEarlyIncremented && "Cannot compare after dereferencing!"
) ? static_cast<void> (0) : __assert_fail ("!IsEarlyIncremented && \"Cannot compare after dereferencing!\""
, "/build/llvm-toolchain-snapshot-9~svn358520/include/llvm/ADT/STLExtras.h"
, 493, __PRETTY_FUNCTION__))
;
494#endif
495 return BaseT::operator==(RHS);
496 }
497};
498
499/// Make a range that does early increment to allow mutation of the underlying
500/// range without disrupting iteration.
501///
502/// The underlying iterator will be incremented immediately after it is
503/// dereferenced, allowing deletion of the current node or insertion of nodes to
504/// not disrupt iteration provided they do not invalidate the *next* iterator --
505/// the current iterator can be invalidated.
506///
507/// This requires a very exact pattern of use that is only really suitable to
508/// range based for loops and other range algorithms that explicitly guarantee
509/// to dereference exactly once each element, and to increment exactly once each
510/// element.
511template <typename RangeT>
512iterator_range<early_inc_iterator_impl<detail::IterOfRange<RangeT>>>
513make_early_inc_range(RangeT &&Range) {
514 using EarlyIncIteratorT =
515 early_inc_iterator_impl<detail::IterOfRange<RangeT>>;
516 return make_range(EarlyIncIteratorT(std::begin(std::forward<RangeT>(Range))),
517 EarlyIncIteratorT(std::end(std::forward<RangeT>(Range))));
518}
519
520// forward declarations required by zip_shortest/zip_first/zip_longest
521template <typename R, typename UnaryPredicate>
522bool all_of(R &&range, UnaryPredicate P);
523template <typename R, typename UnaryPredicate>
524bool any_of(R &&range, UnaryPredicate P);
525
526template <size_t... I> struct index_sequence;
527
528template <class... Ts> struct index_sequence_for;
529
530namespace detail {
531
532using std::declval;
533
534// We have to alias this since inlining the actual type at the usage site
535// in the parameter list of iterator_facade_base<> below ICEs MSVC 2017.
536template<typename... Iters> struct ZipTupleType {
537 using type = std::tuple<decltype(*declval<Iters>())...>;
538};
539
540template <typename ZipType, typename... Iters>
541using zip_traits = iterator_facade_base<
542 ZipType, typename std::common_type<std::bidirectional_iterator_tag,
543 typename std::iterator_traits<
544 Iters>::iterator_category...>::type,
545 // ^ TODO: Implement random access methods.
546 typename ZipTupleType<Iters...>::type,
547 typename std::iterator_traits<typename std::tuple_element<
548 0, std::tuple<Iters...>>::type>::difference_type,
549 // ^ FIXME: This follows boost::make_zip_iterator's assumption that all
550 // inner iterators have the same difference_type. It would fail if, for
551 // instance, the second field's difference_type were non-numeric while the
552 // first is.
553 typename ZipTupleType<Iters...>::type *,
554 typename ZipTupleType<Iters...>::type>;
555
556template <typename ZipType, typename... Iters>
557struct zip_common : public zip_traits<ZipType, Iters...> {
558 using Base = zip_traits<ZipType, Iters...>;
559 using value_type = typename Base::value_type;
560
561 std::tuple<Iters...> iterators;
562
563protected:
564 template <size_t... Ns> value_type deref(index_sequence<Ns...>) const {
565 return value_type(*std::get<Ns>(iterators)...);
566 }
567
568 template <size_t... Ns>
569 decltype(iterators) tup_inc(index_sequence<Ns...>) const {
570 return std::tuple<Iters...>(std::next(std::get<Ns>(iterators))...);
571 }
572
573 template <size_t... Ns>
574 decltype(iterators) tup_dec(index_sequence<Ns...>) const {
575 return std::tuple<Iters...>(std::prev(std::get<Ns>(iterators))...);
576 }
577
578public:
579 zip_common(Iters &&... ts) : iterators(std::forward<Iters>(ts)...) {}
580
581 value_type operator*() { return deref(index_sequence_for<Iters...>{}); }
582
583 const value_type operator*() const {
584 return deref(index_sequence_for<Iters...>{});
585 }
586
587 ZipType &operator++() {
588 iterators = tup_inc(index_sequence_for<Iters...>{});
589 return *reinterpret_cast<ZipType *>(this);
590 }
591
592 ZipType &operator--() {
593 static_assert(Base::IsBidirectional,
594 "All inner iterators must be at least bidirectional.");
595 iterators = tup_dec(index_sequence_for<Iters...>{});
596 return *reinterpret_cast<ZipType *>(this);
597 }
598};
599
600template <typename... Iters>
601struct zip_first : public zip_common<zip_first<Iters...>, Iters...> {
602 using Base = zip_common<zip_first<Iters...>, Iters...>;
603
604 bool operator==(const zip_first<Iters...> &other) const {
605 return std::get<0>(this->iterators) == std::get<0>(other.iterators);
606 }
607
608 zip_first(Iters &&... ts) : Base(std::forward<Iters>(ts)...) {}
609};
610
611template <typename... Iters>
612class zip_shortest : public zip_common<zip_shortest<Iters...>, Iters...> {
613 template <size_t... Ns>
614 bool test(const zip_shortest<Iters...> &other, index_sequence<Ns...>) const {
615 return all_of(std::initializer_list<bool>{std::get<Ns>(this->iterators) !=
616 std::get<Ns>(other.iterators)...},
617 identity<bool>{});
618 }
619
620public:
621 using Base = zip_common<zip_shortest<Iters...>, Iters...>;
622
623 zip_shortest(Iters &&... ts) : Base(std::forward<Iters>(ts)...) {}
624
625 bool operator==(const zip_shortest<Iters...> &other) const {
626 return !test(other, index_sequence_for<Iters...>{});
627 }
628};
629
630template <template <typename...> class ItType, typename... Args> class zippy {
631public:
632 using iterator = ItType<decltype(std::begin(std::declval<Args>()))...>;
633 using iterator_category = typename iterator::iterator_category;
634 using value_type = typename iterator::value_type;
635 using difference_type = typename iterator::difference_type;
636 using pointer = typename iterator::pointer;
637 using reference = typename iterator::reference;
638
639private:
640 std::tuple<Args...> ts;
641
642 template <size_t... Ns> iterator begin_impl(index_sequence<Ns...>) const {
643 return iterator(std::begin(std::get<Ns>(ts))...);
644 }
645 template <size_t... Ns> iterator end_impl(index_sequence<Ns...>) const {
646 return iterator(std::end(std::get<Ns>(ts))...);
647 }
648
649public:
650 zippy(Args &&... ts_) : ts(std::forward<Args>(ts_)...) {}
651
652 iterator begin() const { return begin_impl(index_sequence_for<Args...>{}); }
653 iterator end() const { return end_impl(index_sequence_for<Args...>{}); }
654};
655
656} // end namespace detail
657
658/// zip iterator for two or more iteratable types.
659template <typename T, typename U, typename... Args>
660detail::zippy<detail::zip_shortest, T, U, Args...> zip(T &&t, U &&u,
661 Args &&... args) {
662 return detail::zippy<detail::zip_shortest, T, U, Args...>(
663 std::forward<T>(t), std::forward<U>(u), std::forward<Args>(args)...);
664}
665
666/// zip iterator that, for the sake of efficiency, assumes the first iteratee to
667/// be the shortest.
668template <typename T, typename U, typename... Args>
669detail::zippy<detail::zip_first, T, U, Args...> zip_first(T &&t, U &&u,
670 Args &&... args) {
671 return detail::zippy<detail::zip_first, T, U, Args...>(
672 std::forward<T>(t), std::forward<U>(u), std::forward<Args>(args)...);
673}
674
675namespace detail {
676template <typename Iter>
677static Iter next_or_end(const Iter &I, const Iter &End) {
678 if (I == End)
679 return End;
680 return std::next(I);
681}
682
683template <typename Iter>
684static auto deref_or_none(const Iter &I, const Iter &End)
685 -> llvm::Optional<typename std::remove_const<
686 typename std::remove_reference<decltype(*I)>::type>::type> {
687 if (I == End)
688 return None;
689 return *I;
690}
691
692template <typename Iter> struct ZipLongestItemType {
693 using type =
694 llvm::Optional<typename std::remove_const<typename std::remove_reference<
695 decltype(*std::declval<Iter>())>::type>::type>;
696};
697
698template <typename... Iters> struct ZipLongestTupleType {
699 using type = std::tuple<typename ZipLongestItemType<Iters>::type...>;
700};
701
702template <typename... Iters>
703class zip_longest_iterator
704 : public iterator_facade_base<
705 zip_longest_iterator<Iters...>,
706 typename std::common_type<
707 std::forward_iterator_tag,
708 typename std::iterator_traits<Iters>::iterator_category...>::type,
709 typename ZipLongestTupleType<Iters...>::type,
710 typename std::iterator_traits<typename std::tuple_element<
711 0, std::tuple<Iters...>>::type>::difference_type,
712 typename ZipLongestTupleType<Iters...>::type *,
713 typename ZipLongestTupleType<Iters...>::type> {
714public:
715 using value_type = typename ZipLongestTupleType<Iters...>::type;
716
717private:
718 std::tuple<Iters...> iterators;
719 std::tuple<Iters...> end_iterators;
720
721 template <size_t... Ns>
722 bool test(const zip_longest_iterator<Iters...> &other,
723 index_sequence<Ns...>) const {
724 return llvm::any_of(
725 std::initializer_list<bool>{std::get<Ns>(this->iterators) !=
726 std::get<Ns>(other.iterators)...},
727 identity<bool>{});
728 }
729
730 template <size_t... Ns> value_type deref(index_sequence<Ns...>) const {
731 return value_type(
732 deref_or_none(std::get<Ns>(iterators), std::get<Ns>(end_iterators))...);
733 }
734
735 template <size_t... Ns>
736 decltype(iterators) tup_inc(index_sequence<Ns...>) const {
737 return std::tuple<Iters...>(
738 next_or_end(std::get<Ns>(iterators), std::get<Ns>(end_iterators))...);
739 }
740
741public:
742 zip_longest_iterator(std::pair<Iters &&, Iters &&>... ts)
743 : iterators(std::forward<Iters>(ts.first)...),
744 end_iterators(std::forward<Iters>(ts.second)...) {}
745
746 value_type operator*() { return deref(index_sequence_for<Iters...>{}); }
747
748 value_type operator*() const { return deref(index_sequence_for<Iters...>{}); }
749
750 zip_longest_iterator<Iters...> &operator++() {
751 iterators = tup_inc(index_sequence_for<Iters...>{});
752 return *this;
753 }
754
755 bool operator==(const zip_longest_iterator<Iters...> &other) const {
756 return !test(other, index_sequence_for<Iters...>{});
757 }
758};
759
760template <typename... Args> class zip_longest_range {
761public:
762 using iterator =
763 zip_longest_iterator<decltype(adl_begin(std::declval<Args>()))...>;
764 using iterator_category = typename iterator::iterator_category;
765 using value_type = typename iterator::value_type;
766 using difference_type = typename iterator::difference_type;
767 using pointer = typename iterator::pointer;
768 using reference = typename iterator::reference;
769
770private:
771 std::tuple<Args...> ts;
772
773 template <size_t... Ns> iterator begin_impl(index_sequence<Ns...>) const {
774 return iterator(std::make_pair(adl_begin(std::get<Ns>(ts)),
775 adl_end(std::get<Ns>(ts)))...);
776 }
777
778 template <size_t... Ns> iterator end_impl(index_sequence<Ns...>) const {
779 return iterator(std::make_pair(adl_end(std::get<Ns>(ts)),
780 adl_end(std::get<Ns>(ts)))...);
781 }
782
783public:
784 zip_longest_range(Args &&... ts_) : ts(std::forward<Args>(ts_)...) {}
785
786 iterator begin() const { return begin_impl(index_sequence_for<Args...>{}); }
787 iterator end() const { return end_impl(index_sequence_for<Args...>{}); }
788};
789} // namespace detail
790
791/// Iterate over two or more iterators at the same time. Iteration continues
792/// until all iterators reach the end. The llvm::Optional only contains a value
793/// if the iterator has not reached the end.
794template <typename T, typename U, typename... Args>
795detail::zip_longest_range<T, U, Args...> zip_longest(T &&t, U &&u,
796 Args &&... args) {
797 return detail::zip_longest_range<T, U, Args...>(
798 std::forward<T>(t), std::forward<U>(u), std::forward<Args>(args)...);
799}
800
801/// Iterator wrapper that concatenates sequences together.
802///
803/// This can concatenate different iterators, even with different types, into
804/// a single iterator provided the value types of all the concatenated
805/// iterators expose `reference` and `pointer` types that can be converted to
806/// `ValueT &` and `ValueT *` respectively. It doesn't support more
807/// interesting/customized pointer or reference types.
808///
809/// Currently this only supports forward or higher iterator categories as
810/// inputs and always exposes a forward iterator interface.
811template <typename ValueT, typename... IterTs>
812class concat_iterator
813 : public iterator_facade_base<concat_iterator<ValueT, IterTs...>,
814 std::forward_iterator_tag, ValueT> {
815 using BaseT = typename concat_iterator::iterator_facade_base;
816
817 /// We store both the current and end iterators for each concatenated
818 /// sequence in a tuple of pairs.
819 ///
820 /// Note that something like iterator_range seems nice at first here, but the
821 /// range properties are of little benefit and end up getting in the way
822 /// because we need to do mutation on the current iterators.
823 std::tuple<IterTs...> Begins;
824 std::tuple<IterTs...> Ends;
825
826 /// Attempts to increment a specific iterator.
827 ///
828 /// Returns true if it was able to increment the iterator. Returns false if
829 /// the iterator is already at the end iterator.
830 template <size_t Index> bool incrementHelper() {
831 auto &Begin = std::get<Index>(Begins);
832 auto &End = std::get<Index>(Ends);
833 if (Begin == End)
834 return false;
835
836 ++Begin;
837 return true;
838 }
839
840 /// Increments the first non-end iterator.
841 ///
842 /// It is an error to call this with all iterators at the end.
843 template <size_t... Ns> void increment(index_sequence<Ns...>) {
844 // Build a sequence of functions to increment each iterator if possible.
845 bool (concat_iterator::*IncrementHelperFns[])() = {
846 &concat_iterator::incrementHelper<Ns>...};
847
848 // Loop over them, and stop as soon as we succeed at incrementing one.
849 for (auto &IncrementHelperFn : IncrementHelperFns)
850 if ((this->*IncrementHelperFn)())
851 return;
852
853 llvm_unreachable("Attempted to increment an end concat iterator!")::llvm::llvm_unreachable_internal("Attempted to increment an end concat iterator!"
, "/build/llvm-toolchain-snapshot-9~svn358520/include/llvm/ADT/STLExtras.h"
, 853)
;
854 }
855
856 /// Returns null if the specified iterator is at the end. Otherwise,
857 /// dereferences the iterator and returns the address of the resulting
858 /// reference.
859 template <size_t Index> ValueT *getHelper() const {
860 auto &Begin = std::get<Index>(Begins);
861 auto &End = std::get<Index>(Ends);
862 if (Begin == End)
863 return nullptr;
864
865 return &*Begin;
866 }
867
868 /// Finds the first non-end iterator, dereferences, and returns the resulting
869 /// reference.
870 ///
871 /// It is an error to call this with all iterators at the end.
872 template <size_t... Ns> ValueT &get(index_sequence<Ns...>) const {
873 // Build a sequence of functions to get from iterator if possible.
874 ValueT *(concat_iterator::*GetHelperFns[])() const = {
875 &concat_iterator::getHelper<Ns>...};
876
877 // Loop over them, and return the first result we find.
878 for (auto &GetHelperFn : GetHelperFns)
879 if (ValueT *P = (this->*GetHelperFn)())
880 return *P;
881
882 llvm_unreachable("Attempted to get a pointer from an end concat iterator!")::llvm::llvm_unreachable_internal("Attempted to get a pointer from an end concat iterator!"
, "/build/llvm-toolchain-snapshot-9~svn358520/include/llvm/ADT/STLExtras.h"
, 882)
;
883 }
884
885public:
886 /// Constructs an iterator from a squence of ranges.
887 ///
888 /// We need the full range to know how to switch between each of the
889 /// iterators.
890 template <typename... RangeTs>
891 explicit concat_iterator(RangeTs &&... Ranges)
892 : Begins(std::begin(Ranges)...), Ends(std::end(Ranges)...) {}
893
894 using BaseT::operator++;
895
896 concat_iterator &operator++() {
897 increment(index_sequence_for<IterTs...>());
898 return *this;
899 }
900
901 ValueT &operator*() const { return get(index_sequence_for<IterTs...>()); }
902
903 bool operator==(const concat_iterator &RHS) const {
904 return Begins == RHS.Begins && Ends == RHS.Ends;
905 }
906};
907
908namespace detail {
909
910/// Helper to store a sequence of ranges being concatenated and access them.
911///
912/// This is designed to facilitate providing actual storage when temporaries
913/// are passed into the constructor such that we can use it as part of range
914/// based for loops.
915template <typename ValueT, typename... RangeTs> class concat_range {
916public:
917 using iterator =
918 concat_iterator<ValueT,
919 decltype(std::begin(std::declval<RangeTs &>()))...>;
920
921private:
922 std::tuple<RangeTs...> Ranges;
923
924 template <size_t... Ns> iterator begin_impl(index_sequence<Ns...>) {
925 return iterator(std::get<Ns>(Ranges)...);
926 }
927 template <size_t... Ns> iterator end_impl(index_sequence<Ns...>) {
928 return iterator(make_range(std::end(std::get<Ns>(Ranges)),
929 std::end(std::get<Ns>(Ranges)))...);
930 }
931
932public:
933 concat_range(RangeTs &&... Ranges)
934 : Ranges(std::forward<RangeTs>(Ranges)...) {}
935
936 iterator begin() { return begin_impl(index_sequence_for<RangeTs...>{}); }
937 iterator end() { return end_impl(index_sequence_for<RangeTs...>{}); }
938};
939
940} // end namespace detail
941
942/// Concatenated range across two or more ranges.
943///
944/// The desired value type must be explicitly specified.
945template <typename ValueT, typename... RangeTs>
946detail::concat_range<ValueT, RangeTs...> concat(RangeTs &&... Ranges) {
947 static_assert(sizeof...(RangeTs) > 1,
948 "Need more than one range to concatenate!");
949 return detail::concat_range<ValueT, RangeTs...>(
950 std::forward<RangeTs>(Ranges)...);
951}
952
953//===----------------------------------------------------------------------===//
954// Extra additions to <utility>
955//===----------------------------------------------------------------------===//
956
957/// Function object to check whether the first component of a std::pair
958/// compares less than the first component of another std::pair.
959struct less_first {
960 template <typename T> bool operator()(const T &lhs, const T &rhs) const {
961 return lhs.first < rhs.first;
962 }
963};
964
965/// Function object to check whether the second component of a std::pair
966/// compares less than the second component of another std::pair.
967struct less_second {
968 template <typename T> bool operator()(const T &lhs, const T &rhs) const {
969 return lhs.second < rhs.second;
970 }
971};
972
973/// \brief Function object to apply a binary function to the first component of
974/// a std::pair.
975template<typename FuncTy>
976struct on_first {
977 FuncTy func;
978
979 template <typename T>
980 auto operator()(const T &lhs, const T &rhs) const
981 -> decltype(func(lhs.first, rhs.first)) {
982 return func(lhs.first, rhs.first);
983 }
984};
985
986// A subset of N3658. More stuff can be added as-needed.
987
988/// Represents a compile-time sequence of integers.
989template <class T, T... I> struct integer_sequence {
990 using value_type = T;
991
992 static constexpr size_t size() { return sizeof...(I); }
993};
994
995/// Alias for the common case of a sequence of size_ts.
996template <size_t... I>
997struct index_sequence : integer_sequence<std::size_t, I...> {};
998
999template <std::size_t N, std::size_t... I>
1000struct build_index_impl : build_index_impl<N - 1, N - 1, I...> {};
1001template <std::size_t... I>
1002struct build_index_impl<0, I...> : index_sequence<I...> {};
1003
1004/// Creates a compile-time integer sequence for a parameter pack.
1005template <class... Ts>
1006struct index_sequence_for : build_index_impl<sizeof...(Ts)> {};
1007
1008/// Utility type to build an inheritance chain that makes it easy to rank
1009/// overload candidates.
1010template <int N> struct rank : rank<N - 1> {};
1011template <> struct rank<0> {};
1012
1013/// traits class for checking whether type T is one of any of the given
1014/// types in the variadic list.
1015template <typename T, typename... Ts> struct is_one_of {
1016 static const bool value = false;
1017};
1018
1019template <typename T, typename U, typename... Ts>
1020struct is_one_of<T, U, Ts...> {
1021 static const bool value =
1022 std::is_same<T, U>::value || is_one_of<T, Ts...>::value;
1023};
1024
1025/// traits class for checking whether type T is a base class for all
1026/// the given types in the variadic list.
1027template <typename T, typename... Ts> struct are_base_of {
1028 static const bool value = true;
1029};
1030
1031template <typename T, typename U, typename... Ts>
1032struct are_base_of<T, U, Ts...> {
1033 static const bool value =
1034 std::is_base_of<T, U>::value && are_base_of<T, Ts...>::value;
1035};
1036
1037//===----------------------------------------------------------------------===//
1038// Extra additions for arrays
1039//===----------------------------------------------------------------------===//
1040
1041/// Find the length of an array.
1042template <class T, std::size_t N>
1043constexpr inline size_t array_lengthof(T (&)[N]) {
1044 return N;
1045}
1046
1047/// Adapt std::less<T> for array_pod_sort.
1048template<typename T>
1049inline int array_pod_sort_comparator(const void *P1, const void *P2) {
1050 if (std::less<T>()(*reinterpret_cast<const T*>(P1),
1051 *reinterpret_cast<const T*>(P2)))
1052 return -1;
1053 if (std::less<T>()(*reinterpret_cast<const T*>(P2),
1054 *reinterpret_cast<const T*>(P1)))
1055 return 1;
1056 return 0;
1057}
1058
1059/// get_array_pod_sort_comparator - This is an internal helper function used to
1060/// get type deduction of T right.
1061template<typename T>
1062inline int (*get_array_pod_sort_comparator(const T &))
1063 (const void*, const void*) {
1064 return array_pod_sort_comparator<T>;
1065}
1066
1067/// array_pod_sort - This sorts an array with the specified start and end
1068/// extent. This is just like std::sort, except that it calls qsort instead of
1069/// using an inlined template. qsort is slightly slower than std::sort, but
1070/// most sorts are not performance critical in LLVM and std::sort has to be
1071/// template instantiated for each type, leading to significant measured code
1072/// bloat. This function should generally be used instead of std::sort where
1073/// possible.
1074///
1075/// This function assumes that you have simple POD-like types that can be
1076/// compared with std::less and can be moved with memcpy. If this isn't true,
1077/// you should use std::sort.
1078///
1079/// NOTE: If qsort_r were portable, we could allow a custom comparator and
1080/// default to std::less.
1081template<class IteratorTy>
1082inline void array_pod_sort(IteratorTy Start, IteratorTy End) {
1083 // Don't inefficiently call qsort with one element or trigger undefined
1084 // behavior with an empty sequence.
1085 auto NElts = End - Start;
1086 if (NElts <= 1) return;
1087#ifdef EXPENSIVE_CHECKS
1088 std::mt19937 Generator(std::random_device{}());
1089 std::shuffle(Start, End, Generator);
1090#endif
1091 qsort(&*Start, NElts, sizeof(*Start), get_array_pod_sort_comparator(*Start));
1092}
1093
1094template <class IteratorTy>
1095inline void array_pod_sort(
1096 IteratorTy Start, IteratorTy End,
1097 int (*Compare)(
1098 const typename std::iterator_traits<IteratorTy>::value_type *,
1099 const typename std::iterator_traits<IteratorTy>::value_type *)) {
1100 // Don't inefficiently call qsort with one element or trigger undefined
1101 // behavior with an empty sequence.
1102 auto NElts = End - Start;
1103 if (NElts <= 1) return;
1104#ifdef EXPENSIVE_CHECKS
1105 std::mt19937 Generator(std::random_device{}());
1106 std::shuffle(Start, End, Generator);
1107#endif
1108 qsort(&*Start, NElts, sizeof(*Start),
1109 reinterpret_cast<int (*)(const void *, const void *)>(Compare));
1110}
1111
1112// Provide wrappers to std::sort which shuffle the elements before sorting
1113// to help uncover non-deterministic behavior (PR35135).
1114template <typename IteratorTy>
1115inline void sort(IteratorTy Start, IteratorTy End) {
1116#ifdef EXPENSIVE_CHECKS
1117 std::mt19937 Generator(std::random_device{}());
1118 std::shuffle(Start, End, Generator);
1119#endif
1120 std::sort(Start, End);
1121}
1122
1123template <typename Container> inline void sort(Container &&C) {
1124 llvm::sort(adl_begin(C), adl_end(C));
1125}
1126
1127template <typename IteratorTy, typename Compare>
1128inline void sort(IteratorTy Start, IteratorTy End, Compare Comp) {
1129#ifdef EXPENSIVE_CHECKS
1130 std::mt19937 Generator(std::random_device{}());
1131 std::shuffle(Start, End, Generator);
1132#endif
1133 std::sort(Start, End, Comp);
1134}
1135
1136template <typename Container, typename Compare>
1137inline void sort(Container &&C, Compare Comp) {
1138 llvm::sort(adl_begin(C), adl_end(C), Comp);
1139}
1140
1141//===----------------------------------------------------------------------===//
1142// Extra additions to <algorithm>
1143//===----------------------------------------------------------------------===//
1144
1145/// For a container of pointers, deletes the pointers and then clears the
1146/// container.
1147template<typename Container>
1148void DeleteContainerPointers(Container &C) {
1149 for (auto V : C)
1150 delete V;
1151 C.clear();
1152}
1153
1154/// In a container of pairs (usually a map) whose second element is a pointer,
1155/// deletes the second elements and then clears the container.
1156template<typename Container>
1157void DeleteContainerSeconds(Container &C) {
1158 for (auto &V : C)
1159 delete V.second;
1160 C.clear();
1161}
1162
1163/// Get the size of a range. This is a wrapper function around std::distance
1164/// which is only enabled when the operation is O(1).
1165template <typename R>
1166auto size(R &&Range, typename std::enable_if<
1167 std::is_same<typename std::iterator_traits<decltype(
1168 Range.begin())>::iterator_category,
1169 std::random_access_iterator_tag>::value,
1170 void>::type * = nullptr)
1171 -> decltype(std::distance(Range.begin(), Range.end())) {
1172 return std::distance(Range.begin(), Range.end());
1173}
1174
1175/// Provide wrappers to std::for_each which take ranges instead of having to
1176/// pass begin/end explicitly.
1177template <typename R, typename UnaryPredicate>
1178UnaryPredicate for_each(R &&Range, UnaryPredicate P) {
1179 return std::for_each(adl_begin(Range), adl_end(Range), P);
1180}
1181
1182/// Provide wrappers to std::all_of which take ranges instead of having to pass
1183/// begin/end explicitly.
1184template <typename R, typename UnaryPredicate>
1185bool all_of(R &&Range, UnaryPredicate P) {
1186 return std::all_of(adl_begin(Range), adl_end(Range), P);
1187}
1188
1189/// Provide wrappers to std::any_of which take ranges instead of having to pass
1190/// begin/end explicitly.
1191template <typename R, typename UnaryPredicate>
1192bool any_of(R &&Range, UnaryPredicate P) {
1193 return std::any_of(adl_begin(Range), adl_end(Range), P);
1194}
1195
1196/// Provide wrappers to std::none_of which take ranges instead of having to pass
1197/// begin/end explicitly.
1198template <typename R, typename UnaryPredicate>
1199bool none_of(R &&Range, UnaryPredicate P) {
1200 return std::none_of(adl_begin(Range), adl_end(Range), P);
1201}
1202
1203/// Provide wrappers to std::find which take ranges instead of having to pass
1204/// begin/end explicitly.
1205template <typename R, typename T>
1206auto find(R &&Range, const T &Val) -> decltype(adl_begin(Range)) {
1207 return std::find(adl_begin(Range), adl_end(Range), Val);
1208}
1209
1210/// Provide wrappers to std::find_if which take ranges instead of having to pass
1211/// begin/end explicitly.
1212template <typename R, typename UnaryPredicate>
1213auto find_if(R &&Range, UnaryPredicate P) -> decltype(adl_begin(Range)) {
1214 return std::find_if(adl_begin(Range), adl_end(Range), P);
1215}
1216
1217template <typename R, typename UnaryPredicate>
1218auto find_if_not(R &&Range, UnaryPredicate P) -> decltype(adl_begin(Range)) {
1219 return std::find_if_not(adl_begin(Range), adl_end(Range), P);
1220}
1221
1222/// Provide wrappers to std::remove_if which take ranges instead of having to
1223/// pass begin/end explicitly.
1224template <typename R, typename UnaryPredicate>
1225auto remove_if(R &&Range, UnaryPredicate P) -> decltype(adl_begin(Range)) {
1226 return std::remove_if(adl_begin(Range), adl_end(Range), P);
1227}
1228
1229/// Provide wrappers to std::copy_if which take ranges instead of having to
1230/// pass begin/end explicitly.
1231template <typename R, typename OutputIt, typename UnaryPredicate>
1232OutputIt copy_if(R &&Range, OutputIt Out, UnaryPredicate P) {
1233 return std::copy_if(adl_begin(Range), adl_end(Range), Out, P);
1234}
1235
1236template <typename R, typename OutputIt>
1237OutputIt copy(R &&Range, OutputIt Out) {
1238 return std::copy(adl_begin(Range), adl_end(Range), Out);
1239}
1240
1241/// Wrapper function around std::find to detect if an element exists
1242/// in a container.
1243template <typename R, typename E>
1244bool is_contained(R &&Range, const E &Element) {
1245 return std::find(adl_begin(Range), adl_end(Range), Element) != adl_end(Range);
1246}
1247
1248/// Wrapper function around std::count to count the number of times an element
1249/// \p Element occurs in the given range \p Range.
1250template <typename R, typename E>
1251auto count(R &&Range, const E &Element) ->
1252 typename std::iterator_traits<decltype(adl_begin(Range))>::difference_type {
1253 return std::count(adl_begin(Range), adl_end(Range), Element);
1254}
1255
1256/// Wrapper function around std::count_if to count the number of times an
1257/// element satisfying a given predicate occurs in a range.
1258template <typename R, typename UnaryPredicate>
1259auto count_if(R &&Range, UnaryPredicate P) ->
1260 typename std::iterator_traits<decltype(adl_begin(Range))>::difference_type {
1261 return std::count_if(adl_begin(Range), adl_end(Range), P);
1262}
1263
1264/// Wrapper function around std::transform to apply a function to a range and
1265/// store the result elsewhere.
1266template <typename R, typename OutputIt, typename UnaryPredicate>
1267OutputIt transform(R &&Range, OutputIt d_first, UnaryPredicate P) {
1268 return std::transform(adl_begin(Range), adl_end(Range), d_first, P);
1269}
1270
1271/// Provide wrappers to std::partition which take ranges instead of having to
1272/// pass begin/end explicitly.
1273template <typename R, typename UnaryPredicate>
1274auto partition(R &&Range, UnaryPredicate P) -> decltype(adl_begin(Range)) {
1275 return std::partition(adl_begin(Range), adl_end(Range), P);
1276}
1277
1278/// Provide wrappers to std::lower_bound which take ranges instead of having to
1279/// pass begin/end explicitly.
1280template <typename R, typename T>
1281auto lower_bound(R &&Range, T &&Value) -> decltype(adl_begin(Range)) {
1282 return std::lower_bound(adl_begin(Range), adl_end(Range),
1283 std::forward<T>(Value));
1284}
1285
1286template <typename R, typename T, typename Compare>
1287auto lower_bound(R &&Range, T &&Value, Compare C)
1288 -> decltype(adl_begin(Range)) {
1289 return std::lower_bound(adl_begin(Range), adl_end(Range),
1290 std::forward<T>(Value), C);
1291}
1292
1293/// Provide wrappers to std::upper_bound which take ranges instead of having to
1294/// pass begin/end explicitly.
1295template <typename R, typename T>
1296auto upper_bound(R &&Range, T &&Value) -> decltype(adl_begin(Range)) {
1297 return std::upper_bound(adl_begin(Range), adl_end(Range),
1298 std::forward<T>(Value));
1299}
1300
1301template <typename R, typename T, typename Compare>
1302auto upper_bound(R &&Range, T &&Value, Compare C)
1303 -> decltype(adl_begin(Range)) {
1304 return std::upper_bound(adl_begin(Range), adl_end(Range),
1305 std::forward<T>(Value), C);
1306}
1307/// Wrapper function around std::equal to detect if all elements
1308/// in a container are same.
1309template <typename R>
1310bool is_splat(R &&Range) {
1311 size_t range_size = size(Range);
1312 return range_size != 0 && (range_size == 1 ||
1313 std::equal(adl_begin(Range) + 1, adl_end(Range), adl_begin(Range)));
1314}
1315
1316/// Given a range of type R, iterate the entire range and return a
1317/// SmallVector with elements of the vector. This is useful, for example,
1318/// when you want to iterate a range and then sort the results.
1319template <unsigned Size, typename R>
1320SmallVector<typename std::remove_const<detail::ValueOfRange<R>>::type, Size>
1321to_vector(R &&Range) {
1322 return {adl_begin(Range), adl_end(Range)};
1323}
1324
1325/// Provide a container algorithm similar to C++ Library Fundamentals v2's
1326/// `erase_if` which is equivalent to:
1327///
1328/// C.erase(remove_if(C, pred), C.end());
1329///
1330/// This version works for any container with an erase method call accepting
1331/// two iterators.
1332template <typename Container, typename UnaryPredicate>
1333void erase_if(Container &C, UnaryPredicate P) {
1334 C.erase(remove_if(C, P), C.end());
1335}
1336
1337//===----------------------------------------------------------------------===//
1338// Extra additions to <memory>
1339//===----------------------------------------------------------------------===//
1340
1341// Implement make_unique according to N3656.
1342
1343/// Constructs a `new T()` with the given args and returns a
1344/// `unique_ptr<T>` which owns the object.
1345///
1346/// Example:
1347///
1348/// auto p = make_unique<int>();
1349/// auto p = make_unique<std::tuple<int, int>>(0, 1);
1350template <class T, class... Args>
1351typename std::enable_if<!std::is_array<T>::value, std::unique_ptr<T>>::type
1352make_unique(Args &&... args) {
1353 return std::unique_ptr<T>(new T(std::forward<Args>(args)...));
4
Memory is allocated
1354}
1355
1356/// Constructs a `new T[n]` with the given args and returns a
1357/// `unique_ptr<T[]>` which owns the object.
1358///
1359/// \param n size of the new array.
1360///
1361/// Example:
1362///
1363/// auto p = make_unique<int[]>(2); // value-initializes the array with 0's.
1364template <class T>
1365typename std::enable_if<std::is_array<T>::value && std::extent<T>::value == 0,
1366 std::unique_ptr<T>>::type
1367make_unique(size_t n) {
1368 return std::unique_ptr<T>(new typename std::remove_extent<T>::type[n]());
1369}
1370
1371/// This function isn't used and is only here to provide better compile errors.
1372template <class T, class... Args>
1373typename std::enable_if<std::extent<T>::value != 0>::type
1374make_unique(Args &&...) = delete;
1375
1376struct FreeDeleter {
1377 void operator()(void* v) {
1378 ::free(v);
1379 }
1380};
1381
1382template<typename First, typename Second>
1383struct pair_hash {
1384 size_t operator()(const std::pair<First, Second> &P) const {
1385 return std::hash<First>()(P.first) * 31 + std::hash<Second>()(P.second);
1386 }
1387};
1388
1389/// A functor like C++14's std::less<void> in its absence.
1390struct less {
1391 template <typename A, typename B> bool operator()(A &&a, B &&b) const {
1392 return std::forward<A>(a) < std::forward<B>(b);
1393 }
1394};
1395
1396/// A functor like C++14's std::equal<void> in its absence.
1397struct equal {
1398 template <typename A, typename B> bool operator()(A &&a, B &&b) const {
1399 return std::forward<A>(a) == std::forward<B>(b);
1400 }
1401};
1402
1403/// Binary functor that adapts to any other binary functor after dereferencing
1404/// operands.
1405template <typename T> struct deref {
1406 T func;
1407
1408 // Could be further improved to cope with non-derivable functors and
1409 // non-binary functors (should be a variadic template member function
1410 // operator()).
1411 template <typename A, typename B>
1412 auto operator()(A &lhs, B &rhs) const -> decltype(func(*lhs, *rhs)) {
1413 assert(lhs)((lhs) ? static_cast<void> (0) : __assert_fail ("lhs", "/build/llvm-toolchain-snapshot-9~svn358520/include/llvm/ADT/STLExtras.h"
, 1413, __PRETTY_FUNCTION__))
;
1414 assert(rhs)((rhs) ? static_cast<void> (0) : __assert_fail ("rhs", "/build/llvm-toolchain-snapshot-9~svn358520/include/llvm/ADT/STLExtras.h"
, 1414, __PRETTY_FUNCTION__))
;
1415 return func(*lhs, *rhs);
1416 }
1417};
1418
1419namespace detail {
1420
1421template <typename R> class enumerator_iter;
1422
1423template <typename R> struct result_pair {
1424 friend class enumerator_iter<R>;
1425
1426 result_pair() = default;
1427 result_pair(std::size_t Index, IterOfRange<R> Iter)
1428 : Index(Index), Iter(Iter) {}
1429
1430 result_pair<R> &operator=(const result_pair<R> &Other) {
1431 Index = Other.Index;
1432 Iter = Other.Iter;
1433 return *this;
1434 }
1435
1436 std::size_t index() const { return Index; }
1437 const ValueOfRange<R> &value() const { return *Iter; }
1438 ValueOfRange<R> &value() { return *Iter; }
1439
1440private:
1441 std::size_t Index = std::numeric_limits<std::size_t>::max();
1442 IterOfRange<R> Iter;
1443};
1444
1445template <typename R>
1446class enumerator_iter
1447 : public iterator_facade_base<
1448 enumerator_iter<R>, std::forward_iterator_tag, result_pair<R>,
1449 typename std::iterator_traits<IterOfRange<R>>::difference_type,
1450 typename std::iterator_traits<IterOfRange<R>>::pointer,
1451 typename std::iterator_traits<IterOfRange<R>>::reference> {
1452 using result_type = result_pair<R>;
1453
1454public:
1455 explicit enumerator_iter(IterOfRange<R> EndIter)
1456 : Result(std::numeric_limits<size_t>::max(), EndIter) {}
1457
1458 enumerator_iter(std::size_t Index, IterOfRange<R> Iter)
1459 : Result(Index, Iter) {}
1460
1461 result_type &operator*() { return Result; }
1462 const result_type &operator*() const { return Result; }
1463
1464 enumerator_iter<R> &operator++() {
1465 assert(Result.Index != std::numeric_limits<size_t>::max())((Result.Index != std::numeric_limits<size_t>::max()) ?
static_cast<void> (0) : __assert_fail ("Result.Index != std::numeric_limits<size_t>::max()"
, "/build/llvm-toolchain-snapshot-9~svn358520/include/llvm/ADT/STLExtras.h"
, 1465, __PRETTY_FUNCTION__))
;
1466 ++Result.Iter;
1467 ++Result.Index;
1468 return *this;
1469 }
1470
1471 bool operator==(const enumerator_iter<R> &RHS) const {
1472 // Don't compare indices here, only iterators. It's possible for an end
1473 // iterator to have different indices depending on whether it was created
1474 // by calling std::end() versus incrementing a valid iterator.
1475 return Result.Iter == RHS.Result.Iter;
1476 }
1477
1478 enumerator_iter<R> &operator=(const enumerator_iter<R> &Other) {
1479 Result = Other.Result;
1480 return *this;
1481 }
1482
1483private:
1484 result_type Result;
1485};
1486
1487template <typename R> class enumerator {
1488public:
1489 explicit enumerator(R &&Range) : TheRange(std::forward<R>(Range)) {}
1490
1491 enumerator_iter<R> begin() {
1492 return enumerator_iter<R>(0, std::begin(TheRange));
1493 }
1494
1495 enumerator_iter<R> end() {
1496 return enumerator_iter<R>(std::end(TheRange));
1497 }
1498
1499private:
1500 R TheRange;
1501};
1502
1503} // end namespace detail
1504
1505/// Given an input range, returns a new range whose values are are pair (A,B)
1506/// such that A is the 0-based index of the item in the sequence, and B is
1507/// the value from the original sequence. Example:
1508///
1509/// std::vector<char> Items = {'A', 'B', 'C', 'D'};
1510/// for (auto X : enumerate(Items)) {
1511/// printf("Item %d - %c\n", X.index(), X.value());
1512/// }
1513///
1514/// Output:
1515/// Item 0 - A
1516/// Item 1 - B
1517/// Item 2 - C
1518/// Item 3 - D
1519///
1520template <typename R> detail::enumerator<R> enumerate(R &&TheRange) {
1521 return detail::enumerator<R>(std::forward<R>(TheRange));
1522}
1523
1524namespace detail {
1525
1526template <typename F, typename Tuple, std::size_t... I>
1527auto apply_tuple_impl(F &&f, Tuple &&t, index_sequence<I...>)
1528 -> decltype(std::forward<F>(f)(std::get<I>(std::forward<Tuple>(t))...)) {
1529 return std::forward<F>(f)(std::get<I>(std::forward<Tuple>(t))...);
1530}
1531
1532} // end namespace detail
1533
1534/// Given an input tuple (a1, a2, ..., an), pass the arguments of the
1535/// tuple variadically to f as if by calling f(a1, a2, ..., an) and
1536/// return the result.
1537template <typename F, typename Tuple>
1538auto apply_tuple(F &&f, Tuple &&t) -> decltype(detail::apply_tuple_impl(
1539 std::forward<F>(f), std::forward<Tuple>(t),
1540 build_index_impl<
1541 std::tuple_size<typename std::decay<Tuple>::type>::value>{})) {
1542 using Indices = build_index_impl<
1543 std::tuple_size<typename std::decay<Tuple>::type>::value>;
1544
1545 return detail::apply_tuple_impl(std::forward<F>(f), std::forward<Tuple>(t),
1546 Indices{});
1547}
1548
1549/// Return true if the sequence [Begin, End) has exactly N items. Runs in O(N)
1550/// time. Not meant for use with random-access iterators.
1551template <typename IterTy>
1552bool hasNItems(
1553 IterTy &&Begin, IterTy &&End, unsigned N,
1554 typename std::enable_if<
1555 !std::is_same<
1556 typename std::iterator_traits<typename std::remove_reference<
1557 decltype(Begin)>::type>::iterator_category,
1558 std::random_access_iterator_tag>::value,
1559 void>::type * = nullptr) {
1560 for (; N; --N, ++Begin)
1561 if (Begin == End)
1562 return false; // Too few.
1563 return Begin == End;
1564}
1565
1566/// Return true if the sequence [Begin, End) has N or more items. Runs in O(N)
1567/// time. Not meant for use with random-access iterators.
1568template <typename IterTy>
1569bool hasNItemsOrMore(
1570 IterTy &&Begin, IterTy &&End, unsigned N,
1571 typename std::enable_if<
1572 !std::is_same<
1573 typename std::iterator_traits<typename std::remove_reference<
1574 decltype(Begin)>::type>::iterator_category,
1575 std::random_access_iterator_tag>::value,
1576 void>::type * = nullptr) {
1577 for (; N; --N, ++Begin)
1578 if (Begin == End)
1579 return false; // Too few.
1580 return true;
1581}
1582
1583/// Returns a raw pointer that represents the same address as the argument.
1584///
1585/// The late bound return should be removed once we move to C++14 to better
1586/// align with the C++20 declaration. Also, this implementation can be removed
1587/// once we move to C++20 where it's defined as std::to_addres()
1588///
1589/// The std::pointer_traits<>::to_address(p) variations of these overloads has
1590/// not been implemented.
1591template <class Ptr> auto to_address(const Ptr &P) -> decltype(P.operator->()) {
1592 return P.operator->();
1593}
1594template <class T> constexpr T *to_address(T *P) { return P; }
1595
1596} // end namespace llvm
1597
1598#endif // LLVM_ADT_STLEXTRAS_H