llvm/TextAPI/Symbol.h

0001 //===- llvm/TextAPI/Symbol.h - TAPI Symbol ----------------------*- C++ -*-===//
0002 //
0003 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
0004 // See https://llvm.org/LICENSE.txt for license information.
0005 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
0006 //
0007 //===----------------------------------------------------------------------===//
0008
0009 #ifndef LLVM_TEXTAPI_SYMBOL_H
0010 #define LLVM_TEXTAPI_SYMBOL_H
0011
0012 #include "llvm/ADT/BitmaskEnum.h"
0013 #include "llvm/ADT/StringRef.h"
0014 #include "llvm/Support/raw_ostream.h"
0015 #include "llvm/TextAPI/ArchitectureSet.h"
0016 #include "llvm/TextAPI/Target.h"
0017
0018 namespace llvm {
0019 namespace MachO {
0020
0021 // clang-format off
0022
0023 /// Symbol flags.
0024 enum class SymbolFlags : uint8_t {
0025   /// No flags
0026   None             = 0,
0027
0028   /// Thread-local value symbol
0029   ThreadLocalValue = 1U << 0,
0030
0031   /// Weak defined symbol
0032   WeakDefined      = 1U << 1,
0033
0034   /// Weak referenced symbol
0035   WeakReferenced   = 1U << 2,
0036
0037   /// Undefined
0038   Undefined        = 1U << 3,
0039
0040   /// Rexported
0041   Rexported        = 1U << 4,
0042
0043   /// Data Segment
0044   Data             = 1U << 5,
0045
0046   /// Text Segment
0047   Text             = 1U << 6,
0048
0049   LLVM_MARK_AS_BITMASK_ENUM(/*LargestValue=*/Text),
0050 };
0051
0052 // clang-format on
0053
0054 /// Mapping of entry types in TextStubs.
0055 enum class EncodeKind : uint8_t {
0056   GlobalSymbol,
0057   ObjectiveCClass,
0058   ObjectiveCClassEHType,
0059   ObjectiveCInstanceVariable,
0060 };
0061
0062 constexpr StringLiteral ObjC1ClassNamePrefix = ".objc_class_name_";
0063 constexpr StringLiteral ObjC2ClassNamePrefix = "_OBJC_CLASS_$_";
0064 constexpr StringLiteral ObjC2MetaClassNamePrefix = "_OBJC_METACLASS_$_";
0065 constexpr StringLiteral ObjC2EHTypePrefix = "_OBJC_EHTYPE_$_";
0066 constexpr StringLiteral ObjC2IVarPrefix = "_OBJC_IVAR_$_";
0067
0068 /// ObjC Interface symbol mappings.
0069 enum class ObjCIFSymbolKind : uint8_t {
0070   None = 0,
0071   /// Is OBJC_CLASS* symbol.
0072   Class = 1U << 0,
0073   /// Is OBJC_METACLASS* symbol.
0074   MetaClass = 1U << 1,
0075   /// Is OBJC_EHTYPE* symbol.
0076   EHType = 1U << 2,
0077
0078   LLVM_MARK_AS_BITMASK_ENUM(/*LargestValue=*/EHType),
0079 };
0080
0081 using TargetList = SmallVector<Target, 5>;
0082
0083 // Keep containers that hold Targets in sorted order and uniqued.
0084 template <typename C>
0085 typename C::iterator addEntry(C &Container, const Target &Targ) {
0086   auto Iter =
0087       lower_bound(Container, Targ, [](const Target &LHS, const Target &RHS) {
0088         return LHS < RHS;
0089       });
0090   if ((Iter != std::end(Container)) && !(Targ < *Iter))
0091     return Iter;
0092
0093   return Container.insert(Iter, Targ);
0094 }
0095
0096 class Symbol {
0097 public:
0098   Symbol(EncodeKind Kind, StringRef Name, TargetList Targets, SymbolFlags Flags)
0099       : Name(Name), Targets(std::move(Targets)), Kind(Kind), Flags(Flags) {}
0100
0101   void addTarget(Target InputTarget) { addEntry(Targets, InputTarget); }
0102   EncodeKind getKind() const { return Kind; }
0103   StringRef getName() const { return Name; }
0104   ArchitectureSet getArchitectures() const {
0105     return mapToArchitectureSet(Targets);
0106   }
0107   SymbolFlags getFlags() const { return Flags; }
0108
0109   bool isWeakDefined() const {
0110     return (Flags & SymbolFlags::WeakDefined) == SymbolFlags::WeakDefined;
0111   }
0112
0113   bool isWeakReferenced() const {
0114     return (Flags & SymbolFlags::WeakReferenced) == SymbolFlags::WeakReferenced;
0115   }
0116
0117   bool isThreadLocalValue() const {
0118     return (Flags & SymbolFlags::ThreadLocalValue) ==
0119            SymbolFlags::ThreadLocalValue;
0120   }
0121
0122   bool isUndefined() const {
0123     return (Flags & SymbolFlags::Undefined) == SymbolFlags::Undefined;
0124   }
0125
0126   bool isReexported() const {
0127     return (Flags & SymbolFlags::Rexported) == SymbolFlags::Rexported;
0128   }
0129
0130   bool isData() const {
0131     return (Flags & SymbolFlags::Data) == SymbolFlags::Data;
0132   }
0133
0134   bool isText() const {
0135     return (Flags & SymbolFlags::Text) == SymbolFlags::Text;
0136   }
0137
0138   bool hasArchitecture(Architecture Arch) const {
0139     return mapToArchitectureSet(Targets).contains(Arch);
0140   }
0141
0142   bool hasTarget(const Target &Targ) const {
0143     return llvm::is_contained(Targets, Targ);
0144   }
0145
0146   using const_target_iterator = TargetList::const_iterator;
0147   using const_target_range = llvm::iterator_range<const_target_iterator>;
0148   const_target_range targets() const { return {Targets}; }
0149
0150   using const_filtered_target_iterator =
0151       llvm::filter_iterator<const_target_iterator,
0152                             std::function<bool(const Target &)>>;
0153   using const_filtered_target_range =
0154       llvm::iterator_range<const_filtered_target_iterator>;
0155   const_filtered_target_range targets(ArchitectureSet architectures) const;
0156
0157 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
0158   void dump(raw_ostream &OS) const;
0159   void dump() const { dump(llvm::errs()); }
0160 #endif
0161
0162   bool operator==(const Symbol &O) const;
0163
0164   bool operator!=(const Symbol &O) const { return !(*this == O); }
0165
0166   bool operator<(const Symbol &O) const {
0167     return std::tie(Kind, Name) < std::tie(O.Kind, O.Name);
0168   }
0169
0170 private:
0171   StringRef Name;
0172   TargetList Targets;
0173   EncodeKind Kind;
0174   SymbolFlags Flags;
0175 };
0176
0177 /// Lightweight struct for passing around symbol information.
0178 struct SimpleSymbol {
0179   StringRef Name;
0180   EncodeKind Kind;
0181   ObjCIFSymbolKind ObjCInterfaceType;
0182
0183   bool operator<(const SimpleSymbol &O) const {
0184     return std::tie(Name, Kind, ObjCInterfaceType) <
0185            std::tie(O.Name, O.Kind, O.ObjCInterfaceType);
0186   }
0187 };
0188
0189 /// Get symbol classification by parsing the name of a symbol.
0190 ///
0191 /// \param SymName The name of symbol.
0192 SimpleSymbol parseSymbol(StringRef SymName);
0193
0194 } // end namespace MachO.
0195 } // end namespace llvm.
0196
0197 #endif // LLVM_TEXTAPI_SYMBOL_H