URL https://opencores.org/ocsvn/or1k/or1k/trunk

Subversion Repositories or1k

[/] [or1k/] [trunk/] [gdb-5.3/] [sim/] [z8k/] [inlines.h] - Blame information for rev 1773

Go to most recent revision | Details | Compare with Previous | View Log


/* inline functions for Z8KSIM
   Copyright (C) 1992, 1993 Free Software Foundation, Inc.
 
This file is part of Z8KSIM
 
GNU CC 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 2, or (at your option)
any later version.
 
GNU CC 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 Z8KZIM; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
 
#ifndef INLINE
#define INLINE
#endif
#define UGT 0x0b
#define ULE 0x03
#define ULT 0x07
#define UGE 0x0f
#define SLOW 0
#define T 0x8
#define F 0x0
#define LT 0x1
#define GT 0xa
#define LE 0x2
#define EQ 0x6
#define NE 0xe
#define GE 0x9
 
 static int is_cond_true PARAMS((sim_state_type *context, int c));
 static void makeflags PARAMS((sim_state_type *context, int mask));
 
static INLINE
long
sitoptr (si)
long si;
{
  return ((si & 0xff000000) >> 8) | (si & 0xffff);
}
static INLINE long
ptrtosi (ptr)
long ptr;
{
  return ((ptr & 0xff0000) << 8) | (ptr & 0xffff);
}
 
static INLINE
void
put_long_reg (context, reg, val)
     sim_state_type *context;
     int reg;
     int val;
{
  context->regs[reg].word = val >> 16;
  context->regs[reg + 1].word = val;
}
 
static INLINE
void
put_quad_reg (context, reg, val1, val2)
     sim_state_type *context;
     int reg;
     int val1;
     int val2;
{
  context->regs[reg].word = val2 >> 16;
  context->regs[reg + 1].word = val2;
  context->regs[reg + 2].word = val1 >> 16;
  context->regs[reg + 3].word = val1;
}
 
static INLINE
void
put_word_reg (context, reg, val)
     sim_state_type *context;
     int reg;
     int val;
{
  context->regs[reg].word = val;
}
 
static INLINE
SItype get_long_reg (context, reg)
     sim_state_type *context;
     int reg;
{
  USItype lsw = context->regs[reg + 1].word;
  USItype msw = context->regs[reg].word;
 
  return (msw << 16) | lsw;
}
 
#ifdef __GNUC__
static INLINE
struct UDIstruct
get_quad_reg (context, reg)
     sim_state_type *context;
     int reg;
{
  UDItype res;
  USItype lsw = get_long_reg (context, reg + 2);
  USItype msw = get_long_reg (context, reg);
 
  res.low = lsw;
  res.high = msw;
  return res;
}
 
#endif
 
static INLINE void
put_byte_mem_da (context, addr, value)
     sim_state_type *context;
     int addr;
     int value;
{
  ((unsigned char *) (context->memory))[addr] = value;
}
 
static INLINE
void
put_byte_reg (context, reg, val)
     sim_state_type *context;
     int reg;
     int val;
{
  int old = context->regs[reg & 0x7].word;
  if (reg & 0x8)
    {
      old = old & 0xff00 | (val & 0xff);
    }
  else
    {
      old = old & 0x00ff | (val << 8);
    }
  context->regs[reg & 0x7].word = old;
}
 
static INLINE
int
get_byte_reg (context, reg)
     sim_state_type *context;
     int reg;
{
  if (reg & 0x8)
    return  context->regs[reg & 0x7].word & 0xff;
  else
    return  (context->regs[reg & 0x7].word >> 8) & 0xff;
}
 
static INLINE
void
put_word_mem_da (context, addr, value)
     sim_state_type *context;
     int addr;
     int value;
{
  if (addr & 1)
    {
      context->exception = SIM_BAD_ALIGN;
      addr &= ~1;
    }
  put_byte_mem_da(context, addr, value>>8);
  put_byte_mem_da(context, addr+1, value);
}
 
static INLINE unsigned char
get_byte_mem_da (context, addr)
     sim_state_type *context;
     int addr;
{
  return ((unsigned char *) (context->memory))[addr];
}
 
 
#if 0
#define get_word_mem_da(context,addr)\
 *((unsigned short*)((char*)((context)->memory)+(addr)))
 
#else
#define get_word_mem_da(context,addr) (get_byte_mem_da(context, addr) << 8) | (get_byte_mem_da(context,addr+1))
#endif
 
#define get_word_reg(context,reg) (context)->regs[reg].word
 
static INLINE
SItype
get_long_mem_da (context, addr)
     sim_state_type *context;
     int addr;
{
  USItype lsw = get_word_mem_da(context,addr+2);
  USItype msw =  get_word_mem_da(context, addr);
 
  return (msw << 16) + lsw;
}
 
static INLINE
void
put_long_mem_da (context, addr, value)
     sim_state_type *context;
     int addr;
     int value;
{
  put_word_mem_da(context,addr, value>>16);
  put_word_mem_da(context,addr+2, value);
}
 
static INLINE
int
get_word_mem_ir (context, reg)
     sim_state_type *context;
     int reg;
{
  return get_word_mem_da (context, get_word_reg (context, reg));
}
 
static INLINE
void
put_word_mem_ir (context, reg, value)
     sim_state_type *context;
     int reg;
     int value;
{
 
  put_word_mem_da (context, get_word_reg (context, reg), value);
}
 
static INLINE
int
get_byte_mem_ir (context, reg)
     sim_state_type *context;
     int reg;
{
  return get_byte_mem_da (context, get_word_reg (context, reg));
}
 
static INLINE
void
put_byte_mem_ir (context, reg, value)
     sim_state_type *context;
     int reg;
     int value;
{
  put_byte_mem_da (context, get_word_reg (context, reg), value);
}
 
static INLINE
int
get_long_mem_ir (context, reg)
     sim_state_type *context;
     int reg;
{
  return get_long_mem_da (context, get_word_reg (context, reg));
}
 
static INLINE
void
put_long_mem_ir (context, reg, value)
     sim_state_type *context;
     int reg;
     int value;
{
 
  put_long_mem_da (context, get_word_reg (context, reg), value);
}
 
static INLINE
void
put_long_mem_x (context, base, reg, value)
     sim_state_type *context;
     int base;
     int reg;
     int value;
{
  put_long_mem_da (context, get_word_reg (context, reg) + base, value);
}
 
static INLINE
void
put_word_mem_x (context, base, reg, value)
     sim_state_type *context;
     int base;
     int reg;
     int value;
{
  put_word_mem_da (context, get_word_reg (context, reg) + base, value);
}
 
static INLINE
void
put_byte_mem_x (context, base, reg, value)
     sim_state_type *context;
     int base;
     int reg;
     int value;
{
  put_byte_mem_da (context, get_word_reg (context, reg) + base, value);
}
 
static INLINE
int
get_word_mem_x (context, base, reg)
     sim_state_type *context;
     int base;
     int reg;
{
  return get_word_mem_da (context, base + get_word_reg (context, reg));
}
 
static INLINE
int
get_byte_mem_x (context, base, reg)
     sim_state_type *context;
     int base;
     int reg;
{
  return get_byte_mem_da (context, base + get_word_reg (context, reg));
}
 
static INLINE
int
get_long_mem_x (context, base, reg)
     sim_state_type *context;
     int base;
     int reg;
{
  return get_long_mem_da (context, base + get_word_reg (context, reg));
}
 
 
static
void
makeflags (context, mask)
     sim_state_type *context;
     int mask;
{
 
  PSW_ZERO = (context->dst & mask) == 0;
  PSW_SIGN = (context->dst >> (context->size - 1));
 
  if (context->broken_flags == TST_FLAGS)
    {
      extern char the_parity[];
 
      if (context->size == 8)
        {
          PSW_OVERFLOW = the_parity[context->dst & 0xff];
        }
    }
  else
    {
      /* Overflow is set if both operands have the same sign and the
         result is of different sign.
 
         V =  A==B && R!=B  jumping logic
         (~(A^B))&(R^B)
         V =  (A^B)^(R^B)   boolean
         */
 
      PSW_OVERFLOW =
        ((
           (~(context->srca ^ context->srcb)
            & (context->srca ^ context->dst))
         ) >> (context->size - 1)
        );
 
      if (context->size < 32)
        {
          PSW_CARRY = ((context->dst >> context->size)) & 1;
        }
      else
        {
          /* carry is set when the result is smaller than a source */
 
 
          PSW_CARRY =  (unsigned) context->dst > (unsigned) context->srca ;
 
        }
    }
  context->broken_flags = 0;
}
 
 
/* There are two ways to calculate the flags.  We can
   either always calculate them and so the cc will always
   be correct, or we can only keep the arguments around and
   calc the flags when they're actually going to be used. */
 
/* Right now we always calc the flags - I think it may be faster*/
 
 
#define NORMAL_FLAGS(c,s,d,sa,sb,sub)   \
    if (s == 8)                \
      normal_flags_8(c,d,sa,sb,sub); \
    else if (s == 16)                \
      normal_flags_16(c,d,sa,sb,sub); \
    else if (s == 32)                \
      normal_flags_32(c,d,sa,sb,sub);
 
static INLINE
void
normal_flags (context, size, dst, srca, srcb)
     sim_state_type *context;
     int size;
     int dst;
     int srca;
     int srcb;
{
  context->srca = srca;
  context->srcb = srcb;
  context->dst = dst;
  context->size = size;
  context->broken_flags = CMP_FLAGS;
}
 
static INLINE
void
TEST_NORMAL_FLAGS (context, size, dst)
     sim_state_type *context;
     int size;
     int dst;
{
  context->dst = dst;
  context->size = size;
  context->broken_flags = TST_FLAGS;
}
 
static INLINE
void
put_ptr_long_reg (context, reg, val)
     sim_state_type *context;
     int reg;
     int val;
{
  context->regs[reg].word = (val >> 8) & 0x7f00;
  context->regs[reg + 1].word = val;
}
 
static INLINE
long
get_ptr_long_reg (context, reg)
     sim_state_type *context;
     int reg;
{
  int val;
 
  val = (context->regs[reg].word << 8) | context->regs[reg + 1].word;
  return val;
}
 
static INLINE
long
get_ptr_long_mem_ir (context, reg)
sim_state_type *context;
int reg;
{
  return sitoptr (get_long_mem_da (context, get_ptr_long_reg (context, reg)));
}
 
static INLINE
long
get_ptr_long_mem_da (context, addr)
sim_state_type *context;
long addr;
{
  return sitoptr (get_long_mem_da (context, addr));
}
 
static INLINE
void
put_ptr_long_mem_da (context, addr, ptr)
sim_state_type *context;
long addr;
long ptr;
{
  put_long_mem_da (context, addr, ptrtosi (ptr));
 
}

Browse

Tools

Subversion Repositories or1k

[/] [or1k/] [trunk/] [gdb-5.3/] [sim/] [z8k/] [inlines.h] - Blame information for rev 1773

Line No.	Rev	Author	Line
1	1181	sfurman	`/* inline functions for Z8KSIM`
2			`Copyright (C) 1992, 1993 Free Software Foundation, Inc.`
3
4			`This file is part of Z8KSIM`
5
6			`GNU CC is free software; you can redistribute it and/or modify`
7			`it under the terms of the GNU General Public License as published by`
8			`the Free Software Foundation; either version 2, or (at your option)`
9			`any later version.`
10
11			`GNU CC is distributed in the hope that it will be useful,`
12			`but WITHOUT ANY WARRANTY; without even the implied warranty of`
13			`MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the`
14			`GNU General Public License for more details.`
15
16			`You should have received a copy of the GNU General Public License`
17			`along with Z8KZIM; if not, write to the Free Software`
18			`Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */`
19
20			`#ifndef INLINE`
21			`#define INLINE`
22			`#endif`
23			`#define UGT 0x0b`
24			`#define ULE 0x03`
25			`#define ULT 0x07`
26			`#define UGE 0x0f`
27			`#define SLOW 0`
28			`#define T 0x8`
29			`#define F 0x0`
30			`#define LT 0x1`
31			`#define GT 0xa`
32			`#define LE 0x2`
33			`#define EQ 0x6`
34			`#define NE 0xe`
35			`#define GE 0x9`
36
37			`static int is_cond_true PARAMS((sim_state_type *context, int c));`
38			`static void makeflags PARAMS((sim_state_type *context, int mask));`
39
40			`static INLINE`
41			`long`
42			`sitoptr (si)`
43			`long si;`
44			`{`
45			`return ((si & 0xff000000) >> 8) \| (si & 0xffff);`
46			`}`
47			`static INLINE long`
48			`ptrtosi (ptr)`
49			`long ptr;`
50			`{`
51			`return ((ptr & 0xff0000) << 8) \| (ptr & 0xffff);`
52			`}`
53
54			`static INLINE`
55			`void`
56			`put_long_reg (context, reg, val)`
57			`sim_state_type *context;`
58			`int reg;`
59			`int val;`
60			`{`
61			`context->regs[reg].word = val >> 16;`
62			`context->regs[reg + 1].word = val;`
63			`}`
64
65			`static INLINE`
66			`void`
67			`put_quad_reg (context, reg, val1, val2)`
68			`sim_state_type *context;`
69			`int reg;`
70			`int val1;`
71			`int val2;`
72			`{`
73			`context->regs[reg].word = val2 >> 16;`
74			`context->regs[reg + 1].word = val2;`
75			`context->regs[reg + 2].word = val1 >> 16;`
76			`context->regs[reg + 3].word = val1;`
77			`}`
78
79			`static INLINE`
80			`void`
81			`put_word_reg (context, reg, val)`
82			`sim_state_type *context;`
83			`int reg;`
84			`int val;`
85			`{`
86			`context->regs[reg].word = val;`
87			`}`
88
89			`static INLINE`
90			`SItype get_long_reg (context, reg)`
91			`sim_state_type *context;`
92			`int reg;`
93			`{`
94			`USItype lsw = context->regs[reg + 1].word;`
95			`USItype msw = context->regs[reg].word;`
96
97			`return (msw << 16) \| lsw;`
98			`}`
99
100			`#ifdef __GNUC__`
101			`static INLINE`
102			`struct UDIstruct`
103			`get_quad_reg (context, reg)`
104			`sim_state_type *context;`
105			`int reg;`
106			`{`
107			`UDItype res;`
108			`USItype lsw = get_long_reg (context, reg + 2);`
109			`USItype msw = get_long_reg (context, reg);`
110
111			`res.low = lsw;`
112			`res.high = msw;`
113			`return res;`
114			`}`
115
116			`#endif`
117
118			`static INLINE void`
119			`put_byte_mem_da (context, addr, value)`
120			`sim_state_type *context;`
121			`int addr;`
122			`int value;`
123			`{`
124			`((unsigned char *) (context->memory))[addr] = value;`
125			`}`
126
127			`static INLINE`
128			`void`
129			`put_byte_reg (context, reg, val)`
130			`sim_state_type *context;`
131			`int reg;`
132			`int val;`
133			`{`
134			`int old = context->regs[reg & 0x7].word;`
135			`if (reg & 0x8)`
136			`{`
137			`old = old & 0xff00 \| (val & 0xff);`
138			`}`
139			`else`
140			`{`
141			`old = old & 0x00ff \| (val << 8);`
142			`}`
143			`context->regs[reg & 0x7].word = old;`
144			`}`
145
146			`static INLINE`
147			`int`
148			`get_byte_reg (context, reg)`
149			`sim_state_type *context;`
150			`int reg;`
151			`{`
152			`if (reg & 0x8)`
153			`return context->regs[reg & 0x7].word & 0xff;`
154			`else`
155			`return (context->regs[reg & 0x7].word >> 8) & 0xff;`
156			`}`
157
158			`static INLINE`
159			`void`
160			`put_word_mem_da (context, addr, value)`
161			`sim_state_type *context;`
162			`int addr;`
163			`int value;`
164			`{`
165			`if (addr & 1)`
166			`{`
167			`context->exception = SIM_BAD_ALIGN;`
168			`addr &= ~1;`
169			`}`
170			`put_byte_mem_da(context, addr, value>>8);`
171			`put_byte_mem_da(context, addr+1, value);`
172			`}`
173
174			`static INLINE unsigned char`
175			`get_byte_mem_da (context, addr)`
176			`sim_state_type *context;`
177			`int addr;`
178			`{`
179			`return ((unsigned char *) (context->memory))[addr];`
180			`}`
181
182
183			`#if 0`
184			`#define get_word_mem_da(context,addr)\`
185			`((unsigned short)((char*)((context)->memory)+(addr)))`
186
187			`#else`
188			`#define get_word_mem_da(context,addr) (get_byte_mem_da(context, addr) << 8) \| (get_byte_mem_da(context,addr+1))`
189			`#endif`
190
191			`#define get_word_reg(context,reg) (context)->regs[reg].word`
192
193			`static INLINE`
194			`SItype`
195			`get_long_mem_da (context, addr)`
196			`sim_state_type *context;`
197			`int addr;`
198			`{`
199			`USItype lsw = get_word_mem_da(context,addr+2);`
200			`USItype msw = get_word_mem_da(context, addr);`
201
202			`return (msw << 16) + lsw;`
203			`}`
204
205			`static INLINE`
206			`void`
207			`put_long_mem_da (context, addr, value)`
208			`sim_state_type *context;`
209			`int addr;`
210			`int value;`
211			`{`
212			`put_word_mem_da(context,addr, value>>16);`
213			`put_word_mem_da(context,addr+2, value);`
214			`}`
215
216			`static INLINE`
217			`int`
218			`get_word_mem_ir (context, reg)`
219			`sim_state_type *context;`
220			`int reg;`
221			`{`
222			`return get_word_mem_da (context, get_word_reg (context, reg));`
223			`}`
224
225			`static INLINE`
226			`void`
227			`put_word_mem_ir (context, reg, value)`
228			`sim_state_type *context;`
229			`int reg;`
230			`int value;`
231			`{`
232
233			`put_word_mem_da (context, get_word_reg (context, reg), value);`
234			`}`
235
236			`static INLINE`
237			`int`
238			`get_byte_mem_ir (context, reg)`
239			`sim_state_type *context;`
240			`int reg;`
241			`{`
242			`return get_byte_mem_da (context, get_word_reg (context, reg));`
243			`}`
244
245			`static INLINE`
246			`void`
247			`put_byte_mem_ir (context, reg, value)`
248			`sim_state_type *context;`
249			`int reg;`
250			`int value;`
251			`{`
252			`put_byte_mem_da (context, get_word_reg (context, reg), value);`
253			`}`
254
255			`static INLINE`
256			`int`
257			`get_long_mem_ir (context, reg)`
258			`sim_state_type *context;`
259			`int reg;`
260			`{`
261			`return get_long_mem_da (context, get_word_reg (context, reg));`
262			`}`
263
264			`static INLINE`
265			`void`
266			`put_long_mem_ir (context, reg, value)`
267			`sim_state_type *context;`
268			`int reg;`
269			`int value;`
270			`{`
271
272			`put_long_mem_da (context, get_word_reg (context, reg), value);`
273			`}`
274
275			`static INLINE`
276			`void`
277			`put_long_mem_x (context, base, reg, value)`
278			`sim_state_type *context;`
279			`int base;`
280			`int reg;`
281			`int value;`
282			`{`
283			`put_long_mem_da (context, get_word_reg (context, reg) + base, value);`
284			`}`
285
286			`static INLINE`
287			`void`
288			`put_word_mem_x (context, base, reg, value)`
289			`sim_state_type *context;`
290			`int base;`
291			`int reg;`
292			`int value;`
293			`{`
294			`put_word_mem_da (context, get_word_reg (context, reg) + base, value);`
295			`}`
296
297			`static INLINE`
298			`void`
299			`put_byte_mem_x (context, base, reg, value)`
300			`sim_state_type *context;`
301			`int base;`
302			`int reg;`
303			`int value;`
304			`{`
305			`put_byte_mem_da (context, get_word_reg (context, reg) + base, value);`
306			`}`
307
308			`static INLINE`
309			`int`
310			`get_word_mem_x (context, base, reg)`
311			`sim_state_type *context;`
312			`int base;`
313			`int reg;`
314			`{`
315			`return get_word_mem_da (context, base + get_word_reg (context, reg));`
316			`}`
317
318			`static INLINE`
319			`int`
320			`get_byte_mem_x (context, base, reg)`
321			`sim_state_type *context;`
322			`int base;`
323			`int reg;`
324			`{`
325			`return get_byte_mem_da (context, base + get_word_reg (context, reg));`
326			`}`
327
328			`static INLINE`
329			`int`
330			`get_long_mem_x (context, base, reg)`
331			`sim_state_type *context;`
332			`int base;`
333			`int reg;`
334			`{`
335			`return get_long_mem_da (context, base + get_word_reg (context, reg));`
336			`}`
337
338
339			`static`
340			`void`
341			`makeflags (context, mask)`
342			`sim_state_type *context;`
343			`int mask;`
344			`{`
345
346			`PSW_ZERO = (context->dst & mask) == 0;`
347			`PSW_SIGN = (context->dst >> (context->size - 1));`
348
349			`if (context->broken_flags == TST_FLAGS)`
350			`{`
351			`extern char the_parity[];`
352
353			`if (context->size == 8)`
354			`{`
355			`PSW_OVERFLOW = the_parity[context->dst & 0xff];`
356			`}`
357			`}`
358			`else`
359			`{`
360			`/* Overflow is set if both operands have the same sign and the`
361			`result is of different sign.`
362
363			`V = A==B && R!=B jumping logic`
364			`(~(A^B))&(R^B)`
365			`V = (A^B)^(R^B) boolean`
366			`*/`
367
368			`PSW_OVERFLOW =`
369			`((`
370			`(~(context->srca ^ context->srcb)`
371			`& (context->srca ^ context->dst))`
372			`) >> (context->size - 1)`
373			`);`
374
375			`if (context->size < 32)`
376			`{`
377			`PSW_CARRY = ((context->dst >> context->size)) & 1;`
378			`}`
379			`else`
380			`{`
381			`/* carry is set when the result is smaller than a source */`
382
383
384			`PSW_CARRY = (unsigned) context->dst > (unsigned) context->srca ;`
385
386			`}`
387			`}`
388			`context->broken_flags = 0;`
389			`}`
390
391
392			`/* There are two ways to calculate the flags. We can`
393			`either always calculate them and so the cc will always`
394			`be correct, or we can only keep the arguments around and`
395			`calc the flags when they're actually going to be used. */`
396
397			`/* Right now we always calc the flags - I think it may be faster*/`
398
399
400			`#define NORMAL_FLAGS(c,s,d,sa,sb,sub) \`
401			`if (s == 8) \`
402			`normal_flags_8(c,d,sa,sb,sub); \`
403			`else if (s == 16) \`
404			`normal_flags_16(c,d,sa,sb,sub); \`
405			`else if (s == 32) \`
406			`normal_flags_32(c,d,sa,sb,sub);`
407
408			`static INLINE`
409			`void`
410			`normal_flags (context, size, dst, srca, srcb)`
411			`sim_state_type *context;`
412			`int size;`
413			`int dst;`
414			`int srca;`
415			`int srcb;`
416			`{`
417			`context->srca = srca;`
418			`context->srcb = srcb;`
419			`context->dst = dst;`
420			`context->size = size;`
421			`context->broken_flags = CMP_FLAGS;`
422			`}`
423
424			`static INLINE`
425			`void`
426			`TEST_NORMAL_FLAGS (context, size, dst)`
427			`sim_state_type *context;`
428			`int size;`
429			`int dst;`
430			`{`
431			`context->dst = dst;`
432			`context->size = size;`
433			`context->broken_flags = TST_FLAGS;`
434			`}`
435
436			`static INLINE`
437			`void`
438			`put_ptr_long_reg (context, reg, val)`
439			`sim_state_type *context;`
440			`int reg;`
441			`int val;`
442			`{`
443			`context->regs[reg].word = (val >> 8) & 0x7f00;`
444			`context->regs[reg + 1].word = val;`
445			`}`
446
447			`static INLINE`
448			`long`
449			`get_ptr_long_reg (context, reg)`
450			`sim_state_type *context;`
451			`int reg;`
452			`{`
453			`int val;`
454
455			`val = (context->regs[reg].word << 8) \| context->regs[reg + 1].word;`
456			`return val;`
457			`}`
458
459			`static INLINE`
460			`long`
461			`get_ptr_long_mem_ir (context, reg)`
462			`sim_state_type *context;`
463			`int reg;`
464			`{`
465			`return sitoptr (get_long_mem_da (context, get_ptr_long_reg (context, reg)));`
466			`}`
467
468			`static INLINE`
469			`long`
470			`get_ptr_long_mem_da (context, addr)`
471			`sim_state_type *context;`
472			`long addr;`
473			`{`
474			`return sitoptr (get_long_mem_da (context, addr));`
475			`}`
476
477			`static INLINE`
478			`void`
479			`put_ptr_long_mem_da (context, addr, ptr)`
480			`sim_state_type *context;`
481			`long addr;`
482			`long ptr;`
483			`{`
484			`put_long_mem_da (context, addr, ptrtosi (ptr));`
485
486			`}`