gdb/tic6x-tdep.c

   1 /* Target dependent code for GDB on TI C6x systems.
   2
   3    Copyright (C) 2010-2018 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 /* This is the implementation of gdbarch method unwind_sp.  */
 380
 381 static CORE_ADDR
 382 tic6x_unwind_sp (struct gdbarch *gdbarch, struct frame_info *this_frame)
 383 {
 384   return frame_unwind_register_unsigned (this_frame, TIC6X_SP_REGNUM);
 385 }
 386
 387
 388 /* Frame base handling.  */
 389
 390 static struct tic6x_unwind_cache*
 391 tic6x_frame_unwind_cache (struct frame_info *this_frame,
 392                           void **this_prologue_cache)
 393 {
 394   struct gdbarch *gdbarch = get_frame_arch (this_frame);
 395   CORE_ADDR current_pc;
 396   struct tic6x_unwind_cache *cache;
 397
 398   if (*this_prologue_cache)
 399     return (struct tic6x_unwind_cache *) *this_prologue_cache;
 400
 401   cache = FRAME_OBSTACK_ZALLOC (struct tic6x_unwind_cache);
 402   (*this_prologue_cache) = cache;
 403
 404   cache->return_regnum = TIC6X_RA_REGNUM;
 405
 406   tic6x_setup_default (cache);
 407
 408   cache->pc = get_frame_func (this_frame);
 409   current_pc = get_frame_pc (this_frame);
 410
 411   /* Prologue analysis does the rest...  */
 412   if (cache->pc != 0)
 413     tic6x_analyze_prologue (gdbarch, cache->pc, current_pc, cache, this_frame);
 414
 415   return cache;
 416 }
 417
 418 static void
 419 tic6x_frame_this_id (struct frame_info *this_frame, void **this_cache,
 420                      struct frame_id *this_id)
 421 {
 422   struct tic6x_unwind_cache *cache =
 423     tic6x_frame_unwind_cache (this_frame, this_cache);
 424
 425   /* This marks the outermost frame.  */
 426   if (cache->base == 0)
 427     return;
 428
 429   (*this_id) = frame_id_build (cache->cfa, cache->pc);
 430 }
 431
 432 static struct value *
 433 tic6x_frame_prev_register (struct frame_info *this_frame, void **this_cache,
 434                            int regnum)
 435 {
 436   struct tic6x_unwind_cache *cache =
 437     tic6x_frame_unwind_cache (this_frame, this_cache);
 438
 439   gdb_assert (regnum >= 0);
 440
 441   /* The PC of the previous frame is stored in the RA register of
 442      the current frame.  Frob regnum so that we pull the value from
 443      the correct place.  */
 444   if (regnum == TIC6X_PC_REGNUM)
 445     regnum = cache->return_regnum;
 446
 447   if (regnum == TIC6X_SP_REGNUM && cache->cfa)
 448     return frame_unwind_got_constant (this_frame, regnum, cache->cfa);
 449
 450   /* If we've worked out where a register is stored then load it from
 451      there.  */
 452   if (regnum < TIC6X_NUM_CORE_REGS && cache->reg_saved[regnum] != -1)
 453     return frame_unwind_got_memory (this_frame, regnum,
 454                                     cache->reg_saved[regnum]);
 455
 456   return frame_unwind_got_register (this_frame, regnum, regnum);
 457 }
 458
 459 static CORE_ADDR
 460 tic6x_frame_base_address (struct frame_info *this_frame, void **this_cache)
 461 {
 462   struct tic6x_unwind_cache *info
 463     = tic6x_frame_unwind_cache (this_frame, this_cache);
 464   return info->base;
 465 }
 466
 467 static const struct frame_unwind tic6x_frame_unwind =
 468 {
 469   NORMAL_FRAME,
 470   default_frame_unwind_stop_reason,
 471   tic6x_frame_this_id,
 472   tic6x_frame_prev_register,
 473   NULL,
 474   default_frame_sniffer
 475 };
 476
 477 static const struct frame_base tic6x_frame_base =
 478 {
 479   &tic6x_frame_unwind,
 480   tic6x_frame_base_address,
 481   tic6x_frame_base_address,
 482   tic6x_frame_base_address
 483 };
 484
 485
 486 static struct tic6x_unwind_cache *
 487 tic6x_make_stub_cache (struct frame_info *this_frame)
 488 {
 489   struct tic6x_unwind_cache *cache;
 490
 491   cache = FRAME_OBSTACK_ZALLOC (struct tic6x_unwind_cache);
 492
 493   cache->return_regnum = TIC6X_RA_REGNUM;
 494
 495   tic6x_setup_default (cache);
 496
 497   cache->cfa = get_frame_register_unsigned (this_frame, TIC6X_SP_REGNUM);
 498
 499   return cache;
 500 }
 501
 502 static void
 503 tic6x_stub_this_id (struct frame_info *this_frame, void **this_cache,
 504                     struct frame_id *this_id)
 505 {
 506   struct tic6x_unwind_cache *cache;
 507
 508   if (*this_cache == NULL)
 509     *this_cache = tic6x_make_stub_cache (this_frame);
 510   cache = (struct tic6x_unwind_cache *) *this_cache;
 511
 512   *this_id = frame_id_build (cache->cfa, get_frame_pc (this_frame));
 513 }
 514
 515 static int
 516 tic6x_stub_unwind_sniffer (const struct frame_unwind *self,
 517                            struct frame_info *this_frame,
 518                            void **this_prologue_cache)
 519 {
 520   CORE_ADDR addr_in_block;
 521
 522   addr_in_block = get_frame_address_in_block (this_frame);
 523   if (in_plt_section (addr_in_block))
 524     return 1;
 525
 526   return 0;
 527 }
 528
 529 static const struct frame_unwind tic6x_stub_unwind =
 530 {
 531   NORMAL_FRAME,
 532   default_frame_unwind_stop_reason,
 533   tic6x_stub_this_id,
 534   tic6x_frame_prev_register,
 535   NULL,
 536   tic6x_stub_unwind_sniffer
 537 };
 538
 539 /* Return the instruction on address PC.  */
 540
 541 static unsigned long
 542 tic6x_fetch_instruction (struct gdbarch *gdbarch, CORE_ADDR pc)
 543 {
 544   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 545   return read_memory_unsigned_integer (pc, TIC6X_OPCODE_SIZE, byte_order);
 546 }
 547
 548 /* Compute the condition of INST if it is a conditional instruction.  Always
 549    return 1 if INST is not a conditional instruction.  */
 550
 551 static int
 552 tic6x_condition_true (struct regcache *regcache, unsigned long inst)
 553 {
 554   int register_number;
 555   int register_value;
 556   static const int register_numbers[8] = { -1, 16, 17, 18, 1, 2, 0, -1 };
 557
 558   register_number = register_numbers[(inst >> 29) & 7];
 559   if (register_number == -1)
 560     return 1;
 561
 562   register_value = regcache_raw_get_signed (regcache, register_number);
 563   if ((inst & 0x10000000) != 0)
 564     return register_value == 0;
 565   return register_value != 0;
 566 }
 567
 568 /* Get the register number by decoding raw bits REG, SIDE, and CROSSPATH in
 569    instruction.  */
 570
 571 static int
 572 tic6x_register_number (int reg, int side, int crosspath)
 573 {
 574   int r = (reg & 15) | ((crosspath ^ side) << 4);
 575   if ((reg & 16) != 0) /* A16 - A31, B16 - B31 */
 576     r += 37;
 577   return r;
 578 }
 579
 580 static int
 581 tic6x_extract_signed_field (int value, int low_bit, int bits)
 582 {
 583   int mask = (1 << bits) - 1;
 584   int r = (value >> low_bit) & mask;
 585   if ((r & (1 << (bits - 1))) != 0)
 586     r -= mask + 1;
 587   return r;
 588 }
 589
 590 /* Determine where to set a single step breakpoint.  */
 591
 592 static CORE_ADDR
 593 tic6x_get_next_pc (struct regcache *regcache, CORE_ADDR pc)
 594 {
 595   struct gdbarch *gdbarch = regcache->arch ();
 596   unsigned long inst;
 597   int register_number;
 598   int last = 0;
 599
 600   do
 601     {
 602       inst = tic6x_fetch_instruction (gdbarch, pc);
 603
 604       last = !(inst & 1);
 605
 606       if (inst == TIC6X_INST_SWE)
 607         {
 608           struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 609
 610           if (tdep->syscall_next_pc != NULL)
 611             return tdep->syscall_next_pc (get_current_frame ());
 612         }
 613
 614       if (tic6x_condition_true (regcache, inst))
 615         {
 616           if ((inst & 0x0000007c) == 0x00000010)
 617             {
 618               /* B with displacement */
 619               pc &= ~(TIC6X_FETCH_PACKET_SIZE - 1);
 620               pc += tic6x_extract_signed_field (inst, 7, 21) << 2;
 621               break;
 622             }
 623           if ((inst & 0x0f83effc) == 0x00000360)
 624             {
 625               /* B with register */
 626
 627               register_number = tic6x_register_number ((inst >> 18) & 0x1f,
 628                                                        INST_S_BIT (inst),
 629                                                        INST_X_BIT (inst));
 630               pc = regcache_raw_get_unsigned (regcache, register_number);
 631               break;
 632             }
 633           if ((inst & 0x00001ffc) == 0x00001020)
 634             {
 635               /* BDEC */
 636               register_number = tic6x_register_number ((inst >> 23) & 0x1f,
 637                                                        INST_S_BIT (inst), 0);
 638               if (regcache_raw_get_signed (regcache, register_number) >= 0)
 639                 {
 640                   pc &= ~(TIC6X_FETCH_PACKET_SIZE - 1);
 641                   pc += tic6x_extract_signed_field (inst, 7, 10) << 2;
 642                 }
 643               break;
 644             }
 645           if ((inst & 0x00001ffc) == 0x00000120)
 646             {
 647               /* BNOP with displacement */
 648               pc &= ~(TIC6X_FETCH_PACKET_SIZE - 1);
 649               pc += tic6x_extract_signed_field (inst, 16, 12) << 2;
 650               break;
 651             }
 652           if ((inst & 0x0f830ffe) == 0x00800362)
 653             {
 654               /* BNOP with register */
 655               register_number = tic6x_register_number ((inst >> 18) & 0x1f,
 656                                                        1, INST_X_BIT (inst));
 657               pc = regcache_raw_get_unsigned (regcache, register_number);
 658               break;
 659             }
 660           if ((inst & 0x00001ffc) == 0x00000020)
 661             {
 662               /* BPOS */
 663               register_number = tic6x_register_number ((inst >> 23) & 0x1f,
 664                                                        INST_S_BIT (inst), 0);
 665               if (regcache_raw_get_signed (regcache, register_number) >= 0)
 666                 {
 667                   pc &= ~(TIC6X_FETCH_PACKET_SIZE - 1);
 668                   pc += tic6x_extract_signed_field (inst, 13, 10) << 2;
 669                 }
 670               break;
 671             }
 672           if ((inst & 0xf000007c) == 0x10000010)
 673             {
 674               /* CALLP */
 675               pc &= ~(TIC6X_FETCH_PACKET_SIZE - 1);
 676               pc += tic6x_extract_signed_field (inst, 7, 21) << 2;
 677               break;
 678             }
 679         }
 680       pc += TIC6X_OPCODE_SIZE;
 681     }
 682   while (!last);
 683   return pc;
 684 }
 685
 686 /* This is the implementation of gdbarch method software_single_step.  */
 687
 688 static std::vector<CORE_ADDR>
 689 tic6x_software_single_step (struct regcache *regcache)
 690 {
 691   CORE_ADDR next_pc = tic6x_get_next_pc (regcache, regcache_read_pc (regcache));
 692
 693   return {next_pc};
 694 }
 695
 696 /* This is the implementation of gdbarch method frame_align.  */
 697
 698 static CORE_ADDR
 699 tic6x_frame_align (struct gdbarch *gdbarch, CORE_ADDR addr)
 700 {
 701   return align_down (addr, 8);
 702 }
 703
 704 /* Given a return value in REGCACHE with a type VALTYPE, extract and copy its
 705    value into VALBUF.  */
 706
 707 static void
 708 tic6x_extract_return_value (struct type *valtype, struct regcache *regcache,
 709                             enum bfd_endian byte_order, gdb_byte *valbuf)
 710 {
 711   int len = TYPE_LENGTH (valtype);
 712
 713   /* pointer types are returned in register A4,
 714      up to 32-bit types in A4
 715      up to 64-bit types in A5:A4  */
 716   if (len <= 4)
 717     {
 718       /* In big-endian,
 719          - one-byte structure or union occupies the LSB of single even register.
 720          - for two-byte structure or union, the first byte occupies byte 1 of
 721          register and the second byte occupies byte 0.
 722          so, we read the contents in VAL from the LSBs of register.  */
 723       if (len < 3 && byte_order == BFD_ENDIAN_BIG)
 724         regcache->cooked_read_part (TIC6X_A4_REGNUM, 4 - len, len, valbuf);
 725       else
 726         regcache->cooked_read (TIC6X_A4_REGNUM, valbuf);
 727     }
 728   else if (len <= 8)
 729     {
 730       /* For a 5-8 byte structure or union in big-endian, the first byte
 731          occupies byte 3 (the MSB) of the upper (odd) register and the
 732          remaining bytes fill the decreasingly significant bytes.  5-7
 733          byte structures or unions have padding in the LSBs of the
 734          lower (even) register.  */
 735       if (byte_order == BFD_ENDIAN_BIG)
 736         {
 737           regcache->cooked_read (TIC6X_A4_REGNUM, valbuf + 4);
 738           regcache->cooked_read (TIC6X_A5_REGNUM, valbuf);
 739         }
 740       else
 741         {
 742           regcache->cooked_read (TIC6X_A4_REGNUM, valbuf);
 743           regcache->cooked_read (TIC6X_A5_REGNUM, valbuf + 4);
 744         }
 745     }
 746 }
 747
 748 /* Write into appropriate registers a function return value
 749    of type TYPE, given in virtual format.  */
 750
 751 static void
 752 tic6x_store_return_value (struct type *valtype, struct regcache *regcache,
 753                           enum bfd_endian byte_order, const gdb_byte *valbuf)
 754 {
 755   int len = TYPE_LENGTH (valtype);
 756
 757   /* return values of up to 8 bytes are returned in A5:A4 */
 758
 759   if (len <= 4)
 760     {
 761       if (len < 3 && byte_order == BFD_ENDIAN_BIG)
 762         regcache->cooked_write_part (TIC6X_A4_REGNUM, 4 - len, len, valbuf);
 763       else
 764         regcache->cooked_write (TIC6X_A4_REGNUM, valbuf);
 765     }
 766   else if (len <= 8)
 767     {
 768       if (byte_order == BFD_ENDIAN_BIG)
 769         {
 770           regcache->cooked_write (TIC6X_A4_REGNUM, valbuf + 4);
 771           regcache->cooked_write (TIC6X_A5_REGNUM, valbuf);
 772         }
 773       else
 774         {
 775           regcache->cooked_write (TIC6X_A4_REGNUM, valbuf);
 776           regcache->cooked_write (TIC6X_A5_REGNUM, valbuf + 4);
 777         }
 778     }
 779 }
 780
 781 /* This is the implementation of gdbarch method return_value.  */
 782
 783 static enum return_value_convention
 784 tic6x_return_value (struct gdbarch *gdbarch, struct value *function,
 785                     struct type *type, struct regcache *regcache,
 786                     gdb_byte *readbuf, const gdb_byte *writebuf)
 787 {
 788   /* In C++, when function returns an object, even its size is small
 789      enough, it stii has to be passed via reference, pointed by register
 790      A3.  */
 791   if (current_language->la_language == language_cplus)
 792     {
 793       if (type != NULL)
 794         {
 795           type = check_typedef (type);
 796           if (language_pass_by_reference (type))
 797             return RETURN_VALUE_STRUCT_CONVENTION;
 798         }
 799     }
 800
 801   if (TYPE_LENGTH (type) > 8)
 802     return RETURN_VALUE_STRUCT_CONVENTION;
 803
 804   if (readbuf)
 805     tic6x_extract_return_value (type, regcache,
 806                                 gdbarch_byte_order (gdbarch), readbuf);
 807   if (writebuf)
 808     tic6x_store_return_value (type, regcache,
 809                               gdbarch_byte_order (gdbarch), writebuf);
 810
 811   return RETURN_VALUE_REGISTER_CONVENTION;
 812 }
 813
 814 /* This is the implementation of gdbarch method dummy_id.  */
 815
 816 static struct frame_id
 817 tic6x_dummy_id (struct gdbarch *gdbarch, struct frame_info *this_frame)
 818 {
 819   return frame_id_build
 820     (get_frame_register_unsigned (this_frame, TIC6X_SP_REGNUM),
 821      get_frame_pc (this_frame));
 822 }
 823
 824 /* Get the alignment requirement of TYPE.  */
 825
 826 static int
 827 tic6x_arg_type_alignment (struct type *type)
 828 {
 829   int len = TYPE_LENGTH (check_typedef (type));
 830   enum type_code typecode = TYPE_CODE (check_typedef (type));
 831
 832   if (typecode == TYPE_CODE_STRUCT || typecode == TYPE_CODE_UNION)
 833     {
 834       /* The stack alignment of a structure (and union) passed by value is the
 835          smallest power of two greater than or equal to its size.
 836          This cannot exceed 8 bytes, which is the largest allowable size for
 837          a structure passed by value.  */
 838
 839       if (len <= 2)
 840         return len;
 841       else if (len <= 4)
 842         return 4;
 843       else if (len <= 8)
 844         return 8;
 845       else
 846         gdb_assert_not_reached ("unexpected length of data");
 847     }
 848   else
 849     {
 850       if (len <= 4)
 851         return 4;
 852       else if (len == 8)
 853         {
 854           if (typecode == TYPE_CODE_COMPLEX)
 855             return 4;
 856           else
 857             return 8;
 858         }
 859       else if (len == 16)
 860         {
 861           if (typecode == TYPE_CODE_COMPLEX)
 862             return 8;
 863           else
 864             return 16;
 865         }
 866       else
 867         internal_error (__FILE__, __LINE__, _("unexpected length %d of type"),
 868                         len);
 869     }
 870 }
 871
 872 /* This is the implementation of gdbarch method push_dummy_call.  */
 873
 874 static CORE_ADDR
 875 tic6x_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
 876                        struct regcache *regcache, CORE_ADDR bp_addr,
 877                        int nargs, struct value **args, CORE_ADDR sp,
 878                        function_call_return_method return_method,
 879                        CORE_ADDR struct_addr)
 880 {
 881   int argreg = 0;
 882   int argnum;
 883   int stack_offset = 4;
 884   int references_offset = 4;
 885   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 886   struct type *func_type = value_type (function);
 887   /* The first arg passed on stack.  Mostly the first 10 args are passed by
 888      registers.  */
 889   int first_arg_on_stack = 10;
 890
 891   /* Set the return address register to point to the entry point of
 892      the program, where a breakpoint lies in wait.  */
 893   regcache_cooked_write_unsigned (regcache, TIC6X_RA_REGNUM, bp_addr);
 894
 895   /* The caller must pass an argument in A3 containing a destination address
 896      for the returned value.  The callee returns the object by copying it to
 897      the address in A3.  */
 898   if (return_method == return_method_struct)
 899     regcache_cooked_write_unsigned (regcache, 3, struct_addr);
 900
 901   /* Determine the type of this function.  */
 902   func_type = check_typedef (func_type);
 903   if (TYPE_CODE (func_type) == TYPE_CODE_PTR)
 904     func_type = check_typedef (TYPE_TARGET_TYPE (func_type));
 905
 906   gdb_assert (TYPE_CODE (func_type) == TYPE_CODE_FUNC
 907               || TYPE_CODE (func_type) == TYPE_CODE_METHOD);
 908
 909   /* For a variadic C function, the last explicitly declared argument and all
 910      remaining arguments are passed on the stack.  */
 911   if (TYPE_VARARGS (func_type))
 912     first_arg_on_stack = TYPE_NFIELDS (func_type) - 1;
 913
 914   /* Now make space on the stack for the args.  */
 915   for (argnum = 0; argnum < nargs; argnum++)
 916     {
 917       int len = align_up (TYPE_LENGTH (value_type (args[argnum])), 4);
 918       if (argnum >= 10 - argreg)
 919         references_offset += len;
 920       stack_offset += len;
 921     }
 922   sp -= stack_offset;
 923   /* SP should be 8-byte aligned, see C6000 ABI section 4.4.1
 924      Stack Alignment.  */
 925   sp = align_down (sp, 8);
 926   stack_offset = 4;
 927
 928   /* Now load as many as possible of the first arguments into
 929      registers, and push the rest onto the stack.  Loop through args
 930      from first to last.  */
 931   for (argnum = 0; argnum < nargs; argnum++)
 932     {
 933       const gdb_byte *val;
 934       struct value *arg = args[argnum];
 935       struct type *arg_type = check_typedef (value_type (arg));
 936       int len = TYPE_LENGTH (arg_type);
 937       enum type_code typecode = TYPE_CODE (arg_type);
 938
 939       val = value_contents (arg);
 940
 941       /* Copy the argument to general registers or the stack in
 942          register-sized pieces.  */
 943       if (argreg < first_arg_on_stack)
 944         {
 945           if (len <= 4)
 946             {
 947               if (typecode == TYPE_CODE_STRUCT || typecode == TYPE_CODE_UNION)
 948                 {
 949                   /* In big-endian,
 950                      - one-byte structure or union occupies the LSB of single
 951                      even register.
 952                      - for two-byte structure or union, the first byte
 953                      occupies byte 1 of register and the second byte occupies
 954                      byte 0.
 955                      so, we write the contents in VAL to the lsp of
 956                      register.  */
 957                   if (len < 3 && byte_order == BFD_ENDIAN_BIG)
 958                     regcache->cooked_write_part (arg_regs[argreg], 4 - len, len,
 959                                                  val);
 960                   else
 961                     regcache->cooked_write (arg_regs[argreg], val);
 962                 }
 963               else
 964                 {
 965                   /* The argument is being passed by value in a single
 966                      register.  */
 967                   CORE_ADDR regval = extract_unsigned_integer (val, len,
 968                                                                byte_order);
 969
 970                   regcache_cooked_write_unsigned (regcache, arg_regs[argreg],
 971                                                   regval);
 972                 }
 973             }
 974           else
 975             {
 976               if (len <= 8)
 977                 {
 978                   if (typecode == TYPE_CODE_STRUCT
 979                       || typecode == TYPE_CODE_UNION)
 980                     {
 981                       /* For a 5-8 byte structure or union in big-endian, the
 982                          first byte occupies byte 3 (the MSB) of the upper (odd)
 983                          register and the remaining bytes fill the decreasingly
 984                          significant bytes.  5-7 byte structures or unions have
 985                          padding in the LSBs of the lower (even) register.  */
 986                       if (byte_order == BFD_ENDIAN_BIG)
 987                         {
 988                           regcache->cooked_write (arg_regs[argreg] + 1, val);
 989                           regcache->cooked_write_part (arg_regs[argreg], 0,
 990                                                        len - 4, val + 4);
 991                         }
 992                       else
 993                         {
 994                           regcache->cooked_write (arg_regs[argreg], val);
 995                           regcache->cooked_write_part (arg_regs[argreg] + 1, 0,
 996                                                        len - 4, val + 4);
 997                         }
 998                     }
 999                   else
1000                     {
1001                       /* The argument is being passed by value in a pair of
1002                          registers.  */
1003                       ULONGEST regval = extract_unsigned_integer (val, len,
1004                                                                   byte_order);
1005
1006                       regcache_cooked_write_unsigned (regcache,
1007                                                       arg_regs[argreg],
1008                                                       regval);
1009                       regcache_cooked_write_unsigned (regcache,
1010                                                       arg_regs[argreg] + 1,
1011                                                       regval >> 32);
1012                     }
1013                 }
1014               else
1015                 {
1016                   /* The argument is being passed by reference in a single
1017                      register.  */
1018                   CORE_ADDR addr;
1019
1020                   /* It is not necessary to adjust REFERENCES_OFFSET to
1021                      8-byte aligned in some cases, in which 4-byte alignment
1022                      is sufficient.  For simplicity, we adjust
1023                      REFERENCES_OFFSET to 8-byte aligned.  */
1024                   references_offset = align_up (references_offset, 8);
1025
1026                   addr = sp + references_offset;
1027                   write_memory (addr, val, len);
1028                   references_offset += align_up (len, 4);
1029                   regcache_cooked_write_unsigned (regcache, arg_regs[argreg],
1030                                                   addr);
1031                 }
1032             }
1033           argreg++;
1034         }
1035       else
1036         {
1037           /* The argument is being passed on the stack.  */
1038           CORE_ADDR addr;
1039
1040           /* There are six different cases of alignment, and these rules can
1041              be found in tic6x_arg_type_alignment:
1042
1043              1) 4-byte aligned if size is less than or equal to 4 byte, such
1044              as short, int, struct, union etc.
1045              2) 8-byte aligned if size is less than or equal to 8-byte, such
1046              as double, long long,
1047              3) 4-byte aligned if it is of type _Complex float, even its size
1048              is 8-byte.
1049              4) 8-byte aligned if it is of type _Complex double or _Complex
1050              long double, even its size is 16-byte.  Because, the address of
1051              variable is passed as reference.
1052              5) struct and union larger than 8-byte are passed by reference, so
1053              it is 4-byte aligned.
1054              6) struct and union of size between 4 byte and 8 byte varies.
1055              alignment of struct variable is the alignment of its first field,
1056              while alignment of union variable is the max of all its fields'
1057              alignment.  */
1058
1059           if (len <= 4)
1060             ; /* Default is 4-byte aligned.  Nothing to be done.  */
1061           else if (len <= 8)
1062             stack_offset = align_up (stack_offset,
1063                                      tic6x_arg_type_alignment (arg_type));
1064           else if (len == 16)
1065             {
1066               /* _Complex double or _Complex long double */
1067               if (typecode == TYPE_CODE_COMPLEX)
1068                 {
1069                   /* The argument is being passed by reference on stack.  */
1070                   references_offset = align_up (references_offset, 8);
1071
1072                   addr = sp + references_offset;
1073                   /* Store variable on stack.  */
1074                   write_memory (addr, val, len);
1075
1076                   references_offset += align_up (len, 4);
1077
1078                   /* Pass the address of variable on stack as reference.  */
1079                   store_unsigned_integer ((gdb_byte *) val, 4, byte_order,
1080                                           addr);
1081                   len = 4;
1082
1083                 }
1084               else
1085                 internal_error (__FILE__, __LINE__,
1086                                 _("unexpected type %d of arg %d"),
1087                                 typecode, argnum);
1088             }
1089           else
1090             internal_error (__FILE__, __LINE__,
1091                             _("unexpected length %d of arg %d"), len, argnum);
1092
1093           addr = sp + stack_offset;
1094           write_memory (addr, val, len);
1095           stack_offset += align_up (len, 4);
1096         }
1097     }
1098
1099   regcache_cooked_write_signed (regcache, TIC6X_SP_REGNUM, sp);
1100
1101   /* Return adjusted stack pointer.  */
1102   return sp;
1103 }
1104
1105 /* This is the implementation of gdbarch method stack_frame_destroyed_p.  */
1106
1107 static int
1108 tic6x_stack_frame_destroyed_p (struct gdbarch *gdbarch, CORE_ADDR pc)
1109 {
1110   unsigned long inst = tic6x_fetch_instruction (gdbarch, pc);
1111   /* Normally, the epilogue is composed by instruction `b .S2 b3'.  */
1112   if ((inst & 0x0f83effc) == 0x360)
1113     {
1114       unsigned int src2 = tic6x_register_number ((inst >> 18) & 0x1f,
1115                                                  INST_S_BIT (inst),
1116                                                  INST_X_BIT (inst));
1117       if (src2 == TIC6X_RA_REGNUM)
1118         return 1;
1119     }
1120
1121   return 0;
1122 }
1123
1124 /* This is the implementation of gdbarch method get_longjmp_target.  */
1125
1126 static int
1127 tic6x_get_longjmp_target (struct frame_info *frame, CORE_ADDR *pc)
1128 {
1129   struct gdbarch *gdbarch = get_frame_arch (frame);
1130   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1131   CORE_ADDR jb_addr;
1132   gdb_byte buf[4];
1133
1134   /* JMP_BUF is passed by reference in A4.  */
1135   jb_addr = get_frame_register_unsigned (frame, 4);
1136
1137   /* JMP_BUF contains 13 elements of type int, and return address is stored
1138      in the last slot.  */
1139   if (target_read_memory (jb_addr + 12 * 4, buf, 4))
1140     return 0;
1141
1142   *pc = extract_unsigned_integer (buf, 4, byte_order);
1143
1144   return 1;
1145 }
1146
1147 /* This is the implementation of gdbarch method
1148    return_in_first_hidden_param_p.  */
1149
1150 static int
1151 tic6x_return_in_first_hidden_param_p (struct gdbarch *gdbarch,
1152                                       struct type *type)
1153 {
1154   return 0;
1155 }
1156
1157 static struct gdbarch *
1158 tic6x_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
1159 {
1160   struct gdbarch *gdbarch;
1161   struct gdbarch_tdep *tdep;
1162   struct tdesc_arch_data *tdesc_data = NULL;
1163   const struct target_desc *tdesc = info.target_desc;
1164   int has_gp = 0;
1165
1166   /* Check any target description for validity.  */
1167   if (tdesc_has_registers (tdesc))
1168     {
1169       const struct tdesc_feature *feature;
1170       int valid_p, i;
1171
1172       feature = tdesc_find_feature (tdesc, "org.gnu.gdb.tic6x.core");
1173
1174       if (feature == NULL)
1175         return NULL;
1176
1177       tdesc_data = tdesc_data_alloc ();
1178
1179       valid_p = 1;
1180       for (i = 0; i < 32; i++)  /* A0 - A15, B0 - B15 */
1181         valid_p &= tdesc_numbered_register (feature, tdesc_data, i,
1182                                             tic6x_register_names[i]);
1183
1184       /* CSR */
1185       valid_p &= tdesc_numbered_register (feature, tdesc_data, i++,
1186                                           tic6x_register_names[TIC6X_CSR_REGNUM]);
1187       valid_p &= tdesc_numbered_register (feature, tdesc_data, i++,
1188                                           tic6x_register_names[TIC6X_PC_REGNUM]);
1189
1190       if (!valid_p)
1191         {
1192           tdesc_data_cleanup (tdesc_data);
1193           return NULL;
1194         }
1195
1196       feature = tdesc_find_feature (tdesc, "org.gnu.gdb.tic6x.gp");
1197       if (feature)
1198         {
1199           int j = 0;
1200           static const char *const gp[] =
1201             {
1202               "A16", "A17", "A18", "A19", "A20", "A21", "A22", "A23",
1203               "A24", "A25", "A26", "A27", "A28", "A29", "A30", "A31",
1204               "B16", "B17", "B18", "B19", "B20", "B21", "B22", "B23",
1205               "B24", "B25", "B26", "B27", "B28", "B29", "B30", "B31",
1206             };
1207
1208           has_gp = 1;
1209           valid_p = 1;
1210           for (j = 0; j < 32; j++)      /* A16 - A31, B16 - B31 */
1211             valid_p &= tdesc_numbered_register (feature, tdesc_data, i++,
1212                                                 gp[j]);
1213
1214           if (!valid_p)
1215             {
1216               tdesc_data_cleanup (tdesc_data);
1217               return NULL;
1218             }
1219         }
1220
1221       feature = tdesc_find_feature (tdesc, "org.gnu.gdb.tic6x.c6xp");
1222       if (feature)
1223         {
1224           valid_p &= tdesc_numbered_register (feature, tdesc_data, i++, "TSR");
1225           valid_p &= tdesc_numbered_register (feature, tdesc_data, i++, "ILC");
1226           valid_p &= tdesc_numbered_register (feature, tdesc_data, i++, "RILC");
1227
1228           if (!valid_p)
1229             {
1230               tdesc_data_cleanup (tdesc_data);
1231               return NULL;
1232             }
1233         }
1234
1235     }
1236
1237   /* Find a candidate among extant architectures.  */
1238   for (arches = gdbarch_list_lookup_by_info (arches, &info);
1239        arches != NULL;
1240        arches = gdbarch_list_lookup_by_info (arches->next, &info))
1241     {
1242       tdep = gdbarch_tdep (arches->gdbarch);
1243
1244       if (has_gp != tdep->has_gp)
1245         continue;
1246
1247       if (tdep && tdep->breakpoint)
1248         return arches->gdbarch;
1249     }
1250
1251   tdep = XCNEW (struct gdbarch_tdep);
1252
1253   tdep->has_gp = has_gp;
1254   gdbarch = gdbarch_alloc (&info, tdep);
1255
1256   /* Data type sizes.  */
1257   set_gdbarch_ptr_bit (gdbarch, 32);
1258   set_gdbarch_addr_bit (gdbarch, 32);
1259   set_gdbarch_short_bit (gdbarch, 16);
1260   set_gdbarch_int_bit (gdbarch, 32);
1261   set_gdbarch_long_bit (gdbarch, 32);
1262   set_gdbarch_long_long_bit (gdbarch, 64);
1263   set_gdbarch_float_bit (gdbarch, 32);
1264   set_gdbarch_double_bit (gdbarch, 64);
1265
1266   set_gdbarch_float_format (gdbarch, floatformats_ieee_single);
1267   set_gdbarch_double_format (gdbarch, floatformats_ieee_double);
1268
1269   /* The register set.  */
1270   set_gdbarch_num_regs (gdbarch, TIC6X_NUM_REGS);
1271   set_gdbarch_sp_regnum (gdbarch, TIC6X_SP_REGNUM);
1272   set_gdbarch_pc_regnum (gdbarch, TIC6X_PC_REGNUM);
1273
1274   set_gdbarch_register_name (gdbarch, tic6x_register_name);
1275   set_gdbarch_register_type (gdbarch, tic6x_register_type);
1276
1277   set_gdbarch_inner_than (gdbarch, core_addr_lessthan);
1278
1279   set_gdbarch_skip_prologue (gdbarch, tic6x_skip_prologue);
1280   set_gdbarch_breakpoint_kind_from_pc (gdbarch,
1281                                        tic6x_breakpoint_kind_from_pc);
1282   set_gdbarch_sw_breakpoint_from_kind (gdbarch,
1283                                        tic6x_sw_breakpoint_from_kind);
1284
1285   set_gdbarch_unwind_pc (gdbarch, tic6x_unwind_pc);
1286   set_gdbarch_unwind_sp (gdbarch, tic6x_unwind_sp);
1287
1288   /* Unwinding.  */
1289   dwarf2_append_unwinders (gdbarch);
1290
1291   frame_unwind_append_unwinder (gdbarch, &tic6x_stub_unwind);
1292   frame_unwind_append_unwinder (gdbarch, &tic6x_frame_unwind);
1293   frame_base_set_default (gdbarch, &tic6x_frame_base);
1294
1295   dwarf2_frame_set_init_reg (gdbarch, tic6x_dwarf2_frame_init_reg);
1296
1297   /* Single stepping.  */
1298   set_gdbarch_software_single_step (gdbarch, tic6x_software_single_step);
1299
1300   /* Call dummy code.  */
1301   set_gdbarch_frame_align (gdbarch, tic6x_frame_align);
1302
1303   set_gdbarch_return_value (gdbarch, tic6x_return_value);
1304
1305   set_gdbarch_dummy_id (gdbarch, tic6x_dummy_id);
1306
1307   /* Enable inferior call support.  */
1308   set_gdbarch_push_dummy_call (gdbarch, tic6x_push_dummy_call);
1309
1310   set_gdbarch_get_longjmp_target (gdbarch, tic6x_get_longjmp_target);
1311
1312   set_gdbarch_stack_frame_destroyed_p (gdbarch, tic6x_stack_frame_destroyed_p);
1313
1314   set_gdbarch_return_in_first_hidden_param_p (gdbarch,
1315                                               tic6x_return_in_first_hidden_param_p);
1316
1317   /* Hook in ABI-specific overrides, if they have been registered.  */
1318   gdbarch_init_osabi (info, gdbarch);
1319
1320   if (tdesc_data)
1321     tdesc_use_registers (gdbarch, tdesc, tdesc_data);
1322
1323   return gdbarch;
1324 }
1325
1326 void
1327 _initialize_tic6x_tdep (void)
1328 {
1329   register_gdbarch_init (bfd_arch_tic6x, tic6x_gdbarch_init);
1330 }