kernel/rtlil.h

   1 /* -*- c++ -*-
   2  *  yosys -- Yosys Open SYnthesis Suite
   3  *
   4  *  Copyright (C) 2012  Claire Xenia Wolf <claire@yosyshq.com>
   5  *
   6  *  Permission to use, copy, modify, and/or distribute this software for any
   7  *  purpose with or without fee is hereby granted, provided that the above
   8  *  copyright notice and this permission notice appear in all copies.
   9  *
  10  *  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
  11  *  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  12  *  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
  13  *  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  14  *  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  15  *  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  16  *  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  17  *
  18  */
  19
  20 #include "kernel/yosys.h"
  21
  22 #ifndef RTLIL_H
  23 #define RTLIL_H
  24
  25 YOSYS_NAMESPACE_BEGIN
  26
  27 namespace RTLIL
  28 {
  29         enum State : unsigned char {
  30                 S0 = 0,
  31                 S1 = 1,
  32                 Sx = 2, // undefined value or conflict
  33                 Sz = 3, // high-impedance / not-connected
  34                 Sa = 4, // don't care (used only in cases)
  35                 Sm = 5  // marker (used internally by some passes)
  36         };
  37
  38         enum SyncType : unsigned char {
  39                 ST0 = 0, // level sensitive: 0
  40                 ST1 = 1, // level sensitive: 1
  41                 STp = 2, // edge sensitive: posedge
  42                 STn = 3, // edge sensitive: negedge
  43                 STe = 4, // edge sensitive: both edges
  44                 STa = 5, // always active
  45                 STg = 6, // global clock
  46                 STi = 7  // init
  47         };
  48
  49         enum ConstFlags : unsigned char {
  50                 CONST_FLAG_NONE   = 0,
  51                 CONST_FLAG_STRING = 1,
  52                 CONST_FLAG_SIGNED = 2,  // only used for parameters
  53                 CONST_FLAG_REAL   = 4   // only used for parameters
  54         };
  55
  56         struct Const;
  57         struct AttrObject;
  58         struct Selection;
  59         struct Monitor;
  60         struct Design;
  61         struct Module;
  62         struct Wire;
  63         struct Memory;
  64         struct Cell;
  65         struct SigChunk;
  66         struct SigBit;
  67         struct SigSpecIterator;
  68         struct SigSpecConstIterator;
  69         struct SigSpec;
  70         struct CaseRule;
  71         struct SwitchRule;
  72         struct MemWriteAction;
  73         struct SyncRule;
  74         struct Process;
  75         struct Binding;
  76
  77         typedef std::pair<SigSpec, SigSpec> SigSig;
  78
  79         struct IdString
  80         {
  81                 #undef YOSYS_XTRACE_GET_PUT
  82                 #undef YOSYS_SORT_ID_FREE_LIST
  83                 #undef YOSYS_USE_STICKY_IDS
  84                 #undef YOSYS_NO_IDS_REFCNT
  85
  86                 // the global id string cache
  87
  88                 static struct destruct_guard_t {
  89                         bool ok; // POD, will be initialized to zero
  90                         destruct_guard_t() { ok = true; }
  91                         ~destruct_guard_t() { ok = false; }
  92                 } destruct_guard;
  93
  94                 static std::vector<char*> global_id_storage_;
  95                 static dict<char*, int, hash_cstr_ops> global_id_index_;
  96         #ifndef YOSYS_NO_IDS_REFCNT
  97                 static std::vector<int> global_refcount_storage_;
  98                 static std::vector<int> global_free_idx_list_;
  99         #endif
 100
 101         #ifdef YOSYS_USE_STICKY_IDS
 102                 static int last_created_idx_ptr_;
 103                 static int last_created_idx_[8];
 104         #endif
 105
 106                 static inline void xtrace_db_dump()
 107                 {
 108                 #ifdef YOSYS_XTRACE_GET_PUT
 109                         for (int idx = 0; idx < GetSize(global_id_storage_); idx++)
 110                         {
 111                                 if (global_id_storage_.at(idx) == nullptr)
 112                                         log("#X# DB-DUMP index %d: FREE\n", idx);
 113                                 else
 114                                         log("#X# DB-DUMP index %d: '%s' (ref %d)\n", idx, global_id_storage_.at(idx), global_refcount_storage_.at(idx));
 115                         }
 116                 #endif
 117                 }
 118
 119                 static inline void checkpoint()
 120                 {
 121                 #ifdef YOSYS_USE_STICKY_IDS
 122                         last_created_idx_ptr_ = 0;
 123                         for (int i = 0; i < 8; i++) {
 124                                 if (last_created_idx_[i])
 125                                         put_reference(last_created_idx_[i]);
 126                                 last_created_idx_[i] = 0;
 127                         }
 128                 #endif
 129                 #ifdef YOSYS_SORT_ID_FREE_LIST
 130                         std::sort(global_free_idx_list_.begin(), global_free_idx_list_.end(), std::greater<int>());
 131                 #endif
 132                 }
 133
 134                 static inline int get_reference(int idx)
 135                 {
 136                         if (idx) {
 137                 #ifndef YOSYS_NO_IDS_REFCNT
 138                                 global_refcount_storage_[idx]++;
 139                 #endif
 140                 #ifdef YOSYS_XTRACE_GET_PUT
 141                                 if (yosys_xtrace)
 142                                         log("#X# GET-BY-INDEX '%s' (index %d, refcount %d)\n", global_id_storage_.at(idx), idx, global_refcount_storage_.at(idx));
 143                 #endif
 144                         }
 145                         return idx;
 146                 }
 147
 148                 static int get_reference(const char *p)
 149                 {
 150                         log_assert(destruct_guard.ok);
 151
 152                         if (!p[0])
 153                                 return 0;
 154
 155                         auto it = global_id_index_.find((char*)p);
 156                         if (it != global_id_index_.end()) {
 157                 #ifndef YOSYS_NO_IDS_REFCNT
 158                                 global_refcount_storage_.at(it->second)++;
 159                 #endif
 160                 #ifdef YOSYS_XTRACE_GET_PUT
 161                                 if (yosys_xtrace)
 162                                         log("#X# GET-BY-NAME '%s' (index %d, refcount %d)\n", global_id_storage_.at(it->second), it->second, global_refcount_storage_.at(it->second));
 163                 #endif
 164                                 return it->second;
 165                         }
 166
 167                         log_assert(p[0] == '$' || p[0] == '\\');
 168                         log_assert(p[1] != 0);
 169                         for (const char *c = p; *c; c++)
 170                                 if ((unsigned)*c <= (unsigned)' ')
 171                                         log_error("Found control character or space (0x%02hhx) in string '%s' which is not allowed in RTLIL identifiers\n", *c, p);
 172
 173                 #ifndef YOSYS_NO_IDS_REFCNT
 174                         if (global_free_idx_list_.empty()) {
 175                                 if (global_id_storage_.empty()) {
 176                                         global_refcount_storage_.push_back(0);
 177                                         global_id_storage_.push_back((char*)"");
 178                                         global_id_index_[global_id_storage_.back()] = 0;
 179                                 }
 180                                 log_assert(global_id_storage_.size() < 0x40000000);
 181                                 global_free_idx_list_.push_back(global_id_storage_.size());
 182                                 global_id_storage_.push_back(nullptr);
 183                                 global_refcount_storage_.push_back(0);
 184                         }
 185
 186                         int idx = global_free_idx_list_.back();
 187                         global_free_idx_list_.pop_back();
 188                         global_id_storage_.at(idx) = strdup(p);
 189                         global_id_index_[global_id_storage_.at(idx)] = idx;
 190                         global_refcount_storage_.at(idx)++;
 191                 #else
 192                         if (global_id_storage_.empty()) {
 193                                 global_id_storage_.push_back((char*)"");
 194                                 global_id_index_[global_id_storage_.back()] = 0;
 195                         }
 196                         int idx = global_id_storage_.size();
 197                         global_id_storage_.push_back(strdup(p));
 198                         global_id_index_[global_id_storage_.back()] = idx;
 199                 #endif
 200
 201                         if (yosys_xtrace) {
 202                                 log("#X# New IdString '%s' with index %d.\n", p, idx);
 203                                 log_backtrace("-X- ", yosys_xtrace-1);
 204                         }
 205
 206                 #ifdef YOSYS_XTRACE_GET_PUT
 207                         if (yosys_xtrace)
 208                                 log("#X# GET-BY-NAME '%s' (index %d, refcount %d)\n", global_id_storage_.at(idx), idx, global_refcount_storage_.at(idx));
 209                 #endif
 210
 211                 #ifdef YOSYS_USE_STICKY_IDS
 212                         // Avoid Create->Delete->Create pattern
 213                         if (last_created_idx_[last_created_idx_ptr_])
 214                                 put_reference(last_created_idx_[last_created_idx_ptr_]);
 215                         last_created_idx_[last_created_idx_ptr_] = idx;
 216                         get_reference(last_created_idx_[last_created_idx_ptr_]);
 217                         last_created_idx_ptr_ = (last_created_idx_ptr_ + 1) & 7;
 218                 #endif
 219
 220                         return idx;
 221                 }
 222
 223         #ifndef YOSYS_NO_IDS_REFCNT
 224                 static inline void put_reference(int idx)
 225                 {
 226                         // put_reference() may be called from destructors after the destructor of
 227                         // global_refcount_storage_ has been run. in this case we simply do nothing.
 228                         if (!destruct_guard.ok || !idx)
 229                                 return;
 230
 231                 #ifdef YOSYS_XTRACE_GET_PUT
 232                         if (yosys_xtrace) {
 233                                 log("#X# PUT '%s' (index %d, refcount %d)\n", global_id_storage_.at(idx), idx, global_refcount_storage_.at(idx));
 234                         }
 235                 #endif
 236
 237                         int &refcount = global_refcount_storage_[idx];
 238
 239                         if (--refcount > 0)
 240                                 return;
 241
 242                         log_assert(refcount == 0);
 243                         free_reference(idx);
 244                 }
 245                 static inline void free_reference(int idx)
 246                 {
 247                         if (yosys_xtrace) {
 248                                 log("#X# Removed IdString '%s' with index %d.\n", global_id_storage_.at(idx), idx);
 249                                 log_backtrace("-X- ", yosys_xtrace-1);
 250                         }
 251
 252                         global_id_index_.erase(global_id_storage_.at(idx));
 253                         free(global_id_storage_.at(idx));
 254                         global_id_storage_.at(idx) = nullptr;
 255                         global_free_idx_list_.push_back(idx);
 256                 }
 257         #else
 258                 static inline void put_reference(int) { }
 259         #endif
 260
 261                 // the actual IdString object is just is a single int
 262
 263                 int index_;
 264
 265                 inline IdString() : index_(0) { }
 266                 inline IdString(const char *str) : index_(get_reference(str)) { }
 267                 inline IdString(const IdString &str) : index_(get_reference(str.index_)) { }
 268                 inline IdString(IdString &&str) : index_(str.index_) { str.index_ = 0; }
 269                 inline IdString(const std::string &str) : index_(get_reference(str.c_str())) { }
 270                 inline ~IdString() { put_reference(index_); }
 271
 272                 inline void operator=(const IdString &rhs) {
 273                         put_reference(index_);
 274                         index_ = get_reference(rhs.index_);
 275                 }
 276
 277                 inline void operator=(const char *rhs) {
 278                         IdString id(rhs);
 279                         *this = id;
 280                 }
 281
 282                 inline void operator=(const std::string &rhs) {
 283                         IdString id(rhs);
 284                         *this = id;
 285                 }
 286
 287                 inline const char *c_str() const {
 288                         return global_id_storage_.at(index_);
 289                 }
 290
 291                 inline std::string str() const {
 292                         return std::string(global_id_storage_.at(index_));
 293                 }
 294
 295                 inline bool operator<(const IdString &rhs) const {
 296                         return index_ < rhs.index_;
 297                 }
 298
 299                 inline bool operator==(const IdString &rhs) const { return index_ == rhs.index_; }
 300                 inline bool operator!=(const IdString &rhs) const { return index_ != rhs.index_; }
 301
 302                 // The methods below are just convenience functions for better compatibility with std::string.
 303
 304                 bool operator==(const std::string &rhs) const { return c_str() == rhs; }
 305                 bool operator!=(const std::string &rhs) const { return c_str() != rhs; }
 306
 307                 bool operator==(const char *rhs) const { return strcmp(c_str(), rhs) == 0; }
 308                 bool operator!=(const char *rhs) const { return strcmp(c_str(), rhs) != 0; }
 309
 310                 char operator[](size_t i) const {
 311                         const char *p = c_str();
 312                         for (; i != 0; i--, p++)
 313                                 log_assert(*p != 0);
 314                         return *p;
 315                 }
 316
 317                 std::string substr(size_t pos = 0, size_t len = std::string::npos) const {
 318                         if (len == std::string::npos || len >= strlen(c_str() + pos))
 319                                 return std::string(c_str() + pos);
 320                         else
 321                                 return std::string(c_str() + pos, len);
 322                 }
 323
 324                 int compare(size_t pos, size_t len, const char* s) const {
 325                         return strncmp(c_str()+pos, s, len);
 326                 }
 327
 328                 bool begins_with(const char* prefix) const {
 329                         size_t len = strlen(prefix);
 330                         if (size() < len) return false;
 331                         return compare(0, len, prefix) == 0;
 332                 }
 333
 334                 bool ends_with(const char* suffix) const {
 335                         size_t len = strlen(suffix);
 336                         if (size() < len) return false;
 337                         return compare(size()-len, len, suffix) == 0;
 338                 }
 339
 340                 bool contains(const char* str) const {
 341                         return strstr(c_str(), str);
 342                 }
 343
 344                 size_t size() const {
 345                         return strlen(c_str());
 346                 }
 347
 348                 bool empty() const {
 349                         return c_str()[0] == 0;
 350                 }
 351
 352                 void clear() {
 353                         *this = IdString();
 354                 }
 355
 356                 unsigned int hash() const {
 357                         return index_;
 358                 }
 359
 360                 // The following is a helper key_compare class. Instead of for example std::set<Cell*>
 361                 // use std::set<Cell*, IdString::compare_ptr_by_name<Cell>> if the order of cells in the
 362                 // set has an influence on the algorithm.
 363
 364                 template<typename T> struct compare_ptr_by_name {
 365                         bool operator()(const T *a, const T *b) const {
 366                                 return (a == nullptr || b == nullptr) ? (a < b) : (a->name < b->name);
 367                         }
 368                 };
 369
 370                 // often one needs to check if a given IdString is part of a list (for example a list
 371                 // of cell types). the following functions helps with that.
 372
 373                 template<typename... Args>
 374                 bool in(Args... args) const {
 375                         // Credit: https://articles.emptycrate.com/2016/05/14/folds_in_cpp11_ish.html
 376                         bool result = false;
 377                         (void) std::initializer_list<int>{ (result = result || in(args), 0)... };
 378                         return result;
 379                 }
 380
 381                 bool in(const IdString &rhs) const { return *this == rhs; }
 382                 bool in(const char *rhs) const { return *this == rhs; }
 383                 bool in(const std::string &rhs) const { return *this == rhs; }
 384                 bool in(const pool<IdString> &rhs) const { return rhs.count(*this) != 0; }
 385
 386                 bool isPublic() const { return begins_with("\\"); }
 387         };
 388
 389         namespace ID {
 390 #define X(_id) extern IdString _id;
 391 #include "kernel/constids.inc"
 392 #undef X
 393         };
 394
 395         extern dict<std::string, std::string> constpad;
 396
 397         const pool<IdString> &builtin_ff_cell_types();
 398
 399         static inline std::string escape_id(const std::string &str) {
 400                 if (str.size() > 0 && str[0] != '\\' && str[0] != '$')
 401                         return "\\" + str;
 402                 return str;
 403         }
 404
 405         static inline std::string unescape_id(const std::string &str) {
 406                 if (str.size() < 2)
 407                         return str;
 408                 if (str[0] != '\\')
 409                         return str;
 410                 if (str[1] == '$' || str[1] == '\\')
 411                         return str;
 412                 if (str[1] >= '0' && str[1] <= '9')
 413                         return str;
 414                 return str.substr(1);
 415         }
 416
 417         static inline std::string unescape_id(RTLIL::IdString str) {
 418                 return unescape_id(str.str());
 419         }
 420
 421         static inline const char *id2cstr(RTLIL::IdString str) {
 422                 return log_id(str);
 423         }
 424
 425         template <typename T> struct sort_by_name_id {
 426                 bool operator()(T *a, T *b) const {
 427                         return a->name < b->name;
 428                 }
 429         };
 430
 431         template <typename T> struct sort_by_name_str {
 432                 bool operator()(T *a, T *b) const {
 433                         return strcmp(a->name.c_str(), b->name.c_str()) < 0;
 434                 }
 435         };
 436
 437         struct sort_by_id_str {
 438                 bool operator()(RTLIL::IdString a, RTLIL::IdString b) const {
 439                         return strcmp(a.c_str(), b.c_str()) < 0;
 440                 }
 441         };
 442
 443         // see calc.cc for the implementation of this functions
 444         RTLIL::Const const_not         (const RTLIL::Const &arg1, const RTLIL::Const &arg2, bool signed1, bool signed2, int result_len);
 445         RTLIL::Const const_and         (const RTLIL::Const &arg1, const RTLIL::Const &arg2, bool signed1, bool signed2, int result_len);
 446         RTLIL::Const const_or          (const RTLIL::Const &arg1, const RTLIL::Const &arg2, bool signed1, bool signed2, int result_len);
 447         RTLIL::Const const_xor         (const RTLIL::Const &arg1, const RTLIL::Const &arg2, bool signed1, bool signed2, int result_len);
 448         RTLIL::Const const_xnor        (const RTLIL::Const &arg1, const RTLIL::Const &arg2, bool signed1, bool signed2, int result_len);
 449
 450         RTLIL::Const const_reduce_and  (const RTLIL::Const &arg1, const RTLIL::Const &arg2, bool signed1, bool signed2, int result_len);
 451         RTLIL::Const const_reduce_or   (const RTLIL::Const &arg1, const RTLIL::Const &arg2, bool signed1, bool signed2, int result_len);
 452         RTLIL::Const const_reduce_xor  (const RTLIL::Const &arg1, const RTLIL::Const &arg2, bool signed1, bool signed2, int result_len);
 453         RTLIL::Const const_reduce_xnor (const RTLIL::Const &arg1, const RTLIL::Const &arg2, bool signed1, bool signed2, int result_len);
 454         RTLIL::Const const_reduce_bool (const RTLIL::Const &arg1, const RTLIL::Const &arg2, bool signed1, bool signed2, int result_len);
 455
 456         RTLIL::Const const_logic_not   (const RTLIL::Const &arg1, const RTLIL::Const &arg2, bool signed1, bool signed2, int result_len);
 457         RTLIL::Const const_logic_and   (const RTLIL::Const &arg1, const RTLIL::Const &arg2, bool signed1, bool signed2, int result_len);
 458         RTLIL::Const const_logic_or    (const RTLIL::Const &arg1, const RTLIL::Const &arg2, bool signed1, bool signed2, int result_len);
 459
 460         RTLIL::Const const_shl         (const RTLIL::Const &arg1, const RTLIL::Const &arg2, bool signed1, bool signed2, int result_len);
 461         RTLIL::Const const_shr         (const RTLIL::Const &arg1, const RTLIL::Const &arg2, bool signed1, bool signed2, int result_len);
 462         RTLIL::Const const_sshl        (const RTLIL::Const &arg1, const RTLIL::Const &arg2, bool signed1, bool signed2, int result_len);
 463         RTLIL::Const const_sshr        (const RTLIL::Const &arg1, const RTLIL::Const &arg2, bool signed1, bool signed2, int result_len);
 464         RTLIL::Const const_shift       (const RTLIL::Const &arg1, const RTLIL::Const &arg2, bool signed1, bool signed2, int result_len);
 465         RTLIL::Const const_shiftx      (const RTLIL::Const &arg1, const RTLIL::Const &arg2, bool signed1, bool signed2, int result_len);
 466
 467         RTLIL::Const const_lt          (const RTLIL::Const &arg1, const RTLIL::Const &arg2, bool signed1, bool signed2, int result_len);
 468         RTLIL::Const const_le          (const RTLIL::Const &arg1, const RTLIL::Const &arg2, bool signed1, bool signed2, int result_len);
 469         RTLIL::Const const_eq          (const RTLIL::Const &arg1, const RTLIL::Const &arg2, bool signed1, bool signed2, int result_len);
 470         RTLIL::Const const_ne          (const RTLIL::Const &arg1, const RTLIL::Const &arg2, bool signed1, bool signed2, int result_len);
 471         RTLIL::Const const_eqx         (const RTLIL::Const &arg1, const RTLIL::Const &arg2, bool signed1, bool signed2, int result_len);
 472         RTLIL::Const const_nex         (const RTLIL::Const &arg1, const RTLIL::Const &arg2, bool signed1, bool signed2, int result_len);
 473         RTLIL::Const const_ge          (const RTLIL::Const &arg1, const RTLIL::Const &arg2, bool signed1, bool signed2, int result_len);
 474         RTLIL::Const const_gt          (const RTLIL::Const &arg1, const RTLIL::Const &arg2, bool signed1, bool signed2, int result_len);
 475
 476         RTLIL::Const const_add         (const RTLIL::Const &arg1, const RTLIL::Const &arg2, bool signed1, bool signed2, int result_len);
 477         RTLIL::Const const_sub         (const RTLIL::Const &arg1, const RTLIL::Const &arg2, bool signed1, bool signed2, int result_len);
 478         RTLIL::Const const_mul         (const RTLIL::Const &arg1, const RTLIL::Const &arg2, bool signed1, bool signed2, int result_len);
 479         RTLIL::Const const_div         (const RTLIL::Const &arg1, const RTLIL::Const &arg2, bool signed1, bool signed2, int result_len);
 480         RTLIL::Const const_divfloor    (const RTLIL::Const &arg1, const RTLIL::Const &arg2, bool signed1, bool signed2, int result_len);
 481         RTLIL::Const const_modfloor    (const RTLIL::Const &arg1, const RTLIL::Const &arg2, bool signed1, bool signed2, int result_len);
 482         RTLIL::Const const_mod         (const RTLIL::Const &arg1, const RTLIL::Const &arg2, bool signed1, bool signed2, int result_len);
 483         RTLIL::Const const_pow         (const RTLIL::Const &arg1, const RTLIL::Const &arg2, bool signed1, bool signed2, int result_len);
 484
 485         RTLIL::Const const_pos         (const RTLIL::Const &arg1, const RTLIL::Const &arg2, bool signed1, bool signed2, int result_len);
 486         RTLIL::Const const_neg         (const RTLIL::Const &arg1, const RTLIL::Const &arg2, bool signed1, bool signed2, int result_len);
 487
 488
 489         // This iterator-range-pair is used for Design::modules(), Module::wires() and Module::cells().
 490         // It maintains a reference counter that is used to make sure that the container is not modified while being iterated over.
 491
 492         template<typename T>
 493         struct ObjIterator {
 494                 using iterator_category = std::forward_iterator_tag;
 495                 using value_type = T;
 496                 using difference_type = ptrdiff_t;
 497                 using pointer = T*;
 498                 using reference = T&;
 499                 typename dict<RTLIL::IdString, T>::iterator it;
 500                 dict<RTLIL::IdString, T> *list_p;
 501                 int *refcount_p;
 502
 503                 ObjIterator() : list_p(nullptr), refcount_p(nullptr) {
 504                 }
 505
 506                 ObjIterator(decltype(list_p) list_p, int *refcount_p) : list_p(list_p), refcount_p(refcount_p) {
 507                         if (list_p->empty()) {
 508                                 this->list_p = nullptr;
 509                                 this->refcount_p = nullptr;
 510                         } else {
 511                                 it = list_p->begin();
 512                                 (*refcount_p)++;
 513                         }
 514                 }
 515
 516                 ObjIterator(const RTLIL::ObjIterator<T> &other) {
 517                         it = other.it;
 518                         list_p = other.list_p;
 519                         refcount_p = other.refcount_p;
 520                         if (refcount_p)
 521                                 (*refcount_p)++;
 522                 }
 523
 524                 ObjIterator &operator=(const RTLIL::ObjIterator<T> &other) {
 525                         if (refcount_p)
 526                                 (*refcount_p)--;
 527                         it = other.it;
 528                         list_p = other.list_p;
 529                         refcount_p = other.refcount_p;
 530                         if (refcount_p)
 531                                 (*refcount_p)++;
 532                         return *this;
 533                 }
 534
 535                 ~ObjIterator() {
 536                         if (refcount_p)
 537                                 (*refcount_p)--;
 538                 }
 539
 540                 inline T operator*() const {
 541                         log_assert(list_p != nullptr);
 542                         return it->second;
 543                 }
 544
 545                 inline bool operator!=(const RTLIL::ObjIterator<T> &other) const {
 546                         if (list_p == nullptr || other.list_p == nullptr)
 547                                 return list_p != other.list_p;
 548                         return it != other.it;
 549                 }
 550
 551
 552                 inline bool operator==(const RTLIL::ObjIterator<T> &other) const {
 553                         return !(*this != other);
 554                 }
 555
 556                 inline ObjIterator<T>& operator++() {
 557                         log_assert(list_p != nullptr);
 558                         if (++it == list_p->end()) {
 559                                 (*refcount_p)--;
 560                                 list_p = nullptr;
 561                                 refcount_p = nullptr;
 562                         }
 563                         return *this;
 564                 }
 565
 566                 inline ObjIterator<T>& operator+=(int amt) {
 567                         log_assert(list_p != nullptr);
 568                         it += amt;
 569                         if (it == list_p->end()) {
 570                                 (*refcount_p)--;
 571                                 list_p = nullptr;
 572                                 refcount_p = nullptr;
 573                         }
 574                         return *this;
 575                 }
 576
 577                 inline ObjIterator<T> operator+(int amt) {
 578                         log_assert(list_p != nullptr);
 579                         ObjIterator<T> new_obj(*this);
 580                         new_obj.it += amt;
 581                         if (new_obj.it == list_p->end()) {
 582                                 (*(new_obj.refcount_p))--;
 583                                 new_obj.list_p = nullptr;
 584                                 new_obj.refcount_p = nullptr;
 585                         }
 586                         return new_obj;
 587                 }
 588
 589                 inline const ObjIterator<T> operator++(int) {
 590                         ObjIterator<T> result(*this);
 591                         ++(*this);
 592                         return result;
 593                 }
 594         };
 595
 596         template<typename T>
 597         struct ObjRange
 598         {
 599                 dict<RTLIL::IdString, T> *list_p;
 600                 int *refcount_p;
 601
 602                 ObjRange(decltype(list_p) list_p, int *refcount_p) : list_p(list_p), refcount_p(refcount_p) { }
 603                 RTLIL::ObjIterator<T> begin() { return RTLIL::ObjIterator<T>(list_p, refcount_p); }
 604                 RTLIL::ObjIterator<T> end() { return RTLIL::ObjIterator<T>(); }
 605
 606                 size_t size() const {
 607                         return list_p->size();
 608                 }
 609
 610                 operator pool<T>() const {
 611                         pool<T> result;
 612                         for (auto &it : *list_p)
 613                                 result.insert(it.second);
 614                         return result;
 615                 }
 616
 617                 operator std::vector<T>() const {
 618                         std::vector<T> result;
 619                         result.reserve(list_p->size());
 620                         for (auto &it : *list_p)
 621                                 result.push_back(it.second);
 622                         return result;
 623                 }
 624
 625                 pool<T> to_pool() const { return *this; }
 626                 std::vector<T> to_vector() const { return *this; }
 627         };
 628 };
 629
 630 struct RTLIL::Const
 631 {
 632         int flags;
 633         std::vector<RTLIL::State> bits;
 634
 635         Const();
 636         Const(std::string str);
 637         Const(int val, int width = 32);
 638         Const(RTLIL::State bit, int width = 1);
 639         Const(const std::vector<RTLIL::State> &bits) : bits(bits) { flags = CONST_FLAG_NONE; }
 640         Const(const std::vector<bool> &bits);
 641         Const(const RTLIL::Const &c);
 642         RTLIL::Const &operator =(const RTLIL::Const &other) = default;
 643
 644         bool operator <(const RTLIL::Const &other) const;
 645         bool operator ==(const RTLIL::Const &other) const;
 646         bool operator !=(const RTLIL::Const &other) const;
 647
 648         bool as_bool() const;
 649         int as_int(bool is_signed = false) const;
 650         std::string as_string() const;
 651         static Const from_string(const std::string &str);
 652
 653         std::string decode_string() const;
 654
 655         inline int size() const { return bits.size(); }
 656         inline bool empty() const { return bits.empty(); }
 657         inline RTLIL::State &operator[](int index) { return bits.at(index); }
 658         inline const RTLIL::State &operator[](int index) const { return bits.at(index); }
 659         inline decltype(bits)::iterator begin() { return bits.begin(); }
 660         inline decltype(bits)::iterator end() { return bits.end(); }
 661
 662         bool is_fully_zero() const;
 663         bool is_fully_ones() const;
 664         bool is_fully_def() const;
 665         bool is_fully_undef() const;
 666         bool is_onehot(int *pos = nullptr) const;
 667
 668         inline RTLIL::Const extract(int offset, int len = 1, RTLIL::State padding = RTLIL::State::S0) const {
 669                 RTLIL::Const ret;
 670                 ret.bits.reserve(len);
 671                 for (int i = offset; i < offset + len; i++)
 672                         ret.bits.push_back(i < GetSize(bits) ? bits[i] : padding);
 673                 return ret;
 674         }
 675
 676         void extu(int width) {
 677                 bits.resize(width, RTLIL::State::S0);
 678         }
 679
 680         void exts(int width) {
 681                 bits.resize(width, bits.empty() ? RTLIL::State::Sx : bits.back());
 682         }
 683
 684         inline unsigned int hash() const {
 685                 unsigned int h = mkhash_init;
 686                 for (auto b : bits)
 687                         mkhash(h, b);
 688                 return h;
 689         }
 690 };
 691
 692 struct RTLIL::AttrObject
 693 {
 694         dict<RTLIL::IdString, RTLIL::Const> attributes;
 695
 696         bool has_attribute(RTLIL::IdString id) const;
 697
 698         void set_bool_attribute(RTLIL::IdString id, bool value=true);
 699         bool get_bool_attribute(RTLIL::IdString id) const;
 700
 701         bool get_blackbox_attribute(bool ignore_wb=false) const {
 702                 return get_bool_attribute(ID::blackbox) || (!ignore_wb && get_bool_attribute(ID::whitebox));
 703         }
 704
 705         void set_string_attribute(RTLIL::IdString id, string value);
 706         string get_string_attribute(RTLIL::IdString id) const;
 707
 708         void set_strpool_attribute(RTLIL::IdString id, const pool<string> &data);
 709         void add_strpool_attribute(RTLIL::IdString id, const pool<string> &data);
 710         pool<string> get_strpool_attribute(RTLIL::IdString id) const;
 711
 712         void set_src_attribute(const std::string &src) {
 713                 set_string_attribute(ID::src, src);
 714         }
 715         std::string get_src_attribute() const {
 716                 return get_string_attribute(ID::src);
 717         }
 718
 719         void set_hdlname_attribute(const vector<string> &hierarchy);
 720         vector<string> get_hdlname_attribute() const;
 721
 722         void set_intvec_attribute(RTLIL::IdString id, const vector<int> &data);
 723         vector<int> get_intvec_attribute(RTLIL::IdString id) const;
 724 };
 725
 726 struct RTLIL::SigChunk
 727 {
 728         RTLIL::Wire *wire;
 729         std::vector<RTLIL::State> data; // only used if wire == NULL, LSB at index 0
 730         int width, offset;
 731
 732         SigChunk();
 733         SigChunk(const RTLIL::Const &value);
 734         SigChunk(RTLIL::Wire *wire);
 735         SigChunk(RTLIL::Wire *wire, int offset, int width = 1);
 736         SigChunk(const std::string &str);
 737         SigChunk(int val, int width = 32);
 738         SigChunk(RTLIL::State bit, int width = 1);
 739         SigChunk(const RTLIL::SigBit &bit);
 740         SigChunk(const RTLIL::SigChunk &sigchunk);
 741         RTLIL::SigChunk &operator =(const RTLIL::SigChunk &other) = default;
 742
 743         RTLIL::SigChunk extract(int offset, int length) const;
 744         inline int size() const { return width; }
 745         inline bool is_wire() const { return wire != NULL; }
 746
 747         bool operator <(const RTLIL::SigChunk &other) const;
 748         bool operator ==(const RTLIL::SigChunk &other) const;
 749         bool operator !=(const RTLIL::SigChunk &other) const;
 750 };
 751
 752 struct RTLIL::SigBit
 753 {
 754         RTLIL::Wire *wire;
 755         union {
 756                 RTLIL::State data; // used if wire == NULL
 757                 int offset;        // used if wire != NULL
 758         };
 759
 760         SigBit();
 761         SigBit(RTLIL::State bit);
 762         explicit SigBit(bool bit);
 763         SigBit(RTLIL::Wire *wire);
 764         SigBit(RTLIL::Wire *wire, int offset);
 765         SigBit(const RTLIL::SigChunk &chunk);
 766         SigBit(const RTLIL::SigChunk &chunk, int index);
 767         SigBit(const RTLIL::SigSpec &sig);
 768         SigBit(const RTLIL::SigBit &sigbit) = default;
 769         RTLIL::SigBit &operator =(const RTLIL::SigBit &other) = default;
 770
 771         inline bool is_wire() const { return wire != NULL; }
 772
 773         bool operator <(const RTLIL::SigBit &other) const;
 774         bool operator ==(const RTLIL::SigBit &other) const;
 775         bool operator !=(const RTLIL::SigBit &other) const;
 776         unsigned int hash() const;
 777 };
 778
 779 struct RTLIL::SigSpecIterator : public std::iterator<std::input_iterator_tag, RTLIL::SigSpec>
 780 {
 781         RTLIL::SigSpec *sig_p;
 782         int index;
 783
 784         inline RTLIL::SigBit &operator*() const;
 785         inline bool operator!=(const RTLIL::SigSpecIterator &other) const { return index != other.index; }
 786         inline bool operator==(const RTLIL::SigSpecIterator &other) const { return index == other.index; }
 787         inline void operator++() { index++; }
 788 };
 789
 790 struct RTLIL::SigSpecConstIterator : public std::iterator<std::input_iterator_tag, RTLIL::SigSpec>
 791 {
 792         const RTLIL::SigSpec *sig_p;
 793         int index;
 794
 795         inline const RTLIL::SigBit &operator*() const;
 796         inline bool operator!=(const RTLIL::SigSpecConstIterator &other) const { return index != other.index; }
 797         inline bool operator==(const RTLIL::SigSpecIterator &other) const { return index == other.index; }
 798         inline void operator++() { index++; }
 799 };
 800
 801 struct RTLIL::SigSpec
 802 {
 803 private:
 804         int width_;
 805         unsigned long hash_;
 806         std::vector<RTLIL::SigChunk> chunks_; // LSB at index 0
 807         std::vector<RTLIL::SigBit> bits_; // LSB at index 0
 808
 809         void pack() const;
 810         void unpack() const;
 811         void updhash() const;
 812
 813         inline bool packed() const {
 814                 return bits_.empty();
 815         }
 816
 817         inline void inline_unpack() const {
 818                 if (!chunks_.empty())
 819                         unpack();
 820         }
 821
 822         // Only used by Module::remove(const pool<Wire*> &wires)
 823         // but cannot be more specific as it isn't yet declared
 824         friend struct RTLIL::Module;
 825
 826 public:
 827         SigSpec();
 828         SigSpec(const RTLIL::SigSpec &other);
 829         SigSpec(std::initializer_list<RTLIL::SigSpec> parts);
 830         RTLIL::SigSpec &operator=(const RTLIL::SigSpec &other);
 831
 832         SigSpec(const RTLIL::Const &value);
 833         SigSpec(const RTLIL::SigChunk &chunk);
 834         SigSpec(RTLIL::Wire *wire);
 835         SigSpec(RTLIL::Wire *wire, int offset, int width = 1);
 836         SigSpec(const std::string &str);
 837         SigSpec(int val, int width = 32);
 838         SigSpec(RTLIL::State bit, int width = 1);
 839         SigSpec(const RTLIL::SigBit &bit, int width = 1);
 840         SigSpec(const std::vector<RTLIL::SigChunk> &chunks);
 841         SigSpec(const std::vector<RTLIL::SigBit> &bits);
 842         SigSpec(const pool<RTLIL::SigBit> &bits);
 843         SigSpec(const std::set<RTLIL::SigBit> &bits);
 844         explicit SigSpec(bool bit);
 845
 846         SigSpec(RTLIL::SigSpec &&other) {
 847                 width_ = other.width_;
 848                 hash_ = other.hash_;
 849                 chunks_ = std::move(other.chunks_);
 850                 bits_ = std::move(other.bits_);
 851         }
 852
 853         const RTLIL::SigSpec &operator=(RTLIL::SigSpec &&other) {
 854                 width_ = other.width_;
 855                 hash_ = other.hash_;
 856                 chunks_ = std::move(other.chunks_);
 857                 bits_ = std::move(other.bits_);
 858                 return *this;
 859         }
 860
 861         size_t get_hash() const {
 862                 if (!hash_) hash();
 863                 return hash_;
 864         }
 865
 866         inline const std::vector<RTLIL::SigChunk> &chunks() const { pack(); return chunks_; }
 867         inline const std::vector<RTLIL::SigBit> &bits() const { inline_unpack(); return bits_; }
 868
 869         inline int size() const { return width_; }
 870         inline bool empty() const { return width_ == 0; }
 871
 872         inline RTLIL::SigBit &operator[](int index) { inline_unpack(); return bits_.at(index); }
 873         inline const RTLIL::SigBit &operator[](int index) const { inline_unpack(); return bits_.at(index); }
 874
 875         inline RTLIL::SigSpecIterator begin() { RTLIL::SigSpecIterator it; it.sig_p = this; it.index = 0; return it; }
 876         inline RTLIL::SigSpecIterator end() { RTLIL::SigSpecIterator it; it.sig_p = this; it.index = width_; return it; }
 877
 878         inline RTLIL::SigSpecConstIterator begin() const { RTLIL::SigSpecConstIterator it; it.sig_p = this; it.index = 0; return it; }
 879         inline RTLIL::SigSpecConstIterator end() const { RTLIL::SigSpecConstIterator it; it.sig_p = this; it.index = width_; return it; }
 880
 881         void sort();
 882         void sort_and_unify();
 883
 884         void replace(const RTLIL::SigSpec &pattern, const RTLIL::SigSpec &with);
 885         void replace(const RTLIL::SigSpec &pattern, const RTLIL::SigSpec &with, RTLIL::SigSpec *other) const;
 886
 887         void replace(const dict<RTLIL::SigBit, RTLIL::SigBit> &rules);
 888         void replace(const dict<RTLIL::SigBit, RTLIL::SigBit> &rules, RTLIL::SigSpec *other) const;
 889
 890         void replace(const std::map<RTLIL::SigBit, RTLIL::SigBit> &rules);
 891         void replace(const std::map<RTLIL::SigBit, RTLIL::SigBit> &rules, RTLIL::SigSpec *other) const;
 892
 893         void replace(int offset, const RTLIL::SigSpec &with);
 894
 895         void remove(const RTLIL::SigSpec &pattern);
 896         void remove(const RTLIL::SigSpec &pattern, RTLIL::SigSpec *other) const;
 897         void remove2(const RTLIL::SigSpec &pattern, RTLIL::SigSpec *other);
 898
 899         void remove(const pool<RTLIL::SigBit> &pattern);
 900         void remove(const pool<RTLIL::SigBit> &pattern, RTLIL::SigSpec *other) const;
 901         void remove2(const pool<RTLIL::SigBit> &pattern, RTLIL::SigSpec *other);
 902         void remove2(const std::set<RTLIL::SigBit> &pattern, RTLIL::SigSpec *other);
 903
 904         void remove(int offset, int length = 1);
 905         void remove_const();
 906
 907         RTLIL::SigSpec extract(const RTLIL::SigSpec &pattern, const RTLIL::SigSpec *other = NULL) const;
 908         RTLIL::SigSpec extract(const pool<RTLIL::SigBit> &pattern, const RTLIL::SigSpec *other = NULL) const;
 909         RTLIL::SigSpec extract(int offset, int length = 1) const;
 910         RTLIL::SigSpec extract_end(int offset) const { return extract(offset, width_ - offset); }
 911
 912         void append(const RTLIL::SigSpec &signal);
 913         inline void append(Wire *wire) { append(RTLIL::SigSpec(wire)); }
 914         inline void append(const RTLIL::SigChunk &chunk) { append(RTLIL::SigSpec(chunk)); }
 915         inline void append(const RTLIL::Const &const_) { append(RTLIL::SigSpec(const_)); }
 916
 917         void append(const RTLIL::SigBit &bit);
 918         inline void append(RTLIL::State state) { append(RTLIL::SigBit(state)); }
 919         inline void append(bool bool_) { append(RTLIL::SigBit(bool_)); }
 920
 921         void extend_u0(int width, bool is_signed = false);
 922
 923         RTLIL::SigSpec repeat(int num) const;
 924
 925         void reverse() { inline_unpack(); std::reverse(bits_.begin(), bits_.end()); }
 926
 927         bool operator <(const RTLIL::SigSpec &other) const;
 928         bool operator ==(const RTLIL::SigSpec &other) const;
 929         inline bool operator !=(const RTLIL::SigSpec &other) const { return !(*this == other); }
 930
 931         bool is_wire() const;
 932         bool is_chunk() const;
 933         inline bool is_bit() const { return width_ == 1; }
 934
 935         bool is_fully_const() const;
 936         bool is_fully_zero() const;
 937         bool is_fully_ones() const;
 938         bool is_fully_def() const;
 939         bool is_fully_undef() const;
 940         bool has_const() const;
 941         bool has_marked_bits() const;
 942         bool is_onehot(int *pos = nullptr) const;
 943
 944         bool as_bool() const;
 945         int as_int(bool is_signed = false) const;
 946         std::string as_string() const;
 947         RTLIL::Const as_const() const;
 948         RTLIL::Wire *as_wire() const;
 949         RTLIL::SigChunk as_chunk() const;
 950         RTLIL::SigBit as_bit() const;
 951
 952         bool match(const char* pattern) const;
 953
 954         std::set<RTLIL::SigBit> to_sigbit_set() const;
 955         pool<RTLIL::SigBit> to_sigbit_pool() const;
 956         std::vector<RTLIL::SigBit> to_sigbit_vector() const;
 957         std::map<RTLIL::SigBit, RTLIL::SigBit> to_sigbit_map(const RTLIL::SigSpec &other) const;
 958         dict<RTLIL::SigBit, RTLIL::SigBit> to_sigbit_dict(const RTLIL::SigSpec &other) const;
 959
 960         static bool parse(RTLIL::SigSpec &sig, RTLIL::Module *module, std::string str);
 961         static bool parse_sel(RTLIL::SigSpec &sig, RTLIL::Design *design, RTLIL::Module *module, std::string str);
 962         static bool parse_rhs(const RTLIL::SigSpec &lhs, RTLIL::SigSpec &sig, RTLIL::Module *module, std::string str);
 963
 964         operator std::vector<RTLIL::SigChunk>() const { return chunks(); }
 965         operator std::vector<RTLIL::SigBit>() const { return bits(); }
 966         const RTLIL::SigBit &at(int offset, const RTLIL::SigBit &defval) { return offset < width_ ? (*this)[offset] : defval; }
 967
 968         unsigned int hash() const { if (!hash_) updhash(); return hash_; };
 969
 970 #ifndef NDEBUG
 971         void check(Module *mod = nullptr) const;
 972 #else
 973         void check(Module *mod = nullptr) const { (void)mod; }
 974 #endif
 975 };
 976
 977 struct RTLIL::Selection
 978 {
 979         bool full_selection;
 980         pool<RTLIL::IdString> selected_modules;
 981         dict<RTLIL::IdString, pool<RTLIL::IdString>> selected_members;
 982
 983         Selection(bool full = true) : full_selection(full) { }
 984
 985         bool selected_module(RTLIL::IdString mod_name) const;
 986         bool selected_whole_module(RTLIL::IdString mod_name) const;
 987         bool selected_member(RTLIL::IdString mod_name, RTLIL::IdString memb_name) const;
 988         void optimize(RTLIL::Design *design);
 989
 990         template<typename T1> void select(T1 *module) {
 991                 if (!full_selection && selected_modules.count(module->name) == 0) {
 992                         selected_modules.insert(module->name);
 993                         selected_members.erase(module->name);
 994                 }
 995         }
 996
 997         template<typename T1, typename T2> void select(T1 *module, T2 *member) {
 998                 if (!full_selection && selected_modules.count(module->name) == 0)
 999                         selected_members[module->name].insert(member->name);
1000         }
1001
1002         bool empty() const {
1003                 return !full_selection && selected_modules.empty() && selected_members.empty();
1004         }
1005 };
1006
1007 struct RTLIL::Monitor
1008 {
1009         unsigned int hashidx_;
1010         unsigned int hash() const { return hashidx_; }
1011
1012         Monitor() {
1013                 static unsigned int hashidx_count = 123456789;
1014                 hashidx_count = mkhash_xorshift(hashidx_count);
1015                 hashidx_ = hashidx_count;
1016         }
1017
1018         virtual ~Monitor() { }
1019         virtual void notify_module_add(RTLIL::Module*) { }
1020         virtual void notify_module_del(RTLIL::Module*) { }
1021         virtual void notify_connect(RTLIL::Cell*, const RTLIL::IdString&, const RTLIL::SigSpec&, const RTLIL::SigSpec&) { }
1022         virtual void notify_connect(RTLIL::Module*, const RTLIL::SigSig&) { }
1023         virtual void notify_connect(RTLIL::Module*, const std::vector<RTLIL::SigSig>&) { }
1024         virtual void notify_blackout(RTLIL::Module*) { }
1025 };
1026
1027 // Forward declaration; defined in preproc.h.
1028 struct define_map_t;
1029
1030 struct RTLIL::Design
1031 {
1032         unsigned int hashidx_;
1033         unsigned int hash() const { return hashidx_; }
1034
1035         pool<RTLIL::Monitor*> monitors;
1036         dict<std::string, std::string> scratchpad;
1037
1038         int refcount_modules_;
1039         dict<RTLIL::IdString, RTLIL::Module*> modules_;
1040         std::vector<RTLIL::Binding*> bindings_;
1041
1042         std::vector<AST::AstNode*> verilog_packages, verilog_globals;
1043         std::unique_ptr<define_map_t> verilog_defines;
1044
1045         std::vector<RTLIL::Selection> selection_stack;
1046         dict<RTLIL::IdString, RTLIL::Selection> selection_vars;
1047         std::string selected_active_module;
1048
1049         Design();
1050         ~Design();
1051
1052         RTLIL::ObjRange<RTLIL::Module*> modules();
1053         RTLIL::Module *module(RTLIL::IdString name);
1054         const RTLIL::Module *module(RTLIL::IdString name) const;
1055         RTLIL::Module *top_module();
1056
1057         bool has(RTLIL::IdString id) const {
1058                 return modules_.count(id) != 0;
1059         }
1060
1061         void add(RTLIL::Module *module);
1062         void add(RTLIL::Binding *binding);
1063
1064         RTLIL::Module *addModule(RTLIL::IdString name);
1065         void remove(RTLIL::Module *module);
1066         void rename(RTLIL::Module *module, RTLIL::IdString new_name);
1067
1068         void scratchpad_unset(const std::string &varname);
1069
1070         void scratchpad_set_int(const std::string &varname, int value);
1071         void scratchpad_set_bool(const std::string &varname, bool value);
1072         void scratchpad_set_string(const std::string &varname, std::string value);
1073
1074         int scratchpad_get_int(const std::string &varname, int default_value = 0) const;
1075         bool scratchpad_get_bool(const std::string &varname, bool default_value = false) const;
1076         std::string scratchpad_get_string(const std::string &varname, const std::string &default_value = std::string()) const;
1077
1078         void sort();
1079         void check();
1080         void optimize();
1081
1082         bool selected_module(RTLIL::IdString mod_name) const;
1083         bool selected_whole_module(RTLIL::IdString mod_name) const;
1084         bool selected_member(RTLIL::IdString mod_name, RTLIL::IdString memb_name) const;
1085
1086         bool selected_module(RTLIL::Module *mod) const;
1087         bool selected_whole_module(RTLIL::Module *mod) const;
1088
1089         RTLIL::Selection &selection() {
1090                 return selection_stack.back();
1091         }
1092
1093         const RTLIL::Selection &selection() const {
1094                 return selection_stack.back();
1095         }
1096
1097         bool full_selection() const {
1098                 return selection_stack.back().full_selection;
1099         }
1100
1101         template<typename T1> bool selected(T1 *module) const {
1102                 return selected_module(module->name);
1103         }
1104
1105         template<typename T1, typename T2> bool selected(T1 *module, T2 *member) const {
1106                 return selected_member(module->name, member->name);
1107         }
1108
1109         template<typename T1> void select(T1 *module) {
1110                 if (selection_stack.size() > 0) {
1111                         RTLIL::Selection &sel = selection_stack.back();
1112                         sel.select(module);
1113                 }
1114         }
1115
1116         template<typename T1, typename T2> void select(T1 *module, T2 *member) {
1117                 if (selection_stack.size() > 0) {
1118                         RTLIL::Selection &sel = selection_stack.back();
1119                         sel.select(module, member);
1120                 }
1121         }
1122
1123
1124         std::vector<RTLIL::Module*> selected_modules() const;
1125         std::vector<RTLIL::Module*> selected_whole_modules() const;
1126         std::vector<RTLIL::Module*> selected_whole_modules_warn(bool include_wb = false) const;
1127 #ifdef WITH_PYTHON
1128         static std::map<unsigned int, RTLIL::Design*> *get_all_designs(void);
1129 #endif
1130 };
1131
1132 struct RTLIL::Module : public RTLIL::AttrObject
1133 {
1134         unsigned int hashidx_;
1135         unsigned int hash() const { return hashidx_; }
1136
1137 protected:
1138         void add(RTLIL::Wire *wire);
1139         void add(RTLIL::Cell *cell);
1140         void add(RTLIL::Process *process);
1141
1142 public:
1143         RTLIL::Design *design;
1144         pool<RTLIL::Monitor*> monitors;
1145
1146         int refcount_wires_;
1147         int refcount_cells_;
1148
1149         dict<RTLIL::IdString, RTLIL::Wire*> wires_;
1150         dict<RTLIL::IdString, RTLIL::Cell*> cells_;
1151
1152         std::vector<RTLIL::SigSig>   connections_;
1153         std::vector<RTLIL::Binding*> bindings_;
1154
1155         RTLIL::IdString name;
1156         idict<RTLIL::IdString> avail_parameters;
1157         dict<RTLIL::IdString, RTLIL::Const> parameter_default_values;
1158         dict<RTLIL::IdString, RTLIL::Memory*> memories;
1159         dict<RTLIL::IdString, RTLIL::Process*> processes;
1160
1161         Module();
1162         virtual ~Module();
1163         virtual RTLIL::IdString derive(RTLIL::Design *design, const dict<RTLIL::IdString, RTLIL::Const> &parameters, bool mayfail = false);
1164         virtual RTLIL::IdString derive(RTLIL::Design *design, const dict<RTLIL::IdString, RTLIL::Const> &parameters, const dict<RTLIL::IdString, RTLIL::Module*> &interfaces, const dict<RTLIL::IdString, RTLIL::IdString> &modports, bool mayfail = false);
1165         virtual size_t count_id(RTLIL::IdString id);
1166         virtual void expand_interfaces(RTLIL::Design *design, const dict<RTLIL::IdString, RTLIL::Module *> &local_interfaces);
1167         virtual bool reprocess_if_necessary(RTLIL::Design *design);
1168
1169         virtual void sort();
1170         virtual void check();
1171         virtual void optimize();
1172         virtual void makeblackbox();
1173
1174         void connect(const RTLIL::SigSig &conn);
1175         void connect(const RTLIL::SigSpec &lhs, const RTLIL::SigSpec &rhs);
1176         void new_connections(const std::vector<RTLIL::SigSig> &new_conn);
1177         const std::vector<RTLIL::SigSig> &connections() const;
1178
1179         std::vector<RTLIL::IdString> ports;
1180         void fixup_ports();
1181
1182         template<typename T> void rewrite_sigspecs(T &functor);
1183         template<typename T> void rewrite_sigspecs2(T &functor);
1184         void cloneInto(RTLIL::Module *new_mod) const;
1185         virtual RTLIL::Module *clone() const;
1186
1187         bool has_memories() const;
1188         bool has_processes() const;
1189
1190         bool has_memories_warn() const;
1191         bool has_processes_warn() const;
1192
1193         std::vector<RTLIL::Wire*> selected_wires() const;
1194         std::vector<RTLIL::Cell*> selected_cells() const;
1195
1196         template<typename T> bool selected(T *member) const {
1197                 return design->selected_member(name, member->name);
1198         }
1199
1200         RTLIL::Wire* wire(RTLIL::IdString id) {
1201                 auto it = wires_.find(id);
1202                 return it == wires_.end() ? nullptr : it->second;
1203         }
1204         RTLIL::Cell* cell(RTLIL::IdString id) {
1205                 auto it = cells_.find(id);
1206                 return it == cells_.end() ? nullptr : it->second;
1207         }
1208
1209         const RTLIL::Wire* wire(RTLIL::IdString id) const{
1210                 auto it = wires_.find(id);
1211                 return it == wires_.end() ? nullptr : it->second;
1212         }
1213         const RTLIL::Cell* cell(RTLIL::IdString id) const {
1214                 auto it = cells_.find(id);
1215                 return it == cells_.end() ? nullptr : it->second;
1216         }
1217
1218         RTLIL::ObjRange<RTLIL::Wire*> wires() { return RTLIL::ObjRange<RTLIL::Wire*>(&wires_, &refcount_wires_); }
1219         RTLIL::ObjRange<RTLIL::Cell*> cells() { return RTLIL::ObjRange<RTLIL::Cell*>(&cells_, &refcount_cells_); }
1220
1221         void add(RTLIL::Binding *binding);
1222
1223         // Removing wires is expensive. If you have to remove wires, remove them all at once.
1224         void remove(const pool<RTLIL::Wire*> &wires);
1225         void remove(RTLIL::Cell *cell);
1226         void remove(RTLIL::Process *process);
1227
1228         void rename(RTLIL::Wire *wire, RTLIL::IdString new_name);
1229         void rename(RTLIL::Cell *cell, RTLIL::IdString new_name);
1230         void rename(RTLIL::IdString old_name, RTLIL::IdString new_name);
1231
1232         void swap_names(RTLIL::Wire *w1, RTLIL::Wire *w2);
1233         void swap_names(RTLIL::Cell *c1, RTLIL::Cell *c2);
1234
1235         RTLIL::IdString uniquify(RTLIL::IdString name);
1236         RTLIL::IdString uniquify(RTLIL::IdString name, int &index);
1237
1238         RTLIL::Wire *addWire(RTLIL::IdString name, int width = 1);
1239         RTLIL::Wire *addWire(RTLIL::IdString name, const RTLIL::Wire *other);
1240
1241         RTLIL::Cell *addCell(RTLIL::IdString name, RTLIL::IdString type);
1242         RTLIL::Cell *addCell(RTLIL::IdString name, const RTLIL::Cell *other);
1243
1244         RTLIL::Memory *addMemory(RTLIL::IdString name, const RTLIL::Memory *other);
1245
1246         RTLIL::Process *addProcess(RTLIL::IdString name);
1247         RTLIL::Process *addProcess(RTLIL::IdString name, const RTLIL::Process *other);
1248
1249         // The add* methods create a cell and return the created cell. All signals must exist in advance.
1250
1251         RTLIL::Cell* addNot (RTLIL::IdString name, const RTLIL::SigSpec &sig_a, const RTLIL::SigSpec &sig_y, bool is_signed = false, const std::string &src = "");
1252         RTLIL::Cell* addPos (RTLIL::IdString name, const RTLIL::SigSpec &sig_a, const RTLIL::SigSpec &sig_y, bool is_signed = false, const std::string &src = "");
1253         RTLIL::Cell* addNeg (RTLIL::IdString name, const RTLIL::SigSpec &sig_a, const RTLIL::SigSpec &sig_y, bool is_signed = false, const std::string &src = "");
1254
1255         RTLIL::Cell* addAnd  (RTLIL::IdString name, const RTLIL::SigSpec &sig_a, const RTLIL::SigSpec &sig_b, const RTLIL::SigSpec &sig_y, bool is_signed = false, const std::string &src = "");
1256         RTLIL::Cell* addOr   (RTLIL::IdString name, const RTLIL::SigSpec &sig_a, const RTLIL::SigSpec &sig_b, const RTLIL::SigSpec &sig_y, bool is_signed = false, const std::string &src = "");
1257         RTLIL::Cell* addXor  (RTLIL::IdString name, const RTLIL::SigSpec &sig_a, const RTLIL::SigSpec &sig_b, const RTLIL::SigSpec &sig_y, bool is_signed = false, const std::string &src = "");
1258         RTLIL::Cell* addXnor (RTLIL::IdString name, const RTLIL::SigSpec &sig_a, const RTLIL::SigSpec &sig_b, const RTLIL::SigSpec &sig_y, bool is_signed = false, const std::string &src = "");
1259
1260         RTLIL::Cell* addReduceAnd  (RTLIL::IdString name, const RTLIL::SigSpec &sig_a, const RTLIL::SigSpec &sig_y, bool is_signed = false, const std::string &src = "");
1261         RTLIL::Cell* addReduceOr   (RTLIL::IdString name, const RTLIL::SigSpec &sig_a, const RTLIL::SigSpec &sig_y, bool is_signed = false, const std::string &src = "");
1262         RTLIL::Cell* addReduceXor  (RTLIL::IdString name, const RTLIL::SigSpec &sig_a, const RTLIL::SigSpec &sig_y, bool is_signed = false, const std::string &src = "");
1263         RTLIL::Cell* addReduceXnor (RTLIL::IdString name, const RTLIL::SigSpec &sig_a, const RTLIL::SigSpec &sig_y, bool is_signed = false, const std::string &src = "");
1264         RTLIL::Cell* addReduceBool (RTLIL::IdString name, const RTLIL::SigSpec &sig_a, const RTLIL::SigSpec &sig_y, bool is_signed = false, const std::string &src = "");
1265
1266         RTLIL::Cell* addShl    (RTLIL::IdString name, const RTLIL::SigSpec &sig_a, const RTLIL::SigSpec &sig_b, const RTLIL::SigSpec &sig_y, bool is_signed = false, const std::string &src = "");
1267         RTLIL::Cell* addShr    (RTLIL::IdString name, const RTLIL::SigSpec &sig_a, const RTLIL::SigSpec &sig_b, const RTLIL::SigSpec &sig_y, bool is_signed = false, const std::string &src = "");
1268         RTLIL::Cell* addSshl   (RTLIL::IdString name, const RTLIL::SigSpec &sig_a, const RTLIL::SigSpec &sig_b, const RTLIL::SigSpec &sig_y, bool is_signed = false, const std::string &src = "");
1269         RTLIL::Cell* addSshr   (RTLIL::IdString name, const RTLIL::SigSpec &sig_a, const RTLIL::SigSpec &sig_b, const RTLIL::SigSpec &sig_y, bool is_signed = false, const std::string &src = "");
1270         RTLIL::Cell* addShift  (RTLIL::IdString name, const RTLIL::SigSpec &sig_a, const RTLIL::SigSpec &sig_b, const RTLIL::SigSpec &sig_y, bool is_signed = false, const std::string &src = "");
1271         RTLIL::Cell* addShiftx (RTLIL::IdString name, const RTLIL::SigSpec &sig_a, const RTLIL::SigSpec &sig_b, const RTLIL::SigSpec &sig_y, bool is_signed = false, const std::string &src = "");
1272
1273         RTLIL::Cell* addLt  (RTLIL::IdString name, const RTLIL::SigSpec &sig_a, const RTLIL::SigSpec &sig_b, const RTLIL::SigSpec &sig_y, bool is_signed = false, const std::string &src = "");
1274         RTLIL::Cell* addLe  (RTLIL::IdString name, const RTLIL::SigSpec &sig_a, const RTLIL::SigSpec &sig_b, const RTLIL::SigSpec &sig_y, bool is_signed = false, const std::string &src = "");
1275         RTLIL::Cell* addEq  (RTLIL::IdString name, const RTLIL::SigSpec &sig_a, const RTLIL::SigSpec &sig_b, const RTLIL::SigSpec &sig_y, bool is_signed = false, const std::string &src = "");
1276         RTLIL::Cell* addNe  (RTLIL::IdString name, const RTLIL::SigSpec &sig_a, const RTLIL::SigSpec &sig_b, const RTLIL::SigSpec &sig_y, bool is_signed = false, const std::string &src = "");
1277         RTLIL::Cell* addEqx (RTLIL::IdString name, const RTLIL::SigSpec &sig_a, const RTLIL::SigSpec &sig_b, const RTLIL::SigSpec &sig_y, bool is_signed = false, const std::string &src = "");
1278         RTLIL::Cell* addNex (RTLIL::IdString name, const RTLIL::SigSpec &sig_a, const RTLIL::SigSpec &sig_b, const RTLIL::SigSpec &sig_y, bool is_signed = false, const std::string &src = "");
1279         RTLIL::Cell* addGe  (RTLIL::IdString name, const RTLIL::SigSpec &sig_a, const RTLIL::SigSpec &sig_b, const RTLIL::SigSpec &sig_y, bool is_signed = false, const std::string &src = "");
1280         RTLIL::Cell* addGt  (RTLIL::IdString name, const RTLIL::SigSpec &sig_a, const RTLIL::SigSpec &sig_b, const RTLIL::SigSpec &sig_y, bool is_signed = false, const std::string &src = "");
1281
1282         RTLIL::Cell* addAdd (RTLIL::IdString name, const RTLIL::SigSpec &sig_a, const RTLIL::SigSpec &sig_b, const RTLIL::SigSpec &sig_y, bool is_signed = false, const std::string &src = "");
1283         RTLIL::Cell* addSub (RTLIL::IdString name, const RTLIL::SigSpec &sig_a, const RTLIL::SigSpec &sig_b, const RTLIL::SigSpec &sig_y, bool is_signed = false, const std::string &src = "");
1284         RTLIL::Cell* addMul (RTLIL::IdString name, const RTLIL::SigSpec &sig_a, const RTLIL::SigSpec &sig_b, const RTLIL::SigSpec &sig_y, bool is_signed = false, const std::string &src = "");
1285         // truncating division
1286         RTLIL::Cell* addDiv (RTLIL::IdString name, const RTLIL::SigSpec &sig_a, const RTLIL::SigSpec &sig_b, const RTLIL::SigSpec &sig_y, bool is_signed = false, const std::string &src = "");
1287         // truncating modulo
1288         RTLIL::Cell* addMod (RTLIL::IdString name, const RTLIL::SigSpec &sig_a, const RTLIL::SigSpec &sig_b, const RTLIL::SigSpec &sig_y, bool is_signed = false, const std::string &src = "");
1289         RTLIL::Cell* addDivFloor (RTLIL::IdString name, const RTLIL::SigSpec &sig_a, const RTLIL::SigSpec &sig_b, const RTLIL::SigSpec &sig_y, bool is_signed = false, const std::string &src = "");
1290         RTLIL::Cell* addModFloor (RTLIL::IdString name, const RTLIL::SigSpec &sig_a, const RTLIL::SigSpec &sig_b, const RTLIL::SigSpec &sig_y, bool is_signed = false, const std::string &src = "");
1291         RTLIL::Cell* addPow (RTLIL::IdString name, const RTLIL::SigSpec &sig_a, const RTLIL::SigSpec &sig_b, const RTLIL::SigSpec &sig_y, bool a_signed = false, bool b_signed = false, const std::string &src = "");
1292
1293         RTLIL::Cell* addLogicNot (RTLIL::IdString name, const RTLIL::SigSpec &sig_a, const RTLIL::SigSpec &sig_y, bool is_signed = false, const std::string &src = "");
1294         RTLIL::Cell* addLogicAnd (RTLIL::IdString name, const RTLIL::SigSpec &sig_a, const RTLIL::SigSpec &sig_b, const RTLIL::SigSpec &sig_y, bool is_signed = false, const std::string &src = "");
1295         RTLIL::Cell* addLogicOr  (RTLIL::IdString name, const RTLIL::SigSpec &sig_a, const RTLIL::SigSpec &sig_b, const RTLIL::SigSpec &sig_y, bool is_signed = false, const std::string &src = "");
1296
1297         RTLIL::Cell* addMux  (RTLIL::IdString name, const RTLIL::SigSpec &sig_a, const RTLIL::SigSpec &sig_b, const RTLIL::SigSpec &sig_s, const RTLIL::SigSpec &sig_y, const std::string &src = "");
1298         RTLIL::Cell* addPmux (RTLIL::IdString name, const RTLIL::SigSpec &sig_a, const RTLIL::SigSpec &sig_b, const RTLIL::SigSpec &sig_s, const RTLIL::SigSpec &sig_y, const std::string &src = "");
1299
1300         RTLIL::Cell* addSlice  (RTLIL::IdString name, const RTLIL::SigSpec &sig_a, const RTLIL::SigSpec &sig_y, RTLIL::Const offset, const std::string &src = "");
1301         RTLIL::Cell* addConcat (RTLIL::IdString name, const RTLIL::SigSpec &sig_a, const RTLIL::SigSpec &sig_b, const RTLIL::SigSpec &sig_y, const std::string &src = "");
1302         RTLIL::Cell* addLut    (RTLIL::IdString name, const RTLIL::SigSpec &sig_a, const RTLIL::SigSpec &sig_y, RTLIL::Const lut, const std::string &src = "");
1303         RTLIL::Cell* addTribuf (RTLIL::IdString name, const RTLIL::SigSpec &sig_a, const RTLIL::SigSpec &sig_en, const RTLIL::SigSpec &sig_y, const std::string &src = "");
1304         RTLIL::Cell* addAssert (RTLIL::IdString name, const RTLIL::SigSpec &sig_a, const RTLIL::SigSpec &sig_en, const std::string &src = "");
1305         RTLIL::Cell* addAssume (RTLIL::IdString name, const RTLIL::SigSpec &sig_a, const RTLIL::SigSpec &sig_en, const std::string &src = "");
1306         RTLIL::Cell* addLive   (RTLIL::IdString name, const RTLIL::SigSpec &sig_a, const RTLIL::SigSpec &sig_en, const std::string &src = "");
1307         RTLIL::Cell* addFair   (RTLIL::IdString name, const RTLIL::SigSpec &sig_a, const RTLIL::SigSpec &sig_en, const std::string &src = "");
1308         RTLIL::Cell* addCover  (RTLIL::IdString name, const RTLIL::SigSpec &sig_a, const RTLIL::SigSpec &sig_en, const std::string &src = "");
1309         RTLIL::Cell* addEquiv  (RTLIL::IdString name, const RTLIL::SigSpec &sig_a, const RTLIL::SigSpec &sig_b, const RTLIL::SigSpec &sig_y, const std::string &src = "");
1310
1311         RTLIL::Cell* addSr    (RTLIL::IdString name, const RTLIL::SigSpec &sig_set, const RTLIL::SigSpec &sig_clr, const RTLIL::SigSpec &sig_q, bool set_polarity = true, bool clr_polarity = true, const std::string &src = "");
1312         RTLIL::Cell* addFf    (RTLIL::IdString name, const RTLIL::SigSpec &sig_d, const RTLIL::SigSpec &sig_q, const std::string &src = "");
1313         RTLIL::Cell* addDff   (RTLIL::IdString name, const RTLIL::SigSpec &sig_clk, const RTLIL::SigSpec &sig_d,   const RTLIL::SigSpec &sig_q, bool clk_polarity = true, const std::string &src = "");
1314         RTLIL::Cell* addDffe  (RTLIL::IdString name, const RTLIL::SigSpec &sig_clk, const RTLIL::SigSpec &sig_en,  const RTLIL::SigSpec &sig_d, const RTLIL::SigSpec &sig_q, bool clk_polarity = true, bool en_polarity = true, const std::string &src = "");
1315         RTLIL::Cell* addDffsr (RTLIL::IdString name, const RTLIL::SigSpec &sig_clk, const RTLIL::SigSpec &sig_set, const RTLIL::SigSpec &sig_clr, RTLIL::SigSpec sig_d, const RTLIL::SigSpec &sig_q, bool clk_polarity = true, bool set_polarity = true, bool clr_polarity = true, const std::string &src = "");
1316         RTLIL::Cell* addDffsre (RTLIL::IdString name, const RTLIL::SigSpec &sig_clk, const RTLIL::SigSpec &sig_en, const RTLIL::SigSpec &sig_set, const RTLIL::SigSpec &sig_clr, RTLIL::SigSpec sig_d, const RTLIL::SigSpec &sig_q, bool clk_polarity = true, bool en_polarity = true, bool set_polarity = true, bool clr_polarity = true, const std::string &src = "");
1317         RTLIL::Cell* addAdff (RTLIL::IdString name, const RTLIL::SigSpec &sig_clk, const RTLIL::SigSpec &sig_arst, const RTLIL::SigSpec &sig_d, const RTLIL::SigSpec &sig_q, RTLIL::Const arst_value, bool clk_polarity = true, bool arst_polarity = true, const std::string &src = "");
1318         RTLIL::Cell* addAdffe (RTLIL::IdString name, const RTLIL::SigSpec &sig_clk, const RTLIL::SigSpec &sig_en, const RTLIL::SigSpec &sig_arst,  const RTLIL::SigSpec &sig_d, const RTLIL::SigSpec &sig_q, RTLIL::Const arst_value, bool clk_polarity = true, bool en_polarity = true, bool arst_polarity = true, const std::string &src = "");
1319         RTLIL::Cell* addAldff (RTLIL::IdString name, const RTLIL::SigSpec &sig_clk, const RTLIL::SigSpec &sig_aload, const RTLIL::SigSpec &sig_d, const RTLIL::SigSpec &sig_q, const RTLIL::SigSpec &sig_ad, bool clk_polarity = true, bool aload_polarity = true, const std::string &src = "");
1320         RTLIL::Cell* addAldffe (RTLIL::IdString name, const RTLIL::SigSpec &sig_clk, const RTLIL::SigSpec &sig_en, const RTLIL::SigSpec &sig_aload,  const RTLIL::SigSpec &sig_d, const RTLIL::SigSpec &sig_q, const RTLIL::SigSpec &sig_ad, bool clk_polarity = true, bool en_polarity = true, bool aload_polarity = true, const std::string &src = "");
1321         RTLIL::Cell* addSdff (RTLIL::IdString name, const RTLIL::SigSpec &sig_clk, const RTLIL::SigSpec &sig_srst, const RTLIL::SigSpec &sig_d, const RTLIL::SigSpec &sig_q, RTLIL::Const srst_value, bool clk_polarity = true, bool srst_polarity = true, const std::string &src = "");
1322         RTLIL::Cell* addSdffe (RTLIL::IdString name, const RTLIL::SigSpec &sig_clk, const RTLIL::SigSpec &sig_en, const RTLIL::SigSpec &sig_srst,  const RTLIL::SigSpec &sig_d, const RTLIL::SigSpec &sig_q, RTLIL::Const srst_value, bool clk_polarity = true, bool en_polarity = true, bool srst_polarity = true, const std::string &src = "");
1323         RTLIL::Cell* addSdffce (RTLIL::IdString name, const RTLIL::SigSpec &sig_clk, const RTLIL::SigSpec &sig_en, const RTLIL::SigSpec &sig_srst, const RTLIL::SigSpec &sig_d, const RTLIL::SigSpec &sig_q, RTLIL::Const srst_value, bool clk_polarity = true, bool en_polarity = true, bool srst_polarity = true, const std::string &src = "");
1324         RTLIL::Cell* addDlatch (RTLIL::IdString name, const RTLIL::SigSpec &sig_en, const RTLIL::SigSpec &sig_d, const RTLIL::SigSpec &sig_q, bool en_polarity = true, const std::string &src = "");
1325         RTLIL::Cell* addAdlatch (RTLIL::IdString name, const RTLIL::SigSpec &sig_en, const RTLIL::SigSpec &sig_arst, const RTLIL::SigSpec &sig_d, const RTLIL::SigSpec &sig_q, RTLIL::Const arst_value, bool en_polarity = true, bool arst_polarity = true, const std::string &src = "");
1326         RTLIL::Cell* addDlatchsr (RTLIL::IdString name, const RTLIL::SigSpec &sig_en, const RTLIL::SigSpec &sig_set, const RTLIL::SigSpec &sig_clr, RTLIL::SigSpec sig_d, const RTLIL::SigSpec &sig_q, bool en_polarity = true, bool set_polarity = true, bool clr_polarity = true, const std::string &src = "");
1327
1328         RTLIL::Cell* addBufGate    (RTLIL::IdString name, const RTLIL::SigBit &sig_a, const RTLIL::SigBit &sig_y, const std::string &src = "");
1329         RTLIL::Cell* addNotGate    (RTLIL::IdString name, const RTLIL::SigBit &sig_a, const RTLIL::SigBit &sig_y, const std::string &src = "");
1330         RTLIL::Cell* addAndGate    (RTLIL::IdString name, const RTLIL::SigBit &sig_a, const RTLIL::SigBit &sig_b, const RTLIL::SigBit &sig_y, const std::string &src = "");
1331         RTLIL::Cell* addNandGate   (RTLIL::IdString name, const RTLIL::SigBit &sig_a, const RTLIL::SigBit &sig_b, const RTLIL::SigBit &sig_y, const std::string &src = "");
1332         RTLIL::Cell* addOrGate     (RTLIL::IdString name, const RTLIL::SigBit &sig_a, const RTLIL::SigBit &sig_b, const RTLIL::SigBit &sig_y, const std::string &src = "");
1333         RTLIL::Cell* addNorGate    (RTLIL::IdString name, const RTLIL::SigBit &sig_a, const RTLIL::SigBit &sig_b, const RTLIL::SigBit &sig_y, const std::string &src = "");
1334         RTLIL::Cell* addXorGate    (RTLIL::IdString name, const RTLIL::SigBit &sig_a, const RTLIL::SigBit &sig_b, const RTLIL::SigBit &sig_y, const std::string &src = "");
1335         RTLIL::Cell* addXnorGate   (RTLIL::IdString name, const RTLIL::SigBit &sig_a, const RTLIL::SigBit &sig_b, const RTLIL::SigBit &sig_y, const std::string &src = "");
1336         RTLIL::Cell* addAndnotGate (RTLIL::IdString name, const RTLIL::SigBit &sig_a, const RTLIL::SigBit &sig_b, const RTLIL::SigBit &sig_y, const std::string &src = "");
1337         RTLIL::Cell* addOrnotGate  (RTLIL::IdString name, const RTLIL::SigBit &sig_a, const RTLIL::SigBit &sig_b, const RTLIL::SigBit &sig_y, const std::string &src = "");
1338         RTLIL::Cell* addMuxGate    (RTLIL::IdString name, const RTLIL::SigBit &sig_a, const RTLIL::SigBit &sig_b, const RTLIL::SigBit &sig_s, const RTLIL::SigBit &sig_y, const std::string &src = "");
1339         RTLIL::Cell* addNmuxGate   (RTLIL::IdString name, const RTLIL::SigBit &sig_a, const RTLIL::SigBit &sig_b, const RTLIL::SigBit &sig_s, const RTLIL::SigBit &sig_y, const std::string &src = "");
1340         RTLIL::Cell* addAoi3Gate   (RTLIL::IdString name, const RTLIL::SigBit &sig_a, const RTLIL::SigBit &sig_b, const RTLIL::SigBit &sig_c, const RTLIL::SigBit &sig_y, const std::string &src = "");
1341         RTLIL::Cell* addOai3Gate   (RTLIL::IdString name, const RTLIL::SigBit &sig_a, const RTLIL::SigBit &sig_b, const RTLIL::SigBit &sig_c, const RTLIL::SigBit &sig_y, const std::string &src = "");
1342         RTLIL::Cell* addAoi4Gate   (RTLIL::IdString name, const RTLIL::SigBit &sig_a, const RTLIL::SigBit &sig_b, const RTLIL::SigBit &sig_c, const RTLIL::SigBit &sig_d, const RTLIL::SigBit &sig_y, const std::string &src = "");
1343         RTLIL::Cell* addOai4Gate   (RTLIL::IdString name, const RTLIL::SigBit &sig_a, const RTLIL::SigBit &sig_b, const RTLIL::SigBit &sig_c, const RTLIL::SigBit &sig_d, const RTLIL::SigBit &sig_y, const std::string &src = "");
1344
1345         RTLIL::Cell* addSrGate     (RTLIL::IdString name, const RTLIL::SigSpec &sig_set, const RTLIL::SigSpec &sig_clr,
1346                         const RTLIL::SigSpec &sig_q, bool set_polarity = true, bool clr_polarity = true, const std::string &src = "");
1347         RTLIL::Cell* addFfGate     (RTLIL::IdString name, const RTLIL::SigSpec &sig_d, const RTLIL::SigSpec &sig_q, const std::string &src = "");
1348         RTLIL::Cell* addDffGate    (RTLIL::IdString name, const RTLIL::SigSpec &sig_clk, const RTLIL::SigSpec &sig_d, const RTLIL::SigSpec &sig_q, bool clk_polarity = true, const std::string &src = "");
1349         RTLIL::Cell* addDffeGate   (RTLIL::IdString name, const RTLIL::SigSpec &sig_clk, const RTLIL::SigSpec &sig_en, const RTLIL::SigSpec &sig_d, const RTLIL::SigSpec &sig_q, bool clk_polarity = true, bool en_polarity = true, const std::string &src = "");
1350         RTLIL::Cell* addDffsrGate  (RTLIL::IdString name, const RTLIL::SigSpec &sig_clk, const RTLIL::SigSpec &sig_set, const RTLIL::SigSpec &sig_clr,
1351                         RTLIL::SigSpec sig_d, const RTLIL::SigSpec &sig_q, bool clk_polarity = true, bool set_polarity = true, bool clr_polarity = true, const std::string &src = "");
1352         RTLIL::Cell* addDffsreGate (RTLIL::IdString name, const RTLIL::SigSpec &sig_clk, const RTLIL::SigSpec &sig_en, const RTLIL::SigSpec &sig_set, const RTLIL::SigSpec &sig_clr,
1353                         RTLIL::SigSpec sig_d, const RTLIL::SigSpec &sig_q, bool clk_polarity = true, bool en_polarity = true, bool set_polarity = true, bool clr_polarity = true, const std::string &src = "");
1354         RTLIL::Cell* addAdffGate   (RTLIL::IdString name, const RTLIL::SigSpec &sig_clk, const RTLIL::SigSpec &sig_arst, const RTLIL::SigSpec &sig_d, const RTLIL::SigSpec &sig_q,
1355                         bool arst_value = false, bool clk_polarity = true, bool arst_polarity = true, const std::string &src = "");
1356         RTLIL::Cell* addAdffeGate  (RTLIL::IdString name, const RTLIL::SigSpec &sig_clk, const RTLIL::SigSpec &sig_en, const RTLIL::SigSpec &sig_arst, const RTLIL::SigSpec &sig_d, const RTLIL::SigSpec &sig_q,
1357                         bool arst_value = false, bool clk_polarity = true, bool en_polarity = true, bool arst_polarity = true, const std::string &src = "");
1358         RTLIL::Cell* addAldffGate   (RTLIL::IdString name, const RTLIL::SigSpec &sig_clk, const RTLIL::SigSpec &sig_aload, const RTLIL::SigSpec &sig_d, const RTLIL::SigSpec &sig_q,
1359                         const RTLIL::SigSpec &sig_ad, bool clk_polarity = true, bool aload_polarity = true, const std::string &src = "");
1360         RTLIL::Cell* addAldffeGate  (RTLIL::IdString name, const RTLIL::SigSpec &sig_clk, const RTLIL::SigSpec &sig_en, const RTLIL::SigSpec &sig_aload, const RTLIL::SigSpec &sig_d, const RTLIL::SigSpec &sig_q,
1361                         const RTLIL::SigSpec &sig_ad, bool clk_polarity = true, bool en_polarity = true, bool aload_polarity = true, const std::string &src = "");
1362         RTLIL::Cell* addSdffGate   (RTLIL::IdString name, const RTLIL::SigSpec &sig_clk, const RTLIL::SigSpec &sig_srst, const RTLIL::SigSpec &sig_d, const RTLIL::SigSpec &sig_q,
1363                         bool srst_value = false, bool clk_polarity = true, bool srst_polarity = true, const std::string &src = "");
1364         RTLIL::Cell* addSdffeGate  (RTLIL::IdString name, const RTLIL::SigSpec &sig_clk, const RTLIL::SigSpec &sig_en, const RTLIL::SigSpec &sig_srst, const RTLIL::SigSpec &sig_d, const RTLIL::SigSpec &sig_q,
1365                         bool srst_value = false, bool clk_polarity = true, bool en_polarity = true, bool srst_polarity = true, const std::string &src = "");
1366         RTLIL::Cell* addSdffceGate (RTLIL::IdString name, const RTLIL::SigSpec &sig_clk, const RTLIL::SigSpec &sig_en, const RTLIL::SigSpec &sig_srst, const RTLIL::SigSpec &sig_d, const RTLIL::SigSpec &sig_q,
1367                         bool srst_value = false, bool clk_polarity = true, bool en_polarity = true, bool srst_polarity = true, const std::string &src = "");
1368         RTLIL::Cell* addDlatchGate (RTLIL::IdString name, const RTLIL::SigSpec &sig_en, const RTLIL::SigSpec &sig_d, const RTLIL::SigSpec &sig_q, bool en_polarity = true, const std::string &src = "");
1369         RTLIL::Cell* addAdlatchGate(RTLIL::IdString name, const RTLIL::SigSpec &sig_en, const RTLIL::SigSpec &sig_arst, const RTLIL::SigSpec &sig_d, const RTLIL::SigSpec &sig_q,
1370                         bool arst_value = false, bool en_polarity = true, bool arst_polarity = true, const std::string &src = "");
1371         RTLIL::Cell* addDlatchsrGate  (RTLIL::IdString name, const RTLIL::SigSpec &sig_en, const RTLIL::SigSpec &sig_set, const RTLIL::SigSpec &sig_clr,
1372                         RTLIL::SigSpec sig_d, const RTLIL::SigSpec &sig_q, bool en_polarity = true, bool set_polarity = true, bool clr_polarity = true, const std::string &src = "");
1373
1374         // The methods without the add* prefix create a cell and an output signal. They return the newly created output signal.
1375
1376         RTLIL::SigSpec Not (RTLIL::IdString name, const RTLIL::SigSpec &sig_a, bool is_signed = false, const std::string &src = "");
1377         RTLIL::SigSpec Pos (RTLIL::IdString name, const RTLIL::SigSpec &sig_a, bool is_signed = false, const std::string &src = "");
1378         RTLIL::SigSpec Neg (RTLIL::IdString name, const RTLIL::SigSpec &sig_a, bool is_signed = false, const std::string &src = "");
1379
1380         RTLIL::SigSpec And  (RTLIL::IdString name, const RTLIL::SigSpec &sig_a, const RTLIL::SigSpec &sig_b, bool is_signed = false, const std::string &src = "");
1381         RTLIL::SigSpec Or   (RTLIL::IdString name, const RTLIL::SigSpec &sig_a, const RTLIL::SigSpec &sig_b, bool is_signed = false, const std::string &src = "");
1382         RTLIL::SigSpec Xor  (RTLIL::IdString name, const RTLIL::SigSpec &sig_a, const RTLIL::SigSpec &sig_b, bool is_signed = false, const std::string &src = "");
1383         RTLIL::SigSpec Xnor (RTLIL::IdString name, const RTLIL::SigSpec &sig_a, const RTLIL::SigSpec &sig_b, bool is_signed = false, const std::string &src = "");
1384
1385         RTLIL::SigSpec ReduceAnd  (RTLIL::IdString name, const RTLIL::SigSpec &sig_a, bool is_signed = false, const std::string &src = "");
1386         RTLIL::SigSpec ReduceOr   (RTLIL::IdString name, const RTLIL::SigSpec &sig_a, bool is_signed = false, const std::string &src = "");
1387         RTLIL::SigSpec ReduceXor  (RTLIL::IdString name, const RTLIL::SigSpec &sig_a, bool is_signed = false, const std::string &src = "");
1388         RTLIL::SigSpec ReduceXnor (RTLIL::IdString name, const RTLIL::SigSpec &sig_a, bool is_signed = false, const std::string &src = "");
1389         RTLIL::SigSpec ReduceBool (RTLIL::IdString name, const RTLIL::SigSpec &sig_a, bool is_signed = false, const std::string &src = "");
1390
1391         RTLIL::SigSpec Shl    (RTLIL::IdString name, const RTLIL::SigSpec &sig_a, const RTLIL::SigSpec &sig_b, bool is_signed = false, const std::string &src = "");
1392         RTLIL::SigSpec Shr    (RTLIL::IdString name, const RTLIL::SigSpec &sig_a, const RTLIL::SigSpec &sig_b, bool is_signed = false, const std::string &src = "");
1393         RTLIL::SigSpec Sshl   (RTLIL::IdString name, const RTLIL::SigSpec &sig_a, const RTLIL::SigSpec &sig_b, bool is_signed = false, const std::string &src = "");
1394         RTLIL::SigSpec Sshr   (RTLIL::IdString name, const RTLIL::SigSpec &sig_a, const RTLIL::SigSpec &sig_b, bool is_signed = false, const std::string &src = "");
1395         RTLIL::SigSpec Shift  (RTLIL::IdString name, const RTLIL::SigSpec &sig_a, const RTLIL::SigSpec &sig_b, bool is_signed = false, const std::string &src = "");
1396         RTLIL::SigSpec Shiftx (RTLIL::IdString name, const RTLIL::SigSpec &sig_a, const RTLIL::SigSpec &sig_b, bool is_signed = false, const std::string &src = "");
1397
1398         RTLIL::SigSpec Lt  (RTLIL::IdString name, const RTLIL::SigSpec &sig_a, const RTLIL::SigSpec &sig_b, bool is_signed = false, const std::string &src = "");
1399         RTLIL::SigSpec Le  (RTLIL::IdString name, const RTLIL::SigSpec &sig_a, const RTLIL::SigSpec &sig_b, bool is_signed = false, const std::string &src = "");
1400         RTLIL::SigSpec Eq  (RTLIL::IdString name, const RTLIL::SigSpec &sig_a, const RTLIL::SigSpec &sig_b, bool is_signed = false, const std::string &src = "");
1401         RTLIL::SigSpec Ne  (RTLIL::IdString name, const RTLIL::SigSpec &sig_a, const RTLIL::SigSpec &sig_b, bool is_signed = false, const std::string &src = "");
1402         RTLIL::SigSpec Eqx (RTLIL::IdString name, const RTLIL::SigSpec &sig_a, const RTLIL::SigSpec &sig_b, bool is_signed = false, const std::string &src = "");
1403         RTLIL::SigSpec Nex (RTLIL::IdString name, const RTLIL::SigSpec &sig_a, const RTLIL::SigSpec &sig_b, bool is_signed = false, const std::string &src = "");
1404         RTLIL::SigSpec Ge  (RTLIL::IdString name, const RTLIL::SigSpec &sig_a, const RTLIL::SigSpec &sig_b, bool is_signed = false, const std::string &src = "");
1405         RTLIL::SigSpec Gt  (RTLIL::IdString name, const RTLIL::SigSpec &sig_a, const RTLIL::SigSpec &sig_b, bool is_signed = false, const std::string &src = "");
1406
1407         RTLIL::SigSpec Add (RTLIL::IdString name, const RTLIL::SigSpec &sig_a, const RTLIL::SigSpec &sig_b, bool is_signed = false, const std::string &src = "");
1408         RTLIL::SigSpec Sub (RTLIL::IdString name, const RTLIL::SigSpec &sig_a, const RTLIL::SigSpec &sig_b, bool is_signed = false, const std::string &src = "");
1409         RTLIL::SigSpec Mul (RTLIL::IdString name, const RTLIL::SigSpec &sig_a, const RTLIL::SigSpec &sig_b, bool is_signed = false, const std::string &src = "");
1410         // truncating division
1411         RTLIL::SigSpec Div (RTLIL::IdString name, const RTLIL::SigSpec &sig_a, const RTLIL::SigSpec &sig_b, bool is_signed = false, const std::string &src = "");
1412         // truncating modulo
1413         RTLIL::SigSpec Mod (RTLIL::IdString name, const RTLIL::SigSpec &sig_a, const RTLIL::SigSpec &sig_b, bool is_signed = false, const std::string &src = "");
1414         RTLIL::SigSpec DivFloor (RTLIL::IdString name, const RTLIL::SigSpec &sig_a, const RTLIL::SigSpec &sig_b, bool is_signed = false, const std::string &src = "");
1415         RTLIL::SigSpec ModFloor (RTLIL::IdString name, const RTLIL::SigSpec &sig_a, const RTLIL::SigSpec &sig_b, bool is_signed = false, const std::string &src = "");
1416         RTLIL::SigSpec Pow (RTLIL::IdString name, const RTLIL::SigSpec &sig_a, const RTLIL::SigSpec &sig_b, bool a_signed = false, bool b_signed = false, const std::string &src = "");
1417
1418         RTLIL::SigSpec LogicNot (RTLIL::IdString name, const RTLIL::SigSpec &sig_a, bool is_signed = false, const std::string &src = "");
1419         RTLIL::SigSpec LogicAnd (RTLIL::IdString name, const RTLIL::SigSpec &sig_a, const RTLIL::SigSpec &sig_b, bool is_signed = false, const std::string &src = "");
1420         RTLIL::SigSpec LogicOr  (RTLIL::IdString name, const RTLIL::SigSpec &sig_a, const RTLIL::SigSpec &sig_b, bool is_signed = false, const std::string &src = "");
1421
1422         RTLIL::SigSpec Mux      (RTLIL::IdString name, const RTLIL::SigSpec &sig_a, const RTLIL::SigSpec &sig_b, const RTLIL::SigSpec &sig_s, const std::string &src = "");
1423         RTLIL::SigSpec Pmux     (RTLIL::IdString name, const RTLIL::SigSpec &sig_a, const RTLIL::SigSpec &sig_b, const RTLIL::SigSpec &sig_s, const std::string &src = "");
1424
1425         RTLIL::SigBit BufGate    (RTLIL::IdString name, const RTLIL::SigBit &sig_a, const std::string &src = "");
1426         RTLIL::SigBit NotGate    (RTLIL::IdString name, const RTLIL::SigBit &sig_a, const std::string &src = "");
1427         RTLIL::SigBit AndGate    (RTLIL::IdString name, const RTLIL::SigBit &sig_a, const RTLIL::SigBit &sig_b, const std::string &src = "");
1428         RTLIL::SigBit NandGate   (RTLIL::IdString name, const RTLIL::SigBit &sig_a, const RTLIL::SigBit &sig_b, const std::string &src = "");
1429         RTLIL::SigBit OrGate     (RTLIL::IdString name, const RTLIL::SigBit &sig_a, const RTLIL::SigBit &sig_b, const std::string &src = "");
1430         RTLIL::SigBit NorGate    (RTLIL::IdString name, const RTLIL::SigBit &sig_a, const RTLIL::SigBit &sig_b, const std::string &src = "");
1431         RTLIL::SigBit XorGate    (RTLIL::IdString name, const RTLIL::SigBit &sig_a, const RTLIL::SigBit &sig_b, const std::string &src = "");
1432         RTLIL::SigBit XnorGate   (RTLIL::IdString name, const RTLIL::SigBit &sig_a, const RTLIL::SigBit &sig_b, const std::string &src = "");
1433         RTLIL::SigBit AndnotGate (RTLIL::IdString name, const RTLIL::SigBit &sig_a, const RTLIL::SigBit &sig_b, const std::string &src = "");
1434         RTLIL::SigBit OrnotGate  (RTLIL::IdString name, const RTLIL::SigBit &sig_a, const RTLIL::SigBit &sig_b, const std::string &src = "");
1435         RTLIL::SigBit MuxGate    (RTLIL::IdString name, const RTLIL::SigBit &sig_a, const RTLIL::SigBit &sig_b, const RTLIL::SigBit &sig_s, const std::string &src = "");
1436         RTLIL::SigBit NmuxGate   (RTLIL::IdString name, const RTLIL::SigBit &sig_a, const RTLIL::SigBit &sig_b, const RTLIL::SigBit &sig_s, const std::string &src = "");
1437         RTLIL::SigBit Aoi3Gate   (RTLIL::IdString name, const RTLIL::SigBit &sig_a, const RTLIL::SigBit &sig_b, const RTLIL::SigBit &sig_c, const std::string &src = "");
1438         RTLIL::SigBit Oai3Gate   (RTLIL::IdString name, const RTLIL::SigBit &sig_a, const RTLIL::SigBit &sig_b, const RTLIL::SigBit &sig_c, const std::string &src = "");
1439         RTLIL::SigBit Aoi4Gate   (RTLIL::IdString name, const RTLIL::SigBit &sig_a, const RTLIL::SigBit &sig_b, const RTLIL::SigBit &sig_c, const RTLIL::SigBit &sig_d, const std::string &src = "");
1440         RTLIL::SigBit Oai4Gate   (RTLIL::IdString name, const RTLIL::SigBit &sig_a, const RTLIL::SigBit &sig_b, const RTLIL::SigBit &sig_c, const RTLIL::SigBit &sig_d, const std::string &src = "");
1441
1442         RTLIL::SigSpec Anyconst  (RTLIL::IdString name, int width = 1, const std::string &src = "");
1443         RTLIL::SigSpec Anyseq    (RTLIL::IdString name, int width = 1, const std::string &src = "");
1444         RTLIL::SigSpec Allconst  (RTLIL::IdString name, int width = 1, const std::string &src = "");
1445         RTLIL::SigSpec Allseq    (RTLIL::IdString name, int width = 1, const std::string &src = "");
1446         RTLIL::SigSpec Initstate (RTLIL::IdString name, const std::string &src = "");
1447
1448 #ifdef WITH_PYTHON
1449         static std::map<unsigned int, RTLIL::Module*> *get_all_modules(void);
1450 #endif
1451 };
1452
1453 struct RTLIL::Wire : public RTLIL::AttrObject
1454 {
1455         unsigned int hashidx_;
1456         unsigned int hash() const { return hashidx_; }
1457
1458 protected:
1459         // use module->addWire() and module->remove() to create or destroy wires
1460         friend struct RTLIL::Module;
1461         Wire();
1462         ~Wire();
1463
1464 public:
1465         // do not simply copy wires
1466         Wire(RTLIL::Wire &other) = delete;
1467         void operator=(RTLIL::Wire &other) = delete;
1468
1469         RTLIL::Module *module;
1470         RTLIL::IdString name;
1471         int width, start_offset, port_id;
1472         bool port_input, port_output, upto, is_signed;
1473
1474 #ifdef WITH_PYTHON
1475         static std::map<unsigned int, RTLIL::Wire*> *get_all_wires(void);
1476 #endif
1477 };
1478
1479 struct RTLIL::Memory : public RTLIL::AttrObject
1480 {
1481         unsigned int hashidx_;
1482         unsigned int hash() const { return hashidx_; }
1483
1484         Memory();
1485
1486         RTLIL::IdString name;
1487         int width, start_offset, size;
1488 #ifdef WITH_PYTHON
1489         ~Memory();
1490         static std::map<unsigned int, RTLIL::Memory*> *get_all_memorys(void);
1491 #endif
1492 };
1493
1494 struct RTLIL::Cell : public RTLIL::AttrObject
1495 {
1496         unsigned int hashidx_;
1497         unsigned int hash() const { return hashidx_; }
1498
1499 protected:
1500         // use module->addCell() and module->remove() to create or destroy cells
1501         friend struct RTLIL::Module;
1502         Cell();
1503         ~Cell();
1504
1505 public:
1506         // do not simply copy cells
1507         Cell(RTLIL::Cell &other) = delete;
1508         void operator=(RTLIL::Cell &other) = delete;
1509
1510         RTLIL::Module *module;
1511         RTLIL::IdString name;
1512         RTLIL::IdString type;
1513         dict<RTLIL::IdString, RTLIL::SigSpec> connections_;
1514         dict<RTLIL::IdString, RTLIL::Const> parameters;
1515
1516         // access cell ports
1517         bool hasPort(RTLIL::IdString portname) const;
1518         void unsetPort(RTLIL::IdString portname);
1519         void setPort(RTLIL::IdString portname, RTLIL::SigSpec signal);
1520         const RTLIL::SigSpec &getPort(RTLIL::IdString portname) const;
1521         const dict<RTLIL::IdString, RTLIL::SigSpec> &connections() const;
1522
1523         // information about cell ports
1524         bool known() const;
1525         bool input(RTLIL::IdString portname) const;
1526         bool output(RTLIL::IdString portname) const;
1527
1528         // access cell parameters
1529         bool hasParam(RTLIL::IdString paramname) const;
1530         void unsetParam(RTLIL::IdString paramname);
1531         void setParam(RTLIL::IdString paramname, RTLIL::Const value);
1532         const RTLIL::Const &getParam(RTLIL::IdString paramname) const;
1533
1534         void sort();
1535         void check();
1536         void fixup_parameters(bool set_a_signed = false, bool set_b_signed = false);
1537
1538         bool has_keep_attr() const {
1539                 return get_bool_attribute(ID::keep) || (module && module->design && module->design->module(type) &&
1540                                 module->design->module(type)->get_bool_attribute(ID::keep));
1541         }
1542
1543         template<typename T> void rewrite_sigspecs(T &functor);
1544         template<typename T> void rewrite_sigspecs2(T &functor);
1545
1546 #ifdef WITH_PYTHON
1547         static std::map<unsigned int, RTLIL::Cell*> *get_all_cells(void);
1548 #endif
1549
1550         bool has_memid() const;
1551         bool is_mem_cell() const;
1552 };
1553
1554 struct RTLIL::CaseRule : public RTLIL::AttrObject
1555 {
1556         std::vector<RTLIL::SigSpec> compare;
1557         std::vector<RTLIL::SigSig> actions;
1558         std::vector<RTLIL::SwitchRule*> switches;
1559
1560         ~CaseRule();
1561
1562         bool empty() const;
1563
1564         template<typename T> void rewrite_sigspecs(T &functor);
1565         template<typename T> void rewrite_sigspecs2(T &functor);
1566         RTLIL::CaseRule *clone() const;
1567 };
1568
1569 struct RTLIL::SwitchRule : public RTLIL::AttrObject
1570 {
1571         RTLIL::SigSpec signal;
1572         std::vector<RTLIL::CaseRule*> cases;
1573
1574         ~SwitchRule();
1575
1576         bool empty() const;
1577
1578         template<typename T> void rewrite_sigspecs(T &functor);
1579         template<typename T> void rewrite_sigspecs2(T &functor);
1580         RTLIL::SwitchRule *clone() const;
1581 };
1582
1583 struct RTLIL::MemWriteAction : RTLIL::AttrObject
1584 {
1585         RTLIL::IdString memid;
1586         RTLIL::SigSpec address;
1587         RTLIL::SigSpec data;
1588         RTLIL::SigSpec enable;
1589         RTLIL::Const priority_mask;
1590 };
1591
1592 struct RTLIL::SyncRule
1593 {
1594         RTLIL::SyncType type;
1595         RTLIL::SigSpec signal;
1596         std::vector<RTLIL::SigSig> actions;
1597         std::vector<RTLIL::MemWriteAction> mem_write_actions;
1598
1599         template<typename T> void rewrite_sigspecs(T &functor);
1600         template<typename T> void rewrite_sigspecs2(T &functor);
1601         RTLIL::SyncRule *clone() const;
1602 };
1603
1604 struct RTLIL::Process : public RTLIL::AttrObject
1605 {
1606         unsigned int hashidx_;
1607         unsigned int hash() const { return hashidx_; }
1608
1609 protected:
1610         // use module->addProcess() and module->remove() to create or destroy processes
1611         friend struct RTLIL::Module;
1612         Process();
1613         ~Process();
1614
1615 public:
1616         RTLIL::IdString name;
1617         RTLIL::Module *module;
1618         RTLIL::CaseRule root_case;
1619         std::vector<RTLIL::SyncRule*> syncs;
1620
1621         template<typename T> void rewrite_sigspecs(T &functor);
1622         template<typename T> void rewrite_sigspecs2(T &functor);
1623         RTLIL::Process *clone() const;
1624 };
1625
1626
1627 inline RTLIL::SigBit::SigBit() : wire(NULL), data(RTLIL::State::S0) { }
1628 inline RTLIL::SigBit::SigBit(RTLIL::State bit) : wire(NULL), data(bit) { }
1629 inline RTLIL::SigBit::SigBit(bool bit) : wire(NULL), data(bit ? State::S1 : State::S0) { }
1630 inline RTLIL::SigBit::SigBit(RTLIL::Wire *wire) : wire(wire), offset(0) { log_assert(wire && wire->width == 1); }
1631 inline RTLIL::SigBit::SigBit(RTLIL::Wire *wire, int offset) : wire(wire), offset(offset) { log_assert(wire != nullptr); }
1632 inline RTLIL::SigBit::SigBit(const RTLIL::SigChunk &chunk) : wire(chunk.wire) { log_assert(chunk.width == 1); if (wire) offset = chunk.offset; else data = chunk.data[0]; }
1633 inline RTLIL::SigBit::SigBit(const RTLIL::SigChunk &chunk, int index) : wire(chunk.wire) { if (wire) offset = chunk.offset + index; else data = chunk.data[index]; }
1634
1635 inline bool RTLIL::SigBit::operator<(const RTLIL::SigBit &other) const {
1636         if (wire == other.wire)
1637                 return wire ? (offset < other.offset) : (data < other.data);
1638         if (wire != nullptr && other.wire != nullptr)
1639                 return wire->name < other.wire->name;
1640         return (wire != nullptr) < (other.wire != nullptr);
1641 }
1642
1643 inline bool RTLIL::SigBit::operator==(const RTLIL::SigBit &other) const {
1644         return (wire == other.wire) && (wire ? (offset == other.offset) : (data == other.data));
1645 }
1646
1647 inline bool RTLIL::SigBit::operator!=(const RTLIL::SigBit &other) const {
1648         return (wire != other.wire) || (wire ? (offset != other.offset) : (data != other.data));
1649 }
1650
1651 inline unsigned int RTLIL::SigBit::hash() const {
1652         if (wire)
1653                 return mkhash_add(wire->name.hash(), offset);
1654         return data;
1655 }
1656
1657 inline RTLIL::SigBit &RTLIL::SigSpecIterator::operator*() const {
1658         return (*sig_p)[index];
1659 }
1660
1661 inline const RTLIL::SigBit &RTLIL::SigSpecConstIterator::operator*() const {
1662         return (*sig_p)[index];
1663 }
1664
1665 inline RTLIL::SigBit::SigBit(const RTLIL::SigSpec &sig) {
1666         log_assert(sig.size() == 1 && sig.chunks().size() == 1);
1667         *this = SigBit(sig.chunks().front());
1668 }
1669
1670 template<typename T>
1671 void RTLIL::Module::rewrite_sigspecs(T &functor)
1672 {
1673         for (auto &it : cells_)
1674                 it.second->rewrite_sigspecs(functor);
1675         for (auto &it : processes)
1676                 it.second->rewrite_sigspecs(functor);
1677         for (auto &it : connections_) {
1678                 functor(it.first);
1679                 functor(it.second);
1680         }
1681 }
1682
1683 template<typename T>
1684 void RTLIL::Module::rewrite_sigspecs2(T &functor)
1685 {
1686         for (auto &it : cells_)
1687                 it.second->rewrite_sigspecs2(functor);
1688         for (auto &it : processes)
1689                 it.second->rewrite_sigspecs2(functor);
1690         for (auto &it : connections_) {
1691                 functor(it.first, it.second);
1692         }
1693 }
1694
1695 template<typename T>
1696 void RTLIL::Cell::rewrite_sigspecs(T &functor) {
1697         for (auto &it : connections_)
1698                 functor(it.second);
1699 }
1700
1701 template<typename T>
1702 void RTLIL::Cell::rewrite_sigspecs2(T &functor) {
1703         for (auto &it : connections_)
1704                 functor(it.second);
1705 }
1706
1707 template<typename T>
1708 void RTLIL::CaseRule::rewrite_sigspecs(T &functor) {
1709         for (auto &it : compare)
1710                 functor(it);
1711         for (auto &it : actions) {
1712                 functor(it.first);
1713                 functor(it.second);
1714         }
1715         for (auto it : switches)
1716                 it->rewrite_sigspecs(functor);
1717 }
1718
1719 template<typename T>
1720 void RTLIL::CaseRule::rewrite_sigspecs2(T &functor) {
1721         for (auto &it : compare)
1722                 functor(it);
1723         for (auto &it : actions) {
1724                 functor(it.first, it.second);
1725         }
1726         for (auto it : switches)
1727                 it->rewrite_sigspecs2(functor);
1728 }
1729
1730 template<typename T>
1731 void RTLIL::SwitchRule::rewrite_sigspecs(T &functor)
1732 {
1733         functor(signal);
1734         for (auto it : cases)
1735                 it->rewrite_sigspecs(functor);
1736 }
1737
1738 template<typename T>
1739 void RTLIL::SwitchRule::rewrite_sigspecs2(T &functor)
1740 {
1741         functor(signal);
1742         for (auto it : cases)
1743                 it->rewrite_sigspecs2(functor);
1744 }
1745
1746 template<typename T>
1747 void RTLIL::SyncRule::rewrite_sigspecs(T &functor)
1748 {
1749         functor(signal);
1750         for (auto &it : actions) {
1751                 functor(it.first);
1752                 functor(it.second);
1753         }
1754         for (auto &it : mem_write_actions) {
1755                 functor(it.address);
1756                 functor(it.data);
1757                 functor(it.enable);
1758         }
1759 }
1760
1761 template<typename T>
1762 void RTLIL::SyncRule::rewrite_sigspecs2(T &functor)
1763 {
1764         functor(signal);
1765         for (auto &it : actions) {
1766                 functor(it.first, it.second);
1767         }
1768         for (auto &it : mem_write_actions) {
1769                 functor(it.address);
1770                 functor(it.data);
1771                 functor(it.enable);
1772         }
1773 }
1774
1775 template<typename T>
1776 void RTLIL::Process::rewrite_sigspecs(T &functor)
1777 {
1778         root_case.rewrite_sigspecs(functor);
1779         for (auto it : syncs)
1780                 it->rewrite_sigspecs(functor);
1781 }
1782
1783 template<typename T>
1784 void RTLIL::Process::rewrite_sigspecs2(T &functor)
1785 {
1786         root_case.rewrite_sigspecs2(functor);
1787         for (auto it : syncs)
1788                 it->rewrite_sigspecs2(functor);
1789 }
1790
1791 YOSYS_NAMESPACE_END
1792
1793 #endif