Subversion Repositories tendra.SVN

Rev

Rev 2 | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
2 7u83 1 
/*
2 
    		 Crown Copyright (c) 1997
3 
 
4 
    This TenDRA(r) Computer Program is subject to Copyright
5 
    owned by the United Kingdom Secretary of State for Defence
6 
    acting through the Defence Evaluation and Research Agency
7 
    (DERA).  It is made available to Recipients with a
8 
    royalty-free licence for its use, reproduction, transfer
9 
    to other parties and amendment for any purpose not excluding
10 
    product development provided that any such use et cetera
11 
    shall be deemed to be acceptance of the following conditions:-
12 
 
13 
        (1) Its Recipients shall ensure that this Notice is
14 
        reproduced upon any copies or amended versions of it;
15 
 
16 
        (2) Any amended version of it shall be clearly marked to
17 
        show both the nature of and the organisation responsible
18 
        for the relevant amendment or amendments;
19 
 
20 
        (3) Its onward transfer from a recipient to another
21 
        party shall be deemed to be that party's acceptance of
22 
        these conditions;
23 
 
24 
        (4) DERA gives no warranty or assurance as to its
25 
        quality or suitability for any purpose and DERA accepts
26 
        no liability whatsoever in relation to any use to which
27 
        it may be put.
28 
*/
29 
 
30 
 
31 
/**********************************************************************
32 
$Author: release $
33 
$Date: 1998/01/17 15:56:05 $
34 
$Revision: 1.1.1.1 $
35 
$Log: handle_sregs.c,v $
36 
 * Revision 1.1.1.1  1998/01/17  15:56:05  release
37 
 * First version to be checked into rolling release.
38 
 *
39 
 * Revision 1.3  1995/09/12  10:59:24  currie
40 
 * gcc pedanttry
41 
 *
42 
 * Revision 1.2  1995/08/16  16:06:45  currie
43 
 * Shortened some .h names
44 
 *
45 
 * Revision 1.1  1995/04/13  09:08:06  currie
46 
 * Initial revision
47 
 *
48 
***********************************************************************/
49 
/* handle_sregs.c
50 
	handle_sregs dumps and recovers the s-registers;
51 
	the registers to be dumped are expressed as bits in a long eg
52 
	bit 31 => reg 31 must be dumped.
53 
	They are called in the dump_tag part of make_code.
54 
 
55 
****************************************************************/
56 
 
57 
 
58 
 
59 
#include "config.h"
60 
#include "mips_ins.h"
61 
#include "inst_fmt.h"
62 
#include "addrtypes.h"
63 
#include "expmacs.h"
64 
#include "frames.h"
65 
#include "basicread.h"
66 
#include "handle_sregs.h"
67 
 
68 
extern long frame_size;
69 
long  dumpstart;		/* where to start dumping fixeds */
70 
long  fldumpstart;		/* where to start dumping floats */
71 
 
72 
long  fixdump;			/* all the fixeds to be dumped */
73 
long  floatdump;		/* all the floats to be dumped */
74 
 
75 
long  fixdone;			/* the fixeds which have already been
76 
				   dumped */
77 
long  fltdone;			/* the floats which have already been
78 
				   dumped */
79 
 
80 
/* dump_sreg, dump_sfreg & recover .. etc not used at present!! */
81 
 
82 
baseoff dump_baseoff
83 
    PROTO_N ( (ds) )
84 
    PROTO_T ( long ds )
85 
{	baseoff b;
86 
	b.base = (Has_vcallees)?local_reg:(29+Has_fp);
87 
	b.offset = (Has_vcallees)?(ds - (frame_size>>3)):
88 
		   (Has_fp)?(ds - ((frame_size+callee_size)>>3)):ds;
89 
        return b;
90 
}
91 
 
92 
void dump_sreg
93 
    PROTO_N ( (n) )
94 
    PROTO_T ( int n )
95 
{
96 
   unsigned long maskn = 1 << n;
97 
   unsigned long mask = 1 << 31;
98 
   int i;
99 
   baseoff b;
100 
   b = dump_baseoff(dumpstart);
101 
   Assert(maskn & fixdump);
102 
 
103 
   for(i = 31; ; i--) {
104 
       if (mask & fixdump) b.offset -=4;
105 
       if (i== n) {
106 
       		ls_ins(i_sw, n, b);
107 
       		fixdone |= maskn;
108 
       		return;
109 
       }
110 
       mask >>= 1;
111 
   }
112 
}
113 
 
114 
void dump_sfreg
115 
    PROTO_N ( (n) )
116 
    PROTO_T ( int n )
117 
{
118 
   unsigned long maskn = 3 << n;
119 
   unsigned long mask = 3 << 30;
120 
   int i;
121 
   baseoff b;
122 
   b = dump_baseoff(fldumpstart);
123 
   Assert(maskn & floatdump);
124 
 
125 
   for (i =30; ; i-=2) {
126 
      if (mask & floatdump) b.offset -=8;
127 
      if (i==n) {
128 
      	   	lsfp_ins(i_s_d, i, b);
129 
      	   	fltdone |= maskn;
130 
      	   	return;
131 
      }
132 
      mask >>= 2;
133 
   }
134 
}
135 
 
136 
void recover_sreg
137 
    PROTO_N ( (n) )
138 
    PROTO_T ( int n )
139 
{
140 
   unsigned long maskn = 1 << n;
141 
   unsigned long mask = 1 << 31;
142 
   int i;
143 
   baseoff b;
144 
   b = dump_baseoff(dumpstart);
145 
   Assert(maskn & fixdump);
146 
 
147 
   for(i = 31; ; i--) {
148 
       if (mask & fixdump) b.offset -=4;
149 
       if (i== n) {
150 
       		ls_ins(i_lw, n, b);
151 
       		fixdone &= ~maskn;
152 
       		return;
153 
       }
154 
       mask >>= 1;
155 
   }
156 
}
157 
 
158 
void recover_sfreg
159 
    PROTO_N ( (n) )
160 
    PROTO_T ( int n )
161 
{
162 
   unsigned long maskn = 3 << n;
163 
   unsigned long mask = 3 << 30;
164 
   int i;
165 
   baseoff b;
166 
   b = dump_baseoff(fldumpstart);
167 
   Assert(maskn & floatdump);
168 
 
169 
   for (i =30; ; i-=2) {
170 
      if (mask & floatdump) b.offset -=8;
171 
      if (i==n) {
172 
      	   	lsfp_ins(i_l_d, i, b);
173 
      	   	fltdone &= ~maskn;
174 
      	   	return;
175 
      }
176 
      mask >>= 2;
177 
   }
178 
}
179 
 
180 
void dump_sregs
181 
    PROTO_N ( (fdi, fldi) )
182 
    PROTO_T ( long fdi X long fldi )
183 
{
184 
  unsigned long mask = 1 << 31;
185 
  long fd = fdi;
186 
  long fld = fldi;
187 
  baseoff b;
188 
  int   i;
189 
  b = dump_baseoff(dumpstart);
190 
 
191 
  for (i = 31; fd != 0; i--) {
192 
    if (mask & fixdump) {
193 
      b.offset -= 4;
194 
      if (mask & fd) {
195 
	ls_ins (i_sw, i, b);
196 
	fd &= ~mask;
197 
      }
198 
    }
199 
    mask = mask >> 1;
200 
  }
201 
 
202 
  b = dump_baseoff(fldumpstart);
203 
  mask = 3 << 30;
204 
  for (i = 30; fld != 0; i -= 2) {
205 
    if ((mask & floatdump) == mask) {
206 
      b.offset -= 8;
207 
      if (mask & fld) {
208 
	lsfp_ins (i_s_d, i, b);
209 
	fld &= ~mask;
210 
      }
211 
    }
212 
    mask = mask >> 2;
213 
  }
214 
  fixdone |= fdi;
215 
  fltdone |= fldi;
216 
}
217 
 
218 
 
219 
 
220 
void restore_sregs
221 
    PROTO_N ( (fd, fld) )
222 
    PROTO_T ( long fd X long fld )
223 
{
224 
  unsigned long mask = 1 << 31;
225 
  baseoff b;
226 
  int   i;
227 
  b = dump_baseoff(dumpstart);
228 
 
229 
  for (i = 31; fd != 0; i--) {
230 
    if (mask & fixdump) {
231 
      b.offset -= 4;
232 
      if (mask & fd) {
233 
	ls_ins (i_lw, i, b);
234 
	fd &= ~mask;
235 
      }
236 
    }
237 
    mask = mask >> 1;
238 
  }
239 
 
240 
 b = dump_baseoff(fldumpstart);
241 
  mask = 3 << 30;
242 
  for (i = 30; fld != 0; i -= 2) {
243 
    if ((mask & floatdump) == mask) {
244 
      b.offset-= 8;
245 
      if (mask & fld) {
246 
	lsfp_ins (i_l_d, i, b);
247 
	fld &= ~mask;
248 
      }
249 
    }
250 
    mask = mask >> 2;
251 
  }
252 
}
253 
 
254 
void dump_all_sregs
255 
    PROTO_Z ()
256 
{
257 
  unsigned long mask = 1 << 31;
258 
  long fd = fixdump;
259 
  long fld = floatdump;
260 
  baseoff b;
261 
  int   i;
262 
 
263 
  b = dump_baseoff(dumpstart);
264 
  for (i = 31; fd != 0; i--) {
265 
    if (mask & fixdump) {
266 
      b.offset-= 4;
267 
      ls_ins (i_sw, i, b);
268 
      fd &= ~mask;
269 
    }
270 
    mask = mask >> 1;
271 
  }
272 
 
273 
  b = dump_baseoff(fldumpstart);
274 
  mask = 3 << 30;
275 
  for (i = 30; fld != 0; i -= 2) {
276 
    if ((mask & floatdump) == mask) {
277 
      b.offset-= 8;
278 
      lsfp_ins (i_s_d, i, b);
279 
      fld &= ~mask;
280 
    }
281 
    mask = mask >> 2;
282 
  }
283 
  fixdone = fixdump;
284 
  fltdone = floatdump;
285 
}