gdb/tic6x-tdep.c

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