/[emacs]/emacs/src/alloc.c
ViewVC logotype

Diff of /emacs/src/alloc.c

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 1.357 by rms, Tue Dec 21 11:30:31 2004 UTC revision 1.358 by jhd, Sat Dec 25 10:13:57 2004 UTC
# Line 601  static char xmalloc_overrun_check_traile Line 601  static char xmalloc_overrun_check_traile
601             ((unsigned)(ptr[-4]) << 24))             ((unsigned)(ptr[-4]) << 24))
602    
603    
604    /* The call depth in overrun_check  functions.  Realloc may call both malloc
605       and free.  If realloc calls malloc, this may happen:
606       overrun_check_realloc()
607          -> malloc -> (via hook)_-> emacs_blocked_malloc
608             -> overrun_check_malloc
609                call malloc  (hooks are NULL, so real malloc is called).
610                malloc returns 10000.
611                add overhead, return 10016.
612          <- (back in overrun_check_realloc)
613          add overhead again, return 10032
614    
615       (time passes).
616    
617       overrun_check_free(10032)
618         decrease overhed
619         free(10016)  <-  crash, because 10000 is the original pointer.  */
620    
621    static int check_depth;
622    
623  /* Like malloc, but wraps allocated block with header and trailer.  */  /* Like malloc, but wraps allocated block with header and trailer.  */
624    
625  POINTER_TYPE *  POINTER_TYPE *
# Line 608  overrun_check_malloc (size) Line 627  overrun_check_malloc (size)
627       size_t size;       size_t size;
628  {  {
629    register unsigned char *val;    register unsigned char *val;
630      size_t overhead = ++check_depth == 1 ? XMALLOC_OVERRUN_CHECK_SIZE*2 : 0;
631    
632    val = (unsigned char *) malloc (size + XMALLOC_OVERRUN_CHECK_SIZE*2);    val = (unsigned char *) malloc (size + overhead);
633    if (val)    if (val && check_depth == 1)
634      {      {
635        bcopy (xmalloc_overrun_check_header, val, XMALLOC_OVERRUN_CHECK_SIZE - 4);        bcopy (xmalloc_overrun_check_header, val, XMALLOC_OVERRUN_CHECK_SIZE - 4);
636        val += XMALLOC_OVERRUN_CHECK_SIZE;        val += XMALLOC_OVERRUN_CHECK_SIZE;
637        XMALLOC_PUT_SIZE(val, size);        XMALLOC_PUT_SIZE(val, size);
638        bcopy (xmalloc_overrun_check_trailer, val + size, XMALLOC_OVERRUN_CHECK_SIZE);        bcopy (xmalloc_overrun_check_trailer, val + size, XMALLOC_OVERRUN_CHECK_SIZE);
639      }      }
640      --check_depth;
641    return (POINTER_TYPE *)val;    return (POINTER_TYPE *)val;
642  }  }
643    
# Line 630  overrun_check_realloc (block, size) Line 651  overrun_check_realloc (block, size)
651       size_t size;       size_t size;
652  {  {
653    register unsigned char *val = (unsigned char *)block;    register unsigned char *val = (unsigned char *)block;
654      size_t overhead = ++check_depth == 1 ? XMALLOC_OVERRUN_CHECK_SIZE*2 : 0;
655    
656    if (val    if (val
657          && check_depth == 1
658        && bcmp (xmalloc_overrun_check_header,        && bcmp (xmalloc_overrun_check_header,
659                 val - XMALLOC_OVERRUN_CHECK_SIZE,                 val - XMALLOC_OVERRUN_CHECK_SIZE,
660                 XMALLOC_OVERRUN_CHECK_SIZE - 4) == 0)                 XMALLOC_OVERRUN_CHECK_SIZE - 4) == 0)
# Line 646  overrun_check_realloc (block, size) Line 669  overrun_check_realloc (block, size)
669        bzero (val, XMALLOC_OVERRUN_CHECK_SIZE);        bzero (val, XMALLOC_OVERRUN_CHECK_SIZE);
670      }      }
671    
672    val = (unsigned char *) realloc ((POINTER_TYPE *)val, size + XMALLOC_OVERRUN_CHECK_SIZE*2);    val = (unsigned char *) realloc ((POINTER_TYPE *)val, size + overhead);
673    
674    if (val)    if (val && check_depth == 1)
675      {      {
676        bcopy (xmalloc_overrun_check_header, val, XMALLOC_OVERRUN_CHECK_SIZE - 4);        bcopy (xmalloc_overrun_check_header, val, XMALLOC_OVERRUN_CHECK_SIZE - 4);
677        val += XMALLOC_OVERRUN_CHECK_SIZE;        val += XMALLOC_OVERRUN_CHECK_SIZE;
678        XMALLOC_PUT_SIZE(val, size);        XMALLOC_PUT_SIZE(val, size);
679        bcopy (xmalloc_overrun_check_trailer, val + size, XMALLOC_OVERRUN_CHECK_SIZE);        bcopy (xmalloc_overrun_check_trailer, val + size, XMALLOC_OVERRUN_CHECK_SIZE);
680      }      }
681      --check_depth;
682    return (POINTER_TYPE *)val;    return (POINTER_TYPE *)val;
683  }  }
684    
# Line 666  overrun_check_free (block) Line 690  overrun_check_free (block)
690  {  {
691    unsigned char *val = (unsigned char *)block;    unsigned char *val = (unsigned char *)block;
692    
693      ++check_depth;
694    if (val    if (val
695          && check_depth == 1
696        && bcmp (xmalloc_overrun_check_header,        && bcmp (xmalloc_overrun_check_header,
697                 val - XMALLOC_OVERRUN_CHECK_SIZE,                 val - XMALLOC_OVERRUN_CHECK_SIZE,
698                 XMALLOC_OVERRUN_CHECK_SIZE - 4) == 0)                 XMALLOC_OVERRUN_CHECK_SIZE - 4) == 0)
# Line 682  overrun_check_free (block) Line 708  overrun_check_free (block)
708      }      }
709    
710    free (val);    free (val);
711      --check_depth;
712  }  }
713    
714  #undef malloc  #undef malloc

Legend:
Removed from v.1.357  
changed lines
  Added in v.1.358

savannah-hackers-public@gnu.org
ViewVC Help
Powered by ViewVC 1.1.26