Bug Summary

File:include/llvm/Support/YAMLTraits.h
Warning:line 811, column 17
1st function call argument is an uninitialized value

Annotated Source Code

Press '?' to see keyboard shortcuts

clang -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name ELFYAML.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~svn362543/build-llvm/lib/ObjectYAML -I /build/llvm-toolchain-snapshot-9~svn362543/lib/ObjectYAML -I /build/llvm-toolchain-snapshot-9~svn362543/build-llvm/include -I /build/llvm-toolchain-snapshot-9~svn362543/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~svn362543/build-llvm/lib/ObjectYAML -fdebug-prefix-map=/build/llvm-toolchain-snapshot-9~svn362543=. -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-06-05-060531-1271-1 -x c++ /build/llvm-toolchain-snapshot-9~svn362543/lib/ObjectYAML/ELFYAML.cpp -faddrsig

/build/llvm-toolchain-snapshot-9~svn362543/lib/ObjectYAML/ELFYAML.cpp

1//===- ELFYAML.cpp - ELF YAMLIO 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// This file defines classes for handling the YAML representation of ELF.
10//
11//===----------------------------------------------------------------------===//
12
13#include "llvm/ObjectYAML/ELFYAML.h"
14#include "llvm/ADT/StringRef.h"
15#include "llvm/BinaryFormat/ELF.h"
16#include "llvm/Support/Casting.h"
17#include "llvm/Support/ErrorHandling.h"
18#include "llvm/Support/MipsABIFlags.h"
19#include "llvm/Support/YAMLTraits.h"
20#include <cassert>
21#include <cstdint>
22
23namespace llvm {
24
25ELFYAML::Section::~Section() = default;
26
27namespace yaml {
28
29void ScalarEnumerationTraits<ELFYAML::ELF_ET>::enumeration(
30 IO &IO, ELFYAML::ELF_ET &Value) {
31#define ECase(X) IO.enumCase(Value, #X, ELF::X)
32 ECase(ET_NONE);
33 ECase(ET_REL);
34 ECase(ET_EXEC);
35 ECase(ET_DYN);
36 ECase(ET_CORE);
37#undef ECase
38 IO.enumFallback<Hex16>(Value);
39}
40
41void ScalarEnumerationTraits<ELFYAML::ELF_PT>::enumeration(
42 IO &IO, ELFYAML::ELF_PT &Value) {
43#define ECase(X) IO.enumCase(Value, #X, ELF::X)
44 ECase(PT_NULL);
45 ECase(PT_LOAD);
46 ECase(PT_DYNAMIC);
47 ECase(PT_INTERP);
48 ECase(PT_NOTE);
49 ECase(PT_SHLIB);
50 ECase(PT_PHDR);
51 ECase(PT_TLS);
52 ECase(PT_GNU_EH_FRAME);
53#undef ECase
54 IO.enumFallback<Hex32>(Value);
55}
56
57void ScalarEnumerationTraits<ELFYAML::ELF_EM>::enumeration(
58 IO &IO, ELFYAML::ELF_EM &Value) {
59#define ECase(X) IO.enumCase(Value, #X, ELF::X)
60 ECase(EM_NONE);
61 ECase(EM_M32);
62 ECase(EM_SPARC);
63 ECase(EM_386);
64 ECase(EM_68K);
65 ECase(EM_88K);
66 ECase(EM_IAMCU);
67 ECase(EM_860);
68 ECase(EM_MIPS);
69 ECase(EM_S370);
70 ECase(EM_MIPS_RS3_LE);
71 ECase(EM_PARISC);
72 ECase(EM_VPP500);
73 ECase(EM_SPARC32PLUS);
74 ECase(EM_960);
75 ECase(EM_PPC);
76 ECase(EM_PPC64);
77 ECase(EM_S390);
78 ECase(EM_SPU);
79 ECase(EM_V800);
80 ECase(EM_FR20);
81 ECase(EM_RH32);
82 ECase(EM_RCE);
83 ECase(EM_ARM);
84 ECase(EM_ALPHA);
85 ECase(EM_SH);
86 ECase(EM_SPARCV9);
87 ECase(EM_TRICORE);
88 ECase(EM_ARC);
89 ECase(EM_H8_300);
90 ECase(EM_H8_300H);
91 ECase(EM_H8S);
92 ECase(EM_H8_500);
93 ECase(EM_IA_64);
94 ECase(EM_MIPS_X);
95 ECase(EM_COLDFIRE);
96 ECase(EM_68HC12);
97 ECase(EM_MMA);
98 ECase(EM_PCP);
99 ECase(EM_NCPU);
100 ECase(EM_NDR1);
101 ECase(EM_STARCORE);
102 ECase(EM_ME16);
103 ECase(EM_ST100);
104 ECase(EM_TINYJ);
105 ECase(EM_X86_64);
106 ECase(EM_PDSP);
107 ECase(EM_PDP10);
108 ECase(EM_PDP11);
109 ECase(EM_FX66);
110 ECase(EM_ST9PLUS);
111 ECase(EM_ST7);
112 ECase(EM_68HC16);
113 ECase(EM_68HC11);
114 ECase(EM_68HC08);
115 ECase(EM_68HC05);
116 ECase(EM_SVX);
117 ECase(EM_ST19);
118 ECase(EM_VAX);
119 ECase(EM_CRIS);
120 ECase(EM_JAVELIN);
121 ECase(EM_FIREPATH);
122 ECase(EM_ZSP);
123 ECase(EM_MMIX);
124 ECase(EM_HUANY);
125 ECase(EM_PRISM);
126 ECase(EM_AVR);
127 ECase(EM_FR30);
128 ECase(EM_D10V);
129 ECase(EM_D30V);
130 ECase(EM_V850);
131 ECase(EM_M32R);
132 ECase(EM_MN10300);
133 ECase(EM_MN10200);
134 ECase(EM_PJ);
135 ECase(EM_OPENRISC);
136 ECase(EM_ARC_COMPACT);
137 ECase(EM_XTENSA);
138 ECase(EM_VIDEOCORE);
139 ECase(EM_TMM_GPP);
140 ECase(EM_NS32K);
141 ECase(EM_TPC);
142 ECase(EM_SNP1K);
143 ECase(EM_ST200);
144 ECase(EM_IP2K);
145 ECase(EM_MAX);
146 ECase(EM_CR);
147 ECase(EM_F2MC16);
148 ECase(EM_MSP430);
149 ECase(EM_BLACKFIN);
150 ECase(EM_SE_C33);
151 ECase(EM_SEP);
152 ECase(EM_ARCA);
153 ECase(EM_UNICORE);
154 ECase(EM_EXCESS);
155 ECase(EM_DXP);
156 ECase(EM_ALTERA_NIOS2);
157 ECase(EM_CRX);
158 ECase(EM_XGATE);
159 ECase(EM_C166);
160 ECase(EM_M16C);
161 ECase(EM_DSPIC30F);
162 ECase(EM_CE);
163 ECase(EM_M32C);
164 ECase(EM_TSK3000);
165 ECase(EM_RS08);
166 ECase(EM_SHARC);
167 ECase(EM_ECOG2);
168 ECase(EM_SCORE7);
169 ECase(EM_DSP24);
170 ECase(EM_VIDEOCORE3);
171 ECase(EM_LATTICEMICO32);
172 ECase(EM_SE_C17);
173 ECase(EM_TI_C6000);
174 ECase(EM_TI_C2000);
175 ECase(EM_TI_C5500);
176 ECase(EM_MMDSP_PLUS);
177 ECase(EM_CYPRESS_M8C);
178 ECase(EM_R32C);
179 ECase(EM_TRIMEDIA);
180 ECase(EM_HEXAGON);
181 ECase(EM_8051);
182 ECase(EM_STXP7X);
183 ECase(EM_NDS32);
184 ECase(EM_ECOG1);
185 ECase(EM_ECOG1X);
186 ECase(EM_MAXQ30);
187 ECase(EM_XIMO16);
188 ECase(EM_MANIK);
189 ECase(EM_CRAYNV2);
190 ECase(EM_RX);
191 ECase(EM_METAG);
192 ECase(EM_MCST_ELBRUS);
193 ECase(EM_ECOG16);
194 ECase(EM_CR16);
195 ECase(EM_ETPU);
196 ECase(EM_SLE9X);
197 ECase(EM_L10M);
198 ECase(EM_K10M);
199 ECase(EM_AARCH64);
200 ECase(EM_AVR32);
201 ECase(EM_STM8);
202 ECase(EM_TILE64);
203 ECase(EM_TILEPRO);
204 ECase(EM_CUDA);
205 ECase(EM_TILEGX);
206 ECase(EM_CLOUDSHIELD);
207 ECase(EM_COREA_1ST);
208 ECase(EM_COREA_2ND);
209 ECase(EM_ARC_COMPACT2);
210 ECase(EM_OPEN8);
211 ECase(EM_RL78);
212 ECase(EM_VIDEOCORE5);
213 ECase(EM_78KOR);
214 ECase(EM_56800EX);
215 ECase(EM_AMDGPU);
216 ECase(EM_RISCV);
217 ECase(EM_LANAI);
218 ECase(EM_BPF);
219#undef ECase
220}
221
222void ScalarEnumerationTraits<ELFYAML::ELF_ELFCLASS>::enumeration(
223 IO &IO, ELFYAML::ELF_ELFCLASS &Value) {
224#define ECase(X) IO.enumCase(Value, #X, ELF::X)
225 // Since the semantics of ELFCLASSNONE is "invalid", just don't accept it
226 // here.
227 ECase(ELFCLASS32);
228 ECase(ELFCLASS64);
229#undef ECase
230}
231
232void ScalarEnumerationTraits<ELFYAML::ELF_ELFDATA>::enumeration(
233 IO &IO, ELFYAML::ELF_ELFDATA &Value) {
234#define ECase(X) IO.enumCase(Value, #X, ELF::X)
235 // ELFDATANONE is an invalid data encoding, but we accept it because
236 // we want to be able to produce invalid binaries for the tests.
237 ECase(ELFDATANONE);
238 ECase(ELFDATA2LSB);
239 ECase(ELFDATA2MSB);
240#undef ECase
241}
242
243void ScalarEnumerationTraits<ELFYAML::ELF_ELFOSABI>::enumeration(
244 IO &IO, ELFYAML::ELF_ELFOSABI &Value) {
245#define ECase(X) IO.enumCase(Value, #X, ELF::X)
246 ECase(ELFOSABI_NONE);
247 ECase(ELFOSABI_HPUX);
248 ECase(ELFOSABI_NETBSD);
249 ECase(ELFOSABI_GNU);
250 ECase(ELFOSABI_HURD);
251 ECase(ELFOSABI_SOLARIS);
252 ECase(ELFOSABI_AIX);
253 ECase(ELFOSABI_IRIX);
254 ECase(ELFOSABI_FREEBSD);
255 ECase(ELFOSABI_TRU64);
256 ECase(ELFOSABI_MODESTO);
257 ECase(ELFOSABI_OPENBSD);
258 ECase(ELFOSABI_OPENVMS);
259 ECase(ELFOSABI_NSK);
260 ECase(ELFOSABI_AROS);
261 ECase(ELFOSABI_FENIXOS);
262 ECase(ELFOSABI_CLOUDABI);
263 ECase(ELFOSABI_AMDGPU_HSA);
264 ECase(ELFOSABI_AMDGPU_PAL);
265 ECase(ELFOSABI_AMDGPU_MESA3D);
266 ECase(ELFOSABI_ARM);
267 ECase(ELFOSABI_C6000_ELFABI);
268 ECase(ELFOSABI_C6000_LINUX);
269 ECase(ELFOSABI_STANDALONE);
270#undef ECase
271}
272
273void ScalarBitSetTraits<ELFYAML::ELF_EF>::bitset(IO &IO,
274 ELFYAML::ELF_EF &Value) {
275 const auto *Object = static_cast<ELFYAML::Object *>(IO.getContext());
276 assert(Object && "The IO context is not initialized")((Object && "The IO context is not initialized") ? static_cast
<void> (0) : __assert_fail ("Object && \"The IO context is not initialized\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/ObjectYAML/ELFYAML.cpp"
, 276, __PRETTY_FUNCTION__))
;
277#define BCase(X) IO.bitSetCase(Value, #X, ELF::X)
278#define BCaseMask(X, M) IO.maskedBitSetCase(Value, #X, ELF::X, ELF::M)
279 switch (Object->Header.Machine) {
280 case ELF::EM_ARM:
281 BCase(EF_ARM_SOFT_FLOAT);
282 BCase(EF_ARM_VFP_FLOAT);
283 BCaseMask(EF_ARM_EABI_UNKNOWN, EF_ARM_EABIMASK);
284 BCaseMask(EF_ARM_EABI_VER1, EF_ARM_EABIMASK);
285 BCaseMask(EF_ARM_EABI_VER2, EF_ARM_EABIMASK);
286 BCaseMask(EF_ARM_EABI_VER3, EF_ARM_EABIMASK);
287 BCaseMask(EF_ARM_EABI_VER4, EF_ARM_EABIMASK);
288 BCaseMask(EF_ARM_EABI_VER5, EF_ARM_EABIMASK);
289 break;
290 case ELF::EM_MIPS:
291 BCase(EF_MIPS_NOREORDER);
292 BCase(EF_MIPS_PIC);
293 BCase(EF_MIPS_CPIC);
294 BCase(EF_MIPS_ABI2);
295 BCase(EF_MIPS_32BITMODE);
296 BCase(EF_MIPS_FP64);
297 BCase(EF_MIPS_NAN2008);
298 BCase(EF_MIPS_MICROMIPS);
299 BCase(EF_MIPS_ARCH_ASE_M16);
300 BCase(EF_MIPS_ARCH_ASE_MDMX);
301 BCaseMask(EF_MIPS_ABI_O32, EF_MIPS_ABI);
302 BCaseMask(EF_MIPS_ABI_O64, EF_MIPS_ABI);
303 BCaseMask(EF_MIPS_ABI_EABI32, EF_MIPS_ABI);
304 BCaseMask(EF_MIPS_ABI_EABI64, EF_MIPS_ABI);
305 BCaseMask(EF_MIPS_MACH_3900, EF_MIPS_MACH);
306 BCaseMask(EF_MIPS_MACH_4010, EF_MIPS_MACH);
307 BCaseMask(EF_MIPS_MACH_4100, EF_MIPS_MACH);
308 BCaseMask(EF_MIPS_MACH_4650, EF_MIPS_MACH);
309 BCaseMask(EF_MIPS_MACH_4120, EF_MIPS_MACH);
310 BCaseMask(EF_MIPS_MACH_4111, EF_MIPS_MACH);
311 BCaseMask(EF_MIPS_MACH_SB1, EF_MIPS_MACH);
312 BCaseMask(EF_MIPS_MACH_OCTEON, EF_MIPS_MACH);
313 BCaseMask(EF_MIPS_MACH_XLR, EF_MIPS_MACH);
314 BCaseMask(EF_MIPS_MACH_OCTEON2, EF_MIPS_MACH);
315 BCaseMask(EF_MIPS_MACH_OCTEON3, EF_MIPS_MACH);
316 BCaseMask(EF_MIPS_MACH_5400, EF_MIPS_MACH);
317 BCaseMask(EF_MIPS_MACH_5900, EF_MIPS_MACH);
318 BCaseMask(EF_MIPS_MACH_5500, EF_MIPS_MACH);
319 BCaseMask(EF_MIPS_MACH_9000, EF_MIPS_MACH);
320 BCaseMask(EF_MIPS_MACH_LS2E, EF_MIPS_MACH);
321 BCaseMask(EF_MIPS_MACH_LS2F, EF_MIPS_MACH);
322 BCaseMask(EF_MIPS_MACH_LS3A, EF_MIPS_MACH);
323 BCaseMask(EF_MIPS_ARCH_1, EF_MIPS_ARCH);
324 BCaseMask(EF_MIPS_ARCH_2, EF_MIPS_ARCH);
325 BCaseMask(EF_MIPS_ARCH_3, EF_MIPS_ARCH);
326 BCaseMask(EF_MIPS_ARCH_4, EF_MIPS_ARCH);
327 BCaseMask(EF_MIPS_ARCH_5, EF_MIPS_ARCH);
328 BCaseMask(EF_MIPS_ARCH_32, EF_MIPS_ARCH);
329 BCaseMask(EF_MIPS_ARCH_64, EF_MIPS_ARCH);
330 BCaseMask(EF_MIPS_ARCH_32R2, EF_MIPS_ARCH);
331 BCaseMask(EF_MIPS_ARCH_64R2, EF_MIPS_ARCH);
332 BCaseMask(EF_MIPS_ARCH_32R6, EF_MIPS_ARCH);
333 BCaseMask(EF_MIPS_ARCH_64R6, EF_MIPS_ARCH);
334 break;
335 case ELF::EM_HEXAGON:
336 BCase(EF_HEXAGON_MACH_V2);
337 BCase(EF_HEXAGON_MACH_V3);
338 BCase(EF_HEXAGON_MACH_V4);
339 BCase(EF_HEXAGON_MACH_V5);
340 BCase(EF_HEXAGON_MACH_V55);
341 BCase(EF_HEXAGON_MACH_V60);
342 BCase(EF_HEXAGON_MACH_V62);
343 BCase(EF_HEXAGON_MACH_V65);
344 BCase(EF_HEXAGON_ISA_V2);
345 BCase(EF_HEXAGON_ISA_V3);
346 BCase(EF_HEXAGON_ISA_V4);
347 BCase(EF_HEXAGON_ISA_V5);
348 BCase(EF_HEXAGON_ISA_V55);
349 BCase(EF_HEXAGON_ISA_V60);
350 BCase(EF_HEXAGON_ISA_V62);
351 BCase(EF_HEXAGON_ISA_V65);
352 break;
353 case ELF::EM_AVR:
354 BCase(EF_AVR_ARCH_AVR1);
355 BCase(EF_AVR_ARCH_AVR2);
356 BCase(EF_AVR_ARCH_AVR25);
357 BCase(EF_AVR_ARCH_AVR3);
358 BCase(EF_AVR_ARCH_AVR31);
359 BCase(EF_AVR_ARCH_AVR35);
360 BCase(EF_AVR_ARCH_AVR4);
361 BCase(EF_AVR_ARCH_AVR51);
362 BCase(EF_AVR_ARCH_AVR6);
363 BCase(EF_AVR_ARCH_AVRTINY);
364 BCase(EF_AVR_ARCH_XMEGA1);
365 BCase(EF_AVR_ARCH_XMEGA2);
366 BCase(EF_AVR_ARCH_XMEGA3);
367 BCase(EF_AVR_ARCH_XMEGA4);
368 BCase(EF_AVR_ARCH_XMEGA5);
369 BCase(EF_AVR_ARCH_XMEGA6);
370 BCase(EF_AVR_ARCH_XMEGA7);
371 break;
372 case ELF::EM_RISCV:
373 BCase(EF_RISCV_RVC);
374 BCaseMask(EF_RISCV_FLOAT_ABI_SOFT, EF_RISCV_FLOAT_ABI);
375 BCaseMask(EF_RISCV_FLOAT_ABI_SINGLE, EF_RISCV_FLOAT_ABI);
376 BCaseMask(EF_RISCV_FLOAT_ABI_DOUBLE, EF_RISCV_FLOAT_ABI);
377 BCaseMask(EF_RISCV_FLOAT_ABI_QUAD, EF_RISCV_FLOAT_ABI);
378 BCase(EF_RISCV_RVE);
379 break;
380 case ELF::EM_AMDGPU:
381 BCaseMask(EF_AMDGPU_MACH_NONE, EF_AMDGPU_MACH);
382 BCaseMask(EF_AMDGPU_MACH_R600_R600, EF_AMDGPU_MACH);
383 BCaseMask(EF_AMDGPU_MACH_R600_R630, EF_AMDGPU_MACH);
384 BCaseMask(EF_AMDGPU_MACH_R600_RS880, EF_AMDGPU_MACH);
385 BCaseMask(EF_AMDGPU_MACH_R600_RV670, EF_AMDGPU_MACH);
386 BCaseMask(EF_AMDGPU_MACH_R600_RV710, EF_AMDGPU_MACH);
387 BCaseMask(EF_AMDGPU_MACH_R600_RV730, EF_AMDGPU_MACH);
388 BCaseMask(EF_AMDGPU_MACH_R600_RV770, EF_AMDGPU_MACH);
389 BCaseMask(EF_AMDGPU_MACH_R600_CEDAR, EF_AMDGPU_MACH);
390 BCaseMask(EF_AMDGPU_MACH_R600_CYPRESS, EF_AMDGPU_MACH);
391 BCaseMask(EF_AMDGPU_MACH_R600_JUNIPER, EF_AMDGPU_MACH);
392 BCaseMask(EF_AMDGPU_MACH_R600_REDWOOD, EF_AMDGPU_MACH);
393 BCaseMask(EF_AMDGPU_MACH_R600_SUMO, EF_AMDGPU_MACH);
394 BCaseMask(EF_AMDGPU_MACH_R600_BARTS, EF_AMDGPU_MACH);
395 BCaseMask(EF_AMDGPU_MACH_R600_CAICOS, EF_AMDGPU_MACH);
396 BCaseMask(EF_AMDGPU_MACH_R600_CAYMAN, EF_AMDGPU_MACH);
397 BCaseMask(EF_AMDGPU_MACH_R600_TURKS, EF_AMDGPU_MACH);
398 BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX600, EF_AMDGPU_MACH);
399 BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX601, EF_AMDGPU_MACH);
400 BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX700, EF_AMDGPU_MACH);
401 BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX701, EF_AMDGPU_MACH);
402 BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX702, EF_AMDGPU_MACH);
403 BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX703, EF_AMDGPU_MACH);
404 BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX704, EF_AMDGPU_MACH);
405 BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX801, EF_AMDGPU_MACH);
406 BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX802, EF_AMDGPU_MACH);
407 BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX803, EF_AMDGPU_MACH);
408 BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX810, EF_AMDGPU_MACH);
409 BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX900, EF_AMDGPU_MACH);
410 BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX902, EF_AMDGPU_MACH);
411 BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX904, EF_AMDGPU_MACH);
412 BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX906, EF_AMDGPU_MACH);
413 BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX909, EF_AMDGPU_MACH);
414 BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX1010, EF_AMDGPU_MACH);
415 BCase(EF_AMDGPU_XNACK);
416 BCase(EF_AMDGPU_SRAM_ECC);
417 break;
418 case ELF::EM_X86_64:
419 break;
420 default:
421 llvm_unreachable("Unsupported architecture")::llvm::llvm_unreachable_internal("Unsupported architecture",
"/build/llvm-toolchain-snapshot-9~svn362543/lib/ObjectYAML/ELFYAML.cpp"
, 421)
;
422 }
423#undef BCase
424#undef BCaseMask
425}
426
427void ScalarEnumerationTraits<ELFYAML::ELF_SHT>::enumeration(
428 IO &IO, ELFYAML::ELF_SHT &Value) {
429 const auto *Object = static_cast<ELFYAML::Object *>(IO.getContext());
430 assert(Object && "The IO context is not initialized")((Object && "The IO context is not initialized") ? static_cast
<void> (0) : __assert_fail ("Object && \"The IO context is not initialized\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/ObjectYAML/ELFYAML.cpp"
, 430, __PRETTY_FUNCTION__))
;
12
Assuming 'Object' is non-null
13
'?' condition is true
431#define ECase(X) IO.enumCase(Value, #X, ELF::X)
432 ECase(SHT_NULL);
14
Calling 'IO::enumCase'
19
Returning from 'IO::enumCase'
433 ECase(SHT_PROGBITS);
20
Calling 'IO::enumCase'
25
Returning from 'IO::enumCase'
434 ECase(SHT_SYMTAB);
26
Calling 'IO::enumCase'
31
Returning from 'IO::enumCase'
435 // FIXME: Issue a diagnostic with this information.
436 ECase(SHT_STRTAB);
32
Calling 'IO::enumCase'
37
Returning from 'IO::enumCase'
437 ECase(SHT_RELA);
38
Calling 'IO::enumCase'
43
Returning from 'IO::enumCase'
438 ECase(SHT_HASH);
44
Calling 'IO::enumCase'
49
Returning from 'IO::enumCase'
439 ECase(SHT_DYNAMIC);
50
Calling 'IO::enumCase'
55
Returning from 'IO::enumCase'
440 ECase(SHT_NOTE);
56
Calling 'IO::enumCase'
61
Returning from 'IO::enumCase'
441 ECase(SHT_NOBITS);
62
Calling 'IO::enumCase'
67
Returning from 'IO::enumCase'
442 ECase(SHT_REL);
68
Calling 'IO::enumCase'
73
Returning from 'IO::enumCase'
443 ECase(SHT_SHLIB);
74
Calling 'IO::enumCase'
79
Returning from 'IO::enumCase'
444 ECase(SHT_DYNSYM);
80
Calling 'IO::enumCase'
85
Returning from 'IO::enumCase'
445 ECase(SHT_INIT_ARRAY);
86
Calling 'IO::enumCase'
91
Returning from 'IO::enumCase'
446 ECase(SHT_FINI_ARRAY);
92
Calling 'IO::enumCase'
97
Returning from 'IO::enumCase'
447 ECase(SHT_PREINIT_ARRAY);
98
Calling 'IO::enumCase'
103
Returning from 'IO::enumCase'
448 ECase(SHT_GROUP);
104
Calling 'IO::enumCase'
109
Returning from 'IO::enumCase'
449 ECase(SHT_SYMTAB_SHNDX);
110
Calling 'IO::enumCase'
115
Returning from 'IO::enumCase'
450 ECase(SHT_RELR);
116
Calling 'IO::enumCase'
121
Returning from 'IO::enumCase'
451 ECase(SHT_ANDROID_REL);
122
Calling 'IO::enumCase'
127
Returning from 'IO::enumCase'
452 ECase(SHT_ANDROID_RELA);
128
Calling 'IO::enumCase'
133
Returning from 'IO::enumCase'
453 ECase(SHT_ANDROID_RELR);
134
Calling 'IO::enumCase'
139
Returning from 'IO::enumCase'
454 ECase(SHT_LLVM_ODRTAB);
140
Calling 'IO::enumCase'
145
Returning from 'IO::enumCase'
455 ECase(SHT_LLVM_LINKER_OPTIONS);
146
Calling 'IO::enumCase'
151
Returning from 'IO::enumCase'
456 ECase(SHT_LLVM_CALL_GRAPH_PROFILE);
152
Calling 'IO::enumCase'
157
Returning from 'IO::enumCase'
457 ECase(SHT_LLVM_ADDRSIG);
158
Calling 'IO::enumCase'
163
Returning from 'IO::enumCase'
458 ECase(SHT_LLVM_DEPENDENT_LIBRARIES);
164
Calling 'IO::enumCase'
169
Returning from 'IO::enumCase'
459 ECase(SHT_GNU_ATTRIBUTES);
170
Calling 'IO::enumCase'
175
Returning from 'IO::enumCase'
460 ECase(SHT_GNU_HASH);
176
Calling 'IO::enumCase'
181
Returning from 'IO::enumCase'
461 ECase(SHT_GNU_verdef);
182
Calling 'IO::enumCase'
187
Returning from 'IO::enumCase'
462 ECase(SHT_GNU_verneed);
188
Calling 'IO::enumCase'
193
Returning from 'IO::enumCase'
463 ECase(SHT_GNU_versym);
194
Calling 'IO::enumCase'
199
Returning from 'IO::enumCase'
464 switch (Object->Header.Machine) {
200
Control jumps to the 'default' case at line 484
465 case ELF::EM_ARM:
466 ECase(SHT_ARM_EXIDX);
467 ECase(SHT_ARM_PREEMPTMAP);
468 ECase(SHT_ARM_ATTRIBUTES);
469 ECase(SHT_ARM_DEBUGOVERLAY);
470 ECase(SHT_ARM_OVERLAYSECTION);
471 break;
472 case ELF::EM_HEXAGON:
473 ECase(SHT_HEX_ORDERED);
474 break;
475 case ELF::EM_X86_64:
476 ECase(SHT_X86_64_UNWIND);
477 break;
478 case ELF::EM_MIPS:
479 ECase(SHT_MIPS_REGINFO);
480 ECase(SHT_MIPS_OPTIONS);
481 ECase(SHT_MIPS_DWARF);
482 ECase(SHT_MIPS_ABIFLAGS);
483 break;
484 default:
485 // Nothing to do.
486 break;
201
Execution continues on line 489
487 }
488#undef ECase
489 IO.enumFallback<Hex32>(Value);
202
Calling 'IO::enumFallback'
490}
491
492void ScalarBitSetTraits<ELFYAML::ELF_PF>::bitset(IO &IO,
493 ELFYAML::ELF_PF &Value) {
494#define BCase(X) IO.bitSetCase(Value, #X, ELF::X)
495 BCase(PF_X);
496 BCase(PF_W);
497 BCase(PF_R);
498}
499
500void ScalarBitSetTraits<ELFYAML::ELF_SHF>::bitset(IO &IO,
501 ELFYAML::ELF_SHF &Value) {
502 const auto *Object = static_cast<ELFYAML::Object *>(IO.getContext());
503#define BCase(X) IO.bitSetCase(Value, #X, ELF::X)
504 BCase(SHF_WRITE);
505 BCase(SHF_ALLOC);
506 BCase(SHF_EXCLUDE);
507 BCase(SHF_EXECINSTR);
508 BCase(SHF_MERGE);
509 BCase(SHF_STRINGS);
510 BCase(SHF_INFO_LINK);
511 BCase(SHF_LINK_ORDER);
512 BCase(SHF_OS_NONCONFORMING);
513 BCase(SHF_GROUP);
514 BCase(SHF_TLS);
515 BCase(SHF_COMPRESSED);
516 switch (Object->Header.Machine) {
517 case ELF::EM_ARM:
518 BCase(SHF_ARM_PURECODE);
519 break;
520 case ELF::EM_HEXAGON:
521 BCase(SHF_HEX_GPREL);
522 break;
523 case ELF::EM_MIPS:
524 BCase(SHF_MIPS_NODUPES);
525 BCase(SHF_MIPS_NAMES);
526 BCase(SHF_MIPS_LOCAL);
527 BCase(SHF_MIPS_NOSTRIP);
528 BCase(SHF_MIPS_GPREL);
529 BCase(SHF_MIPS_MERGE);
530 BCase(SHF_MIPS_ADDR);
531 BCase(SHF_MIPS_STRING);
532 break;
533 case ELF::EM_X86_64:
534 BCase(SHF_X86_64_LARGE);
535 break;
536 default:
537 // Nothing to do.
538 break;
539 }
540#undef BCase
541}
542
543void ScalarEnumerationTraits<ELFYAML::ELF_SHN>::enumeration(
544 IO &IO, ELFYAML::ELF_SHN &Value) {
545#define ECase(X) IO.enumCase(Value, #X, ELF::X)
546 ECase(SHN_UNDEF);
547 ECase(SHN_LORESERVE);
548 ECase(SHN_LOPROC);
549 ECase(SHN_HIPROC);
550 ECase(SHN_LOOS);
551 ECase(SHN_HIOS);
552 ECase(SHN_ABS);
553 ECase(SHN_COMMON);
554 ECase(SHN_XINDEX);
555 ECase(SHN_HIRESERVE);
556 ECase(SHN_HEXAGON_SCOMMON);
557 ECase(SHN_HEXAGON_SCOMMON_1);
558 ECase(SHN_HEXAGON_SCOMMON_2);
559 ECase(SHN_HEXAGON_SCOMMON_4);
560 ECase(SHN_HEXAGON_SCOMMON_8);
561#undef ECase
562 IO.enumFallback<Hex32>(Value);
563}
564
565void ScalarEnumerationTraits<ELFYAML::ELF_STB>::enumeration(
566 IO &IO, ELFYAML::ELF_STB &Value) {
567#define ECase(X) IO.enumCase(Value, #X, ELF::X)
568 ECase(STB_LOCAL);
569 ECase(STB_GLOBAL);
570 ECase(STB_WEAK);
571 ECase(STB_GNU_UNIQUE);
572#undef ECase
573 IO.enumFallback<Hex8>(Value);
574}
575
576void ScalarEnumerationTraits<ELFYAML::ELF_STT>::enumeration(
577 IO &IO, ELFYAML::ELF_STT &Value) {
578#define ECase(X) IO.enumCase(Value, #X, ELF::X)
579 ECase(STT_NOTYPE);
580 ECase(STT_OBJECT);
581 ECase(STT_FUNC);
582 ECase(STT_SECTION);
583 ECase(STT_FILE);
584 ECase(STT_COMMON);
585 ECase(STT_TLS);
586 ECase(STT_GNU_IFUNC);
587#undef ECase
588 IO.enumFallback<Hex8>(Value);
589}
590
591void ScalarEnumerationTraits<ELFYAML::ELF_STV>::enumeration(
592 IO &IO, ELFYAML::ELF_STV &Value) {
593#define ECase(X) IO.enumCase(Value, #X, ELF::X)
594 ECase(STV_DEFAULT);
595 ECase(STV_INTERNAL);
596 ECase(STV_HIDDEN);
597 ECase(STV_PROTECTED);
598#undef ECase
599}
600
601void ScalarBitSetTraits<ELFYAML::ELF_STO>::bitset(IO &IO,
602 ELFYAML::ELF_STO &Value) {
603 const auto *Object = static_cast<ELFYAML::Object *>(IO.getContext());
604 assert(Object && "The IO context is not initialized")((Object && "The IO context is not initialized") ? static_cast
<void> (0) : __assert_fail ("Object && \"The IO context is not initialized\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/ObjectYAML/ELFYAML.cpp"
, 604, __PRETTY_FUNCTION__))
;
605#define BCase(X) IO.bitSetCase(Value, #X, ELF::X)
606 switch (Object->Header.Machine) {
607 case ELF::EM_MIPS:
608 BCase(STO_MIPS_OPTIONAL);
609 BCase(STO_MIPS_PLT);
610 BCase(STO_MIPS_PIC);
611 BCase(STO_MIPS_MICROMIPS);
612 break;
613 default:
614 break; // Nothing to do
615 }
616#undef BCase
617#undef BCaseMask
618}
619
620void ScalarEnumerationTraits<ELFYAML::ELF_RSS>::enumeration(
621 IO &IO, ELFYAML::ELF_RSS &Value) {
622#define ECase(X) IO.enumCase(Value, #X, ELF::X)
623 ECase(RSS_UNDEF);
624 ECase(RSS_GP);
625 ECase(RSS_GP0);
626 ECase(RSS_LOC);
627#undef ECase
628}
629
630void ScalarEnumerationTraits<ELFYAML::ELF_REL>::enumeration(
631 IO &IO, ELFYAML::ELF_REL &Value) {
632 const auto *Object = static_cast<ELFYAML::Object *>(IO.getContext());
633 assert(Object && "The IO context is not initialized")((Object && "The IO context is not initialized") ? static_cast
<void> (0) : __assert_fail ("Object && \"The IO context is not initialized\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/ObjectYAML/ELFYAML.cpp"
, 633, __PRETTY_FUNCTION__))
;
634#define ELF_RELOC(X, Y) IO.enumCase(Value, #X, ELF::X);
635 switch (Object->Header.Machine) {
636 case ELF::EM_X86_64:
637#include "llvm/BinaryFormat/ELFRelocs/x86_64.def"
638 break;
639 case ELF::EM_MIPS:
640#include "llvm/BinaryFormat/ELFRelocs/Mips.def"
641 break;
642 case ELF::EM_HEXAGON:
643#include "llvm/BinaryFormat/ELFRelocs/Hexagon.def"
644 break;
645 case ELF::EM_386:
646 case ELF::EM_IAMCU:
647#include "llvm/BinaryFormat/ELFRelocs/i386.def"
648 break;
649 case ELF::EM_AARCH64:
650#include "llvm/BinaryFormat/ELFRelocs/AArch64.def"
651 break;
652 case ELF::EM_ARM:
653#include "llvm/BinaryFormat/ELFRelocs/ARM.def"
654 break;
655 case ELF::EM_ARC:
656#include "llvm/BinaryFormat/ELFRelocs/ARC.def"
657 break;
658 case ELF::EM_RISCV:
659#include "llvm/BinaryFormat/ELFRelocs/RISCV.def"
660 break;
661 case ELF::EM_LANAI:
662#include "llvm/BinaryFormat/ELFRelocs/Lanai.def"
663 break;
664 case ELF::EM_AMDGPU:
665#include "llvm/BinaryFormat/ELFRelocs/AMDGPU.def"
666 break;
667 case ELF::EM_BPF:
668#include "llvm/BinaryFormat/ELFRelocs/BPF.def"
669 break;
670 default:
671 llvm_unreachable("Unsupported architecture")::llvm::llvm_unreachable_internal("Unsupported architecture",
"/build/llvm-toolchain-snapshot-9~svn362543/lib/ObjectYAML/ELFYAML.cpp"
, 671)
;
672 }
673#undef ELF_RELOC
674 IO.enumFallback<Hex32>(Value);
675}
676
677void ScalarEnumerationTraits<ELFYAML::ELF_DYNTAG>::enumeration(
678 IO &IO, ELFYAML::ELF_DYNTAG &Value) {
679 const auto *Object = static_cast<ELFYAML::Object *>(IO.getContext());
680 assert(Object && "The IO context is not initialized")((Object && "The IO context is not initialized") ? static_cast
<void> (0) : __assert_fail ("Object && \"The IO context is not initialized\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/ObjectYAML/ELFYAML.cpp"
, 680, __PRETTY_FUNCTION__))
;
681
682// Disable architecture specific tags by default. We might enable them below.
683#define AARCH64_DYNAMIC_TAG(name, value)
684#define MIPS_DYNAMIC_TAG(name, value)
685#define HEXAGON_DYNAMIC_TAG(name, value)
686#define PPC64_DYNAMIC_TAG(name, value)
687// Ignore marker tags such as DT_HIOS (maps to DT_VERNEEDNUM), etc.
688#define DYNAMIC_TAG_MARKER(name, value)
689
690#define STRINGIFY(X) (#X)
691#define DYNAMIC_TAG(X, Y) IO.enumCase(Value, STRINGIFY(DT_##X), ELF::DT_##X);
692 switch (Object->Header.Machine) {
693 case ELF::EM_AARCH64:
694#undef AARCH64_DYNAMIC_TAG
695#define AARCH64_DYNAMIC_TAG(name, value) DYNAMIC_TAG(name, value)
696#include "llvm/BinaryFormat/DynamicTags.def"
697#undef AARCH64_DYNAMIC_TAG
698#define AARCH64_DYNAMIC_TAG(name, value)
699 break;
700 case ELF::EM_MIPS:
701#undef MIPS_DYNAMIC_TAG
702#define MIPS_DYNAMIC_TAG(name, value) DYNAMIC_TAG(name, value)
703#include "llvm/BinaryFormat/DynamicTags.def"
704#undef MIPS_DYNAMIC_TAG
705#define MIPS_DYNAMIC_TAG(name, value)
706 break;
707 case ELF::EM_HEXAGON:
708#undef HEXAGON_DYNAMIC_TAG
709#define HEXAGON_DYNAMIC_TAG(name, value) DYNAMIC_TAG(name, value)
710#include "llvm/BinaryFormat/DynamicTags.def"
711#undef HEXAGON_DYNAMIC_TAG
712#define HEXAGON_DYNAMIC_TAG(name, value)
713 break;
714 case ELF::EM_PPC64:
715#undef PPC64_DYNAMIC_TAG
716#define PPC64_DYNAMIC_TAG(name, value) DYNAMIC_TAG(name, value)
717#include "llvm/BinaryFormat/DynamicTags.def"
718#undef PPC64_DYNAMIC_TAG
719#define PPC64_DYNAMIC_TAG(name, value)
720 break;
721 default:
722#include "llvm/BinaryFormat/DynamicTags.def"
723 break;
724 }
725#undef AARCH64_DYNAMIC_TAG
726#undef MIPS_DYNAMIC_TAG
727#undef HEXAGON_DYNAMIC_TAG
728#undef PPC64_DYNAMIC_TAG
729#undef DYNAMIC_TAG_MARKER
730#undef STRINGIFY
731#undef DYNAMIC_TAG
732
733 IO.enumFallback<Hex64>(Value);
734}
735
736void ScalarEnumerationTraits<ELFYAML::MIPS_AFL_REG>::enumeration(
737 IO &IO, ELFYAML::MIPS_AFL_REG &Value) {
738#define ECase(X) IO.enumCase(Value, #X, Mips::AFL_##X)
739 ECase(REG_NONE);
740 ECase(REG_32);
741 ECase(REG_64);
742 ECase(REG_128);
743#undef ECase
744}
745
746void ScalarEnumerationTraits<ELFYAML::MIPS_ABI_FP>::enumeration(
747 IO &IO, ELFYAML::MIPS_ABI_FP &Value) {
748#define ECase(X) IO.enumCase(Value, #X, Mips::Val_GNU_MIPS_ABI_##X)
749 ECase(FP_ANY);
750 ECase(FP_DOUBLE);
751 ECase(FP_SINGLE);
752 ECase(FP_SOFT);
753 ECase(FP_OLD_64);
754 ECase(FP_XX);
755 ECase(FP_64);
756 ECase(FP_64A);
757#undef ECase
758}
759
760void ScalarEnumerationTraits<ELFYAML::MIPS_AFL_EXT>::enumeration(
761 IO &IO, ELFYAML::MIPS_AFL_EXT &Value) {
762#define ECase(X) IO.enumCase(Value, #X, Mips::AFL_##X)
763 ECase(EXT_NONE);
764 ECase(EXT_XLR);
765 ECase(EXT_OCTEON2);
766 ECase(EXT_OCTEONP);
767 ECase(EXT_LOONGSON_3A);
768 ECase(EXT_OCTEON);
769 ECase(EXT_5900);
770 ECase(EXT_4650);
771 ECase(EXT_4010);
772 ECase(EXT_4100);
773 ECase(EXT_3900);
774 ECase(EXT_10000);
775 ECase(EXT_SB1);
776 ECase(EXT_4111);
777 ECase(EXT_4120);
778 ECase(EXT_5400);
779 ECase(EXT_5500);
780 ECase(EXT_LOONGSON_2E);
781 ECase(EXT_LOONGSON_2F);
782 ECase(EXT_OCTEON3);
783#undef ECase
784}
785
786void ScalarEnumerationTraits<ELFYAML::MIPS_ISA>::enumeration(
787 IO &IO, ELFYAML::MIPS_ISA &Value) {
788 IO.enumCase(Value, "MIPS1", 1);
789 IO.enumCase(Value, "MIPS2", 2);
790 IO.enumCase(Value, "MIPS3", 3);
791 IO.enumCase(Value, "MIPS4", 4);
792 IO.enumCase(Value, "MIPS5", 5);
793 IO.enumCase(Value, "MIPS32", 32);
794 IO.enumCase(Value, "MIPS64", 64);
795}
796
797void ScalarBitSetTraits<ELFYAML::MIPS_AFL_ASE>::bitset(
798 IO &IO, ELFYAML::MIPS_AFL_ASE &Value) {
799#define BCase(X) IO.bitSetCase(Value, #X, Mips::AFL_ASE_##X)
800 BCase(DSP);
801 BCase(DSPR2);
802 BCase(EVA);
803 BCase(MCU);
804 BCase(MDMX);
805 BCase(MIPS3D);
806 BCase(MT);
807 BCase(SMARTMIPS);
808 BCase(VIRT);
809 BCase(MSA);
810 BCase(MIPS16);
811 BCase(MICROMIPS);
812 BCase(XPA);
813#undef BCase
814}
815
816void ScalarBitSetTraits<ELFYAML::MIPS_AFL_FLAGS1>::bitset(
817 IO &IO, ELFYAML::MIPS_AFL_FLAGS1 &Value) {
818#define BCase(X) IO.bitSetCase(Value, #X, Mips::AFL_FLAGS1_##X)
819 BCase(ODDSPREG);
820#undef BCase
821}
822
823void MappingTraits<ELFYAML::FileHeader>::mapping(IO &IO,
824 ELFYAML::FileHeader &FileHdr) {
825 IO.mapRequired("Class", FileHdr.Class);
826 IO.mapRequired("Data", FileHdr.Data);
827 IO.mapOptional("OSABI", FileHdr.OSABI, ELFYAML::ELF_ELFOSABI(0));
828 IO.mapOptional("ABIVersion", FileHdr.ABIVersion, Hex8(0));
829 IO.mapRequired("Type", FileHdr.Type);
830 IO.mapRequired("Machine", FileHdr.Machine);
831 IO.mapOptional("Flags", FileHdr.Flags, ELFYAML::ELF_EF(0));
832 IO.mapOptional("Entry", FileHdr.Entry, Hex64(0));
833}
834
835void MappingTraits<ELFYAML::ProgramHeader>::mapping(
836 IO &IO, ELFYAML::ProgramHeader &Phdr) {
837 IO.mapRequired("Type", Phdr.Type);
838 IO.mapOptional("Flags", Phdr.Flags, ELFYAML::ELF_PF(0));
839 IO.mapOptional("Sections", Phdr.Sections);
840 IO.mapOptional("VAddr", Phdr.VAddr, Hex64(0));
841 IO.mapOptional("PAddr", Phdr.PAddr, Hex64(0));
842 IO.mapOptional("Align", Phdr.Align);
843 IO.mapOptional("FileSize", Phdr.FileSize);
844 IO.mapOptional("MemSize", Phdr.MemSize);
845 IO.mapOptional("Offset", Phdr.Offset);
846}
847
848namespace {
849
850struct NormalizedOther {
851 NormalizedOther(IO &)
852 : Visibility(ELFYAML::ELF_STV(0)), Other(ELFYAML::ELF_STO(0)) {}
853 NormalizedOther(IO &, uint8_t Original)
854 : Visibility(Original & 0x3), Other(Original & ~0x3) {}
855
856 uint8_t denormalize(IO &) { return Visibility | Other; }
857
858 ELFYAML::ELF_STV Visibility;
859 ELFYAML::ELF_STO Other;
860};
861
862} // end anonymous namespace
863
864void MappingTraits<ELFYAML::Symbol>::mapping(IO &IO, ELFYAML::Symbol &Symbol) {
865 IO.mapOptional("Name", Symbol.Name, StringRef());
866 IO.mapOptional("NameIndex", Symbol.NameIndex);
867 IO.mapOptional("Type", Symbol.Type, ELFYAML::ELF_STT(0));
868 IO.mapOptional("Section", Symbol.Section, StringRef());
869 IO.mapOptional("Index", Symbol.Index);
870 IO.mapOptional("Binding", Symbol.Binding, ELFYAML::ELF_STB(0));
871 IO.mapOptional("Value", Symbol.Value, Hex64(0));
872 IO.mapOptional("Size", Symbol.Size, Hex64(0));
873 MappingNormalization<NormalizedOther, uint8_t> Keys(IO, Symbol.Other);
874 IO.mapOptional("Visibility", Keys->Visibility, ELFYAML::ELF_STV(0));
875 IO.mapOptional("Other", Keys->Other, ELFYAML::ELF_STO(0));
876}
877
878StringRef MappingTraits<ELFYAML::Symbol>::validate(IO &IO,
879 ELFYAML::Symbol &Symbol) {
880 if (Symbol.Index && Symbol.Section.data())
881 return "Index and Section cannot both be specified for Symbol";
882 if (Symbol.Index && *Symbol.Index == ELFYAML::ELF_SHN(ELF::SHN_XINDEX))
883 return "Large indexes are not supported";
884 if (Symbol.NameIndex && !Symbol.Name.empty())
885 return "Name and NameIndex cannot both be specified for Symbol";
886 return StringRef();
887}
888
889static void commonSectionMapping(IO &IO, ELFYAML::Section &Section) {
890 IO.mapOptional("Name", Section.Name, StringRef());
891 IO.mapRequired("Type", Section.Type);
892 IO.mapOptional("Flags", Section.Flags, ELFYAML::ELF_SHF(0));
893 IO.mapOptional("Address", Section.Address, Hex64(0));
894 IO.mapOptional("Link", Section.Link, StringRef());
895 IO.mapOptional("AddressAlign", Section.AddressAlign, Hex64(0));
896 IO.mapOptional("EntSize", Section.EntSize);
897}
898
899static void sectionMapping(IO &IO, ELFYAML::DynamicSection &Section) {
900 commonSectionMapping(IO, Section);
901 IO.mapOptional("Entries", Section.Entries);
902 IO.mapOptional("Content", Section.Content);
903}
904
905static void sectionMapping(IO &IO, ELFYAML::RawContentSection &Section) {
906 commonSectionMapping(IO, Section);
907 IO.mapOptional("Content", Section.Content);
908 IO.mapOptional("Size", Section.Size, Hex64(Section.Content.binary_size()));
909 IO.mapOptional("Info", Section.Info, Hex64(0));
910}
911
912static void sectionMapping(IO &IO, ELFYAML::NoBitsSection &Section) {
913 commonSectionMapping(IO, Section);
914 IO.mapOptional("Size", Section.Size, Hex64(0));
915}
916
917static void sectionMapping(IO &IO, ELFYAML::VerdefSection &Section) {
918 commonSectionMapping(IO, Section);
919 IO.mapRequired("Info", Section.Info);
920 IO.mapRequired("Entries", Section.Entries);
921}
922
923static void sectionMapping(IO &IO, ELFYAML::SymverSection &Section) {
924 commonSectionMapping(IO, Section);
925 IO.mapRequired("Entries", Section.Entries);
926}
927
928static void sectionMapping(IO &IO, ELFYAML::VerneedSection &Section) {
929 commonSectionMapping(IO, Section);
930 IO.mapRequired("Info", Section.Info);
931 IO.mapRequired("Dependencies", Section.VerneedV);
932}
933
934static void sectionMapping(IO &IO, ELFYAML::RelocationSection &Section) {
935 commonSectionMapping(IO, Section);
936 IO.mapOptional("Info", Section.RelocatableSec, StringRef());
937 IO.mapOptional("Relocations", Section.Relocations);
938}
939
940static void groupSectionMapping(IO &IO, ELFYAML::Group &Group) {
941 commonSectionMapping(IO, Group);
942 IO.mapOptional("Info", Group.Signature, StringRef());
943 IO.mapRequired("Members", Group.Members);
944}
945
946void MappingTraits<ELFYAML::SectionOrType>::mapping(
947 IO &IO, ELFYAML::SectionOrType &sectionOrType) {
948 IO.mapRequired("SectionOrType", sectionOrType.sectionNameOrType);
949}
950
951void MappingTraits<ELFYAML::SectionName>::mapping(
952 IO &IO, ELFYAML::SectionName &sectionName) {
953 IO.mapRequired("Section", sectionName.Section);
954}
955
956static void sectionMapping(IO &IO, ELFYAML::MipsABIFlags &Section) {
957 commonSectionMapping(IO, Section);
958 IO.mapOptional("Version", Section.Version, Hex16(0));
959 IO.mapRequired("ISA", Section.ISALevel);
960 IO.mapOptional("ISARevision", Section.ISARevision, Hex8(0));
961 IO.mapOptional("ISAExtension", Section.ISAExtension,
962 ELFYAML::MIPS_AFL_EXT(Mips::AFL_EXT_NONE));
963 IO.mapOptional("ASEs", Section.ASEs, ELFYAML::MIPS_AFL_ASE(0));
964 IO.mapOptional("FpABI", Section.FpABI,
965 ELFYAML::MIPS_ABI_FP(Mips::Val_GNU_MIPS_ABI_FP_ANY));
966 IO.mapOptional("GPRSize", Section.GPRSize,
967 ELFYAML::MIPS_AFL_REG(Mips::AFL_REG_NONE));
968 IO.mapOptional("CPR1Size", Section.CPR1Size,
969 ELFYAML::MIPS_AFL_REG(Mips::AFL_REG_NONE));
970 IO.mapOptional("CPR2Size", Section.CPR2Size,
971 ELFYAML::MIPS_AFL_REG(Mips::AFL_REG_NONE));
972 IO.mapOptional("Flags1", Section.Flags1, ELFYAML::MIPS_AFL_FLAGS1(0));
973 IO.mapOptional("Flags2", Section.Flags2, Hex32(0));
974}
975
976void MappingTraits<std::unique_ptr<ELFYAML::Section>>::mapping(
977 IO &IO, std::unique_ptr<ELFYAML::Section> &Section) {
978 ELFYAML::ELF_SHT sectionType;
1
Calling defaulted default constructor for 'ELF_SHT'
3
Returning from default constructor for 'ELF_SHT'
979 if (IO.outputting())
4
Assuming the condition is false
5
Taking false branch
980 sectionType = Section->Type;
981 else
982 IO.mapRequired("Type", sectionType);
6
Calling 'IO::mapRequired'
983
984 switch (sectionType) {
985 case ELF::SHT_DYNAMIC:
986 if (!IO.outputting())
987 Section.reset(new ELFYAML::DynamicSection());
988 sectionMapping(IO, *cast<ELFYAML::DynamicSection>(Section.get()));
989 break;
990 case ELF::SHT_REL:
991 case ELF::SHT_RELA:
992 if (!IO.outputting())
993 Section.reset(new ELFYAML::RelocationSection());
994 sectionMapping(IO, *cast<ELFYAML::RelocationSection>(Section.get()));
995 break;
996 case ELF::SHT_GROUP:
997 if (!IO.outputting())
998 Section.reset(new ELFYAML::Group());
999 groupSectionMapping(IO, *cast<ELFYAML::Group>(Section.get()));
1000 break;
1001 case ELF::SHT_NOBITS:
1002 if (!IO.outputting())
1003 Section.reset(new ELFYAML::NoBitsSection());
1004 sectionMapping(IO, *cast<ELFYAML::NoBitsSection>(Section.get()));
1005 break;
1006 case ELF::SHT_MIPS_ABIFLAGS:
1007 if (!IO.outputting())
1008 Section.reset(new ELFYAML::MipsABIFlags());
1009 sectionMapping(IO, *cast<ELFYAML::MipsABIFlags>(Section.get()));
1010 break;
1011 case ELF::SHT_GNU_verdef:
1012 if (!IO.outputting())
1013 Section.reset(new ELFYAML::VerdefSection());
1014 sectionMapping(IO, *cast<ELFYAML::VerdefSection>(Section.get()));
1015 break;
1016 case ELF::SHT_GNU_versym:
1017 if (!IO.outputting())
1018 Section.reset(new ELFYAML::SymverSection());
1019 sectionMapping(IO, *cast<ELFYAML::SymverSection>(Section.get()));
1020 break;
1021 case ELF::SHT_GNU_verneed:
1022 if (!IO.outputting())
1023 Section.reset(new ELFYAML::VerneedSection());
1024 sectionMapping(IO, *cast<ELFYAML::VerneedSection>(Section.get()));
1025 break;
1026 default:
1027 if (!IO.outputting())
1028 Section.reset(new ELFYAML::RawContentSection());
1029 sectionMapping(IO, *cast<ELFYAML::RawContentSection>(Section.get()));
1030 }
1031}
1032
1033StringRef MappingTraits<std::unique_ptr<ELFYAML::Section>>::validate(
1034 IO &io, std::unique_ptr<ELFYAML::Section> &Section) {
1035 const auto *RawSection = dyn_cast<ELFYAML::RawContentSection>(Section.get());
1036 if (!RawSection || RawSection->Size >= RawSection->Content.binary_size())
1037 return StringRef();
1038 return "Section size must be greater or equal to the content size";
1039}
1040
1041namespace {
1042
1043struct NormalizedMips64RelType {
1044 NormalizedMips64RelType(IO &)
1045 : Type(ELFYAML::ELF_REL(ELF::R_MIPS_NONE)),
1046 Type2(ELFYAML::ELF_REL(ELF::R_MIPS_NONE)),
1047 Type3(ELFYAML::ELF_REL(ELF::R_MIPS_NONE)),
1048 SpecSym(ELFYAML::ELF_REL(ELF::RSS_UNDEF)) {}
1049 NormalizedMips64RelType(IO &, ELFYAML::ELF_REL Original)
1050 : Type(Original & 0xFF), Type2(Original >> 8 & 0xFF),
1051 Type3(Original >> 16 & 0xFF), SpecSym(Original >> 24 & 0xFF) {}
1052
1053 ELFYAML::ELF_REL denormalize(IO &) {
1054 ELFYAML::ELF_REL Res = Type | Type2 << 8 | Type3 << 16 | SpecSym << 24;
1055 return Res;
1056 }
1057
1058 ELFYAML::ELF_REL Type;
1059 ELFYAML::ELF_REL Type2;
1060 ELFYAML::ELF_REL Type3;
1061 ELFYAML::ELF_RSS SpecSym;
1062};
1063
1064} // end anonymous namespace
1065
1066void MappingTraits<ELFYAML::DynamicEntry>::mapping(IO &IO,
1067 ELFYAML::DynamicEntry &Rel) {
1068 assert(IO.getContext() && "The IO context is not initialized")((IO.getContext() && "The IO context is not initialized"
) ? static_cast<void> (0) : __assert_fail ("IO.getContext() && \"The IO context is not initialized\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/ObjectYAML/ELFYAML.cpp"
, 1068, __PRETTY_FUNCTION__))
;
1069
1070 IO.mapRequired("Tag", Rel.Tag);
1071 IO.mapRequired("Value", Rel.Val);
1072}
1073
1074void MappingTraits<ELFYAML::VerdefEntry>::mapping(IO &IO,
1075 ELFYAML::VerdefEntry &E) {
1076 assert(IO.getContext() && "The IO context is not initialized")((IO.getContext() && "The IO context is not initialized"
) ? static_cast<void> (0) : __assert_fail ("IO.getContext() && \"The IO context is not initialized\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/ObjectYAML/ELFYAML.cpp"
, 1076, __PRETTY_FUNCTION__))
;
1077
1078 IO.mapRequired("Version", E.Version);
1079 IO.mapRequired("Flags", E.Flags);
1080 IO.mapRequired("VersionNdx", E.VersionNdx);
1081 IO.mapRequired("Hash", E.Hash);
1082 IO.mapRequired("Names", E.VerNames);
1083}
1084
1085void MappingTraits<ELFYAML::VerneedEntry>::mapping(IO &IO,
1086 ELFYAML::VerneedEntry &E) {
1087 assert(IO.getContext() && "The IO context is not initialized")((IO.getContext() && "The IO context is not initialized"
) ? static_cast<void> (0) : __assert_fail ("IO.getContext() && \"The IO context is not initialized\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/ObjectYAML/ELFYAML.cpp"
, 1087, __PRETTY_FUNCTION__))
;
1088
1089 IO.mapRequired("Version", E.Version);
1090 IO.mapRequired("File", E.File);
1091 IO.mapRequired("Entries", E.AuxV);
1092}
1093
1094void MappingTraits<ELFYAML::VernauxEntry>::mapping(IO &IO,
1095 ELFYAML::VernauxEntry &E) {
1096 assert(IO.getContext() && "The IO context is not initialized")((IO.getContext() && "The IO context is not initialized"
) ? static_cast<void> (0) : __assert_fail ("IO.getContext() && \"The IO context is not initialized\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/ObjectYAML/ELFYAML.cpp"
, 1096, __PRETTY_FUNCTION__))
;
1097
1098 IO.mapRequired("Name", E.Name);
1099 IO.mapRequired("Hash", E.Hash);
1100 IO.mapRequired("Flags", E.Flags);
1101 IO.mapRequired("Other", E.Other);
1102}
1103
1104void MappingTraits<ELFYAML::Relocation>::mapping(IO &IO,
1105 ELFYAML::Relocation &Rel) {
1106 const auto *Object = static_cast<ELFYAML::Object *>(IO.getContext());
1107 assert(Object && "The IO context is not initialized")((Object && "The IO context is not initialized") ? static_cast
<void> (0) : __assert_fail ("Object && \"The IO context is not initialized\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/ObjectYAML/ELFYAML.cpp"
, 1107, __PRETTY_FUNCTION__))
;
1108
1109 IO.mapRequired("Offset", Rel.Offset);
1110 IO.mapOptional("Symbol", Rel.Symbol);
1111
1112 if (Object->Header.Machine == ELFYAML::ELF_EM(ELF::EM_MIPS) &&
1113 Object->Header.Class == ELFYAML::ELF_ELFCLASS(ELF::ELFCLASS64)) {
1114 MappingNormalization<NormalizedMips64RelType, ELFYAML::ELF_REL> Key(
1115 IO, Rel.Type);
1116 IO.mapRequired("Type", Key->Type);
1117 IO.mapOptional("Type2", Key->Type2, ELFYAML::ELF_REL(ELF::R_MIPS_NONE));
1118 IO.mapOptional("Type3", Key->Type3, ELFYAML::ELF_REL(ELF::R_MIPS_NONE));
1119 IO.mapOptional("SpecSym", Key->SpecSym, ELFYAML::ELF_RSS(ELF::RSS_UNDEF));
1120 } else
1121 IO.mapRequired("Type", Rel.Type);
1122
1123 IO.mapOptional("Addend", Rel.Addend, (int64_t)0);
1124}
1125
1126void MappingTraits<ELFYAML::Object>::mapping(IO &IO, ELFYAML::Object &Object) {
1127 assert(!IO.getContext() && "The IO context is initialized already")((!IO.getContext() && "The IO context is initialized already"
) ? static_cast<void> (0) : __assert_fail ("!IO.getContext() && \"The IO context is initialized already\""
, "/build/llvm-toolchain-snapshot-9~svn362543/lib/ObjectYAML/ELFYAML.cpp"
, 1127, __PRETTY_FUNCTION__))
;
1128 IO.setContext(&Object);
1129 IO.mapTag("!ELF", true);
1130 IO.mapRequired("FileHeader", Object.Header);
1131 IO.mapOptional("ProgramHeaders", Object.ProgramHeaders);
1132 IO.mapOptional("Sections", Object.Sections);
1133 IO.mapOptional("Symbols", Object.Symbols);
1134 IO.mapOptional("DynamicSymbols", Object.DynamicSymbols);
1135 IO.setContext(nullptr);
1136}
1137
1138LLVM_YAML_STRONG_TYPEDEF(uint8_t, MIPS_AFL_REG)struct MIPS_AFL_REG { MIPS_AFL_REG() = default; MIPS_AFL_REG(
const uint8_t v) : value(v) {} MIPS_AFL_REG(const MIPS_AFL_REG
&v) = default; MIPS_AFL_REG &operator=(const MIPS_AFL_REG
&rhs) = default; MIPS_AFL_REG &operator=(const uint8_t
&rhs) { value = rhs; return *this; } operator const uint8_t
& () const { return value; } bool operator==(const MIPS_AFL_REG
&rhs) const { return value == rhs.value; } bool operator
==(const uint8_t &rhs) const { return value == rhs; } bool
operator<(const MIPS_AFL_REG &rhs) const { return value
< rhs.value; } uint8_t value; using BaseType = uint8_t; }
;
1139LLVM_YAML_STRONG_TYPEDEF(uint8_t, MIPS_ABI_FP)struct MIPS_ABI_FP { MIPS_ABI_FP() = default; MIPS_ABI_FP(const
uint8_t v) : value(v) {} MIPS_ABI_FP(const MIPS_ABI_FP &
v) = default; MIPS_ABI_FP &operator=(const MIPS_ABI_FP &
rhs) = default; MIPS_ABI_FP &operator=(const uint8_t &
rhs) { value = rhs; return *this; } operator const uint8_t &
() const { return value; } bool operator==(const MIPS_ABI_FP
&rhs) const { return value == rhs.value; } bool operator
==(const uint8_t &rhs) const { return value == rhs; } bool
operator<(const MIPS_ABI_FP &rhs) const { return value
< rhs.value; } uint8_t value; using BaseType = uint8_t; }
;
1140LLVM_YAML_STRONG_TYPEDEF(uint32_t, MIPS_AFL_EXT)struct MIPS_AFL_EXT { MIPS_AFL_EXT() = default; MIPS_AFL_EXT(
const uint32_t v) : value(v) {} MIPS_AFL_EXT(const MIPS_AFL_EXT
&v) = default; MIPS_AFL_EXT &operator=(const MIPS_AFL_EXT
&rhs) = default; MIPS_AFL_EXT &operator=(const uint32_t
&rhs) { value = rhs; return *this; } operator const uint32_t
& () const { return value; } bool operator==(const MIPS_AFL_EXT
&rhs) const { return value == rhs.value; } bool operator
==(const uint32_t &rhs) const { return value == rhs; } bool
operator<(const MIPS_AFL_EXT &rhs) const { return value
< rhs.value; } uint32_t value; using BaseType = uint32_t;
};
1141LLVM_YAML_STRONG_TYPEDEF(uint32_t, MIPS_AFL_ASE)struct MIPS_AFL_ASE { MIPS_AFL_ASE() = default; MIPS_AFL_ASE(
const uint32_t v) : value(v) {} MIPS_AFL_ASE(const MIPS_AFL_ASE
&v) = default; MIPS_AFL_ASE &operator=(const MIPS_AFL_ASE
&rhs) = default; MIPS_AFL_ASE &operator=(const uint32_t
&rhs) { value = rhs; return *this; } operator const uint32_t
& () const { return value; } bool operator==(const MIPS_AFL_ASE
&rhs) const { return value == rhs.value; } bool operator
==(const uint32_t &rhs) const { return value == rhs; } bool
operator<(const MIPS_AFL_ASE &rhs) const { return value
< rhs.value; } uint32_t value; using BaseType = uint32_t;
};
1142LLVM_YAML_STRONG_TYPEDEF(uint32_t, MIPS_AFL_FLAGS1)struct MIPS_AFL_FLAGS1 { MIPS_AFL_FLAGS1() = default; MIPS_AFL_FLAGS1
(const uint32_t v) : value(v) {} MIPS_AFL_FLAGS1(const MIPS_AFL_FLAGS1
&v) = default; MIPS_AFL_FLAGS1 &operator=(const MIPS_AFL_FLAGS1
&rhs) = default; MIPS_AFL_FLAGS1 &operator=(const uint32_t
&rhs) { value = rhs; return *this; } operator const uint32_t
& () const { return value; } bool operator==(const MIPS_AFL_FLAGS1
&rhs) const { return value == rhs.value; } bool operator
==(const uint32_t &rhs) const { return value == rhs; } bool
operator<(const MIPS_AFL_FLAGS1 &rhs) const { return value
< rhs.value; } uint32_t value; using BaseType = uint32_t;
};
1143
1144} // end namespace yaml
1145
1146} // end namespace llvm

/build/llvm-toolchain-snapshot-9~svn362543/include/llvm/ObjectYAML/ELFYAML.h

1//===- ELFYAML.h - ELF YAMLIO implementation --------------------*- C++ -*-===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8///
9/// \file
10/// This file declares classes for handling the YAML representation
11/// of ELF.
12///
13//===----------------------------------------------------------------------===//
14
15#ifndef LLVM_OBJECTYAML_ELFYAML_H
16#define LLVM_OBJECTYAML_ELFYAML_H
17
18#include "llvm/ADT/StringRef.h"
19#include "llvm/ObjectYAML/YAML.h"
20#include "llvm/Support/YAMLTraits.h"
21#include <cstdint>
22#include <memory>
23#include <vector>
24
25namespace llvm {
26namespace ELFYAML {
27
28// These types are invariant across 32/64-bit ELF, so for simplicity just
29// directly give them their exact sizes. We don't need to worry about
30// endianness because these are just the types in the YAMLIO structures,
31// and are appropriately converted to the necessary endianness when
32// reading/generating binary object files.
33// The naming of these types is intended to be ELF_PREFIX, where PREFIX is
34// the common prefix of the respective constants. E.g. ELF_EM corresponds
35// to the `e_machine` constants, like `EM_X86_64`.
36// In the future, these would probably be better suited by C++11 enum
37// class's with appropriate fixed underlying type.
38LLVM_YAML_STRONG_TYPEDEF(uint16_t, ELF_ET)struct ELF_ET { ELF_ET() = default; ELF_ET(const uint16_t v) :
value(v) {} ELF_ET(const ELF_ET &v) = default; ELF_ET &
operator=(const ELF_ET &rhs) = default; ELF_ET &operator
=(const uint16_t &rhs) { value = rhs; return *this; } operator
const uint16_t & () const { return value; } bool operator
==(const ELF_ET &rhs) const { return value == rhs.value; }
bool operator==(const uint16_t &rhs) const { return value
== rhs; } bool operator<(const ELF_ET &rhs) const { return
value < rhs.value; } uint16_t value; using BaseType = uint16_t
; };
39LLVM_YAML_STRONG_TYPEDEF(uint32_t, ELF_PT)struct ELF_PT { ELF_PT() = default; ELF_PT(const uint32_t v) :
value(v) {} ELF_PT(const ELF_PT &v) = default; ELF_PT &
operator=(const ELF_PT &rhs) = default; ELF_PT &operator
=(const uint32_t &rhs) { value = rhs; return *this; } operator
const uint32_t & () const { return value; } bool operator
==(const ELF_PT &rhs) const { return value == rhs.value; }
bool operator==(const uint32_t &rhs) const { return value
== rhs; } bool operator<(const ELF_PT &rhs) const { return
value < rhs.value; } uint32_t value; using BaseType = uint32_t
; };
40LLVM_YAML_STRONG_TYPEDEF(uint32_t, ELF_EM)struct ELF_EM { ELF_EM() = default; ELF_EM(const uint32_t v) :
value(v) {} ELF_EM(const ELF_EM &v) = default; ELF_EM &
operator=(const ELF_EM &rhs) = default; ELF_EM &operator
=(const uint32_t &rhs) { value = rhs; return *this; } operator
const uint32_t & () const { return value; } bool operator
==(const ELF_EM &rhs) const { return value == rhs.value; }
bool operator==(const uint32_t &rhs) const { return value
== rhs; } bool operator<(const ELF_EM &rhs) const { return
value < rhs.value; } uint32_t value; using BaseType = uint32_t
; };
41LLVM_YAML_STRONG_TYPEDEF(uint8_t, ELF_ELFCLASS)struct ELF_ELFCLASS { ELF_ELFCLASS() = default; ELF_ELFCLASS(
const uint8_t v) : value(v) {} ELF_ELFCLASS(const ELF_ELFCLASS
&v) = default; ELF_ELFCLASS &operator=(const ELF_ELFCLASS
&rhs) = default; ELF_ELFCLASS &operator=(const uint8_t
&rhs) { value = rhs; return *this; } operator const uint8_t
& () const { return value; } bool operator==(const ELF_ELFCLASS
&rhs) const { return value == rhs.value; } bool operator
==(const uint8_t &rhs) const { return value == rhs; } bool
operator<(const ELF_ELFCLASS &rhs) const { return value
< rhs.value; } uint8_t value; using BaseType = uint8_t; }
;
42LLVM_YAML_STRONG_TYPEDEF(uint8_t, ELF_ELFDATA)struct ELF_ELFDATA { ELF_ELFDATA() = default; ELF_ELFDATA(const
uint8_t v) : value(v) {} ELF_ELFDATA(const ELF_ELFDATA &
v) = default; ELF_ELFDATA &operator=(const ELF_ELFDATA &
rhs) = default; ELF_ELFDATA &operator=(const uint8_t &
rhs) { value = rhs; return *this; } operator const uint8_t &
() const { return value; } bool operator==(const ELF_ELFDATA
&rhs) const { return value == rhs.value; } bool operator
==(const uint8_t &rhs) const { return value == rhs; } bool
operator<(const ELF_ELFDATA &rhs) const { return value
< rhs.value; } uint8_t value; using BaseType = uint8_t; }
;
43LLVM_YAML_STRONG_TYPEDEF(uint8_t, ELF_ELFOSABI)struct ELF_ELFOSABI { ELF_ELFOSABI() = default; ELF_ELFOSABI(
const uint8_t v) : value(v) {} ELF_ELFOSABI(const ELF_ELFOSABI
&v) = default; ELF_ELFOSABI &operator=(const ELF_ELFOSABI
&rhs) = default; ELF_ELFOSABI &operator=(const uint8_t
&rhs) { value = rhs; return *this; } operator const uint8_t
& () const { return value; } bool operator==(const ELF_ELFOSABI
&rhs) const { return value == rhs.value; } bool operator
==(const uint8_t &rhs) const { return value == rhs; } bool
operator<(const ELF_ELFOSABI &rhs) const { return value
< rhs.value; } uint8_t value; using BaseType = uint8_t; }
;
44// Just use 64, since it can hold 32-bit values too.
45LLVM_YAML_STRONG_TYPEDEF(uint64_t, ELF_EF)struct ELF_EF { ELF_EF() = default; ELF_EF(const uint64_t v) :
value(v) {} ELF_EF(const ELF_EF &v) = default; ELF_EF &
operator=(const ELF_EF &rhs) = default; ELF_EF &operator
=(const uint64_t &rhs) { value = rhs; return *this; } operator
const uint64_t & () const { return value; } bool operator
==(const ELF_EF &rhs) const { return value == rhs.value; }
bool operator==(const uint64_t &rhs) const { return value
== rhs; } bool operator<(const ELF_EF &rhs) const { return
value < rhs.value; } uint64_t value; using BaseType = uint64_t
; };
46// Just use 64, since it can hold 32-bit values too.
47LLVM_YAML_STRONG_TYPEDEF(uint64_t, ELF_DYNTAG)struct ELF_DYNTAG { ELF_DYNTAG() = default; ELF_DYNTAG(const uint64_t
v) : value(v) {} ELF_DYNTAG(const ELF_DYNTAG &v) = default
; ELF_DYNTAG &operator=(const ELF_DYNTAG &rhs) = default
; ELF_DYNTAG &operator=(const uint64_t &rhs) { value =
rhs; return *this; } operator const uint64_t & () const {
return value; } bool operator==(const ELF_DYNTAG &rhs) const
{ return value == rhs.value; } bool operator==(const uint64_t
&rhs) const { return value == rhs; } bool operator<(const
ELF_DYNTAG &rhs) const { return value < rhs.value; } uint64_t
value; using BaseType = uint64_t; };
48LLVM_YAML_STRONG_TYPEDEF(uint32_t, ELF_PF)struct ELF_PF { ELF_PF() = default; ELF_PF(const uint32_t v) :
value(v) {} ELF_PF(const ELF_PF &v) = default; ELF_PF &
operator=(const ELF_PF &rhs) = default; ELF_PF &operator
=(const uint32_t &rhs) { value = rhs; return *this; } operator
const uint32_t & () const { return value; } bool operator
==(const ELF_PF &rhs) const { return value == rhs.value; }
bool operator==(const uint32_t &rhs) const { return value
== rhs; } bool operator<(const ELF_PF &rhs) const { return
value < rhs.value; } uint32_t value; using BaseType = uint32_t
; };
49LLVM_YAML_STRONG_TYPEDEF(uint32_t, ELF_SHT)struct ELF_SHT { ELF_SHT() = default; ELF_SHT(const uint32_t v
) : value(v) {} ELF_SHT(const ELF_SHT &v) = default; ELF_SHT
&operator=(const ELF_SHT &rhs) = default; ELF_SHT &
operator=(const uint32_t &rhs) { value = rhs; return *this
; } operator const uint32_t & () const { return value; } bool
operator==(const ELF_SHT &rhs) const { return value == rhs
.value; } bool operator==(const uint32_t &rhs) const { return
value == rhs; } bool operator<(const ELF_SHT &rhs) const
{ return value < rhs.value; } uint32_t value; using BaseType
= uint32_t; };
2
Returning without writing to 'this->value'
206
Returning pointer (reference to 'sectionType.value')
50LLVM_YAML_STRONG_TYPEDEF(uint32_t, ELF_REL)struct ELF_REL { ELF_REL() = default; ELF_REL(const uint32_t v
) : value(v) {} ELF_REL(const ELF_REL &v) = default; ELF_REL
&operator=(const ELF_REL &rhs) = default; ELF_REL &
operator=(const uint32_t &rhs) { value = rhs; return *this
; } operator const uint32_t & () const { return value; } bool
operator==(const ELF_REL &rhs) const { return value == rhs
.value; } bool operator==(const uint32_t &rhs) const { return
value == rhs; } bool operator<(const ELF_REL &rhs) const
{ return value < rhs.value; } uint32_t value; using BaseType
= uint32_t; };
51LLVM_YAML_STRONG_TYPEDEF(uint8_t, ELF_RSS)struct ELF_RSS { ELF_RSS() = default; ELF_RSS(const uint8_t v
) : value(v) {} ELF_RSS(const ELF_RSS &v) = default; ELF_RSS
&operator=(const ELF_RSS &rhs) = default; ELF_RSS &
operator=(const uint8_t &rhs) { value = rhs; return *this
; } operator const uint8_t & () const { return value; } bool
operator==(const ELF_RSS &rhs) const { return value == rhs
.value; } bool operator==(const uint8_t &rhs) const { return
value == rhs; } bool operator<(const ELF_RSS &rhs) const
{ return value < rhs.value; } uint8_t value; using BaseType
= uint8_t; };
52// Just use 64, since it can hold 32-bit values too.
53LLVM_YAML_STRONG_TYPEDEF(uint64_t, ELF_SHF)struct ELF_SHF { ELF_SHF() = default; ELF_SHF(const uint64_t v
) : value(v) {} ELF_SHF(const ELF_SHF &v) = default; ELF_SHF
&operator=(const ELF_SHF &rhs) = default; ELF_SHF &
operator=(const uint64_t &rhs) { value = rhs; return *this
; } operator const uint64_t & () const { return value; } bool
operator==(const ELF_SHF &rhs) const { return value == rhs
.value; } bool operator==(const uint64_t &rhs) const { return
value == rhs; } bool operator<(const ELF_SHF &rhs) const
{ return value < rhs.value; } uint64_t value; using BaseType
= uint64_t; };
54LLVM_YAML_STRONG_TYPEDEF(uint16_t, ELF_SHN)struct ELF_SHN { ELF_SHN() = default; ELF_SHN(const uint16_t v
) : value(v) {} ELF_SHN(const ELF_SHN &v) = default; ELF_SHN
&operator=(const ELF_SHN &rhs) = default; ELF_SHN &
operator=(const uint16_t &rhs) { value = rhs; return *this
; } operator const uint16_t & () const { return value; } bool
operator==(const ELF_SHN &rhs) const { return value == rhs
.value; } bool operator==(const uint16_t &rhs) const { return
value == rhs; } bool operator<(const ELF_SHN &rhs) const
{ return value < rhs.value; } uint16_t value; using BaseType
= uint16_t; };
55LLVM_YAML_STRONG_TYPEDEF(uint8_t, ELF_STB)struct ELF_STB { ELF_STB() = default; ELF_STB(const uint8_t v
) : value(v) {} ELF_STB(const ELF_STB &v) = default; ELF_STB
&operator=(const ELF_STB &rhs) = default; ELF_STB &
operator=(const uint8_t &rhs) { value = rhs; return *this
; } operator const uint8_t & () const { return value; } bool
operator==(const ELF_STB &rhs) const { return value == rhs
.value; } bool operator==(const uint8_t &rhs) const { return
value == rhs; } bool operator<(const ELF_STB &rhs) const
{ return value < rhs.value; } uint8_t value; using BaseType
= uint8_t; };
56LLVM_YAML_STRONG_TYPEDEF(uint8_t, ELF_STT)struct ELF_STT { ELF_STT() = default; ELF_STT(const uint8_t v
) : value(v) {} ELF_STT(const ELF_STT &v) = default; ELF_STT
&operator=(const ELF_STT &rhs) = default; ELF_STT &
operator=(const uint8_t &rhs) { value = rhs; return *this
; } operator const uint8_t & () const { return value; } bool
operator==(const ELF_STT &rhs) const { return value == rhs
.value; } bool operator==(const uint8_t &rhs) const { return
value == rhs; } bool operator<(const ELF_STT &rhs) const
{ return value < rhs.value; } uint8_t value; using BaseType
= uint8_t; };
57LLVM_YAML_STRONG_TYPEDEF(uint8_t, ELF_STV)struct ELF_STV { ELF_STV() = default; ELF_STV(const uint8_t v
) : value(v) {} ELF_STV(const ELF_STV &v) = default; ELF_STV
&operator=(const ELF_STV &rhs) = default; ELF_STV &
operator=(const uint8_t &rhs) { value = rhs; return *this
; } operator const uint8_t & () const { return value; } bool
operator==(const ELF_STV &rhs) const { return value == rhs
.value; } bool operator==(const uint8_t &rhs) const { return
value == rhs; } bool operator<(const ELF_STV &rhs) const
{ return value < rhs.value; } uint8_t value; using BaseType
= uint8_t; };
58LLVM_YAML_STRONG_TYPEDEF(uint8_t, ELF_STO)struct ELF_STO { ELF_STO() = default; ELF_STO(const uint8_t v
) : value(v) {} ELF_STO(const ELF_STO &v) = default; ELF_STO
&operator=(const ELF_STO &rhs) = default; ELF_STO &
operator=(const uint8_t &rhs) { value = rhs; return *this
; } operator const uint8_t & () const { return value; } bool
operator==(const ELF_STO &rhs) const { return value == rhs
.value; } bool operator==(const uint8_t &rhs) const { return
value == rhs; } bool operator<(const ELF_STO &rhs) const
{ return value < rhs.value; } uint8_t value; using BaseType
= uint8_t; };
59
60LLVM_YAML_STRONG_TYPEDEF(uint8_t, MIPS_AFL_REG)struct MIPS_AFL_REG { MIPS_AFL_REG() = default; MIPS_AFL_REG(
const uint8_t v) : value(v) {} MIPS_AFL_REG(const MIPS_AFL_REG
&v) = default; MIPS_AFL_REG &operator=(const MIPS_AFL_REG
&rhs) = default; MIPS_AFL_REG &operator=(const uint8_t
&rhs) { value = rhs; return *this; } operator const uint8_t
& () const { return value; } bool operator==(const MIPS_AFL_REG
&rhs) const { return value == rhs.value; } bool operator
==(const uint8_t &rhs) const { return value == rhs; } bool
operator<(const MIPS_AFL_REG &rhs) const { return value
< rhs.value; } uint8_t value; using BaseType = uint8_t; }
;
61LLVM_YAML_STRONG_TYPEDEF(uint8_t, MIPS_ABI_FP)struct MIPS_ABI_FP { MIPS_ABI_FP() = default; MIPS_ABI_FP(const
uint8_t v) : value(v) {} MIPS_ABI_FP(const MIPS_ABI_FP &
v) = default; MIPS_ABI_FP &operator=(const MIPS_ABI_FP &
rhs) = default; MIPS_ABI_FP &operator=(const uint8_t &
rhs) { value = rhs; return *this; } operator const uint8_t &
() const { return value; } bool operator==(const MIPS_ABI_FP
&rhs) const { return value == rhs.value; } bool operator
==(const uint8_t &rhs) const { return value == rhs; } bool
operator<(const MIPS_ABI_FP &rhs) const { return value
< rhs.value; } uint8_t value; using BaseType = uint8_t; }
;
62LLVM_YAML_STRONG_TYPEDEF(uint32_t, MIPS_AFL_EXT)struct MIPS_AFL_EXT { MIPS_AFL_EXT() = default; MIPS_AFL_EXT(
const uint32_t v) : value(v) {} MIPS_AFL_EXT(const MIPS_AFL_EXT
&v) = default; MIPS_AFL_EXT &operator=(const MIPS_AFL_EXT
&rhs) = default; MIPS_AFL_EXT &operator=(const uint32_t
&rhs) { value = rhs; return *this; } operator const uint32_t
& () const { return value; } bool operator==(const MIPS_AFL_EXT
&rhs) const { return value == rhs.value; } bool operator
==(const uint32_t &rhs) const { return value == rhs; } bool
operator<(const MIPS_AFL_EXT &rhs) const { return value
< rhs.value; } uint32_t value; using BaseType = uint32_t;
};
63LLVM_YAML_STRONG_TYPEDEF(uint32_t, MIPS_AFL_ASE)struct MIPS_AFL_ASE { MIPS_AFL_ASE() = default; MIPS_AFL_ASE(
const uint32_t v) : value(v) {} MIPS_AFL_ASE(const MIPS_AFL_ASE
&v) = default; MIPS_AFL_ASE &operator=(const MIPS_AFL_ASE
&rhs) = default; MIPS_AFL_ASE &operator=(const uint32_t
&rhs) { value = rhs; return *this; } operator const uint32_t
& () const { return value; } bool operator==(const MIPS_AFL_ASE
&rhs) const { return value == rhs.value; } bool operator
==(const uint32_t &rhs) const { return value == rhs; } bool
operator<(const MIPS_AFL_ASE &rhs) const { return value
< rhs.value; } uint32_t value; using BaseType = uint32_t;
};
64LLVM_YAML_STRONG_TYPEDEF(uint32_t, MIPS_AFL_FLAGS1)struct MIPS_AFL_FLAGS1 { MIPS_AFL_FLAGS1() = default; MIPS_AFL_FLAGS1
(const uint32_t v) : value(v) {} MIPS_AFL_FLAGS1(const MIPS_AFL_FLAGS1
&v) = default; MIPS_AFL_FLAGS1 &operator=(const MIPS_AFL_FLAGS1
&rhs) = default; MIPS_AFL_FLAGS1 &operator=(const uint32_t
&rhs) { value = rhs; return *this; } operator const uint32_t
& () const { return value; } bool operator==(const MIPS_AFL_FLAGS1
&rhs) const { return value == rhs.value; } bool operator
==(const uint32_t &rhs) const { return value == rhs; } bool
operator<(const MIPS_AFL_FLAGS1 &rhs) const { return value
< rhs.value; } uint32_t value; using BaseType = uint32_t;
};
65LLVM_YAML_STRONG_TYPEDEF(uint32_t, MIPS_ISA)struct MIPS_ISA { MIPS_ISA() = default; MIPS_ISA(const uint32_t
v) : value(v) {} MIPS_ISA(const MIPS_ISA &v) = default; MIPS_ISA
&operator=(const MIPS_ISA &rhs) = default; MIPS_ISA &
operator=(const uint32_t &rhs) { value = rhs; return *this
; } operator const uint32_t & () const { return value; } bool
operator==(const MIPS_ISA &rhs) const { return value == rhs
.value; } bool operator==(const uint32_t &rhs) const { return
value == rhs; } bool operator<(const MIPS_ISA &rhs) const
{ return value < rhs.value; } uint32_t value; using BaseType
= uint32_t; };
66
67// For now, hardcode 64 bits everywhere that 32 or 64 would be needed
68// since 64-bit can hold 32-bit values too.
69struct FileHeader {
70 ELF_ELFCLASS Class;
71 ELF_ELFDATA Data;
72 ELF_ELFOSABI OSABI;
73 llvm::yaml::Hex8 ABIVersion;
74 ELF_ET Type;
75 ELF_EM Machine;
76 ELF_EF Flags;
77 llvm::yaml::Hex64 Entry;
78};
79
80struct SectionName {
81 StringRef Section;
82};
83
84struct ProgramHeader {
85 ELF_PT Type;
86 ELF_PF Flags;
87 llvm::yaml::Hex64 VAddr;
88 llvm::yaml::Hex64 PAddr;
89 Optional<llvm::yaml::Hex64> Align;
90 Optional<llvm::yaml::Hex64> FileSize;
91 Optional<llvm::yaml::Hex64> MemSize;
92 Optional<llvm::yaml::Hex64> Offset;
93 std::vector<SectionName> Sections;
94};
95
96struct Symbol {
97 StringRef Name;
98 Optional<uint32_t> NameIndex;
99 ELF_STT Type;
100 StringRef Section;
101 Optional<ELF_SHN> Index;
102 ELF_STB Binding;
103 llvm::yaml::Hex64 Value;
104 llvm::yaml::Hex64 Size;
105 uint8_t Other;
106};
107
108struct SectionOrType {
109 StringRef sectionNameOrType;
110};
111
112struct DynamicEntry {
113 ELF_DYNTAG Tag;
114 llvm::yaml::Hex64 Val;
115};
116
117struct Section {
118 enum class SectionKind {
119 Dynamic,
120 Group,
121 RawContent,
122 Relocation,
123 NoBits,
124 Verdef,
125 Verneed,
126 Symver,
127 MipsABIFlags
128 };
129 SectionKind Kind;
130 StringRef Name;
131 ELF_SHT Type;
132 ELF_SHF Flags;
133 llvm::yaml::Hex64 Address;
134 StringRef Link;
135 llvm::yaml::Hex64 AddressAlign;
136 Optional<llvm::yaml::Hex64> EntSize;
137
138 Section(SectionKind Kind) : Kind(Kind) {}
139 virtual ~Section();
140};
141
142struct DynamicSection : Section {
143 std::vector<DynamicEntry> Entries;
144 Optional<yaml::BinaryRef> Content;
145
146 DynamicSection() : Section(SectionKind::Dynamic) {}
147
148 static bool classof(const Section *S) {
149 return S->Kind == SectionKind::Dynamic;
150 }
151};
152
153struct RawContentSection : Section {
154 yaml::BinaryRef Content;
155 llvm::yaml::Hex64 Size;
156 llvm::yaml::Hex64 Info;
157
158 RawContentSection() : Section(SectionKind::RawContent) {}
159
160 static bool classof(const Section *S) {
161 return S->Kind == SectionKind::RawContent;
162 }
163};
164
165struct NoBitsSection : Section {
166 llvm::yaml::Hex64 Size;
167
168 NoBitsSection() : Section(SectionKind::NoBits) {}
169
170 static bool classof(const Section *S) {
171 return S->Kind == SectionKind::NoBits;
172 }
173};
174
175struct VernauxEntry {
176 uint32_t Hash;
177 uint16_t Flags;
178 uint16_t Other;
179 StringRef Name;
180};
181
182struct VerneedEntry {
183 uint16_t Version;
184 StringRef File;
185 std::vector<VernauxEntry> AuxV;
186};
187
188struct VerneedSection : Section {
189 std::vector<VerneedEntry> VerneedV;
190 llvm::yaml::Hex64 Info;
191
192 VerneedSection() : Section(SectionKind::Verneed) {}
193
194 static bool classof(const Section *S) {
195 return S->Kind == SectionKind::Verneed;
196 }
197};
198
199struct SymverSection : Section {
200 std::vector<uint16_t> Entries;
201
202 SymverSection() : Section(SectionKind::Symver) {}
203
204 static bool classof(const Section *S) {
205 return S->Kind == SectionKind::Symver;
206 }
207};
208
209struct VerdefEntry {
210 uint16_t Version;
211 uint16_t Flags;
212 uint16_t VersionNdx;
213 uint32_t Hash;
214 std::vector<StringRef> VerNames;
215};
216
217struct VerdefSection : Section {
218 std::vector<VerdefEntry> Entries;
219 llvm::yaml::Hex64 Info;
220
221 VerdefSection() : Section(SectionKind::Verdef) {}
222
223 static bool classof(const Section *S) {
224 return S->Kind == SectionKind::Verdef;
225 }
226};
227
228struct Group : Section {
229 // Members of a group contain a flag and a list of section indices
230 // that are part of the group.
231 std::vector<SectionOrType> Members;
232 StringRef Signature; /* Info */
233
234 Group() : Section(SectionKind::Group) {}
235
236 static bool classof(const Section *S) {
237 return S->Kind == SectionKind::Group;
238 }
239};
240
241struct Relocation {
242 llvm::yaml::Hex64 Offset;
243 int64_t Addend;
244 ELF_REL Type;
245 Optional<StringRef> Symbol;
246};
247
248struct RelocationSection : Section {
249 std::vector<Relocation> Relocations;
250 StringRef RelocatableSec; /* Info */
251
252 RelocationSection() : Section(SectionKind::Relocation) {}
253
254 static bool classof(const Section *S) {
255 return S->Kind == SectionKind::Relocation;
256 }
257};
258
259// Represents .MIPS.abiflags section
260struct MipsABIFlags : Section {
261 llvm::yaml::Hex16 Version;
262 MIPS_ISA ISALevel;
263 llvm::yaml::Hex8 ISARevision;
264 MIPS_AFL_REG GPRSize;
265 MIPS_AFL_REG CPR1Size;
266 MIPS_AFL_REG CPR2Size;
267 MIPS_ABI_FP FpABI;
268 MIPS_AFL_EXT ISAExtension;
269 MIPS_AFL_ASE ASEs;
270 MIPS_AFL_FLAGS1 Flags1;
271 llvm::yaml::Hex32 Flags2;
272
273 MipsABIFlags() : Section(SectionKind::MipsABIFlags) {}
274
275 static bool classof(const Section *S) {
276 return S->Kind == SectionKind::MipsABIFlags;
277 }
278};
279
280struct Object {
281 FileHeader Header;
282 std::vector<ProgramHeader> ProgramHeaders;
283 std::vector<std::unique_ptr<Section>> Sections;
284 // Although in reality the symbols reside in a section, it is a lot
285 // cleaner and nicer if we read them from the YAML as a separate
286 // top-level key, which automatically ensures that invariants like there
287 // being a single SHT_SYMTAB section are upheld.
288 std::vector<Symbol> Symbols;
289 std::vector<Symbol> DynamicSymbols;
290};
291
292} // end namespace ELFYAML
293} // end namespace llvm
294
295LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::DynamicEntry)namespace llvm { namespace yaml { static_assert( !std::is_fundamental
<llvm::ELFYAML::DynamicEntry>::value && !std::is_same
<llvm::ELFYAML::DynamicEntry, std::string>::value &&
!std::is_same<llvm::ELFYAML::DynamicEntry, llvm::StringRef
>::value, "only use LLVM_YAML_IS_SEQUENCE_VECTOR for types you control"
); template <> struct SequenceElementTraits<llvm::ELFYAML
::DynamicEntry> { static const bool flow = false; }; } }
296LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::ProgramHeader)namespace llvm { namespace yaml { static_assert( !std::is_fundamental
<llvm::ELFYAML::ProgramHeader>::value && !std::
is_same<llvm::ELFYAML::ProgramHeader, std::string>::value
&& !std::is_same<llvm::ELFYAML::ProgramHeader, llvm
::StringRef>::value, "only use LLVM_YAML_IS_SEQUENCE_VECTOR for types you control"
); template <> struct SequenceElementTraits<llvm::ELFYAML
::ProgramHeader> { static const bool flow = false; }; } }
297LLVM_YAML_IS_SEQUENCE_VECTOR(std::unique_ptr<llvm::ELFYAML::Section>)namespace llvm { namespace yaml { static_assert( !std::is_fundamental
<std::unique_ptr<llvm::ELFYAML::Section> >::value
&& !std::is_same<std::unique_ptr<llvm::ELFYAML
::Section>, std::string>::value && !std::is_same
<std::unique_ptr<llvm::ELFYAML::Section>, llvm::StringRef
>::value, "only use LLVM_YAML_IS_SEQUENCE_VECTOR for types you control"
); template <> struct SequenceElementTraits<std::unique_ptr
<llvm::ELFYAML::Section> > { static const bool flow =
false; }; } }
298LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::Symbol)namespace llvm { namespace yaml { static_assert( !std::is_fundamental
<llvm::ELFYAML::Symbol>::value && !std::is_same
<llvm::ELFYAML::Symbol, std::string>::value && !
std::is_same<llvm::ELFYAML::Symbol, llvm::StringRef>::value
, "only use LLVM_YAML_IS_SEQUENCE_VECTOR for types you control"
); template <> struct SequenceElementTraits<llvm::ELFYAML
::Symbol> { static const bool flow = false; }; } }
299LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::VerdefEntry)namespace llvm { namespace yaml { static_assert( !std::is_fundamental
<llvm::ELFYAML::VerdefEntry>::value && !std::is_same
<llvm::ELFYAML::VerdefEntry, std::string>::value &&
!std::is_same<llvm::ELFYAML::VerdefEntry, llvm::StringRef
>::value, "only use LLVM_YAML_IS_SEQUENCE_VECTOR for types you control"
); template <> struct SequenceElementTraits<llvm::ELFYAML
::VerdefEntry> { static const bool flow = false; }; } }
300LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::VernauxEntry)namespace llvm { namespace yaml { static_assert( !std::is_fundamental
<llvm::ELFYAML::VernauxEntry>::value && !std::is_same
<llvm::ELFYAML::VernauxEntry, std::string>::value &&
!std::is_same<llvm::ELFYAML::VernauxEntry, llvm::StringRef
>::value, "only use LLVM_YAML_IS_SEQUENCE_VECTOR for types you control"
); template <> struct SequenceElementTraits<llvm::ELFYAML
::VernauxEntry> { static const bool flow = false; }; } }
301LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::VerneedEntry)namespace llvm { namespace yaml { static_assert( !std::is_fundamental
<llvm::ELFYAML::VerneedEntry>::value && !std::is_same
<llvm::ELFYAML::VerneedEntry, std::string>::value &&
!std::is_same<llvm::ELFYAML::VerneedEntry, llvm::StringRef
>::value, "only use LLVM_YAML_IS_SEQUENCE_VECTOR for types you control"
); template <> struct SequenceElementTraits<llvm::ELFYAML
::VerneedEntry> { static const bool flow = false; }; } }
302LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::Relocation)namespace llvm { namespace yaml { static_assert( !std::is_fundamental
<llvm::ELFYAML::Relocation>::value && !std::is_same
<llvm::ELFYAML::Relocation, std::string>::value &&
!std::is_same<llvm::ELFYAML::Relocation, llvm::StringRef>
::value, "only use LLVM_YAML_IS_SEQUENCE_VECTOR for types you control"
); template <> struct SequenceElementTraits<llvm::ELFYAML
::Relocation> { static const bool flow = false; }; } }
303LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::SectionOrType)namespace llvm { namespace yaml { static_assert( !std::is_fundamental
<llvm::ELFYAML::SectionOrType>::value && !std::
is_same<llvm::ELFYAML::SectionOrType, std::string>::value
&& !std::is_same<llvm::ELFYAML::SectionOrType, llvm
::StringRef>::value, "only use LLVM_YAML_IS_SEQUENCE_VECTOR for types you control"
); template <> struct SequenceElementTraits<llvm::ELFYAML
::SectionOrType> { static const bool flow = false; }; } }
304LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::SectionName)namespace llvm { namespace yaml { static_assert( !std::is_fundamental
<llvm::ELFYAML::SectionName>::value && !std::is_same
<llvm::ELFYAML::SectionName, std::string>::value &&
!std::is_same<llvm::ELFYAML::SectionName, llvm::StringRef
>::value, "only use LLVM_YAML_IS_SEQUENCE_VECTOR for types you control"
); template <> struct SequenceElementTraits<llvm::ELFYAML
::SectionName> { static const bool flow = false; }; } }
305
306namespace llvm {
307namespace yaml {
308
309template <>
310struct ScalarEnumerationTraits<ELFYAML::ELF_ET> {
311 static void enumeration(IO &IO, ELFYAML::ELF_ET &Value);
312};
313
314template <> struct ScalarEnumerationTraits<ELFYAML::ELF_PT> {
315 static void enumeration(IO &IO, ELFYAML::ELF_PT &Value);
316};
317
318template <>
319struct ScalarEnumerationTraits<ELFYAML::ELF_EM> {
320 static void enumeration(IO &IO, ELFYAML::ELF_EM &Value);
321};
322
323template <>
324struct ScalarEnumerationTraits<ELFYAML::ELF_ELFCLASS> {
325 static void enumeration(IO &IO, ELFYAML::ELF_ELFCLASS &Value);
326};
327
328template <>
329struct ScalarEnumerationTraits<ELFYAML::ELF_ELFDATA> {
330 static void enumeration(IO &IO, ELFYAML::ELF_ELFDATA &Value);
331};
332
333template <>
334struct ScalarEnumerationTraits<ELFYAML::ELF_ELFOSABI> {
335 static void enumeration(IO &IO, ELFYAML::ELF_ELFOSABI &Value);
336};
337
338template <>
339struct ScalarBitSetTraits<ELFYAML::ELF_EF> {
340 static void bitset(IO &IO, ELFYAML::ELF_EF &Value);
341};
342
343template <> struct ScalarBitSetTraits<ELFYAML::ELF_PF> {
344 static void bitset(IO &IO, ELFYAML::ELF_PF &Value);
345};
346
347template <>
348struct ScalarEnumerationTraits<ELFYAML::ELF_SHT> {
349 static void enumeration(IO &IO, ELFYAML::ELF_SHT &Value);
350};
351
352template <>
353struct ScalarBitSetTraits<ELFYAML::ELF_SHF> {
354 static void bitset(IO &IO, ELFYAML::ELF_SHF &Value);
355};
356
357template <> struct ScalarEnumerationTraits<ELFYAML::ELF_SHN> {
358 static void enumeration(IO &IO, ELFYAML::ELF_SHN &Value);
359};
360
361template <> struct ScalarEnumerationTraits<ELFYAML::ELF_STB> {
362 static void enumeration(IO &IO, ELFYAML::ELF_STB &Value);
363};
364
365template <>
366struct ScalarEnumerationTraits<ELFYAML::ELF_STT> {
367 static void enumeration(IO &IO, ELFYAML::ELF_STT &Value);
368};
369
370template <>
371struct ScalarEnumerationTraits<ELFYAML::ELF_STV> {
372 static void enumeration(IO &IO, ELFYAML::ELF_STV &Value);
373};
374
375template <>
376struct ScalarBitSetTraits<ELFYAML::ELF_STO> {
377 static void bitset(IO &IO, ELFYAML::ELF_STO &Value);
378};
379
380template <>
381struct ScalarEnumerationTraits<ELFYAML::ELF_REL> {
382 static void enumeration(IO &IO, ELFYAML::ELF_REL &Value);
383};
384
385template <>
386struct ScalarEnumerationTraits<ELFYAML::ELF_DYNTAG> {
387 static void enumeration(IO &IO, ELFYAML::ELF_DYNTAG &Value);
388};
389
390template <>
391struct ScalarEnumerationTraits<ELFYAML::ELF_RSS> {
392 static void enumeration(IO &IO, ELFYAML::ELF_RSS &Value);
393};
394
395template <>
396struct ScalarEnumerationTraits<ELFYAML::MIPS_AFL_REG> {
397 static void enumeration(IO &IO, ELFYAML::MIPS_AFL_REG &Value);
398};
399
400template <>
401struct ScalarEnumerationTraits<ELFYAML::MIPS_ABI_FP> {
402 static void enumeration(IO &IO, ELFYAML::MIPS_ABI_FP &Value);
403};
404
405template <>
406struct ScalarEnumerationTraits<ELFYAML::MIPS_AFL_EXT> {
407 static void enumeration(IO &IO, ELFYAML::MIPS_AFL_EXT &Value);
408};
409
410template <>
411struct ScalarEnumerationTraits<ELFYAML::MIPS_ISA> {
412 static void enumeration(IO &IO, ELFYAML::MIPS_ISA &Value);
413};
414
415template <>
416struct ScalarBitSetTraits<ELFYAML::MIPS_AFL_ASE> {
417 static void bitset(IO &IO, ELFYAML::MIPS_AFL_ASE &Value);
418};
419
420template <>
421struct ScalarBitSetTraits<ELFYAML::MIPS_AFL_FLAGS1> {
422 static void bitset(IO &IO, ELFYAML::MIPS_AFL_FLAGS1 &Value);
423};
424
425template <>
426struct MappingTraits<ELFYAML::FileHeader> {
427 static void mapping(IO &IO, ELFYAML::FileHeader &FileHdr);
428};
429
430template <> struct MappingTraits<ELFYAML::ProgramHeader> {
431 static void mapping(IO &IO, ELFYAML::ProgramHeader &FileHdr);
432};
433
434template <>
435struct MappingTraits<ELFYAML::Symbol> {
436 static void mapping(IO &IO, ELFYAML::Symbol &Symbol);
437 static StringRef validate(IO &IO, ELFYAML::Symbol &Symbol);
438};
439
440template <> struct MappingTraits<ELFYAML::DynamicEntry> {
441 static void mapping(IO &IO, ELFYAML::DynamicEntry &Rel);
442};
443
444template <> struct MappingTraits<ELFYAML::VerdefEntry> {
445 static void mapping(IO &IO, ELFYAML::VerdefEntry &E);
446};
447
448template <> struct MappingTraits<ELFYAML::VerneedEntry> {
449 static void mapping(IO &IO, ELFYAML::VerneedEntry &E);
450};
451
452template <> struct MappingTraits<ELFYAML::VernauxEntry> {
453 static void mapping(IO &IO, ELFYAML::VernauxEntry &E);
454};
455
456template <> struct MappingTraits<ELFYAML::Relocation> {
457 static void mapping(IO &IO, ELFYAML::Relocation &Rel);
458};
459
460template <>
461struct MappingTraits<std::unique_ptr<ELFYAML::Section>> {
462 static void mapping(IO &IO, std::unique_ptr<ELFYAML::Section> &Section);
463 static StringRef validate(IO &io, std::unique_ptr<ELFYAML::Section> &Section);
464};
465
466template <>
467struct MappingTraits<ELFYAML::Object> {
468 static void mapping(IO &IO, ELFYAML::Object &Object);
469};
470
471template <> struct MappingTraits<ELFYAML::SectionOrType> {
472 static void mapping(IO &IO, ELFYAML::SectionOrType &sectionOrType);
473};
474
475template <> struct MappingTraits<ELFYAML::SectionName> {
476 static void mapping(IO &IO, ELFYAML::SectionName &sectionName);
477};
478
479} // end namespace yaml
480} // end namespace llvm
481
482#endif // LLVM_OBJECTYAML_ELFYAML_H

/build/llvm-toolchain-snapshot-9~svn362543/include/llvm/Support/YAMLTraits.h

1//===- llvm/Support/YAMLTraits.h --------------------------------*- 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#ifndef LLVM_SUPPORT_YAMLTRAITS_H
10#define LLVM_SUPPORT_YAMLTRAITS_H
11
12#include "llvm/ADT/Optional.h"
13#include "llvm/ADT/SmallVector.h"
14#include "llvm/ADT/StringExtras.h"
15#include "llvm/ADT/StringMap.h"
16#include "llvm/ADT/StringRef.h"
17#include "llvm/ADT/Twine.h"
18#include "llvm/Support/AlignOf.h"
19#include "llvm/Support/Allocator.h"
20#include "llvm/Support/Endian.h"
21#include "llvm/Support/Regex.h"
22#include "llvm/Support/SourceMgr.h"
23#include "llvm/Support/YAMLParser.h"
24#include "llvm/Support/raw_ostream.h"
25#include <cassert>
26#include <cctype>
27#include <cstddef>
28#include <cstdint>
29#include <iterator>
30#include <map>
31#include <memory>
32#include <new>
33#include <string>
34#include <system_error>
35#include <type_traits>
36#include <vector>
37
38namespace llvm {
39namespace yaml {
40
41enum class NodeKind : uint8_t {
42 Scalar,
43 Map,
44 Sequence,
45};
46
47struct EmptyContext {};
48
49/// This class should be specialized by any type that needs to be converted
50/// to/from a YAML mapping. For example:
51///
52/// struct MappingTraits<MyStruct> {
53/// static void mapping(IO &io, MyStruct &s) {
54/// io.mapRequired("name", s.name);
55/// io.mapRequired("size", s.size);
56/// io.mapOptional("age", s.age);
57/// }
58/// };
59template<class T>
60struct MappingTraits {
61 // Must provide:
62 // static void mapping(IO &io, T &fields);
63 // Optionally may provide:
64 // static StringRef validate(IO &io, T &fields);
65 //
66 // The optional flow flag will cause generated YAML to use a flow mapping
67 // (e.g. { a: 0, b: 1 }):
68 // static const bool flow = true;
69};
70
71/// This class is similar to MappingTraits<T> but allows you to pass in
72/// additional context for each map operation. For example:
73///
74/// struct MappingContextTraits<MyStruct, MyContext> {
75/// static void mapping(IO &io, MyStruct &s, MyContext &c) {
76/// io.mapRequired("name", s.name);
77/// io.mapRequired("size", s.size);
78/// io.mapOptional("age", s.age);
79/// ++c.TimesMapped;
80/// }
81/// };
82template <class T, class Context> struct MappingContextTraits {
83 // Must provide:
84 // static void mapping(IO &io, T &fields, Context &Ctx);
85 // Optionally may provide:
86 // static StringRef validate(IO &io, T &fields, Context &Ctx);
87 //
88 // The optional flow flag will cause generated YAML to use a flow mapping
89 // (e.g. { a: 0, b: 1 }):
90 // static const bool flow = true;
91};
92
93/// This class should be specialized by any integral type that converts
94/// to/from a YAML scalar where there is a one-to-one mapping between
95/// in-memory values and a string in YAML. For example:
96///
97/// struct ScalarEnumerationTraits<Colors> {
98/// static void enumeration(IO &io, Colors &value) {
99/// io.enumCase(value, "red", cRed);
100/// io.enumCase(value, "blue", cBlue);
101/// io.enumCase(value, "green", cGreen);
102/// }
103/// };
104template <typename T, typename Enable = void> struct ScalarEnumerationTraits {
105 // Must provide:
106 // static void enumeration(IO &io, T &value);
107};
108
109/// This class should be specialized by any integer type that is a union
110/// of bit values and the YAML representation is a flow sequence of
111/// strings. For example:
112///
113/// struct ScalarBitSetTraits<MyFlags> {
114/// static void bitset(IO &io, MyFlags &value) {
115/// io.bitSetCase(value, "big", flagBig);
116/// io.bitSetCase(value, "flat", flagFlat);
117/// io.bitSetCase(value, "round", flagRound);
118/// }
119/// };
120template <typename T, typename Enable = void> struct ScalarBitSetTraits {
121 // Must provide:
122 // static void bitset(IO &io, T &value);
123};
124
125/// Describe which type of quotes should be used when quoting is necessary.
126/// Some non-printable characters need to be double-quoted, while some others
127/// are fine with simple-quoting, and some don't need any quoting.
128enum class QuotingType { None, Single, Double };
129
130/// This class should be specialized by type that requires custom conversion
131/// to/from a yaml scalar. For example:
132///
133/// template<>
134/// struct ScalarTraits<MyType> {
135/// static void output(const MyType &val, void*, llvm::raw_ostream &out) {
136/// // stream out custom formatting
137/// out << llvm::format("%x", val);
138/// }
139/// static StringRef input(StringRef scalar, void*, MyType &value) {
140/// // parse scalar and set `value`
141/// // return empty string on success, or error string
142/// return StringRef();
143/// }
144/// static QuotingType mustQuote(StringRef) { return QuotingType::Single; }
145/// };
146template <typename T, typename Enable = void> struct ScalarTraits {
147 // Must provide:
148 //
149 // Function to write the value as a string:
150 // static void output(const T &value, void *ctxt, llvm::raw_ostream &out);
151 //
152 // Function to convert a string to a value. Returns the empty
153 // StringRef on success or an error string if string is malformed:
154 // static StringRef input(StringRef scalar, void *ctxt, T &value);
155 //
156 // Function to determine if the value should be quoted.
157 // static QuotingType mustQuote(StringRef);
158};
159
160/// This class should be specialized by type that requires custom conversion
161/// to/from a YAML literal block scalar. For example:
162///
163/// template <>
164/// struct BlockScalarTraits<MyType> {
165/// static void output(const MyType &Value, void*, llvm::raw_ostream &Out)
166/// {
167/// // stream out custom formatting
168/// Out << Value;
169/// }
170/// static StringRef input(StringRef Scalar, void*, MyType &Value) {
171/// // parse scalar and set `value`
172/// // return empty string on success, or error string
173/// return StringRef();
174/// }
175/// };
176template <typename T>
177struct BlockScalarTraits {
178 // Must provide:
179 //
180 // Function to write the value as a string:
181 // static void output(const T &Value, void *ctx, llvm::raw_ostream &Out);
182 //
183 // Function to convert a string to a value. Returns the empty
184 // StringRef on success or an error string if string is malformed:
185 // static StringRef input(StringRef Scalar, void *ctxt, T &Value);
186 //
187 // Optional:
188 // static StringRef inputTag(T &Val, std::string Tag)
189 // static void outputTag(const T &Val, raw_ostream &Out)
190};
191
192/// This class should be specialized by type that requires custom conversion
193/// to/from a YAML scalar with optional tags. For example:
194///
195/// template <>
196/// struct TaggedScalarTraits<MyType> {
197/// static void output(const MyType &Value, void*, llvm::raw_ostream
198/// &ScalarOut, llvm::raw_ostream &TagOut)
199/// {
200/// // stream out custom formatting including optional Tag
201/// Out << Value;
202/// }
203/// static StringRef input(StringRef Scalar, StringRef Tag, void*, MyType
204/// &Value) {
205/// // parse scalar and set `value`
206/// // return empty string on success, or error string
207/// return StringRef();
208/// }
209/// static QuotingType mustQuote(const MyType &Value, StringRef) {
210/// return QuotingType::Single;
211/// }
212/// };
213template <typename T> struct TaggedScalarTraits {
214 // Must provide:
215 //
216 // Function to write the value and tag as strings:
217 // static void output(const T &Value, void *ctx, llvm::raw_ostream &ScalarOut,
218 // llvm::raw_ostream &TagOut);
219 //
220 // Function to convert a string to a value. Returns the empty
221 // StringRef on success or an error string if string is malformed:
222 // static StringRef input(StringRef Scalar, StringRef Tag, void *ctxt, T
223 // &Value);
224 //
225 // Function to determine if the value should be quoted.
226 // static QuotingType mustQuote(const T &Value, StringRef Scalar);
227};
228
229/// This class should be specialized by any type that needs to be converted
230/// to/from a YAML sequence. For example:
231///
232/// template<>
233/// struct SequenceTraits<MyContainer> {
234/// static size_t size(IO &io, MyContainer &seq) {
235/// return seq.size();
236/// }
237/// static MyType& element(IO &, MyContainer &seq, size_t index) {
238/// if ( index >= seq.size() )
239/// seq.resize(index+1);
240/// return seq[index];
241/// }
242/// };
243template<typename T, typename EnableIf = void>
244struct SequenceTraits {
245 // Must provide:
246 // static size_t size(IO &io, T &seq);
247 // static T::value_type& element(IO &io, T &seq, size_t index);
248 //
249 // The following is option and will cause generated YAML to use
250 // a flow sequence (e.g. [a,b,c]).
251 // static const bool flow = true;
252};
253
254/// This class should be specialized by any type for which vectors of that
255/// type need to be converted to/from a YAML sequence.
256template<typename T, typename EnableIf = void>
257struct SequenceElementTraits {
258 // Must provide:
259 // static const bool flow;
260};
261
262/// This class should be specialized by any type that needs to be converted
263/// to/from a list of YAML documents.
264template<typename T>
265struct DocumentListTraits {
266 // Must provide:
267 // static size_t size(IO &io, T &seq);
268 // static T::value_type& element(IO &io, T &seq, size_t index);
269};
270
271/// This class should be specialized by any type that needs to be converted
272/// to/from a YAML mapping in the case where the names of the keys are not known
273/// in advance, e.g. a string map.
274template <typename T>
275struct CustomMappingTraits {
276 // static void inputOne(IO &io, StringRef key, T &elem);
277 // static void output(IO &io, T &elem);
278};
279
280/// This class should be specialized by any type that can be represented as
281/// a scalar, map, or sequence, decided dynamically. For example:
282///
283/// typedef std::unique_ptr<MyBase> MyPoly;
284///
285/// template<>
286/// struct PolymorphicTraits<MyPoly> {
287/// static NodeKind getKind(const MyPoly &poly) {
288/// return poly->getKind();
289/// }
290/// static MyScalar& getAsScalar(MyPoly &poly) {
291/// if (!poly || !isa<MyScalar>(poly))
292/// poly.reset(new MyScalar());
293/// return *cast<MyScalar>(poly.get());
294/// }
295/// // ...
296/// };
297template <typename T> struct PolymorphicTraits {
298 // Must provide:
299 // static NodeKind getKind(const T &poly);
300 // static scalar_type &getAsScalar(T &poly);
301 // static map_type &getAsMap(T &poly);
302 // static sequence_type &getAsSequence(T &poly);
303};
304
305// Only used for better diagnostics of missing traits
306template <typename T>
307struct MissingTrait;
308
309// Test if ScalarEnumerationTraits<T> is defined on type T.
310template <class T>
311struct has_ScalarEnumerationTraits
312{
313 using Signature_enumeration = void (*)(class IO&, T&);
314
315 template <typename U>
316 static char test(SameType<Signature_enumeration, &U::enumeration>*);
317
318 template <typename U>
319 static double test(...);
320
321 static bool const value =
322 (sizeof(test<ScalarEnumerationTraits<T>>(nullptr)) == 1);
323};
324
325// Test if ScalarBitSetTraits<T> is defined on type T.
326template <class T>
327struct has_ScalarBitSetTraits
328{
329 using Signature_bitset = void (*)(class IO&, T&);
330
331 template <typename U>
332 static char test(SameType<Signature_bitset, &U::bitset>*);
333
334 template <typename U>
335 static double test(...);
336
337 static bool const value = (sizeof(test<ScalarBitSetTraits<T>>(nullptr)) == 1);
338};
339
340// Test if ScalarTraits<T> is defined on type T.
341template <class T>
342struct has_ScalarTraits
343{
344 using Signature_input = StringRef (*)(StringRef, void*, T&);
345 using Signature_output = void (*)(const T&, void*, raw_ostream&);
346 using Signature_mustQuote = QuotingType (*)(StringRef);
347
348 template <typename U>
349 static char test(SameType<Signature_input, &U::input> *,
350 SameType<Signature_output, &U::output> *,
351 SameType<Signature_mustQuote, &U::mustQuote> *);
352
353 template <typename U>
354 static double test(...);
355
356 static bool const value =
357 (sizeof(test<ScalarTraits<T>>(nullptr, nullptr, nullptr)) == 1);
358};
359
360// Test if BlockScalarTraits<T> is defined on type T.
361template <class T>
362struct has_BlockScalarTraits
363{
364 using Signature_input = StringRef (*)(StringRef, void *, T &);
365 using Signature_output = void (*)(const T &, void *, raw_ostream &);
366
367 template <typename U>
368 static char test(SameType<Signature_input, &U::input> *,
369 SameType<Signature_output, &U::output> *);
370
371 template <typename U>
372 static double test(...);
373
374 static bool const value =
375 (sizeof(test<BlockScalarTraits<T>>(nullptr, nullptr)) == 1);
376};
377
378// Test if TaggedScalarTraits<T> is defined on type T.
379template <class T> struct has_TaggedScalarTraits {
380 using Signature_input = StringRef (*)(StringRef, StringRef, void *, T &);
381 using Signature_output = void (*)(const T &, void *, raw_ostream &,
382 raw_ostream &);
383 using Signature_mustQuote = QuotingType (*)(const T &, StringRef);
384
385 template <typename U>
386 static char test(SameType<Signature_input, &U::input> *,
387 SameType<Signature_output, &U::output> *,
388 SameType<Signature_mustQuote, &U::mustQuote> *);
389
390 template <typename U> static double test(...);
391
392 static bool const value =
393 (sizeof(test<TaggedScalarTraits<T>>(nullptr, nullptr, nullptr)) == 1);
394};
395
396// Test if MappingContextTraits<T> is defined on type T.
397template <class T, class Context> struct has_MappingTraits {
398 using Signature_mapping = void (*)(class IO &, T &, Context &);
399
400 template <typename U>
401 static char test(SameType<Signature_mapping, &U::mapping>*);
402
403 template <typename U>
404 static double test(...);
405
406 static bool const value =
407 (sizeof(test<MappingContextTraits<T, Context>>(nullptr)) == 1);
408};
409
410// Test if MappingTraits<T> is defined on type T.
411template <class T> struct has_MappingTraits<T, EmptyContext> {
412 using Signature_mapping = void (*)(class IO &, T &);
413
414 template <typename U>
415 static char test(SameType<Signature_mapping, &U::mapping> *);
416
417 template <typename U> static double test(...);
418
419 static bool const value = (sizeof(test<MappingTraits<T>>(nullptr)) == 1);
420};
421
422// Test if MappingContextTraits<T>::validate() is defined on type T.
423template <class T, class Context> struct has_MappingValidateTraits {
424 using Signature_validate = StringRef (*)(class IO &, T &, Context &);
425
426 template <typename U>
427 static char test(SameType<Signature_validate, &U::validate>*);
428
429 template <typename U>
430 static double test(...);
431
432 static bool const value =
433 (sizeof(test<MappingContextTraits<T, Context>>(nullptr)) == 1);
434};
435
436// Test if MappingTraits<T>::validate() is defined on type T.
437template <class T> struct has_MappingValidateTraits<T, EmptyContext> {
438 using Signature_validate = StringRef (*)(class IO &, T &);
439
440 template <typename U>
441 static char test(SameType<Signature_validate, &U::validate> *);
442
443 template <typename U> static double test(...);
444
445 static bool const value = (sizeof(test<MappingTraits<T>>(nullptr)) == 1);
446};
447
448// Test if SequenceTraits<T> is defined on type T.
449template <class T>
450struct has_SequenceMethodTraits
451{
452 using Signature_size = size_t (*)(class IO&, T&);
453
454 template <typename U>
455 static char test(SameType<Signature_size, &U::size>*);
456
457 template <typename U>
458 static double test(...);
459
460 static bool const value = (sizeof(test<SequenceTraits<T>>(nullptr)) == 1);
461};
462
463// Test if CustomMappingTraits<T> is defined on type T.
464template <class T>
465struct has_CustomMappingTraits
466{
467 using Signature_input = void (*)(IO &io, StringRef key, T &v);
468
469 template <typename U>
470 static char test(SameType<Signature_input, &U::inputOne>*);
471
472 template <typename U>
473 static double test(...);
474
475 static bool const value =
476 (sizeof(test<CustomMappingTraits<T>>(nullptr)) == 1);
477};
478
479// has_FlowTraits<int> will cause an error with some compilers because
480// it subclasses int. Using this wrapper only instantiates the
481// real has_FlowTraits only if the template type is a class.
482template <typename T, bool Enabled = std::is_class<T>::value>
483class has_FlowTraits
484{
485public:
486 static const bool value = false;
487};
488
489// Some older gcc compilers don't support straight forward tests
490// for members, so test for ambiguity cause by the base and derived
491// classes both defining the member.
492template <class T>
493struct has_FlowTraits<T, true>
494{
495 struct Fallback { bool flow; };
496 struct Derived : T, Fallback { };
497
498 template<typename C>
499 static char (&f(SameType<bool Fallback::*, &C::flow>*))[1];
500
501 template<typename C>
502 static char (&f(...))[2];
503
504 static bool const value = sizeof(f<Derived>(nullptr)) == 2;
505};
506
507// Test if SequenceTraits<T> is defined on type T
508template<typename T>
509struct has_SequenceTraits : public std::integral_constant<bool,
510 has_SequenceMethodTraits<T>::value > { };
511
512// Test if DocumentListTraits<T> is defined on type T
513template <class T>
514struct has_DocumentListTraits
515{
516 using Signature_size = size_t (*)(class IO &, T &);
517
518 template <typename U>
519 static char test(SameType<Signature_size, &U::size>*);
520
521 template <typename U>
522 static double test(...);
523
524 static bool const value = (sizeof(test<DocumentListTraits<T>>(nullptr))==1);
525};
526
527template <class T> struct has_PolymorphicTraits {
528 using Signature_getKind = NodeKind (*)(const T &);
529
530 template <typename U>
531 static char test(SameType<Signature_getKind, &U::getKind> *);
532
533 template <typename U> static double test(...);
534
535 static bool const value = (sizeof(test<PolymorphicTraits<T>>(nullptr)) == 1);
536};
537
538inline bool isNumeric(StringRef S) {
539 const static auto skipDigits = [](StringRef Input) {
540 return Input.drop_front(
541 std::min(Input.find_first_not_of("0123456789"), Input.size()));
542 };
543
544 // Make S.front() and S.drop_front().front() (if S.front() is [+-]) calls
545 // safe.
546 if (S.empty() || S.equals("+") || S.equals("-"))
547 return false;
548
549 if (S.equals(".nan") || S.equals(".NaN") || S.equals(".NAN"))
550 return true;
551
552 // Infinity and decimal numbers can be prefixed with sign.
553 StringRef Tail = (S.front() == '-' || S.front() == '+') ? S.drop_front() : S;
554
555 // Check for infinity first, because checking for hex and oct numbers is more
556 // expensive.
557 if (Tail.equals(".inf") || Tail.equals(".Inf") || Tail.equals(".INF"))
558 return true;
559
560 // Section 10.3.2 Tag Resolution
561 // YAML 1.2 Specification prohibits Base 8 and Base 16 numbers prefixed with
562 // [-+], so S should be used instead of Tail.
563 if (S.startswith("0o"))
564 return S.size() > 2 &&
565 S.drop_front(2).find_first_not_of("01234567") == StringRef::npos;
566
567 if (S.startswith("0x"))
568 return S.size() > 2 && S.drop_front(2).find_first_not_of(
569 "0123456789abcdefABCDEF") == StringRef::npos;
570
571 // Parse float: [-+]? (\. [0-9]+ | [0-9]+ (\. [0-9]* )?) ([eE] [-+]? [0-9]+)?
572 S = Tail;
573
574 // Handle cases when the number starts with '.' and hence needs at least one
575 // digit after dot (as opposed by number which has digits before the dot), but
576 // doesn't have one.
577 if (S.startswith(".") &&
578 (S.equals(".") ||
579 (S.size() > 1 && std::strchr("0123456789", S[1]) == nullptr)))
580 return false;
581
582 if (S.startswith("E") || S.startswith("e"))
583 return false;
584
585 enum ParseState {
586 Default,
587 FoundDot,
588 FoundExponent,
589 };
590 ParseState State = Default;
591
592 S = skipDigits(S);
593
594 // Accept decimal integer.
595 if (S.empty())
596 return true;
597
598 if (S.front() == '.') {
599 State = FoundDot;
600 S = S.drop_front();
601 } else if (S.front() == 'e' || S.front() == 'E') {
602 State = FoundExponent;
603 S = S.drop_front();
604 } else {
605 return false;
606 }
607
608 if (State == FoundDot) {
609 S = skipDigits(S);
610 if (S.empty())
611 return true;
612
613 if (S.front() == 'e' || S.front() == 'E') {
614 State = FoundExponent;
615 S = S.drop_front();
616 } else {
617 return false;
618 }
619 }
620
621 assert(State == FoundExponent && "Should have found exponent at this point.")((State == FoundExponent && "Should have found exponent at this point."
) ? static_cast<void> (0) : __assert_fail ("State == FoundExponent && \"Should have found exponent at this point.\""
, "/build/llvm-toolchain-snapshot-9~svn362543/include/llvm/Support/YAMLTraits.h"
, 621, __PRETTY_FUNCTION__))
;
622 if (S.empty())
623 return false;
624
625 if (S.front() == '+' || S.front() == '-') {
626 S = S.drop_front();
627 if (S.empty())
628 return false;
629 }
630
631 return skipDigits(S).empty();
632}
633
634inline bool isNull(StringRef S) {
635 return S.equals("null") || S.equals("Null") || S.equals("NULL") ||
636 S.equals("~");
637}
638
639inline bool isBool(StringRef S) {
640 return S.equals("true") || S.equals("True") || S.equals("TRUE") ||
641 S.equals("false") || S.equals("False") || S.equals("FALSE");
642}
643
644// 5.1. Character Set
645// The allowed character range explicitly excludes the C0 control block #x0-#x1F
646// (except for TAB #x9, LF #xA, and CR #xD which are allowed), DEL #x7F, the C1
647// control block #x80-#x9F (except for NEL #x85 which is allowed), the surrogate
648// block #xD800-#xDFFF, #xFFFE, and #xFFFF.
649inline QuotingType needsQuotes(StringRef S) {
650 if (S.empty())
651 return QuotingType::Single;
652 if (isspace(S.front()) || isspace(S.back()))
653 return QuotingType::Single;
654 if (isNull(S))
655 return QuotingType::Single;
656 if (isBool(S))
657 return QuotingType::Single;
658 if (isNumeric(S))
659 return QuotingType::Single;
660
661 // 7.3.3 Plain Style
662 // Plain scalars must not begin with most indicators, as this would cause
663 // ambiguity with other YAML constructs.
664 static constexpr char Indicators[] = R"(-?:\,[]{}#&*!|>'"%@`)";
665 if (S.find_first_of(Indicators) == 0)
666 return QuotingType::Single;
667
668 QuotingType MaxQuotingNeeded = QuotingType::None;
669 for (unsigned char C : S) {
670 // Alphanum is safe.
671 if (isAlnum(C))
672 continue;
673
674 switch (C) {
675 // Safe scalar characters.
676 case '_':
677 case '-':
678 case '^':
679 case '.':
680 case ',':
681 case ' ':
682 // TAB (0x9) is allowed in unquoted strings.
683 case 0x9:
684 continue;
685 // LF(0xA) and CR(0xD) may delimit values and so require at least single
686 // quotes.
687 case 0xA:
688 case 0xD:
689 MaxQuotingNeeded = QuotingType::Single;
690 continue;
691 // DEL (0x7F) are excluded from the allowed character range.
692 case 0x7F:
693 return QuotingType::Double;
694 // Forward slash is allowed to be unquoted, but we quote it anyway. We have
695 // many tests that use FileCheck against YAML output, and this output often
696 // contains paths. If we quote backslashes but not forward slashes then
697 // paths will come out either quoted or unquoted depending on which platform
698 // the test is run on, making FileCheck comparisons difficult.
699 case '/':
700 default: {
701 // C0 control block (0x0 - 0x1F) is excluded from the allowed character
702 // range.
703 if (C <= 0x1F)
704 return QuotingType::Double;
705
706 // Always double quote UTF-8.
707 if ((C & 0x80) != 0)
708 return QuotingType::Double;
709
710 // The character is not safe, at least simple quoting needed.
711 MaxQuotingNeeded = QuotingType::Single;
712 }
713 }
714 }
715
716 return MaxQuotingNeeded;
717}
718
719template <typename T, typename Context>
720struct missingTraits
721 : public std::integral_constant<bool,
722 !has_ScalarEnumerationTraits<T>::value &&
723 !has_ScalarBitSetTraits<T>::value &&
724 !has_ScalarTraits<T>::value &&
725 !has_BlockScalarTraits<T>::value &&
726 !has_TaggedScalarTraits<T>::value &&
727 !has_MappingTraits<T, Context>::value &&
728 !has_SequenceTraits<T>::value &&
729 !has_CustomMappingTraits<T>::value &&
730 !has_DocumentListTraits<T>::value &&
731 !has_PolymorphicTraits<T>::value> {};
732
733template <typename T, typename Context>
734struct validatedMappingTraits
735 : public std::integral_constant<
736 bool, has_MappingTraits<T, Context>::value &&
737 has_MappingValidateTraits<T, Context>::value> {};
738
739template <typename T, typename Context>
740struct unvalidatedMappingTraits
741 : public std::integral_constant<
742 bool, has_MappingTraits<T, Context>::value &&
743 !has_MappingValidateTraits<T, Context>::value> {};
744
745// Base class for Input and Output.
746class IO {
747public:
748 IO(void *Ctxt = nullptr);
749 virtual ~IO();
750
751 virtual bool outputting() = 0;
752
753 virtual unsigned beginSequence() = 0;
754 virtual bool preflightElement(unsigned, void *&) = 0;
755 virtual void postflightElement(void*) = 0;
756 virtual void endSequence() = 0;
757 virtual bool canElideEmptySequence() = 0;
758
759 virtual unsigned beginFlowSequence() = 0;
760 virtual bool preflightFlowElement(unsigned, void *&) = 0;
761 virtual void postflightFlowElement(void*) = 0;
762 virtual void endFlowSequence() = 0;
763
764 virtual bool mapTag(StringRef Tag, bool Default=false) = 0;
765 virtual void beginMapping() = 0;
766 virtual void endMapping() = 0;
767 virtual bool preflightKey(const char*, bool, bool, bool &, void *&) = 0;
768 virtual void postflightKey(void*) = 0;
769 virtual std::vector<StringRef> keys() = 0;
770
771 virtual void beginFlowMapping() = 0;
772 virtual void endFlowMapping() = 0;
773
774 virtual void beginEnumScalar() = 0;
775 virtual bool matchEnumScalar(const char*, bool) = 0;
776 virtual bool matchEnumFallback() = 0;
777 virtual void endEnumScalar() = 0;
778
779 virtual bool beginBitSetScalar(bool &) = 0;
780 virtual bool bitSetMatch(const char*, bool) = 0;
781 virtual void endBitSetScalar() = 0;
782
783 virtual void scalarString(StringRef &, QuotingType) = 0;
784 virtual void blockScalarString(StringRef &) = 0;
785 virtual void scalarTag(std::string &) = 0;
786
787 virtual NodeKind getNodeKind() = 0;
788
789 virtual void setError(const Twine &) = 0;
790
791 template <typename T>
792 void enumCase(T &Val, const char* Str, const T ConstVal) {
793 if ( matchEnumScalar(Str, outputting() && Val == ConstVal) ) {
794 Val = ConstVal;
795 }
796 }
797
798 // allow anonymous enum values to be used with LLVM_YAML_STRONG_TYPEDEF
799 template <typename T>
800 void enumCase(T &Val, const char* Str, const uint32_t ConstVal) {
801 if ( matchEnumScalar(Str, outputting() && Val == static_cast<T>(ConstVal)) ) {
15
Assuming the condition is false
16
Assuming the condition is false
17
Taking false branch
21
Assuming the condition is false
22
Assuming the condition is false
23
Taking false branch
27
Assuming the condition is false
28
Assuming the condition is false
29
Taking false branch
33
Assuming the condition is false
34
Assuming the condition is false
35
Taking false branch
39
Assuming the condition is false
40
Assuming the condition is false
41
Taking false branch
45
Assuming the condition is false
46
Assuming the condition is false
47
Taking false branch
51
Assuming the condition is false
52
Assuming the condition is false
53
Taking false branch
57
Assuming the condition is false
58
Assuming the condition is false
59
Taking false branch
63
Assuming the condition is false
64
Assuming the condition is false
65
Taking false branch
69
Assuming the condition is false
70
Assuming the condition is false
71
Taking false branch
75
Assuming the condition is false
76
Assuming the condition is false
77
Taking false branch
81
Assuming the condition is false
82
Assuming the condition is false
83
Taking false branch
87
Assuming the condition is false
88
Assuming the condition is false
89
Taking false branch
93
Assuming the condition is false
94
Assuming the condition is false
95
Taking false branch
99
Assuming the condition is false
100
Assuming the condition is false
101
Taking false branch
105
Assuming the condition is false
106
Assuming the condition is false
107
Taking false branch
111
Assuming the condition is false
112
Assuming the condition is false
113
Taking false branch
117
Assuming the condition is false
118
Assuming the condition is false
119
Taking false branch
123
Assuming the condition is false
124
Assuming the condition is false
125
Taking false branch
129
Assuming the condition is false
130
Assuming the condition is false
131
Taking false branch
135
Assuming the condition is false
136
Assuming the condition is false
137
Taking false branch
141
Assuming the condition is false
142
Assuming the condition is false
143
Taking false branch
147
Assuming the condition is false
148
Assuming the condition is false
149
Taking false branch
153
Assuming the condition is false
154
Assuming the condition is false
155
Taking false branch
159
Assuming the condition is false
160
Assuming the condition is false
161
Taking false branch
165
Assuming the condition is false
166
Assuming the condition is false
167
Taking false branch
171
Assuming the condition is false
172
Assuming the condition is false
173
Taking false branch
177
Assuming the condition is false
178
Assuming the condition is false
179
Taking false branch
183
Assuming the condition is false
184
Assuming the condition is false
185
Taking false branch
189
Assuming the condition is false
190
Assuming the condition is false
191
Taking false branch
195
Assuming the condition is false
196
Assuming the condition is false
197
Taking false branch
802 Val = ConstVal;
803 }
804 }
18
Returning without writing to 'Val.value'
24
Returning without writing to 'Val.value'
30
Returning without writing to 'Val.value'
36
Returning without writing to 'Val.value'
42
Returning without writing to 'Val.value'
48
Returning without writing to 'Val.value'
54
Returning without writing to 'Val.value'
60
Returning without writing to 'Val.value'
66
Returning without writing to 'Val.value'
72
Returning without writing to 'Val.value'
78
Returning without writing to 'Val.value'
84
Returning without writing to 'Val.value'
90
Returning without writing to 'Val.value'
96
Returning without writing to 'Val.value'
102
Returning without writing to 'Val.value'
108
Returning without writing to 'Val.value'
114
Returning without writing to 'Val.value'
120
Returning without writing to 'Val.value'
126
Returning without writing to 'Val.value'
132
Returning without writing to 'Val.value'
138
Returning without writing to 'Val.value'
144
Returning without writing to 'Val.value'
150
Returning without writing to 'Val.value'
156
Returning without writing to 'Val.value'
162
Returning without writing to 'Val.value'
168
Returning without writing to 'Val.value'
174
Returning without writing to 'Val.value'
180
Returning without writing to 'Val.value'
186
Returning without writing to 'Val.value'
192
Returning without writing to 'Val.value'
198
Returning without writing to 'Val.value'
805
806 template <typename FBT, typename T>
807 void enumFallback(T &Val) {
808 if (matchEnumFallback()) {
203
Assuming the condition is true
204
Taking true branch
809 EmptyContext Context;
810 // FIXME: Force integral conversion to allow strong typedefs to convert.
811 FBT Res = static_cast<typename FBT::BaseType>(Val);
205
Calling 'ELF_SHT::operator const unsigned int &'
207
Returning from 'ELF_SHT::operator const unsigned int &'
208
1st function call argument is an uninitialized value
812 yamlize(*this, Res, true, Context);
813 Val = static_cast<T>(static_cast<typename FBT::BaseType>(Res));
814 }
815 }
816
817 template <typename T>
818 void bitSetCase(T &Val, const char* Str, const T ConstVal) {
819 if ( bitSetMatch(Str, outputting() && (Val & ConstVal) == ConstVal) ) {
820 Val = static_cast<T>(Val | ConstVal);
821 }
822 }
823
824 // allow anonymous enum values to be used with LLVM_YAML_STRONG_TYPEDEF
825 template <typename T>
826 void bitSetCase(T &Val, const char* Str, const uint32_t ConstVal) {
827 if ( bitSetMatch(Str, outputting() && (Val & ConstVal) == ConstVal) ) {
828 Val = static_cast<T>(Val | ConstVal);
829 }
830 }
831
832 template <typename T>
833 void maskedBitSetCase(T &Val, const char *Str, T ConstVal, T Mask) {
834 if (bitSetMatch(Str, outputting() && (Val & Mask) == ConstVal))
835 Val = Val | ConstVal;
836 }
837
838 template <typename T>
839 void maskedBitSetCase(T &Val, const char *Str, uint32_t ConstVal,
840 uint32_t Mask) {
841 if (bitSetMatch(Str, outputting() && (Val & Mask) == ConstVal))
842 Val = Val | ConstVal;
843 }
844
845 void *getContext();
846 void setContext(void *);
847
848 template <typename T> void mapRequired(const char *Key, T &Val) {
849 EmptyContext Ctx;
850 this->processKey(Key, Val, true, Ctx);
7
Calling 'IO::processKey'
851 }
852
853 template <typename T, typename Context>
854 void mapRequired(const char *Key, T &Val, Context &Ctx) {
855 this->processKey(Key, Val, true, Ctx);
856 }
857
858 template <typename T> void mapOptional(const char *Key, T &Val) {
859 EmptyContext Ctx;
860 mapOptionalWithContext(Key, Val, Ctx);
861 }
862
863 template <typename T, typename DefaultT>
864 void mapOptional(const char *Key, T &Val, const DefaultT &Default) {
865 EmptyContext Ctx;
866 mapOptionalWithContext(Key, Val, Default, Ctx);
867 }
868
869 template <typename T, typename Context>
870 typename std::enable_if<has_SequenceTraits<T>::value, void>::type
871 mapOptionalWithContext(const char *Key, T &Val, Context &Ctx) {
872 // omit key/value instead of outputting empty sequence
873 if (this->canElideEmptySequence() && !(Val.begin() != Val.end()))
874 return;
875 this->processKey(Key, Val, false, Ctx);
876 }
877
878 template <typename T, typename Context>
879 void mapOptionalWithContext(const char *Key, Optional<T> &Val, Context &Ctx) {
880 this->processKeyWithDefault(Key, Val, Optional<T>(), /*Required=*/false,
881 Ctx);
882 }
883
884 template <typename T, typename Context>
885 typename std::enable_if<!has_SequenceTraits<T>::value, void>::type
886 mapOptionalWithContext(const char *Key, T &Val, Context &Ctx) {
887 this->processKey(Key, Val, false, Ctx);
888 }
889
890 template <typename T, typename Context, typename DefaultT>
891 void mapOptionalWithContext(const char *Key, T &Val, const DefaultT &Default,
892 Context &Ctx) {
893 static_assert(std::is_convertible<DefaultT, T>::value,
894 "Default type must be implicitly convertible to value type!");
895 this->processKeyWithDefault(Key, Val, static_cast<const T &>(Default),
896 false, Ctx);
897 }
898
899private:
900 template <typename T, typename Context>
901 void processKeyWithDefault(const char *Key, Optional<T> &Val,
902 const Optional<T> &DefaultValue, bool Required,
903 Context &Ctx) {
904 assert(DefaultValue.hasValue() == false &&((DefaultValue.hasValue() == false && "Optional<T> shouldn't have a value!"
) ? static_cast<void> (0) : __assert_fail ("DefaultValue.hasValue() == false && \"Optional<T> shouldn't have a value!\""
, "/build/llvm-toolchain-snapshot-9~svn362543/include/llvm/Support/YAMLTraits.h"
, 905, __PRETTY_FUNCTION__))
905 "Optional<T> shouldn't have a value!")((DefaultValue.hasValue() == false && "Optional<T> shouldn't have a value!"
) ? static_cast<void> (0) : __assert_fail ("DefaultValue.hasValue() == false && \"Optional<T> shouldn't have a value!\""
, "/build/llvm-toolchain-snapshot-9~svn362543/include/llvm/Support/YAMLTraits.h"
, 905, __PRETTY_FUNCTION__))
;
906 void *SaveInfo;
907 bool UseDefault = true;
908 const bool sameAsDefault = outputting() && !Val.hasValue();
909 if (!outputting() && !Val.hasValue())
910 Val = T();
911 if (Val.hasValue() &&
912 this->preflightKey(Key, Required, sameAsDefault, UseDefault,
913 SaveInfo)) {
914 yamlize(*this, Val.getValue(), Required, Ctx);
915 this->postflightKey(SaveInfo);
916 } else {
917 if (UseDefault)
918 Val = DefaultValue;
919 }
920 }
921
922 template <typename T, typename Context>
923 void processKeyWithDefault(const char *Key, T &Val, const T &DefaultValue,
924 bool Required, Context &Ctx) {
925 void *SaveInfo;
926 bool UseDefault;
927 const bool sameAsDefault = outputting() && Val == DefaultValue;
928 if ( this->preflightKey(Key, Required, sameAsDefault, UseDefault,
929 SaveInfo) ) {
930 yamlize(*this, Val, Required, Ctx);
931 this->postflightKey(SaveInfo);
932 }
933 else {
934 if ( UseDefault )
935 Val = DefaultValue;
936 }
937 }
938
939 template <typename T, typename Context>
940 void processKey(const char *Key, T &Val, bool Required, Context &Ctx) {
941 void *SaveInfo;
942 bool UseDefault;
943 if ( this->preflightKey(Key, Required, false, UseDefault, SaveInfo) ) {
8
Assuming the condition is true
9
Taking true branch
944 yamlize(*this, Val, Required, Ctx);
10
Calling 'yamlize<llvm::ELFYAML::ELF_SHT>'
945 this->postflightKey(SaveInfo);
946 }
947 }
948
949private:
950 void *Ctxt;
951};
952
953namespace detail {
954
955template <typename T, typename Context>
956void doMapping(IO &io, T &Val, Context &Ctx) {
957 MappingContextTraits<T, Context>::mapping(io, Val, Ctx);
958}
959
960template <typename T> void doMapping(IO &io, T &Val, EmptyContext &Ctx) {
961 MappingTraits<T>::mapping(io, Val);
962}
963
964} // end namespace detail
965
966template <typename T>
967typename std::enable_if<has_ScalarEnumerationTraits<T>::value, void>::type
968yamlize(IO &io, T &Val, bool, EmptyContext &Ctx) {
969 io.beginEnumScalar();
970 ScalarEnumerationTraits<T>::enumeration(io, Val);
11
Calling 'ScalarEnumerationTraits::enumeration'
971 io.endEnumScalar();
972}
973
974template <typename T>
975typename std::enable_if<has_ScalarBitSetTraits<T>::value, void>::type
976yamlize(IO &io, T &Val, bool, EmptyContext &Ctx) {
977 bool DoClear;
978 if ( io.beginBitSetScalar(DoClear) ) {
979 if ( DoClear )
980 Val = T();
981 ScalarBitSetTraits<T>::bitset(io, Val);
982 io.endBitSetScalar();
983 }
984}
985
986template <typename T>
987typename std::enable_if<has_ScalarTraits<T>::value, void>::type
988yamlize(IO &io, T &Val, bool, EmptyContext &Ctx) {
989 if ( io.outputting() ) {
990 std::string Storage;
991 raw_string_ostream Buffer(Storage);
992 ScalarTraits<T>::output(Val, io.getContext(), Buffer);
993 StringRef Str = Buffer.str();
994 io.scalarString(Str, ScalarTraits<T>::mustQuote(Str));
995 }
996 else {
997 StringRef Str;
998 io.scalarString(Str, ScalarTraits<T>::mustQuote(Str));
999 StringRef Result = ScalarTraits<T>::input(Str, io.getContext(), Val);
1000 if ( !Result.empty() ) {
1001 io.setError(Twine(Result));
1002 }
1003 }
1004}
1005
1006template <typename T>
1007typename std::enable_if<has_BlockScalarTraits<T>::value, void>::type
1008yamlize(IO &YamlIO, T &Val, bool, EmptyContext &Ctx) {
1009 if (YamlIO.outputting()) {
1010 std::string Storage;
1011 raw_string_ostream Buffer(Storage);
1012 BlockScalarTraits<T>::output(Val, YamlIO.getContext(), Buffer);
1013 StringRef Str = Buffer.str();
1014 YamlIO.blockScalarString(Str);
1015 } else {
1016 StringRef Str;
1017 YamlIO.blockScalarString(Str);
1018 StringRef Result =
1019 BlockScalarTraits<T>::input(Str, YamlIO.getContext(), Val);
1020 if (!Result.empty())
1021 YamlIO.setError(Twine(Result));
1022 }
1023}
1024
1025template <typename T>
1026typename std::enable_if<has_TaggedScalarTraits<T>::value, void>::type
1027yamlize(IO &io, T &Val, bool, EmptyContext &Ctx) {
1028 if (io.outputting()) {
1029 std::string ScalarStorage, TagStorage;
1030 raw_string_ostream ScalarBuffer(ScalarStorage), TagBuffer(TagStorage);
1031 TaggedScalarTraits<T>::output(Val, io.getContext(), ScalarBuffer,
1032 TagBuffer);
1033 io.scalarTag(TagBuffer.str());
1034 StringRef ScalarStr = ScalarBuffer.str();
1035 io.scalarString(ScalarStr,
1036 TaggedScalarTraits<T>::mustQuote(Val, ScalarStr));
1037 } else {
1038 std::string Tag;
1039 io.scalarTag(Tag);
1040 StringRef Str;
1041 io.scalarString(Str, QuotingType::None);
1042 StringRef Result =
1043 TaggedScalarTraits<T>::input(Str, Tag, io.getContext(), Val);
1044 if (!Result.empty()) {
1045 io.setError(Twine(Result));
1046 }
1047 }
1048}
1049
1050template <typename T, typename Context>
1051typename std::enable_if<validatedMappingTraits<T, Context>::value, void>::type
1052yamlize(IO &io, T &Val, bool, Context &Ctx) {
1053 if (has_FlowTraits<MappingTraits<T>>::value)
1054 io.beginFlowMapping();
1055 else
1056 io.beginMapping();
1057 if (io.outputting()) {
1058 StringRef Err = MappingTraits<T>::validate(io, Val);
1059 if (!Err.empty()) {
1060 errs() << Err << "\n";
1061 assert(Err.empty() && "invalid struct trying to be written as yaml")((Err.empty() && "invalid struct trying to be written as yaml"
) ? static_cast<void> (0) : __assert_fail ("Err.empty() && \"invalid struct trying to be written as yaml\""
, "/build/llvm-toolchain-snapshot-9~svn362543/include/llvm/Support/YAMLTraits.h"
, 1061, __PRETTY_FUNCTION__))
;
1062 }
1063 }
1064 detail::doMapping(io, Val, Ctx);
1065 if (!io.outputting()) {
1066 StringRef Err = MappingTraits<T>::validate(io, Val);
1067 if (!Err.empty())
1068 io.setError(Err);
1069 }
1070 if (has_FlowTraits<MappingTraits<T>>::value)
1071 io.endFlowMapping();
1072 else
1073 io.endMapping();
1074}
1075
1076template <typename T, typename Context>
1077typename std::enable_if<unvalidatedMappingTraits<T, Context>::value, void>::type
1078yamlize(IO &io, T &Val, bool, Context &Ctx) {
1079 if (has_FlowTraits<MappingTraits<T>>::value) {
1080 io.beginFlowMapping();
1081 detail::doMapping(io, Val, Ctx);
1082 io.endFlowMapping();
1083 } else {
1084 io.beginMapping();
1085 detail::doMapping(io, Val, Ctx);
1086 io.endMapping();
1087 }
1088}
1089
1090template <typename T>
1091typename std::enable_if<has_CustomMappingTraits<T>::value, void>::type
1092yamlize(IO &io, T &Val, bool, EmptyContext &Ctx) {
1093 if ( io.outputting() ) {
1094 io.beginMapping();
1095 CustomMappingTraits<T>::output(io, Val);
1096 io.endMapping();
1097 } else {
1098 io.beginMapping();
1099 for (StringRef key : io.keys())
1100 CustomMappingTraits<T>::inputOne(io, key, Val);
1101 io.endMapping();
1102 }
1103}
1104
1105template <typename T>
1106typename std::enable_if<has_PolymorphicTraits<T>::value, void>::type
1107yamlize(IO &io, T &Val, bool, EmptyContext &Ctx) {
1108 switch (io.outputting() ? PolymorphicTraits<T>::getKind(Val)
1109 : io.getNodeKind()) {
1110 case NodeKind::Scalar:
1111 return yamlize(io, PolymorphicTraits<T>::getAsScalar(Val), true, Ctx);
1112 case NodeKind::Map:
1113 return yamlize(io, PolymorphicTraits<T>::getAsMap(Val), true, Ctx);
1114 case NodeKind::Sequence:
1115 return yamlize(io, PolymorphicTraits<T>::getAsSequence(Val), true, Ctx);
1116 }
1117}
1118
1119template <typename T>
1120typename std::enable_if<missingTraits<T, EmptyContext>::value, void>::type
1121yamlize(IO &io, T &Val, bool, EmptyContext &Ctx) {
1122 char missing_yaml_trait_for_type[sizeof(MissingTrait<T>)];
1123}
1124
1125template <typename T, typename Context>
1126typename std::enable_if<has_SequenceTraits<T>::value, void>::type
1127yamlize(IO &io, T &Seq, bool, Context &Ctx) {
1128 if ( has_FlowTraits< SequenceTraits<T>>::value ) {
1129 unsigned incnt = io.beginFlowSequence();
1130 unsigned count = io.outputting() ? SequenceTraits<T>::size(io, Seq) : incnt;
1131 for(unsigned i=0; i < count; ++i) {
1132 void *SaveInfo;
1133 if ( io.preflightFlowElement(i, SaveInfo) ) {
1134 yamlize(io, SequenceTraits<T>::element(io, Seq, i), true, Ctx);
1135 io.postflightFlowElement(SaveInfo);
1136 }
1137 }
1138 io.endFlowSequence();
1139 }
1140 else {
1141 unsigned incnt = io.beginSequence();
1142 unsigned count = io.outputting() ? SequenceTraits<T>::size(io, Seq) : incnt;
1143 for(unsigned i=0; i < count; ++i) {
1144 void *SaveInfo;
1145 if ( io.preflightElement(i, SaveInfo) ) {
1146 yamlize(io, SequenceTraits<T>::element(io, Seq, i), true, Ctx);
1147 io.postflightElement(SaveInfo);
1148 }
1149 }
1150 io.endSequence();
1151 }
1152}
1153
1154template<>
1155struct ScalarTraits<bool> {
1156 static void output(const bool &, void* , raw_ostream &);
1157 static StringRef input(StringRef, void *, bool &);
1158 static QuotingType mustQuote(StringRef) { return QuotingType::None; }
1159};
1160
1161template<>
1162struct ScalarTraits<StringRef> {
1163 static void output(const StringRef &, void *, raw_ostream &);
1164 static StringRef input(StringRef, void *, StringRef &);
1165 static QuotingType mustQuote(StringRef S) { return needsQuotes(S); }
1166};
1167
1168template<>
1169struct ScalarTraits<std::string> {
1170 static void output(const std::string &, void *, raw_ostream &);
1171 static StringRef input(StringRef, void *, std::string &);
1172 static QuotingType mustQuote(StringRef S) { return needsQuotes(S); }
1173};
1174
1175template<>
1176struct ScalarTraits<uint8_t> {
1177 static void output(const uint8_t &, void *, raw_ostream &);
1178 static StringRef input(StringRef, void *, uint8_t &);
1179 static QuotingType mustQuote(StringRef) { return QuotingType::None; }
1180};
1181
1182template<>
1183struct ScalarTraits<uint16_t> {
1184 static void output(const uint16_t &, void *, raw_ostream &);
1185 static StringRef input(StringRef, void *, uint16_t &);
1186 static QuotingType mustQuote(StringRef) { return QuotingType::None; }
1187};
1188
1189template<>
1190struct ScalarTraits<uint32_t> {
1191 static void output(const uint32_t &, void *, raw_ostream &);
1192 static StringRef input(StringRef, void *, uint32_t &);
1193 static QuotingType mustQuote(StringRef) { return QuotingType::None; }
1194};
1195
1196template<>
1197struct ScalarTraits<uint64_t> {
1198 static void output(const uint64_t &, void *, raw_ostream &);
1199 static StringRef input(StringRef, void *, uint64_t &);
1200 static QuotingType mustQuote(StringRef) { return QuotingType::None; }
1201};
1202
1203template<>
1204struct ScalarTraits<int8_t> {
1205 static void output(const int8_t &, void *, raw_ostream &);
1206 static StringRef input(StringRef, void *, int8_t &);
1207 static QuotingType mustQuote(StringRef) { return QuotingType::None; }
1208};
1209
1210template<>
1211struct ScalarTraits<int16_t> {
1212 static void output(const int16_t &, void *, raw_ostream &);
1213 static StringRef input(StringRef, void *, int16_t &);
1214 static QuotingType mustQuote(StringRef) { return QuotingType::None; }
1215};
1216
1217template<>
1218struct ScalarTraits<int32_t> {
1219 static void output(const int32_t &, void *, raw_ostream &);
1220 static StringRef input(StringRef, void *, int32_t &);
1221 static QuotingType mustQuote(StringRef) { return QuotingType::None; }
1222};
1223
1224template<>
1225struct ScalarTraits<int64_t> {
1226 static void output(const int64_t &, void *, raw_ostream &);
1227 static StringRef input(StringRef, void *, int64_t &);
1228 static QuotingType mustQuote(StringRef) { return QuotingType::None; }
1229};
1230
1231template<>
1232struct ScalarTraits<float> {
1233 static void output(const float &, void *, raw_ostream &);
1234 static StringRef input(StringRef, void *, float &);
1235 static QuotingType mustQuote(StringRef) { return QuotingType::None; }
1236};
1237
1238template<>
1239struct ScalarTraits<double> {
1240 static void output(const double &, void *, raw_ostream &);
1241 static StringRef input(StringRef, void *, double &);
1242 static QuotingType mustQuote(StringRef) { return QuotingType::None; }
1243};
1244
1245// For endian types, we use existing scalar Traits class for the underlying
1246// type. This way endian aware types are supported whenever the traits are
1247// defined for the underlying type.
1248template <typename value_type, support::endianness endian, size_t alignment>
1249struct ScalarTraits<
1250 support::detail::packed_endian_specific_integral<value_type, endian,
1251 alignment>,
1252 typename std::enable_if<has_ScalarTraits<value_type>::value>::type> {
1253 using endian_type =
1254 support::detail::packed_endian_specific_integral<value_type, endian,
1255 alignment>;
1256
1257 static void output(const endian_type &E, void *Ctx, raw_ostream &Stream) {
1258 ScalarTraits<value_type>::output(static_cast<value_type>(E), Ctx, Stream);
1259 }
1260
1261 static StringRef input(StringRef Str, void *Ctx, endian_type &E) {
1262 value_type V;
1263 auto R = ScalarTraits<value_type>::input(Str, Ctx, V);
1264 E = static_cast<endian_type>(V);
1265 return R;
1266 }
1267
1268 static QuotingType mustQuote(StringRef Str) {
1269 return ScalarTraits<value_type>::mustQuote(Str);
1270 }
1271};
1272
1273template <typename value_type, support::endianness endian, size_t alignment>
1274struct ScalarEnumerationTraits<
1275 support::detail::packed_endian_specific_integral<value_type, endian,
1276 alignment>,
1277 typename std::enable_if<
1278 has_ScalarEnumerationTraits<value_type>::value>::type> {
1279 using endian_type =
1280 support::detail::packed_endian_specific_integral<value_type, endian,
1281 alignment>;
1282
1283 static void enumeration(IO &io, endian_type &E) {
1284 value_type V = E;
1285 ScalarEnumerationTraits<value_type>::enumeration(io, V);
1286 E = V;
1287 }
1288};
1289
1290template <typename value_type, support::endianness endian, size_t alignment>
1291struct ScalarBitSetTraits<
1292 support::detail::packed_endian_specific_integral<value_type, endian,
1293 alignment>,
1294 typename std::enable_if<has_ScalarBitSetTraits<value_type>::value>::type> {
1295 using endian_type =
1296 support::detail::packed_endian_specific_integral<value_type, endian,
1297 alignment>;
1298 static void bitset(IO &io, endian_type &E) {
1299 value_type V = E;
1300 ScalarBitSetTraits<value_type>::bitset(io, V);
1301 E = V;
1302 }
1303};
1304
1305// Utility for use within MappingTraits<>::mapping() method
1306// to [de]normalize an object for use with YAML conversion.
1307template <typename TNorm, typename TFinal>
1308struct MappingNormalization {
1309 MappingNormalization(IO &i_o, TFinal &Obj)
1310 : io(i_o), BufPtr(nullptr), Result(Obj) {
1311 if ( io.outputting() ) {
1312 BufPtr = new (&Buffer) TNorm(io, Obj);
1313 }
1314 else {
1315 BufPtr = new (&Buffer) TNorm(io);
1316 }
1317 }
1318
1319 ~MappingNormalization() {
1320 if ( ! io.outputting() ) {
1321 Result = BufPtr->denormalize(io);
1322 }
1323 BufPtr->~TNorm();
1324 }
1325
1326 TNorm* operator->() { return BufPtr; }
1327
1328private:
1329 using Storage = AlignedCharArrayUnion<TNorm>;
1330
1331 Storage Buffer;
1332 IO &io;
1333 TNorm *BufPtr;
1334 TFinal &Result;
1335};
1336
1337// Utility for use within MappingTraits<>::mapping() method
1338// to [de]normalize an object for use with YAML conversion.
1339template <typename TNorm, typename TFinal>
1340struct MappingNormalizationHeap {
1341 MappingNormalizationHeap(IO &i_o, TFinal &Obj, BumpPtrAllocator *allocator)
1342 : io(i_o), Result(Obj) {
1343 if ( io.outputting() ) {
1344 BufPtr = new (&Buffer) TNorm(io, Obj);
1345 }
1346 else if (allocator) {
1347 BufPtr = allocator->Allocate<TNorm>();
1348 new (BufPtr) TNorm(io);
1349 } else {
1350 BufPtr = new TNorm(io);
1351 }
1352 }
1353
1354 ~MappingNormalizationHeap() {
1355 if ( io.outputting() ) {
1356 BufPtr->~TNorm();
1357 }
1358 else {
1359 Result = BufPtr->denormalize(io);
1360 }
1361 }
1362
1363 TNorm* operator->() { return BufPtr; }
1364
1365private:
1366 using Storage = AlignedCharArrayUnion<TNorm>;
1367
1368 Storage Buffer;
1369 IO &io;
1370 TNorm *BufPtr = nullptr;
1371 TFinal &Result;
1372};
1373
1374///
1375/// The Input class is used to parse a yaml document into in-memory structs
1376/// and vectors.
1377///
1378/// It works by using YAMLParser to do a syntax parse of the entire yaml
1379/// document, then the Input class builds a graph of HNodes which wraps
1380/// each yaml Node. The extra layer is buffering. The low level yaml
1381/// parser only lets you look at each node once. The buffering layer lets
1382/// you search and interate multiple times. This is necessary because
1383/// the mapRequired() method calls may not be in the same order
1384/// as the keys in the document.
1385///
1386class Input : public IO {
1387public:
1388 // Construct a yaml Input object from a StringRef and optional
1389 // user-data. The DiagHandler can be specified to provide
1390 // alternative error reporting.
1391 Input(StringRef InputContent,
1392 void *Ctxt = nullptr,
1393 SourceMgr::DiagHandlerTy DiagHandler = nullptr,
1394 void *DiagHandlerCtxt = nullptr);
1395 Input(MemoryBufferRef Input,
1396 void *Ctxt = nullptr,
1397 SourceMgr::DiagHandlerTy DiagHandler = nullptr,
1398 void *DiagHandlerCtxt = nullptr);
1399 ~Input() override;
1400
1401 // Check if there was an syntax or semantic error during parsing.
1402 std::error_code error();
1403
1404private:
1405 bool outputting() override;
1406 bool mapTag(StringRef, bool) override;
1407 void beginMapping() override;
1408 void endMapping() override;
1409 bool preflightKey(const char *, bool, bool, bool &, void *&) override;
1410 void postflightKey(void *) override;
1411 std::vector<StringRef> keys() override;
1412 void beginFlowMapping() override;
1413 void endFlowMapping() override;
1414 unsigned beginSequence() override;
1415 void endSequence() override;
1416 bool preflightElement(unsigned index, void *&) override;
1417 void postflightElement(void *) override;
1418 unsigned beginFlowSequence() override;
1419 bool preflightFlowElement(unsigned , void *&) override;
1420 void postflightFlowElement(void *) override;
1421 void endFlowSequence() override;
1422 void beginEnumScalar() override;
1423 bool matchEnumScalar(const char*, bool) override;
1424 bool matchEnumFallback() override;
1425 void endEnumScalar() override;
1426 bool beginBitSetScalar(bool &) override;
1427 bool bitSetMatch(const char *, bool ) override;
1428 void endBitSetScalar() override;
1429 void scalarString(StringRef &, QuotingType) override;
1430 void blockScalarString(StringRef &) override;
1431 void scalarTag(std::string &) override;
1432 NodeKind getNodeKind() override;
1433 void setError(const Twine &message) override;
1434 bool canElideEmptySequence() override;
1435
1436 class HNode {
1437 virtual void anchor();
1438
1439 public:
1440 HNode(Node *n) : _node(n) { }
1441 virtual ~HNode() = default;
1442
1443 static bool classof(const HNode *) { return true; }
1444
1445 Node *_node;
1446 };
1447
1448 class EmptyHNode : public HNode {
1449 void anchor() override;
1450
1451 public:
1452 EmptyHNode(Node *n) : HNode(n) { }
1453
1454 static bool classof(const HNode *n) { return NullNode::classof(n->_node); }
1455
1456 static bool classof(const EmptyHNode *) { return true; }
1457 };
1458
1459 class ScalarHNode : public HNode {
1460 void anchor() override;
1461
1462 public:
1463 ScalarHNode(Node *n, StringRef s) : HNode(n), _value(s) { }
1464
1465 StringRef value() const { return _value; }
1466
1467 static bool classof(const HNode *n) {
1468 return ScalarNode::classof(n->_node) ||
1469 BlockScalarNode::classof(n->_node);
1470 }
1471
1472 static bool classof(const ScalarHNode *) { return true; }
1473
1474 protected:
1475 StringRef _value;
1476 };
1477
1478 class MapHNode : public HNode {
1479 void anchor() override;
1480
1481 public:
1482 MapHNode(Node *n) : HNode(n) { }
1483
1484 static bool classof(const HNode *n) {
1485 return MappingNode::classof(n->_node);
1486 }
1487
1488 static bool classof(const MapHNode *) { return true; }
1489
1490 using NameToNode = StringMap<std::unique_ptr<HNode>>;
1491
1492 NameToNode Mapping;
1493 SmallVector<std::string, 6> ValidKeys;
1494 };
1495
1496 class SequenceHNode : public HNode {
1497 void anchor() override;
1498
1499 public:
1500 SequenceHNode(Node *n) : HNode(n) { }
1501
1502 static bool classof(const HNode *n) {
1503 return SequenceNode::classof(n->_node);
1504 }
1505
1506 static bool classof(const SequenceHNode *) { return true; }
1507
1508 std::vector<std::unique_ptr<HNode>> Entries;
1509 };
1510
1511 std::unique_ptr<Input::HNode> createHNodes(Node *node);
1512 void setError(HNode *hnode, const Twine &message);
1513 void setError(Node *node, const Twine &message);
1514
1515public:
1516 // These are only used by operator>>. They could be private
1517 // if those templated things could be made friends.
1518 bool setCurrentDocument();
1519 bool nextDocument();
1520
1521 /// Returns the current node that's being parsed by the YAML Parser.
1522 const Node *getCurrentNode() const;
1523
1524private:
1525 SourceMgr SrcMgr; // must be before Strm
1526 std::unique_ptr<llvm::yaml::Stream> Strm;
1527 std::unique_ptr<HNode> TopNode;
1528 std::error_code EC;
1529 BumpPtrAllocator StringAllocator;
1530 document_iterator DocIterator;
1531 std::vector<bool> BitValuesUsed;
1532 HNode *CurrentNode = nullptr;
1533 bool ScalarMatchFound;
1534};
1535
1536///
1537/// The Output class is used to generate a yaml document from in-memory structs
1538/// and vectors.
1539///
1540class Output : public IO {
1541public:
1542 Output(raw_ostream &, void *Ctxt = nullptr, int WrapColumn = 70);
1543 ~Output() override;
1544
1545 /// Set whether or not to output optional values which are equal
1546 /// to the default value. By default, when outputting if you attempt
1547 /// to write a value that is equal to the default, the value gets ignored.
1548 /// Sometimes, it is useful to be able to see these in the resulting YAML
1549 /// anyway.
1550 void setWriteDefaultValues(bool Write) { WriteDefaultValues = Write; }
1551
1552 bool outputting() override;
1553 bool mapTag(StringRef, bool) override;
1554 void beginMapping() override;
1555 void endMapping() override;
1556 bool preflightKey(const char *key, bool, bool, bool &, void *&) override;
1557 void postflightKey(void *) override;
1558 std::vector<StringRef> keys() override;
1559 void beginFlowMapping() override;
1560 void endFlowMapping() override;
1561 unsigned beginSequence() override;
1562 void endSequence() override;
1563 bool preflightElement(unsigned, void *&) override;
1564 void postflightElement(void *) override;
1565 unsigned beginFlowSequence() override;
1566 bool preflightFlowElement(unsigned, void *&) override;
1567 void postflightFlowElement(void *) override;
1568 void endFlowSequence() override;
1569 void beginEnumScalar() override;
1570 bool matchEnumScalar(const char*, bool) override;
1571 bool matchEnumFallback() override;
1572 void endEnumScalar() override;
1573 bool beginBitSetScalar(bool &) override;
1574 bool bitSetMatch(const char *, bool ) override;
1575 void endBitSetScalar() override;
1576 void scalarString(StringRef &, QuotingType) override;
1577 void blockScalarString(StringRef &) override;
1578 void scalarTag(std::string &) override;
1579 NodeKind getNodeKind() override;
1580 void setError(const Twine &message) override;
1581 bool canElideEmptySequence() override;
1582
1583 // These are only used by operator<<. They could be private
1584 // if that templated operator could be made a friend.
1585 void beginDocuments();
1586 bool preflightDocument(unsigned);
1587 void postflightDocument();
1588 void endDocuments();
1589
1590private:
1591 void output(StringRef s);
1592 void outputUpToEndOfLine(StringRef s);
1593 void newLineCheck();
1594 void outputNewLine();
1595 void paddedKey(StringRef key);
1596 void flowKey(StringRef Key);
1597
1598 enum InState {
1599 inSeqFirstElement,
1600 inSeqOtherElement,
1601 inFlowSeqFirstElement,
1602 inFlowSeqOtherElement,
1603 inMapFirstKey,
1604 inMapOtherKey,
1605 inFlowMapFirstKey,
1606 inFlowMapOtherKey
1607 };
1608
1609 static bool inSeqAnyElement(InState State);
1610 static bool inFlowSeqAnyElement(InState State);
1611 static bool inMapAnyKey(InState State);
1612 static bool inFlowMapAnyKey(InState State);
1613
1614 raw_ostream &Out;
1615 int WrapColumn;
1616 SmallVector<InState, 8> StateStack;
1617 int Column = 0;
1618 int ColumnAtFlowStart = 0;
1619 int ColumnAtMapFlowStart = 0;
1620 bool NeedBitValueComma = false;
1621 bool NeedFlowSequenceComma = false;
1622 bool EnumerationMatchFound = false;
1623 bool NeedsNewLine = false;
1624 bool WriteDefaultValues = false;
1625};
1626
1627/// YAML I/O does conversion based on types. But often native data types
1628/// are just a typedef of built in intergral types (e.g. int). But the C++
1629/// type matching system sees through the typedef and all the typedefed types
1630/// look like a built in type. This will cause the generic YAML I/O conversion
1631/// to be used. To provide better control over the YAML conversion, you can
1632/// use this macro instead of typedef. It will create a class with one field
1633/// and automatic conversion operators to and from the base type.
1634/// Based on BOOST_STRONG_TYPEDEF
1635#define LLVM_YAML_STRONG_TYPEDEF(_base, _type)struct _type { _type() = default; _type(const _base v) : value
(v) {} _type(const _type &v) = default; _type &operator
=(const _type &rhs) = default; _type &operator=(const
_base &rhs) { value = rhs; return *this; } operator const
_base & () const { return value; } bool operator==(const
_type &rhs) const { return value == rhs.value; } bool operator
==(const _base &rhs) const { return value == rhs; } bool operator
<(const _type &rhs) const { return value < rhs.value
; } _base value; using BaseType = _base; };
\
1636 struct _type { \
1637 _type() = default; \
1638 _type(const _base v) : value(v) {} \
1639 _type(const _type &v) = default; \
1640 _type &operator=(const _type &rhs) = default; \
1641 _type &operator=(const _base &rhs) { value = rhs; return *this; } \
1642 operator const _base & () const { return value; } \
1643 bool operator==(const _type &rhs) const { return value == rhs.value; } \
1644 bool operator==(const _base &rhs) const { return value == rhs; } \
1645 bool operator<(const _type &rhs) const { return value < rhs.value; } \
1646 _base value; \
1647 using BaseType = _base; \
1648 };
1649
1650///
1651/// Use these types instead of uintXX_t in any mapping to have
1652/// its yaml output formatted as hexadecimal.
1653///
1654LLVM_YAML_STRONG_TYPEDEF(uint8_t, Hex8)struct Hex8 { Hex8() = default; Hex8(const uint8_t v) : value
(v) {} Hex8(const Hex8 &v) = default; Hex8 &operator=
(const Hex8 &rhs) = default; Hex8 &operator=(const uint8_t
&rhs) { value = rhs; return *this; } operator const uint8_t
& () const { return value; } bool operator==(const Hex8 &
rhs) const { return value == rhs.value; } bool operator==(const
uint8_t &rhs) const { return value == rhs; } bool operator
<(const Hex8 &rhs) const { return value < rhs.value
; } uint8_t value; using BaseType = uint8_t; };
1655LLVM_YAML_STRONG_TYPEDEF(uint16_t, Hex16)struct Hex16 { Hex16() = default; Hex16(const uint16_t v) : value
(v) {} Hex16(const Hex16 &v) = default; Hex16 &operator
=(const Hex16 &rhs) = default; Hex16 &operator=(const
uint16_t &rhs) { value = rhs; return *this; } operator const
uint16_t & () const { return value; } bool operator==(const
Hex16 &rhs) const { return value == rhs.value; } bool operator
==(const uint16_t &rhs) const { return value == rhs; } bool
operator<(const Hex16 &rhs) const { return value <
rhs.value; } uint16_t value; using BaseType = uint16_t; };
1656LLVM_YAML_STRONG_TYPEDEF(uint32_t, Hex32)struct Hex32 { Hex32() = default; Hex32(const uint32_t v) : value
(v) {} Hex32(const Hex32 &v) = default; Hex32 &operator
=(const Hex32 &rhs) = default; Hex32 &operator=(const
uint32_t &rhs) { value = rhs; return *this; } operator const
uint32_t & () const { return value; } bool operator==(const
Hex32 &rhs) const { return value == rhs.value; } bool operator
==(const uint32_t &rhs) const { return value == rhs; } bool
operator<(const Hex32 &rhs) const { return value <
rhs.value; } uint32_t value; using BaseType = uint32_t; };
1657LLVM_YAML_STRONG_TYPEDEF(uint64_t, Hex64)struct Hex64 { Hex64() = default; Hex64(const uint64_t v) : value
(v) {} Hex64(const Hex64 &v) = default; Hex64 &operator
=(const Hex64 &rhs) = default; Hex64 &operator=(const
uint64_t &rhs) { value = rhs; return *this; } operator const
uint64_t & () const { return value; } bool operator==(const
Hex64 &rhs) const { return value == rhs.value; } bool operator
==(const uint64_t &rhs) const { return value == rhs; } bool
operator<(const Hex64 &rhs) const { return value <
rhs.value; } uint64_t value; using BaseType = uint64_t; };
1658
1659template<>
1660struct ScalarTraits<Hex8> {
1661 static void output(const Hex8 &, void *, raw_ostream &);
1662 static StringRef input(StringRef, void *, Hex8 &);
1663 static QuotingType mustQuote(StringRef) { return QuotingType::None; }
1664};
1665
1666template<>
1667struct ScalarTraits<Hex16> {
1668 static void output(const Hex16 &, void *, raw_ostream &);
1669 static StringRef input(StringRef, void *, Hex16 &);
1670 static QuotingType mustQuote(StringRef) { return QuotingType::None; }
1671};
1672
1673template<>
1674struct ScalarTraits<Hex32> {
1675 static void output(const Hex32 &, void *, raw_ostream &);
1676 static StringRef input(StringRef, void *, Hex32 &);
1677 static QuotingType mustQuote(StringRef) { return QuotingType::None; }
1678};
1679
1680template<>
1681struct ScalarTraits<Hex64> {
1682 static void output(const Hex64 &, void *, raw_ostream &);
1683 static StringRef input(StringRef, void *, Hex64 &);
1684 static QuotingType mustQuote(StringRef) { return QuotingType::None; }
1685};
1686
1687// Define non-member operator>> so that Input can stream in a document list.
1688template <typename T>
1689inline
1690typename std::enable_if<has_DocumentListTraits<T>::value, Input &>::type
1691operator>>(Input &yin, T &docList) {
1692 int i = 0;
1693 EmptyContext Ctx;
1694 while ( yin.setCurrentDocument() ) {
1695 yamlize(yin, DocumentListTraits<T>::element(yin, docList, i), true, Ctx);
1696 if ( yin.error() )
1697 return yin;
1698 yin.nextDocument();
1699 ++i;
1700 }
1701 return yin;
1702}
1703
1704// Define non-member operator>> so that Input can stream in a map as a document.
1705template <typename T>
1706inline typename std::enable_if<has_MappingTraits<T, EmptyContext>::value,
1707 Input &>::type
1708operator>>(Input &yin, T &docMap) {
1709 EmptyContext Ctx;
1710 yin.setCurrentDocument();
1711 yamlize(yin, docMap, true, Ctx);
1712 return yin;
1713}
1714
1715// Define non-member operator>> so that Input can stream in a sequence as
1716// a document.
1717template <typename T>
1718inline
1719typename std::enable_if<has_SequenceTraits<T>::value, Input &>::type
1720operator>>(Input &yin, T &docSeq) {
1721 EmptyContext Ctx;
1722 if (yin.setCurrentDocument())
1723 yamlize(yin, docSeq, true, Ctx);
1724 return yin;
1725}
1726
1727// Define non-member operator>> so that Input can stream in a block scalar.
1728template <typename T>
1729inline
1730typename std::enable_if<has_BlockScalarTraits<T>::value, Input &>::type
1731operator>>(Input &In, T &Val) {
1732 EmptyContext Ctx;
1733 if (In.setCurrentDocument())
1734 yamlize(In, Val, true, Ctx);
1735 return In;
1736}
1737
1738// Define non-member operator>> so that Input can stream in a string map.
1739template <typename T>
1740inline
1741typename std::enable_if<has_CustomMappingTraits<T>::value, Input &>::type
1742operator>>(Input &In, T &Val) {
1743 EmptyContext Ctx;
1744 if (In.setCurrentDocument())
1745 yamlize(In, Val, true, Ctx);
1746 return In;
1747}
1748
1749// Define non-member operator>> so that Input can stream in a polymorphic type.
1750template <typename T>
1751inline typename std::enable_if<has_PolymorphicTraits<T>::value, Input &>::type
1752operator>>(Input &In, T &Val) {
1753 EmptyContext Ctx;
1754 if (In.setCurrentDocument())
1755 yamlize(In, Val, true, Ctx);
1756 return In;
1757}
1758
1759// Provide better error message about types missing a trait specialization
1760template <typename T>
1761inline typename std::enable_if<missingTraits<T, EmptyContext>::value,
1762 Input &>::type
1763operator>>(Input &yin, T &docSeq) {
1764 char missing_yaml_trait_for_type[sizeof(MissingTrait<T>)];
1765 return yin;
1766}
1767
1768// Define non-member operator<< so that Output can stream out document list.
1769template <typename T>
1770inline
1771typename std::enable_if<has_DocumentListTraits<T>::value, Output &>::type
1772operator<<(Output &yout, T &docList) {
1773 EmptyContext Ctx;
1774 yout.beginDocuments();
1775 const size_t count = DocumentListTraits<T>::size(yout, docList);
1776 for(size_t i=0; i < count; ++i) {
1777 if ( yout.preflightDocument(i) ) {
1778 yamlize(yout, DocumentListTraits<T>::element(yout, docList, i), true,
1779 Ctx);
1780 yout.postflightDocument();
1781 }
1782 }
1783 yout.endDocuments();
1784 return yout;
1785}
1786
1787// Define non-member operator<< so that Output can stream out a map.
1788template <typename T>
1789inline typename std::enable_if<has_MappingTraits<T, EmptyContext>::value,
1790 Output &>::type
1791operator<<(Output &yout, T &map) {
1792 EmptyContext Ctx;
1793 yout.beginDocuments();
1794 if ( yout.preflightDocument(0) ) {
1795 yamlize(yout, map, true, Ctx);
1796 yout.postflightDocument();
1797 }
1798 yout.endDocuments();
1799 return yout;
1800}
1801
1802// Define non-member operator<< so that Output can stream out a sequence.
1803template <typename T>
1804inline
1805typename std::enable_if<has_SequenceTraits<T>::value, Output &>::type
1806operator<<(Output &yout, T &seq) {
1807 EmptyContext Ctx;
1808 yout.beginDocuments();
1809 if ( yout.preflightDocument(0) ) {
1810 yamlize(yout, seq, true, Ctx);
1811 yout.postflightDocument();
1812 }
1813 yout.endDocuments();
1814 return yout;
1815}
1816
1817// Define non-member operator<< so that Output can stream out a block scalar.
1818template <typename T>
1819inline
1820typename std::enable_if<has_BlockScalarTraits<T>::value, Output &>::type
1821operator<<(Output &Out, T &Val) {
1822 EmptyContext Ctx;
1823 Out.beginDocuments();
1824 if (Out.preflightDocument(0)) {
1825 yamlize(Out, Val, true, Ctx);
1826 Out.postflightDocument();
1827 }
1828 Out.endDocuments();
1829 return Out;
1830}
1831
1832// Define non-member operator<< so that Output can stream out a string map.
1833template <typename T>
1834inline
1835typename std::enable_if<has_CustomMappingTraits<T>::value, Output &>::type
1836operator<<(Output &Out, T &Val) {
1837 EmptyContext Ctx;
1838 Out.beginDocuments();
1839 if (Out.preflightDocument(0)) {
1840 yamlize(Out, Val, true, Ctx);
1841 Out.postflightDocument();
1842 }
1843 Out.endDocuments();
1844 return Out;
1845}
1846
1847// Define non-member operator<< so that Output can stream out a polymorphic
1848// type.
1849template <typename T>
1850inline typename std::enable_if<has_PolymorphicTraits<T>::value, Output &>::type
1851operator<<(Output &Out, T &Val) {
1852 EmptyContext Ctx;
1853 Out.beginDocuments();
1854 if (Out.preflightDocument(0)) {
1855 // FIXME: The parser does not support explicit documents terminated with a
1856 // plain scalar; the end-marker is included as part of the scalar token.
1857 assert(PolymorphicTraits<T>::getKind(Val) != NodeKind::Scalar && "plain scalar documents are not supported")((PolymorphicTraits<T>::getKind(Val) != NodeKind::Scalar
&& "plain scalar documents are not supported") ? static_cast
<void> (0) : __assert_fail ("PolymorphicTraits<T>::getKind(Val) != NodeKind::Scalar && \"plain scalar documents are not supported\""
, "/build/llvm-toolchain-snapshot-9~svn362543/include/llvm/Support/YAMLTraits.h"
, 1857, __PRETTY_FUNCTION__))
;
1858 yamlize(Out, Val, true, Ctx);
1859 Out.postflightDocument();
1860 }
1861 Out.endDocuments();
1862 return Out;
1863}
1864
1865// Provide better error message about types missing a trait specialization
1866template <typename T>
1867inline typename std::enable_if<missingTraits<T, EmptyContext>::value,
1868 Output &>::type
1869operator<<(Output &yout, T &seq) {
1870 char missing_yaml_trait_for_type[sizeof(MissingTrait<T>)];
1871 return yout;
1872}
1873
1874template <bool B> struct IsFlowSequenceBase {};
1875template <> struct IsFlowSequenceBase<true> { static const bool flow = true; };
1876
1877template <typename T, bool Flow>
1878struct SequenceTraitsImpl : IsFlowSequenceBase<Flow> {
1879private:
1880 using type = typename T::value_type;
1881
1882public:
1883 static size_t size(IO &io, T &seq) { return seq.size(); }
1884
1885 static type &element(IO &io, T &seq, size_t index) {
1886 if (index >= seq.size())
1887 seq.resize(index + 1);
1888 return seq[index];
1889 }
1890};
1891
1892// Simple helper to check an expression can be used as a bool-valued template
1893// argument.
1894template <bool> struct CheckIsBool { static const bool value = true; };
1895
1896// If T has SequenceElementTraits, then vector<T> and SmallVector<T, N> have
1897// SequenceTraits that do the obvious thing.
1898template <typename T>
1899struct SequenceTraits<std::vector<T>,
1900 typename std::enable_if<CheckIsBool<
1901 SequenceElementTraits<T>::flow>::value>::type>
1902 : SequenceTraitsImpl<std::vector<T>, SequenceElementTraits<T>::flow> {};
1903template <typename T, unsigned N>
1904struct SequenceTraits<SmallVector<T, N>,
1905 typename std::enable_if<CheckIsBool<
1906 SequenceElementTraits<T>::flow>::value>::type>
1907 : SequenceTraitsImpl<SmallVector<T, N>, SequenceElementTraits<T>::flow> {};
1908template <typename T>
1909struct SequenceTraits<SmallVectorImpl<T>,
1910 typename std::enable_if<CheckIsBool<
1911 SequenceElementTraits<T>::flow>::value>::type>
1912 : SequenceTraitsImpl<SmallVectorImpl<T>, SequenceElementTraits<T>::flow> {};
1913
1914// Sequences of fundamental types use flow formatting.
1915template <typename T>
1916struct SequenceElementTraits<
1917 T, typename std::enable_if<std::is_fundamental<T>::value>::type> {
1918 static const bool flow = true;
1919};
1920
1921// Sequences of strings use block formatting.
1922template<> struct SequenceElementTraits<std::string> {
1923 static const bool flow = false;
1924};
1925template<> struct SequenceElementTraits<StringRef> {
1926 static const bool flow = false;
1927};
1928template<> struct SequenceElementTraits<std::pair<std::string, std::string>> {
1929 static const bool flow = false;
1930};
1931
1932/// Implementation of CustomMappingTraits for std::map<std::string, T>.
1933template <typename T> struct StdMapStringCustomMappingTraitsImpl {
1934 using map_type = std::map<std::string, T>;
1935
1936 static void inputOne(IO &io, StringRef key, map_type &v) {
1937 io.mapRequired(key.str().c_str(), v[key]);
1938 }
1939
1940 static void output(IO &io, map_type &v) {
1941 for (auto &p : v)
1942 io.mapRequired(p.first.c_str(), p.second);
1943 }
1944};
1945
1946} // end namespace yaml
1947} // end namespace llvm
1948
1949#define LLVM_YAML_IS_SEQUENCE_VECTOR_IMPL(TYPE, FLOW)namespace llvm { namespace yaml { static_assert( !std::is_fundamental
<TYPE>::value && !std::is_same<TYPE, std::string
>::value && !std::is_same<TYPE, llvm::StringRef
>::value, "only use LLVM_YAML_IS_SEQUENCE_VECTOR for types you control"
); template <> struct SequenceElementTraits<TYPE>
{ static const bool flow = FLOW; }; } }
\
1950 namespace llvm { \
1951 namespace yaml { \
1952 static_assert( \
1953 !std::is_fundamental<TYPE>::value && \
1954 !std::is_same<TYPE, std::string>::value && \
1955 !std::is_same<TYPE, llvm::StringRef>::value, \
1956 "only use LLVM_YAML_IS_SEQUENCE_VECTOR for types you control"); \
1957 template <> struct SequenceElementTraits<TYPE> { \
1958 static const bool flow = FLOW; \
1959 }; \
1960 } \
1961 }
1962
1963/// Utility for declaring that a std::vector of a particular type
1964/// should be considered a YAML sequence.
1965#define LLVM_YAML_IS_SEQUENCE_VECTOR(type)namespace llvm { namespace yaml { static_assert( !std::is_fundamental
<type>::value && !std::is_same<type, std::string
>::value && !std::is_same<type, llvm::StringRef
>::value, "only use LLVM_YAML_IS_SEQUENCE_VECTOR for types you control"
); template <> struct SequenceElementTraits<type>
{ static const bool flow = false; }; } }
\
1966 LLVM_YAML_IS_SEQUENCE_VECTOR_IMPL(type, false)namespace llvm { namespace yaml { static_assert( !std::is_fundamental
<type>::value && !std::is_same<type, std::string
>::value && !std::is_same<type, llvm::StringRef
>::value, "only use LLVM_YAML_IS_SEQUENCE_VECTOR for types you control"
); template <> struct SequenceElementTraits<type>
{ static const bool flow = false; }; } }
1967
1968/// Utility for declaring that a std::vector of a particular type
1969/// should be considered a YAML flow sequence.
1970#define LLVM_YAML_IS_FLOW_SEQUENCE_VECTOR(type)namespace llvm { namespace yaml { static_assert( !std::is_fundamental
<type>::value && !std::is_same<type, std::string
>::value && !std::is_same<type, llvm::StringRef
>::value, "only use LLVM_YAML_IS_SEQUENCE_VECTOR for types you control"
); template <> struct SequenceElementTraits<type>
{ static const bool flow = true; }; } }
\
1971 LLVM_YAML_IS_SEQUENCE_VECTOR_IMPL(type, true)namespace llvm { namespace yaml { static_assert( !std::is_fundamental
<type>::value && !std::is_same<type, std::string
>::value && !std::is_same<type, llvm::StringRef
>::value, "only use LLVM_YAML_IS_SEQUENCE_VECTOR for types you control"
); template <> struct SequenceElementTraits<type>
{ static const bool flow = true; }; } }
1972
1973#define LLVM_YAML_DECLARE_MAPPING_TRAITS(Type)namespace llvm { namespace yaml { template <> struct MappingTraits
<Type> { static void mapping(IO &IO, Type &Obj)
; }; } }
\
1974 namespace llvm { \
1975 namespace yaml { \
1976 template <> struct MappingTraits<Type> { \
1977 static void mapping(IO &IO, Type &Obj); \
1978 }; \
1979 } \
1980 }
1981
1982#define LLVM_YAML_DECLARE_ENUM_TRAITS(Type)namespace llvm { namespace yaml { template <> struct ScalarEnumerationTraits
<Type> { static void enumeration(IO &io, Type &
Value); }; } }
\
1983 namespace llvm { \
1984 namespace yaml { \
1985 template <> struct ScalarEnumerationTraits<Type> { \
1986 static void enumeration(IO &io, Type &Value); \
1987 }; \
1988 } \
1989 }
1990
1991#define LLVM_YAML_DECLARE_BITSET_TRAITS(Type)namespace llvm { namespace yaml { template <> struct ScalarBitSetTraits
<Type> { static void bitset(IO &IO, Type &Options
); }; } }
\
1992 namespace llvm { \
1993 namespace yaml { \
1994 template <> struct ScalarBitSetTraits<Type> { \
1995 static void bitset(IO &IO, Type &Options); \
1996 }; \
1997 } \
1998 }
1999
2000#define LLVM_YAML_DECLARE_SCALAR_TRAITS(Type, MustQuote)namespace llvm { namespace yaml { template <> struct ScalarTraits
<Type> { static void output(const Type &Value, void
*ctx, raw_ostream &Out); static StringRef input(StringRef
Scalar, void *ctxt, Type &Value); static QuotingType mustQuote
(StringRef) { return MustQuote; } }; } }
\
2001 namespace llvm { \
2002 namespace yaml { \
2003 template <> struct ScalarTraits<Type> { \
2004 static void output(const Type &Value, void *ctx, raw_ostream &Out); \
2005 static StringRef input(StringRef Scalar, void *ctxt, Type &Value); \
2006 static QuotingType mustQuote(StringRef) { return MustQuote; } \
2007 }; \
2008 } \
2009 }
2010
2011/// Utility for declaring that a std::vector of a particular type
2012/// should be considered a YAML document list.
2013#define LLVM_YAML_IS_DOCUMENT_LIST_VECTOR(_type)namespace llvm { namespace yaml { template <unsigned N>
struct DocumentListTraits<SmallVector<_type, N>>
: public SequenceTraitsImpl<SmallVector<_type, N>, false
> {}; template <> struct DocumentListTraits<std::
vector<_type>> : public SequenceTraitsImpl<std::vector
<_type>, false> {}; } }
\
2014 namespace llvm { \
2015 namespace yaml { \
2016 template <unsigned N> \
2017 struct DocumentListTraits<SmallVector<_type, N>> \
2018 : public SequenceTraitsImpl<SmallVector<_type, N>, false> {}; \
2019 template <> \
2020 struct DocumentListTraits<std::vector<_type>> \
2021 : public SequenceTraitsImpl<std::vector<_type>, false> {}; \
2022 } \
2023 }
2024
2025/// Utility for declaring that std::map<std::string, _type> should be considered
2026/// a YAML map.
2027#define LLVM_YAML_IS_STRING_MAP(_type)namespace llvm { namespace yaml { template <> struct CustomMappingTraits
<std::map<std::string, _type>> : public StdMapStringCustomMappingTraitsImpl
<_type> {}; } }
\
2028 namespace llvm { \
2029 namespace yaml { \
2030 template <> \
2031 struct CustomMappingTraits<std::map<std::string, _type>> \
2032 : public StdMapStringCustomMappingTraitsImpl<_type> {}; \
2033 } \
2034 }
2035
2036#endif // LLVM_SUPPORT_YAMLTRAITS_H