Lines Matching refs:IO
20 static inline void mapOptional(yaml::IO &IO, const char *Key, EndianType &Val,
22 IO.mapOptional(Key, Val, EndianType(Default));
27 static inline void mapRequiredAs(yaml::IO &IO, const char *Key,
30 IO.mapRequired(Key, Mapped);
37 static inline void mapOptionalAs(yaml::IO &IO, const char *Key, EndianType &Val,
40 IO.mapOptional(Key, Mapped, Default);
54 static inline void mapRequiredHex(yaml::IO &IO, const char *Key,
56 mapRequiredAs<typename HexType<EndianType>::type>(IO, Key, Val);
62 static inline void mapOptionalHex(yaml::IO &IO, const char *Key,
65 mapOptionalAs<typename HexType<EndianType>::type>(IO, Key, Val, Default);
121 IO &IO, MemoryProtection &Protect) {
123 IO.bitSetCase(Protect, #NATIVENAME, MemoryProtection::NAME);
127 void yaml::ScalarBitSetTraits<MemoryState>::bitset(IO &IO, MemoryState &State) {
129 IO.bitSetCase(State, #NATIVENAME, MemoryState::NAME);
133 void yaml::ScalarBitSetTraits<MemoryType>::bitset(IO &IO, MemoryType &Type) {
135 IO.bitSetCase(Type, #NATIVENAME, MemoryType::NAME);
140 IO &IO, ProcessorArchitecture &Arch) {
142 IO.enumCase(Arch, #NAME, ProcessorArchitecture::NAME);
144 IO.enumFallback<Hex16>(Arch);
147 void yaml::ScalarEnumerationTraits<OSPlatform>::enumeration(IO &IO,
150 IO.enumCase(Plat, #NAME, OSPlatform::NAME);
152 IO.enumFallback<Hex32>(Plat);
155 void yaml::ScalarEnumerationTraits<StreamType>::enumeration(IO &IO,
158 IO.enumCase(Type, #NAME, StreamType::NAME);
160 IO.enumFallback<Hex32>(Type);
163 void yaml::MappingTraits<CPUInfo::ArmInfo>::mapping(IO &IO,
165 mapRequiredHex(IO, "CPUID", Info.CPUID);
166 mapOptionalHex(IO, "ELF hwcaps", Info.ElfHWCaps, 0);
200 IO &IO, CPUInfo::OtherInfo &Info) {
202 IO.mapRequired("Features", Features);
235 void yaml::MappingTraits<CPUInfo::X86Info>::mapping(IO &IO,
238 IO.mapRequired("Vendor ID", VendorID);
240 mapRequiredHex(IO, "Version Info", Info.VersionInfo);
241 mapRequiredHex(IO, "Feature Info", Info.FeatureInfo);
242 mapOptionalHex(IO, "AMD Extended Features", Info.AMDExtendedFeatures, 0);
245 void yaml::MappingTraits<MemoryInfo>::mapping(IO &IO, MemoryInfo &Info) {
246 mapRequiredHex(IO, "Base Address", Info.BaseAddress);
247 mapOptionalHex(IO, "Allocation Base", Info.AllocationBase, Info.BaseAddress);
248 mapRequiredAs<MemoryProtection>(IO, "Allocation Protect",
250 mapOptionalHex(IO, "Reserved0", Info.Reserved0, 0);
251 mapRequiredHex(IO, "Region Size", Info.RegionSize);
252 mapRequiredAs<MemoryState>(IO, "State", Info.State);
253 mapOptionalAs<MemoryProtection>(IO, "Protect", Info.Protect,
255 mapRequiredAs<MemoryType>(IO, "Type", Info.Type);
256 mapOptionalHex(IO, "Reserved1", Info.Reserved1, 0);
259 void yaml::MappingTraits<VSFixedFileInfo>::mapping(IO &IO,
261 mapOptionalHex(IO, "Signature", Info.Signature, 0);
262 mapOptionalHex(IO, "Struct Version", Info.StructVersion, 0);
263 mapOptionalHex(IO, "File Version High", Info.FileVersionHigh, 0);
264 mapOptionalHex(IO, "File Version Low", Info.FileVersionLow, 0);
265 mapOptionalHex(IO, "Product Version High", Info.ProductVersionHigh, 0);
266 mapOptionalHex(IO, "Product Version Low", Info.ProductVersionLow, 0);
267 mapOptionalHex(IO, "File Flags Mask", Info.FileFlagsMask, 0);
268 mapOptionalHex(IO, "File Flags", Info.FileFlags, 0);
269 mapOptionalHex(IO, "File OS", Info.FileOS, 0);
270 mapOptionalHex(IO, "File Type", Info.FileType, 0);
271 mapOptionalHex(IO, "File Subtype", Info.FileSubtype, 0);
272 mapOptionalHex(IO, "File Date High", Info.FileDateHigh, 0);
273 mapOptionalHex(IO, "File Date Low", Info.FileDateLow, 0);
277 IO &IO, ModuleListStream::entry_type &M) {
278 mapRequiredHex(IO, "Base of Image", M.Entry.BaseOfImage);
279 mapRequiredHex(IO, "Size of Image", M.Entry.SizeOfImage);
280 mapOptionalHex(IO, "Checksum", M.Entry.Checksum, 0);
281 mapOptional(IO, "Time Date Stamp", M.Entry.TimeDateStamp, 0);
282 IO.mapRequired("Module Name", M.Name);
283 IO.mapOptional("Version Info", M.Entry.VersionInfo, VSFixedFileInfo());
284 IO.mapRequired("CodeView Record", M.CvRecord);
285 IO.mapOptional("Misc Record", M.MiscRecord, yaml::BinaryRef());
286 mapOptionalHex(IO, "Reserved0", M.Entry.Reserved0, 0);
287 mapOptionalHex(IO, "Reserved1", M.Entry.Reserved1, 0);
290 static void streamMapping(yaml::IO &IO, RawContentStream &Stream) {
291 IO.mapOptional("Content", Stream.Content);
292 IO.mapOptional("Size", Stream.Size, Stream.Content.binary_size());
302 IO &IO, MemoryListStream::entry_type &Range) {
304 IO, Range.Entry, Range.Content);
307 static void streamMapping(yaml::IO &IO, MemoryInfoListStream &Stream) {
308 IO.mapRequired("Memory Ranges", Stream.Infos);
311 static void streamMapping(yaml::IO &IO, MemoryListStream &Stream) {
312 IO.mapRequired("Memory Ranges", Stream.Entries);
315 static void streamMapping(yaml::IO &IO, ModuleListStream &Stream) {
316 IO.mapRequired("Modules", Stream.Entries);
319 static void streamMapping(yaml::IO &IO, SystemInfoStream &Stream) {
321 IO.mapRequired("Processor Arch", Info.ProcessorArch);
322 mapOptional(IO, "Processor Level", Info.ProcessorLevel, 0);
323 mapOptional(IO, "Processor Revision", Info.ProcessorRevision, 0);
324 IO.mapOptional("Number of Processors", Info.NumberOfProcessors, 0);
325 IO.mapOptional("Product type", Info.ProductType, 0);
326 mapOptional(IO, "Major Version", Info.MajorVersion, 0);
327 mapOptional(IO, "Minor Version", Info.MinorVersion, 0);
328 mapOptional(IO, "Build Number", Info.BuildNumber, 0);
329 IO.mapRequired("Platform ID", Info.PlatformId);
330 IO.mapOptional("CSD Version", Stream.CSDVersion, "");
331 mapOptionalHex(IO, "Suite Mask", Info.SuiteMask, 0);
332 mapOptionalHex(IO, "Reserved", Info.Reserved, 0);
336 IO.mapOptional("CPU", Info.CPU.X86);
341 IO.mapOptional("CPU", Info.CPU.Arm);
344 IO.mapOptional("CPU", Info.CPU.Other);
349 static void streamMapping(yaml::IO &IO, TextContentStream &Stream) {
350 IO.mapOptional("Text", Stream.Text);
354 IO &IO, MemoryDescriptor &Memory, BinaryRef &Content) {
355 mapRequiredHex(IO, "Start of Memory Range", Memory.StartOfMemoryRange);
356 IO.mapRequired("Content", Content);
360 IO &IO, ThreadListStream::entry_type &T) {
361 mapRequiredHex(IO, "Thread Id", T.Entry.ThreadId);
362 mapOptionalHex(IO, "Suspend Count", T.Entry.SuspendCount, 0);
363 mapOptionalHex(IO, "Priority Class", T.Entry.PriorityClass, 0);
364 mapOptionalHex(IO, "Priority", T.Entry.Priority, 0);
365 mapOptionalHex(IO, "Environment Block", T.Entry.EnvironmentBlock, 0);
366 IO.mapRequired("Context", T.Context);
367 IO.mapRequired("Stack", T.Entry.Stack, T.Stack);
370 static void streamMapping(yaml::IO &IO, ThreadListStream &Stream) {
371 IO.mapRequired("Threads", Stream.Entries);
374 static void streamMapping(yaml::IO &IO, MinidumpYAML::ExceptionStream &Stream) {
375 mapRequiredHex(IO, "Thread ID", Stream.MDExceptionStream.ThreadId);
376 IO.mapRequired("Exception Record", Stream.MDExceptionStream.ExceptionRecord);
377 IO.mapRequired("Thread Context", Stream.ThreadContext);
381 yaml::IO &IO, minidump::Exception &Exception) {
382 mapRequiredHex(IO, "Exception Code", Exception.ExceptionCode);
383 mapOptionalHex(IO, "Exception Flags", Exception.ExceptionFlags, 0);
384 mapOptionalHex(IO, "Exception Record", Exception.ExceptionRecord, 0);
385 mapOptionalHex(IO, "Exception Address", Exception.ExceptionAddress, 0);
386 mapOptional(IO, "Number of Parameters", Exception.NumberParameters, 0);
394 mapRequiredHex(IO, Name.c_str(), Field);
396 mapOptionalHex(IO, Name.c_str(), Field, 0);
401 yaml::IO &IO, std::unique_ptr<MinidumpYAML::Stream> &S) {
403 if (IO.outputting())
405 IO.mapRequired("Type", Type);
407 if (!IO.outputting())
411 streamMapping(IO, llvm::cast<MinidumpYAML::ExceptionStream>(*S));
414 streamMapping(IO, llvm::cast<MemoryInfoListStream>(*S));
417 streamMapping(IO, llvm::cast<MemoryListStream>(*S));
420 streamMapping(IO, llvm::cast<ModuleListStream>(*S));
423 streamMapping(IO, llvm::cast<RawContentStream>(*S));
426 streamMapping(IO, llvm::cast<SystemInfoStream>(*S));
429 streamMapping(IO, llvm::cast<TextContentStream>(*S));
432 streamMapping(IO, llvm::cast<ThreadListStream>(*S));
438 yaml::IO &IO, std::unique_ptr<MinidumpYAML::Stream> &S) {
454 void yaml::MappingTraits<Object>::mapping(IO &IO, Object &O) {
455 IO.mapTag("!minidump", true);
456 mapOptionalHex(IO, "Signature", O.Header.Signature, Header::MagicSignature);
457 mapOptionalHex(IO, "Version", O.Header.Version, Header::MagicVersion);
458 mapOptionalHex(IO, "Flags", O.Header.Flags, 0);
459 IO.mapRequired("Streams", O.Streams);