//=============================================================================
//
//      profile.c
//
//      Support for profiling on x86 synthetic target
//
//=============================================================================
// ####ECOSGPLCOPYRIGHTBEGIN####                                            
// -------------------------------------------                              
// This file is part of eCos, the Embedded Configurable Operating System.   
// Copyright (C) 2003, 2005 Free Software Foundation, Inc.                  
//
// eCos is free software; you can redistribute it and/or modify it under    
// the terms of the GNU General Public License as published by the Free     
// Software Foundation; either version 2 or (at your option) any later      
// version.                                                                 
//
// eCos 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 General Public License    
// for more details.                                                        
//
// You should have received a copy of the GNU General Public License        
// along with eCos; if not, write to the Free Software Foundation, Inc.,    
// 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.            
//
// As a special exception, if other files instantiate templates or use      
// macros or inline functions from this file, or you compile this file      
// and link it with other works to produce a work based on this file,       
// this file does not by itself cause the resulting work to be covered by   
// the GNU General Public License. However the source code for this file    
// must still be made available in accordance with section (3) of the GNU   
// General Public License v2.                                               
//
// This exception does not invalidate any other reasons why a work based    
// on this file might be covered by the GNU General Public License.         
// -------------------------------------------                              
// ####ECOSGPLCOPYRIGHTEND####                                              
//=============================================================================
//#####DESCRIPTIONBEGIN####
//
// Author(s):    bartv
// Contributors: bartv
// Date:         2003-10-12
//
//####DESCRIPTIONEND####
//=============================================================================

#include <pkgconf/system.h>
#ifdef CYGPKG_PROFILE_GPROF
#include <pkgconf/hal_synth.h>
#include <pkgconf/hal_synth_i386.h>
#include <cyg/infra/cyg_type.h>
#include <cyg/infra/cyg_ass.h>
#include <cyg/hal/hal_io.h>
#include <cyg/hal/hal_intr.h>
#include <cyg/profile/profile.h>

#if 1
// Profiling support.
//
// The profile timer uses the ITIMER_PROF, which means we get a SIGPROF
// signal at the desired rate. The signal handler can obtain the address
// of the interrupted code via a sigcontext structure. The contents of
// the sigcontext structure and exactly how it gets passed to the signal
// handler depends on the architecture, hence this code is x86-specific.
//
// The results of this profiling code seem a lot poorer than on other
// targets, but it is not clear why. There may be some subtle
// interaction between the system and profiling clocks.
static void
synth_prof_sighandler(int sig, struct cyg_hal_sys_sigcontext context)
{
    __profile_hit((CYG_ADDRWORD) context.hal_eip);
    CYG_UNUSED_PARAM(int, sig);
}

int
hal_enable_profile_timer(int resolution)
{
    struct cyg_hal_sys_sigaction    action;
    struct cyg_hal_sys_sigset_t     mask;
    struct cyg_hal_sys_itimerval    timer;

    // We want profiling to be an atomic operation. __profile_hit() is
    // a very simple function which should return quickly, and there
    // is no need for a DSR or context switching. Hence everything
    // including SIGIO and SIGALRM are blocked, effectively giving the
    // profiling timer the highest priority.
    action.hal_mask     = 0xffffffff;
    action.hal_flags    = CYG_HAL_SYS_SA_RESTORER;
    action.hal_handler  = (void (*)(int)) &synth_prof_sighandler;
    action.hal_restorer = &cyg_hal_sys_restore;
    
    if (0 != cyg_hal_sys_sigaction(CYG_HAL_SYS_SIGPROF, &action, (struct cyg_hal_sys_sigaction*) 0)) {
        CYG_FAIL("Failed to install signal handler for SIGPROF");
    }

    // The resolution is limited by the underlying 100Hz system clock,
    // there is no hardware timer which can generate faster clock
    // interrupts.
    if (resolution < 10000) {
        resolution = 10000;
    } else {
        resolution  = (resolution + 5000) / 10000;
        resolution *= 10000;
    }
    timer.hal_it_interval.hal_tv_sec    = 0;
    timer.hal_it_interval.hal_tv_usec   = resolution;
    timer.hal_it_value.hal_tv_sec       = 0;
    timer.hal_it_value.hal_tv_usec      = resolution;
    if (0 != cyg_hal_sys_setitimer(CYG_HAL_SYS_ITIMER_PROF, &timer, (struct cyg_hal_sys_itimerval*) 0)) {
        CYG_FAIL("Failed to initialize the profiling itimer");
    }

    // Now unblock SIGPROF
    CYG_HAL_SYS_SIGEMPTYSET(&mask);
    CYG_HAL_SYS_SIGADDSET(&mask, CYG_HAL_SYS_SIGPROF);
    if (0 != cyg_hal_sys_sigprocmask(CYG_HAL_SYS_SIG_UNBLOCK, &mask, (cyg_hal_sys_sigset_t*)0)) {
        CYG_FAIL("Failed to unblock SIGPROF");
    }

    return resolution;
}

#else

// An alternative implementation that overloads the SIGALRM handler
// rather than using SIGPROF. It does not seem to work any better.
static void (*synth_profile_old_alrm_sighandler)(int);

static void
synth_profile_alrm_sighandler(int sig, struct cyg_hal_sys_sigcontext context)
{
    __profile_hit((CYG_ADDRWORD) context.hal_eip);
    (*synth_profile_old_alrm_sighandler)(sig);
}

int
hal_enable_profile_timer(int resolution)
{
    struct cyg_hal_sys_sigaction    action;

    if (0 != cyg_hal_sys_sigaction(CYG_HAL_SYS_SIGALRM, (const struct cyg_hal_sys_sigaction*)0, &action)) {
        CYG_FAIL("Failed to retrieve old signal handler for SIGALRM");
    }
    synth_profile_old_alrm_sighandler   = action.hal_handler;
    action.hal_handler = (void (*)(int)) &synth_profile_alrm_sighandler;
    if (0 != cyg_hal_sys_sigaction(CYG_HAL_SYS_SIGALRM, &action, (struct cyg_hal_sys_sigaction*)0)) {
        CYG_FAIL("Failed to install new signal handler for SIGALRM");
    }

    return CYGNUM_HAL_RTC_PERIOD;
}

#endif

// mcount() can be implemented largely using compiler built-ins. However
// there are two complications. The generic profiling code assumes
// __profile_mcount() is called with interrupts disabled. Blocking interrupts
// won't stop the low-level signal handlers, so mcount() calls from those
// may get lost because of the nesting test but that is fairly harmless.
// Those signal handlers will complete before control returns here, i.e.
// we have strict nesting, so there is no risk of the nested flag remaining
// set while a context switch occurs.  Also if eCos itself is built with
// -pg then the compiler will insert a recursive call to mcount(), and
// we have to guard against that.
void
mcount(void)
{
    static int  nested = 0;
    int         enabled;

    HAL_DISABLE_INTERRUPTS(enabled);
    if (!nested) {
        nested = 1;
        __profile_mcount((CYG_ADDRWORD)__builtin_return_address(1),
                         (CYG_ADDRWORD)__builtin_return_address(0));
        nested = 0;
    }
    HAL_RESTORE_INTERRUPTS(enabled);
}

#endif
