123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032 |
- /* Target-dependent code for the Tilera TILE-Gx processor.
- Copyright (C) 2012-2022 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 "frame.h"
- #include "frame-base.h"
- #include "frame-unwind.h"
- #include "dwarf2/frame.h"
- #include "trad-frame.h"
- #include "symtab.h"
- #include "gdbtypes.h"
- #include "gdbcmd.h"
- #include "gdbcore.h"
- #include "value.h"
- #include "dis-asm.h"
- #include "inferior.h"
- #include "arch-utils.h"
- #include "regcache.h"
- #include "regset.h"
- #include "osabi.h"
- #include "linux-tdep.h"
- #include "objfiles.h"
- #include "solib-svr4.h"
- #include "tilegx-tdep.h"
- #include "opcode/tilegx.h"
- #include <algorithm>
- #include "gdbsupport/byte-vector.h"
- struct tilegx_frame_cache
- {
- /* Base address. */
- CORE_ADDR base;
- /* Function start. */
- CORE_ADDR start_pc;
- /* Table of saved registers. */
- trad_frame_saved_reg *saved_regs;
- };
- /* Register state values used by analyze_prologue. */
- enum reverse_state
- {
- REVERSE_STATE_REGISTER,
- REVERSE_STATE_VALUE,
- REVERSE_STATE_UNKNOWN
- };
- /* Register state used by analyze_prologue(). */
- struct tilegx_reverse_regs
- {
- LONGEST value;
- enum reverse_state state;
- };
- static const struct tilegx_reverse_regs
- template_reverse_regs[TILEGX_NUM_PHYS_REGS] =
- {
- { TILEGX_R0_REGNUM, REVERSE_STATE_REGISTER },
- { TILEGX_R1_REGNUM, REVERSE_STATE_REGISTER },
- { TILEGX_R2_REGNUM, REVERSE_STATE_REGISTER },
- { TILEGX_R3_REGNUM, REVERSE_STATE_REGISTER },
- { TILEGX_R4_REGNUM, REVERSE_STATE_REGISTER },
- { TILEGX_R5_REGNUM, REVERSE_STATE_REGISTER },
- { TILEGX_R6_REGNUM, REVERSE_STATE_REGISTER },
- { TILEGX_R7_REGNUM, REVERSE_STATE_REGISTER },
- { TILEGX_R8_REGNUM, REVERSE_STATE_REGISTER },
- { TILEGX_R9_REGNUM, REVERSE_STATE_REGISTER },
- { TILEGX_R10_REGNUM, REVERSE_STATE_REGISTER },
- { TILEGX_R11_REGNUM, REVERSE_STATE_REGISTER },
- { TILEGX_R12_REGNUM, REVERSE_STATE_REGISTER },
- { TILEGX_R13_REGNUM, REVERSE_STATE_REGISTER },
- { TILEGX_R14_REGNUM, REVERSE_STATE_REGISTER },
- { TILEGX_R15_REGNUM, REVERSE_STATE_REGISTER },
- { TILEGX_R16_REGNUM, REVERSE_STATE_REGISTER },
- { TILEGX_R17_REGNUM, REVERSE_STATE_REGISTER },
- { TILEGX_R18_REGNUM, REVERSE_STATE_REGISTER },
- { TILEGX_R19_REGNUM, REVERSE_STATE_REGISTER },
- { TILEGX_R20_REGNUM, REVERSE_STATE_REGISTER },
- { TILEGX_R21_REGNUM, REVERSE_STATE_REGISTER },
- { TILEGX_R22_REGNUM, REVERSE_STATE_REGISTER },
- { TILEGX_R23_REGNUM, REVERSE_STATE_REGISTER },
- { TILEGX_R24_REGNUM, REVERSE_STATE_REGISTER },
- { TILEGX_R25_REGNUM, REVERSE_STATE_REGISTER },
- { TILEGX_R26_REGNUM, REVERSE_STATE_REGISTER },
- { TILEGX_R27_REGNUM, REVERSE_STATE_REGISTER },
- { TILEGX_R28_REGNUM, REVERSE_STATE_REGISTER },
- { TILEGX_R29_REGNUM, REVERSE_STATE_REGISTER },
- { TILEGX_R30_REGNUM, REVERSE_STATE_REGISTER },
- { TILEGX_R31_REGNUM, REVERSE_STATE_REGISTER },
- { TILEGX_R32_REGNUM, REVERSE_STATE_REGISTER },
- { TILEGX_R33_REGNUM, REVERSE_STATE_REGISTER },
- { TILEGX_R34_REGNUM, REVERSE_STATE_REGISTER },
- { TILEGX_R35_REGNUM, REVERSE_STATE_REGISTER },
- { TILEGX_R36_REGNUM, REVERSE_STATE_REGISTER },
- { TILEGX_R37_REGNUM, REVERSE_STATE_REGISTER },
- { TILEGX_R38_REGNUM, REVERSE_STATE_REGISTER },
- { TILEGX_R39_REGNUM, REVERSE_STATE_REGISTER },
- { TILEGX_R40_REGNUM, REVERSE_STATE_REGISTER },
- { TILEGX_R41_REGNUM, REVERSE_STATE_REGISTER },
- { TILEGX_R42_REGNUM, REVERSE_STATE_REGISTER },
- { TILEGX_R43_REGNUM, REVERSE_STATE_REGISTER },
- { TILEGX_R44_REGNUM, REVERSE_STATE_REGISTER },
- { TILEGX_R45_REGNUM, REVERSE_STATE_REGISTER },
- { TILEGX_R46_REGNUM, REVERSE_STATE_REGISTER },
- { TILEGX_R47_REGNUM, REVERSE_STATE_REGISTER },
- { TILEGX_R48_REGNUM, REVERSE_STATE_REGISTER },
- { TILEGX_R49_REGNUM, REVERSE_STATE_REGISTER },
- { TILEGX_R50_REGNUM, REVERSE_STATE_REGISTER },
- { TILEGX_R51_REGNUM, REVERSE_STATE_REGISTER },
- { TILEGX_R52_REGNUM, REVERSE_STATE_REGISTER },
- { TILEGX_TP_REGNUM, REVERSE_STATE_REGISTER },
- { TILEGX_SP_REGNUM, REVERSE_STATE_REGISTER },
- { TILEGX_LR_REGNUM, REVERSE_STATE_REGISTER },
- { 0, REVERSE_STATE_UNKNOWN },
- { 0, REVERSE_STATE_UNKNOWN },
- { 0, REVERSE_STATE_UNKNOWN },
- { 0, REVERSE_STATE_UNKNOWN },
- { 0, REVERSE_STATE_UNKNOWN },
- { 0, REVERSE_STATE_UNKNOWN },
- { 0, REVERSE_STATE_UNKNOWN },
- { TILEGX_ZERO_REGNUM, REVERSE_STATE_VALUE }
- };
- /* Implement the "register_name" gdbarch method. */
- static const char *
- tilegx_register_name (struct gdbarch *gdbarch, int regnum)
- {
- static const char *const register_names[TILEGX_NUM_REGS] =
- {
- "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
- "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
- "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
- "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31",
- "r32", "r33", "r34", "r35", "r36", "r37", "r38", "r39",
- "r40", "r41", "r42", "r43", "r44", "r45", "r46", "r47",
- "r48", "r49", "r50", "r51", "r52", "tp", "sp", "lr",
- "sn", "idn0", "idn1", "udn0", "udn1", "udn2", "udn3", "zero",
- "pc", "faultnum",
- };
- if (regnum < 0 || regnum >= TILEGX_NUM_REGS)
- internal_error (__FILE__, __LINE__,
- "tilegx_register_name: invalid register number %d",
- regnum);
- return register_names[regnum];
- }
- /* This is the implementation of gdbarch method register_type. */
- static struct type *
- tilegx_register_type (struct gdbarch *gdbarch, int regnum)
- {
- if (regnum == TILEGX_PC_REGNUM)
- return builtin_type (gdbarch)->builtin_func_ptr;
- else
- return builtin_type (gdbarch)->builtin_uint64;
- }
- /* This is the implementation of gdbarch method dwarf2_reg_to_regnum. */
- static int
- tilegx_dwarf2_reg_to_regnum (struct gdbarch *gdbarch, int num)
- {
- return num;
- }
- /* Makes the decision of whether a given type is a scalar type.
- Scalar types are returned in the registers r2-r11 as they fit. */
- static int
- tilegx_type_is_scalar (struct type *t)
- {
- return (t->code () != TYPE_CODE_STRUCT
- && t->code () != TYPE_CODE_UNION
- && t->code () != TYPE_CODE_ARRAY);
- }
- /* Returns non-zero if the given struct type will be returned using
- a special convention, rather than the normal function return method.
- Used in the context of the "return" command, and target function
- calls from the debugger. */
- static int
- tilegx_use_struct_convention (struct type *type)
- {
- /* Only scalars which fit in R0 - R9 can be returned in registers.
- Otherwise, they are returned via a pointer passed in R0. */
- return (!tilegx_type_is_scalar (type)
- && (TYPE_LENGTH (type) > (1 + TILEGX_R9_REGNUM - TILEGX_R0_REGNUM)
- * tilegx_reg_size));
- }
- /* Find a function's return value in the appropriate registers (in
- REGCACHE), and copy it into VALBUF. */
- static void
- tilegx_extract_return_value (struct type *type, struct regcache *regcache,
- gdb_byte *valbuf)
- {
- int len = TYPE_LENGTH (type);
- int i, regnum = TILEGX_R0_REGNUM;
- for (i = 0; i < len; i += tilegx_reg_size)
- regcache->raw_read (regnum++, valbuf + i);
- }
- /* Copy the function return value from VALBUF into the proper
- location for a function return.
- Called only in the context of the "return" command. */
- static void
- tilegx_store_return_value (struct type *type, struct regcache *regcache,
- const void *valbuf)
- {
- if (TYPE_LENGTH (type) < tilegx_reg_size)
- {
- /* Add leading zeros to the (little-endian) value. */
- gdb_byte buf[tilegx_reg_size] = { 0 };
- memcpy (buf, valbuf, TYPE_LENGTH (type));
- regcache->raw_write (TILEGX_R0_REGNUM, buf);
- }
- else
- {
- int len = TYPE_LENGTH (type);
- int i, regnum = TILEGX_R0_REGNUM;
- for (i = 0; i < len; i += tilegx_reg_size)
- regcache->raw_write (regnum++, (gdb_byte *) valbuf + i);
- }
- }
- /* This is the implementation of gdbarch method return_value. */
- static enum return_value_convention
- tilegx_return_value (struct gdbarch *gdbarch, struct value *function,
- struct type *type, struct regcache *regcache,
- gdb_byte *readbuf, const gdb_byte *writebuf)
- {
- if (tilegx_use_struct_convention (type))
- return RETURN_VALUE_STRUCT_CONVENTION;
- if (writebuf)
- tilegx_store_return_value (type, regcache, writebuf);
- else if (readbuf)
- tilegx_extract_return_value (type, regcache, readbuf);
- return RETURN_VALUE_REGISTER_CONVENTION;
- }
- /* This is the implementation of gdbarch method frame_align. */
- static CORE_ADDR
- tilegx_frame_align (struct gdbarch *gdbarch, CORE_ADDR addr)
- {
- return addr & -8;
- }
- /* Implement the "push_dummy_call" gdbarch method. */
- static CORE_ADDR
- tilegx_push_dummy_call (struct gdbarch *gdbarch,
- struct value *function,
- struct regcache *regcache,
- CORE_ADDR bp_addr, int nargs,
- struct value **args,
- CORE_ADDR sp, function_call_return_method return_method,
- CORE_ADDR struct_addr)
- {
- enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
- CORE_ADDR stack_dest = sp;
- int argreg = TILEGX_R0_REGNUM;
- int i, j;
- int typelen, slacklen;
- static const gdb_byte four_zero_words[16] = { 0 };
- /* If struct_return is 1, then the struct return address will
- consume one argument-passing register. */
- if (return_method == return_method_struct)
- regcache_cooked_write_unsigned (regcache, argreg++, struct_addr);
- /* Arguments are passed in R0 - R9, and as soon as an argument
- will not fit completely in the remaining registers, then it,
- and all remaining arguments, are put on the stack. */
- for (i = 0; i < nargs && argreg <= TILEGX_R9_REGNUM; i++)
- {
- const gdb_byte *val;
- typelen = TYPE_LENGTH (value_enclosing_type (args[i]));
- if (typelen > (TILEGX_R9_REGNUM - argreg + 1) * tilegx_reg_size)
- break;
- /* Put argument into registers wordwise. */
- val = value_contents (args[i]).data ();
- for (j = 0; j < typelen; j += tilegx_reg_size)
- {
- /* ISSUE: Why special handling for "typelen = 4x + 1"?
- I don't ever see "typelen" values except 4 and 8. */
- int n = (typelen - j == 1) ? 1 : tilegx_reg_size;
- ULONGEST w = extract_unsigned_integer (val + j, n, byte_order);
- regcache_cooked_write_unsigned (regcache, argreg++, w);
- }
- }
- /* Align SP. */
- stack_dest = tilegx_frame_align (gdbarch, stack_dest);
- /* Loop backwards through remaining arguments and push them on
- the stack, word aligned. */
- for (j = nargs - 1; j >= i; j--)
- {
- const gdb_byte *contents = value_contents (args[j]).data ();
- typelen = TYPE_LENGTH (value_enclosing_type (args[j]));
- slacklen = align_up (typelen, 8) - typelen;
- gdb::byte_vector val (typelen + slacklen);
- memcpy (val.data (), contents, typelen);
- memset (val.data () + typelen, 0, slacklen);
- /* Now write data to the stack. The stack grows downwards. */
- stack_dest -= typelen + slacklen;
- write_memory (stack_dest, val.data (), typelen + slacklen);
- }
- /* Add 16 bytes for linkage space to the stack. */
- stack_dest = stack_dest - 16;
- write_memory (stack_dest, four_zero_words, 16);
- /* Update stack pointer. */
- regcache_cooked_write_unsigned (regcache, TILEGX_SP_REGNUM, stack_dest);
- /* 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, TILEGX_LR_REGNUM, bp_addr);
- return stack_dest;
- }
- /* Decode the instructions within the given address range.
- Decide when we must have reached the end of the function prologue.
- If a frame_info pointer is provided, fill in its saved_regs etc.
- Returns the address of the first instruction after the prologue.
- NOTE: This is often called with start_addr being the start of some
- function, and end_addr being the current PC. */
- static CORE_ADDR
- tilegx_analyze_prologue (struct gdbarch* gdbarch,
- CORE_ADDR start_addr, CORE_ADDR end_addr,
- struct tilegx_frame_cache *cache,
- struct frame_info *next_frame)
- {
- enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
- CORE_ADDR next_addr;
- CORE_ADDR prolog_end = end_addr;
- gdb_byte instbuf[32 * TILEGX_BUNDLE_SIZE_IN_BYTES];
- CORE_ADDR instbuf_start;
- unsigned int instbuf_size;
- int status;
- bfd_uint64_t bundle;
- struct tilegx_decoded_instruction
- decoded[TILEGX_MAX_INSTRUCTIONS_PER_BUNDLE];
- int num_insns;
- struct tilegx_reverse_regs reverse_frame[TILEGX_NUM_PHYS_REGS];
- struct tilegx_reverse_regs
- new_reverse_frame[TILEGX_MAX_INSTRUCTIONS_PER_BUNDLE];
- int dest_regs[TILEGX_MAX_INSTRUCTIONS_PER_BUNDLE];
- int reverse_frame_valid, prolog_done, branch_seen, lr_saved_on_stack_p;
- LONGEST prev_sp_value;
- int i, j;
- if (start_addr >= end_addr
- || (start_addr % TILEGX_BUNDLE_ALIGNMENT_IN_BYTES) != 0)
- return end_addr;
- /* Initialize the reverse frame. This maps the CURRENT frame's
- registers to the outer frame's registers (the frame on the
- stack goes the other way). */
- memcpy (&reverse_frame, &template_reverse_regs, sizeof (reverse_frame));
- prolog_done = 0;
- branch_seen = 0;
- prev_sp_value = 0;
- lr_saved_on_stack_p = 0;
- /* To cut down on round-trip overhead, we fetch multiple bundles
- at once. These variables describe the range of memory we have
- prefetched. */
- instbuf_start = 0;
- instbuf_size = 0;
- for (next_addr = start_addr;
- next_addr < end_addr;
- next_addr += TILEGX_BUNDLE_SIZE_IN_BYTES)
- {
- /* Retrieve the next instruction. */
- if (next_addr - instbuf_start >= instbuf_size)
- {
- /* Figure out how many bytes to fetch. Don't span a page
- boundary since that might cause an unnecessary memory
- error. */
- unsigned int size_on_same_page = 4096 - (next_addr & 4095);
- instbuf_size = sizeof instbuf;
- if (instbuf_size > size_on_same_page)
- instbuf_size = size_on_same_page;
- instbuf_size = std::min ((CORE_ADDR) instbuf_size,
- (end_addr - next_addr));
- instbuf_start = next_addr;
- status = safe_frame_unwind_memory (next_frame, instbuf_start,
- {instbuf, instbuf_size});
- if (status == 0)
- memory_error (TARGET_XFER_E_IO, next_addr);
- }
- reverse_frame_valid = 0;
- bundle = extract_unsigned_integer (&instbuf[next_addr - instbuf_start],
- 8, byte_order);
- num_insns = parse_insn_tilegx (bundle, next_addr, decoded);
- for (i = 0; i < num_insns; i++)
- {
- struct tilegx_decoded_instruction *this_insn = &decoded[i];
- long long *operands = this_insn->operand_values;
- const struct tilegx_opcode *opcode = this_insn->opcode;
- switch (opcode->mnemonic)
- {
- case TILEGX_OPC_ST:
- if (cache
- && reverse_frame[operands[0]].state == REVERSE_STATE_VALUE
- && reverse_frame[operands[1]].state
- == REVERSE_STATE_REGISTER)
- {
- LONGEST saved_address = reverse_frame[operands[0]].value;
- unsigned saved_register
- = (unsigned) reverse_frame[operands[1]].value;
- cache->saved_regs[saved_register].set_addr (saved_address);
- }
- else if (cache
- && (operands[0] == TILEGX_SP_REGNUM)
- && (operands[1] == TILEGX_LR_REGNUM))
- lr_saved_on_stack_p = 1;
- break;
- case TILEGX_OPC_ADDI:
- case TILEGX_OPC_ADDLI:
- if (cache
- && operands[0] == TILEGX_SP_REGNUM
- && operands[1] == TILEGX_SP_REGNUM
- && reverse_frame[operands[1]].state == REVERSE_STATE_REGISTER)
- {
- /* Special case. We're fixing up the stack frame. */
- uint64_t hopefully_sp
- = (unsigned) reverse_frame[operands[1]].value;
- short op2_as_short = (short) operands[2];
- signed char op2_as_char = (signed char) operands[2];
- /* Fix up the sign-extension. */
- if (opcode->mnemonic == TILEGX_OPC_ADDI)
- op2_as_short = op2_as_char;
- prev_sp_value = (cache->saved_regs[hopefully_sp].addr ()
- - op2_as_short);
- new_reverse_frame[i].state = REVERSE_STATE_VALUE;
- new_reverse_frame[i].value
- = cache->saved_regs[hopefully_sp].addr ();
- cache->saved_regs[hopefully_sp].set_value (prev_sp_value);
- }
- else
- {
- short op2_as_short = (short) operands[2];
- signed char op2_as_char = (signed char) operands[2];
- /* Fix up the sign-extension. */
- if (opcode->mnemonic == TILEGX_OPC_ADDI)
- op2_as_short = op2_as_char;
- new_reverse_frame[i] = reverse_frame[operands[1]];
- if (new_reverse_frame[i].state == REVERSE_STATE_VALUE)
- new_reverse_frame[i].value += op2_as_short;
- else
- new_reverse_frame[i].state = REVERSE_STATE_UNKNOWN;
- }
- reverse_frame_valid |= 1 << i;
- dest_regs[i] = operands[0];
- break;
- case TILEGX_OPC_ADD:
- if (reverse_frame[operands[1]].state == REVERSE_STATE_VALUE
- && reverse_frame[operands[2]].state == REVERSE_STATE_VALUE)
- {
- /* We have values -- we can do this. */
- new_reverse_frame[i] = reverse_frame[operands[2]];
- new_reverse_frame[i].value
- += reverse_frame[operands[i]].value;
- }
- else
- {
- /* We don't know anything about the values. Punt. */
- new_reverse_frame[i].state = REVERSE_STATE_UNKNOWN;
- }
- reverse_frame_valid |= 1 << i;
- dest_regs[i] = operands[0];
- break;
- case TILEGX_OPC_MOVE:
- new_reverse_frame[i] = reverse_frame[operands[1]];
- reverse_frame_valid |= 1 << i;
- dest_regs[i] = operands[0];
- break;
- case TILEGX_OPC_MOVEI:
- case TILEGX_OPC_MOVELI:
- new_reverse_frame[i].state = REVERSE_STATE_VALUE;
- new_reverse_frame[i].value = operands[1];
- reverse_frame_valid |= 1 << i;
- dest_regs[i] = operands[0];
- break;
- case TILEGX_OPC_ORI:
- if (reverse_frame[operands[1]].state == REVERSE_STATE_VALUE)
- {
- /* We have a value in A -- we can do this. */
- new_reverse_frame[i] = reverse_frame[operands[1]];
- new_reverse_frame[i].value
- = reverse_frame[operands[1]].value | operands[2];
- }
- else if (operands[2] == 0)
- {
- /* This is a move. */
- new_reverse_frame[i] = reverse_frame[operands[1]];
- }
- else
- {
- /* We don't know anything about the values. Punt. */
- new_reverse_frame[i].state = REVERSE_STATE_UNKNOWN;
- }
- reverse_frame_valid |= 1 << i;
- dest_regs[i] = operands[0];
- break;
- case TILEGX_OPC_OR:
- if (reverse_frame[operands[1]].state == REVERSE_STATE_VALUE
- && reverse_frame[operands[1]].value == 0)
- {
- /* This is a move. */
- new_reverse_frame[i] = reverse_frame[operands[2]];
- }
- else if (reverse_frame[operands[2]].state == REVERSE_STATE_VALUE
- && reverse_frame[operands[2]].value == 0)
- {
- /* This is a move. */
- new_reverse_frame[i] = reverse_frame[operands[1]];
- }
- else
- {
- /* We don't know anything about the values. Punt. */
- new_reverse_frame[i].state = REVERSE_STATE_UNKNOWN;
- }
- reverse_frame_valid |= 1 << i;
- dest_regs[i] = operands[0];
- break;
- case TILEGX_OPC_SUB:
- if (reverse_frame[operands[1]].state == REVERSE_STATE_VALUE
- && reverse_frame[operands[2]].state == REVERSE_STATE_VALUE)
- {
- /* We have values -- we can do this. */
- new_reverse_frame[i] = reverse_frame[operands[1]];
- new_reverse_frame[i].value
- -= reverse_frame[operands[2]].value;
- }
- else
- {
- /* We don't know anything about the values. Punt. */
- new_reverse_frame[i].state = REVERSE_STATE_UNKNOWN;
- }
- reverse_frame_valid |= 1 << i;
- dest_regs[i] = operands[0];
- break;
- case TILEGX_OPC_FNOP:
- case TILEGX_OPC_INFO:
- case TILEGX_OPC_INFOL:
- /* Nothing to see here, move on.
- Note that real NOP is treated as a 'real' instruction
- because someone must have intended that it be there.
- It therefore terminates the prolog. */
- break;
- case TILEGX_OPC_J:
- case TILEGX_OPC_JAL:
- case TILEGX_OPC_BEQZ:
- case TILEGX_OPC_BEQZT:
- case TILEGX_OPC_BGEZ:
- case TILEGX_OPC_BGEZT:
- case TILEGX_OPC_BGTZ:
- case TILEGX_OPC_BGTZT:
- case TILEGX_OPC_BLBC:
- case TILEGX_OPC_BLBCT:
- case TILEGX_OPC_BLBS:
- case TILEGX_OPC_BLBST:
- case TILEGX_OPC_BLEZ:
- case TILEGX_OPC_BLEZT:
- case TILEGX_OPC_BLTZ:
- case TILEGX_OPC_BLTZT:
- case TILEGX_OPC_BNEZ:
- case TILEGX_OPC_BNEZT:
- case TILEGX_OPC_IRET:
- case TILEGX_OPC_JALR:
- case TILEGX_OPC_JALRP:
- case TILEGX_OPC_JR:
- case TILEGX_OPC_JRP:
- case TILEGX_OPC_SWINT0:
- case TILEGX_OPC_SWINT1:
- case TILEGX_OPC_SWINT2:
- case TILEGX_OPC_SWINT3:
- /* We're really done -- this is a branch. */
- branch_seen = 1;
- prolog_done = 1;
- break;
- default:
- /* We don't know or care what this instruction is.
- All we know is that it isn't part of a prolog, and if
- there's a destination register, we're trashing it. */
- prolog_done = 1;
- for (j = 0; j < opcode->num_operands; j++)
- {
- if (this_insn->operands[j]->is_dest_reg)
- {
- dest_regs[i] = operands[j];
- new_reverse_frame[i].state = REVERSE_STATE_UNKNOWN;
- reverse_frame_valid |= 1 << i;
- break;
- }
- }
- break;
- }
- }
- /* Now update the reverse frames. */
- for (i = 0; i < num_insns; i++)
- {
- /* ISSUE: Does this properly handle "network" registers? */
- if ((reverse_frame_valid & (1 << i))
- && dest_regs[i] != TILEGX_ZERO_REGNUM)
- reverse_frame[dest_regs[i]] = new_reverse_frame[i];
- }
- if (prev_sp_value != 0)
- {
- /* GCC uses R52 as a frame pointer. Have we seen "move r52, sp"? */
- if (reverse_frame[TILEGX_R52_REGNUM].state == REVERSE_STATE_REGISTER
- && reverse_frame[TILEGX_R52_REGNUM].value == TILEGX_SP_REGNUM)
- {
- reverse_frame[TILEGX_R52_REGNUM].state = REVERSE_STATE_VALUE;
- reverse_frame[TILEGX_R52_REGNUM].value = prev_sp_value;
- }
- prev_sp_value = 0;
- }
- if (prolog_done && prolog_end == end_addr)
- {
- /* We found non-prolog code. As such, _this_ instruction
- is the one after the prolog. We keep processing, because
- there may be more prolog code in there, but this is what
- we'll return. */
- /* ISSUE: There may not have actually been a prologue, and
- we may have simply skipped some random instructions. */
- prolog_end = next_addr;
- }
- if (branch_seen)
- {
- /* We saw a branch. The prolog absolutely must be over. */
- break;
- }
- }
- if (prolog_end == end_addr && cache)
- {
- /* We may have terminated the prolog early, and we're certainly
- at THIS point right now. It's possible that the values of
- registers we need are currently actually in other registers
- (and haven't been written to memory yet). Go find them. */
- for (i = 0; i < TILEGX_NUM_PHYS_REGS; i++)
- {
- if (reverse_frame[i].state == REVERSE_STATE_REGISTER
- && reverse_frame[i].value != i)
- {
- unsigned saved_register = (unsigned) reverse_frame[i].value;
- cache->saved_regs[saved_register].set_realreg (i);
- }
- }
- }
- if (lr_saved_on_stack_p)
- {
- CORE_ADDR addr = cache->saved_regs[TILEGX_SP_REGNUM].addr ();
- cache->saved_regs[TILEGX_LR_REGNUM].set_addr (addr);
- }
- return prolog_end;
- }
- /* This is the implementation of gdbarch method skip_prologue. */
- static CORE_ADDR
- tilegx_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR start_pc)
- {
- CORE_ADDR func_start, end_pc;
- struct obj_section *s;
- /* This is the preferred method, find the end of the prologue by
- using the debugging information. */
- if (find_pc_partial_function (start_pc, NULL, &func_start, NULL))
- {
- CORE_ADDR post_prologue_pc
- = skip_prologue_using_sal (gdbarch, func_start);
- if (post_prologue_pc != 0)
- return std::max (start_pc, post_prologue_pc);
- }
- /* Don't straddle a section boundary. */
- s = find_pc_section (start_pc);
- end_pc = start_pc + 8 * TILEGX_BUNDLE_SIZE_IN_BYTES;
- if (s != NULL)
- end_pc = std::min (end_pc, s->endaddr ());
- /* Otherwise, try to skip prologue the hard way. */
- return tilegx_analyze_prologue (gdbarch,
- start_pc,
- end_pc,
- NULL, NULL);
- }
- /* This is the implementation of gdbarch method stack_frame_destroyed_p. */
- static int
- tilegx_stack_frame_destroyed_p (struct gdbarch *gdbarch, CORE_ADDR pc)
- {
- CORE_ADDR func_addr = 0, func_end = 0;
- if (find_pc_partial_function (pc, NULL, &func_addr, &func_end))
- {
- CORE_ADDR addr = func_end - TILEGX_BUNDLE_SIZE_IN_BYTES;
- /* FIXME: Find the actual epilogue. */
- /* HACK: Just assume the final bundle is the "ret" instruction". */
- if (pc > addr)
- return 1;
- }
- return 0;
- }
- /* This is the implementation of gdbarch method get_longjmp_target. */
- static int
- tilegx_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;
- gdb_byte buf[8];
- jb_addr = get_frame_register_unsigned (frame, TILEGX_R0_REGNUM);
- /* TileGX jmp_buf contains 32 elements of type __uint_reg_t which
- has a size of 8 bytes. The return address is stored in the 25th
- slot. */
- if (target_read_memory (jb_addr + 25 * 8, buf, 8))
- return 0;
- *pc = extract_unsigned_integer (buf, 8, byte_order);
- return 1;
- }
- /* by assigning the 'faultnum' reg in kernel pt_regs with this value,
- kernel do_signal will not check r0. see tilegx kernel/signal.c
- for details. */
- #define INT_SWINT_1_SIGRETURN (~0)
- /* Implement the "write_pc" gdbarch method. */
- static void
- tilegx_write_pc (struct regcache *regcache, CORE_ADDR pc)
- {
- regcache_cooked_write_unsigned (regcache, TILEGX_PC_REGNUM, pc);
- /* We must be careful with modifying the program counter. If we
- just interrupted a system call, the kernel might try to restart
- it when we resume the inferior. On restarting the system call,
- the kernel will try backing up the program counter even though it
- no longer points at the system call. This typically results in a
- SIGSEGV or SIGILL. We can prevent this by writing INT_SWINT_1_SIGRETURN
- in the "faultnum" pseudo-register.
- Note that "faultnum" is saved when setting up a dummy call frame.
- This means that it is properly restored when that frame is
- popped, and that the interrupted system call will be restarted
- when we resume the inferior on return from a function call from
- within GDB. In all other cases the system call will not be
- restarted. */
- regcache_cooked_write_unsigned (regcache, TILEGX_FAULTNUM_REGNUM,
- INT_SWINT_1_SIGRETURN);
- }
- /* 64-bit pattern for a { bpt ; nop } bundle. */
- constexpr gdb_byte tilegx_break_insn[] =
- { 0x00, 0x50, 0x48, 0x51, 0xae, 0x44, 0x6a, 0x28 };
- typedef BP_MANIPULATION (tilegx_break_insn) tilegx_breakpoint;
- /* Normal frames. */
- static struct tilegx_frame_cache *
- tilegx_frame_cache (struct frame_info *this_frame, void **this_cache)
- {
- struct gdbarch *gdbarch = get_frame_arch (this_frame);
- struct tilegx_frame_cache *cache;
- CORE_ADDR current_pc;
- if (*this_cache)
- return (struct tilegx_frame_cache *) *this_cache;
- cache = FRAME_OBSTACK_ZALLOC (struct tilegx_frame_cache);
- *this_cache = cache;
- cache->saved_regs = trad_frame_alloc_saved_regs (this_frame);
- cache->base = 0;
- cache->start_pc = get_frame_func (this_frame);
- current_pc = get_frame_pc (this_frame);
- cache->base = get_frame_register_unsigned (this_frame, TILEGX_SP_REGNUM);
- cache->saved_regs[TILEGX_SP_REGNUM].set_value (cache->base);
- if (cache->start_pc)
- tilegx_analyze_prologue (gdbarch, cache->start_pc, current_pc,
- cache, this_frame);
- cache->saved_regs[TILEGX_PC_REGNUM] = cache->saved_regs[TILEGX_LR_REGNUM];
- return cache;
- }
- /* Retrieve the value of REGNUM in FRAME. */
- static struct value*
- tilegx_frame_prev_register (struct frame_info *this_frame,
- void **this_cache,
- int regnum)
- {
- struct tilegx_frame_cache *info =
- tilegx_frame_cache (this_frame, this_cache);
- return trad_frame_get_prev_register (this_frame, info->saved_regs,
- regnum);
- }
- /* Build frame id. */
- static void
- tilegx_frame_this_id (struct frame_info *this_frame, void **this_cache,
- struct frame_id *this_id)
- {
- struct tilegx_frame_cache *info =
- tilegx_frame_cache (this_frame, this_cache);
- /* This marks the outermost frame. */
- if (info->base == 0)
- return;
- (*this_id) = frame_id_build (info->base, info->start_pc);
- }
- static CORE_ADDR
- tilegx_frame_base_address (struct frame_info *this_frame, void **this_cache)
- {
- struct tilegx_frame_cache *cache =
- tilegx_frame_cache (this_frame, this_cache);
- return cache->base;
- }
- static const struct frame_unwind tilegx_frame_unwind = {
- "tilegx prologue",
- NORMAL_FRAME,
- default_frame_unwind_stop_reason,
- tilegx_frame_this_id,
- tilegx_frame_prev_register,
- NULL, /* const struct frame_data *unwind_data */
- default_frame_sniffer, /* frame_sniffer_ftype *sniffer */
- NULL /* frame_prev_pc_ftype *prev_pc */
- };
- static const struct frame_base tilegx_frame_base = {
- &tilegx_frame_unwind,
- tilegx_frame_base_address,
- tilegx_frame_base_address,
- tilegx_frame_base_address
- };
- /* We cannot read/write the "special" registers. */
- static int
- tilegx_cannot_reference_register (struct gdbarch *gdbarch, int regno)
- {
- if (regno >= 0 && regno < TILEGX_NUM_EASY_REGS)
- return 0;
- else if (regno == TILEGX_PC_REGNUM
- || regno == TILEGX_FAULTNUM_REGNUM)
- return 0;
- else
- return 1;
- }
- static struct gdbarch *
- tilegx_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
- {
- struct gdbarch *gdbarch;
- int arch_size = 64;
- /* Handle arch_size == 32 or 64. Default to 64. */
- if (info.abfd)
- arch_size = bfd_get_arch_size (info.abfd);
- /* Try to find a pre-existing architecture. */
- for (arches = gdbarch_list_lookup_by_info (arches, &info);
- arches != NULL;
- arches = gdbarch_list_lookup_by_info (arches->next, &info))
- {
- /* We only have two flavors -- just make sure arch_size matches. */
- if (gdbarch_ptr_bit (arches->gdbarch) == arch_size)
- return (arches->gdbarch);
- }
- gdbarch = gdbarch_alloc (&info, NULL);
- /* Basic register fields and methods, datatype sizes and stuff. */
- /* There are 64 physical registers which can be referenced by
- instructions (although only 56 of them can actually be
- debugged) and 1 magic register (the PC). The other three
- magic registers (ex1, syscall, orig_r0) which are known to
- "ptrace" are ignored by "gdb". Note that we simply pretend
- that there are 65 registers, and no "pseudo registers". */
- set_gdbarch_num_regs (gdbarch, TILEGX_NUM_REGS);
- set_gdbarch_num_pseudo_regs (gdbarch, 0);
- set_gdbarch_sp_regnum (gdbarch, TILEGX_SP_REGNUM);
- set_gdbarch_pc_regnum (gdbarch, TILEGX_PC_REGNUM);
- set_gdbarch_register_name (gdbarch, tilegx_register_name);
- set_gdbarch_register_type (gdbarch, tilegx_register_type);
- set_gdbarch_short_bit (gdbarch, 2 * TARGET_CHAR_BIT);
- set_gdbarch_int_bit (gdbarch, 4 * TARGET_CHAR_BIT);
- set_gdbarch_long_bit (gdbarch, arch_size);
- set_gdbarch_long_long_bit (gdbarch, 8 * TARGET_CHAR_BIT);
- set_gdbarch_float_bit (gdbarch, 4 * TARGET_CHAR_BIT);
- set_gdbarch_double_bit (gdbarch, 8 * TARGET_CHAR_BIT);
- set_gdbarch_long_double_bit (gdbarch, 8 * TARGET_CHAR_BIT);
- set_gdbarch_ptr_bit (gdbarch, arch_size);
- set_gdbarch_addr_bit (gdbarch, arch_size);
- set_gdbarch_cannot_fetch_register (gdbarch,
- tilegx_cannot_reference_register);
- set_gdbarch_cannot_store_register (gdbarch,
- tilegx_cannot_reference_register);
- /* Stack grows down. */
- set_gdbarch_inner_than (gdbarch, core_addr_lessthan);
- /* Frame Info. */
- set_gdbarch_frame_align (gdbarch, tilegx_frame_align);
- frame_base_set_default (gdbarch, &tilegx_frame_base);
- set_gdbarch_skip_prologue (gdbarch, tilegx_skip_prologue);
- set_gdbarch_stack_frame_destroyed_p (gdbarch, tilegx_stack_frame_destroyed_p);
- /* Map debug registers into internal register numbers. */
- set_gdbarch_dwarf2_reg_to_regnum (gdbarch, tilegx_dwarf2_reg_to_regnum);
- /* These values and methods are used when gdb calls a target function. */
- set_gdbarch_push_dummy_call (gdbarch, tilegx_push_dummy_call);
- set_gdbarch_get_longjmp_target (gdbarch, tilegx_get_longjmp_target);
- set_gdbarch_write_pc (gdbarch, tilegx_write_pc);
- set_gdbarch_breakpoint_kind_from_pc (gdbarch,
- tilegx_breakpoint::kind_from_pc);
- set_gdbarch_sw_breakpoint_from_kind (gdbarch,
- tilegx_breakpoint::bp_from_kind);
- set_gdbarch_return_value (gdbarch, tilegx_return_value);
- gdbarch_init_osabi (info, gdbarch);
- dwarf2_append_unwinders (gdbarch);
- frame_unwind_append_unwinder (gdbarch, &tilegx_frame_unwind);
- return gdbarch;
- }
- void _initialize_tilegx_tdep ();
- void
- _initialize_tilegx_tdep ()
- {
- register_gdbarch_init (bfd_arch_tilegx, tilegx_gdbarch_init);
- }
|