/[qemu]/qemu/target-ppc/op_mem.h
ViewVC logotype

Diff of /qemu/target-ppc/op_mem.h

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 1.6 by bellard, Mon Jan 3 23:42:39 2005 UTC revision 1.7 by bellard, Sat Apr 23 18:16:07 2005 UTC
# Line 8  static inline uint16_t glue(ld16r, MEMSU Line 8  static inline uint16_t glue(ld16r, MEMSU
8      return ((tmp & 0xFF00) >> 8) | ((tmp & 0x00FF) << 8);      return ((tmp & 0xFF00) >> 8) | ((tmp & 0x00FF) << 8);
9  }  }
10    
11    static inline int32_t glue(ld16rs, MEMSUFFIX) (target_ulong EA)
12    {
13        int16_t tmp = glue(lduw, MEMSUFFIX)(EA);
14        return ((tmp & 0xFF00) >> 8) | ((tmp & 0x00FF) << 8);
15    }
16    
17  static inline uint32_t glue(ld32r, MEMSUFFIX) (target_ulong EA)  static inline uint32_t glue(ld32r, MEMSUFFIX) (target_ulong EA)
18  {  {
19      uint32_t tmp = glue(ldl, MEMSUFFIX)(EA);      uint32_t tmp = glue(ldl, MEMSUFFIX)(EA);
# Line 48  PPC_LD_OP(ha, ldsw); Line 54  PPC_LD_OP(ha, ldsw);
54  PPC_LD_OP(hz, lduw);  PPC_LD_OP(hz, lduw);
55  PPC_LD_OP(wz, ldl);  PPC_LD_OP(wz, ldl);
56    
57    PPC_LD_OP(ha_le, ld16rs);
58    PPC_LD_OP(hz_le, ld16r);
59    PPC_LD_OP(wz_le, ld32r);
60    
61  /***                              Integer store                            ***/  /***                              Integer store                            ***/
62  PPC_ST_OP(b, stb);  PPC_ST_OP(b, stb);
63  PPC_ST_OP(h, stw);  PPC_ST_OP(h, stw);
64  PPC_ST_OP(w, stl);  PPC_ST_OP(w, stl);
65    
66    PPC_ST_OP(h_le, st16r);
67    PPC_ST_OP(w_le, st32r);
68    
69  /***                Integer load and store with byte reverse               ***/  /***                Integer load and store with byte reverse               ***/
70  PPC_LD_OP(hbr, ld16r);  PPC_LD_OP(hbr, ld16r);
71  PPC_LD_OP(wbr, ld32r);  PPC_LD_OP(wbr, ld32r);
72  PPC_ST_OP(hbr, st16r);  PPC_ST_OP(hbr, st16r);
73  PPC_ST_OP(wbr, st32r);  PPC_ST_OP(wbr, st32r);
74    
75    PPC_LD_OP(hbr_le, lduw);
76    PPC_LD_OP(wbr_le, ldl);
77    PPC_ST_OP(hbr_le, stw);
78    PPC_ST_OP(wbr_le, stl);
79    
80  /***                    Integer load and store multiple                    ***/  /***                    Integer load and store multiple                    ***/
81  PPC_OP(glue(lmw, MEMSUFFIX))  PPC_OP(glue(lmw, MEMSUFFIX))
82  {  {
# Line 80  PPC_OP(glue(stmw, MEMSUFFIX)) Line 98  PPC_OP(glue(stmw, MEMSUFFIX))
98      RETURN();      RETURN();
99  }  }
100    
101    PPC_OP(glue(lmw_le, MEMSUFFIX))
102    {
103        int dst = PARAM(1);
104    
105        for (; dst < 32; dst++, T0 += 4) {
106            ugpr(dst) = glue(ld32r, MEMSUFFIX)(T0);
107        }
108        RETURN();
109    }
110    
111    PPC_OP(glue(stmw_le, MEMSUFFIX))
112    {
113        int src = PARAM(1);
114    
115        for (; src < 32; src++, T0 += 4) {
116            glue(st32r, MEMSUFFIX)(T0, ugpr(src));
117        }
118        RETURN();
119    }
120    
121  /***                    Integer load and store strings                     ***/  /***                    Integer load and store strings                     ***/
122  PPC_OP(glue(lswi, MEMSUFFIX))  PPC_OP(glue(lswi, MEMSUFFIX))
123  {  {
# Line 87  PPC_OP(glue(lswi, MEMSUFFIX)) Line 125  PPC_OP(glue(lswi, MEMSUFFIX))
125      RETURN();      RETURN();
126  }  }
127    
128    void glue(do_lsw_le, MEMSUFFIX) (int dst);
129    PPC_OP(glue(lswi_le, MEMSUFFIX))
130    {
131        glue(do_lsw_le, MEMSUFFIX)(PARAM(1));
132        RETURN();
133    }
134    
135  /* PPC32 specification says we must generate an exception if  /* PPC32 specification says we must generate an exception if
136   * rA is in the range of registers to be loaded.   * rA is in the range of registers to be loaded.
137   * In an other hand, IBM says this is valid, but rA won't be loaded.   * In an other hand, IBM says this is valid, but rA won't be loaded.
# Line 105  PPC_OP(glue(lswx, MEMSUFFIX)) Line 150  PPC_OP(glue(lswx, MEMSUFFIX))
150      RETURN();      RETURN();
151  }  }
152    
153    PPC_OP(glue(lswx_le, MEMSUFFIX))
154    {
155        if (T1 > 0) {
156            if ((PARAM(1) < PARAM(2) && (PARAM(1) + T1) > PARAM(2)) ||
157                (PARAM(1) < PARAM(3) && (PARAM(1) + T1) > PARAM(3))) {
158                do_raise_exception_err(EXCP_PROGRAM, EXCP_INVAL | EXCP_INVAL_LSWX);
159            } else {
160                glue(do_lsw_le, MEMSUFFIX)(PARAM(1));
161            }
162        }
163        RETURN();
164    }
165    
166  PPC_OP(glue(stsw, MEMSUFFIX))  PPC_OP(glue(stsw, MEMSUFFIX))
167  {  {
168      glue(do_stsw, MEMSUFFIX)(PARAM(1));      glue(do_stsw, MEMSUFFIX)(PARAM(1));
169      RETURN();      RETURN();
170  }  }
171    
172    void glue(do_stsw_le, MEMSUFFIX) (int src);
173    PPC_OP(glue(stsw_le, MEMSUFFIX))
174    {
175        glue(do_stsw_le, MEMSUFFIX)(PARAM(1));
176        RETURN();
177    }
178    
179  /***                         Floating-point store                          ***/  /***                         Floating-point store                          ***/
180  #define PPC_STF_OP(name, op)                                                  \  #define PPC_STF_OP(name, op)                                                  \
181  PPC_OP(glue(glue(st, name), MEMSUFFIX))                                       \  PPC_OP(glue(glue(st, name), MEMSUFFIX))                                       \
# Line 122  PPC_OP(glue(glue(st, name), MEMSUFFIX)) Line 187  PPC_OP(glue(glue(st, name), MEMSUFFIX))
187  PPC_STF_OP(fd, stfq);  PPC_STF_OP(fd, stfq);
188  PPC_STF_OP(fs, stfl);  PPC_STF_OP(fs, stfl);
189    
190    static inline void glue(stfqr, MEMSUFFIX) (target_ulong EA, double d)
191    {
192        union {
193            double d;
194            uint64_t u;
195        } u;
196    
197        u.d = d;
198        u.u = ((u.u & 0xFF00000000000000ULL) >> 56) |
199            ((u.u & 0x00FF000000000000ULL) >> 40) |
200            ((u.u & 0x0000FF0000000000ULL) >> 24) |
201            ((u.u & 0x000000FF00000000ULL) >> 8) |
202            ((u.u & 0x00000000FF000000ULL) << 8) |
203            ((u.u & 0x0000000000FF0000ULL) << 24) |
204            ((u.u & 0x000000000000FF00ULL) << 40) |
205            ((u.u & 0x00000000000000FFULL) << 56);
206        glue(stfq, MEMSUFFIX)(EA, u.d);
207    }
208    
209    static inline void glue(stflr, MEMSUFFIX) (target_ulong EA, float f)
210    {
211        union {
212            float f;
213            uint32_t u;
214        } u;
215    
216        u.f = f;
217        u.u = ((u.u & 0xFF000000UL) >> 24) |
218            ((u.u & 0x00FF0000ULL) >> 8) |
219            ((u.u & 0x0000FF00UL) << 8) |
220            ((u.u & 0x000000FFULL) << 24);
221        glue(stfl, MEMSUFFIX)(EA, u.f);
222    }
223    
224    PPC_STF_OP(fd_le, stfqr);
225    PPC_STF_OP(fs_le, stflr);
226    
227  /***                         Floating-point load                           ***/  /***                         Floating-point load                           ***/
228  #define PPC_LDF_OP(name, op)                                                  \  #define PPC_LDF_OP(name, op)                                                  \
229  PPC_OP(glue(glue(l, name), MEMSUFFIX))                                        \  PPC_OP(glue(glue(l, name), MEMSUFFIX))                                        \
# Line 133  PPC_OP(glue(glue(l, name), MEMSUFFIX)) Line 235  PPC_OP(glue(glue(l, name), MEMSUFFIX))
235  PPC_LDF_OP(fd, ldfq);  PPC_LDF_OP(fd, ldfq);
236  PPC_LDF_OP(fs, ldfl);  PPC_LDF_OP(fs, ldfl);
237    
238    static inline double glue(ldfqr, MEMSUFFIX) (target_ulong EA)
239    {
240        union {
241            double d;
242            uint64_t u;
243        } u;
244    
245        u.d = glue(ldfq, MEMSUFFIX)(EA);
246        u.u = ((u.u & 0xFF00000000000000ULL) >> 56) |
247            ((u.u & 0x00FF000000000000ULL) >> 40) |
248            ((u.u & 0x0000FF0000000000ULL) >> 24) |
249            ((u.u & 0x000000FF00000000ULL) >> 8) |
250            ((u.u & 0x00000000FF000000ULL) << 8) |
251            ((u.u & 0x0000000000FF0000ULL) << 24) |
252            ((u.u & 0x000000000000FF00ULL) << 40) |
253            ((u.u & 0x00000000000000FFULL) << 56);
254    
255        return u.d;
256    }
257    
258    static inline float glue(ldflr, MEMSUFFIX) (target_ulong EA)
259    {
260        union {
261            float f;
262            uint32_t u;
263        } u;
264    
265        u.f = glue(ldfl, MEMSUFFIX)(EA);
266        u.u = ((u.u & 0xFF000000UL) >> 24) |
267            ((u.u & 0x00FF0000ULL) >> 8) |
268            ((u.u & 0x0000FF00UL) << 8) |
269            ((u.u & 0x000000FFULL) << 24);
270    
271        return u.f;
272    }
273    
274    PPC_LDF_OP(fd_le, ldfqr);
275    PPC_LDF_OP(fs_le, ldflr);
276    
277  /* Load and set reservation */  /* Load and set reservation */
278  PPC_OP(glue(lwarx, MEMSUFFIX))  PPC_OP(glue(lwarx, MEMSUFFIX))
279  {  {
# Line 145  PPC_OP(glue(lwarx, MEMSUFFIX)) Line 286  PPC_OP(glue(lwarx, MEMSUFFIX))
286      RETURN();      RETURN();
287  }  }
288    
289    PPC_OP(glue(lwarx_le, MEMSUFFIX))
290    {
291        if (T0 & 0x03) {
292            do_raise_exception(EXCP_ALIGN);
293        } else {
294           T1 = glue(ld32r, MEMSUFFIX)(T0);
295           regs->reserve = T0;
296        }
297        RETURN();
298    }
299    
300  /* Store with reservation */  /* Store with reservation */
301  PPC_OP(glue(stwcx, MEMSUFFIX))  PPC_OP(glue(stwcx, MEMSUFFIX))
302  {  {
# Line 162  PPC_OP(glue(stwcx, MEMSUFFIX)) Line 314  PPC_OP(glue(stwcx, MEMSUFFIX))
314      RETURN();      RETURN();
315  }  }
316    
317    PPC_OP(glue(stwcx_le, MEMSUFFIX))
318    {
319        if (T0 & 0x03) {
320            do_raise_exception(EXCP_ALIGN);
321        } else {
322            if (regs->reserve != T0) {
323                env->crf[0] = xer_ov;
324            } else {
325                glue(st32r, MEMSUFFIX)(T0, T1);
326                env->crf[0] = xer_ov | 0x02;
327            }
328        }
329        regs->reserve = 0;
330        RETURN();
331    }
332    
333  PPC_OP(glue(dcbz, MEMSUFFIX))  PPC_OP(glue(dcbz, MEMSUFFIX))
334  {  {
335      glue(stl, MEMSUFFIX)(T0 + 0x00, 0);      glue(stl, MEMSUFFIX)(T0 + 0x00, 0);
# Line 188  PPC_OP(glue(ecowx, MEMSUFFIX)) Line 356  PPC_OP(glue(ecowx, MEMSUFFIX))
356      RETURN();      RETURN();
357  }  }
358    
359    PPC_OP(glue(eciwx_le, MEMSUFFIX))
360    {
361        T1 = glue(ld32r, MEMSUFFIX)(T0);
362        RETURN();
363    }
364    
365    PPC_OP(glue(ecowx_le, MEMSUFFIX))
366    {
367        glue(st32r, MEMSUFFIX)(T0, T1);
368        RETURN();
369    }
370    
371  #undef MEMSUFFIX  #undef MEMSUFFIX

Legend:
Removed from v.1.6  
changed lines
  Added in v.1.7

savannah-hackers-public@gnu.org
ViewVC Help
Powered by ViewVC 1.1.26