Param Package

Description:

The param package is designed to provide an abstraction for obtaining
the parameters passed to a function.  It allows you to ask "what is the
<n>th argument passed to the function I'm in?"

Files:

h/param_public.h      | Public header file - exported API
h/param_private.h     | Private header file - package use
h/param_arch.h        | Private header file to include arch header file
h/arch/param_<arch>.h | Private architecture dependent header file
  
param.c               | Architecture independent implementations   
param_test.c          | Architecture independent test code
param_signature.c     | Architecture independent implementation
arch/param_<arch>.c   | Architecture dependent implementations

Architecture dependent code and header files are kept in the 'arch'
directories.  The code is designed to achieve ease-of-porting and 
keep the majority of code architecture independent.

Usage:

See param_public.h for details on API usage information.

The general flow of using Param will be:

1] Call RTI_ParamSignatureCreate() for each function that you would like
   to be able to trace.  This can be done in-line or beforehand.  
2] Call RTI_ParamCreate() when you have data for the REG_SET and FPREG_SET
   [if required] for the call.
3] Call RTI_Param<type>Get functions any time after that to retrieve the
   values that RTI_ParamCreate has saved.

Development:

In general, we try to follow the rule:

"Implement the majority of code in an architecture-independent manner.  Do
 this in all cases except where it represents an absurd amount of extra
 overhead.  In this last case, try hard to redesign to encapsulate the
 architecture dependent code."

This provides several advantages:

1] Ease of porting - most code is written for all architecture, and thus
   does not need to be written for each port.
2] Robustness - any fixes to architecture independent code will improve the 
   reliability of all architectures.
3] Testing - test code can be written to test architecture dependent and
   independent code separately, easing the testing burden at each stage of
   integration.

Porting:

When porting to a new architecture:

1] Create a new h/arch/param_<arch>.h header file from the 
   param_h_example.txt file.  Modify the #define at the top to
   reflect your architecture.  Turn on RTI_PARAM_DEV_MODE.  
2] Edit h/param_arch.h to include your new architecture header file
   under the appropriate conditions.
3] Create a new arch/param_<arch>.c file from the param_c_example.txt
   file.  
4] Edit the makefiles to compile your architecture [if necessary].  At
   this point, the code should compile for the new architecture. 
5] Fill in the routines in arch/param_<arch>.c for your architecture
6] Begin testing using RTI_ParamTest to verify proper operation
