reference, declaration → definition
definition → references, declarations, derived classes, virtual overrides
reference to multiple definitions → definitions
unreferenced

Derived Classes

  164 class FunctionSymbol : public Symbol {
  226 class OutputSectionSymbol : public Symbol {
  240 class SectionSymbol : public Symbol {
  252 class DataSymbol : public Symbol {
  302 class GlobalSymbol : public Symbol {
  364 class EventSymbol : public Symbol {
  405 class LazySymbol : public Symbol {

References

  108         const ArrayRef<U *> &A,
  110            std::is_convertible<U *const *, T const *>::value>::type * = nullptr)
  127     ArrayRef(const std::vector<U *, A> &Vec,
  129                  std::is_convertible<U *const *, T const *>::value>::type* = 0)

   39   static inline T* getEmptyKey() {
   41     Val <<= PointerLikeTypeTraits<T*>::NumLowBitsAvailable;
   45   static inline T* getTombstoneKey() {
   47     Val <<= PointerLikeTypeTraits<T*>::NumLowBitsAvailable;
   51   static unsigned getHashValue(const T *PtrVal) {
   56   static bool isEqual(const T *LHS, const T *RHS) { return LHS == RHS; }
   56   static bool isEqual(const T *LHS, const T *RHS) { return LHS == RHS; }

   57   static inline bool doit(const From &Val) {
  104   static inline bool doit(const From *Val) {
  106     return isa_impl<To, From>::doit(*Val);
  263 inline typename cast_retty<X, Y *>::ret_type cast(Y *Val) {
  263 inline typename cast_retty<X, Y *>::ret_type cast(Y *Val) {
  265   return cast_convert_val<X, Y*,
  266                           typename simplify_type<Y*>::SimpleType>::doit(Val);
  342 LLVM_NODISCARD inline typename cast_retty<X, Y *>::ret_type dyn_cast(Y *Val) {
  342 LLVM_NODISCARD inline typename cast_retty<X, Y *>::ret_type dyn_cast(Y *Val) {

   56   static inline void *getAsVoidPointer(T *P) { return P; }
   57   static inline T *getFromVoidPointer(void *P) { return static_cast<T *>(P); }
   59   enum { NumLowBitsAvailable = detail::ConstantLog2<alignof(T)>::value };

  425 static Symbol *handleUndefined(StringRef name) {
  426   Symbol *sym = symtab->find(name);
  575   Symbol *sym;
  576   Symbol *real;
  577   Symbol *wrap;
  580 static Symbol *addUndefined(StringRef name) {
  599     Symbol *sym = symtab->find(name);
  603     Symbol *real = addUndefined(saver.save("__real_" + name));
  604     Symbol *wrap = addUndefined(saver.save("__wrap_" + name));
  626   DenseMap<Symbol *, Symbol *> map;
  626   DenseMap<Symbol *, Symbol *> map;
  634     MutableArrayRef<Symbol *> syms = file->getMutableSymbols();
  636       if (Symbol *s = map.lookup(syms[i]))
  727   Symbol *entrySym = nullptr;
  762     Symbol *sym = symtab->find(arg->getValue());

  322     Symbol *sym = file->getSymbol(rel);

   96   const Symbol *sym = symbols[reloc.Index];
  166   const Symbol* sym = nullptr;
  354       if (Symbol *d = createDefined(wasmSym)) {
  391 Symbol *ObjFile::createDefined(const WasmSymbol &sym) {
  438 Symbol *ObjFile::createUndefined(const WasmSymbol &sym, bool isCalledDirectly) {
  516 static Symbol *createBitcodeSymbol(const std::vector<bool> &keptComdats,

   59   ArrayRef<Symbol *> getSymbols() const { return symbols; }
   61   MutableArrayRef<Symbol *> getMutableSymbols() { return symbols; }
   68   std::vector<Symbol *> symbols;
  109   Symbol *getSymbol(const WasmRelocation &reloc) const {
  129   Symbol *getSymbol(uint32_t index) const { return symbols[index]; }
  137   Symbol *createDefined(const WasmSymbol &sym);
  138   Symbol *createUndefined(const WasmSymbol &sym, bool isCalledDirectly);

   78 static void undefine(Symbol *s) {
   91   ArrayRef<Symbol *> syms = f.getSymbols();
   96     Symbol *sym = syms[symNum];

   44   void enqueue(Symbol *sym);
   45   void markSymbol(Symbol *sym);
   54 void MarkLive::enqueue(Symbol *sym) {
   85   for (Symbol *sym : symtab->getSymbols())
  115       Symbol *sym = c->file->getSymbol(reloc.Index);

   19 static bool requiresGOTAccess(const Symbol *sym) {
   23 static bool allowUndefined(const Symbol* sym) {
   35 static void reportUndefined(const Symbol* sym) {
   42 static void addGOTEntry(Symbol *sym) {
   71     Symbol *sym = file->getSymbols()[reloc.Index];

   83 Symbol *SymbolTable::find(StringRef name) {
   90 void SymbolTable::replace(StringRef name, Symbol* sym) {
   95 std::pair<Symbol *, bool> SymbolTable::insertName(StringRef name) {
  109   Symbol *sym = reinterpret_cast<Symbol *>(make<SymbolUnion>());
  117 std::pair<Symbol *, bool> SymbolTable::insert(StringRef name,
  119   Symbol *s;
  129 static void reportTypeError(const Symbol *existing, const InputFile *file,
  153 static void checkGlobalType(const Symbol *existing, const InputFile *file,
  168 static void checkEventType(const Symbol *existing, const InputFile *file,
  190 static void checkDataType(const Symbol *existing, const InputFile *file) {
  210   Symbol *s = find(name);
  239 static bool shouldReplace(const Symbol *existing, InputFile *newFile,
  267 Symbol *SymbolTable::addDefinedFunction(StringRef name, uint32_t flags,
  273   Symbol *s;
  302     Symbol* variant;
  323 Symbol *SymbolTable::addDefinedData(StringRef name, uint32_t flags,
  328   Symbol *s;
  348 Symbol *SymbolTable::addDefinedGlobal(StringRef name, uint32_t flags,
  352   Symbol *s;
  372 Symbol *SymbolTable::addDefinedEvent(StringRef name, uint32_t flags,
  376   Symbol *s;
  426 Symbol *SymbolTable::addUndefinedFunction(StringRef name, StringRef importName,
  436   Symbol *s;
  476 Symbol *SymbolTable::addUndefinedData(StringRef name, uint32_t flags,
  481   Symbol *s;
  496 Symbol *SymbolTable::addUndefinedGlobal(StringRef name, StringRef importName,
  503   Symbol *s;
  523   Symbol *s;
  562 bool SymbolTable::getFunctionVariant(Symbol* sym, const WasmSignature *sig,
  563                                      const InputFile *file, Symbol **out) {
  566   Symbol *variant = nullptr;
  574   for (Symbol* v : variants) {
  602 void SymbolTable::wrap(Symbol *sym, Symbol *real, Symbol *wrap) {
  602 void SymbolTable::wrap(Symbol *sym, Symbol *real, Symbol *wrap) {
  602 void SymbolTable::wrap(Symbol *sym, Symbol *real, Symbol *wrap) {
  624 InputFunction *SymbolTable::replaceWithUnreachable(Symbol *sym,
  640   for (Symbol *sym : getSymbols()) {
  686     std::vector<Symbol *> &variants = pair.second;
  691     for (auto *s: variants) {
  700     for (auto *symbol : variants) {
  717     for (auto *symbol : variants) {

   38   void wrap(Symbol *sym, Symbol *real, Symbol *wrap);
   38   void wrap(Symbol *sym, Symbol *real, Symbol *wrap);
   38   void wrap(Symbol *sym, Symbol *real, Symbol *wrap);
   44   ArrayRef<Symbol *> getSymbols() const { return symVector; }
   46   Symbol *find(StringRef name);
   48   void replace(StringRef name, Symbol* sym);
   52   Symbol *addDefinedFunction(StringRef name, uint32_t flags, InputFile *file,
   54   Symbol *addDefinedData(StringRef name, uint32_t flags, InputFile *file,
   57   Symbol *addDefinedGlobal(StringRef name, uint32_t flags, InputFile *file,
   59   Symbol *addDefinedEvent(StringRef name, uint32_t flags, InputFile *file,
   62   Symbol *addUndefinedFunction(StringRef name, StringRef importName,
   66   Symbol *addUndefinedData(StringRef name, uint32_t flags, InputFile *file);
   67   Symbol *addUndefinedGlobal(StringRef name, StringRef importName,
   92   std::pair<Symbol *, bool> insert(StringRef name, const InputFile *file);
   93   std::pair<Symbol *, bool> insertName(StringRef name);
   95   bool getFunctionVariant(Symbol* sym, const WasmSignature *sig,
   96                           const InputFile *file, Symbol **out);
   97   InputFunction *replaceWithUnreachable(Symbol *sym, const WasmSignature &sig,
  104   std::vector<Symbol *> symVector;
  108   llvm::DenseMap<llvm::CachedHashStringRef, std::vector<Symbol *>> symVariants;

   26 std::string toString(const wasm::Symbol &sym) {
   36 std::string toString(wasm::Symbol::Kind kind) {
   38   case wasm::Symbol::DefinedFunctionKind:
   40   case wasm::Symbol::DefinedDataKind:
   42   case wasm::Symbol::DefinedGlobalKind:
   44   case wasm::Symbol::DefinedEventKind:
   46   case wasm::Symbol::UndefinedFunctionKind:
   48   case wasm::Symbol::UndefinedDataKind:
   50   case wasm::Symbol::UndefinedGlobalKind:
   52   case wasm::Symbol::LazyKind:
   54   case wasm::Symbol::SectionKind:
   56   case wasm::Symbol::OutputSectionKind:
  342 void printTraceSymbol(Symbol *sym) {

  164 class FunctionSymbol : public Symbol {
  166   static bool classof(const Symbol *s) {
  197   static bool classof(const Symbol *s) {
  214   static bool classof(const Symbol *s) {
  226 class OutputSectionSymbol : public Symbol {
  233   static bool classof(const Symbol *s) {
  240 class SectionSymbol : public Symbol {
  245   static bool classof(const Symbol *s) { return s->kind() == SectionKind; }
  252 class DataSymbol : public Symbol {
  254   static bool classof(const Symbol *s) {
  275   static bool classof(const Symbol *s) { return s->kind() == DefinedDataKind; }
  297   static bool classof(const Symbol *s) {
  302 class GlobalSymbol : public Symbol {
  304   static bool classof(const Symbol *s) {
  329   static bool classof(const Symbol *s) {
  344   static bool classof(const Symbol *s) {
  364 class EventSymbol : public Symbol {
  366   static bool classof(const Symbol *s) { return s->kind() == DefinedEventKind; }
  391   static bool classof(const Symbol *s) { return s->kind() == DefinedEventKind; }
  405 class LazySymbol : public Symbol {
  411   static bool classof(const Symbol *s) { return s->kind() == LazyKind; }
  514 void printTraceSymbol(Symbol *sym);
  518 T *replaceSymbol(Symbol *s, ArgT &&... arg) {
  527   Symbol symCopy = *s;
  546 std::string toString(const wasm::Symbol &sym);
  547 std::string toString(wasm::Symbol::Kind kind);

  104 void ImportSection::addGOTEntry(Symbol *sym) {
  113 void ImportSection::addImport(Symbol *sym) {
  156   for (const Symbol *sym : importedSymbols) {
  184   for (const Symbol *sym : gotSymbols) {
  247   for (Symbol *sym : staticGotSymbols)
  252 void GlobalSection::addStaticGOTEntry(Symbol *sym) {
  270   for (const Symbol *sym : staticGotSymbols) {
  391     for (const Symbol *sym : symtabEntries) {
  490 void LinkingSection::addToSymtab(Symbol *sym) {
  512   for (const Symbol *s : out.importSec->importedSymbols) {

  104   void addImport(Symbol *sym);
  105   void addGOTEntry(Symbol *sym);
  121   std::vector<const Symbol *> importedSymbols;
  128   std::vector<const Symbol *> gotSymbols;
  187   void addStaticGOTEntry(Symbol *sym);
  194   std::vector<Symbol *> staticGotSymbols;
  273   void addToSymtab(Symbol *sym);
  276   std::vector<const Symbol *> symtabEntries;

  481   for (Symbol *sym : symtab->getSymbols()) {
  515   for (Symbol *sym : symtab->getSymbols()) {
  552   for (Symbol *sym : symtab->getSymbols())
  558     for (Symbol *sym : file->getSymbols())
  579   for (const Symbol *sym : out.importSec->importedSymbols) {

 1983     { typedef _Up     type; };