gem5  v21.1.0.2
sc_lv_base.hh
Go to the documentation of this file.
1 /*****************************************************************************
2 
3  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
4  more contributor license agreements. See the NOTICE file distributed
5  with this work for additional information regarding copyright ownership.
6  Accellera licenses this file to you under the Apache License, Version 2.0
7  (the "License"); you may not use this file except in compliance with the
8  License. You may obtain a copy of the License at
9 
10  http://www.apache.org/licenses/LICENSE-2.0
11 
12  Unless required by applicable law or agreed to in writing, software
13  distributed under the License is distributed on an "AS IS" BASIS,
14  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
15  implied. See the License for the specific language governing
16  permissions and limitations under the License.
17 
18  *****************************************************************************/
19 
20 /*****************************************************************************
21 
22  sc_lv_base.h -- Arbitrary size logic vector class.
23 
24  Original Author: Gene Bushuyev, Synopsys, Inc.
25 
26  *****************************************************************************/
27 
28 /*****************************************************************************
29 
30  MODIFICATION LOG - modifiers, enter your name, affiliation, date and
31  changes you are making here.
32 
33  Name, Affiliation, Date:
34  Description of Modification:
35  Andy Goodrich, Forte Design Systems
36  Fixed bug in clean_tail for sizes that are modulo 32, which caused
37  zeroing of values.
38 
39  *****************************************************************************/
40 
41 // $Log: sc_lv_base.h,v $
42 // Revision 1.4 2011/08/26 22:32:00 acg
43 // Torsten Maehne: added parentheses to make opearator ordering more obvious.
44 //
45 // Revision 1.3 2010/01/27 19:41:29 acg
46 // Andy Goodrich: fix 8 instances of sc_concref constructor invocations
47 // that failed to indicate that their arguments should be freed when the
48 // object was freed.
49 //
50 // Revision 1.2 2009/02/28 00:26:14 acg
51 // Andy Goodrich: bug fixes.
52 //
53 // Revision 1.2 2007/03/14 17:47:49 acg
54 // Andy Goodrich: Formatting.
55 //
56 // Revision 1.1.1.1 2006/12/15 20:31:36 acg
57 // SystemC 2.2
58 //
59 // Revision 1.3 2006/01/13 18:53:53 acg
60 // Andy Goodrich: added $Log command so that CVS comments are reproduced in
61 // the source.
62 //
63 
64 #ifndef __SYSTEMC_EXT_DT_BIT_SC_LV_BASE_HH__
65 #define __SYSTEMC_EXT_DT_BIT_SC_LV_BASE_HH__
66 
67 #include "../int/sc_length_param.hh"
68 #include "sc_bv_base.hh"
69 #include "sc_logic.hh"
70 
71 namespace sc_dt
72 {
73 
74 // classes defined in this module
75 class sc_lv_base;
76 
77 
78 // ----------------------------------------------------------------------------
79 // CLASS : sc_lv_base
80 //
81 // Arbitrary size logic vector base class.
82 // ----------------------------------------------------------------------------
83 
84 class sc_lv_base : public sc_proxy<sc_lv_base>
85 {
86  friend class sc_bv_base;
87 
88  void init(int length_, const sc_logic &init_value=SC_LOGIC_X);
89  void assign_from_string(const std::string &);
90 
91  public:
92  // typedefs
93  typedef sc_proxy<sc_lv_base> base_type;
95 
96  // constructors
97  explicit sc_lv_base(int length_=sc_length_param().len()) :
98  m_len(0), m_size(0), m_data(0), m_ctrl(0)
99  {
100  init(length_);
101  }
102 
103  explicit sc_lv_base(
104  const sc_logic &a, int length_=sc_length_param().len()) :
105  m_len(0), m_size(0), m_data(0), m_ctrl(0)
106  {
107  init(length_, a);
108  }
109 
110  sc_lv_base(const char *a);
111  sc_lv_base(const char *a, int length_);
112 
113  template <class X>
114  sc_lv_base(const sc_proxy<X> &a) :
115  m_len(0), m_size(0), m_data(0), m_ctrl(0)
116  {
117  init(a.back_cast().length());
119  }
120 
121  sc_lv_base(const sc_lv_base &a);
122 
123  // destructor
124  virtual ~sc_lv_base() { delete [] m_data; }
125 
126  // assignment operators
127  template <class X>
129  operator = (const sc_proxy<X> &a)
130  {
131  assign_p_(*this, a);
132  return *this;
133  }
134 
135  sc_lv_base &
136  operator = (const sc_lv_base &a)
137  {
138  assign_p_(*this, a);
139  return *this;
140  }
141 
142  sc_lv_base &operator = (const char *a);
143 
144  sc_lv_base &
145  operator = (const bool *a)
146  {
148  return *this;
149  }
150 
151  sc_lv_base &
152  operator = (const sc_logic *a)
153  {
155  return *this;
156  }
157 
159  operator = (const sc_unsigned &a)
160  {
162  return *this;
163  }
164 
165  sc_lv_base &
166  operator = (const sc_signed &a)
167  {
169  return *this;
170  }
171 
172  sc_lv_base &
173  operator = (const sc_uint_base &a)
174  {
176  return *this;
177  }
178 
180  operator = (const sc_int_base &a)
181  {
183  return *this;
184  }
185 
187  operator = (unsigned long a)
188  {
190  return *this;
191  }
192 
194  operator = (long a)
195  {
197  return *this;
198  }
199 
201  operator = (unsigned int a)
202  {
204  return *this;
205  }
206 
208  operator = (int a)
209  {
211  return *this;
212  }
213 
216  {
218  return *this;
219  }
220 
223  {
225  return *this;
226  }
227 
228  // common methods
229  int length() const { return m_len; }
230  int size() const { return m_size; }
231 
232  value_type get_bit(int i) const;
233  void set_bit(int i, value_type value);
234 
235  sc_digit get_word(int wi) const { return m_data[wi]; }
236 
237  // note the test for out of range access here. this is necessary
238  // because of the hair-brained way concatenations are set up.
239  // an extend_sign on a concatenation uses the whole length of
240  // the concatenation to determine how many words to set.
241  void
242  set_word(int wi, sc_digit w)
243  {
244  sc_assert(wi < m_size);
245  m_data[wi] = w;
246  }
247 
248  sc_digit get_cword(int wi) const { return m_ctrl[wi]; }
249 
250  void
251  set_cword(int wi, sc_digit w)
252  {
253  sc_assert(wi < m_size);
254  m_ctrl[wi] = w;
255  }
256  void clean_tail();
257 
258  // other methods
259  bool is_01() const;
260 
261  protected:
262  int m_len; // length in bits
263  int m_size; // size of the data array
264  sc_digit *m_data; // data array
265  sc_digit *m_ctrl; // dito (control part)
266 };
267 
268 // IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII
269 
271 sc_lv_base::get_bit(int i) const
272 {
273  int wi = i / SC_DIGIT_SIZE;
274  int bi = i % SC_DIGIT_SIZE;
275  return value_type(((m_data[wi] >> bi) & SC_DIGIT_ONE) |
276  (((m_ctrl[wi] >> bi) << 1) & SC_DIGIT_TWO));
277 }
278 
279 inline void
280 sc_lv_base::set_bit(int i, value_type value)
281 {
282  int wi = i / SC_DIGIT_SIZE; // word index
283  int bi = i % SC_DIGIT_SIZE; // bit index
285  m_data[wi] |= mask; // set bit to 1
286  m_ctrl[wi] |= mask; // set bit to 1
287  m_data[wi] &= value << bi | ~mask;
288  m_ctrl[wi] &= value >> 1 << bi | ~mask;
289 }
290 
291 inline void
293 {
294  int wi = m_size - 1;
295  int bi = m_len % SC_DIGIT_SIZE;
297  if (mask) {
298  m_data[wi] &= mask;
299  m_ctrl[wi] &= mask;
300  }
301 }
302 
303 
304 // ----------------------------------------------------------------------------
305 // CLASS TEMPLATE : sc_proxy
306 //
307 // Base class template for bit/logic vector classes.
308 // (Barton/Nackmann implementation)
309 // ----------------------------------------------------------------------------
310 
311 // bitwise operators and functions
312 
313 // bitwise complement
314 template <class X>
315 inline const sc_lv_base
317 {
318  sc_lv_base a(back_cast());
319  return a.b_not();
320 }
321 
322 // bitwise and
323 template <class X, class Y>
324 inline X &
326 {
327  X &x = px.back_cast();
328  sc_lv_base a(x.length());
329  a = py.back_cast();
330  return b_and_assign_(x, a);
331 }
332 
333 #define DEFN_BITWISE_AND_ASN_OP_T(tp) \
334 template <class X> \
335 inline X & \
336 sc_proxy<X>::operator &= (tp b) \
337 { \
338  X &x = back_cast(); \
339  sc_lv_base a(x.length()); \
340  a = b; \
341  return b_and_assign_(x, a); \
342 }
343 
344 DEFN_BITWISE_AND_ASN_OP_T(const char *)
345 DEFN_BITWISE_AND_ASN_OP_T(const bool *)
349 DEFN_BITWISE_AND_ASN_OP_T(unsigned long)
353 
354 #undef DEFN_BITWISE_AND_ASN_OP_T
355 
356 template <class X, class Y>
357 inline const sc_lv_base
358 operator & (const sc_proxy<X> &px, const sc_proxy<Y> &py)
359 {
360  sc_lv_base a(px.back_cast());
361  return (a &= py.back_cast());
362 }
363 
364 #define DEFN_BITWISE_AND_OP_T_A(tp) \
365 template <class X> \
366 inline const sc_lv_base \
367 sc_proxy<X>::operator & (tp b) const \
368 { \
369  sc_lv_base a(back_cast()); \
370  return (a &= b); \
371 }
372 
373 DEFN_BITWISE_AND_OP_T_A(const char *)
374 DEFN_BITWISE_AND_OP_T_A(const bool *)
375 DEFN_BITWISE_AND_OP_T_A(const sc_logic *)
376 DEFN_BITWISE_AND_OP_T_A(const sc_unsigned &)
377 DEFN_BITWISE_AND_OP_T_A(const sc_signed &)
378 DEFN_BITWISE_AND_OP_T_A(const sc_uint_base &)
379 DEFN_BITWISE_AND_OP_T_A(const sc_int_base &)
380 DEFN_BITWISE_AND_OP_T_A(unsigned long)
382 DEFN_BITWISE_AND_OP_T_A(unsigned int)
386 
387 #undef DEFN_BITWISE_AND_OP_T_A
388 
389 #define DEFN_BITWISE_AND_OP_T_B(tp) \
390 template <class X> \
391 inline const sc_lv_base \
392 operator & (tp b, const sc_proxy<X> &px) \
393 { \
394  return (px & b); \
395 }
396 
397 DEFN_BITWISE_AND_OP_T_B(const char *)
399 DEFN_BITWISE_AND_OP_T_B(const sc_logic *)
400 DEFN_BITWISE_AND_OP_T_B(const sc_unsigned &)
401 DEFN_BITWISE_AND_OP_T_B(const sc_signed &)
402 DEFN_BITWISE_AND_OP_T_B(const sc_uint_base &)
403 DEFN_BITWISE_AND_OP_T_B(const sc_int_base &)
404 DEFN_BITWISE_AND_OP_T_B(unsigned long)
406 DEFN_BITWISE_AND_OP_T_B(unsigned int)
410 
411 #undef DEFN_BITWISE_AND_OP_T_B
412 
413 // bitwise or
414 template <class X, class Y>
415 inline X &
416 operator |= (sc_proxy<X> &px, const sc_proxy<Y> &py)
417 {
418  X &x = px.back_cast();
419  sc_lv_base a(x.length());
420  a = py.back_cast();
421  return b_or_assign_(x, a);
422 }
423 
424 #define DEFN_BITWISE_OR_ASN_OP_T(tp) \
425 template <class X> \
426 inline X & \
427 sc_proxy<X>::operator |= (tp b) \
428 { \
429  X &x = back_cast(); \
430  sc_lv_base a(x.length()); \
431  a = b; \
432  return b_or_assign_(x, a); \
433 }
434 
435 DEFN_BITWISE_OR_ASN_OP_T(const char *)
436 DEFN_BITWISE_OR_ASN_OP_T(const bool *)
437 DEFN_BITWISE_OR_ASN_OP_T(const sc_logic *)
438 DEFN_BITWISE_OR_ASN_OP_T(const sc_unsigned &)
439 DEFN_BITWISE_OR_ASN_OP_T(const sc_signed &)
440 DEFN_BITWISE_OR_ASN_OP_T(unsigned long)
444 
445 #undef DEFN_BITWISE_OR_ASN_OP_T
446 
447 template <class X, class Y>
448 inline const sc_lv_base
449 operator | (const sc_proxy<X> &px, const sc_proxy<Y> &py)
450 {
451  sc_lv_base a(px.back_cast());
452  return (a |= py.back_cast());
453 }
454 
455 #define DEFN_BITWISE_OR_OP_T_A(tp) \
456 template <class X> \
457 inline const sc_lv_base \
458 sc_proxy<X>::operator | (tp b) const \
459 { \
460  sc_lv_base a(back_cast()); \
461  return (a |= b); \
462 }
463 
464 DEFN_BITWISE_OR_OP_T_A(const char *)
465 DEFN_BITWISE_OR_OP_T_A(const bool *)
466 DEFN_BITWISE_OR_OP_T_A(const sc_logic *)
467 DEFN_BITWISE_OR_OP_T_A(const sc_unsigned &)
468 DEFN_BITWISE_OR_OP_T_A(const sc_signed &)
469 DEFN_BITWISE_OR_OP_T_A(const sc_uint_base &)
470 DEFN_BITWISE_OR_OP_T_A(const sc_int_base &)
471 DEFN_BITWISE_OR_OP_T_A(unsigned long)
473 DEFN_BITWISE_OR_OP_T_A(unsigned int)
477 
478 #undef DEFN_BITWISE_OR_OP_T_A
479 
480 #define DEFN_BITWISE_OR_OP_T_B(tp) \
481 template <class X> \
482 inline const sc_lv_base \
483 operator | (tp b, const sc_proxy<X> &px) \
484 { \
485  return (px | b); \
486 }
487 
488 DEFN_BITWISE_OR_OP_T_B(const char *)
490 DEFN_BITWISE_OR_OP_T_B(const sc_logic *)
491 DEFN_BITWISE_OR_OP_T_B(const sc_unsigned &)
492 DEFN_BITWISE_OR_OP_T_B(const sc_signed &)
493 DEFN_BITWISE_OR_OP_T_B(const sc_uint_base &)
494 DEFN_BITWISE_OR_OP_T_B(const sc_int_base &)
495 DEFN_BITWISE_OR_OP_T_B(unsigned long)
497 DEFN_BITWISE_OR_OP_T_B(unsigned int)
501 
502 #undef DEFN_BITWISE_OR_OP_T_B
503 
504 // bitwise xor
505 template <class X, class Y>
506 inline X &
507 operator ^= (sc_proxy<X> &px, const sc_proxy<Y> &py)
508 {
509  X &x = px.back_cast();
510  sc_lv_base a(x.length());
511  a = py.back_cast();
512  return b_xor_assign_(x, a);
513 }
514 
515 #define DEFN_BITWISE_XOR_ASN_OP_T(tp) \
516 template <class X> \
517 inline X & \
518 sc_proxy<X>::operator ^= (tp b) \
519 { \
520  X &x = back_cast(); \
521  sc_lv_base a(x.length()); \
522  a = b; \
523  return b_xor_assign_(x, a); \
524 }
525 
526 DEFN_BITWISE_XOR_ASN_OP_T(const char *)
527 DEFN_BITWISE_XOR_ASN_OP_T(const bool *)
528 DEFN_BITWISE_XOR_ASN_OP_T(const sc_logic *)
529 DEFN_BITWISE_XOR_ASN_OP_T(const sc_unsigned &)
530 DEFN_BITWISE_XOR_ASN_OP_T(const sc_signed &)
531 DEFN_BITWISE_XOR_ASN_OP_T(unsigned long)
535 
536 #undef DEFN_BITWISE_XOR_ASN_OP_T
537 
538 template <class X, class Y>
539 inline const sc_lv_base
540 operator ^ (const sc_proxy<X> &px, const sc_proxy<Y> &py)
541 {
542  sc_lv_base a(px.back_cast());
543  return (a ^= py.back_cast());
544 }
545 
546 #define DEFN_BITWISE_XOR_OP_T_A(tp) \
547 template <class X> \
548 inline const sc_lv_base \
549 sc_proxy<X>::operator ^ (tp b) const \
550 { \
551  sc_lv_base a(back_cast()); \
552  return (a ^= b); \
553 }
554 
555 DEFN_BITWISE_XOR_OP_T_A(const char *)
556 DEFN_BITWISE_XOR_OP_T_A(const bool *)
557 DEFN_BITWISE_XOR_OP_T_A(const sc_logic *)
558 DEFN_BITWISE_XOR_OP_T_A(const sc_unsigned &)
559 DEFN_BITWISE_XOR_OP_T_A(const sc_signed &)
560 DEFN_BITWISE_XOR_OP_T_A(const sc_uint_base &)
561 DEFN_BITWISE_XOR_OP_T_A(const sc_int_base &)
562 DEFN_BITWISE_XOR_OP_T_A(unsigned long)
564 DEFN_BITWISE_XOR_OP_T_A(unsigned int)
568 
569 #undef DEFN_BITWISE_XOR_OP_T_A
570 
571 #define DEFN_BITWISE_XOR_OP_T_B(tp) \
572 template <class X> \
573 inline const sc_lv_base \
574 operator ^ (tp b, const sc_proxy<X> &px) \
575 { \
576  return (px ^ b); \
577 }
578 
579 DEFN_BITWISE_XOR_OP_T_B(const char *)
581 DEFN_BITWISE_XOR_OP_T_B(const sc_logic *)
582 DEFN_BITWISE_XOR_OP_T_B(const sc_unsigned &)
583 DEFN_BITWISE_XOR_OP_T_B(const sc_signed &)
584 DEFN_BITWISE_XOR_OP_T_B(const sc_uint_base &)
585 DEFN_BITWISE_XOR_OP_T_B(const sc_int_base &)
586 DEFN_BITWISE_XOR_OP_T_B(unsigned long)
588 DEFN_BITWISE_XOR_OP_T_B(unsigned int)
592 
593 #undef DEFN_BITWISE_XOR_OP_T_B
594 
595 // bitwise left shift
596 template <class X>
597 inline const sc_lv_base
598 sc_proxy<X>::operator << (int n) const
599 {
600  sc_lv_base a(back_cast().length() + n);
601  a = back_cast();
602  return (a <<= n);
603 }
604 
605 // bitwise right shift
606 template <class X>
607 inline const sc_lv_base
608 sc_proxy<X>::operator >> (int n) const
609 {
610  sc_lv_base a(back_cast());
611  return (a >>= n);
612 }
613 
614 // bitwise left rotate
615 template <class X>
616 inline X &
618 {
619  X &x = back_cast();
620  if (n < 0) {
621  sc_proxy_out_of_bounds("left rotate operation is only allowed with "
622  "positive rotate values, rotate value = ", n);
623  return x;
624  }
625  int len = x.length();
626  n %= len;
627  // x = (x << n) | (x >> (len - n));
628  sc_lv_base a(x << n);
629  sc_lv_base b(x >> (len - n));
630  int sz = x.size();
631  for (int i = 0; i < sz; ++i) {
632  x.set_word(i, a.get_word(i) | b.get_word(i));
633  x.set_cword(i, a.get_cword(i) | b.get_cword(i));
634  }
635  x.clean_tail();
636  return x;
637 }
638 
639 template <class X>
640 inline const sc_lv_base
641 lrotate(const sc_proxy<X> &x, int n)
642 {
643  sc_lv_base a(x.back_cast());
644  return a.lrotate(n);
645 }
646 
647 // bitwise right rotate
648 template <class X>
649 inline X &
651 {
652  X &x = back_cast();
653  if (n < 0 ) {
654  sc_proxy_out_of_bounds("right rotate operation is only allowed with "
655  "positive rotate values, rotate value = ", n);
656  return x;
657  }
658  int len = x.length();
659  n %= len;
660  // x = (x >> n) | (x << (len - n));
661  sc_lv_base a(x >> n);
662  sc_lv_base b(x << (len - n));
663  int sz = x.size();
664  for (int i = 0; i < sz; ++i) {
665  x.set_word(i, a.get_word(i) | b.get_word(i));
666  x.set_cword(i, a.get_cword(i) | b.get_cword(i));
667  }
668  x.clean_tail();
669  return x;
670 }
671 
672 template <class X>
673 inline const sc_lv_base
674 rrotate(const sc_proxy<X> &x, int n)
675 {
676  sc_lv_base a(x.back_cast());
677  return a.rrotate(n);
678 }
679 
680 // bitwise reverse
681 template <class X>
682 inline const sc_lv_base
683 reverse(const sc_proxy<X> &x)
684 {
685  sc_lv_base a(x.back_cast());
686  return a.reverse();
687 }
688 
689 // relational operators
690 template <class X, class Y>
691 inline bool
692 operator == (const sc_proxy<X> &px, const sc_proxy<Y> &py)
693 {
694  const X &x = px.back_cast();
695  const Y &y = py.back_cast();
696  int x_len = x.length();
697  int y_len = y.length();
698  if (x_len != y_len) {
699  return false;
700  }
701  int sz = x.size();
702  for (int i = 0; i < sz; ++i) {
703  if (x.get_word(i) != y.get_word(i) ||
704  x.get_cword(i) != y.get_cword(i)) {
705  return false;
706  }
707  }
708  return true;
709 }
710 
711 #define DEFN_REL_OP_T(tp) \
712 template <class X> \
713 inline bool \
714 sc_proxy<X>::operator == (tp b) const \
715 { \
716  const X &x = back_cast(); \
717  sc_lv_base y(x.length()); \
718  y = b; \
719  return (x == y); \
720 }
721 
722 DEFN_REL_OP_T(const char *)
723 DEFN_REL_OP_T(const bool *)
724 DEFN_REL_OP_T(const sc_logic *)
725 DEFN_REL_OP_T(const sc_unsigned &)
728 DEFN_REL_OP_T(const sc_int_base &)
729 DEFN_REL_OP_T(unsigned long)
730 DEFN_REL_OP_T(long)
731 DEFN_REL_OP_T(unsigned int)
732 DEFN_REL_OP_T(int)
735 
736 #undef DEFN_REL_OP_T
737 
738 
739 // ----------------------------------------------------------------------------
740 // CLASS TEMPLATE : sc_bitref_r<X>
741 //
742 // Proxy class for sc_proxy bit selection (r-value only).
743 // ----------------------------------------------------------------------------
744 
745 // r-value concatenation operators and functions
746 
747 template <class T>
748 inline sc_concref_r<sc_bitref_r<T>, sc_lv_base>
749 operator , (sc_bitref_r<T> a, const char *b)
750 {
751  return sc_concref_r<sc_bitref_r<T>, sc_lv_base>(
752  *a.clone(), *new sc_lv_base(b), 3);
753 }
754 
755 template <class T>
756 inline sc_concref_r<sc_lv_base, sc_bitref_r<T> >
757 operator , (const char *a, sc_bitref_r<T> b)
758 {
759  return sc_concref_r<sc_lv_base, sc_bitref_r<T> >(
760  *new sc_lv_base(a), *b.clone(), 3);
761 }
762 
763 template <class T>
764 inline sc_concref_r<sc_bitref_r<T>, sc_lv_base>
765 operator , (sc_bitref_r<T> a, const sc_logic &b)
766 {
767  return sc_concref_r<sc_bitref_r<T>, sc_lv_base>(
768  *a.clone(), *new sc_lv_base(b, 1), 3);
769 }
770 
771 template <class T>
772 inline sc_concref_r<sc_lv_base, sc_bitref_r<T> >
773 operator , (const sc_logic &a, sc_bitref_r<T> b)
774 {
775  return sc_concref_r<sc_lv_base,sc_bitref_r<T> >(
776  *new sc_lv_base(a, 1), *b.clone(), 3);
777 }
778 
779 template <class T>
780 inline sc_concref_r<sc_bitref_r<T>, sc_bv_base>
781 operator , (sc_bitref_r<T> a, bool b)
782 {
784  *a.clone(), *new sc_bv_base(b, 1), 3);
785 }
786 
787 template <class T>
788 inline sc_concref_r<sc_bv_base, sc_bitref_r<T> >
789 operator , (bool a, sc_bitref_r<T> b)
790 {
792  *new sc_bv_base(a, 1), *b.clone(), 3);
793 }
794 
795 template <class T>
796 inline sc_concref_r<sc_bitref_r<T>, sc_lv_base>
797 concat(sc_bitref_r<T> a, const char *b)
798 {
800  *a.clone(), *new sc_lv_base(b), 3);
801 }
802 
803 template <class T>
804 inline sc_concref_r<sc_lv_base, sc_bitref_r<T> >
805 concat(const char *a, sc_bitref_r<T> b)
806 {
808  *new sc_lv_base(a), *b.clone(), 3);
809 }
810 
811 template <class T>
812 inline sc_concref_r<sc_bitref_r<T>, sc_lv_base>
813 concat(sc_bitref_r<T> a, const sc_logic &b)
814 {
816  *a.clone(), *new sc_lv_base(b, 1), 3);
817 }
818 
819 template <class T>
820 inline sc_concref_r<sc_lv_base, sc_bitref_r<T> >
821 concat(const sc_logic &a, sc_bitref_r<T> b)
822 {
824  *new sc_lv_base(a, 1), *b.clone(), 3);
825 }
826 
827 template <class T>
828 inline sc_concref_r<sc_bitref_r<T>, sc_bv_base>
829 concat(sc_bitref_r<T> a, bool b)
830 {
832  *a.clone(), *new sc_bv_base(b, 1), 3);
833 }
834 
835 template <class T>
836 inline sc_concref_r<sc_bv_base, sc_bitref_r<T> >
837 concat(bool a, sc_bitref_r<T> b)
838 {
840  *new sc_bv_base(a, 1), *b.clone(), 3);
841 }
842 
843 
844 template <class T>
845 inline sc_concref_r<sc_bitref_r<T>, sc_lv_base>
846 operator , (sc_bitref<T> a, const char *b)
847 {
849  *a.clone(), *new sc_lv_base(b), 3);
850 }
851 
852 template <class T>
853 inline sc_concref_r<sc_lv_base, sc_bitref_r<T> >
854 operator , (const char *a, sc_bitref<T> b)
855 {
857  *new sc_lv_base(a), *b.clone(), 3);
858 }
859 
860 template <class T>
861 inline sc_concref_r<sc_bitref_r<T>, sc_lv_base>
862 operator , (sc_bitref<T> a, const sc_logic &b)
863 {
865  *a.clone(), *new sc_lv_base(b, 1), 3);
866 }
867 
868 template <class T>
869 inline sc_concref_r<sc_lv_base, sc_bitref_r<T> >
870 operator , (const sc_logic &a, sc_bitref<T> b)
871 {
873  *new sc_lv_base(a, 1), *b.clone(), 3);
874 }
875 
876 template <class T>
877 inline sc_concref_r<sc_bitref_r<T>, sc_bv_base>
878 operator , (sc_bitref<T> a, bool b)
879 {
881  *a.clone(), *new sc_bv_base(b, 1), 3);
882 }
883 
884 template <class T>
885 inline sc_concref_r<sc_bv_base, sc_bitref_r<T> >
886 operator , (bool a, sc_bitref<T> b)
887 {
889  *new sc_bv_base(a, 1), *b.clone(), 3);
890 }
891 
892 template <class T>
893 inline sc_concref_r<sc_bitref_r<T>, sc_lv_base>
894 concat(sc_bitref<T> a, const char *b)
895 {
897  *a.clone(), *new sc_lv_base(b), 3);
898 }
899 
900 template <class T>
901 inline sc_concref_r<sc_lv_base, sc_bitref_r<T> >
902 concat(const char *a, sc_bitref<T> b)
903 {
905  *new sc_lv_base(a), *b.clone(), 3);
906 }
907 
908 template <class T>
909 inline sc_concref_r<sc_bitref_r<T>, sc_lv_base>
910 concat(sc_bitref<T> a, const sc_logic &b)
911 {
913  *a.clone(), *new sc_lv_base(b, 1), 3);
914 }
915 
916 template <class T>
917 inline sc_concref_r<sc_lv_base, sc_bitref_r<T> >
918 concat(const sc_logic &a, sc_bitref<T> b)
919 {
921  *new sc_lv_base(a, 1), *b.clone(), 3);
922 }
923 
924 template <class T>
925 inline sc_concref_r<sc_bitref_r<T>, sc_bv_base>
926 concat(sc_bitref<T> a, bool b)
927 {
929  *a.clone(), *new sc_bv_base(b, 1), 3);
930 }
931 
932 template <class T>
933 inline sc_concref_r<sc_bv_base, sc_bitref_r<T> >
934 concat(bool a, sc_bitref<T> b)
935 {
937  *new sc_bv_base(a, 1), *b.clone(), 3);
938 }
939 
940 
941 // ----------------------------------------------------------------------------
942 // CLASS TEMPLATE : sc_subref_r<X>
943 //
944 // Proxy class for sc_proxy part selection (r-value only).
945 // ----------------------------------------------------------------------------
946 
947 // r-value concatenation operators and functions
948 template <class T>
950 operator , (sc_subref_r<T> a, const char *b)
951 {
953  *a.clone(), *new sc_lv_base(b), 3);
954 }
955 
956 template <class T>
957 inline sc_concref_r<sc_lv_base, sc_subref_r<T> >
958 operator , (const char *a, sc_subref_r<T> b)
959 {
961  *new sc_lv_base(a), *b.clone(), 3);
962 }
963 
964 template <class T>
965 inline sc_concref_r<sc_subref_r<T>, sc_lv_base>
966 operator , (sc_subref_r<T> a, const sc_logic &b)
967 {
969  *a.clone(), *new sc_lv_base(b, 1), 3);
970 }
971 
972 template <class T>
973 inline sc_concref_r<sc_lv_base, sc_subref_r<T> >
974 operator , (const sc_logic &a, sc_subref_r<T> b)
975 {
976  return sc_concref_r<sc_lv_base, sc_subref_r<T> >(
977  *new sc_lv_base(a, 1), *b.clone(), 3);
978 }
979 
980 template <class T>
981 inline sc_concref_r<sc_subref_r<T>, sc_bv_base>
982 operator , (sc_subref_r<T> a, bool b)
983 {
985  *a.clone(), *new sc_bv_base(b, 1), 3);
986 }
987 
988 template <class T>
989 inline sc_concref_r<sc_bv_base, sc_subref_r<T> >
990 operator , (bool a, sc_subref_r<T> b)
991 {
993  *new sc_bv_base(a, 1), *b.clone(), 3);
994 }
995 
996 template <class T>
997 inline sc_concref_r<sc_subref_r<T>, sc_lv_base>
998 concat(sc_subref_r<T> a, const char *b)
999 {
1001  *a.clone(), *new sc_lv_base(b), 3);
1002 }
1003 
1004 template <class T>
1005 inline sc_concref_r<sc_lv_base, sc_subref_r<T> >
1006 concat(const char *a, sc_subref_r<T> b)
1007 {
1009  *new sc_lv_base(a), *b.clone(), 3);
1010 }
1011 
1012 template <class T>
1013 inline sc_concref_r<sc_subref_r<T>, sc_lv_base>
1014 concat(sc_subref_r<T> a, const sc_logic &b)
1015 {
1017  *a.clone(), *new sc_lv_base(b, 1), 3);
1018 }
1019 
1020 template <class T>
1021 inline sc_concref_r<sc_lv_base, sc_subref_r<T> >
1022 concat(const sc_logic &a, sc_subref_r<T> b)
1023 {
1025  *new sc_lv_base(a, 1), *b.clone(), 3);
1026 }
1027 
1028 template <class T>
1029 inline sc_concref_r<sc_subref_r<T>, sc_bv_base>
1030 concat(sc_subref_r<T> a, bool b)
1031 {
1033  *a.clone(), *new sc_bv_base(b, 1), 3);
1034 }
1035 
1036 template <class T>
1037 inline sc_concref_r<sc_bv_base, sc_subref_r<T> >
1038 concat(bool a, sc_subref_r<T> b)
1039 {
1041  *new sc_bv_base(a, 1), *b.clone(), 3);
1042 }
1043 
1044 
1045 template <class T>
1046 inline sc_concref_r<sc_subref_r<T>, sc_lv_base>
1047 operator , (sc_subref<T> a, const char *b)
1050  *a.clone(), *new sc_lv_base(b), 3);
1051 }
1052 
1053 template <class T>
1054 inline sc_concref_r<sc_lv_base, sc_subref_r<T> >
1055 operator , (const char *a, sc_subref<T> b)
1058  *new sc_lv_base(a), *b.clone(), 3);
1059 }
1060 
1061 template <class T>
1062 inline sc_concref_r<sc_subref_r<T>, sc_lv_base>
1063 operator , (sc_subref<T> a, const sc_logic &b)
1066  *a.clone(), *new sc_lv_base(b, 1), 3);
1067 }
1068 
1069 template <class T>
1070 inline sc_concref_r<sc_lv_base, sc_subref_r<T> >
1071 operator , (const sc_logic &a, sc_subref<T> b)
1074  *new sc_lv_base(a, 1), *b.clone(), 3);
1075 }
1076 
1077 template <class T>
1078 inline sc_concref_r<sc_subref_r<T>, sc_bv_base>
1079 operator , (sc_subref<T> a, bool b)
1080 {
1082  *a.clone(), *new sc_bv_base(b, 1), 3);
1083 }
1084 
1085 template <class T>
1086 inline sc_concref_r<sc_bv_base, sc_subref_r<T> >
1087 operator , (bool a, sc_subref<T> b)
1088 {
1090  *new sc_bv_base(a, 1), *b.clone(), 3);
1091 }
1092 
1093 
1094 template <class T>
1095 inline sc_concref_r<sc_subref_r<T>, sc_lv_base>
1096 concat(sc_subref<T> a, const char *b)
1099  *a.clone(), *new sc_lv_base(b), 3);
1100 }
1101 
1102 template <class T>
1103 inline sc_concref_r<sc_lv_base, sc_subref_r<T> >
1104 concat(const char *a, sc_subref<T> b)
1107  *new sc_lv_base(a), *b.clone(), 3);
1108 }
1109 
1110 template <class T>
1111 inline sc_concref_r<sc_subref_r<T>, sc_lv_base>
1112 concat(sc_subref<T> a, const sc_logic &b)
1115  *a.clone(), *new sc_lv_base(b, 1), 3);
1116 }
1117 
1118 template <class T>
1119 inline sc_concref_r<sc_lv_base, sc_subref_r<T> >
1120 concat(const sc_logic &a, sc_subref<T> b)
1123  *new sc_lv_base(a, 1), *b.clone(), 3);
1124 }
1125 
1126 template <class T>
1127 inline sc_concref_r<sc_subref_r<T>, sc_bv_base>
1128 concat(sc_subref<T> a, bool b)
1129 {
1131  *a.clone(), *new sc_bv_base(b, 1), 3);
1132 }
1133 
1134 template <class T>
1135 inline sc_concref_r<sc_bv_base, sc_subref_r<T> >
1136 concat(bool a, sc_subref<T> b)
1137 {
1139  *new sc_bv_base(a, 1), *b.clone(), 3);
1140 }
1141 
1142 
1143 // ----------------------------------------------------------------------------
1144 // CLASS TEMPLATE : sc_subref<X>
1145 //
1146 // Proxy class for sc_proxy part selection (r-value and l-value).
1147 // ----------------------------------------------------------------------------
1148 
1149 template <class X>
1150 inline sc_subref<X> &
1152 {
1153  sc_lv_base t(b); // (partial) self assignment protection
1154  int len = sc_min(this->length(), t.length());
1155  if (!this->reversed()) {
1156  for (int i = len - 1; i >= 0; --i) {
1157  this->m_obj.set_bit(this->m_lo + i, t[i].value());
1158  }
1159  } else {
1160  for (int i = len - 1; i >= 0; --i) {
1161  this->m_obj.set_bit(this->m_lo - i, t[i].value());
1162  }
1163  }
1164  return *this;
1165 }
1166 
1167 template <class X>
1168 inline sc_subref<X> &
1169 sc_subref<X>::operator = (const sc_subref<X> &b)
1171  sc_lv_base t(b); // (partial) self assignment protection
1172  int len = sc_min(this->length(), t.length());
1173  if (!this->reversed()) {
1174  for (int i = len - 1; i >= 0; --i) {
1175  this->m_obj.set_bit(this->m_lo + i, t[i].value());
1176  }
1177  } else {
1178  for (int i = len - 1; i >= 0; --i) {
1179  this->m_obj.set_bit(this->m_lo - i, t[i].value());
1180  }
1181  }
1182  return *this;
1183 }
1184 
1186 // ----------------------------------------------------------------------------
1187 // CLASS TEMPLATE : sc_concref_r<X,Y>
1188 //
1189 // Proxy class for sc_proxy concatenation (r-value only).
1190 // ----------------------------------------------------------------------------
1191 
1192 // r-value concatenation operators and functions
1193 
1194 template <class T1, class T2>
1196 operator , (sc_concref_r<T1, T2> a, const char *b)
1197 {
1199  *a.clone(), *new sc_lv_base(b), 3);
1200 }
1201 
1202 template <class T1, class T2>
1204 operator , (const char *a, sc_concref_r<T1, T2> b)
1205 {
1207  *new sc_lv_base(a), *b.clone(), 3);
1208 }
1209 
1210 template <class T1, class T2>
1213 {
1215  *a.clone(), *new sc_lv_base(b, 1), 3);
1216 }
1217 
1218 template <class T1, class T2>
1219 inline sc_concref_r<sc_lv_base, sc_concref_r<T1, T2> >
1220 operator , (const sc_logic &a, sc_concref_r<T1, T2> b)
1221 {
1222  return sc_concref_r<sc_lv_base, sc_concref_r<T1, T2> >(
1223  *new sc_lv_base(a, 1), *b.clone(), 3);
1224 }
1225 
1226 template <class T1, class T2>
1227 inline sc_concref_r<sc_concref_r<T1, T2>, sc_bv_base>
1228 operator , (sc_concref_r<T1, T2> a, bool b)
1229 {
1231  *a.clone(), *new sc_bv_base(b, 1), 3);
1232 }
1233 
1234 template <class T1, class T2>
1235 inline sc_concref_r<sc_bv_base, sc_concref_r<T1, T2> >
1236 operator , (bool a, sc_concref_r<T1, T2> b)
1237 {
1239  *new sc_bv_base(a, 1), *b.clone(), 3);
1240 }
1241 
1242 template <class T1, class T2>
1243 inline sc_concref_r<sc_concref_r<T1, T2>, sc_lv_base>
1244 concat(sc_concref_r<T1, T2> a, const char *b)
1245 {
1247  *a.clone(), *new sc_lv_base(b), 3);
1248 }
1249 
1250 template <class T1, class T2>
1251 inline sc_concref_r<sc_lv_base, sc_concref_r<T1, T2> >
1252 concat(const char *a, sc_concref_r<T1, T2> b)
1253 {
1255  *new sc_lv_base(a), *b.clone(), 3);
1256 }
1257 
1258 template <class T1, class T2>
1259 inline sc_concref_r<sc_concref_r<T1, T2>, sc_lv_base>
1260 concat(sc_concref_r<T1, T2> a, const sc_logic &b)
1261 {
1263  *a.clone(), *new sc_lv_base(b, 1), 3);
1264 }
1265 
1266 template <class T1, class T2>
1267 inline sc_concref_r<sc_lv_base, sc_concref_r<T1, T2> >
1268 concat(const sc_logic &a, sc_concref_r<T1, T2> b)
1269 {
1271  *new sc_lv_base(a, 1), *b.clone(), 3);
1272 }
1273 
1274 template <class T1, class T2>
1275 inline sc_concref_r<sc_concref_r<T1, T2>, sc_bv_base>
1276 concat(sc_concref_r<T1, T2> a, bool b)
1277 {
1279  *a.clone(), *new sc_bv_base(b, 1), 3);
1280 }
1281 
1282 template <class T1, class T2>
1283 inline sc_concref_r<sc_bv_base, sc_concref_r<T1, T2> >
1284 concat(bool a, sc_concref_r<T1, T2> b)
1285 {
1287  *new sc_bv_base(a, 1), *b.clone(), 3);
1288 }
1289 
1290 
1291 template <class T1, class T2>
1292 inline sc_concref_r<sc_concref_r<T1, T2>, sc_lv_base>
1293 operator , (sc_concref<T1, T2> a, const char *b)
1296  *a.clone(), *new sc_lv_base(b), 3);
1297 }
1298 
1299 template <class T1, class T2>
1300 inline sc_concref_r<sc_lv_base, sc_concref_r<T1, T2> >
1301 operator , (const char *a, sc_concref<T1, T2> b)
1304  *new sc_lv_base(a), *b.clone(), 3);
1305 }
1306 
1307 template <class T1, class T2>
1308 inline sc_concref_r<sc_concref_r<T1, T2>, sc_lv_base>
1309 operator , (sc_concref<T1, T2> a, const sc_logic &b)
1312  *a.clone(), *new sc_lv_base(b, 1), 3);
1313 }
1314 
1315 template <class T1, class T2>
1316 inline sc_concref_r<sc_lv_base, sc_concref_r<T1, T2> >
1317 operator , (const sc_logic &a, sc_concref<T1, T2> b)
1320  *new sc_lv_base(a, 1), *b.clone(), 3);
1321 }
1322 
1323 template <class T1, class T2>
1324 inline sc_concref_r<sc_concref_r<T1, T2>, sc_bv_base>
1325 operator , (sc_concref<T1, T2> a, bool b)
1326 {
1328  *a.clone(), *new sc_bv_base(b, 1), 3);
1329 }
1330 
1331 template <class T1, class T2>
1332 inline sc_concref_r<sc_bv_base, sc_concref_r<T1, T2> >
1333 operator , (bool a, sc_concref<T1, T2> b)
1334 {
1336  *new sc_bv_base(a, 1), *b.clone(), 3);
1337 }
1338 
1339 template <class T1, class T2>
1340 inline sc_concref_r<sc_concref_r<T1, T2>, sc_lv_base>
1341 concat(sc_concref<T1, T2> a, const char *b)
1342 {
1344  *a.clone(), *new sc_lv_base(b), 3);
1345 }
1346 
1347 template <class T1, class T2>
1348 inline sc_concref_r<sc_lv_base, sc_concref_r<T1, T2> >
1349 concat(const char *a, sc_concref<T1, T2> b)
1350 {
1352  *new sc_lv_base(a), *b.clone(), 3);
1353 }
1354 
1355 template <class T1, class T2>
1356 inline sc_concref_r<sc_concref_r<T1, T2>, sc_lv_base>
1357 concat(sc_concref<T1, T2> a, const sc_logic &b)
1358 {
1360  *a.clone(), *new sc_lv_base(b, 1), 3);
1361 }
1362 
1363 template <class T1, class T2>
1364 inline sc_concref_r<sc_lv_base, sc_concref_r<T1, T2> >
1365 concat(const sc_logic &a, sc_concref<T1, T2> b)
1366 {
1368  *new sc_lv_base(a, 1), *b.clone(), 3);
1369 }
1370 
1371 template <class T1, class T2>
1372 inline sc_concref_r<sc_concref_r<T1, T2>, sc_bv_base>
1373 concat(sc_concref<T1, T2> a, bool b)
1374 {
1376  *a.clone(), *new sc_bv_base(b, 1), 3);
1377 }
1378 
1379 template <class T1, class T2>
1380 inline sc_concref_r<sc_bv_base, sc_concref_r<T1, T2> >
1381 concat(bool a, sc_concref<T1, T2> b)
1382 {
1384  *new sc_bv_base(a, 1), *b.clone(), 3);
1385 }
1386 
1387 
1388 // ----------------------------------------------------------------------------
1389 // CLASS TEMPLATE : sc_proxy<T>
1390 //
1391 // Base class template for bit/logic vector classes.
1392 // (Barton/Nackmann implementation)
1393 // ----------------------------------------------------------------------------
1394 
1395 // r-value concatenation operators and functions
1396 
1397 template <class T>
1399 operator , (const sc_proxy<T> &a, const char *b)
1400 {
1401  return sc_concref_r<T, sc_lv_base>(a.back_cast(), *new sc_lv_base(b), 2);
1402 }
1403 
1404 template <class T>
1405 inline sc_concref_r<sc_lv_base, T>
1406 operator , (const char *a, const sc_proxy<T> &b)
1408  return sc_concref_r<sc_lv_base, T>(*new sc_lv_base(a), b.back_cast(), 1);
1409 }
1410 
1411 template <class T>
1412 inline sc_concref_r<T, sc_lv_base>
1413 operator , (const sc_proxy<T> &a, const sc_logic &b)
1414 {
1416  a.back_cast(), *new sc_lv_base(b, 1), 2);
1417 }
1418 
1419 template <class T>
1420 inline sc_concref_r<sc_lv_base, T>
1421 operator , (const sc_logic &a, const sc_proxy<T> &b)
1422 {
1423  return sc_concref_r<sc_lv_base, T>(
1424  *new sc_lv_base(a, 1), b.back_cast(), 1);
1425 }
1426 
1427 template <class T>
1428 inline sc_concref_r<T, sc_bv_base>
1429 operator , (const sc_proxy<T> &a, bool b)
1430 {
1431  return sc_concref_r<T, sc_bv_base>(
1432  a.back_cast(), *new sc_bv_base(b, 1), 2);
1434 
1435 template <class T>
1436 inline sc_concref_r<sc_bv_base, T>
1437 operator , (bool a, const sc_proxy<T> &b)
1438 {
1439  return sc_concref_r<sc_bv_base, T>(
1440  *new sc_bv_base(a, 1), b.back_cast(), 1);
1441 }
1442 
1443 template <class T>
1444 inline sc_concref_r<T, sc_lv_base>
1445 concat(const sc_proxy<T> &a, const char *b)
1446 {
1447  return sc_concref_r<T, sc_lv_base>(a.back_cast(), *new sc_lv_base(b), 2);
1448 }
1449 
1450 template <class T>
1451 inline sc_concref_r<sc_lv_base, T>
1452 concat(const char *a, const sc_proxy<T> &b)
1453 {
1454  return sc_concref_r<sc_lv_base, T>(*new sc_lv_base(a), b.back_cast(), 1);
1456 
1457 template <class T>
1458 inline sc_concref_r<T, sc_lv_base>
1459 concat(const sc_proxy<T> &a, const sc_logic &b)
1460 {
1461  return sc_concref_r<T, sc_lv_base>(
1462  a.back_cast(), *new sc_lv_base(b, 1), 2);
1464 
1465 template <class T>
1466 inline sc_concref_r<sc_lv_base, T>
1467 concat(const sc_logic &a, const sc_proxy<T> &b)
1468 {
1469  return sc_concref_r<sc_lv_base, T>(
1470  *new sc_lv_base(a, 1), b.back_cast(), 1);
1472 
1473 template <class T>
1474 inline sc_concref_r<T, sc_bv_base>
1475 concat(const sc_proxy<T> &a, bool b)
1476 {
1477  return sc_concref_r<T, sc_bv_base>(
1478  a.back_cast(), *new sc_bv_base(b, 1), 2);
1480 
1481 template <class T>
1482 inline sc_concref_r<sc_bv_base, T>
1483 concat(bool a, const sc_proxy<T> &b)
1484 {
1485  return sc_concref_r<sc_bv_base, T>(
1486  *new sc_bv_base(a, 1), b.back_cast(), 1);
1487 }
1488 
1489 
1490 template <class T>
1491 inline sc_concref_r<T, sc_lv_base>
1492 operator , (sc_proxy<T> &a, const char *b)
1494  return sc_concref_r<T, sc_lv_base>(a.back_cast(), *new sc_lv_base(b), 2);
1495 }
1496 
1497 template <class T>
1498 inline sc_concref_r<sc_lv_base, T>
1499 operator , (const char *a, sc_proxy<T> &b)
1500 {
1501  return sc_concref_r<sc_lv_base, T>(*new sc_lv_base(a), b.back_cast(), 1);
1502 }
1503 
1504 template <class T>
1505 inline sc_concref_r<T, sc_lv_base>
1506 operator , (sc_proxy<T> &a, const sc_logic &b)
1507 {
1508  return sc_concref_r<T, sc_lv_base>(
1509  a.back_cast(), *new sc_lv_base(b, 1), 2);
1510 }
1511 
1512 template <class T>
1513 inline sc_concref_r<sc_lv_base, T>
1514 operator , (const sc_logic &a, sc_proxy<T> &b)
1515 {
1516  return sc_concref_r<sc_lv_base, T>(
1517  *new sc_lv_base(a, 1), b.back_cast(), 1);
1518 }
1519 
1520 template <class T>
1521 inline sc_concref_r<T, sc_bv_base>
1522 operator , (sc_proxy<T> &a, bool b)
1523 {
1524  return sc_concref_r<T, sc_bv_base>(
1525  a.back_cast(), *new sc_bv_base(b, 1), 2);
1527 
1528 template <class T>
1529 inline sc_concref_r<sc_bv_base, T>
1530 operator , (bool a, sc_proxy<T> &b)
1531 {
1532  return sc_concref_r<sc_bv_base, T>(
1533  *new sc_bv_base(a, 1), b.back_cast(), 1);
1534 }
1535 
1536 
1537 template <class T>
1538 inline sc_concref_r<T, sc_lv_base>
1539 concat(sc_proxy<T> &a, const char *b)
1541  return sc_concref_r<T, sc_lv_base>(a.back_cast(), *new sc_lv_base(b), 2);
1542 }
1543 
1544 template <class T>
1545 inline sc_concref_r<sc_lv_base, T>
1546 concat(const char *a, sc_proxy<T> &b)
1547 {
1548  return sc_concref_r<sc_lv_base, T>(*new sc_lv_base(a), b.back_cast(), 1);
1549 }
1550 
1551 template <class T>
1552 inline sc_concref_r<T, sc_lv_base>
1553 concat(sc_proxy<T> &a, const sc_logic &b)
1554 {
1555  return sc_concref_r<T, sc_lv_base>(
1556  a.back_cast(), *new sc_lv_base(b, 1), 2);
1557 }
1558 
1559 template <class T>
1560 inline sc_concref_r<sc_lv_base, T>
1561 concat(const sc_logic &a, sc_proxy<T> &b)
1562 {
1563  return sc_concref_r<sc_lv_base, T>(
1564  *new sc_lv_base(a, 1), b.back_cast(), 1);
1565 }
1566 
1567 template <class T>
1568 inline sc_concref_r<T, sc_bv_base>
1569 concat(sc_proxy<T> &a, bool b)
1570 {
1571  return sc_concref_r<T, sc_bv_base>(
1572  a.back_cast(), *new sc_bv_base(b, 1), 2);
1574 
1575 template <class T>
1576 inline sc_concref_r<sc_bv_base, T>
1577 concat(bool a, sc_proxy<T> &b)
1578 {
1579  return sc_concref_r<sc_bv_base, T>(
1580  *new sc_bv_base(a, 1), b.back_cast(), 1);
1581 }
1582 
1583 // extern template instantiations
1584 extern template class sc_proxy<sc_lv_base>;
1585 extern template class sc_proxy<sc_bv_base>;
1586 
1587 } // namespace sc_dt
1588 
1589 #endif // __SYSTEMC_EXT_DT_BIT_SC_LV_BASE_HH__
sc_dt::sc_lv_base::assign_from_string
void assign_from_string(const std::string &)
Definition: sc_lv_base.cc:145
gem5::ArmISA::len
Bitfield< 18, 16 > len
Definition: misc_types.hh:444
sc_dt::operator|
sc_signed operator|(const sc_unsigned &u, const sc_int_base &v)
Definition: sc_signed.cc:791
gem5::MipsISA::w
Bitfield< 0 > w
Definition: pra_constants.hh:281
DEFN_BITWISE_AND_ASN_OP_T
#define DEFN_BITWISE_AND_ASN_OP_T(tp)
Definition: sc_lv_base.hh:367
sc_dt::operator|=
X & operator|=(sc_proxy< X > &px, const sc_proxy< Y > &py)
Definition: sc_lv_base.hh:450
sc_dt::SC_DIGIT_ZERO
const sc_digit SC_DIGIT_ZERO
Definition: sc_proxy.hh:139
sc_dt::b_and_assign_
X & b_and_assign_(sc_proxy< X > &px, const sc_proxy< Y > &py)
Definition: sc_proxy.hh:975
DEFN_BITWISE_OR_OP_T_A
#define DEFN_BITWISE_OR_OP_T_A(tp)
Definition: sc_lv_base.hh:489
sc_dt::sc_lv_base::init
void init(int length_, const sc_logic &init_value=SC_LOGIC_X)
Definition: sc_lv_base.cc:121
sc_dt
Definition: sc_bit.cc:67
sc_dt::sc_lv_base::clean_tail
void clean_tail()
Definition: sc_lv_base.hh:326
sc_dt::sc_lv_base::operator=
sc_lv_base & operator=(const sc_proxy< X > &a)
Definition: sc_lv_base.hh:163
sc_dt::sc_lv_base::length
int length() const
Definition: sc_lv_base.hh:263
sc_dt::sc_digit
unsigned int sc_digit
Definition: sc_nbdefs.hh:197
sc_dt::b_xor_assign_
X & b_xor_assign_(sc_proxy< X > &a, const sc_proxy< Y > &b)
Definition: sc_proxy.hh:1017
sc_dt::sc_proxy::back_cast
X & back_cast()
Definition: sc_proxy.hh:246
sc_dt::sc_lv_base::m_len
int m_len
Definition: sc_lv_base.hh:296
DEFN_BITWISE_XOR_ASN_OP_T
#define DEFN_BITWISE_XOR_ASN_OP_T(tp)
Definition: sc_lv_base.hh:549
sc_dt::sc_bv_base
Definition: sc_bv_base.hh:105
DEFN_BITWISE_AND_OP_T_A
#define DEFN_BITWISE_AND_OP_T_A(tp)
Definition: sc_lv_base.hh:398
sc_dt::sc_int_base
Definition: sc_int_base.hh:494
gem5::ArmISA::a
Bitfield< 8 > a
Definition: misc_types.hh:65
sc_dt::sc_lv_base::sc_lv_base
sc_lv_base(int length_=sc_length_param().len())
Definition: sc_lv_base.hh:131
sc_dt::sc_lv_base::get_bit
value_type get_bit(int i) const
Definition: sc_lv_base.hh:305
sc_dt::operator&=
X & operator&=(sc_proxy< X > &px, const sc_proxy< Y > &py)
Definition: sc_lv_base.hh:359
sc_bv_base.hh
sc_dt::sc_concref_r
Definition: sc_bit_proxies.hh:76
sc_dt::sc_lv_base::is_01
bool is_01() const
Definition: sc_lv_base.cc:202
sc_dt::sc_signed
Definition: sc_signed.hh:984
sc_dt::sc_logic
Definition: sc_logic.hh:130
sc_dt::operator^
sc_signed operator^(const sc_unsigned &u, const sc_int_base &v)
Definition: sc_signed.cc:822
sc_dt::sc_lv_base::get_word
sc_digit get_word(int wi) const
Definition: sc_lv_base.hh:269
gem5::ArmISA::i
Bitfield< 7 > i
Definition: misc_types.hh:66
gem5::PowerISA::bi
Bitfield< 20, 16 > bi
Definition: types.hh:80
sc_assert
#define sc_assert(expr)
Definition: sc_report_handler.hh:135
sc_dt::operator==
bool operator==(const sc_signed &u, const sc_int_base &v)
Definition: sc_signed.cc:879
sc_dt::sc_proxy::rrotate
X & rrotate(int n)
Definition: sc_lv_base.hh:684
sc_dt::sc_lv_base::sc_bv_base
friend class sc_bv_base
Definition: sc_lv_base.hh:120
sc_dt::assign_p_
void assign_p_(sc_proxy< X > &px, const sc_proxy< Y > &py)
Definition: sc_proxy.hh:671
DEFN_BITWISE_XOR_OP_T_A
#define DEFN_BITWISE_XOR_OP_T_A(tp)
Definition: sc_lv_base.hh:580
sc_dt::sc_proxy::operator>>
const sc_lv_base operator>>(int n) const
Definition: sc_lv_base.hh:642
sc_dt::sc_lv_base::base_type
sc_proxy< sc_lv_base > base_type
Definition: sc_lv_base.hh:127
gem5::ArmISA::b
Bitfield< 7 > b
Definition: misc_types.hh:381
sc_dt::uint64
uint64_t uint64
Definition: sc_nbdefs.hh:206
sc_dt::sc_lv_base::m_ctrl
sc_digit * m_ctrl
Definition: sc_lv_base.hh:299
sc_dt::SC_LOGIC_X
const sc_logic SC_LOGIC_X(Log_X)
Definition: sc_logic.hh:402
sc_dt::SC_DIGIT_ONE
const sc_digit SC_DIGIT_ONE
Definition: sc_proxy.hh:140
sc_dt::lrotate
const sc_lv_base lrotate(const sc_proxy< X > &x, int n)
Definition: sc_lv_base.hh:675
sc_dt::sc_proxy::lrotate
X & lrotate(int n)
Definition: sc_lv_base.hh:651
sc_dt::b_or_assign_
X & b_or_assign_(sc_proxy< X > &px, const sc_proxy< Y > &py)
Definition: sc_proxy.hh:996
sc_dt::sc_proxy
Definition: sc_proxy.hh:119
DEFN_BITWISE_XOR_OP_T_B
#define DEFN_BITWISE_XOR_OP_T_B(tp)
Definition: sc_lv_base.hh:605
sc_dt::sc_subref_r
Definition: sc_bit_proxies.hh:72
sc_dt::sc_proxy::operator<<
const sc_lv_base operator<<(int n) const
Definition: sc_lv_base.hh:632
sc_dt::sc_lv_base::set_cword
void set_cword(int wi, sc_digit w)
Definition: sc_lv_base.hh:285
sc_dt::reverse
const sc_lv_base reverse(const sc_proxy< X > &x)
Definition: sc_lv_base.hh:717
gem5::ArmISA::mask
Bitfield< 3, 0 > mask
Definition: pcstate.hh:63
sc_dt::sc_proxy::operator~
const sc_lv_base operator~() const
Definition: sc_lv_base.hh:350
sc_dt::int64
int64_t int64
Definition: sc_nbdefs.hh:205
sc_dt::sc_lv_base::m_data
sc_digit * m_data
Definition: sc_lv_base.hh:298
gem5::ArmISA::t
Bitfield< 5 > t
Definition: misc_types.hh:70
sc_dt::sc_lv_base::set_word
void set_word(int wi, sc_digit w)
Definition: sc_lv_base.hh:276
DEFN_BITWISE_OR_ASN_OP_T
#define DEFN_BITWISE_OR_ASN_OP_T(tp)
Definition: sc_lv_base.hh:458
sc_dt::sc_min
const T sc_min(const T &a, const T &b)
Definition: functions.hh:59
sc_dt::sc_lv_base::get_cword
sc_digit get_cword(int wi) const
Definition: sc_lv_base.hh:282
sc_dt::sc_uint_base
Definition: sc_uint_base.hh:465
sc_dt::sc_lv_base::set_bit
void set_bit(int i, value_type value)
Definition: sc_lv_base.hh:314
gem5::MipsISA::px
Bitfield< 23 > px
Definition: pra_constants.hh:116
sc_dt::operator,
sc_concref_r< sc_bitref_r< T1 >, sc_bitref_r< T2 > > operator,(sc_bitref_r< T1 >, sc_bitref_r< T2 >)
Definition: sc_bit_proxies.hh:1862
sc_dt::rrotate
const sc_lv_base rrotate(const sc_proxy< X > &x, int n)
Definition: sc_lv_base.hh:708
sc_dt::sc_lv_base::value_type
base_type::value_type value_type
Definition: sc_lv_base.hh:128
sc_dt::sc_lv_base
Definition: sc_lv_base.hh:118
sc_dt::sc_subref
Definition: sc_bit_proxies.hh:74
sc_dt::concat
sc_concref_r< sc_bitref_r< T1 >, sc_bitref_r< T2 > > concat(sc_bitref_r< T1 >, sc_bitref_r< T2 >)
Definition: sc_bit_proxies.hh:1927
gem5::RiscvISA::x
Bitfield< 3 > x
Definition: pagetable.hh:73
sc_dt::sc_subref::operator=
sc_subref< X > & operator=(const sc_proxy< Y > &a)
Definition: sc_bit_proxies.hh:903
sc_dt::sc_proxy< sc_lv_base >::assign_
sc_lv_base & assign_(const sc_proxy< Y > &a)
Definition: sc_proxy.hh:253
gem5::ArmISA::n
Bitfield< 31 > n
Definition: misc_types.hh:455
DEFN_REL_OP_T
#define DEFN_REL_OP_T(tp)
Definition: sc_lv_base.hh:745
sc_dt::operator^=
X & operator^=(sc_proxy< X > &px, const sc_proxy< Y > &py)
Definition: sc_lv_base.hh:541
sc_dt::sc_lv_base::m_size
int m_size
Definition: sc_lv_base.hh:297
sc_dt::sc_lv_base::~sc_lv_base
virtual ~sc_lv_base()
Definition: sc_lv_base.hh:158
sc_dt::sc_unsigned
Definition: sc_unsigned.hh:890
sc_dt::SC_DIGIT_SIZE
const int SC_DIGIT_SIZE
Definition: sc_proxy.hh:137
sc_dt::sc_lv_base::size
int size() const
Definition: sc_lv_base.hh:264
DEFN_BITWISE_OR_OP_T_B
#define DEFN_BITWISE_OR_OP_T_B(tp)
Definition: sc_lv_base.hh:514
sc_dt::sc_proxy< sc_lv_base >::value_type
traits_type::value_type value_type
Definition: sc_proxy.hh:240
DEFN_BITWISE_AND_OP_T_B
#define DEFN_BITWISE_AND_OP_T_B(tp)
Definition: sc_lv_base.hh:423
sc_logic.hh
gem5::X86ISA::X
Bitfield< 15, 0 > X
Definition: int.hh:55
sc_dt::SC_DIGIT_TWO
const sc_digit SC_DIGIT_TWO
Definition: sc_proxy.hh:141
sc_dt::operator&
sc_signed operator&(const sc_unsigned &u, const sc_int_base &v)
Definition: sc_signed.cc:760
sc_dt::sc_proxy_out_of_bounds
void sc_proxy_out_of_bounds(const char *msg, int64 val)
Definition: sc_lv_base.cc:96

Generated on Tue Sep 21 2021 12:25:52 for gem5 by doxygen 1.8.17