compiler/purify/src/stack.c

   1 /*
   2     Copyright © 1995-2014, The AROS Development Team. All rights reserved.
   3     $Id$
   4 */
   5
   6 #include <stdio.h>
   7 #include <assert.h>
   8 #include "debug.h"
   9 #include "hash.h"
  10
  11 static MemHash * Purify_CurrentStackNode;
  12
  13 void Purify_InitStack (char * stackBase, long stackSize)
  14 {
  15     MemHash * node;
  16     char ** argv;
  17     int argc, t;
  18     long offset;
  19
  20     stackBase +=
  21         4 /* two arguments */
  22         +4 /* return address for main() */
  23         +8 /* two arguments for main() */
  24     ;
  25
  26 #if DEBUG
  27     printf ("Stack goes from %p to %p\n", stackBase - stackSize, stackBase);
  28 #endif
  29
  30     node = Purify_AddMemory (stackBase - stackSize
  31         , stackSize
  32         , PURIFY_MemFlag_Empty
  33         , PURIFY_MemType_Stack
  34     );
  35
  36     node->data = "Stack";
  37
  38     Purify_CurrentStackNode = node;
  39
  40     /* Major hack :-/ */
  41     argv = ((char ***)stackBase)[-1];
  42     argc = ((int *)stackBase)[-2];
  43
  44 #if 0
  45     printf ("&argc=%p\n", &((int *)stackBase)[-2]);
  46     printf ("argc=%d argv=%p\n", argc, argv);
  47 #endif
  48
  49     offset = (long)(&((int *)stackBase)[-2]) - (long)(node->mem);
  50
  51     Purify_SetMemoryFlags (node, offset, 8,
  52         PURIFY_MemFlag_Readable|PURIFY_MemFlag_Writable
  53     );
  54
  55     node = Purify_AddMemory (argv
  56         , (argc+1) * sizeof (char *)
  57         , PURIFY_MemFlag_Readable|PURIFY_MemFlag_Writable
  58         , PURIFY_MemType_Stack
  59     );
  60
  61     node->data = "argv[] array";
  62
  63     for (t=0; t<argc; t++)
  64     {
  65         node = Purify_AddMemory (argv[t]
  66             , strlen (argv[t]) + 1
  67             , PURIFY_MemFlag_Readable|PURIFY_MemFlag_Writable
  68             , PURIFY_MemType_Stack
  69         );
  70
  71         node->data = "argument string";
  72     }
  73
  74 #if DEBUG
  75     Purify_PrintMemory ();
  76 #endif
  77 }
  78
  79 void Purify_Push (char * stackBase, long pushSize)
  80 {
  81     long offset;
  82
  83     passert (Purify_CurrentStackNode);
  84     passert (Purify_CurrentStackNode->mem);
  85
  86 #if 0
  87     printf ("Push(): sp=%p, size=%ld fp=%p  stackBase=%p\n",
  88         stackBase, pushSize, (&offset)-1, Purify_CurrentStackNode->mem);
  89 #endif
  90
  91     stackBase += 4;
  92     stackBase -= pushSize;
  93
  94     offset = (long)stackBase - (long)(Purify_CurrentStackNode->mem);
  95
  96 #if 0
  97     printf ("offset=%d\n", offset);
  98 #endif
  99
 100     passert (offset >= 0);
 101
 102     Purify_SetMemoryFlags (Purify_CurrentStackNode, offset, pushSize,
 103         PURIFY_MemFlag_Readable|PURIFY_MemFlag_Writable
 104     );
 105 }
 106
 107 void Purify_Pop (char * stackBase, long popSize)
 108 {
 109     long offset;
 110
 111     passert (Purify_CurrentStackNode);
 112     passert (Purify_CurrentStackNode->mem);
 113
 114     stackBase += 4;
 115
 116     offset = (long)stackBase - (long)(Purify_CurrentStackNode->mem);
 117
 118     passert (offset >= 0);
 119
 120     Purify_SetMemoryFlags (Purify_CurrentStackNode, offset, popSize,
 121         PURIFY_MemFlag_Free
 122     );
 123 }
 124
 125 void Purify_Alloca (char * stackBase, long allocSize)
 126 {
 127     long offset;
 128
 129     passert (Purify_CurrentStackNode);
 130     passert (Purify_CurrentStackNode->mem);
 131
 132 #if 0
 133     printf ("alloca(): sp=%p, size=%ld fp=%p  stackBase=%p\n",
 134         stackBase, allocSize, (&offset)-1, Purify_CurrentStackNode->mem);
 135 #endif
 136
 137     stackBase += 4;
 138     stackBase -= allocSize;
 139
 140     offset = (long)stackBase - (long)(Purify_CurrentStackNode->mem);
 141
 142 #if 0
 143     printf ("offset=%ld\n", offset);
 144 #endif
 145
 146     passert (offset >= 0);
 147
 148     Purify_SetMemoryFlags (Purify_CurrentStackNode, offset, allocSize,
 149         PURIFY_MemFlag_Empty|PURIFY_MemFlag_Writable
 150     );
 151 }
 152
 153 void Purify_MoveSP (char * SP, char * newSP)
 154 {
 155     long dist;
 156
 157     dist = (long)newSP - (long)SP;
 158
 159     if (dist > 0)
 160         Purify_Pop (SP, dist);
 161     else if (dist < 0)
 162         Purify_Alloca (SP, -dist);
 163 }