/*
* Copyright (c) 2008 Jiri Svoboda
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* - Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* - Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* - The name of the author may not be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
/** @addtogroup debug
* @{
*/
/** @file
*/
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <sys/types.h>
#include <errno.h>
#include <udebug.h>
#include "../../cons.h"
#include "../../main.h"
#include "../../breakpoint.h"
#include "../../include/arch.h"
#include "../../include/arch/arch.h"
#include "idec.h"
static istate_t istate;
int idec_breakpoint_set(breakpoint_t *b)
{
bstore_initialize(&b->arch.bs);
bstore_initialize(&b->arch.next_bs[0]);
bstore_initialize(&b->arch.next_bs[1]);
return bstore_push(&b->arch.bs, b->addr, OPCODE_BREAK);
}
int idec_breakpoint_remove(breakpoint_t *b)
{
return bstore_pop(&b->arch.bs);
}
static void _ev_breakpoint(thash_t thread_hash)
{
breakpoint_t *b;
dthread_t *dt;
int rc, n_next, i;
uint32_t epc;
uintptr_t brk_addr;
uintptr_t next_addr[2];
uint32_t brkp;
brkp = OPCODE_BREAK;
cons_printf("arch_event_breakpoint\n");
rc = udebug_regs_read(app_phone, thread_hash, &istate);
cons_printf("udebug_regs_read -> %d\n", rc);
epc = istate_get_pc(&istate);
cons_printf("EPC was 0x%08x\n", epc);
brk_addr = epc;
dt = dthread_get();
if (active_bkpt != NULL) {
assert(active_bkpt
->arch.
bs.
address == brk_addr
); b = active_bkpt;
/* A breakpoint-restoring BRK has been hit */
cons_printf("restoring breakpoint %d\n", b->id);
for (i = 0; i < b->arch.n_next; ++i) {
rc = bstore_pop(&b->arch.next_bs[i]);
if (rc != 0) return;
}
rc = bstore_push(&b->arch.bs, b->addr, OPCODE_BREAK);
if (rc != 0) return;
active_bkpt = NULL;
return;
}
b = breakpoint_find_by_addr(brk_addr);
if (b == NULL) {
cons_printf("Unrecognized breakpoint at 0x%lx\n", brk_addr);
}
/* A breakpoint has been hit */
cons_printf("breakpoint_hit...\n");
breakpoint_hit(b);
/* While in breakpoint_hit(), singlestep was activated */
if (dt->arch.singlestep) return;
cons_printf("move breakpoint\b");
rc = bstore_pop(&b->arch.bs);
if (rc != 0) return;
n_next = get_next_addr(dt, brk_addr, next_addr);
if (n_next < 0) return;
/*
* There could be another breakpoint at next_addr,
* but that's okay. We'll pop the active breakpoint bs
* before doing anything else.
*/
for (i = 0; i < n_next; ++i) {
rc = bstore_push(&b->arch.next_bs[i], next_addr[i],
OPCODE_BREAK);
if (rc != 0) return;
}
b->arch.n_next = n_next;
active_bkpt = b;
b->active = true;
cons_printf("end_hit...\n");
}
static void _ev_singlestep(thash_t thread_hash)
{
dthread_t *dt;
int rc, i;
uint32_t epc;
int brk_addr;
uint32_t brkp;
dt = dthread_get();
brkp = OPCODE_BREAK;
cons_printf("arch_event_breakpoint\n");
rc = udebug_regs_read(app_phone, thread_hash, &istate);
cons_printf("udebug_regs_read -> %d\n", rc);
epc = istate_get_pc(&istate);
cons_printf("EPC was 0x%08x\n", epc);
brk_addr = epc;
if (dt->arch.cur.valid) {
cons_printf("restore breakpoint BREAK\n");
rc = bstore_pop(&dt->arch.cur);
}
cons_printf("\nclear singlestep BREAKs\n");
for (i = 0; i < dt->arch.n_next; ++i) {
rc = bstore_pop(&dt->arch.next[i]);
if (rc != 0) return;
}
dt->arch.singlestep = false;
singlestep_hit();
}
void idec_event_breakpoint(thash_t thread_hash)
{
dthread_t *dt;
dt = dthread_get();
if (dt->arch.singlestep) {
_ev_singlestep(thread_hash);
} else {
_ev_breakpoint(thread_hash);
}
}
void idec_singlestep(dthread_t *dt)
{
int rc, i;
uint32_t epc;
breakpoint_t *b;
uint32_t old_instr;
uintptr_t next_addr[2];
int n_next;
assert(dt
->arch.
singlestep == false);
cons_printf("idec_singlestep(dt)\n");
rc = udebug_regs_read(app_phone, dt->hash, &istate);
cons_printf("udebug_regs_read -> %d\n", rc);
epc = istate_get_pc(&istate);
cons_printf("EPC was 0x%08x\n", epc);
cons_printf("initial set singlestep\n");
b = breakpoint_find_by_addr(epc);
if (b != NULL) {
/* Cover breakpoint with old instruction */
old_instr = b->arch.bs.value;
rc = bstore_push(&dt->arch.cur, epc, old_instr);
if (rc < 0) return;
}
n_next = get_next_addr(dt, epc, next_addr);
if (n_next < 0) return;
/* Cover next instruction(s) with BREAK */
for (i = 0; i < n_next; ++i) {
rc = bstore_push(&dt->arch.next[i], next_addr[i], OPCODE_BREAK);
if (rc != 0) return;
}
dt->arch.n_next = n_next;
dt->arch.singlestep = true;
dthread_resume(dt);
}
/** @}
*/