diff options
Diffstat (limited to 'gdb')
| -rw-r--r-- | gdb/ChangeLog | 10 | ||||
| -rw-r--r-- | gdb/configure.tgt | 11 | ||||
| -rw-r--r-- | gdb/solib-dsbt.c | 1259 | ||||
| -rw-r--r-- | gdb/tic6x-linux-tdep.c | 227 | ||||
| -rw-r--r-- | gdb/tic6x-tdep.c | 1386 | ||||
| -rw-r--r-- | gdb/tic6x-tdep.h | 54 |
6 files changed, 2947 insertions, 0 deletions
diff --git a/gdb/ChangeLog b/gdb/ChangeLog index 534de9b..b0ed11e 100644 --- a/gdb/ChangeLog +++ b/gdb/ChangeLog @@ -1,3 +1,13 @@ +2011-08-14 Andrew Jenner <andrew@codesourcery.com> + Bernd Schmidt <bernds@codesourcery.com> + Yao Qi <yao@codesourcery.com> + + * configure.tgt: Handle tic6x-*-*linux and tic6x-*-*. + * solib-dsbt.c: New file. Support DSBT shared object. + * tic6x-linux-tdep.c: New file. + * tic6x-tdep.c: New file. + * tic6x-tdep.h: New file. + 2011-08-14 Andrew Stubbs <ams@codesourcery.com> Yao Qi <yao@codesourcery.com> diff --git a/gdb/configure.tgt b/gdb/configure.tgt index eb05c26..137deba 100644 --- a/gdb/configure.tgt +++ b/gdb/configure.tgt @@ -552,6 +552,17 @@ spu*-*-*) build_gdbserver=yes ;; +tic6x-*-*linux) + # Target: GNU/Linux TI C6x + gdb_target_obs="tic6x-tdep.o tic6x-linux-tdep.o solib-dsbt.o \ + glibc-tdep.o corelow.o linux-tdep.o" + ;; + +tic6x-*-*) + # Target: TI C6X + gdb_target_obs="tic6x-tdep.o" + ;; + xstormy16-*-*) # Target: Sanyo Xstormy16a processor gdb_target_obs="xstormy16-tdep.o" diff --git a/gdb/solib-dsbt.c b/gdb/solib-dsbt.c new file mode 100644 index 0000000..2569395 --- /dev/null +++ b/gdb/solib-dsbt.c @@ -0,0 +1,1259 @@ +/* Handle TIC6X (DSBT) shared libraries for GDB, the GNU Debugger. + Copyright (C) 2010, 2011 Free Software Foundation, Inc. + + 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/>. */ + + +#include "defs.h" +#include "gdb_string.h" +#include "inferior.h" +#include "gdbcore.h" +#include "solib.h" +#include "solist.h" +#include "objfiles.h" +#include "symtab.h" +#include "language.h" +#include "command.h" +#include "gdbcmd.h" +#include "elf-bfd.h" +#include "exceptions.h" + +#define GOT_MODULE_OFFSET 4 + +/* Flag which indicates whether internal debug messages should be printed. */ +static int solib_dsbt_debug = 0; + +/* TIC6X pointers are four bytes wide. */ +enum { TIC6X_PTR_SIZE = 4 }; + +/* Representation of loadmap and related structs for the TIC6X DSBT. */ + +/* External versions; the size and alignment of the fields should be + the same as those on the target. When loaded, the placement of + the bits in each field will be the same as on the target. */ +typedef gdb_byte ext_Elf32_Half[2]; +typedef gdb_byte ext_Elf32_Addr[4]; +typedef gdb_byte ext_Elf32_Word[4]; + +struct ext_elf32_dsbt_loadseg +{ + /* Core address to which the segment is mapped. */ + ext_Elf32_Addr addr; + /* VMA recorded in the program header. */ + ext_Elf32_Addr p_vaddr; + /* Size of this segment in memory. */ + ext_Elf32_Word p_memsz; +}; + +struct ext_elf32_dsbt_loadmap { + /* Protocol version number, must be zero. */ + ext_Elf32_Word version; + /* A pointer to the DSBT table; the DSBT size and the index of this + module. */ + ext_Elf32_Word dsbt_table_ptr; + ext_Elf32_Word dsbt_size; + ext_Elf32_Word dsbt_index; + /* Number of segments in this map. */ + ext_Elf32_Word nsegs; + /* The actual memory map. */ + struct ext_elf32_dsbt_loadseg segs[1 /* nsegs, actually */]; +}; + +/* Internal versions; the types are GDB types and the data in each + of the fields is (or will be) decoded from the external struct + for ease of consumption. */ +struct int_elf32_dsbt_loadseg +{ + /* Core address to which the segment is mapped. */ + CORE_ADDR addr; + /* VMA recorded in the program header. */ + CORE_ADDR p_vaddr; + /* Size of this segment in memory. */ + long p_memsz; +}; + +struct int_elf32_dsbt_loadmap +{ + /* Protocol version number, must be zero. */ + int version; + CORE_ADDR dsbt_table_ptr; + /* A pointer to the DSBT table; the DSBT size and the index of this + module. */ + int dsbt_size, dsbt_index; + /* Number of segments in this map. */ + int nsegs; + /* The actual memory map. */ + struct int_elf32_dsbt_loadseg segs[1 /* nsegs, actually */]; +}; + +/* External link_map and elf32_dsbt_loadaddr struct definitions. */ + +typedef gdb_byte ext_ptr[4]; + +struct ext_elf32_dsbt_loadaddr +{ + ext_ptr map; /* struct elf32_dsbt_loadmap *map; */ +}; + +struct ext_link_map +{ + struct ext_elf32_dsbt_loadaddr l_addr; + + /* Absolute file name object was found in. */ + ext_ptr l_name; /* char *l_name; */ + + /* Dynamic section of the shared object. */ + ext_ptr l_ld; /* ElfW(Dyn) *l_ld; */ + + /* Chain of loaded objects. */ + ext_ptr l_next, l_prev; /* struct link_map *l_next, *l_prev; */ +}; + +/* Link map info to include in an allocated so_list entry */ + +struct lm_info +{ + /* The loadmap, digested into an easier to use form. */ + struct int_elf32_dsbt_loadmap *map; +}; + +/* Per pspace dsbt specific data. */ + +struct dsbt_info +{ + /* The load map, got value, etc. are not available from the chain + of loaded shared objects. ``main_executable_lm_info'' provides + a way to get at this information so that it doesn't need to be + frequently recomputed. Initialized by dsbt_relocate_main_executable. */ + struct lm_info *main_executable_lm_info; + + /* Load maps for the main executable and the interpreter. These are obtained + from ptrace. They are the starting point for getting into the program, + and are required to find the solib list with the individual load maps for + each module. */ + struct int_elf32_dsbt_loadmap *exec_loadmap; + struct int_elf32_dsbt_loadmap *interp_loadmap; + + /* Cached value for lm_base, below. */ + CORE_ADDR lm_base_cache; + + /* Link map address for main module. */ + CORE_ADDR main_lm_addr; + + int enable_break2_done; + + CORE_ADDR interp_text_sect_low; + CORE_ADDR interp_text_sect_high; + CORE_ADDR interp_plt_sect_low; + CORE_ADDR interp_plt_sect_high; +}; + +/* Per-program-space data key. */ +static const struct program_space_data *solib_dsbt_pspace_data; + +static void +dsbt_pspace_data_cleanup (struct program_space *pspace, void *arg) +{ + struct dsbt_info *info; + + info = program_space_data (pspace, solib_dsbt_pspace_data); + xfree (info); +} + +/* Get the current dsbt data. If none is found yet, add it now. This + function always returns a valid object. */ + +static struct dsbt_info * +get_dsbt_info (void) +{ + struct dsbt_info *info; + + info = program_space_data (current_program_space, solib_dsbt_pspace_data); + if (info != NULL) + return info; + + info = XZALLOC (struct dsbt_info); + set_program_space_data (current_program_space, solib_dsbt_pspace_data, info); + + info->enable_break2_done = 0; + info->lm_base_cache = 0; + info->main_lm_addr = 0; + + return info; +} + + +static void +dsbt_print_loadmap (struct int_elf32_dsbt_loadmap *map) +{ + int i; + + if (map == NULL) + printf_filtered ("(null)\n"); + else if (map->version != 0) + printf_filtered (_("Unsupported map version: %d\n"), map->version); + else + { + printf_filtered ("version %d\n", map->version); + + for (i = 0; i < map->nsegs; i++) + printf_filtered ("%s:%s -> %s:%s\n", + print_core_address (target_gdbarch, + map->segs[i].p_vaddr), + print_core_address (target_gdbarch, + map->segs[i].p_vaddr + + map->segs[i].p_memsz), + print_core_address (target_gdbarch, map->segs[i].addr), + print_core_address (target_gdbarch, map->segs[i].addr + + map->segs[i].p_memsz)); + } +} + +/* Decode int_elf32_dsbt_loadmap from BUF. */ + +static struct int_elf32_dsbt_loadmap * +decode_loadmap (gdb_byte *buf) +{ + enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch); + struct ext_elf32_dsbt_loadmap *ext_ldmbuf; + struct int_elf32_dsbt_loadmap *int_ldmbuf; + + int version, seg, nsegs; + int ext_ldmbuf_size, int_ldmbuf_size; + + ext_ldmbuf = (struct ext_elf32_dsbt_loadmap *) buf; + + /* Extract the version. */ + version = extract_unsigned_integer (ext_ldmbuf->version, + sizeof ext_ldmbuf->version, + byte_order); + if (version != 0) + { + /* We only handle version 0. */ + return NULL; + } + + /* Extract the number of segments. */ + nsegs = extract_unsigned_integer (ext_ldmbuf->nsegs, + sizeof ext_ldmbuf->nsegs, + byte_order); + + if (nsegs <= 0) + return NULL; + + /* Allocate space into which to put information extract from the + external loadsegs. I.e, allocate the internal loadsegs. */ + int_ldmbuf_size = (sizeof (struct int_elf32_dsbt_loadmap) + + (nsegs - 1) * sizeof (struct int_elf32_dsbt_loadseg)); + int_ldmbuf = xmalloc (int_ldmbuf_size); + + /* Place extracted information in internal structs. */ + int_ldmbuf->version = version; + int_ldmbuf->nsegs = nsegs; + for (seg = 0; seg < nsegs; seg++) + { + int_ldmbuf->segs[seg].addr + = extract_unsigned_integer (ext_ldmbuf->segs[seg].addr, + sizeof (ext_ldmbuf->segs[seg].addr), + byte_order); + int_ldmbuf->segs[seg].p_vaddr + = extract_unsigned_integer (ext_ldmbuf->segs[seg].p_vaddr, + sizeof (ext_ldmbuf->segs[seg].p_vaddr), + byte_order); + int_ldmbuf->segs[seg].p_memsz + = extract_unsigned_integer (ext_ldmbuf->segs[seg].p_memsz, + sizeof (ext_ldmbuf->segs[seg].p_memsz), + byte_order); + } + + xfree (ext_ldmbuf); + return int_ldmbuf; +} + + +static struct dsbt_info *get_dsbt_info (void); + +/* Interrogate the Linux kernel to find out where the program was loaded. + There are two load maps; one for the executable and one for the + interpreter (only in the case of a dynamically linked executable). */ + +static void +dsbt_get_initial_loadmaps (void) +{ + gdb_byte *buf; + struct dsbt_info *info = get_dsbt_info (); + + if (0 >= target_read_alloc (¤t_target, TARGET_OBJECT_FDPIC, + "exec", (gdb_byte**) &buf)) + { + info->exec_loadmap = NULL; + error (_("Error reading DSBT exec loadmap")); + } + info->exec_loadmap = decode_loadmap (buf); + if (solib_dsbt_debug) + dsbt_print_loadmap (info->exec_loadmap); + + if (0 >= target_read_alloc (¤t_target, TARGET_OBJECT_FDPIC, + "interp", (gdb_byte**)&buf)) + { + info->interp_loadmap = NULL; + error (_("Error reading DSBT interp loadmap")); + } + info->interp_loadmap = decode_loadmap (buf); + if (solib_dsbt_debug) + dsbt_print_loadmap (info->interp_loadmap); +} + +/* Given address LDMADDR, fetch and decode the loadmap at that address. + Return NULL if there is a problem reading the target memory or if + there doesn't appear to be a loadmap at the given address. The + allocated space (representing the loadmap) returned by this + function may be freed via a single call to xfree. */ + +static struct int_elf32_dsbt_loadmap * +fetch_loadmap (CORE_ADDR ldmaddr) +{ + enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch); + struct ext_elf32_dsbt_loadmap ext_ldmbuf_partial; + struct ext_elf32_dsbt_loadmap *ext_ldmbuf; + struct int_elf32_dsbt_loadmap *int_ldmbuf; + int ext_ldmbuf_size, int_ldmbuf_size; + int version, seg, nsegs; + + /* Fetch initial portion of the loadmap. */ + if (target_read_memory (ldmaddr, (gdb_byte *) &ext_ldmbuf_partial, + sizeof ext_ldmbuf_partial)) + { + /* Problem reading the target's memory. */ + return NULL; + } + + /* Extract the version. */ + version = extract_unsigned_integer (ext_ldmbuf_partial.version, + sizeof ext_ldmbuf_partial.version, + byte_order); + if (version != 0) + { + /* We only handle version 0. */ + return NULL; + } + + /* Extract the number of segments. */ + nsegs = extract_unsigned_integer (ext_ldmbuf_partial.nsegs, + sizeof ext_ldmbuf_partial.nsegs, + byte_order); + + if (nsegs <= 0) + return NULL; + + /* Allocate space for the complete (external) loadmap. */ + ext_ldmbuf_size = sizeof (struct ext_elf32_dsbt_loadmap) + + (nsegs - 1) * sizeof (struct ext_elf32_dsbt_loadseg); + ext_ldmbuf = xmalloc (ext_ldmbuf_size); + + /* Copy over the portion of the loadmap that's already been read. */ + memcpy (ext_ldmbuf, &ext_ldmbuf_partial, sizeof ext_ldmbuf_partial); + + /* Read the rest of the loadmap from the target. */ + if (target_read_memory (ldmaddr + sizeof ext_ldmbuf_partial, + (gdb_byte *) ext_ldmbuf + sizeof ext_ldmbuf_partial, + ext_ldmbuf_size - sizeof ext_ldmbuf_partial)) + { + /* Couldn't read rest of the loadmap. */ + xfree (ext_ldmbuf); + return NULL; + } + + /* Allocate space into which to put information extract from the + external loadsegs. I.e, allocate the internal loadsegs. */ + int_ldmbuf_size = sizeof (struct int_elf32_dsbt_loadmap) + + (nsegs - 1) * sizeof (struct int_elf32_dsbt_loadseg); + int_ldmbuf = xmalloc (int_ldmbuf_size); + + /* Place extracted information in internal structs. */ + int_ldmbuf->version = version; + int_ldmbuf->nsegs = nsegs; + for (seg = 0; seg < nsegs; seg++) + { + int_ldmbuf->segs[seg].addr + = extract_unsigned_integer (ext_ldmbuf->segs[seg].addr, + sizeof (ext_ldmbuf->segs[seg].addr), + byte_order); + int_ldmbuf->segs[seg].p_vaddr + = extract_unsigned_integer (ext_ldmbuf->segs[seg].p_vaddr, + sizeof (ext_ldmbuf->segs[seg].p_vaddr), + byte_order); + int_ldmbuf->segs[seg].p_memsz + = extract_unsigned_integer (ext_ldmbuf->segs[seg].p_memsz, + sizeof (ext_ldmbuf->segs[seg].p_memsz), + byte_order); + } + + xfree (ext_ldmbuf); + return int_ldmbuf; +} + +static void dsbt_relocate_main_executable (void); +static int enable_break2 (void); + +/* Scan for DYNTAG in .dynamic section of ABFD. If DYNTAG is found 1 is + returned and the corresponding PTR is set. */ + +static int +scan_dyntag (int dyntag, bfd *abfd, CORE_ADDR *ptr) +{ + int arch_size, step, sect_size; + long dyn_tag; + CORE_ADDR dyn_ptr, dyn_addr; + gdb_byte *bufend, *bufstart, *buf; + Elf32_External_Dyn *x_dynp_32; + Elf64_External_Dyn *x_dynp_64; + struct bfd_section *sect; + struct target_section *target_section; + + if (abfd == NULL) + return 0; + + if (bfd_get_flavour (abfd) != bfd_target_elf_flavour) + return 0; + + arch_size = bfd_get_arch_size (abfd); + if (arch_size == -1) + return 0; + + /* Find the start address of the .dynamic section. */ + sect = bfd_get_section_by_name (abfd, ".dynamic"); + if (sect == NULL) + return 0; + + for (target_section = current_target_sections->sections; + target_section < current_target_sections->sections_end; + target_section++) + if (sect == target_section->the_bfd_section) + break; + if (target_section < current_target_sections->sections_end) + dyn_addr = target_section->addr; + else + { + /* ABFD may come from OBJFILE acting only as a symbol file without being + loaded into the target (see add_symbol_file_command). This case is + such fallback to the file VMA address without the possibility of + having the section relocated to its actual in-memory address. */ + + dyn_addr = bfd_section_vma (abfd, sect); + } + + /* Read in .dynamic from the BFD. We will get the actual value + from memory later. */ + sect_size = bfd_section_size (abfd, sect); + buf = bufstart = alloca (sect_size); + if (!bfd_get_section_contents (abfd, sect, + buf, 0, sect_size)) + return 0; + + /* Iterate over BUF and scan for DYNTAG. If found, set PTR and return. */ + step = (arch_size == 32) ? sizeof (Elf32_External_Dyn) + : sizeof (Elf64_External_Dyn); + for (bufend = buf + sect_size; + buf < bufend; + buf += step) + { + if (arch_size == 32) + { + x_dynp_32 = (Elf32_External_Dyn *) buf; + dyn_tag = bfd_h_get_32 (abfd, (bfd_byte *) x_dynp_32->d_tag); + dyn_ptr = bfd_h_get_32 (abfd, (bfd_byte *) x_dynp_32->d_un.d_ptr); + } + else + { + x_dynp_64 = (Elf64_External_Dyn *) buf; + dyn_tag = bfd_h_get_64 (abfd, (bfd_byte *) x_dynp_64->d_tag); + dyn_ptr = bfd_h_get_64 (abfd, (bfd_byte *) x_dynp_64->d_un.d_ptr); + } + if (dyn_tag == DT_NULL) + return 0; + if (dyn_tag == dyntag) + { + /* If requested, try to read the runtime value of this .dynamic + entry. */ + if (ptr) + { + struct type *ptr_type; + gdb_byte ptr_buf[8]; + CORE_ADDR ptr_addr; + + ptr_type = builtin_type (target_gdbarch)->builtin_data_ptr; + ptr_addr = dyn_addr + (buf - bufstart) + arch_size / 8; + if (target_read_memory (ptr_addr, ptr_buf, arch_size / 8) == 0) + dyn_ptr = extract_typed_address (ptr_buf, ptr_type); + *ptr = dyn_ptr; + } + return 1; + } + } + + return 0; +} + +/* An expensive way to lookup the value of a single symbol for + bfd's that are only temporary anyway. This is used by the + shared library support to find the address of the debugger + interface structures in the shared library. + + Note that 0 is specifically allowed as an error return (no + such symbol). */ + +static CORE_ADDR +bfd_lookup_symbol (bfd *abfd, char *symname) +{ + long storage_needed; + asymbol *sym; + asymbol **symbol_table; + unsigned int number_of_symbols; + unsigned int i; + struct cleanup *back_to; + CORE_ADDR symaddr = 0; + + storage_needed = bfd_get_symtab_upper_bound (abfd); + + if (storage_needed > 0) + { + symbol_table = (asymbol **) xmalloc (storage_needed); + back_to = make_cleanup (xfree, symbol_table); + number_of_symbols = bfd_canonicalize_symtab (abfd, symbol_table); + + for (i = 0; i < number_of_symbols; i++) + { + sym = *symbol_table++; + if (strcmp (sym->name, symname) == 0) + { + /* Bfd symbols are section relative. */ + symaddr = sym->value + sym->section->vma; + break; + } + } + do_cleanups (back_to); + } + + if (symaddr) + return symaddr; + + /* Look for the symbol in the dynamic string table too. */ + + storage_needed = bfd_get_dynamic_symtab_upper_bound (abfd); + + if (storage_needed > 0) + { + symbol_table = (asymbol **) xmalloc (storage_needed); + back_to = make_cleanup (xfree, symbol_table); + number_of_symbols = bfd_canonicalize_dynamic_symtab (abfd, symbol_table); + + for (i = 0; i < number_of_symbols; i++) + { + sym = *symbol_table++; + if (strcmp (sym->name, symname) == 0) + { + /* Bfd symbols are section relative. */ + symaddr = sym->value + sym->section->vma; + break; + } + } + do_cleanups (back_to); + } + + return symaddr; +} + + +/* If no open symbol file, attempt to locate and open the main symbol + file. + + If FROM_TTYP dereferences to a non-zero integer, allow messages to + be printed. This parameter is a pointer rather than an int because + open_symbol_file_object is called via catch_errors and + catch_errors requires a pointer argument. */ + +static int +open_symbol_file_object (void *from_ttyp) +{ + /* Unimplemented. */ + return 0; +} + +/* Given a loadmap and an address, return the displacement needed + to relocate the address. */ + +static CORE_ADDR +displacement_from_map (struct int_elf32_dsbt_loadmap *map, + CORE_ADDR addr) +{ + int seg; + + for (seg = 0; seg < map->nsegs; seg++) + if (map->segs[seg].p_vaddr <= addr + && addr < map->segs[seg].p_vaddr + map->segs[seg].p_memsz) + return map->segs[seg].addr - map->segs[seg].p_vaddr; + + return 0; +} + +/* Return the address from which the link map chain may be found. On + DSBT, a pointer to the start of the link map will be located at the + word found at base of GOT + GOT_MODULE_OFFSET. + + The base of GOT may be found in a number of ways. Assuming that the + main executable has already been relocated, + 1 The easiest way to find this value is to look up the address of + _GLOBAL_OFFSET_TABLE_. + 2 The other way is to look for tag DT_PLTGOT, which contains the virtual + address of Global Offset Table. .*/ + +static CORE_ADDR +lm_base (void) +{ + enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch); + struct minimal_symbol *got_sym; + CORE_ADDR addr; + gdb_byte buf[TIC6X_PTR_SIZE]; + struct dsbt_info *info = get_dsbt_info (); + + /* One of our assumptions is that the main executable has been relocated. + Bail out if this has not happened. (Note that post_create_inferior + in infcmd.c will call solib_add prior to solib_create_inferior_hook. + If we allow this to happen, lm_base_cache will be initialized with + a bogus value. */ + if (info->main_executable_lm_info == 0) + return 0; + + /* If we already have a cached value, return it. */ + if (info->lm_base_cache) + return info->lm_base_cache; + + got_sym = lookup_minimal_symbol ("_GLOBAL_OFFSET_TABLE_", NULL, + symfile_objfile); + + if (got_sym != 0) + { + addr = SYMBOL_VALUE_ADDRESS (got_sym); + if (solib_dsbt_debug) + fprintf_unfiltered (gdb_stdlog, + "lm_base: get addr %x by _GLOBAL_OFFSET_TABLE_.\n", + (unsigned int) addr); + } + else if (scan_dyntag (DT_PLTGOT, exec_bfd, &addr)) + { + struct int_elf32_dsbt_loadmap *ldm; + + dsbt_get_initial_loadmaps (); + ldm = info->exec_loadmap; + addr += displacement_from_map (ldm, addr); + if (solib_dsbt_debug) + fprintf_unfiltered (gdb_stdlog, + "lm_base: get addr %x by DT_PLTGOT.\n", + (unsigned int) addr); + } + else + { + if (solib_dsbt_debug) + fprintf_unfiltered (gdb_stdlog, + "lm_base: _GLOBAL_OFFSET_TABLE_ not found.\n"); + return 0; + } + addr += GOT_MODULE_OFFSET; + + if (solib_dsbt_debug) + fprintf_unfiltered (gdb_stdlog, + "lm_base: _GLOBAL_OFFSET_TABLE_ + %d = %s\n", + GOT_MODULE_OFFSET, hex_string_custom (addr, 8)); + + if (target_read_memory (addr, buf, sizeof buf) != 0) + return 0; + info->lm_base_cache = extract_unsigned_integer (buf, sizeof buf, byte_order); + + if (solib_dsbt_debug) + fprintf_unfiltered (gdb_stdlog, + "lm_base: lm_base_cache = %s\n", + hex_string_custom (info->lm_base_cache, 8)); + + return info->lm_base_cache; +} + + +/* Build a list of `struct so_list' objects describing the shared + objects currently loaded in the inferior. This list does not + include an entry for the main executable file. + + Note that we only gather information directly available from the + inferior --- we don't examine any of the shared library files + themselves. The declaration of `struct so_list' says which fields + we provide values for. */ + +static struct so_list * +dsbt_current_sos (void) +{ + enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch); + CORE_ADDR lm_addr; + struct so_list *sos_head = NULL; + struct so_list **sos_next_ptr = &sos_head; + struct dsbt_info *info = get_dsbt_info (); + + /* Make sure that the main executable has been relocated. This is + required in order to find the address of the global offset table, + which in turn is used to find the link map info. (See lm_base + for details.) + + Note that the relocation of the main executable is also performed + by SOLIB_CREATE_INFERIOR_HOOK, however, in the case of core + files, this hook is called too late in order to be of benefit to + SOLIB_ADD. SOLIB_ADD eventually calls this function, + dsbt_current_sos, and also precedes the call to + SOLIB_CREATE_INFERIOR_HOOK. (See post_create_inferior in + infcmd.c.) */ + if (info->main_executable_lm_info == 0 && core_bfd != NULL) + dsbt_relocate_main_executable (); + + /* Locate the address of the first link map struct. */ + lm_addr = lm_base (); + + /* We have at least one link map entry. Fetch the the lot of them, + building the solist chain. */ + while (lm_addr) + { + struct ext_link_map lm_buf; + ext_Elf32_Word indexword; + CORE_ADDR map_addr; + int dsbt_index; + int ret; + + if (solib_dsbt_debug) + fprintf_unfiltered (gdb_stdlog, + "current_sos: reading link_map entry at %s\n", + hex_string_custom (lm_addr, 8)); + + ret = target_read_memory (lm_addr, (gdb_byte *) &lm_buf, sizeof (lm_buf)); + if (ret) + { + warning (_("dsbt_current_sos: Unable to read link map entry." + " Shared object chain may be incomplete.")); + break; + } + + /* Fetch the load map address. */ + map_addr = extract_unsigned_integer (lm_buf.l_addr.map, + sizeof lm_buf.l_addr.map, + byte_order); + + ret = target_read_memory (map_addr + 12, (gdb_byte *) &indexword, + sizeof indexword); + if (ret) + { + warning (_("dsbt_current_sos: Unable to read dsbt index." + " Shared object chain may be incomplete.")); + break; + } + dsbt_index = extract_unsigned_integer (indexword, sizeof indexword, + byte_order); + + /* If the DSBT index is zero, then we're looking at the entry + for the main executable. By convention, we don't include + this in the list of shared objects. */ + if (dsbt_index != 0) + { + int errcode; + char *name_buf; + struct int_elf32_dsbt_loadmap *loadmap; + struct so_list *sop; + CORE_ADDR addr; + + loadmap = fetch_loadmap (map_addr); + if (loadmap == NULL) + { + warning (_("dsbt_current_sos: Unable to fetch load map." + " Shared object chain may be incomplete.")); + break; + } + + sop = xcalloc (1, sizeof (struct so_list)); + sop->lm_info = xcalloc (1, sizeof (struct lm_info)); + sop->lm_info->map = loadmap; + /* Fetch the name. */ + addr = extract_unsigned_integer (lm_buf.l_name, + sizeof (lm_buf.l_name), + byte_order); + target_read_string (addr, &name_buf, SO_NAME_MAX_PATH_SIZE - 1, + &errcode); + + if (errcode != 0) + warning (_("Can't read pathname for link map entry: %s."), + safe_strerror (errcode)); + else + { + if (solib_dsbt_debug) + fprintf_unfiltered (gdb_stdlog, "current_sos: name = %s\n", + name_buf); + + strncpy (sop->so_name, name_buf, SO_NAME_MAX_PATH_SIZE - 1); + sop->so_name[SO_NAME_MAX_PATH_SIZE - 1] = '\0'; + xfree (name_buf); + strcpy (sop->so_original_name, sop->so_name); + } + + *sos_next_ptr = sop; + sos_next_ptr = &sop->next; + } + else + { + info->main_lm_addr = lm_addr; + } + + lm_addr = extract_unsigned_integer (lm_buf.l_next, + sizeof (lm_buf.l_next), byte_order); + } + + enable_break2 (); + + return sos_head; +} + +/* Return 1 if PC lies in the dynamic symbol resolution code of the + run time loader. */ + +static int +dsbt_in_dynsym_resolve_code (CORE_ADDR pc) +{ + struct dsbt_info *info = get_dsbt_info (); + + return ((pc >= info->interp_text_sect_low && pc < info->interp_text_sect_high) + || (pc >= info->interp_plt_sect_low && pc < info->interp_plt_sect_high) + || in_plt_section (pc, NULL)); +} + +/* Print a warning about being unable to set the dynamic linker + breakpoint. */ + +static void +enable_break_failure_warning (void) +{ + warning (_("Unable to find dynamic linker breakpoint function.\n" + "GDB will be unable to debug shared library initializers\n" + "and track explicitly loaded dynamic code.")); +} + +/* The dynamic linkers has, as part of its debugger interface, support + for arranging for the inferior to hit a breakpoint after mapping in + the shared libraries. This function enables that breakpoint. + + On the TIC6X, using the shared library (DSBT), the symbol + _dl_debug_addr points to the r_debug struct which contains + a field called r_brk. r_brk is the address of the function + descriptor upon which a breakpoint must be placed. Being a + function descriptor, we must extract the entry point in order + to set the breakpoint. + + Our strategy will be to get the .interp section from the + executable. This section will provide us with the name of the + interpreter. We'll open the interpreter and then look up + the address of _dl_debug_addr. We then relocate this address + using the interpreter's loadmap. Once the relocated address + is known, we fetch the value (address) corresponding to r_brk + and then use that value to fetch the entry point of the function + we're interested in. */ + +static int +enable_break2 (void) +{ + enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch); + int success = 0; + char **bkpt_namep; + asection *interp_sect; + struct dsbt_info *info = get_dsbt_info (); + + if (exec_bfd == NULL) + return 0; + + if (!target_has_execution) + return 0; + + if (info->enable_break2_done) + return 1; + + info->interp_text_sect_low = 0; + info->interp_text_sect_high = 0; + info->interp_plt_sect_low = 0; + info->interp_plt_sect_high = 0; + + /* Find the .interp section; if not found, warn the user and drop + into the old breakpoint at symbol code. */ + interp_sect = bfd_get_section_by_name (exec_bfd, ".interp"); + if (interp_sect) + { + unsigned int interp_sect_size; + gdb_byte *buf; + bfd *tmp_bfd = NULL; + int status; + CORE_ADDR addr, interp_loadmap_addr; + gdb_byte addr_buf[TIC6X_PTR_SIZE]; + struct int_elf32_dsbt_loadmap *ldm; + volatile struct gdb_exception ex; + + /* Read the contents of the .interp section into a local buffer; + the contents specify the dynamic linker this program uses. */ + interp_sect_size = bfd_section_size (exec_bfd, interp_sect); + buf = alloca (interp_sect_size); + bfd_get_section_contents (exec_bfd, interp_sect, + buf, 0, interp_sect_size); + + /* Now we need to figure out where the dynamic linker was + loaded so that we can load its symbols and place a breakpoint + in the dynamic linker itself. */ + + TRY_CATCH (ex, RETURN_MASK_ALL) + { + tmp_bfd = solib_bfd_open (buf); + } + if (tmp_bfd == NULL) + { + enable_break_failure_warning (); + return 0; + } + + dsbt_get_initial_loadmaps (); + ldm = info->interp_loadmap; + + /* Record the relocated start and end address of the dynamic linker + text and plt section for dsbt_in_dynsym_resolve_code. */ + interp_sect = bfd_get_section_by_name (tmp_bfd, ".text"); + if (interp_sect) + { + info->interp_text_sect_low + = bfd_section_vma (tmp_bfd, interp_sect); + info->interp_text_sect_low + += displacement_from_map (ldm, info->interp_text_sect_low); + info->interp_text_sect_high + = info->interp_text_sect_low + + bfd_section_size (tmp_bfd, interp_sect); + } + interp_sect = bfd_get_section_by_name (tmp_bfd, ".plt"); + if (interp_sect) + { + info->interp_plt_sect_low = + bfd_section_vma (tmp_bfd, interp_sect); + info->interp_plt_sect_low + += displacement_from_map (ldm, info->interp_plt_sect_low); + info->interp_plt_sect_high = + info->interp_plt_sect_low + bfd_section_size (tmp_bfd, interp_sect); + } + + addr = bfd_lookup_symbol (tmp_bfd, "_dl_debug_addr"); + if (addr == 0) + { + warning (_("Could not find symbol _dl_debug_addr in dynamic linker")); + enable_break_failure_warning (); + bfd_close (tmp_bfd); + return 0; + } + + if (solib_dsbt_debug) + fprintf_unfiltered (gdb_stdlog, + "enable_break: _dl_debug_addr (prior to relocation) = %s\n", + hex_string_custom (addr, 8)); + + addr += displacement_from_map (ldm, addr); + + if (solib_dsbt_debug) + fprintf_unfiltered (gdb_stdlog, + "enable_break: _dl_debug_addr (after relocation) = %s\n", + hex_string_custom (addr, 8)); + + /* Fetch the address of the r_debug struct. */ + if (target_read_memory (addr, addr_buf, sizeof addr_buf) != 0) + { + warning (_("Unable to fetch contents of _dl_debug_addr " + "(at address %s) from dynamic linker"), + hex_string_custom (addr, 8)); + } + addr = extract_unsigned_integer (addr_buf, sizeof addr_buf, byte_order); + + if (solib_dsbt_debug) + fprintf_unfiltered (gdb_stdlog, + "enable_break: _dl_debug_addr[0..3] = %s\n", + hex_string_custom (addr, 8)); + + /* If it's zero, then the ldso hasn't initialized yet, and so + there are no shared libs yet loaded. */ + if (addr == 0) + { + if (solib_dsbt_debug) + fprintf_unfiltered (gdb_stdlog, + "enable_break: ldso not yet initialized\n"); + /* Do not warn, but mark to run again. */ + return 0; + } + + /* Fetch the r_brk field. It's 8 bytes from the start of + _dl_debug_addr. */ + if (target_read_memory (addr + 8, addr_buf, sizeof addr_buf) != 0) + { + warning (_("Unable to fetch _dl_debug_addr->r_brk " + "(at address %s) from dynamic linker"), + hex_string_custom (addr + 8, 8)); + enable_break_failure_warning (); + bfd_close (tmp_bfd); + return 0; + } + addr = extract_unsigned_integer (addr_buf, sizeof addr_buf, byte_order); + + /* We're done with the temporary bfd. */ + bfd_close (tmp_bfd); + + /* We're also done with the loadmap. */ + xfree (ldm); + + /* Remove all the solib event breakpoints. Their addresses + may have changed since the last time we ran the program. */ + remove_solib_event_breakpoints (); + + /* Now (finally!) create the solib breakpoint. */ + create_solib_event_breakpoint (target_gdbarch, addr); + + info->enable_break2_done = 1; + + return 1; + } + + /* Tell the user we couldn't set a dynamic linker breakpoint. */ + enable_break_failure_warning (); + + /* Failure return. */ + return 0; +} + +static int +enable_break (void) +{ + asection *interp_sect; + struct minimal_symbol *start; + + /* Check for the presence of a .interp section. If there is no + such section, the executable is statically linked. */ + + interp_sect = bfd_get_section_by_name (exec_bfd, ".interp"); + + if (interp_sect == NULL) + { + if (solib_dsbt_debug) + fprintf_unfiltered (gdb_stdlog, + "enable_break: No .interp section found.\n"); + return 0; + } + + start = lookup_minimal_symbol ("_start", NULL, symfile_objfile); + if (start == NULL) + { + if (solib_dsbt_debug) + fprintf_unfiltered (gdb_stdlog, + "enable_break: symbol _start is not found.\n"); + return 0; + } + + create_solib_event_breakpoint (target_gdbarch, + SYMBOL_VALUE_ADDRESS (start)); + + if (solib_dsbt_debug) + fprintf_unfiltered (gdb_stdlog, + "enable_break: solib event breakpoint placed at : %s\n", + hex_string_custom (SYMBOL_VALUE_ADDRESS (start), 8)); + return 1; +} + +/* Once the symbols from a shared object have been loaded in the usual + way, we are called to do any system specific symbol handling that + is needed. */ + +static void +dsbt_special_symbol_handling (void) +{ +} + +static void +dsbt_relocate_main_executable (void) +{ + int status; + CORE_ADDR exec_addr, interp_addr; + struct int_elf32_dsbt_loadmap *ldm; + struct cleanup *old_chain; + struct section_offsets *new_offsets; + int changed; + struct obj_section *osect; + struct dsbt_info *info = get_dsbt_info (); + + dsbt_get_initial_loadmaps (); + ldm = info->exec_loadmap; + + xfree (info->main_executable_lm_info); + info->main_executable_lm_info = xcalloc (1, sizeof (struct lm_info)); + info->main_executable_lm_info->map = ldm; + + new_offsets = xcalloc (symfile_objfile->num_sections, + sizeof (struct section_offsets)); + old_chain = make_cleanup (xfree, new_offsets); + changed = 0; + + ALL_OBJFILE_OSECTIONS (symfile_objfile, osect) + { + CORE_ADDR orig_addr, addr, offset; + int osect_idx; + int seg; + + osect_idx = osect->the_bfd_section->index; + + /* Current address of section. */ + addr = obj_section_addr (osect); + /* Offset from where this section started. */ + offset = ANOFFSET (symfile_objfile->section_offsets, osect_idx); + /* Original address prior to any past relocations. */ + orig_addr = addr - offset; + + for (seg = 0; seg < ldm->nsegs; seg++) + { + if (ldm->segs[seg].p_vaddr <= orig_addr + && orig_addr < ldm->segs[seg].p_vaddr + ldm->segs[seg].p_memsz) + { + new_offsets->offsets[osect_idx] + = ldm->segs[seg].addr - ldm->segs[seg].p_vaddr; + + if (new_offsets->offsets[osect_idx] != offset) + changed = 1; + break; + } + } + } + + if (changed) + objfile_relocate (symfile_objfile, new_offsets); + + do_cleanups (old_chain); + + /* Now that symfile_objfile has been relocated, we can compute the + GOT value and stash it away. */ +} + +/* When gdb starts up the inferior, it nurses it along (through the + shell) until it is ready to execute it's first instruction. At this + point, this function gets called via expansion of the macro + SOLIB_CREATE_INFERIOR_HOOK. + + For the DSBT shared library, the main executable needs to be relocated. + The shared library breakpoints also need to be enabled. + */ + +static void +dsbt_solib_create_inferior_hook (int from_tty) +{ + /* Relocate main executable. */ + dsbt_relocate_main_executable (); + + /* Enable shared library breakpoints. */ + if (!enable_break ()) + { + warning (_("shared library handler failed to enable breakpoint")); + return; + } +} + +static void +dsbt_clear_solib (void) +{ + struct dsbt_info *info = get_dsbt_info (); + + info->lm_base_cache = 0; + info->enable_break2_done = 0; + info->main_lm_addr = 0; + if (info->main_executable_lm_info != 0) + { + xfree (info->main_executable_lm_info->map); + xfree (info->main_executable_lm_info); + info->main_executable_lm_info = 0; + } +} + +static void +dsbt_free_so (struct so_list *so) +{ + xfree (so->lm_info->map); + xfree (so->lm_info); +} + +static void +dsbt_relocate_section_addresses (struct so_list *so, + struct target_section *sec) +{ + int seg; + struct int_elf32_dsbt_loadmap *map; + + map = so->lm_info->map; + + for (seg = 0; seg < map->nsegs; seg++) + { + if (map->segs[seg].p_vaddr <= sec->addr + && sec->addr < map->segs[seg].p_vaddr + map->segs[seg].p_memsz) + { + CORE_ADDR displ = map->segs[seg].addr - map->segs[seg].p_vaddr; + + sec->addr += displ; + sec->endaddr += displ; + break; + } + } +} +static void +show_dsbt_debug (struct ui_file *file, int from_tty, + struct cmd_list_element *c, const char *value) +{ + fprintf_filtered (file, _("solib-dsbt debugging is %s.\n"), value); +} + +struct target_so_ops dsbt_so_ops; + +/* Provide a prototype to silence -Wmissing-prototypes. */ +extern initialize_file_ftype _initialize_dsbt_solib; + +void +_initialize_dsbt_solib (void) +{ + solib_dsbt_pspace_data + = register_program_space_data_with_cleanup (dsbt_pspace_data_cleanup); + + dsbt_so_ops.relocate_section_addresses = dsbt_relocate_section_addresses; + dsbt_so_ops.free_so = dsbt_free_so; + dsbt_so_ops.clear_solib = dsbt_clear_solib; + dsbt_so_ops.solib_create_inferior_hook = dsbt_solib_create_inferior_hook; + dsbt_so_ops.special_symbol_handling = dsbt_special_symbol_handling; + dsbt_so_ops.current_sos = dsbt_current_sos; + dsbt_so_ops.open_symbol_file_object = open_symbol_file_object; + dsbt_so_ops.in_dynsym_resolve_code = dsbt_in_dynsym_resolve_code; + dsbt_so_ops.bfd_open = solib_bfd_open; + + /* Debug this file's internals. */ + add_setshow_zinteger_cmd ("solib-dsbt", class_maintenance, + &solib_dsbt_debug, _("\ +Set internal debugging of shared library code for DSBT ELF."), _("\ +Show internal debugging of shared library code for DSBT ELF."), _("\ +When non-zero, DSBT solib specific internal debugging is enabled."), + NULL, + show_dsbt_debug, + &setdebuglist, &showdebuglist); +} diff --git a/gdb/tic6x-linux-tdep.c b/gdb/tic6x-linux-tdep.c new file mode 100644 index 0000000..0e4d327 --- /dev/null +++ b/gdb/tic6x-linux-tdep.c @@ -0,0 +1,227 @@ +/* GNU/Linux on TI C6x target support. + Copyright (C) 2011 + Free Software Foundation, Inc. + Contributed by Yao Qi <yao@codesourcery.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/>. */ + +#include "defs.h" +#include "solib.h" +#include "osabi.h" +#include "linux-tdep.h" +#include "tic6x-tdep.h" +#include "trad-frame.h" +#include "tramp-frame.h" +#include "gdb_assert.h" +#include "elf-bfd.h" +#include "elf/tic6x.h" + +#include "features/tic6x-c64xp-linux.c" +#include "features/tic6x-c64x-linux.c" +#include "features/tic6x-c62x-linux.c" + +/* The offset from rt_sigframe pointer to SP register. */ +#define TIC6X_SP_RT_SIGFRAME 8 +/* Size of struct siginfo info. */ +#define TIC6X_SIGINFO_SIZE 128 +/* Size of type stack_t, which contains three fields of type void*, int, and + size_t respectively. */ +#define TIC6X_STACK_T_SIZE (3 * 4) + +const gdb_byte tic6x_bkpt_illegal_opcode_be[] = { 0x56, 0x45, 0x43, 0x14 }; +const gdb_byte tic6x_bkpt_illegal_opcode_le[] = { 0x14, 0x43, 0x45, 0x56 }; + +static const gdb_byte tic6x_bkpt_bnop_be[] = { 0x00, 0x00, 0xa1, 0x22 }; +static const gdb_byte tic6x_bkpt_bnop_le[] = { 0x22, 0xa1, 0x00, 0x00 }; + +/* Return the offset of register REGNUM in struct sigcontext. Return 0 if no + such register in sigcontext. */ + +static unsigned int +tic6x_register_sigcontext_offset (unsigned int regnum, struct gdbarch *gdbarch) +{ + struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); + + if (regnum == TIC6X_A4_REGNUM || regnum == TIC6X_A4_REGNUM + 2 + || regnum == TIC6X_A4_REGNUM + 4) + return 4 * (regnum - TIC6X_A4_REGNUM + 2); /* A4, A6, A8 */ + else if (regnum == TIC6X_A5_REGNUM || regnum == TIC6X_A5_REGNUM + 2 + || regnum == TIC6X_A5_REGNUM + 4) + return 4 * (regnum - TIC6X_A5_REGNUM + 12); /* A5, A7, A9 */ + else if (regnum == TIC6X_B4_REGNUM || regnum == TIC6X_B4_REGNUM + 2 + || regnum == TIC6X_B4_REGNUM + 4) + return 4 * (regnum - TIC6X_B4_REGNUM + 3); /* B4, B6, B8 */ + else if (regnum == TIC6X_B5_REGNUM || regnum == TIC6X_B5_REGNUM + 2 + || regnum == TIC6X_B5_REGNUM + 4) + return 4 * (regnum - TIC6X_B5_REGNUM + 19); /* B5, B7, B9 */ + else if (regnum >= 0 && regnum < TIC6X_A4_REGNUM) + return 4 * (regnum - 0 + 8); /* A0 - A3 */ + else if (regnum >= TIC6X_B0_REGNUM && regnum < TIC6X_B4_REGNUM) + return 4 * (regnum - TIC6X_B0_REGNUM + 15); /* B0 - B3 */ + else if (regnum >= 34 && regnum < 34 + 32) + return 4 * (regnum - 34 + 23); /* A16 - A31, B16 - B31 */ + else if (regnum == TIC6X_PC_REGNUM) + return 4 * (tdep->has_gp ? 55 : 23); + else if (regnum == TIC6X_SP_REGNUM) + return 4; + + return 0; +} + +/* Support unwinding frame in signal trampoline. We don't check sigreturn, + since it is not used in kernel. */ + +static void +tic6x_linux_rt_sigreturn_init (const struct tramp_frame *self, + struct frame_info *this_frame, + struct trad_frame_cache *this_cache, + CORE_ADDR func) +{ + struct gdbarch *gdbarch = get_frame_arch (this_frame); + CORE_ADDR sp = get_frame_register_unsigned (this_frame, TIC6X_SP_REGNUM); + /* The base of struct sigcontext is computed by examining the definition of + struct rt_sigframe in linux kernel source arch/c6x/kernel/signal.c. */ + CORE_ADDR base = (sp + TIC6X_SP_RT_SIGFRAME + /* Pointer type *pinfo and *puc in struct rt_sigframe. */ + + 4 + 4 + + TIC6X_SIGINFO_SIZE + + 4 + 4 /* uc_flags and *uc_link in struct ucontext. */ + + TIC6X_STACK_T_SIZE); + struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); + unsigned int reg_offset; + unsigned int i; + + for (i = 0; i < 10; i++) /* A0 - A9 */ + { + reg_offset = tic6x_register_sigcontext_offset (i, gdbarch); + gdb_assert (reg_offset != 0); + + trad_frame_set_reg_addr (this_cache, i, base + reg_offset); + } + + for (i = TIC6X_B0_REGNUM; i < TIC6X_B0_REGNUM + 10; i++) /* B0 - B9 */ + { + reg_offset = tic6x_register_sigcontext_offset (i, gdbarch); + gdb_assert (reg_offset != 0); + + trad_frame_set_reg_addr (this_cache, i, base + reg_offset); + } + + if (tdep->has_gp) + for (i = 34; i < 34 + 32; i++) /* A16 - A31, B16 - B31 */ + { + reg_offset = tic6x_register_sigcontext_offset (i, gdbarch); + gdb_assert (reg_offset != 0); + + trad_frame_set_reg_addr (this_cache, i, base + reg_offset); + } + + trad_frame_set_reg_addr (this_cache, TIC6X_PC_REGNUM, + base + tic6x_register_sigcontext_offset (TIC6X_PC_REGNUM, + gdbarch)); + trad_frame_set_reg_addr (this_cache, TIC6X_SP_REGNUM, + base + tic6x_register_sigcontext_offset (TIC6X_SP_REGNUM, + gdbarch)); + + /* Save a frame ID. */ + trad_frame_set_id (this_cache, frame_id_build (sp, func)); +} + +static struct tramp_frame tic6x_linux_rt_sigreturn_tramp_frame = +{ + SIGTRAMP_FRAME, + 4, + { + {0x000045aa, 0x0fffffff}, /* mvk .S2 139,b0 */ + {0x10000000, -1}, /* swe */ + {TRAMP_SENTINEL_INSN} + }, + tic6x_linux_rt_sigreturn_init +}; + +/* When FRAME is at a syscall instruction, return the PC of the next + instruction to be executed. */ + +static CORE_ADDR +tic6x_linux_syscall_next_pc (struct frame_info *frame) +{ + ULONGEST syscall_number = get_frame_register_unsigned (frame, + TIC6X_B0_REGNUM); + CORE_ADDR pc = get_frame_pc (frame); + + if (syscall_number == 139 /* rt_sigreturn */) + return frame_unwind_caller_pc (frame); + + return pc + 4; +} + + +extern struct target_so_ops dsbt_so_ops; +static void +tic6x_uclinux_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch) +{ + struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); + + linux_init_abi (info, gdbarch); + + /* Shared library handling. */ + set_solib_ops (gdbarch, &dsbt_so_ops); + + tdep->syscall_next_pc = tic6x_linux_syscall_next_pc; + +#ifdef HAVE_ELF + /* In tic6x Linux kernel, breakpoint instructions varies on different archs. + On C64x+ and C67x+, breakpoint instruction is 0x56454314, which is an + illegal opcode. On other arch, breakpoint instruction is 0x0000a122 + (BNOP .S2 0,5). */ + if (info.abfd) + switch (bfd_elf_get_obj_attr_int (info.abfd, OBJ_ATTR_PROC, Tag_ISA)) + { + case C6XABI_Tag_ISA_C64XP: + case C6XABI_Tag_ISA_C67XP: + if (info.byte_order == BFD_ENDIAN_BIG) + tdep->breakpoint = tic6x_bkpt_illegal_opcode_be; + else + tdep->breakpoint = tic6x_bkpt_illegal_opcode_le; + break; + default: + { + if (info.byte_order == BFD_ENDIAN_BIG) + tdep->breakpoint = tic6x_bkpt_bnop_be; + else + tdep->breakpoint = tic6x_bkpt_bnop_le; + } + } +#endif + + /* Signal trampoline support. */ + tramp_frame_prepend_unwinder (gdbarch, + &tic6x_linux_rt_sigreturn_tramp_frame); +} + +/* Provide a prototype to silence -Wmissing-prototypes. */ +extern initialize_file_ftype _initialize_tic6x_linux_tdep; + +void +_initialize_tic6x_linux_tdep (void) +{ + gdbarch_register_osabi (bfd_arch_tic6x, 0, GDB_OSABI_LINUX, + tic6x_uclinux_init_abi); + + initialize_tdesc_tic6x_c64xp_linux (); + initialize_tdesc_tic6x_c64x_linux (); + initialize_tdesc_tic6x_c62x_linux (); +} diff --git a/gdb/tic6x-tdep.c b/gdb/tic6x-tdep.c new file mode 100644 index 0000000..eedb5e9 --- /dev/null +++ b/gdb/tic6x-tdep.c @@ -0,0 +1,1386 @@ +/* Target dependent code for GDB on TI C6x systems. + + Copyright (C) 2010, 2011. + Free Software Foundation, Inc. + Contributed by Andrew Jenner <andrew@codesourcery.com> + Contributed by Yao Qi <yao@codesourcery.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/>. */ + +#include "defs.h" +#include "frame.h" +#include "frame-unwind.h" +#include "frame-base.h" +#include "trad-frame.h" +#include "dwarf2-frame.h" +#include "symtab.h" +#include "inferior.h" +#include "gdbtypes.h" +#include "gdbcore.h" +#include "gdbcmd.h" +#include "target.h" +#include "dis-asm.h" +#include "regcache.h" +#include "value.h" +#include "symfile.h" +#include "arch-utils.h" +#include "floatformat.h" +#include "glibc-tdep.h" +#include "infcall.h" +#include "regset.h" +#include "tramp-frame.h" +#include "linux-tdep.h" +#include "solib.h" +#include "objfiles.h" +#include "gdb_assert.h" +#include "osabi.h" +#include "tic6x-tdep.h" +#include "language.h" +#include "target-descriptions.h" + +#include "features/tic6x-c64xp.c" +#include "features/tic6x-c64x.c" +#include "features/tic6x-c62x.c" + +#define TIC6X_OPCODE_SIZE 4 +#define TIC6X_FETCH_PACKET_SIZE 32 + +#define INST_S_BIT(INST) ((INST >> 1) & 1) +#define INST_X_BIT(INST) ((INST >> 12) & 1) + +struct tic6x_unwind_cache +{ + /* The frame's base, optionally used by the high-level debug info. */ + CORE_ADDR base; + + /* The previous frame's inner most stack address. Used as this + frame ID's stack_addr. */ + CORE_ADDR cfa; + + /* The address of the first instruction in this function */ + CORE_ADDR pc; + + /* Which register holds the return address for the frame. */ + int return_regnum; + + /* The offset of register saved on stack. If register is not saved, the + corresponding element is -1. */ + CORE_ADDR reg_saved[TIC6X_NUM_CORE_REGS]; +}; + + +/* Name of TI C6x core registers. */ +static const char *const tic6x_register_names[] = +{ + "A0", "A1", "A2", "A3", /* 0 1 2 3 */ + "A4", "A5", "A6", "A7", /* 4 5 6 7 */ + "A8", "A9", "A10", "A11", /* 8 9 10 11 */ + "A12", "A13", "A14", "A15", /* 12 13 14 15 */ + "B0", "B1", "B2", "B3", /* 16 17 18 19 */ + "B4", "B5", "B6", "B7", /* 20 21 22 23 */ + "B8", "B9", "B10", "B11", /* 24 25 26 27 */ + "B12", "B13", "B14", "B15", /* 28 29 30 31 */ + "CSR", "PC", /* 32 33 */ +}; + +/* This array maps the arguments to the register number which passes argument + in function call according to C6000 ELF ABI. */ +static const int arg_regs[] = { 4, 20, 6, 22, 8, 24, 10, 26, 12, 28 }; + +/* This is the implementation of gdbarch method register_name. */ + +static const char * +tic6x_register_name (struct gdbarch *gdbarch, int regno) +{ + if (regno < 0) + return NULL; + + if (tdesc_has_registers (gdbarch_target_desc (gdbarch))) + return tdesc_register_name (gdbarch, regno); + else if (regno >= ARRAY_SIZE (tic6x_register_names)) + return ""; + else + return tic6x_register_names[regno]; +} + +/* This is the implementation of gdbarch method register_type. */ + +static struct type * +tic6x_register_type (struct gdbarch *gdbarch, int regno) +{ + + if (regno == TIC6X_PC_REGNUM) + return builtin_type (gdbarch)->builtin_func_ptr; + else + return builtin_type (gdbarch)->builtin_uint32; +} + +static void +tic6x_setup_default (struct tic6x_unwind_cache *cache) +{ + int i; + + for (i = 0; i < TIC6X_NUM_CORE_REGS; i++) + cache->reg_saved[i] = -1; +} + +static unsigned long tic6x_fetch_instruction (struct gdbarch *, CORE_ADDR); +static int tic6x_register_number (int reg, int side, int crosspath); + +/* Do a full analysis of the prologue at START_PC and update CACHE accordingly. + Bail out early if CURRENT_PC is reached. Returns the address of the first + instruction after the prologue. */ + +CORE_ADDR +tic6x_analyze_prologue (struct gdbarch *gdbarch, const CORE_ADDR start_pc, + const CORE_ADDR current_pc, + struct tic6x_unwind_cache *cache, + struct frame_info *this_frame) +{ + enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); + unsigned long inst; + unsigned int src_reg, base_reg, dst_reg; + int i; + CORE_ADDR pc = start_pc; + CORE_ADDR return_pc = start_pc; + int frame_base_offset_to_sp = 0; + /* Counter of non-stw instructions after first insn ` sub sp, xxx, sp'. */ + int non_stw_insn_counter = 0; + + if (start_pc >= current_pc) + return_pc = current_pc; + + cache->base = 0; + + /* The landmarks in prologue is one or two SUB instructions to SP. + Instructions on setting up dsbt are in the last part of prologue, if + needed. In maxim, prologue can be divided to three parts by two + `sub sp, xx, sp' insns. */ + + /* Step 1: Look for the 1st and 2nd insn `sub sp, xx, sp', in which, the + 2nd one is optional. */ + while (pc < current_pc) + { + int offset = 0; + + unsigned long inst = tic6x_fetch_instruction (gdbarch, pc); + + if ((inst & 0x1ffc) == 0x1dc0 || (inst & 0x1ffc) == 0x1bc0 + || (inst & 0x0ffc) == 0x9c0) + { + /* SUBAW/SUBAH/SUB, and src1 is ucst 5. */ + unsigned int src2 = tic6x_register_number ((inst >> 18) & 0x1f, + INST_S_BIT (inst), 0); + unsigned int dst = tic6x_register_number ((inst >> 23) & 0x1f, + INST_S_BIT (inst), 0); + + if (src2 == TIC6X_SP_REGNUM && dst == TIC6X_SP_REGNUM) + { + /* Extract const from insn SUBAW/SUBAH/SUB, and translate it to + offset. The constant offset is decoded in bit 13-17 in all + these three kinds of instructions. */ + unsigned int ucst5 = (inst >> 13) & 0x1f; + + if ((inst & 0x1ffc) == 0x1dc0) /* SUBAW */ + frame_base_offset_to_sp += ucst5 << 2; + else if ((inst & 0x1ffc) == 0x1bc0) /* SUBAH */ + frame_base_offset_to_sp += ucst5 << 1; + else if ((inst & 0x0ffc) == 0x9c0) /* SUB */ + frame_base_offset_to_sp += ucst5; + else + gdb_assert_not_reached ("unexpected instruction"); + + return_pc = pc + 4; + } + } + else if ((inst & 0x174) == 0x74) /* stw SRC, *+b15(uconst) */ + { + /* The y bit determines which file base is read from. */ + base_reg = tic6x_register_number ((inst >> 18) & 0x1f, + (inst >> 7) & 1, 0); + + if (base_reg == TIC6X_SP_REGNUM) + { + src_reg = tic6x_register_number ((inst >> 23) & 0x1f, + INST_S_BIT (inst), 0); + + cache->reg_saved[src_reg] = ((inst >> 13) & 0x1f) << 2; + + return_pc = pc + 4; + } + non_stw_insn_counter = 0; + } + else + { + non_stw_insn_counter++; + /* Following instruction sequence may be emitted in prologue: + + <+0>: subah .D2 b15,28,b15 + <+4>: or .L2X 0,a4,b0 + <+8>: || stw .D2T2 b14,*+b15(56) + <+12>:[!b0] b .S1 0xe50e4c1c <sleep+220> + <+16>:|| stw .D2T1 a10,*+b15(48) + <+20>:stw .D2T2 b3,*+b15(52) + <+24>:stw .D2T1 a4,*+b15(40) + + we should look forward for next instruction instead of breaking loop + here. So far, we allow almost two sequential non-stw instructions + in prologue. */ + if (non_stw_insn_counter >= 2) + break; + } + + + pc += 4; + } + /* Step 2: Skip insn on setting up dsbt if it is. Usually, it looks like, + ldw .D2T2 *+b14(0),b14 */ + inst = tic6x_fetch_instruction (gdbarch, pc); + /* The s bit determines which file dst will be loaded into, same effect as + other places. */ + dst_reg = tic6x_register_number ((inst >> 23) & 0x1f, (inst >> 1) & 1, 0); + /* The y bit (bit 7), instead of s bit, determines which file base be + used. */ + base_reg = tic6x_register_number ((inst >> 18) & 0x1f, (inst >> 7) & 1, 0); + + if ((inst & 0x164) == 0x64 /* ldw */ + && dst_reg == TIC6X_DP_REGNUM /* dst is B14 */ + && base_reg == TIC6X_DP_REGNUM) /* baseR is B14 */ + { + return_pc = pc + 4; + } + + if (this_frame) + { + cache->base = get_frame_register_unsigned (this_frame, TIC6X_SP_REGNUM); + + if (cache->reg_saved[TIC6X_FP_REGNUM] != -1) + { + /* If the FP now holds an offset from the CFA then this is a frame + which uses the frame pointer. */ + + cache->cfa = get_frame_register_unsigned (this_frame, + TIC6X_FP_REGNUM); + } + else + { + /* FP doesn't hold an offset from the CFA. If SP still holds an + offset from the CFA then we might be in a function which omits + the frame pointer. */ + + cache->cfa = cache->base + frame_base_offset_to_sp; + } + } + + /* Adjust all the saved registers such that they contain addresses + instead of offsets. */ + for (i = 0; i < TIC6X_NUM_CORE_REGS; i++) + if (cache->reg_saved[i] != -1) + cache->reg_saved[i] = cache->base + cache->reg_saved[i]; + + return return_pc; +} + +/* This is the implementation of gdbarch method skip_prologue. */ + +CORE_ADDR +tic6x_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR start_pc) +{ + CORE_ADDR limit_pc; + CORE_ADDR func_addr; + struct tic6x_unwind_cache cache; + + /* See if we can determine the end of the prologue via the symbol table. + If so, then return either PC, or the PC after the prologue, whichever is + greater. */ + if (find_pc_partial_function (start_pc, NULL, &func_addr, NULL)) + { + CORE_ADDR post_prologue_pc + = skip_prologue_using_sal (gdbarch, func_addr); + if (post_prologue_pc != 0) + return max (start_pc, post_prologue_pc); + } + + /* Can't determine prologue from the symbol table, need to examine + instructions. */ + return tic6x_analyze_prologue (gdbarch, start_pc, (CORE_ADDR) -1, &cache, + NULL); +} + +/* This is the implementation of gdbarch method breakpiont_from_pc. */ + +const unsigned char* +tic6x_breakpoint_from_pc (struct gdbarch *gdbarch, CORE_ADDR *bp_addr, + int *bp_size) +{ + struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); + + *bp_size = 4; + + if (tdep == NULL || tdep->breakpoint == NULL) + { + if (BFD_ENDIAN_BIG == gdbarch_byte_order_for_code (gdbarch)) + return tic6x_bkpt_illegal_opcode_be; + else + return tic6x_bkpt_illegal_opcode_le; + } + else + return tdep->breakpoint; +} + +/* This is the implementation of gdbarch method print_insn. */ + +static int +tic6x_print_insn (bfd_vma memaddr, disassemble_info *info) +{ + return print_insn_tic6x (memaddr, info); +} + +static void +tic6x_dwarf2_frame_init_reg (struct gdbarch *gdbarch, int regnum, + struct dwarf2_frame_state_reg *reg, + struct frame_info *this_frame) +{ + /* Mark the PC as the destination for the return address. */ + if (regnum == gdbarch_pc_regnum (gdbarch)) + reg->how = DWARF2_FRAME_REG_RA; + + /* Mark the stack pointer as the call frame address. */ + else if (regnum == gdbarch_sp_regnum (gdbarch)) + reg->how = DWARF2_FRAME_REG_CFA; + + /* The above was taken from the default init_reg in dwarf2-frame.c + while the below is c6x specific. */ + + /* Callee save registers. The ABI designates A10-A15 and B10-B15 as + callee-save. */ + else if ((regnum >= 10 && regnum <= 15) || (regnum >= 26 && regnum <= 31)) + reg->how = DWARF2_FRAME_REG_SAME_VALUE; + else + /* All other registers are caller-save. */ + reg->how = DWARF2_FRAME_REG_UNDEFINED; +} + +/* This is the implementation of gdbarch method unwind_pc. */ + +static CORE_ADDR +tic6x_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame) +{ + gdb_byte buf[8]; + + frame_unwind_register (next_frame, TIC6X_PC_REGNUM, buf); + return extract_typed_address (buf, builtin_type (gdbarch)->builtin_func_ptr); +} + +/* This is the implementation of gdbarch method unwind_sp. */ + +static CORE_ADDR +tic6x_unwind_sp (struct gdbarch *gdbarch, struct frame_info *this_frame) +{ + return frame_unwind_register_unsigned (this_frame, TIC6X_SP_REGNUM); +} + + +/* Frame base handling. */ + +struct tic6x_unwind_cache* +tic6x_frame_unwind_cache (struct frame_info *this_frame, + void **this_prologue_cache) +{ + struct gdbarch *gdbarch = get_frame_arch (this_frame); + CORE_ADDR current_pc; + struct tic6x_unwind_cache *cache; + int i; + + if (*this_prologue_cache) + return *this_prologue_cache; + + cache = FRAME_OBSTACK_ZALLOC (struct tic6x_unwind_cache); + (*this_prologue_cache) = cache; + + cache->return_regnum = TIC6X_RA_REGNUM; + + tic6x_setup_default (cache); + + cache->pc = get_frame_func (this_frame); + current_pc = get_frame_pc (this_frame); + + /* Prologue analysis does the rest... */ + if (cache->pc != 0) + tic6x_analyze_prologue (gdbarch, cache->pc, current_pc, cache, this_frame); + + return cache; +} + +static void +tic6x_frame_this_id (struct frame_info *this_frame, void **this_cache, + struct frame_id *this_id) +{ + struct tic6x_unwind_cache *cache = + tic6x_frame_unwind_cache (this_frame, this_cache); + + /* This marks the outermost frame. */ + if (cache->base == 0) + return; + + (*this_id) = frame_id_build (cache->cfa, cache->pc); +} + +static struct value * +tic6x_frame_prev_register (struct frame_info *this_frame, void **this_cache, + int regnum) +{ + struct tic6x_unwind_cache *cache = + tic6x_frame_unwind_cache (this_frame, this_cache); + + gdb_assert (regnum >= 0); + + /* The PC of the previous frame is stored in the RA register of + the current frame. Frob regnum so that we pull the value from + the correct place. */ + if (regnum == TIC6X_PC_REGNUM) + regnum = cache->return_regnum; + + if (regnum == TIC6X_SP_REGNUM && cache->cfa) + return frame_unwind_got_constant (this_frame, regnum, cache->cfa); + + /* If we've worked out where a register is stored then load it from + there. */ + if (regnum < TIC6X_NUM_CORE_REGS && cache->reg_saved[regnum] != -1) + return frame_unwind_got_memory (this_frame, regnum, + cache->reg_saved[regnum]); + + return frame_unwind_got_register (this_frame, regnum, regnum); +} + +static CORE_ADDR +tic6x_frame_base_address (struct frame_info *this_frame, void **this_cache) +{ + struct tic6x_unwind_cache *info + = tic6x_frame_unwind_cache (this_frame, this_cache); + return info->base; +} + +static const struct frame_unwind tic6x_frame_unwind = +{ + NORMAL_FRAME, + default_frame_unwind_stop_reason, + tic6x_frame_this_id, + tic6x_frame_prev_register, + NULL, + default_frame_sniffer +}; + +static const struct frame_base tic6x_frame_base = +{ + &tic6x_frame_unwind, + tic6x_frame_base_address, + tic6x_frame_base_address, + tic6x_frame_base_address +}; + + +static struct tic6x_unwind_cache * +tic6x_make_stub_cache (struct frame_info *this_frame) +{ + struct tic6x_unwind_cache *cache; + + cache = FRAME_OBSTACK_ZALLOC (struct tic6x_unwind_cache); + + cache->return_regnum = TIC6X_RA_REGNUM; + + tic6x_setup_default (cache); + + cache->cfa = get_frame_register_unsigned (this_frame, TIC6X_SP_REGNUM); + + return cache; +} + +static void +tic6x_stub_this_id (struct frame_info *this_frame, void **this_cache, + struct frame_id *this_id) +{ + struct tic6x_unwind_cache *cache; + + if (*this_cache == NULL) + *this_cache = tic6x_make_stub_cache (this_frame); + cache = *this_cache; + + *this_id = frame_id_build (cache->cfa, get_frame_pc (this_frame)); +} + +static int +tic6x_stub_unwind_sniffer (const struct frame_unwind *self, + struct frame_info *this_frame, + void **this_prologue_cache) +{ + CORE_ADDR addr_in_block; + + addr_in_block = get_frame_address_in_block (this_frame); + if (in_plt_section (addr_in_block, NULL)) + return 1; + + return 0; +} + +static const struct frame_unwind tic6x_stub_unwind = +{ + NORMAL_FRAME, + default_frame_unwind_stop_reason, + tic6x_stub_this_id, + tic6x_frame_prev_register, + NULL, + tic6x_stub_unwind_sniffer +}; + +/* Return the instruction on address PC. */ + +static unsigned long +tic6x_fetch_instruction (struct gdbarch *gdbarch, CORE_ADDR pc) +{ + enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); + return read_memory_unsigned_integer (pc, TIC6X_OPCODE_SIZE, byte_order); +} + +/* Compute the condition of INST if it is a conditional instruction. Always + return 1 if INST is not a conditional instruction. */ + +static int +tic6x_condition_true (struct frame_info *frame, unsigned long inst) +{ + int register_number; + int register_value; + static const int register_numbers[8] = { -1, 16, 17, 18, 1, 2, 0, -1 }; + + register_number = register_numbers[(inst >> 29) & 7]; + if (register_number == -1) + return 1; + + register_value = get_frame_register_signed (frame, register_number); + if ((inst & 0x10000000) != 0) + return register_value == 0; + return register_value != 0; +} + +/* Get the register number by decoding raw bits REG, SIDE, and CROSSPATH in + instruction. */ + +static int +tic6x_register_number (int reg, int side, int crosspath) +{ + int r = (reg & 15) | ((crosspath ^ side) << 4); + if ((reg & 16) != 0) /* A16 - A31, B16 - B31 */ + r += 37; + return r; +} + +static int +tic6x_extract_signed_field (int value, int low_bit, int bits) +{ + int mask = (1 << bits) - 1; + int r = (value >> low_bit) & mask; + if ((r & (1 << (bits - 1))) != 0) + r -= mask + 1; + return r; +} + +/* Determine where to set a single step breakpoint. */ + +static CORE_ADDR +tic6x_get_next_pc (struct frame_info *frame, CORE_ADDR pc) +{ + struct gdbarch *gdbarch = get_frame_arch (frame); + unsigned long inst; + int offset; + int register_number; + int last = 0; + + do + { + inst = tic6x_fetch_instruction (gdbarch, pc); + + last = !(inst & 1); + + if (inst == TIC6X_INST_SWE) + { + struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); + + if (tdep->syscall_next_pc != NULL) + return tdep->syscall_next_pc (frame); + } + + if (tic6x_condition_true (frame, inst)) + { + if ((inst & 0x0000007c) == 0x00000010) + { + /* B with displacement */ + pc &= ~(TIC6X_FETCH_PACKET_SIZE - 1); + pc += tic6x_extract_signed_field (inst, 7, 21) << 2; + break; + } + if ((inst & 0x0f83effc) == 0x00000360) + { + /* B with register */ + + register_number = tic6x_register_number ((inst >> 18) & 0x1f, + INST_S_BIT (inst), + INST_X_BIT (inst)); + pc = get_frame_register_unsigned (frame, register_number); + break; + } + if ((inst & 0x00001ffc) == 0x00001020) + { + /* BDEC */ + register_number = tic6x_register_number ((inst >> 23) & 0x1f, + INST_S_BIT (inst), 0); + if (get_frame_register_signed (frame, register_number) >= 0) + { + pc &= ~(TIC6X_FETCH_PACKET_SIZE - 1); + pc += tic6x_extract_signed_field (inst, 7, 10) << 2; + } + break; + } + if ((inst & 0x00001ffc) == 0x00000120) + { + /* BNOP with displacement */ + pc &= ~(TIC6X_FETCH_PACKET_SIZE - 1); + pc += tic6x_extract_signed_field (inst, 16, 12) << 2; + break; + } + if ((inst & 0x0f830ffe) == 0x00800362) + { + /* BNOP with register */ + register_number = tic6x_register_number ((inst >> 18) & 0x1f, + 1, INST_X_BIT (inst)); + pc = get_frame_register_unsigned (frame, register_number); + break; + } + if ((inst & 0x00001ffc) == 0x00000020) + { + /* BPOS */ + register_number = tic6x_register_number ((inst >> 23) & 0x1f, + INST_S_BIT (inst), 0); + if (get_frame_register_signed (frame, register_number) >= 0) + { + pc &= ~(TIC6X_FETCH_PACKET_SIZE - 1); + pc += tic6x_extract_signed_field (inst, 13, 10) << 2; + } + break; + } + if ((inst & 0xf000007c) == 0x10000010) + { + /* CALLP */ + pc &= ~(TIC6X_FETCH_PACKET_SIZE - 1); + pc += tic6x_extract_signed_field (inst, 7, 21) << 2; + break; + } + } + pc += TIC6X_OPCODE_SIZE; + } + while (!last); + return pc; +} + +/* This is the implementation of gdbarch method software_single_step. */ + +int +tic6x_software_single_step (struct frame_info *frame) +{ + struct gdbarch *gdbarch = get_frame_arch (frame); + struct address_space *aspace = get_frame_address_space (frame); + CORE_ADDR next_pc = tic6x_get_next_pc (frame, get_frame_pc (frame)); + + insert_single_step_breakpoint (gdbarch, aspace, next_pc); + + return 1; +} + +/* This is the implementation of gdbarch method frame_align. */ + +static CORE_ADDR +tic6x_frame_align (struct gdbarch *gdbarch, CORE_ADDR addr) +{ + return align_down (addr, 8); +} + +/* This is the implementation of gdbarch method register_to_value. */ + +static int +tic6x_register_to_value (struct frame_info *frame, int regnum, + struct type *type, gdb_byte * to, + int *optimizedp, int *unavailablep) +{ + get_frame_register (frame, regnum, (char *) to); + *optimizedp = *unavailablep = 0; + return 1; +} + +/* This is the implementation of gdbarch method value_to_register. */ + +static void +tic6x_value_to_register (struct frame_info *frame, int regnum, + struct type *type, const gdb_byte *from) +{ + put_frame_register (frame, regnum, from); +} + +/* Given a return value in REGCACHE with a type VALTYPE, extract and copy its + value into VALBUF. */ + +static void +tic6x_extract_return_value (struct type *valtype, struct regcache *regcache, + enum bfd_endian byte_order, gdb_byte *valbuf) +{ + int len = TYPE_LENGTH (valtype); + + /* pointer types are returned in register A4, + up to 32-bit types in A4 + up to 64-bit types in A5:A4 */ + if (len <= 4) + { + /* In big-endian, + - one-byte structure or union occupies the LSB of single even register. + - for two-byte structure or union, the first byte occupies byte 1 of + register and the second byte occupies byte 0. + so, we read the contents in VAL from the LSBs of register. */ + if (len < 3 && byte_order == BFD_ENDIAN_BIG) + regcache_cooked_read_part (regcache, TIC6X_A4_REGNUM, 4 - len, len, + valbuf); + else + regcache_cooked_read (regcache, TIC6X_A4_REGNUM, valbuf); + } + else if (len <= 8) + { + /* For a 5-8 byte structure or union in big-endian, the first byte + occupies byte 3 (the MSB) of the upper (odd) register and the + remaining bytes fill the decreasingly significant bytes. 5-7 + byte structures or unions have padding in the LSBs of the + lower (even) register. */ + if (byte_order == BFD_ENDIAN_BIG) + { + regcache_cooked_read (regcache, TIC6X_A4_REGNUM, valbuf + 4); + regcache_cooked_read (regcache, TIC6X_A5_REGNUM, valbuf); + } + else + { + regcache_cooked_read (regcache, TIC6X_A4_REGNUM, valbuf); + regcache_cooked_read (regcache, TIC6X_A5_REGNUM, valbuf + 4); + } + } +} + +/* Write into appropriate registers a function return value + of type TYPE, given in virtual format. */ + +static void +tic6x_store_return_value (struct type *valtype, struct regcache *regcache, + enum bfd_endian byte_order, const gdb_byte *valbuf) +{ + int len = TYPE_LENGTH (valtype); + + /* return values of up to 8 bytes are returned in A5:A4 */ + + if (len <= 4) + { + if (len < 3 && byte_order == BFD_ENDIAN_BIG) + regcache_cooked_write_part (regcache, TIC6X_A4_REGNUM, 4 - len, len, + valbuf); + else + regcache_cooked_write (regcache, TIC6X_A4_REGNUM, valbuf); + } + else if (len <= 8) + { + if (byte_order == BFD_ENDIAN_BIG) + { + regcache_cooked_write (regcache, TIC6X_A4_REGNUM, valbuf + 4); + regcache_cooked_write (regcache, TIC6X_A5_REGNUM, valbuf); + } + else + { + regcache_cooked_write (regcache, TIC6X_A4_REGNUM, valbuf); + regcache_cooked_write (regcache, TIC6X_A5_REGNUM, valbuf + 4); + } + } +} + +/* This is the implementation of gdbarch method return_value. */ + +static enum return_value_convention +tic6x_return_value (struct gdbarch *gdbarch, struct type *func_type, + struct type *type, struct regcache *regcache, + gdb_byte *readbuf, const gdb_byte *writebuf) +{ + if (TYPE_LENGTH (type) > 8) + return RETURN_VALUE_STRUCT_CONVENTION; + + if (readbuf) + tic6x_extract_return_value (type, regcache, + gdbarch_byte_order (gdbarch), readbuf); + if (writebuf) + tic6x_store_return_value (type, regcache, + gdbarch_byte_order (gdbarch), writebuf); + + return RETURN_VALUE_REGISTER_CONVENTION; +} + +/* This is the implementation of gdbarch method dummy_id. */ + +static struct frame_id +tic6x_dummy_id (struct gdbarch *gdbarch, struct frame_info *this_frame) +{ + return frame_id_build + (get_frame_register_unsigned (this_frame, TIC6X_SP_REGNUM), + get_frame_pc (this_frame)); +} + +/* Get the alignment requirement of TYPE. */ + +static int +tic6x_arg_type_alignment (struct type *type) +{ + int len = TYPE_LENGTH (check_typedef (type)); + enum type_code typecode = TYPE_CODE (check_typedef (type)); + + if (typecode == TYPE_CODE_STRUCT || typecode == TYPE_CODE_UNION) + { + /* The stack alignment of a structure (and union) passed by value is the + smallest power of two greater than or equal to its size. + This cannot exceed 8 bytes, which is the largest allowable size for + a structure passed by value. */ + + if (len <= 2) + return len; + else if (len <= 4) + return 4; + else if (len <= 8) + return 8; + else + gdb_assert_not_reached ("unexpected length of data"); + } + else + { + if (len <= 4) + return 4; + else if (len == 8) + { + if (typecode == TYPE_CODE_COMPLEX) + return 4; + else + return 8; + } + else if (len == 16) + { + if (typecode == TYPE_CODE_COMPLEX) + return 8; + else + return 16; + } + else + internal_error (__FILE__, __LINE__, _("unexpected length %d of type"), + len); + } +} + +/* This is the implementation of gdbarch method push_dummy_call. */ + +static CORE_ADDR +tic6x_push_dummy_call (struct gdbarch *gdbarch, struct value *function, + struct regcache *regcache, CORE_ADDR bp_addr, + int nargs, struct value **args, CORE_ADDR sp, + int struct_return, CORE_ADDR struct_addr) +{ + int argreg = 0; + int argnum; + int len = 0; + int stack_offset = 4; + int references_offset = 4; + CORE_ADDR func_addr = find_function_addr (function, NULL); + enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); + struct type *func_type = value_type (function); + /* The first arg passed on stack. Mostly the first 10 args are passed by + registers. */ + int first_arg_on_stack = 10; + /* If this inf-call is a cpp method call, and return value is passed by + reference, this flag is set to 1, otherwise set to 0. We need this flag + because computation of the return location in + infcall.c:call_function_by_hand is wrong for C6000 ELF ABI. In + call_function_by_hand, the language is considered first, and then + target ABI is considered. If language_pass_by_reference returns true, + the return location is passed as the first parameter to the function, + which is conflict with C6000 ELF ABI. If this flag is true, we should + adjust args and return locations accordingly to comply with C6000 ELF + ABI. */ + int cplus_return_struct_by_reference = 0; + + if (current_language->la_language == language_cplus) + { + struct type *values_type; + + find_function_addr (function, &values_type); + + if (values_type) + { + CHECK_TYPEDEF (values_type); + if (language_pass_by_reference (values_type)) + cplus_return_struct_by_reference = 1; + } + + } + /* Set the return address register to point to the entry point of + the program, where a breakpoint lies in wait. */ + regcache_cooked_write_unsigned (regcache, TIC6X_RA_REGNUM, bp_addr); + + /* The caller must pass an argument in A3 containing a destination address + for the returned value. The callee returns the object by copying it to + the address in A3. */ + if (struct_return) + regcache_cooked_write_unsigned (regcache, 3, struct_addr); + else if (cplus_return_struct_by_reference) + /* When cplus_return_struct_by_reference is 1, means local variable + lang_struct_return in call_function_by_hand is 1, so struct is + returned by reference, even STRUCT_RETURN is 0. Note that STRUCT_ADDR + is still valid in this case. */ + regcache_cooked_write_unsigned (regcache, 3, struct_addr); + + /* Determine the type of this function. */ + func_type = check_typedef (func_type); + if (TYPE_CODE (func_type) == TYPE_CODE_PTR) + func_type = check_typedef (TYPE_TARGET_TYPE (func_type)); + + gdb_assert (TYPE_CODE (func_type) == TYPE_CODE_FUNC + || TYPE_CODE (func_type) == TYPE_CODE_METHOD); + + /* For a variadic C function, the last explicitly declared argument and all + remaining arguments are passed on the stack. */ + if (TYPE_VARARGS (func_type)) + first_arg_on_stack = TYPE_NFIELDS (func_type) - 1; + + /* Now make space on the stack for the args. If + cplus_return_struct_by_reference is 1, means GDB pass an extra parameter + in ARGS, which is useless here, skip it. */ + for (argnum = cplus_return_struct_by_reference; argnum < nargs; argnum++) + { + int len = align_up (TYPE_LENGTH (value_type (args[argnum])), 4); + if (argnum >= 10 - argreg) + references_offset += len; + stack_offset += len; + } + sp -= stack_offset; + /* SP should be 8-byte aligned, see C6000 ABI section 4.4.1 + Stack Alignment. */ + sp = align_down (sp, 8); + stack_offset = 4; + + /* Now load as many as possible of the first arguments into + registers, and push the rest onto the stack. Loop through args + from first to last. */ + for (argnum = cplus_return_struct_by_reference; argnum < nargs; argnum++) + { + const gdb_byte *val; + struct value *arg = args[argnum]; + struct type *arg_type = check_typedef (value_type (arg)); + int len = TYPE_LENGTH (arg_type); + enum type_code typecode = TYPE_CODE (arg_type); + + val = value_contents (arg); + + /* Copy the argument to general registers or the stack in + register-sized pieces. */ + if (argreg < first_arg_on_stack) + { + if (len <= 4) + { + if (typecode == TYPE_CODE_STRUCT || typecode == TYPE_CODE_UNION) + { + /* In big-endian, + - one-byte structure or union occupies the LSB of single + even register. + - for two-byte structure or union, the first byte + occupies byte 1 of register and the second byte occupies + byte 0. + so, we write the contents in VAL to the lsp of + register. */ + if (len < 3 && byte_order == BFD_ENDIAN_BIG) + regcache_cooked_write_part (regcache, arg_regs[argreg], + 4 - len, len, val); + else + regcache_cooked_write (regcache, arg_regs[argreg], val); + } + else + { + /* The argument is being passed by value in a single + register. */ + CORE_ADDR regval = extract_unsigned_integer (val, len, + byte_order); + + regcache_cooked_write_unsigned (regcache, arg_regs[argreg], + regval); + } + } + else + { + if (len <= 8) + { + if (typecode == TYPE_CODE_STRUCT + || typecode == TYPE_CODE_UNION) + { + /* For a 5-8 byte structure or union in big-endian, the + first byte occupies byte 3 (the MSB) of the upper (odd) + register and the remaining bytes fill the decreasingly + significant bytes. 5-7 byte structures or unions have + padding in the LSBs of the lower (even) register. */ + if (byte_order == BFD_ENDIAN_BIG) + { + regcache_cooked_write (regcache, + arg_regs[argreg] + 1, val); + regcache_cooked_write_part (regcache, + arg_regs[argreg], 0, + len - 4, val + 4); + } + else + { + regcache_cooked_write (regcache, arg_regs[argreg], + val); + regcache_cooked_write_part (regcache, + arg_regs[argreg] + 1, 0, + len - 4, val + 4); + } + } + else + { + /* The argument is being passed by value in a pair of + registers. */ + ULONGEST regval = extract_unsigned_integer (val, len, + byte_order); + + regcache_cooked_write_unsigned (regcache, + arg_regs[argreg], + regval); + regcache_cooked_write_unsigned (regcache, + arg_regs[argreg] + 1, + regval >> 32); + } + } + else + { + /* The argument is being passed by reference in a single + register. */ + CORE_ADDR addr; + + /* It is not necessary to adjust REFERENCES_OFFSET to + 8-byte aligned in some cases, in which 4-byte alignment + is sufficient. For simplicity, we adjust + REFERENCES_OFFSET to 8-byte aligned. */ + references_offset = align_up (references_offset, 8); + + addr = sp + references_offset; + write_memory (addr, val, len); + references_offset += align_up (len, 4); + regcache_cooked_write_unsigned (regcache, arg_regs[argreg], + addr); + } + } + argreg++; + } + else + { + /* The argument is being passed on the stack. */ + CORE_ADDR addr; + + /* There are six different cases of alignment, and these rules can + be found in tic6x_arg_type_alignment: + + 1) 4-byte aligned if size is less than or equal to 4 byte, such + as short, int, struct, union etc. + 2) 8-byte aligned if size is less than or equal to 8-byte, such + as double, long long, + 3) 4-byte aligned if it is of type _Complex float, even its size + is 8-byte. + 4) 8-byte aligned if it is of type _Complex double or _Complex + long double, even its size is 16-byte. Because, the address of + variable is passed as reference. + 5) struct and union larger than 8-byte are passed by reference, so + it is 4-byte aligned. + 6) struct and union of size between 4 byte and 8 byte varies. + alignment of struct variable is the alignment of its first field, + while alignment of union variable is the max of all its fields' + alignment. */ + + if (len <= 4) + ; /* Default is 4-byte aligned. Nothing to be done. */ + else if (len <= 8) + stack_offset = align_up (stack_offset, + tic6x_arg_type_alignment (arg_type)); + else if (len == 16) + { + /* _Complex double or _Complex long double */ + if (typecode == TYPE_CODE_COMPLEX) + { + /* The argument is being passed by reference on stack. */ + CORE_ADDR addr; + references_offset = align_up (references_offset, 8); + + addr = sp + references_offset; + /* Store variable on stack. */ + write_memory (addr, val, len); + + references_offset += align_up (len, 4); + + /* Pass the address of variable on stack as reference. */ + store_unsigned_integer ((gdb_byte *) val, 4, byte_order, + addr); + len = 4; + + } + else + internal_error (__FILE__, __LINE__, + _("unexpected type %d of arg %d"), + typecode, argnum); + } + else + internal_error (__FILE__, __LINE__, + _("unexpected length %d of arg %d"), len, argnum); + + addr = sp + stack_offset; + write_memory (addr, val, len); + stack_offset += align_up (len, 4); + } + } + + regcache_cooked_write_signed (regcache, TIC6X_SP_REGNUM, sp); + + /* Return adjusted stack pointer. */ + return sp; +} + +/* This is the implementation of gdbarch method in_function_epilogue_p. */ + +static int +tic6x_in_function_epilogue_p (struct gdbarch *gdbarch, CORE_ADDR pc) +{ + unsigned long inst = tic6x_fetch_instruction (gdbarch, pc); + /* Normally, the epilogue is composed by instruction `b .S2 b3'. */ + if ((inst & 0x0f83effc) == 0x360) + { + unsigned int src2 = tic6x_register_number ((inst >> 18) & 0x1f, + INST_S_BIT (inst), + INST_X_BIT (inst)); + if (src2 == TIC6X_RA_REGNUM) + return 1; + } + + return 0; +} + +/* This is the implementation of gdbarch method get_longjmp_target. */ + +static int +tic6x_get_longjmp_target (struct frame_info *frame, CORE_ADDR *pc) +{ + struct gdbarch *gdbarch = get_frame_arch (frame); + enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); + CORE_ADDR jb_addr; + char buf[4]; + + /* JMP_BUF is passed by reference in A4. */ + jb_addr = get_frame_register_unsigned (frame, 4); + + /* JMP_BUF contains 13 elements of type int, and return address is stored + in the last slot. */ + if (target_read_memory (jb_addr + 12 * 4, buf, 4)) + return 0; + + *pc = extract_unsigned_integer (buf, 4, byte_order); + + return 1; +} + +static struct gdbarch * +tic6x_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches) +{ + struct gdbarch *gdbarch; + struct gdbarch_tdep *tdep; + struct tdesc_arch_data *tdesc_data = NULL; + const struct target_desc *tdesc = info.target_desc; + int has_gp = 0; + + /* Check any target description for validity. */ + if (tdesc_has_registers (tdesc)) + { + const struct tdesc_feature *feature; + int valid_p, i; + + feature = tdesc_find_feature (tdesc, "org.gnu.gdb.tic6x.core"); + + if (feature == NULL) + return NULL; + + tdesc_data = tdesc_data_alloc (); + + valid_p = 1; + for (i = 0; i < 32; i++) /* A0 - A15, B0 - B15 */ + valid_p &= tdesc_numbered_register (feature, tdesc_data, i, + tic6x_register_names[i]); + + /* CSR */ + valid_p &= tdesc_numbered_register (feature, tdesc_data, i++, + tic6x_register_names[TIC6X_CSR_REGNUM]); + valid_p &= tdesc_numbered_register (feature, tdesc_data, i++, + tic6x_register_names[TIC6X_PC_REGNUM]); + + if (!valid_p) + { + tdesc_data_cleanup (tdesc_data); + return NULL; + } + + feature = tdesc_find_feature (tdesc, "org.gnu.gdb.tic6x.gp"); + if (feature) + { + int j = 0; + static const char *const gp[] = + { + "A16", "A17", "A18", "A19", "A20", "A21", "A22", "A23", + "A24", "A25", "A26", "A27", "A28", "A29", "A30", "A31", + "B16", "B17", "B18", "B19", "B20", "B21", "B22", "B23", + "B24", "B25", "B26", "B27", "B28", "B29", "B30", "B31", + }; + + has_gp = 1; + valid_p = 1; + for (j = 0; j < 32; j++) /* A16 - A31, B16 - B31 */ + valid_p &= tdesc_numbered_register (feature, tdesc_data, i++, + gp[j]); + + if (!valid_p) + { + tdesc_data_cleanup (tdesc_data); + return NULL; + } + } + + feature = tdesc_find_feature (tdesc, "org.gnu.gdb.tic6x.c6xp"); + if (feature) + { + valid_p &= tdesc_numbered_register (feature, tdesc_data, i++, "TSR"); + valid_p &= tdesc_numbered_register (feature, tdesc_data, i++, "ILC"); + valid_p &= tdesc_numbered_register (feature, tdesc_data, i++, "RILC"); + + if (!valid_p) + { + tdesc_data_cleanup (tdesc_data); + return NULL; + } + } + + } + + /* Find a candidate among extant architectures. */ + for (arches = gdbarch_list_lookup_by_info (arches, &info); + arches != NULL; + arches = gdbarch_list_lookup_by_info (arches->next, &info)) + { + tdep = gdbarch_tdep (arches->gdbarch); + + if (has_gp != tdep->has_gp) + continue; + + if (tdep && tdep->breakpoint) + return arches->gdbarch; + } + + tdep = xcalloc (1, sizeof (struct gdbarch_tdep)); + + tdep->has_gp = has_gp; + gdbarch = gdbarch_alloc (&info, tdep); + + /* Data type sizes. */ + set_gdbarch_ptr_bit (gdbarch, 32); + set_gdbarch_addr_bit (gdbarch, 32); + set_gdbarch_short_bit (gdbarch, 16); + set_gdbarch_int_bit (gdbarch, 32); + set_gdbarch_long_bit (gdbarch, 32); + set_gdbarch_long_long_bit (gdbarch, 64); + set_gdbarch_float_bit (gdbarch, 32); + set_gdbarch_double_bit (gdbarch, 64); + + set_gdbarch_float_format (gdbarch, floatformats_ieee_single); + set_gdbarch_double_format (gdbarch, floatformats_ieee_double); + + /* The register set. */ + set_gdbarch_num_regs (gdbarch, TIC6X_NUM_REGS); + set_gdbarch_sp_regnum (gdbarch, TIC6X_SP_REGNUM); + set_gdbarch_pc_regnum (gdbarch, TIC6X_PC_REGNUM); + + set_gdbarch_register_name (gdbarch, tic6x_register_name); + set_gdbarch_register_type (gdbarch, tic6x_register_type); + + set_gdbarch_inner_than (gdbarch, core_addr_lessthan); + + set_gdbarch_skip_prologue (gdbarch, tic6x_skip_prologue); + set_gdbarch_breakpoint_from_pc (gdbarch, tic6x_breakpoint_from_pc); + + set_gdbarch_unwind_pc (gdbarch, tic6x_unwind_pc); + set_gdbarch_unwind_sp (gdbarch, tic6x_unwind_sp); + + /* Unwinding. */ + dwarf2_append_unwinders (gdbarch); + + frame_unwind_append_unwinder (gdbarch, &tic6x_stub_unwind); + frame_unwind_append_unwinder (gdbarch, &tic6x_frame_unwind); + + dwarf2_frame_set_init_reg (gdbarch, tic6x_dwarf2_frame_init_reg); + + /* Single stepping. */ + set_gdbarch_software_single_step (gdbarch, tic6x_software_single_step); + + set_gdbarch_print_insn (gdbarch, tic6x_print_insn); + + /* Call dummy code. */ + set_gdbarch_frame_align (gdbarch, tic6x_frame_align); + + set_gdbarch_register_to_value (gdbarch, tic6x_register_to_value); + set_gdbarch_value_to_register (gdbarch, tic6x_value_to_register); + + set_gdbarch_return_value (gdbarch, tic6x_return_value); + + set_gdbarch_dummy_id (gdbarch, tic6x_dummy_id); + + /* Enable inferior call support. */ + set_gdbarch_push_dummy_call (gdbarch, tic6x_push_dummy_call); + + set_gdbarch_get_longjmp_target (gdbarch, tic6x_get_longjmp_target); + + set_gdbarch_in_function_epilogue_p (gdbarch, tic6x_in_function_epilogue_p); + + /* Hook in ABI-specific overrides, if they have been registered. */ + gdbarch_init_osabi (info, gdbarch); + + if (tdesc_data) + tdesc_use_registers (gdbarch, tdesc, tdesc_data); + + return gdbarch; +} + +void +_initialize_tic6x_tdep (void) +{ + register_gdbarch_init (bfd_arch_tic6x, tic6x_gdbarch_init); + + initialize_tdesc_tic6x_c64xp (); + initialize_tdesc_tic6x_c64x (); + initialize_tdesc_tic6x_c62x (); +} diff --git a/gdb/tic6x-tdep.h b/gdb/tic6x-tdep.h new file mode 100644 index 0000000..0227572 --- /dev/null +++ b/gdb/tic6x-tdep.h @@ -0,0 +1,54 @@ +/* GNU/Linux on TI C6x target support. + Copyright (C) 2011 + Free Software Foundation, Inc. + Contributed by Yao Qi <yao@codesourcery.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/>. */ + +enum +{ + TIC6X_A4_REGNUM = 4, + TIC6X_A5_REGNUM = 5, + TIC6X_FP_REGNUM = 15, /* Frame Pointer: A15 */ + TIC6X_B0_REGNUM = 16, + TIC6X_RA_REGNUM = 19, /* Return address: B3 */ + TIC6X_B4_REGNUM = 20, + TIC6X_B5_REGNUM = 21, + TIC6X_DP_REGNUM = 30, /* Data Page Pointer: B14 */ + TIC6X_SP_REGNUM = 31, /* Stack Pointer: B15 */ + TIC6X_CSR_REGNUM = 32, + TIC6X_PC_REGNUM = 33, + TIC6X_NUM_CORE_REGS = 33, /* The number of core registers */ + TIC6X_RILC_REGNUM = 68, + TIC6X_NUM_REGS /* The number of registers */ +}; + +#define TIC6X_INST_SWE 0x10000000 + +extern const gdb_byte tic6x_bkpt_illegal_opcode_be[]; +extern const gdb_byte tic6x_bkpt_illegal_opcode_le[]; + +/* Target-dependent structure in gdbarch. */ +struct gdbarch_tdep +{ + /* Return the expected next PC if FRAME is stopped at a syscall + instruction. */ + CORE_ADDR (*syscall_next_pc) (struct frame_info *frame); + + const char *breakpoint; /* Breakpoint instruction. */ + + int has_gp; /* Has general purpose registers A16 - A31 and B16 - B31. */ +}; |