231 lines
6.1 KiB
C
231 lines
6.1 KiB
C
/*
|
|
* This file is part of ltrace.
|
|
* Copyright (C) 2008,2009 Juan Cespedes
|
|
* Copyright (C) 2005,2006 Ian Wienand
|
|
*
|
|
* 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.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program; if not, write to the Free Software
|
|
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
|
|
* 02110-1301 USA
|
|
*/
|
|
|
|
/* IA64 breakpoint support. Much of this clagged from gdb
|
|
* -Ian Wienand <ianw@gelato.unsw.edu.au> 10/3/2005
|
|
*/
|
|
|
|
#include <sys/ptrace.h>
|
|
#include <string.h>
|
|
#include <assert.h>
|
|
|
|
#include "breakpoint.h"
|
|
#include "debug.h"
|
|
|
|
static long long
|
|
extract_bit_field(char *bundle, int from, int len) {
|
|
long long result = 0LL;
|
|
int to = from + len;
|
|
int from_byte = from / 8;
|
|
int to_byte = to / 8;
|
|
unsigned char *b = (unsigned char *)bundle;
|
|
unsigned char c;
|
|
int lshift;
|
|
int i;
|
|
|
|
c = b[from_byte];
|
|
if (from_byte == to_byte)
|
|
c = ((unsigned char)(c << (8 - to % 8))) >> (8 - to % 8);
|
|
result = c >> (from % 8);
|
|
lshift = 8 - (from % 8);
|
|
|
|
for (i = from_byte + 1; i < to_byte; i++) {
|
|
result |= ((long long)b[i]) << lshift;
|
|
lshift += 8;
|
|
}
|
|
|
|
if (from_byte < to_byte && (to % 8 != 0)) {
|
|
c = b[to_byte];
|
|
c = ((unsigned char)(c << (8 - to % 8))) >> (8 - to % 8);
|
|
result |= ((long long)c) << lshift;
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
/* Replace the specified bits in an instruction bundle */
|
|
static void
|
|
replace_bit_field(char *bundle, long long val, int from, int len) {
|
|
int to = from + len;
|
|
int from_byte = from / 8;
|
|
int to_byte = to / 8;
|
|
unsigned char *b = (unsigned char *)bundle;
|
|
unsigned char c;
|
|
|
|
if (from_byte == to_byte) {
|
|
unsigned char left, right;
|
|
c = b[from_byte];
|
|
left = (c >> (to % 8)) << (to % 8);
|
|
right =
|
|
((unsigned char)(c << (8 - from % 8))) >> (8 - from % 8);
|
|
c = (unsigned char)(val & 0xff);
|
|
c = (unsigned char)(c << (from % 8 + 8 - to % 8)) >> (8 -
|
|
to % 8);
|
|
c |= right | left;
|
|
b[from_byte] = c;
|
|
} else {
|
|
int i;
|
|
c = b[from_byte];
|
|
c = ((unsigned char)(c << (8 - from % 8))) >> (8 - from % 8);
|
|
c = c | (val << (from % 8));
|
|
b[from_byte] = c;
|
|
val >>= 8 - from % 8;
|
|
|
|
for (i = from_byte + 1; i < to_byte; i++) {
|
|
c = val & 0xff;
|
|
val >>= 8;
|
|
b[i] = c;
|
|
}
|
|
|
|
if (to % 8 != 0) {
|
|
unsigned char cv = (unsigned char)val;
|
|
c = b[to_byte];
|
|
c = c >> (to % 8) << (to % 8);
|
|
c |= ((unsigned char)(cv << (8 - to % 8))) >> (8 -
|
|
to % 8);
|
|
b[to_byte] = c;
|
|
}
|
|
}
|
|
}
|
|
|
|
/* Return the contents of slot N (for N = 0, 1, or 2) in
|
|
and instruction bundle */
|
|
static long long
|
|
slotN_contents(char *bundle, int slotnum) {
|
|
return extract_bit_field(bundle, 5 + 41 * slotnum, 41);
|
|
}
|
|
|
|
/* Store an instruction in an instruction bundle */
|
|
|
|
static void
|
|
replace_slotN_contents(char *bundle, long long instr, int slotnum) {
|
|
replace_bit_field(bundle, instr, 5 + 41 * slotnum, 41);
|
|
}
|
|
|
|
typedef enum instruction_type {
|
|
A, /* Integer ALU ; I-unit or M-unit */
|
|
I, /* Non-ALU integer; I-unit */
|
|
M, /* Memory ; M-unit */
|
|
F, /* Floating-point ; F-unit */
|
|
B, /* Branch ; B-unit */
|
|
L, /* Extended (L+X) ; I-unit */
|
|
X, /* Extended (L+X) ; I-unit */
|
|
undefined /* undefined or reserved */
|
|
} instruction_type;
|
|
|
|
static enum instruction_type template_encoding_table[32][3] = {
|
|
{M, I, I}, /* 00 */
|
|
{M, I, I}, /* 01 */
|
|
{M, I, I}, /* 02 */
|
|
{M, I, I}, /* 03 */
|
|
{M, L, X}, /* 04 */
|
|
{M, L, X}, /* 05 */
|
|
{undefined, undefined, undefined}, /* 06 */
|
|
{undefined, undefined, undefined}, /* 07 */
|
|
{M, M, I}, /* 08 */
|
|
{M, M, I}, /* 09 */
|
|
{M, M, I}, /* 0A */
|
|
{M, M, I}, /* 0B */
|
|
{M, F, I}, /* 0C */
|
|
{M, F, I}, /* 0D */
|
|
{M, M, F}, /* 0E */
|
|
{M, M, F}, /* 0F */
|
|
{M, I, B}, /* 10 */
|
|
{M, I, B}, /* 11 */
|
|
{M, B, B}, /* 12 */
|
|
{M, B, B}, /* 13 */
|
|
{undefined, undefined, undefined}, /* 14 */
|
|
{undefined, undefined, undefined}, /* 15 */
|
|
{B, B, B}, /* 16 */
|
|
{B, B, B}, /* 17 */
|
|
{M, M, B}, /* 18 */
|
|
{M, M, B}, /* 19 */
|
|
{undefined, undefined, undefined}, /* 1A */
|
|
{undefined, undefined, undefined}, /* 1B */
|
|
{M, F, B}, /* 1C */
|
|
{M, F, B}, /* 1D */
|
|
{undefined, undefined, undefined}, /* 1E */
|
|
{undefined, undefined, undefined}, /* 1F */
|
|
};
|
|
|
|
union bundle_t {
|
|
char cbundle[16];
|
|
unsigned long ubundle[2];
|
|
};
|
|
|
|
void
|
|
arch_enable_breakpoint(pid_t pid, struct breakpoint *sbp)
|
|
{
|
|
|
|
unsigned long addr = (unsigned long)sbp->addr;
|
|
union bundle_t bundle;
|
|
int slotnum = (int)(addr & 0x0f) & 0x3;
|
|
long long instr;
|
|
int template;
|
|
|
|
debug(1, "Enable Breakpoint at %p)", sbp->addr);
|
|
|
|
assert(slotnum <= 2);
|
|
|
|
addr &= ~0x0f;
|
|
bundle.ubundle[0] = ptrace(PTRACE_PEEKTEXT, pid, addr, 0);
|
|
bundle.ubundle[1] = ptrace(PTRACE_PEEKTEXT, pid, addr + 8, 0);
|
|
|
|
/* Check for L type instruction in 2nd slot, if present then
|
|
bump up the slot number to the 3rd slot */
|
|
template = extract_bit_field(bundle.cbundle, 0, 5);
|
|
if (slotnum == 1 && template_encoding_table[template][1] == L) {
|
|
slotnum = 2;
|
|
}
|
|
|
|
instr = slotN_contents(bundle.cbundle, slotnum);
|
|
|
|
memcpy(sbp->orig_value, &instr, sizeof(instr));
|
|
|
|
replace_slotN_contents(bundle.cbundle, 0x00002000040LL, slotnum);
|
|
|
|
ptrace(PTRACE_POKETEXT, pid, addr, bundle.ubundle[0]);
|
|
ptrace(PTRACE_POKETEXT, pid, addr + 8, bundle.ubundle[1]);
|
|
|
|
}
|
|
|
|
void
|
|
arch_disable_breakpoint(pid_t pid, const struct breakpoint *sbp)
|
|
{
|
|
|
|
unsigned long addr = (unsigned long)sbp->addr;
|
|
int slotnum = (int)(addr & 0x0f) & 0x3;
|
|
union bundle_t bundle;
|
|
unsigned long instr;
|
|
|
|
debug(1, "Disable Breakpoint at %p", sbp->addr);
|
|
|
|
addr &= ~0x0f;
|
|
|
|
bundle.ubundle[0] = ptrace(PTRACE_PEEKTEXT, pid, addr, 0);
|
|
bundle.ubundle[1] = ptrace(PTRACE_PEEKTEXT, pid, addr + 8, 0);
|
|
|
|
memcpy(&instr, sbp->orig_value, sizeof(instr));
|
|
|
|
replace_slotN_contents(bundle.cbundle, instr, slotnum);
|
|
ptrace(PTRACE_POKETEXT, pid, addr, bundle.ubundle[0]);
|
|
ptrace(PTRACE_POKETEXT, pid, addr + 8, bundle.ubundle[1]);
|
|
}
|