[deliverable/binutils-gdb.git] / gdb / arm-tdep.c

/* Copyright (C) 1988, 1989 Free Software Foundation, Inc.

This file is part of GDB.

GDB is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 1, or (at your option)
any later version.

GDB is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with GDB; see the file COPYING.  If not, write to
the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */

#include "defs.h"
#include "param.h"
#include "frame.h"
#include "inferior.h"
#include "arm-opcode.h"

#include <stdio.h>
#include <sys/param.h>
#include <sys/dir.h>
#include <signal.h>
#include <sys/ioctl.h>
#include <sys/ptrace.h>
#include <machine/reg.h>

#define N_TXTADDR(hdr) 0x8000
#define N_DATADDR(hdr) (hdr.a_text + 0x8000)

#include "gdbcore.h"
#include <sys/user.h>		/* After a.out.h  */
#include <sys/file.h>
#include <sys/stat.h>

#include <errno.h>

\f
/* Work with core dump and executable files, for GDB. 
   This code would be in core.c if it weren't machine-dependent. */

/* Structure to describe the chain of shared libraries used
   by the execfile.
   e.g. prog shares Xt which shares X11 which shares c. */

struct shared_library {
    struct exec_header header;
    char name[SHLIBLEN];
    CORE_ADDR text_start;	/* CORE_ADDR of 1st byte of text, this file */
    long data_offset;		/* offset of data section in file */
    int chan;			/* file descriptor for the file */
    struct shared_library *shares; /* library this one shares */
};
static struct shared_library *shlib = 0;

/* Hook for `exec_file_command' command to call.  */

extern void (*exec_file_display_hook) ();
   
static CORE_ADDR unshared_text_start;

/* extended header from exec file (for shared library info) */

static struct exec_header exec_header;

void
exec_file_command (filename, from_tty)
     char *filename;
     int from_tty;
{
  int val;

  /* Eliminate all traces of old exec file.
     Mark text segment as empty.  */

  if (execfile)
    free (execfile);
  execfile = 0;
  data_start = 0;
  data_end -= exec_data_start;
  text_start = 0;
  unshared_text_start = 0;
  text_end = 0;
  exec_data_start = 0;
  exec_data_end = 0;
  if (execchan >= 0)
    close (execchan);
  execchan = -1;
  if (shlib) {
      close_shared_library(shlib);
      shlib = 0;
  }

  /* Now open and digest the file the user requested, if any.  */

  if (filename)
    {
      filename = tilde_expand (filename);
      make_cleanup (free, filename);

      execchan = openp (getenv ("PATH"), 1, filename, O_RDONLY, 0,
			&execfile);
      if (execchan < 0)
	perror_with_name (filename);

      {
	struct stat st_exec;

#ifdef HEADER_SEEK_FD
	HEADER_SEEK_FD (execchan);
#endif
	
	val = myread (execchan, &exec_header, sizeof exec_header);
	exec_aouthdr = exec_header.a_exec;

	if (val < 0)
	  perror_with_name (filename);

	text_start = 0x8000;

	/* Look for shared library if needed */
	if (exec_header.a_exec.a_magic & MF_USES_SL)
	    shlib = open_shared_library(exec_header.a_shlibname, text_start);

	text_offset = N_TXTOFF (exec_aouthdr);
	exec_data_offset = N_TXTOFF (exec_aouthdr) + exec_aouthdr.a_text;

	if (shlib) {
	    unshared_text_start = shared_text_end(shlib) & ~0x7fff;
	    stack_start = shlib->header.a_exec.a_sldatabase;
	    stack_end = STACK_END_ADDR;
	} else
	    unshared_text_start = 0x8000;
	text_end = unshared_text_start + exec_aouthdr.a_text;

	exec_data_start = unshared_text_start + exec_aouthdr.a_text;
        exec_data_end = exec_data_start + exec_aouthdr.a_data;

	data_start = exec_data_start;
	data_end += exec_data_start;

	fstat (execchan, &st_exec);
	exec_mtime = st_exec.st_mtime;
      }

      validate_files ();
    }
  else if (from_tty)
    printf ("No exec file now.\n");

  /* Tell display code (if any) about the changed file name.  */
  if (exec_file_display_hook)
    (*exec_file_display_hook) (filename);
}

/* Read from the program's memory (except for inferior processes).
   This function is misnamed, since it only reads, never writes; and
   since it will use the core file and/or executable file as necessary.

   It should be extended to write as well as read, FIXME, for patching files.

   Return 0 if address could be read, EIO if addresss out of bounds.  */

int
xfer_core_file (memaddr, myaddr, len)
     CORE_ADDR memaddr;
     char *myaddr;
     int len;
{
  register int i;
  register int val;
  int xferchan;
  char **xferfile;
  int fileptr;
  int returnval = 0;

  while (len > 0)
    {
      xferfile = 0;
      xferchan = 0;

      /* Determine which file the next bunch of addresses reside in,
	 and where in the file.  Set the file's read/write pointer
	 to point at the proper place for the desired address
	 and set xferfile and xferchan for the correct file.

	 If desired address is nonexistent, leave them zero.

	 i is set to the number of bytes that can be handled
	 along with the next address.

	 We put the most likely tests first for efficiency.  */

      /* Note that if there is no core file
	 data_start and data_end are equal.  */
      if (memaddr >= data_start && memaddr < data_end)
	{
	  i = min (len, data_end - memaddr);
	  fileptr = memaddr - data_start + data_offset;
	  xferfile = &corefile;
	  xferchan = corechan;
	}
      /* Note that if there is no core file
	 stack_start and stack_end define the shared library data.  */
      else if (memaddr >= stack_start && memaddr < stack_end)
	{
	    if (corechan < 0) {
		struct shared_library *lib;
		for (lib = shlib; lib; lib = lib->shares)
		    if (memaddr >= lib->header.a_exec.a_sldatabase &&
			memaddr < lib->header.a_exec.a_sldatabase +
			  lib->header.a_exec.a_data)
			break;
		if (lib) {
		    i = min (len, lib->header.a_exec.a_sldatabase +
			     lib->header.a_exec.a_data - memaddr);
		    fileptr = lib->data_offset + memaddr -
			lib->header.a_exec.a_sldatabase;
		    xferfile = execfile;
		    xferchan = lib->chan;
		}
	    } else {
		i = min (len, stack_end - memaddr);
		fileptr = memaddr - stack_start + stack_offset;
		xferfile = &corefile;
		xferchan = corechan;
	    }
	}
      else if (corechan < 0
	       && memaddr >= exec_data_start && memaddr < exec_data_end)
	{
	  i = min (len, exec_data_end - memaddr);
	  fileptr = memaddr - exec_data_start + exec_data_offset;
	  xferfile = &execfile;
	  xferchan = execchan;
	}
      else if (memaddr >= text_start && memaddr < text_end)
	{
	    struct shared_library *lib;
	    for (lib = shlib; lib; lib = lib->shares)
		if (memaddr >= lib->text_start &&
		    memaddr < lib->text_start + lib->header.a_exec.a_text)
		    break;
	    if (lib) {
		i = min (len, lib->header.a_exec.a_text +
			 lib->text_start - memaddr);
		fileptr = memaddr - lib->text_start + text_offset;
		xferfile = &execfile;
		xferchan = lib->chan;
	    } else {
		i = min (len, text_end - memaddr);
		fileptr = memaddr - unshared_text_start + text_offset;
		xferfile = &execfile;
		xferchan = execchan;
	    }
	}
      else if (memaddr < text_start)
	{
	  i = min (len, text_start - memaddr);
	}
      else if (memaddr >= text_end
	       && memaddr < (corechan >= 0? data_start : exec_data_start))
	{
	  i = min (len, data_start - memaddr);
	}
      else if (corechan >= 0
	       && memaddr >= data_end && memaddr < stack_start)
	{
	  i = min (len, stack_start - memaddr);
	}
      else if (corechan < 0 && memaddr >= exec_data_end)
	{
	  i = min (len, - memaddr);
	}
      else if (memaddr >= stack_end && stack_end != 0)
	{
	  i = min (len, - memaddr);
	}
      else
	{
	  /* Address did not classify into one of the known ranges.
	     This shouldn't happen; we catch the endpoints.  */
	  fatal ("Internal: Bad case logic in xfer_core_file.");
	}

      /* Now we know which file to use.
	 Set up its pointer and transfer the data.  */
      if (xferfile)
	{
	  if (*xferfile == 0)
	    if (xferfile == &execfile)
	      error ("No program file to examine.");
	    else
	      error ("No core dump file or running program to examine.");
	  val = lseek (xferchan, fileptr, 0);
	  if (val < 0)
	    perror_with_name (*xferfile);
	  val = myread (xferchan, myaddr, i);
	  if (val < 0)
	    perror_with_name (*xferfile);
	}
      /* If this address is for nonexistent memory,
	 read zeros if reading, or do nothing if writing.
	 Actually, we never right.  */
      else
	{
	  bzero (myaddr, i);
	  returnval = EIO;
	}

      memaddr += i;
      myaddr += i;
      len -= i;
    }
  return returnval;
}
\f
/* APCS (ARM procedure call standard) defines the following prologue:

   mov		ip, sp
  [stmfd	sp!, {a1,a2,a3,a4}]
   stmfd	sp!, {...,fp,ip,lr,pc}
  [stfe		f7, [sp, #-12]!]
  [stfe		f6, [sp, #-12]!]
  [stfe		f5, [sp, #-12]!]
  [stfe		f4, [sp, #-12]!]
   sub		fp, ip, #nn	// nn == 20 or 4 depending on second ins
*/

CORE_ADDR
skip_prologue(pc)
CORE_ADDR pc;
{
    union insn_fmt op;
    CORE_ADDR skip_pc = pc;

    op.ins = read_memory_integer(skip_pc, 4);
    /* look for the "mov ip,sp" */
    if (op.generic.type != TYPE_ARITHMETIC ||
	op.arith.opcode != OPCODE_MOV ||
	op.arith.dest != SPTEMP ||
	op.arith.operand2 != SP) return pc;
    skip_pc += 4;
    /* skip the "stmfd sp!,{a1,a2,a3,a4}" if its there */
    op.ins = read_memory_integer(skip_pc, 4);
    if (op.generic.type == TYPE_BLOCK_BRANCH &&
	op.generic.subtype == SUBTYPE_BLOCK &&
	op.block.mask == 0xf &&
	op.block.base == SP &&
	op.block.is_load == 0 &&
	op.block.writeback == 1 &&
	op.block.increment == 0 &&
	op.block.before == 1) skip_pc += 4;
    /* skip the "stmfd sp!,{...,fp,ip,lr,pc} */
    op.ins = read_memory_integer(skip_pc, 4);
    if (op.generic.type != TYPE_BLOCK_BRANCH ||
	op.generic.subtype != SUBTYPE_BLOCK ||
	/* the mask should look like 110110xxxxxx0000 */
	(op.block.mask & 0xd800) != 0xd800 ||
	op.block.base != SP ||
	op.block.is_load != 0 ||
	op.block.writeback != 1 ||
	op.block.increment != 0 ||
	op.block.before != 1) return pc;
    skip_pc += 4;
    /* check for "sub fp,ip,#nn" */
    op.ins = read_memory_integer(skip_pc, 4);
    if (op.generic.type != TYPE_ARITHMETIC ||
	op.arith.opcode != OPCODE_SUB ||
	op.arith.dest != FP ||
	op.arith.operand1 != SPTEMP) return pc;
    return skip_pc + 4;
}

static void
print_fpu_flags(flags)
int flags;
{
    if (flags & (1 << 0)) fputs("IVO ", stdout);
    if (flags & (1 << 1)) fputs("DVZ ", stdout);
    if (flags & (1 << 2)) fputs("OFL ", stdout);
    if (flags & (1 << 3)) fputs("UFL ", stdout);
    if (flags & (1 << 4)) fputs("INX ", stdout);
    putchar('\n');
}

void
arm_float_info()
{
    register unsigned long status = read_register(FPS_REGNUM);
    int type;

    type = (status >> 24) & 127;
    printf("%s FPU type %d\n",
	   (status & (1<<31)) ? "Hardware" : "Software",
	   type);
    fputs("mask: ", stdout);
    print_fpu_flags(status >> 16);
    fputs("flags: ", stdout);
    print_fpu_flags(status);
}
Commit	Line	Data
bd5635a1 RP	1	/* Copyright (C) 1988, 1989 Free Software Foundation, Inc.
	2
	3	This file is part of GDB.
	4
	5	GDB is free software; you can redistribute it and/or modify
	6	it under the terms of the GNU General Public License as published by
	7	the Free Software Foundation; either version 1, or (at your option)
	8	any later version.
	9
	10	GDB is distributed in the hope that it will be useful,
	11	but WITHOUT ANY WARRANTY; without even the implied warranty of
	12	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	13	GNU General Public License for more details.
	14
	15	You should have received a copy of the GNU General Public License
	16	along with GDB; see the file COPYING. If not, write to
	17	the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
	18
	19	#include "defs.h"
	20	#include "param.h"
	21	#include "frame.h"
	22	#include "inferior.h"
	23	#include "arm-opcode.h"
	24
	25	#include <stdio.h>
	26	#include <sys/param.h>
	27	#include <sys/dir.h>
	28	#include <signal.h>
	29	#include <sys/ioctl.h>
	30	#include <sys/ptrace.h>
	31	#include <machine/reg.h>
	32
	33	#define N_TXTADDR(hdr) 0x8000
	34	#define N_DATADDR(hdr) (hdr.a_text + 0x8000)
	35
	36	#include "gdbcore.h"
	37	#include <sys/user.h> /* After a.out.h */
	38	#include <sys/file.h>
	39	#include <sys/stat.h>
	40
	41	#include <errno.h>
	42
	43	\f
	44	/* Work with core dump and executable files, for GDB.
	45	This code would be in core.c if it weren't machine-dependent. */
	46
	47	/* Structure to describe the chain of shared libraries used
	48	by the execfile.
	49	e.g. prog shares Xt which shares X11 which shares c. */
	50
	51	struct shared_library {
	52	struct exec_header header;
	53	char name[SHLIBLEN];
	54	CORE_ADDR text_start; /* CORE_ADDR of 1st byte of text, this file */
	55	long data_offset; /* offset of data section in file */
	56	int chan; /* file descriptor for the file */
	57	struct shared_library shares; / library this one shares */
	58	};
	59	static struct shared_library *shlib = 0;
	60
	61	/* Hook for `exec_file_command' command to call. */
	62
	63	extern void (*exec_file_display_hook) ();
	64
65	static CORE_ADDR unshared_text_start;
66
67	/* extended header from exec file (for shared library info) */
68
69	static struct exec_header exec_header;
70
71	void
72	exec_file_command (filename, from_tty)
73	char *filename;
74	int from_tty;
75	{
76	int val;
77
78	/* Eliminate all traces of old exec file.
79	Mark text segment as empty. */
80
81	if (execfile)
82	free (execfile);
83	execfile = 0;
84	data_start = 0;
85	data_end -= exec_data_start;
86	text_start = 0;
87	unshared_text_start = 0;
88	text_end = 0;
89	exec_data_start = 0;
90	exec_data_end = 0;
91	if (execchan >= 0)
92	close (execchan);
93	execchan = -1;
94	if (shlib) {
95	close_shared_library(shlib);
96	shlib = 0;
97	}
98
99	/* Now open and digest the file the user requested, if any. */
100
101	if (filename)
102	{
103	filename = tilde_expand (filename);
104	make_cleanup (free, filename);
105
106	execchan = openp (getenv ("PATH"), 1, filename, O_RDONLY, 0,
107	&execfile);
108	if (execchan < 0)
109	perror_with_name (filename);
110
111	{
112	struct stat st_exec;
113
114	#ifdef HEADER_SEEK_FD
115	HEADER_SEEK_FD (execchan);
116	#endif
117
118	val = myread (execchan, &exec_header, sizeof exec_header);
119	exec_aouthdr = exec_header.a_exec;
120
121	if (val < 0)
122	perror_with_name (filename);
123
124	text_start = 0x8000;
125
126	/* Look for shared library if needed */
127	if (exec_header.a_exec.a_magic & MF_USES_SL)
128	shlib = open_shared_library(exec_header.a_shlibname, text_start);
129
130	text_offset = N_TXTOFF (exec_aouthdr);
131	exec_data_offset = N_TXTOFF (exec_aouthdr) + exec_aouthdr.a_text;
132
133	if (shlib) {
134	unshared_text_start = shared_text_end(shlib) & ~0x7fff;
135	stack_start = shlib->header.a_exec.a_sldatabase;
136	stack_end = STACK_END_ADDR;
137	} else
138	unshared_text_start = 0x8000;
139	text_end = unshared_text_start + exec_aouthdr.a_text;
140
141	exec_data_start = unshared_text_start + exec_aouthdr.a_text;
142	exec_data_end = exec_data_start + exec_aouthdr.a_data;
143
144	data_start = exec_data_start;
145	data_end += exec_data_start;
146
147	fstat (execchan, &st_exec);
148	exec_mtime = st_exec.st_mtime;
149	}
150
151	validate_files ();
152	}
153	else if (from_tty)
154	printf ("No exec file now.\n");
155
156	/* Tell display code (if any) about the changed file name. */
157	if (exec_file_display_hook)
158	(*exec_file_display_hook) (filename);
159	}
160
161	/* Read from the program's memory (except for inferior processes).
162	This function is misnamed, since it only reads, never writes; and
163	since it will use the core file and/or executable file as necessary.
164
165	It should be extended to write as well as read, FIXME, for patching files.
166
167	Return 0 if address could be read, EIO if addresss out of bounds. */
168
169	int
170	xfer_core_file (memaddr, myaddr, len)
171	CORE_ADDR memaddr;
172	char *myaddr;
173	int len;
174	{
175	register int i;
176	register int val;
177	int xferchan;
178	char **xferfile;
179	int fileptr;
180	int returnval = 0;
181
182	while (len > 0)
183	{
184	xferfile = 0;
185	xferchan = 0;
186
187	/* Determine which file the next bunch of addresses reside in,
188	and where in the file. Set the file's read/write pointer
189	to point at the proper place for the desired address
190	and set xferfile and xferchan for the correct file.
191
192	If desired address is nonexistent, leave them zero.
193
194	i is set to the number of bytes that can be handled
195	along with the next address.
196
197	We put the most likely tests first for efficiency. */
198
199	/* Note that if there is no core file
200	data_start and data_end are equal. */
201	if (memaddr >= data_start && memaddr < data_end)
202	{
203	i = min (len, data_end - memaddr);
204	fileptr = memaddr - data_start + data_offset;
205	xferfile = &corefile;
206	xferchan = corechan;
207	}
208	/* Note that if there is no core file
209	stack_start and stack_end define the shared library data. */
210	else if (memaddr >= stack_start && memaddr < stack_end)
211	{
212	if (corechan < 0) {
213	struct shared_library *lib;
214	for (lib = shlib; lib; lib = lib->shares)
215	if (memaddr >= lib->header.a_exec.a_sldatabase &&
216	memaddr < lib->header.a_exec.a_sldatabase +
217	lib->header.a_exec.a_data)
218	break;
219	if (lib) {
220	i = min (len, lib->header.a_exec.a_sldatabase +
221	lib->header.a_exec.a_data - memaddr);
222	fileptr = lib->data_offset + memaddr -
223	lib->header.a_exec.a_sldatabase;
224	xferfile = execfile;
225	xferchan = lib->chan;
226	}
227	} else {
228	i = min (len, stack_end - memaddr);
229	fileptr = memaddr - stack_start + stack_offset;
230	xferfile = &corefile;
231	xferchan = corechan;
232	}
233	}
234	else if (corechan < 0
235	&& memaddr >= exec_data_start && memaddr < exec_data_end)
236	{
237	i = min (len, exec_data_end - memaddr);
238	fileptr = memaddr - exec_data_start + exec_data_offset;
239	xferfile = &execfile;
240	xferchan = execchan;
241	}
242	else if (memaddr >= text_start && memaddr < text_end)
243	{
244	struct shared_library *lib;
245	for (lib = shlib; lib; lib = lib->shares)
246	if (memaddr >= lib->text_start &&
247	memaddr < lib->text_start + lib->header.a_exec.a_text)
248	break;
249	if (lib) {
250	i = min (len, lib->header.a_exec.a_text +
251	lib->text_start - memaddr);
252	fileptr = memaddr - lib->text_start + text_offset;
253	xferfile = &execfile;
254	xferchan = lib->chan;
255	} else {
256	i = min (len, text_end - memaddr);
257	fileptr = memaddr - unshared_text_start + text_offset;
258	xferfile = &execfile;
259	xferchan = execchan;
260	}
261	}
262	else if (memaddr < text_start)
263	{
264	i = min (len, text_start - memaddr);
265	}
266	else if (memaddr >= text_end
267	&& memaddr < (corechan >= 0? data_start : exec_data_start))
268	{
269	i = min (len, data_start - memaddr);
270	}
271	else if (corechan >= 0
272	&& memaddr >= data_end && memaddr < stack_start)
273	{
274	i = min (len, stack_start - memaddr);
275	}
276	else if (corechan < 0 && memaddr >= exec_data_end)
277	{
278	i = min (len, - memaddr);
279	}
280	else if (memaddr >= stack_end && stack_end != 0)
281	{
282	i = min (len, - memaddr);
283	}
284	else
285	{
286	/* Address did not classify into one of the known ranges.
287	This shouldn't happen; we catch the endpoints. */
288	fatal ("Internal: Bad case logic in xfer_core_file.");
289	}
290
291	/* Now we know which file to use.
292	Set up its pointer and transfer the data. */
293	if (xferfile)
294	{
295	if (*xferfile == 0)
296	if (xferfile == &execfile)
297	error ("No program file to examine.");
298	else
299	error ("No core dump file or running program to examine.");
300	val = lseek (xferchan, fileptr, 0);
301	if (val < 0)
302	perror_with_name (*xferfile);
303	val = myread (xferchan, myaddr, i);
304	if (val < 0)
305	perror_with_name (*xferfile);
306	}
307	/* If this address is for nonexistent memory,
308	read zeros if reading, or do nothing if writing.
309	Actually, we never right. */
310	else
311	{
312	bzero (myaddr, i);
313	returnval = EIO;
314	}
315
316	memaddr += i;
317	myaddr += i;
318	len -= i;
319	}
320	return returnval;
321	}
322	\f
323	/* APCS (ARM procedure call standard) defines the following prologue:
324
325	mov ip, sp
326	[stmfd sp!, {a1,a2,a3,a4}]
327	stmfd sp!, {...,fp,ip,lr,pc}
328	[stfe f7, [sp, #-12]!]
329	[stfe f6, [sp, #-12]!]
330	[stfe f5, [sp, #-12]!]
331	[stfe f4, [sp, #-12]!]
332	sub fp, ip, #nn // nn == 20 or 4 depending on second ins
333	*/
334
335	CORE_ADDR
336	skip_prologue(pc)
337	CORE_ADDR pc;
338	{
339	union insn_fmt op;
340	CORE_ADDR skip_pc = pc;
341
342	op.ins = read_memory_integer(skip_pc, 4);
343	/* look for the "mov ip,sp" */
344	if (op.generic.type != TYPE_ARITHMETIC \|\|
345	op.arith.opcode != OPCODE_MOV \|\|
346	op.arith.dest != SPTEMP \|\|
347	op.arith.operand2 != SP) return pc;
348	skip_pc += 4;
349	/* skip the "stmfd sp!,{a1,a2,a3,a4}" if its there */
350	op.ins = read_memory_integer(skip_pc, 4);
351	if (op.generic.type == TYPE_BLOCK_BRANCH &&
352	op.generic.subtype == SUBTYPE_BLOCK &&
353	op.block.mask == 0xf &&
354	op.block.base == SP &&
355	op.block.is_load == 0 &&
356	op.block.writeback == 1 &&
357	op.block.increment == 0 &&
358	op.block.before == 1) skip_pc += 4;
359	/* skip the "stmfd sp!,{...,fp,ip,lr,pc} */
360	op.ins = read_memory_integer(skip_pc, 4);
361	if (op.generic.type != TYPE_BLOCK_BRANCH \|\|
362	op.generic.subtype != SUBTYPE_BLOCK \|\|
363	/* the mask should look like 110110xxxxxx0000 */
364	(op.block.mask & 0xd800) != 0xd800 \|\|
365	op.block.base != SP \|\|
366	op.block.is_load != 0 \|\|
367	op.block.writeback != 1 \|\|
368	op.block.increment != 0 \|\|
369	op.block.before != 1) return pc;
370	skip_pc += 4;
371	/* check for "sub fp,ip,#nn" */
372	op.ins = read_memory_integer(skip_pc, 4);
373	if (op.generic.type != TYPE_ARITHMETIC \|\|
374	op.arith.opcode != OPCODE_SUB \|\|
375	op.arith.dest != FP \|\|
376	op.arith.operand1 != SPTEMP) return pc;
377	return skip_pc + 4;
378	}
379
380	static void
381	print_fpu_flags(flags)
382	int flags;
383	{
384	if (flags & (1 << 0)) fputs("IVO ", stdout);
385	if (flags & (1 << 1)) fputs("DVZ ", stdout);
386	if (flags & (1 << 2)) fputs("OFL ", stdout);
387	if (flags & (1 << 3)) fputs("UFL ", stdout);
388	if (flags & (1 << 4)) fputs("INX ", stdout);
389	putchar('\n');
390	}
391
392	void
393	arm_float_info()
394	{
395	register unsigned long status = read_register(FPS_REGNUM);
396	int type;
397
398	type = (status >> 24) & 127;
399	printf("%s FPU type %d\n",
400	(status & (1<<31)) ? "Hardware" : "Software",
401	type);
402	fputs("mask: ", stdout);
403	print_fpu_flags(status >> 16);
404	fputs("flags: ", stdout);
405	print_fpu_flags(status);
406	}