Lines Matching refs:io
183 RefNameResolver(const lld::File *file, IO &io);
286 static void enumeration(IO &io, lld::File::Kind &value) {
287 io.enumCase(value, "error-object", lld::File::kindErrorObject);
288 io.enumCase(value, "object", lld::File::kindMachObject);
289 io.enumCase(value, "shared-library", lld::File::kindSharedLibrary);
290 io.enumCase(value, "static-library", lld::File::kindArchiveLibrary);
295 static void enumeration(IO &io, lld::Atom::Scope &value) {
296 io.enumCase(value, "global", lld::Atom::scopeGlobal);
297 io.enumCase(value, "hidden", lld::Atom::scopeLinkageUnit);
298 io.enumCase(value, "static", lld::Atom::scopeTranslationUnit);
303 static void enumeration(IO &io, lld::DefinedAtom::SectionChoice &value) {
304 io.enumCase(value, "content", lld::DefinedAtom::sectionBasedOnContent);
305 io.enumCase(value, "custom", lld::DefinedAtom::sectionCustomPreferred);
306 io.enumCase(value, "custom-required",
312 static void enumeration(IO &io, lld::DefinedAtom::Interposable &value) {
313 io.enumCase(value, "no", DefinedAtom::interposeNo);
314 io.enumCase(value, "yes", DefinedAtom::interposeYes);
315 io.enumCase(value, "yes-and-weak", DefinedAtom::interposeYesAndRuntimeWeak);
320 static void enumeration(IO &io, lld::DefinedAtom::Merge &value) {
321 io.enumCase(value, "no", lld::DefinedAtom::mergeNo);
322 io.enumCase(value, "as-tentative", lld::DefinedAtom::mergeAsTentative);
323 io.enumCase(value, "as-weak", lld::DefinedAtom::mergeAsWeak);
324 io.enumCase(value, "as-addressed-weak",
326 io.enumCase(value, "by-content", lld::DefinedAtom::mergeByContent);
327 io.enumCase(value, "same-name-and-size",
329 io.enumCase(value, "largest", lld::DefinedAtom::mergeByLargestSection);
334 static void enumeration(IO &io, lld::DefinedAtom::DeadStripKind &value) {
335 io.enumCase(value, "normal", lld::DefinedAtom::deadStripNormal);
336 io.enumCase(value, "never", lld::DefinedAtom::deadStripNever);
337 io.enumCase(value, "always", lld::DefinedAtom::deadStripAlways);
342 static void enumeration(IO &io, lld::DefinedAtom::DynamicExport &value) {
343 io.enumCase(value, "normal", lld::DefinedAtom::dynamicExportNormal);
344 io.enumCase(value, "always", lld::DefinedAtom::dynamicExportAlways);
349 static void enumeration(IO &io, lld::DefinedAtom::CodeModel &value) {
350 io.enumCase(value, "none", lld::DefinedAtom::codeNA);
351 io.enumCase(value, "mips-pic", lld::DefinedAtom::codeMipsPIC);
352 io.enumCase(value, "mips-micro", lld::DefinedAtom::codeMipsMicro);
353 io.enumCase(value, "mips-micro-pic", lld::DefinedAtom::codeMipsMicroPIC);
354 io.enumCase(value, "mips-16", lld::DefinedAtom::codeMips16);
355 io.enumCase(value, "arm-thumb", lld::DefinedAtom::codeARMThumb);
356 io.enumCase(value, "arm-a", lld::DefinedAtom::codeARM_a);
357 io.enumCase(value, "arm-d", lld::DefinedAtom::codeARM_d);
358 io.enumCase(value, "arm-t", lld::DefinedAtom::codeARM_t);
364 static void enumeration(IO &io, lld::DefinedAtom::ContentPermissions &value) {
365 io.enumCase(value, "---", lld::DefinedAtom::perm___);
366 io.enumCase(value, "r--", lld::DefinedAtom::permR__);
367 io.enumCase(value, "r-x", lld::DefinedAtom::permR_X);
368 io.enumCase(value, "rw-", lld::DefinedAtom::permRW_);
369 io.enumCase(value, "rwx", lld::DefinedAtom::permRWX);
370 io.enumCase(value, "rw-l", lld::DefinedAtom::permRW_L);
371 io.enumCase(value, "unknown", lld::DefinedAtom::permUnknown);
376 static void enumeration(IO &io, lld::DefinedAtom::ContentType &value) {
377 io.enumCase(value, "unknown", DefinedAtom::typeUnknown);
378 io.enumCase(value, "code", DefinedAtom::typeCode);
379 io.enumCase(value, "stub", DefinedAtom::typeStub);
380 io.enumCase(value, "constant", DefinedAtom::typeConstant);
381 io.enumCase(value, "data", DefinedAtom::typeData);
382 io.enumCase(value, "quick-data", DefinedAtom::typeDataFast);
383 io.enumCase(value, "zero-fill", DefinedAtom::typeZeroFill);
384 io.enumCase(value, "zero-fill-quick", DefinedAtom::typeZeroFillFast);
385 io.enumCase(value, "const-data", DefinedAtom::typeConstData);
386 io.enumCase(value, "got", DefinedAtom::typeGOT);
387 io.enumCase(value, "resolver", DefinedAtom::typeResolver);
388 io.enumCase(value, "branch-island", DefinedAtom::typeBranchIsland);
389 io.enumCase(value, "branch-shim", DefinedAtom::typeBranchShim);
390 io.enumCase(value, "stub-helper", DefinedAtom::typeStubHelper);
391 io.enumCase(value, "c-string", DefinedAtom::typeCString);
392 io.enumCase(value, "utf16-string", DefinedAtom::typeUTF16String);
393 io.enumCase(value, "unwind-cfi", DefinedAtom::typeCFI);
394 io.enumCase(value, "unwind-lsda", DefinedAtom::typeLSDA);
395 io.enumCase(value, "const-4-byte", DefinedAtom::typeLiteral4);
396 io.enumCase(value, "const-8-byte", DefinedAtom::typeLiteral8);
397 io.enumCase(value, "const-16-byte", DefinedAtom::typeLiteral16);
398 io.enumCase(value, "lazy-pointer", DefinedAtom::typeLazyPointer);
399 io.enumCase(value, "lazy-dylib-pointer",
401 io.enumCase(value, "cfstring", DefinedAtom::typeCFString);
402 io.enumCase(value, "initializer-pointer",
404 io.enumCase(value, "terminator-pointer",
406 io.enumCase(value, "c-string-pointer",DefinedAtom::typeCStringPtr);
407 io.enumCase(value, "objc-class-pointer",
409 io.enumCase(value, "objc-category-list",
411 io.enumCase(value, "objc-image-info",
413 io.enumCase(value, "objc-method-list",
415 io.enumCase(value, "objc-class1", DefinedAtom::typeObjC1Class);
416 io.enumCase(value, "dtraceDOF", DefinedAtom::typeDTraceDOF);
417 io.enumCase(value, "interposing-tuples",
419 io.enumCase(value, "lto-temp", DefinedAtom::typeTempLTO);
420 io.enumCase(value, "compact-unwind", DefinedAtom::typeCompactUnwindInfo);
421 io.enumCase(value, "unwind-info", DefinedAtom::typeProcessedUnwindInfo);
422 io.enumCase(value, "tlv-thunk", DefinedAtom::typeThunkTLV);
423 io.enumCase(value, "tlv-data", DefinedAtom::typeTLVInitialData);
424 io.enumCase(value, "tlv-zero-fill", DefinedAtom::typeTLVInitialZeroFill);
425 io.enumCase(value, "tlv-initializer-ptr",
427 io.enumCase(value, "mach_header", DefinedAtom::typeMachHeader);
428 io.enumCase(value, "dso_handle", DefinedAtom::typeDSOHandle);
429 io.enumCase(value, "sectcreate", DefinedAtom::typeSectCreate);
434 static void enumeration(IO &io, lld::UndefinedAtom::CanBeNull &value) {
435 io.enumCase(value, "never", lld::UndefinedAtom::canBeNullNever);
436 io.enumCase(value, "at-runtime", lld::UndefinedAtom::canBeNullAtRuntime);
437 io.enumCase(value, "at-buildtime",lld::UndefinedAtom::canBeNullAtBuildtime);
442 static void enumeration(IO &io, ShlibCanBeNull &value) {
443 io.enumCase(value, "never", false);
444 io.enumCase(value, "at-runtime", true);
450 static void enumeration(IO &io, lld::SharedLibraryAtom::Type &value) {
451 io.enumCase(value, "code", lld::SharedLibraryAtom::Type::Code);
452 io.enumCase(value, "data", lld::SharedLibraryAtom::Type::Data);
453 io.enumCase(value, "unknown", lld::SharedLibraryAtom::Type::Unknown);
501 static void enumeration(IO &io, FileKinds &value) {
502 io.enumCase(value, "object", fileKindObjectAtoms);
503 io.enumCase(value, "archive", fileKindArchive);
504 io.enumCase(value, "object-mach-o", fileKindObjectMachO);
509 static void mapping(IO &io, ArchMember &member) {
510 io.mapOptional("kind", member._kind, fileKindObjectAtoms);
511 io.mapOptional("name", member._name);
512 io.mapRequired("content", member._content);
518 static size_t size(IO &io, AtomList<T> &seq) { return seq._atoms.size(); }
519 static T *&element(IO &io, AtomList<T> &seq, size_t index) {
528 static size_t size(IO &io, File::AtomRange<T> &seq) { return seq.size(); }
529 static T *&element(IO &io, File::AtomRange<T> &seq, size_t index) {
530 assert(io.outputting() && "AtomRange only used when outputting");
559 static size_t size(IO &io, std::vector<const lld::File *> &seq) {
562 static const lld::File *&element(IO &io, std::vector<const lld::File *> &seq,
574 NormArchiveFile(IO &io) : ArchiveLibraryFile("") {}
576 NormArchiveFile(IO &io, const lld::File *file)
582 const lld::File *denormalize(IO &io) { return this; }
626 NormalizedFile(IO &io)
627 : File("", kindNormalizedObject), _io(io), _rnb(nullptr),
633 NormalizedFile(IO &io, const lld::File *file)
634 : File(file->path(), kindNormalizedObject), _io(io),
645 const lld::File *denormalize(IO &io);
692 static void mapping(IO &io, const lld::File *&file) {
693 YamlContext *info = reinterpret_cast<YamlContext *>(io.getContext());
696 if (info->_registry && info->_registry->handleTaggedDoc(io, file))
700 if (io.mapTag("!native", true) || io.mapTag("tag:yaml.org,2002:map"))
701 mappingAtoms(io, file);
704 static void mappingAtoms(IO &io, const lld::File *&file) {
705 YamlContext *info = reinterpret_cast<YamlContext *>(io.getContext());
707 keys(io, file, nullptr);
711 io.mapOptional("path", keys->_path);
713 if (io.outputting()) {
714 io.mapOptional("defined-atoms", keys->_definedAtomsRef);
715 io.mapOptional("undefined-atoms", keys->_undefinedAtomsRef);
716 io.mapOptional("shared-library-atoms", keys->_sharedLibraryAtomsRef);
717 io.mapOptional("absolute-atoms", keys->_absoluteAtomsRef);
719 io.mapOptional("defined-atoms", keys->_definedAtoms);
720 io.mapOptional("undefined-atoms", keys->_undefinedAtoms);
721 io.mapOptional("shared-library-atoms", keys->_sharedLibraryAtoms);
722 io.mapOptional("absolute-atoms", keys->_absoluteAtoms);
726 static void mappingArchive(IO &io, const lld::File *&file) {
727 YamlContext *info = reinterpret_cast<YamlContext *>(io.getContext());
729 keys(io, file, &info->_file->allocator());
731 io.mapOptional("path", keys->_path);
732 io.mapOptional("members", keys->_members);
740 NormalizedReference(IO &io)
745 NormalizedReference(IO &io, const lld::Reference *ref)
748 _target(nullptr), _targetName(targetName(io, ref)),
756 const lld::Reference *denormalize(IO &io) {
757 YamlContext *info = reinterpret_cast<YamlContext *>(io.getContext());
775 static StringRef targetName(IO &io, const lld::Reference *ref);
791 static void mapping(IO &io, const lld::Reference *&ref) {
792 YamlContext *info = reinterpret_cast<YamlContext *>(io.getContext());
794 io, ref, &info->_file->allocator());
796 io.mapRequired("kind", keys->_mappedKind);
797 io.mapOptional("offset", keys->_offset);
798 io.mapOptional("target", keys->_targetName);
799 io.mapOptional("addend", keys->_addend, (lld::Reference::Addend)0);
800 io.mapOptional("tag", keys->_tag, 0u);
809 NormalizedAtom(IO &io)
810 : _file(fileFromContext(io)), _contentType(), _alignment(1) {
815 NormalizedAtom(IO &io, const lld::DefinedAtom *atom)
816 : _file(fileFromContext(io)), _name(atom->name()),
837 const lld::DefinedAtom *denormalize(IO &io) {
838 YamlContext *info = reinterpret_cast<YamlContext *>(io.getContext());
858 const lld::File &fileFromContext(IO &io) {
859 YamlContext *info = reinterpret_cast<YamlContext *>(io.getContext());
941 static void mapping(IO &io, const lld::DefinedAtom *&atom) {
942 YamlContext *info = reinterpret_cast<YamlContext *>(io.getContext());
944 io, atom, &info->_file->allocator());
945 if (io.outputting()) {
957 io.mapOptional("name", keys->_name, StringRef());
958 io.mapOptional("ref-name", keys->_refName, StringRef());
959 io.mapOptional("scope", keys->_scope,
961 io.mapOptional("type", keys->_contentType,
963 io.mapOptional("content", keys->_content);
964 io.mapOptional("size", keys->_size, (uint64_t)keys->_content.size());
965 io.mapOptional("interposable", keys->_interpose,
967 io.mapOptional("merge", keys->_merge, DefinedAtom::mergeNo);
968 io.mapOptional("alignment", keys->_alignment,
970 io.mapOptional("section-choice", keys->_sectionChoice,
972 io.mapOptional("section-name", keys->_sectionName, StringRef());
973 io.mapOptional("section-size", keys->_sectionSize, (uint64_t)0);
974 io.mapOptional("dead-strip", keys->_deadStrip,
976 io.mapOptional("dynamic-export", keys->_dynamicExport,
978 io.mapOptional("code-model", keys->_codeModel, DefinedAtom::codeNA);
980 io.mapOptional("permissions", keys->_permissions,
983 io.mapOptional("references", keys->_references);
988 static void mapping(IO &io, lld::DefinedAtom *&atom) {
990 MappingTraits<const lld::DefinedAtom *>::mapping(io, atomPtr);
999 NormalizedAtom(IO &io)
1000 : _file(fileFromContext(io)), _canBeNull(canBeNullNever) {}
1002 NormalizedAtom(IO &io, const lld::UndefinedAtom *atom)
1003 : _file(fileFromContext(io)), _name(atom->name()),
1008 const lld::UndefinedAtom *denormalize(IO &io) {
1009 YamlContext *info = reinterpret_cast<YamlContext *>(io.getContext());
1024 const lld::File &fileFromContext(IO &io) {
1025 YamlContext *info = reinterpret_cast<YamlContext *>(io.getContext());
1040 static void mapping(IO &io, const lld::UndefinedAtom *&atom) {
1041 YamlContext *info = reinterpret_cast<YamlContext *>(io.getContext());
1043 io, atom, &info->_file->allocator());
1045 io.mapRequired("name", keys->_name);
1046 io.mapOptional("can-be-null", keys->_canBeNull,
1052 static void mapping(IO &io, lld::UndefinedAtom *&atom) {
1054 MappingTraits<const lld::UndefinedAtom *>::mapping(io, atomPtr);
1063 NormalizedAtom(IO &io)
1064 : _file(fileFromContext(io)), _canBeNull(false),
1067 NormalizedAtom(IO &io, const lld::SharedLibraryAtom *atom)
1068 : _file(fileFromContext(io)), _name(atom->name()),
1074 const lld::SharedLibraryAtom *denormalize(IO &io) {
1075 YamlContext *info = reinterpret_cast<YamlContext *>(io.getContext());
1093 const lld::File &fileFromContext(IO &io) {
1094 YamlContext *info = reinterpret_cast<YamlContext *>(io.getContext());
1115 static void mapping(IO &io, const lld::SharedLibraryAtom *&atom) {
1117 YamlContext *info = reinterpret_cast<YamlContext *>(io.getContext());
1119 keys(io, atom, &info->_file->allocator());
1121 io.mapRequired("name", keys->_name);
1122 io.mapOptional("load-name", keys->_loadName);
1123 io.mapOptional("can-be-null", keys->_canBeNull, (ShlibCanBeNull) false);
1124 io.mapOptional("type", keys->_type, SharedLibraryAtom::Type::Code);
1125 io.mapOptional("size", keys->_size, uint64_t(0));
1130 static void mapping(IO &io, lld::SharedLibraryAtom *&atom) {
1132 MappingTraits<const lld::SharedLibraryAtom *>::mapping(io, atomPtr);
1141 NormalizedAtom(IO &io)
1142 : _file(fileFromContext(io)), _scope(), _value(0) {}
1144 NormalizedAtom(IO &io, const lld::AbsoluteAtom *atom)
1145 : _file(fileFromContext(io)), _name(atom->name()),
1150 const lld::AbsoluteAtom *denormalize(IO &io) {
1151 YamlContext *info = reinterpret_cast<YamlContext *>(io.getContext());
1166 const lld::File &fileFromContext(IO &io) {
1167 YamlContext *info = reinterpret_cast<YamlContext *>(io.getContext());
1185 static void mapping(IO &io, const lld::AbsoluteAtom *&atom) {
1186 YamlContext *info = reinterpret_cast<YamlContext *>(io.getContext());
1188 io, atom, &info->_file->allocator());
1190 if (io.outputting()) {
1192 YamlContext *info = reinterpret_cast<YamlContext *>(io.getContext());
1202 io.mapRequired("name", keys->_name);
1203 io.mapOptional("ref-name", keys->_refName, StringRef());
1204 io.mapOptional("scope", keys->_scope);
1205 io.mapRequired("value", keys->_value);
1210 static void mapping(IO &io, lld::AbsoluteAtom *&atom) {
1212 MappingTraits<const lld::AbsoluteAtom *>::mapping(io, atomPtr);
1220 RefNameResolver::RefNameResolver(const lld::File *file, IO &io) : _io(io) {
1248 MappingTraits<const lld::File *>::NormalizedFile::denormalize(IO &io) {
1252 RefNameResolver nameResolver(this, io);
1279 IO &io, const lld::Reference *ref) {
1282 YamlContext *info = reinterpret_cast<YamlContext *>(io.getContext());
1329 bool handledDocTag(llvm::yaml::IO &io, const lld::File *&file) const override {
1330 if (io.mapTag("!native")) {
1331 MappingTraits<const lld::File *>::mappingAtoms(io, file);
1340 bool handledDocTag(llvm::yaml::IO &io, const lld::File *&file) const override {
1341 if (io.mapTag("!archive")) {
1342 MappingTraits<const lld::File *>::mappingArchive(io, file);