projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Update copyright year range in all GDB files.
[deliverable/binutils-gdb.git] / sim / common / sim-bits.h
CommitLineData
b85e4829
AC		 1/* The common simulator framework for GDB, the GNU Debugger.
2
b811d2c2 3 Copyright 2002-2020 Free Software Foundation, Inc.
b85e4829
AC		 4
5 Contributed by Andrew Cagney and Red Hat.
6
7 This file is part of GDB.
8
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
4744ac1b 11 the Free Software Foundation; either version 3 of the License, or
b85e4829
AC		 12 (at your option) any later version.
13
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
18
19 You should have received a copy of the GNU General Public License
4744ac1b 20 along with this program. If not, see <http://www.gnu.org/licenses/>. */
c906108c
SS		 21
22
618b526e
MF		 23#ifndef SIM_BITS_H
24#define SIM_BITS_H
c906108c
SS		 25
26
27/* Bit manipulation routines:
28
29 Bit numbering: The bits are numbered according to the target ISA's
30 convention. That being controlled by WITH_TARGET_WORD_MSB. For
31 the PowerPC (WITH_TARGET_WORD_MSB == 0) the numbering is 0..31
32 while for the MIPS (WITH_TARGET_WORD_MSB == 31) it is 31..0.
33
34 Size convention: Each macro is in three forms - <MACRO>32 which
35 operates in 32bit quantity (bits are numbered 0..31); <MACRO>64
36 which operates using 64bit quantites (and bits are numbered 0..63);
37 and <MACRO> which operates using the bit size of the target
38 architecture (bits are still numbered 0..63), with 32bit
39 architectures ignoring the first 32bits leaving bit 32 as the most
40 significant.
41
42 NB: Use EXTRACTED, MSEXTRACTED and LSEXTRACTED as a guideline for
43 naming. LSMASK and LSMASKED are wrong.
44
45 BIT*(POS): `*' bit constant with just 1 bit set.
46
47 LSBIT*(OFFSET): `*' bit constant with just 1 bit set - LS bit is
48 zero.
49
50 MSBIT*(OFFSET): `*' bit constant with just 1 bit set - MS bit is
51 zero.
52
53 MASK*(FIRST, LAST): `*' bit constant with bits [FIRST .. LAST]
54 set. The <MACRO> (no size) version permits FIRST >= LAST and
55 generates a wrapped bit mask vis ([0..LAST] | [FIRST..LSB]).
56
57 LSMASK*(FIRST, LAST): Like MASK - LS bit is zero.
58
59 MSMASK*(FIRST, LAST): Like MASK - LS bit is zero.
60
61 MASKED*(VALUE, FIRST, LAST): Masks out all but bits [FIRST
62 .. LAST].
63
64 LSMASKED*(VALUE, FIRST, LAST): Like MASKED - LS bit is zero.
65
66 MSMASKED*(VALUE, FIRST, LAST): Like MASKED - MS bit is zero.
67
68 EXTRACTED*(VALUE, FIRST, LAST): Masks out bits [FIRST .. LAST] but
69 also right shifts the masked value so that bit LAST becomes the
70 least significant (right most).
71
72 LSEXTRACTED*(VALUE, FIRST, LAST): Same as extracted - LS bit is
73 zero.
74
75 MSEXTRACTED*(VALUE, FIRST, LAST): Same as extracted - MS bit is
76 zero.
77
78 SHUFFLED**(VALUE, OLD, NEW): Mask then move a single bit from OLD
79 new NEW.
80
81 MOVED**(VALUE, OLD_FIRST, OLD_LAST, NEW_FIRST, NEW_LAST): Moves
82 things around so that bits OLD_FIRST..OLD_LAST are masked then
83 moved to NEW_FIRST..NEW_LAST.
84
85 INSERTED*(VALUE, FIRST, LAST): Takes VALUE and `inserts' the (LAST
86 - FIRST + 1) least significant bits into bit positions [ FIRST
87 .. LAST ]. This is almost the complement to EXTRACTED.
88
89 IEA_MASKED(SHOULD_MASK, ADDR): Convert the address to the targets
90 natural size. If in 32bit mode, discard the high 32bits.
91
92 EXTEND*(VALUE): Convert the `*' bit value to the targets natural
93 word size. Sign extend the value if needed.
94
95 ALIGN_*(VALUE): Round the value upwards so that it is aligned to a
96 `_*' byte boundary.
97
98 FLOOR_*(VALUE): Truncate the value so that it is aligned to a `_*'
99 byte boundary.
100
101 ROT*(VALUE, NR_BITS): Return the `*' bit VALUE rotated by NR_BITS
102 right (positive) or left (negative).
103
104 ROTL*(VALUE, NR_BITS): Return the `*' bit value rotated by NR_BITS
105 left. 0 <= NR_BITS <= `*'.
106
107 ROTR*(VALUE, NR_BITS): Return the `*' bit value rotated by NR_BITS
108 right. 0 <= NR_BITS <= N.
109
110 SEXT*(VALUE, SIGN_BIT): Treat SIGN_BIT as VALUEs sign, extend it ti
111 `*' bits.
112
113 Note: Only the BIT* and MASK* macros return a constant that can be
114 used in variable declarations.
115
116 */
117
118
119/* compute the number of bits between START and STOP */
120
121#if (WITH_TARGET_WORD_MSB == 0)
122#define _MAKE_WIDTH(START, STOP) (STOP - START + 1)
123#else
124#define _MAKE_WIDTH(START, STOP) (START - STOP + 1)
125#endif
126
127
128
129/* compute the number shifts required to move a bit between LSB (MSB)
130 and POS */
131
132#if (WITH_TARGET_WORD_MSB == 0)
133#define _LSB_SHIFT(WIDTH, POS) (WIDTH - 1 - POS)
134#else
135#define _LSB_SHIFT(WIDTH, POS) (POS)
136#endif
137
138#if (WITH_TARGET_WORD_MSB == 0)
139#define _MSB_SHIFT(WIDTH, POS) (POS)
140#else
141#define _MSB_SHIFT(WIDTH, POS) (WIDTH - 1 - POS)
142#endif
143
144
145/* compute the absolute bit position given the OFFSET from the MSB(LSB)
146 NB: _MAKE_xxx_POS (WIDTH, _MAKE_xxx_SHIFT (WIDTH, POS)) == POS */
147
148#if (WITH_TARGET_WORD_MSB == 0)
149#define _MSB_POS(WIDTH, SHIFT) (SHIFT)
150#else
151#define _MSB_POS(WIDTH, SHIFT) (WIDTH - 1 - SHIFT)
152#endif
153
154#if (WITH_TARGET_WORD_MSB == 0)
155#define _LSB_POS(WIDTH, SHIFT) (WIDTH - 1 - SHIFT)
156#else
157#define _LSB_POS(WIDTH, SHIFT) (SHIFT)
158#endif
159
160
161/* convert a 64 bit position into a corresponding 32bit position. MSB
162 pos handles the posibility that the bit lies beyond the 32bit
163 boundary */
164
165#if (WITH_TARGET_WORD_MSB == 0)
166#define _MSB_32(START, STOP) (START <= STOP \
167 ? (START < 32 ? 0 : START - 32) \
168 : (STOP < 32 ? 0 : STOP - 32))
3c765a54
AC		 169#define _MSB_16(START, STOP) (START <= STOP \
170 ? (START < 48 ? 0 : START - 48) \
171 : (STOP < 48 ? 0 : STOP - 48))
c906108c
SS		 172#else
173#define _MSB_32(START, STOP) (START >= STOP \
174 ? (START >= 32 ? 31 : START) \
175 : (STOP >= 32 ? 31 : STOP))
3c765a54
AC		 176#define _MSB_16(START, STOP) (START >= STOP \
177 ? (START >= 16 ? 15 : START) \
178 : (STOP >= 16 ? 15 : STOP))
c906108c
SS		 179#endif
180
181#if (WITH_TARGET_WORD_MSB == 0)
182#define _LSB_32(START, STOP) (START <= STOP \
183 ? (STOP < 32 ? 0 : STOP - 32) \
184 : (START < 32 ? 0 : START - 32))
3c765a54
AC		 185#define _LSB_16(START, STOP) (START <= STOP \
186 ? (STOP < 48 ? 0 : STOP - 48) \
187 : (START < 48 ? 0 : START - 48))
c906108c
SS		 188#else
189#define _LSB_32(START, STOP) (START >= STOP \
190 ? (STOP >= 32 ? 31 : STOP) \
191 : (START >= 32 ? 31 : START))
3c765a54
AC		 192#define _LSB_16(START, STOP) (START >= STOP \
193 ? (STOP >= 16 ? 15 : STOP) \
194 : (START >= 16 ? 15 : START))
c906108c
SS		 195#endif
196
197#if (WITH_TARGET_WORD_MSB == 0)
198#define _MSB(START, STOP) (START <= STOP ? START : STOP)
199#else
200#define _MSB(START, STOP) (START >= STOP ? START : STOP)
201#endif
202
203#if (WITH_TARGET_WORD_MSB == 0)
204#define _LSB(START, STOP) (START <= STOP ? STOP : START)
205#else
206#define _LSB(START, STOP) (START >= STOP ? STOP : START)
207#endif
208
209
210/* LS/MS Bit operations */
211
212#define LSBIT8(POS) ((unsigned8) 1 << (POS))
213#define LSBIT16(POS) ((unsigned16)1 << (POS))
214#define LSBIT32(POS) ((unsigned32)1 << (POS))
215#define LSBIT64(POS) ((unsigned64)1 << (POS))
216
217#if (WITH_TARGET_WORD_BITSIZE == 64)
218#define LSBIT(POS) LSBIT64 (POS)
3c765a54
AC		 219#endif
220#if (WITH_TARGET_WORD_BITSIZE == 32)
c906108c
SS		 221#define LSBIT(POS) ((unsigned32)((POS) >= 32 \
222 ? 0 \
223 : (1 << ((POS) >= 32 ? 0 : (POS)))))
224#endif
3c765a54
AC		 225#if (WITH_TARGET_WORD_BITSIZE == 16)
226#define LSBIT(POS) ((unsigned16)((POS) >= 16 \
227 ? 0 \
228 : (1 << ((POS) >= 16 ? 0 : (POS)))))
229#endif
c906108c
SS		 230
231
232#define MSBIT8(POS) ((unsigned8) 1 << ( 8 - 1 - (POS)))
233#define MSBIT16(POS) ((unsigned16)1 << (16 - 1 - (POS)))
234#define MSBIT32(POS) ((unsigned32)1 << (32 - 1 - (POS)))
235#define MSBIT64(POS) ((unsigned64)1 << (64 - 1 - (POS)))
236
237#if (WITH_TARGET_WORD_BITSIZE == 64)
238#define MSBIT(POS) MSBIT64 (POS)
3c765a54
AC		 239#endif
240#if (WITH_TARGET_WORD_BITSIZE == 32)
c906108c
SS		 241#define MSBIT(POS) ((unsigned32)((POS) < 32 \
242 ? 0 \
243 : (1 << ((POS) < 32 ? 0 : (64 - 1) - (POS)))))
244#endif
3c765a54
AC		 245#if (WITH_TARGET_WORD_BITSIZE == 16)
246#define MSBIT(POS) ((unsigned16)((POS) < 48 \
247 ? 0 \
248 : (1 << ((POS) < 48 ? 0 : (64 - 1) - (POS)))))
249#endif
c906108c
SS		 250
251
252/* Bit operations */
253
254#define BIT4(POS) (1 << _LSB_SHIFT (4, (POS)))
255#define BIT5(POS) (1 << _LSB_SHIFT (5, (POS)))
256#define BIT10(POS) (1 << _LSB_SHIFT (10, (POS)))
257
258#if (WITH_TARGET_WORD_MSB == 0)
259#define BIT8 MSBIT8
260#define BIT16 MSBIT16
261#define BIT32 MSBIT32
262#define BIT64 MSBIT64
263#define BIT MSBIT
264#else
265#define BIT8 LSBIT8
266#define BIT16 LSBIT16
267#define BIT32 LSBIT32
268#define BIT64 LSBIT64
269#define BIT LSBIT
270#endif
271
272
273
274/* multi bit mask */
275
276/* 111111 -> mmll11 -> mm11ll */
277#define _MASKn(WIDTH, START, STOP) (((unsigned##WIDTH)(-1) \
278 >> (_MSB_SHIFT (WIDTH, START) \
279 + _LSB_SHIFT (WIDTH, STOP))) \
280 << _LSB_SHIFT (WIDTH, STOP))
281
282#if (WITH_TARGET_WORD_MSB == 0)
283#define _POS_LE(START, STOP) (START <= STOP)
284#else
285#define _POS_LE(START, STOP) (STOP <= START)
286#endif
287
288#if (WITH_TARGET_WORD_BITSIZE == 64)
289#define MASK(START, STOP) \
290 (_POS_LE ((START), (STOP)) \
291 ? _MASKn(64, \
292 _MSB ((START), (STOP)), \
293 _LSB ((START), (STOP)) ) \
294 : (_MASKn(64, _MSB_POS (64, 0), (STOP)) \
295 | _MASKn(64, (START), _LSB_POS (64, 0))))
296#endif
297#if (WITH_TARGET_WORD_BITSIZE == 32)
298#define MASK(START, STOP) \
299 (_POS_LE ((START), (STOP)) \
300 ? (_POS_LE ((STOP), _MSB_POS (64, 31)) \
301 ? 0 \
302 : _MASKn (32, \
303 _MSB_32 ((START), (STOP)), \
304 _LSB_32 ((START), (STOP)))) \
305 : (_MASKn (32, \
306 _LSB_32 ((START), (STOP)), \
307 _LSB_POS (32, 0)) \
308 | (_POS_LE ((STOP), _MSB_POS (64, 31)) \
309 ? 0 \
310 : _MASKn (32, \
311 _MSB_POS (32, 0), \
312 _MSB_32 ((START), (STOP))))))
313#endif
3c765a54
AC		 314#if (WITH_TARGET_WORD_BITSIZE == 16)
315#define MASK(START, STOP) \
316 (_POS_LE ((START), (STOP)) \
317 ? (_POS_LE ((STOP), _MSB_POS (64, 15)) \
318 ? 0 \
319 : _MASKn (16, \
320 _MSB_16 ((START), (STOP)), \
321 _LSB_16 ((START), (STOP)))) \
322 : (_MASKn (16, \
323 _LSB_16 ((START), (STOP)), \
324 _LSB_POS (16, 0)) \
325 | (_POS_LE ((STOP), _MSB_POS (64, 15)) \
326 ? 0 \
327 : _MASKn (16, \
328 _MSB_POS (16, 0), \
329 _MSB_16 ((START), (STOP))))))
330#endif
c906108c
SS		 331#if !defined (MASK)
332#error "MASK never undefined"
333#endif
334
335
336/* Multi-bit mask on least significant bits */
337
338#define _LSMASKn(WIDTH, FIRST, LAST) _MASKn (WIDTH, \
339 _LSB_POS (WIDTH, FIRST), \
340 _LSB_POS (WIDTH, LAST))
341
342#define LSMASK8(FIRST, LAST) _LSMASKn ( 8, (FIRST), (LAST))
343#define LSMASK16(FIRST, LAST) _LSMASKn (16, (FIRST), (LAST))
344#define LSMASK32(FIRST, LAST) _LSMASKn (32, (FIRST), (LAST))
345#define LSMASK64(FIRST, LAST) _LSMASKn (64, (FIRST), (LAST))
346
347#define LSMASK(FIRST, LAST) (MASK (_LSB_POS (64, FIRST), _LSB_POS (64, LAST)))
348
349
350/* Multi-bit mask on most significant bits */
351
352#define _MSMASKn(WIDTH, FIRST, LAST) _MASKn (WIDTH, \
353 _MSB_POS (WIDTH, FIRST), \
354 _MSB_POS (WIDTH, LAST))
355
356#define MSMASK8(FIRST, LAST) _MSMASKn ( 8, (FIRST), (LAST))
357#define MSMASK16(FIRST, LAST) _MSMASKn (16, (FIRST), (LAST))
358#define MSMASK32(FIRST, LAST) _MSMASKn (32, (FIRST), (LAST))
359#define MSMASK64(FIRST, LAST) _MSMASKn (64, (FIRST), (LAST))
360
361#define MSMASK(FIRST, LAST) (MASK (_MSB_POS (64, FIRST), _MSB_POS (64, LAST)))
362
363
364
365#if (WITH_TARGET_WORD_MSB == 0)
366#define MASK8 MSMASK8
367#define MASK16 MSMASK16
368#define MASK32 MSMASK32
369#define MASK64 MSMASK64
370#else
371#define MASK8 LSMASK8
372#define MASK16 LSMASK16
373#define MASK32 LSMASK32
374#define MASK64 LSMASK64
375#endif
376
377
378
379/* mask the required bits, leaving them in place */
380
381INLINE_SIM_BITS(unsigned8) LSMASKED8 (unsigned8 word, int first, int last);
382INLINE_SIM_BITS(unsigned16) LSMASKED16 (unsigned16 word, int first, int last);
383INLINE_SIM_BITS(unsigned32) LSMASKED32 (unsigned32 word, int first, int last);
384INLINE_SIM_BITS(unsigned64) LSMASKED64 (unsigned64 word, int first, int last);
385
386INLINE_SIM_BITS(unsigned_word) LSMASKED (unsigned_word word, int first, int last);
387
388INLINE_SIM_BITS(unsigned8) MSMASKED8 (unsigned8 word, int first, int last);
389INLINE_SIM_BITS(unsigned16) MSMASKED16 (unsigned16 word, int first, int last);
390INLINE_SIM_BITS(unsigned32) MSMASKED32 (unsigned32 word, int first, int last);
391INLINE_SIM_BITS(unsigned64) MSMASKED64 (unsigned64 word, int first, int last);
392
393INLINE_SIM_BITS(unsigned_word) MSMASKED (unsigned_word word, int first, int last);
394
395#if (WITH_TARGET_WORD_MSB == 0)
396#define MASKED8 MSMASKED8
397#define MASKED16 MSMASKED16
398#define MASKED32 MSMASKED32
399#define MASKED64 MSMASKED64
400#define MASKED MSMASKED
401#else
402#define MASKED8 LSMASKED8
403#define MASKED16 LSMASKED16
404#define MASKED32 LSMASKED32
405#define MASKED64 LSMASKED64
406#define MASKED LSMASKED
407#endif
408
409
410
411/* extract the required bits aligning them with the lsb */
412
413INLINE_SIM_BITS(unsigned8) LSEXTRACTED8 (unsigned8 val, int start, int stop);
414INLINE_SIM_BITS(unsigned16) LSEXTRACTED16 (unsigned16 val, int start, int stop);
415INLINE_SIM_BITS(unsigned32) LSEXTRACTED32 (unsigned32 val, int start, int stop);
416INLINE_SIM_BITS(unsigned64) LSEXTRACTED64 (unsigned64 val, int start, int stop);
417
418INLINE_SIM_BITS(unsigned_word) LSEXTRACTED (unsigned_word val, int start, int stop);
419
420INLINE_SIM_BITS(unsigned8) MSEXTRACTED8 (unsigned8 val, int start, int stop);
421INLINE_SIM_BITS(unsigned16) MSEXTRACTED16 (unsigned16 val, int start, int stop);
422INLINE_SIM_BITS(unsigned32) MSEXTRACTED32 (unsigned32 val, int start, int stop);
423INLINE_SIM_BITS(unsigned64) MSEXTRACTED64 (unsigned64 val, int start, int stop);
424
425INLINE_SIM_BITS(unsigned_word) MSEXTRACTED (unsigned_word val, int start, int stop);
426
427#if (WITH_TARGET_WORD_MSB == 0)
428#define EXTRACTED8 MSEXTRACTED8
429#define EXTRACTED16 MSEXTRACTED16
430#define EXTRACTED32 MSEXTRACTED32
431#define EXTRACTED64 MSEXTRACTED64
432#define EXTRACTED MSEXTRACTED
433#else
434#define EXTRACTED8 LSEXTRACTED8
435#define EXTRACTED16 LSEXTRACTED16
436#define EXTRACTED32 LSEXTRACTED32
437#define EXTRACTED64 LSEXTRACTED64
438#define EXTRACTED LSEXTRACTED
439#endif
440
441
442
443/* move a single bit around */
444/* NB: the wierdness (N>O?N-O:0) is to stop a warning from GCC */
445#define _SHUFFLEDn(N, WORD, OLD, NEW) \
446((OLD) < (NEW) \
447 ? (((unsigned##N)(WORD) \
448 >> (((NEW) > (OLD)) ? ((NEW) - (OLD)) : 0)) \
449 & MASK32((NEW), (NEW))) \
450 : (((unsigned##N)(WORD) \
451 << (((OLD) > (NEW)) ? ((OLD) - (NEW)) : 0)) \
452 & MASK32((NEW), (NEW))))
453
454#define SHUFFLED32(WORD, OLD, NEW) _SHUFFLEDn (32, WORD, OLD, NEW)
455#define SHUFFLED64(WORD, OLD, NEW) _SHUFFLEDn (64, WORD, OLD, NEW)
456
457#define SHUFFLED(WORD, OLD, NEW) _SHUFFLEDn (_word, WORD, OLD, NEW)
458
459
460/* Insert a group of bits into a bit position */
461
462INLINE_SIM_BITS(unsigned8) LSINSERTED8 (unsigned8 val, int start, int stop);
463INLINE_SIM_BITS(unsigned16) LSINSERTED16 (unsigned16 val, int start, int stop);
464INLINE_SIM_BITS(unsigned32) LSINSERTED32 (unsigned32 val, int start, int stop);
465INLINE_SIM_BITS(unsigned64) LSINSERTED64 (unsigned64 val, int start, int stop);
466INLINE_SIM_BITS(unsigned_word) LSINSERTED (unsigned_word val, int start, int stop);
467
468INLINE_SIM_BITS(unsigned8) MSINSERTED8 (unsigned8 val, int start, int stop);
469INLINE_SIM_BITS(unsigned16) MSINSERTED16 (unsigned16 val, int start, int stop);
470INLINE_SIM_BITS(unsigned32) MSINSERTED32 (unsigned32 val, int start, int stop);
471INLINE_SIM_BITS(unsigned64) MSINSERTED64 (unsigned64 val, int start, int stop);
472INLINE_SIM_BITS(unsigned_word) MSINSERTED (unsigned_word val, int start, int stop);
473
474#if (WITH_TARGET_WORD_MSB == 0)
475#define INSERTED8 MSINSERTED8
476#define INSERTED16 MSINSERTED16
477#define INSERTED32 MSINSERTED32
478#define INSERTED64 MSINSERTED64
479#define INSERTED MSINSERTED
480#else
481#define INSERTED8 LSINSERTED8
482#define INSERTED16 LSINSERTED16
483#define INSERTED32 LSINSERTED32
484#define INSERTED64 LSINSERTED64
485#define INSERTED LSINSERTED
486#endif
487
488
489
490/* MOVE bits from one loc to another (combination of extract/insert) */
491
492#define MOVED8(VAL,OH,OL,NH,NL) INSERTED8 (EXTRACTED8 ((VAL), OH, OL), NH, NL)
493#define MOVED16(VAL,OH,OL,NH,NL) INSERTED16(EXTRACTED16((VAL), OH, OL), NH, NL)
494#define MOVED32(VAL,OH,OL,NH,NL) INSERTED32(EXTRACTED32((VAL), OH, OL), NH, NL)
495#define MOVED64(VAL,OH,OL,NH,NL) INSERTED64(EXTRACTED64((VAL), OH, OL), NH, NL)
496#define MOVED(VAL,OH,OL,NH,NL) INSERTED (EXTRACTED ((VAL), OH, OL), NH, NL)
497
498
499
500/* Sign extend the quantity to the targets natural word size */
501
502#define EXTEND4(X) (LSSEXT ((X), 3))
503#define EXTEND5(X) (LSSEXT ((X), 4))
8e394ffc 504#define EXTEND6(X) (LSSEXT ((X), 5))
c906108c
SS		 505#define EXTEND8(X) ((signed_word)(signed8)(X))
506#define EXTEND11(X) (LSSEXT ((X), 10))
8e394ffc 507#define EXTEND12(X) (LSSEXT ((X), 11))
c906108c
SS		 508#define EXTEND15(X) (LSSEXT ((X), 14))
509#define EXTEND16(X) ((signed_word)(signed16)(X))
510#define EXTEND24(X) (LSSEXT ((X), 23))
8e394ffc 511#define EXTEND25(X) (LSSEXT ((X), 24))
c906108c
SS		 512#define EXTEND32(X) ((signed_word)(signed32)(X))
513#define EXTEND64(X) ((signed_word)(signed64)(X))
514
515/* depending on MODE return a 64bit or 32bit (sign extended) value */
516#if (WITH_TARGET_WORD_BITSIZE == 64)
517#define EXTENDED(X) ((signed64)(signed32)(X))
518#endif
519#if (WITH_TARGET_WORD_BITSIZE == 32)
520#define EXTENDED(X) (X)
521#endif
3c765a54
AC		 522#if (WITH_TARGET_WORD_BITSIZE == 16)
523#define EXTENDED(X) (X)
524#endif
c906108c
SS		 525
526
527/* memory alignment macro's */
528#define _ALIGNa(A,X) (((X) + ((A) - 1)) & ~((A) - 1))
529#define _FLOORa(A,X) ((X) & ~((A) - 1))
530
531#define ALIGN_8(X) _ALIGNa (8, X)
532#define ALIGN_16(X) _ALIGNa (16, X)
533
534#define ALIGN_PAGE(X) _ALIGNa (0x1000, X)
535#define FLOOR_PAGE(X) ((X) & ~(0x1000 - 1))
536
537
538/* bit bliting macro's */
539#define BLIT32(V, POS, BIT) \
540do { \
541 if (BIT) \
542 V |= BIT32 (POS); \
543 else \
544 V &= ~BIT32 (POS); \
545} while (0)
546#define MBLIT32(V, LO, HI, VAL) \
547do { \
548 (V) = (((V) & ~MASK32 ((LO), (HI))) \
549 | INSERTED32 (VAL, LO, HI)); \
550} while (0)
551
552
553
554/* some rotate functions. The generic macro's ROT, ROTL, ROTR are
555 intentionally omited. */
556
557
558INLINE_SIM_BITS(unsigned8) ROT8 (unsigned8 val, int shift);
559INLINE_SIM_BITS(unsigned16) ROT16 (unsigned16 val, int shift);
560INLINE_SIM_BITS(unsigned32) ROT32 (unsigned32 val, int shift);
561INLINE_SIM_BITS(unsigned64) ROT64 (unsigned64 val, int shift);
562
563
564INLINE_SIM_BITS(unsigned8) ROTL8 (unsigned8 val, int shift);
565INLINE_SIM_BITS(unsigned16) ROTL16 (unsigned16 val, int shift);
566INLINE_SIM_BITS(unsigned32) ROTL32 (unsigned32 val, int shift);
567INLINE_SIM_BITS(unsigned64) ROTL64 (unsigned64 val, int shift);
568
569
570INLINE_SIM_BITS(unsigned8) ROTR8 (unsigned8 val, int shift);
571INLINE_SIM_BITS(unsigned16) ROTR16 (unsigned16 val, int shift);
572INLINE_SIM_BITS(unsigned32) ROTR32 (unsigned32 val, int shift);
573INLINE_SIM_BITS(unsigned64) ROTR64 (unsigned64 val, int shift);
574
575
576
577/* Sign extension operations */
578
579INLINE_SIM_BITS(unsigned8) LSSEXT8 (signed8 val, int sign_bit);
580INLINE_SIM_BITS(unsigned16) LSSEXT16 (signed16 val, int sign_bit);
581INLINE_SIM_BITS(unsigned32) LSSEXT32 (signed32 val, int sign_bit);
582INLINE_SIM_BITS(unsigned64) LSSEXT64 (signed64 val, int sign_bit);
583INLINE_SIM_BITS(unsigned_word) LSSEXT (signed_word val, int sign_bit);
584
585INLINE_SIM_BITS(unsigned8) MSSEXT8 (signed8 val, int sign_bit);
586INLINE_SIM_BITS(unsigned16) MSSEXT16 (signed16 val, int sign_bit);
587INLINE_SIM_BITS(unsigned32) MSSEXT32 (signed32 val, int sign_bit);
588INLINE_SIM_BITS(unsigned64) MSSEXT64 (signed64 val, int sign_bit);
589INLINE_SIM_BITS(unsigned_word) MSSEXT (signed_word val, int sign_bit);
590
591#if (WITH_TARGET_WORD_MSB == 0)
592#define SEXT8 MSSEXT8
593#define SEXT16 MSSEXT16
594#define SEXT32 MSSEXT32
595#define SEXT64 MSSEXT64
596#define SEXT MSSEXT
597#else
598#define SEXT8 LSSEXT8
599#define SEXT16 LSSEXT16
600#define SEXT32 LSSEXT32
601#define SEXT64 LSSEXT64
602#define SEXT LSSEXT
603#endif
604
605
606
607#if H_REVEALS_MODULE_P (SIM_BITS_INLINE)
608#include "sim-bits.c"
609#endif
610
618b526e 611#endif /* SIM_BITS_H */
GDB Binutils - Deliverables
This page took 0.945372 seconds and 4 git commands to generate.