symtab.hh

Go to the documentation of this file.

/*
 * Copyright (c) 2023 Arm Limited
 * All rights reserved
 *
 * The license below extends only to copyright in the software and shall
 * not be construed as granting a license to any other intellectual
 * property including but not limited to intellectual property relating
 * to a hardware implementation of the functionality of the software
 * licensed hereunder.  You may use the software subject to the license
 * terms below provided that you ensure that this notice is replicated
 * unmodified and in its entirety in all distributions of the software,
 * modified or unmodified, in source code or in binary form.
 *
 * Copyright (c) 2021 Daniel R. Carvalho
 * Copyright (c) 2002-2005 The Regents of The University of Michigan
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are
 * met: redistributions of source code must retain the above copyright
 * notice, this list of conditions and the following disclaimer;
 * redistributions in binary form must reproduce the above copyright
 * notice, this list of conditions and the following disclaimer in the
 * documentation and/or other materials provided with the distribution;
 * neither the name of the copyright holders nor the names of its
 * contributors may be used to endorse or promote products derived from
 * this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
 
#ifndef __BASE_LOADER_SYMTAB_HH__
#define __BASE_LOADER_SYMTAB_HH__
 
#include <functional>
#include <iosfwd>
#include <map>
#include <memory>
#include <string>
#include <vector>
 
#include "base/compiler.hh"
#include "base/types.hh"
#include "sim/serialize.hh"
 
namespace gem5
{
 
namespace loader
{
 
class Symbol
{
  public:
    enum class Binding
    {
        Global,
        Local,
        Weak
    };
 
    // The ELF64_ST_TYPE field of gelf's st_info
    enum class SymbolType
    {
        NoType,
        Object,
        Function,
        Section,
        File,
        Other
    };
 
    Symbol(const Binding binding, const SymbolType type,
           const std::string & name, const Addr addr, const size_t size)
        : _binding(binding), _type(type), _name(name), _address(addr),
          _size(size), _sizeIsValid(true)
    {}
 
    Symbol(const Binding binding, const SymbolType type,
           const std::string & name, const Addr addr)
        : _binding(binding), _type(type), _name(name), _address(addr),
          _size(0x0), _sizeIsValid(false)
    {}
 
    Symbol(const Symbol & other) = default;
    Symbol & operator=(const Symbol & other) = default;
 
    Binding binding() const {
        return _binding;
    }
 
    SymbolType type() const {
        return _type;
    }
 
    std::string name() const {
        return _name;
    }
 
    void rename(const std::string & new_name) {
        _name = new_name;
    }
 
    Addr address() const {
        return _address;
    }
 
    void relocate(const Addr new_addr) {
        _address = new_addr;
    }
 
    size_t sizeOrDefault(const size_t default_size) const {
        return _sizeIsValid ? _size : default_size;
    }
 
    bool sizeIsValid() const {
        return _sizeIsValid;
    }
 
  private:
    Binding _binding;
    SymbolType _type;
    std::string _name;
    Addr _address;
    size_t _size;
    bool _sizeIsValid;
};
 
 
class SymbolTable
{
  public:
    typedef std::shared_ptr<SymbolTable> SymbolTablePtr;
 
  private:
    typedef std::vector<Symbol> SymbolVector;
    typedef std::multimap<Addr, int> AddrMap;
    typedef std::map<std::string, int> NameMap;
 
    SymbolVector symbols;
    AddrMap addrMap;
    NameMap nameMap;
 
    bool
    upperBound(Addr addr, AddrMap::const_iterator &iter) const
    {
        // find first key *larger* than desired address
        iter = addrMap.upper_bound(addr);
 
        // if very first key is larger, we're out of luck
        if (iter == addrMap.begin())
            return false;
 
        return true;
    }
 
    typedef std::function<void(SymbolTable &symtab,
                               const Symbol &symbol)> SymTabOp;
 
    SymbolTablePtr
    operate(SymTabOp op) const
    {
        SymbolTablePtr symtab(new SymbolTable);
        for (const auto &symbol: symbols)
            op(*symtab, symbol);
        return symtab;
    }
 
    typedef std::function<bool(const Symbol &symbol)> SymTabFilter;
 
    SymbolTablePtr
    filter(SymTabFilter filter) const
    {
        SymTabOp apply_filter =
            [filter](SymbolTable &symtab, const Symbol &symbol) {
            if (filter(symbol)) {
                symtab.insert(symbol);
            }
        };
        return operate(apply_filter);
    }
 
    SymbolTablePtr
    filterByBinding(Symbol::Binding binding) const
    {
        auto filt = [binding](const Symbol &symbol) {
            return symbol.binding() == binding;
        };
        return filter(filt);
    }
 
    SymbolTablePtr
    filterBySymbolType(const Symbol::SymbolType& symbol_type) const
    {
        auto filt = [symbol_type](const Symbol &symbol) {
            return symbol.type() == symbol_type;
        };
        return filter(filt);
    }
 
  public:
    typedef SymbolVector::iterator iterator;
    typedef SymbolVector::const_iterator const_iterator;
 
    const_iterator begin() const { return symbols.begin(); }
 
    const_iterator end() const { return symbols.end(); }
 
    void clear();
 
    bool insert(const Symbol &symbol);
 
    bool insert(const SymbolTable &other);
 
    bool empty() const { return symbols.empty(); }
 
    SymbolTablePtr
    offset(Addr addr_offset) const
    {
        SymTabOp op =
            [addr_offset](SymbolTable &symtab, const Symbol &symbol) {
                symtab.insert(
                    Symbol(symbol.binding(), symbol.type(), symbol.name(),
                           symbol.address() + addr_offset));
            };
        return operate(op);
    }
 
    SymbolTablePtr
    mask(Addr m) const
    {
        SymTabOp op = [m](SymbolTable &symtab, const Symbol &symbol) {
            symtab.insert(
                Symbol(symbol.binding(), symbol.type(), symbol.name(),
                       symbol.address() & m));
        };
        return operate(op);
    }
 
    SymbolTablePtr
    rename(std::function<std::string (const std::string&)> func) const
    {
        SymTabOp op = [func](SymbolTable &symtab, const Symbol &symbol) {
            Symbol sym = symbol;
            sym.rename(func(sym.name()));
            symtab.insert(sym);
        };
        return operate(op);
    }
 
    SymbolTablePtr
    globals() const
    {
        return filterByBinding(Symbol::Binding::Global);
    }
 
    SymbolTablePtr
    locals() const
    {
        return filterByBinding(Symbol::Binding::Local);
    }
 
    SymbolTablePtr
    weaks() const
    {
        return filterByBinding(Symbol::Binding::Weak);
    }
 
    SymbolTablePtr
    functionSymbols() const
    {
        return filterBySymbolType(Symbol::SymbolType::Function);
    }
 
    void serialize(const std::string &base, CheckpointOut &cp) const;
 
    void unserialize(const std::string &base, CheckpointIn &cp,
                     Symbol::Binding default_binding=Symbol::Binding::Global);
 
    const_iterator
    find(Addr address) const
    {
        AddrMap::const_iterator i = addrMap.find(address);
        if (i == addrMap.end())
            return end();
 
        // There are potentially multiple symbols that map to the same
        // address. For simplicity, just return the first one.
        return symbols.begin() + i->second;
    }
 
    const_iterator
    find(const std::string &name) const
    {
        NameMap::const_iterator i = nameMap.find(name);
        if (i == nameMap.end())
            return end();
 
        return symbols.begin() + i->second;
    }
 
    const_iterator
    findNearest(Addr addr, Addr &next_addr) const
    {
        AddrMap::const_iterator i = addrMap.end();
        if (!upperBound(addr, i))
            return end();
 
        // If there is no next address, make it 0 since 0 is not larger than
        // any other address, so it is clear that next is not valid
        if (i == addrMap.end()) {
            next_addr = 0;
        } else {
            next_addr = i->first;
        }
        --i;
        return symbols.begin() + i->second;
    }
 
    const_iterator
    findNearest(Addr addr) const
    {
        AddrMap::const_iterator i = addrMap.end();
        if (!upperBound(addr, i))
            return end();
 
        --i;
        return symbols.begin() + i->second;
    }
};
 
extern SymbolTable debugSymbolTable;
 
} // namespace loader
} // namespace gem5
 
#endif // __BASE_LOADER_SYMTAB_HH__