/*

 * See the dyninst/COPYRIGHT file for copyright information.

 * 

 * We provide the Paradyn Tools (below described as "Paradyn")

 * on an AS IS basis, and do not warrant its validity or performance.

 * We reserve the right to update, modify, or discontinue this

 * software at any time.  We shall have no obligation to supply such

 * updates or modifications or any other form of support to you.

 * 

 * By your use of Paradyn, you understand and agree that we (or any

 * other person or entity with proprietary rights in Paradyn) are

 * under no obligation to provide either maintenance services,

 * update services, notices of latent defects, or correction of

 * defects for Paradyn.

 * 

 * This library is free software; you can redistribute it and/or

 * modify it under the terms of the GNU Lesser General Public

 * License as published by the Free Software Foundation; either

 * version 2.1 of the License, or (at your option) any later version.

 * 

 * This library is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

 * Lesser General Public License for more details.

 * 

 * You should have received a copy of the GNU Lesser General Public

 * License along with this library; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

 */

#include "dynProcess.h"

#include "dynThread.h"

#include "pcEventHandler.h"

#include "pcEventMuxer.h"

#include "function.h"

#include "os.h"

#include "debug.h"

#include "instPoint.h"

#include "BPatch.h"

#include "mapped_module.h"

#include "baseTramp.h"

#include "registerSpace.h"

#include "mapped_object.h"

#include "image.h"

#include "common/src/pathName.h"

#include "PCErrors.h"

#include "MemoryEmulator/memEmulator.h"

#include <boost/tuple/tuple.hpp>

#include "symtabAPI/h/SymtabReader.h"

#include "patchAPI/h/PatchMgr.h"

#include "patchAPI/h/Point.h"

#include <sstream>

using namespace Dyninst::ProcControlAPI;

using std::map;

using std::vector;

using std::string;

using std::stringstream;

Dyninst::SymtabAPI::SymtabReaderFactory *PCProcess::symReaderFactory_;

PCProcess *PCProcess::createProcess(const string file, pdvector<string> &argv,

                                    BPatch_hybridMode analysisMode,

                                    pdvector<string> &envp,

                                    const string dir, int stdin_fd, int stdout_fd,

                                    int stderr_fd)

{

    // Debugging information

    startup_cerr << "Creating process " << file << " in directory " << dir << endl;

    startup_cerr << "Arguments: (" << argv.size() << ")" << endl;

    for (unsigned a = 0; a < argv.size(); a++)

        startup_cerr << "   " << a << ": " << argv[a] << endl;

    startup_cerr << "Environment: (" << envp.size() << ")" << endl;

    for (unsigned e = 0; e < envp.size(); e++)

        startup_cerr << "   " << e << ": " << envp[e] << endl;

    startup_printf("%s[%d]: stdin: %d, stdout: %d, stderr: %d\n", FILE__, __LINE__,

            stdin_fd, stdout_fd, stderr_fd);

    initSymtabReader();

    // Create a full path to the executable

    string path = createExecPath(file, dir);

    std::map<int, int> fdMap;

    redirectFds(stdin_fd, stdout_fd, stderr_fd, fdMap);

    if( !setEnvPreload(envp, path) ) {

        startup_cerr << "Failed to set environment var to preload RT library" << endl;

        return NULL;

    }

    // Create the ProcControl process

    Process::ptr tmpPcProc = Process::createProcess(path, argv, envp, fdMap);

    if( !tmpPcProc ) {

       cerr << "Failed to create process " << path << endl;

       const char *lastErrMsg = getLastErrorMsg();

        startup_printf("%s[%d]: failed to create process for %s: %s\n", __FILE__,

                __LINE__, file.c_str(), lastErrMsg);

        string msg = string("Failed to create process for ") + file +

           string(": ") + lastErrMsg;

        showErrorCallback(68, msg.c_str());

        return NULL;

    }

    startup_cerr << "Created process " << tmpPcProc->getPid() << endl;

    PCProcess *ret = new PCProcess(tmpPcProc, file, analysisMode);

    assert(ret);

    tmpPcProc->setData(ret);

    if( !ret->bootstrapProcess() ) {

        startup_cerr << "Failed to bootstrap process " << ret->getPid()

                     << ": terminating..." << endl;

        ret->terminateProcess();

        delete ret;

        return NULL;

    }

    return ret;

}

PCProcess *PCProcess::attachProcess(const string &progpath, int pid,

                                    BPatch_hybridMode analysisMode)

{

    initSymtabReader();

    startup_cerr << "Attaching to process " << pid << endl;

    Process::ptr tmpPcProc = Process::attachProcess(pid, progpath);

    if( !tmpPcProc ) {

        const char *lastErrMsg = getLastErrorMsg();

        startup_printf("%s[%d]: Failed to attach process %d: %s\n",

                __FILE__, __LINE__, pid, lastErrMsg);

        stringstream msg;

        msg << "Failed to attach to process " << pid << ": " << lastErrMsg;

        showErrorCallback(26, msg.str());

        return NULL;

    }

    startup_cerr << "Attached to process " << tmpPcProc->getPid() << endl;

    PCProcess *ret = new PCProcess(tmpPcProc, analysisMode);

    assert(ret);

    tmpPcProc->setData(ret);

    ret->runningWhenAttached_ = tmpPcProc->allThreadsRunningWhenAttached();

    ret->file_ = tmpPcProc->libraries().getExecutable()->getAbsoluteName();

    if( !ret->bootstrapProcess() ) {

        startup_cerr << "Failed to bootstrap process " << pid 

                     << ": terminating..." << endl;

        ret->terminateProcess();

        delete ret;

        return NULL;

    }

    return ret;

}

PCProcess *PCProcess::setupForkedProcess(PCProcess *parent, Process::ptr pcProc) {

    startup_printf("%s[%d]: setting up forked process %d\n",

            FILE__, __LINE__, pcProc->getPid());

    PCProcess *ret = new PCProcess(parent, pcProc);

    assert(ret);

    pcProc->setData(ret);

    ret->copyAddressSpace(parent);

    // This requires the AddressSpace be copied from the parent

    if (parent->tracedSyscalls_)

      ret->tracedSyscalls_ = new syscallNotification(parent->tracedSyscalls_, ret);

    else

      ret->tracedSyscalls_ = NULL;

    // Check if RT library exists in child

    if( ret->runtime_lib.size() == 0 ) {

        // Set the RT library name

        if( !ret->getDyninstRTLibName() ) {

            startup_printf("%s[%d]: failed to get Dyninst RT lib name\n",

                    FILE__, __LINE__);

            delete ret;

            return NULL;

        }

        startup_printf("%s[%d]: Got Dyninst RT libname: %s\n", FILE__, __LINE__,

                       ret->dyninstRT_name.c_str());

        for(unsigned i = 0; i < ret->mapped_objects.size(); ++i) {

            const fileDescriptor &desc = ret->mapped_objects[i]->getFileDesc();

            fileDescriptor tmpDesc(ret->dyninstRT_name,

                    desc.code(), desc.data(), true);

            if( desc == tmpDesc ) {

                ret->runtime_lib.insert(ret->mapped_objects[i]);

                break;

            }

        }

    }

    // TODO hybrid mode stuff

    // Copy signal handlers

    pdvector<codeRange *> sigHandlers;

    parent->signalHandlerLocations_.elements(sigHandlers);

    for(unsigned i = 0; i < sigHandlers.size(); ++i) {

        signal_handler_location *oldSig = dynamic_cast<signal_handler_location *>(sigHandlers[i]);

        assert(oldSig);

        signal_handler_location *newSig = new signal_handler_location(*oldSig);

        ret->signalHandlerLocations_.insert(newSig);

    }

    // If required

    if( !ret->copyDanglingMemory(parent) ) {

        startup_printf("%s[%d]: failed to copy dangling memory from parent %d to child %d\n",

                FILE__, __LINE__, parent->getPid(), ret->getPid());

        ret->terminateProcess();

        delete ret;

        return NULL;

    }

    ret->setInEventHandling(true);

    if( !ret->bootstrapProcess() ) {

        startup_cerr << "Failed to bootstrap process " << ret->getPid()

                     << ": terminating..." << endl;

        ret->terminateProcess();

        delete ret;

        return NULL;

    }

    ret->setDesiredProcessState(parent->getDesiredProcessState());

    return ret;

}

PCProcess *PCProcess::setupExecedProcess(PCProcess *oldProc, std::string execPath) {

    BPatch::bpatch->registerExecCleanup(oldProc, NULL);

    PCProcess *newProc = new PCProcess(oldProc->pcProc_, execPath, oldProc->analysisMode_);

    oldProc->pcProc_->setData(newProc);

    newProc->setExecing(true);

    if( !newProc->bootstrapProcess() ) {

        proccontrol_printf("%s[%d]: failed to bootstrap execed process %d\n",

                FILE__, __LINE__, newProc->getPid());

        delete newProc;

        return NULL;

    }

    delete oldProc;

    oldProc = NULL;

    newProc->setInEventHandling(true);

    //newProc->incPendingEvents();

    BPatch::bpatch->registerExecExit(newProc);

    newProc->setExecing(false);

    newProc->setDesiredProcessState(ps_running);

    return newProc;

}

PCProcess::~PCProcess() {

        proccontrol_printf("%s[%d]: destructing PCProcess %d\n",

                FILE__, __LINE__, getPid());

    if( tracedSyscalls_ ) delete tracedSyscalls_;

    tracedSyscalls_ = NULL;

    if( irpcTramp_ ) delete irpcTramp_;

    irpcTramp_ = NULL;

    signalHandlerLocations_.clear();

    trapMapping.clearTrapMappings();

    if(pcProc_ && pcProc_->getData() == this) pcProc_->setData(NULL);

}

void PCProcess::initSymtabReader()

{

   //Set SymbolReaderFactory in Stackwalker before create/attach

   if (!symReaderFactory_) {

      symReaderFactory_ = new Dyninst::SymtabAPI::SymtabReaderFactory();

      Dyninst::Stackwalker::Walker::setSymbolReader(symReaderFactory_);

   }

}

/***************************************************************************

 **** Runtime library initialization code (Dyninst)                     ****

 ***************************************************************************/

/*

 *

 * Gratuitously large comment. This diagrams the startup flow of

 * messages between the mutator and mutatee. Entry points

 * for create and attach process are both given.

 *     Mutator           Signal              Mutatee

 * Create:

 *     Fork/Exec

 *                     <-- Trap              Halted in exec (handled by ProcControlAPI)

 *     Install trap in main

 *                     <-- Trap              Halted in main

 *  Attach: (also paused, not in main)

 *     Install call to dlopen/

 *     LoadLibrary

 *                     <-- Trap              In library load

 *     Set parameters in library

 *                     <-- Trap              Finished loading

 *     Restore code and leave paused

 *     Finalize library

 *       If finalizing fails, init via iRPC

 */

/*

 * In all cases, the process is left paused at the entry of main

 * (create) or where it was (attach). No permanent instrumentation

 * is inserted.

 */

bool PCProcess::hasReachedBootstrapState(bootstrapState_t state) const {

    return state <= bootstrapState_;

}

void PCProcess::setBootstrapState(bootstrapState_t newState) {

    bootstrapState_ = newState;

}

bool PCProcess::bootstrapProcess() {

    assert( pcProc_->allThreadsStopped() );

    startup_printf("%s[%d]: attempting to bootstrap process %d\n", 

            FILE__, __LINE__, getPid());

    if( !wasCreatedViaFork() ) {

        // Initialize the inferior heaps

        initializeHeap();

        for(unsigned i = 0; i < mapped_objects.size(); ++i) {

            addInferiorHeap(mapped_objects[i]);

        }

        // Create the mapped_objects for the executable and shared libraries

        if( !createInitialMappedObjects() ) {

            startup_printf("%s[%d]: bootstrap failed while creating mapped objects\n",

                    FILE__, __LINE__);

            return false;

        }

    }

    // Create the initial threads

    createInitialThreads();

    // Initialize StackwalkerAPI

    if ( !createStackwalker() )

    {

      startup_printf("Bootstrap failed while initializing Stackwalker\n");

      return false;

    }

    // Insert a breakpoint at the entry point of main (and possibly __libc_start_main)

    if( !hasPassedMain() ) {

      startup_printf("%s[%d]: inserting breakpoint at main\n", FILE__, __LINE__);

        if( !insertBreakpointAtMain() ) {

            startup_printf("%s[%d]: bootstrap failed while setting a breakpoint at main\n",

                    FILE__, __LINE__);

            return false;

        }

	startup_printf("%s[%d]: continuing process to breakpoint\n", FILE__, __LINE__);

        if( !continueProcess() ) {

            startup_printf("%s[%d]: bootstrap failed while continuing the process\n",

                    FILE__, __LINE__);

            return false;

        }

        while( !hasReachedBootstrapState(bs_readyToLoadRTLib) ) {

	  startup_printf("%s[%d]: waiting for main() loop\n", FILE__, __LINE__);

            if( isStopped() ) {

	      startup_printf("%s[%d]: We think the process is stopped, continuing\n", FILE__, __LINE__);

                if( !continueProcess() ) {

                    startup_printf("%s[%d]: bootstrap failed while continuing the process\n",

                            FILE__, __LINE__);

                    return false;

                }

            }

            if( isTerminated() ) {

                bperr("The process exited during startup.  This is likely due to one "

                      "of two reasons:\n"

                      "A). The application is mis-built and unable to load.  Try "

                      "running the application outside of Dyninst and see if it "

                      "loads properly.\n"

                      "B). libdyninstAPI_RT is mis-built.  Try loading the library "

                      "into another application and see if it reports any errors.  "

                      "Ubuntu users - You may need to rebuild the RT library "

                      "with the DISABLE_STACK_PROT line enabled in "

                      "core/make.config.local");

                startup_printf("%s[%d]: program exited early, never reached "

                               "initialized state\n", FILE__, __LINE__);

                startup_printf("Error is likely due to the application or RT "

                               "library having missing symbols or dependencies\n");

                return false;

            }

            startup_printf("%s[%d]: bootstrap waiting for process to initialize\n",

                    FILE__, __LINE__);

            if( PCEventMuxer::wait(true) == PCEventMuxer::Error) {

                startup_printf("%s[%d]: bootstrap failed to wait for events\n",

                        FILE__, __LINE__);

                return false;

            }

        }

    }else{

        bootstrapState_ = bs_readyToLoadRTLib;

    }

    startup_printf("%s[%d]: process initialized, loading the RT library\n",

            FILE__, __LINE__);

    // Load the RT library

    if( !loadRTLib() ) {

        bperr("Dyninst was unable to load the dyninst runtime library "

              "into the application.  This may be caused by statically "

              "linked executables, or by having dyninst linked against a "

              "different version of libelf than it was built with.");

        startup_printf("%s[%d]: bootstrap failed to load RT library\n",

                FILE__, __LINE__);

        return false;

    }

    pdvector<int_variable *> obsCostVec;

    if( !findVarsByAll("DYNINSTobsCostLow", obsCostVec) ) {

        startup_printf("%s[%d]: failed to find DYNINSTobsCostLow\n",

                FILE__, __LINE__);

        return false;

    }

    costAddr_ = obsCostVec[0]->getAddress();

    assert(costAddr_);

    if( !wasCreatedViaFork() ) {

        // Install system call tracing

        startup_printf("%s[%d]: installing default Dyninst instrumentation into process %d\n", 

            FILE__, __LINE__, getPid());

        tracedSyscalls_ = new syscallNotification(this);

        // TODO 

        // pre-fork and pre-exit should depend on whether a callback is defined

        // 

        // This will require checking whether BPatch holds a defined callback and also

        // adding a way for BPatch enable this instrumentation in all processes when

        // a callback is registered

        if (!tracedSyscalls_->installPreFork()) {

            startup_printf("%s[%d]: failed pre-fork notification setup\n",

                    FILE__, __LINE__);

            return false;

        }

        if (!tracedSyscalls_->installPostFork()) {

            startup_printf("%s[%d]: failed post-fork notification setup\n",

                    FILE__, __LINE__);

            return false;

        }

        if (!tracedSyscalls_->installPreExec()) {

            startup_printf("%s[%d]: failed pre-exec notification setup\n",

                    FILE__, __LINE__);

            return false;

        }

        if (!tracedSyscalls_->installPostExec()) {

            startup_printf("%s[%d]: failed post-exec notification setup\n",

                    FILE__, __LINE__);

            return false;

        }

        if (!tracedSyscalls_->installPreExit()) {

            startup_printf("%s[%d]: failed pre-exit notification setup\n",

                    FILE__, __LINE__);

            return false;

        }

        if (!tracedSyscalls_->installPreLwpExit()) {

            startup_printf("%s[%d]: failed pre-lwp-exit notification setup\n",

                    FILE__, __LINE__);

            return false;

        }

        // Initialize the MT stuff

        if (multithread_capable()) {

            if( !instrumentMTFuncs() ) {

                startup_printf("%s[%d]: Failed to instrument MT funcs\n",

                        FILE__, __LINE__);

                return false;

            }

        }

    }

    // use heuristics to set hybrid analysis mode

    if (BPatch_heuristicMode == analysisMode_) {

        if (getAOut()->parse_img()->codeObject()->defensiveMode()) {

            analysisMode_ = BPatch_defensiveMode;

        } else {

            analysisMode_ = BPatch_normalMode;

        }

    }

    bootstrapState_ = bs_initialized;

    startup_printf("%s[%d]: finished bootstrapping process %d\n", FILE__, __LINE__, getPid());

    return true;

}

bool PCProcess::createStackwalker()

{

  using namespace Stackwalker;

  ProcDebug *procDebug = NULL;

  StackwalkSymLookup *symLookup = NULL;

  // Create ProcessState

  if (NULL == (procDebug = ProcDebug::newProcDebug(pcProc_)))

  {

    startup_printf("Could not create Stackwalker process state\n");

    return false;

  }

  // Create SymbolLookup

  symLookup = new StackwalkSymLookup(this);

  // Create Walker without default steppers

  if (NULL == (stackwalker_ = Walker::newWalker(procDebug,

                                                NULL,

                                                symLookup,

                                                false)))

  {

    startup_printf("Could not create Stackwalker\n");

    return false;

  }

  return createStackwalkerSteppers();

}

void PCProcess::createInitialThreads() {

    ThreadPool &pcThreads = pcProc_->threads();

    initialThread_ = PCThread::createPCThread(this, pcThreads.getInitialThread());

    addThread(initialThread_);

    for(ThreadPool::iterator i = pcThreads.begin(); i != pcThreads.end(); ++i) {

        if( *i == pcThreads.getInitialThread() ) continue;

        // Wait to create threads until they have user thread information available

        if( !(*i)->haveUserThreadInfo() ) continue;

        PCThread *newThr = PCThread::createPCThread(this, *i);

        addThread(newThr);

    }

}

bool PCProcess::createInitialMappedObjects() {

    if( file_.empty() ) {

        startup_printf("%s[%d]: failed to determine executable for process %d\n",

                FILE__, __LINE__, getPid());

        return false;

    }

    startup_printf("Processing initial shared objects\n");

    startup_printf("----\n");

    initPatchAPI();

    // Do the a.out first...

    mapped_object *aout = mapped_object::createMappedObject(pcProc_->libraries().getExecutable(), this, analysisMode_);

    addASharedObject(aout);

    // Set the RT library name

    if( !getDyninstRTLibName() ) {

      bperr("Dyninst was unable to find the dyninst runtime library.");

        startup_printf("%s[%d]: failed to get Dyninst RT lib name\n",

                FILE__, __LINE__);

        return false;

    }

    // Find main

    startup_printf("%s[%d]:  leave setAOut/setting main\n", FILE__, __LINE__);

    setMainFunction();

    // Create mapped objects for any loaded shared libraries

    const LibraryPool &libraries = pcProc_->libraries();

    for(LibraryPool::const_iterator i = libraries.begin(); i != libraries.end(); ++i) {

       // Some platforms don't use the data load address field

       if ((*i) == libraries.getExecutable()) continue;

       startup_cerr << "Library: " << (*i)->getAbsoluteName() 

            << hex << " / " << (*i)->getLoadAddress() 

            << ", " << ((*i)->isSharedLib() ? "<lib>" : "<aout>") << dec << endl;

       mapped_object *newObj = mapped_object::createMappedObject(*i, 

                                                                 this, analysisMode_);

       if( newObj == NULL ) {

           startup_printf("%s[%d]: failed to create mapped object for library %s\n",

                   FILE__, __LINE__, (*i)->getAbsoluteName().c_str());

           return false;

       }

       const fileDescriptor &desc = newObj->getFileDesc();

       fileDescriptor tmpDesc(dyninstRT_name, desc.code(), desc.data(), true);

       if( desc == tmpDesc ) {

          startup_printf("%s[%d]: RT library already loaded, manual loading not necessary\n",

                         FILE__, __LINE__);

          runtime_lib.insert(newObj);

       }

       if (analysisMode_ == BPatch_defensiveMode) {

           std::string lib_name = newObj->fileName();

           if (lib_name == "dyninstAPI_RT.dll" ||

               lib_name == "ntdll.dll" ||

               lib_name == "kernel32.dll" ||

               lib_name == "user32.dll" ||

               lib_name == "KERNELBASE.dll" ||

               lib_name == "msvcrt.dll" ||

               lib_name == "msvcr80.dll" ||

               lib_name == "msvcr100d.dll" ||

               lib_name == "msvcp100d.dll" ||

               lib_name == "MSVCR100.dll") {

                   startup_cerr << "Running library " << lib_name

                       << " in normal mode because it is trusted.\n";

                   newObj->enableDefensiveMode(false);

           }

       }

       addASharedObject(newObj);

    }

    startup_printf("----\n");

    return true;

}

// creates an image, creates new resources for a new shared object

// adds it to the collection of mapped_objects

void PCProcess::addASharedObject(mapped_object *newObj) {

    assert(newObj);

    addMappedObject(newObj);

    findSignalHandler(newObj);

    startup_printf("%s[%d]: adding shared object %s, addr range 0x%lx to 0x%lx\n",

            FILE__, __LINE__,

            newObj->fileName().c_str(),

            newObj->getBaseAddress(),

            newObj->getBaseAddress() + newObj->get_size());

    parsing_printf("Adding shared object %s, addr range 0x%x to 0x%x\n",

            newObj->fileName().c_str(),

            newObj->getBaseAddress(),

            newObj->getBaseAddress() + newObj->get_size());

    if( heapInitialized_ ) {

        addInferiorHeap(newObj);

    }else{

        startup_printf("%s[%d]: skipping check for new inferior heaps, heap uninitialized\n",

                                       FILE__, __LINE__);

    }

}

void PCProcess::removeASharedObject(mapped_object *obj) {

    // Remove from mapped_objects list

    for (unsigned j = 0; j < mapped_objects.size(); j++) {

        if (obj == mapped_objects[j]) {

            mapped_objects[j] = mapped_objects.back();

            mapped_objects.pop_back();

            deletedObjects_.push_back(obj);

            break;

        }

    }

    if (runtime_lib.end() != runtime_lib.find(obj)) {

        runtime_lib.erase( runtime_lib.find(obj) );

    }

    proccontrol_printf("Removing shared object %s, addr range 0x%x to 0x%x\n",

                  obj->fileName().c_str(),

                  obj->getBaseAddress(),

                  obj->get_size());

    // TODO Signal handler...

}

bool PCProcess::setAOut(fileDescriptor &desc) {

    startup_printf("%s[%d]:  enter setAOut\n", FILE__, __LINE__);

    assert(mapped_objects.size() == 0);

    mapped_object *aout = mapped_object::createMappedObject

                          (desc, this, getHybridMode());

    if (!aout) {

        startup_printf("%s[%d]:  fail setAOut\n", FILE__, __LINE__);

        return false;

    }

    return true;

}

// We keep a vector of all signal handler locations

void PCProcess::findSignalHandler(mapped_object *obj) {

    startup_printf("%s[%d]: findSignalhandler(%p)\n", FILE__, __LINE__, obj);

    assert(obj);

    int_symbol sigSym;

    string signame(SIGNAL_HANDLER);

    startup_printf("%s[%d]: findSignalhandler(%p): gettingSymbolInfo\n", FILE__, __LINE__, obj);

    if (obj->getSymbolInfo(signame, sigSym)) {

        // Symbols often have a size of 0. This b0rks the codeRange code,

        // so override to 1 if this is true...

        unsigned size_to_use = sigSym.getSize();

        if (!size_to_use) size_to_use = 1;

        startup_printf("%s[%d]: findSignalhandler(%p): addingSignalHandler(%p, %d)\n", FILE__, __LINE__, obj, (void *) sigSym.getAddr(), size_to_use);

        addSignalHandler(sigSym.getAddr(), size_to_use);

    }

    startup_printf("%s[%d]: leaving findSignalhandler(%p)\n", FILE__, __LINE__, obj);

}

// NUMBER_OF_MAIN_POSSIBILITIES is defined in image.h

void PCProcess::setMainFunction() {

    assert(!main_function_);

    for (unsigned i = 0; i < NUMBER_OF_MAIN_POSSIBILITIES; i++) {

        main_function_ = findOnlyOneFunction(main_function_names[i]);

        if (main_function_) {

           break;

        }

    }

}

/*

 * Given an image, add all static heaps inside it

 * (DYNINSTstaticHeap...) to the buffer pool.

 */

void PCProcess::addInferiorHeap(mapped_object *obj) {

    pdvector<heapDescriptor> infHeaps;

    /* Get a list of inferior heaps in the new image */

    if (obj->getInfHeapList(infHeaps)) {

        /* Add the vector to the inferior heap structure */

        for (u_int j=0; j < infHeaps.size(); j++) {

            infmalloc_printf("%s[%d]: adding heap at 0x%lx to 0x%lx, name %s\n",

                             FILE__, __LINE__,

                             infHeaps[j].addr(),

                             infHeaps[j].addr() + infHeaps[j].size(),

                             infHeaps[j].name().c_str());

            // platform-specific check to ignore this heap

            if( skipHeap(infHeaps[j]) ) continue;

            heapItem *h = new heapItem (infHeaps[j].addr(), infHeaps[j].size(),

                                        infHeaps[j].type(), false);

            infmalloc_printf("%s[%d]: Adding heap from 0x%lx - 0x%lx (%d bytes, type %d) from mapped object %s\n",

                             FILE__, __LINE__,

                             infHeaps[j].addr(),

                             infHeaps[j].addr() + infHeaps[j].size(),

                             infHeaps[j].size(),

                             infHeaps[j].type(),

                             obj->fileName().c_str());

            addHeap(h);

            // set rtlib heaps (runtime_lib hasn't been set yet)

            if ( ! obj->fullName().compare( dyninstRT_name ) ) {

                dyninstRT_heaps_.push_back(h);

            }

        }

    }

}

static const unsigned MAX_THREADS = 32; // Should match MAX_THREADS in RTcommon.c

bool PCProcess::loadRTLib() {

    // Check if the RT library has already been loaded

   if( runtime_lib.size() != 0 ) {

      startup_printf("%s[%d]: RT library already loaded\n",

                     FILE__, __LINE__);

      bootstrapState_ = bs_loadedRTLib;

   }

   else {

     if (!pcProc_->addLibrary(dyninstRT_name)) {

       startup_printf("%s[%d]: failed to start loading RT lib\n", FILE__,

		      __LINE__);

       return false;

     }

     bootstrapState_ = bs_loadedRTLib;

     // Process the library load (we hope)

     PCEventMuxer::handle(this);

     if( runtime_lib.size() == 0 ) {

       startup_printf("%s[%d]: failed to load RT lib\n", FILE__,

		      __LINE__);

       return false;

     }

     bootstrapState_ = bs_loadedRTLib;

   }

   int loaded_ok = 0;

   pdvector<int_variable *> vars;

   if (!findVarsByAll("DYNINSThasInitialized", vars)) {

        startup_printf("%s[%d]: no DYNINSThasInitialized variable\n", FILE__, __LINE__);

		return false;

   }

   if (!readDataWord((void*)vars[0]->getAddress(), sizeof(int), (void *)&loaded_ok, false)) {

        startup_printf("%s[%d]: readDataWord failed\n", FILE__, __LINE__);

        return false;

   }

   if(!loaded_ok)

   {

	   startup_printf("%s[%d]: DYNINSTinit not called automatically\n", FILE__, __LINE__);

   }

   startup_printf("%s[%d]: DYNINSTinit succeeded\n", FILE__, __LINE__);

   return setRTLibInitParams();

}

// Set up the parameters for DYNINSTinit in the RT lib

bool PCProcess::setRTLibInitParams() {

    startup_printf("%s[%d]: welcome to PCProcess::setRTLibInitParams\n",

            FILE__, __LINE__);

    int pid = P_getpid();

    // Now we write these variables into the following global vrbles

    // in the dyninst library:

    // libdyninstAPI_RT_init_localCause

    // libdyninstAPI_RT_init_localPid

    pdvector<int_variable *> vars;

    if (!findVarsByAll("libdyninstAPI_RT_init_localPid", vars)) {

        if (!findVarsByAll("_libdyninstAPI_RT_init_localPid", vars)) {

            startup_printf("%s[%d]: could not find necessary internal variable\n",

                    FILE__, __LINE__);

            return false;

        }

    }

    assert(vars.size() >= 1);

    if (!writeDataWord((void*)vars[0]->getAddress(), sizeof(int), (void *)&pid)) {

        startup_printf("%s[%d]: writeDataWord failed\n", FILE__, __LINE__);

        return false;

    }

    vars.clear();

    if (!findVarsByAll("libdyninstAPI_RT_init_maxthreads", vars)) {

        if (!findVarsByAll("_libdyninstAPI_RT_init_maxthreads", vars)) {

            startup_printf("%s[%d]: could not find necessary internal variable\n",

                    FILE__, __LINE__);

            return false;

        }