Function check

examples/bounds.c:146–222

* Memory error check routine: * - loc = static instruction address. * - base = memory operand base pointer. * - access = actual address that is accessed. * - sz = the size of the memory access. * - _asm = the ASM string of the instruction. */

 *  - _asm   = the ASM string of the instruction.
 */ 
void check(const void *loc, const void *base, const void *access, size_t sz,
    const char *_asm)
{
    /*
     * Step (1): Find the base of the allocation, which has the following
     *           layout (as guaranteed by libredfat.so):
     *
     *           +----+--------------+
     *           | Sz |    Object    |
     *           +----+--------------+
     *           Allocation
     *
     *           The allocation base stores the object size metadata (Sz)
     *           which is prepended to the start of the object.  The meta
     *           region also serves as an inaccessible redzone between
     *           objects.
     */
    const size_t *meta = (size_t *)redfat_base(base, access);
    if (meta == NULL)
        return;         // Not a RedFat pointer

    /*
     * Step (2): Do the bounds check.  Note that "free" objects will have a
     *           size==0, so will always fail the bounds check.
     */
    size_t size = *meta;
    const uint8_t *lb = (uint8_t *)meta + REDZONE;
    const uint8_t *ub = lb + size;
    const uint8_t *access8 = (uint8_t *)access;
    if (access8 >= lb && access8 + sz <= ub && size < redfat_size(access))
        return;         // Valid memory access

    /*
     * Step (3): A memory error has been detected.  Gather useful information
     *           and print the error to stderr, then abort.
     */
    const uint8_t *access_base = (uint8_t *)redfat_base(access, access);
    size_t access_size         = *(size_t *)access_base;
    bool access_free           = (access_size == 0x0);
    access_size                = (access_free? redfat_size(access): access_size);
    const uint8_t *access_lb   = access_base + REDZONE;
    const uint8_t *access_ub   = access_lb + access_size;

    const uint8_t *base_base   = (uint8_t *)redfat_base(base, access);
    size_t base_size           = *(size_t *)base_base;
    bool base_free             = (base_size == 0x0);
    base_size                  = (base_free? redfat_size(base): base_size);
    const uint8_t *base_lb     = base_base + REDZONE;
    const uint8_t *base_ub     = base_lb + base_size;

    const char *kind = "out-of-bounds";
    if (access_free && base_free)
        kind = "use-after-free";
    else if (size > redfat_size(access))
        kind = "size-metadata-corruption";

    const uint8_t *base8 = (uint8_t *)base;
    fprintf(stderr, "%sMEMORY ERROR%s: %s error detected!\n"