资源

http://blog.youkuaiyun.com/li_guotao/archive/2008/08/20/2802241.aspx

仅通过崩溃地址找出源代码的出错行

 

http://blog.youkuaiyun.com/haxixi_keli/archive/2008/11/05/3224731.aspx

lua源码分析3（lua是怎么执行的）

http://blog.youkuaiyun.com/ZOLoveGD/archive/2007/10/15/1824826.aspx

ARM学习笔记(三)

 

/****************************************************************
Copyright   1990,   1994,   2000   by   AT&T,   Lucent   Technologies   and   Bellcore.

Permission   to   use,   copy,   modify,   and   distribute   this   software
and   its   documentation   for   any   purpose   and   without   fee   is   hereby
granted,   provided   that   the   above   copyright   notice   appear   in   all
copies   and   that   both   that   the   copyright   notice   and   this
permission   notice   and   warranty   disclaimer   appear   in   supporting
documentation,   and   that   the   names   of   AT&T,   Bell   Laboratories,
Lucent   or   Bellcore   or   any   of   their   entities   not   be   used   in
advertising   or   publicity   pertaining   to   distribution   of   the
software   without   specific,   written   prior   permission.

AT&T,   Lucent   and   Bellcore   disclaim   all   warranties   with   regard   to
this   software,   including   all   implied   warranties   of
merchantability   and   fitness.     In   no   event   shall   AT&T,   Lucent   or
Bellcore   be   liable   for   any   special,   indirect   or   consequential
damages   or   any   damages   whatsoever   resulting   from   loss   of   use,
data   or   profits,   whether   in   an   action   of   contract,   negligence   or
other   tortious   action,   arising   out   of   or   in   connection   with   the
use   or   performance   of   this   software.
****************************************************************/

#ifndef   CRAY
#define   STACKMIN   512
#define   MINBLK   (2*sizeof(struct   mem)   +   16)
#define   F   _malloc_free_
#define   SBGULP   8192
#include   "string.h " /*   for   memcpy   */

#ifdef   KR_headers
#define   Char   char
#define   Unsigned   unsigned
#define   Int   /*int*/
#else
#define   Char   void
#define   Unsigned   size_t
#define   Int   int
#endif

typedef   struct   mem   {
struct   mem   *next;
Unsigned   len;
}   mem;

mem   *F;

  Char   *
#ifdef   KR_headers
malloc(size)
register   Unsigned   size;
#else
malloc(register   Unsigned   size)
#endif
{
register   mem   *p,   *q,   *r,   *s;
unsigned   register   k,   m;
extern   Char   *sbrk(Int);
char   *top,   *top1;

size   =   (size+7)   &   ~7;
r   =   (mem   *)   &F;
for   (p   =   F,   q   =   0;   p;   r   =   p,   p   =   p-> next)   {
if   ((k   =   p-> len)   > =   size   &&   (!q   ||   m   >   k))   {
m   =   k;
q   =   p;
s   =   r;
}
}
if   (q)   {
if   (q-> len   -   size   > =   MINBLK)   {   /*   split   block   */
p   =   (mem   *)   (((char   *)   (q+1))   +   size);
p-> next   =   q-> next;
p-> len   =   q-> len   -   size   -   sizeof(mem);
s-> next   =   p;
q-> len   =   size;
}
else
s-> next   =   q-> next;
}
else   {
top   =   (Char   *)(((long)sbrk(0)   +   7)   &   ~7);
if   (F   &&   (char   *)(F+1)   +   F-> len   ==   top)   {
q   =   F;
F   =   F-> next;
}
else
q   =   (mem   *)   top;
top1   =   (char   *)(q+1)   +   size;
if   (sbrk((int)(top1-top+SBGULP))   ==   (Char   *)   -1)
return   0;
r   =   (mem   *)top1;
r-> len   =   SBGULP   -   sizeof(mem);
r-> next   =   F;
F   =   r;
q-> len   =   size;
}
return   (Char   *)   (q+1);
}

  void
#ifdef   KR_headers
free(f)
Char   *f;
#else
free(Char   *f)
#endif
{
mem   *p,   *q,   *r;
char   *pn,   *qn;

if   (!f)   return;
q   =   (mem   *)   ((char   *)f   -   sizeof(mem));
qn   =   (char   *)f   +   q-> len;
for   (p   =   F,   r   =   (mem   *)   &F;   ;   r   =   p,   p   =   p-> next)   {
if   (qn   ==   (Char   *)   p)   {
q-> len   +=   p-> len   +   sizeof(mem);
p   =   p-> next;
}
pn   =   p   ?   ((char   *)   (p+1))   +   p-> len   :   0;
if   (pn   ==   (Char   *)   q)   {
p-> len   +=   sizeof(mem)   +   q-> len;
q-> len   =   0;
q-> next   =   p;
r-> next   =   p;
break;
}
if   (pn   <   (char   *)   q)   {
r-> next   =   q;
q-> next   =   p;
break;
}
}
}

  Char   *
#ifdef   KR_headers
realloc(f,   size)
Char   *f;
Unsigned   size;
#else
realloc(Char   *f,   Unsigned   size)
#endif
{
mem   *p;
Char   *q,   *f1;
Unsigned   s1;

if   (!f)   return   malloc(size);
p   =   (mem   *)   ((char   *)f   -   sizeof(mem));
s1   =   p-> len;
free(f);
if   (s1   >   size)
s1   =   size   +   7   &   ~7;
if   (!p-> len)   {
f1   =   (Char   *)(p-> next   +   1);
memcpy(f1,   f,   s1);
f   =   f1;
}
q   =   malloc(size);
if   (q   &&   q   !=   f)
memcpy(q,   f,   s1);
return   q;
}

/*   The   following   (calloc)   should   really   be   in   a   separate   file,   */
/*   but   defining   it   here   sometimes   avoids   confusion   on   systems   */
/*   that   do   not   provide   calloc   in   its   own   file.   */

  Char   *
#ifdef   KR_headers
calloc(n,   m)   Unsigned   m,   n;
#else
calloc(Unsigned   n,   Unsigned   m)
#endif
{
Char   *rv;
rv   =   malloc(n   *=   m);
if   (n   &&   rv)
memset(rv,   0,   n);
return   rv;
}
#endif

谢谢，再问一句，以上类似源码那里可以下载，可能还会需要其它一些函数的源码：）

去找个LXR或者FXR就可以找到，LXR是Linux的，FXR是FreeBSD的，我看了一下FreeBSD的/usr/src/lib/libc /stdlib/malloc.c，里面有1k多行，我就不贴了，给你一个地址自己去看好了（这个是给kernel用的，凑乎着看吧，user   space的source在cvs.freebsd.org有）
http://fxr.watson.org/fxr/source//kern/kern_malloc.c