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);

    void eraseByElf(Elf *pParent);

    uintptr_t EXPORTED_PUBLIC lookup(
        const HashedStringView &name, Elf *pElf, Policy policy = LocalFirst,
        Binding *pBinding = 0);

  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;

#ifdef THREADS
    Mutex m_Lock;
#endif
};

#endif