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

Subversion Repositories or1k

[/] [or1k/] [branches/] [oc/] [gdb-5.0/] [sim/] [common/] [sim-bits.c] - Blame information for rev 1771

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


/*  This file is part of the program psim.
 
    Copyright (C) 1994-1997, Andrew Cagney <cagney@highland.com.au>
 
    This program 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 of the License, or
    (at your option) any later version.
 
    This program 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 this program; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 
    */
 
 
#ifndef _SIM_BITS_C_
#define _SIM_BITS_C_
 
#include "sim-basics.h"
#include "sim-assert.h"
#include "sim-io.h"
 
 
INLINE_SIM_BITS\
(unsigned_word)
LSMASKED (unsigned_word val,
          int start,
          int stop)
{
  /* NOTE - start, stop can wrap */
  val &= LSMASK (start, stop);
  return val;
}
 
 
INLINE_SIM_BITS\
(unsigned_word)
MSMASKED (unsigned_word val,
          int start,
          int stop)
{
  /* NOTE - start, stop can wrap */
  val &= MSMASK (start, stop);
  return val;
}
 
 
INLINE_SIM_BITS\
(unsigned_word)
LSEXTRACTED (unsigned_word val,
             int start,
             int stop)
{
  ASSERT (start >= stop);
#if (WITH_TARGET_WORD_BITSIZE == 64)
  return LSEXTRACTED64 (val, start, stop);
#endif
#if (WITH_TARGET_WORD_BITSIZE == 32)
  if (stop >= 32)
    return 0;
  else
    {
      if (start < 32)
        val &= LSMASK (start, 0);
      val >>= stop;
      return val;
    }
#endif
}
 
 
INLINE_SIM_BITS\
(unsigned_word)
MSEXTRACTED (unsigned_word val,
             int start,
             int stop)
{
  ASSERT (start <= stop);
#if (WITH_TARGET_WORD_BITSIZE == 64)
  return MSEXTRACTED64 (val, start, stop);
#endif
#if (WITH_TARGET_WORD_BITSIZE == 32)
  if (stop < 32)
    return 0;
  else
    {
      if (start >= 32)
        val &= MSMASK (start, 64 - 1);
      val >>= (64 - stop - 1);
      return val;
    }
#endif
}
 
 
INLINE_SIM_BITS\
(unsigned_word)
LSINSERTED (unsigned_word val,
            int start,
            int stop)
{
  ASSERT (start >= stop);
#if (WITH_TARGET_WORD_BITSIZE == 64)
  return LSINSERTED64 (val, start, stop);
#endif
#if (WITH_TARGET_WORD_BITSIZE == 32)
  /* Bit numbers are 63..0, even for 32 bit targets.
     On 32 bit targets we ignore 63..32  */
  if (stop >= 32)
    return 0;
  else
    {
      val <<= stop;
      val &= LSMASK (start, stop);
      return val;
    }
#endif
}
 
INLINE_SIM_BITS\
(unsigned_word)
MSINSERTED (unsigned_word val,
            int start,
            int stop)
{
  ASSERT (start <= stop);
#if (WITH_TARGET_WORD_BITSIZE == 64)
  return MSINSERTED64 (val, start, stop);
#endif
#if (WITH_TARGET_WORD_BITSIZE == 32)
  /* Bit numbers are 0..63, even for 32 bit targets.
     On 32 bit targets we ignore 0..31.  */
  if (stop < 32)
    return 0;
  else
    {
      val <<= ((64 - 1) - stop);
      val &= MSMASK (start, stop);
      return val;
    }
#endif
}
 
 
 
INLINE_SIM_BITS\
(unsigned_word)
LSSEXT (signed_word val,
        int sign_bit)
{
  ASSERT (sign_bit < 64);
#if (WITH_TARGET_WORD_BITSIZE == 64)
  return LSSEXT64 (val, sign_bit);
#endif
#if (WITH_TARGET_WORD_BITSIZE == 32)
  if (sign_bit >= 32)
    return val;
  else {
    val = LSSEXT32 (val, sign_bit);
    return val;
  }
#endif
}
 
INLINE_SIM_BITS\
(unsigned_word)
MSSEXT (signed_word val,
        int sign_bit)
{
  ASSERT (sign_bit < 64);
#if (WITH_TARGET_WORD_BITSIZE == 64)
  return MSSEXT64 (val, sign_bit);
#endif
#if (WITH_TARGET_WORD_BITSIZE == 32)
  if (sign_bit < 32)
    return val;
  else {
    val = MSSEXT32 (val, sign_bit - 32);
    return val;
  }
#endif
}
 
 
 
#define N 8
#include "sim-n-bits.h"
#undef N
 
#define N 16
#include "sim-n-bits.h"
#undef N
 
#define N 32
#include "sim-n-bits.h"
#undef N
 
#define N 64
#include "sim-n-bits.h"
#undef N
 
#endif /* _SIM_BITS_C_ */

Browse

Tools

Subversion Repositories or1k

[/] [or1k/] [branches/] [oc/] [gdb-5.0/] [sim/] [common/] [sim-bits.c] - Blame information for rev 1771

Line No.	Rev	Author	Line
1	106	markom	`/* This file is part of the program psim.`
2
3			`Copyright (C) 1994-1997, Andrew Cagney <cagney@highland.com.au>`
4
5			`This program 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 2 of the License, or`
8			`(at your option) any later version.`
9
10			`This program 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 this program; if not, write to the Free Software`
17			`Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.`
18
19			`*/`
20
21
22			`#ifndef _SIM_BITS_C_`
23			`#define _SIM_BITS_C_`
24
25			`#include "sim-basics.h"`
26			`#include "sim-assert.h"`
27			`#include "sim-io.h"`
28
29
30			`INLINE_SIM_BITS\`
31			`(unsigned_word)`
32			`LSMASKED (unsigned_word val,`
33			`int start,`
34			`int stop)`
35			`{`
36			`/* NOTE - start, stop can wrap */`
37			`val &= LSMASK (start, stop);`
38			`return val;`
39			`}`
40
41
42			`INLINE_SIM_BITS\`
43			`(unsigned_word)`
44			`MSMASKED (unsigned_word val,`
45			`int start,`
46			`int stop)`
47			`{`
48			`/* NOTE - start, stop can wrap */`
49			`val &= MSMASK (start, stop);`
50			`return val;`
51			`}`
52
53
54			`INLINE_SIM_BITS\`
55			`(unsigned_word)`
56			`LSEXTRACTED (unsigned_word val,`
57			`int start,`
58			`int stop)`
59			`{`
60			`ASSERT (start >= stop);`
61			`#if (WITH_TARGET_WORD_BITSIZE == 64)`
62			`return LSEXTRACTED64 (val, start, stop);`
63			`#endif`
64			`#if (WITH_TARGET_WORD_BITSIZE == 32)`
65			`if (stop >= 32)`
66			`return 0;`
67			`else`
68			`{`
69			`if (start < 32)`
70			`val &= LSMASK (start, 0);`
71			`val >>= stop;`
72			`return val;`
73			`}`
74			`#endif`
75			`}`
76
77
78			`INLINE_SIM_BITS\`
79			`(unsigned_word)`
80			`MSEXTRACTED (unsigned_word val,`
81			`int start,`
82			`int stop)`
83			`{`
84			`ASSERT (start <= stop);`
85			`#if (WITH_TARGET_WORD_BITSIZE == 64)`
86			`return MSEXTRACTED64 (val, start, stop);`
87			`#endif`
88			`#if (WITH_TARGET_WORD_BITSIZE == 32)`
89			`if (stop < 32)`
90			`return 0;`
91			`else`
92			`{`
93			`if (start >= 32)`
94			`val &= MSMASK (start, 64 - 1);`
95			`val >>= (64 - stop - 1);`
96			`return val;`
97			`}`
98			`#endif`
99			`}`
100
101
102			`INLINE_SIM_BITS\`
103			`(unsigned_word)`
104			`LSINSERTED (unsigned_word val,`
105			`int start,`
106			`int stop)`
107			`{`
108			`ASSERT (start >= stop);`
109			`#if (WITH_TARGET_WORD_BITSIZE == 64)`
110			`return LSINSERTED64 (val, start, stop);`
111			`#endif`
112			`#if (WITH_TARGET_WORD_BITSIZE == 32)`
113			`/* Bit numbers are 63..0, even for 32 bit targets.`
114			`On 32 bit targets we ignore 63..32 */`
115			`if (stop >= 32)`
116			`return 0;`
117			`else`
118			`{`
119			`val <<= stop;`
120			`val &= LSMASK (start, stop);`
121			`return val;`
122			`}`
123			`#endif`
124			`}`
125
126			`INLINE_SIM_BITS\`
127			`(unsigned_word)`
128			`MSINSERTED (unsigned_word val,`
129			`int start,`
130			`int stop)`
131			`{`
132			`ASSERT (start <= stop);`
133			`#if (WITH_TARGET_WORD_BITSIZE == 64)`
134			`return MSINSERTED64 (val, start, stop);`
135			`#endif`
136			`#if (WITH_TARGET_WORD_BITSIZE == 32)`
137			`/* Bit numbers are 0..63, even for 32 bit targets.`
138			`On 32 bit targets we ignore 0..31. */`
139			`if (stop < 32)`
140			`return 0;`
141			`else`
142			`{`
143			`val <<= ((64 - 1) - stop);`
144			`val &= MSMASK (start, stop);`
145			`return val;`
146			`}`
147			`#endif`
148			`}`
149
150
151
152			`INLINE_SIM_BITS\`
153			`(unsigned_word)`
154			`LSSEXT (signed_word val,`
155			`int sign_bit)`
156			`{`
157			`ASSERT (sign_bit < 64);`
158			`#if (WITH_TARGET_WORD_BITSIZE == 64)`
159			`return LSSEXT64 (val, sign_bit);`
160			`#endif`
161			`#if (WITH_TARGET_WORD_BITSIZE == 32)`
162			`if (sign_bit >= 32)`
163			`return val;`
164			`else {`
165			`val = LSSEXT32 (val, sign_bit);`
166			`return val;`
167			`}`
168			`#endif`
169			`}`
170
171			`INLINE_SIM_BITS\`
172			`(unsigned_word)`
173			`MSSEXT (signed_word val,`
174			`int sign_bit)`
175			`{`
176			`ASSERT (sign_bit < 64);`
177			`#if (WITH_TARGET_WORD_BITSIZE == 64)`
178			`return MSSEXT64 (val, sign_bit);`
179			`#endif`
180			`#if (WITH_TARGET_WORD_BITSIZE == 32)`
181			`if (sign_bit < 32)`
182			`return val;`
183			`else {`
184			`val = MSSEXT32 (val, sign_bit - 32);`
185			`return val;`
186			`}`
187			`#endif`
188			`}`
189
190
191
192			`#define N 8`
193			`#include "sim-n-bits.h"`
194			`#undef N`
195
196			`#define N 16`
197			`#include "sim-n-bits.h"`
198			`#undef N`
199
200			`#define N 32`
201			`#include "sim-n-bits.h"`
202			`#undef N`
203
204			`#define N 64`
205			`#include "sim-n-bits.h"`
206			`#undef N`
207
208			`#endif /* _SIM_BITS_C_ */`