| /* Target dependent code for ARC processor family, for GDB, the GNU debugger. |
| |
| Copyright 2008, 2009 Free Software Foundation, Inc. |
| |
| Contributed by ARC International (www.arc.com) |
| |
| Author: |
| Richard Stuckey <richard.stuckey@arc.com> |
| |
| This file is part of GDB. |
| |
| 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 3 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, see <http://www.gnu.org/licenses/>. */ |
| |
| /******************************************************************************/ |
| /* */ |
| /* Outline: */ |
| /* This module implements facilities for intercepting I/O (and other) */ |
| /* operations attempted on an ARC target and performing them on the host, */ |
| /* using a RPC (Remote Procedure Call) mechanism. */ |
| /* */ |
| /* Mechanism: */ |
| /* When interception is enabled, this module sets a breakpoint at the */ |
| /* entry point of each operation which is to be intercepted; it finds the */ |
| /* entry points of named routines in the C runtime library code by using */ |
| /* gdb's symbol lookup facilities. */ |
| /* */ |
| /* When a breakpoint is triggered on the target, the target monitoring */ |
| /* loop calls the function 'arc_check_interception_breakpoint' to check */ |
| /* whether the breakpoint triggered is an interception breakpoint; this */ |
| /* function will return a code indicating either */ |
| /* */ |
| /* a) the breakpoint is an interception breakpoint, the interception */ |
| /* has been performed and execution of the target program should be */ |
| /* resumed; or */ |
| /* */ |
| /* b) the breakpoint is an interception breakpoint, but the intercepted */ |
| /* routine is 'exit' and execution should not be resumed; or */ |
| /* */ |
| /* c) the breakpoint is not an interception breakpoint, so execution */ |
| /* should not be resumed and the trigger should be reported to gdb. */ |
| /* */ |
| /* In case a), this module then reads the routine's parameters from the */ |
| /* target's registers, performs whatever conversions are required, and */ |
| /* constructs a gdb RSP File I/O extension 'F' message which it passes to */ |
| /* the gdb target_fileio module, which performs the requested operation */ |
| /* on the host machine. */ |
| /* */ |
| /* The target_fileio module is passed a set of operations which allow it */ |
| /* to read data from target memory, write data to target memory, and */ |
| /* return a result value (and possibly a error code) to the intercepted */ |
| /* routine. The result value is written into the target's R0 register; */ |
| /* the error code (if any) is written into the location of the 'errno' */ |
| /* variable. */ |
| /* */ |
| /* Finally, this module copies the routine return address from the BLINK */ |
| /* register to the PC register - this ensures that when execution of the */ |
| /* target is resumed, control returns to the code after the call to the */ |
| /* intercepted routine. */ |
| /* */ |
| /* Notes: */ |
| /* 1) the set of routines to be intercepted, and the parameters to these */ |
| /* routines, is defined by a table (see below) - so it is simple to */ |
| /* add more routines to the set; */ |
| /* */ |
| /* 2) the 'open' syscall (see man open(2)) has a 'flags' parameter which */ |
| /* is a bit mask; unfortunately, the bits differ in meaning between */ |
| /* the host and the elf-32 target program, so the parameter must be */ |
| /* converted before it can be passed to the target_fileio module; */ |
| /* */ |
| /* 3) the 'fstat' syscall (see man fstat(2)) has an out parameter which */ |
| /* is a 'struct stat' structure (i.e. the address of such a structure */ |
| /* is a parameter to the syscall): the target_fileio module writes the */ |
| /* data of the structure to that location in target memory; however, */ |
| /* the structure does not have the same layout on host and target, so */ |
| /* the structure must be converted before it can be written to the */ |
| /* target; */ |
| /* */ |
| /* 4) the interception breakpoints are not handled by the core gdb */ |
| /* breakpoint mechanism; hence, they are not listed by the 'info break'*/ |
| /* command, and can not be (accidentally) deleted by the user; though */ |
| /* they could be handled by gdb, that would require the introduction */ |
| /* of a new "invisible" breakpoint type, and hence more changes to */ |
| /* supposedly generic code; */ |
| /* */ |
| /* 5) it would be more elegant (from one perspective) to intecept these */ |
| /* operations by placing a breakpoint at the interrupt vector location */ |
| /* of the 'swi' (SoftWare Interrupt) handler: only one breakpoint */ |
| /* would then be required, and all syscalls would be intercepted; */ |
| /* however, this module would then have to simulate a "return from */ |
| /* exception" in order to resume target execution, which would be more */ |
| /* complex than the "restart at return address" method currently used. */ |
| /* */ |
| /* Restrictions: */ |
| /* 1) this module places s/w breakpoints at the entry points; therefore, */ |
| /* the mechanism will not work with programs that are loaded into read */ |
| /* -only memory; */ |
| /* */ |
| /* 2) this mechanism will probably not work if the user sets breakpoints */ |
| /* on the entry points of the intercepted routines - there will be a */ |
| /* conflict! */ |
| /* */ |
| /******************************************************************************/ |
| |
| /* system header files */ |
| #include <stdio.h> |
| #include <string.h> |
| #include <signal.h> |
| |
| /* gdb header files */ |
| #include "defs.h" |
| #include "symtab.h" |
| #include "frame.h" |
| #include "block.h" |
| #include "target.h" |
| #include "target-fileio.h" |
| #include "exceptions.h" |
| #include "gdb/fileio.h" |
| |
| /* ARC header files */ |
| #include "arc-remote-fileio.h" |
| #include "config/arc/tm-embed.h" |
| |
| |
| /* -------------------------------------------------------------------------- */ |
| /* local types */ |
| /* -------------------------------------------------------------------------- */ |
| |
| #define MAX_SYSCALL_PARAMS 4 |
| |
| /* These are the intercepted routines. */ |
| typedef enum |
| { |
| READ_CALL, |
| WRITE_CALL, |
| OPEN_CALL, |
| CLOSE_CALL, |
| LSEEK_CALL, |
| FSTAT_CALL, |
| GETTIMEOFDAY_CALL, |
| EXIT_CALL |
| } SystemCall; |
| |
| |
| struct lib_function |
| { |
| SystemCall call; |
| const char *name; |
| const char *format; |
| Boolean bp_is_set; |
| unsigned int param_count; |
| ARC_RegisterNumber param_register[MAX_SYSCALL_PARAMS]; |
| struct bp_target_info breakpoint; |
| }; |
| |
| |
| /* This structure defines a memory image of the 'stat' structure as it is |
| represented on the ARC target. */ |
| struct arc_stat |
| { |
| ARC_Byte fst_dev [4]; |
| ARC_Byte fst_ino [4]; |
| ARC_Byte fst_mode [2]; |
| ARC_Byte fst_nlink [2]; |
| ARC_Byte fst_uid [2]; |
| ARC_Byte fst_gid [2]; |
| ARC_Byte fst_rdev [4]; |
| ARC_Byte fst_size [4]; |
| ARC_Byte fst_blksize[4]; |
| ARC_Byte fst_blocks [4]; |
| ARC_Byte fst_atime [8]; |
| ARC_Byte fst_mtime [8]; |
| ARC_Byte fst_ctime [8]; |
| }; |
| |
| |
| /* -------------------------------------------------------------------------- */ |
| /* local data */ |
| /* -------------------------------------------------------------------------- */ |
| |
| /* The %x specifiers in the format strings in this table correspond to the |
| parameters to the intercepted functions; the register number of the target |
| register in which the parameter is passed is given by the corresponding |
| entry in the param_register array. |
| |
| N.B. the special value of SL as the number of the register in which a |
| parameter is passed indicates that the preceding parameter was the |
| address of a string, and the length of that string (including the |
| terminating NUL) is required here. |
| |
| F<n> indicates that the parameter in register <n> is a word of flag |
| bits which must be handled specially! |
| |
| X indicates that the array element is not used. */ |
| |
| #define SL 1000 |
| #define F2 1002 |
| #define X 9999 |
| |
| static struct lib_function functions[] = |
| { |
| { READ_CALL, "_read_r", "Fread,%x,%x,%x", FALSE, 3, {1, 2, 3, X} }, |
| { WRITE_CALL, "_write_r", "Fwrite,%x,%x,%x", FALSE, 3, {1, 2, 3, X} }, |
| { OPEN_CALL, "_open_r", "Fopen,%x/%x,%x,%x", FALSE, 4, {1, SL, F2, 3} }, |
| { CLOSE_CALL, "_close_r", "Fclose,%x", FALSE, 1, {1, X, X, X} }, |
| { LSEEK_CALL, "_lseek_r", "Flseek,%x,%x,%x", FALSE, 3, {1, 2, 3, X} }, |
| { FSTAT_CALL, "_fstat_r", "Ffstat,%x,%x", FALSE, 2, {1, 2, X, X} }, |
| { GETTIMEOFDAY_CALL, "_gettimeofday_r", "Fgettimeofday,%x,%x", FALSE, 2, {1, 2, X, X} }, |
| { EXIT_CALL, "_exit_r", NULL, FALSE, 1, {1, X, X, X} } |
| }; |
| |
| |
| /* A pointer to the set of target operations for the current target. */ |
| static TargetOperations *target_operations; |
| |
| /* TRUE if the operation currently being intercepted has NOT been interrupted |
| by the user typing a Ctrl-C. */ |
| static Boolean not_interrupted; |
| |
| /* For the Ctrl-C signal handler. */ |
| static void (*old_signal_handler) (int); |
| |
| |
| /* -------------------------------------------------------------------------- */ |
| /* local functions */ |
| /* -------------------------------------------------------------------------- */ |
| |
| /* Read a number of bytes of data from the given address in target memory. */ |
| |
| static int |
| read_bytes (CORE_ADDR memaddr, gdb_byte *myaddr, int len) |
| { |
| DEBUG("reading %d bytes from %x\n", len, (unsigned int) memaddr); |
| |
| return (int) target_read (¤t_target, TARGET_OBJECT_MEMORY, NULL, myaddr, memaddr, len); |
| } |
| |
| |
| /* Read a number of bytes of data from the given address in target memory. */ |
| |
| static int |
| write_bytes (CORE_ADDR memaddr, gdb_byte *myaddr, int len) |
| { |
| DEBUG("writing %d bytes to %x\n", len, (unsigned int) memaddr); |
| |
| return (int) target_write (¤t_target, TARGET_OBJECT_MEMORY, NULL, myaddr, memaddr, len); |
| } |
| |
| |
| /* Perform the reply to the intercepted operation: set up the result of the call |
| and the error code (if any) so that the intercepted operation receives them |
| just as though the operation had really been performed upon the target. */ |
| |
| static void |
| reply (int retcode, int error) |
| { |
| /* Ignore any Ctrl-Cs while performing the reply. */ |
| (void) signal (SIGINT, SIG_IGN); |
| |
| DEBUG("reply: retcode = %d, error = %d\n", retcode, error); |
| |
| /* If an error has occurred. */ |
| if (retcode == -1) |
| { |
| ARC_RegisterContents errno_address; |
| |
| if (error == FILEIO_EINTR) |
| { |
| DEBUG("*** interrupted by user!\n"); |
| /* Set the global flag so that it can be tested later. */ |
| not_interrupted = FALSE; |
| return; |
| } |
| |
| /* Read the address of the 'errno' variable from R0. */ |
| if (target_operations->read_core_register(0, &errno_address, TRUE)) |
| /* Write the error number into the 'errno' variable. */ |
| (void) write_bytes((CORE_ADDR) errno_address, (gdb_byte*) &error, BYTES_IN_WORD); |
| } |
| |
| /* Write the return code into the function result register R0. */ |
| (void) target_operations->write_core_register(0, (ARC_RegisterContents) retcode, TRUE); |
| } |
| |
| |
| /* Copy a number of bytes of data from one buffer to another. Note that the |
| buffers are not necessarily of the same size. Perform endianess byte-swapping |
| if necessary. */ |
| |
| static void |
| copy_bytes (char *from, size_t from_size, |
| ARC_Byte *to, size_t to_size, |
| Boolean target_is_big_endian) |
| { |
| /* We can not copy more data than we have been given in the source buffer, |
| or for which there is room in the destination buffer. */ |
| unsigned int bytes = (unsigned int) ((from_size > to_size) ? to_size : from_size); |
| unsigned int i; |
| |
| /* N.B. 1) the fio_stat structure created by target-fileio.c has the values |
| in big-endian byte order; so if the ARC target is little-endian |
| we must reverse the order; |
| |
| 2) the fields in the fio_stat structure may be smaller (or larger!) |
| than the corresponding fields in the ARC target structure - so we |
| copy the *least* significant bytes of the fields, on the grounds |
| that the most significant bytes are probably just sign-extensions! */ |
| for (i = 0; i < bytes; i++) |
| to[i] = (ARC_Byte) ((target_is_big_endian) ? from[i] |
| : from[from_size - 1 - i]); |
| } |
| |
| |
| /* Write a 'stat' structure to the target at a given address in memory. |
| 'myaddr' points to a fio_stat structure created by the target-fileio module; |
| this structure is meant for use in the RSP protocol, and is designed for |
| independence of host/target systems - therefore, we must create an equivalent |
| structure which is ARC-specific, and write that structure to the target. |
| |
| Return the number of bytes of data written. */ |
| |
| static int |
| write_fstat (CORE_ADDR memaddr, gdb_byte *myaddr, int len) |
| { |
| Boolean target_is_big_endian = (gdbarch_byte_order (current_gdbarch) == BFD_ENDIAN_BIG); |
| struct fio_stat *fst = (struct fio_stat*) myaddr; |
| struct arc_stat ast; |
| |
| memset(&ast, 0, sizeof(ast)); |
| |
| #define COPY(from, to) copy_bytes(from, sizeof(from), to, sizeof(to), target_is_big_endian) |
| |
| COPY(fst->fst_dev, ast.fst_dev); |
| COPY(fst->fst_ino, ast.fst_ino); |
| COPY(fst->fst_mode, ast.fst_mode); |
| COPY(fst->fst_nlink, ast.fst_nlink); |
| COPY(fst->fst_uid, ast.fst_uid); |
| COPY(fst->fst_gid, ast.fst_gid); |
| COPY(fst->fst_rdev, ast.fst_rdev); |
| COPY(fst->fst_size, ast.fst_size); |
| COPY(fst->fst_blksize, ast.fst_blksize); |
| COPY(fst->fst_blocks, ast.fst_blocks); |
| COPY(fst->fst_atime, ast.fst_atime); |
| COPY(fst->fst_mtime, ast.fst_mtime); |
| COPY(fst->fst_ctime, ast.fst_ctime); |
| |
| return write_bytes(memaddr, (gdb_byte*) &ast, (int) sizeof(ast)); |
| } |
| |
| |
| /* Find the address of the entry point of the given routine in the target program. |
| Return 0 if the entry point can not be found, or is not a function. */ |
| |
| static CORE_ADDR |
| findEntryPoint (const char *routine) |
| { |
| CORE_ADDR entry = 0; |
| int is_a_field_of_this; |
| struct symbol *sym = lookup_symbol (routine, |
| get_selected_block (0), |
| VAR_DOMAIN, |
| &is_a_field_of_this, |
| (struct symtab **) NULL); |
| if (sym) |
| { |
| if (SYMBOL_CLASS (sym) == LOC_BLOCK) |
| entry = BLOCK_START (SYMBOL_BLOCK_VALUE (sym)); |
| else |
| warning(_("%s is not a function"), routine); |
| } |
| else |
| warning(_("can not find entry point of function %s"), routine); |
| |
| return entry; |
| } |
| |
| |
| /* Insert a s/w breakpoint in the target program code at the entry point of the |
| given library function. */ |
| |
| static void |
| insert_breakpoint (struct lib_function *f) |
| { |
| if (!f->bp_is_set) |
| { |
| if (arc_elf32_insert_breakpoint(&f->breakpoint) == 0) |
| f->bp_is_set = TRUE; |
| else |
| warning(_("can not set breakpoint at entrypoint of %s"), f->name); |
| } |
| } |
| |
| |
| /* Remove a s/w breakpoint from the target program code at the entry point of the |
| given library function. */ |
| |
| static void |
| remove_breakpoint (struct lib_function *f) |
| { |
| if (f->bp_is_set) |
| { |
| if (arc_elf32_remove_breakpoint(&f->breakpoint) == 0) |
| f->bp_is_set = FALSE; |
| else |
| warning(_("can not unset breakpoint at entrypoint of %s"), f->name); |
| } |
| } |
| |
| |
| /* This function handles any Ctrl-C typed by the user whilst the interception of |
| an operation is in progress. */ |
| |
| static void |
| Ctrl_C_signal_handler (int signo) |
| { |
| /* Ignore any more Ctrl-Cs. */ |
| (void) signal (SIGINT, SIG_IGN); |
| |
| /* We must use the gdb exception mechanism since the target_fileio_request |
| function calls catch_exceptions, and if we do something else (like a long |
| jump) here, gdb's cleanup list would be left in an inconsistent state! */ |
| DEBUG("*** throwing RETURN_QUIT...\n"); |
| deprecated_throw_reason (RETURN_QUIT); |
| } |
| |
| |
| /* This function is called from the gdb target-fileio module: it sets up this |
| module's handler for Ctrl-C interrupts. */ |
| |
| static void |
| set_Ctrl_C_signal_handler (void) |
| { |
| old_signal_handler = signal (SIGINT, Ctrl_C_signal_handler); |
| } |
| |
| |
| /* This function finds the length of a C string stored in target memory at the |
| given address. */ |
| |
| static unsigned int |
| find_string_length (ARC_Address address) |
| { |
| unsigned int length = 0; |
| |
| while (TRUE) |
| { |
| gdb_byte buf[65]; |
| int bytes = read_bytes((CORE_ADDR) address, |
| buf, |
| (int) sizeof(buf) - 1); |
| int i; |
| |
| for (i = 0; i < bytes; i++) |
| if (buf[i] == (gdb_byte) '\0') |
| return (unsigned int) (length + i + 1); |
| |
| address += bytes; |
| length += bytes; |
| } |
| } |
| |
| |
| /* Convert flags to target syscall to what they "should" be! */ |
| |
| static ARC_RegisterContents |
| convert_flags (ARC_RegisterContents flags) |
| { |
| ARC_RegisterContents result = flags; |
| |
| /* See gcc/src/newlib/libc/sys/arc/sys/fcntl.h */ |
| |
| /* The following values have been changed for uclibc compatibility. */ |
| #define _FAPPEND 0x0400 /* append (writes guaranteed at the end) */ |
| #define _FASYNC 0x2000 /* signal pgrp when data ready */ |
| #define _FCREAT 0x0040 /* open with file create */ |
| #define _FTRUNC 0x0200 /* open with truncation */ |
| #define _FEXCL 0x0080 /* error on open if file exists */ |
| #define _FSYNC 0x1000 /* do all writes synchronously */ |
| #define _FNONBLOCK 0x0800 /* non blocking I/O (POSIX style) */ |
| |
| #define REMOVE(flag) if (flags & _F ## flag) result &= ~ _F ## flag |
| #define ADD(flag) if (flags & _F ## flag) result |= FILEIO_O_ ## flag |
| |
| /* N.B. all "old" bits most be removed from the result word before all |
| "new" bits are added, in case the old and new sets intersect! */ |
| REMOVE(APPEND); |
| // REMOVE(ASYNC); // no equivalent flag in gdb/fileio.h |
| REMOVE(CREAT); |
| REMOVE(TRUNC); |
| REMOVE(EXCL); |
| // REMOVE(SYNC); // no equivalent flag in gdb/fileio.h |
| // REMOVE(NONBLOCK); // no equivalent flag in gdb/fileio.h |
| ADD(APPEND); |
| // ADD(ASYNC); // no equivalent flag in gdb/fileio.h |
| ADD(CREAT); |
| ADD(TRUNC); |
| ADD(EXCL); |
| // ADD(SYNC); // no equivalent flag in gdb/fileio.h |
| // ADD(NONBLOCK); // no equivalent flag in gdb/fileio.h |
| |
| return result; |
| } |
| |
| |
| /* Perform the interception of the given library function. |
| Return TRUE if the interception is completed successfully, |
| FALSE if it is interrupted by the user. */ |
| |
| static Boolean |
| perform_interception (struct lib_function *f) |
| { |
| ARC_RegisterContents params [MAX_SYSCALL_PARAMS]; |
| char request[MAX_SYSCALL_PARAMS * 9 + 40]; |
| unsigned int i; |
| |
| /* These operations allow the target_fileio module to read data from target |
| memory, write data to target memory, and return a result value (and |
| possibly a error code) to the intercepted routine. |
| |
| N.B. if the syscsall is 'fstat', we pass a special write function |
| which converts the 'struct stat' structure to target layout before |
| writing it to target memory. */ |
| struct file_io_operations io_operations = |
| { |
| read_bytes, |
| (f->call == FSTAT_CALL) ? write_fstat : write_bytes, |
| reply, |
| set_Ctrl_C_signal_handler |
| }; |
| |
| /* Evaluate the parameters to be passed to the RPC request. */ |
| for (i = 0; i < f->param_count; i++) |
| { |
| ARC_RegisterNumber reg = f->param_register[i]; |
| |
| if (reg == SL) |
| params[i] = find_string_length((ARC_Address) params[i - 1]); |
| else if (reg == F2) |
| { |
| ARC_RegisterContents flags; |
| |
| (void) target_operations->read_core_register(2, &flags, TRUE); |
| params[i] = convert_flags(flags); |
| } |
| else |
| (void) target_operations->read_core_register(reg, ¶ms[i], TRUE); |
| } |
| |
| /* Do not close the target program's stdin, stdout or stderr streams on the |
| host: it is possible that the program may be re-loaded and re-run on the |
| target in the same debugging session (so re-initializing its I/O system) |
| so it may try to read/write those streams again - instead, just tell the |
| target that the close succeeded. */ |
| if (f->call == CLOSE_CALL) |
| { |
| int fd = (int) params[0]; |
| |
| if (fd == STDIN_FILENO || fd == STDOUT_FILENO || fd == STDERR_FILENO) |
| { |
| reply(0, 0); |
| DEBUG("*** RPC close of stream %d ignored\n", fd); |
| return TRUE; |
| } |
| } |
| |
| /* Parameters which are extra to those required by the format will simply be |
| ignored. */ |
| (void) snprintf(request, sizeof(request), f->format, |
| params[0], params[1], params[2], params[3]); |
| |
| DEBUG("RPC request: %s\n", request); |
| |
| /* the interception might be interrupted by the user typing Ctrl-C whilst |
| the interception is in progress; if that happens, this flag will be set |
| to FALSE. */ |
| not_interrupted = TRUE; |
| |
| /* Make the RPC request. */ |
| target_fileio_request(request, &io_operations); |
| |
| (void) signal (SIGINT, old_signal_handler); |
| |
| /* If the call was not interrupted, the interception has been performed. */ |
| return not_interrupted; |
| } |
| |
| |
| /* -------------------------------------------------------------------------- */ |
| /* externally visible functions */ |
| /* -------------------------------------------------------------------------- */ |
| |
| /* Set the state of the I/O interception mechanism: |
| ON : set breakpoints on all the functions to be intercepted |
| OFF : clear breakpoints from all the intercepted functions |
| RESET: mark the breakpoints as not being set (if a new program has been |
| downloaded to the target, the s/w breakpoints in the old program |
| have been lost, and so should not be removed). */ |
| |
| void |
| arc_set_IO_interception (TargetOperations *operations, |
| InterceptionState state) |
| { |
| unsigned int i; |
| |
| DEBUG("*** interception: %s\n", (state == INTERCEPTION_RESET) ? "RESET" : |
| (state == INTERCEPTION_ON) ? "ON" : |
| "OFF"); |
| |
| target_operations = operations; |
| |
| for (i = 0; i < ELEMENTS_IN_ARRAY(functions); i++) |
| { |
| struct lib_function* f = &functions[i]; |
| |
| switch (state) |
| { |
| case INTERCEPTION_RESET: |
| f->bp_is_set = FALSE; |
| break; |
| |
| case INTERCEPTION_ON: |
| /* Set a breakpoint on the entry point of the function. */ |
| f->breakpoint.placed_address = findEntryPoint(f->name); |
| |
| if (f->breakpoint.placed_address != 0) |
| { |
| DEBUG("intercept 0x%08X : %s\n", (unsigned int) f->breakpoint.placed_address, f->name); |
| insert_breakpoint(f); |
| } |
| break; |
| |
| case INTERCEPTION_OFF: |
| if (f->breakpoint.placed_address != 0) |
| { |
| remove_breakpoint(f); |
| f->breakpoint.placed_address = 0; |
| } |
| break; |
| } |
| } |
| } |
| |
| |
| /* This function is called when the execution of the target program has been |
| halted by a breakpoint trigger. It checks whether the breakpoint that has |
| been triggered is at the entry point of an intercepted function, and, if so, |
| performs the required interception. |
| |
| Returns: |
| INTERCEPTION_RESUME : interception has been performed, execution should be resumed |
| INTERCEPTION_HALT : the program is halted (no interception has been performed) |
| INTERCEPTION_EXIT : the program has exited |
| INTERCEPTION_INTERRUPT : the interception has been interrupted by the user |
| |
| If the program has exited, the 'exitcode' parameter is set to the program's exit code. */ |
| |
| InterceptionAction |
| arc_check_interception_breakpoint (int *exitcode) |
| { |
| ARC_RegisterContents pc; |
| |
| ENTERMSG; |
| |
| *exitcode = 0; |
| |
| /* Get the current execution point from the PCL, rather than the PC - this |
| gives the same result on both ARC700 and ARC600 targets. */ |
| if (target_operations->read_core_register(ARC_PCL_REGNUM, &pc, TRUE)) |
| { |
| unsigned int i; |
| |
| DEBUG("checking for interception at 0x%08X\n", pc); |
| |
| /* Look at each of the intercepted operations. */ |
| for (i = 0; i < ELEMENTS_IN_ARRAY(functions); i++) |
| { |
| struct lib_function *f = &functions[i]; |
| |
| if (f->breakpoint.placed_address == (CORE_ADDR) pc) |
| { |
| DEBUG("intercepted function %s\n", f->name); |
| |
| if (f->call == EXIT_CALL) |
| { |
| ARC_RegisterContents code; |
| |
| /* The exit code is in parameter register R1. */ |
| if (target_operations->read_core_register(1, &code, TRUE)) |
| *exitcode = (int) code; |
| |
| return INTERCEPTION_EXIT; |
| } |
| else |
| { |
| /* If the interception is performed. */ |
| if (perform_interception(f)) |
| { |
| ARC_RegisterContents blink; |
| |
| /* Copy BLINK to PC, so that when execution is re-started, |
| control will return to the point after the call of the |
| intercepted function. */ |
| if (target_operations->read_core_register (ARC_BLINK_REGNUM, &blink, TRUE) && |
| target_operations->write_auxiliary_register(arc_pc_regnum, blink, TRUE)) |
| { |
| DEBUG("copied BLINK (%x) to PC (was %x)\n", blink, pc); |
| return INTERCEPTION_RESUME; |
| } |
| |
| /* If we couldn't set PC, fall through. */ |
| } |
| else |
| { |
| /* The interception has been interrupted by a Ctrl-C |
| from the user - do not change the PC, as we want |
| execution to resume at the same point in the code, |
| so that the I/O request will be performed (and |
| intercepted) again: this e.g. allows the user to |
| break into a program that is in a tight loop doing |
| reads or writes. */ |
| return INTERCEPTION_INTERRUPT; |
| } |
| } |
| } |
| } |
| } |
| |
| return INTERCEPTION_HALT; |
| } |
| |
| /******************************************************************************/ |
