82using AttrToTargets = std::map<std::string, TargetList>;
83using TargetsToSymbols =
124std::array<StringRef, 64> Keys = {
136 "compatibility_versions",
144 "reexported_libraries",
148 "reexported_symbols",
163 return {
"invalid ", Keys[
Key],
" section"};
167 return {
"missing ", Keys[
Key],
" information"};
172 JSONStubError(
Twine ErrMsg) : Message(ErrMsg.str()) {}
183template <
typename JsonT,
typename StubT = JsonT>
185 TBDKey Key,
const Object *Obj,
186 std::function<std::optional<JsonT>(
const Object *,
StringRef)> GetValue,
187 std::function<std::optional<StubT>(JsonT)> Validate =
nullptr) {
188 std::optional<JsonT> Val = GetValue(Obj, Keys[Key]);
190 return make_error<JSONStubError>(getParseErrorMsg(Key));
192 if (Validate ==
nullptr)
193 return static_cast<StubT
>(*Val);
195 std::optional<StubT>
Result = Validate(*Val);
197 return make_error<JSONStubError>(getParseErrorMsg(Key));
201template <
typename JsonT,
typename StubT = JsonT>
203 TBDKey Key,
const Object *Obj,
204 std::function<std::optional<JsonT>(
const Object *,
StringRef)> GetValue,
205 StubT DefaultValue, std::function<std::optional<StubT>(JsonT)> Validate) {
206 std::optional<JsonT> Val = GetValue(Obj, Keys[Key]);
210 std::optional<StubT>
Result;
213 return make_error<JSONStubError>(getParseErrorMsg(Key));
217Error collectFromArray(TBDKey Key,
const Object *Obj,
219 bool IsRequired =
false) {
220 const auto *Values = Obj->
getArray(Keys[Key]);
223 return make_error<JSONStubError>(getParseErrorMsg(Key));
227 for (
const Value &Val : *Values) {
228 auto ValStr = Val.getAsString();
229 if (!ValStr.has_value())
230 return make_error<JSONStubError>(getParseErrorMsg(Key));
231 Append(ValStr.value());
240 auto VersionOrErr = getRequiredValue<int64_t, FileType>(
242 [](int64_t Val) -> std::optional<FileType> {
243 unsigned Result = Val;
246 return FileType::TBD_V5;
251 return *VersionOrErr;
255 const auto *Targets = Section->getArray(Keys[TBDKey::Targets]);
257 return make_error<JSONStubError>(getParseErrorMsg(TBDKey::Targets));
260 for (
const Value &JSONTarget : *Targets) {
261 auto TargetStr = JSONTarget.getAsString();
262 if (!TargetStr.has_value())
263 return make_error<JSONStubError>(getParseErrorMsg(TBDKey::Target));
266 return make_error<JSONStubError>(getParseErrorMsg(TBDKey::Target));
269 return std::move(IFTargets);
273 const Array *Targets = Section->getArray(Keys[TBDKey::TargetInfo]);
275 return make_error<JSONStubError>(getParseErrorMsg(TBDKey::Targets));
278 for (
const Value &JSONTarget : *Targets) {
279 const auto *Obj = JSONTarget.getAsObject();
281 return make_error<JSONStubError>(getParseErrorMsg(TBDKey::Target));
285 return make_error<JSONStubError>(getParseErrorMsg(TBDKey::Target));
288 return make_error<JSONStubError>(getParseErrorMsg(TBDKey::Target));
290 auto VersionStr = Obj->
getString(Keys[TBDKey::Deployment]);
292 if (VersionStr && Version.tryParse(*VersionStr))
293 return make_error<JSONStubError>(getParseErrorMsg(TBDKey::Deployment));
294 TargetOrErr->MinDeployment = Version;
301 return std::move(IFTargets);
304Error collectSymbolsFromSegment(
const Object *Segment, TargetsToSymbols &Result,
306 auto Err = collectFromArray(
307 TBDKey::Globals, Segment, [&Result, &SectionFlag](
StringRef Name) {
308 JSONSymbol
Sym = {SymbolKind::GlobalSymbol,
Name.str(), SectionFlag};
309 Result.back().second.emplace_back(
Sym);
314 Err = collectFromArray(
315 TBDKey::ObjCClass, Segment, [&Result, &SectionFlag](
StringRef Name) {
316 JSONSymbol
Sym = {SymbolKind::ObjectiveCClass,
Name.str(), SectionFlag};
317 Result.back().second.emplace_back(
Sym);
322 Err = collectFromArray(TBDKey::ObjCEHType, Segment,
324 JSONSymbol
Sym = {SymbolKind::ObjectiveCClassEHType,
325 Name.str(), SectionFlag};
326 Result.back().second.emplace_back(
Sym);
331 Err = collectFromArray(
332 TBDKey::ObjCIvar, Segment, [&Result, &SectionFlag](
StringRef Name) {
333 JSONSymbol
Sym = {SymbolKind::ObjectiveCInstanceVariable,
Name.str(),
335 Result.back().second.emplace_back(
Sym);
342 (((SectionFlag & SymbolFlags::Undefined) == SymbolFlags::Undefined)
343 ? SymbolFlags::WeakReferenced
344 : SymbolFlags::WeakDefined);
345 Err = collectFromArray(
347 JSONSymbol
Sym = {SymbolKind::GlobalSymbol,
Name.str(), WeakFlag};
348 Result.back().second.emplace_back(
Sym);
353 Err = collectFromArray(
354 TBDKey::ThreadLocal, Segment, [&Result, SectionFlag](
StringRef Name) {
355 JSONSymbol
Sym = {SymbolKind::GlobalSymbol,
Name.str(),
356 SymbolFlags::ThreadLocalValue | SectionFlag};
357 Result.back().second.emplace_back(
Sym);
366 const Array *Section = File->getArray(Keys[TBDKey::InstallName]);
368 return make_error<JSONStubError>(getParseErrorMsg(TBDKey::InstallName));
370 assert(!Section->empty() &&
"unexpected missing install name");
372 const auto *Obj = Section->front().getAsObject();
374 return make_error<JSONStubError>(getParseErrorMsg(TBDKey::InstallName));
382 const Array *Section = File->getArray(Keys[Key]);
384 return TargetsToSymbols();
388 case TBDKey::Reexports:
389 SectionFlag = SymbolFlags::Rexported;
391 case TBDKey::Undefineds:
392 SectionFlag = SymbolFlags::Undefined;
395 SectionFlag = SymbolFlags::None;
399 TargetsToSymbols Result;
401 for (
auto Val : *Section) {
402 auto *Obj = Val.getAsObject();
406 auto TargetsOrErr = getTargets(Obj);
408 MappedTargets = Targets;
411 MappedTargets = *TargetsOrErr;
414 std::make_pair(std::move(MappedTargets), std::vector<JSONSymbol>()));
416 auto *DataSection = Obj->
getObject(Keys[TBDKey::Data]);
417 auto *TextSection = Obj->
getObject(Keys[TBDKey::Text]);
419 if (!DataSection && !TextSection)
420 return make_error<JSONStubError>(getParseErrorMsg(Key));
423 auto Err = collectSymbolsFromSegment(DataSection, Result,
424 SectionFlag | SymbolFlags::Data);
426 return std::move(Err);
429 auto Err = collectSymbolsFromSegment(TextSection, Result,
430 SectionFlag | SymbolFlags::Text);
432 return std::move(Err);
436 return std::move(Result);
442 auto *Section = File->getArray(Keys[Key]);
444 return AttrToTargets();
446 AttrToTargets Result;
448 for (
auto Val : *Section) {
449 auto *Obj = Val.getAsObject();
453 auto TargetsOrErr = getTargets(Obj);
455 MappedTargets = Targets;
458 MappedTargets = *TargetsOrErr;
461 collectFromArray(SubKey, Obj, [&Result, &MappedTargets](
StringRef Key) {
462 Result[Key.str()] = MappedTargets;
465 return std::move(Err);
468 return std::move(Result);
473 const auto *Umbrella = File->getArray(Keys[TBDKey::ParentUmbrella]);
475 return AttrToTargets();
477 AttrToTargets Result;
479 for (
auto Val : *Umbrella) {
480 auto *Obj = Val.getAsObject();
482 return make_error<JSONStubError>(
483 getParseErrorMsg(TBDKey::ParentUmbrella));
486 auto TargetsOrErr = getTargets(Obj);
488 MappedTargets = Targets;
491 MappedTargets = *TargetsOrErr;
497 return UmbrellaOrErr.takeError();
498 Result[UmbrellaOrErr->str()] = Targets;
500 return std::move(Result);
504 const Array *Versions = File->getArray(Keys[TBDKey::SwiftABI]);
508 for (
const auto &Val : *Versions) {
509 const auto *Obj = Val.getAsObject();
511 return make_error<JSONStubError>(getParseErrorMsg(TBDKey::SwiftABI));
514 return getRequiredValue<int64_t, uint8_t>(TBDKey::ABI, Obj,
522 const Array *Versions = File->getArray(Keys[Key]);
526 for (
const auto &Val : *Versions) {
527 const auto *Obj = Val.getAsObject();
529 return make_error<JSONStubError>(getParseErrorMsg(Key));
531 auto ValidatePV = [](
StringRef Version) -> std::optional<PackedVersion> {
539 return getRequiredValue<StringRef, PackedVersion>(
549 const Array *Section = File->getArray(Keys[TBDKey::Flags]);
550 if (!Section || Section->empty())
553 for (
auto &Val : *Section) {
555 const auto *Obj = Val.getAsObject();
557 return make_error<JSONStubError>(getParseErrorMsg(TBDKey::Flags));
560 collectFromArray(TBDKey::Attributes, Obj, [&Flags](
StringRef Flag) {
563 .
Case(
"flat_namespace", TBDFlags::FlatNamespace)
564 .
Case(
"not_app_extension_safe",
565 TBDFlags::NotApplicationExtensionSafe)
566 .
Case(
"sim_support", TBDFlags::SimulatorSupport)
567 .
Case(
"not_for_dyld_shared_cache",
568 TBDFlags::OSLibNotForSharedCache)
574 return std::move(FlagsOrErr);
582using IFPtr = std::unique_ptr<InterfaceFile>;
584 auto TargetsOrErr = getTargetsSection(File);
586 return TargetsOrErr.takeError();
589 auto NameOrErr = getNameSection(File);
591 return NameOrErr.takeError();
594 auto CurrVersionOrErr = getPackedVersion(File, TBDKey::CurrentVersion);
595 if (!CurrVersionOrErr)
596 return CurrVersionOrErr.takeError();
599 auto CompVersionOrErr = getPackedVersion(File, TBDKey::CompatibilityVersion);
600 if (!CompVersionOrErr)
601 return CompVersionOrErr.takeError();
604 auto SwiftABIOrErr = getSwiftVersion(File);
606 return SwiftABIOrErr.takeError();
607 uint8_t SwiftABI = *SwiftABIOrErr;
611 return FlagsOrErr.takeError();
614 auto UmbrellasOrErr = getUmbrellaSection(File, Targets);
616 return UmbrellasOrErr.takeError();
617 AttrToTargets Umbrellas = *UmbrellasOrErr;
620 getLibSection(File, TBDKey::AllowableClients, TBDKey::Clients, Targets);
622 return ClientsOrErr.takeError();
623 AttrToTargets Clients = *ClientsOrErr;
626 getLibSection(File, TBDKey::ReexportLibs, TBDKey::Names, Targets);
628 return RLOrErr.takeError();
629 AttrToTargets ReexportLibs = std::move(*RLOrErr);
631 auto RPathsOrErr = getLibSection(File, TBDKey::RPath, TBDKey::Paths, Targets);
633 return RPathsOrErr.takeError();
634 AttrToTargets RPaths = std::move(*RPathsOrErr);
636 auto ExportsOrErr = getSymbolSection(File, TBDKey::Exports, Targets);
638 return ExportsOrErr.takeError();
639 TargetsToSymbols Exports = std::move(*ExportsOrErr);
641 auto ReexportsOrErr = getSymbolSection(File, TBDKey::Reexports, Targets);
643 return ReexportsOrErr.takeError();
644 TargetsToSymbols Reexports = std::move(*ReexportsOrErr);
646 auto UndefinedsOrErr = getSymbolSection(File, TBDKey::Undefineds, Targets);
647 if (!UndefinedsOrErr)
648 return UndefinedsOrErr.takeError();
649 TargetsToSymbols Undefineds = std::move(*UndefinedsOrErr);
652 F->setInstallName(
Name);
653 F->setCurrentVersion(CurrVersion);
654 F->setCompatibilityVersion(CompVersion);
655 F->setSwiftABIVersion(SwiftABI);
656 F->setTwoLevelNamespace(!(Flags & TBDFlags::FlatNamespace));
657 F->setApplicationExtensionSafe(
658 !(Flags & TBDFlags::NotApplicationExtensionSafe));
659 F->setSimulatorSupport((Flags & TBDFlags::SimulatorSupport));
660 F->setOSLibNotForSharedCache((Flags & TBDFlags::OSLibNotForSharedCache));
661 for (
auto &
T : Targets)
663 for (
auto &[
Lib, Targets] : Clients)
664 for (
auto Target : Targets)
666 for (
auto &[
Lib, Targets] : ReexportLibs)
667 for (
auto Target : Targets)
669 for (
auto &[
Lib, Targets] : Umbrellas)
670 for (
auto Target : Targets)
672 for (
auto &[
Path, Targets] : RPaths)
673 for (
auto Target : Targets)
675 for (
auto &[Targets, Symbols] : Exports)
676 for (
auto &
Sym : Symbols)
677 F->addSymbol(
Sym.Kind,
Sym.Name, Targets,
Sym.Flags);
678 for (
auto &[Targets, Symbols] : Reexports)
679 for (
auto &
Sym : Symbols)
680 F->addSymbol(
Sym.Kind,
Sym.Name, Targets,
Sym.Flags);
681 for (
auto &[Targets, Symbols] : Undefineds)
682 for (
auto &
Sym : Symbols)
683 F->addSymbol(
Sym.Kind,
Sym.Name, Targets,
Sym.Flags);
689 std::vector<IFPtr> IFs;
690 const Array *Files = File->getArray(Keys[TBDKey::Documents]);
692 return std::move(IFs);
694 for (
auto Lib : *Files) {
695 auto IFOrErr = parseToInterfaceFile(
Lib.getAsObject());
697 return IFOrErr.takeError();
698 auto IF = std::move(*IFOrErr);
699 IFs.emplace_back(std::move(IF));
701 return std::move(IFs);
709 auto ValOrErr =
parse(JSON);
711 return ValOrErr.takeError();
713 auto *Root = ValOrErr->getAsObject();
714 auto VersionOrErr = StubParser::getVersion(Root);
716 return VersionOrErr.takeError();
720 auto IFOrErr = StubParser::parseToInterfaceFile(MainLib);
722 return IFOrErr.takeError();
723 (*IFOrErr)->setFileType(Version);
724 std::unique_ptr<InterfaceFile> IF(std::move(*IFOrErr));
726 auto IFsOrErr = StubParser::getInlinedLibs(Root);
728 return IFsOrErr.takeError();
729 for (
auto &File : *IFsOrErr) {
730 File->setFileType(Version);
731 IF->addDocument(std::shared_ptr<InterfaceFile>(std::move(File)));
733 return std::move(IF);
738template <
typename ContainerT = Array>
739bool insertNonEmptyValues(
Object &Obj, TBDKey Key, ContainerT &&Contents) {
740 if (Contents.empty())
742 Obj[Keys[Key]] = std::move(Contents);
747 std::string PlatformStr = Targ.
Platform == PLATFORM_MACCATALYST
753template <
typename AggregateT>
754std::vector<std::string> serializeTargets(
const AggregateT Targets,
756 std::vector<std::string> TargetsStr;
757 if (Targets.size() == ActiveTargets.
size())
761 TargetsStr.emplace_back(getFormattedStr(
Target));
768 for (
const auto Targ : ActiveTargets) {
772 TargetInfo[Keys[TBDKey::Target]] = getFormattedStr(Targ);
778template <
typename ValueT,
typename EntryT = ValueT>
789using TargetsToValuesMap =
790 std::map<std::vector<std::string>, std::vector<std::string>>;
792template <
typename AggregateT = TargetsToValuesMap>
793Array serializeAttrToTargets(AggregateT &Entries, TBDKey Key) {
795 for (
const auto &[Targets, Values] : Entries) {
797 insertNonEmptyValues(Obj, TBDKey::Targets, std::move(Targets));
798 Obj[Keys[
Key]] = Values;
804template <
typename ValueT = std::string,
805 typename AggregateT = std::vector<std::pair<MachO::Target, ValueT>>>
806Array serializeField(TBDKey Key,
const AggregateT &Values,
807 const TargetList &ActiveTargets,
bool IsArray =
true) {
808 std::map<ValueT, std::set<MachO::Target>> Entries;
809 for (
const auto &[
Target, Val] : Values)
810 Entries[Val].insert(
Target);
813 std::map<std::vector<std::string>, std::string> FinalEntries;
814 for (
const auto &[Val, Targets] : Entries)
815 FinalEntries[serializeTargets(Targets, ActiveTargets)] = Val;
816 return serializeAttrToTargets(FinalEntries, Key);
819 TargetsToValuesMap FinalEntries;
820 for (
const auto &[Val, Targets] : Entries)
821 FinalEntries[serializeTargets(Targets, ActiveTargets)].emplace_back(Val);
822 return serializeAttrToTargets(FinalEntries, Key);
825Array serializeField(TBDKey Key,
const std::vector<InterfaceFileRef> &Values,
827 TargetsToValuesMap FinalEntries;
828 for (
const auto &
Ref : Values) {
830 FinalEntries[serializeTargets(Targets, ActiveTargets)].emplace_back(
831 Ref.getInstallName());
833 return serializeAttrToTargets(FinalEntries, Key);
838 std::vector<StringRef> Weaks;
839 std::vector<StringRef> Globals;
840 std::vector<StringRef> TLV;
841 std::vector<StringRef> ObjCClasses;
842 std::vector<StringRef> IVars;
843 std::vector<StringRef> EHTypes;
846 return Weaks.empty() && Globals.empty() && TLV.empty() &&
847 ObjCClasses.empty() && IVars.empty() && EHTypes.empty();
856 auto AssignForSymbolType = [](SymbolFields::SymbolTypes &Assignment,
859 case SymbolKind::ObjectiveCClass:
862 case SymbolKind::ObjectiveCClassEHType:
863 Assignment.EHTypes.emplace_back(
Sym->
getName());
865 case SymbolKind::ObjectiveCInstanceVariable:
866 Assignment.IVars.emplace_back(
Sym->
getName());
868 case SymbolKind::GlobalSymbol: {
870 Assignment.Weaks.emplace_back(
Sym->
getName());
874 Assignment.Globals.emplace_back(
Sym->
getName());
880 std::map<std::vector<std::string>, SymbolFields> Entries;
881 for (
const auto *
Sym : Symbols) {
884 auto JSONTargets = serializeTargets(Targets, ActiveTargets);
886 AssignForSymbolType(Entries[std::move(JSONTargets)].Data,
Sym);
888 AssignForSymbolType(Entries[std::move(JSONTargets)].
Text,
Sym);
893 auto InsertSymbolsToJSON = [](
Object &SymSection, TBDKey SegmentKey,
894 SymbolFields::SymbolTypes &SymField) {
895 if (SymField.empty())
898 insertNonEmptyValues(Segment, TBDKey::Globals, std::move(SymField.Globals));
899 insertNonEmptyValues(Segment, TBDKey::ThreadLocal, std::move(SymField.TLV));
900 insertNonEmptyValues(Segment, TBDKey::Weak, std::move(SymField.Weaks));
901 insertNonEmptyValues(Segment, TBDKey::ObjCClass,
902 std::move(SymField.ObjCClasses));
903 insertNonEmptyValues(Segment, TBDKey::ObjCEHType,
904 std::move(SymField.EHTypes));
905 insertNonEmptyValues(Segment, TBDKey::ObjCIvar, std::move(SymField.IVars));
906 insertNonEmptyValues(SymSection, SegmentKey, std::move(Segment));
910 for (
auto &[Targets, Fields] : Entries) {
912 insertNonEmptyValues(AllSyms, TBDKey::Targets, std::move(Targets));
913 InsertSymbolsToJSON(AllSyms, TBDKey::Data, Fields.Data);
914 InsertSymbolsToJSON(AllSyms, TBDKey::Text, Fields.Text);
918 return SymbolSection;
924 if (!
File->isTwoLevelNamespace())
925 Flags.emplace_back(
"flat_namespace");
926 if (!
File->isApplicationExtensionSafe())
927 Flags.emplace_back(
"not_app_extension_safe");
928 if (
File->hasSimulatorSupport())
929 Flags.emplace_back(
"sim_support");
930 if (
File->isOSLibNotForSharedCache())
931 Flags.emplace_back(
"not_for_dyld_shared_cache");
932 return serializeScalar(TBDKey::Attributes, std::move(Flags));
940 if (!insertNonEmptyValues(Library, TBDKey::TargetInfo,
941 serializeTargetInfo(ActiveTargets)))
942 return make_error<JSONStubError>(getSerializeErrorMsg(TBDKey::TargetInfo));
944 Array Name = serializeScalar<StringRef>(TBDKey::Name,
File->getInstallName());
945 if (!insertNonEmptyValues(Library, TBDKey::InstallName, std::move(
Name)))
946 return make_error<JSONStubError>(getSerializeErrorMsg(TBDKey::InstallName));
950 insertNonEmptyValues(Library, TBDKey::Flags, std::move(Flags));
952 Array CurrentV = serializeScalar<PackedVersion, std::string>(
954 insertNonEmptyValues(Library, TBDKey::CurrentVersion, std::move(CurrentV));
956 Array CompatV = serializeScalar<PackedVersion, std::string>(
958 insertNonEmptyValues(Library, TBDKey::CompatibilityVersion,
961 Array SwiftABI = serializeScalar<uint8_t, int64_t>(
962 TBDKey::ABI,
File->getSwiftABIVersion(), 0u);
963 insertNonEmptyValues(Library, TBDKey::SwiftABI, std::move(SwiftABI));
965 Array RPaths = serializeField(TBDKey::Paths,
File->rpaths(), ActiveTargets);
966 insertNonEmptyValues(Library, TBDKey::RPath, std::move(RPaths));
968 Array Umbrellas = serializeField(TBDKey::Umbrella,
File->umbrellas(),
969 ActiveTargets,
false);
970 insertNonEmptyValues(Library, TBDKey::ParentUmbrella, std::move(Umbrellas));
973 serializeField(TBDKey::Clients,
File->allowableClients(), ActiveTargets);
974 insertNonEmptyValues(Library, TBDKey::AllowableClients, std::move(Clients));
977 serializeField(TBDKey::Names,
File->reexportedLibraries(), ActiveTargets);
978 insertNonEmptyValues(Library, TBDKey::ReexportLibs, std::move(ReexportLibs));
981 Array Exports = serializeSymbols(
File->exports(), ActiveTargets);
982 insertNonEmptyValues(Library, TBDKey::Exports, std::move(Exports));
984 Array Reexports = serializeSymbols(
File->reexports(), ActiveTargets);
985 insertNonEmptyValues(Library, TBDKey::Reexports, std::move(Reexports));
987 if (!
File->isTwoLevelNamespace()) {
988 Array Undefineds = serializeSymbols(
File->undefineds(), ActiveTargets);
989 insertNonEmptyValues(Library, TBDKey::Undefineds, std::move(Undefineds));
992 return std::move(Library);
996 assert(FileKind == FileType::TBD_V5 &&
"unexpected json file format version");
999 auto MainLibOrErr = serializeIF(File);
1001 return MainLibOrErr;
1002 Root[Keys[TBDKey::MainLibrary]] = std::move(*MainLibOrErr);
1004 for (
const auto &Doc :
File->documents()) {
1005 auto LibOrErr = serializeIF(Doc.get());
1011 Root[Keys[TBDKey::TBDVersion]] = 5;
1012 insertNonEmptyValues(Root, TBDKey::Documents, std::move(Documents));
1013 return std::move(Root);
1022 auto TextFile = getJSON(&File, FileKind);
1024 return TextFile.takeError();
This file supports working with JSON data.
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
This file implements the StringSwitch template, which mimics a switch() statement whose cases are str...
static uint32_t getFlags(const Symbol *Sym)
virtual std::error_code convertToErrorCode() const =0
Convert this error to a std::error_code.
virtual void log(raw_ostream &OS) const =0
Print an error message to an output stream.
Base class for user error types.
Lightweight error class with error context and mandatory checking.
static ErrorSuccess success()
Create a success value.
Tagged union holding either a T or a Error.
Error takeError()
Take ownership of the stored error.
Defines the interface file.
std::pair< bool, bool > parse64(StringRef Str)
bool isWeakDefined() const
const_target_range targets() const
bool isThreadLocalValue() const
SymbolKind getKind() const
StringRef getName() const
bool isWeakReferenced() const
static llvm::Expected< Target > create(StringRef Target)
VersionTuple MinDeployment
SmallString - A SmallString is just a SmallVector with methods and accessors that make it work better...
void push_back(const T &Elt)
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
StringRef - Represent a constant reference to a string, i.e.
A switch()-like statement whose cases are string literals.
StringSwitch & Case(StringLiteral S, T Value)
Target - Wrapper for Target specific information.
Triple - Helper class for working with autoconf configuration names.
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
LLVM Value Representation.
Represents a version number in the form major[.minor[.subminor[.build]]].
std::string getAsString() const
Retrieve a string representation of the version number.
bool empty() const
Determine whether this version information is empty (e.g., all version components are zero).
A range adaptor for a pair of iterators.
An Array is a JSON array, which contains heterogeneous JSON values.
void emplace_back(Args &&...A)
An Object is a JSON object, which maps strings to heterogenous JSON values.
const json::Object * getObject(StringRef K) const
std::optional< llvm::StringRef > getString(StringRef K) const
std::optional< int64_t > getInteger(StringRef K) const
const json::Array * getArray(StringRef K) const
A "cursor" marking a position within a Value.
This class implements an extremely fast bulk output stream that can only output to a stream.
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
std::string getTargetTripleName(const Target &Targ)
FileType
Defines the file type this file represents.
StringRef getArchitectureName(Architecture Arch)
Convert an architecture slice to a string.
std::string getOSAndEnvironmentName(PlatformType Platform, std::string Version="")
Error serializeInterfaceFileToJSON(raw_ostream &OS, const InterfaceFile &File, const FileType FileKind, bool Compact)
Expected< std::unique_ptr< InterfaceFile > > getInterfaceFileFromJSON(StringRef JSON)
This is an optimization pass for GlobalISel generic memory operations.
auto formatv(const char *Fmt, Ts &&... Vals) -> formatv_object< decltype(std::make_tuple(detail::build_format_adapter(std::forward< Ts >(Vals))...))>
std::error_code inconvertibleErrorCode()
The value returned by this function can be returned from convertToErrorCode for Error values where no...
@ Ref
The access may reference the value stored in memory.
void consumeError(Error Err)
Consume a Error without doing anything.