projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Fix test-cp-name-parser build, unused variable
[deliverable/binutils-gdb.git] / gdb / tic6x-tdep.c
CommitLineData
8cd64e00
YQ		 1/* Target dependent code for GDB on TI C6x systems.
2
42a4f53d 3 Copyright (C) 2010-2019 Free Software Foundation, Inc.
8cd64e00
YQ		 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"
8cd64e00
YQ		 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"
8cd64e00
YQ		 46#include "osabi.h"
47#include "tic6x-tdep.h"
48#include "language.h"
49#include "target-descriptions.h"
325fac50 50#include <algorithm>
8cd64e00 51
8cd64e00
YQ		 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
85661b1e
YQ		 58const gdb_byte tic6x_bkpt_illegal_opcode_be[] = { 0x56, 0x45, 0x43, 0x14 };
59const gdb_byte tic6x_bkpt_illegal_opcode_le[] = { 0x14, 0x43, 0x45, 0x56 };
60
8cd64e00
YQ		 61struct 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. */
83static 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. */
98static 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
102static const char *
103tic6x_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
118static struct type *
119tic6x_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
128static void
129tic6x_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
137static unsigned long tic6x_fetch_instruction (struct gdbarch *, CORE_ADDR);
138static 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
693be288 144static CORE_ADDR
8cd64e00
YQ		 145tic6x_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{
8cd64e00
YQ		 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 {
8cd64e00
YQ		 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 */
b926417a 244 unsigned long inst = tic6x_fetch_instruction (gdbarch, pc);
8cd64e00
YQ		 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
693be288 292static CORE_ADDR
8cd64e00
YQ		 293tic6x_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR start_pc)
294{
8cd64e00
YQ		 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)
325fac50 306 return std::max (start_pc, post_prologue_pc);
8cd64e00
YQ		 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
cd6c3b4f
YQ		 315/* Implement the breakpoint_kind_from_pc gdbarch method. */
316
d19280ad
YQ		 317static int
318tic6x_breakpoint_kind_from_pc (struct gdbarch *gdbarch, CORE_ADDR *pcptr)
319{
320 return 4;
321}
8cd64e00 322
cd6c3b4f
YQ		 323/* Implement the sw_breakpoint_from_kind gdbarch method. */
324
948f8e3d 325static const gdb_byte *
d19280ad 326tic6x_sw_breakpoint_from_kind (struct gdbarch *gdbarch, int kind, int *size)
8cd64e00
YQ		 327{
328 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
329
d19280ad 330 *size = kind;
8cd64e00
YQ		 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
8cd64e00
YQ		 343static void
344tic6x_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
370static CORE_ADDR
371tic6x_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
381static CORE_ADDR
382tic6x_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
693be288 390static struct tic6x_unwind_cache*
8cd64e00
YQ		 391tic6x_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;
8cd64e00
YQ		 397
398 if (*this_prologue_cache)
19ba03f4 399 return (struct tic6x_unwind_cache *) *this_prologue_cache;
8cd64e00
YQ		 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
418static void
419tic6x_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
432static struct value *
433tic6x_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
459static CORE_ADDR
460tic6x_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
467static 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
477static 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
486static struct tic6x_unwind_cache *
487tic6x_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
502static void
503tic6x_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);
19ba03f4 510 cache = (struct tic6x_unwind_cache *) *this_cache;
8cd64e00
YQ		 511
512 *this_id = frame_id_build (cache->cfa, get_frame_pc (this_frame));
513}
514
515static int
516tic6x_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);
3e5d3a5a 523 if (in_plt_section (addr_in_block))
8cd64e00
YQ		 524 return 1;
525
526 return 0;
527}
528
529static 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
541static unsigned long
542tic6x_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
551static int
fb090cfa 552tic6x_condition_true (struct regcache *regcache, unsigned long inst)
8cd64e00
YQ		 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
fb090cfa 562 register_value = regcache_raw_get_signed (regcache, register_number);
8cd64e00
YQ		 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
571static int
572tic6x_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
580static int
581tic6x_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
592static CORE_ADDR
fb090cfa 593tic6x_get_next_pc (struct regcache *regcache, CORE_ADDR pc)
8cd64e00 594{
ac7936df 595 struct gdbarch *gdbarch = regcache->arch ();
8cd64e00 596 unsigned long inst;
8cd64e00
YQ		 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)
fb090cfa 611 return tdep->syscall_next_pc (get_current_frame ());
8cd64e00
YQ		 612 }
613
fb090cfa 614 if (tic6x_condition_true (regcache, inst))
8cd64e00
YQ		 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));
fb090cfa 630 pc = regcache_raw_get_unsigned (regcache, register_number);
8cd64e00
YQ		 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);
fb090cfa 638 if (regcache_raw_get_signed (regcache, register_number) >= 0)
8cd64e00
YQ		 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));
fb090cfa 657 pc = regcache_raw_get_unsigned (regcache, register_number);
8cd64e00
YQ		 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);
fb090cfa 665 if (regcache_raw_get_signed (regcache, register_number) >= 0)
8cd64e00
YQ		 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
a0ff9e1a 688static std::vector<CORE_ADDR>
f5ea389a 689tic6x_software_single_step (struct regcache *regcache)
8cd64e00 690{
fb090cfa 691 CORE_ADDR next_pc = tic6x_get_next_pc (regcache, regcache_read_pc (regcache));
8cd64e00 692
a0ff9e1a 693 return {next_pc};
8cd64e00
YQ		 694}
695
696/* This is the implementation of gdbarch method frame_align. */
697
698static CORE_ADDR
699tic6x_frame_align (struct gdbarch *gdbarch, CORE_ADDR addr)
700{
701 return align_down (addr, 8);
702}
703
8cd64e00
YQ		 704/* Given a return value in REGCACHE with a type VALTYPE, extract and copy its
705 value into VALBUF. */
706
707static void
708tic6x_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)
73bb0000 724 regcache->cooked_read_part (TIC6X_A4_REGNUM, 4 - len, len, valbuf);
8cd64e00 725 else
dca08e1f 726 regcache->cooked_read (TIC6X_A4_REGNUM, valbuf);
8cd64e00
YQ		 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 {
dca08e1f
SM		 737 regcache->cooked_read (TIC6X_A4_REGNUM, valbuf + 4);
738 regcache->cooked_read (TIC6X_A5_REGNUM, valbuf);
8cd64e00
YQ		 739 }
740 else
741 {
dca08e1f
SM		 742 regcache->cooked_read (TIC6X_A4_REGNUM, valbuf);
743 regcache->cooked_read (TIC6X_A5_REGNUM, valbuf + 4);
8cd64e00
YQ		 744 }
745 }
746}
747
748/* Write into appropriate registers a function return value
749 of type TYPE, given in virtual format. */
750
751static void
752tic6x_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)
e4c4a59b 762 regcache->cooked_write_part (TIC6X_A4_REGNUM, 4 - len, len, valbuf);
8cd64e00 763 else
b66f5587 764 regcache->cooked_write (TIC6X_A4_REGNUM, valbuf);
8cd64e00
YQ		 765 }
766 else if (len <= 8)
767 {
768 if (byte_order == BFD_ENDIAN_BIG)
769 {
b66f5587
SM		 770 regcache->cooked_write (TIC6X_A4_REGNUM, valbuf + 4);
771 regcache->cooked_write (TIC6X_A5_REGNUM, valbuf);
8cd64e00
YQ		 772 }
773 else
774 {
b66f5587
SM		 775 regcache->cooked_write (TIC6X_A4_REGNUM, valbuf);
776 regcache->cooked_write (TIC6X_A5_REGNUM, valbuf + 4);
8cd64e00
YQ		 777 }
778 }
779}
780
781/* This is the implementation of gdbarch method return_value. */
782
783static enum return_value_convention
6a3a010b 784tic6x_return_value (struct gdbarch *gdbarch, struct value *function,
8cd64e00
YQ		 785 struct type *type, struct regcache *regcache,
786 gdb_byte *readbuf, const gdb_byte *writebuf)
787{
18648a37
YQ		 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 {
f168693b 795 type = check_typedef (type);
18648a37
YQ		 796 if (language_pass_by_reference (type))
797 return RETURN_VALUE_STRUCT_CONVENTION;
798 }
799 }
800
8cd64e00
YQ		 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
816static struct frame_id
817tic6x_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
826static int
827tic6x_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
874static CORE_ADDR
875tic6x_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,
cf84fa6b
AH		 878 function_call_return_method return_method,
879 CORE_ADDR struct_addr)
8cd64e00
YQ		 880{
881 int argreg = 0;
882 int argnum;
8cd64e00
YQ		 883 int stack_offset = 4;
884 int references_offset = 4;
8cd64e00
YQ		 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;
8cd64e00 890
8cd64e00
YQ		 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. */
cf84fa6b 898 if (return_method == return_method_struct)
8cd64e00 899 regcache_cooked_write_unsigned (regcache, 3, struct_addr);
8cd64e00
YQ		 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
18648a37
YQ		 914 /* Now make space on the stack for the args. */
915 for (argnum = 0; argnum < nargs; argnum++)
8cd64e00
YQ		 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. */
18648a37 931 for (argnum = 0; argnum < nargs; argnum++)
8cd64e00
YQ		 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)
e4c4a59b
SM		 958 regcache->cooked_write_part (arg_regs[argreg], 4 - len, len,
959 val);
8cd64e00 960 else
b66f5587 961 regcache->cooked_write (arg_regs[argreg], val);
8cd64e00
YQ		 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 {
b66f5587 988 regcache->cooked_write (arg_regs[argreg] + 1, val);
e4c4a59b
SM		 989 regcache->cooked_write_part (arg_regs[argreg], 0,
990 len - 4, val + 4);
8cd64e00
YQ		 991 }
992 else
993 {
b66f5587 994 regcache->cooked_write (arg_regs[argreg], val);
e4c4a59b
SM		 995 regcache->cooked_write_part (arg_regs[argreg] + 1, 0,
996 len - 4, val + 4);
8cd64e00
YQ		 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. */
8cd64e00
YQ		 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
c9cf6e20 1105/* This is the implementation of gdbarch method stack_frame_destroyed_p. */
8cd64e00
YQ		 1106
1107static int
c9cf6e20 1108tic6x_stack_frame_destroyed_p (struct gdbarch *gdbarch, CORE_ADDR pc)
8cd64e00
YQ		 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
1126static int
1127tic6x_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;
e362b510 1132 gdb_byte buf[4];
8cd64e00
YQ		 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
18648a37
YQ		 1147/* This is the implementation of gdbarch method
1148 return_in_first_hidden_param_p. */
1149
1150static int
1151tic6x_return_in_first_hidden_param_p (struct gdbarch *gdbarch,
1152 struct type *type)
1153{
1154 return 0;
1155}
1156
8cd64e00
YQ		 1157static struct gdbarch *
1158tic6x_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
8d749320 1251 tdep = XCNEW (struct gdbarch_tdep);
8cd64e00
YQ		 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);
04180708
YQ		 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);
8cd64e00
YQ		 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);
195abc10 1293 frame_base_set_default (gdbarch, &tic6x_frame_base);
8cd64e00
YQ		 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
8cd64e00
YQ		 1300 /* Call dummy code. */
1301 set_gdbarch_frame_align (gdbarch, tic6x_frame_align);
1302
8cd64e00
YQ		 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
c9cf6e20 1312 set_gdbarch_stack_frame_destroyed_p (gdbarch, tic6x_stack_frame_destroyed_p);
8cd64e00 1313
18648a37
YQ		 1314 set_gdbarch_return_in_first_hidden_param_p (gdbarch,
1315 tic6x_return_in_first_hidden_param_p);
1316
8cd64e00
YQ		 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
1326void
1327_initialize_tic6x_tdep (void)
1328{
1329 register_gdbarch_init (bfd_arch_tic6x, tic6x_gdbarch_init);
8cd64e00 1330}
GDB Binutils - Deliverables
This page took 1.257445 seconds and 4 git commands to generate.