gdb/tic6x-tdep.c

   1 /* Target dependent code for GDB on TI C6x systems.
   2
   3    Copyright (C) 2010-2019 Free Software Foundation, Inc.
   4    Contributed by Andrew Jenner <andrew@codesourcery.com>
   5    Contributed by Yao Qi <yao@codesourcery.com>
   6
   7    This file is part of GDB.
   8
   9    This program is free software; you can redistribute it and/or modify
  10    it under the terms of the GNU General Public License as published by
  11    the Free Software Foundation; either version 3 of the License, or
  12    (at your option) any later version.
  13
  14    This program is distributed in the hope that it will be useful,
  15    but WITHOUT ANY WARRANTY; without even the implied warranty of
  16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17    GNU General Public License for more details.
  18
  19    You should have received a copy of the GNU General Public License
  20    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  21
  22 #include "defs.h"
  23 #include "frame.h"
  24 #include "frame-unwind.h"
  25 #include "frame-base.h"
  26 #include "trad-frame.h"
  27 #include "dwarf2-frame.h"
  28 #include "symtab.h"
  29 #include "inferior.h"
  30 #include "gdbtypes.h"
  31 #include "gdbcore.h"
  32 #include "gdbcmd.h"
  33 #include "target.h"
  34 #include "dis-asm.h"
  35 #include "regcache.h"
  36 #include "value.h"
  37 #include "symfile.h"
  38 #include "arch-utils.h"
  39 #include "glibc-tdep.h"
  40 #include "infcall.h"
  41 #include "regset.h"
  42 #include "tramp-frame.h"
  43 #include "linux-tdep.h"
  44 #include "solib.h"
  45 #include "objfiles.h"
  46 #include "osabi.h"
  47 #include "tic6x-tdep.h"
  48 #include "language.h"
  49 #include "target-descriptions.h"
  50 #include <algorithm>
  51
  52 #define TIC6X_OPCODE_SIZE 4
  53 #define TIC6X_FETCH_PACKET_SIZE 32
  54
  55 #define INST_S_BIT(INST) ((INST >> 1) & 1)
  56 #define INST_X_BIT(INST) ((INST >> 12) & 1)
  57
  58 const gdb_byte tic6x_bkpt_illegal_opcode_be[] = { 0x56, 0x45, 0x43, 0x14 };
  59 const gdb_byte tic6x_bkpt_illegal_opcode_le[] = { 0x14, 0x43, 0x45, 0x56 };
  60
  61 struct tic6x_unwind_cache
  62 {
  63   /* The frame's base, optionally used by the high-level debug info.  */
  64   CORE_ADDR base;
  65
  66   /* The previous frame's inner most stack address.  Used as this
  67      frame ID's stack_addr.  */
  68   CORE_ADDR cfa;
  69
  70   /* The address of the first instruction in this function */
  71   CORE_ADDR pc;
  72
  73   /* Which register holds the return address for the frame.  */
  74   int return_regnum;
  75
  76   /* The offset of register saved on stack.  If register is not saved, the
  77      corresponding element is -1.  */
  78   CORE_ADDR reg_saved[TIC6X_NUM_CORE_REGS];
  79 };
  80
  81
  82 /* Name of TI C6x core registers.  */
  83 static const char *const tic6x_register_names[] =
  84 {
  85   "A0",  "A1",  "A2",  "A3",  /*  0  1  2  3 */
  86   "A4",  "A5",  "A6",  "A7",  /*  4  5  6  7 */
  87   "A8",  "A9",  "A10", "A11", /*  8  9 10 11 */
  88   "A12", "A13", "A14", "A15", /* 12 13 14 15 */
  89   "B0",  "B1",  "B2",  "B3",  /* 16 17 18 19 */
  90   "B4",  "B5",  "B6",  "B7",  /* 20 21 22 23 */
  91   "B8",  "B9",  "B10", "B11", /* 24 25 26 27 */
  92   "B12", "B13", "B14", "B15", /* 28 29 30 31 */
  93   "CSR", "PC",                /* 32 33       */
  94 };
  95
  96 /* This array maps the arguments to the register number which passes argument
  97    in function call according to C6000 ELF ABI.  */
  98 static const int arg_regs[] = { 4, 20, 6, 22, 8, 24, 10, 26, 12, 28 };
  99
 100 /* This is the implementation of gdbarch method register_name.  */
 101
 102 static const char *
 103 tic6x_register_name (struct gdbarch *gdbarch, int regno)
 104 {
 105   if (regno < 0)
 106     return NULL;
 107
 108   if (tdesc_has_registers (gdbarch_target_desc (gdbarch)))
 109     return tdesc_register_name (gdbarch, regno);
 110   else if (regno >= ARRAY_SIZE (tic6x_register_names))
 111     return "";
 112   else
 113     return tic6x_register_names[regno];
 114 }
 115
 116 /* This is the implementation of gdbarch method register_type.  */
 117
 118 static struct type *
 119 tic6x_register_type (struct gdbarch *gdbarch, int regno)
 120 {
 121
 122   if (regno == TIC6X_PC_REGNUM)
 123     return builtin_type (gdbarch)->builtin_func_ptr;
 124   else
 125     return builtin_type (gdbarch)->builtin_uint32;
 126 }
 127
 128 static void
 129 tic6x_setup_default (struct tic6x_unwind_cache *cache)
 130 {
 131   int i;
 132
 133   for (i = 0; i < TIC6X_NUM_CORE_REGS; i++)
 134     cache->reg_saved[i] = -1;
 135 }
 136
 137 static unsigned long tic6x_fetch_instruction (struct gdbarch *, CORE_ADDR);
 138 static int tic6x_register_number (int reg, int side, int crosspath);
 139
 140 /* Do a full analysis of the prologue at START_PC and update CACHE accordingly.
 141    Bail out early if CURRENT_PC is reached.  Returns the address of the first
 142    instruction after the prologue.  */
 143
 144 static CORE_ADDR
 145 tic6x_analyze_prologue (struct gdbarch *gdbarch, const CORE_ADDR start_pc,
 146                         const CORE_ADDR current_pc,
 147                         struct tic6x_unwind_cache *cache,
 148                         struct frame_info *this_frame)
 149 {
 150   unsigned int src_reg, base_reg, dst_reg;
 151   int i;
 152   CORE_ADDR pc = start_pc;
 153   CORE_ADDR return_pc = start_pc;
 154   int frame_base_offset_to_sp = 0;
 155   /* Counter of non-stw instructions after first insn ` sub sp, xxx, sp'.  */
 156   int non_stw_insn_counter = 0;
 157
 158   if (start_pc >= current_pc)
 159     return_pc = current_pc;
 160
 161   cache->base = 0;
 162
 163   /* The landmarks in prologue is one or two SUB instructions to SP.
 164      Instructions on setting up dsbt are in the last part of prologue, if
 165      needed.  In maxim, prologue can be divided to three parts by two
 166      `sub sp, xx, sp' insns.  */
 167
 168   /* Step 1: Look for the 1st and 2nd insn `sub sp, xx, sp',  in which, the
 169      2nd one is optional.  */
 170   while (pc < current_pc)
 171     {
 172       unsigned long inst = tic6x_fetch_instruction (gdbarch, pc);
 173
 174       if ((inst & 0x1ffc) == 0x1dc0 || (inst & 0x1ffc) == 0x1bc0
 175           || (inst & 0x0ffc) == 0x9c0)
 176         {
 177           /* SUBAW/SUBAH/SUB, and src1 is ucst 5.  */
 178           unsigned int src2 = tic6x_register_number ((inst >> 18) & 0x1f,
 179                                                      INST_S_BIT (inst), 0);
 180           unsigned int dst = tic6x_register_number ((inst >> 23) & 0x1f,
 181                                                     INST_S_BIT (inst), 0);
 182
 183           if (src2 == TIC6X_SP_REGNUM && dst == TIC6X_SP_REGNUM)
 184             {
 185               /* Extract const from insn SUBAW/SUBAH/SUB, and translate it to
 186                  offset.  The constant offset is decoded in bit 13-17 in all
 187                  these three kinds of instructions.  */
 188               unsigned int ucst5 = (inst >> 13) & 0x1f;
 189
 190               if ((inst & 0x1ffc) == 0x1dc0)    /* SUBAW */
 191                 frame_base_offset_to_sp += ucst5 << 2;
 192               else if ((inst & 0x1ffc) == 0x1bc0)       /* SUBAH */
 193                 frame_base_offset_to_sp += ucst5 << 1;
 194               else if ((inst & 0x0ffc) == 0x9c0)        /* SUB */
 195                 frame_base_offset_to_sp += ucst5;
 196               else
 197                 gdb_assert_not_reached ("unexpected instruction");
 198
 199               return_pc = pc + 4;
 200             }
 201         }
 202       else if ((inst & 0x174) == 0x74)  /* stw SRC, *+b15(uconst) */
 203         {
 204           /* The y bit determines which file base is read from.  */
 205           base_reg = tic6x_register_number ((inst >> 18) & 0x1f,
 206                                             (inst >> 7) & 1, 0);
 207
 208           if (base_reg == TIC6X_SP_REGNUM)
 209             {
 210               src_reg = tic6x_register_number ((inst >> 23) & 0x1f,
 211                                                INST_S_BIT (inst), 0);
 212
 213               cache->reg_saved[src_reg] = ((inst >> 13) & 0x1f) << 2;
 214
 215               return_pc = pc + 4;
 216             }
 217           non_stw_insn_counter = 0;
 218         }
 219       else
 220         {
 221           non_stw_insn_counter++;
 222           /* Following instruction sequence may be emitted in prologue:
 223
 224              <+0>: subah .D2 b15,28,b15
 225              <+4>: or .L2X 0,a4,b0
 226              <+8>: || stw .D2T2 b14,*+b15(56)
 227              <+12>:[!b0] b .S1 0xe50e4c1c <sleep+220>
 228              <+16>:|| stw .D2T1 a10,*+b15(48)
 229              <+20>:stw .D2T2 b3,*+b15(52)
 230              <+24>:stw .D2T1 a4,*+b15(40)
 231
 232              we should look forward for next instruction instead of breaking loop
 233              here.  So far, we allow almost two sequential non-stw instructions
 234              in prologue.  */
 235           if (non_stw_insn_counter >= 2)
 236             break;
 237         }
 238
 239
 240       pc += 4;
 241     }
 242   /* Step 2: Skip insn on setting up dsbt if it is.  Usually, it looks like,
 243      ldw .D2T2 *+b14(0),b14 */
 244   unsigned long inst = tic6x_fetch_instruction (gdbarch, pc);
 245   /* The s bit determines which file dst will be loaded into, same effect as
 246      other places.  */
 247   dst_reg = tic6x_register_number ((inst >> 23) & 0x1f, (inst >> 1) & 1, 0);
 248   /* The y bit (bit 7), instead of s bit, determines which file base be
 249      used.  */
 250   base_reg = tic6x_register_number ((inst >> 18) & 0x1f, (inst >> 7) & 1, 0);
 251
 252   if ((inst & 0x164) == 0x64    /* ldw */
 253       && dst_reg == TIC6X_DP_REGNUM     /* dst is B14 */
 254       && base_reg == TIC6X_DP_REGNUM)   /* baseR is B14 */
 255     {
 256       return_pc = pc + 4;
 257     }
 258
 259   if (this_frame)
 260     {
 261       cache->base = get_frame_register_unsigned (this_frame, TIC6X_SP_REGNUM);
 262
 263       if (cache->reg_saved[TIC6X_FP_REGNUM] != -1)
 264         {
 265           /* If the FP now holds an offset from the CFA then this is a frame
 266              which uses the frame pointer.  */
 267
 268           cache->cfa = get_frame_register_unsigned (this_frame,
 269                                                     TIC6X_FP_REGNUM);
 270         }
 271       else
 272         {
 273           /* FP doesn't hold an offset from the CFA.  If SP still holds an
 274              offset from the CFA then we might be in a function which omits
 275              the frame pointer.  */
 276
 277           cache->cfa = cache->base + frame_base_offset_to_sp;
 278         }
 279     }
 280
 281   /* Adjust all the saved registers such that they contain addresses
 282      instead of offsets.  */
 283   for (i = 0; i < TIC6X_NUM_CORE_REGS; i++)
 284     if (cache->reg_saved[i] != -1)
 285       cache->reg_saved[i] = cache->base + cache->reg_saved[i];
 286
 287   return return_pc;
 288 }
 289
 290 /* This is the implementation of gdbarch method skip_prologue.  */
 291
 292 static CORE_ADDR
 293 tic6x_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR start_pc)
 294 {
 295   CORE_ADDR func_addr;
 296   struct tic6x_unwind_cache cache;
 297
 298   /* See if we can determine the end of the prologue via the symbol table.
 299      If so, then return either PC, or the PC after the prologue, whichever is
 300      greater.  */
 301   if (find_pc_partial_function (start_pc, NULL, &func_addr, NULL))
 302     {
 303       CORE_ADDR post_prologue_pc
 304         = skip_prologue_using_sal (gdbarch, func_addr);
 305       if (post_prologue_pc != 0)
 306         return std::max (start_pc, post_prologue_pc);
 307     }
 308
 309   /* Can't determine prologue from the symbol table, need to examine
 310      instructions.  */
 311   return tic6x_analyze_prologue (gdbarch, start_pc, (CORE_ADDR) -1, &cache,
 312                                  NULL);
 313 }
 314
 315 /* Implement the breakpoint_kind_from_pc gdbarch method.  */
 316
 317 static int
 318 tic6x_breakpoint_kind_from_pc (struct gdbarch *gdbarch, CORE_ADDR *pcptr)
 319 {
 320   return 4;
 321 }
 322
 323 /* Implement the sw_breakpoint_from_kind gdbarch method.  */
 324
 325 static const gdb_byte *
 326 tic6x_sw_breakpoint_from_kind (struct gdbarch *gdbarch, int kind, int *size)
 327 {
 328   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 329
 330   *size = kind;
 331
 332   if (tdep == NULL || tdep->breakpoint == NULL)
 333     {
 334       if (BFD_ENDIAN_BIG == gdbarch_byte_order_for_code (gdbarch))
 335         return tic6x_bkpt_illegal_opcode_be;
 336       else
 337         return tic6x_bkpt_illegal_opcode_le;
 338     }
 339   else
 340     return tdep->breakpoint;
 341 }
 342
 343 static void
 344 tic6x_dwarf2_frame_init_reg (struct gdbarch *gdbarch, int regnum,
 345                              struct dwarf2_frame_state_reg *reg,
 346                              struct frame_info *this_frame)
 347 {
 348   /* Mark the PC as the destination for the return address.  */
 349   if (regnum == gdbarch_pc_regnum (gdbarch))
 350     reg->how = DWARF2_FRAME_REG_RA;
 351
 352   /* Mark the stack pointer as the call frame address.  */
 353   else if (regnum == gdbarch_sp_regnum (gdbarch))
 354     reg->how = DWARF2_FRAME_REG_CFA;
 355
 356   /* The above was taken from the default init_reg in dwarf2-frame.c
 357      while the below is c6x specific.  */
 358
 359   /* Callee save registers.  The ABI designates A10-A15 and B10-B15 as
 360      callee-save.  */
 361   else if ((regnum >= 10 && regnum <= 15) || (regnum >= 26 && regnum <= 31))
 362     reg->how = DWARF2_FRAME_REG_SAME_VALUE;
 363   else
 364     /* All other registers are caller-save.  */
 365     reg->how = DWARF2_FRAME_REG_UNDEFINED;
 366 }
 367
 368 /* This is the implementation of gdbarch method unwind_pc.  */
 369
 370 static CORE_ADDR
 371 tic6x_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame)
 372 {
 373   gdb_byte buf[8];
 374
 375   frame_unwind_register (next_frame,  TIC6X_PC_REGNUM, buf);
 376   return extract_typed_address (buf, builtin_type (gdbarch)->builtin_func_ptr);
 377 }
 378
 379 /* Frame base handling.  */
 380
 381 static struct tic6x_unwind_cache*
 382 tic6x_frame_unwind_cache (struct frame_info *this_frame,
 383                           void **this_prologue_cache)
 384 {
 385   struct gdbarch *gdbarch = get_frame_arch (this_frame);
 386   CORE_ADDR current_pc;
 387   struct tic6x_unwind_cache *cache;
 388
 389   if (*this_prologue_cache)
 390     return (struct tic6x_unwind_cache *) *this_prologue_cache;
 391
 392   cache = FRAME_OBSTACK_ZALLOC (struct tic6x_unwind_cache);
 393   (*this_prologue_cache) = cache;
 394
 395   cache->return_regnum = TIC6X_RA_REGNUM;
 396
 397   tic6x_setup_default (cache);
 398
 399   cache->pc = get_frame_func (this_frame);
 400   current_pc = get_frame_pc (this_frame);
 401
 402   /* Prologue analysis does the rest...  */
 403   if (cache->pc != 0)
 404     tic6x_analyze_prologue (gdbarch, cache->pc, current_pc, cache, this_frame);
 405
 406   return cache;
 407 }
 408
 409 static void
 410 tic6x_frame_this_id (struct frame_info *this_frame, void **this_cache,
 411                      struct frame_id *this_id)
 412 {
 413   struct tic6x_unwind_cache *cache =
 414     tic6x_frame_unwind_cache (this_frame, this_cache);
 415
 416   /* This marks the outermost frame.  */
 417   if (cache->base == 0)
 418     return;
 419
 420   (*this_id) = frame_id_build (cache->cfa, cache->pc);
 421 }
 422
 423 static struct value *
 424 tic6x_frame_prev_register (struct frame_info *this_frame, void **this_cache,
 425                            int regnum)
 426 {
 427   struct tic6x_unwind_cache *cache =
 428     tic6x_frame_unwind_cache (this_frame, this_cache);
 429
 430   gdb_assert (regnum >= 0);
 431
 432   /* The PC of the previous frame is stored in the RA register of
 433      the current frame.  Frob regnum so that we pull the value from
 434      the correct place.  */
 435   if (regnum == TIC6X_PC_REGNUM)
 436     regnum = cache->return_regnum;
 437
 438   if (regnum == TIC6X_SP_REGNUM && cache->cfa)
 439     return frame_unwind_got_constant (this_frame, regnum, cache->cfa);
 440
 441   /* If we've worked out where a register is stored then load it from
 442      there.  */
 443   if (regnum < TIC6X_NUM_CORE_REGS && cache->reg_saved[regnum] != -1)
 444     return frame_unwind_got_memory (this_frame, regnum,
 445                                     cache->reg_saved[regnum]);
 446
 447   return frame_unwind_got_register (this_frame, regnum, regnum);
 448 }
 449
 450 static CORE_ADDR
 451 tic6x_frame_base_address (struct frame_info *this_frame, void **this_cache)
 452 {
 453   struct tic6x_unwind_cache *info
 454     = tic6x_frame_unwind_cache (this_frame, this_cache);
 455   return info->base;
 456 }
 457
 458 static const struct frame_unwind tic6x_frame_unwind =
 459 {
 460   NORMAL_FRAME,
 461   default_frame_unwind_stop_reason,
 462   tic6x_frame_this_id,
 463   tic6x_frame_prev_register,
 464   NULL,
 465   default_frame_sniffer
 466 };
 467
 468 static const struct frame_base tic6x_frame_base =
 469 {
 470   &tic6x_frame_unwind,
 471   tic6x_frame_base_address,
 472   tic6x_frame_base_address,
 473   tic6x_frame_base_address
 474 };
 475
 476
 477 static struct tic6x_unwind_cache *
 478 tic6x_make_stub_cache (struct frame_info *this_frame)
 479 {
 480   struct tic6x_unwind_cache *cache;
 481
 482   cache = FRAME_OBSTACK_ZALLOC (struct tic6x_unwind_cache);
 483
 484   cache->return_regnum = TIC6X_RA_REGNUM;
 485
 486   tic6x_setup_default (cache);
 487
 488   cache->cfa = get_frame_register_unsigned (this_frame, TIC6X_SP_REGNUM);
 489
 490   return cache;
 491 }
 492
 493 static void
 494 tic6x_stub_this_id (struct frame_info *this_frame, void **this_cache,
 495                     struct frame_id *this_id)
 496 {
 497   struct tic6x_unwind_cache *cache;
 498
 499   if (*this_cache == NULL)
 500     *this_cache = tic6x_make_stub_cache (this_frame);
 501   cache = (struct tic6x_unwind_cache *) *this_cache;
 502
 503   *this_id = frame_id_build (cache->cfa, get_frame_pc (this_frame));
 504 }
 505
 506 static int
 507 tic6x_stub_unwind_sniffer (const struct frame_unwind *self,
 508                            struct frame_info *this_frame,
 509                            void **this_prologue_cache)
 510 {
 511   CORE_ADDR addr_in_block;
 512
 513   addr_in_block = get_frame_address_in_block (this_frame);
 514   if (in_plt_section (addr_in_block))
 515     return 1;
 516
 517   return 0;
 518 }
 519
 520 static const struct frame_unwind tic6x_stub_unwind =
 521 {
 522   NORMAL_FRAME,
 523   default_frame_unwind_stop_reason,
 524   tic6x_stub_this_id,
 525   tic6x_frame_prev_register,
 526   NULL,
 527   tic6x_stub_unwind_sniffer
 528 };
 529
 530 /* Return the instruction on address PC.  */
 531
 532 static unsigned long
 533 tic6x_fetch_instruction (struct gdbarch *gdbarch, CORE_ADDR pc)
 534 {
 535   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 536   return read_memory_unsigned_integer (pc, TIC6X_OPCODE_SIZE, byte_order);
 537 }
 538
 539 /* Compute the condition of INST if it is a conditional instruction.  Always
 540    return 1 if INST is not a conditional instruction.  */
 541
 542 static int
 543 tic6x_condition_true (struct regcache *regcache, unsigned long inst)
 544 {
 545   int register_number;
 546   int register_value;
 547   static const int register_numbers[8] = { -1, 16, 17, 18, 1, 2, 0, -1 };
 548
 549   register_number = register_numbers[(inst >> 29) & 7];
 550   if (register_number == -1)
 551     return 1;
 552
 553   register_value = regcache_raw_get_signed (regcache, register_number);
 554   if ((inst & 0x10000000) != 0)
 555     return register_value == 0;
 556   return register_value != 0;
 557 }
 558
 559 /* Get the register number by decoding raw bits REG, SIDE, and CROSSPATH in
 560    instruction.  */
 561
 562 static int
 563 tic6x_register_number (int reg, int side, int crosspath)
 564 {
 565   int r = (reg & 15) | ((crosspath ^ side) << 4);
 566   if ((reg & 16) != 0) /* A16 - A31, B16 - B31 */
 567     r += 37;
 568   return r;
 569 }
 570
 571 static int
 572 tic6x_extract_signed_field (int value, int low_bit, int bits)
 573 {
 574   int mask = (1 << bits) - 1;
 575   int r = (value >> low_bit) & mask;
 576   if ((r & (1 << (bits - 1))) != 0)
 577     r -= mask + 1;
 578   return r;
 579 }
 580
 581 /* Determine where to set a single step breakpoint.  */
 582
 583 static CORE_ADDR
 584 tic6x_get_next_pc (struct regcache *regcache, CORE_ADDR pc)
 585 {
 586   struct gdbarch *gdbarch = regcache->arch ();
 587   unsigned long inst;
 588   int register_number;
 589   int last = 0;
 590
 591   do
 592     {
 593       inst = tic6x_fetch_instruction (gdbarch, pc);
 594
 595       last = !(inst & 1);
 596
 597       if (inst == TIC6X_INST_SWE)
 598         {
 599           struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 600
 601           if (tdep->syscall_next_pc != NULL)
 602             return tdep->syscall_next_pc (get_current_frame ());
 603         }
 604
 605       if (tic6x_condition_true (regcache, inst))
 606         {
 607           if ((inst & 0x0000007c) == 0x00000010)
 608             {
 609               /* B with displacement */
 610               pc &= ~(TIC6X_FETCH_PACKET_SIZE - 1);
 611               pc += tic6x_extract_signed_field (inst, 7, 21) << 2;
 612               break;
 613             }
 614           if ((inst & 0x0f83effc) == 0x00000360)
 615             {
 616               /* B with register */
 617
 618               register_number = tic6x_register_number ((inst >> 18) & 0x1f,
 619                                                        INST_S_BIT (inst),
 620                                                        INST_X_BIT (inst));
 621               pc = regcache_raw_get_unsigned (regcache, register_number);
 622               break;
 623             }
 624           if ((inst & 0x00001ffc) == 0x00001020)
 625             {
 626               /* BDEC */
 627               register_number = tic6x_register_number ((inst >> 23) & 0x1f,
 628                                                        INST_S_BIT (inst), 0);
 629               if (regcache_raw_get_signed (regcache, register_number) >= 0)
 630                 {
 631                   pc &= ~(TIC6X_FETCH_PACKET_SIZE - 1);
 632                   pc += tic6x_extract_signed_field (inst, 7, 10) << 2;
 633                 }
 634               break;
 635             }
 636           if ((inst & 0x00001ffc) == 0x00000120)
 637             {
 638               /* BNOP with displacement */
 639               pc &= ~(TIC6X_FETCH_PACKET_SIZE - 1);
 640               pc += tic6x_extract_signed_field (inst, 16, 12) << 2;
 641               break;
 642             }
 643           if ((inst & 0x0f830ffe) == 0x00800362)
 644             {
 645               /* BNOP with register */
 646               register_number = tic6x_register_number ((inst >> 18) & 0x1f,
 647                                                        1, INST_X_BIT (inst));
 648               pc = regcache_raw_get_unsigned (regcache, register_number);
 649               break;
 650             }
 651           if ((inst & 0x00001ffc) == 0x00000020)
 652             {
 653               /* BPOS */
 654               register_number = tic6x_register_number ((inst >> 23) & 0x1f,
 655                                                        INST_S_BIT (inst), 0);
 656               if (regcache_raw_get_signed (regcache, register_number) >= 0)
 657                 {
 658                   pc &= ~(TIC6X_FETCH_PACKET_SIZE - 1);
 659                   pc += tic6x_extract_signed_field (inst, 13, 10) << 2;
 660                 }
 661               break;
 662             }
 663           if ((inst & 0xf000007c) == 0x10000010)
 664             {
 665               /* CALLP */
 666               pc &= ~(TIC6X_FETCH_PACKET_SIZE - 1);
 667               pc += tic6x_extract_signed_field (inst, 7, 21) << 2;
 668               break;
 669             }
 670         }
 671       pc += TIC6X_OPCODE_SIZE;
 672     }
 673   while (!last);
 674   return pc;
 675 }
 676
 677 /* This is the implementation of gdbarch method software_single_step.  */
 678
 679 static std::vector<CORE_ADDR>
 680 tic6x_software_single_step (struct regcache *regcache)
 681 {
 682   CORE_ADDR next_pc = tic6x_get_next_pc (regcache, regcache_read_pc (regcache));
 683
 684   return {next_pc};
 685 }
 686
 687 /* This is the implementation of gdbarch method frame_align.  */
 688
 689 static CORE_ADDR
 690 tic6x_frame_align (struct gdbarch *gdbarch, CORE_ADDR addr)
 691 {
 692   return align_down (addr, 8);
 693 }
 694
 695 /* Given a return value in REGCACHE with a type VALTYPE, extract and copy its
 696    value into VALBUF.  */
 697
 698 static void
 699 tic6x_extract_return_value (struct type *valtype, struct regcache *regcache,
 700                             enum bfd_endian byte_order, gdb_byte *valbuf)
 701 {
 702   int len = TYPE_LENGTH (valtype);
 703
 704   /* pointer types are returned in register A4,
 705      up to 32-bit types in A4
 706      up to 64-bit types in A5:A4  */
 707   if (len <= 4)
 708     {
 709       /* In big-endian,
 710          - one-byte structure or union occupies the LSB of single even register.
 711          - for two-byte structure or union, the first byte occupies byte 1 of
 712          register and the second byte occupies byte 0.
 713          so, we read the contents in VAL from the LSBs of register.  */
 714       if (len < 3 && byte_order == BFD_ENDIAN_BIG)
 715         regcache->cooked_read_part (TIC6X_A4_REGNUM, 4 - len, len, valbuf);
 716       else
 717         regcache->cooked_read (TIC6X_A4_REGNUM, valbuf);
 718     }
 719   else if (len <= 8)
 720     {
 721       /* For a 5-8 byte structure or union in big-endian, the first byte
 722          occupies byte 3 (the MSB) of the upper (odd) register and the
 723          remaining bytes fill the decreasingly significant bytes.  5-7
 724          byte structures or unions have padding in the LSBs of the
 725          lower (even) register.  */
 726       if (byte_order == BFD_ENDIAN_BIG)
 727         {
 728           regcache->cooked_read (TIC6X_A4_REGNUM, valbuf + 4);
 729           regcache->cooked_read (TIC6X_A5_REGNUM, valbuf);
 730         }
 731       else
 732         {
 733           regcache->cooked_read (TIC6X_A4_REGNUM, valbuf);
 734           regcache->cooked_read (TIC6X_A5_REGNUM, valbuf + 4);
 735         }
 736     }
 737 }
 738
 739 /* Write into appropriate registers a function return value
 740    of type TYPE, given in virtual format.  */
 741
 742 static void
 743 tic6x_store_return_value (struct type *valtype, struct regcache *regcache,
 744                           enum bfd_endian byte_order, const gdb_byte *valbuf)
 745 {
 746   int len = TYPE_LENGTH (valtype);
 747
 748   /* return values of up to 8 bytes are returned in A5:A4 */
 749
 750   if (len <= 4)
 751     {
 752       if (len < 3 && byte_order == BFD_ENDIAN_BIG)
 753         regcache->cooked_write_part (TIC6X_A4_REGNUM, 4 - len, len, valbuf);
 754       else
 755         regcache->cooked_write (TIC6X_A4_REGNUM, valbuf);
 756     }
 757   else if (len <= 8)
 758     {
 759       if (byte_order == BFD_ENDIAN_BIG)
 760         {
 761           regcache->cooked_write (TIC6X_A4_REGNUM, valbuf + 4);
 762           regcache->cooked_write (TIC6X_A5_REGNUM, valbuf);
 763         }
 764       else
 765         {
 766           regcache->cooked_write (TIC6X_A4_REGNUM, valbuf);
 767           regcache->cooked_write (TIC6X_A5_REGNUM, valbuf + 4);
 768         }
 769     }
 770 }
 771
 772 /* This is the implementation of gdbarch method return_value.  */
 773
 774 static enum return_value_convention
 775 tic6x_return_value (struct gdbarch *gdbarch, struct value *function,
 776                     struct type *type, struct regcache *regcache,
 777                     gdb_byte *readbuf, const gdb_byte *writebuf)
 778 {
 779   /* In C++, when function returns an object, even its size is small
 780      enough, it stii has to be passed via reference, pointed by register
 781      A3.  */
 782   if (current_language->la_language == language_cplus)
 783     {
 784       if (type != NULL)
 785         {
 786           type = check_typedef (type);
 787           if (language_pass_by_reference (type))
 788             return RETURN_VALUE_STRUCT_CONVENTION;
 789         }
 790     }
 791
 792   if (TYPE_LENGTH (type) > 8)
 793     return RETURN_VALUE_STRUCT_CONVENTION;
 794
 795   if (readbuf)
 796     tic6x_extract_return_value (type, regcache,
 797                                 gdbarch_byte_order (gdbarch), readbuf);
 798   if (writebuf)
 799     tic6x_store_return_value (type, regcache,
 800                               gdbarch_byte_order (gdbarch), writebuf);
 801
 802   return RETURN_VALUE_REGISTER_CONVENTION;
 803 }
 804
 805 /* Get the alignment requirement of TYPE.  */
 806
 807 static int
 808 tic6x_arg_type_alignment (struct type *type)
 809 {
 810   int len = TYPE_LENGTH (check_typedef (type));
 811   enum type_code typecode = TYPE_CODE (check_typedef (type));
 812
 813   if (typecode == TYPE_CODE_STRUCT || typecode == TYPE_CODE_UNION)
 814     {
 815       /* The stack alignment of a structure (and union) passed by value is the
 816          smallest power of two greater than or equal to its size.
 817          This cannot exceed 8 bytes, which is the largest allowable size for
 818          a structure passed by value.  */
 819
 820       if (len <= 2)
 821         return len;
 822       else if (len <= 4)
 823         return 4;
 824       else if (len <= 8)
 825         return 8;
 826       else
 827         gdb_assert_not_reached ("unexpected length of data");
 828     }
 829   else
 830     {
 831       if (len <= 4)
 832         return 4;
 833       else if (len == 8)
 834         {
 835           if (typecode == TYPE_CODE_COMPLEX)
 836             return 4;
 837           else
 838             return 8;
 839         }
 840       else if (len == 16)
 841         {
 842           if (typecode == TYPE_CODE_COMPLEX)
 843             return 8;
 844           else
 845             return 16;
 846         }
 847       else
 848         internal_error (__FILE__, __LINE__, _("unexpected length %d of type"),
 849                         len);
 850     }
 851 }
 852
 853 /* This is the implementation of gdbarch method push_dummy_call.  */
 854
 855 static CORE_ADDR
 856 tic6x_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
 857                        struct regcache *regcache, CORE_ADDR bp_addr,
 858                        int nargs, struct value **args, CORE_ADDR sp,
 859                        function_call_return_method return_method,
 860                        CORE_ADDR struct_addr)
 861 {
 862   int argreg = 0;
 863   int argnum;
 864   int stack_offset = 4;
 865   int references_offset = 4;
 866   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 867   struct type *func_type = value_type (function);
 868   /* The first arg passed on stack.  Mostly the first 10 args are passed by
 869      registers.  */
 870   int first_arg_on_stack = 10;
 871
 872   /* Set the return address register to point to the entry point of
 873      the program, where a breakpoint lies in wait.  */
 874   regcache_cooked_write_unsigned (regcache, TIC6X_RA_REGNUM, bp_addr);
 875
 876   /* The caller must pass an argument in A3 containing a destination address
 877      for the returned value.  The callee returns the object by copying it to
 878      the address in A3.  */
 879   if (return_method == return_method_struct)
 880     regcache_cooked_write_unsigned (regcache, 3, struct_addr);
 881
 882   /* Determine the type of this function.  */
 883   func_type = check_typedef (func_type);
 884   if (TYPE_CODE (func_type) == TYPE_CODE_PTR)
 885     func_type = check_typedef (TYPE_TARGET_TYPE (func_type));
 886
 887   gdb_assert (TYPE_CODE (func_type) == TYPE_CODE_FUNC
 888               || TYPE_CODE (func_type) == TYPE_CODE_METHOD);
 889
 890   /* For a variadic C function, the last explicitly declared argument and all
 891      remaining arguments are passed on the stack.  */
 892   if (TYPE_VARARGS (func_type))
 893     first_arg_on_stack = TYPE_NFIELDS (func_type) - 1;
 894
 895   /* Now make space on the stack for the args.  */
 896   for (argnum = 0; argnum < nargs; argnum++)
 897     {
 898       int len = align_up (TYPE_LENGTH (value_type (args[argnum])), 4);
 899       if (argnum >= 10 - argreg)
 900         references_offset += len;
 901       stack_offset += len;
 902     }
 903   sp -= stack_offset;
 904   /* SP should be 8-byte aligned, see C6000 ABI section 4.4.1
 905      Stack Alignment.  */
 906   sp = align_down (sp, 8);
 907   stack_offset = 4;
 908
 909   /* Now load as many as possible of the first arguments into
 910      registers, and push the rest onto the stack.  Loop through args
 911      from first to last.  */
 912   for (argnum = 0; argnum < nargs; argnum++)
 913     {
 914       const gdb_byte *val;
 915       struct value *arg = args[argnum];
 916       struct type *arg_type = check_typedef (value_type (arg));
 917       int len = TYPE_LENGTH (arg_type);
 918       enum type_code typecode = TYPE_CODE (arg_type);
 919
 920       val = value_contents (arg);
 921
 922       /* Copy the argument to general registers or the stack in
 923          register-sized pieces.  */
 924       if (argreg < first_arg_on_stack)
 925         {
 926           if (len <= 4)
 927             {
 928               if (typecode == TYPE_CODE_STRUCT || typecode == TYPE_CODE_UNION)
 929                 {
 930                   /* In big-endian,
 931                      - one-byte structure or union occupies the LSB of single
 932                      even register.
 933                      - for two-byte structure or union, the first byte
 934                      occupies byte 1 of register and the second byte occupies
 935                      byte 0.
 936                      so, we write the contents in VAL to the lsp of
 937                      register.  */
 938                   if (len < 3 && byte_order == BFD_ENDIAN_BIG)
 939                     regcache->cooked_write_part (arg_regs[argreg], 4 - len, len,
 940                                                  val);
 941                   else
 942                     regcache->cooked_write (arg_regs[argreg], val);
 943                 }
 944               else
 945                 {
 946                   /* The argument is being passed by value in a single
 947                      register.  */
 948                   CORE_ADDR regval = extract_unsigned_integer (val, len,
 949                                                                byte_order);
 950
 951                   regcache_cooked_write_unsigned (regcache, arg_regs[argreg],
 952                                                   regval);
 953                 }
 954             }
 955           else
 956             {
 957               if (len <= 8)
 958                 {
 959                   if (typecode == TYPE_CODE_STRUCT
 960                       || typecode == TYPE_CODE_UNION)
 961                     {
 962                       /* For a 5-8 byte structure or union in big-endian, the
 963                          first byte occupies byte 3 (the MSB) of the upper (odd)
 964                          register and the remaining bytes fill the decreasingly
 965                          significant bytes.  5-7 byte structures or unions have
 966                          padding in the LSBs of the lower (even) register.  */
 967                       if (byte_order == BFD_ENDIAN_BIG)
 968                         {
 969                           regcache->cooked_write (arg_regs[argreg] + 1, val);
 970                           regcache->cooked_write_part (arg_regs[argreg], 0,
 971                                                        len - 4, val + 4);
 972                         }
 973                       else
 974                         {
 975                           regcache->cooked_write (arg_regs[argreg], val);
 976                           regcache->cooked_write_part (arg_regs[argreg] + 1, 0,
 977                                                        len - 4, val + 4);
 978                         }
 979                     }
 980                   else
 981                     {
 982                       /* The argument is being passed by value in a pair of
 983                          registers.  */
 984                       ULONGEST regval = extract_unsigned_integer (val, len,
 985                                                                   byte_order);
 986
 987                       regcache_cooked_write_unsigned (regcache,
 988                                                       arg_regs[argreg],
 989                                                       regval);
 990                       regcache_cooked_write_unsigned (regcache,
 991                                                       arg_regs[argreg] + 1,
 992                                                       regval >> 32);
 993                     }
 994                 }
 995               else
 996                 {
 997                   /* The argument is being passed by reference in a single
 998                      register.  */
 999                   CORE_ADDR addr;
1000
1001                   /* It is not necessary to adjust REFERENCES_OFFSET to
1002                      8-byte aligned in some cases, in which 4-byte alignment
1003                      is sufficient.  For simplicity, we adjust
1004                      REFERENCES_OFFSET to 8-byte aligned.  */
1005                   references_offset = align_up (references_offset, 8);
1006
1007                   addr = sp + references_offset;
1008                   write_memory (addr, val, len);
1009                   references_offset += align_up (len, 4);
1010                   regcache_cooked_write_unsigned (regcache, arg_regs[argreg],
1011                                                   addr);
1012                 }
1013             }
1014           argreg++;
1015         }
1016       else
1017         {
1018           /* The argument is being passed on the stack.  */
1019           CORE_ADDR addr;
1020
1021           /* There are six different cases of alignment, and these rules can
1022              be found in tic6x_arg_type_alignment:
1023
1024              1) 4-byte aligned if size is less than or equal to 4 byte, such
1025              as short, int, struct, union etc.
1026              2) 8-byte aligned if size is less than or equal to 8-byte, such
1027              as double, long long,
1028              3) 4-byte aligned if it is of type _Complex float, even its size
1029              is 8-byte.
1030              4) 8-byte aligned if it is of type _Complex double or _Complex
1031              long double, even its size is 16-byte.  Because, the address of
1032              variable is passed as reference.
1033              5) struct and union larger than 8-byte are passed by reference, so
1034              it is 4-byte aligned.
1035              6) struct and union of size between 4 byte and 8 byte varies.
1036              alignment of struct variable is the alignment of its first field,
1037              while alignment of union variable is the max of all its fields'
1038              alignment.  */
1039
1040           if (len <= 4)
1041             ; /* Default is 4-byte aligned.  Nothing to be done.  */
1042           else if (len <= 8)
1043             stack_offset = align_up (stack_offset,
1044                                      tic6x_arg_type_alignment (arg_type));
1045           else if (len == 16)
1046             {
1047               /* _Complex double or _Complex long double */
1048               if (typecode == TYPE_CODE_COMPLEX)
1049                 {
1050                   /* The argument is being passed by reference on stack.  */
1051                   references_offset = align_up (references_offset, 8);
1052
1053                   addr = sp + references_offset;
1054                   /* Store variable on stack.  */
1055                   write_memory (addr, val, len);
1056
1057                   references_offset += align_up (len, 4);
1058
1059                   /* Pass the address of variable on stack as reference.  */
1060                   store_unsigned_integer ((gdb_byte *) val, 4, byte_order,
1061                                           addr);
1062                   len = 4;
1063
1064                 }
1065               else
1066                 internal_error (__FILE__, __LINE__,
1067                                 _("unexpected type %d of arg %d"),
1068                                 typecode, argnum);
1069             }
1070           else
1071             internal_error (__FILE__, __LINE__,
1072                             _("unexpected length %d of arg %d"), len, argnum);
1073
1074           addr = sp + stack_offset;
1075           write_memory (addr, val, len);
1076           stack_offset += align_up (len, 4);
1077         }
1078     }
1079
1080   regcache_cooked_write_signed (regcache, TIC6X_SP_REGNUM, sp);
1081
1082   /* Return adjusted stack pointer.  */
1083   return sp;
1084 }
1085
1086 /* This is the implementation of gdbarch method stack_frame_destroyed_p.  */
1087
1088 static int
1089 tic6x_stack_frame_destroyed_p (struct gdbarch *gdbarch, CORE_ADDR pc)
1090 {
1091   unsigned long inst = tic6x_fetch_instruction (gdbarch, pc);
1092   /* Normally, the epilogue is composed by instruction `b .S2 b3'.  */
1093   if ((inst & 0x0f83effc) == 0x360)
1094     {
1095       unsigned int src2 = tic6x_register_number ((inst >> 18) & 0x1f,
1096                                                  INST_S_BIT (inst),
1097                                                  INST_X_BIT (inst));
1098       if (src2 == TIC6X_RA_REGNUM)
1099         return 1;
1100     }
1101
1102   return 0;
1103 }
1104
1105 /* This is the implementation of gdbarch method get_longjmp_target.  */
1106
1107 static int
1108 tic6x_get_longjmp_target (struct frame_info *frame, CORE_ADDR *pc)
1109 {
1110   struct gdbarch *gdbarch = get_frame_arch (frame);
1111   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1112   CORE_ADDR jb_addr;
1113   gdb_byte buf[4];
1114
1115   /* JMP_BUF is passed by reference in A4.  */
1116   jb_addr = get_frame_register_unsigned (frame, 4);
1117
1118   /* JMP_BUF contains 13 elements of type int, and return address is stored
1119      in the last slot.  */
1120   if (target_read_memory (jb_addr + 12 * 4, buf, 4))
1121     return 0;
1122
1123   *pc = extract_unsigned_integer (buf, 4, byte_order);
1124
1125   return 1;
1126 }
1127
1128 /* This is the implementation of gdbarch method
1129    return_in_first_hidden_param_p.  */
1130
1131 static int
1132 tic6x_return_in_first_hidden_param_p (struct gdbarch *gdbarch,
1133                                       struct type *type)
1134 {
1135   return 0;
1136 }
1137
1138 static struct gdbarch *
1139 tic6x_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
1140 {
1141   struct gdbarch *gdbarch;
1142   struct gdbarch_tdep *tdep;
1143   struct tdesc_arch_data *tdesc_data = NULL;
1144   const struct target_desc *tdesc = info.target_desc;
1145   int has_gp = 0;
1146
1147   /* Check any target description for validity.  */
1148   if (tdesc_has_registers (tdesc))
1149     {
1150       const struct tdesc_feature *feature;
1151       int valid_p, i;
1152
1153       feature = tdesc_find_feature (tdesc, "org.gnu.gdb.tic6x.core");
1154
1155       if (feature == NULL)
1156         return NULL;
1157
1158       tdesc_data = tdesc_data_alloc ();
1159
1160       valid_p = 1;
1161       for (i = 0; i < 32; i++)  /* A0 - A15, B0 - B15 */
1162         valid_p &= tdesc_numbered_register (feature, tdesc_data, i,
1163                                             tic6x_register_names[i]);
1164
1165       /* CSR */
1166       valid_p &= tdesc_numbered_register (feature, tdesc_data, i++,
1167                                           tic6x_register_names[TIC6X_CSR_REGNUM]);
1168       valid_p &= tdesc_numbered_register (feature, tdesc_data, i++,
1169                                           tic6x_register_names[TIC6X_PC_REGNUM]);
1170
1171       if (!valid_p)
1172         {
1173           tdesc_data_cleanup (tdesc_data);
1174           return NULL;
1175         }
1176
1177       feature = tdesc_find_feature (tdesc, "org.gnu.gdb.tic6x.gp");
1178       if (feature)
1179         {
1180           int j = 0;
1181           static const char *const gp[] =
1182             {
1183               "A16", "A17", "A18", "A19", "A20", "A21", "A22", "A23",
1184               "A24", "A25", "A26", "A27", "A28", "A29", "A30", "A31",
1185               "B16", "B17", "B18", "B19", "B20", "B21", "B22", "B23",
1186               "B24", "B25", "B26", "B27", "B28", "B29", "B30", "B31",
1187             };
1188
1189           has_gp = 1;
1190           valid_p = 1;
1191           for (j = 0; j < 32; j++)      /* A16 - A31, B16 - B31 */
1192             valid_p &= tdesc_numbered_register (feature, tdesc_data, i++,
1193                                                 gp[j]);
1194
1195           if (!valid_p)
1196             {
1197               tdesc_data_cleanup (tdesc_data);
1198               return NULL;
1199             }
1200         }
1201
1202       feature = tdesc_find_feature (tdesc, "org.gnu.gdb.tic6x.c6xp");
1203       if (feature)
1204         {
1205           valid_p &= tdesc_numbered_register (feature, tdesc_data, i++, "TSR");
1206           valid_p &= tdesc_numbered_register (feature, tdesc_data, i++, "ILC");
1207           valid_p &= tdesc_numbered_register (feature, tdesc_data, i++, "RILC");
1208
1209           if (!valid_p)
1210             {
1211               tdesc_data_cleanup (tdesc_data);
1212               return NULL;
1213             }
1214         }
1215
1216     }
1217
1218   /* Find a candidate among extant architectures.  */
1219   for (arches = gdbarch_list_lookup_by_info (arches, &info);
1220        arches != NULL;
1221        arches = gdbarch_list_lookup_by_info (arches->next, &info))
1222     {
1223       tdep = gdbarch_tdep (arches->gdbarch);
1224
1225       if (has_gp != tdep->has_gp)
1226         continue;
1227
1228       if (tdep && tdep->breakpoint)
1229         return arches->gdbarch;
1230     }
1231
1232   tdep = XCNEW (struct gdbarch_tdep);
1233
1234   tdep->has_gp = has_gp;
1235   gdbarch = gdbarch_alloc (&info, tdep);
1236
1237   /* Data type sizes.  */
1238   set_gdbarch_ptr_bit (gdbarch, 32);
1239   set_gdbarch_addr_bit (gdbarch, 32);
1240   set_gdbarch_short_bit (gdbarch, 16);
1241   set_gdbarch_int_bit (gdbarch, 32);
1242   set_gdbarch_long_bit (gdbarch, 32);
1243   set_gdbarch_long_long_bit (gdbarch, 64);
1244   set_gdbarch_float_bit (gdbarch, 32);
1245   set_gdbarch_double_bit (gdbarch, 64);
1246
1247   set_gdbarch_float_format (gdbarch, floatformats_ieee_single);
1248   set_gdbarch_double_format (gdbarch, floatformats_ieee_double);
1249
1250   /* The register set.  */
1251   set_gdbarch_num_regs (gdbarch, TIC6X_NUM_REGS);
1252   set_gdbarch_sp_regnum (gdbarch, TIC6X_SP_REGNUM);
1253   set_gdbarch_pc_regnum (gdbarch, TIC6X_PC_REGNUM);
1254
1255   set_gdbarch_register_name (gdbarch, tic6x_register_name);
1256   set_gdbarch_register_type (gdbarch, tic6x_register_type);
1257
1258   set_gdbarch_inner_than (gdbarch, core_addr_lessthan);
1259
1260   set_gdbarch_skip_prologue (gdbarch, tic6x_skip_prologue);
1261   set_gdbarch_breakpoint_kind_from_pc (gdbarch,
1262                                        tic6x_breakpoint_kind_from_pc);
1263   set_gdbarch_sw_breakpoint_from_kind (gdbarch,
1264                                        tic6x_sw_breakpoint_from_kind);
1265
1266   set_gdbarch_unwind_pc (gdbarch, tic6x_unwind_pc);
1267
1268   /* Unwinding.  */
1269   dwarf2_append_unwinders (gdbarch);
1270
1271   frame_unwind_append_unwinder (gdbarch, &tic6x_stub_unwind);
1272   frame_unwind_append_unwinder (gdbarch, &tic6x_frame_unwind);
1273   frame_base_set_default (gdbarch, &tic6x_frame_base);
1274
1275   dwarf2_frame_set_init_reg (gdbarch, tic6x_dwarf2_frame_init_reg);
1276
1277   /* Single stepping.  */
1278   set_gdbarch_software_single_step (gdbarch, tic6x_software_single_step);
1279
1280   /* Call dummy code.  */
1281   set_gdbarch_frame_align (gdbarch, tic6x_frame_align);
1282
1283   set_gdbarch_return_value (gdbarch, tic6x_return_value);
1284
1285   /* Enable inferior call support.  */
1286   set_gdbarch_push_dummy_call (gdbarch, tic6x_push_dummy_call);
1287
1288   set_gdbarch_get_longjmp_target (gdbarch, tic6x_get_longjmp_target);
1289
1290   set_gdbarch_stack_frame_destroyed_p (gdbarch, tic6x_stack_frame_destroyed_p);
1291
1292   set_gdbarch_return_in_first_hidden_param_p (gdbarch,
1293                                               tic6x_return_in_first_hidden_param_p);
1294
1295   /* Hook in ABI-specific overrides, if they have been registered.  */
1296   gdbarch_init_osabi (info, gdbarch);
1297
1298   if (tdesc_data)
1299     tdesc_use_registers (gdbarch, tdesc, tdesc_data);
1300
1301   return gdbarch;
1302 }
1303
1304 void
1305 _initialize_tic6x_tdep (void)
1306 {
1307   register_gdbarch_init (bfd_arch_tic6x, tic6x_gdbarch_init);
1308 }