/**
 * $Id$
 *
 * Watchpoint support (for debugging)
 *
 * Copyright (c) 2005 Nathan Keynes.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 */

#include <stdlib.h>
#include <string.h>
#include "mem.h"

struct watch_point {
    uint32_t start;
    uint32_t end;
    int flags;
};

struct watch_point *watch_arr = NULL;
int watch_count = 0, watch_capacity = 0;


watch_point_t mem_new_watch( uint32_t start, uint32_t end, int flags )
{
    int num;
    if( watch_arr == NULL ) {
        watch_capacity = 10;
        watch_arr = calloc( sizeof(struct watch_point), watch_capacity );
        num = 0;
    } else if( watch_count == watch_capacity ) {
        struct watch_point *tmp = realloc( watch_arr, sizeof(struct watch_point) * watch_capacity * 2 );
        if( tmp == NULL )
            return NULL;
        watch_arr = tmp;
        memset( &watch_arr[watch_capacity], 0, sizeof( struct watch_point ) * watch_capacity );
        num = watch_capacity;
        watch_capacity *= 2;
    } else {
        for( num=0; num<watch_capacity; num++ ) {
            if( watch_arr[num].flags == 0 )
                break;
        }
    }
    watch_arr[num].start = start & 0x1FFFFFFF;
    watch_arr[num].end = end & 0x1FFFFFFF;
    watch_arr[num].flags = flags;
    watch_count++;
    return &watch_arr[num];
}

void mem_delete_watch( watch_point_t watch )
{
    if( watch_arr == NULL )
        return;
    int num = watch - watch_arr;
    if( num < 0 || num >= watch_capacity )
        return;
    watch->start = watch->end = 0;
    watch->flags = 0;
    watch_count--;
}


watch_point_t mem_is_watched( uint32_t addr, int size, int op )
{
    int i, count;
    addr &= 0x1FFFFFFF;
    for( i=0, count=0; count< watch_count; i++ ) {
        if( watch_arr[i].flags == 0 )
            continue;
        count++;
        if( watch_arr[i].flags & op &&
                watch_arr[i].start < addr+size &&
                watch_arr[i].end >= addr ) {
            return &watch_arr[i];
        }
    }
    return NULL;
}