LDMX Software
ap_int_base.h
1/*
2 * Copyright 2011-2019 Xilinx, Inc.
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17#ifndef __AP_INT_BASE_H__
18#define __AP_INT_BASE_H__
19
20#ifndef __AP_INT_H__
21#error "Only ap_fixed.h and ap_int.h can be included directly in user code."
22#endif
23
24#ifndef __cplusplus
25#error "C++ is required to include this header file"
26#else
27
28#include "ap_common.h"
29#ifndef __SYNTHESIS__
30#if _AP_ENABLE_HALF_ == 1
31#include <hls_half.h>
32#endif
33#include <string.h>
34
35#include <iostream>
36#endif
37
38/* ----------------------------------------------------------------
39 * ap_int_base: AutoPilot integer/Arbitrary precision integer.
40 * ----------------------------------------------------------------
41 */
42
43/* helper trait. Selecting the smallest C type that can hold the value,
44 * return 64 bit C type if not possible.
45 */
46template <int _AP_N, bool _AP_S>
47struct retval;
48
49// at least 64 bit
50template <int _AP_N>
51struct retval<_AP_N, true> {
52 typedef ap_slong Type;
53};
54
55template <int _AP_N>
56struct retval<_AP_N, false> {
57 typedef ap_ulong Type;
58};
59
60// at least 8 bit
61template <>
62struct retval<1, true> {
63 typedef signed char Type;
64};
65
66template <>
67struct retval<1, false> {
68 typedef unsigned char Type;
69};
70
71// at least 16 bit
72template <>
73struct retval<2, true> {
74 typedef short Type;
75};
76
77template <>
78struct retval<2, false> {
79 typedef unsigned short Type;
80};
81
82// at least 32 bit
83template <>
84struct retval<3, true> {
85 typedef long Type;
86};
87
88template <>
89struct retval<3, false> {
90 typedef unsigned long Type;
91};
92
93template <>
94struct retval<4, true> {
95 typedef long Type;
96};
97
98template <>
99struct retval<4, false> {
100 typedef unsigned long Type;
101};
102
103// trait for letting base class to return derived class.
104// Notice that derived class template is incomplete, and we cannot use
105// the member of the derived class.
106template <int _AP_W2, bool _AP_S2>
107struct _ap_int_factory;
108template <int _AP_W2>
109struct _ap_int_factory<_AP_W2, true> {
110 typedef ap_int<_AP_W2> type;
111};
112template <int _AP_W2>
113struct _ap_int_factory<_AP_W2, false> {
114 typedef ap_uint<_AP_W2> type;
115};
116
117template <int _AP_W, bool _AP_S>
118struct ap_int_base : public _AP_ROOT_TYPE<_AP_W, _AP_S> {
119 public:
120 typedef _AP_ROOT_TYPE<_AP_W, _AP_S> Base;
121
122 /* ap_int_base<_AP_W, _AP_S, true>
123 * typedef typename retval<(_AP_W + 7) / 8, _AP_S>::Type RetType;
124 *
125 * ap_int_base<_AP_W, _AP_S, false>
126 * typedef typename retval<8, _AP_S>::Type RetType;
127 */
128 typedef typename retval<AP_MAX((_AP_W + 7) / 8, 8), _AP_S>::Type RetType;
129
130 static const int width = _AP_W;
131
132 template <int _AP_W2, bool _AP_S2>
133 struct RType {
134 enum {
135 mult_w = _AP_W + _AP_W2,
136 mult_s = _AP_S || _AP_S2,
137 plus_w =
138 AP_MAX(_AP_W + (_AP_S2 && !_AP_S), _AP_W2 + (_AP_S && !_AP_S2)) + 1,
139 plus_s = _AP_S || _AP_S2,
140 minus_w =
141 AP_MAX(_AP_W + (_AP_S2 && !_AP_S), _AP_W2 + (_AP_S && !_AP_S2)) + 1,
142 minus_s = true,
143 div_w = _AP_W + _AP_S2,
144 div_s = _AP_S || _AP_S2,
145 mod_w = AP_MIN(_AP_W, _AP_W2 + (!_AP_S2 && _AP_S)),
146 mod_s = _AP_S,
147 logic_w = AP_MAX(_AP_W + (_AP_S2 && !_AP_S), _AP_W2 + (_AP_S && !_AP_S2)),
148 logic_s = _AP_S || _AP_S2
149 };
150
151 typedef ap_int_base<mult_w, mult_s> mult_base;
152 typedef ap_int_base<plus_w, plus_s> plus_base;
153 typedef ap_int_base<minus_w, minus_s> minus_base;
154 typedef ap_int_base<logic_w, logic_s> logic_base;
155 typedef ap_int_base<div_w, div_s> div_base;
156 typedef ap_int_base<mod_w, mod_s> mod_base;
157 typedef ap_int_base<_AP_W, _AP_S> arg1_base;
158
159 typedef typename _ap_int_factory<mult_w, mult_s>::type mult;
160 typedef typename _ap_int_factory<plus_w, plus_s>::type plus;
161 typedef typename _ap_int_factory<minus_w, minus_s>::type minus;
162 typedef typename _ap_int_factory<logic_w, logic_s>::type logic;
163 typedef typename _ap_int_factory<div_w, div_s>::type div;
164 typedef typename _ap_int_factory<mod_w, mod_s>::type mod;
165 typedef typename _ap_int_factory<_AP_W, _AP_S>::type arg1;
166 typedef bool reduce;
167 };
168
169 /* Constructors.
170 * ----------------------------------------------------------------
171 */
173 INLINE ap_int_base() {
174 /*
175 #ifdef __SC_COMPATIBLE__
176 Base::V = 0;
177 #endif
178 */
179 }
180
182 template <int _AP_W2, bool _AP_S2>
183 INLINE ap_int_base(const ap_int_base<_AP_W2, _AP_S2>& op) {
184 Base::V = op.V;
185 }
186
188 template <int _AP_W2, bool _AP_S2>
189 INLINE ap_int_base(const volatile ap_int_base<_AP_W2, _AP_S2>& op) {
190 Base::V = op.V;
191 }
192
193// XXX C++11 feature.
194// The explicit specifier specifies that a constructor or conversion function
195// (since C++11) doesn't allow implicit conversions or copy-initialization.
196// ap_int_base<W,S> x = 1;
197// ap_int_base<W,S> foo() { return 1; }
198// but allows
199// ap_int_base<W,S> x(1);
200// ap_int_base<W,S> y {1};
201
203#define CTOR_FROM_INT(Type, Size, Signed) \
204 INLINE ap_int_base(const Type op) { Base::V = op; }
205
206 CTOR_FROM_INT(bool, 1, false)
207 CTOR_FROM_INT(char, 8, CHAR_IS_SIGNED)
208 CTOR_FROM_INT(signed char, 8, true)
209 CTOR_FROM_INT(unsigned char, 8, false)
210 CTOR_FROM_INT(short, _AP_SIZE_short, true)
211 CTOR_FROM_INT(unsigned short, _AP_SIZE_short, false)
212 CTOR_FROM_INT(int, _AP_SIZE_int, true)
213 CTOR_FROM_INT(unsigned int, _AP_SIZE_int, false)
214 CTOR_FROM_INT(long, _AP_SIZE_long, true)
215 CTOR_FROM_INT(unsigned long, _AP_SIZE_long, false)
216 CTOR_FROM_INT(ap_slong, _AP_SIZE_ap_slong, true)
217 CTOR_FROM_INT(ap_ulong, _AP_SIZE_ap_slong, false)
218#undef CTOR_FROM_INT
219
220#if _AP_ENABLE_HALF_ == 1
222 // TODO optimize
223 INLINE ap_int_base(half op) {
224 ap_int_base<_AP_W, _AP_S> t((float)op);
225 Base::V = t.V;
226 }
227#endif
228
230 INLINE ap_int_base(float op) {
231 const int BITS = FLOAT_MAN + FLOAT_EXP + 1;
232 ap_int_base<BITS, false> reg;
233 reg.V = floatToRawBits(op);
234 bool is_neg = _AP_ROOT_op_get_bit(reg.V, BITS - 1);
235
236 ap_int_base<FLOAT_EXP + 1, true> exp = 0;
237 exp.V = _AP_ROOT_op_get_range(reg.V, FLOAT_MAN, BITS - 2);
238 exp = exp - FLOAT_BIAS;
239
240 ap_int_base<FLOAT_MAN + 2, true> man;
241 man.V = _AP_ROOT_op_get_range(reg.V, 0, FLOAT_MAN - 1);
242 // check for NaN
243 _AP_WARNING(exp == ((unsigned char)(FLOAT_BIAS + 1)) && man.V != 0,
244 "assign NaN to ap integer value");
245 // set leading 1.
246 man.V = _AP_ROOT_op_set_bit(man.V, FLOAT_MAN, 1);
247 // if (is_neg) man = -man;
248
249 if ((reg.V & 0x7ffffffful) == 0) {
250 Base::V = 0;
251 } else {
252 int sh_amt = FLOAT_MAN - exp.V;
253 if (sh_amt == 0) {
254 Base::V = man.V;
255 } else if (sh_amt > 0) {
256 if (sh_amt < FLOAT_MAN + 2) {
257 Base::V = man.V >> sh_amt;
258 } else {
259 if (is_neg)
260 Base::V = -1;
261 else
262 Base::V = 0;
263 }
264 } else {
265 sh_amt = -sh_amt;
266 if (sh_amt < _AP_W) {
267 Base::V = man.V;
268 Base::V <<= sh_amt;
269 } else {
270 Base::V = 0;
271 }
272 }
273 }
274 if (is_neg) *this = -(*this);
275 }
276
278 INLINE ap_int_base(double op) {
279 const int BITS = DOUBLE_MAN + DOUBLE_EXP + 1;
280 ap_int_base<BITS, false> reg;
281 reg.V = doubleToRawBits(op);
282 bool is_neg = _AP_ROOT_op_get_bit(reg.V, BITS - 1);
283
284 ap_int_base<DOUBLE_EXP + 1, true> exp = 0;
285 exp.V = _AP_ROOT_op_get_range(reg.V, DOUBLE_MAN, BITS - 2);
286 exp = exp - DOUBLE_BIAS;
287
288 ap_int_base<DOUBLE_MAN + 2, true> man;
289 man.V = _AP_ROOT_op_get_range(reg.V, 0, DOUBLE_MAN - 1);
290 // check for NaN
291 _AP_WARNING(exp == ((unsigned char)(DOUBLE_BIAS + 1)) && man.V != 0,
292 "assign NaN to ap integer value");
293 // set leading 1.
294 man.V = _AP_ROOT_op_set_bit(man.V, DOUBLE_MAN, 1);
295 // if (is_neg) man = -man;
296
297 if ((reg.V & 0x7fffffffffffffffull) == 0) {
298 Base::V = 0;
299 } else {
300 int sh_amt = DOUBLE_MAN - exp.V;
301 if (sh_amt == 0) {
302 Base::V = man.V;
303 } else if (sh_amt > 0) {
304 if (sh_amt < DOUBLE_MAN + 2) {
305 Base::V = man.V >> sh_amt;
306 } else {
307 if (is_neg)
308 Base::V = -1;
309 else
310 Base::V = 0;
311 }
312 } else {
313 sh_amt = -sh_amt;
314 if (sh_amt < _AP_W) {
315 Base::V = man.V;
316 Base::V <<= sh_amt;
317 } else {
318 Base::V = 0;
319 }
320 }
321 }
322 if (is_neg) *this = -(*this);
323 }
324
326 template <int _AP_W2, int _AP_I2, bool _AP_S2, ap_q_mode _AP_Q2,
327 ap_o_mode _AP_O2, int _AP_N2>
328 INLINE ap_int_base(
329 const ap_fixed_base<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2>& op) {
330 Base::V = op.to_ap_int_base().V;
331 }
332
333 template <int _AP_W2, bool _AP_S2>
334 INLINE ap_int_base(const ap_range_ref<_AP_W2, _AP_S2>& ref) {
335 Base::V = (ref.get()).V;
336 }
337
338 template <int _AP_W2, bool _AP_S2>
339 INLINE ap_int_base(const ap_bit_ref<_AP_W2, _AP_S2>& ref) {
340 Base::V = ref.operator bool();
341 }
342
343 template <int _AP_W2, typename _AP_T2, int _AP_W3, typename _AP_T3>
344 INLINE ap_int_base(const ap_concat_ref<_AP_W2, _AP_T2, _AP_W3, _AP_T3>& ref) {
345 const ap_int_base<ap_concat_ref<_AP_W2, _AP_T2, _AP_W3, _AP_T3>::_AP_WR,
346 false>
347 tmp = ref.get();
348 Base::V = tmp.V;
349 }
350
351 /* radix has default value in set */
352
353#ifndef __SYNTHESIS__
354 INLINE ap_int_base(const char* s, signed char rd = 0) {
355 if (rd == 0) rd = guess_radix(s);
356 unsigned int length = strlen(s);
357 Base::V.fromString(s, length, rd);
358 }
359#else
360 // XXX __builtin_bit_from_string(...) requires const C string and radix.
361 INLINE ap_int_base(const char* s) {
362 typeof(Base::V) t;
363 _ssdm_string2bits((void*)(&t), (const char*)(s), 10, _AP_W, _AP_S, AP_TRN,
364 AP_WRAP, 0, _AP_C99);
365 Base::V = t;
366 }
367 INLINE ap_int_base(const char* s, signed char rd) {
368 typeof(Base::V) t;
369 _ssdm_string2bits((void*)(&t), (const char*)(s), rd, _AP_W, _AP_S, AP_TRN,
370 AP_WRAP, 0, _AP_C99);
371 Base::V = t;
372 }
373#endif
374
375 template <int _AP_W2, int _AP_I2, bool _AP_S2, ap_q_mode _AP_Q2,
376 ap_o_mode _AP_O2, int _AP_N2>
377 INLINE ap_int_base(
378 const af_range_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2>& val) {
379 Base::V = (val.get()).V;
380 }
381
382 template <int _AP_W2, int _AP_I2, bool _AP_S2, ap_q_mode _AP_Q2,
383 ap_o_mode _AP_O2, int _AP_N2>
384 INLINE ap_int_base(
385 const af_bit_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2>& val) {
386 Base::V = val.operator bool();
387 }
388
389 INLINE ap_int_base read() volatile {
390 /*AP_DEBUG(printf("call read %d\n", Base::V););*/
391 ap_int_base ret;
392 ret.V = Base::V;
393 return ret;
394 }
395
396 INLINE void write(const ap_int_base<_AP_W, _AP_S>& op2) volatile {
397 /*AP_DEBUG(printf("call write %d\n", op2.V););*/
398 Base::V = op2.V;
399 }
400
401 /* Another form of "write".*/
402 template <int _AP_W2, bool _AP_S2>
403 INLINE void operator=(
404 const volatile ap_int_base<_AP_W2, _AP_S2>& op2) volatile {
405 Base::V = op2.V;
406 }
407
408 INLINE void operator=(
409 const volatile ap_int_base<_AP_W, _AP_S>& op2) volatile {
410 Base::V = op2.V;
411 }
412
413 template <int _AP_W2, bool _AP_S2>
414 INLINE void operator=(const ap_int_base<_AP_W2, _AP_S2>& op2) volatile {
415 Base::V = op2.V;
416 }
417
418 INLINE void operator=(const ap_int_base<_AP_W, _AP_S>& op2) volatile {
419 Base::V = op2.V;
420 }
421
422 template <int _AP_W2, bool _AP_S2>
423 INLINE ap_int_base& operator=(
424 const volatile ap_int_base<_AP_W2, _AP_S2>& op2) {
425 Base::V = op2.V;
426 return *this;
427 }
428
429 template <int _AP_W2, bool _AP_S2>
430 INLINE ap_int_base& operator=(const ap_int_base<_AP_W2, _AP_S2>& op2) {
431 Base::V = op2.V;
432 return *this;
433 }
434
435 INLINE ap_int_base& operator=(const volatile ap_int_base<_AP_W, _AP_S>& op2) {
436 Base::V = op2.V;
437 return *this;
438 }
439
440 INLINE ap_int_base& operator=(const ap_int_base<_AP_W, _AP_S>& op2) {
441 Base::V = op2.V;
442 return *this;
443 }
444
445#define ASSIGN_OP_FROM_INT(Type, Size, Signed) \
446 INLINE ap_int_base& operator=(Type op) { \
447 Base::V = op; \
448 return *this; \
449 }
450
451 ASSIGN_OP_FROM_INT(bool, 1, false)
452 ASSIGN_OP_FROM_INT(char, 8, CHAR_IS_SIGNED)
453 ASSIGN_OP_FROM_INT(signed char, 8, true)
454 ASSIGN_OP_FROM_INT(unsigned char, 8, false)
455 ASSIGN_OP_FROM_INT(short, _AP_SIZE_short, true)
456 ASSIGN_OP_FROM_INT(unsigned short, _AP_SIZE_short, false)
457 ASSIGN_OP_FROM_INT(int, _AP_SIZE_int, true)
458 ASSIGN_OP_FROM_INT(unsigned int, _AP_SIZE_int, false)
459 ASSIGN_OP_FROM_INT(long, _AP_SIZE_long, true)
460 ASSIGN_OP_FROM_INT(unsigned long, _AP_SIZE_long, false)
461 ASSIGN_OP_FROM_INT(ap_slong, _AP_SIZE_ap_slong, true)
462 ASSIGN_OP_FROM_INT(ap_ulong, _AP_SIZE_ap_slong, false)
463
464#undef ASSIGN_OP_FROM_INT
465
466 template <int _AP_W2, bool _AP_S2>
467 INLINE ap_int_base& operator=(const ap_bit_ref<_AP_W2, _AP_S2>& op2) {
468 Base::V = (bool)op2;
469 return *this;
470 }
471
472 template <int _AP_W2, bool _AP_S2>
473 INLINE ap_int_base& operator=(const ap_range_ref<_AP_W2, _AP_S2>& op2) {
474 Base::V = (ap_int_base<_AP_W2, false>(op2)).V;
475 return *this;
476 }
477
478 template <int _AP_W2, typename _AP_T2, int _AP_W3, typename _AP_T3>
479 INLINE ap_int_base& operator=(
480 const ap_concat_ref<_AP_W2, _AP_T2, _AP_W3, _AP_T3>& op2) {
481 Base::V = op2.get().V;
482 return *this;
483 }
484
485 template <int _AP_W2, int _AP_I2, bool _AP_S2, ap_q_mode _AP_Q2,
486 ap_o_mode _AP_O2, int _AP_N2>
487 INLINE ap_int_base& operator=(
488 const ap_fixed_base<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2>& op) {
489 Base::V = op.to_ap_int_base().V;
490 return *this;
491 }
492
493 template <int _AP_W2, int _AP_I2, bool _AP_S2, ap_q_mode _AP_Q2,
494 ap_o_mode _AP_O2, int _AP_N2>
495 INLINE ap_int_base& operator=(
496 const af_bit_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2>& op) {
497 Base::V = (bool)op;
498 return *this;
499 }
500
501 template <int _AP_W2, int _AP_I2, bool _AP_S2, ap_q_mode _AP_Q2,
502 ap_o_mode _AP_O2, int _AP_N2>
503 INLINE ap_int_base& operator=(
504 const af_range_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2>& op) {
505 Base::V = ((const ap_int_base<_AP_W2, false>)(op)).V;
506 return *this;
507 }
508
509 // FIXME: UG902 has clearly required user to use to_int() to convert to
510 // built-in types, but this implicit conversion is relied on in hls_cordic.h
511 // and hls_rsr.h. For example:
512 // int d_exp = fps_x.exp - fps_y.exp;
513 INLINE operator RetType() const { return (RetType)(Base::V); }
514
515 /* Explicit conversions to C types.
516 * ----------------------------------------------------------------
517 */
518 INLINE bool to_bool() const { return (bool)(Base::V); }
519 INLINE char to_char() const { return (char)(Base::V); }
520 INLINE signed char to_schar() const { return (signed char)(Base::V); }
521 INLINE unsigned char to_uchar() const { return (unsigned char)(Base::V); }
522 INLINE short to_short() const { return (short)(Base::V); }
523 INLINE unsigned short to_ushort() const { return (unsigned short)(Base::V); }
524 INLINE int to_int() const { return (int)(Base::V); }
525 INLINE unsigned to_uint() const { return (unsigned)(Base::V); }
526 INLINE long to_long() const { return (long)(Base::V); }
527 INLINE unsigned long to_ulong() const { return (unsigned long)(Base::V); }
528 INLINE ap_slong to_int64() const { return (ap_slong)(Base::V); }
529 INLINE ap_ulong to_uint64() const { return (ap_ulong)(Base::V); }
530 INLINE float to_float() const { return (float)(Base::V); }
531 INLINE double to_double() const { return (double)(Base::V); }
532
533 // TODO decide if user-defined conversion should be provided.
534#if 0
535 INLINE operator char() const { return (char)(Base::V); }
536 INLINE operator signed char() const { return (signed char)(Base::V); }
537 INLINE operator unsigned char() const { return (unsigned char)(Base::V); }
538 INLINE operator short() const { return (short)(Base::V); }
539 INLINE operator unsigned short() const { return (unsigned short)(Base::V); }
540 INLINE operator int() const { return (int)(Base::V); }
541 INLINE operator unsigned int () const { return (unsigned)(Base::V); }
542 INLINE operator long () const { return (long)(Base::V); }
543 INLINE operator unsigned long () const { return (unsigned long)(Base::V); }
544 INLINE operator ap_slong () { return (ap_slong)(Base::V); }
545 INLINE operator ap_ulong () { return (ap_ulong)(Base::V); }
546#endif
547
548 /* Helper methods.
549 ----------------------------------------------------------------
550 */
551 /* we cannot call a non-volatile function on a volatile instance.
552 * but calling a volatile function is ok.
553 * XXX deleted non-volatile version.
554 */
555 INLINE int length() const volatile { return _AP_W; }
556
557 /*Return true if the value of ap_int_base instance is zero*/
558 INLINE bool iszero() const { return Base::V == 0; }
559
560 /*Return true if the value of ap_int_base instance is zero*/
561 INLINE bool is_zero() const { return Base::V == 0; }
562
563 /* x < 0 */
564 INLINE bool sign() const {
565 if (_AP_S && _AP_ROOT_op_get_bit(Base::V, _AP_W - 1))
566 return true;
567 else
568 return false;
569 }
570
571 /* x[i] = 0 */
572 INLINE void clear(int i) {
573 AP_ASSERT(i >= 0 && i < _AP_W, "position out of range");
574 Base::V = _AP_ROOT_op_set_bit(Base::V, i, 0);
575 }
576
577 /* x[i] = !x[i]*/
578 INLINE void invert(int i) {
579 AP_ASSERT(i >= 0 && i < _AP_W, "position out of range");
580 bool val = _AP_ROOT_op_get_bit(Base::V, i);
581 if (val)
582 Base::V = _AP_ROOT_op_set_bit(Base::V, i, 0);
583 else
584 Base::V = _AP_ROOT_op_set_bit(Base::V, i, 1);
585 }
586
587 INLINE bool test(int i) const {
588 AP_ASSERT(i >= 0 && i < _AP_W, "position out of range");
589 return _AP_ROOT_op_get_bit(Base::V, i);
590 }
591
592 // Get self. For ap_concat_ref expansion.
593 INLINE ap_int_base& get() { return *this; }
594
595 // Set the ith bit into 1
596 INLINE void set(int i) {
597 AP_ASSERT(i >= 0 && i < _AP_W, "position out of range");
598 Base::V = _AP_ROOT_op_set_bit(Base::V, i, 1);
599 }
600
601 // Set the ith bit into v
602 INLINE void set(int i, bool v) {
603 AP_ASSERT(i >= 0 && i < _AP_W, "position out of range");
604 Base::V = _AP_ROOT_op_set_bit(Base::V, i, v);
605 }
606
607 // This is used for sc_lv and sc_bv, which is implemented by sc_uint
608 // Rotate an ap_int_base object n places to the left
609 INLINE ap_int_base& lrotate(int n) {
610 AP_ASSERT(n >= 0 && n < _AP_W, "shift value out of range");
611 // TODO unify this.
612#ifdef __SYNTHESIS__
613 typeof(Base::V) l_p = Base::V << n;
614 typeof(Base::V) r_p = Base::V >> (_AP_W - n);
615 Base::V = l_p | r_p;
616#else
617 Base::V.lrotate(n);
618#endif
619 return *this;
620 }
621
622 // This is used for sc_lv and sc_bv, which is implemented by sc_uint
623 // Rotate an ap_int_base object n places to the right
624 INLINE ap_int_base& rrotate(int n) {
625 AP_ASSERT(n >= 0 && n < _AP_W, "shift value out of range");
626 // TODO unify this.
627#ifdef __SYNTHESIS__
628 typeof(Base::V) l_p = Base::V << (_AP_W - n);
629 typeof(Base::V) r_p = Base::V >> n;
630 Base::V = l_p | r_p;
631#else
632 Base::V.rrotate(n);
633#endif
634 return *this;
635 }
636
637 // Reverse the contents of ap_int_base instance.
638 // I.e. LSB becomes MSB and vise versa.
639 INLINE ap_int_base& reverse() {
640 Base::V = _AP_ROOT_op_get_range(Base::V, _AP_W - 1, 0);
641 return *this;
642 }
643
644 // Set the ith bit into v
645 INLINE void set_bit(int i, bool v) {
646 Base::V = _AP_ROOT_op_set_bit(Base::V, i, v);
647 }
648
649 // Get the value of ith bit
650 INLINE bool get_bit(int i) const {
651 return (bool)_AP_ROOT_op_get_bit(Base::V, i);
652 }
653
654 // complements every bit
655 INLINE void b_not() { Base::V = ~Base::V; }
656
657#define OP_ASSIGN_AP(Sym) \
658 template <int _AP_W2, bool _AP_S2> \
659 INLINE ap_int_base& operator Sym(const ap_int_base<_AP_W2, _AP_S2>& op2) { \
660 Base::V Sym op2.V; \
661 return *this; \
662 }
663
664 /* Arithmetic assign.
665 * ----------------------------------------------------------------
666 */
667 OP_ASSIGN_AP(*=)
668 OP_ASSIGN_AP(+=)
669 OP_ASSIGN_AP(-=)
670 OP_ASSIGN_AP(/=)
671 OP_ASSIGN_AP(%=)
672#undef OP_ASSIGN_AP
673
674 /* Bitwise assign: and, or, xor.
675 * ----------------------------------------------------------------
676 */
677#define OP_ASSIGN_AP_CHK(Sym) \
678 template <int _AP_W2, bool _AP_S2> \
679 INLINE ap_int_base& operator Sym(const ap_int_base<_AP_W2, _AP_S2>& op2) { \
680 _AP_WARNING((_AP_W != _AP_W2), \
681 "Bitsize mismatch for ap_[u]int" #Sym "ap_[u]int."); \
682 Base::V Sym op2.V; \
683 return *this; \
684 }
685 OP_ASSIGN_AP_CHK(&=)
686 OP_ASSIGN_AP_CHK(|=)
687 OP_ASSIGN_AP_CHK(^=)
688#undef OP_ASSIGN_AP_CHK
689
690 /* Prefix increment, decrement.
691 * ----------------------------------------------------------------
692 */
693 INLINE ap_int_base& operator++() {
694 operator+=((ap_int_base<1, false>)1);
695 return *this;
696 }
697 INLINE ap_int_base& operator--() {
698 operator-=((ap_int_base<1, false>)1);
699 return *this;
700 }
701
702 /* Postfix increment, decrement
703 * ----------------------------------------------------------------
704 */
705 INLINE const typename RType<_AP_W, _AP_S>::arg1 operator++(int) {
706 ap_int_base t = *this;
707 operator+=((ap_int_base<1, false>)1);
708 return t;
709 }
710 INLINE const typename RType<_AP_W, _AP_S>::arg1 operator--(int) {
711 ap_int_base t = *this;
712 operator-=((ap_int_base<1, false>)1);
713 return t;
714 }
715
716 /* Unary arithmetic.
717 * ----------------------------------------------------------------
718 */
719 INLINE typename RType<_AP_W, _AP_S>::arg1 operator+() const { return *this; }
720
721 // TODO used to be W>64 only... need check.
722 INLINE typename RType<1, false>::minus operator-() const {
723 return ap_int_base<1, false>(0) - *this;
724 }
725
726 /* Not (!)
727 * ----------------------------------------------------------------
728 */
729 INLINE bool operator!() const { return Base::V == 0; }
730
731 /* Bitwise (arithmetic) unary: complement
732 ----------------------------------------------------------------
733 */
734 // XXX different from Mentor's ac_int!
735 INLINE typename RType<_AP_W, _AP_S>::arg1 operator~() const {
736 ap_int_base<_AP_W, _AP_S> r;
737 r.V = ~Base::V;
738 return r;
739 }
740
741 /* Shift (result constrained by left operand).
742 * ----------------------------------------------------------------
743 */
744 template <int _AP_W2>
745 INLINE typename RType<_AP_W, _AP_S>::arg1 operator<<(
746 const ap_int_base<_AP_W2, true>& op2) const {
747 bool isNeg = _AP_ROOT_op_get_bit(op2.V, _AP_W2 - 1);
748 ap_int_base<_AP_W2, false> sh = op2;
749 if (isNeg) {
750 sh = -op2;
751 return operator>>(sh);
752 } else
753 return operator<<(sh);
754 }
755
756 template <int _AP_W2>
757 INLINE typename RType<_AP_W, _AP_S>::arg1 operator<<(
758 const ap_int_base<_AP_W2, false>& op2) const {
759 ap_int_base r;
760 r.V = Base::V << op2.to_uint();
761 return r;
762 }
763
764 template <int _AP_W2>
765 INLINE typename RType<_AP_W, _AP_S>::arg1 operator>>(
766 const ap_int_base<_AP_W2, true>& op2) const {
767 bool isNeg = _AP_ROOT_op_get_bit(op2.V, _AP_W2 - 1);
768 ap_int_base<_AP_W2, false> sh = op2;
769 if (isNeg) {
770 sh = -op2;
771 return operator<<(sh);
772 }
773 return operator>>(sh);
774 }
775
776 template <int _AP_W2>
777 INLINE typename RType<_AP_W, _AP_S>::arg1 operator>>(
778 const ap_int_base<_AP_W2, false>& op2) const {
779 ap_int_base r;
780 r.V = Base::V >> op2.to_uint();
781 return r;
782 }
783
784 // FIXME we standalone operator>> for ap_int_base and ap_range_ref.
785#if 0
786 template <int _AP_W2, bool _AP_S2>
787 INLINE ap_int_base operator<<(const ap_range_ref<_AP_W2, _AP_S2>& op2) const {
788 return *this << (op2.operator ap_int_base<_AP_W2, false>());
789 }
790
791 template <int _AP_W2, bool _AP_S2>
792 INLINE ap_int_base operator>>(const ap_range_ref<_AP_W2, _AP_S2>& op2) const {
793 return *this >> (op2.operator ap_int_base<_AP_W2, false>());
794 }
795#endif
796
797 /* Shift assign
798 * ----------------------------------------------------------------
799 */
800 template <int _AP_W2>
801 INLINE ap_int_base& operator<<=(const ap_int_base<_AP_W2, true>& op2) {
802 bool isNeg = _AP_ROOT_op_get_bit(op2.V, _AP_W2 - 1);
803 ap_int_base<_AP_W2, false> sh = op2;
804 if (isNeg) {
805 sh = -op2;
806 return operator>>=(sh);
807 } else
808 return operator<<=(sh);
809 }
810
811 template <int _AP_W2>
812 INLINE ap_int_base& operator<<=(const ap_int_base<_AP_W2, false>& op2) {
813 Base::V <<= op2.to_uint();
814 return *this;
815 }
816
817 template <int _AP_W2>
818 INLINE ap_int_base& operator>>=(const ap_int_base<_AP_W2, true>& op2) {
819 bool isNeg = _AP_ROOT_op_get_bit(op2.V, _AP_W2 - 1);
820 ap_int_base<_AP_W2, false> sh = op2;
821 if (isNeg) {
822 sh = -op2;
823 return operator<<=(sh);
824 }
825 return operator>>=(sh);
826 }
827
828 template <int _AP_W2>
829 INLINE ap_int_base& operator>>=(const ap_int_base<_AP_W2, false>& op2) {
830 Base::V >>= op2.to_uint();
831 return *this;
832 }
833
834 // FIXME we standalone operator>> for ap_int_base and ap_range_ref.
835#if 0
836 template <int _AP_W2, bool _AP_S2>
837 INLINE ap_int_base& operator<<=(const ap_range_ref<_AP_W2, _AP_S2>& op2) {
838 return *this <<= (op2.operator ap_int_base<_AP_W2, false>());
839 }
840 template <int _AP_W2, bool _AP_S2>
841 INLINE ap_int_base& operator>>=(const ap_range_ref<_AP_W2, _AP_S2>& op2) {
842 return *this >>= (op2.operator ap_int_base<_AP_W2, false>());
843 }
844#endif
845
846 /* Equality and Relational.
847 * ----------------------------------------------------------------
848 */
849 template <int _AP_W2, bool _AP_S2>
850 INLINE bool operator==(const ap_int_base<_AP_W2, _AP_S2>& op2) const {
851 return Base::V == op2.V;
852 }
853 template <int _AP_W2, bool _AP_S2>
854 INLINE bool operator!=(const ap_int_base<_AP_W2, _AP_S2>& op2) const {
855 return !(Base::V == op2.V);
856 }
857 template <int _AP_W2, bool _AP_S2>
858 INLINE bool operator<(const ap_int_base<_AP_W2, _AP_S2>& op2) const {
859 return Base::V < op2.V;
860 }
861 template <int _AP_W2, bool _AP_S2>
862 INLINE bool operator>=(const ap_int_base<_AP_W2, _AP_S2>& op2) const {
863 return Base::V >= op2.V;
864 }
865 template <int _AP_W2, bool _AP_S2>
866 INLINE bool operator>(const ap_int_base<_AP_W2, _AP_S2>& op2) const {
867 return Base::V > op2.V;
868 }
869 template <int _AP_W2, bool _AP_S2>
870 INLINE bool operator<=(const ap_int_base<_AP_W2, _AP_S2>& op2) const {
871 return Base::V <= op2.V;
872 }
873
874 /* Bit and Part Select
875 * ----------------------------------------------------------------
876 */
877 INLINE ap_range_ref<_AP_W, _AP_S> range(int Hi, int Lo) {
878 _AP_ERROR(Hi >= _AP_W, "Hi(%d)out of bound(%d) in range()", Hi, _AP_W);
879 _AP_ERROR(Lo >= _AP_W, "Lo(%d)out of bound(%d) in range()", Lo, _AP_W);
880 return ap_range_ref<_AP_W, _AP_S>(this, Hi, Lo);
881 }
882
883 // This is a must to strip constness to produce reference type.
884 INLINE ap_range_ref<_AP_W, _AP_S> range(int Hi, int Lo) const {
885 _AP_ERROR(Hi >= _AP_W, "Hi(%d)out of bound(%d) in range()", Hi, _AP_W);
886 _AP_ERROR(Lo >= _AP_W, "Lo(%d)out of bound(%d) in range()", Lo, _AP_W);
887 return ap_range_ref<_AP_W, _AP_S>(const_cast<ap_int_base*>(this), Hi, Lo);
888 }
889
890 template <int _AP_W2, bool _AP_S2, int _AP_W3, bool _AP_S3>
891 INLINE ap_range_ref<_AP_W, _AP_S> range(
892 const ap_int_base<_AP_W2, _AP_S2>& HiIdx,
893 const ap_int_base<_AP_W3, _AP_S3>& LoIdx) {
894 int Hi = HiIdx.to_int();
895 int Lo = LoIdx.to_int();
896 return this->range(Hi, Lo);
897 }
898
899 template <int _AP_W2, bool _AP_S2, int _AP_W3, bool _AP_S3>
900 INLINE ap_range_ref<_AP_W, _AP_S> range(
901 const ap_int_base<_AP_W2, _AP_S2>& HiIdx,
902 const ap_int_base<_AP_W3, _AP_S3>& LoIdx) const {
903 int Hi = HiIdx.to_int();
904 int Lo = LoIdx.to_int();
905 return this->range(Hi, Lo);
906 }
907
908 INLINE ap_range_ref<_AP_W, _AP_S> range() {
909 return this->range(_AP_W - 1, 0);
910 }
911
912 INLINE ap_range_ref<_AP_W, _AP_S> range() const {
913 return this->range(_AP_W - 1, 0);
914 }
915
916 INLINE ap_range_ref<_AP_W, _AP_S> operator()(int Hi, int Lo) {
917 return this->range(Hi, Lo);
918 }
919
920 INLINE ap_range_ref<_AP_W, _AP_S> operator()(int Hi, int Lo) const {
921 return this->range(Hi, Lo);
922 }
923
924 template <int _AP_W2, bool _AP_S2, int _AP_W3, bool _AP_S3>
925 INLINE ap_range_ref<_AP_W, _AP_S> operator()(
926 const ap_int_base<_AP_W2, _AP_S2>& HiIdx,
927 const ap_int_base<_AP_W3, _AP_S3>& LoIdx) {
928 int Hi = HiIdx.to_int();
929 int Lo = LoIdx.to_int();
930 return this->range(Hi, Lo);
931 }
932
933 template <int _AP_W2, bool _AP_S2, int _AP_W3, bool _AP_S3>
934 INLINE ap_range_ref<_AP_W, _AP_S> operator()(
935 const ap_int_base<_AP_W2, _AP_S2>& HiIdx,
936 const ap_int_base<_AP_W3, _AP_S3>& LoIdx) const {
937 int Hi = HiIdx.to_int();
938 int Lo = LoIdx.to_int();
939 return this->range(Hi, Lo);
940 }
941
942#if 0
943 template<int Hi, int Lo>
944 INLINE ap_int_base<Hi-Lo+1, false> slice() const {
945 AP_ASSERT(Hi >= Lo && Hi < _AP_W && Lo < _AP_W, "Out of bounds in slice()");
946 ap_int_base<Hi-Lo+1, false> tmp ;
947 tmp.V = _AP_ROOT_op_get_range(Base::V, Lo, Hi);
948 return tmp;
949 }
950
951 INLINE ap_bit_ref<_AP_W,_AP_S> operator [] ( unsigned int uindex) {
952 AP_ASSERT(uindex < _AP_W, "Attempting to read bit beyond MSB");
953 ap_bit_ref<_AP_W,_AP_S> bvh( this, uindex );
954 return bvh;
955 }
956#endif
957
958 INLINE ap_bit_ref<_AP_W, _AP_S> operator[](int index) {
959 AP_ASSERT(index >= 0, "Attempting to read bit with negative index");
960 AP_ASSERT(index < _AP_W, "Attempting to read bit beyond MSB");
961 ap_bit_ref<_AP_W, _AP_S> bvh(this, index);
962 return bvh;
963 }
964
965 template <int _AP_W2, bool _AP_S2>
966 INLINE ap_bit_ref<_AP_W, _AP_S> operator[](
967 const ap_int_base<_AP_W2, _AP_S2>& index) {
968 AP_ASSERT(index >= 0, "Attempting to read bit with negative index");
969 AP_ASSERT(index < _AP_W, "Attempting to read bit beyond MSB");
970 ap_bit_ref<_AP_W, _AP_S> bvh(this, index.to_int());
971 return bvh;
972 }
973
974 INLINE bool operator[](int index) const {
975 AP_ASSERT(index >= 0, "Attempting to read bit with negative index");
976 AP_ASSERT(index < _AP_W, "Attempting to read bit beyond MSB");
977 ap_bit_ref<_AP_W, _AP_S> br(this, index);
978 return br.to_bool();
979 }
980 template <int _AP_W2, bool _AP_S2>
981 INLINE bool operator[](const ap_int_base<_AP_W2, _AP_S2>& index) const {
982 AP_ASSERT(index < _AP_W, "Attempting to read bit beyond MSB");
983 ap_bit_ref<_AP_W, _AP_S> br(this, index.to_int());
984 return br.to_bool();
985 }
986
987 INLINE ap_bit_ref<_AP_W, _AP_S> bit(int index) {
988 AP_ASSERT(index >= 0, "Attempting to read bit with negative index");
989 AP_ASSERT(index < _AP_W, "Attempting to read bit beyond MSB");
990 ap_bit_ref<_AP_W, _AP_S> bvh(this, index);
991 return bvh;
992 }
993 template <int _AP_W2, bool _AP_S2>
994 INLINE ap_bit_ref<_AP_W, _AP_S> bit(
995 const ap_int_base<_AP_W2, _AP_S2>& index) {
996 AP_ASSERT(index >= 0, "Attempting to read bit with negative index");
997 AP_ASSERT(index < _AP_W, "Attempting to read bit beyond MSB");
998 ap_bit_ref<_AP_W, _AP_S> bvh(this, index.to_int());
999 return bvh;
1000 }
1001
1002 INLINE bool bit(int index) const {
1003 AP_ASSERT(index >= 0, "Attempting to read bit with negative index");
1004 AP_ASSERT(index < _AP_W, "Attempting to read bit beyond MSB");
1005 ap_bit_ref<_AP_W, _AP_S> br(this, index);
1006 return br.to_bool();
1007 }
1008
1009 template <int _AP_W2, bool _AP_S2>
1010 INLINE bool bit(const ap_int_base<_AP_W2, _AP_S2>& index) const {
1011 return bit(index.to_int());
1012 }
1013
1014#if 0
1015 template<typename _AP_T>
1016 INLINE bool operator[](_AP_T index) const {
1017 AP_ASSERT(index < _AP_W, "Attempting to read bit beyond MSB");
1018 ap_bit_ref<_AP_W,_AP_S> br = operator[](index);
1019 return br.to_bool();
1020 }
1021#endif
1022
1023 // Count the number of zeros from the most significant bit
1024 // to the first one bit.
1025 INLINE int countLeadingZeros() {
1026#ifdef __SYNTHESIS__
1027 if (_AP_W <= 32) {
1028 ap_int_base<32, false> t(-1UL), x;
1029 x.V = _AP_ROOT_op_get_range(this->V, _AP_W - 1, 0); // reverse
1030 t.V = _AP_ROOT_op_set_range(t.V, 0, _AP_W - 1, x.V);
1031 return __builtin_ctz(t.V); // count trailing zeros.
1032 } else if (_AP_W <= 64) {
1033 ap_int_base<64, false> t(-1ULL);
1034 ap_int_base<64, false> x;
1035 x.V = _AP_ROOT_op_get_range(this->V, _AP_W - 1, 0); // reverse
1036 t.V = _AP_ROOT_op_set_range(t.V, 0, _AP_W - 1, x.V);
1037 return __builtin_ctzll(t.V); // count trailing zeros.
1038 } else {
1039 enum {__N = (_AP_W + 63) / 64};
1040 int NZeros = 0;
1041 int i = 0;
1042 bool hitNonZero = false;
1043 for (i = 0; i < __N - 1; ++i) {
1044 ap_int_base<64, false> t;
1045 t.V = _AP_ROOT_op_get_range(this->V, _AP_W - i * 64 - 64,
1046 _AP_W - i * 64 - 1);
1047 NZeros +=
1048 hitNonZero ? 0 : __builtin_clzll(t.V); // count leading zeros.
1049 hitNonZero |= (t.V != 0);
1050 }
1051 if (!hitNonZero) {
1052 ap_int_base<64, false> t(-1ULL);
1053 enum {REST = (_AP_W - 1) % 64};
1054 ap_int_base<64, false> x;
1055 x.V = _AP_ROOT_op_get_range(this->V, 0, REST);
1056 t.V = _AP_ROOT_op_set_range(t.V, 63 - REST, 63, x.V);
1057 NZeros += __builtin_clzll(t.V);
1058 }
1059 return NZeros;
1060 }
1061#else
1062 return (Base::V).countLeadingZeros();
1063#endif
1064 } // countLeadingZeros
1065
1066 template <int _AP_W2, bool _AP_S2>
1067 INLINE ap_concat_ref<_AP_W, ap_int_base, _AP_W2, ap_int_base<_AP_W2, _AP_S2> >
1068 concat(const ap_int_base<_AP_W2, _AP_S2>& a2) const {
1069 return ap_concat_ref<_AP_W, ap_int_base, _AP_W2,
1070 ap_int_base<_AP_W2, _AP_S2> >(
1071 const_cast<ap_int_base<_AP_W, _AP_S>&>(*this),
1072 const_cast<ap_int_base<_AP_W2, _AP_S2>&>(a2));
1073 }
1074
1075 template <int _AP_W2, bool _AP_S2>
1076 INLINE ap_concat_ref<_AP_W, ap_int_base, _AP_W2, ap_int_base<_AP_W2, _AP_S2> >
1077 concat(ap_int_base<_AP_W2, _AP_S2>& a2) {
1078 return ap_concat_ref<_AP_W, ap_int_base, _AP_W2,
1079 ap_int_base<_AP_W2, _AP_S2> >(*this, a2);
1080 }
1081
1082 template <int _AP_W2, bool _AP_S2>
1083 INLINE
1084 ap_concat_ref<_AP_W, ap_int_base, _AP_W2, ap_range_ref<_AP_W2, _AP_S2> >
1085 operator,(const ap_range_ref<_AP_W2, _AP_S2>& a2) const {
1086 return ap_concat_ref<_AP_W, ap_int_base, _AP_W2,
1087 ap_range_ref<_AP_W2, _AP_S2> >(
1088 const_cast<ap_int_base<_AP_W, _AP_S>&>(*this),
1089 const_cast<ap_range_ref<_AP_W2, _AP_S2>&>(a2));
1090 }
1091
1092 template <int _AP_W2, bool _AP_S2>
1093 INLINE
1094 ap_concat_ref<_AP_W, ap_int_base, _AP_W2, ap_range_ref<_AP_W2, _AP_S2> >
1095 operator,(ap_range_ref<_AP_W2, _AP_S2>& a2) {
1096 return ap_concat_ref<_AP_W, ap_int_base, _AP_W2,
1097 ap_range_ref<_AP_W2, _AP_S2> >(*this, a2);
1098 }
1099
1100 template <int _AP_W2, bool _AP_S2>
1101 INLINE ap_concat_ref<_AP_W, ap_int_base, _AP_W2, ap_int_base<_AP_W2, _AP_S2> >
1102 operator,(const ap_int_base<_AP_W2, _AP_S2>& a2) {
1103 return ap_concat_ref<_AP_W, ap_int_base, _AP_W2,
1104 ap_int_base<_AP_W2, _AP_S2> >(
1105 *this, const_cast<ap_int_base<_AP_W2, _AP_S2>&>(a2));
1106 }
1107
1108 template <int _AP_W2, bool _AP_S2>
1109 INLINE ap_concat_ref<_AP_W, ap_int_base, _AP_W2, ap_int_base<_AP_W2, _AP_S2> >
1110 operator,(ap_int_base<_AP_W2, _AP_S2>& a2) const {
1111 return ap_concat_ref<_AP_W, ap_int_base, _AP_W2,
1112 ap_int_base<_AP_W2, _AP_S2> >(
1113 const_cast<ap_int_base<_AP_W, _AP_S>&>(*this), a2);
1114 }
1115
1116 template <int _AP_W2, bool _AP_S2>
1117 INLINE ap_concat_ref<_AP_W, ap_int_base, _AP_W2, ap_int_base<_AP_W2, _AP_S2> >
1118 operator,(const ap_int_base<_AP_W2, _AP_S2>& a2) const {
1119 return ap_concat_ref<_AP_W, ap_int_base, _AP_W2,
1120 ap_int_base<_AP_W2, _AP_S2> >(
1121 const_cast<ap_int_base<_AP_W, _AP_S>&>(*this),
1122 const_cast<ap_int_base<_AP_W2, _AP_S2>&>(a2));
1123 }
1124
1125 template <int _AP_W2, bool _AP_S2>
1126 INLINE ap_concat_ref<_AP_W, ap_int_base, _AP_W2, ap_int_base<_AP_W2, _AP_S2> >
1127 operator,(ap_int_base<_AP_W2, _AP_S2>& a2) {
1128 return ap_concat_ref<_AP_W, ap_int_base, _AP_W2,
1129 ap_int_base<_AP_W2, _AP_S2> >(*this, a2);
1130 }
1131
1132 template <int _AP_W2, bool _AP_S2>
1133 INLINE ap_concat_ref<_AP_W, ap_int_base, 1, ap_bit_ref<_AP_W2, _AP_S2> >
1134 operator,(const ap_bit_ref<_AP_W2, _AP_S2>& a2) const {
1135 return ap_concat_ref<_AP_W, ap_int_base, 1, ap_bit_ref<_AP_W2, _AP_S2> >(
1136 const_cast<ap_int_base<_AP_W, _AP_S>&>(*this),
1137 const_cast<ap_bit_ref<_AP_W2, _AP_S2>&>(a2));
1138 }
1139
1140 template <int _AP_W2, bool _AP_S2>
1141 INLINE ap_concat_ref<_AP_W, ap_int_base, 1, ap_bit_ref<_AP_W2, _AP_S2> >
1142 operator,(ap_bit_ref<_AP_W2, _AP_S2>& a2) {
1143 return ap_concat_ref<_AP_W, ap_int_base, 1, ap_bit_ref<_AP_W2, _AP_S2> >(
1144 *this, a2);
1145 }
1146
1147 template <int _AP_W2, typename _AP_T2, int _AP_W3, typename _AP_T3>
1148 INLINE ap_concat_ref<_AP_W, ap_int_base, _AP_W2 + _AP_W3,
1149 ap_concat_ref<_AP_W2, _AP_T2, _AP_W3, _AP_T3> >
1150 operator,(const ap_concat_ref<_AP_W2, _AP_T2, _AP_W3, _AP_T3>& a2) {
1151 return ap_concat_ref<_AP_W, ap_int_base, _AP_W2 + _AP_W3,
1152 ap_concat_ref<_AP_W2, _AP_T2, _AP_W3, _AP_T3> >(
1153 const_cast<ap_int_base<_AP_W, _AP_S>&>(*this),
1154 const_cast<ap_concat_ref<_AP_W2, _AP_T2, _AP_W3, _AP_T3>&>(a2));
1155 }
1156
1157 template <int _AP_W2, typename _AP_T2, int _AP_W3, typename _AP_T3>
1158 INLINE ap_concat_ref<_AP_W, ap_int_base, _AP_W2 + _AP_W3,
1159 ap_concat_ref<_AP_W2, _AP_T2, _AP_W3, _AP_T3> >
1160 operator,(ap_concat_ref<_AP_W2, _AP_T2, _AP_W3, _AP_T3>& a2) {
1161 return ap_concat_ref<_AP_W, ap_int_base, _AP_W2 + _AP_W3,
1162 ap_concat_ref<_AP_W2, _AP_T2, _AP_W3, _AP_T3> >(*this,
1163 a2);
1164 }
1165
1166 template <int _AP_W2, int _AP_I2, bool _AP_S2, ap_q_mode _AP_Q2,
1167 ap_o_mode _AP_O2, int _AP_N2>
1168 INLINE ap_concat_ref<
1169 _AP_W, ap_int_base, _AP_W2,
1170 af_range_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2> >
1171 operator,(const af_range_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2>
1172 & a2) const {
1173 return ap_concat_ref<
1174 _AP_W, ap_int_base, _AP_W2,
1175 af_range_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2> >(
1176 const_cast<ap_int_base<_AP_W, _AP_S>&>(*this),
1177 const_cast<
1178 af_range_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2>&>(a2));
1179 }
1180
1181 template <int _AP_W2, int _AP_I2, bool _AP_S2, ap_q_mode _AP_Q2,
1182 ap_o_mode _AP_O2, int _AP_N2>
1183 INLINE ap_concat_ref<
1184 _AP_W, ap_int_base, _AP_W2,
1185 af_range_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2> >
1186 operator,(af_range_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2>& a2) {
1187 return ap_concat_ref<
1188 _AP_W, ap_int_base, _AP_W2,
1189 af_range_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2> >(*this,
1190 a2);
1191 }
1192
1193 template <int _AP_W2, int _AP_I2, bool _AP_S2, ap_q_mode _AP_Q2,
1194 ap_o_mode _AP_O2, int _AP_N2>
1195 INLINE
1196 ap_concat_ref<_AP_W, ap_int_base, 1,
1197 af_bit_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2> >
1198 operator,(const af_bit_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2>
1199 & a2) const {
1200 return ap_concat_ref<
1201 _AP_W, ap_int_base, 1,
1202 af_bit_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2> >(
1203 const_cast<ap_int_base<_AP_W, _AP_S>&>(*this),
1204 const_cast<af_bit_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2>&>(
1205 a2));
1206 }
1207
1208 template <int _AP_W2, int _AP_I2, bool _AP_S2, ap_q_mode _AP_Q2,
1209 ap_o_mode _AP_O2, int _AP_N2>
1210 INLINE
1211 ap_concat_ref<_AP_W, ap_int_base, 1,
1212 af_bit_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2> >
1213 operator,(
1214 af_bit_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2>& a2) {
1215 return ap_concat_ref<
1216 _AP_W, ap_int_base, 1,
1217 af_bit_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2> >(*this, a2);
1218 }
1219
1220 template <int _AP_W2, typename _AP_T2, int _AP_W3, typename _AP_T3>
1221 INLINE ap_int_base<AP_MAX(_AP_W2 + _AP_W3, _AP_W), _AP_S> operator&(
1222 const ap_concat_ref<_AP_W2, _AP_T2, _AP_W3, _AP_T3>& a2) {
1223 return *this & a2.get();
1224 }
1225
1226 template <int _AP_W2, typename _AP_T2, int _AP_W3, typename _AP_T3>
1227 INLINE ap_int_base<AP_MAX(_AP_W2 + _AP_W3, _AP_W), _AP_S> operator|(
1228 const ap_concat_ref<_AP_W2, _AP_T2, _AP_W3, _AP_T3>& a2) {
1229 return *this | a2.get();
1230 }
1231
1232 template <int _AP_W2, typename _AP_T2, int _AP_W3, typename _AP_T3>
1233 INLINE ap_int_base<AP_MAX(_AP_W2 + _AP_W3, _AP_W), _AP_S> operator^(
1234 const ap_concat_ref<_AP_W2, _AP_T2, _AP_W3, _AP_T3>& a2) {
1235 return *this ^ a2.get();
1236 }
1237
1238 template <int _AP_W3>
1239 INLINE void set(const ap_int_base<_AP_W3, false>& val) {
1240 Base::V = val.V;
1241 }
1242
1243 /* Reduce operations.
1244 * ----------------------------------------------------------------
1245 */
1246 // XXX non-const version deleted.
1247 INLINE bool and_reduce() const { return _AP_ROOT_op_reduce(and, Base::V); }
1248 INLINE bool nand_reduce() const { return _AP_ROOT_op_reduce(nand, Base::V); }
1249 INLINE bool or_reduce() const { return _AP_ROOT_op_reduce(or, Base::V); }
1250 INLINE bool nor_reduce() const { return !(_AP_ROOT_op_reduce(or, Base::V)); }
1251 INLINE bool xor_reduce() const { return _AP_ROOT_op_reduce(xor, Base::V); }
1252 INLINE bool xnor_reduce() const {
1253 return !(_AP_ROOT_op_reduce(xor, Base::V));
1254 }
1255
1256 /* Output as a string.
1257 * ----------------------------------------------------------------
1258 */
1259#ifndef __SYNTHESIS__
1260 std::string to_string(signed char rd = 2, bool sign = _AP_S) const {
1261 // XXX in autosim/autowrap.tcl "(${name}).to_string(2).c_str()" is used to
1262 // initialize sc_lv, which seems incapable of handling format "-0b".
1263 if (rd == 2) sign = false;
1264 return (Base::V).to_string(rd, sign);
1265 }
1266#else
1267 INLINE char* to_string(signed char rd = 2, bool sign = _AP_S) const {
1268 return 0;
1269 }
1270#endif
1271}; // struct ap_int_base
1272
1273// XXX apcc cannot handle global std::ios_base::Init() brought in by <iostream>
1274#ifndef AP_AUTOCC
1275#ifndef __SYNTHESIS__
1276template <int _AP_W, bool _AP_S>
1277INLINE std::ostream& operator<<(std::ostream& os,
1278 const ap_int_base<_AP_W, _AP_S>& x) {
1279 std::ios_base::fmtflags ff = std::cout.flags();
1280 if (ff & std::cout.hex) {
1281 os << x.to_string(16); // don't print sign
1282 } else if (ff & std::cout.oct) {
1283 os << x.to_string(8); // don't print sign
1284 } else {
1285 os << x.to_string(10);
1286 }
1287 return os;
1288}
1289#endif // ifndef __SYNTHESIS__
1290
1291#ifndef __SYNTHESIS__
1292template <int _AP_W, bool _AP_S>
1293INLINE std::istream& operator>>(std::istream& in,
1294 ap_int_base<_AP_W, _AP_S>& op) {
1295 std::string str;
1296 in >> str;
1297 const std::ios_base::fmtflags basefield =
1298 in.flags() & std::ios_base::basefield;
1299 unsigned radix = (basefield == std::ios_base::dec)
1300 ? 0
1301 : ((basefield == std::ios_base::oct)
1302 ? 8
1303 : ((basefield == std::ios_base::hex) ? 16 : 0));
1304 op = ap_int_base<_AP_W, _AP_S>(str.c_str(), radix);
1305 return in;
1306}
1307#endif // ifndef __SYNTHESIS__
1308#endif // ifndef AP_AUTOCC
1309
1310/* Operators with another ap_int_base.
1311 * ----------------------------------------------------------------
1312 */
1313#define OP_BIN_AP(Sym, Rty) \
1314 template <int _AP_W, bool _AP_S, int _AP_W2, bool _AP_S2> \
1315 INLINE \
1316 typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_W2, _AP_S2>::Rty \
1317 operator Sym(const ap_int_base<_AP_W, _AP_S>& op, \
1318 const ap_int_base<_AP_W2, _AP_S2>& op2) { \
1319 typename ap_int_base<_AP_W, _AP_S>::template RType< \
1320 _AP_W2, _AP_S2>::Rty##_base lhs(op); \
1321 typename ap_int_base<_AP_W, _AP_S>::template RType< \
1322 _AP_W2, _AP_S2>::Rty##_base rhs(op2); \
1323 typename ap_int_base<_AP_W, _AP_S>::template RType< \
1324 _AP_W2, _AP_S2>::Rty##_base ret; \
1325 ret.V = lhs.V Sym rhs.V; \
1326 return ret; \
1327 }
1328
1329OP_BIN_AP(*, mult)
1330OP_BIN_AP(+, plus)
1331OP_BIN_AP(-, minus)
1332OP_BIN_AP(&, logic)
1333OP_BIN_AP(|, logic)
1334OP_BIN_AP(^, logic)
1335
1336#define OP_BIN_AP2(Sym, Rty) \
1337 template <int _AP_W, bool _AP_S, int _AP_W2, bool _AP_S2> \
1338 INLINE \
1339 typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_W2, _AP_S2>::Rty \
1340 operator Sym(const ap_int_base<_AP_W, _AP_S>& op, \
1341 const ap_int_base<_AP_W2, _AP_S2>& op2) { \
1342 typename ap_int_base<_AP_W, _AP_S>::template RType< \
1343 _AP_W2, _AP_S2>::Rty##_base ret; \
1344 ret.V = op.V Sym op2.V; \
1345 return ret; \
1346 }
1347
1348OP_BIN_AP2(/, div)
1349OP_BIN_AP2(%, mod)
1350
1351// shift operators are defined inside class.
1352// compound assignment operators are defined inside class.
1353
1354/* Operators with a pointer type.
1355 * ----------------------------------------------------------------
1356 * char a[100];
1357 * char* ptr = a;
1358 * ap_int<2> n = 3;
1359 * char* ptr2 = ptr + n*2;
1360 * avoid ambiguous errors.
1361 */
1362#define OP_BIN_WITH_PTR(BIN_OP) \
1363 template <typename PTR_TYPE, int _AP_W, bool _AP_S> \
1364 INLINE PTR_TYPE* operator BIN_OP(PTR_TYPE * i_op, \
1365 const ap_int_base<_AP_W, _AP_S>& op) { \
1366 ap_slong op2 = op.to_int64(); /* Not all implementation */ \
1367 return i_op BIN_OP op2; \
1368 } \
1369 template <typename PTR_TYPE, int _AP_W, bool _AP_S> \
1370 INLINE PTR_TYPE* operator BIN_OP(const ap_int_base<_AP_W, _AP_S>& op, \
1371 PTR_TYPE * i_op) { \
1372 ap_slong op2 = op.to_int64(); /* Not all implementation */ \
1373 return op2 BIN_OP i_op; \
1374 }
1375
1376OP_BIN_WITH_PTR(+)
1377OP_BIN_WITH_PTR(-)
1378
1379/* Operators with a native floating point types.
1380 * ----------------------------------------------------------------
1381 */
1382// float OP ap_int
1383// when ap_int<wa>'s width > 64, then trunc ap_int<w> to ap_int<64>
1384#define OP_BIN_WITH_FLOAT(BIN_OP, C_TYPE) \
1385 template <int _AP_W, bool _AP_S> \
1386 INLINE C_TYPE operator BIN_OP(C_TYPE i_op, \
1387 const ap_int_base<_AP_W, _AP_S>& op) { \
1388 typename ap_int_base<_AP_W, _AP_S>::RetType op2 = op; \
1389 return i_op BIN_OP op2; \
1390 } \
1391 template <int _AP_W, bool _AP_S> \
1392 INLINE C_TYPE operator BIN_OP(const ap_int_base<_AP_W, _AP_S>& op, \
1393 C_TYPE i_op) { \
1394 typename ap_int_base<_AP_W, _AP_S>::RetType op2 = op; \
1395 return op2 BIN_OP i_op; \
1396 }
1397
1398#define ALL_OP_WITH_FLOAT(C_TYPE) \
1399 OP_BIN_WITH_FLOAT(*, C_TYPE) \
1400 OP_BIN_WITH_FLOAT(/, C_TYPE) \
1401 OP_BIN_WITH_FLOAT(+, C_TYPE) \
1402 OP_BIN_WITH_FLOAT(-, C_TYPE)
1403
1404#if _AP_ENABLE_HALF_ == 1
1405ALL_OP_WITH_FLOAT(half)
1406#endif
1407ALL_OP_WITH_FLOAT(float)
1408ALL_OP_WITH_FLOAT(double)
1409
1410// TODO no shift?
1411
1412/* Operators with a native integral types.
1413 * ----------------------------------------------------------------
1414 */
1415// arithmetic and bitwise operators.
1416#define OP_BIN_WITH_INT(BIN_OP, C_TYPE, _AP_W2, _AP_S2, RTYPE) \
1417 template <int _AP_W, bool _AP_S> \
1418 INLINE typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_W2, \
1419 _AP_S2>::RTYPE \
1420 operator BIN_OP(C_TYPE i_op, const ap_int_base<_AP_W, _AP_S>& op) { \
1421 return ap_int_base<_AP_W2, _AP_S2>(i_op) BIN_OP(op); \
1422 } \
1423 template <int _AP_W, bool _AP_S> \
1424 INLINE typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_W2, \
1425 _AP_S2>::RTYPE \
1426 operator BIN_OP(const ap_int_base<_AP_W, _AP_S>& op, C_TYPE i_op) { \
1427 return op BIN_OP ap_int_base<_AP_W2, _AP_S2>(i_op); \
1428 }
1429
1430#define ALL_OP_BIN_WITH_INT(C_TYPE, _AP_W2, _AP_S2) \
1431 OP_BIN_WITH_INT(*, C_TYPE, _AP_W2, _AP_S2, mult) \
1432 OP_BIN_WITH_INT(+, C_TYPE, _AP_W2, _AP_S2, plus) \
1433 OP_BIN_WITH_INT(-, C_TYPE, _AP_W2, _AP_S2, minus) \
1434 OP_BIN_WITH_INT(/, C_TYPE, _AP_W2, _AP_S2, div) \
1435 OP_BIN_WITH_INT(%, C_TYPE, _AP_W2, _AP_S2, mod) \
1436 OP_BIN_WITH_INT(&, C_TYPE, _AP_W2, _AP_S2, logic) \
1437 OP_BIN_WITH_INT(|, C_TYPE, _AP_W2, _AP_S2, logic) \
1438 OP_BIN_WITH_INT(^, C_TYPE, _AP_W2, _AP_S2, logic)
1439
1440ALL_OP_BIN_WITH_INT(bool, 1, false)
1441ALL_OP_BIN_WITH_INT(char, 8, CHAR_IS_SIGNED)
1442ALL_OP_BIN_WITH_INT(signed char, 8, true)
1443ALL_OP_BIN_WITH_INT(unsigned char, 8, false)
1444ALL_OP_BIN_WITH_INT(short, _AP_SIZE_short, true)
1445ALL_OP_BIN_WITH_INT(unsigned short, _AP_SIZE_short, false)
1446ALL_OP_BIN_WITH_INT(int, _AP_SIZE_int, true)
1447ALL_OP_BIN_WITH_INT(unsigned int, _AP_SIZE_int, false)
1448ALL_OP_BIN_WITH_INT(long, _AP_SIZE_long, true)
1449ALL_OP_BIN_WITH_INT(unsigned long, _AP_SIZE_long, false)
1450ALL_OP_BIN_WITH_INT(ap_slong, _AP_SIZE_ap_slong, true)
1451ALL_OP_BIN_WITH_INT(ap_ulong, _AP_SIZE_ap_slong, false)
1452
1453#undef OP_BIN_WITH_INT
1454#undef ALL_OP_BIN_WITH_INT
1455
1456// shift operators.
1457#define ALL_OP_SHIFT_WITH_INT(C_TYPE, _AP_W2, _AP_S2) \
1458 template <int _AP_W, bool _AP_S> \
1459 INLINE \
1460 typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_W, _AP_S>::arg1 \
1461 operator<<(const ap_int_base<_AP_W, _AP_S>& op, C_TYPE op2) { \
1462 ap_int_base<_AP_W, _AP_S> r; \
1463 if (_AP_S2) \
1464 r.V = op2 >= 0 ? (op.V << op2) : (op.V >> (-op2)); \
1465 else \
1466 r.V = op.V << op2; \
1467 return r; \
1468 } \
1469 template <int _AP_W, bool _AP_S> \
1470 INLINE \
1471 typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_W, _AP_S>::arg1 \
1472 operator>>(const ap_int_base<_AP_W, _AP_S>& op, C_TYPE op2) { \
1473 ap_int_base<_AP_W, _AP_S> r; \
1474 if (_AP_S2) \
1475 r.V = op2 >= 0 ? (op.V >> op2) : (op.V << (-op2)); \
1476 else \
1477 r.V = op.V >> op2; \
1478 return r; \
1479 }
1480
1481ALL_OP_SHIFT_WITH_INT(char, 8, CHAR_IS_SIGNED)
1482ALL_OP_SHIFT_WITH_INT(signed char, 8, true)
1483ALL_OP_SHIFT_WITH_INT(short, _AP_SIZE_short, true)
1484ALL_OP_SHIFT_WITH_INT(int, _AP_SIZE_int, true)
1485ALL_OP_SHIFT_WITH_INT(long, _AP_SIZE_long, true)
1486ALL_OP_SHIFT_WITH_INT(ap_slong, _AP_SIZE_ap_slong, true)
1487
1488#undef ALL_OP_SHIFT_WITH_INT
1489
1490#define ALL_OP_SHIFT_WITH_INT(C_TYPE, _AP_W2, _AP_S2) \
1491 template <int _AP_W, bool _AP_S> \
1492 INLINE \
1493 typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_W, _AP_S>::arg1 \
1494 operator<<(const ap_int_base<_AP_W, _AP_S>& op, C_TYPE op2) { \
1495 ap_int_base<_AP_W, _AP_S> r; \
1496 r.V = op.V << op2; \
1497 return r; \
1498 } \
1499 template <int _AP_W, bool _AP_S> \
1500 INLINE \
1501 typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_W, _AP_S>::arg1 \
1502 operator>>(const ap_int_base<_AP_W, _AP_S>& op, C_TYPE op2) { \
1503 ap_int_base<_AP_W, _AP_S> r; \
1504 r.V = op.V >> op2; \
1505 return r; \
1506 }
1507ALL_OP_SHIFT_WITH_INT(bool, 1, false)
1508ALL_OP_SHIFT_WITH_INT(unsigned char, 8, false)
1509ALL_OP_SHIFT_WITH_INT(unsigned short, _AP_SIZE_short, false)
1510ALL_OP_SHIFT_WITH_INT(unsigned int, _AP_SIZE_int, false)
1511ALL_OP_SHIFT_WITH_INT(unsigned long, _AP_SIZE_long, false)
1512ALL_OP_SHIFT_WITH_INT(ap_ulong, _AP_SIZE_ap_slong, false)
1513
1514#undef ALL_OP_SHIFT_WITH_INT
1515
1516// compound assign operators.
1517#define OP_ASSIGN_WITH_INT(ASSIGN_OP, C_TYPE, _AP_W2, _AP_S2) \
1518 template <int _AP_W, bool _AP_S> \
1519 INLINE ap_int_base<_AP_W, _AP_S>& operator ASSIGN_OP( \
1520 ap_int_base<_AP_W, _AP_S>& op, C_TYPE op2) { \
1521 return op ASSIGN_OP ap_int_base<_AP_W2, _AP_S2>(op2); \
1522 }
1523
1524// TODO int a; ap_int<16> b; a += b;
1525
1526#define ALL_OP_ASSIGN_WITH_INT(C_TYPE, _AP_W2, _AP_S2) \
1527 OP_ASSIGN_WITH_INT(+=, C_TYPE, _AP_W2, _AP_S2) \
1528 OP_ASSIGN_WITH_INT(-=, C_TYPE, _AP_W2, _AP_S2) \
1529 OP_ASSIGN_WITH_INT(*=, C_TYPE, _AP_W2, _AP_S2) \
1530 OP_ASSIGN_WITH_INT(/=, C_TYPE, _AP_W2, _AP_S2) \
1531 OP_ASSIGN_WITH_INT(%=, C_TYPE, _AP_W2, _AP_S2) \
1532 OP_ASSIGN_WITH_INT(&=, C_TYPE, _AP_W2, _AP_S2) \
1533 OP_ASSIGN_WITH_INT(|=, C_TYPE, _AP_W2, _AP_S2) \
1534 OP_ASSIGN_WITH_INT(^=, C_TYPE, _AP_W2, _AP_S2) \
1535 OP_ASSIGN_WITH_INT(>>=, C_TYPE, _AP_W2, _AP_S2) \
1536 OP_ASSIGN_WITH_INT(<<=, C_TYPE, _AP_W2, _AP_S2)
1537
1538ALL_OP_ASSIGN_WITH_INT(bool, 1, false)
1539ALL_OP_ASSIGN_WITH_INT(char, 8, CHAR_IS_SIGNED)
1540ALL_OP_ASSIGN_WITH_INT(signed char, 8, true)
1541ALL_OP_ASSIGN_WITH_INT(unsigned char, 8, false)
1542ALL_OP_ASSIGN_WITH_INT(short, _AP_SIZE_short, true)
1543ALL_OP_ASSIGN_WITH_INT(unsigned short, _AP_SIZE_short, false)
1544ALL_OP_ASSIGN_WITH_INT(int, _AP_SIZE_int, true)
1545ALL_OP_ASSIGN_WITH_INT(unsigned int, _AP_SIZE_int, false)
1546ALL_OP_ASSIGN_WITH_INT(long, _AP_SIZE_long, true)
1547ALL_OP_ASSIGN_WITH_INT(unsigned long, _AP_SIZE_long, false)
1548ALL_OP_ASSIGN_WITH_INT(ap_slong, _AP_SIZE_ap_slong, true)
1549ALL_OP_ASSIGN_WITH_INT(ap_ulong, _AP_SIZE_ap_slong, false)
1550
1551#undef OP_ASSIGN_WITH_INT
1552#undef ALL_OP_ASSIGN_WITH_INT
1553
1554// equality and relational operators.
1555#define OP_REL_WITH_INT(REL_OP, C_TYPE, _AP_W2, _AP_S2) \
1556 template <int _AP_W, bool _AP_S> \
1557 INLINE bool operator REL_OP(C_TYPE i_op, \
1558 const ap_int_base<_AP_W, _AP_S>& op) { \
1559 return ap_int_base<_AP_W2, _AP_S2>(i_op) REL_OP op; \
1560 } \
1561 template <int _AP_W, bool _AP_S> \
1562 INLINE bool operator REL_OP(const ap_int_base<_AP_W, _AP_S>& op, \
1563 C_TYPE op2) { \
1564 return op REL_OP ap_int_base<_AP_W2, _AP_S2>(op2); \
1565 }
1566
1567#define ALL_OP_REL_WITH_INT(C_TYPE, _AP_W2, _AP_S2) \
1568 OP_REL_WITH_INT(>, C_TYPE, _AP_W2, _AP_S2) \
1569 OP_REL_WITH_INT(<, C_TYPE, _AP_W2, _AP_S2) \
1570 OP_REL_WITH_INT(>=, C_TYPE, _AP_W2, _AP_S2) \
1571 OP_REL_WITH_INT(<=, C_TYPE, _AP_W2, _AP_S2) \
1572 OP_REL_WITH_INT(==, C_TYPE, _AP_W2, _AP_S2) \
1573 OP_REL_WITH_INT(!=, C_TYPE, _AP_W2, _AP_S2)
1574
1575ALL_OP_REL_WITH_INT(bool, 1, false)
1576ALL_OP_REL_WITH_INT(char, 8, CHAR_IS_SIGNED)
1577ALL_OP_REL_WITH_INT(signed char, 8, true)
1578ALL_OP_REL_WITH_INT(unsigned char, 8, false)
1579ALL_OP_REL_WITH_INT(short, _AP_SIZE_short, true)
1580ALL_OP_REL_WITH_INT(unsigned short, _AP_SIZE_short, false)
1581ALL_OP_REL_WITH_INT(int, _AP_SIZE_int, true)
1582ALL_OP_REL_WITH_INT(unsigned int, _AP_SIZE_int, false)
1583ALL_OP_REL_WITH_INT(long, _AP_SIZE_long, true)
1584ALL_OP_REL_WITH_INT(unsigned long, _AP_SIZE_long, false)
1585ALL_OP_REL_WITH_INT(ap_slong, _AP_SIZE_ap_slong, true)
1586ALL_OP_REL_WITH_INT(ap_ulong, _AP_SIZE_ap_slong, false)
1587
1588#undef OP_REL_WITH_INT
1589#undef ALL_OP_BIN_WITH_INT
1590
1591#define OP_REL_WITH_DOUBLE_OR_FLOAT(Sym) \
1592 template <int _AP_W, bool _AP_S> \
1593 INLINE bool operator Sym(const ap_int_base<_AP_W, _AP_S>& op1, double op2) { \
1594 return op1.to_double() Sym op2; \
1595 } \
1596 template <int _AP_W, bool _AP_S> \
1597 INLINE bool operator Sym(double op1, const ap_int_base<_AP_W, _AP_S>& op2) { \
1598 return op1 Sym op2.to_double(); \
1599 } \
1600 template <int _AP_W, bool _AP_S> \
1601 INLINE bool operator Sym(const ap_int_base<_AP_W, _AP_S>& op1, float op2) { \
1602 return op1.to_double() Sym op2; \
1603 } \
1604 template <int _AP_W, bool _AP_S> \
1605 INLINE bool operator Sym(float op1, const ap_int_base<_AP_W, _AP_S>& op2) { \
1606 return op1 Sym op2.to_double(); \
1607 }
1608OP_REL_WITH_DOUBLE_OR_FLOAT(>)
1609OP_REL_WITH_DOUBLE_OR_FLOAT(<)
1610OP_REL_WITH_DOUBLE_OR_FLOAT(>=)
1611OP_REL_WITH_DOUBLE_OR_FLOAT(<=)
1612OP_REL_WITH_DOUBLE_OR_FLOAT(==)
1613OP_REL_WITH_DOUBLE_OR_FLOAT(!=)
1614
1615#undef OP_REL_WITH_DOUBLE_OR_FLOAT
1616
1617/* Operators with ap_bit_ref.
1618 * ------------------------------------------------------------
1619 */
1620// arithmetic, bitwise and shift operators.
1621#define OP_BIN_WITH_RANGE(BIN_OP, RTYPE) \
1622 template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> \
1623 INLINE typename ap_int_base<_AP_W1, _AP_S1>::template RType<_AP_W2, \
1624 _AP_S2>::RTYPE \
1625 operator BIN_OP(const ap_range_ref<_AP_W1, _AP_S1>& op1, \
1626 const ap_int_base<_AP_W2, _AP_S2>& op2) { \
1627 return ap_int_base<_AP_W1, false>(op1) BIN_OP op2; \
1628 } \
1629 template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> \
1630 INLINE typename ap_int_base<_AP_W1, _AP_S1>::template RType<_AP_W2, \
1631 _AP_S2>::RTYPE \
1632 operator BIN_OP(const ap_int_base<_AP_W1, _AP_S1>& op1, \
1633 const ap_range_ref<_AP_W2, _AP_S2>& op2) { \
1634 return op1 BIN_OP ap_int_base<_AP_W2, false>(op2); \
1635 }
1636
1637OP_BIN_WITH_RANGE(+, plus)
1638OP_BIN_WITH_RANGE(-, minus)
1639OP_BIN_WITH_RANGE(*, mult)
1640OP_BIN_WITH_RANGE(/, div)
1641OP_BIN_WITH_RANGE(%, mod)
1642OP_BIN_WITH_RANGE(&, logic)
1643OP_BIN_WITH_RANGE(|, logic)
1644OP_BIN_WITH_RANGE(^, logic)
1645OP_BIN_WITH_RANGE(>>, arg1)
1646OP_BIN_WITH_RANGE(<<, arg1)
1647
1648#undef OP_BIN_WITH_RANGE
1649
1650// compound assignment operators.
1651#define OP_ASSIGN_WITH_RANGE(ASSIGN_OP) \
1652 template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> \
1653 INLINE ap_int_base<_AP_W1, _AP_S1>& operator ASSIGN_OP( \
1654 ap_int_base<_AP_W1, _AP_S1>& op1, ap_range_ref<_AP_W2, _AP_S2>& op2) { \
1655 return op1 ASSIGN_OP ap_int_base<_AP_W2, false>(op2); \
1656 } \
1657 template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> \
1658 INLINE ap_range_ref<_AP_W1, _AP_S1>& operator ASSIGN_OP( \
1659 ap_range_ref<_AP_W1, _AP_S1>& op1, ap_int_base<_AP_W2, _AP_S2>& op2) { \
1660 ap_int_base<_AP_W1, false> tmp(op1); \
1661 tmp ASSIGN_OP op2; \
1662 op1 = tmp; \
1663 return op1; \
1664 }
1665
1666OP_ASSIGN_WITH_RANGE(+=)
1667OP_ASSIGN_WITH_RANGE(-=)
1668OP_ASSIGN_WITH_RANGE(*=)
1669OP_ASSIGN_WITH_RANGE(/=)
1670OP_ASSIGN_WITH_RANGE(%=)
1671OP_ASSIGN_WITH_RANGE(&=)
1672OP_ASSIGN_WITH_RANGE(|=)
1673OP_ASSIGN_WITH_RANGE(^=)
1674OP_ASSIGN_WITH_RANGE(>>=)
1675OP_ASSIGN_WITH_RANGE(<<=)
1676
1677#undef OP_ASSIGN_WITH_RANGE
1678
1679// equality and relational operators
1680#define OP_REL_WITH_RANGE(REL_OP) \
1681 template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> \
1682 INLINE bool operator REL_OP(const ap_range_ref<_AP_W1, _AP_S1>& op1, \
1683 const ap_int_base<_AP_W2, _AP_S2>& op2) { \
1684 return ap_int_base<_AP_W1, false>(op1).operator REL_OP(op2); \
1685 } \
1686 template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> \
1687 INLINE bool operator REL_OP(const ap_int_base<_AP_W1, _AP_S1>& op1, \
1688 const ap_range_ref<_AP_W2, _AP_S2>& op2) { \
1689 return op1.operator REL_OP(op2.operator ap_int_base<_AP_W2, false>()); \
1690 }
1691
1692OP_REL_WITH_RANGE(==)
1693OP_REL_WITH_RANGE(!=)
1694OP_REL_WITH_RANGE(>)
1695OP_REL_WITH_RANGE(>=)
1696OP_REL_WITH_RANGE(<)
1697OP_REL_WITH_RANGE(<=)
1698
1699#undef OP_REL_WITH_RANGE
1700
1701/* Operators with ap_bit_ref.
1702 * ------------------------------------------------------------
1703 */
1704// arithmetic, bitwise and shift operators.
1705#define OP_BIN_WITH_BIT(BIN_OP, RTYPE) \
1706 template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> \
1707 INLINE typename ap_int_base<_AP_W1, _AP_S1>::template RType<1, false>::RTYPE \
1708 operator BIN_OP(const ap_int_base<_AP_W1, _AP_S1>& op1, \
1709 const ap_bit_ref<_AP_W2, _AP_S2>& op2) { \
1710 return op1 BIN_OP ap_int_base<1, false>(op2); \
1711 } \
1712 template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> \
1713 INLINE typename ap_int_base<1, false>::template RType<_AP_W2, _AP_S2>::RTYPE \
1714 operator BIN_OP(const ap_bit_ref<_AP_W1, _AP_S1>& op1, \
1715 const ap_int_base<_AP_W2, _AP_S2>& op2) { \
1716 return ap_int_base<1, false>(op1) BIN_OP op2; \
1717 }
1718
1719OP_BIN_WITH_BIT(+, plus)
1720OP_BIN_WITH_BIT(-, minus)
1721OP_BIN_WITH_BIT(*, mult)
1722OP_BIN_WITH_BIT(/, div)
1723OP_BIN_WITH_BIT(%, mod)
1724OP_BIN_WITH_BIT(&, logic)
1725OP_BIN_WITH_BIT(|, logic)
1726OP_BIN_WITH_BIT(^, logic)
1727OP_BIN_WITH_BIT(>>, arg1)
1728OP_BIN_WITH_BIT(<<, arg1)
1729
1730#undef OP_BIN_WITH_BIT
1731
1732// compound assignment operators.
1733#define OP_ASSIGN_WITH_BIT(ASSIGN_OP) \
1734 template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> \
1735 INLINE ap_int_base<_AP_W1, _AP_S1>& operator ASSIGN_OP( \
1736 ap_int_base<_AP_W1, _AP_S1>& op1, ap_bit_ref<_AP_W2, _AP_S2>& op2) { \
1737 return op1 ASSIGN_OP ap_int_base<1, false>(op2); \
1738 } \
1739 template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> \
1740 INLINE ap_bit_ref<_AP_W1, _AP_S1>& operator ASSIGN_OP( \
1741 ap_bit_ref<_AP_W1, _AP_S1>& op1, ap_int_base<_AP_W2, _AP_S2>& op2) { \
1742 ap_int_base<1, false> tmp(op1); \
1743 tmp ASSIGN_OP op2; \
1744 op1 = tmp; \
1745 return op1; \
1746 }
1747
1748OP_ASSIGN_WITH_BIT(+=)
1749OP_ASSIGN_WITH_BIT(-=)
1750OP_ASSIGN_WITH_BIT(*=)
1751OP_ASSIGN_WITH_BIT(/=)
1752OP_ASSIGN_WITH_BIT(%=)
1753OP_ASSIGN_WITH_BIT(&=)
1754OP_ASSIGN_WITH_BIT(|=)
1755OP_ASSIGN_WITH_BIT(^=)
1756OP_ASSIGN_WITH_BIT(>>=)
1757OP_ASSIGN_WITH_BIT(<<=)
1758
1759#undef OP_ASSIGN_WITH_BIT
1760
1761// equality and relational operators.
1762#define OP_REL_WITH_BIT(REL_OP) \
1763 template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> \
1764 INLINE bool operator REL_OP(const ap_int_base<_AP_W1, _AP_S1>& op1, \
1765 const ap_bit_ref<_AP_W2, _AP_S2>& op2) { \
1766 return op1 REL_OP ap_int_base<1, false>(op2); \
1767 } \
1768 template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> \
1769 INLINE bool operator REL_OP(const ap_bit_ref<_AP_W1, _AP_S1>& op1, \
1770 const ap_int_base<_AP_W2, _AP_S2>& op2) { \
1771 return ap_int_base<1, false>(op1) REL_OP op2; \
1772 }
1773
1774OP_REL_WITH_BIT(==)
1775OP_REL_WITH_BIT(!=)
1776OP_REL_WITH_BIT(>)
1777OP_REL_WITH_BIT(>=)
1778OP_REL_WITH_BIT(<)
1779OP_REL_WITH_BIT(<=)
1780
1781#undef OP_REL_WITH_BIT
1782
1783/* Operators with ap_concat_ref.
1784 * ------------------------------------------------------------
1785 */
1786// arithmetic, bitwise and shift operators.
1787// bitwise operators are defined in struct.
1788// TODO specify whether to define arithmetic and bitwise operators.
1789#if 0
1790#define OP_BIN_WITH_CONCAT(BIN_OP, RTYPE) \
1791 template <int _AP_W1, typename _AP_T1, int _AP_W2, typename _AP_T2, \
1792 int _AP_W3, bool _AP_S3> \
1793 INLINE typename ap_int_base<_AP_W3, _AP_S3>::template RType<_AP_W1 + _AP_W2, \
1794 false>::RTYPE \
1795 operator BIN_OP(const ap_int_base<_AP_W3, _AP_S3>& op1, \
1796 const ap_concat_ref<_AP_W1, _AP_T1, _AP_W2, _AP_T2>& op2) { \
1797 /* convert ap_concat_ref to ap_int_base */ \
1798 return op1 BIN_OP op2.get(); \
1799 } \
1800 template <int _AP_W1, typename _AP_T1, int _AP_W2, typename _AP_T2, \
1801 int _AP_W3, bool _AP_S3> \
1802 INLINE typename ap_int_base<_AP_W1 + _AP_W2, \
1803 false>::template RType<_AP_W3, _AP_S3>::RTYPE \
1804 operator BIN_OP(const ap_concat_ref<_AP_W1, _AP_T1, _AP_W2, _AP_T2>& op1, \
1805 const ap_int_base<_AP_W3, _AP_S3>& op2) { \
1806 /* convert ap_concat_ref to ap_int_base */ \
1807 return op1.get() BIN_OP op2; \
1808 }
1809
1810OP_BIN_WITH_CONCAT(+, plus)
1811OP_BIN_WITH_CONCAT(-, minus)
1812OP_BIN_WITH_CONCAT(*, mult)
1813OP_BIN_WITH_CONCAT(/, div)
1814OP_BIN_WITH_CONCAT(%, mod)
1815OP_BIN_WITH_CONCAT(&, logic)
1816OP_BIN_WITH_CONCAT(|, logic)
1817OP_BIN_WITH_CONCAT(^, logic)
1818OP_BIN_WITH_CONCAT(>>, arg1)
1819OP_BIN_WITH_CONCAT(<<, arg1)
1820
1821#undef OP_BIN_WITH_CONCAT
1822
1823// compound assignment operators.
1824#define OP_ASSIGN_WITH_CONCAT(ASSIGN_OP) \
1825 template <int _AP_W1, typename _AP_T1, int _AP_W2, typename _AP_T2, \
1826 int _AP_W3, bool _AP_S3> \
1827 INLINE typename ap_int_base<_AP_W3, _AP_S3>::template RType<_AP_W1 + _AP_W2, \
1828 false>::RTYPE \
1829 operator ASSIGN_OP( \
1830 const ap_int_base<_AP_W3, _AP_S3>& op1, \
1831 const ap_concat_ref<_AP_W1, _AP_T1, _AP_W2, _AP_T2>& op2) { \
1832 /* convert ap_concat_ref to ap_int_base */ \
1833 return op1 ASSIGN_OP op2.get(); \
1834 } \
1835 template <int _AP_W1, typename _AP_T1, int _AP_W2, typename _AP_T2, \
1836 int _AP_W3, bool _AP_S3> \
1837 INLINE typename ap_int_base<_AP_W1 + _AP_W2, \
1838 false>::template RType<_AP_W3, _AP_S3>::RTYPE \
1839 operator ASSIGN_OP(const ap_concat_ref<_AP_W1, _AP_T1, _AP_W2, _AP_T2>& op1, \
1840 const ap_int_base<_AP_W3, _AP_S3>& op2) { \
1841 /* convert ap_concat_ref to ap_int_base */ \
1842 ap_int_base<_AP_W1 + _AP_W2, false> tmp = op1.get(); \
1843 tmp ASSIGN_OP op2; \
1844 op1 = tmp; \
1845 return op1; \
1846 }
1847
1848OP_ASSIGN_WITH_CONCAT(+=)
1849OP_ASSIGN_WITH_CONCAT(-=)
1850OP_ASSIGN_WITH_CONCAT(*=)
1851OP_ASSIGN_WITH_CONCAT(/=)
1852OP_ASSIGN_WITH_CONCAT(%=)
1853OP_ASSIGN_WITH_CONCAT(&=)
1854OP_ASSIGN_WITH_CONCAT(|=)
1855OP_ASSIGN_WITH_CONCAT(^=)
1856OP_ASSIGN_WITH_CONCAT(>>=)
1857OP_ASSIGN_WITH_CONCAT(<<=)
1858
1859#undef OP_ASSIGN_WITH_CONCAT
1860#endif
1861
1862// equality and relational operators.
1863#define OP_REL_WITH_CONCAT(REL_OP) \
1864 template <int _AP_W1, typename _AP_T1, int _AP_W2, typename _AP_T2, \
1865 int _AP_W3, bool _AP_S3> \
1866 INLINE bool operator REL_OP( \
1867 const ap_int_base<_AP_W3, _AP_S3>& op1, \
1868 const ap_concat_ref<_AP_W1, _AP_T1, _AP_W2, _AP_T2>& op2) { \
1869 /* convert ap_concat_ref to ap_int_base */ \
1870 return op1 REL_OP op2.get(); \
1871 } \
1872 template <int _AP_W1, typename _AP_T1, int _AP_W2, typename _AP_T2, \
1873 int _AP_W3, bool _AP_S3> \
1874 INLINE bool operator REL_OP( \
1875 const ap_concat_ref<_AP_W1, _AP_T1, _AP_W2, _AP_T2>& op1, \
1876 const ap_int_base<_AP_W3, _AP_S3>& op2) { \
1877 /* convert ap_concat_ref to ap_int_base */ \
1878 return op1.get() REL_OP op2; \
1879 }
1880
1881OP_REL_WITH_CONCAT(==)
1882OP_REL_WITH_CONCAT(!=)
1883OP_REL_WITH_CONCAT(>)
1884OP_REL_WITH_CONCAT(>=)
1885OP_REL_WITH_CONCAT(<)
1886OP_REL_WITH_CONCAT(<=)
1887
1888#undef OP_REL_WITH_CONCAT
1889
1890#endif // ifndef __cplusplus
1891#endif // ifndef __AP_INT_BASE_H__
1892
1893// -*- cpp -*-
Base
conditions objects which are tables indexed by raw detector id values
af_bit_ref
Definition ap_decl.h:183
af_range_ref
Definition ap_decl.h:179
ap_bit_ref
Definition ap_decl.h:160
ap_concat_ref
Definition ap_decl.h:163
ap_fixed_base
Definition ap_decl.h:167
ap_int_base
Definition ap_decl.h:148
ap_int
Sign Arbitrary Precision Type.
Definition ap_int.h:28
ap_range_ref
Definition ap_decl.h:157
ap_uint
Unsigned Arbitrary Precision Type.
Definition ap_int.h:166
hex
A very simple wrapper enabling us to more easily tell the output stream to style the input word in he...
Generated by doxygen 1.12.0