compiler/purify/src/init.c

   1 #include <stdio.h>
   2 #include <ctype.h>
   3 #include <errno.h>
   4 #include "memory.h"
   5 #include "hash.h"
   6
   7 #define Purify_Begincode _start
   8
   9 void Purify_Init (void)
  10 {
  11     extern void Purify_Begincode (void);
  12     extern void Purify_Endcode (void);
  13     extern int Purify_Beginrodata;
  14     extern int Purify_Endrodata;
  15     extern int Purify_Beginbss;
  16     extern int Purify_Endbss;
  17     extern int Purify_Begindata;
  18     extern int Purify_Enddata;
  19     extern int * Purify_Beginstaticdata;
  20     extern int * Purify_Endstaticdata;
  21
  22     void * ptr;
  23     int    size;
  24     MemHash * node;
  25
  26     printf ("Purify active\n");
  27
  28     Purify_Filename     = "";
  29     Purify_Functionname = "_start";
  30     Purify_Lineno       = 0;
  31
  32     ptr = (&Purify_Beginrodata)+1;
  33     size = (long)(&Purify_Endrodata) - (long)(&Purify_Beginrodata) - 4;
  34
  35     if (size > 0)
  36     {
  37         node = Purify_AddMemory (ptr
  38             , size
  39             , PURIFY_MemFlag_Readable
  40             , PURIFY_MemType_Data
  41         );
  42
  43         node->data = "rodata";
  44     }
  45
  46     ptr = (&Purify_Beginbss)+1;
  47     size = (long)(&Purify_Endbss) - (long)(&Purify_Beginbss) - 4;
  48
  49     if (size > 0)
  50     {
  51         node = Purify_AddMemory (ptr
  52             , size
  53             , PURIFY_MemFlag_Readable
  54                 | PURIFY_MemFlag_Writable
  55             , PURIFY_MemType_Data
  56         );
  57
  58         node->data = "bss";
  59     }
  60
  61     ptr = (&Purify_Begindata)+1;
  62     size = (long)(&Purify_Enddata) - (long)(&Purify_Begindata) - 4;
  63
  64     if (size > 0)
  65     {
  66         node = Purify_AddMemory (ptr
  67             , size
  68             , PURIFY_MemFlag_Readable
  69                 | PURIFY_MemFlag_Writable
  70             , PURIFY_MemType_Data
  71         );
  72
  73         node->data = "data";
  74     }
  75
  76     size = (long)(Purify_Endstaticdata) - (long)(Purify_Beginstaticdata) - 4;
  77
  78     if (size > 0)
  79     {
  80         node = Purify_AddMemory (Purify_Beginstaticdata+1
  81             , size
  82             , PURIFY_MemFlag_Readable
  83                 | PURIFY_MemFlag_Writable
  84             , PURIFY_MemType_Data
  85         );
  86
  87         node->data = "static data";
  88     }
  89
  90     size = (long)Purify_Endcode - (long)Purify_Begincode;
  91
  92     if (size > 0)
  93     {
  94         node = Purify_AddMemory (Purify_Begincode
  95             , size
  96             , PURIFY_MemFlag_Readable
  97             , PURIFY_MemType_Code
  98         );
  99
 100         node->data = "code";
 101     }
 102
 103     node = Purify_AddMemory (__ctype_b
 104         , sizeof(__ctype_b[0])*256
 105         , PURIFY_MemFlag_Readable
 106         , PURIFY_MemType_Data
 107     );
 108
 109     node->data = "ctype array";
 110
 111     node = Purify_AddMemory (__ctype_tolower
 112         , sizeof(__ctype_tolower[0])*256
 113         , PURIFY_MemFlag_Readable
 114         , PURIFY_MemType_Data
 115     );
 116
 117     node->data = "tolower array";
 118
 119     node = Purify_AddMemory (__ctype_toupper
 120         , sizeof(__ctype_toupper[0])*256
 121         , PURIFY_MemFlag_Readable
 122         , PURIFY_MemType_Data
 123     );
 124
 125     node->data = "toupper array";
 126
 127 #define ADDGLOBAL(var,name) \
 128     node = Purify_AddMemory (&(var)                               \
 129         , sizeof(var)                                             \
 130         , PURIFY_MemFlag_Readable|PURIFY_MemFlag_Writable         \
 131         , PURIFY_MemType_Data                                     \
 132     );                                                            \
 133                                                                   \
 134     node->data = name
 135
 136     ADDGLOBAL(errno,"errno");
 137
 138     node = Purify_AddMemory (stdin
 139         , sizeof(stdin)
 140         , PURIFY_MemFlag_Readable
 141         , PURIFY_MemType_Data
 142     );
 143
 144     node->data = "stdin";
 145
 146     node = Purify_AddMemory (stdout
 147         , sizeof(stdout)
 148         , PURIFY_MemFlag_Readable
 149         , PURIFY_MemType_Data
 150     );
 151
 152     node->data = "stdout";
 153
 154     Purify_PrintMemory ();
 155 }
 156
 157 void Purify_Exit (void)
 158 {
 159     printf ("Purify finished\n");
 160
 161     Purify_MemoryExit ();
 162 }