//------------------------------------------------------------------------------
//      Copyright (c) 2003, Ingo Weinhold
//
//      Permission is hereby granted, free of charge, to any person obtaining a
//      copy of this software and associated documentation files (the "Software"),
//      to deal in the Software without restriction, including without limitation
//      the rights to use, copy, modify, merge, publish, distribute, sublicense,
//      and/or sell copies of the Software, and to permit persons to whom the
//      Software is furnished to do so, subject to the following conditions:
//
//      The above copyright notice and this permission notice shall be included in
//      all copies or substantial portions of the Software.
//
//      THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
//      IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
//      FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
//      AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
//      LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
//      FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
//      DEALINGS IN THE SOFTWARE.
//
//      File Name:              ElfImage.cpp
//      Author:                 Ingo Weinhold (bonefish@users.sf.net)
//      Description:    Implementation of ElfImage, a class encapsulating
//                                      a loaded ELF image, providing support for accessing the
//                                      image's symbols and their relocation entries.
//------------------------------------------------------------------------------

#include <new>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include <List.h>

#include <debug/debug_support.h>

#include "ElfImage.h"


static status_t
get_static_image_symbol(image_id image, const char* name, int32 symbolType,
        void** _address)
{
        // try standard lookup first
        status_t error =  get_image_symbol(image, name, symbolType, _address);
        if (error == B_OK)
                return B_OK;

        // get an image info
        image_info imageInfo;
        error = get_image_info(image, &imageInfo);
        if (error != B_OK)
                return error;

        // get a symbol iterator
        debug_symbol_iterator* iterator;
        error = debug_create_file_symbol_iterator(imageInfo.name, &iterator);
        if (error != B_OK)
                return error;

        // get the unrelocated image info
        image_info unrelocatedImageInfo;
        error = debug_get_symbol_iterator_image_info(iterator,
                &unrelocatedImageInfo);
        if (error != B_OK) {
                debug_delete_symbol_iterator(iterator);
                return error;
        }

        // iterate through the symbols
        int32 nameLength = strlen(name);
        while (true) {
                char foundName[nameLength + 1];
                int32 foundType;
                void* foundAddress;
                size_t foundSize;
                if (debug_next_image_symbol(iterator, foundName, nameLength + 1,
                                &foundType, &foundAddress, &foundSize) != B_OK) {
                        debug_delete_symbol_iterator(iterator);
                        return B_ENTRY_NOT_FOUND;
                }

                if (strcmp(foundName, name) == 0
                        && (symbolType == B_SYMBOL_TYPE_ANY || foundType == symbolType)) {
                        *_address = (void*)((addr_t)foundAddress + (addr_t)imageInfo.text
                                - (addr_t)unrelocatedImageInfo.text);
                        debug_delete_symbol_iterator(iterator);
                        return B_OK;
                }
        }
}


// ElfImage

// constructor
ElfImage::ElfImage()
        : fImage(-1),
          fFile(),
          fTextAddress(NULL),
          fDataAddress(NULL),
          fGotAddress(NULL)
{
}

// destructor
ElfImage::~ElfImage()
{
        Unset();
}

// SetTo
status_t
ElfImage::SetTo(image_id image)
{
        Unset();
        status_t error = _SetTo(image);
        if (error)
                Unset();
        return error;
}

// Unset
void
ElfImage::Unset()
{
        fFile.Unset();
        fImage = -1;
        fTextAddress = NULL;
        fDataAddress = NULL;
        fGotAddress = NULL;
}

// Unload
void
ElfImage::Unload()
{
        fFile.Unload();
}

// FindSymbol
status_t
ElfImage::FindSymbol(const char* symbolName, void** address)
{
        return get_image_symbol(fImage, symbolName, B_SYMBOL_TYPE_ANY, address);
}

// GetSymbolRelocations
status_t
ElfImage::GetSymbolRelocations(const char* symbolName, BList* relocations)
{
        status_t error = B_OK;
        ElfRelocation relocation;
        for (ElfRelocationIterator it(&fFile); it.GetNext(&relocation); ) {
                uint32 type = relocation.GetType();
                // get the symbol
                ElfSymbol symbol;
                if ((type == R_GLOB_DAT || type == R_JUMP_SLOT)
                        && relocation.GetSymbol(&symbol) == B_OK
                        && symbol.GetName()) {
                        // only undefined symbols with global binding
                        if ((symbol.GetBinding() == STB_GLOBAL
                                 || symbol.GetBinding() == STB_WEAK)
                                && (symbol.GetTargetSectionIndex() == SHN_UNDEF
                                        || symbol.GetTargetSectionIndex()
                                           >= (uint32)fFile.CountSections())
                                && !strcmp(symbol.GetName(), symbolName)) {
                                // get the address of the GOT entry for the symbol
                                void** gotEntry
                                        = (void**)(fTextAddress + relocation.GetOffset());
                                if (!relocations->AddItem(gotEntry)) {
                                        error = B_NO_MEMORY;
                                        break;
                                }
                        }
                }
        }
        return error;
}


// _SetTo
status_t
ElfImage::_SetTo(image_id image)
{
        // get an image info
        image_info imageInfo;
        status_t error = get_image_info(image, &imageInfo);
        if (error != B_OK)
                return error;
        fImage = imageInfo.id;
        // get the address of global offset table
        error = get_static_image_symbol(image, "_GLOBAL_OFFSET_TABLE_",
                B_SYMBOL_TYPE_ANY, (void**)&fGotAddress);
        if (error != B_OK)
                return error;
        fTextAddress = (uint8*)imageInfo.text;
        fDataAddress = (uint8*)imageInfo.data;
        // init the file
        error = fFile.SetTo(imageInfo.name);
        if (error != B_OK)
                return error;
        return B_OK;
}