开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数据库系统 > SQL Server > 查看源码
vmemory.c
资源名称：gnusql-0.7b5.1.tar.gz　[点击查看]
上传用户：dgyhgb
上传日期：2007-01-07
资源大小：676k
文件大小：51k
源码类别：

SQL Server

开发平台：

Unix_Linux

vmemory.c：源码内容
  1. /*
  2.  *  vmemory.c  - simulated virtual memory manager of GNU SQL compiler
  3.  *
  4.  *  This file is a part of GNU SQL Server
  5.  *
  6.  *  Copyright (c) 1996, 1997, Free Software Foundation, Inc
  7.  *  Developed at the Institute of System Programming, Russia
  8.  *  This file is written by Michael Kimelman
  9.  *
  10.  *  This program is free software; you can redistribute it and/or modify
  11.  *  it under the terms of the GNU General Public License as published by
  12.  *  the Free Software Foundation; either version 2 of the License, or
  13.  *  (at your option) any later version.
  14.  *
  15.  *  This program is distributed in the hope that it will be useful,
  16.  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  17.  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18.  *  GNU General Public License for more details.
  19.  *
  20.  *  You should have received a copy of the GNU General Public License
  21.  *  along with this program; if not, write to the Free Software
  22.  *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  23.  *
  24.  *  Contact:  gss@ispras.ru
  25.  *
  26.  */
  28. /* $Id: vmemory.c,v 1.247 1997/04/24 17:45:01 kml Exp $ */
  30. /*=====================================================================
  31.   
  32.                     Simulated virtual memory 
  33.                                 
  34.         1. User interface
  36.         Simululated virtual memory  looks from the  user point of
  37. view as a   set  of VM  segments, each  of  them assotiated  with
  38. independently compiled or  used piece  of  interpretator code  or
  39. compiler tree (just like object modules in ordinary OS). User can
  40. create, link, unlink  and  store out segments during  the program
  41. execution.  Virtual space  is shared by  all  linked segments and
  42. each   of  them  assotiated   with  it's   own   range of virtual
  43. addresses. To allow intersegment references each segment contains
  44. table  of  relocable virtual  addresses  and table of names which
  45. segment exports. Relocation  table used by  VM manager to correct
  46. listed addresses when the segment linked.
  47.         VM  manager support    special  conception of   "current"
  48. segment, allowing local references inside  segments.  The segment
  49. marked as a  current by 'create', 'link' or 'set_current_segment'
  50. calls. 'vmemory.h'  included   some  specific  comment   to  part
  51. of VMinterface calls.
  54.         2. Virtual Memory Inside
  56.         Virtual  memory      is  realized  like    "segment-page"
  57. adressation in computer. But in   this case it was impossible  to
  58. use fixed    size   pages.  So   memory  divided  to  "segments",
  59. associated  with independently   compiled or used   piece of code
  60. (like object modules).  Each segment  represented by small header
  61. and one-directional list  of pages of different size,  associated
  62. to pieces  of virtual memory. Each virtual  memory page  (vmp) in
  63. turn  has  page descriptor contained pointer  to  page data area,
  64. offset of the page in segment (so there can be holes in vm space)
  65. and other page realated  information. Space on the page allocated
  66. by  a virtual memory  blocks (vmb). Each vmb descriptor specifies
  67. the vmb size (while  consequece of free  vmbs appears it's joined
  68. to one) and mode (alignment of  data or 0  for free vmb). Because
  69. each  free vmb has  to contain  at  least  4 bytes of  free space
  70. (otherwise it doesn't worth to consider it as a free space), this
  71. space used for storing pointers needed  for bidirectional link of
  72. free   blocks.  Using relative   offsets  as a  pointers for this
  73. purpose allows to join pages'  areas (when it's needed) without a
  74. problem.
  75.         The only one available by  user element of VM is segment.
  76. VM manager is  responsible for  creating, storing, unlinking  and
  77. linking  segments and  holds for  this  purpose internal  segment
  78. table (segment_table). Virtual address (i4_t) of any data contain
  79. segment identifier (index  of segment  in segment table),   which
  80. occupied high bits of address, and offset  in segment.  Number of
  81. bits used for offset defined by  SEGMENT_OFFSET_SIZE and equal 20
  82. now.   Segment identifier 0 is used  for reference inside current
  83. segment (there  is a  special  identifier of  "current" segment).
  84. Size of page limited now by 64K  (16bit offset). For intersegment
  85. addressation we use relocation table (contain relocable addresses
  86. inside segment), and  exported name table (contain exported names
  87. and assotiated with  them relocable addresses of exported objects
  88. - structures of data, routines   and so on). The information   of
  89. exported data can  be got by  direct  'resolve_reference' call as
  90. well  as by using special form  of  address used for dynamic name
  91. resolution    (I   mean  'vpointer'    resolves   these cases  by
  92. itself).    This    kind    of    addresses   is     created   by
  93. 'external_reference'   call.  Actually  it's  almost  ordinal  VM
  94. pointer to locally saved imported name, but segment identifier of
  95. it is bit inverted (~seg_id).
  97. ==================================================================*/
  98.      
  99. #include "setup_os.h"
  100. #include "xmem.h"
  101. #include "vmemory.h"
  102. #include "sql_decl.h"
  103. #include <assert.h>
  106. /*------------------------------------------------------*/
  108. #define SEGMENT_OFFSET_SIZE      20
  109. /* Maximum size of the virtual segment */
  110. #define SEGMENT_LIMIT           (1<<SEGMENT_OFFSET_SIZE)
  112. #define SEG_ID(adr)    ((adr)>>SEGMENT_OFFSET_SIZE)
  113. #define SEG_BASE(s_id) ((s_id)<<SEGMENT_OFFSET_SIZE)
  114. #define SEG_IND(adr)   vm_segment_ind(adr)
  115. #define SEG_OFF(adr)   (adr&(SEGMENT_LIMIT-1))
  116. #define SEG_PTR(adr)   (&(segment_table.entries[SEG_IND(adr)]))
  118. #if HAVE_LONG_DOUBLE
  119. #  define HUGEST_MACHINE_TYPE     long double
  120. #  define PAGE_ALIGN              sizeof(HUGEST_MACHINE_TYPE)
  121. #else
  122. #  define HUGEST_MACHINE_TYPE     double
  123. #  define PAGE_ALIGN              sizeof(HUGEST_MACHINE_TYPE)
  124. #endif
  126. int debug_vmemory = 0;
  127. #define DV(mask) (debug_vmemory & (mask))
  129. typedef i2_t Offset;           /* offset on the page, computed in bytes */
  131. /* virtual memory block descriptor -- "VMB descr"  */
  133. typedef struct area
  134. {
  135.   i2_t size;
  136.   i2_t mode;                   /* 0-free; other 'mode' bytes alignment */
  137. } *pdesc;
  139. #define DSC_SZ sizeof(struct area)
  141. /* VMB descr for unused space */
  143. typedef struct f_area
  144. {
  145.   struct area desc;
  146.   Offset      next,             /* double linked list of free blocks */
  147.               prev;
  148. } *pdescf;
  150. #define FDS_SZ sizeof(struct f_area)
  151. #define NEXT(ds)  ((pdescf)((byte*)ds+ds->next))
  152. #define PREV(ds)  ((pdescf)((byte*)ds+ds->prev))
  154. /********* Page **********************/
  156. typedef struct virtual_memory_page *P_vmpage;
  158. struct virtual_memory_page/* VMP  ===========================================*/
  159. {                         /*                                                 */
  160.   P_vmpage  next;         /* points to the next page descriptor              */
  161.   i4_t       base;         /* offset of the page in  segment                  */
  162.   i4_t       size;         /* size of the current page                        */
  163.   i4_t       used;         /* size of used space on the page                  */
  164.   i4_t       free_ptr;     /* points to free space - just after descriptor of */
  165.                           /* the first free vmb on the page                  */
  166.   i4_t       lfree_ptr;    /* points to free space - just after descriptor of */
  167.                           /* the last free vmb on the page                   */
  168.   i4_t       flags;        /* nonzero to avoiding freeing memory-the same     */
  169.                           /* meaning as 'dont_remove' below                  */
  170.   byte     *page;         /* have to be aligned to "i4_t double"             */
  171. };                        /*=================================================*/
  173. /********* Segment *******************/
  174. typedef struct            /* Relocation table================================*/
  175. {                         /*                                                 */
  176.   i4_t  used_ent;         /* number of used entries                          */
  177.   i4_t  ent_nmb;          /* number of entries                               */
  178.   i4_t  dont_remove;      /* nonzero if the memory, used by table, will be   */
  179.                           /* fried later                                     */
  180.   VADR *entries;          /* scalable array with local addresses of          */
  181.                           /* relocable pointers                              */
  182. } reloc_tbl;              /*=================================================*/
  184. typedef struct            /* Name table - this table contains names and =====*/
  185. {                         /* adresses of entry points: routines amd variables*/
  186.   i4_t    ent_nmb;        /* number of entries                               */
  187.   i4_t    dont_remove;    /* nonzero if the memory, used by table, will be   */
  188.                           /* fried later                                     */
  189.   struct                  /*                                                 */
  190.   {                       /*                                                 */
  191.     VADR   name;          /* address in the segment of the exported name     */
  192.     VADR   adr;           /* relocable address in the segment of the object  */
  193.   }      *entries;        /* scalable array of exported entries              */
  194. } export_tbl;             /*=================================================*/
  196. typedef struct virtual_memory_segment /* Virtual memory segment descriptor ==*/
  197. {                                 /*                                         */
  198.   P_vmpage    base;               /* pointer to the chain of segment's pages */
  199.   i4_t        used;               /*                                         */
  200.   reloc_tbl   relocation_table;   /* relocation table of the segment         */
  201.   export_tbl  export_table;       /* exported names table                    */
  202.   void       *loaded_block_address; /* address of the segment - used for     */
  203.                                   /* latter freeing memory if it was loaded  */
  204.                                   /* from outside as a whole piece           */
  205. } vmsegment;                      /*=========================================*/
  207. /********** Global manipulation tables *********/
  209. typedef struct            /* Local table of loaded segments  ================*/
  210. {                         /*                                                 */
  211.   i4_t       ent_nmb;     /* number of segments                              */
  212.   i4_t       dont_remove; /* used just for compatibility in macro            */
  213.   i4_t       current;     /* number (identifier) of the current segment -    */
  214.                           /* used if segment id in VADR==0                   */
  215.   vmsegment *entries;     /* scalable array of segment's descriptors -       */
  216.                           /* Attention! entries[0] never used                */
  217. } SEGM_TBL;               /*=================================================*/
  219. static SEGM_TBL segment_table =
  220. {0, 0, 0, NULL};
  223. #define REALLOC(p,sz) l_realloc(p,sz)
  224. #define FREE(p)       l_free(p)
  226. #ifndef USE_XVM
  228. #define MALLOC(size)   xmalloc(size)
  229. #define AREALLOC(p,sz) xrealloc(p,sz)
  230. #define AFREE(p)       xfree(p)
  232. #else
  234. static void *lmalloc(i4_t size);
  235. static void *lrealloc(void *p,i4_t size);
  236. static void  lfree __P((void *p));
  237. static VADR xmemory_segment = VNULL;
  239. #define MALLOC(size)  lmalloc(size)
  240. #define AREALLOC(p,sz) lrealloc(p,sz)
  241. #define AFREE(p)       lfree(p)
  243. #endif
  245. #define TBL_PORTION 32
  247. #define TBL_ELEM_SZ(tbl) sizeof(*(tbl.entries))
  248. #define TBL_SIZE(tbl)  
  249. ((TBL_PORTION+(tbl.ent_nmb))*TBL_ELEM_SZ(tbl))
  251. #define ADD_ENTRY(tbl) 
  252. {
  253.   if(tbl.ent_nmb%TBL_PORTION==0)
  254.     {
  255.       register void *tmp_ptr=MALLOC(TBL_SIZE(tbl)); 
  256.       if (tbl.ent_nmb >0)
  257.         {
  258.           bcopy(tbl.entries,tmp_ptr,TBL_ELEM_SZ(tbl)*tbl.ent_nmb); 
  259.           if(tbl.dont_remove)tbl.dont_remove=0;
  260.           else               FREE((void*)(tbl.entries)); 
  261.         }
  262.       tbl.entries=tmp_ptr;
  263.     }
  264.   tbl.ent_nmb++; 
  265. }
  267. /************************************************************************
  268. ************  CACHE  *****************************************************
  269. ************************************************************************/
  270. static void *
  271. cache_proc(VADR n, void *p,i4_t action)
  272. {
  273. #define CACHE_SIZE 5
  274.   struct c_el {
  275.     VADR  v;
  276.     void *p;
  277.   };
  278.   static   struct c_el cache[CACHE_SIZE];
  279.   register i4_t         i;
  281.   switch(action)
  282.     {
  283.     case -1: /* flush */
  284. #define  flush_cache() cache_proc(VNULL, NULL, -1)
  285.       for (i = 0; i < CACHE_SIZE; i ++ )
  286.         cache[i].v = 0;
  287.       return NULL;
  288.     case 0: /* check */
  289. #define  check_cache(n) cache_proc(n, NULL, 0)
  290.       assert(n);
  291.       i = (i4_t)(( n >> 4 ) % CACHE_SIZE);
  292.       return ( n == cache[i].v ? cache[i].p : NULL );
  293.     case 1: /* update */
  294. #define  update_cache(n,p) cache_proc(n,p, 1)
  295.       i = (i4_t)(( n >> 4 ) % CACHE_SIZE);
  296.       cache[i].v = n;
  297.       cache[i].p = p;
  298.       return NULL;
  299.     default:
  300.       assert("vm cache_proc unrecognized action");
  301.     }
  302.   return NULL;
  303. #undef CACHE_SIZE
  304. }
  306. static void *
  307. l_realloc(void *p,i4_t size)
  308. {
  309.   flush_cache();
  310.   return AREALLOC(p,size);
  311. }
  313. static void
  314. l_free(void *p)
  315. {
  316.   flush_cache();
  317.   AFREE(p);
  318. }
  320. /************************************************************************
  321. **************************************************************************
  322. ************************************************************************/
  323. static i4_t enable_auto_create = 0;
  324. static i4_t force_free         = 0;
  327. static long
  328. vm_segment_ind (register VADR ptr)
  329. {
  330.   register i4_t p = SEG_ID (ptr);
  331.   if (p == 0)
  332.     {
  333.       if (segment_table.current > 0)
  334. return segment_table.current;
  335.       else if (enable_auto_create)
  336. {
  337.   fprintf (STDERR, "Virtual memory handler: warning :"
  338.    "auto-creating new segmentn");
  339.   create_segment ();
  340.   p = segment_table.current;
  341. }
  342.       else
  343. return p;
  344.     }
  345.   else if (p < 0)
  346.     p = ~p;
  347.   if (p == 0 || p >= segment_table.ent_nmb || !segment_table.entries[p].used)
  348.     yyfatal ("Virtual memory handler: incorrect segment identifier");
  349.   return p;
  350. }
  352. static P_vmpage 
  353. check_for_null_page (register P_vmpage vmp)
  354. {
  355.   if (vmp && vmp->size == 0)
  356.     {
  357.       register P_vmpage vmp1 = vmp;
  358.       vmp = vmp->next;
  359.       vmp1->next = 0;
  360.       if (vmp1->flags == 0)     /* in other case it'll be freed later */
  361.         {
  362.           FREE (vmp1->page);
  363.           FREE (vmp1);
  364.         }
  365.     }
  366.   return vmp;
  367. }
  369. static i4_t 
  370. check_free_memory_on_page (register P_vmpage vmp)
  371. {
  372.   register pdescf a;
  373.   register i4_t    sz = 0;
  374.   assert(!vmp->free_ptr == !vmp->lfree_ptr);
  375.   assert(vmp->free_ptr>=0 && vmp->free_ptr<vmp->size);
  376.   assert(vmp->lfree_ptr>=0 && vmp->lfree_ptr<vmp->size);
  377.   if (DV(0xf) <= 2 )
  378.     return vmp->size - vmp->used;
  379.   if (vmp->free_ptr )
  380.     for (a = (pdescf) (vmp->page + vmp->free_ptr - DSC_SZ);
  381.          a;
  382.          a = a->next ? NEXT (a) : 0)
  383.       {
  384.         if (!(a->desc.size > 0))
  385.           yyfatal ("Virtual memory handler: memory block size <=0 ");
  386.         if (a->desc.mode > 0)
  387.           yyfatal ("Virtual memory handler: VMB mode !=0 in free list");
  388.         sz += a->desc.size + DSC_SZ;
  389.       }
  390.   assert (vmp->used + sz == vmp->size);
  391.   return sz;
  392. }
  394. static int
  395. check_integrity (register P_vmpage vmp)
  396. {
  397.   register pdesc a;
  398.   register i4_t   sz = 0;
  399.   if (vmp == 0)
  400.     return 0;
  401.   vmp->next = check_for_null_page (vmp->next);
  402.   if (vmp->page == 0)
  403.     {
  404.       assert (vmp->used == 0 && vmp->size == 0);
  405.       return 0;
  406.     }
  407.   
  408.   sz = vmp->size - vmp->used;
  409.   
  410.   if (DV(0xf) > 1)
  411.     {
  412.       for (sz = 0,a = (pdesc) (vmp->page);
  413.            (byte *) a < (vmp->page + vmp->size);
  414.            a = (pdesc) ((byte *) a + DSC_SZ + a->size))
  415.         {
  416.           if (!(a->size > 0))
  417.             yyfatal ("Virtual memory handler: memory block size <=0 ");
  418.           if(a->mode)
  419.             {
  420.               register i4_t mode;
  421.               for (mode=1; mode <= PAGE_ALIGN; mode *= 2)
  422.                 if( mode == a->mode)
  423.                   break;
  424.               if (mode > PAGE_ALIGN)
  425.                 yyfatal ("Virtual memory handler: integrity checking failed"
  426.                          " (alignment info destroyed)");
  427.             }
  428.           else /* a->mode==0 */ if (DV(0xf) >=4)
  429.             {
  430.               i4_t
  431.                 *p = (i4_t*)a + FDS_SZ/sizeof(i4_t),
  432.                 *e = p + (a->size + DSC_SZ - FDS_SZ)/sizeof(i4_t);
  433.               while(p<e)
  434.                 if(*p++)
  435.                   yyfatal ("virtual memory handler: free memory not 0");
  436.             }
  437.           sz += a->size + DSC_SZ;
  438.           if (force_free == 2 && a->mode)
  439.             {
  440.               register byte *ptr /* ,*endptr */;
  441.               register FILE *f = stderr;
  442.               register i4_t  ss;
  443.               ptr = (byte*)a + DSC_SZ;
  444.               if ( ((i4_t)ptr) % a->mode )
  445.                 {
  446.                   ptr += a->mode;
  447.                   ptr -= ((i4_t)ptr) % a->mode ;
  448.                 }
  449.               ss = (i4_t)ptr - (i4_t)vmp->page + vmp->base;
  450.               fprintf(f,"/* vmblock:%x (%d)*/ %d,n",ss,a->size,ss);
  451. #if 0
  452.               for ( ptr = (byte*)a + DSC_SZ , endptr = ptr + a->size ; 
  453.                     ptr < endptr;
  454.                     ptr++
  455.                     )
  456.                 fprintf(f,"%c",*ptr);
  457.               fputs(" --- ",f);
  458.               for ( ptr = (byte*)a + DSC_SZ, endptr = ptr + a->size ; 
  459.                     ptr < endptr;
  460.                     ptr++
  461.                     )
  462.                 fprintf(f," %x",(i4_t)(*ptr));
  463.               fputs("n -4b- ",f);
  464.               for ( ptr = (byte*)a + DSC_SZ, endptr = ptr + a->size ; 
  465.                     ptr < endptr;
  466.                     ptr += 4
  467.                     )
  468.                 fprintf(f,"%lx ",*(i4_t*)(ptr));
  469.               fputs("n",f);
  470. #endif
  471.             }
  472.         }
  473.       assert (sz == vmp->size);
  474.     }
  475.   if (DV(0xf) > 0)
  476.     sz = check_free_memory_on_page (vmp);
  477.   return sz;
  478. }
  480. static void 
  481. join_fvmb (register pdescf vmb_a, register P_vmpage vmp)
  482. {
  483.   register pdescf vmb_b;
  484.   register i2_t off;
  485.   check_integrity (vmp);
  486.   if (vmb_a->next == 0)
  487.     return;
  488.   assert (vmb_a->next > 0);
  489.   vmb_b = NEXT (vmb_a);
  490.   off = vmb_a->desc.size + DSC_SZ;
  491.   if ((off + (byte *) vmb_a) != (byte *) (vmb_b))
  492.     return;
  493.   /* join with next area */
  494.   vmb_a->desc.size += DSC_SZ + vmb_b->desc.size;
  495.   assert (vmb_a->desc.size > 0);
  496.   if (vmb_b->next)
  497.     {
  498.       vmb_a->next = vmb_b->next + off;
  499.       NEXT (vmb_a)->prev -= off;
  500.     }
  501.   else
  502.     {
  503.       vmb_a->next = 0;
  504.       vmp->lfree_ptr = (byte *) vmb_a - (byte *) (vmp->page) + DSC_SZ;
  505.     }
  506.   bzero(vmb_b,FDS_SZ);
  507.   join_fvmb (vmb_a, vmp);
  508. }
  510. static void 
  511. insert_fvmb (register pdescf vmb_a, register P_vmpage vmp)
  512. {
  513.   register i4_t off;
  514.   flush_cache();
  515.   check_integrity (vmp);
  516.   assert (vmb_a->desc.size > 0);
  517.   bzero((char*)vmb_a + DSC_SZ, vmb_a->desc.size);
  518.   if (vmp->free_ptr == 0)
  519.     {
  520.       vmp->used -= vmb_a->desc.size + DSC_SZ;
  521.       vmp->free_ptr = vmp->lfree_ptr = 
  522.         (byte *) vmb_a - (byte *) vmp->page + DSC_SZ;
  523.       vmb_a->desc.mode = 0;
  524.       vmb_a->next = vmb_a->prev = 0;
  525.     }
  526.   else
  527.     {                           /* update free areas list */
  528.       register pdescf vmb_b = (pdescf) (vmp->page + vmp->free_ptr - DSC_SZ);
  529.       while (((byte *) vmb_b < (byte *) vmb_a)
  530.              && (vmb_b->next > 0))
  531.         vmb_b = NEXT (vmb_b);
  532.       assert (vmb_b->desc.size > 0);
  533.       assert (vmb_b->desc.mode == 0);
  534.       check_integrity (vmp);
  535.       off = (byte *) vmb_b - (byte *) vmb_a;
  536.       if ((off == 0) || (off % DSC_SZ != 0))
  537.         yyfatal ("Virtual memory handler: incorrect offset of memory block");
  538.       vmb_a->desc.mode = 0;
  539.       vmp->used -= vmb_a->desc.size + DSC_SZ;
  540.       if (off < 0)
  541.         {                       /* b < a */
  542.           vmb_a->prev = off;
  543.           if (vmb_b->next > 0)
  544.             {
  545.               vmb_a->next = vmb_b->next + off;
  546.               NEXT (vmb_a)->prev -= off;
  547.             }
  548.           else
  549.             {
  550.               assert (vmb_b->next == 0);
  551.               vmb_a->next = 0;
  552.               vmp->lfree_ptr = (byte *) vmb_a - (byte *) (vmp->page) + DSC_SZ;
  553.             }
  554.           vmb_b->next = -off;
  555.           join_fvmb (vmb_b, vmp);
  556.         }
  557.       else
  558.         /*  a < b */
  559.         {
  560.           vmb_a->next = off;
  561.           if (vmb_b->prev < 0)
  562.             {
  563.               vmb_a->prev = vmb_b->prev + off;
  564.               PREV (vmb_a)->next -= off;
  565.             }
  566.           else
  567.             {
  568.               assert (vmb_b->prev == 0);
  569.               vmb_a->prev = 0;
  570.               vmp->free_ptr = (byte *) vmb_a - (byte *) (vmp->page) + DSC_SZ;
  571.             }
  572.           vmb_b->prev = -off;
  573.           if (vmb_a->prev)
  574.             join_fvmb (PREV (vmb_a), vmp);
  575.           else
  576.             join_fvmb (vmb_a, vmp);
  577.         }
  578.     }
  579.   check_integrity (vmp);
  580. }
  582. static void 
  583. delete_fvmb (pdescf vmb_a, P_vmpage vmp)
  584. {
  585.   /* let be paranoid about caching */
  586.   flush_cache(); 
  587.   if ( ((DV(0xf00)>>8) > 1) && (DV(0xf) > 2))
  588.     fprintf (STDERR, "(%d free bef del-ing)...", check_integrity (vmp));
  589.   
  590.   if (vmb_a->next)
  591.     {
  592.       if (vmb_a->prev)
  593.         {
  594.           NEXT (vmb_a)->prev += vmb_a->prev;
  595.           PREV (vmb_a)->next += vmb_a->next;
  596.         }
  597.       else
  598.         {
  599.           NEXT (vmb_a)->prev = 0;
  600.           vmp->free_ptr += vmb_a->next;
  601.         }
  602.     }
  603.   else
  604.     {
  605.       if (vmb_a->prev)
  606.         {
  607.           vmp->lfree_ptr += vmb_a->prev;
  608.           PREV (vmb_a)->next = 0;
  609.         }
  610.       else
  611.         {
  612.           vmp->free_ptr = 0;
  613.           vmp->lfree_ptr = 0;
  614.         }
  615.     }
  616.   vmb_a->desc.mode = 1;
  617.   vmp->used += vmb_a->desc.size + DSC_SZ;
  618. }
  620. static void 
  621. split_vmb (register pdescf vmb_a,
  622.            register P_vmpage vmp,
  623.            register i4_t off)
  624. /* "off" - offset on the page - place to split current vmb. Data stored
  625.  * in the vmb ended here.
  626.  */
  627. {
  628.   ALIGN (off, DSC_SZ);
  629.   if (off + FDS_SZ < 
  630.       (i4_t) ((byte *) vmb_a - vmp->page) + vmb_a->desc.size + DSC_SZ)
  631.     {                           /* create new free vmb */
  632.       register pdescf vmb_b = (pdescf) (vmp->page + off);
  634.       if ( ((DV(0xf00)>>8) > 1) && (DV(0xf) > 2))
  635.         fprintf (STDERR, "(%d free bef rep-ing)...",
  636.                  check_integrity (vmp));
  637.       
  638.       off -= (i4_t) ((byte *) vmb_a - vmp->page);
  639.       vmb_b->desc.size = vmb_a->desc.size - off;
  640.       assert (vmb_b->desc.size > 0);
  641.       vmb_a->desc.size = off - DSC_SZ;
  642.       assert (vmb_a->desc.size > 0);
  643.       vmb_b->desc.mode = 0;
  644.       insert_fvmb (vmb_b, vmp);
  645.     }
  646. }
  648. static void 
  649. find_vmb (P_vmpage * pvmp, register VADR n, pdescf * pvmb_a)
  650. {
  651.   register byte *p = (byte *) n;
  652.   register P_vmpage vmp;
  653.   register pdescf vmb_a;
  654.   
  655.   vmp = SEG_PTR (n)->base;
  656.   n = SEG_OFF (n);
  657.   while (vmp
  658.          && (check_integrity (vmp) >= 0)
  659.          && (n > vmp->base + vmp->size)
  660.     )
  661.     vmp = vmp->next;
  662.   if (!vmp)
  663.     yyfatal ("Virtual memory handler: required page not found");
  664.   *pvmp = vmp;
  665.   if (pvmb_a==NULL)
  666.     return;
  667.   /* looking for pvmb_a */
  668.   p = vmp->page + (n - vmp->base);
  669.   for (vmb_a = (pdescf) vmp->page;
  670.        (byte *) vmb_a < vmp->page + vmp->size;
  671.        vmb_a = (pdescf) ((byte *) vmb_a + vmb_a->desc.size + DSC_SZ))
  672.     {
  673.       if (!(vmb_a->desc.size > 0))
  674.         yyfatal ("Virtual memory handler: size <=0 on level 1");
  675.       if ((p >= (byte *) vmb_a + DSC_SZ) &&
  676.           (p < (byte *) vmb_a + DSC_SZ + vmb_a->desc.size) &&
  677.           (vmb_a->desc.mode > 0)
  678.         )
  679.         {
  680.           *pvmb_a = vmb_a;
  681.           return;
  682.         }
  683.     }
  684.   yyfatal ("Virtual memory handler: can't find required block on page");
  685. }
  687. static P_vmpage 
  688. new_vmpage (i4_t base, i4_t size)
  689. {
  690.   register P_vmpage ptr;
  691.   register pdescf vmb_a;
  693.   ALIGN (size, PAGE_ALIGN);
  694.   {
  695.     register Offset s = size-DSC_SZ;
  696.     if (size-DSC_SZ != s)
  697.       yyfatal ("Too large virtual memory segment required");
  698.   }
  699.   ptr = MALLOC (sizeof (*ptr));
  700.   ptr->page = MALLOC (size);
  701.   ptr->size = size;
  702.   ptr->base = base;
  703.   vmb_a = (pdescf) (ptr->page);
  704.   vmb_a->desc.mode = 0;
  705.   vmb_a->desc.size = size - DSC_SZ;
  706.   vmb_a->next = vmb_a->prev = 0;
  707.   ptr->used = 0;
  708.   ptr->lfree_ptr = ptr->free_ptr = DSC_SZ;
  709.   check_integrity (ptr);
  710.   return ptr;
  711. }
  713. static P_vmpage 
  714. resize_vmpage (P_vmpage vmp, i4_t size)
  715. {
  716. #define ret(v)  { debug_vmemory -=1; return (v); }
  718.   debug_vmemory +=1;
  719.   check_integrity (vmp);
  720.   
  721.   ALIGN (size, PAGE_ALIGN);
  722.   
  723.   {
  724.     register Offset s = size - DSC_SZ;
  725.     if (size-DSC_SZ != s)
  726.       {
  727.         lperror("Too large virtual memory segment required (%d > 32k)",
  728.                 size);
  729. yyfatal ("");
  730.       }
  731.   }
  732.   if (size > vmp->size)
  733.     {                                           /* increasing page size      */
  734.       register pdescf vmb_a;
  735.       if (vmp->flags==0)
  736.         vmp->page = REALLOC (vmp->page, size); /* may be explicitly copy? ?!! */
  737.       else
  738.         {
  739.           void *p = MALLOC(size);
  740.           bcopy(vmp->page,p,vmp->size);
  741.           vmp->page = p;
  742.         }
  743.       check_integrity (vmp); /* let's check if it was copied correctly       */
  744.       vmb_a = (pdescf) (vmp->page + vmp->size);
  745.       vmb_a->desc.size = size - vmp->size - DSC_SZ;
  746.       vmb_a->desc.mode = DSC_SZ;
  747.       vmp->used += size - vmp->size;
  748.       vmp->size = size;
  749.       check_integrity (vmp);  /* a lot of pseudo-used memory added to page   */
  750.       insert_fvmb (vmb_a, vmp);
  751.     }
  752.   else if (size < vmp->size)  /* request to decrease page size               */
  753.     {                         /* size must be equal "0" or "lfree_ptr-DSC_SZ"*/
  754.       register byte *p;
  755.       register pdescf vmb_a;
  756.       if ( ! vmp->lfree_ptr)              /* if there is no free space       */
  757.         ret (vmp);                        /* this request has to be rejected */
  758.       {
  759.         register i4_t sz = vmp->lfree_ptr - DSC_SZ;
  760.         ALIGN(sz, PAGE_ALIGN);
  761.         if (vmp->size == sz)       /* if there is only a tiny piece of space */
  762.           ret (vmp);               /* it doen't worth to do anything         */
  763.       }
  764.       vmb_a = (pdescf) (vmp->page + vmp->lfree_ptr - DSC_SZ);
  765.       p = (byte *) vmb_a + DSC_SZ + vmb_a->desc.size - vmp->size;
  766.       if (p < vmp->page)           /* if free space is only in the middle of */
  767.         ret (vmp);                 /* page we reject this request too        */
  768.       if (p > vmp->page)
  769.         yyfatal ("Virtual memory handler: segmentation fault on level 1");
  770.       assert (p == vmp->page);
  771.       
  772.       if ((vmb_a->desc.size + DSC_SZ < sizeof (*vmp)) &&/*IF rest of page is tiny*/
  773.           vmp->next &&                                 /*and there is a next page*/
  774.           (vmp->next->base > vmp->base + vmp->size) && /* just after this one    */
  775.           vmp->used                                    /*and there are some data */
  776.         )                                              /*on this page            */
  777.         ret (vmp);                        /* THEN it doesn't worth to strip page */
  778.       
  779.       delete_fvmb (vmb_a, vmp);
  780.       
  781.       {                                        /* test for page size "alignment" */
  782.         register i4_t sz1,sz = vmp->size - vmb_a->desc.size - DSC_SZ;
  783.         sz1 = sz;
  784.         ALIGN (sz, PAGE_ALIGN);
  785.         if (sz != sz1)
  786.           while (sz < sz1 + FDS_SZ)
  787.             sz += PAGE_ALIGN;
  788.         if (size && size != sz)
  789.           yyerror ("Virtual memory handler: "
  790.                    "incorrect size in request for resizing page");
  791.         size = vmp->size;       /* just save previous size of page           */
  792.         vmp->used -= vmp->size - sz;
  793.         vmp->size = sz;         /*                                           */
  794.         if ( sz != sz1 )        /* if page size alignment requires to have a */
  795.           {                     /* bit more space than it really need        */
  796.             vmb_a->desc.size = sz - sz1 - DSC_SZ;  /* add tiny free block at */
  797.             insert_fvmb(vmb_a,vmp);                /* the end of page        */
  798.           }
  799.       }
  800.       check_integrity (vmp);
  801.       if (vmp->size)
  802.         {
  803.           if(!vmp->flags)
  804.             vmp->page = REALLOC (vmp->page, vmp->size);
  805.         }
  806.       else
  807.         /* if no data on the page */
  808.         {
  809.           register P_vmpage vmp1 = vmp->next;
  810.           if(!vmp->flags)
  811.             FREE (vmp->page);
  812.           vmp->page = NULL;
  813.           if (vmp1)
  814.             {
  815.               bcopy ((void *) vmp1, (void *) vmp, sizeof (*vmp));
  816.               FREE ((void *) vmp1);
  817.             }
  818.         }
  819.     }
  820.   check_integrity (vmp);
  821.   ret (vmp);
  822. #undef ret
  823. }
  825. static P_vmpage 
  826. free_vmpage (P_vmpage ptr)
  827. {
  828.   if (ptr)
  829.     {
  830.       check_integrity (ptr);
  831.       ptr->next = free_vmpage (ptr->next);
  832.       if (ptr->next)
  833.         return ptr;
  834.       if ((ptr->used && (force_free == 0)))
  835.         return ptr;
  836.       if (ptr->flags == 0)      /* in other case it'll be freed later */
  837.         {
  838.           FREE (ptr->page);
  839.           FREE (ptr);
  840.         }
  841.     }
  842.   return NULL;
  843. }
  845. static P_vmpage 
  846. join_memory (register P_vmpage vmp)
  847. {
  848.   register P_vmpage vmp1;
  849.   register i4_t size;
  850.     
  851.   check_integrity (vmp);
  852.   if (vmp == NULL)
  853.     return NULL;
  854.   if (vmp->next)
  855.     vmp->next = join_memory (vmp->next);
  856.   vmp = resize_vmpage (vmp, 0);
  857.   if (vmp->next == 0)
  858.     return vmp;
  859.   if (vmp->next->base > vmp->base + vmp->size)
  860.     return vmp;
  861.   assert (vmp->next->base == vmp->base + vmp->size);
  862.   vmp1 = vmp->next;
  863.   size = vmp->size + vmp1->size;
  864.   {
  865.     register Offset s = size;
  866.     if (s != size)
  867.       return vmp;
  868.   }
  869.   /* We CAN join the page with follow one !!!*/
  871.   vmp->next = vmp1->next;
  872.   size=vmp->size;
  873.   vmp = resize_vmpage (vmp, vmp->size+vmp1->size);
  874.   /* correct last free_vmb */
  875.   {
  876.     register pdescf vmb_a, vmb_b;
  877.     vmb_a = (pdescf) (vmp->page + vmp->lfree_ptr - DSC_SZ);
  878.     delete_fvmb (vmb_a, vmp);
  879.     if ((byte *) vmb_a < vmp->page + size)
  880.       {
  881. vmb_a->desc.size = vmp->page + size - (byte *) vmb_a - DSC_SZ;
  882. insert_fvmb (vmb_a, vmp);
  883.       }
  884.     bcopy (vmp1->page, vmp->page + size, vmp1->size);
  885.     assert(size + vmp1->size == vmp->size);
  886.     vmp->used += vmp1->used - vmp1->size;
  887.     if (vmp1->free_ptr) /* Increasing space is not expected */ 
  888.       {
  889. if (vmp->lfree_ptr)
  890.   {
  891.     vmb_a = (pdescf) (vmp->page + vmp->lfree_ptr - DSC_SZ);
  892.     vmb_b = (pdescf) (vmp->page + size + vmp1->free_ptr-DSC_SZ);
  893.     vmb_b->prev = vmb_a->next = (byte *) vmb_b - (byte *) vmb_a;
  894.     vmp->lfree_ptr = size + vmp1->lfree_ptr;
  895.   }
  896. else
  897.   {
  898.     vmp->free_ptr = size + vmp1->free_ptr;
  899.     vmp->lfree_ptr = size + vmp1->lfree_ptr;
  900.   }
  901.       }
  902.   }
  903.   vmp1->next = 0;
  904.   {
  905.     i4_t ff = force_free;
  906.     force_free=1;
  907.     assert (free_vmpage (vmp1) == 0);
  908.     force_free=ff;
  909.   }
  910.   debug_vmemory +=1;
  911.   check_integrity (vmp);
  912.   debug_vmemory -=1;
  913.   return vmp;
  914. }
  916. static void 
  917. compress_data (register vmsegment * seg)
  918. {
  919.   register P_vmpage vmp;
  920.   flush_cache();
  921.   vmp = seg->base = check_for_null_page (free_vmpage (seg->base));
  922.   if (vmp == NULL)
  923.     return;
  924.   seg->base = check_for_null_page (join_memory (seg->base));
  925. }
  927. static VADR 
  928. ob_alloc (i4_t size, i4_t align, vmsegment * seg)
  929. {
  930.   register i4_t ptr;
  931.   register P_vmpage vmp = seg->base;
  932.   register pdescf vmb_a;
  933.   i4_t pg_size = 0x1000;         /* 32k */
  934.   i4_t os_needs = 0x40;
  935.   if (size == 0)
  936.     return (VADR)NULL;
  938.   if (align != sizeof (i4_t) && align != PAGE_ALIGN )
  939.     if ((align > 0) && (align < sizeof (i4_t)))
  940.         align = sizeof (i4_t);
  941.     else
  942.       {
  943.         align = sizeof (i4_t);
  944.         while ((align < size) && (align<PAGE_ALIGN) )
  945.           align <<= 1;
  946.         if (align > PAGE_ALIGN)
  947.           align >>= 1;
  948.       }
  950.   while ((size + DSC_SZ + align) >= (pg_size - os_needs))
  951.     pg_size <<= 1;
  952.   if (!vmp)
  953.     vmp = seg->base = new_vmpage (0, pg_size);
  954.   ptr = 0;
  955.   for (;;)                   /* check free space for new adding new data and */
  956.     {                        /*  add additional pages if it's needed         */
  957.       check_integrity (vmp);
  958.       if (vmp->free_ptr)     /* if there are some free vmb on page           */
  959.         {
  960.           register Offset p = vmp->free_ptr;
  961.           for (;;)           /* check each of them                           */
  962.             {
  963.               vmb_a = (pdescf) (vmp->page + p - DSC_SZ);
  964.               ptr = p % align;
  965.               if (ptr)
  966.                 ptr = align - ptr;
  967.               if (vmb_a->desc.size >= (size + ptr))
  968.                 {
  969.                   ptr += p;
  970.                   break;
  971.                 }
  972.               ptr = 0;
  973.               if (vmb_a->next == 0)
  974.                 break;
  975.               p += vmb_a->next;
  976.             }
  977.           if (ptr)
  978.             break;
  979.         }
  980.       if (vmp->next)
  981.         vmp = vmp->next;
  982.       else
  983.         {
  984.           vmb_a = (pdescf) (vmp->page + vmp->lfree_ptr - DSC_SZ);
  985.           if (                  /* there is no large free tail on the page */
  986.                vmp->lfree_ptr == 0
  987.                || (vmp->lfree_ptr > vmp->size * 3 / 4)
  988.                || (vmp->lfree_ptr + vmb_a->desc.size < vmp->size)
  989.                || (pg_size > vmp->size)
  990. #ifdef USE_XVM
  991.                || (SEG_PTR(xmemory_segment) == seg) /* don't move xmalloc pages */
  992. #endif
  993.             )
  994.             vmp = vmp->next = new_vmpage (vmp->base + vmp->size,
  995.                                           pg_size-os_needs);
  996.           else                  /* realloc page for large vmb */
  997.             resize_vmpage (vmp, vmp->size + pg_size);
  998.         }
  999.     }
  1000.   /* now "vmb_a" points to free vmb descriptor
  1001.    * and "ptr"   is offset on page to aligned position of data inside this vmb.
  1002.    */
  1003.   delete_fvmb (vmb_a, vmp);
  1004.   split_vmb (vmb_a, vmp, ptr + size);
  1006.   vmb_a->desc.mode = align;
  1007.   bzero ((byte *) vmb_a + DSC_SZ, vmb_a->desc.size);
  1008.   ptr = vmp->base + ptr;
  1009.   {
  1010.     register i4_t sz = check_integrity (vmp);
  1011.     if ( ((DV(0xf00)>>8) > 1) && (DV(0xf) > 2))
  1012.       fprintf (STDERR,
  1013.                "Allocated %3X(%3X),aligned %2X at %5x (used %5X/free %5X)n",
  1014.                size, vmb_a->desc.size, align, ptr, vmp->used, sz);
  1015.   }
  1016. #if 0
  1017.   {
  1018.     VADR critical_regions[] = {0};
  1019.     register i4_t i = sizeof(critical_regions)/sizeof(VADR);
  1020.     while ( i--)
  1021.       if ( critical_regions[i]==(VADR)ptr )
  1022. {
  1023.   yyerror("? ?");
  1024. }
  1025.   }
  1026. #endif
  1027.   return (VADR) ptr;
  1028. }
  1030. static void
  1031. check_segment_integrity(register i4_t s_id)
  1032. {
  1033.   i4_t     i;
  1034.   i4_t     dv;
  1035.   P_vmpage vmp;
  1036.   pdescf   vmb_a;
  1038.   assert (s_id >= 0 && s_id < segment_table.ent_nmb);
  1039.   
  1040.   if( DV(0xf0) == 0)
  1041.     return;
  1042.   dv = debug_vmemory;
  1043.   debug_vmemory &= 0xf0f ;
  1044.   /*
  1045.    * looking for entries in relocation table which have to be deleted 
  1046.    */
  1047. #define TBL segment_table.entries[s_id]
  1048.   for(vmp= TBL.base;vmp;vmp = vmp->next)
  1049.     check_integrity(vmp);
  1050. #undef TBL
  1052.   debug_vmemory = 0;
  1054. #define TBL segment_table.entries[s_id].relocation_table
  1055.   for (i = 0; i < TBL.ent_nmb; i++ )
  1056.     if(TBL.entries[i])
  1057.       find_vmb (&vmp, SEG_BASE (s_id) + TBL.entries[i], &vmb_a);
  1058. #undef TBL
  1059.   
  1060.   /*
  1061.    * looking for entries in export name table which have to be deleted 
  1062.    */
  1063. #define TBL segment_table.entries[s_id].export_table
  1064.   for (i = 0; i < TBL.ent_nmb; i++ )
  1065.     if(TBL.entries[i].adr)
  1066.       {
  1067.         find_vmb (&vmp, SEG_BASE (s_id) + TBL.entries[i].adr, &vmb_a);
  1068.         find_vmb (&vmp, SEG_BASE (s_id) + TBL.entries[i].name, &vmb_a);
  1069.       }
  1070. #undef TBL
  1071.   debug_vmemory = dv;
  1072. }
  1074. static void
  1075. check_vm_integrity(void)
  1076. {
  1077.   i4_t  i;
  1078.   i4_t dv;
  1080.   if( DV(0xf0) == 0x10)
  1081.     return;
  1082.   
  1083.   dv = debug_vmemory;
  1084.   debug_vmemory &= 0xf1f ;
  1085.   
  1086.   for( i = 1; i < segment_table.ent_nmb; i++)
  1087.     check_segment_integrity(i);
  1088.   
  1089.   debug_vmemory = dv;
  1090. }
  1092. VADR 
  1093. vmrealloc (VADR old_ptr, i4_t new_size)
  1094. {
  1095.   P_vmpage vmp;
  1096.   pdescf vmb_a;
  1097.   register i4_t old_size;
  1099.   check_vm_integrity();
  1100.   if (SEG_OFF (old_ptr) == 0)
  1101.     return vmalloc (new_size);
  1102.   find_vmb (&vmp, old_ptr, &vmb_a);
  1103.   old_size = (i4_t) ((byte *) vmb_a - vmp->page) /*   vmb offset on page     */
  1104.     + DSC_SZ + vmb_a->desc.size                  /* + block size             */
  1105.     - (SEG_OFF (old_ptr) - vmp->base);           /* - offset of data on page */
  1106.   if (new_size + FDS_SZ <= old_size)
  1107.     /* decrease memory block size and create new free vmb */
  1108.     split_vmb (vmb_a, vmp, SEG_OFF (old_ptr) - vmp->base + new_size);
  1109.   else if (new_size > old_size)
  1110.     {
  1111.       register pdescf vmb_b = (pdescf) ((byte *) vmb_a + DSC_SZ +
  1112.                                         vmb_a->desc.size);
  1113.       if (((byte *)vmb_b < vmp->page + vmp->size ) &&
  1114.           (vmb_b->desc.mode == 0) &&
  1115.           (new_size <= old_size+DSC_SZ + vmb_b->desc.size))
  1116.         {                      /* append following free block to current one */
  1117.           delete_fvmb (vmb_b, vmp);
  1118.           vmb_a->desc.size += vmb_b->desc.size + DSC_SZ;
  1119.         }
  1120.       else
  1121.         {                     /* allocate another block with required length */
  1122.           register VADR n = ob_alloc (new_size, vmb_a->desc.mode,
  1123.                                       SEG_PTR (old_ptr));
  1124.           bcopy (vpointer (old_ptr), vpointer (n), old_size);
  1125.           insert_fvmb (vmb_a, vmp);
  1126.           return n;
  1127.         }
  1128.     }
  1129.   /* in other case we don't need to do anything */
  1130.   check_segment_integrity(SEG_IND(old_ptr));
  1131.   check_vm_integrity();
  1132.   return old_ptr;
  1133. }
  1135. void 
  1136. vmfree (VADR ptr)
  1137. {
  1138.   P_vmpage vmp;
  1139.   pdescf   vmb_a;
  1140.   i4_t      s_id;
  1141.   
  1142.   check_vm_integrity();
  1143.   if (SEG_OFF (ptr) == 0)
  1144.     return;
  1145.   find_vmb (&vmp, ptr, &vmb_a);
  1146.   s_id = SEG_IND(ptr);
  1148.   if ( ((DV(0xf00)>>8) > 2) && (DV(0xf) > 2))
  1149.     fprintf (STDERR, "Deallocated %X at %X (used %X/free %X)... ",
  1150.              vmb_a->desc.size + DSC_SZ, SEG_OFF(ptr), vmp->used, check_integrity (vmp));
  1151.   
  1152.   /*
  1153.    * looking for entries in relocation table which have to be deleted 
  1154.    */
  1155. #define TBL SEG_PTR(ptr)->relocation_table
  1156.   { 
  1157.     register i4_t i;
  1158.     register i4_t lo,hi,p;
  1159.     lo = vmp->base + ((char*)vmb_a - (char*)vmp->page) + DSC_SZ;
  1160.     hi = lo + vmb_a->desc.size;
  1161.     for (i = 0; i < TBL.ent_nmb; i++ )
  1162.       {
  1163.         p = TBL.entries[i];
  1164.         if ( lo <= p  && p <= hi )
  1165.           {
  1166.             TBL.entries[i] = 0; /* mark the entry dummy */
  1167.             TBL.used_ent --;
  1168.           }
  1169.       }
  1170.   }
  1171. #undef TBL
  1172.   
  1173.   /*
  1174.    * looking for entries in export name table which have to be deleted 
  1175.    */
  1176. #define TBL SEG_PTR(ptr)->export_table
  1177.   { 
  1178.     register i4_t i;
  1179.     register i4_t lo,hi,p;
  1180.     lo = vmp->base + ((char*)vmb_a - (char*)vmp->page) + DSC_SZ;
  1181.     hi = lo + vmb_a->desc.size;
  1182.     for (i = 0; i < TBL.ent_nmb; i++ )
  1183.       {
  1184.         p = TBL.entries[i].adr;
  1185.         if ( lo <= p  && p <= hi )
  1186.   {
  1187.     TBL.entries[i].adr = 0;     /* mark the entry dummy */
  1188.     vmfree(TBL.entries[i].name);
  1189.   }
  1190.       }
  1191.   }
  1192. #undef TBL
  1195.   check_segment_integrity(s_id);
  1196.   insert_fvmb (vmb_a, vmp);
  1197.   check_segment_integrity(s_id);
  1199.   if ( ((DV(0xf00)>>8) > 2) && (DV(0xf) > 2))
  1200.     fprintf (STDERR, "Done (used %X/free %X)n",
  1201.              vmp->used, check_integrity (vmp));
  1202.   
  1203.   if (vmp == SEG_PTR (ptr)->base)
  1204.     SEG_PTR (ptr)->base = free_vmpage (vmp);
  1205.   else
  1206.     vmp->next = free_vmpage (vmp->next);
  1207.   check_vm_integrity();
  1208.   return;
  1209. }
  1211. void *
  1212. vpointer (VADR n)
  1213. {
  1214.   register byte *ret;
  1215.   VADR           n1 = n;
  1216.   P_vmpage vmp;
  1218.   if (SEG_OFF (n) == 0)
  1219.     return NULL;
  1220.   ret = check_cache(n);
  1221.   if (ret)
  1222.     return ret;
  1223.   check_vm_integrity();
  1224.   {                             /* import name processing */
  1225.     register i4_t s_id;
  1226.     s_id = SEG_ID (n);
  1227.     if (s_id < 0)
  1228.       n = resolve_reference (vpointer (SEG_BASE (~s_id) + SEG_OFF (n)));
  1229.   }
  1230.   find_vmb (&vmp, n, NULL);
  1231.   ret = vmp->page + (SEG_OFF (n) - vmp->base);
  1232.   
  1233.   check_vm_integrity();
  1234.   update_cache(n1, ret);
  1235.   return (void *) ret;
  1236. }
  1238. VADR 
  1239. vm_ob_alloc (i4_t size, i4_t align)
  1240. {
  1241.   register VADR obj;
  1242.   
  1243.   check_vm_integrity();
  1244.   enable_auto_create = 1;
  1245.   obj = ob_alloc (size, align, SEG_PTR (0));
  1246.   enable_auto_create = 0;
  1247.   
  1248.   check_segment_integrity(SEG_IND(obj));
  1249.   check_vm_integrity();
  1250.   return obj;
  1251. }
  1253. VADR 
  1254. get_vm_segment_id (VADR ptr)
  1255. {
  1256.   return SEG_BASE (SEG_IND (ptr));
  1257. }
  1259. VADR 
  1260. switch_to_segment (VADR ptr)
  1261. {
  1262.   segment_table.current = SEG_IND (ptr);
  1263.   return SEG_BASE (segment_table.current);
  1264. }
  1266. VADR 
  1267. create_segment (void)
  1268. {
  1269.   register i4_t p;
  1270.   for (p = segment_table.ent_nmb; --p > 0;)
  1271.     if (segment_table.entries[p].used == 0)
  1272.       break;
  1273.   if (p < 0)
  1274.     p = 0;
  1275.   if (!p)
  1276.     {
  1277.       ADD_ENTRY (segment_table);
  1278.       p = segment_table.ent_nmb - 1;
  1279.     }
  1280.   if (!p)                       /* index 0 is used for "current" segment. */
  1281.     {
  1282.       ADD_ENTRY (segment_table);
  1283.       p = segment_table.ent_nmb - 1;
  1284.     }
  1285.   segment_table.current = p;
  1286.   segment_table.entries[p].used = 1;
  1287.   check_segment_integrity(p);
  1289.   return (VADR) SEG_BASE (p);
  1290. }
  1292. int
  1293. unlink_segment (VADR s_id, i4_t enforce_free)
  1294. {
  1295.   register vmsegment *p = SEG_PTR (s_id);
  1296.   force_free = enforce_free;
  1297.   p->base = free_vmpage (p->base);
  1298.   force_free = 0;
  1299.   if (p->base)
  1300.     {
  1301.       if (debug_vmemory)
  1302. {
  1303.   i4_t u = 0;
  1304.   register P_vmpage vmp;
  1305.   for (vmp = p->base; vmp ; vmp = vmp->next )
  1306.     u += vmp->used;
  1307.   fprintf (STDERR,"There are %d bytes used in given segmentn",u);
  1308.   force_free = 2;
  1309.   p->base = free_vmpage (p->base);
  1310.   force_free = 0;
  1311. }
  1312.       return 0;
  1313.     }
  1314.   if (segment_table.current == SEG_IND (s_id))
  1315.     segment_table.current = 0;
  1316.   if (!p->relocation_table.dont_remove)
  1317.     FREE (p->relocation_table.entries);
  1318.   if (!p->export_table.dont_remove)
  1319.     FREE (p->export_table.entries);
  1320.   if (p->loaded_block_address)
  1321.     FREE (p->loaded_block_address);
  1322.   bzero ((void *) p, sizeof (vmsegment));
  1323.   return 1;
  1324. }
  1326. void *
  1327. export_segment (VADR s_id, i4_t *len, i4_t unlink_seg)
  1328. {
  1329.   register i4_t sz,seg_ind = SEG_IND(s_id);
  1330.   register P_vmpage vmp;
  1331.   register void *barr = NULL;
  1332.   register vmsegment *s1, *seg = SEG_PTR (s_id);
  1333.   i4_t      r_en, e_en;
  1334.   i4_t     dv = debug_vmemory;
  1335.   
  1336.   debug_vmemory |= 0x33;
  1337.   
  1338.   *len = 0;
  1339.   check_segment_integrity(seg_ind);
  1340.   compress_data (seg);
  1341.   check_segment_integrity(seg_ind);
  1342.   sz = sizeof (vmsegment);
  1343.   r_en = ( 1 + seg->relocation_table.ent_nmb / TBL_PORTION) * TBL_PORTION;
  1344.   if (seg->relocation_table.ent_nmb % TBL_PORTION ==0)
  1345.     r_en -= TBL_PORTION;
  1346.   sz += r_en * sizeof (*(seg->relocation_table.entries));
  1347.   
  1348.   e_en = ( 1 + seg->export_table.ent_nmb / TBL_PORTION) * TBL_PORTION;
  1349.   if (seg->export_table.ent_nmb % TBL_PORTION ==0)
  1350.     e_en -= TBL_PORTION;
  1351.   sz += e_en * sizeof (*(seg->export_table.entries));
  1352.   
  1353.   {
  1354.     register i4_t pgsp;
  1355.     for (pgsp = 0, vmp = seg->base; vmp; vmp = vmp->next)
  1356.       {
  1357.         pgsp += vmp->size;
  1358.         sz += sizeof (*vmp);
  1359.         check_integrity (vmp);
  1360.       }
  1361.     ALIGN (sz, PAGE_ALIGN);
  1362.     *len = sz + pgsp;
  1363.   }
  1364.   barr = MALLOC (*len);
  1365.   sz = 0;
  1367. #define ADD_BLK(p,l) {bcopy((p),((byte*)barr+sz),l);sz+=l;}
  1369.   ADD_BLK (seg, sizeof (vmsegment));
  1370.   s1 = (vmsegment *) barr;
  1371.   s1->relocation_table.entries = (void *) sz;
  1372.   ADD_BLK (seg->relocation_table.entries,
  1373.            s1->relocation_table.ent_nmb *
  1374.            sizeof (*(s1->relocation_table.entries)));
  1375.   sz = (i4_t) s1->relocation_table.entries  +
  1376.     r_en * sizeof (*(s1->relocation_table.entries));
  1377.   s1->export_table.entries = (void *) sz;
  1378.   ADD_BLK (seg->export_table.entries,
  1379.            s1->export_table.ent_nmb *
  1380.            sizeof (*(s1->export_table.entries)));
  1381.   sz = (i4_t) s1->export_table.entries  +
  1382.     e_en * sizeof (*(s1->export_table.entries));
  1383.   s1->base = (void *) sz;
  1385.   for (vmp = seg->base; vmp; vmp = vmp->next)
  1386.     {
  1387.       register P_vmpage pvmp = (P_vmpage) ((byte *) barr + sz);
  1388.       ADD_BLK (vmp, sizeof (*vmp));
  1389.       if (pvmp->next)
  1390.         pvmp->next = (void *) sz;
  1391.       pvmp->flags = 1;
  1392.     }
  1393.   ALIGN (sz, PAGE_ALIGN);
  1395.   for (vmp = s1->base; vmp;
  1396.        vmp = ((P_vmpage) ((byte *) barr + (i4_t) vmp))->next)
  1397.     {
  1398.       register P_vmpage pvmp = (P_vmpage) ((byte *) barr + (i4_t) vmp);
  1399.       register i4_t page_offset = sz;
  1400.       ADD_BLK (pvmp->page, pvmp->size);
  1401.       pvmp->page = (void *) page_offset;
  1402.     }
  1403. #undef ADD_BLK
  1404.   assert (sz == *len);
  1405.   check_segment_integrity(seg_ind);
  1406.   if (unlink_seg)
  1407.     unlink_segment (s_id, 1);
  1408.   
  1409.   debug_vmemory = dv;
  1410.   return barr;
  1411. }
  1413. VADR 
  1414. link_segment (void *buffer, i4_t size)
  1415. {
  1416.   register i4_t sz;
  1417.   register VADR s_id;
  1418.   register P_vmpage vmp;
  1419.   register vmsegment *s;
  1420.   i4_t     dv = debug_vmemory;
  1422.   debug_vmemory |= 0x33;
  1424.   s_id = create_segment ();
  1425.   s = SEG_PTR (0);
  1427. #define CORRECT_ADR(p) p=(void*)((byte*)buffer+(i4_t)(p))
  1428.   bcopy (buffer, s, sizeof (vmsegment));
  1429.   CORRECT_ADR (s->base);
  1430.   CORRECT_ADR (s->relocation_table.entries);
  1431.   if (s->relocation_table.ent_nmb==0)
  1432.     s->relocation_table.entries = NULL;
  1433.   s->relocation_table.dont_remove = 1;
  1434.   CORRECT_ADR (s->export_table.entries);
  1435.   if (s->export_table.ent_nmb==0)
  1436.     s->export_table.entries = NULL;
  1437.   s->export_table.dont_remove = 1;
  1438.   for (vmp = s->base; vmp; vmp = vmp->next)
  1439.     {
  1440.       if (vmp->page)
  1441.         CORRECT_ADR (vmp->page);
  1442.       if (vmp->next)
  1443.         CORRECT_ADR (vmp->next);
  1444.       check_integrity (vmp);
  1445.     }
  1446. #undef CORRECT_ADR
  1447.   
  1448.   for (sz = 0; sz < s->relocation_table.ent_nmb; sz++)
  1449.     if (s->relocation_table.entries[sz])
  1450.       {
  1451.         VADR *vp = (VADR *) vpointer (s->relocation_table.entries[sz]);
  1452.         if (*vp)
  1453.           *vp = SEG_OFF(*vp) +
  1454.             (SEG_ID(*vp)>=0 ? s_id : SEG_BASE(~SEG_ID(s_id)));
  1455.       }
  1456.   s->loaded_block_address = buffer;
  1457.   check_segment_integrity(SEG_IND(s_id));
  1458.   debug_vmemory = dv;
  1459.   return s_id;
  1460. }
  1462. #define CORRECT_ADR(ptr) 
  1463. {
  1464.   VADR *vp = &(ptr);
  1465.   if(*vp)
  1466.     *vp = SEG_OFF(*vp)+
  1467.       SEG_BASE(get_vm_segment_id(*vp)^(SEG_ID(*vp)>=0?0:~0)); 
  1468. }
  1470. void 
  1471. register_relocation_address (VADR ptr)
  1472. {
  1473.   register i4_t      p;
  1474.   register reloc_tbl *rt  = & (SEG_PTR(ptr)->relocation_table);
  1475. #define TBL (*rt)
  1476.   
  1477.   assert(SEG_OFF(ptr) != 0);
  1479.   
  1480.   /* self checking --- fix to be more smart */ 
  1481.   for (p = 0; p < TBL.ent_nmb; p++ )
  1482.     if ( TBL.entries[p] == SEG_OFF(ptr) )
  1483.       {
  1484.         yyerror("Internal error: relocation address registered twice");
  1485.         return;
  1486.       }
  1487.   /*---------------*/
  1488.   if ( TBL.used_ent == TBL.ent_nmb )
  1489.     p = TBL.ent_nmb;
  1490.   else
  1491.     for (p = TBL.ent_nmb; p > 0 ;)
  1492.       if ( TBL.entries[--p] == 0 ) /* IF there are holes in the table      */
  1493.         break;                     /* just use it instead of adding new entries */
  1494.   if ( p >= TBL.ent_nmb)
  1495.     {
  1496.       ADD_ENTRY (TBL);
  1497.       p = TBL.ent_nmb - 1;
  1498.       TBL.used_ent = TBL.ent_nmb;
  1499.     }
  1500.   TBL.entries[p] = SEG_OFF(ptr);
  1501.   CORRECT_ADR (*((VADR *) vpointer (ptr)));
  1502.   check_segment_integrity(SEG_IND(ptr));
  1503. #undef TBL
  1504. }
  1506. void 
  1507. register_export_name (VADR object_ptr, VADR name_ptr)
  1508. {
  1509. #define TBL seg->export_table
  1510.   register i4_t       p,p1 = -1;
  1511.   register char      *name;
  1512.   register vmsegment *seg;
  1514.   assert (SEG_IND (object_ptr) == SEG_IND (name_ptr));
  1515.   seg = SEG_PTR (object_ptr);
  1516.   name = vpointer (name_ptr);
  1517.   for (p = 0; p < TBL.ent_nmb; p++)
  1518.     if (TBL.entries[p].adr == 0)
  1519.       {
  1520. p1 = p;
  1521. continue;
  1522.       }
  1523.     else if (0 == strcmp (vpointer (TBL.entries[p].name), name))
  1524.       { /* IF given name has already registered */
  1525.         if (SEG_OFF (object_ptr) != SEG_OFF (TBL.entries[p].adr))
  1526.   {
  1527.     /* but the exported object isn't the same */
  1528.     yyerror ("Attempt to register different relocable"
  1529.      " objects with the same name");
  1530.   }
  1531.         return;
  1532.       }
  1533.   if ( p1 >= 0 )              /* IF there are holes in the table           */
  1534.     p = p1;                   /* just use it instead of adding new entries */
  1535.   else                        /* IF there is no holes in the table         */
  1536.     {                         /* add new entry there                       */
  1537.       ADD_ENTRY (TBL);
  1538.       p = TBL.ent_nmb - 1;
  1539.     }
  1540.   TBL.entries[p].adr  = SEG_OFF(object_ptr);
  1541.   TBL.entries[p].name = SEG_OFF(name_ptr);
  1542.   check_segment_integrity(SEG_IND(object_ptr));
  1543. #undef TBL
  1544. }
  1546. void 
  1547. register_export_address (VADR registered_adr, char *name)
  1548. {
  1549.   VADR name_ptr;
  1550.   register i4_t len;
  1551.   len = strlen (name) + 1;
  1552.   name_ptr = ob_alloc (len, 1, SEG_PTR (registered_adr));
  1553.   name_ptr += get_vm_segment_id (registered_adr);
  1554.   bcopy (name, vpointer (name_ptr), len);
  1555.   register_export_name (registered_adr, name_ptr);
  1556. }
  1558. static VADR 
  1559. resolve_reference_1 (char *name,i4_t local)
  1560. {
  1561. #define TBL  segment_table.entries[segment_table.current].export_table
  1562.   register i4_t p, s;
  1563.   register VADR obj = (VADR)NULL, cs = segment_table.current;
  1565.   for (s = 0; s < segment_table.ent_nmb; s++)
  1566.     {
  1567.       segment_table.current = s ? s : cs ;
  1568.       for (p = 0; p < TBL.ent_nmb; p++)
  1569. if (TBL.entries[p].adr == 0 )
  1570.   continue;
  1571. else if (0 == strcmp (vpointer (TBL.entries[p].name), name))
  1572.           {
  1573.             register VADR o;
  1574.     o = TBL.entries[p].adr + SEG_BASE (segment_table.current);
  1575.             if (!obj)
  1576.               obj = o;
  1577.             else if (obj != o)
  1578.               {
  1579.                 fprintf (STDERR, "Ambigous name reference '%s'n", 
  1580.                          (char *) vpointer (TBL.entries[p].name));
  1581.                 obj = TNULL;
  1582. goto EXIT;
  1583.               }
  1584.           }
  1585.       if (s == 0 && (obj || local))
  1586. goto EXIT;
  1587.     }
  1588. EXIT:
  1589.   segment_table.current = cs;
  1590.   return obj;
  1591. #undef TBL
  1592. }
  1594. VADR 
  1595. resolve_reference (char *name)
  1596. {
  1597.   return resolve_reference_1 (name, 0);
  1598. }
  1600. VADR 
  1601. resolve_local_reference (char *name)
  1602. {
  1603.   return resolve_reference_1 (name, 1);
  1604. }
  1606. VADR 
  1607. external_reference (char *name) 
  1608. { /* creating external reference to 'name' from 'current' segment */
  1609.   register VADR ptr;
  1610.   register i4_t len;
  1611.   len = strlen (name) + 1;
  1612.   ptr = vm_ob_alloc (len, 0); 
  1613.   bcopy (name, vpointer (ptr), len);
  1614.   /*
  1615.    * !!! It's a local reference - the name resolution has to be required  
  1616.    *     only while this segment marked as a 'current'
  1617.    */
  1618.   return SEG_OFF (ptr) + SEG_BASE (~SEG_ID (ptr));
  1619. }
  1621. #undef CORRECT_ADR
  1623. VADR
  1624. ptr2vadr(void *p)
  1625. {
  1626.   register i4_t i;
  1627.   register P_vmpage vmp;
  1628.   register vmsegment *s;
  1630.   for(i=0; i<segment_table.ent_nmb; i++)
  1631.     {
  1632.       s = &(segment_table.entries[i?i:segment_table.current]);
  1633.       for(vmp=s->base; vmp; vmp = vmp = vmp->next)
  1634.         if (vmp->page < (byte*)p && (byte*)p < vmp->page+vmp->size)
  1635.           return SEG_BASE(i?i:segment_table.current) +
  1636.             vmp->base + (i4_t)((byte*)p - vmp->page);
  1637.     }
  1638.   return VNULL;
  1639. }
  1642. #ifdef USE_XVM
  1643. /*******************************************************/
  1644. /*********$$$$$$$$$$$$$$$$$$$$$$$$$*********************/
  1645. /*******************************************************/
  1647. #define HPLIM 50
  1648. static void *huge_pieces[HPLIM];
  1649. static i4_t   hp_used = 0;
  1651. static void *
  1652. h1(void *p,i4_t size)
  1653. {
  1654.   i4_t i;
  1655.   for(i=hp_used;i--;)
  1656.     if(huge_pieces[i]==p)
  1657.       break;
  1658.   if(i<0)
  1659.     i=hp_used++;
  1660.   
  1661.   assert(i<HPLIM);
  1662.   if(size)
  1663.     huge_pieces[i] = (p?lrealloc(p,size):lmalloc(size));
  1664.   else
  1665.     {
  1666.       lfree(p);
  1667.       huge_pieces[i] = NULL;
  1668.     }
  1669.   return huge_pieces[i];
  1670. }
  1672. void *
  1673. xmalloc(i4_t size)
  1674. {
  1675.   VADR hold_seg = GET_CURRENT_SEGMENT_ID;
  1676.   void *ptr;
  1677.   if(size>=0x8000) /* 32k*/
  1678.     return h1(NULL,size);
  1679.   if(xmemory_segment==VNULL)
  1680.     xmemory_segment = create_segment();
  1681.   switch_to_segment(xmemory_segment);
  1682.   ptr = vpointer(vmalloc(size));
  1683.   switch_to_segment( hold_seg );
  1684.   return ptr;
  1685. }
  1687. void *
  1688. xcalloc (i4_t number, i4_t size)
  1689. {
  1690.   return xmalloc(number*size);
  1691. }
  1693. void *
  1694. xrealloc(void *p,i4_t size)
  1695. {
  1696.   VADR hold_seg = GET_CURRENT_SEGMENT_ID;
  1697.   void *ptr;
  1698.   if(size>=0x8000) /* 32k*/
  1699.     return h1(p,size);
  1700.   if(xmemory_segment==VNULL)
  1701.     xmemory_segment = create_segment();
  1702.   switch_to_segment(xmemory_segment);
  1703.   ptr = vpointer(vmrealloc(ptr2vadr(p),size));
  1704.   switch_to_segment( hold_seg );
  1705.   return ptr;
  1706. }
  1708. void
  1709. xfree(void *p)
  1710. {
  1711.   VADR hold_seg = GET_CURRENT_SEGMENT_ID;
  1712.   VADR v;
  1713.   if(xmemory_segment==VNULL)
  1714.     xmemory_segment = create_segment();
  1715.   switch_to_segment(xmemory_segment);
  1716.   v = ptr2vadr(p);
  1717.   if (v)
  1718.     vmfree(v);
  1719.   else
  1720.     h1(p,0);
  1721.   switch_to_segment( hold_seg );
  1722. }
  1724. #define L_DLT 0x100
  1726. static void *
  1727. lmalloc(i4_t size)
  1728. {
  1729.   void *p = malloc(2*L_DLT+size);
  1730.   if (p==NULL)
  1731.     yyfatal("Memory Full");
  1732.   p = (char*)p+L_DLT; 
  1733.   bzero (p, size);
  1734.   return p;
  1735. }
  1737. static void *
  1738. lrealloc(void *p,i4_t size)
  1739. {
  1740.   if(p)
  1741.     p = (char*)p-L_DLT;
  1742.   p = realloc(p,size + 2*L_DLT);
  1743.   if (p==NULL)
  1744.     yyfatal("Memory Full");
  1745.   /*  bzero (p, size); */
  1746.   return (char*)p + L_DLT;
  1747. }
  1749. static void
  1750. lfree(void *p)
  1751. {
  1752.   if(p)
  1753.     free((char*)p - L_DLT);
  1754. }
  1756. #endif