SymbolTable.h

/*
 * Copyright (c) 2008-2014, Pedigree Developers
 *
 * Please see the CONTRIB file in the root of the source tree for a full
 * list of contributors.
 *
 * Permission to use, copy, modify, and distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */
 
#ifndef KERNEL_LINKER_SYMBOLTABLE_H
#define KERNEL_LINKER_SYMBOLTABLE_H
 
#include "pedigree/kernel/compiler.h"
#include "pedigree/kernel/process/Mutex.h"
#include "pedigree/kernel/processor/types.h"
#include "pedigree/kernel/utilities/HashTable.h"
#include "pedigree/kernel/utilities/SharedPointer.h"
#include "pedigree/kernel/utilities/String.h"
#include "pedigree/kernel/utilities/StringView.h"
#include "pedigree/kernel/utilities/Tree.h"
#include "pedigree/kernel/utilities/utility.h"
 
class Elf;
 
class SymbolTable {
 public:
  enum Binding { Local, Global, Weak };
 
  enum Policy {
    LocalFirst,        
    NotOriginatingElf  
  };
 
  SymbolTable(Elf* pElf);
  ~SymbolTable();
 
  SymbolTable(const SymbolTable& symtab);
 
  void copyTable(Elf* pNewElf, const SymbolTable& newSymtab);
 
  void insert(const String& name, Binding binding, Elf* pParent, uintptr_t value);
 
  void insertMultiple(SymbolTable* pOther, const String& name, Binding binding, Elf* pParent,
                      uintptr_t value);
 
  void preallocate(size_t numGlobal, size_t numWeak, Elf* localElf, size_t numLocal);
  void preallocateAdditional(size_t numGlobal, size_t numWeak, Elf* localElf, size_t numLocal);
 
  bool hasPreallocated() const;
 
  void eraseByElf(Elf* pParent);
 
  uintptr_t EXPORTED_PUBLIC lookup(const HashedStringView& name, Elf* pElf,
                                   Policy policy = LocalFirst, Binding* pBinding = 0);
 
  uintptr_t lookupOwned(const HashedStringView& name, Elf* owner);
 
 private:
  SymbolTable& operator=(const SymbolTable&);
 
  class Symbol {
   public:
    Symbol() : m_pParent(0), m_Binding(Global), m_Value(0) {}
    Symbol(Elf* pP, Binding b, uintptr_t v) : m_pParent(pP), m_Binding(b), m_Value(v) {}
 
    Elf* getParent() const {
      return m_pParent;
    }
    Binding getBinding() const {
      return m_Binding;
    }
    uintptr_t getValue() const {
      return m_Value;
    }
 
   private:
    Elf* m_pParent;
    Binding m_Binding;
    uintptr_t m_Value;
  };
 
  SharedPointer<Symbol> doInsert(const String& name, Binding binding, Elf* pParent,
                                 uintptr_t value);
  void insertShared(const String& name, SharedPointer<Symbol>& symbol);
 
  typedef HashTable<String, SharedPointer<Symbol>, HashedStringView> symbolTree_t;
  typedef Tree<Elf*, SharedPointer<symbolTree_t>> parentedSymbolTree_t;
 
  symbolTree_t* getOrInsertTree(Elf*, Binding table = Local);
 
  parentedSymbolTree_t m_LocalSymbols;
  parentedSymbolTree_t m_GlobalSymbols;
  parentedSymbolTree_t m_WeakSymbols;
 
  Elf* m_pOriginatingElf;
 
  mutable Mutex m_Lock;
 
  bool m_bPreallocated;
};
 
#endif