home *** CD-ROM | disk | FTP | other *** search
/ InfoMagic Source Code 1993 July / THE_SOURCE_CODE_CD_ROM.iso / gnu / ae / AE / ae-buffer.c next >
Encoding:
C/C++ Source or Header  |  1990-02-28  |  3.8 KB  |  150 lines
  1. /* AE program profiling system.
  2.    Startup and termination code and routines to manipulate AE buffer.
  3.    Copyright (C) 1989, 1990 by James R. Larus (larus@cs.wisc.edu)
  4.  
  5.    This file must be compiled by GCC!
  6.  
  7.    AE and AEC are free software; you can redistribute it and/or modify it
  8.    under the terms of the GNU General Public License as published by the
  9.    Free Software Foundation; either version 1, or (at your option) any
  10.    later version.
  11.  
  12.    AE and AEC are distributed in the hope that it will be useful, but
  13.    WITHOUT ANY WARRANTY; without even the implied warranty of
  14.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15.    General Public License for more details.
  16.  
  17.    You should have received a copy of the GNU General Public License
  18.    along with GNU CC; see the file COPYING.  If not, write to James R.
  19.    Larus, Computer Sciences Department, University of Wisconsin--Madison,
  20.    1210 West Dayton Street, Madison, WI 53706, USA or to the Free
  21.    Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
  22.  
  23. /* $Header: /var/home/larus/AE/AE/RCS/ae-buffer.c,v 2.0 90/02/09 17:18:53 larus Exp Locker: larus $ */
  24.  
  25.  
  26. #include <sys/file.h>
  27. #include <sys/time.h>
  28. #include <sys/resource.h>
  29. #include "ae.h"
  30. #include "ae-machine.h"
  31.  
  32.  
  33. /* Save pointer to beginning of AE buffer. */
  34.  
  35. char *ae_buffer_base;
  36.  
  37.  
  38. /* Register or variable pointing to next free byte in AE buffer. */
  39.  
  40. #ifdef AE_BUFFER_REG
  41. register char *ae_bp asm (AE_BUFFER_REG);
  42. #elif AE_BUFFER_VAR
  43. char *ae_bp;
  44. #endif
  45.  
  46.  
  47. /* Register or variable pointing to end of AE buffer. */
  48.  
  49. #ifdef AE_BUFFER_BOUND_REG
  50. register char *ae_bound asm(AE_BUFFER_BOUND_REG);
  51. #elif AE_BUFFER_BOUND_VAR
  52. char *ae_bound;
  53. #endif
  54.  
  55.  
  56. /* File descriptor for writing AE buffer. */
  57.  
  58. int ae_fd;
  59.  
  60.  
  61. /* Stack pointer upon entry to AE_INITIALIZE. */
  62.  
  63. static char *old_sp;
  64.  
  65.  
  66.  
  67. /* Initialize by allocating AE buffer on the stack and opening the
  68.    output file. Invoked by AE_START (which is written in assembly
  69.    language). Return the new stack pointer. */
  70.  
  71. char *
  72. ae_initialize (argc, argv)    /* Define main's parameters for compiler */
  73.      int argc;
  74.      char *argv[];
  75. {
  76.   register char *sp asm (SP_REG);
  77.   struct rlimit rl;
  78.  
  79.   /* Raise stacksize limit. */
  80.   getrlimit (RLIMIT_STACK, &rl);
  81.   rl.rlim_cur = rl.rlim_max;
  82.   setrlimit (RLIMIT_STACK, &rl);
  83.  
  84.   ae_fd = open ("ae.out", O_WRONLY | O_CREAT | O_TRUNC, 0644);
  85.  
  86.   /* Make space on stack for AE buffer */
  87. #ifdef AE_BUFFER_STACK_OFFSET
  88.   ae_buffer_base =
  89.     (char *) (STACK_TOP - (AE_BUFFER_SIZE + AE_BUFFER_STACK_OFFSET));
  90. #else
  91.   ae_buffer_base = (char *) (sp - AE_BUFFER_SIZE);
  92. #endif
  93.  
  94.   ae_bp = ae_buffer_base;
  95. #if (defined (AE_BUFFER_BOUND_REG) || defined(AE_BUFFER_BOUND_VAR))
  96.   ae_bound = ae_bp + AE_BUFFER_SIZE - CHUNK_SIZE;
  97. #endif
  98.  
  99.   old_sp = sp;
  100.   *ae_bp = 0;            /* Force OS to extend stack */
  101.   return (sp = (ae_buffer_base - AE_START_FRAME_SIZE));
  102. }
  103.  
  104.  
  105. /* Flush AE buffer by writing its contents to a file and reset the
  106.    buffer pointer.  This routine probably must be written in assembly
  107.    language since it cannot affect ANY register visible to its caller
  108.    (not just the callee-saved registers) since it is called at arbitrary
  109.    points in a function. */
  110.  
  111. #ifdef USE_C_FLUSH_BUFFER
  112. void
  113. ae_flush_buffer ()
  114. {
  115.   char *x[32];            /* Space to store registers */
  116.  
  117.   x[0] = ae_bp;            /* Example */
  118.   write (ae_fd, ae_buffer_base, (int) ae_bp - (int) ae_buffer_base);
  119.   ae_bp = ae_buffer_base;
  120. #ifdef (defined (AE_BUFFER_BOUND_REG) || defined (AE_BUFFER_BOUND_VAR))
  121.   ae_bound = ae_bp + AE_BUFFER_SIZE - 4;
  122. #endif
  123. }
  124. #endif
  125.  
  126.  
  127. /* Clean up at program termination by flushing the remaining events. */
  128.  
  129. void
  130. ae_terminate ()
  131. {
  132.   register char *sp asm (SP_REG);
  133.  
  134.   ae_flush_buffer ();
  135.   close (ae_fd);
  136.   /* Restore the stack pointer. */
  137.   sp = old_sp;
  138. }
  139.  
  140.  
  141. /* Redefine the EXIT routine to call AE_TERMINATE. */
  142.  
  143. exit (code)
  144.      int code;
  145. {
  146.   ae_terminate ();
  147.   _cleanup ();
  148.   _exit (code);
  149. }
  150.