		TODO file for Checker V0.1

From Tristan C/O marc@david.sacly.cea.fr:

* check on stack

* libraries compiled with Checker.

* system-calls functions must include a check
  i.e.:    write(fd,buffer,len)
           must check that buffer is readable.
  there are 2 functions provided for that:
	chkr_check_addr(__ptr_t ptr, int len, int right)
	chkr_check_str(__ptr_t ptr, int right)

* parameter to checker, by env: CHECKEROPTIONS
  -> output file, size of red zone, automatic garbage collector at the end, at
     interval, size of bitmap element.

* initialisation of Checker before running the program

************ All previous line will be made in next release ****************

* using libc.chkr_a instead of libc_chkr.a, and add -checker option to ld,
  so that all library could be better supported

* codecheck.S doesn't recognize all instruction, and thinks cld when repxx

* handle syscall in codecheck.S instead of standard lib.

* do_checker in gas do not handle correctly addr16 prefix (gas too)

* chkr_check_right written in asm, in order to be really faster

* catch SIGSEGV, SIGILL ...

* ?? code insertion at link level. Can be very difficult to do ??

* writing a better doc, README, TODO, HowDoesItWork... and a texinfo doc 

* Porting to other systems. If you have problem, email me...

* Be sure we don't break the patents from Purify(tm). Note: I don't have
  Purify(tm), I never use it, and I never see it. I have just an ad.

* in chkr_access_error_heap, if ptr is inside a free block/fragment, show
   the stack frame of this free fragment, if possible.

************* Here is the TODO from GNU malloc package *******************
*** As you can see, we can freeze it .. **********************************

0.  Access data structures with accessor macros, then turn the heapinfo
into several arrays for faster access on machines with addressing modes.
Also, this eventually raises the possibility of maintaining multiple
heaps.
1.  Possible heuristic to catch multiple frees.  Introduce an extra word
of heapinfo that says whether the remaining info is for something
busy or something free.  Then we can catch attempts to free already-free
large blocks, as well as things not belonging to malloc at all.  In the
case of a fragment, we can check if the fragment looks like it *already*
belongs to the fragment list, by comparing it with the "first" fragment
of the block, or checking its "prev" pointer to see if it points into
the block.  Then if it looks like it might we can exhaustively search
the block's free list to see if the fragment is there or not.  Extending
the heapinfo structure would have the benefit of making it a power of
two and thus making array indexing faster, perhaps.  Suitably adapted,
this heuristic could also catch invalid pointers passed to realloc.

All of these additional features require the inclusion of <malloc.h>.
3.  indirect reference allocator: ialloc(), ifree(), irealloc().
4.  garbage collecting allocator: galloc(), garbage(), gfree(), grealloc().
