Ignore:
Timestamp:
Nov 6, 2005, 7:07:59 PM (17 years ago)
Author:
Sam Hocevar
Message:
  • fixed int size issues here and there
File:
1 edited

Legend:

Unmodified
Added
Removed
  • abuse/trunk/src/imlib/jmalloc.cpp

    r4 r7  
    22#include <string.h>
    33#include <stdio.h>
     4#include <stdint.h>
    45
    56#include <specs.hpp>
    67//#include <new.h>
    78
     9#define MEM_CHECK
    810//#ifdef MEM_CHECK
    911//#define MEM_CLEAR
     
    1820
    1921#ifdef MEM_CHECK
    20 long break_mem_point=0;       // can be set in debugger, break mem fun will be called when this address is allocated
     22intptr_t break_mem_point=0;       // can be set in debugger, break mem fun will be called when this address is allocated
    2123void break_mem_fun()
    2224{
     
    3840struct small_block
    3941
    40   unsigned long size;                     // size of blocks...
    41   unsigned long alloc_list;               // bit field saying weither each block is allocated or not.
    42   small_block *next;                      // next small block of same size
     42  unsigned long size;             // size of blocks...
     43  uint32_t alloc_list;            // bit field saying weither each block is allocated or not.
     44  small_block *next;              // next small block of same size
    4345#ifdef MEM_CHECK
    4446  char *name[32];
     
    144146      while (s)
    145147      {
    146                                 for (x=0;x<32;x++)
    147                                   if (s->alloc_list&(1<<x))
    148                                     static_list[size]++;
    149                        
    150                                 s=s->next;
     148        for (x=0;x<32;x++)
     149          if (s->alloc_list&(1<<x))
     150            static_list[size]++;
     151
     152        s=s->next;
    151153      }
    152154
     
    154156      while (s)
    155157      {
    156                                 for (x=0;x<32;x++)
    157                                   if (s->alloc_list&(1<<x))
    158                                     cache_list[size]++;
    159                        
    160                                 s=s->next;
     158        for (x=0;x<32;x++)
     159          if (s->alloc_list&(1<<x))
     160            cache_list[size]++;
     161
     162        s=s->next;
    161163      }
    162164    }
     
    177179      for (int j=0;j<32;j++)
    178180      {
    179                                 if (s->alloc_list&bit)
    180                                 {
    181                                   void *next=(void *)(*(((long *)addr)));
    182                                   if ((long)next!=(long)s)
    183                                   {
    184                                     fprintf(stderr,"inspect : bad pointer\n");
    185                                     return ;       
    186                                   }
    187                                 }
    188                                 bit=bit<<1;
    189                                 addr+=s->size+4;
     181        if (s->alloc_list&bit)
     182        {
     183          void *next=(void *)(*(((intptr_t *)addr)));
     184          if ((intptr_t)next!=(intptr_t)s)
     185          {
     186            fprintf(stderr,"inspect : bad pointer\n");
     187            return ;       
     188          }
     189        }
     190        bit=bit<<1;
     191        addr+=s->size+4;
    190192      }
    191193    }
     
    215217    {     
    216218      fprintf(fp,"*** Small Block size = %d ***\n",i);     
    217       unsigned long bit=1;
    218       char *addr=((char *)(s+1));
    219       for (int j=0;j<32;j++)
    220       {
    221                                 fprintf(fp,"%p   ",addr);
    222                                 if (s->alloc_list&bit)
    223                                 {
    224 #ifdef MEM_CHECK
    225                                   fprintf(fp,"%s\n",s->name[j]);
    226 #else
    227                                   fprintf(fp,"allocated\n");
    228 #endif   
    229                                 } else fprintf(fp,"FREE\n");
    230                                 bit=bit<<1;
    231                                 addr+=s->size+4;
    232       }
    233     }
    234   }
    235 
    236 
    237   fprintf(fp,"************** CACHE SPACE ******************\n",block_size);
    238   i=0;
    239   for (f=cfirst;f;f=f->next,i++)
    240   {   
    241     fprintf(fp,"%4d   %p %4d      ",i,f,f->size);
    242 #ifdef MEM_CHECK
    243     if (f->size>0)
    244       fprintf(fp,"%s",f->name);
    245     else fprintf(fp,"FREE");
    246 #endif
    247     fprintf(fp,"\n");
    248   }   
    249   for (i=0;i<JM_SMALL_SIZE;i++)
    250   {
    251     for (small_block *s=cblocks[i];s;s=s->next)
    252     {     
    253       fprintf(fp,"*** Small Block size = %d ***\n",i);     
    254       unsigned long bit=1;
     219      uint32_t bit=1;
    255220      char *addr=((char *)(s+1));
    256221      for (int j=0;j<32;j++)
     
    270235    }
    271236  }
     237
     238
     239  fprintf(fp,"************** CACHE SPACE ******************\n",block_size);
     240  i=0;
     241  for (f=cfirst;f;f=f->next,i++)
     242  {   
     243    fprintf(fp,"%4d   %p %4d      ",i,f,f->size);
     244#ifdef MEM_CHECK
     245    if (f->size>0)
     246      fprintf(fp,"%s",f->name);
     247    else fprintf(fp,"FREE");
     248#endif
     249    fprintf(fp,"\n");
     250  }   
     251  for (i=0;i<JM_SMALL_SIZE;i++)
     252  {
     253    for (small_block *s=cblocks[i];s;s=s->next)
     254    {     
     255      fprintf(fp,"*** Small Block size = %d ***\n",i);     
     256      uint32_t bit=1;
     257      char *addr=((char *)(s+1));
     258      for (int j=0;j<32;j++)
     259      {
     260        fprintf(fp,"%p   ",addr);
     261        if (s->alloc_list&bit)
     262        {
     263#ifdef MEM_CHECK
     264          fprintf(fp,"%s\n",s->name[j]);
     265#else
     266          fprintf(fp,"allocated\n");
     267#endif   
     268        } else fprintf(fp,"FREE\n");
     269        bit=bit<<1;
     270        addr+=s->size+4;
     271      }
     272    }
     273  }
    272274}
    273275
    274276long block_manager::pointer_size(void *ptr)
    275277{
    276   void *next=(void *)(*(((long *)ptr)-1));
     278  void *next=(void *)(*(((intptr_t *)ptr)-1));
    277279  if (next>ptr)
    278280    return ((memory_node *)(((char *)ptr)-sizeof(memory_node)))->size;
     
    340342#ifdef MEM_CHECK
    341343      s->name[0]=strcpy((char *)malloc(strlen(name)+1),name);
    342       if ((long)s==break_mem_point)
     344      if ((intptr_t)s==break_mem_point)
    343345        break_mem_fun();
    344346#endif     
     
    361363
    362364#ifdef MEM_CHECK
    363           if ((long)addr==break_mem_point)
     365          if ((intptr_t)addr==break_mem_point)
    364366            break_mem_fun();
    365367#endif
     
    396398  s->name=strcpy((char *)malloc(strlen(name)+1),name);
    397399
    398   if ((long)s==break_mem_point)
     400  if ((intptr_t)s==break_mem_point)
    399401    break_mem_fun();
    400402
     
    425427      *addr=(long)s;
    426428#ifdef MEM_CHECK
    427       if ((long)s==break_mem_point)
     429      if ((intptr_t)s==break_mem_point)
    428430        break_mem_fun();
    429431#endif
     
    440442#ifdef MEM_CHECK
    441443          s->name[i]=strcpy((char *)malloc(strlen(name)+1),name);
    442           if ((long)s==break_mem_point)
     444          if ((intptr_t)s==break_mem_point)
    443445            break_mem_fun();
    444446#endif           
     
    473475#ifdef MEM_CHECK
    474476      nc->name=strcpy((char *)malloc(strlen(name)+1),name);     
    475       if ((long)nc==break_mem_point)
     477      if ((intptr_t)nc==break_mem_point)
    476478        break_mem_fun();
    477479#endif     
     
    499501#ifdef MEM_CHECK
    500502  s->name=strcpy((char *)malloc(strlen(name)+1),name);
    501   if ((long)s==break_mem_point)
     503  if ((intptr_t)s==break_mem_point)
    502504    break_mem_fun();
    503505#endif
     
    696698void jmalloc_init(long min_size)
    697699{
     700  fprintf(stderr,"Disabling memory manager, using libc instead\n");
     701  return;
     702
    698703  if (bmanage_total)
    699704    fprintf(stderr,"warning : jmalloc_init called twice\n");
     
    722727    if (mem)
    723728    {
    724                         bmanage[bmanage_total].init(mem,size,HI_BLOCK);
    725                         bmanage_total++;     
    726                         fprintf(stderr,"Added himem block (%d bytes)\n",size);
     729      bmanage[bmanage_total].init(mem,size,HI_BLOCK);
     730      bmanage_total++;     
     731      fprintf(stderr,"Added himem block (%d bytes)\n",size);
    727732    }
    728733
     
    732737    bmanage_total++;      */
    733738
    734 
    735 
    736739#ifdef __WATCOMC__
    737740    if (size!=jmalloc_max_size)
     
    739742      do
    740743      {
    741                                 size=low_memory_available();
    742                                 if (size>jmalloc_min_low_size+0x1000)              // save 64K for misc low memory needs
    743                                 {
    744                                   bmanage[bmanage_total].init(alloc_low_memory(size-jmalloc_min_low_size-0x1000),size-jmalloc_min_low_size-0x1000,LOW_BLOCK);
    745                                   bmanage_total++;
    746                                   fprintf(stderr,"Added low memory block (%d bytes)\n",size);
    747                                 }
     744        size=low_memory_available();
     745        if (size>jmalloc_min_low_size+0x1000)              // save 64K for misc low memory needs
     746        {
     747          bmanage[bmanage_total].init(alloc_low_memory(size-jmalloc_min_low_size-0x1000),size-jmalloc_min_low_size-0x1000,LOW_BLOCK);
     748          bmanage_total++;
     749          fprintf(stderr,"Added low memory block (%d bytes)\n",size);
     750        }
    748751      } while (size>jmalloc_min_low_size+0x1000);
    749752      if (size<jmalloc_min_low_size)
    750753      {
    751                                 fprintf(stderr,not_enough_low_memory_message,size,jmalloc_min_low_size);
    752                                 exit(0);
     754        fprintf(stderr,not_enough_low_memory_message,size,jmalloc_min_low_size);
     755        exit(0);
    753756      }
    754757    }
    755758#endif
    756759 
    757 
    758760    fprintf(stderr,"Memory available : %d\n",j_available());
    759761    if (j_available()<min_size)
     
    762764      exit(0);
    763765    }
    764 
    765766  }
    766767}
     
    796797      void *a;
    797798      if (alloc_space==ALLOC_SPACE_STATIC)
     799      {
    798800        a=bmanage[i].static_alloc(size,name);
     801      }
    799802      else
     803      {
    800804        a=bmanage[i].cache_alloc(size,name);
     805      }
    801806      if (a) return a;
    802807    }
Note: See TracChangeset for help on using the changeset viewer.