static char RCSid[] =

"$Header$";

#endif

/* 

 *   Copyright (c) 1999, 2002 Michael J. Roberts.  All Rights Reserved.

 *   

 *   Please see the accompanying license file, LICENSE.TXT, for information

 *   on using and copying this software.  

 */

/*

Name

  vmimgrb.cpp - T3 Image File Re-Builder

Function

  This module re-builds an image file from the contents of memory after

  the program has been "pre-initialized."  This allows a program to

  run through its static state initialization during the compilation

  process, then store the result as a new image file with pre-initialized

  state.  Any initialization that must always happen for every run of

  the program can be performed during this pre-initialization pass,

  saving the time of doing the work each time the program is run.

  Mostly, we just copy the old image file to the new image file; most

  parts of the image file are copied without changes.  We update the

  object stream, replacing the original objects with the objects in

  their pre-initialized state, and we add any new strings dynamically

  created during pre-initialization to the constant pool.

Notes

Modified

  07/21/99 MJRoberts  - Creation

*/

#include <stdlib.h>

#include <memory.h>

#include "t3std.h"

#include "vmfile.h"

#include "vmimage.h"

#include "vmpool.h"

#include "vmglob.h"

#include "vmwrtimg.h"

#include "vmobj.h"

#include "vmtobj.h"

#include "vmdict.h"

#include "vmhash.h"

#include "vmlst.h"

#include "vmbignum.h"

#include "vmstr.h"

#include "vmgram.h"

#include "vmmeta.h"

#include "vmimgrb.h"

#include "vmintcls.h"

#include "vmiter.h"

#include "vmvec.h"

#include "vmlookup.h"

#include "vmstack.h"

#include "vmbytarr.h"

#include "vmcset.h"

#include "vmfilobj.h"

#include "vmpat.h"

#include "vmstrcmp.h"

/* ------------------------------------------------------------------------ */

/*

 *   Rebuild the OBJS blocks and write the data to the file.  This goes

 *   through the objects in memory and constructs fixed image-file

 *   versions of the objects, then writes them to OBJS blocks.  

 */

static void vm_rewrite_objs_blocks(VMG_ CVmImageWriter *writer,

                                   class CVmConstMapper *mapper)

{

    size_t i;

    /* rewrite the image block for each of our defined metaclasses */

    for (i = 0 ; i < G_meta_table->get_count() ; ++i)

    {

        /* write this metaclass's objects */

        G_obj_table->rebuild_image(vmg_ i, writer, mapper);

    }

}

/* ------------------------------------------------------------------------ */

/*

 *   Re-write the image file 

 */

void vm_rewrite_image(VMG_ CVmFile *origfp, CVmFile *newfp,

                      ulong static_cs_ofs)

{

    char buf[4096];

    int done;

    CVmImageWriter *writer;

    CVmConstMapper *const_mapper;

    uchar xor_mask;

    ulong code_page_size;

    /* we don't know the code page size yet */

    code_page_size = 0;

    /* choose an arbitrary XOR mask for our pages */

    xor_mask = 0xEF;

    /* create an image writer to help us write the output file */

    writer = new CVmImageWriter(newfp);

    /* create our constant mapper */

    const_mapper = new CVmConstMapper(vmg0_);

    /* 

     *   clear all undo information - we don't save undo with the rebuilt

     *   file, so there's no reason to keep any of the objects that are

     *   referenced only in the undo records 

     */

    G_undo->drop_undo(vmg0_);

    /* discard everything on the stack */

    G_stk->discard(G_stk->get_depth());

    /* 

     *   perform a full garbage collection pass, to make sure we don't

     *   include any unreachable objects in the new image file 

     */

    G_obj_table->gc_full(vmg0_);

    /* add any metaclasses that weren't in the dependency table originally */

    G_obj_table->add_metadeps_for_instances(vmg0_);

    /* convert objects to constant data to the extent possible */

    G_obj_table->rebuild_image_convert_const_data(vmg_ const_mapper);

    /* 

     *   copy the header (signature, UINT2 format version number, 32

     *   reserved bytes, 24-byte compilation timestamp) to the new file 

     */

    origfp->read_bytes(buf, sizeof(VMIMAGE_SIG) - 1 + 2 + 32 + 24);

    newfp->write_bytes(buf, sizeof(VMIMAGE_SIG) - 1 + 2 + 32 + 24);

    /* copy or replace the data blocks */

    for (done = FALSE ; !done ; )

    {

        ulong siz;

        /* read the next block header */

        origfp->read_bytes(buf, 10);

        /* get the size */

        siz = t3rp4u(buf + 4);

        /* check the block type */

        if (CVmImageLoader::block_type_is(buf, "OBJS")

            || CVmImageLoader::block_type_is(buf, "MCLD")

            || CVmImageLoader::block_type_is(buf, "SINI"))

        {

            /* 

             *   Simply skip all of the original OBJS (object data) or

             *   MCLD (metaclass dependency table) blocks -- we'll replace

             *   them with our re-built blocks.

             *   

             *   Also skip SINI (static initializer) blocks, since these

             *   are only needed for pre-initialization and can be

             *   discarded from the final image file.  

             */

            origfp->set_pos(origfp->get_pos() + (long)siz);

        }

        else if (CVmImageLoader::block_type_is(buf, "CPDF"))

        {

            char cpdf_buf[20];

            uint pool_id;

            ulong pgcnt;

            ulong pgsiz;

            /* read the pool definition */

            origfp->read_bytes(cpdf_buf, 10);

            /* get the ID, page count, and page size from the definition */

            pool_id = osrp2(cpdf_buf);

            pgcnt = t3rp4u(cpdf_buf + 2);

            pgsiz = t3rp4u(cpdf_buf + 6);

            /* 

             *   if this is the constant pool (pool ID = 2), increase the

             *   page count by the extra constant pool pages we need for

             *   converting new object data to constants 

             */

            if (pool_id == 2)

            {

                /* add in our new count */

                pgcnt += const_mapper->get_page_count();

                /* write the new count */

                oswp4(cpdf_buf + 2, pgcnt);

            }

            /*

             *   if this is the code pool (pool ID = 1), and we have

             *   static initializers, decrease the page count to exclude

             *   the static initializer pages (all of the static

             *   initializers are grouped at the high end of the code

             *   pool, so we can discard them and only them by truncating

             *   the code pool before the page containing the first static

             *   initializer) 

             */

            if (pool_id == 1 && static_cs_ofs != 0)

            {

                /* 

                 *   calculate the new count - it's the offset to the

                 *   first static initializer divided by the size of each

                 *   code page 

                 */

                pgcnt = static_cs_ofs / pgsiz;

                /* write the new count */

                oswp4(cpdf_buf + 2, pgcnt);

                /* 

                 *   remember the code page size for later, when we're

                 *   scanning the code pages themselves 

                 */

                code_page_size = pgsiz;

            }

            /* update the constant block definition */

            newfp->write_bytes(buf, 10);

            newfp->write_bytes(cpdf_buf, 10);

        }

        else if (CVmImageLoader::block_type_is(buf, "CPPG"))

        {

            char cppg_buf[20];

            long start_pos;

            uint pool_id;

            ulong page_idx;

            int keep_block;

            /* presume we're going to keep this block */

            keep_block = TRUE;

            /* 

             *   This is a constant page - if it's in pool 2 (constants),

             *   use its XOR mask for any new pages we write.  First, read

             *   the pool header, then seek back so we can copy the block

             *   unchanged.  

             */

            start_pos = origfp->get_pos();

            origfp->read_bytes(cppg_buf, 7);

            origfp->set_pos(start_pos);

            /* get the pool ID and the page's index */

            pool_id = osrp2(cppg_buf);

            page_idx = t3rp4u(cppg_buf + 2);

            /* if it's pool 2 (constants), read its XOR mask byte */

            if (pool_id == 2)

                xor_mask = cppg_buf[6];

            /* 

             *   if it's pool 1 (code), and it's above the start of the

             *   static initializers, skip it - we don't want to copy

             *   static initializer code to the final image file, since

             *   they're only needed for static initialization, which we

             *   necessarily have finished by the time we reach this point 

             */

            if (pool_id == 1

                && static_cs_ofs != 0

                && page_idx * code_page_size >= static_cs_ofs)

            {

                /* this is a static initializer block - skip it */

                keep_block = FALSE;

            }

            /* keep or skip the block, as appropriate */

            if (keep_block)

            {

                /* 

                 *   we only wanted to get information from this block, so

                 *   go copy it as-is to the output 

                 */

                goto copy_block;

            }

            else

            {

                /* skip past the block */

                origfp->set_pos(origfp->get_pos() + (long)siz);

            }

        }

        else if (CVmImageLoader::block_type_is(buf, "EOF "))

        {

            /* end of file - note that we're done after this block */

            done = TRUE;

            /* re-write the metaclass dependency block */

            G_meta_table->rebuild_image(writer);

            /* write our new OBJS blocks */

            vm_rewrite_objs_blocks(vmg_ writer, const_mapper);

            /* write our new constant pool pages */

            const_mapper->write_to_image_file(writer, xor_mask);

            /* copy the EOF block to the new file unchanged */

            goto copy_block;

        }

        else

        {

        copy_block:

            /*

             *   For anything else, we'll simply copy the original block

             *   from the original image file unchanged. 

             */

            /* write the block header unchanged */

            newfp->write_bytes(buf, 10);

            /* copy the block in chunks */

            while (siz != 0)

            {

                size_t cur;

                /* 

                 *   read as much as we can, up to the amount remaining or

                 *   the buffer size, whichever is smaller 

                 */

                cur = sizeof(buf);

                if (cur > siz)

                    cur = (size_t)siz;

                /* read the data and write it out */

                origfp->read_bytes(buf, cur);

                newfp->write_bytes(buf, cur);

                /* deduct this chunk from the amount remaining */

                siz -= cur;

            }

        }

    }

    /* we're done with the image writer */

    delete writer;

    /* we're done with the constant mapper */

    delete const_mapper;

}

/* ------------------------------------------------------------------------ */

/*

 *   Object Table extension - rebuild the image file representations for

 *   all objects of a particular metaclass.

 */

void CVmObjTable::rebuild_image(VMG_ int meta_dep_idx, CVmImageWriter *writer,

                                class CVmConstMapper *mapper)

{

    int pass;

    /* write persistent and transient objects separately */

    for (pass = 1 ; pass <= 2 ; ++pass)

    {

        int trans;

        /* write persistent on pass 1, transient on pass 2 */

        trans = (pass == 2);

        /* write the objects for this pass */

        rebuild_image(vmg_ meta_dep_idx, writer, mapper, trans);

    }

}

/*

 *   Write all of the transient or persistent objects of a given metaclass. 

 */

void CVmObjTable::rebuild_image(VMG_ int meta_dep_idx, CVmImageWriter *writer,

                                class CVmConstMapper *mapper, int trans)

{

    CVmObjPageEntry **pg;

    size_t i;

    vm_obj_id_t id;

    char *buf;

    ulong bufsiz;

    int block_cnt;

    ulong block_size;

    int large_objects;

    /* we haven't written anything to the file yet */

    block_cnt = 0;

    block_size = 0;

    /* presume we'll use small objects */

    large_objects = FALSE;

    /* 

     *   allocate an initial object buffer - we'll expand this as needed

     *   if we find an object that doesn't fit 

     */

    bufsiz = 4096;

    buf = (char *)t3malloc((size_t)bufsiz);

    if (buf == 0)

        err_throw(VMERR_OUT_OF_MEMORY);

    /* go through each page in the object table */

    for (id = 0, i = pages_used_, pg = pages_ ; i > 0 ; ++pg, --i)

    {

        size_t j;

        CVmObjPageEntry *entry;

        /* start at the start of the page */

        j = VM_OBJ_PAGE_CNT;

        entry = *pg;

        /* go through each entry on this page */

        for ( ; j > 0 ; --j, ++entry, ++id)

        {

            /* 

             *   if this entry is in use, and its transient/persistent type

             *   matches the type we're writing, and its metaclass matches

             *   the one we're writing, write it out 

             */

            if (!entry->free_

                && (entry->transient_ != 0) == (trans != 0)

                && (G_meta_table->get_dependency_index(

                    entry->get_vm_obj()->get_metaclass_reg()->get_reg_idx())

                    == meta_dep_idx))

            {

                ulong objsiz;

                /* 

                 *   if this object has been mapped to a constant value,

                 *   there's no need to store it, since it is no longer

                 *   reachable 

                 */

                if (mapper->get_pool_addr(id) != 0)

                    continue;

                /* try building the object */

                objsiz = entry->get_vm_obj()->rebuild_image(vmg_ buf, bufsiz);

                /* if they need more space, reallocate the buffer */

                if (objsiz > bufsiz)

                {

                    /* if the object is too large, throw an error */

                    if (objsiz > OSMALMAX)

                        err_throw(VMERR_OBJ_SIZE_OVERFLOW);

                    /* reallocate to next 4k increment */

                    bufsiz = (objsiz + 4095) & ~4095;

                    buf = (char *)t3realloc(buf, (size_t)bufsiz);

                    if (buf == 0)

                        err_throw(VMERR_OUT_OF_MEMORY);

                    /* try it again */

                    objsiz = entry->get_vm_obj()->

                             rebuild_image(vmg_ buf, bufsiz);

                }

                /* if the object is not empty, write it out */

                if (objsiz != 0)

                {

                    char prefix[20];

                    /* 

                     *   if this object's size exceeds 64k, and the

                     *   current OBJS block is a small block, end this

                     *   OBJS block and begin a large OBJS block 

                     */

                    if (objsiz > 65535 && !large_objects)

                    {

                        /* if we have a block open, end it */

                        if (block_cnt != 0)

                            writer->end_objs_block(block_cnt);

                        /* reset the count and size for the new block */

                        block_cnt = 0;

                        block_size = 0;

                        /* make the next block a large block */

                        large_objects = TRUE;

                    }

                    /* 

                     *   if this object plus its prefix would push this

                     *   OBJS block over 64k, close it off and start a new

                     *   block 

                     */

                    if (block_size + objsiz + 6 > 64000L && block_cnt != 0)

                    {

                        /* close this block */

                        writer->end_objs_block(block_cnt);

                        /* reset the count and size for the new block */

                        block_cnt = 0;

                        block_size = 0;

                        /* 

                         *   use small size fields if this block isn't

                         *   itself large 

                         */

                        if (objsiz <= 65535)

                            large_objects = FALSE;

                    }

                    /* if this is the first object, write the header */

                    if (block_cnt == 0)

                        writer->begin_objs_block(meta_dep_idx, large_objects,

                                                 trans);

                    /* write the prefix information */

                    oswp4(prefix, id);

                    if (large_objects)

                    {

                        /* write the 32-bit object size */

                        oswp4(prefix + 4, objsiz);

                        /* write the header */

                        writer->write_objs_bytes(prefix, 8);

                    }

                    else

                    {

                        /* write the 16-bit object size */

                        oswp2(prefix + 4, objsiz);

                        /* write the header */

                        writer->write_objs_bytes(prefix, 6);

                    }

                    /* write the object data */

                    writer->write_objs_bytes(buf, objsiz);

                    /* count the object */

                    ++block_cnt;

                    /* count the size (including the prefix) */

                    block_size += objsiz + 6;

                }

            }

        }

    }

    /* if we wrote any objects, end the OBJS block */

    if (block_cnt != 0)

        writer->end_objs_block(block_cnt);

    /* delete our buffer */

    t3free(buf);

}

/*

 *   Scan all active objects and convert objects to constant data where

 *   possible.  Certain object metaclasses, such as strings and lists, can

 *   be represented in a rebuilt image file as constant data; this routine

 *   makes all of these conversions.  

 */

void CVmObjTable::rebuild_image_convert_const_data

   (VMG_ CVmConstMapper *const_mapper)

{

    CVmObjPageEntry **pg;

    size_t i;

    vm_obj_id_t id;

    /* 

     *   First pass: go through each page in the object table, and reserve

     *   space for the constant conversion.  This assigns each object that

     *   can be converted its address in the new constant pool pages. 

     */

    for (id = 0, i = pages_used_, pg = pages_ ; i > 0 ; ++pg, --i)

    {

        size_t j;

        CVmObjPageEntry *entry;

        /* start at the start of the page, but skip object ID = 0 */

        j = VM_OBJ_PAGE_CNT;

        entry = *pg;

        /* go through each entry on this page */

        for ( ; j > 0 ; --j, ++entry, ++id)

        {

            /* 

             *   if this entry is in use, tell it to reserve space for

             *   conversion to constant data 

             */

            if (!entry->free_)

                entry->get_vm_obj()

                    ->reserve_const_data(vmg_ const_mapper, id);

        }

    }

    /* prepare the constant mapper to begin storing */

    const_mapper->prepare_to_store_data();

    /*

     *   Second pass: go through the objects once again and make the

     *   conversions.  We must do this on a separate second pass because

     *   we must fix up all references to objects being converted, hence

     *   we must know the conversion status of every object to be

     *   converted before we can fix up anything.  

     */

    for (id = 0, i = pages_used_, pg = pages_ ; i > 0 ; ++pg, --i)

    {

        size_t j;

        CVmObjPageEntry *entry;

        /* start at the start of the page, but skip object ID = 0 */

        j = VM_OBJ_PAGE_CNT;

        entry = *pg;

        /* go through each entry on this page */

        for ( ; j > 0 ; --j, ++entry, ++id)

        {

            /* if this entry is in use, convert it if possible */

            if (!entry->free_)

                entry->get_vm_obj()

                    ->convert_to_const_data(vmg_ const_mapper, id);

        }

    }

}

/* ------------------------------------------------------------------------ */

/*

 *   Convert a value to constant data.  If the value is an object that has

 *   reserved constant data space for itself, we'll update the value to

 *   reflect the constant data conversion for the value.  

 */

static void convert_dh_to_const_data(VMG_ CVmConstMapper *mapper, char *p)

{

    /* if the value is an object, check for conversion */

    if (vmb_get_dh_type(p) == VM_OBJ)

    {

        vm_obj_id_t obj;

        ulong addr;

        /* get the object value */

        obj = vmb_get_dh_obj(p);

        /* look up the object's converted constant pool address */

        if ((addr = mapper->get_pool_addr(obj)) != 0)

        {

            vm_val_t val;

            /* this value has been converted - set the new value */

            val.typ = vm_objp(vmg_ obj)->get_convert_to_const_data_type();

            val.val.ofs = addr;

            vmb_put_dh(p, &val);

        }

    }

}

/*

 *   Convert a vm_val_t value to constant data if appropriate. 

 */

static void convert_val_to_const_data(VMG_ CVmConstMapper *mapper,

                                      vm_val_t *val)

{

    /* if it's an object, check for conversion */

    if (val->typ == VM_OBJ)

    {

        ulong addr;

        /* look up the object's converted constant pool address */

        if ((addr = mapper->get_pool_addr(val->val.obj)) != 0)

        {

            /* this value has been converted - set the new value */

            val->typ = vm_objp(vmg_ val->val.obj)

                       ->get_convert_to_const_data_type();

            val->val.ofs = addr;

        }

    }

}

/* ------------------------------------------------------------------------ */

/*

 *   List Metaclass implementation - image rebuilding 

 */

/*

 *   Build an image file record for the list.  We need this because we

 *   can't always convert a list to a constant value when rebuilding an

 *   image file; in particular, if the list exceeds the size of a constant

 *   pool page (unlikely but possible), we will have to store the list as

 *   object data.  

 */

ulong CVmObjList::rebuild_image(VMG_ char *buf, ulong buflen)

{

    size_t copy_size;

    /* calculate how much space we need to store the data */

    copy_size = calc_alloc(vmb_get_len(ext_));

    /* make sure we have room for our data */

    if (copy_size > buflen)

        return copy_size;

    /* copy the data */

    memcpy(buf, ext_, copy_size);

    /* return the size */

    return copy_size;

}

/*

 *   Reserve space in a rebuilt constant pool for converting our data to a

 *   constant value.

 */

void CVmObjList::reserve_const_data(VMG_ CVmConstMapper *mapper,

                                    vm_obj_id_t self)

{

    /* reserve the space for our list data */

    mapper->alloc_pool_space(self, calc_alloc(vmb_get_len(ext_)));

}

/*

 *   Convert to constant data.  We must check each object that we

 *   reference via a modified property and convert it to a constant data

 *   item if necessary.  Then, we must store our data in the constant

 *   pool, if we successfully reserved an address for it.  

 */

void CVmObjList::convert_to_const_data(VMG_ CVmConstMapper *mapper,

                                       vm_obj_id_t self)

{

    size_t cnt;

    char *p;

    /* get my element count */

    cnt = vmb_get_len(ext_);

    /* mark as referenced each object in our list */

    for (p = get_element_ptr(0) ; cnt != 0 ; --cnt, inc_element_ptr(&p))

    {

        /* convert the value to constant data if possible */

        convert_dh_to_const_data(vmg_ mapper, p);

    }

    /* 

     *   if we managed to convert our object to constant data, store our

     *   value 

     */

    if (mapper->get_pool_addr(self))

        mapper->store_data(self, ext_, calc_alloc(vmb_get_len(ext_)));

}

/* ------------------------------------------------------------------------ */

/*

 *   String Metaclass implementation - image rebuilding 

 */

/*

 *   Build an image file record for the string.  We need this because we

 *   can't always convert a string to a constant value when rebuilding an

 *   image file; in particular, if the string exceeds the size of a

 *   constant pool page (unlikely but possible), we will have to store the

 *   string as object data.  

 */

ulong CVmObjString::rebuild_image(VMG_ char *buf, ulong buflen)

{

    size_t copy_size;

    /* calculate how much space we need to store the data */

    copy_size = vmb_get_len(ext_) + VMB_LEN;

    /* make sure we have room for our data */

    if (copy_size > buflen)

        return copy_size;

    /* copy the data */

    memcpy(buf, ext_, copy_size);

    /* return the size */

    return copy_size;

}

/*

 *   Reserve space in a rebuilt constant pool for converting our data to a

 *   constant value.

 */

void CVmObjString::reserve_const_data(VMG_ CVmConstMapper *mapper,

                                      vm_obj_id_t self)

{

    /* reserve the space for our string data */

    mapper->alloc_pool_space(self, vmb_get_len(ext_) + VMB_LEN);

}

/*

 *   Convert to constant data.  We don't reference any objects, so we need

 *   simply store our data in the constant pool, if we successfully

 *   reserved an address for it.  

 */

void CVmObjString::convert_to_const_data(VMG_ CVmConstMapper *mapper,

                                         vm_obj_id_t self)

{

    /* 

     *   if we managed to convert our object to constant data, store our

     *   value 

     */

    if (mapper->get_pool_addr(self))

        mapper->store_data(self, ext_, vmb_get_len(ext_) + VMB_LEN);

}

/* ------------------------------------------------------------------------ */

/*

 *   TADS Object implementation - image rebuilding 

 */

/* property comparison callback for qsort() */

extern "C"

{

    static int prop_compare(const void *p1, const void *p2)

    {

        uint id1, id2;

        /* get the ID's */

        id1 = osrp2(p1);

        id2 = osrp2(p2);

        /* compare them and return the result */

        return (id1 < id2 ? -1 : id1 == id2 ? 0 : 1);

    }

}

/*

 *   build an image file record for the object 

 */

ulong CVmObjTads::rebuild_image(VMG_ char *buf, ulong buflen)

{

    size_t max_size;

    char *p;

    char *props;

    char *props_end;

    size_t prop_cnt;

    size_t i;

    vm_tadsobj_prop *entry;

    /* 

     *   Make sure the buffer is big enough.  Start out with worst-case

     *   assumption that we'll need every allocated property slot; we might

     *   actually need fewer, since some of the slots could be empty by

     *   virtue of having been undone.  We need space for our own header

     *   (UINT2 superclass count, UINT2 property count, UINT2 flags), plus a

     *   UINT4 per superclass, plus a (UINT2 + DATAHOLDER) per property.  

     */

    max_size = (2 + 2 + 2)

               + get_sc_count() * 4

               + (get_hdr()->prop_entry_free * 7);

    /* if it's more than we have available, ask for more space */

    if (max_size > buflen)

        return max_size;

    /* 

     *   set up our header - use a placeholder 0 for the property count

     *   for now, until we calculate the real value 

     */

    oswp2(buf, get_sc_count());

    oswp2(buf+2, 0);

    oswp2(buf+4, get_li_obj_flags());

    p = buf + 6;

    /* copy the superclass list */

    for (i = 0 ; i < get_sc_count() ; ++i, p += 4)

        oswp4(p, get_sc(i));

    /* remember where the properties start */

    props = p;

    /* copy the non-empty property slots */

    for (i = get_hdr()->prop_entry_free, entry = get_hdr()->prop_entry_arr,

         prop_cnt = 0 ;

         i != 0 ;

         --i, ++entry)

    {

        /* if this slot is non-empty, store it */

        if (entry->val.typ != VM_EMPTY)

        {

            /* set up this slot */

            oswp2(p, entry->prop);

            vmb_put_dh(p + 2, &entry->val);