/*
 * Copyright 2005-2009, Ingo Weinhold, ingo_weinhold@gmx.de.
 * Copyright 2013, Rene Gollent, rene@gollent.com.
 * Distributed under the terms of the MIT License.
 */

#include "SymbolLookup.h"

#include <stdlib.h>
#include <string.h>
#include <unistd.h>

#include <new>

#include <debug_support.h>
#include <runtime_loader.h>
#include <syscalls.h>

#include "Image.h"


#undef TRACE
//#define TRACE_DEBUG_SYMBOL_LOOKUP
#ifdef TRACE_DEBUG_SYMBOL_LOOKUP
#       define TRACE(x) printf x
#else
#       define TRACE(x) ;
#endif


using namespace BPrivate::Debug;


const void *
Area::TranslateAddress(const void *address)
{
        TRACE(("Area::TranslateAddress(%p): area: %" B_PRId32 "\n", address, fLocalID));

        // translate the address
        const void *result = (const void*)((addr_t)address - (addr_t)fRemoteAddress
                + (addr_t)fLocalAddress);

        TRACE(("Area::TranslateAddress(%p) done: %p\n", address, result));

        return result;
}


// #pragma mark -


RemoteMemoryAccessor::RemoteMemoryAccessor(debug_context* debugContext)
        : fDebugContext(debugContext),
          fAreas()
{
}

RemoteMemoryAccessor::~RemoteMemoryAccessor()
{
        // delete the areas
        while (Area *area = fAreas.Head()) {
                fAreas.Remove(area);
                delete area;
        }
}


status_t
RemoteMemoryAccessor::InitCheck() const
{
        // If we don't have a debug context, then there's nothing we can do.
        // SymbolLookup's image file functionality will still be available, though.
        if (fDebugContext == NULL || fDebugContext->nub_port < 0)
                return B_NO_INIT;

        return B_OK;
}


const void *
RemoteMemoryAccessor::PrepareAddress(const void *remoteAddress,
        int32 size)
{
        TRACE(("RemoteMemoryAccessor::PrepareAddress(%p, %" B_PRId32 ")\n",
                remoteAddress, size));

        if (remoteAddress == NULL) {
                TRACE(("RemoteMemoryAccessor::PrepareAddress(): Got null address!\n"));
                throw Exception(B_BAD_VALUE);
        }

        return _GetArea(remoteAddress, size).TranslateAddress(remoteAddress);
}


const void *
RemoteMemoryAccessor::PrepareAddressNoThrow(const void *remoteAddress,
        int32 size)
{
        if (remoteAddress == NULL)
                return NULL;

        Area* area;
        status_t status = _GetAreaNoThrow(remoteAddress, size, area);
        if (status != B_OK)
                return NULL;

        return area->TranslateAddress(remoteAddress);
}


Area*
RemoteMemoryAccessor::AreaForLocalAddress(const void* address) const
{
        if (address == NULL)
                return NULL;

        for (AreaList::ConstIterator it = fAreas.GetIterator(); it.HasNext();) {
                Area* area = it.Next();
                if (area->ContainsLocalAddress(address))
                        return area;
        }

        return NULL;
}


Area &
RemoteMemoryAccessor::_GetArea(const void *address, int32 size)
{
        TRACE(("RemoteMemoryAccessor::_GetArea(%p, %" B_PRId32 ")\n", address,
                size));

        Area* area;
        status_t status = _GetAreaNoThrow(address, size, area);
        if (status != B_OK) {
                TRACE(("RemoteMemoryAccessor::_GetArea(): Failed to get address %p\n",
                        address));
                throw Exception(status);
        }

        return *area;
}


status_t
RemoteMemoryAccessor::_GetAreaNoThrow(const void *address, int32 size, Area *&_area)
{
        for (AreaList::Iterator it = fAreas.GetIterator(); it.HasNext();) {
                Area *area = it.Next();
                if (area->ContainsAddress(address, size)) {
                        _area = area;
                        return B_OK;
                }
        }

        if (InitCheck() != B_OK)
                return B_NO_INIT;

        // we need to clone a new area
        debug_nub_clone_area message;
        message.reply_port = fDebugContext->reply_port;
        message.address = address;

        debug_nub_clone_area_reply reply;
        status_t error = send_debug_message(fDebugContext, B_DEBUG_MESSAGE_CLONE_AREA,
                &message, sizeof(message), &reply, sizeof(reply));
        if (error != B_OK)
                return error;

        area_id localID = reply.area;
        if (localID < 0) {
                TRACE(("RemoteMemoryAccessor: Failed to clone area for %p: %s\n",
                        address, strerror(localID)));
                return localID;
        }

        area_info areaInfo;
        error = get_area_info(localID, &areaInfo);
        if (error < 0) {
                TRACE(("RemoteMemoryAccessor: Failed to get info for %" B_PRId32
                        ": %s\n", localID, strerror(error)));
                return error;
        }

        const addr_t remoteBaseAddress = (addr_t)address
                - ((addr_t)reply.address - (addr_t)areaInfo.address);

        Area *area = new(std::nothrow) Area(localID,
                remoteBaseAddress, areaInfo.address, areaInfo.size);
        if (area == NULL)
                return B_NO_MEMORY;

        fAreas.Add(area);

        _area = area;
        return B_OK;
}


// #pragma mark -


class SymbolLookup::LoadedImage : public Image {
public:
                                                                LoadedImage(SymbolLookup* symbolLookup,
                                                                        const image_info& info,
                                                                        const image_t* image, int32 symbolCount);
        virtual                                         ~LoadedImage();

        virtual const elf_sym*          LookupSymbol(addr_t address,
                                                                        addr_t* _baseAddress,
                                                                        const char** _symbolName,
                                                                        size_t *_symbolNameLen,
                                                                        bool *_exactMatch) const;
        virtual status_t                        NextSymbol(int32& iterator,
                                                                        const char** _symbolName,
                                                                        size_t* _symbolNameLen,
                                                                        addr_t* _symbolAddress, size_t* _symbolSize,
                                                                        int32* _symbolType) const;

private:
                        SymbolLookup*                   fSymbolLookup;
                        const image_t*                  fImage;
                        int32                                   fSymbolCount;
                        size_t                                  fLoadDelta;
};


// #pragma mark -


SymbolLookup::SymbolLookup(debug_context* debugContext, image_id image)
        :
        RemoteMemoryAccessor(debugContext),
        fDebugArea(NULL),
        fImages(),
        fImageID(image)
{
}


SymbolLookup::~SymbolLookup()
{
        while (Image* image = fImages.RemoveHead())
                delete image;
}


status_t
SymbolLookup::Init()
{
        TRACE(("SymbolLookup::Init()\n"));

        status_t error = 0;

        if (RemoteMemoryAccessor::InitCheck() == B_OK) {
                TRACE(("SymbolLookup::Init(): searching debug area...\n"));

                // find the runtime loader debug area
                runtime_loader_debug_area *remoteDebugArea = NULL;
                ssize_t cookie = 0;
                area_info areaInfo;
                while (get_next_area_info(fDebugContext->team, &cookie, &areaInfo) == B_OK) {
                        if (strcmp(areaInfo.name, RUNTIME_LOADER_DEBUG_AREA_NAME) == 0) {
                                remoteDebugArea = (runtime_loader_debug_area*)areaInfo.address;
                                break;
                        }
                }

                if (remoteDebugArea) {
                        TRACE(("SymbolLookup::Init(): found debug area, translating "
                                "address...\n"));
                } else {
                        TRACE(("SymbolLookup::Init(): Couldn't find debug area!\n"));
                }

                // translate the address
                try {
                        if (remoteDebugArea != NULL) {
                                fDebugArea = &Read(*remoteDebugArea);

                                TRACE(("SymbolLookup::Init(): translated debug area is at: %p, "
                                        "loaded_images: %p\n", fDebugArea, fDebugArea->loaded_images));
                        }
                } catch (Exception& exception) {
                        // we can live without the debug area
                }
        }

        image_info imageInfo;
        if (fImageID < 0) {
                // create a list of the team's images
                int32 cookie = 0;
                while (get_next_image_info(fDebugContext->team, &cookie, &imageInfo) == B_OK) {
                        error = _LoadImageInfo(imageInfo);
                        if (error != B_OK)
                                return error;
                }
        } else {
                error = get_image_info(fImageID, &imageInfo);
                if (error != B_OK)
                        return error;

                error = _LoadImageInfo(imageInfo);
                if (error != B_OK)
                        return error;
        }

        return B_OK;
}


status_t
SymbolLookup::LookupSymbolAddress(addr_t address, addr_t *_baseAddress,
        const char **_symbolName, size_t *_symbolNameLen, const char **_imageName,
        bool *_exactMatch) const
{
        TRACE(("SymbolLookup::LookupSymbolAddress(%p)\n", (void*)address));

        Image* image = _FindImageAtAddress(address);
        if (!image)
                return B_ENTRY_NOT_FOUND;

        if (_imageName != NULL)
                *_imageName = image->Name();

        const elf_sym* symbolFound = image->LookupSymbol(address, _baseAddress,
                _symbolName, _symbolNameLen, _exactMatch);

        TRACE(("SymbolLookup::LookupSymbolAddress(): done: symbol: %p, image name: "
                "%s, exact match: %d\n", symbolFound, image->Name(), _exactMatch ? *_exactMatch : -1));

        if (symbolFound != NULL)
                return B_OK;

        // symbol not found -- return the image itself

        if (_baseAddress)
                *_baseAddress = image->TextAddress();

        if (_imageName)
                *_imageName = image->Name();

        if (_symbolName)
                *_symbolName = NULL;

        if (_exactMatch)
                *_exactMatch = false;

        if (_symbolNameLen != NULL)
                *_symbolNameLen = 0;

        return B_OK;
}


status_t
SymbolLookup::InitSymbolIterator(image_id imageID,
        SymbolIterator& iterator) const
{
        TRACE(("SymbolLookup::InitSymbolIterator(): image ID: %" B_PRId32 "\n",
                imageID));

        // find the image
        iterator.image = _FindImageByID(imageID);

        // If that didn't work, find the loaded image.
        if (iterator.image == NULL) {
                TRACE(("SymbolLookup::InitSymbolIterator() done: image not "
                        "found\n"));
                return B_ENTRY_NOT_FOUND;
        }

        iterator.currentIndex = -1;

        return B_OK;
}


status_t
SymbolLookup::InitSymbolIteratorByAddress(addr_t address,
        SymbolIterator& iterator) const
{
        TRACE(("SymbolLookup::InitSymbolIteratorByAddress(): base address: %#lx\n",
                address));

        // find the image
        iterator.image = _FindImageAtAddress(address);
        if (iterator.image == NULL) {
                TRACE(("SymbolLookup::InitSymbolIteratorByAddress() done: image "
                        "not found\n"));
                return B_ENTRY_NOT_FOUND;
        }

        iterator.currentIndex = -1;

        return B_OK;
}


status_t
SymbolLookup::NextSymbol(SymbolIterator& iterator, const char** _symbolName,
        size_t* _symbolNameLen, addr_t* _symbolAddress, size_t* _symbolSize,
        int32* _symbolType) const
{
        return iterator.image->NextSymbol(iterator.currentIndex, _symbolName,
                _symbolNameLen, _symbolAddress, _symbolSize, _symbolType);
}


status_t
SymbolLookup::GetSymbol(image_id imageID, const char* name, int32 symbolType,
        void** _symbolLocation, size_t* _symbolSize, int32* _symbolType) const
{
        Image* image = _FindImageByID(imageID);
        if (image == NULL)
                return B_ENTRY_NOT_FOUND;

        return image->GetSymbol(name, symbolType, _symbolLocation, _symbolSize,
                _symbolType);
}


const image_t *
SymbolLookup::_FindLoadedImageAtAddress(addr_t address)
{
        TRACE(("SymbolLookup::_FindLoadedImageAtAddress(%p)\n", (void*)address));

        if (fDebugArea == NULL)
                return NULL;

        // iterate through the loaded images
        const image_t *_image = Read(fDebugArea->loaded_images->head);
        while (_image != NULL) {
                const image_t *image = &Read(*_image);
                _image = image->next;

                if (image->regions[0].vmstart <= address
                        && address < image->regions[0].vmstart + image->regions[0].size) {
                        return image;
                }
        }

        return NULL;
}


const image_t*
SymbolLookup::_FindLoadedImageByID(image_id id)
{
        TRACE(("SymbolLookup::_FindLoadedImageByID(%" B_PRId32 ")\n", id));

        if (fDebugArea == NULL)
                return NULL;

        // iterate through the loaded images
        const image_t *_image = Read(fDebugArea->loaded_images->head);
        while (_image != NULL) {
                const image_t *image = &Read(*_image);
                _image = image->next;

                if (image->id == id)
                        return image;
        }

        return NULL;
}


Image*
SymbolLookup::_FindImageAtAddress(addr_t address) const
{
        DoublyLinkedList<Image>::ConstIterator it = fImages.GetIterator();
        while (Image* image = it.Next()) {
                addr_t textAddress = image->TextAddress();
                if (address >= textAddress && address < textAddress + image->TextSize())
                        return image;
        }

        return NULL;
}


Image*
SymbolLookup::_FindImageByID(image_id id) const
{
        DoublyLinkedList<Image>::ConstIterator it = fImages.GetIterator();
        while (Image* image = it.Next()) {
                if (image->ID() == id)
                        return image;
        }

        return NULL;
}


size_t
SymbolLookup::_SymbolNameLen(const char* address) const
{
        Area* area = AreaForLocalAddress(address);
        if (area == NULL)
                return 0;

        return strnlen(address, (addr_t)area->LocalAddress() + area->Size()
                - (addr_t)address);
}


status_t
SymbolLookup::_LoadImageInfo(const image_info& imageInfo)
{
        status_t error = B_OK;

        Image* image;
        if (fDebugContext->team == B_SYSTEM_TEAM) {
                // kernel image
                KernelImage* kernelImage = new(std::nothrow) KernelImage;
                if (kernelImage == NULL)
                        return B_NO_MEMORY;

                error = kernelImage->Init(imageInfo);
                image = kernelImage;
        } else if (!strcmp("commpage", imageInfo.name)) {
                // commpage image
                CommPageImage* commPageImage = new(std::nothrow) CommPageImage;
                if (commPageImage == NULL)
                        return B_NO_MEMORY;

                error = commPageImage->Init(imageInfo);
                image = commPageImage;
        } else {
                // userland image -- try to load an image file
                ImageFile* imageFile = new(std::nothrow) ImageFile;
                if (imageFile == NULL)
                        return B_NO_MEMORY;

                error = imageFile->Init(imageInfo);
                image = imageFile;
        }

        if (error != B_OK) {
                // initialization error -- fall back to the loaded image
                delete image;

                const image_t* loadedImage = _FindLoadedImageByID(imageInfo.id);
                if (loadedImage == NULL)
                        return B_OK;

                image = new(std::nothrow) LoadedImage(this, imageInfo,
                        loadedImage, Read(loadedImage->symhash[1]));
                if (image == NULL)
                        return B_NO_MEMORY;

        }

        fImages.Add(image);

        return B_OK;
}

// #pragma mark - LoadedImage


SymbolLookup::LoadedImage::LoadedImage(SymbolLookup* symbolLookup,
        const image_info& info, const image_t* image, int32 symbolCount)
        :
        fSymbolLookup(symbolLookup),
        fImage(image),
        fSymbolCount(symbolCount),
        fLoadDelta(image->regions[0].delta)
{
        fInfo = info;
}


SymbolLookup::LoadedImage::~LoadedImage()
{
}


const elf_sym*
SymbolLookup::LoadedImage::LookupSymbol(addr_t address, addr_t* _baseAddress,
        const char** _symbolName, size_t *_symbolNameLen, bool *_exactMatch) const
{
        TRACE(("LoadedImage::LookupSymbol(): found image: ID: %" B_PRId32 ", text: "
                "address: %p, size: %ld\n", fImage->id,
                (void*)fImage->regions[0].vmstart, fImage->regions[0].size));

        // search the image for the symbol
        const elf_sym *symbolFound = NULL;
        addr_t deltaFound = INT_MAX;
        bool exactMatch = false;
        const char *symbolName = NULL;

        for (int32 i = 0; i < fSymbolCount; i++) {
                const elf_sym *symbol = &fSymbolLookup->Read(fImage->syms[i]);

                // The symbol table contains not only symbols referring to functions
                // and data symbols within the shared object, but also referenced
                // symbols of other shared objects, as well as section and file
                // references. We ignore everything but function and data symbols
                // that have an st_value != 0 (0 seems to be an indication for a
                // symbol defined elsewhere -- couldn't verify that in the specs
                // though).
                if ((symbol->Type() != STT_FUNC && symbol->Type() != STT_OBJECT)
                        || symbol->st_value == 0
                        || (symbol->st_value + symbol->st_size) > (size_t)fInfo.text_size) {
                        continue;
                }

                // skip symbols starting after the given address
                addr_t symbolAddress = symbol->st_value + fLoadDelta;

                if (symbolAddress > address)
                        continue;
                addr_t symbolDelta = address - symbolAddress;

                if (!symbolFound || symbolDelta < deltaFound) {
                        symbolName = (const char*)fSymbolLookup->PrepareAddressNoThrow(
                                SYMNAME(fImage, symbol), 1);
                        if (symbolName == NULL)
                                continue;

                        deltaFound = symbolDelta;
                        symbolFound = symbol;

                        if (symbolDelta >= 0 && symbolDelta < symbol->st_size) {
                                // exact match
                                exactMatch = true;
                                break;
                        }
                }
        }

        TRACE(("LoadedImage::LookupSymbol(): done: symbol: %p, image name: "
                "%s, exact match: %d\n", symbolFound, fImage->name, exactMatch));

        if (symbolFound != NULL) {
                if (_baseAddress)
                        *_baseAddress = symbolFound->st_value + fLoadDelta;
                if (_symbolName)
                        *_symbolName = symbolName;
                if (_exactMatch)
                        *_exactMatch = exactMatch;
                if (_symbolNameLen != NULL)
                        *_symbolNameLen = fSymbolLookup->_SymbolNameLen(symbolName);
        }

        return symbolFound;
}


status_t
SymbolLookup::LoadedImage::NextSymbol(int32& iterator, const char** _symbolName,
        size_t* _symbolNameLen, addr_t* _symbolAddress, size_t* _symbolSize,
        int32* _symbolType) const
{
        while (true) {
                if (++iterator >= fSymbolCount)
                        return B_ENTRY_NOT_FOUND;

                const elf_sym* symbol
                        = &fSymbolLookup->Read(fImage->syms[iterator]);
                if ((symbol->Type() != STT_FUNC && symbol->Type() != STT_OBJECT)
                        || symbol->st_value == 0) {
                        continue;
                }

                *_symbolName = (const char*)fSymbolLookup->PrepareAddressNoThrow(
                        SYMNAME(fImage, symbol), 1);
                *_symbolNameLen = fSymbolLookup->_SymbolNameLen(*_symbolName);
                *_symbolAddress = symbol->st_value + fLoadDelta;
                *_symbolSize = symbol->st_size;
                *_symbolType = symbol->Type() == STT_FUNC ? B_SYMBOL_TYPE_TEXT
                        : B_SYMBOL_TYPE_DATA;

                return B_OK;
        }
}