*** empty log message ***

* empty log message *
Alain Prouté
1 parent 05814796
Showing 9 changed files with 241 additions and 79 deletions Show diff stats
anubis_dev/vm/proj/linux/Makefile
anubis_dev/vm/src/AnubisAllocator.cpp
anubis_dev/vm/src/AnubisAllocator.h
anubis_dev/vm/src/serialize.cpp
anubis_dev/vm/src/syscall.cpp
anubis_dev/vm/src/vm.cpp
anubis_dev/vm/src/vm.h
anubis_dev/vm/src/vmtools.cpp
anubis_distrib/linux_install/bin/anbexec
@@ -18,6 +18,9 @@ TRDDIR = $(HOME)/third_dev
 OPTIMIZE = -g
 INCLUDE = -I$(DEVDIR)/include -I$(SRCDIR)
  
+#DEFINES = -D_LINUX_ -D_WITH_GRAPHISM_ -Ddebug_vm
+DEFINES = -D_LINUX_ -D_WITH_GRAPHISM_
+
 #
 # Object files by categories.
 #
@@ -69,39 +72,39 @@ dependancies_perso: $(main_objs:.o=.d) $(special_objs:.o=.perso.d) $(cipher_objs
 # Making object files. 
 #
 %.perso.o: $(SRCDIR)/%.c
-	gcc $(OPTIMIZE) $(INCLUDE) -o $@ -c -Wall -Wstrict-prototypes -D_LINUX_ -D_WITH_GRAPHISM_\
+	gcc $(OPTIMIZE) $(INCLUDE) -o $@ -c -Wall -Wstrict-prototypes $(DEFINES)\
           -D_CRYPTADM_ $<
  
 %.perso.o: $(SRCDIR)/%.cpp
-	gcc $(OPTIMIZE) $(INCLUDE) -o $@ -c -Wall -Wstrict-prototypes -D_LINUX_ -D_WITH_GRAPHISM_\
+	gcc $(OPTIMIZE) $(INCLUDE) -o $@ -c -Wall -Wstrict-prototypes $(DEFINES)\
           -D_CRYPTADM_ $<
  
 %.o: $(TRDDIR)/sqlite3/%.c
 	gcc $(OPTIMIZE) $(INCLUDE) -o $@ -c -DNO_TCL $<
  
 %.o: $(SRCDIR)/%.c
-	gcc $(OPTIMIZE) $(INCLUDE) -o $@ -c -Wall -Wstrict-prototypes -D_LINUX_ -D_WITH_GRAPHISM_ $<
+	gcc $(OPTIMIZE) $(INCLUDE) -o $@ -c -Wall -Wstrict-prototypes $(DEFINES) $<
  
 %.o: $(SRCDIR)/%.cpp
-	gcc $(OPTIMIZE) $(INCLUDE) -o $@ -c -Wall -Wstrict-prototypes -D_LINUX_ -D_WITH_GRAPHISM_ $<
+	gcc $(OPTIMIZE) $(INCLUDE) -o $@ -c -Wall -Wstrict-prototypes $(DEFINES) $<
  
 %.o: $(SRCDIR)/linux/%.c
-	gcc $(OPTIMIZE) $(INCLUDE) -o $@ -c -Wall -Wstrict-prototypes -D_LINUX_ -D_WITH_GRAPHISM_ $<
+	gcc $(OPTIMIZE) $(INCLUDE) -o $@ -c -Wall -Wstrict-prototypes $(DEFINES) $<
  
 %.o: $(SRCDIR)/linux/%.cpp
-	gcc $(OPTIMIZE) $(INCLUDE) -o $@ -c -Wall -Wstrict-prototypes -D_LINUX_ -D_WITH_GRAPHISM_ $<
+	gcc $(OPTIMIZE) $(INCLUDE) -o $@ -c -Wall -Wstrict-prototypes $(DEFINES) $<
  
 %.o: $(DEVDIR)/cipher/%.c
-	gcc $(OPTIMIZE) $(INCLUDE) -o $@ -c -Wall -Wstrict-prototypes -D_LINUX_ -D_WITH_GRAPHISM_ $<
+	gcc $(OPTIMIZE) $(INCLUDE) -o $@ -c -Wall -Wstrict-prototypes $(DEFINES) $<
  
 %.o: $(DEVDIR)/cipher/%.cpp
-	gcc $(OPTIMIZE) $(INCLUDE) -o $@ -c -Wall -Wstrict-prototypes -D_LINUX_ -D_WITH_GRAPHISM_ $<
+	gcc $(OPTIMIZE) $(INCLUDE) -o $@ -c -Wall -Wstrict-prototypes $(DEFINES) $<
  
 %.o: $(DEVDIR)/share/%.c
-	gcc $(OPTIMIZE) $(INCLUDE) -o $@ -c -Wall -Wstrict-prototypes -D_LINUX_ -D_WITH_GRAPHISM_ $<
+	gcc $(OPTIMIZE) $(INCLUDE) -o $@ -c -Wall -Wstrict-prototypes $(DEFINES) $<
  
 %.o: $(DEVDIR)/share/%.cpp
-	gcc $(OPTIMIZE) $(INCLUDE) -o $@ -c -Wall -Wstrict-prototypes -D_LINUX_ -D_WITH_GRAPHISM_ $<
+	gcc $(OPTIMIZE) $(INCLUDE) -o $@ -c -Wall -Wstrict-prototypes $(DEFINES) $<
  
 #
 # Using BISON and FLEX
@@ -132,7 +135,7 @@ anbexec: $(main_objs) $(special_objs) $(cipher_objs) $(graph_objs) $(sqlite3_obj
 	gcc -o anbexec $(main_objs) $(special_objs) $(cipher_objs) $(graph_objs)\
           $(sqlite3_objs) -L/usr/X11R6/lib\
           -ljpeg -lssl -lcrypto -lm -lX11 -ldl -lstdc++ -lpthread -lc
-#	strip anbexec
+	strip anbexec
 	cp anbexec $(HOME)/anubis_distrib/linux_install/bin
 #	cp anbexec $(HOME)/bin/anbexec
  
-#include "AnubisAllocator.h"
+
 #include "stdlib.h"
 #include "assert.h"
+   
+   
+#include "AnubisAllocator.h"
+#include "vm.h"
 #include "DebugLog.h"
 #include "dependencies.h"
 #include "AnubisSupport.h"
-#include "vm.h"
  
  
  
@@ -101,8 +104,8 @@ AnubisAllocator::AnubisAllocator()
  
 #ifdef debug_vm   
   /* cannot test heap_test here (too early) */ 
-  ComputeMemoryCheckSums(result);
-  TestMemoryCheckSums(result); 
+  //ComputeMemoryCheckSums();
+  //TestMemoryCheckSums(); 
 #endif
  
   //printf("Basic allocator initialized.\n"); 
@@ -178,6 +181,7 @@ void AnubisAllocator::printf_check_segregated_list(int k)
   while (chain != NULL)
     {
       result++; 
+      assert(*(chain-1) == (U32)(k+1)); 
       chain = (U32 *)(chain[0]); 
     }
  
@@ -188,7 +192,7 @@ void AnubisAllocator::printf_check_segregated_list(int k)
 int AnubisAllocator::EnlargeMemory(void)
 {
   U32 *new_segment; 
-  int result = 1; 
+  int result = 1;      // becomes 0 if something cannot be enlarged
  
 #ifdef SEGREGATED_LISTS   
   int k,j; 
@@ -197,31 +201,75 @@ int AnubisAllocator::EnlargeMemory(void)
     {
       if (m_segregated_enlargement[k])
         {
+          // total size (in words) of each segregated segment:
+          //
+          //          |<-- useful size when allocated -->| k+1 words available when allocated
+          //   +------+------+------+------+------+------+
+          //   | size | next | word | word | ...  |      | there are k words after 'next'
+          //   +------+---|--+------+------+------+------+
+          //              V
+          //
+          U32 tot_segr_size = k+2;
+   
           //printf("Enlarging memory for segregated list for size %d\n",k+1); 
  
-          if ((new_segment = (U32 *)malloc((1+((2+k)*segregated_segments_per_main))<<2)) == NULL)
-            // 2+k = 1+(k+1), because we need 1 size word and k+1 available words per segment
+          // Organization of main segment:
+          // 
+          //       | <-- segregated segments ------>|  there are 'segregated_segments_per_main'
+          //   +---+----------+----------+----------+  segments
+          //   | * | segr seg | segr seg | ...      |
+          //   +-|-+----------+----------+----------+
+          //     V
+          //     next
+          //
+          if ((new_segment = 
+               (U32 *)malloc((1+(tot_segr_size*segregated_segments_per_main))*sizeof(U32))) 
+              == NULL)
             {
               result = 0;   // go on waiting for memory for this size ...
             }
           else
             {
-              // chain the new main segment 
-              new_segment[0] = (U32)(m_main_segregated_segment[k]);
-              m_main_segregated_segment[k] = new_segment; 
-   
-              // prepare and chain the segregated segments (for available word size k+1)
+              // Chain the new main segment.
+              //    The new main segment is appended in front of other main segments.
+              //
+              new_segment[0] = (U32)(m_main_segregated_segment[k]);  // chain with others
+              m_main_segregated_segment[k] = new_segment;            // new chain
+   
+              // prepare and chain the segregated segments
+              //
+              //   main segment      new chain of segregated segments
+              //             |       |
+              //             V       V
+              //             +---+---+---+..+---+---+..+---+---+...
+              //             | * |k+1| * |  |k+1| * |  |k+1| * |   
+              //             +-|-+---+-|-+..+---+-|-+..+---+-|-+...
+              //               V       |        ^ |        ^ |
+              //               next    `--------' `--------' `---...
+              //
+              // do for all except the last segregated segment
               for (j = 0; j < segregated_segments_per_main-1; j++)
                 {
-                  U32 segreg_seg_start = 1+(j*(2+k)); 
+                  U32 segreg_seg_start = 1+(j*tot_segr_size); 
                   new_segment[segreg_seg_start] = k+1;     // size word
-                  new_segment[segreg_seg_start+1] = (U32)(new_segment+segreg_seg_start+3+k); // chaining
-                  // because 3+k = 1 + (2+k)
+                  new_segment[segreg_seg_start+1] = 
+                      (U32)(new_segment+segreg_seg_start+tot_segr_size+1); // chaining
                 }
  
-              // chain with previous segregated segments (do for last segment)
-              new_segment[1+((segregated_segments_per_main-1)*(2+k))] = k+1; 
-              new_segment[1+((segregated_segments_per_main-1)*(2+k))+1] = 
+              // do for the last segregated segment
+              //
+              //               last segregated segment
+              //               |                    end of main segment
+              //               |                    |
+              //               V                    V
+              //             ..+---+---+------------+
+              //               |k+1| * |   k words  |
+              //             ..+---+-|-+------------+
+              //                     |
+              //                     `----> to previous chain of segregated segments
+              //
+              new_segment[1+((segregated_segments_per_main-1)*tot_segr_size)] = k+1; 
+              new_segment[1+((segregated_segments_per_main-1)*tot_segr_size)+1] = 
                 (U32)(m_segregated_free_list[k]); 
  
               // install the new chain of segregated segments
@@ -300,16 +348,19 @@ U32 AnubisAllocator::AllocateDataSegment(int words)
 //
 //  gettimeofday(&startTime, &dummy); 
  
-  if (words < 1) words = 1;  
-  words += security_zone_size;
+  if (words < 1) words = 1;      // required at least one word (for compatibility with the allocator)
+  words += security_zone_size;   // normally we add 0 (non zero values are for debugging purpose)
  
 #ifdef SEGREGATED_LISTS
   /* 'words' is the required size in 32 bits words. */ 
   if (words <= number_of_segregated_lists)
-    // <= is good because segregated sizes are: 1 2 3 ... number_of_segregated_lists (included)
-    return allocate_segregated_segment(words); 
+    // '<=' is good because segregated sizes are: 1 2 3 ... number_of_segregated_lists (included)
+    {   
+      return allocate_segregated_segment(words);
+    }
 #endif   
  
+  //printf("\nAllocating a basic segment for size %d.\n",(int)words);
  
   if (m_memory_seg_size < (U32)(words+64)) 
     {
@@ -401,7 +452,7 @@ U32 AnubisAllocator::AllocateDataSegment(int words)
  
 #ifdef debug_vm   
   if (heap_test) 
-    ComputeMemoryCheckSums(allocator);
+    ComputeMemoryCheckSums();
 #endif   
  
   m_memory_in_use += ptr[0]; 
@@ -629,22 +680,46 @@ U32 AnubisAllocator::ReallocateDataSegment(U32 data_seg, int words, char *filena
 U32 AnubisAllocator::ReallocateDataSegment(U32 data_seg, int words)
 #endif
 {
-  /* compare size of segment with requested size */ 
   U32 *seg;
  
-  /* the segment should not be shared */ 
-  // assert(*((U32 *)data_seg) == 1);
-
-  //assert(0); 
-
+  // only unshared segments may be reallocated
+  assert(((U32 *)data_seg)[0] == 1); 
+   
   seg = (U32 *)data_seg;
   seg--;      /* recover size word */ 
  
 #ifdef SEGREGATED_LISTS
+  // if the previous size is small we must reallocate a segregated segment
   if (seg[0] <= number_of_segregated_lists)
     return reallocate_segregated_segment(data_seg,words); 
+   
+   // if the new size is small, but not the previous size the basic segment must be copied
+   // into a segregated segment.
+  if (words <= number_of_segregated_lists)
+    {
+      U32 *new_seg = (U32 *)allocate_segregated_segment(words);
+      if (new_seg == 0)
+        {
+          return 0;   // retry later
+        }
+      else
+        {
+          int k; 
+          // copy data except the reference counter
+          // new reference counter already at 1
+          for (k = 1; k < words; k++)
+            {
+              new_seg[k] = ((U32 *)data_seg)[k]; 
+            }
+          // free the previous (basic) segment
+          FreeDataSegment((U32 *)data_seg); 
+   
+          // return new (segregated) segment
+          return (U32)new_seg; 
+        }
+    }
 #endif   
-    
+   
   words++;    /* need one more word for size */ 
  
  begin:
@@ -844,15 +919,57 @@ U32 AnubisAllocator::allocate_segregated_segment(int words)
     { /* return the head of list, and keep the tail as our new list of free segments. */ 
       m_segregated_free_list[i] = (U32 *)(chain[0]); 
       chain[0] = 1;    /* reference counter */ 
-   
-      //assert(*(chain-1) == (U32)words);
+
+#ifdef debug_vm   
+      // check if the allocated segment has the right size word
+      if (*(chain-1) != (U32)words)
+        {
+          int k; 
+          printf("allocate_segregated_segment: bad size word: %d instead of %d\n***",
+                 (int)(*(chain-1)),(int)words); 
+          for (k = -20; k <= 0; k++)
+            {
+              printf("%c",(((char *)chain)+k)[0]); 
+            }
+          printf("\n"); 
+          exit(1); 
+        }
       //printf("Returned segment at %d\n",(int)chain); 
+#endif   
  
       return (U32)chain;
     }
 }
  
  
+#ifdef debug_vm   
+// check if a liberated segregated segment is back home
+void AnubisAllocator::check_segment_home(U32 *ss)
+{
+  U32 size = *(ss-1); 
+  int i = size-1; 
+  U32 tot_segr_size = size+1; 
+  U32 main_seg_byte_size = (1+(tot_segr_size*segregated_segments_per_main))<<2;
+  U32 *main_seg = m_main_segregated_segment[i]; 
+   
+  while (main_seg != NULL)
+    { // if the segregated segment is within this main segment
+      if (main_seg < ss && ss < main_seg+main_seg_byte_size)
+        { 
+            return; // home found and alignement correct
+        }
+      main_seg = (U32 *)(main_seg[0]); 
+    }
+   
+  // home not found
+  printf("Home not found for segregated segment of size %d at %d\n",
+         (int)size,(int)ss);
+  exit(1);
+  return;
+}
+#endif   
+   
+   
 U32 *AnubisAllocator::free_segregated_segment(U32 *ss)
   // the size word (counting in U32s) is at ss[-1]
 {
@@ -862,9 +979,13 @@ U32 *AnubisAllocator::free_segregated_segment(U32 *ss)
   //printf("Freeing segregated segment for size %d at %d\n",(int)size,(int)ss); 
   //printf_check_segregated_list(i); 
  
+#ifdef debug_vm
+  check_segment_home(ss);   
+#endif   
+   
   ss[0] = (U32)(m_segregated_free_list[i]);
   m_segregated_free_list[i] = ss; 
-   
+      
   return NULL; 
 }
  
@@ -873,8 +994,9 @@ U32 AnubisAllocator::reallocate_segregated_segment(U32 data_segment, int words)
   // 'data_segment' and 'words' are the same as for ReallocateDataSegment
   // 'data_segment' is a segregated segment
 {
-  int previous_size = *(((U32 *)(data_segment))-1);
+  int previous_size = *(((U32 *)data_segment)-1);
   U32 *new_seg; 
+  U32 to_be_copied = previous_size < words ? previous_size : words;    
  
   if (words <= number_of_segregated_lists)
     { /* reallocation into a segregated list */ 
@@ -890,11 +1012,14 @@ U32 AnubisAllocator::reallocate_segregated_segment(U32 data_segment, int words)
       return 0;   // reallocation delayed
     }
   else
-    { /* copy the content */ 
+    { // copy the content (after the reference counter)
+      // the reference counter at new_seg[0] is already 1.
       int k; 
-      for (k = 1; k < previous_size; k++)
+      for (k = 1; k < (int)to_be_copied; k++)
         new_seg[k] = ((U32 *)data_segment)[k];
-      // the reference counter at new_seg[0] is already 1.
+#ifdef debug_vm   
+      printf("reallocate_segregated_segment: freeing previous segment.\n"); 
+#endif   
       free_segregated_segment((U32 *)data_segment); 
       return (U32)new_seg;
     }
@@ -1079,12 +1204,12 @@ void  AnubisAllocator::TestMemoryCheckSums(void)
   while (ptr != NULL)
     {
       count++; 
-      if (count > 10+(m_allocated_segments))
+      if (count > (int)(10+(m_allocated_segments)))
         {
           LOGINFO("\ntest_memory_check_sums: failed");
           LOGINFO("\nincompatible number of allocated segments"); 
           LOGINFO("\n(maybe a loop in free segments chain)"); 
-          LOGINFO("\nIP - code = %d\n",IPcode);
+          //LOGINFO("\nIP - code = %d\n",IPCode);
           fflush(stdout);
           dummy = ((char *)0)[0];
         }
@@ -1103,7 +1228,7 @@ void  AnubisAllocator::TestMemoryCheckSums(void)
       LOGINFO("\nm_ffss_size_sum = %20u computed: %20u",m_ffss_size_sum,size_sum);
       LOGINFO("\nm_ffss_ptr_sum  = %20u computed: %20u",m_ffss_ptr_sum,ptr_sum);
       ShowHeap(); 
-      LOGINFO("\nIP - code = %d\n",IPcode); 
+      //LOGINFO("\nIP - code = %d\n",IPCode); 
       fflush(stdout); 
       dummy = ((char *)0)[0];
     }
@@ -3,6 +3,7 @@
 #define __ANUBIS_ALLOCATOR_H__
  
 #include "AnubisSupport.h"
+//#include "vm.h"   
  
 BEGIN_NAMESPACE(CM);
  
@@ -11,7 +12,7 @@ BEGIN_NAMESPACE(CM);
 #define SEGREGATED_LISTS   
  
 #ifdef SEGREGATED_LISTS   
-#define number_of_segregated_lists            (30)
+#define number_of_segregated_lists            (20)
 #define segregated_segments_per_main          (100)
 #endif   
  
@@ -71,6 +72,7 @@ private:
   U32 *free_segregated_segment(U32 *ss); 
   U32 reallocate_segregated_segment(U32 data_segment, int words); 
   void printf_check_segregated_list(int k);
+  void check_segment_home(U32 *ss);
 #endif   
  
   // the basic allocator (non segregated)
@@ -139,6 +139,7 @@ extern int check_small_datum(U32 datum,          /* datum to be checked */
          { U32 aux;\
            U32 more = byte_size_to_word_size(n);\
            if (more < serial_size_increment) more = serial_size_increment;\
+           assert(((U32 *)(MAM(m_serial_buf)))[0] == 1);\
            if ((aux = MAM(m_allocator)->ReallocateDataSegment((U32)(MAM(m_serial_buf)),\
                                               ((MAM(m_serial_size))/4)+more )) == 0)\
               {\
@@ -455,20 +456,28 @@ si_decl(type_large_switch)
 /* Format:              revert_to_computing (U8)type_width
    Size:                1
  
-  This instruction instructs the machine to revert to 'computing' work sort.
-         Since we are here serializing, we must reduce the serialization buffer
-         to the size needed and transform it into a datum of type 'ByteArray'
-         to be put in MAM(m_R). 
+   This instruction  instructs the machine to  revert to 'computing' work  sort.  Since we
+   are here  serializing, we must reduce the  serialization buffer to the  size needed and
+   transform it into a datum of type 'ByteArray' to be put in MAM(m_R).
  
-         type width is not used here. 
-       */ 
+   type width is not used here. 
+*/ 
 si_decl(revert_to_computing)
 {
-
+  assert(((U32 *)(MAM(m_serial_buf)))[0] == 1); // must be unshared
+   
   MAM(m_R) = MAM(m_allocator)->ReallocateDataSegment((U32)(MAM(m_serial_buf)), 
                                            byte_size_to_word_size(MAM(m_serial_next)));
  
-  assert(MAM(m_R) != 0); /* must have succeeded */ 
+  //assert(MAM(m_R) != 0); /* must have succeeded */ 
+  if (MAM(m_R) == 0)
+    // since segregated  lists reallocation  with smaller new  segment may fail  because a
+    // segregated list may be empty.
+    {
+      MAM(m_status) = need_more_memory; 
+      { MAM(m_steps) = 0; return; }
+    }
+   
   *(((U32 *)MAM(m_R))+1) = (MAM(m_serial_next))
     -(4+4);   /* count,num_bytes,bytes ... */ 
   MAM(m_work_sort) = computing;
@@ -1005,8 +1014,7 @@ ui_decl(type_String)
           /* put the string in MAM(m_R) */ 
           MAM(m_R) = str; 
 #ifdef debug_vm   
-          if (debugging) 
-            LOGINFO("\n   string unserialized into MAM(m_R): \"%s\"",strptr); 
+          //if (debugging) LOGINFO("\n   string unserialized into MAM(m_R): \"%s\"",strptr); 
 #endif   
         }
     }
@@ -1214,8 +1222,7 @@ ui_decl(pop1)
     assert(*(MAM(m_SP)-2)); 
     *((U32 *)(*(MAM(m_SP)-1))) = 0; 
 #ifdef debug_vm   
-                  if (debugging) 
-                    LOGINFO("\n   0 put at %d",*(MAM(m_SP)-1));
+    //if (debugging) LOGINFO("\n   0 put at %d",*(MAM(m_SP)-1));
 #endif
     *(MAM(m_SP)-1) += 4; 
   }
@@ -1224,7 +1231,7 @@ ui_decl(pop1)
      {
        *((U32 *)(*(MAM(m_SP)-1))) = MAM(m_R); 
 #ifdef debug_vm   
-              if (debugging) LOGINFO("\n   %d put at %d",MAM(m_R),*(MAM(m_SP)-1)); 
+       //if (debugging) LOGINFO("\n   %d put at %d",MAM(m_R),*(MAM(m_SP)-1)); 
 #endif   
        *(MAM(m_SP)-1) += 4; 
      }
@@ -1648,8 +1655,7 @@ ui_decl(indirect_type_String)
           *((U32 *)(*(MAM(m_SP)-1))) = str; 
           *(MAM(m_SP)-1) += 4;    /* increment the pointer */ 
 #ifdef debug_vm   
-          if (debugging) 
-            LOGINFO("\n   string unserialized at %d: \"%s\"",(*(MAM(m_SP)-1))-4,strptr); 
+          //if (debugging) LOGINFO("\n   string unserialized at %d: \"%s\"",(*(MAM(m_SP)-1))-4,strptr); 
 #endif   
         }
     }
@@ -153,7 +153,7 @@ ci_decl(syscall)
         LOGERROR("syscall %s (MAM(m_IP) = %d)\n",syscall_names[get16(1)],MAM(m_IP)-MAM(m_code_begin)); 
       }
 #endif   
-   
+   trace
  
 //************************************** BEGIN OF SYSCALL ********************************************
 // before this part was in separate file named syscall.c
@@ -1769,13 +1769,30 @@ ci_decl(syscall)
  
           /* The instruction returns 'unique' of type 'One' in all cases. */ 
           MAM(m_R) = 0; 
+
+          // if the byte array is shared, reallocation  is not possible and we must make a
+          // copy.
+          if (((U32 *)ba)[0] == 1)
+            { // the byte array is not shared
+              if (new_size >= 0 && new_size <= (int)old_size) 
+                {
+                  U32 new_seg = 
+                     MAM(m_allocator)->ReallocateDataSegment(ba, byte_size_to_word_size(new_size+8)); 
+                  assert(new_seg = ba);   /* truncation should not change the segment */ 
+                  ((U32 *)ba)[1] = new_size; 
+                }
+            }
+          else
+            { // the byte  aray is  shared. 
  
-          if (new_size >= 0 && new_size <= (int)old_size) 
-            {
-              U32 new_seg = MAM(m_allocator)->ReallocateDataSegment(ba, byte_size_to_word_size(new_size+8)); 
-              assert(new_seg = ba);   /* truncation should not change the segment */ 
-              ((U32 *)ba)[1] = new_size; 
+              // Actually we  can do nothing  because this primitive  returns (One)unique,
+              // hence needs to  make a side effect.  In this case, the byte  array is not
+              // truncated.
+   
+              // To  do:  define 'truncate_byte_array'  in  predefined.anubis  so that  it
+              // returns the new byte array.
             }
+   
           MAM(m_IP) += 1+2; 
           return; 
         }
@@ -6035,6 +6052,10 @@ ci_decl(syscall)
             {
               /* enlarge the table */ 
               U32 *new_table; 
+   
+              assert(table[0] == 1); // the table must be unshared
+                                      // only unshared segments may be reallocated
+   
               if ((new_table = (U32 *)MAM(m_allocator)->ReallocateDataSegment((U32)table,
                                                               table_size+default_number_of_monitors)) == 0)
                 {
@@ -2459,6 +2459,8 @@ ci_decl(_register)
   if (i == table_size)
     {
       /* enlarge the table */ 
+      assert(table[0] == 1);   // only non shared segments may be reallocated
+   
       U32 *new_table; 
       if ((new_table = 
            (U32 *)MAM(m_allocator)->ReallocateDataSegment((U32)table, 
@@ -3151,20 +3153,21 @@ ci_decl(del_stack_ptr)
 {
    trace
   U32 i = get32(1);                              /* depth in stack */ 
-  U32 aux = (*(MAM(m_SP)-i-1));                         /* get the pointer */ 
-  while (i)                                  /* collapse the stack */ 
+  U32 aux = (*(MAM(m_SP)-i-1));                  /* get the pointer */ 
+  while (i)                                      /* collapse the stack */ 
     {
       *(MAM(m_SP)-i-1) = *(MAM(m_SP)-i); 
       i--; 
     }
   MAM(m_SP)--;
  
-  //printf("del_stack_ptr (%d) [%p]\n",*(((U32 *)aux)-1),((U32 *)aux)); 
-  //printf("aux = %d\n",aux); 
-  //fflush(stdout); 
+  //printf("del_stack_ptr (%d) [%p]\n",(int)(*(((U32 *)aux)-1)),((U32 *)aux)); 
+  //printf("aux = %d\n",(int)aux); 
+  //printf("*aux = %d\n",(int)(*((U32 *)aux))); 
+  fflush(stdout); 
  
   if (aux &&                                  /* beware of null pointer */ 
-      *((U32 *)aux) &&                        /* don't do for permanent data */ 
+      (*((U32 *)aux)) &&                      /* don't do for permanent data */ 
       !(--(*((U32 *)aux))))                   /* delete virtually */ 
     {
       //printf("freeing.\n"); fflush(stdout); 
@@ -92,6 +92,7 @@ extern int counting_instructions;
 extern int show_syscalls;    
  
 extern char *instr_names[]; 
+extern char *instr_name(int i, int n);    
  
 extern U32 max_memory; 
 extern U32 current_memory;    
@@ -957,6 +957,7 @@ U32 anubis_cons(U32 h, U32 t, int index, AnubisAllocator *allocator)
   return result|index;   /* glue mixed index */ 
 }
  
+   
 /* making a virtual machine triple */ 
 U32 anubis_mcons3(U32 h, U32 t, U32 u, int index, AnubisAllocator *allocator)
 {