Automatic date update in version.in
[external/binutils.git] / gdb / arm-tdep.c
1 /* Common target dependent code for GDB on ARM systems.
2
3    Copyright (C) 1988-2019 Free Software Foundation, Inc.
4
5    This file is part of GDB.
6
7    This program is free software; you can redistribute it and/or modify
8    it under the terms of the GNU General Public License as published by
9    the Free Software Foundation; either version 3 of the License, or
10    (at your option) any later version.
11
12    This program is distributed in the hope that it will be useful,
13    but WITHOUT ANY WARRANTY; without even the implied warranty of
14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15    GNU General Public License for more details.
16
17    You should have received a copy of the GNU General Public License
18    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
19
20 #include "defs.h"
21
22 #include <ctype.h>              /* XXX for isupper ().  */
23
24 #include "frame.h"
25 #include "inferior.h"
26 #include "infrun.h"
27 #include "gdbcmd.h"
28 #include "gdbcore.h"
29 #include "dis-asm.h"            /* For register styles.  */
30 #include "disasm.h"
31 #include "regcache.h"
32 #include "reggroups.h"
33 #include "target-float.h"
34 #include "value.h"
35 #include "arch-utils.h"
36 #include "osabi.h"
37 #include "frame-unwind.h"
38 #include "frame-base.h"
39 #include "trad-frame.h"
40 #include "objfiles.h"
41 #include "dwarf2-frame.h"
42 #include "gdbtypes.h"
43 #include "prologue-value.h"
44 #include "remote.h"
45 #include "target-descriptions.h"
46 #include "user-regs.h"
47 #include "observable.h"
48
49 #include "arch/arm.h"
50 #include "arch/arm-get-next-pcs.h"
51 #include "arm-tdep.h"
52 #include "gdb/sim-arm.h"
53
54 #include "elf-bfd.h"
55 #include "coff/internal.h"
56 #include "elf/arm.h"
57
58 #include "common/vec.h"
59
60 #include "record.h"
61 #include "record-full.h"
62 #include <algorithm>
63
64 #include "features/arm/arm-with-m.c"
65 #include "features/arm/arm-with-m-fpa-layout.c"
66 #include "features/arm/arm-with-m-vfp-d16.c"
67 #include "features/arm/arm-with-iwmmxt.c"
68 #include "features/arm/arm-with-vfpv2.c"
69 #include "features/arm/arm-with-vfpv3.c"
70 #include "features/arm/arm-with-neon.c"
71
72 #if GDB_SELF_TEST
73 #include "common/selftest.h"
74 #endif
75
76 static int arm_debug;
77
78 /* Macros for setting and testing a bit in a minimal symbol that marks
79    it as Thumb function.  The MSB of the minimal symbol's "info" field
80    is used for this purpose.
81
82    MSYMBOL_SET_SPECIAL  Actually sets the "special" bit.
83    MSYMBOL_IS_SPECIAL   Tests the "special" bit in a minimal symbol.  */
84
85 #define MSYMBOL_SET_SPECIAL(msym)                               \
86         MSYMBOL_TARGET_FLAG_1 (msym) = 1
87
88 #define MSYMBOL_IS_SPECIAL(msym)                                \
89         MSYMBOL_TARGET_FLAG_1 (msym)
90
91 /* Per-objfile data used for mapping symbols.  */
92 static const struct objfile_data *arm_objfile_data_key;
93
94 struct arm_mapping_symbol
95 {
96   bfd_vma value;
97   char type;
98 };
99 typedef struct arm_mapping_symbol arm_mapping_symbol_s;
100 DEF_VEC_O(arm_mapping_symbol_s);
101
102 struct arm_per_objfile
103 {
104   VEC(arm_mapping_symbol_s) **section_maps;
105 };
106
107 /* The list of available "set arm ..." and "show arm ..." commands.  */
108 static struct cmd_list_element *setarmcmdlist = NULL;
109 static struct cmd_list_element *showarmcmdlist = NULL;
110
111 /* The type of floating-point to use.  Keep this in sync with enum
112    arm_float_model, and the help string in _initialize_arm_tdep.  */
113 static const char *const fp_model_strings[] =
114 {
115   "auto",
116   "softfpa",
117   "fpa",
118   "softvfp",
119   "vfp",
120   NULL
121 };
122
123 /* A variable that can be configured by the user.  */
124 static enum arm_float_model arm_fp_model = ARM_FLOAT_AUTO;
125 static const char *current_fp_model = "auto";
126
127 /* The ABI to use.  Keep this in sync with arm_abi_kind.  */
128 static const char *const arm_abi_strings[] =
129 {
130   "auto",
131   "APCS",
132   "AAPCS",
133   NULL
134 };
135
136 /* A variable that can be configured by the user.  */
137 static enum arm_abi_kind arm_abi_global = ARM_ABI_AUTO;
138 static const char *arm_abi_string = "auto";
139
140 /* The execution mode to assume.  */
141 static const char *const arm_mode_strings[] =
142   {
143     "auto",
144     "arm",
145     "thumb",
146     NULL
147   };
148
149 static const char *arm_fallback_mode_string = "auto";
150 static const char *arm_force_mode_string = "auto";
151
152 /* The standard register names, and all the valid aliases for them.  Note
153    that `fp', `sp' and `pc' are not added in this alias list, because they
154    have been added as builtin user registers in
155    std-regs.c:_initialize_frame_reg.  */
156 static const struct
157 {
158   const char *name;
159   int regnum;
160 } arm_register_aliases[] = {
161   /* Basic register numbers.  */
162   { "r0", 0 },
163   { "r1", 1 },
164   { "r2", 2 },
165   { "r3", 3 },
166   { "r4", 4 },
167   { "r5", 5 },
168   { "r6", 6 },
169   { "r7", 7 },
170   { "r8", 8 },
171   { "r9", 9 },
172   { "r10", 10 },
173   { "r11", 11 },
174   { "r12", 12 },
175   { "r13", 13 },
176   { "r14", 14 },
177   { "r15", 15 },
178   /* Synonyms (argument and variable registers).  */
179   { "a1", 0 },
180   { "a2", 1 },
181   { "a3", 2 },
182   { "a4", 3 },
183   { "v1", 4 },
184   { "v2", 5 },
185   { "v3", 6 },
186   { "v4", 7 },
187   { "v5", 8 },
188   { "v6", 9 },
189   { "v7", 10 },
190   { "v8", 11 },
191   /* Other platform-specific names for r9.  */
192   { "sb", 9 },
193   { "tr", 9 },
194   /* Special names.  */
195   { "ip", 12 },
196   { "lr", 14 },
197   /* Names used by GCC (not listed in the ARM EABI).  */
198   { "sl", 10 },
199   /* A special name from the older ATPCS.  */
200   { "wr", 7 },
201 };
202
203 static const char *const arm_register_names[] =
204 {"r0",  "r1",  "r2",  "r3",     /*  0  1  2  3 */
205  "r4",  "r5",  "r6",  "r7",     /*  4  5  6  7 */
206  "r8",  "r9",  "r10", "r11",    /*  8  9 10 11 */
207  "r12", "sp",  "lr",  "pc",     /* 12 13 14 15 */
208  "f0",  "f1",  "f2",  "f3",     /* 16 17 18 19 */
209  "f4",  "f5",  "f6",  "f7",     /* 20 21 22 23 */
210  "fps", "cpsr" };               /* 24 25       */
211
212 /* Holds the current set of options to be passed to the disassembler.  */
213 static char *arm_disassembler_options;
214
215 /* Valid register name styles.  */
216 static const char **valid_disassembly_styles;
217
218 /* Disassembly style to use. Default to "std" register names.  */
219 static const char *disassembly_style;
220
221 /* This is used to keep the bfd arch_info in sync with the disassembly
222    style.  */
223 static void set_disassembly_style_sfunc (const char *, int,
224                                          struct cmd_list_element *);
225 static void show_disassembly_style_sfunc (struct ui_file *, int,
226                                           struct cmd_list_element *,
227                                           const char *);
228
229 static enum register_status arm_neon_quad_read (struct gdbarch *gdbarch,
230                                                 readable_regcache *regcache,
231                                                 int regnum, gdb_byte *buf);
232 static void arm_neon_quad_write (struct gdbarch *gdbarch,
233                                  struct regcache *regcache,
234                                  int regnum, const gdb_byte *buf);
235
236 static CORE_ADDR
237   arm_get_next_pcs_syscall_next_pc (struct arm_get_next_pcs *self);
238
239
240 /* get_next_pcs operations.  */
241 static struct arm_get_next_pcs_ops arm_get_next_pcs_ops = {
242   arm_get_next_pcs_read_memory_unsigned_integer,
243   arm_get_next_pcs_syscall_next_pc,
244   arm_get_next_pcs_addr_bits_remove,
245   arm_get_next_pcs_is_thumb,
246   NULL,
247 };
248
249 struct arm_prologue_cache
250 {
251   /* The stack pointer at the time this frame was created; i.e. the
252      caller's stack pointer when this function was called.  It is used
253      to identify this frame.  */
254   CORE_ADDR prev_sp;
255
256   /* The frame base for this frame is just prev_sp - frame size.
257      FRAMESIZE is the distance from the frame pointer to the
258      initial stack pointer.  */
259
260   int framesize;
261
262   /* The register used to hold the frame pointer for this frame.  */
263   int framereg;
264
265   /* Saved register offsets.  */
266   struct trad_frame_saved_reg *saved_regs;
267 };
268
269 static CORE_ADDR arm_analyze_prologue (struct gdbarch *gdbarch,
270                                        CORE_ADDR prologue_start,
271                                        CORE_ADDR prologue_end,
272                                        struct arm_prologue_cache *cache);
273
274 /* Architecture version for displaced stepping.  This effects the behaviour of
275    certain instructions, and really should not be hard-wired.  */
276
277 #define DISPLACED_STEPPING_ARCH_VERSION         5
278
279 /* Set to true if the 32-bit mode is in use.  */
280
281 int arm_apcs_32 = 1;
282
283 /* Return the bit mask in ARM_PS_REGNUM that indicates Thumb mode.  */
284
285 int
286 arm_psr_thumb_bit (struct gdbarch *gdbarch)
287 {
288   if (gdbarch_tdep (gdbarch)->is_m)
289     return XPSR_T;
290   else
291     return CPSR_T;
292 }
293
294 /* Determine if the processor is currently executing in Thumb mode.  */
295
296 int
297 arm_is_thumb (struct regcache *regcache)
298 {
299   ULONGEST cpsr;
300   ULONGEST t_bit = arm_psr_thumb_bit (regcache->arch ());
301
302   cpsr = regcache_raw_get_unsigned (regcache, ARM_PS_REGNUM);
303
304   return (cpsr & t_bit) != 0;
305 }
306
307 /* Determine if FRAME is executing in Thumb mode.  */
308
309 int
310 arm_frame_is_thumb (struct frame_info *frame)
311 {
312   CORE_ADDR cpsr;
313   ULONGEST t_bit = arm_psr_thumb_bit (get_frame_arch (frame));
314
315   /* Every ARM frame unwinder can unwind the T bit of the CPSR, either
316      directly (from a signal frame or dummy frame) or by interpreting
317      the saved LR (from a prologue or DWARF frame).  So consult it and
318      trust the unwinders.  */
319   cpsr = get_frame_register_unsigned (frame, ARM_PS_REGNUM);
320
321   return (cpsr & t_bit) != 0;
322 }
323
324 /* Callback for VEC_lower_bound.  */
325
326 static inline int
327 arm_compare_mapping_symbols (const struct arm_mapping_symbol *lhs,
328                              const struct arm_mapping_symbol *rhs)
329 {
330   return lhs->value < rhs->value;
331 }
332
333 /* Search for the mapping symbol covering MEMADDR.  If one is found,
334    return its type.  Otherwise, return 0.  If START is non-NULL,
335    set *START to the location of the mapping symbol.  */
336
337 static char
338 arm_find_mapping_symbol (CORE_ADDR memaddr, CORE_ADDR *start)
339 {
340   struct obj_section *sec;
341
342   /* If there are mapping symbols, consult them.  */
343   sec = find_pc_section (memaddr);
344   if (sec != NULL)
345     {
346       struct arm_per_objfile *data;
347       VEC(arm_mapping_symbol_s) *map;
348       struct arm_mapping_symbol map_key = { memaddr - obj_section_addr (sec),
349                                             0 };
350       unsigned int idx;
351
352       data = (struct arm_per_objfile *) objfile_data (sec->objfile,
353                                                       arm_objfile_data_key);
354       if (data != NULL)
355         {
356           map = data->section_maps[sec->the_bfd_section->index];
357           if (!VEC_empty (arm_mapping_symbol_s, map))
358             {
359               struct arm_mapping_symbol *map_sym;
360
361               idx = VEC_lower_bound (arm_mapping_symbol_s, map, &map_key,
362                                      arm_compare_mapping_symbols);
363
364               /* VEC_lower_bound finds the earliest ordered insertion
365                  point.  If the following symbol starts at this exact
366                  address, we use that; otherwise, the preceding
367                  mapping symbol covers this address.  */
368               if (idx < VEC_length (arm_mapping_symbol_s, map))
369                 {
370                   map_sym = VEC_index (arm_mapping_symbol_s, map, idx);
371                   if (map_sym->value == map_key.value)
372                     {
373                       if (start)
374                         *start = map_sym->value + obj_section_addr (sec);
375                       return map_sym->type;
376                     }
377                 }
378
379               if (idx > 0)
380                 {
381                   map_sym = VEC_index (arm_mapping_symbol_s, map, idx - 1);
382                   if (start)
383                     *start = map_sym->value + obj_section_addr (sec);
384                   return map_sym->type;
385                 }
386             }
387         }
388     }
389
390   return 0;
391 }
392
393 /* Determine if the program counter specified in MEMADDR is in a Thumb
394    function.  This function should be called for addresses unrelated to
395    any executing frame; otherwise, prefer arm_frame_is_thumb.  */
396
397 int
398 arm_pc_is_thumb (struct gdbarch *gdbarch, CORE_ADDR memaddr)
399 {
400   struct bound_minimal_symbol sym;
401   char type;
402   arm_displaced_step_closure *dsc
403     = ((arm_displaced_step_closure * )
404         get_displaced_step_closure_by_addr (memaddr));
405
406   /* If checking the mode of displaced instruction in copy area, the mode
407      should be determined by instruction on the original address.  */
408   if (dsc)
409     {
410       if (debug_displaced)
411         fprintf_unfiltered (gdb_stdlog,
412                             "displaced: check mode of %.8lx instead of %.8lx\n",
413                             (unsigned long) dsc->insn_addr,
414                             (unsigned long) memaddr);
415       memaddr = dsc->insn_addr;
416     }
417
418   /* If bit 0 of the address is set, assume this is a Thumb address.  */
419   if (IS_THUMB_ADDR (memaddr))
420     return 1;
421
422   /* If the user wants to override the symbol table, let him.  */
423   if (strcmp (arm_force_mode_string, "arm") == 0)
424     return 0;
425   if (strcmp (arm_force_mode_string, "thumb") == 0)
426     return 1;
427
428   /* ARM v6-M and v7-M are always in Thumb mode.  */
429   if (gdbarch_tdep (gdbarch)->is_m)
430     return 1;
431
432   /* If there are mapping symbols, consult them.  */
433   type = arm_find_mapping_symbol (memaddr, NULL);
434   if (type)
435     return type == 't';
436
437   /* Thumb functions have a "special" bit set in minimal symbols.  */
438   sym = lookup_minimal_symbol_by_pc (memaddr);
439   if (sym.minsym)
440     return (MSYMBOL_IS_SPECIAL (sym.minsym));
441
442   /* If the user wants to override the fallback mode, let them.  */
443   if (strcmp (arm_fallback_mode_string, "arm") == 0)
444     return 0;
445   if (strcmp (arm_fallback_mode_string, "thumb") == 0)
446     return 1;
447
448   /* If we couldn't find any symbol, but we're talking to a running
449      target, then trust the current value of $cpsr.  This lets
450      "display/i $pc" always show the correct mode (though if there is
451      a symbol table we will not reach here, so it still may not be
452      displayed in the mode it will be executed).  */
453   if (target_has_registers)
454     return arm_frame_is_thumb (get_current_frame ());
455
456   /* Otherwise we're out of luck; we assume ARM.  */
457   return 0;
458 }
459
460 /* Determine if the address specified equals any of these magic return
461    values, called EXC_RETURN, defined by the ARM v6-M and v7-M
462    architectures.
463
464    From ARMv6-M Reference Manual B1.5.8
465    Table B1-5 Exception return behavior
466
467    EXC_RETURN    Return To        Return Stack
468    0xFFFFFFF1    Handler mode     Main
469    0xFFFFFFF9    Thread mode      Main
470    0xFFFFFFFD    Thread mode      Process
471
472    From ARMv7-M Reference Manual B1.5.8
473    Table B1-8 EXC_RETURN definition of exception return behavior, no FP
474
475    EXC_RETURN    Return To        Return Stack
476    0xFFFFFFF1    Handler mode     Main
477    0xFFFFFFF9    Thread mode      Main
478    0xFFFFFFFD    Thread mode      Process
479
480    Table B1-9 EXC_RETURN definition of exception return behavior, with
481    FP
482
483    EXC_RETURN    Return To        Return Stack    Frame Type
484    0xFFFFFFE1    Handler mode     Main            Extended
485    0xFFFFFFE9    Thread mode      Main            Extended
486    0xFFFFFFED    Thread mode      Process         Extended
487    0xFFFFFFF1    Handler mode     Main            Basic
488    0xFFFFFFF9    Thread mode      Main            Basic
489    0xFFFFFFFD    Thread mode      Process         Basic
490
491    For more details see "B1.5.8 Exception return behavior"
492    in both ARMv6-M and ARMv7-M Architecture Reference Manuals.  */
493
494 static int
495 arm_m_addr_is_magic (CORE_ADDR addr)
496 {
497   switch (addr)
498     {
499       /* Values from Tables in B1.5.8 the EXC_RETURN definitions of
500          the exception return behavior.  */
501       case 0xffffffe1:
502       case 0xffffffe9:
503       case 0xffffffed:
504       case 0xfffffff1:
505       case 0xfffffff9:
506       case 0xfffffffd:
507         /* Address is magic.  */
508         return 1;
509
510       default:
511         /* Address is not magic.  */
512         return 0;
513     }
514 }
515
516 /* Remove useless bits from addresses in a running program.  */
517 static CORE_ADDR
518 arm_addr_bits_remove (struct gdbarch *gdbarch, CORE_ADDR val)
519 {
520   /* On M-profile devices, do not strip the low bit from EXC_RETURN
521      (the magic exception return address).  */
522   if (gdbarch_tdep (gdbarch)->is_m
523       && arm_m_addr_is_magic (val))
524     return val;
525
526   if (arm_apcs_32)
527     return UNMAKE_THUMB_ADDR (val);
528   else
529     return (val & 0x03fffffc);
530 }
531
532 /* Return 1 if PC is the start of a compiler helper function which
533    can be safely ignored during prologue skipping.  IS_THUMB is true
534    if the function is known to be a Thumb function due to the way it
535    is being called.  */
536 static int
537 skip_prologue_function (struct gdbarch *gdbarch, CORE_ADDR pc, int is_thumb)
538 {
539   enum bfd_endian byte_order_for_code = gdbarch_byte_order_for_code (gdbarch);
540   struct bound_minimal_symbol msym;
541
542   msym = lookup_minimal_symbol_by_pc (pc);
543   if (msym.minsym != NULL
544       && BMSYMBOL_VALUE_ADDRESS (msym) == pc
545       && MSYMBOL_LINKAGE_NAME (msym.minsym) != NULL)
546     {
547       const char *name = MSYMBOL_LINKAGE_NAME (msym.minsym);
548
549       /* The GNU linker's Thumb call stub to foo is named
550          __foo_from_thumb.  */
551       if (strstr (name, "_from_thumb") != NULL)
552         name += 2;
553
554       /* On soft-float targets, __truncdfsf2 is called to convert promoted
555          arguments to their argument types in non-prototyped
556          functions.  */
557       if (startswith (name, "__truncdfsf2"))
558         return 1;
559       if (startswith (name, "__aeabi_d2f"))
560         return 1;
561
562       /* Internal functions related to thread-local storage.  */
563       if (startswith (name, "__tls_get_addr"))
564         return 1;
565       if (startswith (name, "__aeabi_read_tp"))
566         return 1;
567     }
568   else
569     {
570       /* If we run against a stripped glibc, we may be unable to identify
571          special functions by name.  Check for one important case,
572          __aeabi_read_tp, by comparing the *code* against the default
573          implementation (this is hand-written ARM assembler in glibc).  */
574
575       if (!is_thumb
576           && read_code_unsigned_integer (pc, 4, byte_order_for_code)
577              == 0xe3e00a0f /* mov r0, #0xffff0fff */
578           && read_code_unsigned_integer (pc + 4, 4, byte_order_for_code)
579              == 0xe240f01f) /* sub pc, r0, #31 */
580         return 1;
581     }
582
583   return 0;
584 }
585
586 /* Extract the immediate from instruction movw/movt of encoding T.  INSN1 is
587    the first 16-bit of instruction, and INSN2 is the second 16-bit of
588    instruction.  */
589 #define EXTRACT_MOVW_MOVT_IMM_T(insn1, insn2) \
590   ((bits ((insn1), 0, 3) << 12)               \
591    | (bits ((insn1), 10, 10) << 11)           \
592    | (bits ((insn2), 12, 14) << 8)            \
593    | bits ((insn2), 0, 7))
594
595 /* Extract the immediate from instruction movw/movt of encoding A.  INSN is
596    the 32-bit instruction.  */
597 #define EXTRACT_MOVW_MOVT_IMM_A(insn) \
598   ((bits ((insn), 16, 19) << 12) \
599    | bits ((insn), 0, 11))
600
601 /* Decode immediate value; implements ThumbExpandImmediate pseudo-op.  */
602
603 static unsigned int
604 thumb_expand_immediate (unsigned int imm)
605 {
606   unsigned int count = imm >> 7;
607
608   if (count < 8)
609     switch (count / 2)
610       {
611       case 0:
612         return imm & 0xff;
613       case 1:
614         return (imm & 0xff) | ((imm & 0xff) << 16);
615       case 2:
616         return ((imm & 0xff) << 8) | ((imm & 0xff) << 24);
617       case 3:
618         return (imm & 0xff) | ((imm & 0xff) << 8)
619                 | ((imm & 0xff) << 16) | ((imm & 0xff) << 24);
620       }
621
622   return (0x80 | (imm & 0x7f)) << (32 - count);
623 }
624
625 /* Return 1 if the 16-bit Thumb instruction INSN restores SP in
626    epilogue, 0 otherwise.  */
627
628 static int
629 thumb_instruction_restores_sp (unsigned short insn)
630 {
631   return (insn == 0x46bd  /* mov sp, r7 */
632           || (insn & 0xff80) == 0xb000  /* add sp, imm */
633           || (insn & 0xfe00) == 0xbc00);  /* pop <registers> */
634 }
635
636 /* Analyze a Thumb prologue, looking for a recognizable stack frame
637    and frame pointer.  Scan until we encounter a store that could
638    clobber the stack frame unexpectedly, or an unknown instruction.
639    Return the last address which is definitely safe to skip for an
640    initial breakpoint.  */
641
642 static CORE_ADDR
643 thumb_analyze_prologue (struct gdbarch *gdbarch,
644                         CORE_ADDR start, CORE_ADDR limit,
645                         struct arm_prologue_cache *cache)
646 {
647   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
648   enum bfd_endian byte_order_for_code = gdbarch_byte_order_for_code (gdbarch);
649   int i;
650   pv_t regs[16];
651   CORE_ADDR offset;
652   CORE_ADDR unrecognized_pc = 0;
653
654   for (i = 0; i < 16; i++)
655     regs[i] = pv_register (i, 0);
656   pv_area stack (ARM_SP_REGNUM, gdbarch_addr_bit (gdbarch));
657
658   while (start < limit)
659     {
660       unsigned short insn;
661
662       insn = read_code_unsigned_integer (start, 2, byte_order_for_code);
663
664       if ((insn & 0xfe00) == 0xb400)            /* push { rlist } */
665         {
666           int regno;
667           int mask;
668
669           if (stack.store_would_trash (regs[ARM_SP_REGNUM]))
670             break;
671
672           /* Bits 0-7 contain a mask for registers R0-R7.  Bit 8 says
673              whether to save LR (R14).  */
674           mask = (insn & 0xff) | ((insn & 0x100) << 6);
675
676           /* Calculate offsets of saved R0-R7 and LR.  */
677           for (regno = ARM_LR_REGNUM; regno >= 0; regno--)
678             if (mask & (1 << regno))
679               {
680                 regs[ARM_SP_REGNUM] = pv_add_constant (regs[ARM_SP_REGNUM],
681                                                        -4);
682                 stack.store (regs[ARM_SP_REGNUM], 4, regs[regno]);
683               }
684         }
685       else if ((insn & 0xff80) == 0xb080)       /* sub sp, #imm */
686         {
687           offset = (insn & 0x7f) << 2;          /* get scaled offset */
688           regs[ARM_SP_REGNUM] = pv_add_constant (regs[ARM_SP_REGNUM],
689                                                  -offset);
690         }
691       else if (thumb_instruction_restores_sp (insn))
692         {
693           /* Don't scan past the epilogue.  */
694           break;
695         }
696       else if ((insn & 0xf800) == 0xa800)       /* add Rd, sp, #imm */
697         regs[bits (insn, 8, 10)] = pv_add_constant (regs[ARM_SP_REGNUM],
698                                                     (insn & 0xff) << 2);
699       else if ((insn & 0xfe00) == 0x1c00        /* add Rd, Rn, #imm */
700                && pv_is_register (regs[bits (insn, 3, 5)], ARM_SP_REGNUM))
701         regs[bits (insn, 0, 2)] = pv_add_constant (regs[bits (insn, 3, 5)],
702                                                    bits (insn, 6, 8));
703       else if ((insn & 0xf800) == 0x3000        /* add Rd, #imm */
704                && pv_is_register (regs[bits (insn, 8, 10)], ARM_SP_REGNUM))
705         regs[bits (insn, 8, 10)] = pv_add_constant (regs[bits (insn, 8, 10)],
706                                                     bits (insn, 0, 7));
707       else if ((insn & 0xfe00) == 0x1800        /* add Rd, Rn, Rm */
708                && pv_is_register (regs[bits (insn, 6, 8)], ARM_SP_REGNUM)
709                && pv_is_constant (regs[bits (insn, 3, 5)]))
710         regs[bits (insn, 0, 2)] = pv_add (regs[bits (insn, 3, 5)],
711                                           regs[bits (insn, 6, 8)]);
712       else if ((insn & 0xff00) == 0x4400        /* add Rd, Rm */
713                && pv_is_constant (regs[bits (insn, 3, 6)]))
714         {
715           int rd = (bit (insn, 7) << 3) + bits (insn, 0, 2);
716           int rm = bits (insn, 3, 6);
717           regs[rd] = pv_add (regs[rd], regs[rm]);
718         }
719       else if ((insn & 0xff00) == 0x4600)       /* mov hi, lo or mov lo, hi */
720         {
721           int dst_reg = (insn & 0x7) + ((insn & 0x80) >> 4);
722           int src_reg = (insn & 0x78) >> 3;
723           regs[dst_reg] = regs[src_reg];
724         }
725       else if ((insn & 0xf800) == 0x9000)       /* str rd, [sp, #off] */
726         {
727           /* Handle stores to the stack.  Normally pushes are used,
728              but with GCC -mtpcs-frame, there may be other stores
729              in the prologue to create the frame.  */
730           int regno = (insn >> 8) & 0x7;
731           pv_t addr;
732
733           offset = (insn & 0xff) << 2;
734           addr = pv_add_constant (regs[ARM_SP_REGNUM], offset);
735
736           if (stack.store_would_trash (addr))
737             break;
738
739           stack.store (addr, 4, regs[regno]);
740         }
741       else if ((insn & 0xf800) == 0x6000)       /* str rd, [rn, #off] */
742         {
743           int rd = bits (insn, 0, 2);
744           int rn = bits (insn, 3, 5);
745           pv_t addr;
746
747           offset = bits (insn, 6, 10) << 2;
748           addr = pv_add_constant (regs[rn], offset);
749
750           if (stack.store_would_trash (addr))
751             break;
752
753           stack.store (addr, 4, regs[rd]);
754         }
755       else if (((insn & 0xf800) == 0x7000       /* strb Rd, [Rn, #off] */
756                 || (insn & 0xf800) == 0x8000)   /* strh Rd, [Rn, #off] */
757                && pv_is_register (regs[bits (insn, 3, 5)], ARM_SP_REGNUM))
758         /* Ignore stores of argument registers to the stack.  */
759         ;
760       else if ((insn & 0xf800) == 0xc800        /* ldmia Rn!, { registers } */
761                && pv_is_register (regs[bits (insn, 8, 10)], ARM_SP_REGNUM))
762         /* Ignore block loads from the stack, potentially copying
763            parameters from memory.  */
764         ;
765       else if ((insn & 0xf800) == 0x9800        /* ldr Rd, [Rn, #immed] */
766                || ((insn & 0xf800) == 0x6800    /* ldr Rd, [sp, #immed] */
767                    && pv_is_register (regs[bits (insn, 3, 5)], ARM_SP_REGNUM)))
768         /* Similarly ignore single loads from the stack.  */
769         ;
770       else if ((insn & 0xffc0) == 0x0000        /* lsls Rd, Rm, #0 */
771                || (insn & 0xffc0) == 0x1c00)    /* add Rd, Rn, #0 */
772         /* Skip register copies, i.e. saves to another register
773            instead of the stack.  */
774         ;
775       else if ((insn & 0xf800) == 0x2000)       /* movs Rd, #imm */
776         /* Recognize constant loads; even with small stacks these are necessary
777            on Thumb.  */
778         regs[bits (insn, 8, 10)] = pv_constant (bits (insn, 0, 7));
779       else if ((insn & 0xf800) == 0x4800)       /* ldr Rd, [pc, #imm] */
780         {
781           /* Constant pool loads, for the same reason.  */
782           unsigned int constant;
783           CORE_ADDR loc;
784
785           loc = start + 4 + bits (insn, 0, 7) * 4;
786           constant = read_memory_unsigned_integer (loc, 4, byte_order);
787           regs[bits (insn, 8, 10)] = pv_constant (constant);
788         }
789       else if (thumb_insn_size (insn) == 4) /* 32-bit Thumb-2 instructions.  */
790         {
791           unsigned short inst2;
792
793           inst2 = read_code_unsigned_integer (start + 2, 2,
794                                               byte_order_for_code);
795
796           if ((insn & 0xf800) == 0xf000 && (inst2 & 0xe800) == 0xe800)
797             {
798               /* BL, BLX.  Allow some special function calls when
799                  skipping the prologue; GCC generates these before
800                  storing arguments to the stack.  */
801               CORE_ADDR nextpc;
802               int j1, j2, imm1, imm2;
803
804               imm1 = sbits (insn, 0, 10);
805               imm2 = bits (inst2, 0, 10);
806               j1 = bit (inst2, 13);
807               j2 = bit (inst2, 11);
808
809               offset = ((imm1 << 12) + (imm2 << 1));
810               offset ^= ((!j2) << 22) | ((!j1) << 23);
811
812               nextpc = start + 4 + offset;
813               /* For BLX make sure to clear the low bits.  */
814               if (bit (inst2, 12) == 0)
815                 nextpc = nextpc & 0xfffffffc;
816
817               if (!skip_prologue_function (gdbarch, nextpc,
818                                            bit (inst2, 12) != 0))
819                 break;
820             }
821
822           else if ((insn & 0xffd0) == 0xe900    /* stmdb Rn{!},
823                                                    { registers } */
824                    && pv_is_register (regs[bits (insn, 0, 3)], ARM_SP_REGNUM))
825             {
826               pv_t addr = regs[bits (insn, 0, 3)];
827               int regno;
828
829               if (stack.store_would_trash (addr))
830                 break;
831
832               /* Calculate offsets of saved registers.  */
833               for (regno = ARM_LR_REGNUM; regno >= 0; regno--)
834                 if (inst2 & (1 << regno))
835                   {
836                     addr = pv_add_constant (addr, -4);
837                     stack.store (addr, 4, regs[regno]);
838                   }
839
840               if (insn & 0x0020)
841                 regs[bits (insn, 0, 3)] = addr;
842             }
843
844           else if ((insn & 0xff50) == 0xe940    /* strd Rt, Rt2,
845                                                    [Rn, #+/-imm]{!} */
846                    && pv_is_register (regs[bits (insn, 0, 3)], ARM_SP_REGNUM))
847             {
848               int regno1 = bits (inst2, 12, 15);
849               int regno2 = bits (inst2, 8, 11);
850               pv_t addr = regs[bits (insn, 0, 3)];
851
852               offset = inst2 & 0xff;
853               if (insn & 0x0080)
854                 addr = pv_add_constant (addr, offset);
855               else
856                 addr = pv_add_constant (addr, -offset);
857
858               if (stack.store_would_trash (addr))
859                 break;
860
861               stack.store (addr, 4, regs[regno1]);
862               stack.store (pv_add_constant (addr, 4),
863                            4, regs[regno2]);
864
865               if (insn & 0x0020)
866                 regs[bits (insn, 0, 3)] = addr;
867             }
868
869           else if ((insn & 0xfff0) == 0xf8c0    /* str Rt,[Rn,+/-#imm]{!} */
870                    && (inst2 & 0x0c00) == 0x0c00
871                    && pv_is_register (regs[bits (insn, 0, 3)], ARM_SP_REGNUM))
872             {
873               int regno = bits (inst2, 12, 15);
874               pv_t addr = regs[bits (insn, 0, 3)];
875
876               offset = inst2 & 0xff;
877               if (inst2 & 0x0200)
878                 addr = pv_add_constant (addr, offset);
879               else
880                 addr = pv_add_constant (addr, -offset);
881
882               if (stack.store_would_trash (addr))
883                 break;
884
885               stack.store (addr, 4, regs[regno]);
886
887               if (inst2 & 0x0100)
888                 regs[bits (insn, 0, 3)] = addr;
889             }
890
891           else if ((insn & 0xfff0) == 0xf8c0    /* str.w Rt,[Rn,#imm] */
892                    && pv_is_register (regs[bits (insn, 0, 3)], ARM_SP_REGNUM))
893             {
894               int regno = bits (inst2, 12, 15);
895               pv_t addr;
896
897               offset = inst2 & 0xfff;
898               addr = pv_add_constant (regs[bits (insn, 0, 3)], offset);
899
900               if (stack.store_would_trash (addr))
901                 break;
902
903               stack.store (addr, 4, regs[regno]);
904             }
905
906           else if ((insn & 0xffd0) == 0xf880    /* str{bh}.w Rt,[Rn,#imm] */
907                    && pv_is_register (regs[bits (insn, 0, 3)], ARM_SP_REGNUM))
908             /* Ignore stores of argument registers to the stack.  */
909             ;
910
911           else if ((insn & 0xffd0) == 0xf800    /* str{bh} Rt,[Rn,#+/-imm] */
912                    && (inst2 & 0x0d00) == 0x0c00
913                    && pv_is_register (regs[bits (insn, 0, 3)], ARM_SP_REGNUM))
914             /* Ignore stores of argument registers to the stack.  */
915             ;
916
917           else if ((insn & 0xffd0) == 0xe890    /* ldmia Rn[!],
918                                                    { registers } */
919                    && (inst2 & 0x8000) == 0x0000
920                    && pv_is_register (regs[bits (insn, 0, 3)], ARM_SP_REGNUM))
921             /* Ignore block loads from the stack, potentially copying
922                parameters from memory.  */
923             ;
924
925           else if ((insn & 0xffb0) == 0xe950    /* ldrd Rt, Rt2,
926                                                    [Rn, #+/-imm] */
927                    && pv_is_register (regs[bits (insn, 0, 3)], ARM_SP_REGNUM))
928             /* Similarly ignore dual loads from the stack.  */
929             ;
930
931           else if ((insn & 0xfff0) == 0xf850    /* ldr Rt,[Rn,#+/-imm] */
932                    && (inst2 & 0x0d00) == 0x0c00
933                    && pv_is_register (regs[bits (insn, 0, 3)], ARM_SP_REGNUM))
934             /* Similarly ignore single loads from the stack.  */
935             ;
936
937           else if ((insn & 0xfff0) == 0xf8d0    /* ldr.w Rt,[Rn,#imm] */
938                    && pv_is_register (regs[bits (insn, 0, 3)], ARM_SP_REGNUM))
939             /* Similarly ignore single loads from the stack.  */
940             ;
941
942           else if ((insn & 0xfbf0) == 0xf100    /* add.w Rd, Rn, #imm */
943                    && (inst2 & 0x8000) == 0x0000)
944             {
945               unsigned int imm = ((bits (insn, 10, 10) << 11)
946                                   | (bits (inst2, 12, 14) << 8)
947                                   | bits (inst2, 0, 7));
948
949               regs[bits (inst2, 8, 11)]
950                 = pv_add_constant (regs[bits (insn, 0, 3)],
951                                    thumb_expand_immediate (imm));
952             }
953
954           else if ((insn & 0xfbf0) == 0xf200    /* addw Rd, Rn, #imm */
955                    && (inst2 & 0x8000) == 0x0000)
956             {
957               unsigned int imm = ((bits (insn, 10, 10) << 11)
958                                   | (bits (inst2, 12, 14) << 8)
959                                   | bits (inst2, 0, 7));
960
961               regs[bits (inst2, 8, 11)]
962                 = pv_add_constant (regs[bits (insn, 0, 3)], imm);
963             }
964
965           else if ((insn & 0xfbf0) == 0xf1a0    /* sub.w Rd, Rn, #imm */
966                    && (inst2 & 0x8000) == 0x0000)
967             {
968               unsigned int imm = ((bits (insn, 10, 10) << 11)
969                                   | (bits (inst2, 12, 14) << 8)
970                                   | bits (inst2, 0, 7));
971
972               regs[bits (inst2, 8, 11)]
973                 = pv_add_constant (regs[bits (insn, 0, 3)],
974                                    - (CORE_ADDR) thumb_expand_immediate (imm));
975             }
976
977           else if ((insn & 0xfbf0) == 0xf2a0    /* subw Rd, Rn, #imm */
978                    && (inst2 & 0x8000) == 0x0000)
979             {
980               unsigned int imm = ((bits (insn, 10, 10) << 11)
981                                   | (bits (inst2, 12, 14) << 8)
982                                   | bits (inst2, 0, 7));
983
984               regs[bits (inst2, 8, 11)]
985                 = pv_add_constant (regs[bits (insn, 0, 3)], - (CORE_ADDR) imm);
986             }
987
988           else if ((insn & 0xfbff) == 0xf04f)   /* mov.w Rd, #const */
989             {
990               unsigned int imm = ((bits (insn, 10, 10) << 11)
991                                   | (bits (inst2, 12, 14) << 8)
992                                   | bits (inst2, 0, 7));
993
994               regs[bits (inst2, 8, 11)]
995                 = pv_constant (thumb_expand_immediate (imm));
996             }
997
998           else if ((insn & 0xfbf0) == 0xf240)   /* movw Rd, #const */
999             {
1000               unsigned int imm
1001                 = EXTRACT_MOVW_MOVT_IMM_T (insn, inst2);
1002
1003               regs[bits (inst2, 8, 11)] = pv_constant (imm);
1004             }
1005
1006           else if (insn == 0xea5f               /* mov.w Rd,Rm */
1007                    && (inst2 & 0xf0f0) == 0)
1008             {
1009               int dst_reg = (inst2 & 0x0f00) >> 8;
1010               int src_reg = inst2 & 0xf;
1011               regs[dst_reg] = regs[src_reg];
1012             }
1013
1014           else if ((insn & 0xff7f) == 0xf85f)   /* ldr.w Rt,<label> */
1015             {
1016               /* Constant pool loads.  */
1017               unsigned int constant;
1018               CORE_ADDR loc;
1019
1020               offset = bits (inst2, 0, 11);
1021               if (insn & 0x0080)
1022                 loc = start + 4 + offset;
1023               else
1024                 loc = start + 4 - offset;
1025
1026               constant = read_memory_unsigned_integer (loc, 4, byte_order);
1027               regs[bits (inst2, 12, 15)] = pv_constant (constant);
1028             }
1029
1030           else if ((insn & 0xff7f) == 0xe95f)   /* ldrd Rt,Rt2,<label> */
1031             {
1032               /* Constant pool loads.  */
1033               unsigned int constant;
1034               CORE_ADDR loc;
1035
1036               offset = bits (inst2, 0, 7) << 2;
1037               if (insn & 0x0080)
1038                 loc = start + 4 + offset;
1039               else
1040                 loc = start + 4 - offset;
1041
1042               constant = read_memory_unsigned_integer (loc, 4, byte_order);
1043               regs[bits (inst2, 12, 15)] = pv_constant (constant);
1044
1045               constant = read_memory_unsigned_integer (loc + 4, 4, byte_order);
1046               regs[bits (inst2, 8, 11)] = pv_constant (constant);
1047             }
1048
1049           else if (thumb2_instruction_changes_pc (insn, inst2))
1050             {
1051               /* Don't scan past anything that might change control flow.  */
1052               break;
1053             }
1054           else
1055             {
1056               /* The optimizer might shove anything into the prologue,
1057                  so we just skip what we don't recognize.  */
1058               unrecognized_pc = start;
1059             }
1060
1061           start += 2;
1062         }
1063       else if (thumb_instruction_changes_pc (insn))
1064         {
1065           /* Don't scan past anything that might change control flow.  */
1066           break;
1067         }
1068       else
1069         {
1070           /* The optimizer might shove anything into the prologue,
1071              so we just skip what we don't recognize.  */
1072           unrecognized_pc = start;
1073         }
1074
1075       start += 2;
1076     }
1077
1078   if (arm_debug)
1079     fprintf_unfiltered (gdb_stdlog, "Prologue scan stopped at %s\n",
1080                         paddress (gdbarch, start));
1081
1082   if (unrecognized_pc == 0)
1083     unrecognized_pc = start;
1084
1085   if (cache == NULL)
1086     return unrecognized_pc;
1087
1088   if (pv_is_register (regs[ARM_FP_REGNUM], ARM_SP_REGNUM))
1089     {
1090       /* Frame pointer is fp.  Frame size is constant.  */
1091       cache->framereg = ARM_FP_REGNUM;
1092       cache->framesize = -regs[ARM_FP_REGNUM].k;
1093     }
1094   else if (pv_is_register (regs[THUMB_FP_REGNUM], ARM_SP_REGNUM))
1095     {
1096       /* Frame pointer is r7.  Frame size is constant.  */
1097       cache->framereg = THUMB_FP_REGNUM;
1098       cache->framesize = -regs[THUMB_FP_REGNUM].k;
1099     }
1100   else
1101     {
1102       /* Try the stack pointer... this is a bit desperate.  */
1103       cache->framereg = ARM_SP_REGNUM;
1104       cache->framesize = -regs[ARM_SP_REGNUM].k;
1105     }
1106
1107   for (i = 0; i < 16; i++)
1108     if (stack.find_reg (gdbarch, i, &offset))
1109       cache->saved_regs[i].addr = offset;
1110
1111   return unrecognized_pc;
1112 }
1113
1114
1115 /* Try to analyze the instructions starting from PC, which load symbol
1116    __stack_chk_guard.  Return the address of instruction after loading this
1117    symbol, set the dest register number to *BASEREG, and set the size of
1118    instructions for loading symbol in OFFSET.  Return 0 if instructions are
1119    not recognized.  */
1120
1121 static CORE_ADDR
1122 arm_analyze_load_stack_chk_guard(CORE_ADDR pc, struct gdbarch *gdbarch,
1123                                  unsigned int *destreg, int *offset)
1124 {
1125   enum bfd_endian byte_order_for_code = gdbarch_byte_order_for_code (gdbarch);
1126   int is_thumb = arm_pc_is_thumb (gdbarch, pc);
1127   unsigned int low, high, address;
1128
1129   address = 0;
1130   if (is_thumb)
1131     {
1132       unsigned short insn1
1133         = read_code_unsigned_integer (pc, 2, byte_order_for_code);
1134
1135       if ((insn1 & 0xf800) == 0x4800) /* ldr Rd, #immed */
1136         {
1137           *destreg = bits (insn1, 8, 10);
1138           *offset = 2;
1139           address = (pc & 0xfffffffc) + 4 + (bits (insn1, 0, 7) << 2);
1140           address = read_memory_unsigned_integer (address, 4,
1141                                                   byte_order_for_code);
1142         }
1143       else if ((insn1 & 0xfbf0) == 0xf240) /* movw Rd, #const */
1144         {
1145           unsigned short insn2
1146             = read_code_unsigned_integer (pc + 2, 2, byte_order_for_code);
1147
1148           low = EXTRACT_MOVW_MOVT_IMM_T (insn1, insn2);
1149
1150           insn1
1151             = read_code_unsigned_integer (pc + 4, 2, byte_order_for_code);
1152           insn2
1153             = read_code_unsigned_integer (pc + 6, 2, byte_order_for_code);
1154
1155           /* movt Rd, #const */
1156           if ((insn1 & 0xfbc0) == 0xf2c0)
1157             {
1158               high = EXTRACT_MOVW_MOVT_IMM_T (insn1, insn2);
1159               *destreg = bits (insn2, 8, 11);
1160               *offset = 8;
1161               address = (high << 16 | low);
1162             }
1163         }
1164     }
1165   else
1166     {
1167       unsigned int insn
1168         = read_code_unsigned_integer (pc, 4, byte_order_for_code);
1169
1170       if ((insn & 0x0e5f0000) == 0x041f0000) /* ldr Rd, [PC, #immed] */
1171         {
1172           address = bits (insn, 0, 11) + pc + 8;
1173           address = read_memory_unsigned_integer (address, 4,
1174                                                   byte_order_for_code);
1175
1176           *destreg = bits (insn, 12, 15);
1177           *offset = 4;
1178         }
1179       else if ((insn & 0x0ff00000) == 0x03000000) /* movw Rd, #const */
1180         {
1181           low = EXTRACT_MOVW_MOVT_IMM_A (insn);
1182
1183           insn
1184             = read_code_unsigned_integer (pc + 4, 4, byte_order_for_code);
1185
1186           if ((insn & 0x0ff00000) == 0x03400000) /* movt Rd, #const */
1187             {
1188               high = EXTRACT_MOVW_MOVT_IMM_A (insn);
1189               *destreg = bits (insn, 12, 15);
1190               *offset = 8;
1191               address = (high << 16 | low);
1192             }
1193         }
1194     }
1195
1196   return address;
1197 }
1198
1199 /* Try to skip a sequence of instructions used for stack protector.  If PC
1200    points to the first instruction of this sequence, return the address of
1201    first instruction after this sequence, otherwise, return original PC.
1202
1203    On arm, this sequence of instructions is composed of mainly three steps,
1204      Step 1: load symbol __stack_chk_guard,
1205      Step 2: load from address of __stack_chk_guard,
1206      Step 3: store it to somewhere else.
1207
1208    Usually, instructions on step 2 and step 3 are the same on various ARM
1209    architectures.  On step 2, it is one instruction 'ldr Rx, [Rn, #0]', and
1210    on step 3, it is also one instruction 'str Rx, [r7, #immd]'.  However,
1211    instructions in step 1 vary from different ARM architectures.  On ARMv7,
1212    they are,
1213
1214         movw    Rn, #:lower16:__stack_chk_guard
1215         movt    Rn, #:upper16:__stack_chk_guard
1216
1217    On ARMv5t, it is,
1218
1219         ldr     Rn, .Label
1220         ....
1221         .Lable:
1222         .word   __stack_chk_guard
1223
1224    Since ldr/str is a very popular instruction, we can't use them as
1225    'fingerprint' or 'signature' of stack protector sequence.  Here we choose
1226    sequence {movw/movt, ldr}/ldr/str plus symbol __stack_chk_guard, if not
1227    stripped, as the 'fingerprint' of a stack protector cdoe sequence.  */
1228
1229 static CORE_ADDR
1230 arm_skip_stack_protector(CORE_ADDR pc, struct gdbarch *gdbarch)
1231 {
1232   enum bfd_endian byte_order_for_code = gdbarch_byte_order_for_code (gdbarch);
1233   unsigned int basereg;
1234   struct bound_minimal_symbol stack_chk_guard;
1235   int offset;
1236   int is_thumb = arm_pc_is_thumb (gdbarch, pc);
1237   CORE_ADDR addr;
1238
1239   /* Try to parse the instructions in Step 1.  */
1240   addr = arm_analyze_load_stack_chk_guard (pc, gdbarch,
1241                                            &basereg, &offset);
1242   if (!addr)
1243     return pc;
1244
1245   stack_chk_guard = lookup_minimal_symbol_by_pc (addr);
1246   /* ADDR must correspond to a symbol whose name is __stack_chk_guard.
1247      Otherwise, this sequence cannot be for stack protector.  */
1248   if (stack_chk_guard.minsym == NULL
1249       || !startswith (MSYMBOL_LINKAGE_NAME (stack_chk_guard.minsym), "__stack_chk_guard"))
1250    return pc;
1251
1252   if (is_thumb)
1253     {
1254       unsigned int destreg;
1255       unsigned short insn
1256         = read_code_unsigned_integer (pc + offset, 2, byte_order_for_code);
1257
1258       /* Step 2: ldr Rd, [Rn, #immed], encoding T1.  */
1259       if ((insn & 0xf800) != 0x6800)
1260         return pc;
1261       if (bits (insn, 3, 5) != basereg)
1262         return pc;
1263       destreg = bits (insn, 0, 2);
1264
1265       insn = read_code_unsigned_integer (pc + offset + 2, 2,
1266                                          byte_order_for_code);
1267       /* Step 3: str Rd, [Rn, #immed], encoding T1.  */
1268       if ((insn & 0xf800) != 0x6000)
1269         return pc;
1270       if (destreg != bits (insn, 0, 2))
1271         return pc;
1272     }
1273   else
1274     {
1275       unsigned int destreg;
1276       unsigned int insn
1277         = read_code_unsigned_integer (pc + offset, 4, byte_order_for_code);
1278
1279       /* Step 2: ldr Rd, [Rn, #immed], encoding A1.  */
1280       if ((insn & 0x0e500000) != 0x04100000)
1281         return pc;
1282       if (bits (insn, 16, 19) != basereg)
1283         return pc;
1284       destreg = bits (insn, 12, 15);
1285       /* Step 3: str Rd, [Rn, #immed], encoding A1.  */
1286       insn = read_code_unsigned_integer (pc + offset + 4,
1287                                            4, byte_order_for_code);
1288       if ((insn & 0x0e500000) != 0x04000000)
1289         return pc;
1290       if (bits (insn, 12, 15) != destreg)
1291         return pc;
1292     }
1293   /* The size of total two instructions ldr/str is 4 on Thumb-2, while 8
1294      on arm.  */
1295   if (is_thumb)
1296     return pc + offset + 4;
1297   else
1298     return pc + offset + 8;
1299 }
1300
1301 /* Advance the PC across any function entry prologue instructions to
1302    reach some "real" code.
1303
1304    The APCS (ARM Procedure Call Standard) defines the following
1305    prologue:
1306
1307    mov          ip, sp
1308    [stmfd       sp!, {a1,a2,a3,a4}]
1309    stmfd        sp!, {...,fp,ip,lr,pc}
1310    [stfe        f7, [sp, #-12]!]
1311    [stfe        f6, [sp, #-12]!]
1312    [stfe        f5, [sp, #-12]!]
1313    [stfe        f4, [sp, #-12]!]
1314    sub fp, ip, #nn @@ nn == 20 or 4 depending on second insn.  */
1315
1316 static CORE_ADDR
1317 arm_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR pc)
1318 {
1319   CORE_ADDR func_addr, limit_pc;
1320
1321   /* See if we can determine the end of the prologue via the symbol table.
1322      If so, then return either PC, or the PC after the prologue, whichever
1323      is greater.  */
1324   if (find_pc_partial_function (pc, NULL, &func_addr, NULL))
1325     {
1326       CORE_ADDR post_prologue_pc
1327         = skip_prologue_using_sal (gdbarch, func_addr);
1328       struct compunit_symtab *cust = find_pc_compunit_symtab (func_addr);
1329
1330       if (post_prologue_pc)
1331         post_prologue_pc
1332           = arm_skip_stack_protector (post_prologue_pc, gdbarch);
1333
1334
1335       /* GCC always emits a line note before the prologue and another
1336          one after, even if the two are at the same address or on the
1337          same line.  Take advantage of this so that we do not need to
1338          know every instruction that might appear in the prologue.  We
1339          will have producer information for most binaries; if it is
1340          missing (e.g. for -gstabs), assuming the GNU tools.  */
1341       if (post_prologue_pc
1342           && (cust == NULL
1343               || COMPUNIT_PRODUCER (cust) == NULL
1344               || startswith (COMPUNIT_PRODUCER (cust), "GNU ")
1345               || startswith (COMPUNIT_PRODUCER (cust), "clang ")))
1346         return post_prologue_pc;
1347
1348       if (post_prologue_pc != 0)
1349         {
1350           CORE_ADDR analyzed_limit;
1351
1352           /* For non-GCC compilers, make sure the entire line is an
1353              acceptable prologue; GDB will round this function's
1354              return value up to the end of the following line so we
1355              can not skip just part of a line (and we do not want to).
1356
1357              RealView does not treat the prologue specially, but does
1358              associate prologue code with the opening brace; so this
1359              lets us skip the first line if we think it is the opening
1360              brace.  */
1361           if (arm_pc_is_thumb (gdbarch, func_addr))
1362             analyzed_limit = thumb_analyze_prologue (gdbarch, func_addr,
1363                                                      post_prologue_pc, NULL);
1364           else
1365             analyzed_limit = arm_analyze_prologue (gdbarch, func_addr,
1366                                                    post_prologue_pc, NULL);
1367
1368           if (analyzed_limit != post_prologue_pc)
1369             return func_addr;
1370
1371           return post_prologue_pc;
1372         }
1373     }
1374
1375   /* Can't determine prologue from the symbol table, need to examine
1376      instructions.  */
1377
1378   /* Find an upper limit on the function prologue using the debug
1379      information.  If the debug information could not be used to provide
1380      that bound, then use an arbitrary large number as the upper bound.  */
1381   /* Like arm_scan_prologue, stop no later than pc + 64.  */
1382   limit_pc = skip_prologue_using_sal (gdbarch, pc);
1383   if (limit_pc == 0)
1384     limit_pc = pc + 64;          /* Magic.  */
1385
1386
1387   /* Check if this is Thumb code.  */
1388   if (arm_pc_is_thumb (gdbarch, pc))
1389     return thumb_analyze_prologue (gdbarch, pc, limit_pc, NULL);
1390   else
1391     return arm_analyze_prologue (gdbarch, pc, limit_pc, NULL);
1392 }
1393
1394 /* *INDENT-OFF* */
1395 /* Function: thumb_scan_prologue (helper function for arm_scan_prologue)
1396    This function decodes a Thumb function prologue to determine:
1397      1) the size of the stack frame
1398      2) which registers are saved on it
1399      3) the offsets of saved regs
1400      4) the offset from the stack pointer to the frame pointer
1401
1402    A typical Thumb function prologue would create this stack frame
1403    (offsets relative to FP)
1404      old SP ->  24  stack parameters
1405                 20  LR
1406                 16  R7
1407      R7 ->       0  local variables (16 bytes)
1408      SP ->     -12  additional stack space (12 bytes)
1409    The frame size would thus be 36 bytes, and the frame offset would be
1410    12 bytes.  The frame register is R7.
1411    
1412    The comments for thumb_skip_prolog() describe the algorithm we use
1413    to detect the end of the prolog.  */
1414 /* *INDENT-ON* */
1415
1416 static void
1417 thumb_scan_prologue (struct gdbarch *gdbarch, CORE_ADDR prev_pc,
1418                      CORE_ADDR block_addr, struct arm_prologue_cache *cache)
1419 {
1420   CORE_ADDR prologue_start;
1421   CORE_ADDR prologue_end;
1422
1423   if (find_pc_partial_function (block_addr, NULL, &prologue_start,
1424                                 &prologue_end))
1425     {
1426       /* See comment in arm_scan_prologue for an explanation of
1427          this heuristics.  */
1428       if (prologue_end > prologue_start + 64)
1429         {
1430           prologue_end = prologue_start + 64;
1431         }
1432     }
1433   else
1434     /* We're in the boondocks: we have no idea where the start of the
1435        function is.  */
1436     return;
1437
1438   prologue_end = std::min (prologue_end, prev_pc);
1439
1440   thumb_analyze_prologue (gdbarch, prologue_start, prologue_end, cache);
1441 }
1442
1443 /* Return 1 if the ARM instruction INSN restores SP in epilogue, 0
1444    otherwise.  */
1445
1446 static int
1447 arm_instruction_restores_sp (unsigned int insn)
1448 {
1449   if (bits (insn, 28, 31) != INST_NV)
1450     {
1451       if ((insn & 0x0df0f000) == 0x0080d000
1452           /* ADD SP (register or immediate).  */
1453           || (insn & 0x0df0f000) == 0x0040d000
1454           /* SUB SP (register or immediate).  */
1455           || (insn & 0x0ffffff0) == 0x01a0d000
1456           /* MOV SP.  */
1457           || (insn & 0x0fff0000) == 0x08bd0000
1458           /* POP (LDMIA).  */
1459           || (insn & 0x0fff0000) == 0x049d0000)
1460           /* POP of a single register.  */
1461         return 1;
1462     }
1463
1464   return 0;
1465 }
1466
1467 /* Analyze an ARM mode prologue starting at PROLOGUE_START and
1468    continuing no further than PROLOGUE_END.  If CACHE is non-NULL,
1469    fill it in.  Return the first address not recognized as a prologue
1470    instruction.
1471
1472    We recognize all the instructions typically found in ARM prologues,
1473    plus harmless instructions which can be skipped (either for analysis
1474    purposes, or a more restrictive set that can be skipped when finding
1475    the end of the prologue).  */
1476
1477 static CORE_ADDR
1478 arm_analyze_prologue (struct gdbarch *gdbarch,
1479                       CORE_ADDR prologue_start, CORE_ADDR prologue_end,
1480                       struct arm_prologue_cache *cache)
1481 {
1482   enum bfd_endian byte_order_for_code = gdbarch_byte_order_for_code (gdbarch);
1483   int regno;
1484   CORE_ADDR offset, current_pc;
1485   pv_t regs[ARM_FPS_REGNUM];
1486   CORE_ADDR unrecognized_pc = 0;
1487
1488   /* Search the prologue looking for instructions that set up the
1489      frame pointer, adjust the stack pointer, and save registers.
1490
1491      Be careful, however, and if it doesn't look like a prologue,
1492      don't try to scan it.  If, for instance, a frameless function
1493      begins with stmfd sp!, then we will tell ourselves there is
1494      a frame, which will confuse stack traceback, as well as "finish" 
1495      and other operations that rely on a knowledge of the stack
1496      traceback.  */
1497
1498   for (regno = 0; regno < ARM_FPS_REGNUM; regno++)
1499     regs[regno] = pv_register (regno, 0);
1500   pv_area stack (ARM_SP_REGNUM, gdbarch_addr_bit (gdbarch));
1501
1502   for (current_pc = prologue_start;
1503        current_pc < prologue_end;
1504        current_pc += 4)
1505     {
1506       unsigned int insn
1507         = read_code_unsigned_integer (current_pc, 4, byte_order_for_code);
1508
1509       if (insn == 0xe1a0c00d)           /* mov ip, sp */
1510         {
1511           regs[ARM_IP_REGNUM] = regs[ARM_SP_REGNUM];
1512           continue;
1513         }
1514       else if ((insn & 0xfff00000) == 0xe2800000        /* add Rd, Rn, #n */
1515                && pv_is_register (regs[bits (insn, 16, 19)], ARM_SP_REGNUM))
1516         {
1517           unsigned imm = insn & 0xff;                   /* immediate value */
1518           unsigned rot = (insn & 0xf00) >> 7;           /* rotate amount */
1519           int rd = bits (insn, 12, 15);
1520           imm = (imm >> rot) | (imm << (32 - rot));
1521           regs[rd] = pv_add_constant (regs[bits (insn, 16, 19)], imm);
1522           continue;
1523         }
1524       else if ((insn & 0xfff00000) == 0xe2400000        /* sub Rd, Rn, #n */
1525                && pv_is_register (regs[bits (insn, 16, 19)], ARM_SP_REGNUM))
1526         {
1527           unsigned imm = insn & 0xff;                   /* immediate value */
1528           unsigned rot = (insn & 0xf00) >> 7;           /* rotate amount */
1529           int rd = bits (insn, 12, 15);
1530           imm = (imm >> rot) | (imm << (32 - rot));
1531           regs[rd] = pv_add_constant (regs[bits (insn, 16, 19)], -imm);
1532           continue;
1533         }
1534       else if ((insn & 0xffff0fff) == 0xe52d0004)       /* str Rd,
1535                                                            [sp, #-4]! */
1536         {
1537           if (stack.store_would_trash (regs[ARM_SP_REGNUM]))
1538             break;
1539           regs[ARM_SP_REGNUM] = pv_add_constant (regs[ARM_SP_REGNUM], -4);
1540           stack.store (regs[ARM_SP_REGNUM], 4,
1541                        regs[bits (insn, 12, 15)]);
1542           continue;
1543         }
1544       else if ((insn & 0xffff0000) == 0xe92d0000)
1545         /* stmfd sp!, {..., fp, ip, lr, pc}
1546            or
1547            stmfd sp!, {a1, a2, a3, a4}  */
1548         {
1549           int mask = insn & 0xffff;
1550
1551           if (stack.store_would_trash (regs[ARM_SP_REGNUM]))
1552             break;
1553
1554           /* Calculate offsets of saved registers.  */
1555           for (regno = ARM_PC_REGNUM; regno >= 0; regno--)
1556             if (mask & (1 << regno))
1557               {
1558                 regs[ARM_SP_REGNUM]
1559                   = pv_add_constant (regs[ARM_SP_REGNUM], -4);
1560                 stack.store (regs[ARM_SP_REGNUM], 4, regs[regno]);
1561               }
1562         }
1563       else if ((insn & 0xffff0000) == 0xe54b0000        /* strb rx,[r11,#-n] */
1564                || (insn & 0xffff00f0) == 0xe14b00b0     /* strh rx,[r11,#-n] */
1565                || (insn & 0xffffc000) == 0xe50b0000)    /* str  rx,[r11,#-n] */
1566         {
1567           /* No need to add this to saved_regs -- it's just an arg reg.  */
1568           continue;
1569         }
1570       else if ((insn & 0xffff0000) == 0xe5cd0000        /* strb rx,[sp,#n] */
1571                || (insn & 0xffff00f0) == 0xe1cd00b0     /* strh rx,[sp,#n] */
1572                || (insn & 0xffffc000) == 0xe58d0000)    /* str  rx,[sp,#n] */
1573         {
1574           /* No need to add this to saved_regs -- it's just an arg reg.  */
1575           continue;
1576         }
1577       else if ((insn & 0xfff00000) == 0xe8800000        /* stm Rn,
1578                                                            { registers } */
1579                && pv_is_register (regs[bits (insn, 16, 19)], ARM_SP_REGNUM))
1580         {
1581           /* No need to add this to saved_regs -- it's just arg regs.  */
1582           continue;
1583         }
1584       else if ((insn & 0xfffff000) == 0xe24cb000)       /* sub fp, ip #n */
1585         {
1586           unsigned imm = insn & 0xff;                   /* immediate value */
1587           unsigned rot = (insn & 0xf00) >> 7;           /* rotate amount */
1588           imm = (imm >> rot) | (imm << (32 - rot));
1589           regs[ARM_FP_REGNUM] = pv_add_constant (regs[ARM_IP_REGNUM], -imm);
1590         }
1591       else if ((insn & 0xfffff000) == 0xe24dd000)       /* sub sp, sp #n */
1592         {
1593           unsigned imm = insn & 0xff;                   /* immediate value */
1594           unsigned rot = (insn & 0xf00) >> 7;           /* rotate amount */
1595           imm = (imm >> rot) | (imm << (32 - rot));
1596           regs[ARM_SP_REGNUM] = pv_add_constant (regs[ARM_SP_REGNUM], -imm);
1597         }
1598       else if ((insn & 0xffff7fff) == 0xed6d0103        /* stfe f?,
1599                                                            [sp, -#c]! */
1600                && gdbarch_tdep (gdbarch)->have_fpa_registers)
1601         {
1602           if (stack.store_would_trash (regs[ARM_SP_REGNUM]))
1603             break;
1604
1605           regs[ARM_SP_REGNUM] = pv_add_constant (regs[ARM_SP_REGNUM], -12);
1606           regno = ARM_F0_REGNUM + ((insn >> 12) & 0x07);
1607           stack.store (regs[ARM_SP_REGNUM], 12, regs[regno]);
1608         }
1609       else if ((insn & 0xffbf0fff) == 0xec2d0200        /* sfmfd f0, 4,
1610                                                            [sp!] */
1611                && gdbarch_tdep (gdbarch)->have_fpa_registers)
1612         {
1613           int n_saved_fp_regs;
1614           unsigned int fp_start_reg, fp_bound_reg;
1615
1616           if (stack.store_would_trash (regs[ARM_SP_REGNUM]))
1617             break;
1618
1619           if ((insn & 0x800) == 0x800)          /* N0 is set */
1620             {
1621               if ((insn & 0x40000) == 0x40000)  /* N1 is set */
1622                 n_saved_fp_regs = 3;
1623               else
1624                 n_saved_fp_regs = 1;
1625             }
1626           else
1627             {
1628               if ((insn & 0x40000) == 0x40000)  /* N1 is set */
1629                 n_saved_fp_regs = 2;
1630               else
1631                 n_saved_fp_regs = 4;
1632             }
1633
1634           fp_start_reg = ARM_F0_REGNUM + ((insn >> 12) & 0x7);
1635           fp_bound_reg = fp_start_reg + n_saved_fp_regs;
1636           for (; fp_start_reg < fp_bound_reg; fp_start_reg++)
1637             {
1638               regs[ARM_SP_REGNUM] = pv_add_constant (regs[ARM_SP_REGNUM], -12);
1639               stack.store (regs[ARM_SP_REGNUM], 12,
1640                            regs[fp_start_reg++]);
1641             }
1642         }
1643       else if ((insn & 0xff000000) == 0xeb000000 && cache == NULL) /* bl */
1644         {
1645           /* Allow some special function calls when skipping the
1646              prologue; GCC generates these before storing arguments to
1647              the stack.  */
1648           CORE_ADDR dest = BranchDest (current_pc, insn);
1649
1650           if (skip_prologue_function (gdbarch, dest, 0))
1651             continue;
1652           else
1653             break;
1654         }
1655       else if ((insn & 0xf0000000) != 0xe0000000)
1656         break;                  /* Condition not true, exit early.  */
1657       else if (arm_instruction_changes_pc (insn))
1658         /* Don't scan past anything that might change control flow.  */
1659         break;
1660       else if (arm_instruction_restores_sp (insn))
1661         {
1662           /* Don't scan past the epilogue.  */
1663           break;
1664         }
1665       else if ((insn & 0xfe500000) == 0xe8100000        /* ldm */
1666                && pv_is_register (regs[bits (insn, 16, 19)], ARM_SP_REGNUM))
1667         /* Ignore block loads from the stack, potentially copying
1668            parameters from memory.  */
1669         continue;
1670       else if ((insn & 0xfc500000) == 0xe4100000
1671                && pv_is_register (regs[bits (insn, 16, 19)], ARM_SP_REGNUM))
1672         /* Similarly ignore single loads from the stack.  */
1673         continue;
1674       else if ((insn & 0xffff0ff0) == 0xe1a00000)
1675         /* MOV Rd, Rm.  Skip register copies, i.e. saves to another
1676            register instead of the stack.  */
1677         continue;
1678       else
1679         {
1680           /* The optimizer might shove anything into the prologue, if
1681              we build up cache (cache != NULL) from scanning prologue,
1682              we just skip what we don't recognize and scan further to
1683              make cache as complete as possible.  However, if we skip
1684              prologue, we'll stop immediately on unrecognized
1685              instruction.  */
1686           unrecognized_pc = current_pc;
1687           if (cache != NULL)
1688             continue;
1689           else
1690             break;
1691         }
1692     }
1693
1694   if (unrecognized_pc == 0)
1695     unrecognized_pc = current_pc;
1696
1697   if (cache)
1698     {
1699       int framereg, framesize;
1700
1701       /* The frame size is just the distance from the frame register
1702          to the original stack pointer.  */
1703       if (pv_is_register (regs[ARM_FP_REGNUM], ARM_SP_REGNUM))
1704         {
1705           /* Frame pointer is fp.  */
1706           framereg = ARM_FP_REGNUM;
1707           framesize = -regs[ARM_FP_REGNUM].k;
1708         }
1709       else
1710         {
1711           /* Try the stack pointer... this is a bit desperate.  */
1712           framereg = ARM_SP_REGNUM;
1713           framesize = -regs[ARM_SP_REGNUM].k;
1714         }
1715
1716       cache->framereg = framereg;
1717       cache->framesize = framesize;
1718
1719       for (regno = 0; regno < ARM_FPS_REGNUM; regno++)
1720         if (stack.find_reg (gdbarch, regno, &offset))
1721           cache->saved_regs[regno].addr = offset;
1722     }
1723
1724   if (arm_debug)
1725     fprintf_unfiltered (gdb_stdlog, "Prologue scan stopped at %s\n",
1726                         paddress (gdbarch, unrecognized_pc));
1727
1728   return unrecognized_pc;
1729 }
1730
1731 static void
1732 arm_scan_prologue (struct frame_info *this_frame,
1733                    struct arm_prologue_cache *cache)
1734 {
1735   struct gdbarch *gdbarch = get_frame_arch (this_frame);
1736   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1737   CORE_ADDR prologue_start, prologue_end;
1738   CORE_ADDR prev_pc = get_frame_pc (this_frame);
1739   CORE_ADDR block_addr = get_frame_address_in_block (this_frame);
1740
1741   /* Assume there is no frame until proven otherwise.  */
1742   cache->framereg = ARM_SP_REGNUM;
1743   cache->framesize = 0;
1744
1745   /* Check for Thumb prologue.  */
1746   if (arm_frame_is_thumb (this_frame))
1747     {
1748       thumb_scan_prologue (gdbarch, prev_pc, block_addr, cache);
1749       return;
1750     }
1751
1752   /* Find the function prologue.  If we can't find the function in
1753      the symbol table, peek in the stack frame to find the PC.  */
1754   if (find_pc_partial_function (block_addr, NULL, &prologue_start,
1755                                 &prologue_end))
1756     {
1757       /* One way to find the end of the prologue (which works well
1758          for unoptimized code) is to do the following:
1759
1760             struct symtab_and_line sal = find_pc_line (prologue_start, 0);
1761
1762             if (sal.line == 0)
1763               prologue_end = prev_pc;
1764             else if (sal.end < prologue_end)
1765               prologue_end = sal.end;
1766
1767          This mechanism is very accurate so long as the optimizer
1768          doesn't move any instructions from the function body into the
1769          prologue.  If this happens, sal.end will be the last
1770          instruction in the first hunk of prologue code just before
1771          the first instruction that the scheduler has moved from
1772          the body to the prologue.
1773
1774          In order to make sure that we scan all of the prologue
1775          instructions, we use a slightly less accurate mechanism which
1776          may scan more than necessary.  To help compensate for this
1777          lack of accuracy, the prologue scanning loop below contains
1778          several clauses which'll cause the loop to terminate early if
1779          an implausible prologue instruction is encountered.
1780
1781          The expression
1782
1783               prologue_start + 64
1784
1785          is a suitable endpoint since it accounts for the largest
1786          possible prologue plus up to five instructions inserted by
1787          the scheduler.  */
1788
1789       if (prologue_end > prologue_start + 64)
1790         {
1791           prologue_end = prologue_start + 64;   /* See above.  */
1792         }
1793     }
1794   else
1795     {
1796       /* We have no symbol information.  Our only option is to assume this
1797          function has a standard stack frame and the normal frame register.
1798          Then, we can find the value of our frame pointer on entrance to
1799          the callee (or at the present moment if this is the innermost frame).
1800          The value stored there should be the address of the stmfd + 8.  */
1801       CORE_ADDR frame_loc;
1802       ULONGEST return_value;
1803
1804       /* AAPCS does not use a frame register, so we can abort here.  */
1805       if (gdbarch_tdep (gdbarch)->arm_abi == ARM_ABI_AAPCS)
1806         return;
1807
1808       frame_loc = get_frame_register_unsigned (this_frame, ARM_FP_REGNUM);
1809       if (!safe_read_memory_unsigned_integer (frame_loc, 4, byte_order,
1810                                               &return_value))
1811         return;
1812       else
1813         {
1814           prologue_start = gdbarch_addr_bits_remove
1815                              (gdbarch, return_value) - 8;
1816           prologue_end = prologue_start + 64;   /* See above.  */
1817         }
1818     }
1819
1820   if (prev_pc < prologue_end)
1821     prologue_end = prev_pc;
1822
1823   arm_analyze_prologue (gdbarch, prologue_start, prologue_end, cache);
1824 }
1825
1826 static struct arm_prologue_cache *
1827 arm_make_prologue_cache (struct frame_info *this_frame)
1828 {
1829   int reg;
1830   struct arm_prologue_cache *cache;
1831   CORE_ADDR unwound_fp;
1832
1833   cache = FRAME_OBSTACK_ZALLOC (struct arm_prologue_cache);
1834   cache->saved_regs = trad_frame_alloc_saved_regs (this_frame);
1835
1836   arm_scan_prologue (this_frame, cache);
1837
1838   unwound_fp = get_frame_register_unsigned (this_frame, cache->framereg);
1839   if (unwound_fp == 0)
1840     return cache;
1841
1842   cache->prev_sp = unwound_fp + cache->framesize;
1843
1844   /* Calculate actual addresses of saved registers using offsets
1845      determined by arm_scan_prologue.  */
1846   for (reg = 0; reg < gdbarch_num_regs (get_frame_arch (this_frame)); reg++)
1847     if (trad_frame_addr_p (cache->saved_regs, reg))
1848       cache->saved_regs[reg].addr += cache->prev_sp;
1849
1850   return cache;
1851 }
1852
1853 /* Implementation of the stop_reason hook for arm_prologue frames.  */
1854
1855 static enum unwind_stop_reason
1856 arm_prologue_unwind_stop_reason (struct frame_info *this_frame,
1857                                  void **this_cache)
1858 {
1859   struct arm_prologue_cache *cache;
1860   CORE_ADDR pc;
1861
1862   if (*this_cache == NULL)
1863     *this_cache = arm_make_prologue_cache (this_frame);
1864   cache = (struct arm_prologue_cache *) *this_cache;
1865
1866   /* This is meant to halt the backtrace at "_start".  */
1867   pc = get_frame_pc (this_frame);
1868   if (pc <= gdbarch_tdep (get_frame_arch (this_frame))->lowest_pc)
1869     return UNWIND_OUTERMOST;
1870
1871   /* If we've hit a wall, stop.  */
1872   if (cache->prev_sp == 0)
1873     return UNWIND_OUTERMOST;
1874
1875   return UNWIND_NO_REASON;
1876 }
1877
1878 /* Our frame ID for a normal frame is the current function's starting PC
1879    and the caller's SP when we were called.  */
1880
1881 static void
1882 arm_prologue_this_id (struct frame_info *this_frame,
1883                       void **this_cache,
1884                       struct frame_id *this_id)
1885 {
1886   struct arm_prologue_cache *cache;
1887   struct frame_id id;
1888   CORE_ADDR pc, func;
1889
1890   if (*this_cache == NULL)
1891     *this_cache = arm_make_prologue_cache (this_frame);
1892   cache = (struct arm_prologue_cache *) *this_cache;
1893
1894   /* Use function start address as part of the frame ID.  If we cannot
1895      identify the start address (due to missing symbol information),
1896      fall back to just using the current PC.  */
1897   pc = get_frame_pc (this_frame);
1898   func = get_frame_func (this_frame);
1899   if (!func)
1900     func = pc;
1901
1902   id = frame_id_build (cache->prev_sp, func);
1903   *this_id = id;
1904 }
1905
1906 static struct value *
1907 arm_prologue_prev_register (struct frame_info *this_frame,
1908                             void **this_cache,
1909                             int prev_regnum)
1910 {
1911   struct gdbarch *gdbarch = get_frame_arch (this_frame);
1912   struct arm_prologue_cache *cache;
1913
1914   if (*this_cache == NULL)
1915     *this_cache = arm_make_prologue_cache (this_frame);
1916   cache = (struct arm_prologue_cache *) *this_cache;
1917
1918   /* If we are asked to unwind the PC, then we need to return the LR
1919      instead.  The prologue may save PC, but it will point into this
1920      frame's prologue, not the next frame's resume location.  Also
1921      strip the saved T bit.  A valid LR may have the low bit set, but
1922      a valid PC never does.  */
1923   if (prev_regnum == ARM_PC_REGNUM)
1924     {
1925       CORE_ADDR lr;
1926
1927       lr = frame_unwind_register_unsigned (this_frame, ARM_LR_REGNUM);
1928       return frame_unwind_got_constant (this_frame, prev_regnum,
1929                                         arm_addr_bits_remove (gdbarch, lr));
1930     }
1931
1932   /* SP is generally not saved to the stack, but this frame is
1933      identified by the next frame's stack pointer at the time of the call.
1934      The value was already reconstructed into PREV_SP.  */
1935   if (prev_regnum == ARM_SP_REGNUM)
1936     return frame_unwind_got_constant (this_frame, prev_regnum, cache->prev_sp);
1937
1938   /* The CPSR may have been changed by the call instruction and by the
1939      called function.  The only bit we can reconstruct is the T bit,
1940      by checking the low bit of LR as of the call.  This is a reliable
1941      indicator of Thumb-ness except for some ARM v4T pre-interworking
1942      Thumb code, which could get away with a clear low bit as long as
1943      the called function did not use bx.  Guess that all other
1944      bits are unchanged; the condition flags are presumably lost,
1945      but the processor status is likely valid.  */
1946   if (prev_regnum == ARM_PS_REGNUM)
1947     {
1948       CORE_ADDR lr, cpsr;
1949       ULONGEST t_bit = arm_psr_thumb_bit (gdbarch);
1950
1951       cpsr = get_frame_register_unsigned (this_frame, prev_regnum);
1952       lr = frame_unwind_register_unsigned (this_frame, ARM_LR_REGNUM);
1953       if (IS_THUMB_ADDR (lr))
1954         cpsr |= t_bit;
1955       else
1956         cpsr &= ~t_bit;
1957       return frame_unwind_got_constant (this_frame, prev_regnum, cpsr);
1958     }
1959
1960   return trad_frame_get_prev_register (this_frame, cache->saved_regs,
1961                                        prev_regnum);
1962 }
1963
1964 struct frame_unwind arm_prologue_unwind = {
1965   NORMAL_FRAME,
1966   arm_prologue_unwind_stop_reason,
1967   arm_prologue_this_id,
1968   arm_prologue_prev_register,
1969   NULL,
1970   default_frame_sniffer
1971 };
1972
1973 /* Maintain a list of ARM exception table entries per objfile, similar to the
1974    list of mapping symbols.  We only cache entries for standard ARM-defined
1975    personality routines; the cache will contain only the frame unwinding
1976    instructions associated with the entry (not the descriptors).  */
1977
1978 static const struct objfile_data *arm_exidx_data_key;
1979
1980 struct arm_exidx_entry
1981 {
1982   bfd_vma addr;
1983   gdb_byte *entry;
1984 };
1985 typedef struct arm_exidx_entry arm_exidx_entry_s;
1986 DEF_VEC_O(arm_exidx_entry_s);
1987
1988 struct arm_exidx_data
1989 {
1990   VEC(arm_exidx_entry_s) **section_maps;
1991 };
1992
1993 static void
1994 arm_exidx_data_free (struct objfile *objfile, void *arg)
1995 {
1996   struct arm_exidx_data *data = (struct arm_exidx_data *) arg;
1997   unsigned int i;
1998
1999   for (i = 0; i < objfile->obfd->section_count; i++)
2000     VEC_free (arm_exidx_entry_s, data->section_maps[i]);
2001 }
2002
2003 static inline int
2004 arm_compare_exidx_entries (const struct arm_exidx_entry *lhs,
2005                            const struct arm_exidx_entry *rhs)
2006 {
2007   return lhs->addr < rhs->addr;
2008 }
2009
2010 static struct obj_section *
2011 arm_obj_section_from_vma (struct objfile *objfile, bfd_vma vma)
2012 {
2013   struct obj_section *osect;
2014
2015   ALL_OBJFILE_OSECTIONS (objfile, osect)
2016     if (bfd_get_section_flags (objfile->obfd,
2017                                osect->the_bfd_section) & SEC_ALLOC)
2018       {
2019         bfd_vma start, size;
2020         start = bfd_get_section_vma (objfile->obfd, osect->the_bfd_section);
2021         size = bfd_get_section_size (osect->the_bfd_section);
2022
2023         if (start <= vma && vma < start + size)
2024           return osect;
2025       }
2026
2027   return NULL;
2028 }
2029
2030 /* Parse contents of exception table and exception index sections
2031    of OBJFILE, and fill in the exception table entry cache.
2032
2033    For each entry that refers to a standard ARM-defined personality
2034    routine, extract the frame unwinding instructions (from either
2035    the index or the table section).  The unwinding instructions
2036    are normalized by:
2037     - extracting them from the rest of the table data
2038     - converting to host endianness
2039     - appending the implicit 0xb0 ("Finish") code
2040
2041    The extracted and normalized instructions are stored for later
2042    retrieval by the arm_find_exidx_entry routine.  */
2043  
2044 static void
2045 arm_exidx_new_objfile (struct objfile *objfile)
2046 {
2047   struct arm_exidx_data *data;
2048   asection *exidx, *extab;
2049   bfd_vma exidx_vma = 0, extab_vma = 0;
2050   LONGEST i;
2051
2052   /* If we've already touched this file, do nothing.  */
2053   if (!objfile || objfile_data (objfile, arm_exidx_data_key) != NULL)
2054     return;
2055
2056   /* Read contents of exception table and index.  */
2057   exidx = bfd_get_section_by_name (objfile->obfd, ELF_STRING_ARM_unwind);
2058   gdb::byte_vector exidx_data;
2059   if (exidx)
2060     {
2061       exidx_vma = bfd_section_vma (objfile->obfd, exidx);
2062       exidx_data.resize (bfd_get_section_size (exidx));
2063
2064       if (!bfd_get_section_contents (objfile->obfd, exidx,
2065                                      exidx_data.data (), 0,
2066                                      exidx_data.size ()))
2067         return;
2068     }
2069
2070   extab = bfd_get_section_by_name (objfile->obfd, ".ARM.extab");
2071   gdb::byte_vector extab_data;
2072   if (extab)
2073     {
2074       extab_vma = bfd_section_vma (objfile->obfd, extab);
2075       extab_data.resize (bfd_get_section_size (extab));
2076
2077       if (!bfd_get_section_contents (objfile->obfd, extab,
2078                                      extab_data.data (), 0,
2079                                      extab_data.size ()))
2080         return;
2081     }
2082
2083   /* Allocate exception table data structure.  */
2084   data = OBSTACK_ZALLOC (&objfile->objfile_obstack, struct arm_exidx_data);
2085   set_objfile_data (objfile, arm_exidx_data_key, data);
2086   data->section_maps = OBSTACK_CALLOC (&objfile->objfile_obstack,
2087                                        objfile->obfd->section_count,
2088                                        VEC(arm_exidx_entry_s) *);
2089
2090   /* Fill in exception table.  */
2091   for (i = 0; i < exidx_data.size () / 8; i++)
2092     {
2093       struct arm_exidx_entry new_exidx_entry;
2094       bfd_vma idx = bfd_h_get_32 (objfile->obfd, exidx_data.data () + i * 8);
2095       bfd_vma val = bfd_h_get_32 (objfile->obfd,
2096                                   exidx_data.data () + i * 8 + 4);
2097       bfd_vma addr = 0, word = 0;
2098       int n_bytes = 0, n_words = 0;
2099       struct obj_section *sec;
2100       gdb_byte *entry = NULL;
2101
2102       /* Extract address of start of function.  */
2103       idx = ((idx & 0x7fffffff) ^ 0x40000000) - 0x40000000;
2104       idx += exidx_vma + i * 8;
2105
2106       /* Find section containing function and compute section offset.  */
2107       sec = arm_obj_section_from_vma (objfile, idx);
2108       if (sec == NULL)
2109         continue;
2110       idx -= bfd_get_section_vma (objfile->obfd, sec->the_bfd_section);
2111
2112       /* Determine address of exception table entry.  */
2113       if (val == 1)
2114         {
2115           /* EXIDX_CANTUNWIND -- no exception table entry present.  */
2116         }
2117       else if ((val & 0xff000000) == 0x80000000)
2118         {
2119           /* Exception table entry embedded in .ARM.exidx
2120              -- must be short form.  */
2121           word = val;
2122           n_bytes = 3;
2123         }
2124       else if (!(val & 0x80000000))
2125         {
2126           /* Exception table entry in .ARM.extab.  */
2127           addr = ((val & 0x7fffffff) ^ 0x40000000) - 0x40000000;
2128           addr += exidx_vma + i * 8 + 4;
2129
2130           if (addr >= extab_vma && addr + 4 <= extab_vma + extab_data.size ())
2131             {
2132               word = bfd_h_get_32 (objfile->obfd,
2133                                    extab_data.data () + addr - extab_vma);
2134               addr += 4;
2135
2136               if ((word & 0xff000000) == 0x80000000)
2137                 {
2138                   /* Short form.  */
2139                   n_bytes = 3;
2140                 }
2141               else if ((word & 0xff000000) == 0x81000000
2142                        || (word & 0xff000000) == 0x82000000)
2143                 {
2144                   /* Long form.  */
2145                   n_bytes = 2;
2146                   n_words = ((word >> 16) & 0xff);
2147                 }
2148               else if (!(word & 0x80000000))
2149                 {
2150                   bfd_vma pers;
2151                   struct obj_section *pers_sec;
2152                   int gnu_personality = 0;
2153
2154                   /* Custom personality routine.  */
2155                   pers = ((word & 0x7fffffff) ^ 0x40000000) - 0x40000000;
2156                   pers = UNMAKE_THUMB_ADDR (pers + addr - 4);
2157
2158                   /* Check whether we've got one of the variants of the
2159                      GNU personality routines.  */
2160                   pers_sec = arm_obj_section_from_vma (objfile, pers);
2161                   if (pers_sec)
2162                     {
2163                       static const char *personality[] = 
2164                         {
2165                           "__gcc_personality_v0",
2166                           "__gxx_personality_v0",
2167                           "__gcj_personality_v0",
2168                           "__gnu_objc_personality_v0",
2169                           NULL
2170                         };
2171
2172                       CORE_ADDR pc = pers + obj_section_offset (pers_sec);
2173                       int k;
2174
2175                       for (k = 0; personality[k]; k++)
2176                         if (lookup_minimal_symbol_by_pc_name
2177                               (pc, personality[k], objfile))
2178                           {
2179                             gnu_personality = 1;
2180                             break;
2181                           }
2182                     }
2183
2184                   /* If so, the next word contains a word count in the high
2185                      byte, followed by the same unwind instructions as the
2186                      pre-defined forms.  */
2187                   if (gnu_personality
2188                       && addr + 4 <= extab_vma + extab_data.size ())
2189                     {
2190                       word = bfd_h_get_32 (objfile->obfd,
2191                                            (extab_data.data ()
2192                                             + addr - extab_vma));
2193                       addr += 4;
2194                       n_bytes = 3;
2195                       n_words = ((word >> 24) & 0xff);
2196                     }
2197                 }
2198             }
2199         }
2200
2201       /* Sanity check address.  */
2202       if (n_words)
2203         if (addr < extab_vma
2204             || addr + 4 * n_words > extab_vma + extab_data.size ())
2205           n_words = n_bytes = 0;
2206
2207       /* The unwind instructions reside in WORD (only the N_BYTES least
2208          significant bytes are valid), followed by N_WORDS words in the
2209          extab section starting at ADDR.  */
2210       if (n_bytes || n_words)
2211         {
2212           gdb_byte *p = entry
2213             = (gdb_byte *) obstack_alloc (&objfile->objfile_obstack,
2214                                           n_bytes + n_words * 4 + 1);
2215
2216           while (n_bytes--)
2217             *p++ = (gdb_byte) ((word >> (8 * n_bytes)) & 0xff);
2218
2219           while (n_words--)
2220             {
2221               word = bfd_h_get_32 (objfile->obfd,
2222                                    extab_data.data () + addr - extab_vma);
2223               addr += 4;
2224
2225               *p++ = (gdb_byte) ((word >> 24) & 0xff);
2226               *p++ = (gdb_byte) ((word >> 16) & 0xff);
2227               *p++ = (gdb_byte) ((word >> 8) & 0xff);
2228               *p++ = (gdb_byte) (word & 0xff);
2229             }
2230
2231           /* Implied "Finish" to terminate the list.  */
2232           *p++ = 0xb0;
2233         }
2234
2235       /* Push entry onto vector.  They are guaranteed to always
2236          appear in order of increasing addresses.  */
2237       new_exidx_entry.addr = idx;
2238       new_exidx_entry.entry = entry;
2239       VEC_safe_push (arm_exidx_entry_s,
2240                      data->section_maps[sec->the_bfd_section->index],
2241                      &new_exidx_entry);
2242     }
2243 }
2244
2245 /* Search for the exception table entry covering MEMADDR.  If one is found,
2246    return a pointer to its data.  Otherwise, return 0.  If START is non-NULL,
2247    set *START to the start of the region covered by this entry.  */
2248
2249 static gdb_byte *
2250 arm_find_exidx_entry (CORE_ADDR memaddr, CORE_ADDR *start)
2251 {
2252   struct obj_section *sec;
2253
2254   sec = find_pc_section (memaddr);
2255   if (sec != NULL)
2256     {
2257       struct arm_exidx_data *data;
2258       VEC(arm_exidx_entry_s) *map;
2259       struct arm_exidx_entry map_key = { memaddr - obj_section_addr (sec), 0 };
2260       unsigned int idx;
2261
2262       data = ((struct arm_exidx_data *)
2263               objfile_data (sec->objfile, arm_exidx_data_key));
2264       if (data != NULL)
2265         {
2266           map = data->section_maps[sec->the_bfd_section->index];
2267           if (!VEC_empty (arm_exidx_entry_s, map))
2268             {
2269               struct arm_exidx_entry *map_sym;
2270
2271               idx = VEC_lower_bound (arm_exidx_entry_s, map, &map_key,
2272                                      arm_compare_exidx_entries);
2273
2274               /* VEC_lower_bound finds the earliest ordered insertion
2275                  point.  If the following symbol starts at this exact
2276                  address, we use that; otherwise, the preceding
2277                  exception table entry covers this address.  */
2278               if (idx < VEC_length (arm_exidx_entry_s, map))
2279                 {
2280                   map_sym = VEC_index (arm_exidx_entry_s, map, idx);
2281                   if (map_sym->addr == map_key.addr)
2282                     {
2283                       if (start)
2284                         *start = map_sym->addr + obj_section_addr (sec);
2285                       return map_sym->entry;
2286                     }
2287                 }
2288
2289               if (idx > 0)
2290                 {
2291                   map_sym = VEC_index (arm_exidx_entry_s, map, idx - 1);
2292                   if (start)
2293                     *start = map_sym->addr + obj_section_addr (sec);
2294                   return map_sym->entry;
2295                 }
2296             }
2297         }
2298     }
2299
2300   return NULL;
2301 }
2302
2303 /* Given the current frame THIS_FRAME, and its associated frame unwinding
2304    instruction list from the ARM exception table entry ENTRY, allocate and
2305    return a prologue cache structure describing how to unwind this frame.
2306
2307    Return NULL if the unwinding instruction list contains a "spare",
2308    "reserved" or "refuse to unwind" instruction as defined in section
2309    "9.3 Frame unwinding instructions" of the "Exception Handling ABI
2310    for the ARM Architecture" document.  */
2311
2312 static struct arm_prologue_cache *
2313 arm_exidx_fill_cache (struct frame_info *this_frame, gdb_byte *entry)
2314 {
2315   CORE_ADDR vsp = 0;
2316   int vsp_valid = 0;
2317
2318   struct arm_prologue_cache *cache;
2319   cache = FRAME_OBSTACK_ZALLOC (struct arm_prologue_cache);
2320   cache->saved_regs = trad_frame_alloc_saved_regs (this_frame);
2321
2322   for (;;)
2323     {
2324       gdb_byte insn;
2325
2326       /* Whenever we reload SP, we actually have to retrieve its
2327          actual value in the current frame.  */
2328       if (!vsp_valid)
2329         {
2330           if (trad_frame_realreg_p (cache->saved_regs, ARM_SP_REGNUM))
2331             {
2332               int reg = cache->saved_regs[ARM_SP_REGNUM].realreg;
2333               vsp = get_frame_register_unsigned (this_frame, reg);
2334             }
2335           else
2336             {
2337               CORE_ADDR addr = cache->saved_regs[ARM_SP_REGNUM].addr;
2338               vsp = get_frame_memory_unsigned (this_frame, addr, 4);
2339             }
2340
2341           vsp_valid = 1;
2342         }
2343
2344       /* Decode next unwind instruction.  */
2345       insn = *entry++;
2346
2347       if ((insn & 0xc0) == 0)
2348         {
2349           int offset = insn & 0x3f;
2350           vsp += (offset << 2) + 4;
2351         }
2352       else if ((insn & 0xc0) == 0x40)
2353         {
2354           int offset = insn & 0x3f;
2355           vsp -= (offset << 2) + 4;
2356         }
2357       else if ((insn & 0xf0) == 0x80)
2358         {
2359           int mask = ((insn & 0xf) << 8) | *entry++;
2360           int i;
2361
2362           /* The special case of an all-zero mask identifies
2363              "Refuse to unwind".  We return NULL to fall back
2364              to the prologue analyzer.  */
2365           if (mask == 0)
2366             return NULL;
2367
2368           /* Pop registers r4..r15 under mask.  */
2369           for (i = 0; i < 12; i++)
2370             if (mask & (1 << i))
2371               {
2372                 cache->saved_regs[4 + i].addr = vsp;
2373                 vsp += 4;
2374               }
2375
2376           /* Special-case popping SP -- we need to reload vsp.  */
2377           if (mask & (1 << (ARM_SP_REGNUM - 4)))
2378             vsp_valid = 0;
2379         }
2380       else if ((insn & 0xf0) == 0x90)
2381         {
2382           int reg = insn & 0xf;
2383
2384           /* Reserved cases.  */
2385           if (reg == ARM_SP_REGNUM || reg == ARM_PC_REGNUM)
2386             return NULL;
2387
2388           /* Set SP from another register and mark VSP for reload.  */
2389           cache->saved_regs[ARM_SP_REGNUM] = cache->saved_regs[reg];
2390           vsp_valid = 0;
2391         }
2392       else if ((insn & 0xf0) == 0xa0)
2393         {
2394           int count = insn & 0x7;
2395           int pop_lr = (insn & 0x8) != 0;
2396           int i;
2397
2398           /* Pop r4..r[4+count].  */
2399           for (i = 0; i <= count; i++)
2400             {
2401               cache->saved_regs[4 + i].addr = vsp;
2402               vsp += 4;
2403             }
2404
2405           /* If indicated by flag, pop LR as well.  */
2406           if (pop_lr)
2407             {
2408               cache->saved_regs[ARM_LR_REGNUM].addr = vsp;
2409               vsp += 4;
2410             }
2411         }
2412       else if (insn == 0xb0)
2413         {
2414           /* We could only have updated PC by popping into it; if so, it
2415              will show up as address.  Otherwise, copy LR into PC.  */
2416           if (!trad_frame_addr_p (cache->saved_regs, ARM_PC_REGNUM))
2417             cache->saved_regs[ARM_PC_REGNUM]
2418               = cache->saved_regs[ARM_LR_REGNUM];
2419
2420           /* We're done.  */
2421           break;
2422         }
2423       else if (insn == 0xb1)
2424         {
2425           int mask = *entry++;
2426           int i;
2427
2428           /* All-zero mask and mask >= 16 is "spare".  */
2429           if (mask == 0 || mask >= 16)
2430             return NULL;
2431
2432           /* Pop r0..r3 under mask.  */
2433           for (i = 0; i < 4; i++)
2434             if (mask & (1 << i))
2435               {
2436                 cache->saved_regs[i].addr = vsp;
2437                 vsp += 4;
2438               }
2439         }
2440       else if (insn == 0xb2)
2441         {
2442           ULONGEST offset = 0;
2443           unsigned shift = 0;
2444
2445           do
2446             {
2447               offset |= (*entry & 0x7f) << shift;
2448               shift += 7;
2449             }
2450           while (*entry++ & 0x80);
2451
2452           vsp += 0x204 + (offset << 2);
2453         }
2454       else if (insn == 0xb3)
2455         {
2456           int start = *entry >> 4;
2457           int count = (*entry++) & 0xf;
2458           int i;
2459
2460           /* Only registers D0..D15 are valid here.  */
2461           if (start + count >= 16)
2462             return NULL;
2463
2464           /* Pop VFP double-precision registers D[start]..D[start+count].  */
2465           for (i = 0; i <= count; i++)
2466             {
2467               cache->saved_regs[ARM_D0_REGNUM + start + i].addr = vsp;
2468               vsp += 8;
2469             }
2470
2471           /* Add an extra 4 bytes for FSTMFDX-style stack.  */
2472           vsp += 4;
2473         }
2474       else if ((insn & 0xf8) == 0xb8)
2475         {
2476           int count = insn & 0x7;
2477           int i;
2478
2479           /* Pop VFP double-precision registers D[8]..D[8+count].  */
2480           for (i = 0; i <= count; i++)
2481             {
2482               cache->saved_regs[ARM_D0_REGNUM + 8 + i].addr = vsp;
2483               vsp += 8;
2484             }
2485
2486           /* Add an extra 4 bytes for FSTMFDX-style stack.  */
2487           vsp += 4;
2488         }
2489       else if (insn == 0xc6)
2490         {
2491           int start = *entry >> 4;
2492           int count = (*entry++) & 0xf;
2493           int i;
2494
2495           /* Only registers WR0..WR15 are valid.  */
2496           if (start + count >= 16)
2497             return NULL;
2498
2499           /* Pop iwmmx registers WR[start]..WR[start+count].  */
2500           for (i = 0; i <= count; i++)
2501             {
2502               cache->saved_regs[ARM_WR0_REGNUM + start + i].addr = vsp;
2503               vsp += 8;
2504             }
2505         }
2506       else if (insn == 0xc7)
2507         {
2508           int mask = *entry++;
2509           int i;
2510
2511           /* All-zero mask and mask >= 16 is "spare".  */
2512           if (mask == 0 || mask >= 16)
2513             return NULL;
2514
2515           /* Pop iwmmx general-purpose registers WCGR0..WCGR3 under mask.  */
2516           for (i = 0; i < 4; i++)
2517             if (mask & (1 << i))
2518               {
2519                 cache->saved_regs[ARM_WCGR0_REGNUM + i].addr = vsp;
2520                 vsp += 4;
2521               }
2522         }
2523       else if ((insn & 0xf8) == 0xc0)
2524         {
2525           int count = insn & 0x7;
2526           int i;
2527
2528           /* Pop iwmmx registers WR[10]..WR[10+count].  */
2529           for (i = 0; i <= count; i++)
2530             {
2531               cache->saved_regs[ARM_WR0_REGNUM + 10 + i].addr = vsp;
2532               vsp += 8;
2533             }
2534         }
2535       else if (insn == 0xc8)
2536         {
2537           int start = *entry >> 4;
2538           int count = (*entry++) & 0xf;
2539           int i;
2540
2541           /* Only registers D0..D31 are valid.  */
2542           if (start + count >= 16)
2543             return NULL;
2544
2545           /* Pop VFP double-precision registers
2546              D[16+start]..D[16+start+count].  */
2547           for (i = 0; i <= count; i++)
2548             {
2549               cache->saved_regs[ARM_D0_REGNUM + 16 + start + i].addr = vsp;
2550               vsp += 8;
2551             }
2552         }
2553       else if (insn == 0xc9)
2554         {
2555           int start = *entry >> 4;
2556           int count = (*entry++) & 0xf;
2557           int i;
2558
2559           /* Pop VFP double-precision registers D[start]..D[start+count].  */
2560           for (i = 0; i <= count; i++)
2561             {
2562               cache->saved_regs[ARM_D0_REGNUM + start + i].addr = vsp;
2563               vsp += 8;
2564             }
2565         }
2566       else if ((insn & 0xf8) == 0xd0)
2567         {
2568           int count = insn & 0x7;
2569           int i;
2570
2571           /* Pop VFP double-precision registers D[8]..D[8+count].  */
2572           for (i = 0; i <= count; i++)
2573             {
2574               cache->saved_regs[ARM_D0_REGNUM + 8 + i].addr = vsp;
2575               vsp += 8;
2576             }
2577         }
2578       else
2579         {
2580           /* Everything else is "spare".  */
2581           return NULL;
2582         }
2583     }
2584
2585   /* If we restore SP from a register, assume this was the frame register.
2586      Otherwise just fall back to SP as frame register.  */
2587   if (trad_frame_realreg_p (cache->saved_regs, ARM_SP_REGNUM))
2588     cache->framereg = cache->saved_regs[ARM_SP_REGNUM].realreg;
2589   else
2590     cache->framereg = ARM_SP_REGNUM;
2591
2592   /* Determine offset to previous frame.  */
2593   cache->framesize
2594     = vsp - get_frame_register_unsigned (this_frame, cache->framereg);
2595
2596   /* We already got the previous SP.  */
2597   cache->prev_sp = vsp;
2598
2599   return cache;
2600 }
2601
2602 /* Unwinding via ARM exception table entries.  Note that the sniffer
2603    already computes a filled-in prologue cache, which is then used
2604    with the same arm_prologue_this_id and arm_prologue_prev_register
2605    routines also used for prologue-parsing based unwinding.  */
2606
2607 static int
2608 arm_exidx_unwind_sniffer (const struct frame_unwind *self,
2609                           struct frame_info *this_frame,
2610                           void **this_prologue_cache)
2611 {
2612   struct gdbarch *gdbarch = get_frame_arch (this_frame);
2613   enum bfd_endian byte_order_for_code = gdbarch_byte_order_for_code (gdbarch);
2614   CORE_ADDR addr_in_block, exidx_region, func_start;
2615   struct arm_prologue_cache *cache;
2616   gdb_byte *entry;
2617
2618   /* See if we have an ARM exception table entry covering this address.  */
2619   addr_in_block = get_frame_address_in_block (this_frame);
2620   entry = arm_find_exidx_entry (addr_in_block, &exidx_region);
2621   if (!entry)
2622     return 0;
2623
2624   /* The ARM exception table does not describe unwind information
2625      for arbitrary PC values, but is guaranteed to be correct only
2626      at call sites.  We have to decide here whether we want to use
2627      ARM exception table information for this frame, or fall back
2628      to using prologue parsing.  (Note that if we have DWARF CFI,
2629      this sniffer isn't even called -- CFI is always preferred.)
2630
2631      Before we make this decision, however, we check whether we
2632      actually have *symbol* information for the current frame.
2633      If not, prologue parsing would not work anyway, so we might
2634      as well use the exception table and hope for the best.  */
2635   if (find_pc_partial_function (addr_in_block, NULL, &func_start, NULL))
2636     {
2637       int exc_valid = 0;
2638
2639       /* If the next frame is "normal", we are at a call site in this
2640          frame, so exception information is guaranteed to be valid.  */
2641       if (get_next_frame (this_frame)
2642           && get_frame_type (get_next_frame (this_frame)) == NORMAL_FRAME)
2643         exc_valid = 1;
2644
2645       /* We also assume exception information is valid if we're currently
2646          blocked in a system call.  The system library is supposed to
2647          ensure this, so that e.g. pthread cancellation works.  */
2648       if (arm_frame_is_thumb (this_frame))
2649         {
2650           ULONGEST insn;
2651
2652           if (safe_read_memory_unsigned_integer (get_frame_pc (this_frame) - 2,
2653                                                  2, byte_order_for_code, &insn)
2654               && (insn & 0xff00) == 0xdf00 /* svc */)
2655             exc_valid = 1;
2656         }
2657       else
2658         {
2659           ULONGEST insn;
2660
2661           if (safe_read_memory_unsigned_integer (get_frame_pc (this_frame) - 4,
2662                                                  4, byte_order_for_code, &insn)
2663               && (insn & 0x0f000000) == 0x0f000000 /* svc */)
2664             exc_valid = 1;
2665         }
2666         
2667       /* Bail out if we don't know that exception information is valid.  */
2668       if (!exc_valid)
2669         return 0;
2670
2671      /* The ARM exception index does not mark the *end* of the region
2672         covered by the entry, and some functions will not have any entry.
2673         To correctly recognize the end of the covered region, the linker
2674         should have inserted dummy records with a CANTUNWIND marker.
2675
2676         Unfortunately, current versions of GNU ld do not reliably do
2677         this, and thus we may have found an incorrect entry above.
2678         As a (temporary) sanity check, we only use the entry if it
2679         lies *within* the bounds of the function.  Note that this check
2680         might reject perfectly valid entries that just happen to cover
2681         multiple functions; therefore this check ought to be removed
2682         once the linker is fixed.  */
2683       if (func_start > exidx_region)
2684         return 0;
2685     }
2686
2687   /* Decode the list of unwinding instructions into a prologue cache.
2688      Note that this may fail due to e.g. a "refuse to unwind" code.  */
2689   cache = arm_exidx_fill_cache (this_frame, entry);
2690   if (!cache)
2691     return 0;
2692
2693   *this_prologue_cache = cache;
2694   return 1;
2695 }
2696
2697 struct frame_unwind arm_exidx_unwind = {
2698   NORMAL_FRAME,
2699   default_frame_unwind_stop_reason,
2700   arm_prologue_this_id,
2701   arm_prologue_prev_register,
2702   NULL,
2703   arm_exidx_unwind_sniffer
2704 };
2705
2706 static struct arm_prologue_cache *
2707 arm_make_epilogue_frame_cache (struct frame_info *this_frame)
2708 {
2709   struct arm_prologue_cache *cache;
2710   int reg;
2711
2712   cache = FRAME_OBSTACK_ZALLOC (struct arm_prologue_cache);
2713   cache->saved_regs = trad_frame_alloc_saved_regs (this_frame);
2714
2715   /* Still rely on the offset calculated from prologue.  */
2716   arm_scan_prologue (this_frame, cache);
2717
2718   /* Since we are in epilogue, the SP has been restored.  */
2719   cache->prev_sp = get_frame_register_unsigned (this_frame, ARM_SP_REGNUM);
2720
2721   /* Calculate actual addresses of saved registers using offsets
2722      determined by arm_scan_prologue.  */
2723   for (reg = 0; reg < gdbarch_num_regs (get_frame_arch (this_frame)); reg++)
2724     if (trad_frame_addr_p (cache->saved_regs, reg))
2725       cache->saved_regs[reg].addr += cache->prev_sp;
2726
2727   return cache;
2728 }
2729
2730 /* Implementation of function hook 'this_id' in
2731    'struct frame_uwnind' for epilogue unwinder.  */
2732
2733 static void
2734 arm_epilogue_frame_this_id (struct frame_info *this_frame,
2735                             void **this_cache,
2736                             struct frame_id *this_id)
2737 {
2738   struct arm_prologue_cache *cache;
2739   CORE_ADDR pc, func;
2740
2741   if (*this_cache == NULL)
2742     *this_cache = arm_make_epilogue_frame_cache (this_frame);
2743   cache = (struct arm_prologue_cache *) *this_cache;
2744
2745   /* Use function start address as part of the frame ID.  If we cannot
2746      identify the start address (due to missing symbol information),
2747      fall back to just using the current PC.  */
2748   pc = get_frame_pc (this_frame);
2749   func = get_frame_func (this_frame);
2750   if (func == 0)
2751     func = pc;
2752
2753   (*this_id) = frame_id_build (cache->prev_sp, pc);
2754 }
2755
2756 /* Implementation of function hook 'prev_register' in
2757    'struct frame_uwnind' for epilogue unwinder.  */
2758
2759 static struct value *
2760 arm_epilogue_frame_prev_register (struct frame_info *this_frame,
2761                                   void **this_cache, int regnum)
2762 {
2763   if (*this_cache == NULL)
2764     *this_cache = arm_make_epilogue_frame_cache (this_frame);
2765
2766   return arm_prologue_prev_register (this_frame, this_cache, regnum);
2767 }
2768
2769 static int arm_stack_frame_destroyed_p_1 (struct gdbarch *gdbarch,
2770                                           CORE_ADDR pc);
2771 static int thumb_stack_frame_destroyed_p (struct gdbarch *gdbarch,
2772                                           CORE_ADDR pc);
2773
2774 /* Implementation of function hook 'sniffer' in
2775    'struct frame_uwnind' for epilogue unwinder.  */
2776
2777 static int
2778 arm_epilogue_frame_sniffer (const struct frame_unwind *self,
2779                             struct frame_info *this_frame,
2780                             void **this_prologue_cache)
2781 {
2782   if (frame_relative_level (this_frame) == 0)
2783     {
2784       struct gdbarch *gdbarch = get_frame_arch (this_frame);
2785       CORE_ADDR pc = get_frame_pc (this_frame);
2786
2787       if (arm_frame_is_thumb (this_frame))
2788         return thumb_stack_frame_destroyed_p (gdbarch, pc);
2789       else
2790         return arm_stack_frame_destroyed_p_1 (gdbarch, pc);
2791     }
2792   else
2793     return 0;
2794 }
2795
2796 /* Frame unwinder from epilogue.  */
2797
2798 static const struct frame_unwind arm_epilogue_frame_unwind =
2799 {
2800   NORMAL_FRAME,
2801   default_frame_unwind_stop_reason,
2802   arm_epilogue_frame_this_id,
2803   arm_epilogue_frame_prev_register,
2804   NULL,
2805   arm_epilogue_frame_sniffer,
2806 };
2807
2808 /* Recognize GCC's trampoline for thumb call-indirect.  If we are in a
2809    trampoline, return the target PC.  Otherwise return 0.
2810
2811    void call0a (char c, short s, int i, long l) {}
2812
2813    int main (void)
2814    {
2815      (*pointer_to_call0a) (c, s, i, l);
2816    }
2817
2818    Instead of calling a stub library function  _call_via_xx (xx is
2819    the register name), GCC may inline the trampoline in the object
2820    file as below (register r2 has the address of call0a).
2821
2822    .global main
2823    .type main, %function
2824    ...
2825    bl .L1
2826    ...
2827    .size main, .-main
2828
2829    .L1:
2830    bx r2
2831
2832    The trampoline 'bx r2' doesn't belong to main.  */
2833
2834 static CORE_ADDR
2835 arm_skip_bx_reg (struct frame_info *frame, CORE_ADDR pc)
2836 {
2837   /* The heuristics of recognizing such trampoline is that FRAME is
2838      executing in Thumb mode and the instruction on PC is 'bx Rm'.  */
2839   if (arm_frame_is_thumb (frame))
2840     {
2841       gdb_byte buf[2];
2842
2843       if (target_read_memory (pc, buf, 2) == 0)
2844         {
2845           struct gdbarch *gdbarch = get_frame_arch (frame);
2846           enum bfd_endian byte_order_for_code
2847             = gdbarch_byte_order_for_code (gdbarch);
2848           uint16_t insn
2849             = extract_unsigned_integer (buf, 2, byte_order_for_code);
2850
2851           if ((insn & 0xff80) == 0x4700)  /* bx <Rm> */
2852             {
2853               CORE_ADDR dest
2854                 = get_frame_register_unsigned (frame, bits (insn, 3, 6));
2855
2856               /* Clear the LSB so that gdb core sets step-resume
2857                  breakpoint at the right address.  */
2858               return UNMAKE_THUMB_ADDR (dest);
2859             }
2860         }
2861     }
2862
2863   return 0;
2864 }
2865
2866 static struct arm_prologue_cache *
2867 arm_make_stub_cache (struct frame_info *this_frame)
2868 {
2869   struct arm_prologue_cache *cache;
2870
2871   cache = FRAME_OBSTACK_ZALLOC (struct arm_prologue_cache);
2872   cache->saved_regs = trad_frame_alloc_saved_regs (this_frame);
2873
2874   cache->prev_sp = get_frame_register_unsigned (this_frame, ARM_SP_REGNUM);
2875
2876   return cache;
2877 }
2878
2879 /* Our frame ID for a stub frame is the current SP and LR.  */
2880
2881 static void
2882 arm_stub_this_id (struct frame_info *this_frame,
2883                   void **this_cache,
2884                   struct frame_id *this_id)
2885 {
2886   struct arm_prologue_cache *cache;
2887
2888   if (*this_cache == NULL)
2889     *this_cache = arm_make_stub_cache (this_frame);
2890   cache = (struct arm_prologue_cache *) *this_cache;
2891
2892   *this_id = frame_id_build (cache->prev_sp, get_frame_pc (this_frame));
2893 }
2894
2895 static int
2896 arm_stub_unwind_sniffer (const struct frame_unwind *self,
2897                          struct frame_info *this_frame,
2898                          void **this_prologue_cache)
2899 {
2900   CORE_ADDR addr_in_block;
2901   gdb_byte dummy[4];
2902   CORE_ADDR pc, start_addr;
2903   const char *name;
2904
2905   addr_in_block = get_frame_address_in_block (this_frame);
2906   pc = get_frame_pc (this_frame);
2907   if (in_plt_section (addr_in_block)
2908       /* We also use the stub winder if the target memory is unreadable
2909          to avoid having the prologue unwinder trying to read it.  */
2910       || target_read_memory (pc, dummy, 4) != 0)
2911     return 1;
2912
2913   if (find_pc_partial_function (pc, &name, &start_addr, NULL) == 0
2914       && arm_skip_bx_reg (this_frame, pc) != 0)
2915     return 1;
2916
2917   return 0;
2918 }
2919
2920 struct frame_unwind arm_stub_unwind = {
2921   NORMAL_FRAME,
2922   default_frame_unwind_stop_reason,
2923   arm_stub_this_id,
2924   arm_prologue_prev_register,
2925   NULL,
2926   arm_stub_unwind_sniffer
2927 };
2928
2929 /* Put here the code to store, into CACHE->saved_regs, the addresses
2930    of the saved registers of frame described by THIS_FRAME.  CACHE is
2931    returned.  */
2932
2933 static struct arm_prologue_cache *
2934 arm_m_exception_cache (struct frame_info *this_frame)
2935 {
2936   struct gdbarch *gdbarch = get_frame_arch (this_frame);
2937   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
2938   struct arm_prologue_cache *cache;
2939   CORE_ADDR unwound_sp;
2940   LONGEST xpsr;
2941
2942   cache = FRAME_OBSTACK_ZALLOC (struct arm_prologue_cache);
2943   cache->saved_regs = trad_frame_alloc_saved_regs (this_frame);
2944
2945   unwound_sp = get_frame_register_unsigned (this_frame,
2946                                             ARM_SP_REGNUM);
2947
2948   /* The hardware saves eight 32-bit words, comprising xPSR,
2949      ReturnAddress, LR (R14), R12, R3, R2, R1, R0.  See details in
2950      "B1.5.6 Exception entry behavior" in
2951      "ARMv7-M Architecture Reference Manual".  */
2952   cache->saved_regs[0].addr = unwound_sp;
2953   cache->saved_regs[1].addr = unwound_sp + 4;
2954   cache->saved_regs[2].addr = unwound_sp + 8;
2955   cache->saved_regs[3].addr = unwound_sp + 12;
2956   cache->saved_regs[12].addr = unwound_sp + 16;
2957   cache->saved_regs[14].addr = unwound_sp + 20;
2958   cache->saved_regs[15].addr = unwound_sp + 24;
2959   cache->saved_regs[ARM_PS_REGNUM].addr = unwound_sp + 28;
2960
2961   /* If bit 9 of the saved xPSR is set, then there is a four-byte
2962      aligner between the top of the 32-byte stack frame and the
2963      previous context's stack pointer.  */
2964   cache->prev_sp = unwound_sp + 32;
2965   if (safe_read_memory_integer (unwound_sp + 28, 4, byte_order, &xpsr)
2966       && (xpsr & (1 << 9)) != 0)
2967     cache->prev_sp += 4;
2968
2969   return cache;
2970 }
2971
2972 /* Implementation of function hook 'this_id' in
2973    'struct frame_uwnind'.  */
2974
2975 static void
2976 arm_m_exception_this_id (struct frame_info *this_frame,
2977                          void **this_cache,
2978                          struct frame_id *this_id)
2979 {
2980   struct arm_prologue_cache *cache;
2981
2982   if (*this_cache == NULL)
2983     *this_cache = arm_m_exception_cache (this_frame);
2984   cache = (struct arm_prologue_cache *) *this_cache;
2985
2986   /* Our frame ID for a stub frame is the current SP and LR.  */
2987   *this_id = frame_id_build (cache->prev_sp,
2988                              get_frame_pc (this_frame));
2989 }
2990
2991 /* Implementation of function hook 'prev_register' in
2992    'struct frame_uwnind'.  */
2993
2994 static struct value *
2995 arm_m_exception_prev_register (struct frame_info *this_frame,
2996                                void **this_cache,
2997                                int prev_regnum)
2998 {
2999   struct arm_prologue_cache *cache;
3000
3001   if (*this_cache == NULL)
3002     *this_cache = arm_m_exception_cache (this_frame);
3003   cache = (struct arm_prologue_cache *) *this_cache;
3004
3005   /* The value was already reconstructed into PREV_SP.  */
3006   if (prev_regnum == ARM_SP_REGNUM)
3007     return frame_unwind_got_constant (this_frame, prev_regnum,
3008                                       cache->prev_sp);
3009
3010   return trad_frame_get_prev_register (this_frame, cache->saved_regs,
3011                                        prev_regnum);
3012 }
3013
3014 /* Implementation of function hook 'sniffer' in
3015    'struct frame_uwnind'.  */
3016
3017 static int
3018 arm_m_exception_unwind_sniffer (const struct frame_unwind *self,
3019                                 struct frame_info *this_frame,
3020                                 void **this_prologue_cache)
3021 {
3022   CORE_ADDR this_pc = get_frame_pc (this_frame);
3023
3024   /* No need to check is_m; this sniffer is only registered for
3025      M-profile architectures.  */
3026
3027   /* Check if exception frame returns to a magic PC value.  */
3028   return arm_m_addr_is_magic (this_pc);
3029 }
3030
3031 /* Frame unwinder for M-profile exceptions.  */
3032
3033 struct frame_unwind arm_m_exception_unwind =
3034 {
3035   SIGTRAMP_FRAME,
3036   default_frame_unwind_stop_reason,
3037   arm_m_exception_this_id,
3038   arm_m_exception_prev_register,
3039   NULL,
3040   arm_m_exception_unwind_sniffer
3041 };
3042
3043 static CORE_ADDR
3044 arm_normal_frame_base (struct frame_info *this_frame, void **this_cache)
3045 {
3046   struct arm_prologue_cache *cache;
3047
3048   if (*this_cache == NULL)
3049     *this_cache = arm_make_prologue_cache (this_frame);
3050   cache = (struct arm_prologue_cache *) *this_cache;
3051
3052   return cache->prev_sp - cache->framesize;
3053 }
3054
3055 struct frame_base arm_normal_base = {
3056   &arm_prologue_unwind,
3057   arm_normal_frame_base,
3058   arm_normal_frame_base,
3059   arm_normal_frame_base
3060 };
3061
3062 /* Assuming THIS_FRAME is a dummy, return the frame ID of that
3063    dummy frame.  The frame ID's base needs to match the TOS value
3064    saved by save_dummy_frame_tos() and returned from
3065    arm_push_dummy_call, and the PC needs to match the dummy frame's
3066    breakpoint.  */
3067
3068 static struct frame_id
3069 arm_dummy_id (struct gdbarch *gdbarch, struct frame_info *this_frame)
3070 {
3071   return frame_id_build (get_frame_register_unsigned (this_frame,
3072                                                       ARM_SP_REGNUM),
3073                          get_frame_pc (this_frame));
3074 }
3075
3076 /* Given THIS_FRAME, find the previous frame's resume PC (which will
3077    be used to construct the previous frame's ID, after looking up the
3078    containing function).  */
3079
3080 static CORE_ADDR
3081 arm_unwind_pc (struct gdbarch *gdbarch, struct frame_info *this_frame)
3082 {
3083   CORE_ADDR pc;
3084   pc = frame_unwind_register_unsigned (this_frame, ARM_PC_REGNUM);
3085   return arm_addr_bits_remove (gdbarch, pc);
3086 }
3087
3088 static CORE_ADDR
3089 arm_unwind_sp (struct gdbarch *gdbarch, struct frame_info *this_frame)
3090 {
3091   return frame_unwind_register_unsigned (this_frame, ARM_SP_REGNUM);
3092 }
3093
3094 static struct value *
3095 arm_dwarf2_prev_register (struct frame_info *this_frame, void **this_cache,
3096                           int regnum)
3097 {
3098   struct gdbarch * gdbarch = get_frame_arch (this_frame);
3099   CORE_ADDR lr, cpsr;
3100   ULONGEST t_bit = arm_psr_thumb_bit (gdbarch);
3101
3102   switch (regnum)
3103     {
3104     case ARM_PC_REGNUM:
3105       /* The PC is normally copied from the return column, which
3106          describes saves of LR.  However, that version may have an
3107          extra bit set to indicate Thumb state.  The bit is not
3108          part of the PC.  */
3109       lr = frame_unwind_register_unsigned (this_frame, ARM_LR_REGNUM);
3110       return frame_unwind_got_constant (this_frame, regnum,
3111                                         arm_addr_bits_remove (gdbarch, lr));
3112
3113     case ARM_PS_REGNUM:
3114       /* Reconstruct the T bit; see arm_prologue_prev_register for details.  */
3115       cpsr = get_frame_register_unsigned (this_frame, regnum);
3116       lr = frame_unwind_register_unsigned (this_frame, ARM_LR_REGNUM);
3117       if (IS_THUMB_ADDR (lr))
3118         cpsr |= t_bit;
3119       else
3120         cpsr &= ~t_bit;
3121       return frame_unwind_got_constant (this_frame, regnum, cpsr);
3122
3123     default:
3124       internal_error (__FILE__, __LINE__,
3125                       _("Unexpected register %d"), regnum);
3126     }
3127 }
3128
3129 static void
3130 arm_dwarf2_frame_init_reg (struct gdbarch *gdbarch, int regnum,
3131                            struct dwarf2_frame_state_reg *reg,
3132                            struct frame_info *this_frame)
3133 {
3134   switch (regnum)
3135     {
3136     case ARM_PC_REGNUM:
3137     case ARM_PS_REGNUM:
3138       reg->how = DWARF2_FRAME_REG_FN;
3139       reg->loc.fn = arm_dwarf2_prev_register;
3140       break;
3141     case ARM_SP_REGNUM:
3142       reg->how = DWARF2_FRAME_REG_CFA;
3143       break;
3144     }
3145 }
3146
3147 /* Implement the stack_frame_destroyed_p gdbarch method.  */
3148
3149 static int
3150 thumb_stack_frame_destroyed_p (struct gdbarch *gdbarch, CORE_ADDR pc)
3151 {
3152   enum bfd_endian byte_order_for_code = gdbarch_byte_order_for_code (gdbarch);
3153   unsigned int insn, insn2;
3154   int found_return = 0, found_stack_adjust = 0;
3155   CORE_ADDR func_start, func_end;
3156   CORE_ADDR scan_pc;
3157   gdb_byte buf[4];
3158
3159   if (!find_pc_partial_function (pc, NULL, &func_start, &func_end))
3160     return 0;
3161
3162   /* The epilogue is a sequence of instructions along the following lines:
3163
3164     - add stack frame size to SP or FP
3165     - [if frame pointer used] restore SP from FP
3166     - restore registers from SP [may include PC]
3167     - a return-type instruction [if PC wasn't already restored]
3168
3169     In a first pass, we scan forward from the current PC and verify the
3170     instructions we find as compatible with this sequence, ending in a
3171     return instruction.
3172
3173     However, this is not sufficient to distinguish indirect function calls
3174     within a function from indirect tail calls in the epilogue in some cases.
3175     Therefore, if we didn't already find any SP-changing instruction during
3176     forward scan, we add a backward scanning heuristic to ensure we actually
3177     are in the epilogue.  */
3178
3179   scan_pc = pc;
3180   while (scan_pc < func_end && !found_return)
3181     {
3182       if (target_read_memory (scan_pc, buf, 2))
3183         break;
3184
3185       scan_pc += 2;
3186       insn = extract_unsigned_integer (buf, 2, byte_order_for_code);
3187
3188       if ((insn & 0xff80) == 0x4700)  /* bx <Rm> */
3189         found_return = 1;
3190       else if (insn == 0x46f7)  /* mov pc, lr */
3191         found_return = 1;
3192       else if (thumb_instruction_restores_sp (insn))
3193         {
3194           if ((insn & 0xff00) == 0xbd00)  /* pop <registers, PC> */
3195             found_return = 1;
3196         }
3197       else if (thumb_insn_size (insn) == 4)  /* 32-bit Thumb-2 instruction */
3198         {
3199           if (target_read_memory (scan_pc, buf, 2))
3200             break;
3201
3202           scan_pc += 2;
3203           insn2 = extract_unsigned_integer (buf, 2, byte_order_for_code);
3204
3205           if (insn == 0xe8bd)  /* ldm.w sp!, <registers> */
3206             {
3207               if (insn2 & 0x8000)  /* <registers> include PC.  */
3208                 found_return = 1;
3209             }
3210           else if (insn == 0xf85d  /* ldr.w <Rt>, [sp], #4 */
3211                    && (insn2 & 0x0fff) == 0x0b04)
3212             {
3213               if ((insn2 & 0xf000) == 0xf000) /* <Rt> is PC.  */
3214                 found_return = 1;
3215             }
3216           else if ((insn & 0xffbf) == 0xecbd  /* vldm sp!, <list> */
3217                    && (insn2 & 0x0e00) == 0x0a00)
3218             ;
3219           else
3220             break;
3221         }
3222       else
3223         break;
3224     }
3225
3226   if (!found_return)
3227     return 0;
3228
3229   /* Since any instruction in the epilogue sequence, with the possible
3230      exception of return itself, updates the stack pointer, we need to
3231      scan backwards for at most one instruction.  Try either a 16-bit or
3232      a 32-bit instruction.  This is just a heuristic, so we do not worry
3233      too much about false positives.  */
3234
3235   if (pc - 4 < func_start)
3236     return 0;
3237   if (target_read_memory (pc - 4, buf, 4))
3238     return 0;
3239
3240   insn = extract_unsigned_integer (buf, 2, byte_order_for_code);
3241   insn2 = extract_unsigned_integer (buf + 2, 2, byte_order_for_code);
3242
3243   if (thumb_instruction_restores_sp (insn2))
3244     found_stack_adjust = 1;
3245   else if (insn == 0xe8bd)  /* ldm.w sp!, <registers> */
3246     found_stack_adjust = 1;
3247   else if (insn == 0xf85d  /* ldr.w <Rt>, [sp], #4 */
3248            && (insn2 & 0x0fff) == 0x0b04)
3249     found_stack_adjust = 1;
3250   else if ((insn & 0xffbf) == 0xecbd  /* vldm sp!, <list> */
3251            && (insn2 & 0x0e00) == 0x0a00)
3252     found_stack_adjust = 1;
3253
3254   return found_stack_adjust;
3255 }
3256
3257 static int
3258 arm_stack_frame_destroyed_p_1 (struct gdbarch *gdbarch, CORE_ADDR pc)
3259 {
3260   enum bfd_endian byte_order_for_code = gdbarch_byte_order_for_code (gdbarch);
3261   unsigned int insn;
3262   int found_return;
3263   CORE_ADDR func_start, func_end;
3264
3265   if (!find_pc_partial_function (pc, NULL, &func_start, &func_end))
3266     return 0;
3267
3268   /* We are in the epilogue if the previous instruction was a stack
3269      adjustment and the next instruction is a possible return (bx, mov
3270      pc, or pop).  We could have to scan backwards to find the stack
3271      adjustment, or forwards to find the return, but this is a decent
3272      approximation.  First scan forwards.  */
3273
3274   found_return = 0;
3275   insn = read_memory_unsigned_integer (pc, 4, byte_order_for_code);
3276   if (bits (insn, 28, 31) != INST_NV)
3277     {
3278       if ((insn & 0x0ffffff0) == 0x012fff10)
3279         /* BX.  */
3280         found_return = 1;
3281       else if ((insn & 0x0ffffff0) == 0x01a0f000)
3282         /* MOV PC.  */
3283         found_return = 1;
3284       else if ((insn & 0x0fff0000) == 0x08bd0000
3285           && (insn & 0x0000c000) != 0)
3286         /* POP (LDMIA), including PC or LR.  */
3287         found_return = 1;
3288     }
3289
3290   if (!found_return)
3291     return 0;
3292
3293   /* Scan backwards.  This is just a heuristic, so do not worry about
3294      false positives from mode changes.  */
3295
3296   if (pc < func_start + 4)
3297     return 0;
3298
3299   insn = read_memory_unsigned_integer (pc - 4, 4, byte_order_for_code);
3300   if (arm_instruction_restores_sp (insn))
3301     return 1;
3302
3303   return 0;
3304 }
3305
3306 /* Implement the stack_frame_destroyed_p gdbarch method.  */
3307
3308 static int
3309 arm_stack_frame_destroyed_p (struct gdbarch *gdbarch, CORE_ADDR pc)
3310 {
3311   if (arm_pc_is_thumb (gdbarch, pc))
3312     return thumb_stack_frame_destroyed_p (gdbarch, pc);
3313   else
3314     return arm_stack_frame_destroyed_p_1 (gdbarch, pc);
3315 }
3316
3317 /* When arguments must be pushed onto the stack, they go on in reverse
3318    order.  The code below implements a FILO (stack) to do this.  */
3319
3320 struct stack_item
3321 {
3322   int len;
3323   struct stack_item *prev;
3324   gdb_byte *data;
3325 };
3326
3327 static struct stack_item *
3328 push_stack_item (struct stack_item *prev, const gdb_byte *contents, int len)
3329 {
3330   struct stack_item *si;
3331   si = XNEW (struct stack_item);
3332   si->data = (gdb_byte *) xmalloc (len);
3333   si->len = len;
3334   si->prev = prev;
3335   memcpy (si->data, contents, len);
3336   return si;
3337 }
3338
3339 static struct stack_item *
3340 pop_stack_item (struct stack_item *si)
3341 {
3342   struct stack_item *dead = si;
3343   si = si->prev;
3344   xfree (dead->data);
3345   xfree (dead);
3346   return si;
3347 }
3348
3349
3350 /* Return the alignment (in bytes) of the given type.  */
3351
3352 static int
3353 arm_type_align (struct type *t)
3354 {
3355   int n;
3356   int align;
3357   int falign;
3358
3359   t = check_typedef (t);
3360   switch (TYPE_CODE (t))
3361     {
3362     default:
3363       /* Should never happen.  */
3364       internal_error (__FILE__, __LINE__, _("unknown type alignment"));
3365       return 4;
3366
3367     case TYPE_CODE_PTR:
3368     case TYPE_CODE_ENUM:
3369     case TYPE_CODE_INT:
3370     case TYPE_CODE_FLT:
3371     case TYPE_CODE_SET:
3372     case TYPE_CODE_RANGE:
3373     case TYPE_CODE_REF:
3374     case TYPE_CODE_RVALUE_REF:
3375     case TYPE_CODE_CHAR:
3376     case TYPE_CODE_BOOL:
3377       return TYPE_LENGTH (t);
3378
3379     case TYPE_CODE_ARRAY:
3380       if (TYPE_VECTOR (t))
3381         {
3382           /* Use the natural alignment for vector types (the same for
3383              scalar type), but the maximum alignment is 64-bit.  */
3384           if (TYPE_LENGTH (t) > 8)
3385             return 8;
3386           else
3387             return TYPE_LENGTH (t);
3388         }
3389       else
3390         return arm_type_align (TYPE_TARGET_TYPE (t));
3391     case TYPE_CODE_COMPLEX:
3392       return arm_type_align (TYPE_TARGET_TYPE (t));
3393
3394     case TYPE_CODE_STRUCT:
3395     case TYPE_CODE_UNION:
3396       align = 1;
3397       for (n = 0; n < TYPE_NFIELDS (t); n++)
3398         {
3399           falign = arm_type_align (TYPE_FIELD_TYPE (t, n));
3400           if (falign > align)
3401             align = falign;
3402         }
3403       return align;
3404     }
3405 }
3406
3407 /* Possible base types for a candidate for passing and returning in
3408    VFP registers.  */
3409
3410 enum arm_vfp_cprc_base_type
3411 {
3412   VFP_CPRC_UNKNOWN,
3413   VFP_CPRC_SINGLE,
3414   VFP_CPRC_DOUBLE,
3415   VFP_CPRC_VEC64,
3416   VFP_CPRC_VEC128
3417 };
3418
3419 /* The length of one element of base type B.  */
3420
3421 static unsigned
3422 arm_vfp_cprc_unit_length (enum arm_vfp_cprc_base_type b)
3423 {
3424   switch (b)
3425     {
3426     case VFP_CPRC_SINGLE:
3427       return 4;
3428     case VFP_CPRC_DOUBLE:
3429       return 8;
3430     case VFP_CPRC_VEC64:
3431       return 8;
3432     case VFP_CPRC_VEC128:
3433       return 16;
3434     default:
3435       internal_error (__FILE__, __LINE__, _("Invalid VFP CPRC type: %d."),
3436                       (int) b);
3437     }
3438 }
3439
3440 /* The character ('s', 'd' or 'q') for the type of VFP register used
3441    for passing base type B.  */
3442
3443 static int
3444 arm_vfp_cprc_reg_char (enum arm_vfp_cprc_base_type b)
3445 {
3446   switch (b)
3447     {
3448     case VFP_CPRC_SINGLE:
3449       return 's';
3450     case VFP_CPRC_DOUBLE:
3451       return 'd';
3452     case VFP_CPRC_VEC64:
3453       return 'd';
3454     case VFP_CPRC_VEC128:
3455       return 'q';
3456     default:
3457       internal_error (__FILE__, __LINE__, _("Invalid VFP CPRC type: %d."),
3458                       (int) b);
3459     }
3460 }
3461
3462 /* Determine whether T may be part of a candidate for passing and
3463    returning in VFP registers, ignoring the limit on the total number
3464    of components.  If *BASE_TYPE is VFP_CPRC_UNKNOWN, set it to the
3465    classification of the first valid component found; if it is not
3466    VFP_CPRC_UNKNOWN, all components must have the same classification
3467    as *BASE_TYPE.  If it is found that T contains a type not permitted
3468    for passing and returning in VFP registers, a type differently
3469    classified from *BASE_TYPE, or two types differently classified
3470    from each other, return -1, otherwise return the total number of
3471    base-type elements found (possibly 0 in an empty structure or
3472    array).  Vector types are not currently supported, matching the
3473    generic AAPCS support.  */
3474
3475 static int
3476 arm_vfp_cprc_sub_candidate (struct type *t,
3477                             enum arm_vfp_cprc_base_type *base_type)
3478 {
3479   t = check_typedef (t);
3480   switch (TYPE_CODE (t))
3481     {
3482     case TYPE_CODE_FLT:
3483       switch (TYPE_LENGTH (t))
3484         {
3485         case 4:
3486           if (*base_type == VFP_CPRC_UNKNOWN)
3487             *base_type = VFP_CPRC_SINGLE;
3488           else if (*base_type != VFP_CPRC_SINGLE)
3489             return -1;
3490           return 1;
3491
3492         case 8:
3493           if (*base_type == VFP_CPRC_UNKNOWN)
3494             *base_type = VFP_CPRC_DOUBLE;
3495           else if (*base_type != VFP_CPRC_DOUBLE)
3496             return -1;
3497           return 1;
3498
3499         default:
3500           return -1;
3501         }
3502       break;
3503
3504     case TYPE_CODE_COMPLEX:
3505       /* Arguments of complex T where T is one of the types float or
3506          double get treated as if they are implemented as:
3507
3508          struct complexT
3509          {
3510            T real;
3511            T imag;
3512          };
3513
3514       */
3515       switch (TYPE_LENGTH (t))
3516         {
3517         case 8:
3518           if (*base_type == VFP_CPRC_UNKNOWN)
3519             *base_type = VFP_CPRC_SINGLE;
3520           else if (*base_type != VFP_CPRC_SINGLE)
3521             return -1;
3522           return 2;
3523
3524         case 16:
3525           if (*base_type == VFP_CPRC_UNKNOWN)
3526             *base_type = VFP_CPRC_DOUBLE;
3527           else if (*base_type != VFP_CPRC_DOUBLE)
3528             return -1;
3529           return 2;
3530
3531         default:
3532           return -1;
3533         }
3534       break;
3535
3536     case TYPE_CODE_ARRAY:
3537       {
3538         if (TYPE_VECTOR (t))
3539           {
3540             /* A 64-bit or 128-bit containerized vector type are VFP
3541                CPRCs.  */
3542             switch (TYPE_LENGTH (t))
3543               {
3544               case 8:
3545                 if (*base_type == VFP_CPRC_UNKNOWN)
3546                   *base_type = VFP_CPRC_VEC64;
3547                 return 1;
3548               case 16:
3549                 if (*base_type == VFP_CPRC_UNKNOWN)
3550                   *base_type = VFP_CPRC_VEC128;
3551                 return 1;
3552               default:
3553                 return -1;
3554               }
3555           }
3556         else
3557           {
3558             int count;
3559             unsigned unitlen;
3560
3561             count = arm_vfp_cprc_sub_candidate (TYPE_TARGET_TYPE (t),
3562                                                 base_type);
3563             if (count == -1)
3564               return -1;
3565             if (TYPE_LENGTH (t) == 0)
3566               {
3567                 gdb_assert (count == 0);
3568                 return 0;
3569               }
3570             else if (count == 0)
3571               return -1;
3572             unitlen = arm_vfp_cprc_unit_length (*base_type);
3573             gdb_assert ((TYPE_LENGTH (t) % unitlen) == 0);
3574             return TYPE_LENGTH (t) / unitlen;
3575           }
3576       }
3577       break;
3578
3579     case TYPE_CODE_STRUCT:
3580       {
3581         int count = 0;
3582         unsigned unitlen;
3583         int i;
3584         for (i = 0; i < TYPE_NFIELDS (t); i++)
3585           {
3586             int sub_count = 0;
3587
3588             if (!field_is_static (&TYPE_FIELD (t, i)))
3589               sub_count = arm_vfp_cprc_sub_candidate (TYPE_FIELD_TYPE (t, i),
3590                                                       base_type);
3591             if (sub_count == -1)
3592               return -1;
3593             count += sub_count;
3594           }
3595         if (TYPE_LENGTH (t) == 0)
3596           {
3597             gdb_assert (count == 0);
3598             return 0;
3599           }
3600         else if (count == 0)
3601           return -1;
3602         unitlen = arm_vfp_cprc_unit_length (*base_type);
3603         if (TYPE_LENGTH (t) != unitlen * count)
3604           return -1;
3605         return count;
3606       }
3607
3608     case TYPE_CODE_UNION:
3609       {
3610         int count = 0;
3611         unsigned unitlen;
3612         int i;
3613         for (i = 0; i < TYPE_NFIELDS (t); i++)
3614           {
3615             int sub_count = arm_vfp_cprc_sub_candidate (TYPE_FIELD_TYPE (t, i),
3616                                                         base_type);
3617             if (sub_count == -1)
3618               return -1;
3619             count = (count > sub_count ? count : sub_count);
3620           }
3621         if (TYPE_LENGTH (t) == 0)
3622           {
3623             gdb_assert (count == 0);
3624             return 0;
3625           }
3626         else if (count == 0)
3627           return -1;
3628         unitlen = arm_vfp_cprc_unit_length (*base_type);
3629         if (TYPE_LENGTH (t) != unitlen * count)
3630           return -1;
3631         return count;
3632       }
3633
3634     default:
3635       break;
3636     }
3637
3638   return -1;
3639 }
3640
3641 /* Determine whether T is a VFP co-processor register candidate (CPRC)
3642    if passed to or returned from a non-variadic function with the VFP
3643    ABI in effect.  Return 1 if it is, 0 otherwise.  If it is, set
3644    *BASE_TYPE to the base type for T and *COUNT to the number of
3645    elements of that base type before returning.  */
3646
3647 static int
3648 arm_vfp_call_candidate (struct type *t, enum arm_vfp_cprc_base_type *base_type,
3649                         int *count)
3650 {
3651   enum arm_vfp_cprc_base_type b = VFP_CPRC_UNKNOWN;
3652   int c = arm_vfp_cprc_sub_candidate (t, &b);
3653   if (c <= 0 || c > 4)
3654     return 0;
3655   *base_type = b;
3656   *count = c;
3657   return 1;
3658 }
3659
3660 /* Return 1 if the VFP ABI should be used for passing arguments to and
3661    returning values from a function of type FUNC_TYPE, 0
3662    otherwise.  */
3663
3664 static int
3665 arm_vfp_abi_for_function (struct gdbarch *gdbarch, struct type *func_type)
3666 {
3667   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
3668   /* Variadic functions always use the base ABI.  Assume that functions
3669      without debug info are not variadic.  */
3670   if (func_type && TYPE_VARARGS (check_typedef (func_type)))
3671     return 0;
3672   /* The VFP ABI is only supported as a variant of AAPCS.  */
3673   if (tdep->arm_abi != ARM_ABI_AAPCS)
3674     return 0;
3675   return gdbarch_tdep (gdbarch)->fp_model == ARM_FLOAT_VFP;
3676 }
3677
3678 /* We currently only support passing parameters in integer registers, which
3679    conforms with GCC's default model, and VFP argument passing following
3680    the VFP variant of AAPCS.  Several other variants exist and
3681    we should probably support some of them based on the selected ABI.  */
3682
3683 static CORE_ADDR
3684 arm_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
3685                      struct regcache *regcache, CORE_ADDR bp_addr, int nargs,
3686                      struct value **args, CORE_ADDR sp,
3687                      function_call_return_method return_method,
3688                      CORE_ADDR struct_addr)
3689 {
3690   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
3691   int argnum;
3692   int argreg;
3693   int nstack;
3694   struct stack_item *si = NULL;
3695   int use_vfp_abi;
3696   struct type *ftype;
3697   unsigned vfp_regs_free = (1 << 16) - 1;
3698
3699   /* Determine the type of this function and whether the VFP ABI
3700      applies.  */
3701   ftype = check_typedef (value_type (function));
3702   if (TYPE_CODE (ftype) == TYPE_CODE_PTR)
3703     ftype = check_typedef (TYPE_TARGET_TYPE (ftype));
3704   use_vfp_abi = arm_vfp_abi_for_function (gdbarch, ftype);
3705
3706   /* Set the return address.  For the ARM, the return breakpoint is
3707      always at BP_ADDR.  */
3708   if (arm_pc_is_thumb (gdbarch, bp_addr))
3709     bp_addr |= 1;
3710   regcache_cooked_write_unsigned (regcache, ARM_LR_REGNUM, bp_addr);
3711
3712   /* Walk through the list of args and determine how large a temporary
3713      stack is required.  Need to take care here as structs may be
3714      passed on the stack, and we have to push them.  */
3715   nstack = 0;
3716
3717   argreg = ARM_A1_REGNUM;
3718   nstack = 0;
3719
3720   /* The struct_return pointer occupies the first parameter
3721      passing register.  */
3722   if (return_method == return_method_struct)
3723     {
3724       if (arm_debug)
3725         fprintf_unfiltered (gdb_stdlog, "struct return in %s = %s\n",
3726                             gdbarch_register_name (gdbarch, argreg),
3727                             paddress (gdbarch, struct_addr));
3728       regcache_cooked_write_unsigned (regcache, argreg, struct_addr);
3729       argreg++;
3730     }
3731
3732   for (argnum = 0; argnum < nargs; argnum++)
3733     {
3734       int len;
3735       struct type *arg_type;
3736       struct type *target_type;
3737       enum type_code typecode;
3738       const bfd_byte *val;
3739       int align;
3740       enum arm_vfp_cprc_base_type vfp_base_type;
3741       int vfp_base_count;
3742       int may_use_core_reg = 1;
3743
3744       arg_type = check_typedef (value_type (args[argnum]));
3745       len = TYPE_LENGTH (arg_type);
3746       target_type = TYPE_TARGET_TYPE (arg_type);
3747       typecode = TYPE_CODE (arg_type);
3748       val = value_contents (args[argnum]);
3749
3750       align = arm_type_align (arg_type);
3751       /* Round alignment up to a whole number of words.  */
3752       align = (align + INT_REGISTER_SIZE - 1) & ~(INT_REGISTER_SIZE - 1);
3753       /* Different ABIs have different maximum alignments.  */
3754       if (gdbarch_tdep (gdbarch)->arm_abi == ARM_ABI_APCS)
3755         {
3756           /* The APCS ABI only requires word alignment.  */
3757           align = INT_REGISTER_SIZE;
3758         }
3759       else
3760         {
3761           /* The AAPCS requires at most doubleword alignment.  */
3762           if (align > INT_REGISTER_SIZE * 2)
3763             align = INT_REGISTER_SIZE * 2;
3764         }
3765
3766       if (use_vfp_abi
3767           && arm_vfp_call_candidate (arg_type, &vfp_base_type,
3768                                      &vfp_base_count))
3769         {
3770           int regno;
3771           int unit_length;
3772           int shift;
3773           unsigned mask;
3774
3775           /* Because this is a CPRC it cannot go in a core register or
3776              cause a core register to be skipped for alignment.
3777              Either it goes in VFP registers and the rest of this loop
3778              iteration is skipped for this argument, or it goes on the
3779              stack (and the stack alignment code is correct for this
3780              case).  */
3781           may_use_core_reg = 0;
3782
3783           unit_length = arm_vfp_cprc_unit_length (vfp_base_type);
3784           shift = unit_length / 4;
3785           mask = (1 << (shift * vfp_base_count)) - 1;
3786           for (regno = 0; regno < 16; regno += shift)
3787             if (((vfp_regs_free >> regno) & mask) == mask)
3788               break;
3789
3790           if (regno < 16)
3791             {
3792               int reg_char;
3793               int reg_scaled;
3794               int i;
3795
3796               vfp_regs_free &= ~(mask << regno);
3797               reg_scaled = regno / shift;
3798               reg_char = arm_vfp_cprc_reg_char (vfp_base_type);
3799               for (i = 0; i < vfp_base_count; i++)
3800                 {
3801                   char name_buf[4];
3802                   int regnum;
3803                   if (reg_char == 'q')
3804                     arm_neon_quad_write (gdbarch, regcache, reg_scaled + i,
3805                                          val + i * unit_length);
3806                   else
3807                     {
3808                       xsnprintf (name_buf, sizeof (name_buf), "%c%d",
3809                                  reg_char, reg_scaled + i);
3810                       regnum = user_reg_map_name_to_regnum (gdbarch, name_buf,
3811                                                             strlen (name_buf));
3812                       regcache->cooked_write (regnum, val + i * unit_length);
3813                     }
3814                 }
3815               continue;
3816             }
3817           else
3818             {
3819               /* This CPRC could not go in VFP registers, so all VFP
3820                  registers are now marked as used.  */
3821               vfp_regs_free = 0;
3822             }
3823         }
3824
3825       /* Push stack padding for dowubleword alignment.  */
3826       if (nstack & (align - 1))
3827         {
3828           si = push_stack_item (si, val, INT_REGISTER_SIZE);
3829           nstack += INT_REGISTER_SIZE;
3830         }
3831       
3832       /* Doubleword aligned quantities must go in even register pairs.  */
3833       if (may_use_core_reg
3834           && argreg <= ARM_LAST_ARG_REGNUM
3835           && align > INT_REGISTER_SIZE
3836           && argreg & 1)
3837         argreg++;
3838
3839       /* If the argument is a pointer to a function, and it is a
3840          Thumb function, create a LOCAL copy of the value and set
3841          the THUMB bit in it.  */
3842       if (TYPE_CODE_PTR == typecode
3843           && target_type != NULL
3844           && TYPE_CODE_FUNC == TYPE_CODE (check_typedef (target_type)))
3845         {
3846           CORE_ADDR regval = extract_unsigned_integer (val, len, byte_order);
3847           if (arm_pc_is_thumb (gdbarch, regval))
3848             {
3849               bfd_byte *copy = (bfd_byte *) alloca (len);
3850               store_unsigned_integer (copy, len, byte_order,
3851                                       MAKE_THUMB_ADDR (regval));
3852               val = copy;
3853             }
3854         }
3855
3856       /* Copy the argument to general registers or the stack in
3857          register-sized pieces.  Large arguments are split between
3858          registers and stack.  */
3859       while (len > 0)
3860         {
3861           int partial_len = len < INT_REGISTER_SIZE ? len : INT_REGISTER_SIZE;
3862           CORE_ADDR regval
3863             = extract_unsigned_integer (val, partial_len, byte_order);
3864
3865           if (may_use_core_reg && argreg <= ARM_LAST_ARG_REGNUM)
3866             {
3867               /* The argument is being passed in a general purpose
3868                  register.  */
3869               if (byte_order == BFD_ENDIAN_BIG)
3870                 regval <<= (INT_REGISTER_SIZE - partial_len) * 8;
3871               if (arm_debug)
3872                 fprintf_unfiltered (gdb_stdlog, "arg %d in %s = 0x%s\n",
3873                                     argnum,
3874                                     gdbarch_register_name
3875                                       (gdbarch, argreg),
3876                                     phex (regval, INT_REGISTER_SIZE));
3877               regcache_cooked_write_unsigned (regcache, argreg, regval);
3878               argreg++;
3879             }
3880           else
3881             {
3882               gdb_byte buf[INT_REGISTER_SIZE];
3883
3884               memset (buf, 0, sizeof (buf));
3885               store_unsigned_integer (buf, partial_len, byte_order, regval);
3886
3887               /* Push the arguments onto the stack.  */
3888               if (arm_debug)
3889                 fprintf_unfiltered (gdb_stdlog, "arg %d @ sp + %d\n",
3890                                     argnum, nstack);
3891               si = push_stack_item (si, buf, INT_REGISTER_SIZE);
3892               nstack += INT_REGISTER_SIZE;
3893             }
3894               
3895           len -= partial_len;
3896           val += partial_len;
3897         }
3898     }
3899   /* If we have an odd number of words to push, then decrement the stack
3900      by one word now, so first stack argument will be dword aligned.  */
3901   if (nstack & 4)
3902     sp -= 4;
3903
3904   while (si)
3905     {
3906       sp -= si->len;
3907       write_memory (sp, si->data, si->len);
3908       si = pop_stack_item (si);
3909     }
3910
3911   /* Finally, update teh SP register.  */
3912   regcache_cooked_write_unsigned (regcache, ARM_SP_REGNUM, sp);
3913
3914   return sp;
3915 }
3916
3917
3918 /* Always align the frame to an 8-byte boundary.  This is required on
3919    some platforms and harmless on the rest.  */
3920
3921 static CORE_ADDR
3922 arm_frame_align (struct gdbarch *gdbarch, CORE_ADDR sp)
3923 {
3924   /* Align the stack to eight bytes.  */
3925   return sp & ~ (CORE_ADDR) 7;
3926 }
3927
3928 static void
3929 print_fpu_flags (struct ui_file *file, int flags)
3930 {
3931   if (flags & (1 << 0))
3932     fputs_filtered ("IVO ", file);
3933   if (flags & (1 << 1))
3934     fputs_filtered ("DVZ ", file);
3935   if (flags & (1 << 2))
3936     fputs_filtered ("OFL ", file);
3937   if (flags & (1 << 3))
3938     fputs_filtered ("UFL ", file);
3939   if (flags & (1 << 4))
3940     fputs_filtered ("INX ", file);
3941   fputc_filtered ('\n', file);
3942 }
3943
3944 /* Print interesting information about the floating point processor
3945    (if present) or emulator.  */
3946 static void
3947 arm_print_float_info (struct gdbarch *gdbarch, struct ui_file *file,
3948                       struct frame_info *frame, const char *args)
3949 {
3950   unsigned long status = get_frame_register_unsigned (frame, ARM_FPS_REGNUM);
3951   int type;
3952
3953   type = (status >> 24) & 127;
3954   if (status & (1 << 31))
3955     fprintf_filtered (file, _("Hardware FPU type %d\n"), type);
3956   else
3957     fprintf_filtered (file, _("Software FPU type %d\n"), type);
3958   /* i18n: [floating point unit] mask */
3959   fputs_filtered (_("mask: "), file);
3960   print_fpu_flags (file, status >> 16);
3961   /* i18n: [floating point unit] flags */
3962   fputs_filtered (_("flags: "), file);
3963   print_fpu_flags (file, status);
3964 }
3965
3966 /* Construct the ARM extended floating point type.  */
3967 static struct type *
3968 arm_ext_type (struct gdbarch *gdbarch)
3969 {
3970   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
3971
3972   if (!tdep->arm_ext_type)
3973     tdep->arm_ext_type
3974       = arch_float_type (gdbarch, -1, "builtin_type_arm_ext",
3975                          floatformats_arm_ext);
3976
3977   return tdep->arm_ext_type;
3978 }
3979
3980 static struct type *
3981 arm_neon_double_type (struct gdbarch *gdbarch)
3982 {
3983   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
3984
3985   if (tdep->neon_double_type == NULL)
3986     {
3987       struct type *t, *elem;
3988
3989       t = arch_composite_type (gdbarch, "__gdb_builtin_type_neon_d",
3990                                TYPE_CODE_UNION);
3991       elem = builtin_type (gdbarch)->builtin_uint8;
3992       append_composite_type_field (t, "u8", init_vector_type (elem, 8));
3993       elem = builtin_type (gdbarch)->builtin_uint16;
3994       append_composite_type_field (t, "u16", init_vector_type (elem, 4));
3995       elem = builtin_type (gdbarch)->builtin_uint32;
3996       append_composite_type_field (t, "u32", init_vector_type (elem, 2));
3997       elem = builtin_type (gdbarch)->builtin_uint64;
3998       append_composite_type_field (t, "u64", elem);
3999       elem = builtin_type (gdbarch)->builtin_float;
4000       append_composite_type_field (t, "f32", init_vector_type (elem, 2));
4001       elem = builtin_type (gdbarch)->builtin_double;
4002       append_composite_type_field (t, "f64", elem);
4003
4004       TYPE_VECTOR (t) = 1;
4005       TYPE_NAME (t) = "neon_d";
4006       tdep->neon_double_type = t;
4007     }
4008
4009   return tdep->neon_double_type;
4010 }
4011
4012 /* FIXME: The vector types are not correctly ordered on big-endian
4013    targets.  Just as s0 is the low bits of d0, d0[0] is also the low
4014    bits of d0 - regardless of what unit size is being held in d0.  So
4015    the offset of the first uint8 in d0 is 7, but the offset of the
4016    first float is 4.  This code works as-is for little-endian
4017    targets.  */
4018
4019 static struct type *
4020 arm_neon_quad_type (struct gdbarch *gdbarch)
4021 {
4022   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
4023
4024   if (tdep->neon_quad_type == NULL)
4025     {
4026       struct type *t, *elem;
4027
4028       t = arch_composite_type (gdbarch, "__gdb_builtin_type_neon_q",
4029                                TYPE_CODE_UNION);
4030       elem = builtin_type (gdbarch)->builtin_uint8;
4031       append_composite_type_field (t, "u8", init_vector_type (elem, 16));
4032       elem = builtin_type (gdbarch)->builtin_uint16;
4033       append_composite_type_field (t, "u16", init_vector_type (elem, 8));
4034       elem = builtin_type (gdbarch)->builtin_uint32;
4035       append_composite_type_field (t, "u32", init_vector_type (elem, 4));
4036       elem = builtin_type (gdbarch)->builtin_uint64;
4037       append_composite_type_field (t, "u64", init_vector_type (elem, 2));
4038       elem = builtin_type (gdbarch)->builtin_float;
4039       append_composite_type_field (t, "f32", init_vector_type (elem, 4));
4040       elem = builtin_type (gdbarch)->builtin_double;
4041       append_composite_type_field (t, "f64", init_vector_type (elem, 2));
4042
4043       TYPE_VECTOR (t) = 1;
4044       TYPE_NAME (t) = "neon_q";
4045       tdep->neon_quad_type = t;
4046     }
4047
4048   return tdep->neon_quad_type;
4049 }
4050
4051 /* Return the GDB type object for the "standard" data type of data in
4052    register N.  */
4053
4054 static struct type *
4055 arm_register_type (struct gdbarch *gdbarch, int regnum)
4056 {
4057   int num_regs = gdbarch_num_regs (gdbarch);
4058
4059   if (gdbarch_tdep (gdbarch)->have_vfp_pseudos
4060       && regnum >= num_regs && regnum < num_regs + 32)
4061     return builtin_type (gdbarch)->builtin_float;
4062
4063   if (gdbarch_tdep (gdbarch)->have_neon_pseudos
4064       && regnum >= num_regs + 32 && regnum < num_regs + 32 + 16)
4065     return arm_neon_quad_type (gdbarch);
4066
4067   /* If the target description has register information, we are only
4068      in this function so that we can override the types of
4069      double-precision registers for NEON.  */
4070   if (tdesc_has_registers (gdbarch_target_desc (gdbarch)))
4071     {
4072       struct type *t = tdesc_register_type (gdbarch, regnum);
4073
4074       if (regnum >= ARM_D0_REGNUM && regnum < ARM_D0_REGNUM + 32
4075           && TYPE_CODE (t) == TYPE_CODE_FLT
4076           && gdbarch_tdep (gdbarch)->have_neon)
4077         return arm_neon_double_type (gdbarch);
4078       else
4079         return t;
4080     }
4081
4082   if (regnum >= ARM_F0_REGNUM && regnum < ARM_F0_REGNUM + NUM_FREGS)
4083     {
4084       if (!gdbarch_tdep (gdbarch)->have_fpa_registers)
4085         return builtin_type (gdbarch)->builtin_void;
4086
4087       return arm_ext_type (gdbarch);
4088     }
4089   else if (regnum == ARM_SP_REGNUM)
4090     return builtin_type (gdbarch)->builtin_data_ptr;
4091   else if (regnum == ARM_PC_REGNUM)
4092     return builtin_type (gdbarch)->builtin_func_ptr;
4093   else if (regnum >= ARRAY_SIZE (arm_register_names))
4094     /* These registers are only supported on targets which supply
4095        an XML description.  */
4096     return builtin_type (gdbarch)->builtin_int0;
4097   else
4098     return builtin_type (gdbarch)->builtin_uint32;
4099 }
4100
4101 /* Map a DWARF register REGNUM onto the appropriate GDB register
4102    number.  */
4103
4104 static int
4105 arm_dwarf_reg_to_regnum (struct gdbarch *gdbarch, int reg)
4106 {
4107   /* Core integer regs.  */
4108   if (reg >= 0 && reg <= 15)
4109     return reg;
4110
4111   /* Legacy FPA encoding.  These were once used in a way which
4112      overlapped with VFP register numbering, so their use is
4113      discouraged, but GDB doesn't support the ARM toolchain
4114      which used them for VFP.  */
4115   if (reg >= 16 && reg <= 23)
4116     return ARM_F0_REGNUM + reg - 16;
4117
4118   /* New assignments for the FPA registers.  */
4119   if (reg >= 96 && reg <= 103)
4120     return ARM_F0_REGNUM + reg - 96;
4121
4122   /* WMMX register assignments.  */
4123   if (reg >= 104 && reg <= 111)
4124     return ARM_WCGR0_REGNUM + reg - 104;
4125
4126   if (reg >= 112 && reg <= 127)
4127     return ARM_WR0_REGNUM + reg - 112;
4128
4129   if (reg >= 192 && reg <= 199)
4130     return ARM_WC0_REGNUM + reg - 192;
4131
4132   /* VFP v2 registers.  A double precision value is actually
4133      in d1 rather than s2, but the ABI only defines numbering
4134      for the single precision registers.  This will "just work"
4135      in GDB for little endian targets (we'll read eight bytes,
4136      starting in s0 and then progressing to s1), but will be
4137      reversed on big endian targets with VFP.  This won't
4138      be a problem for the new Neon quad registers; you're supposed
4139      to use DW_OP_piece for those.  */
4140   if (reg >= 64 && reg <= 95)
4141     {
4142       char name_buf[4];
4143
4144       xsnprintf (name_buf, sizeof (name_buf), "s%d", reg - 64);
4145       return user_reg_map_name_to_regnum (gdbarch, name_buf,
4146                                           strlen (name_buf));
4147     }
4148
4149   /* VFP v3 / Neon registers.  This range is also used for VFP v2
4150      registers, except that it now describes d0 instead of s0.  */
4151   if (reg >= 256 && reg <= 287)
4152     {
4153       char name_buf[4];
4154
4155       xsnprintf (name_buf, sizeof (name_buf), "d%d", reg - 256);
4156       return user_reg_map_name_to_regnum (gdbarch, name_buf,
4157                                           strlen (name_buf));
4158     }
4159
4160   return -1;
4161 }
4162
4163 /* Map GDB internal REGNUM onto the Arm simulator register numbers.  */
4164 static int
4165 arm_register_sim_regno (struct gdbarch *gdbarch, int regnum)
4166 {
4167   int reg = regnum;
4168   gdb_assert (reg >= 0 && reg < gdbarch_num_regs (gdbarch));
4169
4170   if (regnum >= ARM_WR0_REGNUM && regnum <= ARM_WR15_REGNUM)
4171     return regnum - ARM_WR0_REGNUM + SIM_ARM_IWMMXT_COP0R0_REGNUM;
4172
4173   if (regnum >= ARM_WC0_REGNUM && regnum <= ARM_WC7_REGNUM)
4174     return regnum - ARM_WC0_REGNUM + SIM_ARM_IWMMXT_COP1R0_REGNUM;
4175
4176   if (regnum >= ARM_WCGR0_REGNUM && regnum <= ARM_WCGR7_REGNUM)
4177     return regnum - ARM_WCGR0_REGNUM + SIM_ARM_IWMMXT_COP1R8_REGNUM;
4178
4179   if (reg < NUM_GREGS)
4180     return SIM_ARM_R0_REGNUM + reg;
4181   reg -= NUM_GREGS;
4182
4183   if (reg < NUM_FREGS)
4184     return SIM_ARM_FP0_REGNUM + reg;
4185   reg -= NUM_FREGS;
4186
4187   if (reg < NUM_SREGS)
4188     return SIM_ARM_FPS_REGNUM + reg;
4189   reg -= NUM_SREGS;
4190
4191   internal_error (__FILE__, __LINE__, _("Bad REGNUM %d"), regnum);
4192 }
4193
4194 /* Given BUF, which is OLD_LEN bytes ending at ENDADDR, expand
4195    the buffer to be NEW_LEN bytes ending at ENDADDR.  Return
4196    NULL if an error occurs.  BUF is freed.  */
4197
4198 static gdb_byte *
4199 extend_buffer_earlier (gdb_byte *buf, CORE_ADDR endaddr,
4200                        int old_len, int new_len)
4201 {
4202   gdb_byte *new_buf;
4203   int bytes_to_read = new_len - old_len;
4204
4205   new_buf = (gdb_byte *) xmalloc (new_len);
4206   memcpy (new_buf + bytes_to_read, buf, old_len);
4207   xfree (buf);
4208   if (target_read_code (endaddr - new_len, new_buf, bytes_to_read) != 0)
4209     {
4210       xfree (new_buf);
4211       return NULL;
4212     }
4213   return new_buf;
4214 }
4215
4216 /* An IT block is at most the 2-byte IT instruction followed by
4217    four 4-byte instructions.  The furthest back we must search to
4218    find an IT block that affects the current instruction is thus
4219    2 + 3 * 4 == 14 bytes.  */
4220 #define MAX_IT_BLOCK_PREFIX 14
4221
4222 /* Use a quick scan if there are more than this many bytes of
4223    code.  */
4224 #define IT_SCAN_THRESHOLD 32
4225
4226 /* Adjust a breakpoint's address to move breakpoints out of IT blocks.
4227    A breakpoint in an IT block may not be hit, depending on the
4228    condition flags.  */
4229 static CORE_ADDR
4230 arm_adjust_breakpoint_address (struct gdbarch *gdbarch, CORE_ADDR bpaddr)
4231 {
4232   gdb_byte *buf;
4233   char map_type;
4234   CORE_ADDR boundary, func_start;
4235   int buf_len;
4236   enum bfd_endian order = gdbarch_byte_order_for_code (gdbarch);
4237   int i, any, last_it, last_it_count;
4238
4239   /* If we are using BKPT breakpoints, none of this is necessary.  */
4240   if (gdbarch_tdep (gdbarch)->thumb2_breakpoint == NULL)
4241     return bpaddr;
4242
4243   /* ARM mode does not have this problem.  */
4244   if (!arm_pc_is_thumb (gdbarch, bpaddr))
4245     return bpaddr;
4246
4247   /* We are setting a breakpoint in Thumb code that could potentially
4248      contain an IT block.  The first step is to find how much Thumb
4249      code there is; we do not need to read outside of known Thumb
4250      sequences.  */
4251   map_type = arm_find_mapping_symbol (bpaddr, &boundary);
4252   if (map_type == 0)
4253     /* Thumb-2 code must have mapping symbols to have a chance.  */
4254     return bpaddr;
4255
4256   bpaddr = gdbarch_addr_bits_remove (gdbarch, bpaddr);
4257
4258   if (find_pc_partial_function (bpaddr, NULL, &func_start, NULL)
4259       && func_start > boundary)
4260     boundary = func_start;
4261
4262   /* Search for a candidate IT instruction.  We have to do some fancy
4263      footwork to distinguish a real IT instruction from the second
4264      half of a 32-bit instruction, but there is no need for that if
4265      there's no candidate.  */
4266   buf_len = std::min (bpaddr - boundary, (CORE_ADDR) MAX_IT_BLOCK_PREFIX);
4267   if (buf_len == 0)
4268     /* No room for an IT instruction.  */
4269     return bpaddr;
4270
4271   buf = (gdb_byte *) xmalloc (buf_len);
4272   if (target_read_code (bpaddr - buf_len, buf, buf_len) != 0)
4273     return bpaddr;
4274   any = 0;
4275   for (i = 0; i < buf_len; i += 2)
4276     {
4277       unsigned short inst1 = extract_unsigned_integer (&buf[i], 2, order);
4278       if ((inst1 & 0xff00) == 0xbf00 && (inst1 & 0x000f) != 0)
4279         {
4280           any = 1;
4281           break;
4282         }
4283     }
4284
4285   if (any == 0)
4286     {
4287       xfree (buf);
4288       return bpaddr;
4289     }
4290
4291   /* OK, the code bytes before this instruction contain at least one
4292      halfword which resembles an IT instruction.  We know that it's
4293      Thumb code, but there are still two possibilities.  Either the
4294      halfword really is an IT instruction, or it is the second half of
4295      a 32-bit Thumb instruction.  The only way we can tell is to
4296      scan forwards from a known instruction boundary.  */
4297   if (bpaddr - boundary > IT_SCAN_THRESHOLD)
4298     {
4299       int definite;
4300
4301       /* There's a lot of code before this instruction.  Start with an
4302          optimistic search; it's easy to recognize halfwords that can
4303          not be the start of a 32-bit instruction, and use that to
4304          lock on to the instruction boundaries.  */
4305       buf = extend_buffer_earlier (buf, bpaddr, buf_len, IT_SCAN_THRESHOLD);
4306       if (buf == NULL)
4307         return bpaddr;
4308       buf_len = IT_SCAN_THRESHOLD;
4309
4310       definite = 0;
4311       for (i = 0; i < buf_len - sizeof (buf) && ! definite; i += 2)
4312         {
4313           unsigned short inst1 = extract_unsigned_integer (&buf[i], 2, order);
4314           if (thumb_insn_size (inst1) == 2)
4315             {
4316               definite = 1;
4317               break;
4318             }
4319         }
4320
4321       /* At this point, if DEFINITE, BUF[I] is the first place we
4322          are sure that we know the instruction boundaries, and it is far
4323          enough from BPADDR that we could not miss an IT instruction
4324          affecting BPADDR.  If ! DEFINITE, give up - start from a
4325          known boundary.  */
4326       if (! definite)
4327         {
4328           buf = extend_buffer_earlier (buf, bpaddr, buf_len,
4329                                        bpaddr - boundary);
4330           if (buf == NULL)
4331             return bpaddr;
4332           buf_len = bpaddr - boundary;
4333           i = 0;
4334         }
4335     }
4336   else
4337     {
4338       buf = extend_buffer_earlier (buf, bpaddr, buf_len, bpaddr - boundary);
4339       if (buf == NULL)
4340         return bpaddr;
4341       buf_len = bpaddr - boundary;
4342       i = 0;
4343     }
4344
4345   /* Scan forwards.  Find the last IT instruction before BPADDR.  */
4346   last_it = -1;
4347   last_it_count = 0;
4348   while (i < buf_len)
4349     {
4350       unsigned short inst1 = extract_unsigned_integer (&buf[i], 2, order);
4351       last_it_count--;
4352       if ((inst1 & 0xff00) == 0xbf00 && (inst1 & 0x000f) != 0)
4353         {
4354           last_it = i;
4355           if (inst1 & 0x0001)
4356             last_it_count = 4;
4357           else if (inst1 & 0x0002)
4358             last_it_count = 3;
4359           else if (inst1 & 0x0004)
4360             last_it_count = 2;
4361           else
4362             last_it_count = 1;
4363         }
4364       i += thumb_insn_size (inst1);
4365     }
4366
4367   xfree (buf);
4368
4369   if (last_it == -1)
4370     /* There wasn't really an IT instruction after all.  */
4371     return bpaddr;
4372
4373   if (last_it_count < 1)
4374     /* It was too far away.  */
4375     return bpaddr;
4376
4377   /* This really is a trouble spot.  Move the breakpoint to the IT
4378      instruction.  */
4379   return bpaddr - buf_len + last_it;
4380 }
4381
4382 /* ARM displaced stepping support.
4383
4384    Generally ARM displaced stepping works as follows:
4385
4386    1. When an instruction is to be single-stepped, it is first decoded by
4387       arm_process_displaced_insn.  Depending on the type of instruction, it is
4388       then copied to a scratch location, possibly in a modified form.  The
4389       copy_* set of functions performs such modification, as necessary.  A
4390       breakpoint is placed after the modified instruction in the scratch space
4391       to return control to GDB.  Note in particular that instructions which
4392       modify the PC will no longer do so after modification.
4393
4394    2. The instruction is single-stepped, by setting the PC to the scratch
4395       location address, and resuming.  Control returns to GDB when the
4396       breakpoint is hit.
4397
4398    3. A cleanup function (cleanup_*) is called corresponding to the copy_*
4399       function used for the current instruction.  This function's job is to
4400       put the CPU/memory state back to what it would have been if the
4401       instruction had been executed unmodified in its original location.  */
4402
4403 /* NOP instruction (mov r0, r0).  */
4404 #define ARM_NOP                         0xe1a00000
4405 #define THUMB_NOP 0x4600
4406
4407 /* Helper for register reads for displaced stepping.  In particular, this
4408    returns the PC as it would be seen by the instruction at its original
4409    location.  */
4410
4411 ULONGEST
4412 displaced_read_reg (struct regcache *regs, arm_displaced_step_closure *dsc,
4413                     int regno)
4414 {
4415   ULONGEST ret;
4416   CORE_ADDR from = dsc->insn_addr;
4417
4418   if (regno == ARM_PC_REGNUM)
4419     {
4420       /* Compute pipeline offset:
4421          - When executing an ARM instruction, PC reads as the address of the
4422          current instruction plus 8.
4423          - When executing a Thumb instruction, PC reads as the address of the
4424          current instruction plus 4.  */
4425
4426       if (!dsc->is_thumb)
4427         from += 8;
4428       else
4429         from += 4;
4430
4431       if (debug_displaced)
4432         fprintf_unfiltered (gdb_stdlog, "displaced: read pc value %.8lx\n",
4433                             (unsigned long) from);
4434       return (ULONGEST) from;
4435     }
4436   else
4437     {
4438       regcache_cooked_read_unsigned (regs, regno, &ret);
4439       if (debug_displaced)
4440         fprintf_unfiltered (gdb_stdlog, "displaced: read r%d value %.8lx\n",
4441                             regno, (unsigned long) ret);
4442       return ret;
4443     }
4444 }
4445
4446 static int
4447 displaced_in_arm_mode (struct regcache *regs)
4448 {
4449   ULONGEST ps;
4450   ULONGEST t_bit = arm_psr_thumb_bit (regs->arch ());
4451
4452   regcache_cooked_read_unsigned (regs, ARM_PS_REGNUM, &ps);
4453
4454   return (ps & t_bit) == 0;
4455 }
4456
4457 /* Write to the PC as from a branch instruction.  */
4458
4459 static void
4460 branch_write_pc (struct regcache *regs, arm_displaced_step_closure *dsc,
4461                  ULONGEST val)
4462 {
4463   if (!dsc->is_thumb)
4464     /* Note: If bits 0/1 are set, this branch would be unpredictable for
4465        architecture versions < 6.  */
4466     regcache_cooked_write_unsigned (regs, ARM_PC_REGNUM,
4467                                     val & ~(ULONGEST) 0x3);
4468   else
4469     regcache_cooked_write_unsigned (regs, ARM_PC_REGNUM,
4470                                     val & ~(ULONGEST) 0x1);
4471 }
4472
4473 /* Write to the PC as from a branch-exchange instruction.  */
4474
4475 static void
4476 bx_write_pc (struct regcache *regs, ULONGEST val)
4477 {
4478   ULONGEST ps;
4479   ULONGEST t_bit = arm_psr_thumb_bit (regs->arch ());
4480
4481   regcache_cooked_read_unsigned (regs, ARM_PS_REGNUM, &ps);
4482
4483   if ((val & 1) == 1)
4484     {
4485       regcache_cooked_write_unsigned (regs, ARM_PS_REGNUM, ps | t_bit);
4486       regcache_cooked_write_unsigned (regs, ARM_PC_REGNUM, val & 0xfffffffe);
4487     }
4488   else if ((val & 2) == 0)
4489     {
4490       regcache_cooked_write_unsigned (regs, ARM_PS_REGNUM, ps & ~t_bit);
4491       regcache_cooked_write_unsigned (regs, ARM_PC_REGNUM, val);
4492     }
4493   else
4494     {
4495       /* Unpredictable behaviour.  Try to do something sensible (switch to ARM
4496           mode, align dest to 4 bytes).  */
4497       warning (_("Single-stepping BX to non-word-aligned ARM instruction."));
4498       regcache_cooked_write_unsigned (regs, ARM_PS_REGNUM, ps & ~t_bit);
4499       regcache_cooked_write_unsigned (regs, ARM_PC_REGNUM, val & 0xfffffffc);
4500     }
4501 }
4502
4503 /* Write to the PC as if from a load instruction.  */
4504
4505 static void
4506 load_write_pc (struct regcache *regs, arm_displaced_step_closure *dsc,
4507                ULONGEST val)
4508 {
4509   if (DISPLACED_STEPPING_ARCH_VERSION >= 5)
4510     bx_write_pc (regs, val);
4511   else
4512     branch_write_pc (regs, dsc, val);
4513 }
4514
4515 /* Write to the PC as if from an ALU instruction.  */
4516
4517 static void
4518 alu_write_pc (struct regcache *regs, arm_displaced_step_closure *dsc,
4519               ULONGEST val)
4520 {
4521   if (DISPLACED_STEPPING_ARCH_VERSION >= 7 && !dsc->is_thumb)
4522     bx_write_pc (regs, val);
4523   else
4524     branch_write_pc (regs, dsc, val);
4525 }
4526
4527 /* Helper for writing to registers for displaced stepping.  Writing to the PC
4528    has a varying effects depending on the instruction which does the write:
4529    this is controlled by the WRITE_PC argument.  */
4530
4531 void
4532 displaced_write_reg (struct regcache *regs, arm_displaced_step_closure *dsc,
4533                      int regno, ULONGEST val, enum pc_write_style write_pc)
4534 {
4535   if (regno == ARM_PC_REGNUM)
4536     {
4537       if (debug_displaced)
4538         fprintf_unfiltered (gdb_stdlog, "displaced: writing pc %.8lx\n",
4539                             (unsigned long) val);
4540       switch (write_pc)
4541         {
4542         case BRANCH_WRITE_PC:
4543           branch_write_pc (regs, dsc, val);
4544           break;
4545
4546         case BX_WRITE_PC:
4547           bx_write_pc (regs, val);
4548           break;
4549
4550         case LOAD_WRITE_PC:
4551           load_write_pc (regs, dsc, val);
4552           break;
4553
4554         case ALU_WRITE_PC:
4555           alu_write_pc (regs, dsc, val);
4556           break;
4557
4558         case CANNOT_WRITE_PC:
4559           warning (_("Instruction wrote to PC in an unexpected way when "
4560                      "single-stepping"));
4561           break;
4562
4563         default:
4564           internal_error (__FILE__, __LINE__,
4565                           _("Invalid argument to displaced_write_reg"));
4566         }
4567
4568       dsc->wrote_to_pc = 1;
4569     }
4570   else
4571     {
4572       if (debug_displaced)
4573         fprintf_unfiltered (gdb_stdlog, "displaced: writing r%d value %.8lx\n",
4574                             regno, (unsigned long) val);
4575       regcache_cooked_write_unsigned (regs, regno, val);
4576     }
4577 }
4578
4579 /* This function is used to concisely determine if an instruction INSN
4580    references PC.  Register fields of interest in INSN should have the
4581    corresponding fields of BITMASK set to 0b1111.  The function
4582    returns return 1 if any of these fields in INSN reference the PC
4583    (also 0b1111, r15), else it returns 0.  */
4584
4585 static int
4586 insn_references_pc (uint32_t insn, uint32_t bitmask)
4587 {
4588   uint32_t lowbit = 1;
4589
4590   while (bitmask != 0)
4591     {
4592       uint32_t mask;
4593
4594       for (; lowbit && (bitmask & lowbit) == 0; lowbit <<= 1)
4595         ;
4596
4597       if (!lowbit)
4598         break;
4599
4600       mask = lowbit * 0xf;
4601
4602       if ((insn & mask) == mask)
4603         return 1;
4604
4605       bitmask &= ~mask;
4606     }
4607
4608   return 0;
4609 }
4610
4611 /* The simplest copy function.  Many instructions have the same effect no
4612    matter what address they are executed at: in those cases, use this.  */
4613
4614 static int
4615 arm_copy_unmodified (struct gdbarch *gdbarch, uint32_t insn,
4616                      const char *iname, arm_displaced_step_closure *dsc)
4617 {
4618   if (debug_displaced)
4619     fprintf_unfiltered (gdb_stdlog, "displaced: copying insn %.8lx, "
4620                         "opcode/class '%s' unmodified\n", (unsigned long) insn,
4621                         iname);
4622
4623   dsc->modinsn[0] = insn;
4624
4625   return 0;
4626 }
4627
4628 static int
4629 thumb_copy_unmodified_32bit (struct gdbarch *gdbarch, uint16_t insn1,
4630                              uint16_t insn2, const char *iname,
4631                              arm_displaced_step_closure *dsc)
4632 {
4633   if (debug_displaced)
4634     fprintf_unfiltered (gdb_stdlog, "displaced: copying insn %.4x %.4x, "
4635                         "opcode/class '%s' unmodified\n", insn1, insn2,
4636                         iname);
4637
4638   dsc->modinsn[0] = insn1;
4639   dsc->modinsn[1] = insn2;
4640   dsc->numinsns = 2;
4641
4642   return 0;
4643 }
4644
4645 /* Copy 16-bit Thumb(Thumb and 16-bit Thumb-2) instruction without any
4646    modification.  */
4647 static int
4648 thumb_copy_unmodified_16bit (struct gdbarch *gdbarch, uint16_t insn,
4649                              const char *iname,
4650                              arm_displaced_step_closure *dsc)
4651 {
4652   if (debug_displaced)
4653     fprintf_unfiltered (gdb_stdlog, "displaced: copying insn %.4x, "
4654                         "opcode/class '%s' unmodified\n", insn,
4655                         iname);
4656
4657   dsc->modinsn[0] = insn;
4658
4659   return 0;
4660 }
4661
4662 /* Preload instructions with immediate offset.  */
4663
4664 static void
4665 cleanup_preload (struct gdbarch *gdbarch,
4666                  struct regcache *regs, arm_displaced_step_closure *dsc)
4667 {
4668   displaced_write_reg (regs, dsc, 0, dsc->tmp[0], CANNOT_WRITE_PC);
4669   if (!dsc->u.preload.immed)
4670     displaced_write_reg (regs, dsc, 1, dsc->tmp[1], CANNOT_WRITE_PC);
4671 }
4672
4673 static void
4674 install_preload (struct gdbarch *gdbarch, struct regcache *regs,
4675                  arm_displaced_step_closure *dsc, unsigned int rn)
4676 {
4677   ULONGEST rn_val;
4678   /* Preload instructions:
4679
4680      {pli/pld} [rn, #+/-imm]
4681      ->
4682      {pli/pld} [r0, #+/-imm].  */
4683
4684   dsc->tmp[0] = displaced_read_reg (regs, dsc, 0);
4685   rn_val = displaced_read_reg (regs, dsc, rn);
4686   displaced_write_reg (regs, dsc, 0, rn_val, CANNOT_WRITE_PC);
4687   dsc->u.preload.immed = 1;
4688
4689   dsc->cleanup = &cleanup_preload;
4690 }
4691
4692 static int
4693 arm_copy_preload (struct gdbarch *gdbarch, uint32_t insn, struct regcache *regs,
4694                   arm_displaced_step_closure *dsc)
4695 {
4696   unsigned int rn = bits (insn, 16, 19);
4697
4698   if (!insn_references_pc (insn, 0x000f0000ul))
4699     return arm_copy_unmodified (gdbarch, insn, "preload", dsc);
4700
4701   if (debug_displaced)
4702     fprintf_unfiltered (gdb_stdlog, "displaced: copying preload insn %.8lx\n",
4703                         (unsigned long) insn);
4704
4705   dsc->modinsn[0] = insn & 0xfff0ffff;
4706
4707   install_preload (gdbarch, regs, dsc, rn);
4708
4709   return 0;
4710 }
4711
4712 static int
4713 thumb2_copy_preload (struct gdbarch *gdbarch, uint16_t insn1, uint16_t insn2,
4714                      struct regcache *regs, arm_displaced_step_closure *dsc)
4715 {
4716   unsigned int rn = bits (insn1, 0, 3);
4717   unsigned int u_bit = bit (insn1, 7);
4718   int imm12 = bits (insn2, 0, 11);
4719   ULONGEST pc_val;
4720
4721   if (rn != ARM_PC_REGNUM)
4722     return thumb_copy_unmodified_32bit (gdbarch, insn1, insn2, "preload", dsc);
4723
4724   /* PC is only allowed to use in PLI (immediate,literal) Encoding T3, and
4725      PLD (literal) Encoding T1.  */
4726   if (debug_displaced)
4727     fprintf_unfiltered (gdb_stdlog,
4728                         "displaced: copying pld/pli pc (0x%x) %c imm12 %.4x\n",
4729                         (unsigned int) dsc->insn_addr, u_bit ? '+' : '-',
4730                         imm12);
4731
4732   if (!u_bit)
4733     imm12 = -1 * imm12;
4734
4735   /* Rewrite instruction {pli/pld} PC imm12 into:
4736      Prepare: tmp[0] <- r0, tmp[1] <- r1, r0 <- pc, r1 <- imm12
4737
4738      {pli/pld} [r0, r1]
4739
4740      Cleanup: r0 <- tmp[0], r1 <- tmp[1].  */
4741
4742   dsc->tmp[0] = displaced_read_reg (regs, dsc, 0);
4743   dsc->tmp[1] = displaced_read_reg (regs, dsc, 1);
4744
4745   pc_val = displaced_read_reg (regs, dsc, ARM_PC_REGNUM);
4746
4747   displaced_write_reg (regs, dsc, 0, pc_val, CANNOT_WRITE_PC);
4748   displaced_write_reg (regs, dsc, 1, imm12, CANNOT_WRITE_PC);
4749   dsc->u.preload.immed = 0;
4750
4751   /* {pli/pld} [r0, r1] */
4752   dsc->modinsn[0] = insn1 & 0xfff0;
4753   dsc->modinsn[1] = 0xf001;
4754   dsc->numinsns = 2;
4755
4756   dsc->cleanup = &cleanup_preload;
4757   return 0;
4758 }
4759
4760 /* Preload instructions with register offset.  */
4761
4762 static void
4763 install_preload_reg(struct gdbarch *gdbarch, struct regcache *regs,
4764                     arm_displaced_step_closure *dsc, unsigned int rn,
4765                     unsigned int rm)
4766 {
4767   ULONGEST rn_val, rm_val;
4768
4769   /* Preload register-offset instructions:
4770
4771      {pli/pld} [rn, rm {, shift}]
4772      ->
4773      {pli/pld} [r0, r1 {, shift}].  */
4774
4775   dsc->tmp[0] = displaced_read_reg (regs, dsc, 0);
4776   dsc->tmp[1] = displaced_read_reg (regs, dsc, 1);
4777   rn_val = displaced_read_reg (regs, dsc, rn);
4778   rm_val = displaced_read_reg (regs, dsc, rm);
4779   displaced_write_reg (regs, dsc, 0, rn_val, CANNOT_WRITE_PC);
4780   displaced_write_reg (regs, dsc, 1, rm_val, CANNOT_WRITE_PC);
4781   dsc->u.preload.immed = 0;
4782
4783   dsc->cleanup = &cleanup_preload;
4784 }
4785
4786 static int
4787 arm_copy_preload_reg (struct gdbarch *gdbarch, uint32_t insn,
4788                       struct regcache *regs,
4789                       arm_displaced_step_closure *dsc)
4790 {
4791   unsigned int rn = bits (insn, 16, 19);
4792   unsigned int rm = bits (insn, 0, 3);
4793
4794
4795   if (!insn_references_pc (insn, 0x000f000ful))
4796     return arm_copy_unmodified (gdbarch, insn, "preload reg", dsc);
4797
4798   if (debug_displaced)
4799     fprintf_unfiltered (gdb_stdlog, "displaced: copying preload insn %.8lx\n",
4800                         (unsigned long) insn);
4801
4802   dsc->modinsn[0] = (insn & 0xfff0fff0) | 0x1;
4803
4804   install_preload_reg (gdbarch, regs, dsc, rn, rm);
4805   return 0;
4806 }
4807
4808 /* Copy/cleanup coprocessor load and store instructions.  */
4809
4810 static void
4811 cleanup_copro_load_store (struct gdbarch *gdbarch,
4812                           struct regcache *regs,
4813                           arm_displaced_step_closure *dsc)
4814 {
4815   ULONGEST rn_val = displaced_read_reg (regs, dsc, 0);
4816
4817   displaced_write_reg (regs, dsc, 0, dsc->tmp[0], CANNOT_WRITE_PC);
4818
4819   if (dsc->u.ldst.writeback)
4820     displaced_write_reg (regs, dsc, dsc->u.ldst.rn, rn_val, LOAD_WRITE_PC);
4821 }
4822
4823 static void
4824 install_copro_load_store (struct gdbarch *gdbarch, struct regcache *regs,
4825                           arm_displaced_step_closure *dsc,
4826                           int writeback, unsigned int rn)
4827 {
4828   ULONGEST rn_val;
4829
4830   /* Coprocessor load/store instructions:
4831
4832      {stc/stc2} [<Rn>, #+/-imm]  (and other immediate addressing modes)
4833      ->
4834      {stc/stc2} [r0, #+/-imm].
4835
4836      ldc/ldc2 are handled identically.  */
4837
4838   dsc->tmp[0] = displaced_read_reg (regs, dsc, 0);
4839   rn_val = displaced_read_reg (regs, dsc, rn);
4840   /* PC should be 4-byte aligned.  */
4841   rn_val = rn_val & 0xfffffffc;
4842   displaced_write_reg (regs, dsc, 0, rn_val, CANNOT_WRITE_PC);
4843
4844   dsc->u.ldst.writeback = writeback;
4845   dsc->u.ldst.rn = rn;
4846
4847   dsc->cleanup = &cleanup_copro_load_store;
4848 }
4849
4850 static int
4851 arm_copy_copro_load_store (struct gdbarch *gdbarch, uint32_t insn,
4852                            struct regcache *regs,
4853                            arm_displaced_step_closure *dsc)
4854 {
4855   unsigned int rn = bits (insn, 16, 19);
4856
4857   if (!insn_references_pc (insn, 0x000f0000ul))
4858     return arm_copy_unmodified (gdbarch, insn, "copro load/store", dsc);
4859
4860   if (debug_displaced)
4861     fprintf_unfiltered (gdb_stdlog, "displaced: copying coprocessor "
4862                         "load/store insn %.8lx\n", (unsigned long) insn);
4863
4864   dsc->modinsn[0] = insn & 0xfff0ffff;
4865
4866   install_copro_load_store (gdbarch, regs, dsc, bit (insn, 25), rn);
4867
4868   return 0;
4869 }
4870
4871 static int
4872 thumb2_copy_copro_load_store (struct gdbarch *gdbarch, uint16_t insn1,
4873                               uint16_t insn2, struct regcache *regs,
4874                               arm_displaced_step_closure *dsc)
4875 {
4876   unsigned int rn = bits (insn1, 0, 3);
4877
4878   if (rn != ARM_PC_REGNUM)
4879     return thumb_copy_unmodified_32bit (gdbarch, insn1, insn2,
4880                                         "copro load/store", dsc);
4881
4882   if (debug_displaced)
4883     fprintf_unfiltered (gdb_stdlog, "displaced: copying coprocessor "
4884                         "load/store insn %.4x%.4x\n", insn1, insn2);
4885
4886   dsc->modinsn[0] = insn1 & 0xfff0;
4887   dsc->modinsn[1] = insn2;
4888   dsc->numinsns = 2;
4889
4890   /* This function is called for copying instruction LDC/LDC2/VLDR, which
4891      doesn't support writeback, so pass 0.  */
4892   install_copro_load_store (gdbarch, regs, dsc, 0, rn);
4893
4894   return 0;
4895 }
4896
4897 /* Clean up branch instructions (actually perform the branch, by setting
4898    PC).  */
4899
4900 static void
4901 cleanup_branch (struct gdbarch *gdbarch, struct regcache *regs,
4902                 arm_displaced_step_closure *dsc)
4903 {
4904   uint32_t status = displaced_read_reg (regs, dsc, ARM_PS_REGNUM);
4905   int branch_taken = condition_true (dsc->u.branch.cond, status);
4906   enum pc_write_style write_pc = dsc->u.branch.exchange
4907                                  ? BX_WRITE_PC : BRANCH_WRITE_PC;
4908
4909   if (!branch_taken)
4910     return;
4911
4912   if (dsc->u.branch.link)
4913     {
4914       /* The value of LR should be the next insn of current one.  In order
4915        not to confuse logic hanlding later insn `bx lr', if current insn mode
4916        is Thumb, the bit 0 of LR value should be set to 1.  */
4917       ULONGEST next_insn_addr = dsc->insn_addr + dsc->insn_size;
4918
4919       if (dsc->is_thumb)
4920         next_insn_addr |= 0x1;
4921
4922       displaced_write_reg (regs, dsc, ARM_LR_REGNUM, next_insn_addr,
4923                            CANNOT_WRITE_PC);
4924     }
4925
4926   displaced_write_reg (regs, dsc, ARM_PC_REGNUM, dsc->u.branch.dest, write_pc);
4927 }
4928
4929 /* Copy B/BL/BLX instructions with immediate destinations.  */
4930
4931 static void
4932 install_b_bl_blx (struct gdbarch *gdbarch, struct regcache *regs,
4933                   arm_displaced_step_closure *dsc,
4934                   unsigned int cond, int exchange, int link, long offset)
4935 {
4936   /* Implement "BL<cond> <label>" as:
4937
4938      Preparation: cond <- instruction condition
4939      Insn: mov r0, r0  (nop)
4940      Cleanup: if (condition true) { r14 <- pc; pc <- label }.
4941
4942      B<cond> similar, but don't set r14 in cleanup.  */
4943
4944   dsc->u.branch.cond = cond;
4945   dsc->u.branch.link = link;
4946   dsc->u.branch.exchange = exchange;
4947
4948   dsc->u.branch.dest = dsc->insn_addr;
4949   if (link && exchange)
4950     /* For BLX, offset is computed from the Align (PC, 4).  */
4951     dsc->u.branch.dest = dsc->u.branch.dest & 0xfffffffc;
4952
4953   if (dsc->is_thumb)
4954     dsc->u.branch.dest += 4 + offset;
4955   else
4956     dsc->u.branch.dest += 8 + offset;
4957
4958   dsc->cleanup = &cleanup_branch;
4959 }
4960 static int
4961 arm_copy_b_bl_blx (struct gdbarch *gdbarch, uint32_t insn,
4962                    struct regcache *regs, arm_displaced_step_closure *dsc)
4963 {
4964   unsigned int cond = bits (insn, 28, 31);
4965   int exchange = (cond == 0xf);
4966   int link = exchange || bit (insn, 24);
4967   long offset;
4968
4969   if (debug_displaced)
4970     fprintf_unfiltered (gdb_stdlog, "displaced: copying %s immediate insn "
4971                         "%.8lx\n", (exchange) ? "blx" : (link) ? "bl" : "b",
4972                         (unsigned long) insn);
4973   if (exchange)
4974     /* For BLX, set bit 0 of the destination.  The cleanup_branch function will
4975        then arrange the switch into Thumb mode.  */
4976     offset = (bits (insn, 0, 23) << 2) | (bit (insn, 24) << 1) | 1;
4977   else
4978     offset = bits (insn, 0, 23) << 2;
4979
4980   if (bit (offset, 25))
4981     offset = offset | ~0x3ffffff;
4982
4983   dsc->modinsn[0] = ARM_NOP;
4984
4985   install_b_bl_blx (gdbarch, regs, dsc, cond, exchange, link, offset);
4986   return 0;
4987 }
4988
4989 static int
4990 thumb2_copy_b_bl_blx (struct gdbarch *gdbarch, uint16_t insn1,
4991                       uint16_t insn2, struct regcache *regs,
4992                       arm_displaced_step_closure *dsc)
4993 {
4994   int link = bit (insn2, 14);
4995   int exchange = link && !bit (insn2, 12);
4996   int cond = INST_AL;
4997   long offset = 0;
4998   int j1 = bit (insn2, 13);
4999   int j2 = bit (insn2, 11);
5000   int s = sbits (insn1, 10, 10);
5001   int i1 = !(j1 ^ bit (insn1, 10));
5002   int i2 = !(j2 ^ bit (insn1, 10));
5003
5004   if (!link && !exchange) /* B */
5005     {
5006       offset = (bits (insn2, 0, 10) << 1);
5007       if (bit (insn2, 12)) /* Encoding T4 */
5008         {
5009           offset |= (bits (insn1, 0, 9) << 12)
5010             | (i2 << 22)
5011             | (i1 << 23)
5012             | (s << 24);
5013           cond = INST_AL;
5014         }
5015       else /* Encoding T3 */
5016         {
5017           offset |= (bits (insn1, 0, 5) << 12)
5018             | (j1 << 18)
5019             | (j2 << 19)
5020             | (s << 20);
5021           cond = bits (insn1, 6, 9);
5022         }
5023     }
5024   else
5025     {
5026       offset = (bits (insn1, 0, 9) << 12);
5027       offset |= ((i2 << 22) | (i1 << 23) | (s << 24));
5028       offset |= exchange ?
5029         (bits (insn2, 1, 10) << 2) : (bits (insn2, 0, 10) << 1);
5030     }
5031
5032   if (debug_displaced)
5033     fprintf_unfiltered (gdb_stdlog, "displaced: copying %s insn "
5034                         "%.4x %.4x with offset %.8lx\n",
5035                         link ? (exchange) ? "blx" : "bl" : "b",
5036                         insn1, insn2, offset);
5037
5038   dsc->modinsn[0] = THUMB_NOP;
5039
5040   install_b_bl_blx (gdbarch, regs, dsc, cond, exchange, link, offset);
5041   return 0;
5042 }
5043
5044 /* Copy B Thumb instructions.  */
5045 static int
5046 thumb_copy_b (struct gdbarch *gdbarch, uint16_t insn,
5047               arm_displaced_step_closure *dsc)
5048 {
5049   unsigned int cond = 0;
5050   int offset = 0;
5051   unsigned short bit_12_15 = bits (insn, 12, 15);
5052   CORE_ADDR from = dsc->insn_addr;
5053
5054   if (bit_12_15 == 0xd)
5055     {
5056       /* offset = SignExtend (imm8:0, 32) */
5057       offset = sbits ((insn << 1), 0, 8);
5058       cond = bits (insn, 8, 11);
5059     }
5060   else if (bit_12_15 == 0xe) /* Encoding T2 */
5061     {
5062       offset = sbits ((insn << 1), 0, 11);
5063       cond = INST_AL;
5064     }
5065
5066   if (debug_displaced)
5067     fprintf_unfiltered (gdb_stdlog,
5068                         "displaced: copying b immediate insn %.4x "
5069                         "with offset %d\n", insn, offset);
5070
5071   dsc->u.branch.cond = cond;
5072   dsc->u.branch.link = 0;
5073   dsc->u.branch.exchange = 0;
5074   dsc->u.branch.dest = from + 4 + offset;
5075
5076   dsc->modinsn[0] = THUMB_NOP;
5077
5078   dsc->cleanup = &cleanup_branch;
5079
5080   return 0;
5081 }
5082
5083 /* Copy BX/BLX with register-specified destinations.  */
5084
5085 static void
5086 install_bx_blx_reg (struct gdbarch *gdbarch, struct regcache *regs,
5087                     arm_displaced_step_closure *dsc, int link,
5088                     unsigned int cond, unsigned int rm)
5089 {
5090   /* Implement {BX,BLX}<cond> <reg>" as:
5091
5092      Preparation: cond <- instruction condition
5093      Insn: mov r0, r0 (nop)
5094      Cleanup: if (condition true) { r14 <- pc; pc <- dest; }.
5095
5096      Don't set r14 in cleanup for BX.  */
5097
5098   dsc->u.branch.dest = displaced_read_reg (regs, dsc, rm);
5099
5100   dsc->u.branch.cond = cond;
5101   dsc->u.branch.link = link;
5102
5103   dsc->u.branch.exchange = 1;
5104
5105   dsc->cleanup = &cleanup_branch;
5106 }
5107
5108 static int
5109 arm_copy_bx_blx_reg (struct gdbarch *gdbarch, uint32_t insn,
5110                      struct regcache *regs, arm_displaced_step_closure *dsc)
5111 {
5112   unsigned int cond = bits (insn, 28, 31);
5113   /* BX:  x12xxx1x
5114      BLX: x12xxx3x.  */
5115   int link = bit (insn, 5);
5116   unsigned int rm = bits (insn, 0, 3);
5117
5118   if (debug_displaced)
5119     fprintf_unfiltered (gdb_stdlog, "displaced: copying insn %.8lx",
5120                         (unsigned long) insn);
5121
5122   dsc->modinsn[0] = ARM_NOP;
5123
5124   install_bx_blx_reg (gdbarch, regs, dsc, link, cond, rm);
5125   return 0;
5126 }
5127
5128 static int
5129 thumb_copy_bx_blx_reg (struct gdbarch *gdbarch, uint16_t insn,
5130                        struct regcache *regs,
5131                        arm_displaced_step_closure *dsc)
5132 {
5133   int link = bit (insn, 7);
5134   unsigned int rm = bits (insn, 3, 6);
5135
5136   if (debug_displaced)
5137     fprintf_unfiltered (gdb_stdlog, "displaced: copying insn %.4x",
5138                         (unsigned short) insn);
5139
5140   dsc->modinsn[0] = THUMB_NOP;
5141
5142   install_bx_blx_reg (gdbarch, regs, dsc, link, INST_AL, rm);
5143
5144   return 0;
5145 }
5146
5147
5148 /* Copy/cleanup arithmetic/logic instruction with immediate RHS.  */
5149
5150 static void
5151 cleanup_alu_imm (struct gdbarch *gdbarch,
5152                  struct regcache *regs, arm_displaced_step_closure *dsc)
5153 {
5154   ULONGEST rd_val = displaced_read_reg (regs, dsc, 0);
5155   displaced_write_reg (regs, dsc, 0, dsc->tmp[0], CANNOT_WRITE_PC);
5156   displaced_write_reg (regs, dsc, 1, dsc->tmp[1], CANNOT_WRITE_PC);
5157   displaced_write_reg (regs, dsc, dsc->rd, rd_val, ALU_WRITE_PC);
5158 }
5159
5160 static int
5161 arm_copy_alu_imm (struct gdbarch *gdbarch, uint32_t insn, struct regcache *regs,
5162                   arm_displaced_step_closure *dsc)
5163 {
5164   unsigned int rn = bits (insn, 16, 19);
5165   unsigned int rd = bits (insn, 12, 15);
5166   unsigned int op = bits (insn, 21, 24);
5167   int is_mov = (op == 0xd);
5168   ULONGEST rd_val, rn_val;
5169
5170   if (!insn_references_pc (insn, 0x000ff000ul))
5171     return arm_copy_unmodified (gdbarch, insn, "ALU immediate", dsc);
5172
5173   if (debug_displaced)
5174     fprintf_unfiltered (gdb_stdlog, "displaced: copying immediate %s insn "
5175                         "%.8lx\n", is_mov ? "move" : "ALU",
5176                         (unsigned long) insn);
5177
5178   /* Instruction is of form:
5179
5180      <op><cond> rd, [rn,] #imm
5181
5182      Rewrite as:
5183
5184      Preparation: tmp1, tmp2 <- r0, r1;
5185                   r0, r1 <- rd, rn
5186      Insn: <op><cond> r0, r1, #imm
5187      Cleanup: rd <- r0; r0 <- tmp1; r1 <- tmp2
5188   */
5189
5190   dsc->tmp[0] = displaced_read_reg (regs, dsc, 0);
5191   dsc->tmp[1] = displaced_read_reg (regs, dsc, 1);
5192   rn_val = displaced_read_reg (regs, dsc, rn);
5193   rd_val = displaced_read_reg (regs, dsc, rd);
5194   displaced_write_reg (regs, dsc, 0, rd_val, CANNOT_WRITE_PC);
5195   displaced_write_reg (regs, dsc, 1, rn_val, CANNOT_WRITE_PC);
5196   dsc->rd = rd;
5197
5198   if (is_mov)
5199     dsc->modinsn[0] = insn & 0xfff00fff;
5200   else
5201     dsc->modinsn[0] = (insn & 0xfff00fff) | 0x10000;
5202
5203   dsc->cleanup = &cleanup_alu_imm;
5204
5205   return 0;
5206 }
5207
5208 static int
5209 thumb2_copy_alu_imm (struct gdbarch *gdbarch, uint16_t insn1,
5210                      uint16_t insn2, struct regcache *regs,
5211                      arm_displaced_step_closure *dsc)
5212 {
5213   unsigned int op = bits (insn1, 5, 8);
5214   unsigned int rn, rm, rd;
5215   ULONGEST rd_val, rn_val;
5216
5217   rn = bits (insn1, 0, 3); /* Rn */
5218   rm = bits (insn2, 0, 3); /* Rm */
5219   rd = bits (insn2, 8, 11); /* Rd */
5220
5221   /* This routine is only called for instruction MOV.  */
5222   gdb_assert (op == 0x2 && rn == 0xf);
5223
5224   if (rm != ARM_PC_REGNUM && rd != ARM_PC_REGNUM)
5225     return thumb_copy_unmodified_32bit (gdbarch, insn1, insn2, "ALU imm", dsc);
5226
5227   if (debug_displaced)
5228     fprintf_unfiltered (gdb_stdlog, "displaced: copying reg %s insn %.4x%.4x\n",
5229                         "ALU", insn1, insn2);
5230
5231   /* Instruction is of form:
5232
5233      <op><cond> rd, [rn,] #imm
5234
5235      Rewrite as:
5236
5237      Preparation: tmp1, tmp2 <- r0, r1;
5238                   r0, r1 <- rd, rn
5239      Insn: <op><cond> r0, r1, #imm
5240      Cleanup: rd <- r0; r0 <- tmp1; r1 <- tmp2
5241   */
5242
5243   dsc->tmp[0] = displaced_read_reg (regs, dsc, 0);
5244   dsc->tmp[1] = displaced_read_reg (regs, dsc, 1);
5245   rn_val = displaced_read_reg (regs, dsc, rn);
5246   rd_val = displaced_read_reg (regs, dsc, rd);
5247   displaced_write_reg (regs, dsc, 0, rd_val, CANNOT_WRITE_PC);
5248   displaced_write_reg (regs, dsc, 1, rn_val, CANNOT_WRITE_PC);
5249   dsc->rd = rd;
5250
5251   dsc->modinsn[0] = insn1;
5252   dsc->modinsn[1] = ((insn2 & 0xf0f0) | 0x1);
5253   dsc->numinsns = 2;
5254
5255   dsc->cleanup = &cleanup_alu_imm;
5256
5257   return 0;
5258 }
5259
5260 /* Copy/cleanup arithmetic/logic insns with register RHS.  */
5261
5262 static void
5263 cleanup_alu_reg (struct gdbarch *gdbarch,
5264                  struct regcache *regs, arm_displaced_step_closure *dsc)
5265 {
5266   ULONGEST rd_val;
5267   int i;
5268
5269   rd_val = displaced_read_reg (regs, dsc, 0);
5270
5271   for (i = 0; i < 3; i++)
5272     displaced_write_reg (regs, dsc, i, dsc->tmp[i], CANNOT_WRITE_PC);
5273
5274   displaced_write_reg (regs, dsc, dsc->rd, rd_val, ALU_WRITE_PC);
5275 }
5276
5277 static void
5278 install_alu_reg (struct gdbarch *gdbarch, struct regcache *regs,
5279                  arm_displaced_step_closure *dsc,
5280                  unsigned int rd, unsigned int rn, unsigned int rm)
5281 {
5282   ULONGEST rd_val, rn_val, rm_val;
5283
5284   /* Instruction is of form:
5285
5286      <op><cond> rd, [rn,] rm [, <shift>]
5287
5288      Rewrite as:
5289
5290      Preparation: tmp1, tmp2, tmp3 <- r0, r1, r2;
5291                   r0, r1, r2 <- rd, rn, rm
5292      Insn: <op><cond> r0, [r1,] r2 [, <shift>]
5293      Cleanup: rd <- r0; r0, r1, r2 <- tmp1, tmp2, tmp3
5294   */
5295
5296   dsc->tmp[0] = displaced_read_reg (regs, dsc, 0);
5297   dsc->tmp[1] = displaced_read_reg (regs, dsc, 1);
5298   dsc->tmp[2] = displaced_read_reg (regs, dsc, 2);
5299   rd_val = displaced_read_reg (regs, dsc, rd);
5300   rn_val = displaced_read_reg (regs, dsc, rn);
5301   rm_val = displaced_read_reg (regs, dsc, rm);
5302   displaced_write_reg (regs, dsc, 0, rd_val, CANNOT_WRITE_PC);
5303   displaced_write_reg (regs, dsc, 1, rn_val, CANNOT_WRITE_PC);
5304   displaced_write_reg (regs, dsc, 2, rm_val, CANNOT_WRITE_PC);
5305   dsc->rd = rd;
5306
5307   dsc->cleanup = &cleanup_alu_reg;
5308 }
5309
5310 static int
5311 arm_copy_alu_reg (struct gdbarch *gdbarch, uint32_t insn, struct regcache *regs,
5312                   arm_displaced_step_closure *dsc)
5313 {
5314   unsigned int op = bits (insn, 21, 24);
5315   int is_mov = (op == 0xd);
5316
5317   if (!insn_references_pc (insn, 0x000ff00ful))
5318     return arm_copy_unmodified (gdbarch, insn, "ALU reg", dsc);
5319
5320   if (debug_displaced)
5321     fprintf_unfiltered (gdb_stdlog, "displaced: copying reg %s insn %.8lx\n",
5322                         is_mov ? "move" : "ALU", (unsigned long) insn);
5323
5324   if (is_mov)
5325     dsc->modinsn[0] = (insn & 0xfff00ff0) | 0x2;
5326   else
5327     dsc->modinsn[0] = (insn & 0xfff00ff0) | 0x10002;
5328
5329   install_alu_reg (gdbarch, regs, dsc, bits (insn, 12, 15), bits (insn, 16, 19),
5330                    bits (insn, 0, 3));
5331   return 0;
5332 }
5333
5334 static int
5335 thumb_copy_alu_reg (struct gdbarch *gdbarch, uint16_t insn,
5336                     struct regcache *regs,
5337                     arm_displaced_step_closure *dsc)
5338 {
5339   unsigned rm, rd;
5340
5341   rm = bits (insn, 3, 6);
5342   rd = (bit (insn, 7) << 3) | bits (insn, 0, 2);
5343
5344   if (rd != ARM_PC_REGNUM && rm != ARM_PC_REGNUM)
5345     return thumb_copy_unmodified_16bit (gdbarch, insn, "ALU reg", dsc);
5346
5347   if (debug_displaced)
5348     fprintf_unfiltered (gdb_stdlog, "displaced: copying ALU reg insn %.4x\n",
5349                         (unsigned short) insn);
5350
5351   dsc->modinsn[0] = ((insn & 0xff00) | 0x10);
5352
5353   install_alu_reg (gdbarch, regs, dsc, rd, rd, rm);
5354
5355   return 0;
5356 }
5357
5358 /* Cleanup/copy arithmetic/logic insns with shifted register RHS.  */
5359
5360 static void
5361 cleanup_alu_shifted_reg (struct gdbarch *gdbarch,
5362                          struct regcache *regs,
5363                          arm_displaced_step_closure *dsc)
5364 {
5365   ULONGEST rd_val = displaced_read_reg (regs, dsc, 0);
5366   int i;
5367
5368   for (i = 0; i < 4; i++)
5369     displaced_write_reg (regs, dsc, i, dsc->tmp[i], CANNOT_WRITE_PC);
5370
5371   displaced_write_reg (regs, dsc, dsc->rd, rd_val, ALU_WRITE_PC);
5372 }
5373
5374 static void
5375 install_alu_shifted_reg (struct gdbarch *gdbarch, struct regcache *regs,
5376                          arm_displaced_step_closure *dsc,
5377                          unsigned int rd, unsigned int rn, unsigned int rm,
5378                          unsigned rs)
5379 {
5380   int i;
5381   ULONGEST rd_val, rn_val, rm_val, rs_val;
5382
5383   /* Instruction is of form:
5384
5385      <op><cond> rd, [rn,] rm, <shift> rs
5386
5387      Rewrite as:
5388
5389      Preparation: tmp1, tmp2, tmp3, tmp4 <- r0, r1, r2, r3
5390                   r0, r1, r2, r3 <- rd, rn, rm, rs
5391      Insn: <op><cond> r0, r1, r2, <shift> r3
5392      Cleanup: tmp5 <- r0
5393               r0, r1, r2, r3 <- tmp1, tmp2, tmp3, tmp4
5394               rd <- tmp5
5395   */
5396
5397   for (i = 0; i < 4; i++)
5398     dsc->tmp[i] = displaced_read_reg (regs, dsc, i);
5399
5400   rd_val = displaced_read_reg (regs, dsc, rd);
5401   rn_val = displaced_read_reg (regs, dsc, rn);
5402   rm_val = displaced_read_reg (regs, dsc, rm);
5403   rs_val = displaced_read_reg (regs, dsc, rs);
5404   displaced_write_reg (regs, dsc, 0, rd_val, CANNOT_WRITE_PC);
5405   displaced_write_reg (regs, dsc, 1, rn_val, CANNOT_WRITE_PC);
5406   displaced_write_reg (regs, dsc, 2, rm_val, CANNOT_WRITE_PC);
5407   displaced_write_reg (regs, dsc, 3, rs_val, CANNOT_WRITE_PC);
5408   dsc->rd = rd;
5409   dsc->cleanup = &cleanup_alu_shifted_reg;
5410 }
5411
5412 static int
5413 arm_copy_alu_shifted_reg (struct gdbarch *gdbarch, uint32_t insn,
5414                           struct regcache *regs,
5415                           arm_displaced_step_closure *dsc)
5416 {
5417   unsigned int op = bits (insn, 21, 24);
5418   int is_mov = (op == 0xd);
5419   unsigned int rd, rn, rm, rs;
5420
5421   if (!insn_references_pc (insn, 0x000fff0ful))
5422     return arm_copy_unmodified (gdbarch, insn, "ALU shifted reg", dsc);
5423
5424   if (debug_displaced)
5425     fprintf_unfiltered (gdb_stdlog, "displaced: copying shifted reg %s insn "
5426                         "%.8lx\n", is_mov ? "move" : "ALU",
5427                         (unsigned long) insn);
5428
5429   rn = bits (insn, 16, 19);
5430   rm = bits (insn, 0, 3);
5431   rs = bits (insn, 8, 11);
5432   rd = bits (insn, 12, 15);
5433
5434   if (is_mov)
5435     dsc->modinsn[0] = (insn & 0xfff000f0) | 0x302;
5436   else
5437     dsc->modinsn[0] = (insn & 0xfff000f0) | 0x10302;
5438
5439   install_alu_shifted_reg (gdbarch, regs, dsc, rd, rn, rm, rs);
5440
5441   return 0;
5442 }
5443
5444 /* Clean up load instructions.  */
5445
5446 static void
5447 cleanup_load (struct gdbarch *gdbarch, struct regcache *regs,
5448               arm_displaced_step_closure *dsc)
5449 {
5450   ULONGEST rt_val, rt_val2 = 0, rn_val;
5451
5452   rt_val = displaced_read_reg (regs, dsc, 0);
5453   if (dsc->u.ldst.xfersize == 8)
5454     rt_val2 = displaced_read_reg (regs, dsc, 1);
5455   rn_val = displaced_read_reg (regs, dsc, 2);
5456
5457   displaced_write_reg (regs, dsc, 0, dsc->tmp[0], CANNOT_WRITE_PC);
5458   if (dsc->u.ldst.xfersize > 4)
5459     displaced_write_reg (regs, dsc, 1, dsc->tmp[1], CANNOT_WRITE_PC);
5460   displaced_write_reg (regs, dsc, 2, dsc->tmp[2], CANNOT_WRITE_PC);
5461   if (!dsc->u.ldst.immed)
5462     displaced_write_reg (regs, dsc, 3, dsc->tmp[3], CANNOT_WRITE_PC);
5463
5464   /* Handle register writeback.  */
5465   if (dsc->u.ldst.writeback)
5466     displaced_write_reg (regs, dsc, dsc->u.ldst.rn, rn_val, CANNOT_WRITE_PC);
5467   /* Put result in right place.  */
5468   displaced_write_reg (regs, dsc, dsc->rd, rt_val, LOAD_WRITE_PC);
5469   if (dsc->u.ldst.xfersize == 8)
5470     displaced_write_reg (regs, dsc, dsc->rd + 1, rt_val2, LOAD_WRITE_PC);
5471 }
5472
5473 /* Clean up store instructions.  */
5474
5475 static void
5476 cleanup_store (struct gdbarch *gdbarch, struct regcache *regs,
5477                arm_displaced_step_closure *dsc)
5478 {
5479   ULONGEST rn_val = displaced_read_reg (regs, dsc, 2);
5480
5481   displaced_write_reg (regs, dsc, 0, dsc->tmp[0], CANNOT_WRITE_PC);
5482   if (dsc->u.ldst.xfersize > 4)
5483     displaced_write_reg (regs, dsc, 1, dsc->tmp[1], CANNOT_WRITE_PC);
5484   displaced_write_reg (regs, dsc, 2, dsc->tmp[2], CANNOT_WRITE_PC);
5485   if (!dsc->u.ldst.immed)
5486     displaced_write_reg (regs, dsc, 3, dsc->tmp[3], CANNOT_WRITE_PC);
5487   if (!dsc->u.ldst.restore_r4)
5488     displaced_write_reg (regs, dsc, 4, dsc->tmp[4], CANNOT_WRITE_PC);
5489
5490   /* Writeback.  */
5491   if (dsc->u.ldst.writeback)
5492     displaced_write_reg (regs, dsc, dsc->u.ldst.rn, rn_val, CANNOT_WRITE_PC);
5493 }
5494
5495 /* Copy "extra" load/store instructions.  These are halfword/doubleword
5496    transfers, which have a different encoding to byte/word transfers.  */
5497
5498 static int
5499 arm_copy_extra_ld_st (struct gdbarch *gdbarch, uint32_t insn, int unprivileged,
5500                       struct regcache *regs, arm_displaced_step_closure *dsc)
5501 {
5502   unsigned int op1 = bits (insn, 20, 24);
5503   unsigned int op2 = bits (insn, 5, 6);
5504   unsigned int rt = bits (insn, 12, 15);
5505   unsigned int rn = bits (insn, 16, 19);
5506   unsigned int rm = bits (insn, 0, 3);
5507   char load[12]     = {0, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 1};
5508   char bytesize[12] = {2, 2, 2, 2, 8, 1, 8, 1, 8, 2, 8, 2};
5509   int immed = (op1 & 0x4) != 0;
5510   int opcode;
5511   ULONGEST rt_val, rt_val2 = 0, rn_val, rm_val = 0;
5512
5513   if (!insn_references_pc (insn, 0x000ff00ful))
5514     return arm_copy_unmodified (gdbarch, insn, "extra load/store", dsc);
5515
5516   if (debug_displaced)
5517     fprintf_unfiltered (gdb_stdlog, "displaced: copying %sextra load/store "
5518                         "insn %.8lx\n", unprivileged ? "unprivileged " : "",
5519                         (unsigned long) insn);
5520
5521   opcode = ((op2 << 2) | (op1 & 0x1) | ((op1 & 0x4) >> 1)) - 4;
5522
5523   if (opcode < 0)
5524     internal_error (__FILE__, __LINE__,
5525                     _("copy_extra_ld_st: instruction decode error"));
5526
5527   dsc->tmp[0] = displaced_read_reg (regs, dsc, 0);
5528   dsc->tmp[1] = displaced_read_reg (regs, dsc, 1);
5529   dsc->tmp[2] = displaced_read_reg (regs, dsc, 2);
5530   if (!immed)
5531     dsc->tmp[3] = displaced_read_reg (regs, dsc, 3);
5532
5533   rt_val = displaced_read_reg (regs, dsc, rt);
5534   if (bytesize[opcode] == 8)
5535     rt_val2 = displaced_read_reg (regs, dsc, rt + 1);
5536   rn_val = displaced_read_reg (regs, dsc, rn);
5537   if (!immed)
5538     rm_val = displaced_read_reg (regs, dsc, rm);
5539
5540   displaced_write_reg (regs, dsc, 0, rt_val, CANNOT_WRITE_PC);
5541   if (bytesize[opcode] == 8)
5542     displaced_write_reg (regs, dsc, 1, rt_val2, CANNOT_WRITE_PC);
5543   displaced_write_reg (regs, dsc, 2, rn_val, CANNOT_WRITE_PC);
5544   if (!immed)
5545     displaced_write_reg (regs, dsc, 3, rm_val, CANNOT_WRITE_PC);
5546
5547   dsc->rd = rt;
5548   dsc->u.ldst.xfersize = bytesize[opcode];
5549   dsc->u.ldst.rn = rn;
5550   dsc->u.ldst.immed = immed;
5551   dsc->u.ldst.writeback = bit (insn, 24) == 0 || bit (insn, 21) != 0;
5552   dsc->u.ldst.restore_r4 = 0;
5553
5554   if (immed)
5555     /* {ldr,str}<width><cond> rt, [rt2,] [rn, #imm]
5556         ->
5557        {ldr,str}<width><cond> r0, [r1,] [r2, #imm].  */
5558     dsc->modinsn[0] = (insn & 0xfff00fff) | 0x20000;
5559   else
5560     /* {ldr,str}<width><cond> rt, [rt2,] [rn, +/-rm]
5561         ->
5562        {ldr,str}<width><cond> r0, [r1,] [r2, +/-r3].  */
5563     dsc->modinsn[0] = (insn & 0xfff00ff0) | 0x20003;
5564
5565   dsc->cleanup = load[opcode] ? &cleanup_load : &cleanup_store;
5566
5567   return 0;
5568 }
5569
5570 /* Copy byte/half word/word loads and stores.  */
5571
5572 static void
5573 install_load_store (struct gdbarch *gdbarch, struct regcache *regs,
5574                     arm_displaced_step_closure *dsc, int load,
5575                     int immed, int writeback, int size, int usermode,
5576                     int rt, int rm, int rn)
5577 {
5578   ULONGEST rt_val, rn_val, rm_val = 0;
5579
5580   dsc->tmp[0] = displaced_read_reg (regs, dsc, 0);
5581   dsc->tmp[2] = displaced_read_reg (regs, dsc, 2);
5582   if (!immed)
5583     dsc->tmp[3] = displaced_read_reg (regs, dsc, 3);
5584   if (!load)
5585     dsc->tmp[4] = displaced_read_reg (regs, dsc, 4);
5586
5587   rt_val = displaced_read_reg (regs, dsc, rt);
5588   rn_val = displaced_read_reg (regs, dsc, rn);
5589   if (!immed)
5590     rm_val = displaced_read_reg (regs, dsc, rm);
5591
5592   displaced_write_reg (regs, dsc, 0, rt_val, CANNOT_WRITE_PC);
5593   displaced_write_reg (regs, dsc, 2, rn_val, CANNOT_WRITE_PC);
5594   if (!immed)
5595     displaced_write_reg (regs, dsc, 3, rm_val, CANNOT_WRITE_PC);
5596   dsc->rd = rt;
5597   dsc->u.ldst.xfersize = size;
5598   dsc->u.ldst.rn = rn;
5599   dsc->u.ldst.immed = immed;
5600   dsc->u.ldst.writeback = writeback;
5601
5602   /* To write PC we can do:
5603
5604      Before this sequence of instructions:
5605      r0 is the PC value got from displaced_read_reg, so r0 = from + 8;
5606      r2 is the Rn value got from dispalced_read_reg.
5607
5608      Insn1: push {pc} Write address of STR instruction + offset on stack
5609      Insn2: pop  {r4} Read it back from stack, r4 = addr(Insn1) + offset
5610      Insn3: sub r4, r4, pc   r4 = addr(Insn1) + offset - pc
5611                                 = addr(Insn1) + offset - addr(Insn3) - 8
5612                                 = offset - 16
5613      Insn4: add r4, r4, #8   r4 = offset - 8
5614      Insn5: add r0, r0, r4   r0 = from + 8 + offset - 8
5615                                 = from + offset
5616      Insn6: str r0, [r2, #imm] (or str r0, [r2, r3])
5617
5618      Otherwise we don't know what value to write for PC, since the offset is
5619      architecture-dependent (sometimes PC+8, sometimes PC+12).  More details
5620      of this can be found in Section "Saving from r15" in
5621      http://infocenter.arm.com/help/index.jsp?topic=/com.arm.doc.dui0204g/Cihbjifh.html */
5622
5623   dsc->cleanup = load ? &cleanup_load : &cleanup_store;
5624 }
5625
5626
5627 static int
5628 thumb2_copy_load_literal (struct gdbarch *gdbarch, uint16_t insn1,
5629                           uint16_t insn2, struct regcache *regs,
5630                           arm_displaced_step_closure *dsc, int size)
5631 {
5632   unsigned int u_bit = bit (insn1, 7);
5633   unsigned int rt = bits (insn2, 12, 15);
5634   int imm12 = bits (insn2, 0, 11);
5635   ULONGEST pc_val;
5636
5637   if (debug_displaced)
5638     fprintf_unfiltered (gdb_stdlog,
5639                         "displaced: copying ldr pc (0x%x) R%d %c imm12 %.4x\n",
5640                         (unsigned int) dsc->insn_addr, rt, u_bit ? '+' : '-',
5641                         imm12);
5642
5643   if (!u_bit)
5644     imm12 = -1 * imm12;
5645
5646   /* Rewrite instruction LDR Rt imm12 into:
5647
5648      Prepare: tmp[0] <- r0, tmp[1] <- r2, tmp[2] <- r3, r2 <- pc, r3 <- imm12
5649
5650      LDR R0, R2, R3,
5651
5652      Cleanup: rt <- r0, r0 <- tmp[0], r2 <- tmp[1], r3 <- tmp[2].  */
5653
5654
5655   dsc->tmp[0] = displaced_read_reg (regs, dsc, 0);
5656   dsc->tmp[2] = displaced_read_reg (regs, dsc, 2);
5657   dsc->tmp[3] = displaced_read_reg (regs, dsc, 3);
5658
5659   pc_val = displaced_read_reg (regs, dsc, ARM_PC_REGNUM);
5660
5661   pc_val = pc_val & 0xfffffffc;
5662
5663   displaced_write_reg (regs, dsc, 2, pc_val, CANNOT_WRITE_PC);
5664   displaced_write_reg (regs, dsc, 3, imm12, CANNOT_WRITE_PC);
5665
5666   dsc->rd = rt;
5667
5668   dsc->u.ldst.xfersize = size;
5669   dsc->u.ldst.immed = 0;
5670   dsc->u.ldst.writeback = 0;
5671   dsc->u.ldst.restore_r4 = 0;
5672
5673   /* LDR R0, R2, R3 */
5674   dsc->modinsn[0] = 0xf852;
5675   dsc->modinsn[1] = 0x3;
5676   dsc->numinsns = 2;
5677
5678   dsc->cleanup = &cleanup_load;
5679
5680   return 0;
5681 }
5682
5683 static int
5684 thumb2_copy_load_reg_imm (struct gdbarch *gdbarch, uint16_t insn1,
5685                           uint16_t insn2, struct regcache *regs,
5686                           arm_displaced_step_closure *dsc,
5687                           int writeback, int immed)
5688 {
5689   unsigned int rt = bits (insn2, 12, 15);
5690   unsigned int rn = bits (insn1, 0, 3);
5691   unsigned int rm = bits (insn2, 0, 3);  /* Only valid if !immed.  */
5692   /* In LDR (register), there is also a register Rm, which is not allowed to
5693      be PC, so we don't have to check it.  */
5694
5695   if (rt != ARM_PC_REGNUM && rn != ARM_PC_REGNUM)
5696     return thumb_copy_unmodified_32bit (gdbarch, insn1, insn2, "load",
5697                                         dsc);
5698
5699   if (debug_displaced)
5700     fprintf_unfiltered (gdb_stdlog,
5701                         "displaced: copying ldr r%d [r%d] insn %.4x%.4x\n",
5702                          rt, rn, insn1, insn2);
5703
5704   install_load_store (gdbarch, regs, dsc, 1, immed, writeback, 4,
5705                       0, rt, rm, rn);
5706
5707   dsc->u.ldst.restore_r4 = 0;
5708
5709   if (immed)
5710     /* ldr[b]<cond> rt, [rn, #imm], etc.
5711        ->
5712        ldr[b]<cond> r0, [r2, #imm].  */
5713     {
5714       dsc->modinsn[0] = (insn1 & 0xfff0) | 0x2;
5715       dsc->modinsn[1] = insn2 & 0x0fff;
5716     }
5717   else
5718     /* ldr[b]<cond> rt, [rn, rm], etc.
5719        ->
5720        ldr[b]<cond> r0, [r2, r3].  */
5721     {
5722       dsc->modinsn[0] = (insn1 & 0xfff0) | 0x2;
5723       dsc->modinsn[1] = (insn2 & 0x0ff0) | 0x3;
5724     }
5725
5726   dsc->numinsns = 2;
5727
5728   return 0;
5729 }
5730
5731
5732 static int
5733 arm_copy_ldr_str_ldrb_strb (struct gdbarch *gdbarch, uint32_t insn,
5734                             struct regcache *regs,
5735                             arm_displaced_step_closure *dsc,
5736                             int load, int size, int usermode)
5737 {
5738   int immed = !bit (insn, 25);
5739   int writeback = (bit (insn, 24) == 0 || bit (insn, 21) != 0);
5740   unsigned int rt = bits (insn, 12, 15);
5741   unsigned int rn = bits (insn, 16, 19);
5742   unsigned int rm = bits (insn, 0, 3);  /* Only valid if !immed.  */
5743
5744   if (!insn_references_pc (insn, 0x000ff00ful))
5745     return arm_copy_unmodified (gdbarch, insn, "load/store", dsc);
5746
5747   if (debug_displaced)
5748     fprintf_unfiltered (gdb_stdlog,
5749                         "displaced: copying %s%s r%d [r%d] insn %.8lx\n",
5750                         load ? (size == 1 ? "ldrb" : "ldr")
5751                              : (size == 1 ? "strb" : "str"), usermode ? "t" : "",
5752                         rt, rn,
5753                         (unsigned long) insn);
5754
5755   install_load_store (gdbarch, regs, dsc, load, immed, writeback, size,
5756                       usermode, rt, rm, rn);
5757
5758   if (load || rt != ARM_PC_REGNUM)
5759     {
5760       dsc->u.ldst.restore_r4 = 0;
5761
5762       if (immed)
5763         /* {ldr,str}[b]<cond> rt, [rn, #imm], etc.
5764            ->
5765            {ldr,str}[b]<cond> r0, [r2, #imm].  */
5766         dsc->modinsn[0] = (insn & 0xfff00fff) | 0x20000;
5767       else
5768         /* {ldr,str}[b]<cond> rt, [rn, rm], etc.
5769            ->
5770            {ldr,str}[b]<cond> r0, [r2, r3].  */
5771         dsc->modinsn[0] = (insn & 0xfff00ff0) | 0x20003;
5772     }
5773   else
5774     {
5775       /* We need to use r4 as scratch.  Make sure it's restored afterwards.  */
5776       dsc->u.ldst.restore_r4 = 1;
5777       dsc->modinsn[0] = 0xe92d8000;  /* push {pc} */
5778       dsc->modinsn[1] = 0xe8bd0010;  /* pop  {r4} */
5779       dsc->modinsn[2] = 0xe044400f;  /* sub r4, r4, pc.  */
5780       dsc->modinsn[3] = 0xe2844008;  /* add r4, r4, #8.  */
5781       dsc->modinsn[4] = 0xe0800004;  /* add r0, r0, r4.  */
5782
5783       /* As above.  */
5784       if (immed)
5785         dsc->modinsn[5] = (insn & 0xfff00fff) | 0x20000;
5786       else
5787         dsc->modinsn[5] = (insn & 0xfff00ff0) | 0x20003;
5788
5789       dsc->numinsns = 6;
5790     }
5791
5792   dsc->cleanup = load ? &cleanup_load : &cleanup_store;
5793
5794   return 0;
5795 }
5796
5797 /* Cleanup LDM instructions with fully-populated register list.  This is an
5798    unfortunate corner case: it's impossible to implement correctly by modifying
5799    the instruction.  The issue is as follows: we have an instruction,
5800
5801    ldm rN, {r0-r15}
5802
5803    which we must rewrite to avoid loading PC.  A possible solution would be to
5804    do the load in two halves, something like (with suitable cleanup
5805    afterwards):
5806
5807    mov r8, rN
5808    ldm[id][ab] r8!, {r0-r7}
5809    str r7, <temp>
5810    ldm[id][ab] r8, {r7-r14}
5811    <bkpt>
5812
5813    but at present there's no suitable place for <temp>, since the scratch space
5814    is overwritten before the cleanup routine is called.  For now, we simply
5815    emulate the instruction.  */
5816
5817 static void
5818 cleanup_block_load_all (struct gdbarch *gdbarch, struct regcache *regs,
5819                         arm_displaced_step_closure *dsc)
5820 {
5821   int inc = dsc->u.block.increment;
5822   int bump_before = dsc->u.block.before ? (inc ? 4 : -4) : 0;
5823   int bump_after = dsc->u.block.before ? 0 : (inc ? 4 : -4);
5824   uint32_t regmask = dsc->u.block.regmask;
5825   int regno = inc ? 0 : 15;
5826   CORE_ADDR xfer_addr = dsc->u.block.xfer_addr;
5827   int exception_return = dsc->u.block.load && dsc->u.block.user
5828                          && (regmask & 0x8000) != 0;
5829   uint32_t status = displaced_read_reg (regs, dsc, ARM_PS_REGNUM);
5830   int do_transfer = condition_true (dsc->u.block.cond, status);
5831   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
5832
5833   if (!do_transfer)
5834     return;
5835
5836   /* If the instruction is ldm rN, {...pc}^, I don't think there's anything
5837      sensible we can do here.  Complain loudly.  */
5838   if (exception_return)
5839     error (_("Cannot single-step exception return"));
5840
5841   /* We don't handle any stores here for now.  */
5842   gdb_assert (dsc->u.block.load != 0);
5843
5844   if (debug_displaced)
5845     fprintf_unfiltered (gdb_stdlog, "displaced: emulating block transfer: "
5846                         "%s %s %s\n", dsc->u.block.load ? "ldm" : "stm",
5847                         dsc->u.block.increment ? "inc" : "dec",
5848                         dsc->u.block.before ? "before" : "after");
5849
5850   while (regmask)
5851     {
5852       uint32_t memword;
5853
5854       if (inc)
5855         while (regno <= ARM_PC_REGNUM && (regmask & (1 << regno)) == 0)
5856           regno++;
5857       else
5858         while (regno >= 0 && (regmask & (1 << regno)) == 0)
5859           regno--;
5860
5861       xfer_addr += bump_before;
5862
5863       memword = read_memory_unsigned_integer (xfer_addr, 4, byte_order);
5864       displaced_write_reg (regs, dsc, regno, memword, LOAD_WRITE_PC);
5865
5866       xfer_addr += bump_after;
5867
5868       regmask &= ~(1 << regno);
5869     }
5870
5871   if (dsc->u.block.writeback)
5872     displaced_write_reg (regs, dsc, dsc->u.block.rn, xfer_addr,
5873                          CANNOT_WRITE_PC);
5874 }
5875
5876 /* Clean up an STM which included the PC in the register list.  */
5877
5878 static void
5879 cleanup_block_store_pc (struct gdbarch *gdbarch, struct regcache *regs,
5880                         arm_displaced_step_closure *dsc)
5881 {
5882   uint32_t status = displaced_read_reg (regs, dsc, ARM_PS_REGNUM);
5883   int store_executed = condition_true (dsc->u.block.cond, status);
5884   CORE_ADDR pc_stored_at, transferred_regs = bitcount (dsc->u.block.regmask);
5885   CORE_ADDR stm_insn_addr;
5886   uint32_t pc_val;
5887   long offset;
5888   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
5889
5890   /* If condition code fails, there's nothing else to do.  */
5891   if (!store_executed)
5892     return;
5893
5894   if (dsc->u.block.increment)
5895     {
5896       pc_stored_at = dsc->u.block.xfer_addr + 4 * transferred_regs;
5897
5898       if (dsc->u.block.before)
5899          pc_stored_at += 4;
5900     }
5901   else
5902     {
5903       pc_stored_at = dsc->u.block.xfer_addr;
5904
5905       if (dsc->u.block.before)
5906          pc_stored_at -= 4;
5907     }
5908
5909   pc_val = read_memory_unsigned_integer (pc_stored_at, 4, byte_order);
5910   stm_insn_addr = dsc->scratch_base;
5911   offset = pc_val - stm_insn_addr;
5912
5913   if (debug_displaced)
5914     fprintf_unfiltered (gdb_stdlog, "displaced: detected PC offset %.8lx for "
5915                         "STM instruction\n", offset);
5916
5917   /* Rewrite the stored PC to the proper value for the non-displaced original
5918      instruction.  */
5919   write_memory_unsigned_integer (pc_stored_at, 4, byte_order,
5920                                  dsc->insn_addr + offset);
5921 }
5922
5923 /* Clean up an LDM which includes the PC in the register list.  We clumped all
5924    the registers in the transferred list into a contiguous range r0...rX (to
5925    avoid loading PC directly and losing control of the debugged program), so we
5926    must undo that here.  */
5927
5928 static void
5929 cleanup_block_load_pc (struct gdbarch *gdbarch,
5930                        struct regcache *regs,
5931                        arm_displaced_step_closure *dsc)
5932 {
5933   uint32_t status = displaced_read_reg (regs, dsc, ARM_PS_REGNUM);
5934   int load_executed = condition_true (dsc->u.block.cond, status);
5935   unsigned int mask = dsc->u.block.regmask, write_reg = ARM_PC_REGNUM;
5936   unsigned int regs_loaded = bitcount (mask);
5937   unsigned int num_to_shuffle = regs_loaded, clobbered;
5938
5939   /* The method employed here will fail if the register list is fully populated
5940      (we need to avoid loading PC directly).  */
5941   gdb_assert (num_to_shuffle < 16);
5942
5943   if (!load_executed)
5944     return;
5945
5946   clobbered = (1 << num_to_shuffle) - 1;
5947
5948   while (num_to_shuffle > 0)
5949     {
5950       if ((mask & (1 << write_reg)) != 0)
5951         {
5952           unsigned int read_reg = num_to_shuffle - 1;
5953
5954           if (read_reg != write_reg)
5955             {
5956               ULONGEST rval = displaced_read_reg (regs, dsc, read_reg);
5957               displaced_write_reg (regs, dsc, write_reg, rval, LOAD_WRITE_PC);
5958               if (debug_displaced)
5959                 fprintf_unfiltered (gdb_stdlog, _("displaced: LDM: move "
5960                                     "loaded register r%d to r%d\n"), read_reg,
5961                                     write_reg);
5962             }
5963           else if (debug_displaced)
5964             fprintf_unfiltered (gdb_stdlog, _("displaced: LDM: register "
5965                                 "r%d already in the right place\n"),
5966                                 write_reg);
5967
5968           clobbered &= ~(1 << write_reg);
5969
5970           num_to_shuffle--;
5971         }
5972
5973       write_reg--;
5974     }
5975
5976   /* Restore any registers we scribbled over.  */
5977   for (write_reg = 0; clobbered != 0; write_reg++)
5978     {
5979       if ((clobbered & (1 << write_reg)) != 0)
5980         {
5981           displaced_write_reg (regs, dsc, write_reg, dsc->tmp[write_reg],
5982                                CANNOT_WRITE_PC);
5983           if (debug_displaced)
5984             fprintf_unfiltered (gdb_stdlog, _("displaced: LDM: restored "
5985                                 "clobbered register r%d\n"), write_reg);
5986           clobbered &= ~(1 << write_reg);
5987         }
5988     }
5989
5990   /* Perform register writeback manually.  */
5991   if (dsc->u.block.writeback)
5992     {
5993       ULONGEST new_rn_val = dsc->u.block.xfer_addr;
5994
5995       if (dsc->u.block.increment)
5996         new_rn_val += regs_loaded * 4;
5997       else
5998         new_rn_val -= regs_loaded * 4;
5999
6000       displaced_write_reg (regs, dsc, dsc->u.block.rn, new_rn_val,
6001                            CANNOT_WRITE_PC);
6002     }
6003 }
6004
6005 /* Handle ldm/stm, apart from some tricky cases which are unlikely to occur
6006    in user-level code (in particular exception return, ldm rn, {...pc}^).  */
6007
6008 static int
6009 arm_copy_block_xfer (struct gdbarch *gdbarch, uint32_t insn,
6010                      struct regcache *regs,
6011                      arm_displaced_step_closure *dsc)
6012 {
6013   int load = bit (insn, 20);
6014   int user = bit (insn, 22);
6015   int increment = bit (insn, 23);
6016   int before = bit (insn, 24);
6017   int writeback = bit (insn, 21);
6018   int rn = bits (insn, 16, 19);
6019
6020   /* Block transfers which don't mention PC can be run directly
6021      out-of-line.  */
6022   if (rn != ARM_PC_REGNUM && (insn & 0x8000) == 0)
6023     return arm_copy_unmodified (gdbarch, insn, "ldm/stm", dsc);
6024
6025   if (rn == ARM_PC_REGNUM)
6026     {
6027       warning (_("displaced: Unpredictable LDM or STM with "
6028                  "base register r15"));
6029       return arm_copy_unmodified (gdbarch, insn, "unpredictable ldm/stm", dsc);
6030     }
6031
6032   if (debug_displaced)
6033     fprintf_unfiltered (gdb_stdlog, "displaced: copying block transfer insn "
6034                         "%.8lx\n", (unsigned long) insn);
6035
6036   dsc->u.block.xfer_addr = displaced_read_reg (regs, dsc, rn);
6037   dsc->u.block.rn = rn;
6038
6039   dsc->u.block.load = load;
6040   dsc->u.block.user = user;
6041   dsc->u.block.increment = increment;
6042   dsc->u.block.before = before;
6043   dsc->u.block.writeback = writeback;
6044   dsc->u.block.cond = bits (insn, 28, 31);
6045
6046   dsc->u.block.regmask = insn & 0xffff;
6047
6048   if (load)
6049     {
6050       if ((insn & 0xffff) == 0xffff)
6051         {
6052           /* LDM with a fully-populated register list.  This case is
6053              particularly tricky.  Implement for now by fully emulating the
6054              instruction (which might not behave perfectly in all cases, but
6055              these instructions should be rare enough for that not to matter
6056              too much).  */
6057           dsc->modinsn[0] = ARM_NOP;
6058
6059           dsc->cleanup = &cleanup_block_load_all;
6060         }
6061       else
6062         {
6063           /* LDM of a list of registers which includes PC.  Implement by
6064              rewriting the list of registers to be transferred into a
6065              contiguous chunk r0...rX before doing the transfer, then shuffling
6066              registers into the correct places in the cleanup routine.  */
6067           unsigned int regmask = insn & 0xffff;
6068           unsigned int num_in_list = bitcount (regmask), new_regmask;
6069           unsigned int i;
6070
6071           for (i = 0; i < num_in_list; i++)
6072             dsc->tmp[i] = displaced_read_reg (regs, dsc, i);
6073
6074           /* Writeback makes things complicated.  We need to avoid clobbering
6075              the base register with one of the registers in our modified
6076              register list, but just using a different register can't work in
6077              all cases, e.g.:
6078
6079                ldm r14!, {r0-r13,pc}
6080
6081              which would need to be rewritten as:
6082
6083                ldm rN!, {r0-r14}
6084
6085              but that can't work, because there's no free register for N.
6086
6087              Solve this by turning off the writeback bit, and emulating
6088              writeback manually in the cleanup routine.  */
6089
6090           if (writeback)
6091             insn &= ~(1 << 21);
6092
6093           new_regmask = (1 << num_in_list) - 1;
6094
6095           if (debug_displaced)
6096             fprintf_unfiltered (gdb_stdlog, _("displaced: LDM r%d%s, "
6097                                 "{..., pc}: original reg list %.4x, modified "
6098                                 "list %.4x\n"), rn, writeback ? "!" : "",
6099                                 (int) insn & 0xffff, new_regmask);
6100
6101           dsc->modinsn[0] = (insn & ~0xffff) | (new_regmask & 0xffff);
6102
6103           dsc->cleanup = &cleanup_block_load_pc;
6104         }
6105     }
6106   else
6107     {
6108       /* STM of a list of registers which includes PC.  Run the instruction
6109          as-is, but out of line: this will store the wrong value for the PC,
6110          so we must manually fix up the memory in the cleanup routine.
6111          Doing things this way has the advantage that we can auto-detect
6112          the offset of the PC write (which is architecture-dependent) in
6113          the cleanup routine.  */
6114       dsc->modinsn[0] = insn;
6115
6116       dsc->cleanup = &cleanup_block_store_pc;
6117     }
6118
6119   return 0;
6120 }
6121
6122 static int
6123 thumb2_copy_block_xfer (struct gdbarch *gdbarch, uint16_t insn1, uint16_t insn2,
6124                         struct regcache *regs,
6125                         arm_displaced_step_closure *dsc)
6126 {
6127   int rn = bits (insn1, 0, 3);
6128   int load = bit (insn1, 4);
6129   int writeback = bit (insn1, 5);
6130
6131   /* Block transfers which don't mention PC can be run directly
6132      out-of-line.  */
6133   if (rn != ARM_PC_REGNUM && (insn2 & 0x8000) == 0)
6134     return thumb_copy_unmodified_32bit (gdbarch, insn1, insn2, "ldm/stm", dsc);
6135
6136   if (rn == ARM_PC_REGNUM)
6137     {
6138       warning (_("displaced: Unpredictable LDM or STM with "
6139                  "base register r15"));
6140       return thumb_copy_unmodified_32bit (gdbarch, insn1, insn2,
6141                                           "unpredictable ldm/stm", dsc);
6142     }
6143
6144   if (debug_displaced)
6145     fprintf_unfiltered (gdb_stdlog, "displaced: copying block transfer insn "
6146                         "%.4x%.4x\n", insn1, insn2);
6147
6148   /* Clear bit 13, since it should be always zero.  */
6149   dsc->u.block.regmask = (insn2 & 0xdfff);
6150   dsc->u.block.rn = rn;
6151
6152   dsc->u.block.load = load;
6153   dsc->u.block.user = 0;
6154   dsc->u.block.increment = bit (insn1, 7);
6155   dsc->u.block.before = bit (insn1, 8);
6156   dsc->u.block.writeback = writeback;
6157   dsc->u.block.cond = INST_AL;
6158   dsc->u.block.xfer_addr = displaced_read_reg (regs, dsc, rn);
6159
6160   if (load)
6161     {
6162       if (dsc->u.block.regmask == 0xffff)
6163         {
6164           /* This branch is impossible to happen.  */
6165           gdb_assert (0);
6166         }
6167       else
6168         {
6169           unsigned int regmask = dsc->u.block.regmask;
6170           unsigned int num_in_list = bitcount (regmask), new_regmask;
6171           unsigned int i;
6172
6173           for (i = 0; i < num_in_list; i++)
6174             dsc->tmp[i] = displaced_read_reg (regs, dsc, i);
6175
6176           if (writeback)
6177             insn1 &= ~(1 << 5);
6178
6179           new_regmask = (1 << num_in_list) - 1;
6180
6181           if (debug_displaced)
6182             fprintf_unfiltered (gdb_stdlog, _("displaced: LDM r%d%s, "
6183                                 "{..., pc}: original reg list %.4x, modified "
6184                                 "list %.4x\n"), rn, writeback ? "!" : "",
6185                                 (int) dsc->u.block.regmask, new_regmask);
6186
6187           dsc->modinsn[0] = insn1;
6188           dsc->modinsn[1] = (new_regmask & 0xffff);
6189           dsc->numinsns = 2;
6190
6191           dsc->cleanup = &cleanup_block_load_pc;
6192         }
6193     }
6194   else
6195     {
6196       dsc->modinsn[0] = insn1;
6197       dsc->modinsn[1] = insn2;
6198       dsc->numinsns = 2;
6199       dsc->cleanup = &cleanup_block_store_pc;
6200     }
6201   return 0;
6202 }
6203
6204 /* Wrapper over read_memory_unsigned_integer for use in arm_get_next_pcs.
6205  This is used to avoid a dependency on BFD's bfd_endian enum.  */
6206
6207 ULONGEST
6208 arm_get_next_pcs_read_memory_unsigned_integer (CORE_ADDR memaddr, int len,
6209                                                int byte_order)
6210 {
6211   return read_memory_unsigned_integer (memaddr, len,
6212                                        (enum bfd_endian) byte_order);
6213 }
6214
6215 /* Wrapper over gdbarch_addr_bits_remove for use in arm_get_next_pcs.  */
6216
6217 CORE_ADDR
6218 arm_get_next_pcs_addr_bits_remove (struct arm_get_next_pcs *self,
6219                                    CORE_ADDR val)
6220 {
6221   return gdbarch_addr_bits_remove (self->regcache->arch (), val);
6222 }
6223
6224 /* Wrapper over syscall_next_pc for use in get_next_pcs.  */
6225
6226 static CORE_ADDR
6227 arm_get_next_pcs_syscall_next_pc (struct arm_get_next_pcs *self)
6228 {
6229   return 0;
6230 }
6231
6232 /* Wrapper over arm_is_thumb for use in arm_get_next_pcs.  */
6233
6234 int
6235 arm_get_next_pcs_is_thumb (struct arm_get_next_pcs *self)
6236 {
6237   return arm_is_thumb (self->regcache);
6238 }
6239
6240 /* single_step() is called just before we want to resume the inferior,
6241    if we want to single-step it but there is no hardware or kernel
6242    single-step support.  We find the target of the coming instructions
6243    and breakpoint them.  */
6244
6245 std::vector<CORE_ADDR>
6246 arm_software_single_step (struct regcache *regcache)
6247 {
6248   struct gdbarch *gdbarch = regcache->arch ();
6249   struct arm_get_next_pcs next_pcs_ctx;
6250
6251   arm_get_next_pcs_ctor (&next_pcs_ctx,
6252                          &arm_get_next_pcs_ops,
6253                          gdbarch_byte_order (gdbarch),
6254                          gdbarch_byte_order_for_code (gdbarch),
6255                          0,
6256                          regcache);
6257
6258   std::vector<CORE_ADDR> next_pcs = arm_get_next_pcs (&next_pcs_ctx);
6259
6260   for (CORE_ADDR &pc_ref : next_pcs)
6261     pc_ref = gdbarch_addr_bits_remove (gdbarch, pc_ref);
6262
6263   return next_pcs;
6264 }
6265
6266 /* Cleanup/copy SVC (SWI) instructions.  These two functions are overridden
6267    for Linux, where some SVC instructions must be treated specially.  */
6268
6269 static void
6270 cleanup_svc (struct gdbarch *gdbarch, struct regcache *regs,
6271              arm_displaced_step_closure *dsc)
6272 {
6273   CORE_ADDR resume_addr = dsc->insn_addr + dsc->insn_size;
6274
6275   if (debug_displaced)
6276     fprintf_unfiltered (gdb_stdlog, "displaced: cleanup for svc, resume at "
6277                         "%.8lx\n", (unsigned long) resume_addr);
6278
6279   displaced_write_reg (regs, dsc, ARM_PC_REGNUM, resume_addr, BRANCH_WRITE_PC);
6280 }
6281
6282
6283 /* Common copy routine for svc instruciton.  */
6284
6285 static int
6286 install_svc (struct gdbarch *gdbarch, struct regcache *regs,
6287              arm_displaced_step_closure *dsc)
6288 {
6289   /* Preparation: none.
6290      Insn: unmodified svc.
6291      Cleanup: pc <- insn_addr + insn_size.  */
6292
6293   /* Pretend we wrote to the PC, so cleanup doesn't set PC to the next
6294      instruction.  */
6295   dsc->wrote_to_pc = 1;
6296
6297   /* Allow OS-specific code to override SVC handling.  */
6298   if (dsc->u.svc.copy_svc_os)
6299     return dsc->u.svc.copy_svc_os (gdbarch, regs, dsc);
6300   else
6301     {
6302       dsc->cleanup = &cleanup_svc;
6303       return 0;
6304     }
6305 }
6306
6307 static int
6308 arm_copy_svc (struct gdbarch *gdbarch, uint32_t insn,
6309               struct regcache *regs, arm_displaced_step_closure *dsc)
6310 {
6311
6312   if (debug_displaced)
6313     fprintf_unfiltered (gdb_stdlog, "displaced: copying svc insn %.8lx\n",
6314                         (unsigned long) insn);
6315
6316   dsc->modinsn[0] = insn;
6317
6318   return install_svc (gdbarch, regs, dsc);
6319 }
6320
6321 static int
6322 thumb_copy_svc (struct gdbarch *gdbarch, uint16_t insn,
6323                 struct regcache *regs, arm_displaced_step_closure *dsc)
6324 {
6325
6326   if (debug_displaced)
6327     fprintf_unfiltered (gdb_stdlog, "displaced: copying svc insn %.4x\n",
6328                         insn);
6329
6330   dsc->modinsn[0] = insn;
6331
6332   return install_svc (gdbarch, regs, dsc);
6333 }
6334
6335 /* Copy undefined instructions.  */
6336
6337 static int
6338 arm_copy_undef (struct gdbarch *gdbarch, uint32_t insn,
6339                 arm_displaced_step_closure *dsc)
6340 {
6341   if (debug_displaced)
6342     fprintf_unfiltered (gdb_stdlog,
6343                         "displaced: copying undefined insn %.8lx\n",
6344                         (unsigned long) insn);
6345
6346   dsc->modinsn[0] = insn;
6347
6348   return 0;
6349 }
6350
6351 static int
6352 thumb_32bit_copy_undef (struct gdbarch *gdbarch, uint16_t insn1, uint16_t insn2,
6353                        arm_displaced_step_closure *dsc)
6354 {
6355
6356   if (debug_displaced)
6357     fprintf_unfiltered (gdb_stdlog, "displaced: copying undefined insn "
6358                        "%.4x %.4x\n", (unsigned short) insn1,
6359                        (unsigned short) insn2);
6360
6361   dsc->modinsn[0] = insn1;
6362   dsc->modinsn[1] = insn2;
6363   dsc->numinsns = 2;
6364
6365   return 0;
6366 }
6367
6368 /* Copy unpredictable instructions.  */
6369
6370 static int
6371 arm_copy_unpred (struct gdbarch *gdbarch, uint32_t insn,
6372                  arm_displaced_step_closure *dsc)
6373 {
6374   if (debug_displaced)
6375     fprintf_unfiltered (gdb_stdlog, "displaced: copying unpredictable insn "
6376                         "%.8lx\n", (unsigned long) insn);
6377
6378   dsc->modinsn[0] = insn;
6379
6380   return 0;
6381 }
6382
6383 /* The decode_* functions are instruction decoding helpers.  They mostly follow
6384    the presentation in the ARM ARM.  */
6385
6386 static int
6387 arm_decode_misc_memhint_neon (struct gdbarch *gdbarch, uint32_t insn,
6388                               struct regcache *regs,
6389                               arm_displaced_step_closure *dsc)
6390 {
6391   unsigned int op1 = bits (insn, 20, 26), op2 = bits (insn, 4, 7);
6392   unsigned int rn = bits (insn, 16, 19);
6393
6394   if (op1 == 0x10 && (op2 & 0x2) == 0x0 && (rn & 0x1) == 0x0)
6395     return arm_copy_unmodified (gdbarch, insn, "cps", dsc);
6396   else if (op1 == 0x10 && op2 == 0x0 && (rn & 0x1) == 0x1)
6397     return arm_copy_unmodified (gdbarch, insn, "setend", dsc);
6398   else if ((op1 & 0x60) == 0x20)
6399     return arm_copy_unmodified (gdbarch, insn, "neon dataproc", dsc);
6400   else if ((op1 & 0x71) == 0x40)
6401     return arm_copy_unmodified (gdbarch, insn, "neon elt/struct load/store",
6402                                 dsc);
6403   else if ((op1 & 0x77) == 0x41)
6404     return arm_copy_unmodified (gdbarch, insn, "unallocated mem hint", dsc);
6405   else if ((op1 & 0x77) == 0x45)
6406     return arm_copy_preload (gdbarch, insn, regs, dsc);  /* pli.  */
6407   else if ((op1 & 0x77) == 0x51)
6408     {
6409       if (rn != 0xf)
6410         return arm_copy_preload (gdbarch, insn, regs, dsc);  /* pld/pldw.  */
6411       else
6412         return arm_copy_unpred (gdbarch, insn, dsc);
6413     }
6414   else if ((op1 & 0x77) == 0x55)
6415     return arm_copy_preload (gdbarch, insn, regs, dsc);  /* pld/pldw.  */
6416   else if (op1 == 0x57)
6417     switch (op2)
6418       {
6419       case 0x1: return arm_copy_unmodified (gdbarch, insn, "clrex", dsc);
6420       case 0x4: return arm_copy_unmodified (gdbarch, insn, "dsb", dsc);
6421       case 0x5: return arm_copy_unmodified (gdbarch, insn, "dmb", dsc);
6422       case 0x6: return arm_copy_unmodified (gdbarch, insn, "isb", dsc);
6423       default: return arm_copy_unpred (gdbarch, insn, dsc);
6424       }
6425   else if ((op1 & 0x63) == 0x43)
6426     return arm_copy_unpred (gdbarch, insn, dsc);
6427   else if ((op2 & 0x1) == 0x0)
6428     switch (op1 & ~0x80)
6429       {
6430       case 0x61:
6431         return arm_copy_unmodified (gdbarch, insn, "unallocated mem hint", dsc);
6432       case 0x65:
6433         return arm_copy_preload_reg (gdbarch, insn, regs, dsc);  /* pli reg.  */
6434       case 0x71: case 0x75:
6435         /* pld/pldw reg.  */
6436         return arm_copy_preload_reg (gdbarch, insn, regs, dsc);
6437       case 0x63: case 0x67: case 0x73: case 0x77:
6438         return arm_copy_unpred (gdbarch, insn, dsc);
6439       default:
6440         return arm_copy_undef (gdbarch, insn, dsc);
6441       }
6442   else
6443     return arm_copy_undef (gdbarch, insn, dsc);  /* Probably unreachable.  */
6444 }
6445
6446 static int
6447 arm_decode_unconditional (struct gdbarch *gdbarch, uint32_t insn,
6448                           struct regcache *regs,
6449                           arm_displaced_step_closure *dsc)
6450 {
6451   if (bit (insn, 27) == 0)
6452     return arm_decode_misc_memhint_neon (gdbarch, insn, regs, dsc);
6453   /* Switch on bits: 0bxxxxx321xxx0xxxxxxxxxxxxxxxxxxxx.  */
6454   else switch (((insn & 0x7000000) >> 23) | ((insn & 0x100000) >> 20))
6455     {
6456     case 0x0: case 0x2:
6457       return arm_copy_unmodified (gdbarch, insn, "srs", dsc);
6458
6459     case 0x1: case 0x3:
6460       return arm_copy_unmodified (gdbarch, insn, "rfe", dsc);
6461
6462     case 0x4: case 0x5: case 0x6: case 0x7:
6463       return arm_copy_b_bl_blx (gdbarch, insn, regs, dsc);
6464
6465     case 0x8:
6466       switch ((insn & 0xe00000) >> 21)
6467         {
6468         case 0x1: case 0x3: case 0x4: case 0x5: case 0x6: case 0x7:
6469           /* stc/stc2.  */
6470           return arm_copy_copro_load_store (gdbarch, insn, regs, dsc);
6471
6472         case 0x2:
6473           return arm_copy_unmodified (gdbarch, insn, "mcrr/mcrr2", dsc);
6474
6475         default:
6476           return arm_copy_undef (gdbarch, insn, dsc);
6477         }
6478
6479     case 0x9:
6480       {
6481          int rn_f = (bits (insn, 16, 19) == 0xf);
6482         switch ((insn & 0xe00000) >> 21)
6483           {
6484           case 0x1: case 0x3:
6485             /* ldc/ldc2 imm (undefined for rn == pc).  */
6486             return rn_f ? arm_copy_undef (gdbarch, insn, dsc)
6487                         : arm_copy_copro_load_store (gdbarch, insn, regs, dsc);
6488
6489           case 0x2:
6490             return arm_copy_unmodified (gdbarch, insn, "mrrc/mrrc2", dsc);
6491
6492           case 0x4: case 0x5: case 0x6: case 0x7:
6493             /* ldc/ldc2 lit (undefined for rn != pc).  */
6494             return rn_f ? arm_copy_copro_load_store (gdbarch, insn, regs, dsc)
6495                         : arm_copy_undef (gdbarch, insn, dsc);
6496
6497           default:
6498             return arm_copy_undef (gdbarch, insn, dsc);
6499           }
6500       }
6501
6502     case 0xa:
6503       return arm_copy_unmodified (gdbarch, insn, "stc/stc2", dsc);
6504
6505     case 0xb:
6506       if (bits (insn, 16, 19) == 0xf)
6507         /* ldc/ldc2 lit.  */
6508         return arm_copy_copro_load_store (gdbarch, insn, regs, dsc);
6509       else
6510         return arm_copy_undef (gdbarch, insn, dsc);
6511
6512     case 0xc:
6513       if (bit (insn, 4))
6514         return arm_copy_unmodified (gdbarch, insn, "mcr/mcr2", dsc);
6515       else
6516         return arm_copy_unmodified (gdbarch, insn, "cdp/cdp2", dsc);
6517
6518     case 0xd:
6519       if (bit (insn, 4))
6520         return arm_copy_unmodified (gdbarch, insn, "mrc/mrc2", dsc);
6521       else
6522         return arm_copy_unmodified (gdbarch, insn, "cdp/cdp2", dsc);
6523
6524     default:
6525       return arm_copy_undef (gdbarch, insn, dsc);
6526     }
6527 }
6528
6529 /* Decode miscellaneous instructions in dp/misc encoding space.  */
6530
6531 static int
6532 arm_decode_miscellaneous (struct gdbarch *gdbarch, uint32_t insn,
6533                           struct regcache *regs,
6534                           arm_displaced_step_closure *dsc)
6535 {
6536   unsigned int op2 = bits (insn, 4, 6);
6537   unsigned int op = bits (insn, 21, 22);
6538
6539   switch (op2)
6540     {
6541     case 0x0:
6542       return arm_copy_unmodified (gdbarch, insn, "mrs/msr", dsc);
6543
6544     case 0x1:
6545       if (op == 0x1)  /* bx.  */
6546         return arm_copy_bx_blx_reg (gdbarch, insn, regs, dsc);
6547       else if (op == 0x3)
6548         return arm_copy_unmodified (gdbarch, insn, "clz", dsc);
6549       else
6550         return arm_copy_undef (gdbarch, insn, dsc);
6551
6552     case 0x2:
6553       if (op == 0x1)
6554         /* Not really supported.  */
6555         return arm_copy_unmodified (gdbarch, insn, "bxj", dsc);
6556       else
6557         return arm_copy_undef (gdbarch, insn, dsc);
6558
6559     case 0x3:
6560       if (op == 0x1)
6561         return arm_copy_bx_blx_reg (gdbarch, insn,
6562                                 regs, dsc);  /* blx register.  */
6563       else
6564         return arm_copy_undef (gdbarch, insn, dsc);
6565
6566     case 0x5:
6567       return arm_copy_unmodified (gdbarch, insn, "saturating add/sub", dsc);
6568
6569     case 0x7:
6570       if (op == 0x1)
6571         return arm_copy_unmodified (gdbarch, insn, "bkpt", dsc);
6572       else if (op == 0x3)
6573         /* Not really supported.  */
6574         return arm_copy_unmodified (gdbarch, insn, "smc", dsc);
6575       /* Fall through.  */
6576
6577     default:
6578       return arm_copy_undef (gdbarch, insn, dsc);
6579     }
6580 }
6581
6582 static int
6583 arm_decode_dp_misc (struct gdbarch *gdbarch, uint32_t insn,
6584                     struct regcache *regs,
6585                     arm_displaced_step_closure *dsc)
6586 {
6587   if (bit (insn, 25))
6588     switch (bits (insn, 20, 24))
6589       {
6590       case 0x10:
6591         return arm_copy_unmodified (gdbarch, insn, "movw", dsc);
6592
6593       case 0x14:
6594         return arm_copy_unmodified (gdbarch, insn, "movt", dsc);
6595
6596       case 0x12: case 0x16:
6597         return arm_copy_unmodified (gdbarch, insn, "msr imm", dsc);
6598
6599       default:
6600         return arm_copy_alu_imm (gdbarch, insn, regs, dsc);
6601       }
6602   else
6603     {
6604       uint32_t op1 = bits (insn, 20, 24), op2 = bits (insn, 4, 7);
6605
6606       if ((op1 & 0x19) != 0x10 && (op2 & 0x1) == 0x0)
6607         return arm_copy_alu_reg (gdbarch, insn, regs, dsc);
6608       else if ((op1 & 0x19) != 0x10 && (op2 & 0x9) == 0x1)
6609         return arm_copy_alu_shifted_reg (gdbarch, insn, regs, dsc);
6610       else if ((op1 & 0x19) == 0x10 && (op2 & 0x8) == 0x0)
6611         return arm_decode_miscellaneous (gdbarch, insn, regs, dsc);
6612       else if ((op1 & 0x19) == 0x10 && (op2 & 0x9) == 0x8)
6613         return arm_copy_unmodified (gdbarch, insn, "halfword mul/mla", dsc);
6614       else if ((op1 & 0x10) == 0x00 && op2 == 0x9)
6615         return arm_copy_unmodified (gdbarch, insn, "mul/mla", dsc);
6616       else if ((op1 & 0x10) == 0x10 && op2 == 0x9)
6617         return arm_copy_unmodified (gdbarch, insn, "synch", dsc);
6618       else if (op2 == 0xb || (op2 & 0xd) == 0xd)
6619         /* 2nd arg means "unprivileged".  */
6620         return arm_copy_extra_ld_st (gdbarch, insn, (op1 & 0x12) == 0x02, regs,
6621                                      dsc);
6622     }
6623
6624   /* Should be unreachable.  */
6625   return 1;
6626 }
6627
6628 static int
6629 arm_decode_ld_st_word_ubyte (struct gdbarch *gdbarch, uint32_t insn,
6630                              struct regcache *regs,
6631                              arm_displaced_step_closure *dsc)
6632 {
6633   int a = bit (insn, 25), b = bit (insn, 4);
6634   uint32_t op1 = bits (insn, 20, 24);
6635
6636   if ((!a && (op1 & 0x05) == 0x00 && (op1 & 0x17) != 0x02)
6637       || (a && (op1 & 0x05) == 0x00 && (op1 & 0x17) != 0x02 && !b))
6638     return arm_copy_ldr_str_ldrb_strb (gdbarch, insn, regs, dsc, 0, 4, 0);
6639   else if ((!a && (op1 & 0x17) == 0x02)
6640             || (a && (op1 & 0x17) == 0x02 && !b))
6641     return arm_copy_ldr_str_ldrb_strb (gdbarch, insn, regs, dsc, 0, 4, 1);
6642   else if ((!a && (op1 & 0x05) == 0x01 && (op1 & 0x17) != 0x03)
6643             || (a && (op1 & 0x05) == 0x01 && (op1 & 0x17) != 0x03 && !b))
6644     return arm_copy_ldr_str_ldrb_strb (gdbarch, insn, regs, dsc, 1, 4, 0);
6645   else if ((!a && (op1 & 0x17) == 0x03)
6646            || (a && (op1 & 0x17) == 0x03 && !b))
6647     return arm_copy_ldr_str_ldrb_strb (gdbarch, insn, regs, dsc, 1, 4, 1);
6648   else if ((!a && (op1 & 0x05) == 0x04 && (op1 & 0x17) != 0x06)
6649             || (a && (op1 & 0x05) == 0x04 && (op1 & 0x17) != 0x06 && !b))
6650     return arm_copy_ldr_str_ldrb_strb (gdbarch, insn, regs, dsc, 0, 1, 0);
6651   else if ((!a && (op1 & 0x17) == 0x06)
6652            || (a && (op1 & 0x17) == 0x06 && !b))
6653     return arm_copy_ldr_str_ldrb_strb (gdbarch, insn, regs, dsc, 0, 1, 1);
6654   else if ((!a && (op1 & 0x05) == 0x05 && (op1 & 0x17) != 0x07)
6655            || (a && (op1 & 0x05) == 0x05 && (op1 & 0x17) != 0x07 && !b))
6656     return arm_copy_ldr_str_ldrb_strb (gdbarch, insn, regs, dsc, 1, 1, 0);
6657   else if ((!a && (op1 & 0x17) == 0x07)
6658            || (a && (op1 & 0x17) == 0x07 && !b))
6659     return arm_copy_ldr_str_ldrb_strb (gdbarch, insn, regs, dsc, 1, 1, 1);
6660
6661   /* Should be unreachable.  */
6662   return 1;
6663 }
6664
6665 static int
6666 arm_decode_media (struct gdbarch *gdbarch, uint32_t insn,
6667                   arm_displaced_step_closure *dsc)
6668 {
6669   switch (bits (insn, 20, 24))
6670     {
6671     case 0x00: case 0x01: case 0x02: case 0x03:
6672       return arm_copy_unmodified (gdbarch, insn, "parallel add/sub signed", dsc);
6673
6674     case 0x04: case 0x05: case 0x06: case 0x07:
6675       return arm_copy_unmodified (gdbarch, insn, "parallel add/sub unsigned", dsc);
6676
6677     case 0x08: case 0x09: case 0x0a: case 0x0b:
6678     case 0x0c: case 0x0d: case 0x0e: case 0x0f:
6679       return arm_copy_unmodified (gdbarch, insn,
6680                               "decode/pack/unpack/saturate/reverse", dsc);
6681
6682     case 0x18:
6683       if (bits (insn, 5, 7) == 0)  /* op2.  */
6684          {
6685           if (bits (insn, 12, 15) == 0xf)
6686             return arm_copy_unmodified (gdbarch, insn, "usad8", dsc);
6687           else
6688             return arm_copy_unmodified (gdbarch, insn, "usada8", dsc);
6689         }
6690       else
6691          return arm_copy_undef (gdbarch, insn, dsc);
6692
6693     case 0x1a: case 0x1b:
6694       if (bits (insn, 5, 6) == 0x2)  /* op2[1:0].  */
6695         return arm_copy_unmodified (gdbarch, insn, "sbfx", dsc);
6696       else
6697         return arm_copy_undef (gdbarch, insn, dsc);
6698
6699     case 0x1c: case 0x1d:
6700       if (bits (insn, 5, 6) == 0x0)  /* op2[1:0].  */
6701          {
6702           if (bits (insn, 0, 3) == 0xf)
6703             return arm_copy_unmodified (gdbarch, insn, "bfc", dsc);
6704           else
6705             return arm_copy_unmodified (gdbarch, insn, "bfi", dsc);
6706         }
6707       else
6708         return arm_copy_undef (gdbarch, insn, dsc);
6709
6710     case 0x1e: case 0x1f:
6711       if (bits (insn, 5, 6) == 0x2)  /* op2[1:0].  */
6712         return arm_copy_unmodified (gdbarch, insn, "ubfx", dsc);
6713       else
6714         return arm_copy_undef (gdbarch, insn, dsc);
6715     }
6716
6717   /* Should be unreachable.  */
6718   return 1;
6719 }
6720
6721 static int
6722 arm_decode_b_bl_ldmstm (struct gdbarch *gdbarch, uint32_t insn,
6723                         struct regcache *regs,
6724                         arm_displaced_step_closure *dsc)
6725 {
6726   if (bit (insn, 25))
6727     return arm_copy_b_bl_blx (gdbarch, insn, regs, dsc);
6728   else
6729     return arm_copy_block_xfer (gdbarch, insn, regs, dsc);
6730 }
6731
6732 static int
6733 arm_decode_ext_reg_ld_st (struct gdbarch *gdbarch, uint32_t insn,
6734                           struct regcache *regs,
6735                           arm_displaced_step_closure *dsc)
6736 {
6737   unsigned int opcode = bits (insn, 20, 24);
6738
6739   switch (opcode)
6740     {
6741     case 0x04: case 0x05:  /* VFP/Neon mrrc/mcrr.  */
6742       return arm_copy_unmodified (gdbarch, insn, "vfp/neon mrrc/mcrr", dsc);
6743
6744     case 0x08: case 0x0a: case 0x0c: case 0x0e:
6745     case 0x12: case 0x16:
6746       return arm_copy_unmodified (gdbarch, insn, "vfp/neon vstm/vpush", dsc);
6747
6748     case 0x09: case 0x0b: case 0x0d: case 0x0f:
6749     case 0x13: case 0x17:
6750       return arm_copy_unmodified (gdbarch, insn, "vfp/neon vldm/vpop", dsc);
6751
6752     case 0x10: case 0x14: case 0x18: case 0x1c:  /* vstr.  */
6753     case 0x11: case 0x15: case 0x19: case 0x1d:  /* vldr.  */
6754       /* Note: no writeback for these instructions.  Bit 25 will always be
6755          zero though (via caller), so the following works OK.  */
6756       return arm_copy_copro_load_store (gdbarch, insn, regs, dsc);
6757     }
6758
6759   /* Should be unreachable.  */
6760   return 1;
6761 }
6762
6763 /* Decode shifted register instructions.  */
6764
6765 static int
6766 thumb2_decode_dp_shift_reg (struct gdbarch *gdbarch, uint16_t insn1,
6767                             uint16_t insn2,  struct regcache *regs,
6768                             arm_displaced_step_closure *dsc)
6769 {
6770   /* PC is only allowed to be used in instruction MOV.  */
6771
6772   unsigned int op = bits (insn1, 5, 8);
6773   unsigned int rn = bits (insn1, 0, 3);
6774
6775   if (op == 0x2 && rn == 0xf) /* MOV */
6776     return thumb2_copy_alu_imm (gdbarch, insn1, insn2, regs, dsc);
6777   else
6778     return thumb_copy_unmodified_32bit (gdbarch, insn1, insn2,
6779                                         "dp (shift reg)", dsc);
6780 }
6781
6782
6783 /* Decode extension register load/store.  Exactly the same as
6784    arm_decode_ext_reg_ld_st.  */
6785
6786 static int
6787 thumb2_decode_ext_reg_ld_st (struct gdbarch *gdbarch, uint16_t insn1,
6788                              uint16_t insn2,  struct regcache *regs,
6789                              arm_displaced_step_closure *dsc)
6790 {
6791   unsigned int opcode = bits (insn1, 4, 8);
6792
6793   switch (opcode)
6794     {
6795     case 0x04: case 0x05:
6796       return thumb_copy_unmodified_32bit (gdbarch, insn1, insn2,
6797                                           "vfp/neon vmov", dsc);
6798
6799     case 0x08: case 0x0c: /* 01x00 */
6800     case 0x0a: case 0x0e: /* 01x10 */
6801     case 0x12: case 0x16: /* 10x10 */
6802       return thumb_copy_unmodified_32bit (gdbarch, insn1, insn2,
6803                                           "vfp/neon vstm/vpush", dsc);
6804
6805     case 0x09: case 0x0d: /* 01x01 */
6806     case 0x0b: case 0x0f: /* 01x11 */
6807     case 0x13: case 0x17: /* 10x11 */
6808       return thumb_copy_unmodified_32bit (gdbarch, insn1, insn2,
6809                                           "vfp/neon vldm/vpop", dsc);
6810
6811     case 0x10: case 0x14: case 0x18: case 0x1c:  /* vstr.  */
6812       return thumb_copy_unmodified_32bit (gdbarch, insn1, insn2,
6813                                           "vstr", dsc);
6814     case 0x11: case 0x15: case 0x19: case 0x1d:  /* vldr.  */
6815       return thumb2_copy_copro_load_store (gdbarch, insn1, insn2, regs, dsc);
6816     }
6817
6818   /* Should be unreachable.  */
6819   return 1;
6820 }
6821
6822 static int
6823 arm_decode_svc_copro (struct gdbarch *gdbarch, uint32_t insn,
6824                       struct regcache *regs, arm_displaced_step_closure *dsc)
6825 {
6826   unsigned int op1 = bits (insn, 20, 25);
6827   int op = bit (insn, 4);
6828   unsigned int coproc = bits (insn, 8, 11);
6829
6830   if ((op1 & 0x20) == 0x00 && (op1 & 0x3a) != 0x00 && (coproc & 0xe) == 0xa)
6831     return arm_decode_ext_reg_ld_st (gdbarch, insn, regs, dsc);
6832   else if ((op1 & 0x21) == 0x00 && (op1 & 0x3a) != 0x00
6833            && (coproc & 0xe) != 0xa)
6834     /* stc/stc2.  */
6835     return arm_copy_copro_load_store (gdbarch, insn, regs, dsc);
6836   else if ((op1 & 0x21) == 0x01 && (op1 & 0x3a) != 0x00
6837            && (coproc & 0xe) != 0xa)
6838     /* ldc/ldc2 imm/lit.  */
6839     return arm_copy_copro_load_store (gdbarch, insn, regs, dsc);
6840   else if ((op1 & 0x3e) == 0x00)
6841     return arm_copy_undef (gdbarch, insn, dsc);
6842   else if ((op1 & 0x3e) == 0x04 && (coproc & 0xe) == 0xa)
6843     return arm_copy_unmodified (gdbarch, insn, "neon 64bit xfer", dsc);
6844   else if (op1 == 0x04 && (coproc & 0xe) != 0xa)
6845     return arm_copy_unmodified (gdbarch, insn, "mcrr/mcrr2", dsc);
6846   else if (op1 == 0x05 && (coproc & 0xe) != 0xa)
6847     return arm_copy_unmodified (gdbarch, insn, "mrrc/mrrc2", dsc);
6848   else if ((op1 & 0x30) == 0x20 && !op)
6849     {
6850       if ((coproc & 0xe) == 0xa)
6851         return arm_copy_unmodified (gdbarch, insn, "vfp dataproc", dsc);
6852       else
6853         return arm_copy_unmodified (gdbarch, insn, "cdp/cdp2", dsc);
6854     }
6855   else if ((op1 & 0x30) == 0x20 && op)
6856     return arm_copy_unmodified (gdbarch, insn, "neon 8/16/32 bit xfer", dsc);
6857   else if ((op1 & 0x31) == 0x20 && op && (coproc & 0xe) != 0xa)
6858     return arm_copy_unmodified (gdbarch, insn, "mcr/mcr2", dsc);
6859   else if ((op1 & 0x31) == 0x21 && op && (coproc & 0xe) != 0xa)
6860     return arm_copy_unmodified (gdbarch, insn, "mrc/mrc2", dsc);
6861   else if ((op1 & 0x30) == 0x30)
6862     return arm_copy_svc (gdbarch, insn, regs, dsc);
6863   else
6864     return arm_copy_undef (gdbarch, insn, dsc);  /* Possibly unreachable.  */
6865 }
6866
6867 static int
6868 thumb2_decode_svc_copro (struct gdbarch *gdbarch, uint16_t insn1,
6869                          uint16_t insn2, struct regcache *regs,
6870                          arm_displaced_step_closure *dsc)
6871 {
6872   unsigned int coproc = bits (insn2, 8, 11);
6873   unsigned int bit_5_8 = bits (insn1, 5, 8);
6874   unsigned int bit_9 = bit (insn1, 9);
6875   unsigned int bit_4 = bit (insn1, 4);
6876
6877   if (bit_9 == 0)
6878     {
6879       if (bit_5_8 == 2)
6880         return thumb_copy_unmodified_32bit (gdbarch, insn1, insn2,
6881                                             "neon 64bit xfer/mrrc/mrrc2/mcrr/mcrr2",
6882                                             dsc);
6883       else if (bit_5_8 == 0) /* UNDEFINED.  */
6884         return thumb_32bit_copy_undef (gdbarch, insn1, insn2, dsc);
6885       else
6886         {
6887            /*coproc is 101x.  SIMD/VFP, ext registers load/store.  */
6888           if ((coproc & 0xe) == 0xa)
6889             return thumb2_decode_ext_reg_ld_st (gdbarch, insn1, insn2, regs,
6890                                                 dsc);
6891           else /* coproc is not 101x.  */
6892             {
6893               if (bit_4 == 0) /* STC/STC2.  */
6894                 return thumb_copy_unmodified_32bit (gdbarch, insn1, insn2,
6895                                                     "stc/stc2", dsc);
6896               else /* LDC/LDC2 {literal, immeidate}.  */
6897                 return thumb2_copy_copro_load_store (gdbarch, insn1, insn2,
6898                                                      regs, dsc);
6899             }
6900         }
6901     }
6902   else
6903     return thumb_copy_unmodified_32bit (gdbarch, insn1, insn2, "coproc", dsc);
6904
6905   return 0;
6906 }
6907
6908 static void
6909 install_pc_relative (struct gdbarch *gdbarch, struct regcache *regs,
6910                      arm_displaced_step_closure *dsc, int rd)
6911 {
6912   /* ADR Rd, #imm
6913
6914      Rewrite as:
6915
6916      Preparation: Rd <- PC
6917      Insn: ADD Rd, #imm
6918      Cleanup: Null.
6919   */
6920
6921   /* Rd <- PC */
6922   int val = displaced_read_reg (regs, dsc, ARM_PC_REGNUM);
6923   displaced_write_reg (regs, dsc, rd, val, CANNOT_WRITE_PC);
6924 }
6925
6926 static int
6927 thumb_copy_pc_relative_16bit (struct gdbarch *gdbarch, struct regcache *regs,
6928                               arm_displaced_step_closure *dsc,
6929                               int rd, unsigned int imm)
6930 {
6931
6932   /* Encoding T2: ADDS Rd, #imm */
6933   dsc->modinsn[0] = (0x3000 | (rd << 8) | imm);
6934
6935   install_pc_relative (gdbarch, regs, dsc, rd);
6936
6937   return 0;
6938 }
6939
6940 static int
6941 thumb_decode_pc_relative_16bit (struct gdbarch *gdbarch, uint16_t insn,
6942                                 struct regcache *regs,
6943                                 arm_displaced_step_closure *dsc)
6944 {
6945   unsigned int rd = bits (insn, 8, 10);
6946   unsigned int imm8 = bits (insn, 0, 7);
6947
6948   if (debug_displaced)
6949     fprintf_unfiltered (gdb_stdlog,
6950                         "displaced: copying thumb adr r%d, #%d insn %.4x\n",
6951                         rd, imm8, insn);
6952
6953   return thumb_copy_pc_relative_16bit (gdbarch, regs, dsc, rd, imm8);
6954 }
6955
6956 static int
6957 thumb_copy_pc_relative_32bit (struct gdbarch *gdbarch, uint16_t insn1,
6958                               uint16_t insn2, struct regcache *regs,
6959                               arm_displaced_step_closure *dsc)
6960 {
6961   unsigned int rd = bits (insn2, 8, 11);
6962   /* Since immediate has the same encoding in ADR ADD and SUB, so we simply
6963      extract raw immediate encoding rather than computing immediate.  When
6964      generating ADD or SUB instruction, we can simply perform OR operation to
6965      set immediate into ADD.  */
6966   unsigned int imm_3_8 = insn2 & 0x70ff;
6967   unsigned int imm_i = insn1 & 0x0400; /* Clear all bits except bit 10.  */
6968
6969   if (debug_displaced)
6970     fprintf_unfiltered (gdb_stdlog,
6971                         "displaced: copying thumb adr r%d, #%d:%d insn %.4x%.4x\n",
6972                         rd, imm_i, imm_3_8, insn1, insn2);
6973
6974   if (bit (insn1, 7)) /* Encoding T2 */
6975     {
6976       /* Encoding T3: SUB Rd, Rd, #imm */
6977       dsc->modinsn[0] = (0xf1a0 | rd | imm_i);
6978       dsc->modinsn[1] = ((rd << 8) | imm_3_8);
6979     }
6980   else /* Encoding T3 */
6981     {
6982       /* Encoding T3: ADD Rd, Rd, #imm */
6983       dsc->modinsn[0] = (0xf100 | rd | imm_i);
6984       dsc->modinsn[1] = ((rd << 8) | imm_3_8);
6985     }
6986   dsc->numinsns = 2;
6987
6988   install_pc_relative (gdbarch, regs, dsc, rd);
6989
6990   return 0;
6991 }
6992
6993 static int
6994 thumb_copy_16bit_ldr_literal (struct gdbarch *gdbarch, uint16_t insn1,
6995                               struct regcache *regs,
6996                               arm_displaced_step_closure *dsc)
6997 {
6998   unsigned int rt = bits (insn1, 8, 10);
6999   unsigned int pc;
7000   int imm8 = (bits (insn1, 0, 7) << 2);
7001
7002   /* LDR Rd, #imm8
7003
7004      Rwrite as:
7005
7006      Preparation: tmp0 <- R0, tmp2 <- R2, tmp3 <- R3, R2 <- PC, R3 <- #imm8;
7007
7008      Insn: LDR R0, [R2, R3];
7009      Cleanup: R2 <- tmp2, R3 <- tmp3, Rd <- R0, R0 <- tmp0 */
7010
7011   if (debug_displaced)
7012     fprintf_unfiltered (gdb_stdlog,
7013                         "displaced: copying thumb ldr r%d [pc #%d]\n"
7014                         , rt, imm8);
7015
7016   dsc->tmp[0] = displaced_read_reg (regs, dsc, 0);
7017   dsc->tmp[2] = displaced_read_reg (regs, dsc, 2);
7018   dsc->tmp[3] = displaced_read_reg (regs, dsc, 3);
7019   pc = displaced_read_reg (regs, dsc, ARM_PC_REGNUM);
7020   /* The assembler calculates the required value of the offset from the
7021      Align(PC,4) value of this instruction to the label.  */
7022   pc = pc & 0xfffffffc;
7023
7024   displaced_write_reg (regs, dsc, 2, pc, CANNOT_WRITE_PC);
7025   displaced_write_reg (regs, dsc, 3, imm8, CANNOT_WRITE_PC);
7026
7027   dsc->rd = rt;
7028   dsc->u.ldst.xfersize = 4;
7029   dsc->u.ldst.rn = 0;
7030   dsc->u.ldst.immed = 0;
7031   dsc->u.ldst.writeback = 0;
7032   dsc->u.ldst.restore_r4 = 0;
7033
7034   dsc->modinsn[0] = 0x58d0; /* ldr r0, [r2, r3]*/
7035
7036   dsc->cleanup = &cleanup_load;
7037
7038   return 0;
7039 }
7040
7041 /* Copy Thumb cbnz/cbz insruction.  */
7042
7043 static int
7044 thumb_copy_cbnz_cbz (struct gdbarch *gdbarch, uint16_t insn1,
7045                      struct regcache *regs,
7046                      arm_displaced_step_closure *dsc)
7047 {
7048   int non_zero = bit (insn1, 11);
7049   unsigned int imm5 = (bit (insn1, 9) << 6) | (bits (insn1, 3, 7) << 1);
7050   CORE_ADDR from = dsc->insn_addr;
7051   int rn = bits (insn1, 0, 2);
7052   int rn_val = displaced_read_reg (regs, dsc, rn);
7053
7054   dsc->u.branch.cond = (rn_val && non_zero) || (!rn_val && !non_zero);
7055   /* CBNZ and CBZ do not affect the condition flags.  If condition is true,
7056      set it INST_AL, so cleanup_branch will know branch is taken, otherwise,
7057      condition is false, let it be, cleanup_branch will do nothing.  */
7058   if (dsc->u.branch.cond)
7059     {
7060       dsc->u.branch.cond = INST_AL;
7061       dsc->u.branch.dest = from + 4 + imm5;
7062     }
7063   else
7064       dsc->u.branch.dest = from + 2;
7065
7066   dsc->u.branch.link = 0;
7067   dsc->u.branch.exchange = 0;
7068
7069   if (debug_displaced)
7070     fprintf_unfiltered (gdb_stdlog, "displaced: copying %s [r%d = 0x%x]"
7071                         " insn %.4x to %.8lx\n", non_zero ? "cbnz" : "cbz",
7072                         rn, rn_val, insn1, dsc->u.branch.dest);
7073
7074   dsc->modinsn[0] = THUMB_NOP;
7075
7076   dsc->cleanup = &cleanup_branch;
7077   return 0;
7078 }
7079
7080 /* Copy Table Branch Byte/Halfword */
7081 static int
7082 thumb2_copy_table_branch (struct gdbarch *gdbarch, uint16_t insn1,
7083                           uint16_t insn2, struct regcache *regs,
7084                           arm_displaced_step_closure *dsc)
7085 {
7086   ULONGEST rn_val, rm_val;
7087   int is_tbh = bit (insn2, 4);
7088   CORE_ADDR halfwords = 0;
7089   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
7090
7091   rn_val = displaced_read_reg (regs, dsc, bits (insn1, 0, 3));
7092   rm_val = displaced_read_reg (regs, dsc, bits (insn2, 0, 3));
7093
7094   if (is_tbh)
7095     {
7096       gdb_byte buf[2];
7097
7098       target_read_memory (rn_val + 2 * rm_val, buf, 2);
7099       halfwords = extract_unsigned_integer (buf, 2, byte_order);
7100     }
7101   else
7102     {
7103       gdb_byte buf[1];
7104
7105       target_read_memory (rn_val + rm_val, buf, 1);
7106       halfwords = extract_unsigned_integer (buf, 1, byte_order);
7107     }
7108
7109   if (debug_displaced)
7110     fprintf_unfiltered (gdb_stdlog, "displaced: %s base 0x%x offset 0x%x"
7111                         " offset 0x%x\n", is_tbh ? "tbh" : "tbb",
7112                         (unsigned int) rn_val, (unsigned int) rm_val,
7113                         (unsigned int) halfwords);
7114
7115   dsc->u.branch.cond = INST_AL;
7116   dsc->u.branch.link = 0;
7117   dsc->u.branch.exchange = 0;
7118   dsc->u.branch.dest = dsc->insn_addr + 4 + 2 * halfwords;
7119
7120   dsc->cleanup = &cleanup_branch;
7121
7122   return 0;
7123 }
7124
7125 static void
7126 cleanup_pop_pc_16bit_all (struct gdbarch *gdbarch, struct regcache *regs,
7127                           arm_displaced_step_closure *dsc)
7128 {
7129   /* PC <- r7 */
7130   int val = displaced_read_reg (regs, dsc, 7);
7131   displaced_write_reg (regs, dsc, ARM_PC_REGNUM, val, BX_WRITE_PC);
7132
7133   /* r7 <- r8 */
7134   val = displaced_read_reg (regs, dsc, 8);
7135   displaced_write_reg (regs, dsc, 7, val, CANNOT_WRITE_PC);
7136
7137   /* r8 <- tmp[0] */
7138   displaced_write_reg (regs, dsc, 8, dsc->tmp[0], CANNOT_WRITE_PC);
7139
7140 }
7141
7142 static int
7143 thumb_copy_pop_pc_16bit (struct gdbarch *gdbarch, uint16_t insn1,
7144                          struct regcache *regs,
7145                          arm_displaced_step_closure *dsc)
7146 {
7147   dsc->u.block.regmask = insn1 & 0x00ff;
7148
7149   /* Rewrite instruction: POP {rX, rY, ...,rZ, PC}
7150      to :
7151
7152      (1) register list is full, that is, r0-r7 are used.
7153      Prepare: tmp[0] <- r8
7154
7155      POP {r0, r1, ...., r6, r7}; remove PC from reglist
7156      MOV r8, r7; Move value of r7 to r8;
7157      POP {r7}; Store PC value into r7.
7158
7159      Cleanup: PC <- r7, r7 <- r8, r8 <-tmp[0]
7160
7161      (2) register list is not full, supposing there are N registers in
7162      register list (except PC, 0 <= N <= 7).
7163      Prepare: for each i, 0 - N, tmp[i] <- ri.
7164
7165      POP {r0, r1, ...., rN};
7166
7167      Cleanup: Set registers in original reglist from r0 - rN.  Restore r0 - rN
7168      from tmp[] properly.
7169   */
7170   if (debug_displaced)
7171     fprintf_unfiltered (gdb_stdlog,
7172                         "displaced: copying thumb pop {%.8x, pc} insn %.4x\n",
7173                         dsc->u.block.regmask, insn1);
7174
7175   if (dsc->u.block.regmask == 0xff)
7176     {
7177       dsc->tmp[0] = displaced_read_reg (regs, dsc, 8);
7178
7179       dsc->modinsn[0] = (insn1 & 0xfeff); /* POP {r0,r1,...,r6, r7} */
7180       dsc->modinsn[1] = 0x46b8; /* MOV r8, r7 */
7181       dsc->modinsn[2] = 0xbc80; /* POP {r7} */
7182
7183       dsc->numinsns = 3;
7184       dsc->cleanup = &cleanup_pop_pc_16bit_all;
7185     }
7186   else
7187     {
7188       unsigned int num_in_list = bitcount (dsc->u.block.regmask);
7189       unsigned int i;
7190       unsigned int new_regmask;
7191
7192       for (i = 0; i < num_in_list + 1; i++)
7193         dsc->tmp[i] = displaced_read_reg (regs, dsc, i);
7194
7195       new_regmask = (1 << (num_in_list + 1)) - 1;
7196
7197       if (debug_displaced)
7198         fprintf_unfiltered (gdb_stdlog, _("displaced: POP "
7199                                           "{..., pc}: original reg list %.4x,"
7200                                           " modified list %.4x\n"),
7201                             (int) dsc->u.block.regmask, new_regmask);
7202
7203       dsc->u.block.regmask |= 0x8000;
7204       dsc->u.block.writeback = 0;
7205       dsc->u.block.cond = INST_AL;
7206
7207       dsc->modinsn[0] = (insn1 & ~0x1ff) | (new_regmask & 0xff);
7208
7209       dsc->cleanup = &cleanup_block_load_pc;
7210     }
7211
7212   return 0;
7213 }
7214
7215 static void
7216 thumb_process_displaced_16bit_insn (struct gdbarch *gdbarch, uint16_t insn1,
7217                                     struct regcache *regs,
7218                                     arm_displaced_step_closure *dsc)
7219 {
7220   unsigned short op_bit_12_15 = bits (insn1, 12, 15);
7221   unsigned short op_bit_10_11 = bits (insn1, 10, 11);
7222   int err = 0;
7223
7224   /* 16-bit thumb instructions.  */
7225   switch (op_bit_12_15)
7226     {
7227       /* Shift (imme), add, subtract, move and compare.  */
7228     case 0: case 1: case 2: case 3:
7229       err = thumb_copy_unmodified_16bit (gdbarch, insn1,
7230                                          "shift/add/sub/mov/cmp",
7231                                          dsc);
7232       break;
7233     case 4:
7234       switch (op_bit_10_11)
7235         {
7236         case 0: /* Data-processing */
7237           err = thumb_copy_unmodified_16bit (gdbarch, insn1,
7238                                              "data-processing",
7239                                              dsc);
7240           break;
7241         case 1: /* Special data instructions and branch and exchange.  */
7242           {
7243             unsigned short op = bits (insn1, 7, 9);
7244             if (op == 6 || op == 7) /* BX or BLX */
7245               err = thumb_copy_bx_blx_reg (gdbarch, insn1, regs, dsc);
7246             else if (bits (insn1, 6, 7) != 0) /* ADD/MOV/CMP high registers.  */
7247               err = thumb_copy_alu_reg (gdbarch, insn1, regs, dsc);
7248             else
7249               err = thumb_copy_unmodified_16bit (gdbarch, insn1, "special data",
7250                                                  dsc);
7251           }
7252           break;
7253         default: /* LDR (literal) */
7254           err = thumb_copy_16bit_ldr_literal (gdbarch, insn1, regs, dsc);
7255         }
7256       break;
7257     case 5: case 6: case 7: case 8: case 9: /* Load/Store single data item */
7258       err = thumb_copy_unmodified_16bit (gdbarch, insn1, "ldr/str", dsc);
7259       break;
7260     case 10:
7261       if (op_bit_10_11 < 2) /* Generate PC-relative address */
7262         err = thumb_decode_pc_relative_16bit (gdbarch, insn1, regs, dsc);
7263       else /* Generate SP-relative address */
7264         err = thumb_copy_unmodified_16bit (gdbarch, insn1, "sp-relative", dsc);
7265       break;
7266     case 11: /* Misc 16-bit instructions */
7267       {
7268         switch (bits (insn1, 8, 11))
7269           {
7270           case 1: case 3:  case 9: case 11: /* CBNZ, CBZ */
7271             err = thumb_copy_cbnz_cbz (gdbarch, insn1, regs, dsc);
7272             break;
7273           case 12: case 13: /* POP */
7274             if (bit (insn1, 8)) /* PC is in register list.  */
7275               err = thumb_copy_pop_pc_16bit (gdbarch, insn1, regs, dsc);
7276             else
7277               err = thumb_copy_unmodified_16bit (gdbarch, insn1, "pop", dsc);
7278             break;
7279           case 15: /* If-Then, and hints */
7280             if (bits (insn1, 0, 3))
7281               /* If-Then makes up to four following instructions conditional.
7282                  IT instruction itself is not conditional, so handle it as a
7283                  common unmodified instruction.  */
7284               err = thumb_copy_unmodified_16bit (gdbarch, insn1, "If-Then",
7285                                                  dsc);
7286             else
7287               err = thumb_copy_unmodified_16bit (gdbarch, insn1, "hints", dsc);
7288             break;
7289           default:
7290             err = thumb_copy_unmodified_16bit (gdbarch, insn1, "misc", dsc);
7291           }
7292       }
7293       break;
7294     case 12:
7295       if (op_bit_10_11 < 2) /* Store multiple registers */
7296         err = thumb_copy_unmodified_16bit (gdbarch, insn1, "stm", dsc);
7297       else /* Load multiple registers */
7298         err = thumb_copy_unmodified_16bit (gdbarch, insn1, "ldm", dsc);
7299       break;
7300     case 13: /* Conditional branch and supervisor call */
7301       if (bits (insn1, 9, 11) != 7) /* conditional branch */
7302         err = thumb_copy_b (gdbarch, insn1, dsc);
7303       else
7304         err = thumb_copy_svc (gdbarch, insn1, regs, dsc);
7305       break;
7306     case 14: /* Unconditional branch */
7307       err = thumb_copy_b (gdbarch, insn1, dsc);
7308       break;
7309     default:
7310       err = 1;
7311     }
7312
7313   if (err)
7314     internal_error (__FILE__, __LINE__,
7315                     _("thumb_process_displaced_16bit_insn: Instruction decode error"));
7316 }
7317
7318 static int
7319 decode_thumb_32bit_ld_mem_hints (struct gdbarch *gdbarch,
7320                                  uint16_t insn1, uint16_t insn2,
7321                                  struct regcache *regs,
7322                                  arm_displaced_step_closure *dsc)
7323 {
7324   int rt = bits (insn2, 12, 15);
7325   int rn = bits (insn1, 0, 3);
7326   int op1 = bits (insn1, 7, 8);
7327
7328   switch (bits (insn1, 5, 6))
7329     {
7330     case 0: /* Load byte and memory hints */
7331       if (rt == 0xf) /* PLD/PLI */
7332         {
7333           if (rn == 0xf)
7334             /* PLD literal or Encoding T3 of PLI(immediate, literal).  */
7335             return thumb2_copy_preload (gdbarch, insn1, insn2, regs, dsc);
7336           else
7337             return thumb_copy_unmodified_32bit (gdbarch, insn1, insn2,
7338                                                 "pli/pld", dsc);
7339         }
7340       else
7341         {
7342           if (rn == 0xf) /* LDRB/LDRSB (literal) */
7343             return thumb2_copy_load_literal (gdbarch, insn1, insn2, regs, dsc,
7344                                              1);
7345           else
7346             return thumb_copy_unmodified_32bit (gdbarch, insn1, insn2,
7347                                                 "ldrb{reg, immediate}/ldrbt",
7348                                                 dsc);
7349         }
7350
7351       break;
7352     case 1: /* Load halfword and memory hints.  */
7353       if (rt == 0xf) /* PLD{W} and Unalloc memory hint.  */
7354         return thumb_copy_unmodified_32bit (gdbarch, insn1, insn2,
7355                                             "pld/unalloc memhint", dsc);
7356       else
7357         {
7358           if (rn == 0xf)
7359             return thumb2_copy_load_literal (gdbarch, insn1, insn2, regs, dsc,
7360                                              2);
7361           else
7362             return thumb_copy_unmodified_32bit (gdbarch, insn1, insn2,
7363                                                 "ldrh/ldrht", dsc);
7364         }
7365       break;
7366     case 2: /* Load word */
7367       {
7368         int insn2_bit_8_11 = bits (insn2, 8, 11);
7369
7370         if (rn == 0xf)
7371           return thumb2_copy_load_literal (gdbarch, insn1, insn2, regs, dsc, 4);
7372         else if (op1 == 0x1) /* Encoding T3 */
7373           return thumb2_copy_load_reg_imm (gdbarch, insn1, insn2, regs, dsc,
7374                                            0, 1);
7375         else /* op1 == 0x0 */
7376           {
7377             if (insn2_bit_8_11 == 0xc || (insn2_bit_8_11 & 0x9) == 0x9)
7378               /* LDR (immediate) */
7379               return thumb2_copy_load_reg_imm (gdbarch, insn1, insn2, regs,
7380                                                dsc, bit (insn2, 8), 1);
7381             else if (insn2_bit_8_11 == 0xe) /* LDRT */
7382               return thumb_copy_unmodified_32bit (gdbarch, insn1, insn2,
7383                                                   "ldrt", dsc);
7384             else
7385               /* LDR (register) */
7386               return thumb2_copy_load_reg_imm (gdbarch, insn1, insn2, regs,
7387                                                dsc, 0, 0);
7388           }
7389         break;
7390       }
7391     default:
7392       return thumb_32bit_copy_undef (gdbarch, insn1, insn2, dsc);
7393       break;
7394     }
7395   return 0;
7396 }
7397
7398 static void
7399 thumb_process_displaced_32bit_insn (struct gdbarch *gdbarch, uint16_t insn1,
7400                                     uint16_t insn2, struct regcache *regs,
7401                                     arm_displaced_step_closure *dsc)
7402 {
7403   int err = 0;
7404   unsigned short op = bit (insn2, 15);
7405   unsigned int op1 = bits (insn1, 11, 12);
7406
7407   switch (op1)
7408     {
7409     case 1:
7410       {
7411         switch (bits (insn1, 9, 10))
7412           {
7413           case 0:
7414             if (bit (insn1, 6))
7415               {
7416                 /* Load/store {dual, execlusive}, table branch.  */
7417                 if (bits (insn1, 7, 8) == 1 && bits (insn1, 4, 5) == 1
7418                     && bits (insn2, 5, 7) == 0)
7419                   err = thumb2_copy_table_branch (gdbarch, insn1, insn2, regs,
7420                                                   dsc);
7421                 else
7422                   /* PC is not allowed to use in load/store {dual, exclusive}
7423                      instructions.  */
7424                   err = thumb_copy_unmodified_32bit (gdbarch, insn1, insn2,
7425                                                      "load/store dual/ex", dsc);
7426               }
7427             else /* load/store multiple */
7428               {
7429                 switch (bits (insn1, 7, 8))
7430                   {
7431                   case 0: case 3: /* SRS, RFE */
7432                     err = thumb_copy_unmodified_32bit (gdbarch, insn1, insn2,
7433                                                        "srs/rfe", dsc);
7434                     break;
7435                   case 1: case 2: /* LDM/STM/PUSH/POP */
7436                     err = thumb2_copy_block_xfer (gdbarch, insn1, insn2, regs, dsc);
7437                     break;
7438                   }
7439               }
7440             break;
7441
7442           case 1:
7443             /* Data-processing (shift register).  */
7444             err = thumb2_decode_dp_shift_reg (gdbarch, insn1, insn2, regs,
7445                                               dsc);
7446             break;
7447           default: /* Coprocessor instructions.  */
7448             err = thumb2_decode_svc_copro (gdbarch, insn1, insn2, regs, dsc);
7449             break;
7450           }
7451       break;
7452       }
7453     case 2: /* op1 = 2 */
7454       if (op) /* Branch and misc control.  */
7455         {
7456           if (bit (insn2, 14)  /* BLX/BL */
7457               || bit (insn2, 12) /* Unconditional branch */
7458               || (bits (insn1, 7, 9) != 0x7)) /* Conditional branch */
7459             err = thumb2_copy_b_bl_blx (gdbarch, insn1, insn2, regs, dsc);
7460           else
7461             err = thumb_copy_unmodified_32bit (gdbarch, insn1, insn2,
7462                                                "misc ctrl", dsc);
7463         }
7464       else
7465         {
7466           if (bit (insn1, 9)) /* Data processing (plain binary imm).  */
7467             {
7468               int dp_op = bits (insn1, 4, 8);
7469               int rn = bits (insn1, 0, 3);
7470               if ((dp_op == 0 || dp_op == 0xa) && rn == 0xf)
7471                 err = thumb_copy_pc_relative_32bit (gdbarch, insn1, insn2,
7472                                                     regs, dsc);
7473               else
7474                 err = thumb_copy_unmodified_32bit (gdbarch, insn1, insn2,
7475                                                    "dp/pb", dsc);
7476             }
7477           else /* Data processing (modified immeidate) */
7478             err = thumb_copy_unmodified_32bit (gdbarch, insn1, insn2,
7479                                                "dp/mi", dsc);
7480         }
7481       break;
7482     case 3: /* op1 = 3 */
7483       switch (bits (insn1, 9, 10))
7484         {
7485         case 0:
7486           if (bit (insn1, 4))
7487             err = decode_thumb_32bit_ld_mem_hints (gdbarch, insn1, insn2,
7488                                                    regs, dsc);
7489           else /* NEON Load/Store and Store single data item */
7490             err = thumb_copy_unmodified_32bit (gdbarch, insn1, insn2,
7491                                                "neon elt/struct load/store",
7492                                                dsc);
7493           break;
7494         case 1: /* op1 = 3, bits (9, 10) == 1 */
7495           switch (bits (insn1, 7, 8))
7496             {
7497             case 0: case 1: /* Data processing (register) */
7498               err = thumb_copy_unmodified_32bit (gdbarch, insn1, insn2,
7499                                                  "dp(reg)", dsc);
7500               break;
7501             case 2: /* Multiply and absolute difference */
7502               err = thumb_copy_unmodified_32bit (gdbarch, insn1, insn2,
7503                                                  "mul/mua/diff", dsc);
7504               break;
7505             case 3: /* Long multiply and divide */
7506               err = thumb_copy_unmodified_32bit (gdbarch, insn1, insn2,
7507                                                  "lmul/lmua", dsc);
7508               break;
7509             }
7510           break;
7511         default: /* Coprocessor instructions */
7512           err = thumb2_decode_svc_copro (gdbarch, insn1, insn2, regs, dsc);
7513           break;
7514         }
7515       break;
7516     default:
7517       err = 1;
7518     }
7519
7520   if (err)
7521     internal_error (__FILE__, __LINE__,
7522                     _("thumb_process_displaced_32bit_insn: Instruction decode error"));
7523
7524 }
7525
7526 static void
7527 thumb_process_displaced_insn (struct gdbarch *gdbarch, CORE_ADDR from,
7528                               struct regcache *regs,
7529                               arm_displaced_step_closure *dsc)
7530 {
7531   enum bfd_endian byte_order_for_code = gdbarch_byte_order_for_code (gdbarch);
7532   uint16_t insn1
7533     = read_memory_unsigned_integer (from, 2, byte_order_for_code);
7534
7535   if (debug_displaced)
7536     fprintf_unfiltered (gdb_stdlog, "displaced: process thumb insn %.4x "
7537                         "at %.8lx\n", insn1, (unsigned long) from);
7538
7539   dsc->is_thumb = 1;
7540   dsc->insn_size = thumb_insn_size (insn1);
7541   if (thumb_insn_size (insn1) == 4)
7542     {
7543       uint16_t insn2
7544         = read_memory_unsigned_integer (from + 2, 2, byte_order_for_code);
7545       thumb_process_displaced_32bit_insn (gdbarch, insn1, insn2, regs, dsc);
7546     }
7547   else
7548     thumb_process_displaced_16bit_insn (gdbarch, insn1, regs, dsc);
7549 }
7550
7551 void
7552 arm_process_displaced_insn (struct gdbarch *gdbarch, CORE_ADDR from,
7553                             CORE_ADDR to, struct regcache *regs,
7554                             arm_displaced_step_closure *dsc)
7555 {
7556   int err = 0;
7557   enum bfd_endian byte_order_for_code = gdbarch_byte_order_for_code (gdbarch);
7558   uint32_t insn;
7559
7560   /* Most displaced instructions use a 1-instruction scratch space, so set this
7561      here and override below if/when necessary.  */
7562   dsc->numinsns = 1;
7563   dsc->insn_addr = from;
7564   dsc->scratch_base = to;
7565   dsc->cleanup = NULL;
7566   dsc->wrote_to_pc = 0;
7567
7568   if (!displaced_in_arm_mode (regs))
7569     return thumb_process_displaced_insn (gdbarch, from, regs, dsc);
7570
7571   dsc->is_thumb = 0;
7572   dsc->insn_size = 4;
7573   insn = read_memory_unsigned_integer (from, 4, byte_order_for_code);
7574   if (debug_displaced)
7575     fprintf_unfiltered (gdb_stdlog, "displaced: stepping insn %.8lx "
7576                         "at %.8lx\n", (unsigned long) insn,
7577                         (unsigned long) from);
7578
7579   if ((insn & 0xf0000000) == 0xf0000000)
7580     err = arm_decode_unconditional (gdbarch, insn, regs, dsc);
7581   else switch (((insn & 0x10) >> 4) | ((insn & 0xe000000) >> 24))
7582     {
7583     case 0x0: case 0x1: case 0x2: case 0x3:
7584       err = arm_decode_dp_misc (gdbarch, insn, regs, dsc);
7585       break;
7586
7587     case 0x4: case 0x5: case 0x6:
7588       err = arm_decode_ld_st_word_ubyte (gdbarch, insn, regs, dsc);
7589       break;
7590
7591     case 0x7:
7592       err = arm_decode_media (gdbarch, insn, dsc);
7593       break;
7594
7595     case 0x8: case 0x9: case 0xa: case 0xb:
7596       err = arm_decode_b_bl_ldmstm (gdbarch, insn, regs, dsc);
7597       break;
7598
7599     case 0xc: case 0xd: case 0xe: case 0xf:
7600       err = arm_decode_svc_copro (gdbarch, insn, regs, dsc);
7601       break;
7602     }
7603
7604   if (err)
7605     internal_error (__FILE__, __LINE__,
7606                     _("arm_process_displaced_insn: Instruction decode error"));
7607 }
7608
7609 /* Actually set up the scratch space for a displaced instruction.  */
7610
7611 void
7612 arm_displaced_init_closure (struct gdbarch *gdbarch, CORE_ADDR from,
7613                             CORE_ADDR to, arm_displaced_step_closure *dsc)
7614 {
7615   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
7616   unsigned int i, len, offset;
7617   enum bfd_endian byte_order_for_code = gdbarch_byte_order_for_code (gdbarch);
7618   int size = dsc->is_thumb? 2 : 4;
7619   const gdb_byte *bkp_insn;
7620
7621   offset = 0;
7622   /* Poke modified instruction(s).  */
7623   for (i = 0; i < dsc->numinsns; i++)
7624     {
7625       if (debug_displaced)
7626         {
7627           fprintf_unfiltered (gdb_stdlog, "displaced: writing insn ");
7628           if (size == 4)
7629             fprintf_unfiltered (gdb_stdlog, "%.8lx",
7630                                 dsc->modinsn[i]);
7631           else if (size == 2)
7632             fprintf_unfiltered (gdb_stdlog, "%.4x",
7633                                 (unsigned short)dsc->modinsn[i]);
7634
7635           fprintf_unfiltered (gdb_stdlog, " at %.8lx\n",
7636                               (unsigned long) to + offset);
7637
7638         }
7639       write_memory_unsigned_integer (to + offset, size,
7640                                      byte_order_for_code,
7641                                      dsc->modinsn[i]);
7642       offset += size;
7643     }
7644
7645   /* Choose the correct breakpoint instruction.  */
7646   if (dsc->is_thumb)
7647     {
7648       bkp_insn = tdep->thumb_breakpoint;
7649       len = tdep->thumb_breakpoint_size;
7650     }
7651   else
7652     {
7653       bkp_insn = tdep->arm_breakpoint;
7654       len = tdep->arm_breakpoint_size;
7655     }
7656
7657   /* Put breakpoint afterwards.  */
7658   write_memory (to + offset, bkp_insn, len);
7659
7660   if (debug_displaced)
7661     fprintf_unfiltered (gdb_stdlog, "displaced: copy %s->%s: ",
7662                         paddress (gdbarch, from), paddress (gdbarch, to));
7663 }
7664
7665 /* Entry point for cleaning things up after a displaced instruction has been
7666    single-stepped.  */
7667
7668 void
7669 arm_displaced_step_fixup (struct gdbarch *gdbarch,
7670                           struct displaced_step_closure *dsc_,
7671                           CORE_ADDR from, CORE_ADDR to,
7672                           struct regcache *regs)
7673 {
7674   arm_displaced_step_closure *dsc = (arm_displaced_step_closure *) dsc_;
7675
7676   if (dsc->cleanup)
7677     dsc->cleanup (gdbarch, regs, dsc);
7678
7679   if (!dsc->wrote_to_pc)
7680     regcache_cooked_write_unsigned (regs, ARM_PC_REGNUM,
7681                                     dsc->insn_addr + dsc->insn_size);
7682
7683 }
7684
7685 #include "bfd-in2.h"
7686 #include "libcoff.h"
7687
7688 static int
7689 gdb_print_insn_arm (bfd_vma memaddr, disassemble_info *info)
7690 {
7691   gdb_disassembler *di
7692     = static_cast<gdb_disassembler *>(info->application_data);
7693   struct gdbarch *gdbarch = di->arch ();
7694
7695   if (arm_pc_is_thumb (gdbarch, memaddr))
7696     {
7697       static asymbol *asym;
7698       static combined_entry_type ce;
7699       static struct coff_symbol_struct csym;
7700       static struct bfd fake_bfd;
7701       static bfd_target fake_target;
7702
7703       if (csym.native == NULL)
7704         {
7705           /* Create a fake symbol vector containing a Thumb symbol.
7706              This is solely so that the code in print_insn_little_arm() 
7707              and print_insn_big_arm() in opcodes/arm-dis.c will detect
7708              the presence of a Thumb symbol and switch to decoding
7709              Thumb instructions.  */
7710
7711           fake_target.flavour = bfd_target_coff_flavour;
7712           fake_bfd.xvec = &fake_target;
7713           ce.u.syment.n_sclass = C_THUMBEXTFUNC;
7714           csym.native = &ce;
7715           csym.symbol.the_bfd = &fake_bfd;
7716           csym.symbol.name = "fake";
7717           asym = (asymbol *) & csym;
7718         }
7719
7720       memaddr = UNMAKE_THUMB_ADDR (memaddr);
7721       info->symbols = &asym;
7722     }
7723   else
7724     info->symbols = NULL;
7725
7726   /* GDB is able to get bfd_mach from the exe_bfd, info->mach is
7727      accurate, so mark USER_SPECIFIED_MACHINE_TYPE bit.  Otherwise,
7728      opcodes/arm-dis.c:print_insn reset info->mach, and it will trigger
7729      the assert on the mismatch of info->mach and bfd_get_mach (exec_bfd)
7730      in default_print_insn.  */
7731   if (exec_bfd != NULL)
7732     info->flags |= USER_SPECIFIED_MACHINE_TYPE;
7733
7734   return default_print_insn (memaddr, info);
7735 }
7736
7737 /* The following define instruction sequences that will cause ARM
7738    cpu's to take an undefined instruction trap.  These are used to
7739    signal a breakpoint to GDB.
7740    
7741    The newer ARMv4T cpu's are capable of operating in ARM or Thumb
7742    modes.  A different instruction is required for each mode.  The ARM
7743    cpu's can also be big or little endian.  Thus four different
7744    instructions are needed to support all cases.
7745    
7746    Note: ARMv4 defines several new instructions that will take the
7747    undefined instruction trap.  ARM7TDMI is nominally ARMv4T, but does
7748    not in fact add the new instructions.  The new undefined
7749    instructions in ARMv4 are all instructions that had no defined
7750    behaviour in earlier chips.  There is no guarantee that they will
7751    raise an exception, but may be treated as NOP's.  In practice, it
7752    may only safe to rely on instructions matching:
7753    
7754    3 3 2 2 2 2 2 2 2 2 2 2 1 1 1 1 1 1 1 1 1 1 
7755    1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0
7756    C C C C 0 1 1 x x x x x x x x x x x x x x x x x x x x 1 x x x x
7757    
7758    Even this may only true if the condition predicate is true.  The
7759    following use a condition predicate of ALWAYS so it is always TRUE.
7760    
7761    There are other ways of forcing a breakpoint.  GNU/Linux, RISC iX,
7762    and NetBSD all use a software interrupt rather than an undefined
7763    instruction to force a trap.  This can be handled by by the
7764    abi-specific code during establishment of the gdbarch vector.  */
7765
7766 #define ARM_LE_BREAKPOINT {0xFE,0xDE,0xFF,0xE7}
7767 #define ARM_BE_BREAKPOINT {0xE7,0xFF,0xDE,0xFE}
7768 #define THUMB_LE_BREAKPOINT {0xbe,0xbe}
7769 #define THUMB_BE_BREAKPOINT {0xbe,0xbe}
7770
7771 static const gdb_byte arm_default_arm_le_breakpoint[] = ARM_LE_BREAKPOINT;
7772 static const gdb_byte arm_default_arm_be_breakpoint[] = ARM_BE_BREAKPOINT;
7773 static const gdb_byte arm_default_thumb_le_breakpoint[] = THUMB_LE_BREAKPOINT;
7774 static const gdb_byte arm_default_thumb_be_breakpoint[] = THUMB_BE_BREAKPOINT;
7775
7776 /* Implement the breakpoint_kind_from_pc gdbarch method.  */
7777
7778 static int
7779 arm_breakpoint_kind_from_pc (struct gdbarch *gdbarch, CORE_ADDR *pcptr)
7780 {
7781   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
7782   enum bfd_endian byte_order_for_code = gdbarch_byte_order_for_code (gdbarch);
7783
7784   if (arm_pc_is_thumb (gdbarch, *pcptr))
7785     {
7786       *pcptr = UNMAKE_THUMB_ADDR (*pcptr);
7787
7788       /* If we have a separate 32-bit breakpoint instruction for Thumb-2,
7789          check whether we are replacing a 32-bit instruction.  */
7790       if (tdep->thumb2_breakpoint != NULL)
7791         {
7792           gdb_byte buf[2];
7793
7794           if (target_read_memory (*pcptr, buf, 2) == 0)
7795             {
7796               unsigned short inst1;
7797
7798               inst1 = extract_unsigned_integer (buf, 2, byte_order_for_code);
7799               if (thumb_insn_size (inst1) == 4)
7800                 return ARM_BP_KIND_THUMB2;
7801             }
7802         }
7803
7804       return ARM_BP_KIND_THUMB;
7805     }
7806   else
7807     return ARM_BP_KIND_ARM;
7808
7809 }
7810
7811 /* Implement the sw_breakpoint_from_kind gdbarch method.  */
7812
7813 static const gdb_byte *
7814 arm_sw_breakpoint_from_kind (struct gdbarch *gdbarch, int kind, int *size)
7815 {
7816   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
7817
7818   switch (kind)
7819     {
7820     case ARM_BP_KIND_ARM:
7821       *size = tdep->arm_breakpoint_size;
7822       return tdep->arm_breakpoint;
7823     case ARM_BP_KIND_THUMB:
7824       *size = tdep->thumb_breakpoint_size;
7825       return tdep->thumb_breakpoint;
7826     case ARM_BP_KIND_THUMB2:
7827       *size = tdep->thumb2_breakpoint_size;
7828       return tdep->thumb2_breakpoint;
7829     default:
7830       gdb_assert_not_reached ("unexpected arm breakpoint kind");
7831     }
7832 }
7833
7834 /* Implement the breakpoint_kind_from_current_state gdbarch method.  */
7835
7836 static int
7837 arm_breakpoint_kind_from_current_state (struct gdbarch *gdbarch,
7838                                         struct regcache *regcache,
7839                                         CORE_ADDR *pcptr)
7840 {
7841   gdb_byte buf[4];
7842
7843   /* Check the memory pointed by PC is readable.  */
7844   if (target_read_memory (regcache_read_pc (regcache), buf, 4) == 0)
7845     {
7846       struct arm_get_next_pcs next_pcs_ctx;
7847
7848       arm_get_next_pcs_ctor (&next_pcs_ctx,
7849                              &arm_get_next_pcs_ops,
7850                              gdbarch_byte_order (gdbarch),
7851                              gdbarch_byte_order_for_code (gdbarch),
7852                              0,
7853                              regcache);
7854
7855       std::vector<CORE_ADDR> next_pcs = arm_get_next_pcs (&next_pcs_ctx);
7856
7857       /* If MEMADDR is the next instruction of current pc, do the
7858          software single step computation, and get the thumb mode by
7859          the destination address.  */
7860       for (CORE_ADDR pc : next_pcs)
7861         {
7862           if (UNMAKE_THUMB_ADDR (pc) == *pcptr)
7863             {
7864               if (IS_THUMB_ADDR (pc))
7865                 {
7866                   *pcptr = MAKE_THUMB_ADDR (*pcptr);
7867                   return arm_breakpoint_kind_from_pc (gdbarch, pcptr);
7868                 }
7869               else
7870                 return ARM_BP_KIND_ARM;
7871             }
7872         }
7873     }
7874
7875   return arm_breakpoint_kind_from_pc (gdbarch, pcptr);
7876 }
7877
7878 /* Extract from an array REGBUF containing the (raw) register state a
7879    function return value of type TYPE, and copy that, in virtual
7880    format, into VALBUF.  */
7881
7882 static void
7883 arm_extract_return_value (struct type *type, struct regcache *regs,
7884                           gdb_byte *valbuf)
7885 {
7886   struct gdbarch *gdbarch = regs->arch ();
7887   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
7888
7889   if (TYPE_CODE_FLT == TYPE_CODE (type))
7890     {
7891       switch (gdbarch_tdep (gdbarch)->fp_model)
7892         {
7893         case ARM_FLOAT_FPA:
7894           {
7895             /* The value is in register F0 in internal format.  We need to
7896                extract the raw value and then convert it to the desired
7897                internal type.  */
7898             bfd_byte tmpbuf[FP_REGISTER_SIZE];
7899
7900             regs->cooked_read (ARM_F0_REGNUM, tmpbuf);
7901             target_float_convert (tmpbuf, arm_ext_type (gdbarch),
7902                                   valbuf, type);
7903           }
7904           break;
7905
7906         case ARM_FLOAT_SOFT_FPA:
7907         case ARM_FLOAT_SOFT_VFP:
7908           /* ARM_FLOAT_VFP can arise if this is a variadic function so
7909              not using the VFP ABI code.  */
7910         case ARM_FLOAT_VFP:
7911           regs->cooked_read (ARM_A1_REGNUM, valbuf);
7912           if (TYPE_LENGTH (type) > 4)
7913             regs->cooked_read (ARM_A1_REGNUM + 1, valbuf + INT_REGISTER_SIZE);
7914           break;
7915
7916         default:
7917           internal_error (__FILE__, __LINE__,
7918                           _("arm_extract_return_value: "
7919                             "Floating point model not supported"));
7920           break;
7921         }
7922     }
7923   else if (TYPE_CODE (type) == TYPE_CODE_INT
7924            || TYPE_CODE (type) == TYPE_CODE_CHAR
7925            || TYPE_CODE (type) == TYPE_CODE_BOOL
7926            || TYPE_CODE (type) == TYPE_CODE_PTR
7927            || TYPE_IS_REFERENCE (type)
7928            || TYPE_CODE (type) == TYPE_CODE_ENUM)
7929     {
7930       /* If the type is a plain integer, then the access is
7931          straight-forward.  Otherwise we have to play around a bit
7932          more.  */
7933       int len = TYPE_LENGTH (type);
7934       int regno = ARM_A1_REGNUM;
7935       ULONGEST tmp;
7936
7937       while (len > 0)
7938         {
7939           /* By using store_unsigned_integer we avoid having to do
7940              anything special for small big-endian values.  */
7941           regcache_cooked_read_unsigned (regs, regno++, &tmp);
7942           store_unsigned_integer (valbuf, 
7943                                   (len > INT_REGISTER_SIZE
7944                                    ? INT_REGISTER_SIZE : len),
7945                                   byte_order, tmp);
7946           len -= INT_REGISTER_SIZE;
7947           valbuf += INT_REGISTER_SIZE;
7948         }
7949     }
7950   else
7951     {
7952       /* For a structure or union the behaviour is as if the value had
7953          been stored to word-aligned memory and then loaded into 
7954          registers with 32-bit load instruction(s).  */
7955       int len = TYPE_LENGTH (type);
7956       int regno = ARM_A1_REGNUM;
7957       bfd_byte tmpbuf[INT_REGISTER_SIZE];
7958
7959       while (len > 0)
7960         {
7961           regs->cooked_read (regno++, tmpbuf);
7962           memcpy (valbuf, tmpbuf,
7963                   len > INT_REGISTER_SIZE ? INT_REGISTER_SIZE : len);
7964           len -= INT_REGISTER_SIZE;
7965           valbuf += INT_REGISTER_SIZE;
7966         }
7967     }
7968 }
7969
7970
7971 /* Will a function return an aggregate type in memory or in a
7972    register?  Return 0 if an aggregate type can be returned in a
7973    register, 1 if it must be returned in memory.  */
7974
7975 static int
7976 arm_return_in_memory (struct gdbarch *gdbarch, struct type *type)
7977 {
7978   enum type_code code;
7979
7980   type = check_typedef (type);
7981
7982   /* Simple, non-aggregate types (ie not including vectors and
7983      complex) are always returned in a register (or registers).  */
7984   code = TYPE_CODE (type);
7985   if (TYPE_CODE_STRUCT != code && TYPE_CODE_UNION != code
7986       && TYPE_CODE_ARRAY != code && TYPE_CODE_COMPLEX != code)
7987     return 0;
7988
7989   if (TYPE_CODE_ARRAY == code && TYPE_VECTOR (type))
7990     {
7991       /* Vector values should be returned using ARM registers if they
7992          are not over 16 bytes.  */
7993       return (TYPE_LENGTH (type) > 16);
7994     }
7995
7996   if (gdbarch_tdep (gdbarch)->arm_abi != ARM_ABI_APCS)
7997     {
7998       /* The AAPCS says all aggregates not larger than a word are returned
7999          in a register.  */
8000       if (TYPE_LENGTH (type) <= INT_REGISTER_SIZE)
8001         return 0;
8002
8003       return 1;
8004     }
8005   else
8006     {
8007       int nRc;
8008
8009       /* All aggregate types that won't fit in a register must be returned
8010          in memory.  */
8011       if (TYPE_LENGTH (type) > INT_REGISTER_SIZE)
8012         return 1;
8013
8014       /* In the ARM ABI, "integer" like aggregate types are returned in
8015          registers.  For an aggregate type to be integer like, its size
8016          must be less than or equal to INT_REGISTER_SIZE and the
8017          offset of each addressable subfield must be zero.  Note that bit
8018          fields are not addressable, and all addressable subfields of
8019          unions always start at offset zero.
8020
8021          This function is based on the behaviour of GCC 2.95.1.
8022          See: gcc/arm.c: arm_return_in_memory() for details.
8023
8024          Note: All versions of GCC before GCC 2.95.2 do not set up the
8025          parameters correctly for a function returning the following
8026          structure: struct { float f;}; This should be returned in memory,
8027          not a register.  Richard Earnshaw sent me a patch, but I do not
8028          know of any way to detect if a function like the above has been
8029          compiled with the correct calling convention.  */
8030
8031       /* Assume all other aggregate types can be returned in a register.
8032          Run a check for structures, unions and arrays.  */
8033       nRc = 0;
8034
8035       if ((TYPE_CODE_STRUCT == code) || (TYPE_CODE_UNION == code))
8036         {
8037           int i;
8038           /* Need to check if this struct/union is "integer" like.  For
8039              this to be true, its size must be less than or equal to
8040              INT_REGISTER_SIZE and the offset of each addressable
8041              subfield must be zero.  Note that bit fields are not
8042              addressable, and unions always start at offset zero.  If any
8043              of the subfields is a floating point type, the struct/union
8044              cannot be an integer type.  */
8045
8046           /* For each field in the object, check:
8047              1) Is it FP? --> yes, nRc = 1;
8048              2) Is it addressable (bitpos != 0) and
8049              not packed (bitsize == 0)?
8050              --> yes, nRc = 1
8051           */
8052
8053           for (i = 0; i < TYPE_NFIELDS (type); i++)
8054             {
8055               enum type_code field_type_code;
8056
8057               field_type_code
8058                 = TYPE_CODE (check_typedef (TYPE_FIELD_TYPE (type,
8059                                                              i)));
8060
8061               /* Is it a floating point type field?  */
8062               if (field_type_code == TYPE_CODE_FLT)
8063                 {
8064                   nRc = 1;
8065                   break;
8066                 }
8067
8068               /* If bitpos != 0, then we have to care about it.  */
8069               if (TYPE_FIELD_BITPOS (type, i) != 0)
8070                 {
8071                   /* Bitfields are not addressable.  If the field bitsize is 
8072                      zero, then the field is not packed.  Hence it cannot be
8073                      a bitfield or any other packed type.  */
8074                   if (TYPE_FIELD_BITSIZE (type, i) == 0)
8075                     {
8076                       nRc = 1;
8077                       break;
8078                     }
8079                 }
8080             }
8081         }
8082
8083       return nRc;
8084     }
8085 }
8086
8087 /* Write into appropriate registers a function return value of type
8088    TYPE, given in virtual format.  */
8089
8090 static void
8091 arm_store_return_value (struct type *type, struct regcache *regs,
8092                         const gdb_byte *valbuf)
8093 {
8094   struct gdbarch *gdbarch = regs->arch ();
8095   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
8096
8097   if (TYPE_CODE (type) == TYPE_CODE_FLT)
8098     {
8099       gdb_byte buf[FP_REGISTER_SIZE];
8100
8101       switch (gdbarch_tdep (gdbarch)->fp_model)
8102         {
8103         case ARM_FLOAT_FPA:
8104
8105           target_float_convert (valbuf, type, buf, arm_ext_type (gdbarch));
8106           regs->cooked_write (ARM_F0_REGNUM, buf);
8107           break;
8108
8109         case ARM_FLOAT_SOFT_FPA:
8110         case ARM_FLOAT_SOFT_VFP:
8111           /* ARM_FLOAT_VFP can arise if this is a variadic function so
8112              not using the VFP ABI code.  */
8113         case ARM_FLOAT_VFP:
8114           regs->cooked_write (ARM_A1_REGNUM, valbuf);
8115           if (TYPE_LENGTH (type) > 4)
8116             regs->cooked_write (ARM_A1_REGNUM + 1, valbuf + INT_REGISTER_SIZE);
8117           break;
8118
8119         default:
8120           internal_error (__FILE__, __LINE__,
8121                           _("arm_store_return_value: Floating "
8122                             "point model not supported"));
8123           break;
8124         }
8125     }
8126   else if (TYPE_CODE (type) == TYPE_CODE_INT
8127            || TYPE_CODE (type) == TYPE_CODE_CHAR
8128            || TYPE_CODE (type) == TYPE_CODE_BOOL
8129            || TYPE_CODE (type) == TYPE_CODE_PTR
8130            || TYPE_IS_REFERENCE (type)
8131            || TYPE_CODE (type) == TYPE_CODE_ENUM)
8132     {
8133       if (TYPE_LENGTH (type) <= 4)
8134         {
8135           /* Values of one word or less are zero/sign-extended and
8136              returned in r0.  */
8137           bfd_byte tmpbuf[INT_REGISTER_SIZE];
8138           LONGEST val = unpack_long (type, valbuf);
8139
8140           store_signed_integer (tmpbuf, INT_REGISTER_SIZE, byte_order, val);
8141           regs->cooked_write (ARM_A1_REGNUM, tmpbuf);
8142         }
8143       else
8144         {
8145           /* Integral values greater than one word are stored in consecutive
8146              registers starting with r0.  This will always be a multiple of
8147              the regiser size.  */
8148           int len = TYPE_LENGTH (type);
8149           int regno = ARM_A1_REGNUM;
8150
8151           while (len > 0)
8152             {
8153               regs->cooked_write (regno++, valbuf);
8154               len -= INT_REGISTER_SIZE;
8155               valbuf += INT_REGISTER_SIZE;
8156             }
8157         }
8158     }
8159   else
8160     {
8161       /* For a structure or union the behaviour is as if the value had
8162          been stored to word-aligned memory and then loaded into 
8163          registers with 32-bit load instruction(s).  */
8164       int len = TYPE_LENGTH (type);
8165       int regno = ARM_A1_REGNUM;
8166       bfd_byte tmpbuf[INT_REGISTER_SIZE];
8167
8168       while (len > 0)
8169         {
8170           memcpy (tmpbuf, valbuf,
8171                   len > INT_REGISTER_SIZE ? INT_REGISTER_SIZE : len);
8172           regs->cooked_write (regno++, tmpbuf);
8173           len -= INT_REGISTER_SIZE;
8174           valbuf += INT_REGISTER_SIZE;
8175         }
8176     }
8177 }
8178
8179
8180 /* Handle function return values.  */
8181
8182 static enum return_value_convention
8183 arm_return_value (struct gdbarch *gdbarch, struct value *function,
8184                   struct type *valtype, struct regcache *regcache,
8185                   gdb_byte *readbuf, const gdb_byte *writebuf)
8186 {
8187   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
8188   struct type *func_type = function ? value_type (function) : NULL;
8189   enum arm_vfp_cprc_base_type vfp_base_type;
8190   int vfp_base_count;
8191
8192   if (arm_vfp_abi_for_function (gdbarch, func_type)
8193       && arm_vfp_call_candidate (valtype, &vfp_base_type, &vfp_base_count))
8194     {
8195       int reg_char = arm_vfp_cprc_reg_char (vfp_base_type);
8196       int unit_length = arm_vfp_cprc_unit_length (vfp_base_type);
8197       int i;
8198       for (i = 0; i < vfp_base_count; i++)
8199         {
8200           if (reg_char == 'q')
8201             {
8202               if (writebuf)
8203                 arm_neon_quad_write (gdbarch, regcache, i,
8204                                      writebuf + i * unit_length);
8205
8206               if (readbuf)
8207                 arm_neon_quad_read (gdbarch, regcache, i,
8208                                     readbuf + i * unit_length);
8209             }
8210           else
8211             {
8212               char name_buf[4];
8213               int regnum;
8214
8215               xsnprintf (name_buf, sizeof (name_buf), "%c%d", reg_char, i);
8216               regnum = user_reg_map_name_to_regnum (gdbarch, name_buf,
8217                                                     strlen (name_buf));
8218               if (writebuf)
8219                 regcache->cooked_write (regnum, writebuf + i * unit_length);
8220               if (readbuf)
8221                 regcache->cooked_read (regnum, readbuf + i * unit_length);
8222             }
8223         }
8224       return RETURN_VALUE_REGISTER_CONVENTION;
8225     }
8226
8227   if (TYPE_CODE (valtype) == TYPE_CODE_STRUCT
8228       || TYPE_CODE (valtype) == TYPE_CODE_UNION
8229       || TYPE_CODE (valtype) == TYPE_CODE_ARRAY)
8230     {
8231       if (tdep->struct_return == pcc_struct_return
8232           || arm_return_in_memory (gdbarch, valtype))
8233         return RETURN_VALUE_STRUCT_CONVENTION;
8234     }
8235   else if (TYPE_CODE (valtype) == TYPE_CODE_COMPLEX)
8236     {
8237       if (arm_return_in_memory (gdbarch, valtype))
8238         return RETURN_VALUE_STRUCT_CONVENTION;
8239     }
8240
8241   if (writebuf)
8242     arm_store_return_value (valtype, regcache, writebuf);
8243
8244   if (readbuf)
8245     arm_extract_return_value (valtype, regcache, readbuf);
8246
8247   return RETURN_VALUE_REGISTER_CONVENTION;
8248 }
8249
8250
8251 static int
8252 arm_get_longjmp_target (struct frame_info *frame, CORE_ADDR *pc)
8253 {
8254   struct gdbarch *gdbarch = get_frame_arch (frame);
8255   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
8256   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
8257   CORE_ADDR jb_addr;
8258   gdb_byte buf[INT_REGISTER_SIZE];
8259   
8260   jb_addr = get_frame_register_unsigned (frame, ARM_A1_REGNUM);
8261
8262   if (target_read_memory (jb_addr + tdep->jb_pc * tdep->jb_elt_size, buf,
8263                           INT_REGISTER_SIZE))
8264     return 0;
8265
8266   *pc = extract_unsigned_integer (buf, INT_REGISTER_SIZE, byte_order);
8267   return 1;
8268 }
8269
8270 /* Recognize GCC and GNU ld's trampolines.  If we are in a trampoline,
8271    return the target PC.  Otherwise return 0.  */
8272
8273 CORE_ADDR
8274 arm_skip_stub (struct frame_info *frame, CORE_ADDR pc)
8275 {
8276   const char *name;
8277   int namelen;
8278   CORE_ADDR start_addr;
8279
8280   /* Find the starting address and name of the function containing the PC.  */
8281   if (find_pc_partial_function (pc, &name, &start_addr, NULL) == 0)
8282     {
8283       /* Trampoline 'bx reg' doesn't belong to any functions.  Do the
8284          check here.  */
8285       start_addr = arm_skip_bx_reg (frame, pc);
8286       if (start_addr != 0)
8287         return start_addr;
8288
8289       return 0;
8290     }
8291
8292   /* If PC is in a Thumb call or return stub, return the address of the
8293      target PC, which is in a register.  The thunk functions are called
8294      _call_via_xx, where x is the register name.  The possible names
8295      are r0-r9, sl, fp, ip, sp, and lr.  ARM RealView has similar
8296      functions, named __ARM_call_via_r[0-7].  */
8297   if (startswith (name, "_call_via_")
8298       || startswith (name, "__ARM_call_via_"))
8299     {
8300       /* Use the name suffix to determine which register contains the
8301          target PC.  */
8302       static const char *table[15] =
8303       {"r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
8304        "r8", "r9", "sl", "fp", "ip", "sp", "lr"
8305       };
8306       int regno;
8307       int offset = strlen (name) - 2;
8308
8309       for (regno = 0; regno <= 14; regno++)
8310         if (strcmp (&name[offset], table[regno]) == 0)
8311           return get_frame_register_unsigned (frame, regno);
8312     }
8313
8314   /* GNU ld generates __foo_from_arm or __foo_from_thumb for
8315      non-interworking calls to foo.  We could decode the stubs
8316      to find the target but it's easier to use the symbol table.  */
8317   namelen = strlen (name);
8318   if (name[0] == '_' && name[1] == '_'
8319       && ((namelen > 2 + strlen ("_from_thumb")
8320            && startswith (name + namelen - strlen ("_from_thumb"), "_from_thumb"))
8321           || (namelen > 2 + strlen ("_from_arm")
8322               && startswith (name + namelen - strlen ("_from_arm"), "_from_arm"))))
8323     {
8324       char *target_name;
8325       int target_len = namelen - 2;
8326       struct bound_minimal_symbol minsym;
8327       struct objfile *objfile;
8328       struct obj_section *sec;
8329
8330       if (name[namelen - 1] == 'b')
8331         target_len -= strlen ("_from_thumb");
8332       else
8333         target_len -= strlen ("_from_arm");
8334
8335       target_name = (char *) alloca (target_len + 1);
8336       memcpy (target_name, name + 2, target_len);
8337       target_name[target_len] = '\0';
8338
8339       sec = find_pc_section (pc);
8340       objfile = (sec == NULL) ? NULL : sec->objfile;
8341       minsym = lookup_minimal_symbol (target_name, NULL, objfile);
8342       if (minsym.minsym != NULL)
8343         return BMSYMBOL_VALUE_ADDRESS (minsym);
8344       else
8345         return 0;
8346     }
8347
8348   return 0;                     /* not a stub */
8349 }
8350
8351 static void
8352 set_arm_command (const char *args, int from_tty)
8353 {
8354   printf_unfiltered (_("\
8355 \"set arm\" must be followed by an apporpriate subcommand.\n"));
8356   help_list (setarmcmdlist, "set arm ", all_commands, gdb_stdout);
8357 }
8358
8359 static void
8360 show_arm_command (const char *args, int from_tty)
8361 {
8362   cmd_show_list (showarmcmdlist, from_tty, "");
8363 }
8364
8365 static void
8366 arm_update_current_architecture (void)
8367 {
8368   struct gdbarch_info info;
8369
8370   /* If the current architecture is not ARM, we have nothing to do.  */
8371   if (gdbarch_bfd_arch_info (target_gdbarch ())->arch != bfd_arch_arm)
8372     return;
8373
8374   /* Update the architecture.  */
8375   gdbarch_info_init (&info);
8376
8377   if (!gdbarch_update_p (info))
8378     internal_error (__FILE__, __LINE__, _("could not update architecture"));
8379 }
8380
8381 static void
8382 set_fp_model_sfunc (const char *args, int from_tty,
8383                     struct cmd_list_element *c)
8384 {
8385   int fp_model;
8386
8387   for (fp_model = ARM_FLOAT_AUTO; fp_model != ARM_FLOAT_LAST; fp_model++)
8388     if (strcmp (current_fp_model, fp_model_strings[fp_model]) == 0)
8389       {
8390         arm_fp_model = (enum arm_float_model) fp_model;
8391         break;
8392       }
8393
8394   if (fp_model == ARM_FLOAT_LAST)
8395     internal_error (__FILE__, __LINE__, _("Invalid fp model accepted: %s."),
8396                     current_fp_model);
8397
8398   arm_update_current_architecture ();
8399 }
8400
8401 static void
8402 show_fp_model (struct ui_file *file, int from_tty,
8403                struct cmd_list_element *c, const char *value)
8404 {
8405   struct gdbarch_tdep *tdep = gdbarch_tdep (target_gdbarch ());
8406
8407   if (arm_fp_model == ARM_FLOAT_AUTO
8408       && gdbarch_bfd_arch_info (target_gdbarch ())->arch == bfd_arch_arm)
8409     fprintf_filtered (file, _("\
8410 The current ARM floating point model is \"auto\" (currently \"%s\").\n"),
8411                       fp_model_strings[tdep->fp_model]);
8412   else
8413     fprintf_filtered (file, _("\
8414 The current ARM floating point model is \"%s\".\n"),
8415                       fp_model_strings[arm_fp_model]);
8416 }
8417
8418 static void
8419 arm_set_abi (const char *args, int from_tty,
8420              struct cmd_list_element *c)
8421 {
8422   int arm_abi;
8423
8424   for (arm_abi = ARM_ABI_AUTO; arm_abi != ARM_ABI_LAST; arm_abi++)
8425     if (strcmp (arm_abi_string, arm_abi_strings[arm_abi]) == 0)
8426       {
8427         arm_abi_global = (enum arm_abi_kind) arm_abi;
8428         break;
8429       }
8430
8431   if (arm_abi == ARM_ABI_LAST)
8432     internal_error (__FILE__, __LINE__, _("Invalid ABI accepted: %s."),
8433                     arm_abi_string);
8434
8435   arm_update_current_architecture ();
8436 }
8437
8438 static void
8439 arm_show_abi (struct ui_file *file, int from_tty,
8440              struct cmd_list_element *c, const char *value)
8441 {
8442   struct gdbarch_tdep *tdep = gdbarch_tdep (target_gdbarch ());
8443
8444   if (arm_abi_global == ARM_ABI_AUTO
8445       && gdbarch_bfd_arch_info (target_gdbarch ())->arch == bfd_arch_arm)
8446     fprintf_filtered (file, _("\
8447 The current ARM ABI is \"auto\" (currently \"%s\").\n"),
8448                       arm_abi_strings[tdep->arm_abi]);
8449   else
8450     fprintf_filtered (file, _("The current ARM ABI is \"%s\".\n"),
8451                       arm_abi_string);
8452 }
8453
8454 static void
8455 arm_show_fallback_mode (struct ui_file *file, int from_tty,
8456                         struct cmd_list_element *c, const char *value)
8457 {
8458   fprintf_filtered (file,
8459                     _("The current execution mode assumed "
8460                       "(when symbols are unavailable) is \"%s\".\n"),
8461                     arm_fallback_mode_string);
8462 }
8463
8464 static void
8465 arm_show_force_mode (struct ui_file *file, int from_tty,
8466                      struct cmd_list_element *c, const char *value)
8467 {
8468   fprintf_filtered (file,
8469                     _("The current execution mode assumed "
8470                       "(even when symbols are available) is \"%s\".\n"),
8471                     arm_force_mode_string);
8472 }
8473
8474 /* If the user changes the register disassembly style used for info
8475    register and other commands, we have to also switch the style used
8476    in opcodes for disassembly output.  This function is run in the "set
8477    arm disassembly" command, and does that.  */
8478
8479 static void
8480 set_disassembly_style_sfunc (const char *args, int from_tty,
8481                              struct cmd_list_element *c)
8482 {
8483   /* Convert the short style name into the long style name (eg, reg-names-*)
8484      before calling the generic set_disassembler_options() function.  */
8485   std::string long_name = std::string ("reg-names-") + disassembly_style;
8486   set_disassembler_options (&long_name[0]);
8487 }
8488
8489 static void
8490 show_disassembly_style_sfunc (struct ui_file *file, int from_tty,
8491                               struct cmd_list_element *c, const char *value)
8492 {
8493   struct gdbarch *gdbarch = get_current_arch ();
8494   char *options = get_disassembler_options (gdbarch);
8495   const char *style = "";
8496   int len = 0;
8497   const char *opt;
8498
8499   FOR_EACH_DISASSEMBLER_OPTION (opt, options)
8500     if (CONST_STRNEQ (opt, "reg-names-"))
8501       {
8502         style = &opt[strlen ("reg-names-")];
8503         len = strcspn (style, ",");
8504       }
8505
8506   fprintf_unfiltered (file, "The disassembly style is \"%.*s\".\n", len, style);
8507 }
8508 \f
8509 /* Return the ARM register name corresponding to register I.  */
8510 static const char *
8511 arm_register_name (struct gdbarch *gdbarch, int i)
8512 {
8513   const int num_regs = gdbarch_num_regs (gdbarch);
8514
8515   if (gdbarch_tdep (gdbarch)->have_vfp_pseudos
8516       && i >= num_regs && i < num_regs + 32)
8517     {
8518       static const char *const vfp_pseudo_names[] = {
8519         "s0", "s1", "s2", "s3", "s4", "s5", "s6", "s7",
8520         "s8", "s9", "s10", "s11", "s12", "s13", "s14", "s15",
8521         "s16", "s17", "s18", "s19", "s20", "s21", "s22", "s23",
8522         "s24", "s25", "s26", "s27", "s28", "s29", "s30", "s31",
8523       };
8524
8525       return vfp_pseudo_names[i - num_regs];
8526     }
8527
8528   if (gdbarch_tdep (gdbarch)->have_neon_pseudos
8529       && i >= num_regs + 32 && i < num_regs + 32 + 16)
8530     {
8531       static const char *const neon_pseudo_names[] = {
8532         "q0", "q1", "q2", "q3", "q4", "q5", "q6", "q7",
8533         "q8", "q9", "q10", "q11", "q12", "q13", "q14", "q15",
8534       };
8535
8536       return neon_pseudo_names[i - num_regs - 32];
8537     }
8538
8539   if (i >= ARRAY_SIZE (arm_register_names))
8540     /* These registers are only supported on targets which supply
8541        an XML description.  */
8542     return "";
8543
8544   return arm_register_names[i];
8545 }
8546
8547 /* Test whether the coff symbol specific value corresponds to a Thumb
8548    function.  */
8549
8550 static int
8551 coff_sym_is_thumb (int val)
8552 {
8553   return (val == C_THUMBEXT
8554           || val == C_THUMBSTAT
8555           || val == C_THUMBEXTFUNC
8556           || val == C_THUMBSTATFUNC
8557           || val == C_THUMBLABEL);
8558 }
8559
8560 /* arm_coff_make_msymbol_special()
8561    arm_elf_make_msymbol_special()
8562    
8563    These functions test whether the COFF or ELF symbol corresponds to
8564    an address in thumb code, and set a "special" bit in a minimal
8565    symbol to indicate that it does.  */
8566    
8567 static void
8568 arm_elf_make_msymbol_special(asymbol *sym, struct minimal_symbol *msym)
8569 {
8570   elf_symbol_type *elfsym = (elf_symbol_type *) sym;
8571
8572   if (ARM_GET_SYM_BRANCH_TYPE (elfsym->internal_elf_sym.st_target_internal)
8573       == ST_BRANCH_TO_THUMB)
8574     MSYMBOL_SET_SPECIAL (msym);
8575 }
8576
8577 static void
8578 arm_coff_make_msymbol_special(int val, struct minimal_symbol *msym)
8579 {
8580   if (coff_sym_is_thumb (val))
8581     MSYMBOL_SET_SPECIAL (msym);
8582 }
8583
8584 static void
8585 arm_objfile_data_free (struct objfile *objfile, void *arg)
8586 {
8587   struct arm_per_objfile *data = (struct arm_per_objfile *) arg;
8588   unsigned int i;
8589
8590   for (i = 0; i < objfile->obfd->section_count; i++)
8591     VEC_free (arm_mapping_symbol_s, data->section_maps[i]);
8592 }
8593
8594 static void
8595 arm_record_special_symbol (struct gdbarch *gdbarch, struct objfile *objfile,
8596                            asymbol *sym)
8597 {
8598   const char *name = bfd_asymbol_name (sym);
8599   struct arm_per_objfile *data;
8600   VEC(arm_mapping_symbol_s) **map_p;
8601   struct arm_mapping_symbol new_map_sym;
8602
8603   gdb_assert (name[0] == '$');
8604   if (name[1] != 'a' && name[1] != 't' && name[1] != 'd')
8605     return;
8606
8607   data = (struct arm_per_objfile *) objfile_data (objfile,
8608                                                   arm_objfile_data_key);
8609   if (data == NULL)
8610     {
8611       data = OBSTACK_ZALLOC (&objfile->objfile_obstack,
8612                              struct arm_per_objfile);
8613       set_objfile_data (objfile, arm_objfile_data_key, data);
8614       data->section_maps = OBSTACK_CALLOC (&objfile->objfile_obstack,
8615                                            objfile->obfd->section_count,
8616                                            VEC(arm_mapping_symbol_s) *);
8617     }
8618   map_p = &data->section_maps[bfd_get_section (sym)->index];
8619
8620   new_map_sym.value = sym->value;
8621   new_map_sym.type = name[1];
8622
8623   /* Assume that most mapping symbols appear in order of increasing
8624      value.  If they were randomly distributed, it would be faster to
8625      always push here and then sort at first use.  */
8626   if (!VEC_empty (arm_mapping_symbol_s, *map_p))
8627     {
8628       struct arm_mapping_symbol *prev_map_sym;
8629
8630       prev_map_sym = VEC_last (arm_mapping_symbol_s, *map_p);
8631       if (prev_map_sym->value >= sym->value)
8632         {
8633           unsigned int idx;
8634           idx = VEC_lower_bound (arm_mapping_symbol_s, *map_p, &new_map_sym,
8635                                  arm_compare_mapping_symbols);
8636           VEC_safe_insert (arm_mapping_symbol_s, *map_p, idx, &new_map_sym);
8637           return;
8638         }
8639     }
8640
8641   VEC_safe_push (arm_mapping_symbol_s, *map_p, &new_map_sym);
8642 }
8643
8644 static void
8645 arm_write_pc (struct regcache *regcache, CORE_ADDR pc)
8646 {
8647   struct gdbarch *gdbarch = regcache->arch ();
8648   regcache_cooked_write_unsigned (regcache, ARM_PC_REGNUM, pc);
8649
8650   /* If necessary, set the T bit.  */
8651   if (arm_apcs_32)
8652     {
8653       ULONGEST val, t_bit;
8654       regcache_cooked_read_unsigned (regcache, ARM_PS_REGNUM, &val);
8655       t_bit = arm_psr_thumb_bit (gdbarch);
8656       if (arm_pc_is_thumb (gdbarch, pc))
8657         regcache_cooked_write_unsigned (regcache, ARM_PS_REGNUM,
8658                                         val | t_bit);
8659       else
8660         regcache_cooked_write_unsigned (regcache, ARM_PS_REGNUM,
8661                                         val & ~t_bit);
8662     }
8663 }
8664
8665 /* Read the contents of a NEON quad register, by reading from two
8666    double registers.  This is used to implement the quad pseudo
8667    registers, and for argument passing in case the quad registers are
8668    missing; vectors are passed in quad registers when using the VFP
8669    ABI, even if a NEON unit is not present.  REGNUM is the index of
8670    the quad register, in [0, 15].  */
8671
8672 static enum register_status
8673 arm_neon_quad_read (struct gdbarch *gdbarch, readable_regcache *regcache,
8674                     int regnum, gdb_byte *buf)
8675 {
8676   char name_buf[4];
8677   gdb_byte reg_buf[8];
8678   int offset, double_regnum;
8679   enum register_status status;
8680
8681   xsnprintf (name_buf, sizeof (name_buf), "d%d", regnum << 1);
8682   double_regnum = user_reg_map_name_to_regnum (gdbarch, name_buf,
8683                                                strlen (name_buf));
8684
8685   /* d0 is always the least significant half of q0.  */
8686   if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG)
8687     offset = 8;
8688   else
8689     offset = 0;
8690
8691   status = regcache->raw_read (double_regnum, reg_buf);
8692   if (status != REG_VALID)
8693     return status;
8694   memcpy (buf + offset, reg_buf, 8);
8695
8696   offset = 8 - offset;
8697   status = regcache->raw_read (double_regnum + 1, reg_buf);
8698   if (status != REG_VALID)
8699     return status;
8700   memcpy (buf + offset, reg_buf, 8);
8701
8702   return REG_VALID;
8703 }
8704
8705 static enum register_status
8706 arm_pseudo_read (struct gdbarch *gdbarch, readable_regcache *regcache,
8707                  int regnum, gdb_byte *buf)
8708 {
8709   const int num_regs = gdbarch_num_regs (gdbarch);
8710   char name_buf[4];
8711   gdb_byte reg_buf[8];
8712   int offset, double_regnum;
8713
8714   gdb_assert (regnum >= num_regs);
8715   regnum -= num_regs;
8716
8717   if (gdbarch_tdep (gdbarch)->have_neon_pseudos && regnum >= 32 && regnum < 48)
8718     /* Quad-precision register.  */
8719     return arm_neon_quad_read (gdbarch, regcache, regnum - 32, buf);
8720   else
8721     {
8722       enum register_status status;
8723
8724       /* Single-precision register.  */
8725       gdb_assert (regnum < 32);
8726
8727       /* s0 is always the least significant half of d0.  */
8728       if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG)
8729         offset = (regnum & 1) ? 0 : 4;
8730       else
8731         offset = (regnum & 1) ? 4 : 0;
8732
8733       xsnprintf (name_buf, sizeof (name_buf), "d%d", regnum >> 1);
8734       double_regnum = user_reg_map_name_to_regnum (gdbarch, name_buf,
8735                                                    strlen (name_buf));
8736
8737       status = regcache->raw_read (double_regnum, reg_buf);
8738       if (status == REG_VALID)
8739         memcpy (buf, reg_buf + offset, 4);
8740       return status;
8741     }
8742 }
8743
8744 /* Store the contents of BUF to a NEON quad register, by writing to
8745    two double registers.  This is used to implement the quad pseudo
8746    registers, and for argument passing in case the quad registers are
8747    missing; vectors are passed in quad registers when using the VFP
8748    ABI, even if a NEON unit is not present.  REGNUM is the index
8749    of the quad register, in [0, 15].  */
8750
8751 static void
8752 arm_neon_quad_write (struct gdbarch *gdbarch, struct regcache *regcache,
8753                      int regnum, const gdb_byte *buf)
8754 {
8755   char name_buf[4];
8756   int offset, double_regnum;
8757
8758   xsnprintf (name_buf, sizeof (name_buf), "d%d", regnum << 1);
8759   double_regnum = user_reg_map_name_to_regnum (gdbarch, name_buf,
8760                                                strlen (name_buf));
8761
8762   /* d0 is always the least significant half of q0.  */
8763   if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG)
8764     offset = 8;
8765   else
8766     offset = 0;
8767
8768   regcache->raw_write (double_regnum, buf + offset);
8769   offset = 8 - offset;
8770   regcache->raw_write (double_regnum + 1, buf + offset);
8771 }
8772
8773 static void
8774 arm_pseudo_write (struct gdbarch *gdbarch, struct regcache *regcache,
8775                   int regnum, const gdb_byte *buf)
8776 {
8777   const int num_regs = gdbarch_num_regs (gdbarch);
8778   char name_buf[4];
8779   gdb_byte reg_buf[8];
8780   int offset, double_regnum;
8781
8782   gdb_assert (regnum >= num_regs);
8783   regnum -= num_regs;
8784
8785   if (gdbarch_tdep (gdbarch)->have_neon_pseudos && regnum >= 32 && regnum < 48)
8786     /* Quad-precision register.  */
8787     arm_neon_quad_write (gdbarch, regcache, regnum - 32, buf);
8788   else
8789     {
8790       /* Single-precision register.  */
8791       gdb_assert (regnum < 32);
8792
8793       /* s0 is always the least significant half of d0.  */
8794       if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG)
8795         offset = (regnum & 1) ? 0 : 4;
8796       else
8797         offset = (regnum & 1) ? 4 : 0;
8798
8799       xsnprintf (name_buf, sizeof (name_buf), "d%d", regnum >> 1);
8800       double_regnum = user_reg_map_name_to_regnum (gdbarch, name_buf,
8801                                                    strlen (name_buf));
8802
8803       regcache->raw_read (double_regnum, reg_buf);
8804       memcpy (reg_buf + offset, buf, 4);
8805       regcache->raw_write (double_regnum, reg_buf);
8806     }
8807 }
8808
8809 static struct value *
8810 value_of_arm_user_reg (struct frame_info *frame, const void *baton)
8811 {
8812   const int *reg_p = (const int *) baton;
8813   return value_of_register (*reg_p, frame);
8814 }
8815 \f
8816 static enum gdb_osabi
8817 arm_elf_osabi_sniffer (bfd *abfd)
8818 {
8819   unsigned int elfosabi;
8820   enum gdb_osabi osabi = GDB_OSABI_UNKNOWN;
8821
8822   elfosabi = elf_elfheader (abfd)->e_ident[EI_OSABI];
8823
8824   if (elfosabi == ELFOSABI_ARM)
8825     /* GNU tools use this value.  Check note sections in this case,
8826        as well.  */
8827     bfd_map_over_sections (abfd,
8828                            generic_elf_osabi_sniff_abi_tag_sections, 
8829                            &osabi);
8830
8831   /* Anything else will be handled by the generic ELF sniffer.  */
8832   return osabi;
8833 }
8834
8835 static int
8836 arm_register_reggroup_p (struct gdbarch *gdbarch, int regnum,
8837                           struct reggroup *group)
8838 {
8839   /* FPS register's type is INT, but belongs to float_reggroup.  Beside
8840      this, FPS register belongs to save_regroup, restore_reggroup, and
8841      all_reggroup, of course.  */
8842   if (regnum == ARM_FPS_REGNUM)
8843     return (group == float_reggroup
8844             || group == save_reggroup
8845             || group == restore_reggroup
8846             || group == all_reggroup);
8847   else
8848     return default_register_reggroup_p (gdbarch, regnum, group);
8849 }
8850
8851 \f
8852 /* For backward-compatibility we allow two 'g' packet lengths with
8853    the remote protocol depending on whether FPA registers are
8854    supplied.  M-profile targets do not have FPA registers, but some
8855    stubs already exist in the wild which use a 'g' packet which
8856    supplies them albeit with dummy values.  The packet format which
8857    includes FPA registers should be considered deprecated for
8858    M-profile targets.  */
8859
8860 static void
8861 arm_register_g_packet_guesses (struct gdbarch *gdbarch)
8862 {
8863   if (gdbarch_tdep (gdbarch)->is_m)
8864     {
8865       /* If we know from the executable this is an M-profile target,
8866          cater for remote targets whose register set layout is the
8867          same as the FPA layout.  */
8868       register_remote_g_packet_guess (gdbarch,
8869                                       /* r0-r12,sp,lr,pc; f0-f7; fps,xpsr */
8870                                       (16 * INT_REGISTER_SIZE)
8871                                       + (8 * FP_REGISTER_SIZE)
8872                                       + (2 * INT_REGISTER_SIZE),
8873                                       tdesc_arm_with_m_fpa_layout);
8874
8875       /* The regular M-profile layout.  */
8876       register_remote_g_packet_guess (gdbarch,
8877                                       /* r0-r12,sp,lr,pc; xpsr */
8878                                       (16 * INT_REGISTER_SIZE)
8879                                       + INT_REGISTER_SIZE,
8880                                       tdesc_arm_with_m);
8881
8882       /* M-profile plus M4F VFP.  */
8883       register_remote_g_packet_guess (gdbarch,
8884                                       /* r0-r12,sp,lr,pc; d0-d15; fpscr,xpsr */
8885                                       (16 * INT_REGISTER_SIZE)
8886                                       + (16 * VFP_REGISTER_SIZE)
8887                                       + (2 * INT_REGISTER_SIZE),
8888                                       tdesc_arm_with_m_vfp_d16);
8889     }
8890
8891   /* Otherwise we don't have a useful guess.  */
8892 }
8893
8894 /* Implement the code_of_frame_writable gdbarch method.  */
8895
8896 static int
8897 arm_code_of_frame_writable (struct gdbarch *gdbarch, struct frame_info *frame)
8898 {
8899   if (gdbarch_tdep (gdbarch)->is_m
8900       && get_frame_type (frame) == SIGTRAMP_FRAME)
8901     {
8902       /* M-profile exception frames return to some magic PCs, where
8903          isn't writable at all.  */
8904       return 0;
8905     }
8906   else
8907     return 1;
8908 }
8909
8910 \f
8911 /* Initialize the current architecture based on INFO.  If possible,
8912    re-use an architecture from ARCHES, which is a list of
8913    architectures already created during this debugging session.
8914
8915    Called e.g. at program startup, when reading a core file, and when
8916    reading a binary file.  */
8917
8918 static struct gdbarch *
8919 arm_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
8920 {
8921   struct gdbarch_tdep *tdep;
8922   struct gdbarch *gdbarch;
8923   struct gdbarch_list *best_arch;
8924   enum arm_abi_kind arm_abi = arm_abi_global;
8925   enum arm_float_model fp_model = arm_fp_model;
8926   struct tdesc_arch_data *tdesc_data = NULL;
8927   int i, is_m = 0;
8928   int vfp_register_count = 0, have_vfp_pseudos = 0, have_neon_pseudos = 0;
8929   int have_wmmx_registers = 0;
8930   int have_neon = 0;
8931   int have_fpa_registers = 1;
8932   const struct target_desc *tdesc = info.target_desc;
8933
8934   /* If we have an object to base this architecture on, try to determine
8935      its ABI.  */
8936
8937   if (arm_abi == ARM_ABI_AUTO && info.abfd != NULL)
8938     {
8939       int ei_osabi, e_flags;
8940
8941       switch (bfd_get_flavour (info.abfd))
8942         {
8943         case bfd_target_coff_flavour:
8944           /* Assume it's an old APCS-style ABI.  */
8945           /* XXX WinCE?  */
8946           arm_abi = ARM_ABI_APCS;
8947           break;
8948
8949         case bfd_target_elf_flavour:
8950           ei_osabi = elf_elfheader (info.abfd)->e_ident[EI_OSABI];
8951           e_flags = elf_elfheader (info.abfd)->e_flags;
8952
8953           if (ei_osabi == ELFOSABI_ARM)
8954             {
8955               /* GNU tools used to use this value, but do not for EABI
8956                  objects.  There's nowhere to tag an EABI version
8957                  anyway, so assume APCS.  */
8958               arm_abi = ARM_ABI_APCS;
8959             }
8960           else if (ei_osabi == ELFOSABI_NONE || ei_osabi == ELFOSABI_GNU)
8961             {
8962               int eabi_ver = EF_ARM_EABI_VERSION (e_flags);
8963
8964               switch (eabi_ver)
8965                 {
8966                 case EF_ARM_EABI_UNKNOWN:
8967                   /* Assume GNU tools.  */
8968                   arm_abi = ARM_ABI_APCS;
8969                   break;
8970
8971                 case EF_ARM_EABI_VER4:
8972                 case EF_ARM_EABI_VER5:
8973                   arm_abi = ARM_ABI_AAPCS;
8974                   /* EABI binaries default to VFP float ordering.
8975                      They may also contain build attributes that can
8976                      be used to identify if the VFP argument-passing
8977                      ABI is in use.  */
8978                   if (fp_model == ARM_FLOAT_AUTO)
8979                     {
8980 #ifdef HAVE_ELF
8981                       switch (bfd_elf_get_obj_attr_int (info.abfd,
8982                                                         OBJ_ATTR_PROC,
8983                                                         Tag_ABI_VFP_args))
8984                         {
8985                         case AEABI_VFP_args_base:
8986                           /* "The user intended FP parameter/result
8987                              passing to conform to AAPCS, base
8988                              variant".  */
8989                           fp_model = ARM_FLOAT_SOFT_VFP;
8990                           break;
8991                         case AEABI_VFP_args_vfp:
8992                           /* "The user intended FP parameter/result
8993                              passing to conform to AAPCS, VFP
8994                              variant".  */
8995                           fp_model = ARM_FLOAT_VFP;
8996                           break;
8997                         case AEABI_VFP_args_toolchain:
8998                           /* "The user intended FP parameter/result
8999                              passing to conform to tool chain-specific
9000                              conventions" - we don't know any such
9001                              conventions, so leave it as "auto".  */
9002                           break;
9003                         case AEABI_VFP_args_compatible:
9004                           /* "Code is compatible with both the base
9005                              and VFP variants; the user did not permit
9006                              non-variadic functions to pass FP
9007                              parameters/results" - leave it as
9008                              "auto".  */
9009                           break;
9010                         default:
9011                           /* Attribute value not mentioned in the
9012                              November 2012 ABI, so leave it as
9013                              "auto".  */
9014                           break;
9015                         }
9016 #else
9017                       fp_model = ARM_FLOAT_SOFT_VFP;
9018 #endif
9019                     }
9020                   break;
9021
9022                 default:
9023                   /* Leave it as "auto".  */
9024                   warning (_("unknown ARM EABI version 0x%x"), eabi_ver);
9025                   break;
9026                 }
9027
9028 #ifdef HAVE_ELF
9029               /* Detect M-profile programs.  This only works if the
9030                  executable file includes build attributes; GCC does
9031                  copy them to the executable, but e.g. RealView does
9032                  not.  */
9033               int attr_arch
9034                 = bfd_elf_get_obj_attr_int (info.abfd, OBJ_ATTR_PROC,
9035                                             Tag_CPU_arch);
9036               int attr_profile
9037                 = bfd_elf_get_obj_attr_int (info.abfd, OBJ_ATTR_PROC,
9038                                             Tag_CPU_arch_profile);
9039
9040               /* GCC specifies the profile for v6-M; RealView only
9041                  specifies the profile for architectures starting with
9042                  V7 (as opposed to architectures with a tag
9043                  numerically greater than TAG_CPU_ARCH_V7).  */
9044               if (!tdesc_has_registers (tdesc)
9045                   && (attr_arch == TAG_CPU_ARCH_V6_M
9046                       || attr_arch == TAG_CPU_ARCH_V6S_M
9047                       || attr_profile == 'M'))
9048                 is_m = 1;
9049 #endif
9050             }
9051
9052           if (fp_model == ARM_FLOAT_AUTO)
9053             {
9054               switch (e_flags & (EF_ARM_SOFT_FLOAT | EF_ARM_VFP_FLOAT))
9055                 {
9056                 case 0:
9057                   /* Leave it as "auto".  Strictly speaking this case
9058                      means FPA, but almost nobody uses that now, and
9059                      many toolchains fail to set the appropriate bits
9060                      for the floating-point model they use.  */
9061                   break;
9062                 case EF_ARM_SOFT_FLOAT:
9063                   fp_model = ARM_FLOAT_SOFT_FPA;
9064                   break;
9065                 case EF_ARM_VFP_FLOAT:
9066                   fp_model = ARM_FLOAT_VFP;
9067                   break;
9068                 case EF_ARM_SOFT_FLOAT | EF_ARM_VFP_FLOAT:
9069                   fp_model = ARM_FLOAT_SOFT_VFP;
9070                   break;
9071                 }
9072             }
9073
9074           if (e_flags & EF_ARM_BE8)
9075             info.byte_order_for_code = BFD_ENDIAN_LITTLE;
9076
9077           break;
9078
9079         default:
9080           /* Leave it as "auto".  */
9081           break;
9082         }
9083     }
9084
9085   /* Check any target description for validity.  */
9086   if (tdesc_has_registers (tdesc))
9087     {
9088       /* For most registers we require GDB's default names; but also allow
9089          the numeric names for sp / lr / pc, as a convenience.  */
9090       static const char *const arm_sp_names[] = { "r13", "sp", NULL };
9091       static const char *const arm_lr_names[] = { "r14", "lr", NULL };
9092       static const char *const arm_pc_names[] = { "r15", "pc", NULL };
9093
9094       const struct tdesc_feature *feature;
9095       int valid_p;
9096
9097       feature = tdesc_find_feature (tdesc,
9098                                     "org.gnu.gdb.arm.core");
9099       if (feature == NULL)
9100         {
9101           feature = tdesc_find_feature (tdesc,
9102                                         "org.gnu.gdb.arm.m-profile");
9103           if (feature == NULL)
9104             return NULL;
9105           else
9106             is_m = 1;
9107         }
9108
9109       tdesc_data = tdesc_data_alloc ();
9110
9111       valid_p = 1;
9112       for (i = 0; i < ARM_SP_REGNUM; i++)
9113         valid_p &= tdesc_numbered_register (feature, tdesc_data, i,
9114                                             arm_register_names[i]);
9115       valid_p &= tdesc_numbered_register_choices (feature, tdesc_data,
9116                                                   ARM_SP_REGNUM,
9117                                                   arm_sp_names);
9118       valid_p &= tdesc_numbered_register_choices (feature, tdesc_data,
9119                                                   ARM_LR_REGNUM,
9120                                                   arm_lr_names);
9121       valid_p &= tdesc_numbered_register_choices (feature, tdesc_data,
9122                                                   ARM_PC_REGNUM,
9123                                                   arm_pc_names);
9124       if (is_m)
9125         valid_p &= tdesc_numbered_register (feature, tdesc_data,
9126                                             ARM_PS_REGNUM, "xpsr");
9127       else
9128         valid_p &= tdesc_numbered_register (feature, tdesc_data,
9129                                             ARM_PS_REGNUM, "cpsr");
9130
9131       if (!valid_p)
9132         {
9133           tdesc_data_cleanup (tdesc_data);
9134           return NULL;
9135         }
9136
9137       feature = tdesc_find_feature (tdesc,
9138                                     "org.gnu.gdb.arm.fpa");
9139       if (feature != NULL)
9140         {
9141           valid_p = 1;
9142           for (i = ARM_F0_REGNUM; i <= ARM_FPS_REGNUM; i++)
9143             valid_p &= tdesc_numbered_register (feature, tdesc_data, i,
9144                                                 arm_register_names[i]);
9145           if (!valid_p)
9146             {
9147               tdesc_data_cleanup (tdesc_data);
9148               return NULL;
9149             }
9150         }
9151       else
9152         have_fpa_registers = 0;
9153
9154       feature = tdesc_find_feature (tdesc,
9155                                     "org.gnu.gdb.xscale.iwmmxt");
9156       if (feature != NULL)
9157         {
9158           static const char *const iwmmxt_names[] = {
9159             "wR0", "wR1", "wR2", "wR3", "wR4", "wR5", "wR6", "wR7",
9160             "wR8", "wR9", "wR10", "wR11", "wR12", "wR13", "wR14", "wR15",
9161             "wCID", "wCon", "wCSSF", "wCASF", "", "", "", "",
9162             "wCGR0", "wCGR1", "wCGR2", "wCGR3", "", "", "", "",
9163           };
9164
9165           valid_p = 1;
9166           for (i = ARM_WR0_REGNUM; i <= ARM_WR15_REGNUM; i++)
9167             valid_p
9168               &= tdesc_numbered_register (feature, tdesc_data, i,
9169                                           iwmmxt_names[i - ARM_WR0_REGNUM]);
9170
9171           /* Check for the control registers, but do not fail if they
9172              are missing.  */
9173           for (i = ARM_WC0_REGNUM; i <= ARM_WCASF_REGNUM; i++)
9174             tdesc_numbered_register (feature, tdesc_data, i,
9175                                      iwmmxt_names[i - ARM_WR0_REGNUM]);
9176
9177           for (i = ARM_WCGR0_REGNUM; i <= ARM_WCGR3_REGNUM; i++)
9178             valid_p
9179               &= tdesc_numbered_register (feature, tdesc_data, i,
9180                                           iwmmxt_names[i - ARM_WR0_REGNUM]);
9181
9182           if (!valid_p)
9183             {
9184               tdesc_data_cleanup (tdesc_data);
9185               return NULL;
9186             }
9187
9188           have_wmmx_registers = 1;
9189         }
9190
9191       /* If we have a VFP unit, check whether the single precision registers
9192          are present.  If not, then we will synthesize them as pseudo
9193          registers.  */
9194       feature = tdesc_find_feature (tdesc,
9195                                     "org.gnu.gdb.arm.vfp");
9196       if (feature != NULL)
9197         {
9198           static const char *const vfp_double_names[] = {
9199             "d0", "d1", "d2", "d3", "d4", "d5", "d6", "d7",
9200             "d8", "d9", "d10", "d11", "d12", "d13", "d14", "d15",
9201             "d16", "d17", "d18", "d19", "d20", "d21", "d22", "d23",
9202             "d24", "d25", "d26", "d27", "d28", "d29", "d30", "d31",
9203           };
9204
9205           /* Require the double precision registers.  There must be either
9206              16 or 32.  */
9207           valid_p = 1;
9208           for (i = 0; i < 32; i++)
9209             {
9210               valid_p &= tdesc_numbered_register (feature, tdesc_data,
9211                                                   ARM_D0_REGNUM + i,
9212                                                   vfp_double_names[i]);
9213               if (!valid_p)
9214                 break;
9215             }
9216           if (!valid_p && i == 16)
9217             valid_p = 1;
9218
9219           /* Also require FPSCR.  */
9220           valid_p &= tdesc_numbered_register (feature, tdesc_data,
9221                                               ARM_FPSCR_REGNUM, "fpscr");
9222           if (!valid_p)
9223             {
9224               tdesc_data_cleanup (tdesc_data);
9225               return NULL;
9226             }
9227
9228           if (tdesc_unnumbered_register (feature, "s0") == 0)
9229             have_vfp_pseudos = 1;
9230
9231           vfp_register_count = i;
9232
9233           /* If we have VFP, also check for NEON.  The architecture allows
9234              NEON without VFP (integer vector operations only), but GDB
9235              does not support that.  */
9236           feature = tdesc_find_feature (tdesc,
9237                                         "org.gnu.gdb.arm.neon");
9238           if (feature != NULL)
9239             {
9240               /* NEON requires 32 double-precision registers.  */
9241               if (i != 32)
9242                 {
9243                   tdesc_data_cleanup (tdesc_data);
9244                   return NULL;
9245                 }
9246
9247               /* If there are quad registers defined by the stub, use
9248                  their type; otherwise (normally) provide them with
9249                  the default type.  */
9250               if (tdesc_unnumbered_register (feature, "q0") == 0)
9251                 have_neon_pseudos = 1;
9252
9253               have_neon = 1;
9254             }
9255         }
9256     }
9257
9258   /* If there is already a candidate, use it.  */
9259   for (best_arch = gdbarch_list_lookup_by_info (arches, &info);
9260        best_arch != NULL;
9261        best_arch = gdbarch_list_lookup_by_info (best_arch->next, &info))
9262     {
9263       if (arm_abi != ARM_ABI_AUTO
9264           && arm_abi != gdbarch_tdep (best_arch->gdbarch)->arm_abi)
9265         continue;
9266
9267       if (fp_model != ARM_FLOAT_AUTO
9268           && fp_model != gdbarch_tdep (best_arch->gdbarch)->fp_model)
9269         continue;
9270
9271       /* There are various other properties in tdep that we do not
9272          need to check here: those derived from a target description,
9273          since gdbarches with a different target description are
9274          automatically disqualified.  */
9275
9276       /* Do check is_m, though, since it might come from the binary.  */
9277       if (is_m != gdbarch_tdep (best_arch->gdbarch)->is_m)
9278         continue;
9279
9280       /* Found a match.  */
9281       break;
9282     }
9283
9284   if (best_arch != NULL)
9285     {
9286       if (tdesc_data != NULL)
9287         tdesc_data_cleanup (tdesc_data);
9288       return best_arch->gdbarch;
9289     }
9290
9291   tdep = XCNEW (struct gdbarch_tdep);
9292   gdbarch = gdbarch_alloc (&info, tdep);
9293
9294   /* Record additional information about the architecture we are defining.
9295      These are gdbarch discriminators, like the OSABI.  */
9296   tdep->arm_abi = arm_abi;
9297   tdep->fp_model = fp_model;
9298   tdep->is_m = is_m;
9299   tdep->have_fpa_registers = have_fpa_registers;
9300   tdep->have_wmmx_registers = have_wmmx_registers;
9301   gdb_assert (vfp_register_count == 0
9302               || vfp_register_count == 16
9303               || vfp_register_count == 32);
9304   tdep->vfp_register_count = vfp_register_count;
9305   tdep->have_vfp_pseudos = have_vfp_pseudos;
9306   tdep->have_neon_pseudos = have_neon_pseudos;
9307   tdep->have_neon = have_neon;
9308
9309   arm_register_g_packet_guesses (gdbarch);
9310
9311   /* Breakpoints.  */
9312   switch (info.byte_order_for_code)
9313     {
9314     case BFD_ENDIAN_BIG:
9315       tdep->arm_breakpoint = arm_default_arm_be_breakpoint;
9316       tdep->arm_breakpoint_size = sizeof (arm_default_arm_be_breakpoint);
9317       tdep->thumb_breakpoint = arm_default_thumb_be_breakpoint;
9318       tdep->thumb_breakpoint_size = sizeof (arm_default_thumb_be_breakpoint);
9319
9320       break;
9321
9322     case BFD_ENDIAN_LITTLE:
9323       tdep->arm_breakpoint = arm_default_arm_le_breakpoint;
9324       tdep->arm_breakpoint_size = sizeof (arm_default_arm_le_breakpoint);
9325       tdep->thumb_breakpoint = arm_default_thumb_le_breakpoint;
9326       tdep->thumb_breakpoint_size = sizeof (arm_default_thumb_le_breakpoint);
9327
9328       break;
9329
9330     default:
9331       internal_error (__FILE__, __LINE__,
9332                       _("arm_gdbarch_init: bad byte order for float format"));
9333     }
9334
9335   /* On ARM targets char defaults to unsigned.  */
9336   set_gdbarch_char_signed (gdbarch, 0);
9337
9338   /* wchar_t is unsigned under the AAPCS.  */
9339   if (tdep->arm_abi == ARM_ABI_AAPCS)
9340     set_gdbarch_wchar_signed (gdbarch, 0);
9341   else
9342     set_gdbarch_wchar_signed (gdbarch, 1);
9343
9344   /* Note: for displaced stepping, this includes the breakpoint, and one word
9345      of additional scratch space.  This setting isn't used for anything beside
9346      displaced stepping at present.  */
9347   set_gdbarch_max_insn_length (gdbarch, 4 * DISPLACED_MODIFIED_INSNS);
9348
9349   /* This should be low enough for everything.  */
9350   tdep->lowest_pc = 0x20;
9351   tdep->jb_pc = -1;     /* Longjump support not enabled by default.  */
9352
9353   /* The default, for both APCS and AAPCS, is to return small
9354      structures in registers.  */
9355   tdep->struct_return = reg_struct_return;
9356
9357   set_gdbarch_push_dummy_call (gdbarch, arm_push_dummy_call);
9358   set_gdbarch_frame_align (gdbarch, arm_frame_align);
9359
9360   if (is_m)
9361     set_gdbarch_code_of_frame_writable (gdbarch, arm_code_of_frame_writable);
9362
9363   set_gdbarch_write_pc (gdbarch, arm_write_pc);
9364
9365   /* Frame handling.  */
9366   set_gdbarch_dummy_id (gdbarch, arm_dummy_id);
9367   set_gdbarch_unwind_pc (gdbarch, arm_unwind_pc);
9368   set_gdbarch_unwind_sp (gdbarch, arm_unwind_sp);
9369
9370   frame_base_set_default (gdbarch, &arm_normal_base);
9371
9372   /* Address manipulation.  */
9373   set_gdbarch_addr_bits_remove (gdbarch, arm_addr_bits_remove);
9374
9375   /* Advance PC across function entry code.  */
9376   set_gdbarch_skip_prologue (gdbarch, arm_skip_prologue);
9377
9378   /* Detect whether PC is at a point where the stack has been destroyed.  */
9379   set_gdbarch_stack_frame_destroyed_p (gdbarch, arm_stack_frame_destroyed_p);
9380
9381   /* Skip trampolines.  */
9382   set_gdbarch_skip_trampoline_code (gdbarch, arm_skip_stub);
9383
9384   /* The stack grows downward.  */
9385   set_gdbarch_inner_than (gdbarch, core_addr_lessthan);
9386
9387   /* Breakpoint manipulation.  */
9388   set_gdbarch_breakpoint_kind_from_pc (gdbarch, arm_breakpoint_kind_from_pc);
9389   set_gdbarch_sw_breakpoint_from_kind (gdbarch, arm_sw_breakpoint_from_kind);
9390   set_gdbarch_breakpoint_kind_from_current_state (gdbarch,
9391                                                   arm_breakpoint_kind_from_current_state);
9392
9393   /* Information about registers, etc.  */
9394   set_gdbarch_sp_regnum (gdbarch, ARM_SP_REGNUM);
9395   set_gdbarch_pc_regnum (gdbarch, ARM_PC_REGNUM);
9396   set_gdbarch_num_regs (gdbarch, ARM_NUM_REGS);
9397   set_gdbarch_register_type (gdbarch, arm_register_type);
9398   set_gdbarch_register_reggroup_p (gdbarch, arm_register_reggroup_p);
9399
9400   /* This "info float" is FPA-specific.  Use the generic version if we
9401      do not have FPA.  */
9402   if (gdbarch_tdep (gdbarch)->have_fpa_registers)
9403     set_gdbarch_print_float_info (gdbarch, arm_print_float_info);
9404
9405   /* Internal <-> external register number maps.  */
9406   set_gdbarch_dwarf2_reg_to_regnum (gdbarch, arm_dwarf_reg_to_regnum);
9407   set_gdbarch_register_sim_regno (gdbarch, arm_register_sim_regno);
9408
9409   set_gdbarch_register_name (gdbarch, arm_register_name);
9410
9411   /* Returning results.  */
9412   set_gdbarch_return_value (gdbarch, arm_return_value);
9413
9414   /* Disassembly.  */
9415   set_gdbarch_print_insn (gdbarch, gdb_print_insn_arm);
9416
9417   /* Minsymbol frobbing.  */
9418   set_gdbarch_elf_make_msymbol_special (gdbarch, arm_elf_make_msymbol_special);
9419   set_gdbarch_coff_make_msymbol_special (gdbarch,
9420                                          arm_coff_make_msymbol_special);
9421   set_gdbarch_record_special_symbol (gdbarch, arm_record_special_symbol);
9422
9423   /* Thumb-2 IT block support.  */
9424   set_gdbarch_adjust_breakpoint_address (gdbarch,
9425                                          arm_adjust_breakpoint_address);
9426
9427   /* Virtual tables.  */
9428   set_gdbarch_vbit_in_delta (gdbarch, 1);
9429
9430   /* Hook in the ABI-specific overrides, if they have been registered.  */
9431   gdbarch_init_osabi (info, gdbarch);
9432
9433   dwarf2_frame_set_init_reg (gdbarch, arm_dwarf2_frame_init_reg);
9434
9435   /* Add some default predicates.  */
9436   if (is_m)
9437     frame_unwind_append_unwinder (gdbarch, &arm_m_exception_unwind);
9438   frame_unwind_append_unwinder (gdbarch, &arm_stub_unwind);
9439   dwarf2_append_unwinders (gdbarch);
9440   frame_unwind_append_unwinder (gdbarch, &arm_exidx_unwind);
9441   frame_unwind_append_unwinder (gdbarch, &arm_epilogue_frame_unwind);
9442   frame_unwind_append_unwinder (gdbarch, &arm_prologue_unwind);
9443
9444   /* Now we have tuned the configuration, set a few final things,
9445      based on what the OS ABI has told us.  */
9446
9447   /* If the ABI is not otherwise marked, assume the old GNU APCS.  EABI
9448      binaries are always marked.  */
9449   if (tdep->arm_abi == ARM_ABI_AUTO)
9450     tdep->arm_abi = ARM_ABI_APCS;
9451
9452   /* Watchpoints are not steppable.  */
9453   set_gdbarch_have_nonsteppable_watchpoint (gdbarch, 1);
9454
9455   /* We used to default to FPA for generic ARM, but almost nobody
9456      uses that now, and we now provide a way for the user to force
9457      the model.  So default to the most useful variant.  */
9458   if (tdep->fp_model == ARM_FLOAT_AUTO)
9459     tdep->fp_model = ARM_FLOAT_SOFT_FPA;
9460
9461   if (tdep->jb_pc >= 0)
9462     set_gdbarch_get_longjmp_target (gdbarch, arm_get_longjmp_target);
9463
9464   /* Floating point sizes and format.  */
9465   set_gdbarch_float_format (gdbarch, floatformats_ieee_single);
9466   if (tdep->fp_model == ARM_FLOAT_SOFT_FPA || tdep->fp_model == ARM_FLOAT_FPA)
9467     {
9468       set_gdbarch_double_format
9469         (gdbarch, floatformats_ieee_double_littlebyte_bigword);
9470       set_gdbarch_long_double_format
9471         (gdbarch, floatformats_ieee_double_littlebyte_bigword);
9472     }
9473   else
9474     {
9475       set_gdbarch_double_format (gdbarch, floatformats_ieee_double);
9476       set_gdbarch_long_double_format (gdbarch, floatformats_ieee_double);
9477     }
9478
9479   if (have_vfp_pseudos)
9480     {
9481       /* NOTE: These are the only pseudo registers used by
9482          the ARM target at the moment.  If more are added, a
9483          little more care in numbering will be needed.  */
9484
9485       int num_pseudos = 32;
9486       if (have_neon_pseudos)
9487         num_pseudos += 16;
9488       set_gdbarch_num_pseudo_regs (gdbarch, num_pseudos);
9489       set_gdbarch_pseudo_register_read (gdbarch, arm_pseudo_read);
9490       set_gdbarch_pseudo_register_write (gdbarch, arm_pseudo_write);
9491     }
9492
9493   if (tdesc_data)
9494     {
9495       set_tdesc_pseudo_register_name (gdbarch, arm_register_name);
9496
9497       tdesc_use_registers (gdbarch, tdesc, tdesc_data);
9498
9499       /* Override tdesc_register_type to adjust the types of VFP
9500          registers for NEON.  */
9501       set_gdbarch_register_type (gdbarch, arm_register_type);
9502     }
9503
9504   /* Add standard register aliases.  We add aliases even for those
9505      nanes which are used by the current architecture - it's simpler,
9506      and does no harm, since nothing ever lists user registers.  */
9507   for (i = 0; i < ARRAY_SIZE (arm_register_aliases); i++)
9508     user_reg_add (gdbarch, arm_register_aliases[i].name,
9509                   value_of_arm_user_reg, &arm_register_aliases[i].regnum);
9510
9511   set_gdbarch_disassembler_options (gdbarch, &arm_disassembler_options);
9512   set_gdbarch_valid_disassembler_options (gdbarch, disassembler_options_arm ());
9513
9514   return gdbarch;
9515 }
9516
9517 static void
9518 arm_dump_tdep (struct gdbarch *gdbarch, struct ui_file *file)
9519 {
9520   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
9521
9522   if (tdep == NULL)
9523     return;
9524
9525   fprintf_unfiltered (file, _("arm_dump_tdep: Lowest pc = 0x%lx"),
9526                       (unsigned long) tdep->lowest_pc);
9527 }
9528
9529 #if GDB_SELF_TEST
9530 namespace selftests
9531 {
9532 static void arm_record_test (void);
9533 }
9534 #endif
9535
9536 void
9537 _initialize_arm_tdep (void)
9538 {
9539   long length;
9540   int i, j;
9541   char regdesc[1024], *rdptr = regdesc;
9542   size_t rest = sizeof (regdesc);
9543
9544   gdbarch_register (bfd_arch_arm, arm_gdbarch_init, arm_dump_tdep);
9545
9546   arm_objfile_data_key
9547     = register_objfile_data_with_cleanup (NULL, arm_objfile_data_free);
9548
9549   /* Add ourselves to objfile event chain.  */
9550   gdb::observers::new_objfile.attach (arm_exidx_new_objfile);
9551   arm_exidx_data_key
9552     = register_objfile_data_with_cleanup (NULL, arm_exidx_data_free);
9553
9554   /* Register an ELF OS ABI sniffer for ARM binaries.  */
9555   gdbarch_register_osabi_sniffer (bfd_arch_arm,
9556                                   bfd_target_elf_flavour,
9557                                   arm_elf_osabi_sniffer);
9558
9559   /* Initialize the standard target descriptions.  */
9560   initialize_tdesc_arm_with_m ();
9561   initialize_tdesc_arm_with_m_fpa_layout ();
9562   initialize_tdesc_arm_with_m_vfp_d16 ();
9563   initialize_tdesc_arm_with_iwmmxt ();
9564   initialize_tdesc_arm_with_vfpv2 ();
9565   initialize_tdesc_arm_with_vfpv3 ();
9566   initialize_tdesc_arm_with_neon ();
9567
9568   /* Add root prefix command for all "set arm"/"show arm" commands.  */
9569   add_prefix_cmd ("arm", no_class, set_arm_command,
9570                   _("Various ARM-specific commands."),
9571                   &setarmcmdlist, "set arm ", 0, &setlist);
9572
9573   add_prefix_cmd ("arm", no_class, show_arm_command,
9574                   _("Various ARM-specific commands."),
9575                   &showarmcmdlist, "show arm ", 0, &showlist);
9576
9577
9578   arm_disassembler_options = xstrdup ("reg-names-std");
9579   const disasm_options_t *disasm_options
9580     = &disassembler_options_arm ()->options;
9581   int num_disassembly_styles = 0;
9582   for (i = 0; disasm_options->name[i] != NULL; i++)
9583     if (CONST_STRNEQ (disasm_options->name[i], "reg-names-"))
9584       num_disassembly_styles++;
9585
9586   /* Initialize the array that will be passed to add_setshow_enum_cmd().  */
9587   valid_disassembly_styles = XNEWVEC (const char *,
9588                                       num_disassembly_styles + 1);
9589   for (i = j = 0; disasm_options->name[i] != NULL; i++)
9590     if (CONST_STRNEQ (disasm_options->name[i], "reg-names-"))
9591       {
9592         size_t offset = strlen ("reg-names-");
9593         const char *style = disasm_options->name[i];
9594         valid_disassembly_styles[j++] = &style[offset];
9595         length = snprintf (rdptr, rest, "%s - %s\n", &style[offset],
9596                            disasm_options->description[i]);
9597         rdptr += length;
9598         rest -= length;
9599       }
9600   /* Mark the end of valid options.  */
9601   valid_disassembly_styles[num_disassembly_styles] = NULL;
9602
9603   /* Create the help text.  */
9604   std::string helptext = string_printf ("%s%s%s",
9605                                         _("The valid values are:\n"),
9606                                         regdesc,
9607                                         _("The default is \"std\"."));
9608
9609   add_setshow_enum_cmd("disassembler", no_class,
9610                        valid_disassembly_styles, &disassembly_style,
9611                        _("Set the disassembly style."),
9612                        _("Show the disassembly style."),
9613                        helptext.c_str (),
9614                        set_disassembly_style_sfunc,
9615                        show_disassembly_style_sfunc,
9616                        &setarmcmdlist, &showarmcmdlist);
9617
9618   add_setshow_boolean_cmd ("apcs32", no_class, &arm_apcs_32,
9619                            _("Set usage of ARM 32-bit mode."),
9620                            _("Show usage of ARM 32-bit mode."),
9621                            _("When off, a 26-bit PC will be used."),
9622                            NULL,
9623                            NULL, /* FIXME: i18n: Usage of ARM 32-bit
9624                                     mode is %s.  */
9625                            &setarmcmdlist, &showarmcmdlist);
9626
9627   /* Add a command to allow the user to force the FPU model.  */
9628   add_setshow_enum_cmd ("fpu", no_class, fp_model_strings, &current_fp_model,
9629                         _("Set the floating point type."),
9630                         _("Show the floating point type."),
9631                         _("auto - Determine the FP typefrom the OS-ABI.\n\
9632 softfpa - Software FP, mixed-endian doubles on little-endian ARMs.\n\
9633 fpa - FPA co-processor (GCC compiled).\n\
9634 softvfp - Software FP with pure-endian doubles.\n\
9635 vfp - VFP co-processor."),
9636                         set_fp_model_sfunc, show_fp_model,
9637                         &setarmcmdlist, &showarmcmdlist);
9638
9639   /* Add a command to allow the user to force the ABI.  */
9640   add_setshow_enum_cmd ("abi", class_support, arm_abi_strings, &arm_abi_string,
9641                         _("Set the ABI."),
9642                         _("Show the ABI."),
9643                         NULL, arm_set_abi, arm_show_abi,
9644                         &setarmcmdlist, &showarmcmdlist);
9645
9646   /* Add two commands to allow the user to force the assumed
9647      execution mode.  */
9648   add_setshow_enum_cmd ("fallback-mode", class_support,
9649                         arm_mode_strings, &arm_fallback_mode_string,
9650                         _("Set the mode assumed when symbols are unavailable."),
9651                         _("Show the mode assumed when symbols are unavailable."),
9652                         NULL, NULL, arm_show_fallback_mode,
9653                         &setarmcmdlist, &showarmcmdlist);
9654   add_setshow_enum_cmd ("force-mode", class_support,
9655                         arm_mode_strings, &arm_force_mode_string,
9656                         _("Set the mode assumed even when symbols are available."),
9657                         _("Show the mode assumed even when symbols are available."),
9658                         NULL, NULL, arm_show_force_mode,
9659                         &setarmcmdlist, &showarmcmdlist);
9660
9661   /* Debugging flag.  */
9662   add_setshow_boolean_cmd ("arm", class_maintenance, &arm_debug,
9663                            _("Set ARM debugging."),
9664                            _("Show ARM debugging."),
9665                            _("When on, arm-specific debugging is enabled."),
9666                            NULL,
9667                            NULL, /* FIXME: i18n: "ARM debugging is %s.  */
9668                            &setdebuglist, &showdebuglist);
9669
9670 #if GDB_SELF_TEST
9671   selftests::register_test ("arm-record", selftests::arm_record_test);
9672 #endif
9673
9674 }
9675
9676 /* ARM-reversible process record data structures.  */
9677
9678 #define ARM_INSN_SIZE_BYTES 4    
9679 #define THUMB_INSN_SIZE_BYTES 2
9680 #define THUMB2_INSN_SIZE_BYTES 4
9681
9682
9683 /* Position of the bit within a 32-bit ARM instruction
9684    that defines whether the instruction is a load or store.  */
9685 #define INSN_S_L_BIT_NUM 20
9686
9687 #define REG_ALLOC(REGS, LENGTH, RECORD_BUF) \
9688         do  \
9689           { \
9690             unsigned int reg_len = LENGTH; \
9691             if (reg_len) \
9692               { \
9693                 REGS = XNEWVEC (uint32_t, reg_len); \
9694                 memcpy(&REGS[0], &RECORD_BUF[0], sizeof(uint32_t)*LENGTH); \
9695               } \
9696           } \
9697         while (0)
9698
9699 #define MEM_ALLOC(MEMS, LENGTH, RECORD_BUF) \
9700         do  \
9701           { \
9702             unsigned int mem_len = LENGTH; \
9703             if (mem_len) \
9704             { \
9705               MEMS =  XNEWVEC (struct arm_mem_r, mem_len);  \
9706               memcpy(&MEMS->len, &RECORD_BUF[0], \
9707                      sizeof(struct arm_mem_r) * LENGTH); \
9708             } \
9709           } \
9710           while (0)
9711
9712 /* Checks whether insn is already recorded or yet to be decoded. (boolean expression).  */
9713 #define INSN_RECORDED(ARM_RECORD) \
9714         (0 != (ARM_RECORD)->reg_rec_count || 0 != (ARM_RECORD)->mem_rec_count)
9715
9716 /* ARM memory record structure.  */
9717 struct arm_mem_r
9718 {
9719   uint32_t len;    /* Record length.  */
9720   uint32_t addr;   /* Memory address.  */
9721 };
9722
9723 /* ARM instruction record contains opcode of current insn
9724    and execution state (before entry to decode_insn()),
9725    contains list of to-be-modified registers and
9726    memory blocks (on return from decode_insn()).  */
9727
9728 typedef struct insn_decode_record_t
9729 {
9730   struct gdbarch *gdbarch;
9731   struct regcache *regcache;
9732   CORE_ADDR this_addr;          /* Address of the insn being decoded.  */
9733   uint32_t arm_insn;            /* Should accommodate thumb.  */
9734   uint32_t cond;                /* Condition code.  */
9735   uint32_t opcode;              /* Insn opcode.  */
9736   uint32_t decode;              /* Insn decode bits.  */
9737   uint32_t mem_rec_count;       /* No of mem records.  */
9738   uint32_t reg_rec_count;       /* No of reg records.  */
9739   uint32_t *arm_regs;           /* Registers to be saved for this record.  */
9740   struct arm_mem_r *arm_mems;   /* Memory to be saved for this record.  */
9741 } insn_decode_record;
9742
9743
9744 /* Checks ARM SBZ and SBO mandatory fields.  */
9745
9746 static int
9747 sbo_sbz (uint32_t insn, uint32_t bit_num, uint32_t len, uint32_t sbo)
9748 {
9749   uint32_t ones = bits (insn, bit_num - 1, (bit_num -1) + (len - 1));
9750
9751   if (!len)
9752     return 1;
9753
9754   if (!sbo)
9755     ones = ~ones;
9756
9757   while (ones)
9758     {
9759       if (!(ones & sbo))
9760         {
9761           return 0;
9762         }
9763       ones = ones >> 1;
9764     }
9765   return 1;
9766 }
9767
9768 enum arm_record_result
9769 {
9770   ARM_RECORD_SUCCESS = 0,
9771   ARM_RECORD_FAILURE = 1
9772 };
9773
9774 typedef enum
9775 {
9776   ARM_RECORD_STRH=1,
9777   ARM_RECORD_STRD
9778 } arm_record_strx_t;
9779
9780 typedef enum
9781 {
9782   ARM_RECORD=1,
9783   THUMB_RECORD,
9784   THUMB2_RECORD
9785 } record_type_t;
9786
9787
9788 static int
9789 arm_record_strx (insn_decode_record *arm_insn_r, uint32_t *record_buf, 
9790                  uint32_t *record_buf_mem, arm_record_strx_t str_type)
9791 {
9792
9793   struct regcache *reg_cache = arm_insn_r->regcache;
9794   ULONGEST u_regval[2]= {0};
9795
9796   uint32_t reg_src1 = 0, reg_src2 = 0;
9797   uint32_t immed_high = 0, immed_low = 0,offset_8 = 0, tgt_mem_addr = 0;
9798
9799   arm_insn_r->opcode = bits (arm_insn_r->arm_insn, 21, 24);
9800   arm_insn_r->decode = bits (arm_insn_r->arm_insn, 4, 7);
9801
9802   if (14 == arm_insn_r->opcode || 10 == arm_insn_r->opcode)
9803     {
9804       /* 1) Handle misc store, immediate offset.  */
9805       immed_low = bits (arm_insn_r->arm_insn, 0, 3);
9806       immed_high = bits (arm_insn_r->arm_insn, 8, 11);
9807       reg_src1 = bits (arm_insn_r->arm_insn, 16, 19);
9808       regcache_raw_read_unsigned (reg_cache, reg_src1,
9809                                   &u_regval[0]);
9810       if (ARM_PC_REGNUM == reg_src1)
9811         {
9812           /* If R15 was used as Rn, hence current PC+8.  */
9813           u_regval[0] = u_regval[0] + 8;
9814         }
9815       offset_8 = (immed_high << 4) | immed_low;
9816       /* Calculate target store address.  */
9817       if (14 == arm_insn_r->opcode)
9818         {
9819           tgt_mem_addr = u_regval[0] + offset_8;
9820         }
9821       else
9822         {
9823           tgt_mem_addr = u_regval[0] - offset_8;
9824         }
9825       if (ARM_RECORD_STRH == str_type)
9826         {
9827           record_buf_mem[0] = 2;
9828           record_buf_mem[1] = tgt_mem_addr;
9829           arm_insn_r->mem_rec_count = 1;
9830         }
9831       else if (ARM_RECORD_STRD == str_type)
9832         {
9833           record_buf_mem[0] = 4;
9834           record_buf_mem[1] = tgt_mem_addr;
9835           record_buf_mem[2] = 4;
9836           record_buf_mem[3] = tgt_mem_addr + 4;
9837           arm_insn_r->mem_rec_count = 2;
9838         }
9839     }
9840   else if (12 == arm_insn_r->opcode || 8 == arm_insn_r->opcode)
9841     {
9842       /* 2) Store, register offset.  */
9843       /* Get Rm.  */
9844       reg_src1 = bits (arm_insn_r->arm_insn, 0, 3);
9845       /* Get Rn.  */
9846       reg_src2 = bits (arm_insn_r->arm_insn, 16, 19);
9847       regcache_raw_read_unsigned (reg_cache, reg_src1, &u_regval[0]);
9848       regcache_raw_read_unsigned (reg_cache, reg_src2, &u_regval[1]);
9849       if (15 == reg_src2)
9850         {
9851           /* If R15 was used as Rn, hence current PC+8.  */
9852           u_regval[0] = u_regval[0] + 8;
9853         }
9854       /* Calculate target store address, Rn +/- Rm, register offset.  */
9855       if (12 == arm_insn_r->opcode)
9856         {
9857           tgt_mem_addr = u_regval[0] + u_regval[1];
9858         }
9859       else
9860         {
9861           tgt_mem_addr = u_regval[1] - u_regval[0];
9862         }
9863       if (ARM_RECORD_STRH == str_type)
9864         {
9865           record_buf_mem[0] = 2;
9866           record_buf_mem[1] = tgt_mem_addr;
9867           arm_insn_r->mem_rec_count = 1;
9868         }
9869       else if (ARM_RECORD_STRD == str_type)
9870         {
9871           record_buf_mem[0] = 4;
9872           record_buf_mem[1] = tgt_mem_addr;
9873           record_buf_mem[2] = 4;
9874           record_buf_mem[3] = tgt_mem_addr + 4;
9875           arm_insn_r->mem_rec_count = 2;
9876         }
9877     }
9878   else if (11 == arm_insn_r->opcode || 15 == arm_insn_r->opcode
9879            || 2 == arm_insn_r->opcode  || 6 == arm_insn_r->opcode)
9880     {
9881       /* 3) Store, immediate pre-indexed.  */
9882       /* 5) Store, immediate post-indexed.  */
9883       immed_low = bits (arm_insn_r->arm_insn, 0, 3);
9884       immed_high = bits (arm_insn_r->arm_insn, 8, 11);
9885       offset_8 = (immed_high << 4) | immed_low;
9886       reg_src1 = bits (arm_insn_r->arm_insn, 16, 19);
9887       regcache_raw_read_unsigned (reg_cache, reg_src1, &u_regval[0]);
9888       /* Calculate target store address, Rn +/- Rm, register offset.  */
9889       if (15 == arm_insn_r->opcode || 6 == arm_insn_r->opcode)
9890         {
9891           tgt_mem_addr = u_regval[0] + offset_8;
9892         }
9893       else
9894         {
9895           tgt_mem_addr = u_regval[0] - offset_8;
9896         }
9897       if (ARM_RECORD_STRH == str_type)
9898         {
9899           record_buf_mem[0] = 2;
9900           record_buf_mem[1] = tgt_mem_addr;
9901           arm_insn_r->mem_rec_count = 1;
9902         }
9903       else if (ARM_RECORD_STRD == str_type)
9904         {
9905           record_buf_mem[0] = 4;
9906           record_buf_mem[1] = tgt_mem_addr;
9907           record_buf_mem[2] = 4;
9908           record_buf_mem[3] = tgt_mem_addr + 4;
9909           arm_insn_r->mem_rec_count = 2;
9910         }
9911       /* Record Rn also as it changes.  */
9912       *(record_buf) = bits (arm_insn_r->arm_insn, 16, 19);
9913       arm_insn_r->reg_rec_count = 1;
9914     }
9915   else if (9 == arm_insn_r->opcode || 13 == arm_insn_r->opcode
9916            || 0 == arm_insn_r->opcode || 4 == arm_insn_r->opcode)
9917     {
9918       /* 4) Store, register pre-indexed.  */
9919       /* 6) Store, register post -indexed.  */
9920       reg_src1 = bits (arm_insn_r->arm_insn, 0, 3);
9921       reg_src2 = bits (arm_insn_r->arm_insn, 16, 19);
9922       regcache_raw_read_unsigned (reg_cache, reg_src1, &u_regval[0]);
9923       regcache_raw_read_unsigned (reg_cache, reg_src2, &u_regval[1]);
9924       /* Calculate target store address, Rn +/- Rm, register offset.  */
9925       if (13 == arm_insn_r->opcode || 4 == arm_insn_r->opcode)
9926         {
9927           tgt_mem_addr = u_regval[0] + u_regval[1];
9928         }
9929       else
9930         {
9931           tgt_mem_addr = u_regval[1] - u_regval[0];
9932         }
9933       if (ARM_RECORD_STRH == str_type)
9934         {
9935           record_buf_mem[0] = 2;
9936           record_buf_mem[1] = tgt_mem_addr;
9937           arm_insn_r->mem_rec_count = 1;
9938         }
9939       else if (ARM_RECORD_STRD == str_type)
9940         {
9941           record_buf_mem[0] = 4;
9942           record_buf_mem[1] = tgt_mem_addr;
9943           record_buf_mem[2] = 4;
9944           record_buf_mem[3] = tgt_mem_addr + 4;
9945           arm_insn_r->mem_rec_count = 2;
9946         }
9947       /* Record Rn also as it changes.  */
9948       *(record_buf) = bits (arm_insn_r->arm_insn, 16, 19);
9949       arm_insn_r->reg_rec_count = 1;
9950     }
9951   return 0;
9952 }
9953
9954 /* Handling ARM extension space insns.  */
9955
9956 static int
9957 arm_record_extension_space (insn_decode_record *arm_insn_r)
9958 {
9959   int ret = 0;  /* Return value: -1:record failure ;  0:success  */
9960   uint32_t opcode1 = 0, opcode2 = 0, insn_op1 = 0;
9961   uint32_t record_buf[8], record_buf_mem[8];
9962   uint32_t reg_src1 = 0;
9963   struct regcache *reg_cache = arm_insn_r->regcache;
9964   ULONGEST u_regval = 0;
9965
9966   gdb_assert (!INSN_RECORDED(arm_insn_r));
9967   /* Handle unconditional insn extension space.  */
9968
9969   opcode1 = bits (arm_insn_r->arm_insn, 20, 27);
9970   opcode2 = bits (arm_insn_r->arm_insn, 4, 7);
9971   if (arm_insn_r->cond)
9972     {
9973       /* PLD has no affect on architectural state, it just affects
9974          the caches.  */
9975       if (5 == ((opcode1 & 0xE0) >> 5))
9976         {
9977           /* BLX(1) */
9978           record_buf[0] = ARM_PS_REGNUM;
9979           record_buf[1] = ARM_LR_REGNUM;
9980           arm_insn_r->reg_rec_count = 2;
9981         }
9982       /* STC2, LDC2, MCR2, MRC2, CDP2: <TBD>, co-processor insn.  */
9983     }
9984
9985
9986   opcode1 = bits (arm_insn_r->arm_insn, 25, 27);
9987   if (3 == opcode1 && bit (arm_insn_r->arm_insn, 4))
9988     {
9989       ret = -1;
9990       /* Undefined instruction on ARM V5; need to handle if later 
9991          versions define it.  */
9992     }
9993
9994   opcode1 = bits (arm_insn_r->arm_insn, 24, 27);
9995   opcode2 = bits (arm_insn_r->arm_insn, 4, 7);
9996   insn_op1 = bits (arm_insn_r->arm_insn, 20, 23);
9997
9998   /* Handle arithmetic insn extension space.  */
9999   if (!opcode1 && 9 == opcode2 && 1 != arm_insn_r->cond
10000       && !INSN_RECORDED(arm_insn_r))
10001     {
10002       /* Handle MLA(S) and MUL(S).  */
10003       if (in_inclusive_range (insn_op1, 0U, 3U))
10004       {
10005         record_buf[0] = bits (arm_insn_r->arm_insn, 12, 15);
10006         record_buf[1] = ARM_PS_REGNUM;
10007         arm_insn_r->reg_rec_count = 2;
10008       }
10009       else if (in_inclusive_range (insn_op1, 4U, 15U))
10010       {
10011         /* Handle SMLAL(S), SMULL(S), UMLAL(S), UMULL(S).  */
10012         record_buf[0] = bits (arm_insn_r->arm_insn, 16, 19);
10013         record_buf[1] = bits (arm_insn_r->arm_insn, 12, 15);
10014         record_buf[2] = ARM_PS_REGNUM;
10015         arm_insn_r->reg_rec_count = 3;
10016       }
10017     }
10018
10019   opcode1 = bits (arm_insn_r->arm_insn, 26, 27);
10020   opcode2 = bits (arm_insn_r->arm_insn, 23, 24);
10021   insn_op1 = bits (arm_insn_r->arm_insn, 21, 22);
10022
10023   /* Handle control insn extension space.  */
10024
10025   if (!opcode1 && 2 == opcode2 && !bit (arm_insn_r->arm_insn, 20)
10026       && 1 != arm_insn_r->cond && !INSN_RECORDED(arm_insn_r))
10027     {
10028       if (!bit (arm_insn_r->arm_insn,25))
10029         {
10030           if (!bits (arm_insn_r->arm_insn, 4, 7))
10031             {
10032               if ((0 == insn_op1) || (2 == insn_op1))
10033                 {
10034                   /* MRS.  */
10035                   record_buf[0] = bits (arm_insn_r->arm_insn, 12, 15);
10036                   arm_insn_r->reg_rec_count = 1;
10037                 }
10038               else if (1 == insn_op1)
10039                 {
10040                   /* CSPR is going to be changed.  */
10041                   record_buf[0] = ARM_PS_REGNUM;
10042                   arm_insn_r->reg_rec_count = 1;
10043                 }
10044               else if (3 == insn_op1)
10045                 {
10046                   /* SPSR is going to be changed.  */
10047                   /* We need to get SPSR value, which is yet to be done.  */
10048                   return -1;
10049                 }
10050             }
10051           else if (1 == bits (arm_insn_r->arm_insn, 4, 7))
10052             {
10053               if (1 == insn_op1)
10054                 {
10055                   /* BX.  */
10056                   record_buf[0] = ARM_PS_REGNUM;
10057                   arm_insn_r->reg_rec_count = 1;
10058                 }
10059               else if (3 == insn_op1)
10060                 {
10061                   /* CLZ.  */
10062                   record_buf[0] = bits (arm_insn_r->arm_insn, 12, 15);
10063                   arm_insn_r->reg_rec_count = 1;
10064                 }
10065             }
10066           else if (3 == bits (arm_insn_r->arm_insn, 4, 7))
10067             {
10068               /* BLX.  */
10069               record_buf[0] = ARM_PS_REGNUM;
10070               record_buf[1] = ARM_LR_REGNUM;
10071               arm_insn_r->reg_rec_count = 2;
10072             }
10073           else if (5 == bits (arm_insn_r->arm_insn, 4, 7))
10074             {
10075               /* QADD, QSUB, QDADD, QDSUB */
10076               record_buf[0] = ARM_PS_REGNUM;
10077               record_buf[1] = bits (arm_insn_r->arm_insn, 12, 15);
10078               arm_insn_r->reg_rec_count = 2;
10079             }
10080           else if (7 == bits (arm_insn_r->arm_insn, 4, 7))
10081             {
10082               /* BKPT.  */
10083               record_buf[0] = ARM_PS_REGNUM;
10084               record_buf[1] = ARM_LR_REGNUM;
10085               arm_insn_r->reg_rec_count = 2;
10086
10087               /* Save SPSR also;how?  */
10088               return -1;
10089             }
10090           else if(8 == bits (arm_insn_r->arm_insn, 4, 7) 
10091                   || 10 == bits (arm_insn_r->arm_insn, 4, 7)
10092                   || 12 == bits (arm_insn_r->arm_insn, 4, 7)
10093                   || 14 == bits (arm_insn_r->arm_insn, 4, 7)
10094                  )
10095             {
10096               if (0 == insn_op1 || 1 == insn_op1)
10097                 {
10098                   /* SMLA<x><y>, SMLAW<y>, SMULW<y>.  */
10099                   /* We dont do optimization for SMULW<y> where we
10100                      need only Rd.  */
10101                   record_buf[0] = bits (arm_insn_r->arm_insn, 12, 15);
10102                   record_buf[1] = ARM_PS_REGNUM;
10103                   arm_insn_r->reg_rec_count = 2;
10104                 }
10105               else if (2 == insn_op1)
10106                 {
10107                   /* SMLAL<x><y>.  */
10108                   record_buf[0] = bits (arm_insn_r->arm_insn, 12, 15);
10109                   record_buf[1] = bits (arm_insn_r->arm_insn, 16, 19);
10110                   arm_insn_r->reg_rec_count = 2;
10111                 }
10112               else if (3 == insn_op1)
10113                 {
10114                   /* SMUL<x><y>.  */
10115                   record_buf[0] = bits (arm_insn_r->arm_insn, 12, 15);
10116                   arm_insn_r->reg_rec_count = 1;
10117                 }
10118             }
10119         }
10120       else
10121         {
10122           /* MSR : immediate form.  */
10123           if (1 == insn_op1)
10124             {
10125               /* CSPR is going to be changed.  */
10126               record_buf[0] = ARM_PS_REGNUM;
10127               arm_insn_r->reg_rec_count = 1;
10128             }
10129           else if (3 == insn_op1)
10130             {
10131               /* SPSR is going to be changed.  */
10132               /* we need to get SPSR value, which is yet to be done  */
10133               return -1;
10134             }
10135         }
10136     }
10137
10138   opcode1 = bits (arm_insn_r->arm_insn, 25, 27);
10139   opcode2 = bits (arm_insn_r->arm_insn, 20, 24);
10140   insn_op1 = bits (arm_insn_r->arm_insn, 5, 6);
10141
10142   /* Handle load/store insn extension space.  */
10143
10144   if (!opcode1 && bit (arm_insn_r->arm_insn, 7) 
10145       && bit (arm_insn_r->arm_insn, 4) && 1 != arm_insn_r->cond
10146       && !INSN_RECORDED(arm_insn_r))
10147     {
10148       /* SWP/SWPB.  */
10149       if (0 == insn_op1)
10150         {
10151           /* These insn, changes register and memory as well.  */
10152           /* SWP or SWPB insn.  */
10153           /* Get memory address given by Rn.  */
10154           reg_src1 = bits (arm_insn_r->arm_insn, 16, 19);
10155           regcache_raw_read_unsigned (reg_cache, reg_src1, &u_regval);
10156           /* SWP insn ?, swaps word.  */
10157           if (8 == arm_insn_r->opcode)
10158             {
10159               record_buf_mem[0] = 4;
10160             }
10161           else
10162             {
10163               /* SWPB insn, swaps only byte.  */
10164               record_buf_mem[0] = 1;
10165             }
10166           record_buf_mem[1] = u_regval;
10167           arm_insn_r->mem_rec_count = 1;
10168           record_buf[0] = bits (arm_insn_r->arm_insn, 12, 15);
10169           arm_insn_r->reg_rec_count = 1;
10170         }
10171       else if (1 == insn_op1 && !bit (arm_insn_r->arm_insn, 20))
10172         {
10173           /* STRH.  */
10174           arm_record_strx(arm_insn_r, &record_buf[0], &record_buf_mem[0],
10175                           ARM_RECORD_STRH);
10176         }
10177       else if (2 == insn_op1 && !bit (arm_insn_r->arm_insn, 20))
10178         {
10179           /* LDRD.  */
10180           record_buf[0] = bits (arm_insn_r->arm_insn, 12, 15);
10181           record_buf[1] = record_buf[0] + 1;
10182           arm_insn_r->reg_rec_count = 2;
10183         }
10184       else if (3 == insn_op1 && !bit (arm_insn_r->arm_insn, 20))
10185         {
10186           /* STRD.  */
10187           arm_record_strx(arm_insn_r, &record_buf[0], &record_buf_mem[0],
10188                         ARM_RECORD_STRD);
10189         }
10190       else if (bit (arm_insn_r->arm_insn, 20) && insn_op1 <= 3)
10191         {
10192           /* LDRH, LDRSB, LDRSH.  */
10193           record_buf[0] = bits (arm_insn_r->arm_insn, 12, 15);
10194           arm_insn_r->reg_rec_count = 1;
10195         }
10196
10197     }
10198
10199   opcode1 = bits (arm_insn_r->arm_insn, 23, 27);
10200   if (24 == opcode1 && bit (arm_insn_r->arm_insn, 21)
10201       && !INSN_RECORDED(arm_insn_r))
10202     {
10203       ret = -1;
10204       /* Handle coprocessor insn extension space.  */
10205     }
10206
10207   /* To be done for ARMv5 and later; as of now we return -1.  */
10208   if (-1 == ret)
10209     return ret;
10210
10211   REG_ALLOC (arm_insn_r->arm_regs, arm_insn_r->reg_rec_count, record_buf);
10212   MEM_ALLOC (arm_insn_r->arm_mems, arm_insn_r->mem_rec_count, record_buf_mem);
10213
10214   return ret;
10215 }
10216
10217 /* Handling opcode 000 insns.  */
10218
10219 static int
10220 arm_record_data_proc_misc_ld_str (insn_decode_record *arm_insn_r)
10221 {
10222   struct regcache *reg_cache = arm_insn_r->regcache;
10223   uint32_t record_buf[8], record_buf_mem[8];
10224   ULONGEST u_regval[2] = {0};
10225
10226   uint32_t reg_src1 = 0;
10227   uint32_t opcode1 = 0;
10228
10229   arm_insn_r->opcode = bits (arm_insn_r->arm_insn, 21, 24);
10230   arm_insn_r->decode = bits (arm_insn_r->arm_insn, 4, 7);
10231   opcode1 = bits (arm_insn_r->arm_insn, 20, 24);
10232
10233   if (!((opcode1 & 0x19) == 0x10))
10234     {
10235       /* Data-processing (register) and Data-processing (register-shifted
10236          register */
10237       /* Out of 11 shifter operands mode, all the insn modifies destination
10238          register, which is specified by 13-16 decode.  */
10239       record_buf[0] = bits (arm_insn_r->arm_insn, 12, 15);
10240       record_buf[1] = ARM_PS_REGNUM;
10241       arm_insn_r->reg_rec_count = 2;
10242     }
10243   else if ((arm_insn_r->decode < 8) && ((opcode1 & 0x19) == 0x10))
10244     {
10245       /* Miscellaneous instructions */
10246
10247       if (3 == arm_insn_r->decode && 0x12 == opcode1
10248           && sbo_sbz (arm_insn_r->arm_insn, 9, 12, 1))
10249         {
10250           /* Handle BLX, branch and link/exchange.  */
10251           if (9 == arm_insn_r->opcode)
10252             {
10253               /* Branch is chosen by setting T bit of CSPR, bitp[0] of Rm,
10254                  and R14 stores the return address.  */
10255               record_buf[0] = ARM_PS_REGNUM;
10256               record_buf[1] = ARM_LR_REGNUM;
10257               arm_insn_r->reg_rec_count = 2;
10258             }
10259         }
10260       else if (7 == arm_insn_r->decode && 0x12 == opcode1)
10261         {
10262           /* Handle enhanced software breakpoint insn, BKPT.  */
10263           /* CPSR is changed to be executed in ARM state,  disabling normal
10264              interrupts, entering abort mode.  */
10265           /* According to high vector configuration PC is set.  */
10266           /* user hit breakpoint and type reverse, in
10267              that case, we need to go back with previous CPSR and
10268              Program Counter.  */
10269           record_buf[0] = ARM_PS_REGNUM;
10270           record_buf[1] = ARM_LR_REGNUM;
10271           arm_insn_r->reg_rec_count = 2;
10272
10273           /* Save SPSR also; how?  */
10274           return -1;
10275         }
10276       else if (1 == arm_insn_r->decode && 0x12 == opcode1
10277                && sbo_sbz (arm_insn_r->arm_insn, 9, 12, 1))
10278         {
10279           /* Handle BX, branch and link/exchange.  */
10280           /* Branch is chosen by setting T bit of CSPR, bitp[0] of Rm.  */
10281           record_buf[0] = ARM_PS_REGNUM;
10282           arm_insn_r->reg_rec_count = 1;
10283         }
10284       else if (1 == arm_insn_r->decode && 0x16 == opcode1
10285                && sbo_sbz (arm_insn_r->arm_insn, 9, 4, 1)
10286                && sbo_sbz (arm_insn_r->arm_insn, 17, 4, 1))
10287         {
10288           /* Count leading zeros: CLZ.  */
10289           record_buf[0] = bits (arm_insn_r->arm_insn, 12, 15);
10290           arm_insn_r->reg_rec_count = 1;
10291         }
10292       else if (!bit (arm_insn_r->arm_insn, INSN_S_L_BIT_NUM)
10293                && (8 == arm_insn_r->opcode || 10 == arm_insn_r->opcode)
10294                && sbo_sbz (arm_insn_r->arm_insn, 17, 4, 1)
10295                && sbo_sbz (arm_insn_r->arm_insn, 1, 12, 0))
10296         {
10297           /* Handle MRS insn.  */
10298           record_buf[0] = bits (arm_insn_r->arm_insn, 12, 15);
10299           arm_insn_r->reg_rec_count = 1;
10300         }
10301     }
10302   else if (9 == arm_insn_r->decode && opcode1 < 0x10)
10303     {
10304       /* Multiply and multiply-accumulate */
10305
10306       /* Handle multiply instructions.  */
10307       /* MLA, MUL, SMLAL, SMULL, UMLAL, UMULL.  */
10308       if (0 == arm_insn_r->opcode || 1 == arm_insn_r->opcode)
10309           {
10310             /* Handle MLA and MUL.  */
10311             record_buf[0] = bits (arm_insn_r->arm_insn, 16, 19);
10312             record_buf[1] = ARM_PS_REGNUM;
10313             arm_insn_r->reg_rec_count = 2;
10314           }
10315         else if (4 <= arm_insn_r->opcode && 7 >= arm_insn_r->opcode)
10316           {
10317             /* Handle SMLAL, SMULL, UMLAL, UMULL.  */
10318             record_buf[0] = bits (arm_insn_r->arm_insn, 16, 19);
10319             record_buf[1] = bits (arm_insn_r->arm_insn, 12, 15);
10320             record_buf[2] = ARM_PS_REGNUM;
10321             arm_insn_r->reg_rec_count = 3;
10322           }
10323     }
10324   else if (9 == arm_insn_r->decode  && opcode1 > 0x10)
10325     {
10326       /* Synchronization primitives */
10327
10328       /* Handling SWP, SWPB.  */
10329       /* These insn, changes register and memory as well.  */
10330       /* SWP or SWPB insn.  */
10331
10332       reg_src1 = bits (arm_insn_r->arm_insn, 16, 19);
10333       regcache_raw_read_unsigned (reg_cache, reg_src1, &u_regval[0]);
10334       /* SWP insn ?, swaps word.  */
10335       if (8 == arm_insn_r->opcode)
10336         {
10337           record_buf_mem[0] = 4;
10338         }
10339       else
10340         {
10341           /* SWPB insn, swaps only byte.  */
10342           record_buf_mem[0] = 1;
10343         }
10344       record_buf_mem[1] = u_regval[0];
10345       arm_insn_r->mem_rec_count = 1;
10346       record_buf[0] = bits (arm_insn_r->arm_insn, 12, 15);
10347       arm_insn_r->reg_rec_count = 1;
10348     }
10349   else if (11 == arm_insn_r->decode || 13 == arm_insn_r->decode
10350            || 15 == arm_insn_r->decode)
10351     {
10352       if ((opcode1 & 0x12) == 2)
10353         {
10354           /* Extra load/store (unprivileged) */
10355           return -1;
10356         }
10357       else
10358         {
10359           /* Extra load/store */
10360           switch (bits (arm_insn_r->arm_insn, 5, 6))
10361             {
10362             case 1:
10363               if ((opcode1 & 0x05) == 0x0 || (opcode1 & 0x05) == 0x4)
10364                 {
10365                   /* STRH (register), STRH (immediate) */
10366                   arm_record_strx (arm_insn_r, &record_buf[0],
10367                                    &record_buf_mem[0], ARM_RECORD_STRH);
10368                 }
10369               else if ((opcode1 & 0x05) == 0x1)
10370                 {
10371                   /* LDRH (register) */
10372                   record_buf[0] = bits (arm_insn_r->arm_insn, 12, 15);
10373                   arm_insn_r->reg_rec_count = 1;
10374
10375                   if (bit (arm_insn_r->arm_insn, 21))
10376                     {
10377                       /* Write back to Rn.  */
10378                       record_buf[arm_insn_r->reg_rec_count++]
10379                         = bits (arm_insn_r->arm_insn, 16, 19);
10380                     }
10381                 }
10382               else if ((opcode1 & 0x05) == 0x5)
10383                 {
10384                   /* LDRH (immediate), LDRH (literal) */
10385                   int rn = bits (arm_insn_r->arm_insn, 16, 19);
10386
10387                   record_buf[0] = bits (arm_insn_r->arm_insn, 12, 15);
10388                   arm_insn_r->reg_rec_count = 1;
10389
10390                   if (rn != 15)
10391                     {
10392                       /*LDRH (immediate) */
10393                       if (bit (arm_insn_r->arm_insn, 21))
10394                         {
10395                           /* Write back to Rn.  */
10396                           record_buf[arm_insn_r->reg_rec_count++] = rn;
10397                         }
10398                     }
10399                 }
10400               else
10401                 return -1;
10402               break;
10403             case 2:
10404               if ((opcode1 & 0x05) == 0x0)
10405                 {
10406                   /* LDRD (register) */
10407                   record_buf[0] = bits (arm_insn_r->arm_insn, 12, 15);
10408                   record_buf[1] = record_buf[0] + 1;
10409                   arm_insn_r->reg_rec_count = 2;
10410
10411                   if (bit (arm_insn_r->arm_insn, 21))
10412                     {
10413                       /* Write back to Rn.  */
10414                       record_buf[arm_insn_r->reg_rec_count++]
10415                         = bits (arm_insn_r->arm_insn, 16, 19);
10416                     }
10417                 }
10418               else if ((opcode1 & 0x05) == 0x1)
10419                 {
10420                   /* LDRSB (register) */
10421                   record_buf[0] = bits (arm_insn_r->arm_insn, 12, 15);
10422                   arm_insn_r->reg_rec_count = 1;
10423
10424                   if (bit (arm_insn_r->arm_insn, 21))
10425                     {
10426                       /* Write back to Rn.  */
10427                       record_buf[arm_insn_r->reg_rec_count++]
10428                         = bits (arm_insn_r->arm_insn, 16, 19);
10429                     }
10430                 }
10431               else if ((opcode1 & 0x05) == 0x4 || (opcode1 & 0x05) == 0x5)
10432                 {
10433                   /* LDRD (immediate), LDRD (literal), LDRSB (immediate),
10434                      LDRSB (literal) */
10435                   int rn = bits (arm_insn_r->arm_insn, 16, 19);
10436
10437                   record_buf[0] = bits (arm_insn_r->arm_insn, 12, 15);
10438                   arm_insn_r->reg_rec_count = 1;
10439
10440                   if (rn != 15)
10441                     {
10442                       /*LDRD (immediate), LDRSB (immediate) */
10443                       if (bit (arm_insn_r->arm_insn, 21))
10444                         {
10445                           /* Write back to Rn.  */
10446                           record_buf[arm_insn_r->reg_rec_count++] = rn;
10447                         }
10448                     }
10449                 }
10450               else
10451                 return -1;
10452               break;
10453             case 3:
10454               if ((opcode1 & 0x05) == 0x0)
10455                 {
10456                   /* STRD (register) */
10457                   arm_record_strx (arm_insn_r, &record_buf[0],
10458                                    &record_buf_mem[0], ARM_RECORD_STRD);
10459                 }
10460               else if ((opcode1 & 0x05) == 0x1)
10461                 {
10462                   /* LDRSH (register) */
10463                   record_buf[0] = bits (arm_insn_r->arm_insn, 12, 15);
10464                   arm_insn_r->reg_rec_count = 1;
10465
10466                   if (bit (arm_insn_r->arm_insn, 21))
10467                     {
10468                       /* Write back to Rn.  */
10469                       record_buf[arm_insn_r->reg_rec_count++]
10470                         = bits (arm_insn_r->arm_insn, 16, 19);
10471                     }
10472                 }
10473               else if ((opcode1 & 0x05) == 0x4)
10474                 {
10475                   /* STRD (immediate) */
10476                   arm_record_strx (arm_insn_r, &record_buf[0],
10477                                    &record_buf_mem[0], ARM_RECORD_STRD);
10478                 }
10479               else if ((opcode1 & 0x05) == 0x5)
10480                 {
10481                   /* LDRSH (immediate), LDRSH (literal) */
10482                   record_buf[0] = bits (arm_insn_r->arm_insn, 12, 15);
10483                   arm_insn_r->reg_rec_count = 1;
10484
10485                   if (bit (arm_insn_r->arm_insn, 21))
10486                     {
10487                       /* Write back to Rn.  */
10488                       record_buf[arm_insn_r->reg_rec_count++]
10489                         = bits (arm_insn_r->arm_insn, 16, 19);
10490                     }
10491                 }
10492               else
10493                 return -1;
10494               break;
10495             default:
10496               return -1;
10497             }
10498         }
10499     }
10500   else
10501     {
10502       return -1;
10503     }
10504
10505   REG_ALLOC (arm_insn_r->arm_regs, arm_insn_r->reg_rec_count, record_buf);
10506   MEM_ALLOC (arm_insn_r->arm_mems, arm_insn_r->mem_rec_count, record_buf_mem);
10507   return 0;
10508 }
10509
10510 /* Handling opcode 001 insns.  */
10511
10512 static int
10513 arm_record_data_proc_imm (insn_decode_record *arm_insn_r)
10514 {
10515   uint32_t record_buf[8], record_buf_mem[8];
10516
10517   arm_insn_r->opcode = bits (arm_insn_r->arm_insn, 21, 24);
10518   arm_insn_r->decode = bits (arm_insn_r->arm_insn, 4, 7);
10519
10520   if ((9 == arm_insn_r->opcode || 11 == arm_insn_r->opcode)
10521       && 2 == bits (arm_insn_r->arm_insn, 20, 21)
10522       && sbo_sbz (arm_insn_r->arm_insn, 13, 4, 1)
10523      )
10524     {
10525       /* Handle MSR insn.  */
10526       if (9 == arm_insn_r->opcode)
10527         {
10528           /* CSPR is going to be changed.  */
10529           record_buf[0] = ARM_PS_REGNUM;
10530           arm_insn_r->reg_rec_count = 1;
10531         }
10532       else
10533         {
10534           /* SPSR is going to be changed.  */
10535         }
10536     }
10537   else if (arm_insn_r->opcode <= 15)
10538     {
10539       /* Normal data processing insns.  */
10540       /* Out of 11 shifter operands mode, all the insn modifies destination
10541          register, which is specified by 13-16 decode.  */
10542       record_buf[0] = bits (arm_insn_r->arm_insn, 12, 15);
10543       record_buf[1] = ARM_PS_REGNUM;
10544       arm_insn_r->reg_rec_count = 2;
10545     }
10546   else
10547     {
10548       return -1;
10549     }
10550
10551   REG_ALLOC (arm_insn_r->arm_regs, arm_insn_r->reg_rec_count, record_buf);
10552   MEM_ALLOC (arm_insn_r->arm_mems, arm_insn_r->mem_rec_count, record_buf_mem);
10553   return 0;
10554 }
10555
10556 static int
10557 arm_record_media (insn_decode_record *arm_insn_r)
10558 {
10559   uint32_t record_buf[8];
10560
10561   switch (bits (arm_insn_r->arm_insn, 22, 24))
10562     {
10563     case 0:
10564       /* Parallel addition and subtraction, signed */
10565     case 1:
10566       /* Parallel addition and subtraction, unsigned */
10567     case 2:
10568     case 3:
10569       /* Packing, unpacking, saturation and reversal */
10570       {
10571         int rd = bits (arm_insn_r->arm_insn, 12, 15);
10572
10573         record_buf[arm_insn_r->reg_rec_count++] = rd;
10574       }
10575       break;
10576
10577     case 4:
10578     case 5:
10579       /* Signed multiplies */
10580       {
10581         int rd = bits (arm_insn_r->arm_insn, 16, 19);
10582         unsigned int op1 = bits (arm_insn_r->arm_insn, 20, 22);
10583
10584         record_buf[arm_insn_r->reg_rec_count++] = rd;
10585         if (op1 == 0x0)
10586           record_buf[arm_insn_r->reg_rec_count++] = ARM_PS_REGNUM;
10587         else if (op1 == 0x4)
10588           record_buf[arm_insn_r->reg_rec_count++]
10589             = bits (arm_insn_r->arm_insn, 12, 15);
10590       }
10591       break;
10592
10593     case 6:
10594       {
10595         if (bit (arm_insn_r->arm_insn, 21)
10596             && bits (arm_insn_r->arm_insn, 5, 6) == 0x2)
10597           {
10598             /* SBFX */
10599             record_buf[arm_insn_r->reg_rec_count++]
10600               = bits (arm_insn_r->arm_insn, 12, 15);
10601           }
10602         else if (bits (arm_insn_r->arm_insn, 20, 21) == 0x0
10603                  && bits (arm_insn_r->arm_insn, 5, 7) == 0x0)
10604           {
10605             /* USAD8 and USADA8 */
10606             record_buf[arm_insn_r->reg_rec_count++]
10607               = bits (arm_insn_r->arm_insn, 16, 19);
10608           }
10609       }
10610       break;
10611
10612     case 7:
10613       {
10614         if (bits (arm_insn_r->arm_insn, 20, 21) == 0x3
10615             && bits (arm_insn_r->arm_insn, 5, 7) == 0x7)
10616           {
10617             /* Permanently UNDEFINED */
10618             return -1;
10619           }
10620         else
10621           {
10622             /* BFC, BFI and UBFX */
10623             record_buf[arm_insn_r->reg_rec_count++]
10624               = bits (arm_insn_r->arm_insn, 12, 15);
10625           }
10626       }
10627       break;
10628
10629     default:
10630       return -1;
10631     }
10632
10633   REG_ALLOC (arm_insn_r->arm_regs, arm_insn_r->reg_rec_count, record_buf);
10634
10635   return 0;
10636 }
10637
10638 /* Handle ARM mode instructions with opcode 010.  */
10639
10640 static int
10641 arm_record_ld_st_imm_offset (insn_decode_record *arm_insn_r)
10642 {
10643   struct regcache *reg_cache = arm_insn_r->regcache;
10644
10645   uint32_t reg_base , reg_dest;
10646   uint32_t offset_12, tgt_mem_addr;
10647   uint32_t record_buf[8], record_buf_mem[8];
10648   unsigned char wback;
10649   ULONGEST u_regval;
10650
10651   /* Calculate wback.  */
10652   wback = (bit (arm_insn_r->arm_insn, 24) == 0)
10653           || (bit (arm_insn_r->arm_insn, 21) == 1);
10654
10655   arm_insn_r->reg_rec_count = 0;
10656   reg_base = bits (arm_insn_r->arm_insn, 16, 19);
10657
10658   if (bit (arm_insn_r->arm_insn, INSN_S_L_BIT_NUM))
10659     {
10660       /* LDR (immediate), LDR (literal), LDRB (immediate), LDRB (literal), LDRBT
10661          and LDRT.  */
10662
10663       reg_dest = bits (arm_insn_r->arm_insn, 12, 15);
10664       record_buf[arm_insn_r->reg_rec_count++] = reg_dest;
10665
10666       /* The LDR instruction is capable of doing branching.  If MOV LR, PC
10667          preceeds a LDR instruction having R15 as reg_base, it
10668          emulates a branch and link instruction, and hence we need to save
10669          CPSR and PC as well.  */
10670       if (ARM_PC_REGNUM == reg_dest)
10671         record_buf[arm_insn_r->reg_rec_count++] = ARM_PS_REGNUM;
10672
10673       /* If wback is true, also save the base register, which is going to be
10674          written to.  */
10675       if (wback)
10676         record_buf[arm_insn_r->reg_rec_count++] = reg_base;
10677     }
10678   else
10679     {
10680       /* STR (immediate), STRB (immediate), STRBT and STRT.  */
10681
10682       offset_12 = bits (arm_insn_r->arm_insn, 0, 11);
10683       regcache_raw_read_unsigned (reg_cache, reg_base, &u_regval);
10684
10685       /* Handle bit U.  */
10686       if (bit (arm_insn_r->arm_insn, 23))
10687         {
10688           /* U == 1: Add the offset. */
10689           tgt_mem_addr = (uint32_t) u_regval + offset_12;
10690         }
10691       else
10692         {
10693           /* U == 0: subtract the offset. */
10694           tgt_mem_addr = (uint32_t) u_regval - offset_12;
10695         }
10696
10697       /* Bit 22 tells us whether the store instruction writes 1 byte or 4
10698          bytes.  */
10699       if (bit (arm_insn_r->arm_insn, 22))
10700         {
10701           /* STRB and STRBT: 1 byte.  */
10702           record_buf_mem[0] = 1;
10703         }
10704       else
10705         {
10706           /* STR and STRT: 4 bytes.  */
10707           record_buf_mem[0] = 4;
10708         }
10709
10710       /* Handle bit P.  */
10711       if (bit (arm_insn_r->arm_insn, 24))
10712         record_buf_mem[1] = tgt_mem_addr;
10713       else
10714         record_buf_mem[1] = (uint32_t) u_regval;
10715
10716       arm_insn_r->mem_rec_count = 1;
10717
10718       /* If wback is true, also save the base register, which is going to be
10719          written to.  */
10720       if (wback)
10721         record_buf[arm_insn_r->reg_rec_count++] = reg_base;
10722     }
10723
10724   REG_ALLOC (arm_insn_r->arm_regs, arm_insn_r->reg_rec_count, record_buf);
10725   MEM_ALLOC (arm_insn_r->arm_mems, arm_insn_r->mem_rec_count, record_buf_mem);
10726   return 0;
10727 }
10728
10729 /* Handling opcode 011 insns.  */
10730
10731 static int
10732 arm_record_ld_st_reg_offset (insn_decode_record *arm_insn_r)
10733 {
10734   struct regcache *reg_cache = arm_insn_r->regcache;
10735
10736   uint32_t shift_imm = 0;
10737   uint32_t reg_src1 = 0, reg_src2 = 0, reg_dest = 0;
10738   uint32_t offset_12 = 0, tgt_mem_addr = 0;
10739   uint32_t record_buf[8], record_buf_mem[8];
10740
10741   LONGEST s_word;
10742   ULONGEST u_regval[2];
10743
10744   if (bit (arm_insn_r->arm_insn, 4))
10745     return arm_record_media (arm_insn_r);
10746
10747   arm_insn_r->opcode = bits (arm_insn_r->arm_insn, 21, 24);
10748   arm_insn_r->decode = bits (arm_insn_r->arm_insn, 4, 7);
10749
10750   /* Handle enhanced store insns and LDRD DSP insn,
10751      order begins according to addressing modes for store insns
10752      STRH insn.  */
10753
10754   /* LDR or STR?  */
10755   if (bit (arm_insn_r->arm_insn, INSN_S_L_BIT_NUM))
10756     {
10757       reg_dest = bits (arm_insn_r->arm_insn, 12, 15);
10758       /* LDR insn has a capability to do branching, if
10759          MOV LR, PC is precedded by LDR insn having Rn as R15
10760          in that case, it emulates branch and link insn, and hence we
10761          need to save CSPR and PC as well.  */
10762       if (15 != reg_dest)
10763         {
10764           record_buf[0] = bits (arm_insn_r->arm_insn, 12, 15);
10765           arm_insn_r->reg_rec_count = 1;
10766         }
10767       else
10768         {
10769           record_buf[0] = reg_dest;
10770           record_buf[1] = ARM_PS_REGNUM;
10771           arm_insn_r->reg_rec_count = 2;
10772         }
10773     }
10774   else
10775     {
10776       if (! bits (arm_insn_r->arm_insn, 4, 11))
10777         {
10778           /* Store insn, register offset and register pre-indexed,
10779              register post-indexed.  */
10780           /* Get Rm.  */
10781           reg_src1 = bits (arm_insn_r->arm_insn, 0, 3);
10782           /* Get Rn.  */
10783           reg_src2 = bits (arm_insn_r->arm_insn, 16, 19);
10784           regcache_raw_read_unsigned (reg_cache, reg_src1
10785                                       , &u_regval[0]);
10786           regcache_raw_read_unsigned (reg_cache, reg_src2
10787                                       , &u_regval[1]);
10788           if (15 == reg_src2)
10789             {
10790               /* If R15 was used as Rn, hence current PC+8.  */
10791               /* Pre-indexed mode doesnt reach here ; illegal insn.  */
10792                 u_regval[0] = u_regval[0] + 8;
10793             }
10794           /* Calculate target store address, Rn +/- Rm, register offset.  */
10795           /* U == 1.  */
10796           if (bit (arm_insn_r->arm_insn, 23))
10797             {
10798               tgt_mem_addr = u_regval[0] + u_regval[1];
10799             }
10800           else
10801             {
10802               tgt_mem_addr = u_regval[1] - u_regval[0];
10803             }
10804
10805           switch (arm_insn_r->opcode)
10806             {
10807               /* STR.  */
10808               case 8:
10809               case 12:
10810               /* STR.  */    
10811               case 9:
10812               case 13:
10813               /* STRT.  */
10814               case 1:
10815               case 5:
10816               /* STR.  */
10817               case 0:
10818               case 4:
10819                 record_buf_mem[0] = 4;
10820               break;
10821
10822               /* STRB.  */
10823               case 10:
10824               case 14:
10825               /* STRB.  */
10826               case 11:
10827               case 15:
10828               /* STRBT.  */    
10829               case 3:
10830               case 7:
10831               /* STRB.  */
10832               case 2:
10833               case 6:
10834                 record_buf_mem[0] = 1;
10835               break;
10836
10837               default:
10838                 gdb_assert_not_reached ("no decoding pattern found");
10839               break;
10840             }
10841           record_buf_mem[1] = tgt_mem_addr;
10842           arm_insn_r->mem_rec_count = 1;
10843
10844           if (9 == arm_insn_r->opcode || 11 == arm_insn_r->opcode
10845               || 13 == arm_insn_r->opcode || 15 == arm_insn_r->opcode
10846               || 0 == arm_insn_r->opcode || 2 == arm_insn_r->opcode
10847               || 4 == arm_insn_r->opcode || 6 == arm_insn_r->opcode
10848               || 1 == arm_insn_r->opcode || 3 == arm_insn_r->opcode
10849               || 5 == arm_insn_r->opcode || 7 == arm_insn_r->opcode
10850              )
10851             {
10852               /* Rn is going to be changed in pre-indexed mode and
10853                  post-indexed mode as well.  */
10854               record_buf[0] = reg_src2;
10855               arm_insn_r->reg_rec_count = 1;
10856             }
10857         }
10858       else
10859         {
10860           /* Store insn, scaled register offset; scaled pre-indexed.  */
10861           offset_12 = bits (arm_insn_r->arm_insn, 5, 6);
10862           /* Get Rm.  */
10863           reg_src1 = bits (arm_insn_r->arm_insn, 0, 3);
10864           /* Get Rn.  */
10865           reg_src2 = bits (arm_insn_r->arm_insn, 16, 19);
10866           /* Get shift_imm.  */
10867           shift_imm = bits (arm_insn_r->arm_insn, 7, 11);
10868           regcache_raw_read_unsigned (reg_cache, reg_src1, &u_regval[0]);
10869           regcache_raw_read_signed (reg_cache, reg_src1, &s_word);
10870           regcache_raw_read_unsigned (reg_cache, reg_src2, &u_regval[1]);
10871           /* Offset_12 used as shift.  */
10872           switch (offset_12)
10873             {
10874               case 0:
10875                 /* Offset_12 used as index.  */
10876                 offset_12 = u_regval[0] << shift_imm;
10877               break;
10878
10879               case 1:
10880                 offset_12 = (!shift_imm)?0:u_regval[0] >> shift_imm;
10881               break;
10882
10883               case 2:
10884                 if (!shift_imm)
10885                   {
10886                     if (bit (u_regval[0], 31))
10887                       {
10888                         offset_12 = 0xFFFFFFFF;
10889                       }
10890                     else
10891                       {
10892                         offset_12 = 0;
10893                       }
10894                   }
10895                 else
10896                   {
10897                     /* This is arithmetic shift.  */
10898                     offset_12 = s_word >> shift_imm;
10899                   }
10900                 break;
10901
10902               case 3:
10903                 if (!shift_imm)
10904                   {
10905                     regcache_raw_read_unsigned (reg_cache, ARM_PS_REGNUM,
10906                                                 &u_regval[1]);
10907                     /* Get C flag value and shift it by 31.  */
10908                     offset_12 = (((bit (u_regval[1], 29)) << 31) \
10909                                   | (u_regval[0]) >> 1);
10910                   }
10911                 else
10912                   {
10913                     offset_12 = (u_regval[0] >> shift_imm) \
10914                                 | (u_regval[0] <<
10915                                 (sizeof(uint32_t) - shift_imm));
10916                   }
10917               break;
10918
10919               default:
10920                 gdb_assert_not_reached ("no decoding pattern found");
10921               break;
10922             }
10923
10924           regcache_raw_read_unsigned (reg_cache, reg_src2, &u_regval[1]);
10925           /* bit U set.  */
10926           if (bit (arm_insn_r->arm_insn, 23))
10927             {
10928               tgt_mem_addr = u_regval[1] + offset_12;
10929             }
10930           else
10931             {
10932               tgt_mem_addr = u_regval[1] - offset_12;
10933             }
10934
10935           switch (arm_insn_r->opcode)
10936             {
10937               /* STR.  */
10938               case 8:
10939               case 12:
10940               /* STR.  */    
10941               case 9:
10942               case 13:
10943               /* STRT.  */
10944               case 1:
10945               case 5:
10946               /* STR.  */
10947               case 0:
10948               case 4:
10949                 record_buf_mem[0] = 4;
10950               break;
10951
10952               /* STRB.  */
10953               case 10:
10954               case 14:
10955               /* STRB.  */
10956               case 11:
10957               case 15:
10958               /* STRBT.  */    
10959               case 3:
10960               case 7:
10961               /* STRB.  */
10962               case 2:
10963               case 6:
10964                 record_buf_mem[0] = 1;
10965               break;
10966
10967               default:
10968                 gdb_assert_not_reached ("no decoding pattern found");
10969               break;
10970             }
10971           record_buf_mem[1] = tgt_mem_addr;
10972           arm_insn_r->mem_rec_count = 1;
10973
10974           if (9 == arm_insn_r->opcode || 11 == arm_insn_r->opcode
10975               || 13 == arm_insn_r->opcode || 15 == arm_insn_r->opcode
10976               || 0 == arm_insn_r->opcode || 2 == arm_insn_r->opcode
10977               || 4 == arm_insn_r->opcode || 6 == arm_insn_r->opcode
10978               || 1 == arm_insn_r->opcode || 3 == arm_insn_r->opcode
10979               || 5 == arm_insn_r->opcode || 7 == arm_insn_r->opcode
10980              )
10981             {
10982               /* Rn is going to be changed in register scaled pre-indexed
10983                  mode,and scaled post indexed mode.  */
10984               record_buf[0] = reg_src2;
10985               arm_insn_r->reg_rec_count = 1;
10986             }
10987         }
10988     }
10989
10990   REG_ALLOC (arm_insn_r->arm_regs, arm_insn_r->reg_rec_count, record_buf);
10991   MEM_ALLOC (arm_insn_r->arm_mems, arm_insn_r->mem_rec_count, record_buf_mem);
10992   return 0;
10993 }
10994
10995 /* Handle ARM mode instructions with opcode 100.  */
10996
10997 static int
10998 arm_record_ld_st_multiple (insn_decode_record *arm_insn_r)
10999 {
11000   struct regcache *reg_cache = arm_insn_r->regcache;
11001   uint32_t register_count = 0, register_bits;
11002   uint32_t reg_base, addr_mode;
11003   uint32_t record_buf[24], record_buf_mem[48];
11004   uint32_t wback;
11005   ULONGEST u_regval;
11006
11007   /* Fetch the list of registers.  */
11008   register_bits = bits (arm_insn_r->arm_insn, 0, 15);
11009   arm_insn_r->reg_rec_count = 0;
11010
11011   /* Fetch the base register that contains the address we are loading data
11012      to.  */
11013   reg_base = bits (arm_insn_r->arm_insn, 16, 19);
11014
11015   /* Calculate wback.  */
11016   wback = (bit (arm_insn_r->arm_insn, 21) == 1);
11017
11018   if (bit (arm_insn_r->arm_insn, INSN_S_L_BIT_NUM))
11019     {
11020       /* LDM/LDMIA/LDMFD, LDMDA/LDMFA, LDMDB and LDMIB.  */
11021
11022       /* Find out which registers are going to be loaded from memory.  */
11023       while (register_bits)
11024         {
11025           if (register_bits & 0x00000001)
11026             record_buf[arm_insn_r->reg_rec_count++] = register_count;
11027           register_bits = register_bits >> 1;
11028           register_count++;
11029         }
11030
11031   
11032       /* If wback is true, also save the base register, which is going to be
11033          written to.  */
11034       if (wback)
11035         record_buf[arm_insn_r->reg_rec_count++] = reg_base;
11036
11037       /* Save the CPSR register.  */
11038       record_buf[arm_insn_r->reg_rec_count++] = ARM_PS_REGNUM;
11039     }
11040   else
11041     {
11042       /* STM (STMIA, STMEA), STMDA (STMED), STMDB (STMFD) and STMIB (STMFA).  */
11043
11044       addr_mode = bits (arm_insn_r->arm_insn, 23, 24); 
11045
11046       regcache_raw_read_unsigned (reg_cache, reg_base, &u_regval);
11047
11048       /* Find out how many registers are going to be stored to memory.  */
11049       while (register_bits)
11050         {
11051           if (register_bits & 0x00000001)
11052             register_count++;
11053           register_bits = register_bits >> 1;
11054         }
11055
11056       switch (addr_mode)
11057         {
11058           /* STMDA (STMED): Decrement after.  */
11059           case 0:
11060           record_buf_mem[1] = (uint32_t) u_regval
11061                               - register_count * INT_REGISTER_SIZE + 4;
11062           break;
11063           /* STM (STMIA, STMEA): Increment after.  */
11064           case 1:
11065           record_buf_mem[1] = (uint32_t) u_regval;
11066           break;
11067           /* STMDB (STMFD): Decrement before.  */
11068           case 2:
11069           record_buf_mem[1] = (uint32_t) u_regval
11070                               - register_count * INT_REGISTER_SIZE;
11071           break;
11072           /* STMIB (STMFA): Increment before.  */
11073           case 3:
11074           record_buf_mem[1] = (uint32_t) u_regval + INT_REGISTER_SIZE;
11075           break;
11076           default:
11077             gdb_assert_not_reached ("no decoding pattern found");
11078           break;
11079         }
11080
11081       record_buf_mem[0] = register_count * INT_REGISTER_SIZE;
11082       arm_insn_r->mem_rec_count = 1;
11083
11084       /* If wback is true, also save the base register, which is going to be
11085          written to.  */
11086       if (wback)
11087         record_buf[arm_insn_r->reg_rec_count++] = reg_base;
11088     }
11089
11090   REG_ALLOC (arm_insn_r->arm_regs, arm_insn_r->reg_rec_count, record_buf);
11091   MEM_ALLOC (arm_insn_r->arm_mems, arm_insn_r->mem_rec_count, record_buf_mem);
11092   return 0;
11093 }
11094
11095 /* Handling opcode 101 insns.  */
11096
11097 static int
11098 arm_record_b_bl (insn_decode_record *arm_insn_r)
11099 {
11100   uint32_t record_buf[8];
11101
11102   /* Handle B, BL, BLX(1) insns.  */
11103   /* B simply branches so we do nothing here.  */
11104   /* Note: BLX(1) doesnt fall here but instead it falls into
11105      extension space.  */
11106   if (bit (arm_insn_r->arm_insn, 24))
11107   {
11108     record_buf[0] = ARM_LR_REGNUM;
11109     arm_insn_r->reg_rec_count = 1;
11110   }
11111
11112   REG_ALLOC (arm_insn_r->arm_regs, arm_insn_r->reg_rec_count, record_buf);
11113
11114   return 0;
11115 }
11116
11117 static int
11118 arm_record_unsupported_insn (insn_decode_record *arm_insn_r)
11119 {
11120   printf_unfiltered (_("Process record does not support instruction "
11121                        "0x%0x at address %s.\n"),arm_insn_r->arm_insn,
11122                      paddress (arm_insn_r->gdbarch, arm_insn_r->this_addr));
11123
11124   return -1;
11125 }
11126
11127 /* Record handler for vector data transfer instructions.  */
11128
11129 static int
11130 arm_record_vdata_transfer_insn (insn_decode_record *arm_insn_r)
11131 {
11132   uint32_t bits_a, bit_c, bit_l, reg_t, reg_v;
11133   uint32_t record_buf[4];
11134
11135   reg_t = bits (arm_insn_r->arm_insn, 12, 15);
11136   reg_v = bits (arm_insn_r->arm_insn, 21, 23);
11137   bits_a = bits (arm_insn_r->arm_insn, 21, 23);
11138   bit_l = bit (arm_insn_r->arm_insn, 20);
11139   bit_c = bit (arm_insn_r->arm_insn, 8);
11140
11141   /* Handle VMOV instruction.  */
11142   if (bit_l && bit_c)
11143     {
11144       record_buf[0] = reg_t;
11145       arm_insn_r->reg_rec_count = 1;
11146     }
11147   else if (bit_l && !bit_c)
11148     {
11149       /* Handle VMOV instruction.  */
11150       if (bits_a == 0x00)
11151         {
11152           record_buf[0] = reg_t;
11153           arm_insn_r->reg_rec_count = 1;
11154         }
11155       /* Handle VMRS instruction.  */
11156       else if (bits_a == 0x07)
11157         {
11158           if (reg_t == 15)
11159             reg_t = ARM_PS_REGNUM;
11160
11161           record_buf[0] = reg_t;
11162           arm_insn_r->reg_rec_count = 1;
11163         }
11164     }
11165   else if (!bit_l && !bit_c)
11166     {
11167       /* Handle VMOV instruction.  */
11168       if (bits_a == 0x00)
11169         {
11170           record_buf[0] = ARM_D0_REGNUM + reg_v;
11171
11172           arm_insn_r->reg_rec_count = 1;
11173         }
11174       /* Handle VMSR instruction.  */
11175       else if (bits_a == 0x07)
11176         {
11177           record_buf[0] = ARM_FPSCR_REGNUM;
11178           arm_insn_r->reg_rec_count = 1;
11179         }
11180     }
11181   else if (!bit_l && bit_c)
11182     {
11183       /* Handle VMOV instruction.  */
11184       if (!(bits_a & 0x04))
11185         {
11186           record_buf[0] = (reg_v | (bit (arm_insn_r->arm_insn, 7) << 4))
11187                           + ARM_D0_REGNUM;
11188           arm_insn_r->reg_rec_count = 1;
11189         }
11190       /* Handle VDUP instruction.  */
11191       else
11192         {
11193           if (bit (arm_insn_r->arm_insn, 21))
11194             {
11195               reg_v = reg_v | (bit (arm_insn_r->arm_insn, 7) << 4);
11196               record_buf[0] = reg_v + ARM_D0_REGNUM;
11197               record_buf[1] = reg_v + ARM_D0_REGNUM + 1;
11198               arm_insn_r->reg_rec_count = 2;
11199             }
11200           else
11201             {
11202               reg_v = reg_v | (bit (arm_insn_r->arm_insn, 7) << 4);
11203               record_buf[0] = reg_v + ARM_D0_REGNUM;
11204               arm_insn_r->reg_rec_count = 1;
11205             }
11206         }
11207     }
11208
11209   REG_ALLOC (arm_insn_r->arm_regs, arm_insn_r->reg_rec_count, record_buf);
11210   return 0;
11211 }
11212
11213 /* Record handler for extension register load/store instructions.  */
11214
11215 static int
11216 arm_record_exreg_ld_st_insn (insn_decode_record *arm_insn_r)
11217 {
11218   uint32_t opcode, single_reg;
11219   uint8_t op_vldm_vstm;
11220   uint32_t record_buf[8], record_buf_mem[128];
11221   ULONGEST u_regval = 0;
11222
11223   struct regcache *reg_cache = arm_insn_r->regcache;
11224
11225   opcode = bits (arm_insn_r->arm_insn, 20, 24);
11226   single_reg = !bit (arm_insn_r->arm_insn, 8);
11227   op_vldm_vstm = opcode & 0x1b;
11228
11229   /* Handle VMOV instructions.  */
11230   if ((opcode & 0x1e) == 0x04)
11231     {
11232       if (bit (arm_insn_r->arm_insn, 20)) /* to_arm_registers bit 20? */
11233         {
11234           record_buf[0] = bits (arm_insn_r->arm_insn, 12, 15);
11235           record_buf[1] = bits (arm_insn_r->arm_insn, 16, 19);
11236           arm_insn_r->reg_rec_count = 2;
11237         }
11238       else
11239         {
11240           uint8_t reg_m = bits (arm_insn_r->arm_insn, 0, 3);
11241           uint8_t bit_m = bit (arm_insn_r->arm_insn, 5);
11242
11243           if (single_reg)
11244             {
11245               /* The first S register number m is REG_M:M (M is bit 5),
11246                  the corresponding D register number is REG_M:M / 2, which
11247                  is REG_M.  */
11248               record_buf[arm_insn_r->reg_rec_count++] = ARM_D0_REGNUM + reg_m;
11249               /* The second S register number is REG_M:M + 1, the
11250                  corresponding D register number is (REG_M:M + 1) / 2.
11251                  IOW, if bit M is 1, the first and second S registers
11252                  are mapped to different D registers, otherwise, they are
11253                  in the same D register.  */
11254               if (bit_m)
11255                 {
11256                   record_buf[arm_insn_r->reg_rec_count++]
11257                     = ARM_D0_REGNUM + reg_m + 1;
11258                 }
11259             }
11260           else
11261             {
11262               record_buf[0] = ((bit_m << 4) + reg_m + ARM_D0_REGNUM);
11263               arm_insn_r->reg_rec_count = 1;
11264             }
11265         }
11266     }
11267   /* Handle VSTM and VPUSH instructions.  */
11268   else if (op_vldm_vstm == 0x08 || op_vldm_vstm == 0x0a
11269            || op_vldm_vstm == 0x12)
11270     {
11271       uint32_t start_address, reg_rn, imm_off32, imm_off8, memory_count;
11272       uint32_t memory_index = 0;
11273
11274       reg_rn = bits (arm_insn_r->arm_insn, 16, 19);
11275       regcache_raw_read_unsigned (reg_cache, reg_rn, &u_regval);
11276       imm_off8 = bits (arm_insn_r->arm_insn, 0, 7);
11277       imm_off32 = imm_off8 << 2;
11278       memory_count = imm_off8;
11279
11280       if (bit (arm_insn_r->arm_insn, 23))
11281         start_address = u_regval;
11282       else
11283         start_address = u_regval - imm_off32;
11284
11285       if (bit (arm_insn_r->arm_insn, 21))
11286         {
11287           record_buf[0] = reg_rn;
11288           arm_insn_r->reg_rec_count = 1;
11289         }
11290
11291       while (memory_count > 0)
11292         {
11293           if (single_reg)
11294             {
11295               record_buf_mem[memory_index] = 4;
11296               record_buf_mem[memory_index + 1] = start_address;
11297               start_address = start_address + 4;
11298               memory_index = memory_index + 2;
11299             }
11300           else
11301             {
11302               record_buf_mem[memory_index] = 4;
11303               record_buf_mem[memory_index + 1] = start_address;
11304               record_buf_mem[memory_index + 2] = 4;
11305               record_buf_mem[memory_index + 3] = start_address + 4;
11306               start_address = start_address + 8;
11307               memory_index = memory_index + 4;
11308             }
11309           memory_count--;
11310         }
11311       arm_insn_r->mem_rec_count = (memory_index >> 1);
11312     }
11313   /* Handle VLDM instructions.  */
11314   else if (op_vldm_vstm == 0x09 || op_vldm_vstm == 0x0b
11315            || op_vldm_vstm == 0x13)
11316     {
11317       uint32_t reg_count, reg_vd;
11318       uint32_t reg_index = 0;
11319       uint32_t bit_d = bit (arm_insn_r->arm_insn, 22);
11320
11321       reg_vd = bits (arm_insn_r->arm_insn, 12, 15);
11322       reg_count = bits (arm_insn_r->arm_insn, 0, 7);
11323
11324       /* REG_VD is the first D register number.  If the instruction
11325          loads memory to S registers (SINGLE_REG is TRUE), the register
11326          number is (REG_VD << 1 | bit D), so the corresponding D
11327          register number is (REG_VD << 1 | bit D) / 2 = REG_VD.  */
11328       if (!single_reg)
11329         reg_vd = reg_vd | (bit_d << 4);
11330
11331       if (bit (arm_insn_r->arm_insn, 21) /* write back */)
11332         record_buf[reg_index++] = bits (arm_insn_r->arm_insn, 16, 19);
11333
11334       /* If the instruction loads memory to D register, REG_COUNT should
11335          be divided by 2, according to the ARM Architecture Reference
11336          Manual.  If the instruction loads memory to S register, divide by
11337          2 as well because two S registers are mapped to D register.  */
11338       reg_count  = reg_count / 2;
11339       if (single_reg && bit_d)
11340         {
11341           /* Increase the register count if S register list starts from
11342              an odd number (bit d is one).  */
11343           reg_count++;
11344         }
11345
11346       while (reg_count > 0)
11347         {
11348           record_buf[reg_index++] = ARM_D0_REGNUM + reg_vd + reg_count - 1;
11349           reg_count--;
11350         }
11351       arm_insn_r->reg_rec_count = reg_index;
11352     }
11353   /* VSTR Vector store register.  */
11354   else if ((opcode & 0x13) == 0x10)
11355     {
11356       uint32_t start_address, reg_rn, imm_off32, imm_off8;
11357       uint32_t memory_index = 0;
11358
11359       reg_rn = bits (arm_insn_r->arm_insn, 16, 19);
11360       regcache_raw_read_unsigned (reg_cache, reg_rn, &u_regval);
11361       imm_off8 = bits (arm_insn_r->arm_insn, 0, 7);
11362       imm_off32 = imm_off8 << 2;
11363
11364       if (bit (arm_insn_r->arm_insn, 23))
11365         start_address = u_regval + imm_off32;
11366       else
11367         start_address = u_regval - imm_off32;
11368
11369       if (single_reg)
11370         {
11371           record_buf_mem[memory_index] = 4;
11372           record_buf_mem[memory_index + 1] = start_address;
11373           arm_insn_r->mem_rec_count = 1;
11374         }
11375       else
11376         {
11377           record_buf_mem[memory_index] = 4;
11378           record_buf_mem[memory_index + 1] = start_address;
11379           record_buf_mem[memory_index + 2] = 4;
11380           record_buf_mem[memory_index + 3] = start_address + 4;
11381           arm_insn_r->mem_rec_count = 2;
11382         }
11383     }
11384   /* VLDR Vector load register.  */
11385   else if ((opcode & 0x13) == 0x11)
11386     {
11387       uint32_t reg_vd = bits (arm_insn_r->arm_insn, 12, 15);
11388
11389       if (!single_reg)
11390         {
11391           reg_vd = reg_vd | (bit (arm_insn_r->arm_insn, 22) << 4);
11392           record_buf[0] = ARM_D0_REGNUM + reg_vd;
11393         }
11394       else
11395         {
11396           reg_vd = (reg_vd << 1) | bit (arm_insn_r->arm_insn, 22);
11397           /* Record register D rather than pseudo register S.  */
11398           record_buf[0] = ARM_D0_REGNUM + reg_vd / 2;
11399         }
11400       arm_insn_r->reg_rec_count = 1;
11401     }
11402
11403   REG_ALLOC (arm_insn_r->arm_regs, arm_insn_r->reg_rec_count, record_buf);
11404   MEM_ALLOC (arm_insn_r->arm_mems, arm_insn_r->mem_rec_count, record_buf_mem);
11405   return 0;
11406 }
11407
11408 /* Record handler for arm/thumb mode VFP data processing instructions.  */
11409
11410 static int
11411 arm_record_vfp_data_proc_insn (insn_decode_record *arm_insn_r)
11412 {
11413   uint32_t opc1, opc2, opc3, dp_op_sz, bit_d, reg_vd;
11414   uint32_t record_buf[4];
11415   enum insn_types {INSN_T0, INSN_T1, INSN_T2, INSN_T3, INSN_INV};
11416   enum insn_types curr_insn_type = INSN_INV;
11417
11418   reg_vd = bits (arm_insn_r->arm_insn, 12, 15);
11419   opc1 = bits (arm_insn_r->arm_insn, 20, 23);
11420   opc2 = bits (arm_insn_r->arm_insn, 16, 19);
11421   opc3 = bits (arm_insn_r->arm_insn, 6, 7);
11422   dp_op_sz = bit (arm_insn_r->arm_insn, 8);
11423   bit_d = bit (arm_insn_r->arm_insn, 22);
11424   /* Mask off the "D" bit.  */
11425   opc1 = opc1 & ~0x04;
11426
11427   /* Handle VMLA, VMLS.  */
11428   if (opc1 == 0x00)
11429     {
11430       if (bit (arm_insn_r->arm_insn, 10))
11431         {
11432           if (bit (arm_insn_r->arm_insn, 6))
11433             curr_insn_type = INSN_T0;
11434           else
11435             curr_insn_type = INSN_T1;
11436         }
11437       else
11438         {
11439           if (dp_op_sz)
11440             curr_insn_type = INSN_T1;
11441           else
11442             curr_insn_type = INSN_T2;
11443         }
11444     }
11445   /* Handle VNMLA, VNMLS, VNMUL.  */
11446   else if (opc1 == 0x01)
11447     {
11448       if (dp_op_sz)
11449         curr_insn_type = INSN_T1;
11450       else
11451         curr_insn_type = INSN_T2;
11452     }
11453   /* Handle VMUL.  */
11454   else if (opc1 == 0x02 && !(opc3 & 0x01))
11455     {
11456       if (bit (arm_insn_r->arm_insn, 10))
11457         {
11458           if (bit (arm_insn_r->arm_insn, 6))
11459             curr_insn_type = INSN_T0;
11460           else
11461             curr_insn_type = INSN_T1;
11462         }
11463       else
11464         {
11465           if (dp_op_sz)
11466             curr_insn_type = INSN_T1;
11467           else
11468             curr_insn_type = INSN_T2;
11469         }
11470     }
11471   /* Handle VADD, VSUB.  */
11472   else if (opc1 == 0x03)
11473     {
11474       if (!bit (arm_insn_r->arm_insn, 9))
11475         {
11476           if (bit (arm_insn_r->arm_insn, 6))
11477             curr_insn_type = INSN_T0;
11478           else
11479             curr_insn_type = INSN_T1;
11480         }
11481       else
11482         {
11483           if (dp_op_sz)
11484             curr_insn_type = INSN_T1;
11485           else
11486             curr_insn_type = INSN_T2;
11487         }
11488     }
11489   /* Handle VDIV.  */
11490   else if (opc1 == 0x08)
11491     {
11492       if (dp_op_sz)
11493         curr_insn_type = INSN_T1;
11494       else
11495         curr_insn_type = INSN_T2;
11496     }
11497   /* Handle all other vfp data processing instructions.  */
11498   else if (opc1 == 0x0b)
11499     {
11500       /* Handle VMOV.  */
11501       if (!(opc3 & 0x01) || (opc2 == 0x00 && opc3 == 0x01))
11502         {
11503           if (bit (arm_insn_r->arm_insn, 4))
11504             {
11505               if (bit (arm_insn_r->arm_insn, 6))
11506                 curr_insn_type = INSN_T0;
11507               else
11508                 curr_insn_type = INSN_T1;
11509             }
11510           else
11511             {
11512               if (dp_op_sz)
11513                 curr_insn_type = INSN_T1;
11514               else
11515                 curr_insn_type = INSN_T2;
11516             }
11517         }
11518       /* Handle VNEG and VABS.  */
11519       else if ((opc2 == 0x01 && opc3 == 0x01)
11520               || (opc2 == 0x00 && opc3 == 0x03))
11521         {
11522           if (!bit (arm_insn_r->arm_insn, 11))
11523             {
11524               if (bit (arm_insn_r->arm_insn, 6))
11525                 curr_insn_type = INSN_T0;
11526               else
11527                 curr_insn_type = INSN_T1;
11528             }
11529           else
11530             {
11531               if (dp_op_sz)
11532                 curr_insn_type = INSN_T1;
11533               else
11534                 curr_insn_type = INSN_T2;
11535             }
11536         }
11537       /* Handle VSQRT.  */
11538       else if (opc2 == 0x01 && opc3 == 0x03)
11539         {
11540           if (dp_op_sz)
11541             curr_insn_type = INSN_T1;
11542           else
11543             curr_insn_type = INSN_T2;
11544         }
11545       /* Handle VCVT.  */
11546       else if (opc2 == 0x07 && opc3 == 0x03)
11547         {
11548           if (!dp_op_sz)
11549             curr_insn_type = INSN_T1;
11550           else
11551             curr_insn_type = INSN_T2;
11552         }
11553       else if (opc3 & 0x01)
11554         {
11555           /* Handle VCVT.  */
11556           if ((opc2 == 0x08) || (opc2 & 0x0e) == 0x0c)
11557             {
11558               if (!bit (arm_insn_r->arm_insn, 18))
11559                 curr_insn_type = INSN_T2;
11560               else
11561                 {
11562                   if (dp_op_sz)
11563                     curr_insn_type = INSN_T1;
11564                   else
11565                     curr_insn_type = INSN_T2;
11566                 }
11567             }
11568           /* Handle VCVT.  */
11569           else if ((opc2 & 0x0e) == 0x0a || (opc2 & 0x0e) == 0x0e)
11570             {
11571               if (dp_op_sz)
11572                 curr_insn_type = INSN_T1;
11573               else
11574                 curr_insn_type = INSN_T2;
11575             }
11576           /* Handle VCVTB, VCVTT.  */
11577           else if ((opc2 & 0x0e) == 0x02)
11578             curr_insn_type = INSN_T2;
11579           /* Handle VCMP, VCMPE.  */
11580           else if ((opc2 & 0x0e) == 0x04)
11581             curr_insn_type = INSN_T3;
11582         }
11583     }
11584
11585   switch (curr_insn_type)
11586     {
11587       case INSN_T0:
11588         reg_vd = reg_vd | (bit_d << 4);
11589         record_buf[0] = reg_vd + ARM_D0_REGNUM;
11590         record_buf[1] = reg_vd + ARM_D0_REGNUM + 1;
11591         arm_insn_r->reg_rec_count = 2;
11592         break;
11593
11594       case INSN_T1:
11595         reg_vd = reg_vd | (bit_d << 4);
11596         record_buf[0] = reg_vd + ARM_D0_REGNUM;
11597         arm_insn_r->reg_rec_count = 1;
11598         break;
11599
11600       case INSN_T2:
11601         reg_vd = (reg_vd << 1) | bit_d;
11602         record_buf[0] = reg_vd + ARM_D0_REGNUM;
11603         arm_insn_r->reg_rec_count = 1;
11604         break;
11605
11606       case INSN_T3:
11607         record_buf[0] = ARM_FPSCR_REGNUM;
11608         arm_insn_r->reg_rec_count = 1;
11609         break;
11610
11611       default:
11612         gdb_assert_not_reached ("no decoding pattern found");
11613         break;
11614     }
11615
11616   REG_ALLOC (arm_insn_r->arm_regs, arm_insn_r->reg_rec_count, record_buf);
11617   return 0;
11618 }
11619
11620 /* Handling opcode 110 insns.  */
11621
11622 static int
11623 arm_record_asimd_vfp_coproc (insn_decode_record *arm_insn_r)
11624 {
11625   uint32_t op1, op1_ebit, coproc;
11626
11627   coproc = bits (arm_insn_r->arm_insn, 8, 11);
11628   op1 = bits (arm_insn_r->arm_insn, 20, 25);
11629   op1_ebit = bit (arm_insn_r->arm_insn, 20);
11630
11631   if ((coproc & 0x0e) == 0x0a)
11632     {
11633       /* Handle extension register ld/st instructions.  */
11634       if (!(op1 & 0x20))
11635         return arm_record_exreg_ld_st_insn (arm_insn_r);
11636
11637       /* 64-bit transfers between arm core and extension registers.  */
11638       if ((op1 & 0x3e) == 0x04)
11639         return arm_record_exreg_ld_st_insn (arm_insn_r);
11640     }
11641   else
11642     {
11643       /* Handle coprocessor ld/st instructions.  */
11644       if (!(op1 & 0x3a))
11645         {
11646           /* Store.  */
11647           if (!op1_ebit)
11648             return arm_record_unsupported_insn (arm_insn_r);
11649           else
11650             /* Load.  */
11651             return arm_record_unsupported_insn (arm_insn_r);
11652         }
11653
11654       /* Move to coprocessor from two arm core registers.  */
11655       if (op1 == 0x4)
11656         return arm_record_unsupported_insn (arm_insn_r);
11657
11658       /* Move to two arm core registers from coprocessor.  */
11659       if (op1 == 0x5)
11660         {
11661           uint32_t reg_t[2];
11662
11663           reg_t[0] = bits (arm_insn_r->arm_insn, 12, 15);
11664           reg_t[1] = bits (arm_insn_r->arm_insn, 16, 19);
11665           arm_insn_r->reg_rec_count = 2;
11666
11667           REG_ALLOC (arm_insn_r->arm_regs, arm_insn_r->reg_rec_count, reg_t);
11668           return 0;
11669        }
11670     }
11671   return arm_record_unsupported_insn (arm_insn_r);
11672 }
11673
11674 /* Handling opcode 111 insns.  */
11675
11676 static int
11677 arm_record_coproc_data_proc (insn_decode_record *arm_insn_r)
11678 {
11679   uint32_t op, op1_ebit, coproc, bits_24_25;
11680   struct gdbarch_tdep *tdep = gdbarch_tdep (arm_insn_r->gdbarch);
11681   struct regcache *reg_cache = arm_insn_r->regcache;
11682
11683   arm_insn_r->opcode = bits (arm_insn_r->arm_insn, 24, 27);
11684   coproc = bits (arm_insn_r->arm_insn, 8, 11);
11685   op1_ebit = bit (arm_insn_r->arm_insn, 20);
11686   op = bit (arm_insn_r->arm_insn, 4);
11687   bits_24_25 = bits (arm_insn_r->arm_insn, 24, 25);
11688
11689   /* Handle arm SWI/SVC system call instructions.  */
11690   if (bits_24_25 == 0x3)
11691     {
11692       if (tdep->arm_syscall_record != NULL)
11693         {
11694           ULONGEST svc_operand, svc_number;
11695
11696           svc_operand = (0x00ffffff & arm_insn_r->arm_insn);
11697
11698           if (svc_operand)  /* OABI.  */
11699             svc_number = svc_operand - 0x900000;
11700           else /* EABI.  */
11701             regcache_raw_read_unsigned (reg_cache, 7, &svc_number);
11702
11703           return tdep->arm_syscall_record (reg_cache, svc_number);
11704         }
11705       else
11706         {
11707           printf_unfiltered (_("no syscall record support\n"));
11708           return -1;
11709         }
11710     }
11711   else if (bits_24_25 == 0x02)
11712     {
11713       if (op)
11714         {
11715           if ((coproc & 0x0e) == 0x0a)
11716             {
11717               /* 8, 16, and 32-bit transfer */
11718               return arm_record_vdata_transfer_insn (arm_insn_r);
11719             }
11720           else
11721             {
11722               if (op1_ebit)
11723                 {
11724                   /* MRC, MRC2 */
11725                   uint32_t record_buf[1];
11726
11727                   record_buf[0] = bits (arm_insn_r->arm_insn, 12, 15);
11728                   if (record_buf[0] == 15)
11729                     record_buf[0] = ARM_PS_REGNUM;
11730
11731                   arm_insn_r->reg_rec_count = 1;
11732                   REG_ALLOC (arm_insn_r->arm_regs, arm_insn_r->reg_rec_count,
11733                              record_buf);
11734                   return 0;
11735                 }
11736               else
11737                 {
11738                   /* MCR, MCR2 */
11739                   return -1;
11740                 }
11741             }
11742         }
11743       else
11744         {
11745           if ((coproc & 0x0e) == 0x0a)
11746             {
11747               /* VFP data-processing instructions.  */
11748               return arm_record_vfp_data_proc_insn (arm_insn_r);
11749             }
11750           else
11751             {
11752               /* CDP, CDP2 */
11753               return -1;
11754             }
11755         }
11756     }
11757   else
11758     {
11759       unsigned int op1 = bits (arm_insn_r->arm_insn, 20, 25);
11760
11761       if (op1 == 5)
11762         {
11763           if ((coproc & 0x0e) != 0x0a)
11764             {
11765               /* MRRC, MRRC2 */
11766               return -1;
11767             }
11768         }
11769       else if (op1 == 4 || op1 == 5)
11770         {
11771           if ((coproc & 0x0e) == 0x0a)
11772             {
11773               /* 64-bit transfers between ARM core and extension */
11774               return -1;
11775             }
11776           else if (op1 == 4)
11777             {
11778               /* MCRR, MCRR2 */
11779               return -1;
11780             }
11781         }
11782       else if (op1 == 0 || op1 == 1)
11783         {
11784           /* UNDEFINED */
11785           return -1;
11786         }
11787       else
11788         {
11789           if ((coproc & 0x0e) == 0x0a)
11790             {
11791               /* Extension register load/store */
11792             }
11793           else
11794             {
11795               /* STC, STC2, LDC, LDC2 */
11796             }
11797           return -1;
11798         }
11799     }
11800
11801   return -1;
11802 }
11803
11804 /* Handling opcode 000 insns.  */
11805
11806 static int
11807 thumb_record_shift_add_sub (insn_decode_record *thumb_insn_r)
11808 {
11809   uint32_t record_buf[8];
11810   uint32_t reg_src1 = 0;
11811
11812   reg_src1 = bits (thumb_insn_r->arm_insn, 0, 2);
11813
11814   record_buf[0] = ARM_PS_REGNUM;
11815   record_buf[1] = reg_src1;
11816   thumb_insn_r->reg_rec_count = 2;
11817
11818   REG_ALLOC (thumb_insn_r->arm_regs, thumb_insn_r->reg_rec_count, record_buf);
11819
11820   return 0;
11821 }
11822
11823
11824 /* Handling opcode 001 insns.  */
11825
11826 static int
11827 thumb_record_add_sub_cmp_mov (insn_decode_record *thumb_insn_r)
11828 {
11829   uint32_t record_buf[8];
11830   uint32_t reg_src1 = 0;
11831
11832   reg_src1 = bits (thumb_insn_r->arm_insn, 8, 10);
11833
11834   record_buf[0] = ARM_PS_REGNUM;
11835   record_buf[1] = reg_src1;
11836   thumb_insn_r->reg_rec_count = 2;
11837
11838   REG_ALLOC (thumb_insn_r->arm_regs, thumb_insn_r->reg_rec_count, record_buf);
11839
11840   return 0;
11841 }
11842
11843 /* Handling opcode 010 insns.  */
11844
11845 static int
11846 thumb_record_ld_st_reg_offset (insn_decode_record *thumb_insn_r)
11847 {
11848   struct regcache *reg_cache =  thumb_insn_r->regcache;
11849   uint32_t record_buf[8], record_buf_mem[8];
11850
11851   uint32_t reg_src1 = 0, reg_src2 = 0;
11852   uint32_t opcode1 = 0, opcode2 = 0, opcode3 = 0;
11853
11854   ULONGEST u_regval[2] = {0};
11855
11856   opcode1 = bits (thumb_insn_r->arm_insn, 10, 12);
11857
11858   if (bit (thumb_insn_r->arm_insn, 12))
11859     {
11860       /* Handle load/store register offset.  */
11861       uint32_t opB = bits (thumb_insn_r->arm_insn, 9, 11);
11862
11863       if (in_inclusive_range (opB, 4U, 7U))
11864         {
11865           /* LDR(2), LDRB(2) , LDRH(2), LDRSB, LDRSH.  */
11866           reg_src1 = bits (thumb_insn_r->arm_insn,0, 2);
11867           record_buf[0] = reg_src1;
11868           thumb_insn_r->reg_rec_count = 1;
11869         }
11870       else if (in_inclusive_range (opB, 0U, 2U))
11871         {
11872           /* STR(2), STRB(2), STRH(2) .  */
11873           reg_src1 = bits (thumb_insn_r->arm_insn, 3, 5);
11874           reg_src2 = bits (thumb_insn_r->arm_insn, 6, 8);
11875           regcache_raw_read_unsigned (reg_cache, reg_src1, &u_regval[0]);
11876           regcache_raw_read_unsigned (reg_cache, reg_src2, &u_regval[1]);
11877           if (0 == opB)
11878             record_buf_mem[0] = 4;    /* STR (2).  */
11879           else if (2 == opB)
11880             record_buf_mem[0] = 1;    /*  STRB (2).  */
11881           else if (1 == opB)
11882             record_buf_mem[0] = 2;    /* STRH (2).  */
11883           record_buf_mem[1] = u_regval[0] + u_regval[1];
11884           thumb_insn_r->mem_rec_count = 1;
11885         }
11886     }
11887   else if (bit (thumb_insn_r->arm_insn, 11))
11888     {
11889       /* Handle load from literal pool.  */
11890       /* LDR(3).  */
11891       reg_src1 = bits (thumb_insn_r->arm_insn, 8, 10);
11892       record_buf[0] = reg_src1;
11893       thumb_insn_r->reg_rec_count = 1;
11894     }
11895   else if (opcode1)
11896     {
11897       /* Special data instructions and branch and exchange */
11898       opcode2 = bits (thumb_insn_r->arm_insn, 8, 9);
11899       opcode3 = bits (thumb_insn_r->arm_insn, 0, 2);
11900       if ((3 == opcode2) && (!opcode3))
11901         {
11902           /* Branch with exchange.  */
11903           record_buf[0] = ARM_PS_REGNUM;
11904           thumb_insn_r->reg_rec_count = 1;
11905         }
11906       else
11907         {
11908           /* Format 8; special data processing insns.  */
11909           record_buf[0] = ARM_PS_REGNUM;
11910           record_buf[1] = (bit (thumb_insn_r->arm_insn, 7) << 3
11911                            | bits (thumb_insn_r->arm_insn, 0, 2));
11912           thumb_insn_r->reg_rec_count = 2;
11913         }
11914     }
11915   else
11916     {
11917       /* Format 5; data processing insns.  */
11918       reg_src1 = bits (thumb_insn_r->arm_insn, 0, 2);
11919       if (bit (thumb_insn_r->arm_insn, 7))
11920         {
11921           reg_src1 = reg_src1 + 8;
11922         }
11923       record_buf[0] = ARM_PS_REGNUM;
11924       record_buf[1] = reg_src1;
11925       thumb_insn_r->reg_rec_count = 2;
11926     }
11927
11928   REG_ALLOC (thumb_insn_r->arm_regs, thumb_insn_r->reg_rec_count, record_buf);
11929   MEM_ALLOC (thumb_insn_r->arm_mems, thumb_insn_r->mem_rec_count,
11930              record_buf_mem);
11931
11932   return 0;
11933 }
11934
11935 /* Handling opcode 001 insns.  */
11936
11937 static int
11938 thumb_record_ld_st_imm_offset (insn_decode_record *thumb_insn_r)
11939 {
11940   struct regcache *reg_cache = thumb_insn_r->regcache;
11941   uint32_t record_buf[8], record_buf_mem[8];
11942
11943   uint32_t reg_src1 = 0;
11944   uint32_t opcode = 0, immed_5 = 0;
11945
11946   ULONGEST u_regval = 0;
11947
11948   opcode = bits (thumb_insn_r->arm_insn, 11, 12);
11949
11950   if (opcode)
11951     {
11952       /* LDR(1).  */
11953       reg_src1 = bits (thumb_insn_r->arm_insn, 0, 2);
11954       record_buf[0] = reg_src1;
11955       thumb_insn_r->reg_rec_count = 1;
11956     }
11957   else
11958     {
11959       /* STR(1).  */
11960       reg_src1 = bits (thumb_insn_r->arm_insn, 3, 5);
11961       immed_5 = bits (thumb_insn_r->arm_insn, 6, 10);
11962       regcache_raw_read_unsigned (reg_cache, reg_src1, &u_regval);
11963       record_buf_mem[0] = 4;
11964       record_buf_mem[1] = u_regval + (immed_5 * 4);
11965       thumb_insn_r->mem_rec_count = 1;
11966     }
11967
11968   REG_ALLOC (thumb_insn_r->arm_regs, thumb_insn_r->reg_rec_count, record_buf);
11969   MEM_ALLOC (thumb_insn_r->arm_mems, thumb_insn_r->mem_rec_count, 
11970              record_buf_mem);
11971
11972   return 0;
11973 }
11974
11975 /* Handling opcode 100 insns.  */
11976
11977 static int
11978 thumb_record_ld_st_stack (insn_decode_record *thumb_insn_r)
11979 {
11980   struct regcache *reg_cache = thumb_insn_r->regcache;
11981   uint32_t record_buf[8], record_buf_mem[8];
11982
11983   uint32_t reg_src1 = 0;
11984   uint32_t opcode = 0, immed_8 = 0, immed_5 = 0;
11985
11986   ULONGEST u_regval = 0;
11987
11988   opcode = bits (thumb_insn_r->arm_insn, 11, 12);
11989
11990   if (3 == opcode)
11991     {
11992       /* LDR(4).  */
11993       reg_src1 = bits (thumb_insn_r->arm_insn, 8, 10);
11994       record_buf[0] = reg_src1;
11995       thumb_insn_r->reg_rec_count = 1;
11996     }
11997   else if (1 == opcode)
11998     {
11999       /* LDRH(1).  */
12000       reg_src1 = bits (thumb_insn_r->arm_insn, 0, 2);
12001       record_buf[0] = reg_src1;
12002       thumb_insn_r->reg_rec_count = 1;
12003     }
12004   else if (2 == opcode)
12005     {
12006       /* STR(3).  */
12007       immed_8 = bits (thumb_insn_r->arm_insn, 0, 7);
12008       regcache_raw_read_unsigned (reg_cache, ARM_SP_REGNUM, &u_regval);
12009       record_buf_mem[0] = 4;
12010       record_buf_mem[1] = u_regval + (immed_8 * 4);
12011       thumb_insn_r->mem_rec_count = 1;
12012     }
12013   else if (0 == opcode)
12014     {
12015       /* STRH(1).  */
12016       immed_5 = bits (thumb_insn_r->arm_insn, 6, 10);
12017       reg_src1 = bits (thumb_insn_r->arm_insn, 3, 5);
12018       regcache_raw_read_unsigned (reg_cache, reg_src1, &u_regval);
12019       record_buf_mem[0] = 2;
12020       record_buf_mem[1] = u_regval + (immed_5 * 2);
12021       thumb_insn_r->mem_rec_count = 1;
12022     }
12023
12024   REG_ALLOC (thumb_insn_r->arm_regs, thumb_insn_r->reg_rec_count, record_buf);
12025   MEM_ALLOC (thumb_insn_r->arm_mems, thumb_insn_r->mem_rec_count,
12026              record_buf_mem);
12027
12028   return 0;
12029 }
12030
12031 /* Handling opcode 101 insns.  */
12032
12033 static int
12034 thumb_record_misc (insn_decode_record *thumb_insn_r)
12035 {
12036   struct regcache *reg_cache = thumb_insn_r->regcache;
12037
12038   uint32_t opcode = 0;
12039   uint32_t register_bits = 0, register_count = 0;
12040   uint32_t index = 0, start_address = 0;
12041   uint32_t record_buf[24], record_buf_mem[48];
12042   uint32_t reg_src1;
12043
12044   ULONGEST u_regval = 0;
12045
12046   opcode = bits (thumb_insn_r->arm_insn, 11, 12);
12047
12048   if (opcode == 0 || opcode == 1)
12049     {
12050       /* ADR and ADD (SP plus immediate) */
12051
12052       reg_src1 = bits (thumb_insn_r->arm_insn, 8, 10);
12053       record_buf[0] = reg_src1;
12054       thumb_insn_r->reg_rec_count = 1;
12055     }
12056   else
12057     {
12058       /* Miscellaneous 16-bit instructions */
12059       uint32_t opcode2 = bits (thumb_insn_r->arm_insn, 8, 11);
12060
12061       switch (opcode2)
12062         {
12063         case 6:
12064           /* SETEND and CPS */
12065           break;
12066         case 0:
12067           /* ADD/SUB (SP plus immediate)  */
12068           reg_src1 = bits (thumb_insn_r->arm_insn, 8, 10);
12069           record_buf[0] = ARM_SP_REGNUM;
12070           thumb_insn_r->reg_rec_count = 1;
12071           break;
12072         case 1: /* fall through  */
12073         case 3: /* fall through  */
12074         case 9: /* fall through  */
12075         case 11:
12076           /* CBNZ, CBZ */
12077           break;
12078         case 2:
12079           /* SXTH, SXTB, UXTH, UXTB */
12080           record_buf[0] = bits (thumb_insn_r->arm_insn, 0, 2);
12081           thumb_insn_r->reg_rec_count = 1;
12082           break;
12083         case 4: /* fall through  */
12084         case 5:
12085           /* PUSH.  */
12086           register_bits = bits (thumb_insn_r->arm_insn, 0, 7);
12087           regcache_raw_read_unsigned (reg_cache, ARM_SP_REGNUM, &u_regval);
12088           while (register_bits)
12089             {
12090               if (register_bits & 0x00000001)
12091                 register_count++;
12092               register_bits = register_bits >> 1;
12093             }
12094           start_address = u_regval -  \
12095             (4 * (bit (thumb_insn_r->arm_insn, 8) + register_count));
12096           thumb_insn_r->mem_rec_count = register_count;
12097           while (register_count)
12098             {
12099               record_buf_mem[(register_count * 2) - 1] = start_address;
12100               record_buf_mem[(register_count * 2) - 2] = 4;
12101               start_address = start_address + 4;
12102               register_count--;
12103             }
12104           record_buf[0] = ARM_SP_REGNUM;
12105           thumb_insn_r->reg_rec_count = 1;
12106           break;
12107         case 10:
12108           /* REV, REV16, REVSH */
12109           record_buf[0] = bits (thumb_insn_r->arm_insn, 0, 2);
12110           thumb_insn_r->reg_rec_count = 1;
12111           break;
12112         case 12: /* fall through  */
12113         case 13:
12114           /* POP.  */
12115           register_bits = bits (thumb_insn_r->arm_insn, 0, 7);
12116           while (register_bits)
12117             {
12118               if (register_bits & 0x00000001)
12119                 record_buf[index++] = register_count;
12120               register_bits = register_bits >> 1;
12121               register_count++;
12122             }
12123           record_buf[index++] = ARM_PS_REGNUM;
12124           record_buf[index++] = ARM_SP_REGNUM;
12125           thumb_insn_r->reg_rec_count = index;
12126           break;
12127         case 0xe:
12128           /* BKPT insn.  */
12129           /* Handle enhanced software breakpoint insn, BKPT.  */
12130           /* CPSR is changed to be executed in ARM state,  disabling normal
12131              interrupts, entering abort mode.  */
12132           /* According to high vector configuration PC is set.  */
12133           /* User hits breakpoint and type reverse, in that case, we need to go back with 
12134              previous CPSR and Program Counter.  */
12135           record_buf[0] = ARM_PS_REGNUM;
12136           record_buf[1] = ARM_LR_REGNUM;
12137           thumb_insn_r->reg_rec_count = 2;
12138           /* We need to save SPSR value, which is not yet done.  */
12139           printf_unfiltered (_("Process record does not support instruction "
12140                                "0x%0x at address %s.\n"),
12141                              thumb_insn_r->arm_insn,
12142                              paddress (thumb_insn_r->gdbarch,
12143                                        thumb_insn_r->this_addr));
12144           return -1;
12145
12146         case 0xf:
12147           /* If-Then, and hints */
12148           break;
12149         default:
12150           return -1;
12151         };
12152     }
12153
12154   REG_ALLOC (thumb_insn_r->arm_regs, thumb_insn_r->reg_rec_count, record_buf);
12155   MEM_ALLOC (thumb_insn_r->arm_mems, thumb_insn_r->mem_rec_count,
12156              record_buf_mem);
12157
12158   return 0;
12159 }
12160
12161 /* Handling opcode 110 insns.  */
12162
12163 static int
12164 thumb_record_ldm_stm_swi (insn_decode_record *thumb_insn_r)                
12165 {
12166   struct gdbarch_tdep *tdep = gdbarch_tdep (thumb_insn_r->gdbarch);
12167   struct regcache *reg_cache = thumb_insn_r->regcache;
12168
12169   uint32_t ret = 0; /* function return value: -1:record failure ;  0:success  */
12170   uint32_t reg_src1 = 0;
12171   uint32_t opcode1 = 0, opcode2 = 0, register_bits = 0, register_count = 0;
12172   uint32_t index = 0, start_address = 0;
12173   uint32_t record_buf[24], record_buf_mem[48];
12174
12175   ULONGEST u_regval = 0;
12176
12177   opcode1 = bits (thumb_insn_r->arm_insn, 8, 12);
12178   opcode2 = bits (thumb_insn_r->arm_insn, 11, 12);
12179
12180   if (1 == opcode2)
12181     {
12182
12183       /* LDMIA.  */
12184       register_bits = bits (thumb_insn_r->arm_insn, 0, 7);
12185       /* Get Rn.  */
12186       reg_src1 = bits (thumb_insn_r->arm_insn, 8, 10);
12187       while (register_bits)
12188         {
12189           if (register_bits & 0x00000001)
12190             record_buf[index++] = register_count;
12191           register_bits = register_bits >> 1;
12192           register_count++;
12193         }
12194       record_buf[index++] = reg_src1;
12195       thumb_insn_r->reg_rec_count = index;
12196     }
12197   else if (0 == opcode2)
12198     {
12199       /* It handles both STMIA.  */
12200       register_bits = bits (thumb_insn_r->arm_insn, 0, 7);
12201       /* Get Rn.  */
12202       reg_src1 = bits (thumb_insn_r->arm_insn, 8, 10);
12203       regcache_raw_read_unsigned (reg_cache, reg_src1, &u_regval);
12204       while (register_bits)
12205         {
12206           if (register_bits & 0x00000001)
12207             register_count++;
12208           register_bits = register_bits >> 1;
12209         }
12210       start_address = u_regval;
12211       thumb_insn_r->mem_rec_count = register_count;
12212       while (register_count)
12213         {
12214           record_buf_mem[(register_count * 2) - 1] = start_address;
12215           record_buf_mem[(register_count * 2) - 2] = 4;
12216           start_address = start_address + 4;
12217           register_count--;
12218         }
12219     }
12220   else if (0x1F == opcode1)
12221     {
12222         /* Handle arm syscall insn.  */
12223         if (tdep->arm_syscall_record != NULL)
12224           {
12225             regcache_raw_read_unsigned (reg_cache, 7, &u_regval);
12226             ret = tdep->arm_syscall_record (reg_cache, u_regval);
12227           }
12228         else
12229           {
12230             printf_unfiltered (_("no syscall record support\n"));
12231             return -1;
12232           }
12233     }
12234
12235   /* B (1), conditional branch is automatically taken care in process_record,
12236     as PC is saved there.  */
12237
12238   REG_ALLOC (thumb_insn_r->arm_regs, thumb_insn_r->reg_rec_count, record_buf);
12239   MEM_ALLOC (thumb_insn_r->arm_mems, thumb_insn_r->mem_rec_count,
12240              record_buf_mem);
12241
12242   return ret;
12243 }
12244
12245 /* Handling opcode 111 insns.  */
12246
12247 static int
12248 thumb_record_branch (insn_decode_record *thumb_insn_r)
12249 {
12250   uint32_t record_buf[8];
12251   uint32_t bits_h = 0;
12252
12253   bits_h = bits (thumb_insn_r->arm_insn, 11, 12);
12254
12255   if (2 == bits_h || 3 == bits_h)
12256     {
12257       /* BL */
12258       record_buf[0] = ARM_LR_REGNUM;
12259       thumb_insn_r->reg_rec_count = 1;
12260     }
12261   else if (1 == bits_h)
12262     {
12263       /* BLX(1). */
12264       record_buf[0] = ARM_PS_REGNUM;
12265       record_buf[1] = ARM_LR_REGNUM;
12266       thumb_insn_r->reg_rec_count = 2;
12267     }
12268
12269   /* B(2) is automatically taken care in process_record, as PC is 
12270      saved there.  */
12271
12272   REG_ALLOC (thumb_insn_r->arm_regs, thumb_insn_r->reg_rec_count, record_buf);
12273
12274   return 0;     
12275 }
12276
12277 /* Handler for thumb2 load/store multiple instructions.  */
12278
12279 static int
12280 thumb2_record_ld_st_multiple (insn_decode_record *thumb2_insn_r)
12281 {
12282   struct regcache *reg_cache = thumb2_insn_r->regcache;
12283
12284   uint32_t reg_rn, op;
12285   uint32_t register_bits = 0, register_count = 0;
12286   uint32_t index = 0, start_address = 0;
12287   uint32_t record_buf[24], record_buf_mem[48];
12288
12289   ULONGEST u_regval = 0;
12290
12291   reg_rn = bits (thumb2_insn_r->arm_insn, 16, 19);
12292   op = bits (thumb2_insn_r->arm_insn, 23, 24);
12293
12294   if (0 == op || 3 == op)
12295     {
12296       if (bit (thumb2_insn_r->arm_insn, INSN_S_L_BIT_NUM))
12297         {
12298           /* Handle RFE instruction.  */
12299           record_buf[0] = ARM_PS_REGNUM;
12300           thumb2_insn_r->reg_rec_count = 1;
12301         }
12302       else
12303         {
12304           /* Handle SRS instruction after reading banked SP.  */
12305           return arm_record_unsupported_insn (thumb2_insn_r);
12306         }
12307     }
12308   else if (1 == op || 2 == op)
12309     {
12310       if (bit (thumb2_insn_r->arm_insn, INSN_S_L_BIT_NUM))
12311         {
12312           /* Handle LDM/LDMIA/LDMFD and LDMDB/LDMEA instructions.  */
12313           register_bits = bits (thumb2_insn_r->arm_insn, 0, 15);
12314           while (register_bits)
12315             {
12316               if (register_bits & 0x00000001)
12317                 record_buf[index++] = register_count;
12318
12319               register_count++;
12320               register_bits = register_bits >> 1;
12321             }
12322           record_buf[index++] = reg_rn;
12323           record_buf[index++] = ARM_PS_REGNUM;
12324           thumb2_insn_r->reg_rec_count = index;
12325         }
12326       else
12327         {
12328           /* Handle STM/STMIA/STMEA and STMDB/STMFD.  */
12329           register_bits = bits (thumb2_insn_r->arm_insn, 0, 15);
12330           regcache_raw_read_unsigned (reg_cache, reg_rn, &u_regval);
12331           while (register_bits)
12332             {
12333               if (register_bits & 0x00000001)
12334                 register_count++;
12335
12336               register_bits = register_bits >> 1;
12337             }
12338
12339           if (1 == op)
12340             {
12341               /* Start address calculation for LDMDB/LDMEA.  */
12342               start_address = u_regval;
12343             }
12344           else if (2 == op)
12345             {
12346               /* Start address calculation for LDMDB/LDMEA.  */
12347               start_address = u_regval - register_count * 4;
12348             }
12349
12350           thumb2_insn_r->mem_rec_count = register_count;
12351           while (register_count)
12352             {
12353               record_buf_mem[register_count * 2 - 1] = start_address;
12354               record_buf_mem[register_count * 2 - 2] = 4;
12355               start_address = start_address + 4;
12356               register_count--;
12357             }
12358           record_buf[0] = reg_rn;
12359           record_buf[1] = ARM_PS_REGNUM;
12360           thumb2_insn_r->reg_rec_count = 2;
12361         }
12362     }
12363
12364   MEM_ALLOC (thumb2_insn_r->arm_mems, thumb2_insn_r->mem_rec_count,
12365             record_buf_mem);
12366   REG_ALLOC (thumb2_insn_r->arm_regs, thumb2_insn_r->reg_rec_count,
12367             record_buf);
12368   return ARM_RECORD_SUCCESS;
12369 }
12370
12371 /* Handler for thumb2 load/store (dual/exclusive) and table branch
12372    instructions.  */
12373
12374 static int
12375 thumb2_record_ld_st_dual_ex_tbb (insn_decode_record *thumb2_insn_r)
12376 {
12377   struct regcache *reg_cache = thumb2_insn_r->regcache;
12378
12379   uint32_t reg_rd, reg_rn, offset_imm;
12380   uint32_t reg_dest1, reg_dest2;
12381   uint32_t address, offset_addr;
12382   uint32_t record_buf[8], record_buf_mem[8];
12383   uint32_t op1, op2, op3;
12384
12385   ULONGEST u_regval[2];
12386
12387   op1 = bits (thumb2_insn_r->arm_insn, 23, 24);
12388   op2 = bits (thumb2_insn_r->arm_insn, 20, 21);
12389   op3 = bits (thumb2_insn_r->arm_insn, 4, 7);
12390
12391   if (bit (thumb2_insn_r->arm_insn, INSN_S_L_BIT_NUM))
12392     {
12393       if(!(1 == op1 && 1 == op2 && (0 == op3 || 1 == op3)))
12394         {
12395           reg_dest1 = bits (thumb2_insn_r->arm_insn, 12, 15);
12396           record_buf[0] = reg_dest1;
12397           record_buf[1] = ARM_PS_REGNUM;
12398           thumb2_insn_r->reg_rec_count = 2;
12399         }
12400
12401       if (3 == op2 || (op1 & 2) || (1 == op1 && 1 == op2 && 7 == op3))
12402         {
12403           reg_dest2 = bits (thumb2_insn_r->arm_insn, 8, 11);
12404           record_buf[2] = reg_dest2;
12405           thumb2_insn_r->reg_rec_count = 3;
12406         }
12407     }
12408   else
12409     {
12410       reg_rn = bits (thumb2_insn_r->arm_insn, 16, 19);
12411       regcache_raw_read_unsigned (reg_cache, reg_rn, &u_regval[0]);
12412
12413       if (0 == op1 && 0 == op2)
12414         {
12415           /* Handle STREX.  */
12416           offset_imm = bits (thumb2_insn_r->arm_insn, 0, 7);
12417           address = u_regval[0] + (offset_imm * 4);
12418           record_buf_mem[0] = 4;
12419           record_buf_mem[1] = address;
12420           thumb2_insn_r->mem_rec_count = 1;
12421           reg_rd = bits (thumb2_insn_r->arm_insn, 0, 3);
12422           record_buf[0] = reg_rd;
12423           thumb2_insn_r->reg_rec_count = 1;
12424         }
12425       else if (1 == op1 && 0 == op2)
12426         {
12427           reg_rd = bits (thumb2_insn_r->arm_insn, 0, 3);
12428           record_buf[0] = reg_rd;
12429           thumb2_insn_r->reg_rec_count = 1;
12430           address = u_regval[0];
12431           record_buf_mem[1] = address;
12432
12433           if (4 == op3)
12434             {
12435               /* Handle STREXB.  */
12436               record_buf_mem[0] = 1;
12437               thumb2_insn_r->mem_rec_count = 1;
12438             }
12439           else if (5 == op3)
12440             {
12441               /* Handle STREXH.  */
12442               record_buf_mem[0] = 2 ;
12443               thumb2_insn_r->mem_rec_count = 1;
12444             }
12445           else if (7 == op3)
12446             {
12447               /* Handle STREXD.  */
12448               address = u_regval[0];
12449               record_buf_mem[0] = 4;
12450               record_buf_mem[2] = 4;
12451               record_buf_mem[3] = address + 4;
12452               thumb2_insn_r->mem_rec_count = 2;
12453             }
12454         }
12455       else
12456         {
12457           offset_imm = bits (thumb2_insn_r->arm_insn, 0, 7);
12458
12459           if (bit (thumb2_insn_r->arm_insn, 24))
12460             {
12461               if (bit (thumb2_insn_r->arm_insn, 23))
12462                 offset_addr = u_regval[0] + (offset_imm * 4);
12463               else
12464                 offset_addr = u_regval[0] - (offset_imm * 4);
12465
12466               address = offset_addr;
12467             }
12468           else
12469             address = u_regval[0];
12470
12471           record_buf_mem[0] = 4;
12472           record_buf_mem[1] = address;
12473           record_buf_mem[2] = 4;
12474           record_buf_mem[3] = address + 4;
12475           thumb2_insn_r->mem_rec_count = 2;
12476           record_buf[0] = reg_rn;
12477           thumb2_insn_r->reg_rec_count = 1;
12478         }
12479     }
12480
12481   REG_ALLOC (thumb2_insn_r->arm_regs, thumb2_insn_r->reg_rec_count,
12482             record_buf);
12483   MEM_ALLOC (thumb2_insn_r->arm_mems, thumb2_insn_r->mem_rec_count,
12484             record_buf_mem);
12485   return ARM_RECORD_SUCCESS;
12486 }
12487
12488 /* Handler for thumb2 data processing (shift register and modified immediate)
12489    instructions.  */
12490
12491 static int
12492 thumb2_record_data_proc_sreg_mimm (insn_decode_record *thumb2_insn_r)
12493 {
12494   uint32_t reg_rd, op;
12495   uint32_t record_buf[8];
12496
12497   op = bits (thumb2_insn_r->arm_insn, 21, 24);
12498   reg_rd = bits (thumb2_insn_r->arm_insn, 8, 11);
12499
12500   if ((0 == op || 4 == op || 8 == op || 13 == op) && 15 == reg_rd)
12501     {
12502       record_buf[0] = ARM_PS_REGNUM;
12503       thumb2_insn_r->reg_rec_count = 1;
12504     }
12505   else
12506     {
12507       record_buf[0] = reg_rd;
12508       record_buf[1] = ARM_PS_REGNUM;
12509       thumb2_insn_r->reg_rec_count = 2;
12510     }
12511
12512   REG_ALLOC (thumb2_insn_r->arm_regs, thumb2_insn_r->reg_rec_count,
12513             record_buf);
12514   return ARM_RECORD_SUCCESS;
12515 }
12516
12517 /* Generic handler for thumb2 instructions which effect destination and PS
12518    registers.  */
12519
12520 static int
12521 thumb2_record_ps_dest_generic (insn_decode_record *thumb2_insn_r)
12522 {
12523   uint32_t reg_rd;
12524   uint32_t record_buf[8];
12525
12526   reg_rd = bits (thumb2_insn_r->arm_insn, 8, 11);
12527
12528   record_buf[0] = reg_rd;
12529   record_buf[1] = ARM_PS_REGNUM;
12530   thumb2_insn_r->reg_rec_count = 2;
12531
12532   REG_ALLOC (thumb2_insn_r->arm_regs, thumb2_insn_r->reg_rec_count,
12533             record_buf);
12534   return ARM_RECORD_SUCCESS;
12535 }
12536
12537 /* Handler for thumb2 branch and miscellaneous control instructions.  */
12538
12539 static int
12540 thumb2_record_branch_misc_cntrl (insn_decode_record *thumb2_insn_r)
12541 {
12542   uint32_t op, op1, op2;
12543   uint32_t record_buf[8];
12544
12545   op = bits (thumb2_insn_r->arm_insn, 20, 26);
12546   op1 = bits (thumb2_insn_r->arm_insn, 12, 14);
12547   op2 = bits (thumb2_insn_r->arm_insn, 8, 11);
12548
12549   /* Handle MSR insn.  */
12550   if (!(op1 & 0x2) && 0x38 == op)
12551     {
12552       if (!(op2 & 0x3))
12553         {
12554           /* CPSR is going to be changed.  */
12555           record_buf[0] = ARM_PS_REGNUM;
12556           thumb2_insn_r->reg_rec_count = 1;
12557         }
12558       else
12559         {
12560           arm_record_unsupported_insn(thumb2_insn_r);
12561           return -1;
12562         }
12563     }
12564   else if (4 == (op1 & 0x5) || 5 == (op1 & 0x5))
12565     {
12566       /* BLX.  */
12567       record_buf[0] = ARM_PS_REGNUM;
12568       record_buf[1] = ARM_LR_REGNUM;
12569       thumb2_insn_r->reg_rec_count = 2;
12570     }
12571
12572   REG_ALLOC (thumb2_insn_r->arm_regs, thumb2_insn_r->reg_rec_count,
12573             record_buf);
12574   return ARM_RECORD_SUCCESS;
12575 }
12576
12577 /* Handler for thumb2 store single data item instructions.  */
12578
12579 static int
12580 thumb2_record_str_single_data (insn_decode_record *thumb2_insn_r)
12581 {
12582   struct regcache *reg_cache = thumb2_insn_r->regcache;
12583
12584   uint32_t reg_rn, reg_rm, offset_imm, shift_imm;
12585   uint32_t address, offset_addr;
12586   uint32_t record_buf[8], record_buf_mem[8];
12587   uint32_t op1, op2;
12588
12589   ULONGEST u_regval[2];
12590
12591   op1 = bits (thumb2_insn_r->arm_insn, 21, 23);
12592   op2 = bits (thumb2_insn_r->arm_insn, 6, 11);
12593   reg_rn = bits (thumb2_insn_r->arm_insn, 16, 19);
12594   regcache_raw_read_unsigned (reg_cache, reg_rn, &u_regval[0]);
12595
12596   if (bit (thumb2_insn_r->arm_insn, 23))
12597     {
12598       /* T2 encoding.  */
12599       offset_imm = bits (thumb2_insn_r->arm_insn, 0, 11);
12600       offset_addr = u_regval[0] + offset_imm;
12601       address = offset_addr;
12602     }
12603   else
12604     {
12605       /* T3 encoding.  */
12606       if ((0 == op1 || 1 == op1 || 2 == op1) && !(op2 & 0x20))
12607         {
12608           /* Handle STRB (register).  */
12609           reg_rm = bits (thumb2_insn_r->arm_insn, 0, 3);
12610           regcache_raw_read_unsigned (reg_cache, reg_rm, &u_regval[1]);
12611           shift_imm = bits (thumb2_insn_r->arm_insn, 4, 5);
12612           offset_addr = u_regval[1] << shift_imm;
12613           address = u_regval[0] + offset_addr;
12614         }
12615       else
12616         {
12617           offset_imm = bits (thumb2_insn_r->arm_insn, 0, 7);
12618           if (bit (thumb2_insn_r->arm_insn, 10))
12619             {
12620               if (bit (thumb2_insn_r->arm_insn, 9))
12621                 offset_addr = u_regval[0] + offset_imm;
12622               else
12623                 offset_addr = u_regval[0] - offset_imm;
12624
12625               address = offset_addr;
12626             }
12627           else
12628             address = u_regval[0];
12629         }
12630     }
12631
12632   switch (op1)
12633     {
12634       /* Store byte instructions.  */
12635       case 4:
12636       case 0:
12637         record_buf_mem[0] = 1;
12638         break;
12639       /* Store half word instructions.  */
12640       case 1:
12641       case 5:
12642         record_buf_mem[0] = 2;
12643         break;
12644       /* Store word instructions.  */
12645       case 2:
12646       case 6:
12647         record_buf_mem[0] = 4;
12648         break;
12649
12650       default:
12651         gdb_assert_not_reached ("no decoding pattern found");
12652         break;
12653     }
12654
12655   record_buf_mem[1] = address;
12656   thumb2_insn_r->mem_rec_count = 1;
12657   record_buf[0] = reg_rn;
12658   thumb2_insn_r->reg_rec_count = 1;
12659
12660   REG_ALLOC (thumb2_insn_r->arm_regs, thumb2_insn_r->reg_rec_count,
12661             record_buf);
12662   MEM_ALLOC (thumb2_insn_r->arm_mems, thumb2_insn_r->mem_rec_count,
12663             record_buf_mem);
12664   return ARM_RECORD_SUCCESS;
12665 }
12666
12667 /* Handler for thumb2 load memory hints instructions.  */
12668
12669 static int
12670 thumb2_record_ld_mem_hints (insn_decode_record *thumb2_insn_r)
12671 {
12672   uint32_t record_buf[8];
12673   uint32_t reg_rt, reg_rn;
12674
12675   reg_rt = bits (thumb2_insn_r->arm_insn, 12, 15);
12676   reg_rn = bits (thumb2_insn_r->arm_insn, 16, 19);
12677
12678   if (ARM_PC_REGNUM != reg_rt)
12679     {
12680       record_buf[0] = reg_rt;
12681       record_buf[1] = reg_rn;
12682       record_buf[2] = ARM_PS_REGNUM;
12683       thumb2_insn_r->reg_rec_count = 3;
12684
12685       REG_ALLOC (thumb2_insn_r->arm_regs, thumb2_insn_r->reg_rec_count,
12686                 record_buf);
12687       return ARM_RECORD_SUCCESS;
12688     }
12689
12690   return ARM_RECORD_FAILURE;
12691 }
12692
12693 /* Handler for thumb2 load word instructions.  */
12694
12695 static int
12696 thumb2_record_ld_word (insn_decode_record *thumb2_insn_r)
12697 {
12698   uint32_t record_buf[8];
12699
12700   record_buf[0] = bits (thumb2_insn_r->arm_insn, 12, 15);
12701   record_buf[1] = ARM_PS_REGNUM;
12702   thumb2_insn_r->reg_rec_count = 2;
12703
12704   REG_ALLOC (thumb2_insn_r->arm_regs, thumb2_insn_r->reg_rec_count,
12705             record_buf);
12706   return ARM_RECORD_SUCCESS;
12707 }
12708
12709 /* Handler for thumb2 long multiply, long multiply accumulate, and
12710    divide instructions.  */
12711
12712 static int
12713 thumb2_record_lmul_lmla_div (insn_decode_record *thumb2_insn_r)
12714 {
12715   uint32_t opcode1 = 0, opcode2 = 0;
12716   uint32_t record_buf[8];
12717
12718   opcode1 = bits (thumb2_insn_r->arm_insn, 20, 22);
12719   opcode2 = bits (thumb2_insn_r->arm_insn, 4, 7);
12720
12721   if (0 == opcode1 || 2 == opcode1 || (opcode1 >= 4 && opcode1 <= 6))
12722     {
12723       /* Handle SMULL, UMULL, SMULAL.  */
12724       /* Handle SMLAL(S), SMULL(S), UMLAL(S), UMULL(S).  */
12725       record_buf[0] = bits (thumb2_insn_r->arm_insn, 16, 19);
12726       record_buf[1] = bits (thumb2_insn_r->arm_insn, 12, 15);
12727       record_buf[2] = ARM_PS_REGNUM;
12728       thumb2_insn_r->reg_rec_count = 3;
12729     }
12730   else if (1 == opcode1 || 3 == opcode2)
12731     {
12732       /* Handle SDIV and UDIV.  */
12733       record_buf[0] = bits (thumb2_insn_r->arm_insn, 16, 19);
12734       record_buf[1] = bits (thumb2_insn_r->arm_insn, 12, 15);
12735       record_buf[2] = ARM_PS_REGNUM;
12736       thumb2_insn_r->reg_rec_count = 3;
12737     }
12738   else
12739     return ARM_RECORD_FAILURE;
12740
12741   REG_ALLOC (thumb2_insn_r->arm_regs, thumb2_insn_r->reg_rec_count,
12742             record_buf);
12743   return ARM_RECORD_SUCCESS;
12744 }
12745
12746 /* Record handler for thumb32 coprocessor instructions.  */
12747
12748 static int
12749 thumb2_record_coproc_insn (insn_decode_record *thumb2_insn_r)
12750 {
12751   if (bit (thumb2_insn_r->arm_insn, 25))
12752     return arm_record_coproc_data_proc (thumb2_insn_r);
12753   else
12754     return arm_record_asimd_vfp_coproc (thumb2_insn_r);
12755 }
12756
12757 /* Record handler for advance SIMD structure load/store instructions.  */
12758
12759 static int
12760 thumb2_record_asimd_struct_ld_st (insn_decode_record *thumb2_insn_r)
12761 {
12762   struct regcache *reg_cache = thumb2_insn_r->regcache;
12763   uint32_t l_bit, a_bit, b_bits;
12764   uint32_t record_buf[128], record_buf_mem[128];
12765   uint32_t reg_rn, reg_vd, address, f_elem;
12766   uint32_t index_r = 0, index_e = 0, bf_regs = 0, index_m = 0, loop_t = 0;
12767   uint8_t f_ebytes;
12768
12769   l_bit = bit (thumb2_insn_r->arm_insn, 21);
12770   a_bit = bit (thumb2_insn_r->arm_insn, 23);
12771   b_bits = bits (thumb2_insn_r->arm_insn, 8, 11);
12772   reg_rn = bits (thumb2_insn_r->arm_insn, 16, 19);
12773   reg_vd = bits (thumb2_insn_r->arm_insn, 12, 15);
12774   reg_vd = (bit (thumb2_insn_r->arm_insn, 22) << 4) | reg_vd;
12775   f_ebytes = (1 << bits (thumb2_insn_r->arm_insn, 6, 7));
12776   f_elem = 8 / f_ebytes;
12777
12778   if (!l_bit)
12779     {
12780       ULONGEST u_regval = 0;
12781       regcache_raw_read_unsigned (reg_cache, reg_rn, &u_regval);
12782       address = u_regval;
12783
12784       if (!a_bit)
12785         {
12786           /* Handle VST1.  */
12787           if (b_bits == 0x02 || b_bits == 0x0a || (b_bits & 0x0e) == 0x06)
12788             {
12789               if (b_bits == 0x07)
12790                 bf_regs = 1;
12791               else if (b_bits == 0x0a)
12792                 bf_regs = 2;
12793               else if (b_bits == 0x06)
12794                 bf_regs = 3;
12795               else if (b_bits == 0x02)
12796                 bf_regs = 4;
12797               else
12798                 bf_regs = 0;
12799
12800               for (index_r = 0; index_r < bf_regs; index_r++)
12801                 {
12802                   for (index_e = 0; index_e < f_elem; index_e++)
12803                     {
12804                       record_buf_mem[index_m++] = f_ebytes;
12805                       record_buf_mem[index_m++] = address;
12806                       address = address + f_ebytes;
12807                       thumb2_insn_r->mem_rec_count += 1;
12808                     }
12809                 }
12810             }
12811           /* Handle VST2.  */
12812           else if (b_bits == 0x03 || (b_bits & 0x0e) == 0x08)
12813             {
12814               if (b_bits == 0x09 || b_bits == 0x08)
12815                 bf_regs = 1;
12816               else if (b_bits == 0x03)
12817                 bf_regs = 2;
12818               else
12819                 bf_regs = 0;
12820
12821               for (index_r = 0; index_r < bf_regs; index_r++)
12822                 for (index_e = 0; index_e < f_elem; index_e++)
12823                   {
12824                     for (loop_t = 0; loop_t < 2; loop_t++)
12825                       {
12826                         record_buf_mem[index_m++] = f_ebytes;
12827                         record_buf_mem[index_m++] = address + (loop_t * f_ebytes);
12828                         thumb2_insn_r->mem_rec_count += 1;
12829                       }
12830                     address = address + (2 * f_ebytes);
12831                   }
12832             }
12833           /* Handle VST3.  */
12834           else if ((b_bits & 0x0e) == 0x04)
12835             {
12836               for (index_e = 0; index_e < f_elem; index_e++)
12837                 {
12838                   for (loop_t = 0; loop_t < 3; loop_t++)
12839                     {
12840                       record_buf_mem[index_m++] = f_ebytes;
12841                       record_buf_mem[index_m++] = address + (loop_t * f_ebytes);
12842                       thumb2_insn_r->mem_rec_count += 1;
12843                     }
12844                   address = address + (3 * f_ebytes);
12845                 }
12846             }
12847           /* Handle VST4.  */
12848           else if (!(b_bits & 0x0e))
12849             {
12850               for (index_e = 0; index_e < f_elem; index_e++)
12851                 {
12852                   for (loop_t = 0; loop_t < 4; loop_t++)
12853                     {
12854                       record_buf_mem[index_m++] = f_ebytes;
12855                       record_buf_mem[index_m++] = address + (loop_t * f_ebytes);
12856                       thumb2_insn_r->mem_rec_count += 1;
12857                     }
12858                   address = address + (4 * f_ebytes);
12859                 }
12860             }
12861         }
12862       else
12863         {
12864           uint8_t bft_size = bits (thumb2_insn_r->arm_insn, 10, 11);
12865
12866           if (bft_size == 0x00)
12867             f_ebytes = 1;
12868           else if (bft_size == 0x01)
12869             f_ebytes = 2;
12870           else if (bft_size == 0x02)
12871             f_ebytes = 4;
12872           else
12873             f_ebytes = 0;
12874
12875           /* Handle VST1.  */
12876           if (!(b_bits & 0x0b) || b_bits == 0x08)
12877             thumb2_insn_r->mem_rec_count = 1;
12878           /* Handle VST2.  */
12879           else if ((b_bits & 0x0b) == 0x01 || b_bits == 0x09)
12880             thumb2_insn_r->mem_rec_count = 2;
12881           /* Handle VST3.  */
12882           else if ((b_bits & 0x0b) == 0x02 || b_bits == 0x0a)
12883             thumb2_insn_r->mem_rec_count = 3;
12884           /* Handle VST4.  */
12885           else if ((b_bits & 0x0b) == 0x03 || b_bits == 0x0b)
12886             thumb2_insn_r->mem_rec_count = 4;
12887
12888           for (index_m = 0; index_m < thumb2_insn_r->mem_rec_count; index_m++)
12889             {
12890               record_buf_mem[index_m] = f_ebytes;
12891               record_buf_mem[index_m] = address + (index_m * f_ebytes);
12892             }
12893         }
12894     }
12895   else
12896     {
12897       if (!a_bit)
12898         {
12899           /* Handle VLD1.  */
12900           if (b_bits == 0x02 || b_bits == 0x0a || (b_bits & 0x0e) == 0x06)
12901             thumb2_insn_r->reg_rec_count = 1;
12902           /* Handle VLD2.  */
12903           else if (b_bits == 0x03 || (b_bits & 0x0e) == 0x08)
12904             thumb2_insn_r->reg_rec_count = 2;
12905           /* Handle VLD3.  */
12906           else if ((b_bits & 0x0e) == 0x04)
12907             thumb2_insn_r->reg_rec_count = 3;
12908           /* Handle VLD4.  */
12909           else if (!(b_bits & 0x0e))
12910             thumb2_insn_r->reg_rec_count = 4;
12911         }
12912       else
12913         {
12914           /* Handle VLD1.  */
12915           if (!(b_bits & 0x0b) || b_bits == 0x08 || b_bits == 0x0c)
12916             thumb2_insn_r->reg_rec_count = 1;
12917           /* Handle VLD2.  */
12918           else if ((b_bits & 0x0b) == 0x01 || b_bits == 0x09 || b_bits == 0x0d)
12919             thumb2_insn_r->reg_rec_count = 2;
12920           /* Handle VLD3.  */
12921           else if ((b_bits & 0x0b) == 0x02 || b_bits == 0x0a || b_bits == 0x0e)
12922             thumb2_insn_r->reg_rec_count = 3;
12923           /* Handle VLD4.  */
12924           else if ((b_bits & 0x0b) == 0x03 || b_bits == 0x0b || b_bits == 0x0f)
12925             thumb2_insn_r->reg_rec_count = 4;
12926
12927           for (index_r = 0; index_r < thumb2_insn_r->reg_rec_count; index_r++)
12928             record_buf[index_r] = reg_vd + ARM_D0_REGNUM + index_r;
12929         }
12930     }
12931
12932   if (bits (thumb2_insn_r->arm_insn, 0, 3) != 15)
12933     {
12934       record_buf[index_r] = reg_rn;
12935       thumb2_insn_r->reg_rec_count += 1;
12936     }
12937
12938   REG_ALLOC (thumb2_insn_r->arm_regs, thumb2_insn_r->reg_rec_count,
12939             record_buf);
12940   MEM_ALLOC (thumb2_insn_r->arm_mems, thumb2_insn_r->mem_rec_count,
12941             record_buf_mem);
12942   return 0;
12943 }
12944
12945 /* Decodes thumb2 instruction type and invokes its record handler.  */
12946
12947 static unsigned int
12948 thumb2_record_decode_insn_handler (insn_decode_record *thumb2_insn_r)
12949 {
12950   uint32_t op, op1, op2;
12951
12952   op = bit (thumb2_insn_r->arm_insn, 15);
12953   op1 = bits (thumb2_insn_r->arm_insn, 27, 28);
12954   op2 = bits (thumb2_insn_r->arm_insn, 20, 26);
12955
12956   if (op1 == 0x01)
12957     {
12958       if (!(op2 & 0x64 ))
12959         {
12960           /* Load/store multiple instruction.  */
12961           return thumb2_record_ld_st_multiple (thumb2_insn_r);
12962         }
12963       else if ((op2 & 0x64) == 0x4)
12964         {
12965           /* Load/store (dual/exclusive) and table branch instruction.  */
12966           return thumb2_record_ld_st_dual_ex_tbb (thumb2_insn_r);
12967         }
12968       else if ((op2 & 0x60) == 0x20)
12969         {
12970           /* Data-processing (shifted register).  */
12971           return thumb2_record_data_proc_sreg_mimm (thumb2_insn_r);
12972         }
12973       else if (op2 & 0x40)
12974         {
12975           /* Co-processor instructions.  */
12976           return thumb2_record_coproc_insn (thumb2_insn_r);
12977         }
12978     }
12979   else if (op1 == 0x02)
12980     {
12981       if (op)
12982         {
12983           /* Branches and miscellaneous control instructions.  */
12984           return thumb2_record_branch_misc_cntrl (thumb2_insn_r);
12985         }
12986       else if (op2 & 0x20)
12987         {
12988           /* Data-processing (plain binary immediate) instruction.  */
12989           return thumb2_record_ps_dest_generic (thumb2_insn_r);
12990         }
12991       else
12992         {
12993           /* Data-processing (modified immediate).  */
12994           return thumb2_record_data_proc_sreg_mimm (thumb2_insn_r);
12995         }
12996     }
12997   else if (op1 == 0x03)
12998     {
12999       if (!(op2 & 0x71 ))
13000         {
13001           /* Store single data item.  */
13002           return thumb2_record_str_single_data (thumb2_insn_r);
13003         }
13004       else if (!((op2 & 0x71) ^ 0x10))
13005         {
13006           /* Advanced SIMD or structure load/store instructions.  */
13007           return thumb2_record_asimd_struct_ld_st (thumb2_insn_r);
13008         }
13009       else if (!((op2 & 0x67) ^ 0x01))
13010         {
13011           /* Load byte, memory hints instruction.  */
13012           return thumb2_record_ld_mem_hints (thumb2_insn_r);
13013         }
13014       else if (!((op2 & 0x67) ^ 0x03))
13015         {
13016           /* Load halfword, memory hints instruction.  */
13017           return thumb2_record_ld_mem_hints (thumb2_insn_r);
13018         }
13019       else if (!((op2 & 0x67) ^ 0x05))
13020         {
13021           /* Load word instruction.  */
13022           return thumb2_record_ld_word (thumb2_insn_r);
13023         }
13024       else if (!((op2 & 0x70) ^ 0x20))
13025         {
13026           /* Data-processing (register) instruction.  */
13027           return thumb2_record_ps_dest_generic (thumb2_insn_r);
13028         }
13029       else if (!((op2 & 0x78) ^ 0x30))
13030         {
13031           /* Multiply, multiply accumulate, abs diff instruction.  */
13032           return thumb2_record_ps_dest_generic (thumb2_insn_r);
13033         }
13034       else if (!((op2 & 0x78) ^ 0x38))
13035         {
13036           /* Long multiply, long multiply accumulate, and divide.  */
13037           return thumb2_record_lmul_lmla_div (thumb2_insn_r);
13038         }
13039       else if (op2 & 0x40)
13040         {
13041           /* Co-processor instructions.  */
13042           return thumb2_record_coproc_insn (thumb2_insn_r);
13043         }
13044    }
13045
13046   return -1;
13047 }
13048
13049 namespace {
13050 /* Abstract memory reader.  */
13051
13052 class abstract_memory_reader
13053 {
13054 public:
13055   /* Read LEN bytes of target memory at address MEMADDR, placing the
13056      results in GDB's memory at BUF.  Return true on success.  */
13057
13058   virtual bool read (CORE_ADDR memaddr, gdb_byte *buf, const size_t len) = 0;
13059 };
13060
13061 /* Instruction reader from real target.  */
13062
13063 class instruction_reader : public abstract_memory_reader
13064 {
13065  public:
13066   bool read (CORE_ADDR memaddr, gdb_byte *buf, const size_t len) override
13067   {
13068     if (target_read_memory (memaddr, buf, len))
13069       return false;
13070     else
13071       return true;
13072   }
13073 };
13074
13075 } // namespace
13076
13077 /* Extracts arm/thumb/thumb2 insn depending on the size, and returns 0 on success 
13078 and positive val on fauilure.  */
13079
13080 static int
13081 extract_arm_insn (abstract_memory_reader& reader,
13082                   insn_decode_record *insn_record, uint32_t insn_size)
13083 {
13084   gdb_byte buf[insn_size];
13085
13086   memset (&buf[0], 0, insn_size);
13087   
13088   if (!reader.read (insn_record->this_addr, buf, insn_size))
13089     return 1;
13090   insn_record->arm_insn = (uint32_t) extract_unsigned_integer (&buf[0],
13091                            insn_size, 
13092                            gdbarch_byte_order_for_code (insn_record->gdbarch));
13093   return 0;
13094 }
13095
13096 typedef int (*sti_arm_hdl_fp_t) (insn_decode_record*);
13097
13098 /* Decode arm/thumb insn depending on condition cods and opcodes; and
13099    dispatch it.  */
13100
13101 static int
13102 decode_insn (abstract_memory_reader &reader, insn_decode_record *arm_record,
13103              record_type_t record_type, uint32_t insn_size)
13104 {
13105
13106   /* (Starting from numerical 0); bits 25, 26, 27 decodes type of arm
13107      instruction.  */
13108   static const sti_arm_hdl_fp_t arm_handle_insn[8] =
13109   {
13110     arm_record_data_proc_misc_ld_str,   /* 000.  */
13111     arm_record_data_proc_imm,           /* 001.  */
13112     arm_record_ld_st_imm_offset,        /* 010.  */
13113     arm_record_ld_st_reg_offset,        /* 011.  */
13114     arm_record_ld_st_multiple,          /* 100.  */
13115     arm_record_b_bl,                    /* 101.  */
13116     arm_record_asimd_vfp_coproc,        /* 110.  */
13117     arm_record_coproc_data_proc         /* 111.  */
13118   };
13119
13120   /* (Starting from numerical 0); bits 13,14,15 decodes type of thumb
13121      instruction.  */
13122   static const sti_arm_hdl_fp_t thumb_handle_insn[8] =
13123   { \
13124     thumb_record_shift_add_sub,        /* 000.  */
13125     thumb_record_add_sub_cmp_mov,      /* 001.  */
13126     thumb_record_ld_st_reg_offset,     /* 010.  */
13127     thumb_record_ld_st_imm_offset,     /* 011.  */
13128     thumb_record_ld_st_stack,          /* 100.  */
13129     thumb_record_misc,                 /* 101.  */
13130     thumb_record_ldm_stm_swi,          /* 110.  */
13131     thumb_record_branch                /* 111.  */
13132   };
13133
13134   uint32_t ret = 0;    /* return value: negative:failure   0:success.  */
13135   uint32_t insn_id = 0;
13136
13137   if (extract_arm_insn (reader, arm_record, insn_size))
13138     {
13139       if (record_debug)
13140         {
13141           printf_unfiltered (_("Process record: error reading memory at "
13142                                "addr %s len = %d.\n"),
13143                              paddress (arm_record->gdbarch,
13144                                        arm_record->this_addr), insn_size);
13145         }
13146       return -1;
13147     }
13148   else if (ARM_RECORD == record_type)
13149     {
13150       arm_record->cond = bits (arm_record->arm_insn, 28, 31);
13151       insn_id = bits (arm_record->arm_insn, 25, 27);
13152
13153       if (arm_record->cond == 0xf)
13154         ret = arm_record_extension_space (arm_record);
13155       else
13156         {
13157           /* If this insn has fallen into extension space
13158              then we need not decode it anymore.  */
13159           ret = arm_handle_insn[insn_id] (arm_record);
13160         }
13161       if (ret != ARM_RECORD_SUCCESS)
13162         {
13163           arm_record_unsupported_insn (arm_record);
13164           ret = -1;
13165         }
13166     }
13167   else if (THUMB_RECORD == record_type)
13168     {
13169       /* As thumb does not have condition codes, we set negative.  */
13170       arm_record->cond = -1;
13171       insn_id = bits (arm_record->arm_insn, 13, 15);
13172       ret = thumb_handle_insn[insn_id] (arm_record);
13173       if (ret != ARM_RECORD_SUCCESS)
13174         {
13175           arm_record_unsupported_insn (arm_record);
13176           ret = -1;
13177         }
13178     }
13179   else if (THUMB2_RECORD == record_type)
13180     {
13181       /* As thumb does not have condition codes, we set negative.  */
13182       arm_record->cond = -1;
13183
13184       /* Swap first half of 32bit thumb instruction with second half.  */
13185       arm_record->arm_insn
13186         = (arm_record->arm_insn >> 16) | (arm_record->arm_insn << 16);
13187
13188       ret = thumb2_record_decode_insn_handler (arm_record);
13189
13190       if (ret != ARM_RECORD_SUCCESS)
13191         {
13192           arm_record_unsupported_insn (arm_record);
13193           ret = -1;
13194         }
13195     }
13196   else
13197     {
13198       /* Throw assertion.  */
13199       gdb_assert_not_reached ("not a valid instruction, could not decode");
13200     }
13201
13202   return ret;
13203 }
13204
13205 #if GDB_SELF_TEST
13206 namespace selftests {
13207
13208 /* Provide both 16-bit and 32-bit thumb instructions.  */
13209
13210 class instruction_reader_thumb : public abstract_memory_reader
13211 {
13212 public:
13213   template<size_t SIZE>
13214   instruction_reader_thumb (enum bfd_endian endian,
13215                             const uint16_t (&insns)[SIZE])
13216     : m_endian (endian), m_insns (insns), m_insns_size (SIZE)
13217   {}
13218
13219   bool read (CORE_ADDR memaddr, gdb_byte *buf, const size_t len) override
13220   {
13221     SELF_CHECK (len == 4 || len == 2);
13222     SELF_CHECK (memaddr % 2 == 0);
13223     SELF_CHECK ((memaddr / 2) < m_insns_size);
13224
13225     store_unsigned_integer (buf, 2, m_endian, m_insns[memaddr / 2]);
13226     if (len == 4)
13227       {
13228         store_unsigned_integer (&buf[2], 2, m_endian,
13229                                 m_insns[memaddr / 2 + 1]);
13230       }
13231     return true;
13232   }
13233
13234 private:
13235   enum bfd_endian m_endian;
13236   const uint16_t *m_insns;
13237   size_t m_insns_size;
13238 };
13239
13240 static void
13241 arm_record_test (void)
13242 {
13243   struct gdbarch_info info;
13244   gdbarch_info_init (&info);
13245   info.bfd_arch_info = bfd_scan_arch ("arm");
13246
13247   struct gdbarch *gdbarch = gdbarch_find_by_info (info);
13248
13249   SELF_CHECK (gdbarch != NULL);
13250
13251   /* 16-bit Thumb instructions.  */
13252   {
13253     insn_decode_record arm_record;
13254
13255     memset (&arm_record, 0, sizeof (insn_decode_record));
13256     arm_record.gdbarch = gdbarch;
13257
13258     static const uint16_t insns[] = {
13259       /* db b2  uxtb    r3, r3 */
13260       0xb2db,
13261       /* cd 58  ldr     r5, [r1, r3] */
13262       0x58cd,
13263     };
13264
13265     enum bfd_endian endian = gdbarch_byte_order_for_code (arm_record.gdbarch);
13266     instruction_reader_thumb reader (endian, insns);
13267     int ret = decode_insn (reader, &arm_record, THUMB_RECORD,
13268                            THUMB_INSN_SIZE_BYTES);
13269
13270     SELF_CHECK (ret == 0);
13271     SELF_CHECK (arm_record.mem_rec_count == 0);
13272     SELF_CHECK (arm_record.reg_rec_count == 1);
13273     SELF_CHECK (arm_record.arm_regs[0] == 3);
13274
13275     arm_record.this_addr += 2;
13276     ret = decode_insn (reader, &arm_record, THUMB_RECORD,
13277                        THUMB_INSN_SIZE_BYTES);
13278
13279     SELF_CHECK (ret == 0);
13280     SELF_CHECK (arm_record.mem_rec_count == 0);
13281     SELF_CHECK (arm_record.reg_rec_count == 1);
13282     SELF_CHECK (arm_record.arm_regs[0] == 5);
13283   }
13284
13285   /* 32-bit Thumb-2 instructions.  */
13286   {
13287     insn_decode_record arm_record;
13288
13289     memset (&arm_record, 0, sizeof (insn_decode_record));
13290     arm_record.gdbarch = gdbarch;
13291
13292     static const uint16_t insns[] = {
13293       /* 1d ee 70 7f     mrc    15, 0, r7, cr13, cr0, {3} */
13294       0xee1d, 0x7f70,
13295     };
13296
13297     enum bfd_endian endian = gdbarch_byte_order_for_code (arm_record.gdbarch);
13298     instruction_reader_thumb reader (endian, insns);
13299     int ret = decode_insn (reader, &arm_record, THUMB2_RECORD,
13300                            THUMB2_INSN_SIZE_BYTES);
13301
13302     SELF_CHECK (ret == 0);
13303     SELF_CHECK (arm_record.mem_rec_count == 0);
13304     SELF_CHECK (arm_record.reg_rec_count == 1);
13305     SELF_CHECK (arm_record.arm_regs[0] == 7);
13306   }
13307 }
13308 } // namespace selftests
13309 #endif /* GDB_SELF_TEST */
13310
13311 /* Cleans up local record registers and memory allocations.  */
13312
13313 static void 
13314 deallocate_reg_mem (insn_decode_record *record)
13315 {
13316   xfree (record->arm_regs);
13317   xfree (record->arm_mems);    
13318 }
13319
13320
13321 /* Parse the current instruction and record the values of the registers and
13322    memory that will be changed in current instruction to record_arch_list".
13323    Return -1 if something is wrong.  */
13324
13325 int
13326 arm_process_record (struct gdbarch *gdbarch, struct regcache *regcache,
13327                     CORE_ADDR insn_addr)
13328 {
13329
13330   uint32_t no_of_rec = 0;
13331   uint32_t ret = 0;  /* return value: -1:record failure ;  0:success  */
13332   ULONGEST t_bit = 0, insn_id = 0;
13333
13334   ULONGEST u_regval = 0;
13335
13336   insn_decode_record arm_record;
13337
13338   memset (&arm_record, 0, sizeof (insn_decode_record));
13339   arm_record.regcache = regcache;
13340   arm_record.this_addr = insn_addr;
13341   arm_record.gdbarch = gdbarch;
13342
13343
13344   if (record_debug > 1)
13345     {
13346       fprintf_unfiltered (gdb_stdlog, "Process record: arm_process_record "
13347                           "addr = %s\n",
13348       paddress (gdbarch, arm_record.this_addr));
13349     }
13350
13351   instruction_reader reader;
13352   if (extract_arm_insn (reader, &arm_record, 2))
13353     {
13354       if (record_debug)
13355         {
13356           printf_unfiltered (_("Process record: error reading memory at "
13357                                "addr %s len = %d.\n"),
13358                              paddress (arm_record.gdbarch,
13359                                        arm_record.this_addr), 2);
13360         }
13361       return -1;
13362     }
13363
13364   /* Check the insn, whether it is thumb or arm one.  */
13365
13366   t_bit = arm_psr_thumb_bit (arm_record.gdbarch);
13367   regcache_raw_read_unsigned (arm_record.regcache, ARM_PS_REGNUM, &u_regval);
13368
13369
13370   if (!(u_regval & t_bit))
13371     {
13372       /* We are decoding arm insn.  */
13373       ret = decode_insn (reader, &arm_record, ARM_RECORD, ARM_INSN_SIZE_BYTES);
13374     }
13375   else
13376     {
13377       insn_id = bits (arm_record.arm_insn, 11, 15);
13378       /* is it thumb2 insn?  */
13379       if ((0x1D == insn_id) || (0x1E == insn_id) || (0x1F == insn_id))
13380         {
13381           ret = decode_insn (reader, &arm_record, THUMB2_RECORD,
13382                              THUMB2_INSN_SIZE_BYTES);
13383         }
13384       else
13385         {
13386           /* We are decoding thumb insn.  */
13387           ret = decode_insn (reader, &arm_record, THUMB_RECORD,
13388                              THUMB_INSN_SIZE_BYTES);
13389         }
13390     }
13391
13392   if (0 == ret)
13393     {
13394       /* Record registers.  */
13395       record_full_arch_list_add_reg (arm_record.regcache, ARM_PC_REGNUM);
13396       if (arm_record.arm_regs)
13397         {
13398           for (no_of_rec = 0; no_of_rec < arm_record.reg_rec_count; no_of_rec++)
13399             {
13400               if (record_full_arch_list_add_reg
13401                   (arm_record.regcache , arm_record.arm_regs[no_of_rec]))
13402                 ret = -1;
13403             }
13404         }
13405       /* Record memories.  */
13406       if (arm_record.arm_mems)
13407         {
13408           for (no_of_rec = 0; no_of_rec < arm_record.mem_rec_count; no_of_rec++)
13409             {
13410               if (record_full_arch_list_add_mem
13411                   ((CORE_ADDR)arm_record.arm_mems[no_of_rec].addr,
13412                    arm_record.arm_mems[no_of_rec].len))
13413                 ret = -1;
13414             }
13415         }
13416
13417       if (record_full_arch_list_add_end ())
13418         ret = -1;
13419     }
13420
13421
13422   deallocate_reg_mem (&arm_record);
13423
13424   return ret;
13425 }