luke
/
verilator
mirror of https://github.com/verilator/verilator.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

C++11: Remove pre-c11 VL_OVERRIDE etc. No functional change.

This commit is contained in:
Wilson Snyder 2020-08-15 10:03:34 -04:00
parent 2118038cb9
commit 7c54a451a9
104 changed files with 1608 additions and 2125 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
include/verilated_cov.cpp
View File

@ -70,15 +70,15 @@ private:
public:
// METHODS
// cppcheck-suppress truncLongCastReturn
virtual vluint64_t count() const VL_OVERRIDE { return *m_countp; }
virtual void zero() const VL_OVERRIDE { *m_countp = 0; }
virtual vluint64_t count() const override { return *m_countp; }
virtual void zero() const override { *m_countp = 0; }
// CONSTRUCTORS
// cppcheck-suppress noExplicitConstructor
explicit VerilatedCoverItemSpec(T* countp)
: m_countp(countp) {
*m_countp = 0;
}
virtual ~VerilatedCoverItemSpec() VL_OVERRIDE {}
virtual ~VerilatedCoverItemSpec() override {}
};
//=============================================================================

6
include/verilated_fst_c.h
View File

@ -63,11 +63,11 @@ protected:
// Implementation of VerilatedTrace interface
// Implementations of protected virtual methods for VerilatedTrace
void emitTimeChange(vluint64_t timeui) VL_OVERRIDE;
void emitTimeChange(vluint64_t timeui) override;
// Hooks called from VerilatedTrace
bool preFullDump() VL_OVERRIDE { return isOpen(); }
bool preChangeDump() VL_OVERRIDE { return isOpen(); }
bool preFullDump() override { return isOpen(); }
bool preChangeDump() override { return isOpen(); }
// Implementations of duck-typed methods for VerilatedTrace. These are
// called from only one place (namely full*) so always inline them.

8
include/verilated_heavy.h
View File

@ -379,13 +379,7 @@ template <class T_Value> std::string VL_TO_STRING(const VlQueue<T_Value>& obj) {
// be protected by other means
//
// clang-format off
#if (defined(_MSC_VER) && _MSC_VER >= 1900) || (__cplusplus >= 201103L)
# define VlClassRef std::shared_ptr
#else
# define VlClassRef VlClassRef__SystemVerilog_class_support_requires_a_C11_or_newer_compiler
#endif
// clang-format on
#define VlClassRef std::shared_ptr
template <class T> // T typically of type VlClassRef<x>
inline T VL_NULL_CHECK(T t, const char* filename, int linenum) {

14
include/verilated_save.h
View File

@ -165,13 +165,13 @@ public:
// CONSTRUCTORS
VerilatedSave()
: m_fd(-1) {}
virtual ~VerilatedSave() VL_OVERRIDE { close(); }
virtual ~VerilatedSave() override { close(); }
// METHODS
/// Open the file; call isOpen() to see if errors
void open(const char* filenamep) VL_MT_UNSAFE_ONE;
void open(const std::string& filename) VL_MT_UNSAFE_ONE { open(filename.c_str()); }
virtual void close() VL_OVERRIDE VL_MT_UNSAFE_ONE;
virtual void flush() VL_OVERRIDE VL_MT_UNSAFE_ONE;
virtual void close() override VL_MT_UNSAFE_ONE;
virtual void flush() override VL_MT_UNSAFE_ONE;
};
//=============================================================================
@ -186,15 +186,15 @@ public:
// CONSTRUCTORS
VerilatedRestore()
: m_fd(-1) {}
virtual ~VerilatedRestore() VL_OVERRIDE { close(); }
virtual ~VerilatedRestore() override { close(); }
// METHODS
/// Open the file; call isOpen() to see if errors
void open(const char* filenamep) VL_MT_UNSAFE_ONE;
void open(const std::string& filename) VL_MT_UNSAFE_ONE { open(filename.c_str()); }
virtual void close() VL_OVERRIDE VL_MT_UNSAFE_ONE;
virtual void flush() VL_OVERRIDE VL_MT_UNSAFE_ONE {}
virtual void fill() VL_OVERRIDE VL_MT_UNSAFE_ONE;
virtual void close() override VL_MT_UNSAFE_ONE;
virtual void flush() override VL_MT_UNSAFE_ONE {}
virtual void fill() override VL_MT_UNSAFE_ONE;
};
//=============================================================================

501
include/verilated_unordered_set_map.h
View File

@ -1,501 +0,0 @@
// -*- mode: C++; c-file-style: "cc-mode" -*-
//*************************************************************************
// DESCRIPTION: Verilator: pre-C++11 replacements for std::unordered_set
// and std::unordered_map.
//
// Code available from: https://verilator.org
//
//*************************************************************************
//
// Copyright 2003-2020 by Wilson Snyder. This program is free software; you
// can redistribute it and/or modify it under the terms of either the GNU
// Lesser General Public License Version 3 or the Perl Artistic License
// Version 2.0.
// SPDX-License-Identifier: LGPL-3.0-only OR Artistic-2.0
//
//*************************************************************************
//*************************************************************************
// This file has clones of the std::unordered_set and std::unordered_map
// hash table types. They are here so that Verilator can use hash tables
// in pre-C++11 compilers, and the same client code can link against the
// std:: types when they are available.
//
// The implementations in this file do not implement the complete APIs
// of the std:: types. Nor are they correct in every detail,
// notably, the const_iterators do not enforce constness. We can extend
// these implementations to cover more of the std API as needed.
//
// TODO: In the future, when Verilator requires C++11 to compile,
// remove this entire file and switch to the std:: types.
//
//*************************************************************************
#ifndef _VERILATED_UNORDERED_SET_MAP_H_
#define _VERILATED_UNORDERED_SET_MAP_H_
#include "verilatedos.h"
#include <list>
#include <stdexcept>
#include <string>
// Abstract 'vl_hash' and 'vl_equal_to' templates.
template <typename T> struct vl_hash { size_t operator()(const T& k) const; };
template <typename T> struct vl_equal_to { bool operator()(const T& a, const T& b) const; };
// Specializations of 'vl_hash' and 'vl_equal_to'.
inline size_t vl_hash_bytes(const void* vbufp, size_t nbytes) {
const vluint8_t* bufp = static_cast<const vluint8_t*>(vbufp);
size_t hash = 0;
for (size_t i = 0; i < nbytes; i++) {
hash = bufp[i] + 31U * hash; // the K&R classic!
}
return hash;
}
template <> inline size_t vl_hash<int>::operator()(const int& k) const { return k; }
template <> inline bool vl_equal_to<int>::operator()(const int& a, const int& b) const {
return a == b;
}
template <> inline size_t vl_hash<unsigned int>::operator()(const unsigned int& k) const {
return k;
}
template <>
inline bool vl_equal_to<unsigned int>::operator()(const unsigned int& a,
const unsigned int& b) const {
return a == b;
}
template <> inline size_t vl_hash<std::string>::operator()(const std::string& k) const {
return vl_hash_bytes(k.data(), k.size());
}
template <>
inline bool vl_equal_to<std::string>::operator()(const std::string& a,
const std::string& b) const {
// Don't scan the strings if the sizes are different.
if (a.size() != b.size()) return false;
return (0 == a.compare(b)); // Must scan.
}
template <typename T> struct vl_hash<T*> {
size_t operator()(T* kp) const {
return ((sizeof(size_t) == sizeof(kp)) ? reinterpret_cast<size_t>(kp)
: vl_hash_bytes(&kp, sizeof(kp)));
}
};
template <typename T> struct vl_equal_to<T*> {
bool operator()(T* ap, T* bp) const { return ap == bp; }
};
//===================================================================
//
/// Functional clone of the std::unordered_set hash table.
template <class T_Key, class T_Hash = vl_hash<T_Key>, class T_Equal = vl_equal_to<T_Key>>
class vl_unordered_set {
public:
// TYPES
typedef std::list<T_Key> Bucket;
enum RehashType { GROW, SHRINK };
template <class KK, class VV, class HH, class EQ> friend class vl_unordered_map;
class iterator {
protected:
// MEMBERS
size_t m_bucketIdx; // Bucket this iterator points into
typename Bucket::iterator m_bit; // Bucket-local iterator
const vl_unordered_set* m_setp; // The containing set
public:
// CONSTRUCTORS
iterator(size_t bucketIdx, typename Bucket::iterator bit, const vl_unordered_set* setp)
: m_bucketIdx(bucketIdx)
, m_bit(bit)
, m_setp(setp) {}
// METHODS
const T_Key& operator*() const { return *m_bit; }
// This should really be 'const T_Key*' type for unordered_set,
// however this iterator is shared with unordered_map whose
// operator-> returns a non-const ValueType*, so keep this
// non-const to avoid having to define a whole separate iterator
// for unordered_map.
T_Key* operator->() const { return &(*m_bit); }
bool operator==(const iterator& other) const {
return ((m_bucketIdx == other.m_bucketIdx) && (m_bit == other.m_bit));
}
bool operator!=(const iterator& other) const { return (!this->operator==(other)); }
void advanceUntilValid() {
while (true) {
if (m_bit != m_setp->m_bucketsp[m_bucketIdx].end()) {
// Valid iterator in this bucket; we're done.
return;
}
// Try the next bucket?
m_bucketIdx++;
if (m_bucketIdx == m_setp->numBuckets()) {
// Ran past the end of buckets, set to end().
*this = m_setp->end();
return;
}
m_bit = m_setp->m_bucketsp[m_bucketIdx].begin();
}
}
void operator++() {
++m_bit;
advanceUntilValid();
}
typename Bucket::iterator bit() const { return m_bit; }
};
// TODO: there's no real const enforcement on the 'const_iterator'.
typedef iterator const_iterator;
private:
// MEMBERS
size_t m_numElements; // Number of entries present.
size_t m_log2Buckets; // Log-base-2 of the number of buckets.
mutable Bucket* m_bucketsp; // Hash table buckets. May be NULL;
// // we'll allocate it on the fly when
// // the first entries are created.
Bucket m_emptyBucket; // A fake bucket, used to construct end().
T_Hash m_hash; // Hash function provider.
T_Equal m_equal; // Equal-to function provider.
public:
// CONSTRUCTORS
vl_unordered_set()
: m_numElements(0)
, m_log2Buckets(initLog2Buckets())
, m_bucketsp(NULL)
, m_hash()
, m_equal() {}
vl_unordered_set(const vl_unordered_set& other)
: m_numElements(other.m_numElements)
, m_log2Buckets(other.m_log2Buckets)
, m_bucketsp(NULL)
, m_hash()
, m_equal() {
if (other.m_bucketsp) {
m_bucketsp = new Bucket[numBuckets()];
for (size_t i = 0; i < numBuckets(); i++) m_bucketsp[i] = other.m_bucketsp[i];
}
}
~vl_unordered_set() { VL_DO_DANGLING(delete[] m_bucketsp, m_bucketsp); }
vl_unordered_set& operator=(const vl_unordered_set& other) {
if (this != &other) {
clear();
delete[] m_bucketsp;
m_numElements = other.m_numElements;
m_log2Buckets = other.m_log2Buckets;
if (other.m_bucketsp) {
m_bucketsp = new Bucket[numBuckets()];
for (size_t i = 0; i < numBuckets(); i++) m_bucketsp[i] = other.m_bucketsp[i];
} else {
m_bucketsp = NULL;
}
}
return *this;
}
// METHODS
static size_t initLog2Buckets() { return 4; }
iterator begin() {
if (m_numElements) {
initBuckets();
iterator result = iterator(0, m_bucketsp[0].begin(), this);
result.advanceUntilValid();
return result;
}
return end();
}
const_iterator begin() const {
if (m_numElements) {
initBuckets();
const_iterator result = iterator(0, m_bucketsp[0].begin(), this);
result.advanceUntilValid();
return result;
}
return end();
}
const_iterator end() const {
return iterator(0xFFFFFFFFFFFFFFFFULL, const_cast<Bucket&>(m_emptyBucket).begin(), this);
}
bool empty() const { return m_numElements == 0; }
size_t size() const { return m_numElements; }
size_t count(const T_Key& key) const { return (find(key) == end()) ? 0 : 1; }
size_t hashToBucket(size_t hashVal) const { return hashToBucket(hashVal, m_log2Buckets); }
static size_t hashToBucket(size_t hashVal, unsigned log2Buckets) {
// Fibonacci hashing, see
// https://probablydance.com/2018/06/16/fibonacci-hashing-the-optimization
// -that-the-world-forgot-or-a-better-alternative-to-integer-modulo/
//
// * The magic numbers below are UINT_MAX/phi where phi is the
// golden ratio number (1.618...) for either 64- or 32-bit
// values of UINT_MAX.
//
// * Fibonacci hashing mixes the result of the client's hash
// function further. This permits the use of very fast client
// hash funcs (like just returning the int or pointer value as
// is!) and tolerates crappy client hash functions pretty well.
size_t mult = hashVal * ((sizeof(size_t) == 8) ? 11400714819323198485ULL : 2654435769lu);
size_t result = (mult >> (((sizeof(size_t) == 8) ? 64 : 32) - log2Buckets));
return result;
}
iterator find_internal(const T_Key& key, size_t& bucketIdxOut) {
size_t hash = m_hash.operator()(key);
bucketIdxOut = hashToBucket(hash);
initBuckets();
Bucket* bucketp = &m_bucketsp[bucketIdxOut];
for (typename Bucket::iterator it = bucketp->begin(); it != bucketp->end(); ++it) {
if (m_equal.operator()(*it, key)) return iterator(bucketIdxOut, it, this);
}
return end();
}
const_iterator find(const T_Key& key) const {
size_t bucketIdx;
return const_cast<vl_unordered_set*>(this)->find_internal(key, bucketIdx);
}
iterator find(const T_Key& key) {
size_t bucketIdx;
return find_internal(key, bucketIdx);
}
std::pair<iterator, bool> insert(const T_Key& val) {
size_t bucketIdx;
iterator existIt = find_internal(val, bucketIdx);
if (existIt != end()) {
// Collision with existing element.
//
// An element may be inserted only if it is not
// equal to an existing element. So fail.
return std::pair<iterator, bool>(end(), false);
}
// No collision, so insert it.
m_numElements++;
m_bucketsp[bucketIdx].push_front(val);
// Compute result iterator. This pointer will be valid
// if we don't rehash:
iterator result_it(bucketIdx, m_bucketsp[bucketIdx].begin(), this);
if (needToRehash(GROW)) {
rehash(GROW);
// ... since we rehashed, do a lookup to get the result iterator.
result_it = find(val);
}
return std::pair<iterator, bool>(result_it, true);
}
iterator erase(iterator it) {
iterator next_it = it;
++next_it;
erase(*it);
return next_it;
}
size_t erase(const T_Key& key) {
size_t bucketIdx;
iterator it = find_internal(key, bucketIdx);
if (it != end()) {
m_bucketsp[bucketIdx].erase(it.bit());
m_numElements--;
// Rehashing to handle a shrinking data set is important
// for the Scoreboard in V3Partition, which begins tracking
// a huge number of vertices and then tracks a successively
// smaller number over time.
if (needToRehash(SHRINK)) rehash(SHRINK);
return 1;
}
return 0;
}
void clear() {
if (m_bucketsp) {
delete[] m_bucketsp;
m_bucketsp = NULL;
}
m_numElements = 0;
m_log2Buckets = initLog2Buckets();
}
private:
size_t numBuckets() const { return (1ULL << m_log2Buckets); }
Bucket* getBucket(size_t idx) {
initBuckets();
return &m_bucketsp[idx];
}
void initBuckets() const {
if (!m_bucketsp) m_bucketsp = new Bucket[numBuckets()];
}
bool needToRehash(RehashType rt) const {
if (rt == GROW) {
return ((4 * numBuckets()) < m_numElements);
} else {
return (numBuckets() > (4 * m_numElements));
}
}
void rehash(RehashType rt) {
size_t new_log2Buckets;
if (rt == GROW) {
new_log2Buckets = m_log2Buckets + 2;
} else {
if (m_log2Buckets <= 4) {
// On shrink, saturate m_log2Buckets at its
// initial size of 2^4 == 16 buckets. Don't risk
// underflowing!
return;
}
new_log2Buckets = m_log2Buckets - 2;
}
size_t new_num_buckets = 1ULL << new_log2Buckets;
Bucket* new_bucketsp = new Bucket[new_num_buckets];
for (size_t i = 0; i < numBuckets(); i++) {
while (!m_bucketsp[i].empty()) {
typename Bucket::iterator bit = m_bucketsp[i].begin();
size_t hash = m_hash.operator()(*bit);
size_t new_idx = hashToBucket(hash, new_log2Buckets);
// Avoid mallocing one list elem and freeing another;
// splice just moves it over.
new_bucketsp[new_idx].splice(new_bucketsp[new_idx].begin(), m_bucketsp[i], bit);
}
}
delete[] m_bucketsp;
m_bucketsp = new_bucketsp;
m_log2Buckets = new_log2Buckets;
}
};
//===================================================================
//
/// Functional clone of the std::unordered_map hash table.
template <class T_Key, class T_Value, class T_Hash = vl_hash<T_Key>,
class T_Equal = vl_equal_to<T_Key>>
class vl_unordered_map {
private:
// TYPES
typedef std::pair<T_Key, T_Value> KeyValPair;
class KeyHash {
private:
T_Hash key_hash;
public:
KeyHash() {}
size_t operator()(const KeyValPair& kv_pair) const {
return key_hash.operator()(kv_pair.first);
}
};
class KeyEqual {
private:
T_Equal key_eq;
public:
KeyEqual() {}
bool operator()(const KeyValPair& kv_a, const KeyValPair& kv_b) const {
return key_eq.operator()(kv_a.first, kv_b.first);
}
};
// MEMBERS
typedef vl_unordered_set<KeyValPair, KeyHash, KeyEqual> MapSet;
MapSet m_set; // Wrap this vl_unordered_set which holds all state.
public:
// CONSTRUCTORS
vl_unordered_map() {}
~vl_unordered_map() {}
typedef typename MapSet::iterator iterator;
typedef typename MapSet::const_iterator const_iterator;
// METHODS
iterator begin() { return m_set.begin(); }
const_iterator begin() const { return m_set.begin(); }
const_iterator end() const { return m_set.end(); }
bool empty() const { return m_set.empty(); }
iterator find(const T_Key& k) {
// We can't assume that T_Value() is defined.
// ie, this does not work:
// return m_set.find(std::make_pair(k, T_Value()));
// So, do this instead:
T_Hash mapHash;
T_Equal mapEq;
size_t hash = mapHash.operator()(k);
size_t bucketIdxOut = m_set.hashToBucket(hash);
typename MapSet::Bucket* bucketp = m_set.getBucket(bucketIdxOut);
for (typename MapSet::Bucket::iterator it = bucketp->begin(); it != bucketp->end(); ++it) {
if (mapEq.operator()(it->first, k)) return iterator(bucketIdxOut, it, &m_set);
}
return end();
}
const_iterator find(const T_Key& k) const {
return const_cast<vl_unordered_map*>(this)->find(k);
}
std::pair<iterator, bool> insert(const KeyValPair& val) { return m_set.insert(val); }
iterator erase(iterator it) { return m_set.erase(it); }
size_t erase(const T_Key& k) {
iterator it = find(k);
if (it == end()) return 0;
m_set.erase(it);
return 1;
}
T_Value& operator[](const T_Key& k) {
// Here we can assume T_Value() is defined, as
// std::unordered_map::operator[] relies on it too.
KeyValPair dummy = std::make_pair(k, T_Value());
iterator it = m_set.find(dummy);
if (it == m_set.end()) it = m_set.insert(dummy).first;
// For the 'set', it's generally not safe to modify
// the value after deref. For the 'map' though, we know
// it's safe to modify the value field and we can allow it:
return it->second;
}
T_Value& at(const T_Key& k) {
iterator it = find(k);
if (it == end()) { throw std::out_of_range("sorry"); }
return it->second;
}
const T_Value& at(const T_Key& k) const {
iterator it = find(k);
if (it == end()) { throw std::out_of_range("sorry"); }
return it->second;
}
void clear() { m_set.clear(); }
size_t size() const { return m_set.size(); }
};
#endif

6
include/verilated_vcd_c.h
View File

@ -113,11 +113,11 @@ protected:
// Implementation of VerilatedTrace interface
// Implementations of protected virtual methods for VerilatedTrace
void emitTimeChange(vluint64_t timeui) VL_OVERRIDE;
void emitTimeChange(vluint64_t timeui) override;
// Hooks called from VerilatedTrace
bool preFullDump() VL_OVERRIDE { return isOpen(); }
bool preChangeDump() VL_OVERRIDE;
bool preFullDump() override { return isOpen(); }
bool preChangeDump() override;
// Implementations of duck-typed methods for VerilatedTrace. These are
// called from only one place (namely full*) so always inline them.

20
include/verilatedos.h
View File

@ -184,19 +184,13 @@
// C++-2011
#if __cplusplus >= 201103L || defined(__GXX_EXPERIMENTAL_CXX0X__) || defined(VL_CPPCHECK)
// These are deprecated historical defines. We leave them in case users referenced them.
# define VL_EQ_DELETE = delete
# define vl_unique_ptr std::unique_ptr
// By default we use std:: types in C++11.
// Define VL_USE_UNORDERED_TYPES to test these pre-C++11 classes
# ifdef VL_USE_UNORDERED_TYPES
# define VL_INCLUDE_UNORDERED_MAP "verilated_unordered_set_map.h"
# define VL_INCLUDE_UNORDERED_SET "verilated_unordered_set_map.h"
# else
# define vl_unordered_map std::unordered_map
# define vl_unordered_set std::unordered_set
# define VL_INCLUDE_UNORDERED_MAP <unordered_map>
# define VL_INCLUDE_UNORDERED_SET <unordered_set>
# endif
# define vl_unordered_map std::unordered_map
# define vl_unordered_set std::unordered_set
# define VL_INCLUDE_UNORDERED_MAP <unordered_map>
# define VL_INCLUDE_UNORDERED_SET <unordered_set>
# define VL_FINAL final
# define VL_MUTABLE mutable
# define VL_OVERRIDE override
@ -382,8 +376,8 @@ typedef unsigned long long vluint64_t; ///< 64-bit unsigned type
// Used to declare a class as uncopyable; put after a private:
#define VL_UNCOPYABLE(Type) \
Type(const Type& other) VL_EQ_DELETE; \
Type& operator=(const Type&) VL_EQ_DELETE
Type(const Type& other) = delete; \
Type& operator=(const Type&) = delete
//=========================================================================
// Verilated function size macros

46
src/V3Active.cpp
View File

@ -36,7 +36,7 @@
#include "V3Const.h"
#include "V3SenTree.h" // for SenTreeSet
#include VL_INCLUDE_UNORDERED_MAP
#include <unordered_map>
//***** See below for main transformation engine
@ -56,7 +56,7 @@ private:
AstActive* m_cActivep; // For current scope, the SActive(combo) we're building
SenTreeSet m_activeSens; // Sen lists for each active we've made
typedef vl_unordered_map<AstSenTree*, AstActive*> ActiveMap;
typedef std::unordered_map<AstSenTree*, AstActive*> ActiveMap;
ActiveMap m_activeMap; // Map sentree to active, for folding.
// METHODS
@ -65,7 +65,7 @@ private:
m_scopep->addActivep(nodep);
}
// VISITORS
virtual void visit(AstScope* nodep) VL_OVERRIDE {
virtual void visit(AstScope* nodep) override {
m_scopep = nodep;
m_iActivep = NULL;
m_cActivep = NULL;
@ -74,13 +74,13 @@ private:
iterateChildren(nodep);
// Don't clear scopep, the namer persists beyond this visit
}
virtual void visit(AstSenTree* nodep) VL_OVERRIDE {
virtual void visit(AstSenTree* nodep) override {
// Simplify sensitivity list
VL_DO_DANGLING(V3Const::constifyExpensiveEdit(nodep), nodep);
}
//--------------------
virtual void visit(AstNodeStmt*) VL_OVERRIDE {} // Accelerate
virtual void visit(AstNode* nodep) VL_OVERRIDE { iterateChildren(nodep); }
virtual void visit(AstNodeStmt*) override {} // Accelerate
virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
public:
// METHODS
@ -152,7 +152,7 @@ private:
AstNode* m_alwaysp; // Always we're under
AstNode* m_assignp; // In assign
// VISITORS
virtual void visit(AstAssignDly* nodep) VL_OVERRIDE {
virtual void visit(AstAssignDly* nodep) override {
if (m_check != CT_SEQ) {
// Convert to a non-delayed assignment
UINFO(5, " ASSIGNDLY " << nodep << endl);
@ -174,7 +174,7 @@ private:
VL_DO_DANGLING(nodep->deleteTree(), nodep);
}
}
virtual void visit(AstAssign* nodep) VL_OVERRIDE {
virtual void visit(AstAssign* nodep) override {
if (m_check == CT_SEQ) {
AstNode* las = m_assignp;
m_assignp = nodep;
@ -182,7 +182,7 @@ private:
m_assignp = las;
}
}
virtual void visit(AstVarRef* nodep) VL_OVERRIDE {
virtual void visit(AstVarRef* nodep) override {
AstVar* varp = nodep->varp();
if (m_check == CT_SEQ && m_assignp && !varp->isUsedLoopIdx() // Ignore loop indices
&& !varp->isTemp()) {
@ -201,7 +201,7 @@ private:
}
}
//--------------------
virtual void visit(AstNode* nodep) VL_OVERRIDE { iterateChildren(nodep); }
virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
public:
// CONSTRUCTORS
@ -230,7 +230,7 @@ private:
bool m_itemSequent; // Found a SenItem sequential
// VISITORS
virtual void visit(AstScope* nodep) VL_OVERRIDE {
virtual void visit(AstScope* nodep) override {
// Create required actives and add to scope
UINFO(4, " SCOPE " << nodep << endl);
// Clear last scope's names, and collect this scope's existing names
@ -238,10 +238,10 @@ private:
m_scopeFinalp = NULL;
iterateChildren(nodep);
}
virtual void visit(AstActive* nodep) VL_OVERRIDE {
virtual void visit(AstActive* nodep) override {
// Actives are being formed, so we can ignore any already made
}
virtual void visit(AstInitial* nodep) VL_OVERRIDE {
virtual void visit(AstInitial* nodep) override {
// Relink to IACTIVE, unless already under it
UINFO(4, " INITIAL " << nodep << endl);
ActiveDlyVisitor dlyvisitor(nodep, ActiveDlyVisitor::CT_INITIAL);
@ -249,28 +249,28 @@ private:
nodep->unlinkFrBack();
wantactivep->addStmtsp(nodep);
}
virtual void visit(AstAssignAlias* nodep) VL_OVERRIDE {
virtual void visit(AstAssignAlias* nodep) override {
// Relink to CACTIVE, unless already under it
UINFO(4, " ASSIGNW " << nodep << endl);
AstActive* wantactivep = m_namer.getCActive(nodep->fileline());
nodep->unlinkFrBack();
wantactivep->addStmtsp(nodep);
}
virtual void visit(AstAssignW* nodep) VL_OVERRIDE {
virtual void visit(AstAssignW* nodep) override {
// Relink to CACTIVE, unless already under it
UINFO(4, " ASSIGNW " << nodep << endl);
AstActive* wantactivep = m_namer.getCActive(nodep->fileline());
nodep->unlinkFrBack();
wantactivep->addStmtsp(nodep);
}
virtual void visit(AstCoverToggle* nodep) VL_OVERRIDE {
virtual void visit(AstCoverToggle* nodep) override {
// Relink to CACTIVE, unless already under it
UINFO(4, " COVERTOGGLE " << nodep << endl);
AstActive* wantactivep = m_namer.getCActive(nodep->fileline());
nodep->unlinkFrBack();
wantactivep->addStmtsp(nodep);
}
virtual void visit(AstFinal* nodep) VL_OVERRIDE {
virtual void visit(AstFinal* nodep) override {
// Relink to CFUNC for the final
UINFO(4, " FINAL " << nodep << endl);
if (!nodep->bodysp()) { // Empty, Kill it.
@ -358,7 +358,7 @@ private:
ActiveDlyVisitor dlyvisitor(nodep, ActiveDlyVisitor::CT_SEQ);
}
}
virtual void visit(AstAlways* nodep) VL_OVERRIDE {
virtual void visit(AstAlways* nodep) override {
// Move always to appropriate ACTIVE based on its sense list
UINFO(4, " ALW " << nodep << endl);
// if (debug() >= 9) nodep->dumpTree(cout, " Alw: ");
@ -370,13 +370,13 @@ private:
}
visitAlways(nodep, nodep->sensesp(), nodep->keyword());
}
virtual void visit(AstAlwaysPublic* nodep) VL_OVERRIDE {
virtual void visit(AstAlwaysPublic* nodep) override {
// Move always to appropriate ACTIVE based on its sense list
UINFO(4, " ALWPub " << nodep << endl);
// if (debug() >= 9) nodep->dumpTree(cout, " Alw: ");
visitAlways(nodep, nodep->sensesp(), VAlwaysKwd::ALWAYS);
}
virtual void visit(AstSenItem* nodep) VL_OVERRIDE {
virtual void visit(AstSenItem* nodep) override {
if (nodep->varrefp()) {
if (AstBasicDType* basicp = nodep->varrefp()->dtypep()->basicp()) {
if (basicp->isEventValue()) {
@ -405,9 +405,9 @@ private:
}
//--------------------
virtual void visit(AstNodeMath*) VL_OVERRIDE {} // Accelerate
virtual void visit(AstVarScope*) VL_OVERRIDE {} // Accelerate
virtual void visit(AstNode* nodep) VL_OVERRIDE { iterateChildren(nodep); }
virtual void visit(AstNodeMath*) override {} // Accelerate
virtual void visit(AstVarScope*) override {} // Accelerate
virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
public:
// CONSTRUCTORS

20
src/V3ActiveTop.cpp
View File

@ -52,19 +52,19 @@ private:
VL_DEBUG_FUNC; // Declare debug()
// VISITORS
virtual void visit(AstTopScope* nodep) VL_OVERRIDE {
virtual void visit(AstTopScope* nodep) override {
m_topscopep = nodep;
m_finder.init(m_topscopep);
iterateChildren(nodep);
m_topscopep = NULL;
}
virtual void visit(AstNodeModule* nodep) VL_OVERRIDE {
virtual void visit(AstNodeModule* nodep) override {
// Create required actives and add to module
// We can start ordering at a module, or a scope
UINFO(4, " MOD " << nodep << endl);
iterateChildren(nodep);
}
virtual void visit(AstActive* nodep) VL_OVERRIDE {
virtual void visit(AstActive* nodep) override {
UINFO(4, " ACTIVE " << nodep << endl);
// Remove duplicate clocks and such; sensesp() may change!
V3Const::constifyExpensiveEdit(nodep);
@ -108,22 +108,22 @@ private:
// No need to do statements under it, they're already moved.
// iterateChildren(nodep);
}
virtual void visit(AstNodeProcedure* nodep) VL_OVERRIDE { // LCOV_EXCL_LINE
virtual void visit(AstNodeProcedure* nodep) override { // LCOV_EXCL_LINE
nodep->v3fatalSrc("Node should have been under ACTIVE");
}
virtual void visit(AstAssignAlias* nodep) VL_OVERRIDE { // LCOV_EXCL_LINE
virtual void visit(AstAssignAlias* nodep) override { // LCOV_EXCL_LINE
nodep->v3fatalSrc("Node should have been under ACTIVE");
}
virtual void visit(AstAssignW* nodep) VL_OVERRIDE { // LCOV_EXCL_LINE
virtual void visit(AstAssignW* nodep) override { // LCOV_EXCL_LINE
nodep->v3fatalSrc("Node should have been under ACTIVE");
}
virtual void visit(AstAlwaysPublic* nodep) VL_OVERRIDE { // LCOV_EXCL_LINE
virtual void visit(AstAlwaysPublic* nodep) override { // LCOV_EXCL_LINE
nodep->v3fatalSrc("Node should have been under ACTIVE");
}
//--------------------
virtual void visit(AstNodeMath*) VL_OVERRIDE {} // Accelerate
virtual void visit(AstVarScope*) VL_OVERRIDE {} // Accelerate
virtual void visit(AstNode* nodep) VL_OVERRIDE { iterateChildren(nodep); }
virtual void visit(AstNodeMath*) override {} // Accelerate
virtual void visit(AstVarScope*) override {} // Accelerate
virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
public:
// CONSTRUCTORS

22
src/V3Assert.cpp
View File

@ -169,7 +169,7 @@ private:
}
// VISITORS
virtual void visit(AstIf* nodep) VL_OVERRIDE {
virtual void visit(AstIf* nodep) override {
if (nodep->user1SetOnce()) return;
if (nodep->uniquePragma() || nodep->unique0Pragma()) {
AstNodeIf* ifp = nodep;
@ -226,7 +226,7 @@ private:
}
//========== Case assertions
virtual void visit(AstCase* nodep) VL_OVERRIDE {
virtual void visit(AstCase* nodep) override {
iterateChildren(nodep);
if (!nodep->user1SetOnce()) {
bool has_default = false;
@ -296,7 +296,7 @@ private:
}
//========== Past
virtual void visit(AstPast* nodep) VL_OVERRIDE {
virtual void visit(AstPast* nodep) override {
iterateChildren(nodep);
uint32_t ticks = 1;
if (nodep->ticksp()) {
@ -325,13 +325,13 @@ private:
}
nodep->replaceWith(inp);
}
virtual void visit(AstSampled* nodep) VL_OVERRIDE {
virtual void visit(AstSampled* nodep) override {
nodep->replaceWith(nodep->exprp()->unlinkFrBack());
VL_DO_DANGLING(pushDeletep(nodep), nodep);
}
//========== Statements
virtual void visit(AstDisplay* nodep) VL_OVERRIDE {
virtual void visit(AstDisplay* nodep) override {
iterateChildren(nodep);
// Replace the special types with standard text
if (nodep->displayType() == AstDisplayType::DT_INFO) {
@ -344,21 +344,21 @@ private:
}
}
virtual void visit(AstAssert* nodep) VL_OVERRIDE {
virtual void visit(AstAssert* nodep) override {
iterateChildren(nodep);
newPslAssertion(nodep, nodep->failsp());
}
virtual void visit(AstCover* nodep) VL_OVERRIDE {
virtual void visit(AstCover* nodep) override {
iterateChildren(nodep);
newPslAssertion(nodep, NULL);
}
virtual void visit(AstRestrict* nodep) VL_OVERRIDE {
virtual void visit(AstRestrict* nodep) override {
iterateChildren(nodep);
// IEEE says simulator ignores these
VL_DO_DANGLING(pushDeletep(nodep->unlinkFrBack()), nodep);
}
virtual void visit(AstNodeModule* nodep) VL_OVERRIDE {
virtual void visit(AstNodeModule* nodep) override {
AstNodeModule* origModp = m_modp;
unsigned origPastNum = m_modPastNum;
{
@ -369,7 +369,7 @@ private:
m_modp = origModp;
m_modPastNum = origPastNum;
}
virtual void visit(AstBegin* nodep) VL_OVERRIDE {
virtual void visit(AstBegin* nodep) override {
// This code is needed rather than a visitor in V3Begin,
// because V3Assert is called before V3Begin
AstBegin* lastp = m_beginp;
@ -380,7 +380,7 @@ private:
m_beginp = lastp;
}
virtual void visit(AstNode* nodep) VL_OVERRIDE { iterateChildren(nodep); }
virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
public:
// CONSTRUCTORS

20
src/V3AssertPre.cpp
View File

@ -62,7 +62,7 @@ private:
// VISITORS
//========== Statements
virtual void visit(AstClocking* nodep) VL_OVERRIDE {
virtual void visit(AstClocking* nodep) override {
UINFO(8, " CLOCKING" << nodep << endl);
// Store the new default clock, reset on new module
m_seniDefaultp = nodep->sensesp();
@ -74,14 +74,14 @@ private:
}
VL_DO_DANGLING(pushDeletep(nodep), nodep);
}
virtual void visit(AstAlways* nodep) VL_OVERRIDE {
virtual void visit(AstAlways* nodep) override {
iterateAndNextNull(nodep->sensesp());
if (nodep->sensesp()) m_seniAlwaysp = nodep->sensesp()->sensesp();
iterateAndNextNull(nodep->bodysp());
m_seniAlwaysp = NULL;
}
virtual void visit(AstNodeCoverOrAssert* nodep) VL_OVERRIDE {
virtual void visit(AstNodeCoverOrAssert* nodep) override {
if (nodep->sentreep()) return; // Already processed
clearAssertInfo();
// Find Clocking's buried under nodep->exprsp
@ -89,7 +89,7 @@ private:
if (!nodep->immediate()) nodep->sentreep(newSenTree(nodep));
clearAssertInfo();
}
virtual void visit(AstFell* nodep) VL_OVERRIDE {
virtual void visit(AstFell* nodep) override {
if (nodep->sentreep()) return; // Already processed
iterateChildren(nodep);
FileLine* fl = nodep->fileline();
@ -103,12 +103,12 @@ private:
nodep->sentreep(newSenTree(nodep));
VL_DO_DANGLING(pushDeletep(nodep), nodep);
}
virtual void visit(AstPast* nodep) VL_OVERRIDE {
virtual void visit(AstPast* nodep) override {
if (nodep->sentreep()) return; // Already processed
iterateChildren(nodep);
nodep->sentreep(newSenTree(nodep));
}
virtual void visit(AstRose* nodep) VL_OVERRIDE {
virtual void visit(AstRose* nodep) override {
if (nodep->sentreep()) return; // Already processed
iterateChildren(nodep);
FileLine* fl = nodep->fileline();
@ -122,7 +122,7 @@ private:
nodep->sentreep(newSenTree(nodep));
VL_DO_DANGLING(pushDeletep(nodep), nodep);
}
virtual void visit(AstStable* nodep) VL_OVERRIDE {
virtual void visit(AstStable* nodep) override {
if (nodep->sentreep()) return; // Already processed
iterateChildren(nodep);
FileLine* fl = nodep->fileline();
@ -137,7 +137,7 @@ private:
VL_DO_DANGLING(pushDeletep(nodep), nodep);
}
virtual void visit(AstPropClocked* nodep) VL_OVERRIDE {
virtual void visit(AstPropClocked* nodep) override {
// No need to iterate the body, once replace will get iterated
iterateAndNextNull(nodep->sensesp());
if (m_senip)
@ -160,12 +160,12 @@ private:
nodep->replaceWith(blockp);
VL_DO_DANGLING(pushDeletep(nodep), nodep);
}
virtual void visit(AstNodeModule* nodep) VL_OVERRIDE {
virtual void visit(AstNodeModule* nodep) override {
iterateChildren(nodep);
// Reset defaults
m_seniDefaultp = NULL;
}
virtual void visit(AstNode* nodep) VL_OVERRIDE { iterateChildren(nodep); }
virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
public:
// CONSTRUCTORS

2
src/V3Ast.cpp
View File

@ -1119,7 +1119,7 @@ void AstNode::dumpTreeFile(const string& filename, bool append, bool doDump) {
if (doDump) {
{ // Write log & close
UINFO(2, "Dumping " << filename << endl);
const vl_unique_ptr<std::ofstream> logsp(V3File::new_ofstream(filename, append));
const std::unique_ptr<std::ofstream> logsp(V3File::new_ofstream(filename, append));
if (logsp->fail()) v3fatal("Can't write " << filename);
*logsp << "Verilator Tree Dump (format 0x3900) from <e" << std::dec << editCountLast();
*logsp << "> to <e" << std::dec << editCountGbl() << ">" << endl;

2
src/V3Ast.h
View File

@ -26,7 +26,7 @@
#include "V3Global.h"
#include <cmath>
#include VL_INCLUDE_UNORDERED_SET
#include <unordered_set>
#include "V3Ast__gen_classes.h" // From ./astgen
// Things like:

2
src/V3AstNodes.cpp
View File

@ -74,7 +74,7 @@ void AstNodeUOrStructDType::repairMemberCache() {
}
const char* AstNodeUOrStructDType::broken() const {
vl_unordered_set<AstMemberDType*> exists;
std::unordered_set<AstMemberDType*> exists;
for (AstMemberDType* itemp = membersp(); itemp; itemp = VN_CAST(itemp->nextp(), MemberDType)) {
exists.insert(itemp);
}

30
src/V3Begin.cpp
View File

@ -71,7 +71,7 @@ private:
VL_DEBUG_FUNC; // Declare debug()
// VISITORS
virtual void visit(AstNodeModule* nodep) VL_OVERRIDE {
virtual void visit(AstNodeModule* nodep) override {
AstNodeModule* origModp = m_modp;
{
m_modp = nodep;
@ -79,7 +79,7 @@ private:
}
m_modp = origModp;
}
virtual void visit(AstNodeFTask* nodep) VL_OVERRIDE {
virtual void visit(AstNodeFTask* nodep) override {
UINFO(8, " " << nodep << endl);
// Rename it
if (m_unnamedScope != "") {
@ -104,7 +104,7 @@ private:
m_namedScope = oldScope;
m_unnamedScope = oldUnnamed;
}
virtual void visit(AstBegin* nodep) VL_OVERRIDE {
virtual void visit(AstBegin* nodep) override {
// Begin blocks were only useful in variable creation, change names and delete
UINFO(8, " " << nodep << endl);
string oldScope = m_namedScope;
@ -163,7 +163,7 @@ private:
}
VL_DO_DANGLING(pushDeletep(nodep), nodep);
}
virtual void visit(AstVar* nodep) VL_OVERRIDE {
virtual void visit(AstVar* nodep) override {
if (m_unnamedScope != "") {
// Rename it
nodep->name(m_unnamedScope + "__DOT__" + nodep->name());
@ -177,7 +177,7 @@ private:
}
}
}
virtual void visit(AstTypedef* nodep) VL_OVERRIDE {
virtual void visit(AstTypedef* nodep) override {
if (m_unnamedScope != "") {
// Rename it
nodep->name(m_unnamedScope + "__DOT__" + nodep->name());
@ -192,7 +192,7 @@ private:
}
}
}
virtual void visit(AstCell* nodep) VL_OVERRIDE {
virtual void visit(AstCell* nodep) override {
UINFO(8, " CELL " << nodep << endl);
if (m_namedScope != "") {
m_statep->userMarkChanged(nodep);
@ -205,14 +205,14 @@ private:
}
iterateChildren(nodep);
}
virtual void visit(AstVarXRef* nodep) VL_OVERRIDE {
virtual void visit(AstVarXRef* nodep) override {
UINFO(9, " VARXREF " << nodep << endl);
if (m_namedScope != "" && nodep->inlinedDots() == "") {
nodep->inlinedDots(m_namedScope);
UINFO(9, " rescope to " << nodep << endl);
}
}
virtual void visit(AstScopeName* nodep) VL_OVERRIDE {
virtual void visit(AstScopeName* nodep) override {
// If there's a %m in the display text, we add a special node that will contain the name()
// Similar code in V3Inline
if (nodep->user1SetOnce()) return; // Don't double-add text's
@ -225,13 +225,13 @@ private:
}
iterateChildren(nodep);
}
virtual void visit(AstCoverDecl* nodep) VL_OVERRIDE {
virtual void visit(AstCoverDecl* nodep) override {
// Don't need to fix path in coverage statements, they're not under
// any BEGINs, but V3Coverage adds them all under the module itself.
iterateChildren(nodep);
}
// VISITORS - LINT CHECK
virtual void visit(AstIf* nodep) VL_OVERRIDE { // not AstNodeIf; other types not covered
virtual void visit(AstIf* nodep) override { // not AstNodeIf; other types not covered
// Check IFDEPTH warning - could be in other transform files if desire
int prevIfDepth = m_ifDepth;
if (m_ifDepth == -1 || v3Global.opt.ifDepth() < 1) { // Turned off
@ -246,7 +246,7 @@ private:
iterateChildren(nodep);
m_ifDepth = prevIfDepth;
}
virtual void visit(AstNode* nodep) VL_OVERRIDE { iterateChildren(nodep); }
virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
public:
// CONSTRUCTORS
@ -270,21 +270,21 @@ private:
// AstNodeFTask::user1p // Node replaced, rename it
// VISITORS
virtual void visit(AstNodeFTaskRef* nodep) VL_OVERRIDE {
virtual void visit(AstNodeFTaskRef* nodep) override {
if (nodep->taskp()->user1()) { // It was converted
UINFO(9, " relinkFTask " << nodep << endl);
nodep->name(nodep->taskp()->name());
}
iterateChildren(nodep);
}
virtual void visit(AstVarRef* nodep) VL_OVERRIDE {
virtual void visit(AstVarRef* nodep) override {
if (nodep->varp()->user1()) { // It was converted
UINFO(9, " relinVarRef " << nodep << endl);
nodep->name(nodep->varp()->name());
}
iterateChildren(nodep);
}
virtual void visit(AstIfaceRefDType* nodep) VL_OVERRIDE {
virtual void visit(AstIfaceRefDType* nodep) override {
// May have changed cell names
// TypeTable is always after all modules, so names are stable
UINFO(8, " IFACEREFDTYPE " << nodep << endl);
@ -293,7 +293,7 @@ private:
iterateChildren(nodep);
}
//--------------------
virtual void visit(AstNode* nodep) VL_OVERRIDE { iterateChildren(nodep); }
virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
public:
// CONSTRUCTORS

8
src/V3Branch.cpp
View File

@ -65,7 +65,7 @@ private:
}
// VISITORS
virtual void visit(AstNodeIf* nodep) VL_OVERRIDE {
virtual void visit(AstNodeIf* nodep) override {
UINFO(4, " IF: " << nodep << endl);
int lastLikely = m_likely;
int lastUnlikely = m_unlikely;
@ -91,17 +91,17 @@ private:
m_likely = lastLikely;
m_unlikely = lastUnlikely;
}
virtual void visit(AstNodeCCall* nodep) VL_OVERRIDE {
virtual void visit(AstNodeCCall* nodep) override {
checkUnlikely(nodep);
nodep->funcp()->user1Inc();
iterateChildren(nodep);
}
virtual void visit(AstCFunc* nodep) VL_OVERRIDE {
virtual void visit(AstCFunc* nodep) override {
checkUnlikely(nodep);
m_cfuncsp.push_back(nodep);
iterateChildren(nodep);
}
virtual void visit(AstNode* nodep) VL_OVERRIDE {
virtual void visit(AstNode* nodep) override {
checkUnlikely(nodep);
iterateChildren(nodep);
}

10
src/V3Broken.cpp
View File

@ -32,7 +32,7 @@
#include "V3AstConstOnly.h"
#include <algorithm>
#include VL_INCLUDE_UNORDERED_MAP
#include <unordered_map>
//######################################################################
@ -41,7 +41,7 @@ class BrokenTable : public AstNVisitor {
private:
// MEMBERS
// For each node, we keep if it exists or not.
typedef vl_unordered_map<const AstNode*, int> NodeMap; // Performance matters (when --debug)
typedef std::unordered_map<const AstNode*, int> NodeMap; // Performance matters (when --debug)
static NodeMap s_nodes; // Set of all nodes that exist
// BITMASK
enum { FLAG_ALLOCATED = 0x01 }; // new() and not delete()ed
@ -223,7 +223,7 @@ private:
iterateChildrenConst(nodep);
}
// VISITORS
virtual void visit(AstNode* nodep) VL_OVERRIDE {
virtual void visit(AstNode* nodep) override {
// Process not just iterate
processAndIterate(nodep);
}
@ -271,14 +271,14 @@ private:
iterateChildrenConst(nodep);
BrokenTable::setUnder(nodep, false);
}
virtual void visit(AstNodeAssign* nodep) VL_OVERRIDE {
virtual void visit(AstNodeAssign* nodep) override {
processAndIterate(nodep);
UASSERT_OBJ(!(v3Global.assertDTypesResolved() && nodep->brokeLhsMustBeLvalue()
&& VN_IS(nodep->lhsp(), NodeVarRef)
&& !VN_CAST(nodep->lhsp(), NodeVarRef)->lvalue()),
nodep, "Assignment LHS is not an lvalue");
}
virtual void visit(AstNode* nodep) VL_OVERRIDE {
virtual void visit(AstNode* nodep) override {
// Process not just iterate
processAndIterate(nodep);
}

12
src/V3CUse.cpp
View File

@ -32,7 +32,7 @@
#include "V3Ast.h"
#include "V3EmitCBase.h"
#include VL_INCLUDE_UNORDERED_MAP
#include <unordered_map>
//######################################################################
@ -80,7 +80,7 @@ class CUseDTypeVisitor : public AstNVisitor {
CUseState& m_stater; // State for inserter
bool m_impOnly; // In details needed only for implementation
// METHODS
virtual void visit(AstClassRefDType* nodep) VL_OVERRIDE {
virtual void visit(AstClassRefDType* nodep) override {
if (nodep->user2SetOnce()) return; // Process once
if (!m_impOnly) m_stater.newUse(nodep, VUseType::INT_FWD_CLASS, nodep->classp()->name());
// No class.h, it's inside the class package's h file
@ -93,12 +93,12 @@ class CUseDTypeVisitor : public AstNVisitor {
}
m_impOnly = oldImpOnly;
}
virtual void visit(AstNodeDType* nodep) VL_OVERRIDE {
virtual void visit(AstNodeDType* nodep) override {
if (nodep->user2SetOnce()) return; // Process once
if (nodep->virtRefDTypep()) iterate(nodep->virtRefDTypep());
if (nodep->virtRefDType2p()) iterate(nodep->virtRefDType2p());
}
virtual void visit(AstNode* nodep) VL_OVERRIDE {
virtual void visit(AstNode* nodep) override {
if (nodep->user2SetOnce()) return; // Process once
if (nodep->dtypep() && !nodep->dtypep()->user2()) iterate(nodep->dtypep());
iterateChildren(nodep);
@ -189,7 +189,7 @@ class CUseVisitor : public AstNVisitor {
}
// VISITORS
virtual void visit(AstNodeModule* nodep) VL_OVERRIDE {
virtual void visit(AstNodeModule* nodep) override {
if (v3Global.opt.trace()) {
AstCUse* usep
= m_state.newUse(nodep, VUseType::INT_FWD_CLASS, v3Global.opt.traceClassBase());
@ -203,7 +203,7 @@ class CUseVisitor : public AstNVisitor {
makeToStringMiddle(classp);
}
}
virtual void visit(AstNode*) VL_OVERRIDE {} // All in AstNodeModule
virtual void visit(AstNode*) override {} // All in AstNodeModule
public:
// CONSTRUCTORS

10
src/V3Case.cpp
View File

@ -57,7 +57,7 @@ private:
// METHODS
VL_DEBUG_FUNC; // Declare debug()
virtual void visit(AstNodeCase* nodep) VL_OVERRIDE {
virtual void visit(AstNodeCase* nodep) override {
if (VN_IS(nodep, Case) && VN_CAST(nodep, Case)->casex()) {
nodep->v3warn(CASEX, "Suggest casez (with ?'s) in place of casex (with X's)");
}
@ -84,7 +84,7 @@ private:
m_caseExprp = NULL;
}
}
virtual void visit(AstConst* nodep) VL_OVERRIDE {
virtual void visit(AstConst* nodep) override {
// See also neverItem
if (m_caseExprp && nodep->num().isFourState()) {
if (VN_IS(m_caseExprp, GenCase)) {
@ -105,7 +105,7 @@ private:
}
}
}
virtual void visit(AstNode* nodep) VL_OVERRIDE { iterateChildren(nodep); }
virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
public:
// CONSTRUCTORS
@ -467,7 +467,7 @@ private:
}
// VISITORS
virtual void visit(AstCase* nodep) VL_OVERRIDE {
virtual void visit(AstCase* nodep) override {
V3Case::caseLint(nodep);
iterateChildren(nodep);
if (debug() >= 9) nodep->dumpTree(cout, " case_old: ");
@ -482,7 +482,7 @@ private:
}
}
//--------------------
virtual void visit(AstNode* nodep) VL_OVERRIDE { iterateChildren(nodep); }
virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
public:
// CONSTRUCTORS

26
src/V3Cast.cpp
View File

@ -109,25 +109,25 @@ private:
}
// VISITORS
virtual void visit(AstNodeUniop* nodep) VL_OVERRIDE {
virtual void visit(AstNodeUniop* nodep) override {
iterateChildren(nodep);
nodep->user1(nodep->lhsp()->user1());
if (nodep->sizeMattersLhs()) ensureCast(nodep->lhsp());
}
virtual void visit(AstNodeBiop* nodep) VL_OVERRIDE {
virtual void visit(AstNodeBiop* nodep) override {
iterateChildren(nodep);
nodep->user1(nodep->lhsp()->user1() | nodep->rhsp()->user1());
if (nodep->sizeMattersLhs()) ensureCast(nodep->lhsp());
if (nodep->sizeMattersRhs()) ensureCast(nodep->rhsp());
}
virtual void visit(AstNodeTriop* nodep) VL_OVERRIDE {
virtual void visit(AstNodeTriop* nodep) override {
iterateChildren(nodep);
nodep->user1(nodep->lhsp()->user1() | nodep->rhsp()->user1() | nodep->thsp()->user1());
if (nodep->sizeMattersLhs()) ensureCast(nodep->lhsp());
if (nodep->sizeMattersRhs()) ensureCast(nodep->rhsp());
if (nodep->sizeMattersThs()) ensureCast(nodep->thsp());
}
virtual void visit(AstNodeQuadop* nodep) VL_OVERRIDE {
virtual void visit(AstNodeQuadop* nodep) override {
iterateChildren(nodep);
nodep->user1(nodep->lhsp()->user1() | nodep->rhsp()->user1() | nodep->thsp()->user1()
| nodep->fhsp()->user1());
@ -136,12 +136,12 @@ private:
if (nodep->sizeMattersThs()) ensureCast(nodep->thsp());
if (nodep->sizeMattersFhs()) ensureCast(nodep->fhsp());
}
virtual void visit(AstCCast* nodep) VL_OVERRIDE {
virtual void visit(AstCCast* nodep) override {
iterateChildren(nodep);
ensureLower32Cast(nodep);
nodep->user1(1);
}
virtual void visit(AstNegate* nodep) VL_OVERRIDE {
virtual void visit(AstNegate* nodep) override {
iterateChildren(nodep);
nodep->user1(nodep->lhsp()->user1());
if (nodep->lhsp()->widthMin() == 1) {
@ -153,7 +153,7 @@ private:
ensureCast(nodep->lhsp());
}
}
virtual void visit(AstVarRef* nodep) VL_OVERRIDE {
virtual void visit(AstVarRef* nodep) override {
if (!nodep->lvalue() && !VN_IS(nodep->backp(), CCast) && VN_IS(nodep->backp(), NodeMath)
&& !VN_IS(nodep->backp(), ArraySel) && nodep->backp()->width()
&& castSize(nodep) != castSize(nodep->varp())) {
@ -163,7 +163,7 @@ private:
}
nodep->user1(1);
}
virtual void visit(AstConst* nodep) VL_OVERRIDE {
virtual void visit(AstConst* nodep) override {
// Constants are of unknown size if smaller than 33 bits, because
// we're too lazy to wrap every constant in the universe in
// ((IData)#).
@ -171,24 +171,24 @@ private:
}
// Null dereference protection
virtual void visit(AstNullCheck* nodep) VL_OVERRIDE {
virtual void visit(AstNullCheck* nodep) override {
iterateChildren(nodep);
nodep->user1(nodep->lhsp()->user1());
}
virtual void visit(AstCMethodCall* nodep) VL_OVERRIDE {
virtual void visit(AstCMethodCall* nodep) override {
iterateChildren(nodep);
ensureNullChecked(nodep->fromp());
}
virtual void visit(AstMemberSel* nodep) VL_OVERRIDE {
virtual void visit(AstMemberSel* nodep) override {
iterateChildren(nodep);
ensureNullChecked(nodep->fromp());
}
// NOPs
virtual void visit(AstVar*) VL_OVERRIDE {}
virtual void visit(AstVar*) override {}
//--------------------
virtual void visit(AstNode* nodep) VL_OVERRIDE { iterateChildren(nodep); }
virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
public:
// CONSTRUCTORS

52
src/V3Cdc.cpp
View File

@ -145,7 +145,7 @@ private:
std::ofstream* m_ofp; // Output file
string m_prefix;
virtual void visit(AstNode* nodep) VL_OVERRIDE {
virtual void visit(AstNode* nodep) override {
*m_ofp << m_prefix;
if (nodep->user3()) {
*m_ofp << " %%";
@ -182,7 +182,7 @@ private:
int m_maxLineno;
size_t m_maxFilenameLen;
virtual void visit(AstNode* nodep) VL_OVERRIDE {
virtual void visit(AstNode* nodep) override {
iterateChildren(nodep);
// Keeping line+filename lengths separate is much faster than calling ascii().length()
if (nodep->fileline()->lineno() >= m_maxLineno) {
@ -514,7 +514,7 @@ private:
}
string filename = v3Global.opt.makeDir() + "/" + v3Global.opt.prefix() + "__cdc_edges.txt";
const vl_unique_ptr<std::ofstream> ofp(V3File::new_ofstream(filename));
const std::unique_ptr<std::ofstream> ofp(V3File::new_ofstream(filename));
if (ofp->fail()) v3fatal("Can't write " << filename);
*ofp << "Edge Report for " << v3Global.opt.prefix() << endl;
@ -633,7 +633,7 @@ private:
}
// VISITORS
virtual void visit(AstNodeModule* nodep) VL_OVERRIDE {
virtual void visit(AstNodeModule* nodep) override {
AstNodeModule* origModp = m_modp;
{
m_modp = nodep;
@ -641,14 +641,14 @@ private:
}
m_modp = origModp;
}
virtual void visit(AstScope* nodep) VL_OVERRIDE {
virtual void visit(AstScope* nodep) override {
UINFO(4, " SCOPE " << nodep << endl);
m_scopep = nodep;
m_logicVertexp = NULL;
iterateChildren(nodep);
m_scopep = NULL;
}
virtual void visit(AstActive* nodep) VL_OVERRIDE {
virtual void visit(AstActive* nodep) override {
// Create required blocks and add to module
UINFO(4, " BLOCK " << nodep << endl);
AstNode::user2ClearTree();
@ -660,7 +660,7 @@ private:
m_domainp = NULL;
AstNode::user2ClearTree();
}
virtual void visit(AstNodeVarRef* nodep) VL_OVERRIDE {
virtual void visit(AstNodeVarRef* nodep) override {
if (m_scopep) {
UASSERT_OBJ(m_logicVertexp, nodep, "Var ref not under a logic block");
AstVarScope* varscp = nodep->varScopep();
@ -688,51 +688,51 @@ private:
}
}
}
virtual void visit(AstAssignDly* nodep) VL_OVERRIDE {
virtual void visit(AstAssignDly* nodep) override {
m_inDly = true;
iterateChildren(nodep);
m_inDly = false;
}
virtual void visit(AstSenItem* nodep) VL_OVERRIDE {
virtual void visit(AstSenItem* nodep) override {
m_inSenItem = true;
iterateChildren(nodep);
m_inSenItem = false;
}
virtual void visit(AstAlways* nodep) VL_OVERRIDE { iterateNewStmt(nodep); }
virtual void visit(AstAlwaysPublic* nodep) VL_OVERRIDE {
virtual void visit(AstAlways* nodep) override { iterateNewStmt(nodep); }
virtual void visit(AstAlwaysPublic* nodep) override {
// CDC doesn't care about public variables
}
virtual void visit(AstCFunc* nodep) VL_OVERRIDE { iterateNewStmt(nodep); }
virtual void visit(AstAssignAlias* nodep) VL_OVERRIDE { iterateNewStmt(nodep); }
virtual void visit(AstAssignW* nodep) VL_OVERRIDE { iterateNewStmt(nodep); }
virtual void visit(AstCFunc* nodep) override { iterateNewStmt(nodep); }
virtual void visit(AstAssignAlias* nodep) override { iterateNewStmt(nodep); }
virtual void visit(AstAssignW* nodep) override { iterateNewStmt(nodep); }
// Math that shouldn't cause us to clear hazard
virtual void visit(AstConst*) VL_OVERRIDE {}
virtual void visit(AstReplicate* nodep) VL_OVERRIDE { iterateChildren(nodep); }
virtual void visit(AstConcat* nodep) VL_OVERRIDE { iterateChildren(nodep); }
virtual void visit(AstNot* nodep) VL_OVERRIDE { iterateChildren(nodep); }
virtual void visit(AstSel* nodep) VL_OVERRIDE {
virtual void visit(AstConst*) override {}
virtual void visit(AstReplicate* nodep) override { iterateChildren(nodep); }
virtual void visit(AstConcat* nodep) override { iterateChildren(nodep); }
virtual void visit(AstNot* nodep) override { iterateChildren(nodep); }
virtual void visit(AstSel* nodep) override {
if (!VN_IS(nodep->lsbp(), Const)) setNodeHazard(nodep);
iterateChildren(nodep);
}
virtual void visit(AstNodeSel* nodep) VL_OVERRIDE {
virtual void visit(AstNodeSel* nodep) override {
if (!VN_IS(nodep->bitp(), Const)) setNodeHazard(nodep);
iterateChildren(nodep);
}
// Ignores
virtual void visit(AstInitial*) VL_OVERRIDE {}
virtual void visit(AstTraceDecl*) VL_OVERRIDE {}
virtual void visit(AstCoverToggle*) VL_OVERRIDE {}
virtual void visit(AstNodeDType*) VL_OVERRIDE {}
virtual void visit(AstInitial*) override {}
virtual void visit(AstTraceDecl*) override {}
virtual void visit(AstCoverToggle*) override {}
virtual void visit(AstNodeDType*) override {}
//--------------------
// Default
virtual void visit(AstNodeMath* nodep) VL_OVERRIDE {
virtual void visit(AstNodeMath* nodep) override {
setNodeHazard(nodep);
iterateChildren(nodep);
}
virtual void visit(AstNode* nodep) VL_OVERRIDE { iterateChildren(nodep); }
virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
public:
// CONSTRUCTORS

20
src/V3Changed.cpp
View File

@ -142,13 +142,13 @@ private:
m_statep->m_numStmts += visitor.count();
}
virtual void visit(AstBasicDType* nodep) VL_OVERRIDE { //
virtual void visit(AstBasicDType* nodep) override { //
newChangeDet();
}
virtual void visit(AstPackArrayDType* nodep) VL_OVERRIDE { //
virtual void visit(AstPackArrayDType* nodep) override { //
newChangeDet();
}
virtual void visit(AstUnpackArrayDType* nodep) VL_OVERRIDE {
virtual void visit(AstUnpackArrayDType* nodep) override {
for (int index = 0; index < nodep->elementsConst(); ++index) {
AstNode* origVEp = m_varEqnp;
AstNode* origNLEp = m_newLvEqnp;
@ -169,7 +169,7 @@ private:
m_newRvEqnp = origNREp;
}
}
virtual void visit(AstNodeUOrStructDType* nodep) VL_OVERRIDE {
virtual void visit(AstNodeUOrStructDType* nodep) override {
if (nodep->packedUnsup()) {
newChangeDet();
} else {
@ -179,7 +179,7 @@ private:
<< m_vscp->varp()->prettyNameQ());
}
}
virtual void visit(AstNode* nodep) VL_OVERRIDE {
virtual void visit(AstNode* nodep) override {
iterateChildren(nodep);
if (debug()) nodep->dumpTree(cout, "-DETECTARRAY-general-");
m_vscp->v3warn(E_DETECTARRAY, "Unsupported: Can't detect changes on complex variable"
@ -242,13 +242,13 @@ private:
}
// VISITORS
virtual void visit(AstNodeModule* nodep) VL_OVERRIDE {
virtual void visit(AstNodeModule* nodep) override {
UINFO(4, " MOD " << nodep << endl);
if (nodep->isTop()) m_statep->m_topModp = nodep;
iterateChildren(nodep);
}
virtual void visit(AstTopScope* nodep) VL_OVERRIDE {
virtual void visit(AstTopScope* nodep) override {
UINFO(4, " TS " << nodep << endl);
// Clearing
AstNode::user1ClearTree();
@ -271,15 +271,15 @@ private:
iterateChildren(nodep);
}
virtual void visit(AstVarScope* nodep) VL_OVERRIDE {
virtual void visit(AstVarScope* nodep) override {
if (nodep->isCircular()) {
UINFO(8, " CIRC " << nodep << endl);
if (!nodep->user1SetOnce()) genChangeDet(nodep);
}
}
//--------------------
virtual void visit(AstNodeMath*) VL_OVERRIDE {} // Accelerate
virtual void visit(AstNode* nodep) VL_OVERRIDE { iterateChildren(nodep); }
virtual void visit(AstNodeMath*) override {} // Accelerate
virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
public:
// CONSTRUCTORS

14
src/V3Class.cpp
View File

@ -44,7 +44,7 @@ private:
// METHODS
VL_DEBUG_FUNC; // Declare debug()
virtual void visit(AstClass* nodep) VL_OVERRIDE {
virtual void visit(AstClass* nodep) override {
if (nodep->user1SetOnce()) return;
// Move this class
nodep->name(m_prefix + nodep->name());
@ -84,7 +84,7 @@ private:
m_prefix = prevPrefix;
m_classScopep = NULL;
}
virtual void visit(AstPackage* nodep) VL_OVERRIDE {
virtual void visit(AstPackage* nodep) override {
string prevPrefix = m_prefix;
{
m_prefix = nodep->name() + "__03a__03a"; // ::
@ -93,7 +93,7 @@ private:
m_prefix = prevPrefix;
}
virtual void visit(AstVar* nodep) VL_OVERRIDE {
virtual void visit(AstVar* nodep) override {
iterateChildren(nodep);
// Don't move now, or wouldn't keep interating the class
// TODO move class statics only
@ -101,7 +101,7 @@ private:
// m_moves.push_back(make_pair(nodep, m_classScopep));
//}
}
virtual void visit(AstCFunc* nodep) VL_OVERRIDE {
virtual void visit(AstCFunc* nodep) override {
iterateChildren(nodep);
// Don't move now, or wouldn't keep interating the class
// TODO move function statics only
@ -110,9 +110,9 @@ private:
//}
}
virtual void visit(AstNodeMath* nodep) VL_OVERRIDE {} // Short circuit
virtual void visit(AstNodeStmt* nodep) VL_OVERRIDE {} // Short circuit
virtual void visit(AstNode* nodep) VL_OVERRIDE { iterateChildren(nodep); }
virtual void visit(AstNodeMath* nodep) override {} // Short circuit
virtual void visit(AstNodeStmt* nodep) override {} // Short circuit
virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
public:
// CONSTRUCTORS

54
src/V3Clean.cpp
View File

@ -170,7 +170,7 @@ private:
}
// VISITORS
virtual void visit(AstNodeModule* nodep) VL_OVERRIDE {
virtual void visit(AstNodeModule* nodep) override {
AstNodeModule* origModp = m_modp;
{
m_modp = nodep;
@ -178,57 +178,57 @@ private:
}
m_modp = origModp;
}
virtual void visit(AstNodeUniop* nodep) VL_OVERRIDE {
virtual void visit(AstNodeUniop* nodep) override {
iterateChildren(nodep);
computeCppWidth(nodep);
if (nodep->cleanLhs()) ensureClean(nodep->lhsp());
setClean(nodep, nodep->cleanOut());
}
virtual void visit(AstNodeBiop* nodep) VL_OVERRIDE {
virtual void visit(AstNodeBiop* nodep) override {
operandBiop(nodep);
setClean(nodep, nodep->cleanOut());
}
virtual void visit(AstAnd* nodep) VL_OVERRIDE {
virtual void visit(AstAnd* nodep) override {
operandBiop(nodep);
setClean(nodep, isClean(nodep->lhsp()) || isClean(nodep->rhsp()));
}
virtual void visit(AstXor* nodep) VL_OVERRIDE {
virtual void visit(AstXor* nodep) override {
operandBiop(nodep);
setClean(nodep, isClean(nodep->lhsp()) && isClean(nodep->rhsp()));
}
virtual void visit(AstOr* nodep) VL_OVERRIDE {
virtual void visit(AstOr* nodep) override {
operandBiop(nodep);
setClean(nodep, isClean(nodep->lhsp()) && isClean(nodep->rhsp()));
}
virtual void visit(AstNodeQuadop* nodep) VL_OVERRIDE {
virtual void visit(AstNodeQuadop* nodep) override {
operandQuadop(nodep);
setClean(nodep, nodep->cleanOut());
}
virtual void visit(AstNodeMath* nodep) VL_OVERRIDE {
virtual void visit(AstNodeMath* nodep) override {
iterateChildren(nodep);
computeCppWidth(nodep);
setClean(nodep, nodep->cleanOut());
}
virtual void visit(AstNodeAssign* nodep) VL_OVERRIDE {
virtual void visit(AstNodeAssign* nodep) override {
iterateChildren(nodep);
computeCppWidth(nodep);
if (nodep->cleanRhs()) ensureClean(nodep->rhsp());
}
virtual void visit(AstText* nodep) VL_OVERRIDE { //
virtual void visit(AstText* nodep) override { //
setClean(nodep, true);
}
virtual void visit(AstScopeName* nodep) VL_OVERRIDE { //
virtual void visit(AstScopeName* nodep) override { //
setClean(nodep, true);
}
virtual void visit(AstCNew* nodep) VL_OVERRIDE {
virtual void visit(AstCNew* nodep) override {
iterateChildren(nodep);
setClean(nodep, true);
}
virtual void visit(AstSel* nodep) VL_OVERRIDE {
virtual void visit(AstSel* nodep) override {
operandTriop(nodep);
setClean(nodep, nodep->cleanOut());
}
virtual void visit(AstUCFunc* nodep) VL_OVERRIDE {
virtual void visit(AstUCFunc* nodep) override {
iterateChildren(nodep);
computeCppWidth(nodep);
setClean(nodep, false);
@ -236,64 +236,64 @@ private:
if (!VN_IS(nodep->backp(), And)) insertClean(nodep);
ensureCleanAndNext(nodep->bodysp());
}
virtual void visit(AstTraceDecl* nodep) VL_OVERRIDE {
virtual void visit(AstTraceDecl* nodep) override {
// No cleaning, or would loose pointer to enum
iterateChildren(nodep);
}
virtual void visit(AstTraceInc* nodep) VL_OVERRIDE {
virtual void visit(AstTraceInc* nodep) override {
iterateChildren(nodep);
ensureCleanAndNext(nodep->valuep());
}
virtual void visit(AstTypedef* nodep) VL_OVERRIDE {
virtual void visit(AstTypedef* nodep) override {
// No cleaning, or would loose pointer to enum
iterateChildren(nodep);
}
virtual void visit(AstParamTypeDType* nodep) VL_OVERRIDE {
virtual void visit(AstParamTypeDType* nodep) override {
// No cleaning, or would loose pointer to enum
iterateChildren(nodep);
}
// Control flow operators
virtual void visit(AstNodeCond* nodep) VL_OVERRIDE {
virtual void visit(AstNodeCond* nodep) override {
iterateChildren(nodep);
ensureClean(nodep->condp());
setClean(nodep, isClean(nodep->expr1p()) && isClean(nodep->expr2p()));
}
virtual void visit(AstWhile* nodep) VL_OVERRIDE {
virtual void visit(AstWhile* nodep) override {
iterateChildren(nodep);
ensureClean(nodep->condp());
}
virtual void visit(AstNodeIf* nodep) VL_OVERRIDE {
virtual void visit(AstNodeIf* nodep) override {
iterateChildren(nodep);
ensureClean(nodep->condp());
}
virtual void visit(AstSFormatF* nodep) VL_OVERRIDE {
virtual void visit(AstSFormatF* nodep) override {
iterateChildren(nodep);
ensureCleanAndNext(nodep->exprsp());
setClean(nodep, true); // generates a string, so not relevant
}
virtual void visit(AstUCStmt* nodep) VL_OVERRIDE {
virtual void visit(AstUCStmt* nodep) override {
iterateChildren(nodep);
ensureCleanAndNext(nodep->bodysp());
}
virtual void visit(AstNodeCCall* nodep) VL_OVERRIDE {
virtual void visit(AstNodeCCall* nodep) override {
iterateChildren(nodep);
ensureCleanAndNext(nodep->argsp());
setClean(nodep, true);
}
virtual void visit(AstCMethodHard* nodep) VL_OVERRIDE {
virtual void visit(AstCMethodHard* nodep) override {
iterateChildren(nodep);
ensureCleanAndNext(nodep->pinsp());
setClean(nodep, true);
}
virtual void visit(AstIntfRef* nodep) VL_OVERRIDE {
virtual void visit(AstIntfRef* nodep) override {
iterateChildren(nodep);
setClean(nodep, true); // generates a string, so not relevant
}
//--------------------
// Default: Just iterate
virtual void visit(AstNode* nodep) VL_OVERRIDE {
virtual void visit(AstNode* nodep) override {
iterateChildren(nodep);
computeCppWidth(nodep);
}

24
src/V3Clock.cpp
View File

@ -162,7 +162,7 @@ private:
}
// VISITORS
virtual void visit(AstTopScope* nodep) VL_OVERRIDE {
virtual void visit(AstTopScope* nodep) override {
UINFO(4, " TOPSCOPE " << nodep << endl);
m_topScopep = nodep;
m_scopep = nodep->scopep();
@ -226,7 +226,7 @@ private:
m_topScopep = NULL;
m_scopep = NULL;
}
virtual void visit(AstNodeModule* nodep) VL_OVERRIDE {
virtual void visit(AstNodeModule* nodep) override {
// UINFO(4, " MOD " << nodep << endl);
AstNodeModule* origModp = m_modp;
{
@ -235,7 +235,7 @@ private:
}
m_modp = origModp;
}
virtual void visit(AstScope* nodep) VL_OVERRIDE {
virtual void visit(AstScope* nodep) override {
// UINFO(4, " SCOPE " << nodep << endl);
m_scopep = nodep;
iterateChildren(nodep);
@ -246,7 +246,7 @@ private:
}
m_scopep = NULL;
}
virtual void visit(AstAlways* nodep) VL_OVERRIDE {
virtual void visit(AstAlways* nodep) override {
AstNode* cmtp = new AstComment(nodep->fileline(), nodep->typeName(), true);
nodep->replaceWith(cmtp);
if (AstNode* stmtsp = nodep->bodysp()) {
@ -255,7 +255,7 @@ private:
}
VL_DO_DANGLING(nodep->deleteTree(), nodep);
}
virtual void visit(AstAlwaysPost* nodep) VL_OVERRIDE {
virtual void visit(AstAlwaysPost* nodep) override {
AstNode* cmtp = new AstComment(nodep->fileline(), nodep->typeName(), true);
nodep->replaceWith(cmtp);
if (AstNode* stmtsp = nodep->bodysp()) {
@ -264,7 +264,7 @@ private:
}
VL_DO_DANGLING(nodep->deleteTree(), nodep);
}
virtual void visit(AstCoverToggle* nodep) VL_OVERRIDE {
virtual void visit(AstCoverToggle* nodep) override {
// nodep->dumpTree(cout, "ct:");
// COVERTOGGLE(INC, ORIG, CHANGE) ->
// IF(ORIG ^ CHANGE) { INC; CHANGE = ORIG; }
@ -281,7 +281,7 @@ private:
nodep->replaceWith(newp);
VL_DO_DANGLING(nodep->deleteTree(), nodep);
}
virtual void visit(AstInitial* nodep) VL_OVERRIDE {
virtual void visit(AstInitial* nodep) override {
AstNode* cmtp = new AstComment(nodep->fileline(), nodep->typeName(), true);
nodep->replaceWith(cmtp);
if (AstNode* stmtsp = nodep->bodysp()) {
@ -290,7 +290,7 @@ private:
}
VL_DO_DANGLING(nodep->deleteTree(), nodep);
}
virtual void visit(AstCFunc* nodep) VL_OVERRIDE {
virtual void visit(AstCFunc* nodep) override {
iterateChildren(nodep);
// Link to global function
if (nodep->formCallTree()) {
@ -300,7 +300,7 @@ private:
m_finalFuncp->addStmtsp(callp);
}
}
virtual void visit(AstSenTree* nodep) VL_OVERRIDE {
virtual void visit(AstSenTree* nodep) override {
// Delete it later; Actives still pointing to it
nodep->unlinkFrBack();
pushDeletep(nodep);
@ -314,7 +314,7 @@ private:
void addToInitial(AstNode* stmtsp) {
m_initFuncp->addStmtsp(stmtsp); // add to top level function
}
virtual void visit(AstActive* nodep) VL_OVERRIDE {
virtual void visit(AstActive* nodep) override {
// Careful if adding variables here, ACTIVES can be under other ACTIVES
// Need to save and restore any member state in AstUntilStable block
if (!m_topScopep || !nodep->stmtsp()) {
@ -382,7 +382,7 @@ private:
VL_DO_DANGLING(nodep->unlinkFrBack()->deleteTree(), nodep);
}
}
virtual void visit(AstExecGraph* nodep) VL_OVERRIDE {
virtual void visit(AstExecGraph* nodep) override {
for (m_mtaskBodyp = VN_CAST(nodep->op1p(), MTaskBody); m_mtaskBodyp;
m_mtaskBodyp = VN_CAST(m_mtaskBodyp->nextp(), MTaskBody)) {
clearLastSen();
@ -397,7 +397,7 @@ private:
}
//--------------------
virtual void visit(AstNode* nodep) VL_OVERRIDE { iterateChildren(nodep); }
virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
public:
// CONSTRUCTORS

26
src/V3Combine.cpp
View File

@ -121,11 +121,11 @@ public:
private:
// VISITORS
virtual void visit(AstCCall* nodep) VL_OVERRIDE { addCall(nodep); }
virtual void visit(AstCCall* nodep) override { addCall(nodep); }
// Speed things up
virtual void visit(AstNodeAssign*) VL_OVERRIDE {}
virtual void visit(AstNodeMath*) VL_OVERRIDE {}
virtual void visit(AstNode* nodep) VL_OVERRIDE { iterateChildren(nodep); }
virtual void visit(AstNodeAssign*) override {}
virtual void visit(AstNodeMath*) override {}
virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
public:
// CONSTRUCTORS
@ -143,7 +143,7 @@ private:
// OUTPUT:
// AstNode::user3() -> bool. True to indicate duplicated
// VISITORS
virtual void visit(AstNode* nodep) VL_OVERRIDE {
virtual void visit(AstNode* nodep) override {
nodep->user3(true);
iterateChildren(nodep);
}
@ -381,7 +381,7 @@ private:
#endif
// VISITORS
virtual void visit(AstNetlist* nodep) VL_OVERRIDE {
virtual void visit(AstNetlist* nodep) override {
// Track all callers of each function
m_call.main(nodep);
//
@ -390,7 +390,7 @@ private:
// Required so that a module instantiating another can benefit from collapsing.
iterateChildrenBackwards(nodep);
}
virtual void visit(AstNodeModule* nodep) VL_OVERRIDE {
virtual void visit(AstNodeModule* nodep) override {
UINFO(4, " MOD " << nodep << endl);
m_modp = nodep;
m_modNFuncs = 0;
@ -419,7 +419,7 @@ private:
#endif
m_modp = NULL;
}
virtual void visit(AstCFunc* nodep) VL_OVERRIDE {
virtual void visit(AstCFunc* nodep) override {
m_funcp = nodep;
if (!nodep->dontCombine()) {
if (m_state == STATE_HASH) {
@ -433,7 +433,7 @@ private:
}
m_funcp = NULL;
}
virtual void visit(AstNodeStmt* nodep) VL_OVERRIDE {
virtual void visit(AstNodeStmt* nodep) override {
if (!nodep->isStatement()) {
iterateChildren(nodep);
return;
@ -450,10 +450,10 @@ private:
//--------------------
// Default: Just iterate
virtual void visit(AstVar*) VL_OVERRIDE {}
virtual void visit(AstTraceDecl*) VL_OVERRIDE {}
virtual void visit(AstTraceInc*) VL_OVERRIDE {}
virtual void visit(AstNode* nodep) VL_OVERRIDE { iterateChildren(nodep); }
virtual void visit(AstVar*) override {}
virtual void visit(AstTraceDecl*) override {}
virtual void visit(AstTraceInc*) override {}
virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
public:
// CONSTRUCTORS

2
src/V3Config.cpp
View File

@ -157,7 +157,7 @@ typedef V3ConfigWildcardResolver<V3ConfigFTask> V3ConfigFTaskResolver;
// Modules have tasks, variables, named blocks and properties
class V3ConfigModule {
typedef vl_unordered_set<string> StringSet;
typedef std::unordered_set<string> StringSet;
typedef std::set<AstPragmaType> PragmaSet;
V3ConfigFTaskResolver m_tasks; // Functions/tasks in module

76
src/V3Const.cpp
View File

@ -41,10 +41,10 @@ class ConstVarMarkVisitor : public AstNVisitor {
// AstVar::user4p -> bool, Var marked, 0=not set yet
private:
// VISITORS
virtual void visit(AstVarRef* nodep) VL_OVERRIDE {
virtual void visit(AstVarRef* nodep) override {
if (nodep->varp()) nodep->varp()->user4(1);
}
virtual void visit(AstNode* nodep) VL_OVERRIDE { iterateChildren(nodep); }
virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
public:
// CONSTRUCTORS
@ -63,10 +63,10 @@ class ConstVarFindVisitor : public AstNVisitor {
private:
// VISITORS
virtual void visit(AstVarRef* nodep) VL_OVERRIDE {
virtual void visit(AstVarRef* nodep) override {
if (nodep->varp() && nodep->varp()->user4()) m_found = true;
}
virtual void visit(AstNode* nodep) VL_OVERRIDE { iterateChildren(nodep); }
virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
public:
// CONSTRUCTORS
@ -1282,11 +1282,11 @@ private:
//----------------------------------------
// VISITORS
virtual void visit(AstNetlist* nodep) VL_OVERRIDE {
virtual void visit(AstNetlist* nodep) override {
// Iterate modules backwards, in bottom-up order. That's faster
iterateChildrenBackwards(nodep);
}
virtual void visit(AstNodeModule* nodep) VL_OVERRIDE {
virtual void visit(AstNodeModule* nodep) override {
AstNodeModule* origModp = m_modp;
{
m_modp = nodep;
@ -1294,14 +1294,14 @@ private:
}
m_modp = origModp;
}
virtual void visit(AstCFunc* nodep) VL_OVERRIDE {
virtual void visit(AstCFunc* nodep) override {
// No ASSIGNW removals under funcs, we've long eliminated INITIALs
// (We should perhaps rename the assignw's to just assigns)
m_wremove = false;
iterateChildren(nodep);
m_wremove = true;
}
virtual void visit(AstScope* nodep) VL_OVERRIDE {
virtual void visit(AstScope* nodep) override {
// No ASSIGNW removals under scope, we've long eliminated INITIALs
m_scopep = nodep;
m_wremove = false;
@ -1373,16 +1373,16 @@ private:
}
// Special cases
virtual void visit(AstConst*) VL_OVERRIDE {} // Already constant
virtual void visit(AstConst*) override {} // Already constant
virtual void visit(AstCell* nodep) VL_OVERRIDE {
virtual void visit(AstCell* nodep) override {
if (m_params) {
iterateAndNextNull(nodep->paramsp());
} else {
iterateChildren(nodep);
}
}
virtual void visit(AstPin* nodep) VL_OVERRIDE { iterateChildren(nodep); }
virtual void visit(AstPin* nodep) override { iterateChildren(nodep); }
void replaceLogEq(AstLogEq* nodep) {
// LOGEQ(a,b) => AstLogAnd{AstLogOr{AstLogNot{a},b},AstLogOr{AstLogNot{b},a}}
@ -1563,14 +1563,14 @@ private:
VL_DO_DANGLING(nodep->deleteTree(), nodep);
}
virtual void visit(AstAttrOf* nodep) VL_OVERRIDE {
virtual void visit(AstAttrOf* nodep) override {
AstAttrOf* oldAttr = m_attrp;
m_attrp = nodep;
iterateChildren(nodep);
m_attrp = oldAttr;
}
virtual void visit(AstArraySel* nodep) VL_OVERRIDE {
virtual void visit(AstArraySel* nodep) override {
iterateAndNextNull(nodep->bitp());
if (VN_IS(nodep->bitp(), Const)
&& VN_IS(nodep->fromp(), VarRef)
@ -1596,7 +1596,7 @@ private:
}
m_selp = NULL;
}
virtual void visit(AstNodeVarRef* nodep) VL_OVERRIDE {
virtual void visit(AstNodeVarRef* nodep) override {
iterateChildren(nodep);
UASSERT_OBJ(nodep->varp(), nodep, "Not linked");
bool did = false;
@ -1650,7 +1650,7 @@ private:
<< nodep->varp()->prettyNameQ());
}
}
virtual void visit(AstEnumItemRef* nodep) VL_OVERRIDE {
virtual void visit(AstEnumItemRef* nodep) override {
iterateChildren(nodep);
UASSERT_OBJ(nodep->itemp(), nodep, "Not linked");
bool did = false;
@ -1675,7 +1675,7 @@ private:
}
}
// virtual void visit(AstCvtPackString* nodep) VL_OVERRIDE {
// virtual void visit(AstCvtPackString* nodep) override {
// Not constant propagated (for today) because AstNodeMath::isOpaque is set
// Someday if lower is constant, convert to quoted "string".
@ -1683,7 +1683,7 @@ private:
// Only one if it's not in a list
return (!nodep->nextp() && nodep->backp()->nextp() != nodep);
}
virtual void visit(AstSenItem* nodep) VL_OVERRIDE {
virtual void visit(AstSenItem* nodep) override {
iterateChildren(nodep);
if (m_doNConst
&& (VN_IS(nodep->sensp(), Const) || VN_IS(nodep->sensp(), EnumItemRef)
@ -1750,7 +1750,7 @@ private:
}
};
virtual void visit(AstSenTree* nodep) VL_OVERRIDE {
virtual void visit(AstSenTree* nodep) override {
iterateChildren(nodep);
if (m_doExpensive) {
// cout<<endl; nodep->dumpTree(cout, "ssin: ");
@ -1842,17 +1842,17 @@ private:
//-----
// Zero elimination
virtual void visit(AstNodeAssign* nodep) VL_OVERRIDE {
virtual void visit(AstNodeAssign* nodep) override {
iterateChildren(nodep);
if (m_doNConst && replaceNodeAssign(nodep)) return;
}
virtual void visit(AstAssignAlias* nodep) VL_OVERRIDE {
virtual void visit(AstAssignAlias* nodep) override {
// Don't perform any optimizations, keep the alias around
}
virtual void visit(AstAssignVarScope* nodep) VL_OVERRIDE {
virtual void visit(AstAssignVarScope* nodep) override {
// Don't perform any optimizations, the node won't be linked yet
}
virtual void visit(AstAssignW* nodep) VL_OVERRIDE {
virtual void visit(AstAssignW* nodep) override {
iterateChildren(nodep);
if (m_doNConst && replaceNodeAssign(nodep)) return;
AstNodeVarRef* varrefp = VN_CAST(
@ -1879,7 +1879,7 @@ private:
}
}
virtual void visit(AstNodeIf* nodep) VL_OVERRIDE {
virtual void visit(AstNodeIf* nodep) override {
iterateChildren(nodep);
if (m_doNConst) {
if (const AstConst* constp = VN_CAST(nodep->condp(), Const)) {
@ -1958,7 +1958,7 @@ private:
}
}
virtual void visit(AstDisplay* nodep) VL_OVERRIDE {
virtual void visit(AstDisplay* nodep) override {
// DISPLAY(SFORMAT(text1)),DISPLAY(SFORMAT(text2)) -> DISPLAY(SFORMAT(text1+text2))
iterateChildren(nodep);
if (stmtDisplayDisplay(nodep)) return;
@ -2003,7 +2003,7 @@ private:
VL_DO_DANGLING(nodep->unlinkFrBack()->deleteTree(), nodep);
return true;
}
virtual void visit(AstSFormatF* nodep) VL_OVERRIDE {
virtual void visit(AstSFormatF* nodep) override {
// Substitute constants into displays. The main point of this is to
// simplify assertion methodologies which call functions with display's.
// This eliminates a pile of wide temps, and makes the C a whole lot more readable.
@ -2071,17 +2071,17 @@ private:
}
}
virtual void visit(AstFuncRef* nodep) VL_OVERRIDE {
virtual void visit(AstFuncRef* nodep) override {
iterateChildren(nodep);
if (m_params) { // Only parameters force us to do constant function call propagation
replaceWithSimulation(nodep);
}
}
virtual void visit(AstArg* nodep) VL_OVERRIDE {
virtual void visit(AstArg* nodep) override {
// replaceWithSimulation on the Arg's parent FuncRef replaces these
iterateChildren(nodep);
}
virtual void visit(AstWhile* nodep) VL_OVERRIDE {
virtual void visit(AstWhile* nodep) override {
bool oldHasJumpDelay = m_hasJumpDelay;
m_hasJumpDelay = false;
{ iterateChildren(nodep); }
@ -2107,22 +2107,22 @@ private:
}
}
}
virtual void visit(AstInitArray* nodep) VL_OVERRIDE { iterateChildren(nodep); }
virtual void visit(AstInitItem* nodep) VL_OVERRIDE { iterateChildren(nodep); }
virtual void visit(AstUnbounded* nodep) VL_OVERRIDE { iterateChildren(nodep); }
virtual void visit(AstInitArray* nodep) override { iterateChildren(nodep); }
virtual void visit(AstInitItem* nodep) override { iterateChildren(nodep); }
virtual void visit(AstUnbounded* nodep) override { iterateChildren(nodep); }
// These are converted by V3Param. Don't constify as we don't want the
// from() VARREF to disappear, if any.
// If output of a presel didn't get consted, chances are V3Param didn't visit properly
virtual void visit(AstNodePreSel*) VL_OVERRIDE {}
virtual void visit(AstNodePreSel*) override {}
// Ignored, can eliminate early
virtual void visit(AstSysIgnore* nodep) VL_OVERRIDE {
virtual void visit(AstSysIgnore* nodep) override {
iterateChildren(nodep);
if (m_doNConst) { VL_DO_DANGLING(nodep->unlinkFrBack()->deleteTree(), nodep); }
}
// Simplify
virtual void visit(AstBasicDType* nodep) VL_OVERRIDE {
virtual void visit(AstBasicDType* nodep) override {
iterateChildren(nodep);
nodep->cvtRangeConst();
}
@ -2130,11 +2130,11 @@ private:
//-----
// Jump elimination
virtual void visit(AstDelay* nodep) VL_OVERRIDE {
virtual void visit(AstDelay* nodep) override {
iterateChildren(nodep);
m_hasJumpDelay = true;
}
virtual void visit(AstJumpGo* nodep) VL_OVERRIDE {
virtual void visit(AstJumpGo* nodep) override {
iterateChildren(nodep);
// Jump to label where label immediately follows label is not useful
if (nodep->labelp() == VN_CAST(nodep->nextp(), JumpLabel)) {
@ -2165,7 +2165,7 @@ private:
m_hasJumpDelay = true;
}
virtual void visit(AstJumpBlock* nodep) VL_OVERRIDE {
virtual void visit(AstJumpBlock* nodep) override {
// Because JumpLabels disable many optimizations,
// remove JumpLabels that are not pointed to by any AstJumpGos
// Note this assumes all AstJumpGos are underneath the given label; V3Broken asserts this
@ -2519,7 +2519,7 @@ private:
// Note we can't convert EqCase/NeqCase to Eq/Neq here because that would break 3'b1x1==3'b101
//-----
virtual void visit(AstNode* nodep) VL_OVERRIDE {
virtual void visit(AstNode* nodep) override {
// Default: Just iterate
if (m_required) {
if (VN_IS(nodep, NodeDType) || VN_IS(nodep, Range)) {

30
src/V3Coverage.cpp
View File

@ -32,7 +32,7 @@
#include "V3Ast.h"
#include <map>
#include VL_INCLUDE_UNORDERED_MAP
#include <unordered_map>
//######################################################################
// Coverage state, as a visitor of each AstNode
@ -40,9 +40,9 @@
class CoverageVisitor : public AstNVisitor {
private:
// TYPES
typedef vl_unordered_map<string, int> VarNameMap;
typedef std::unordered_map<string, int> VarNameMap;
typedef std::set<int> LinenoSet;
typedef vl_unordered_map<int, LinenoSet> HandleLines;
typedef std::unordered_map<int, LinenoSet> HandleLines;
struct ToggleEnt {
string m_comment; // Comment for coverage dump
@ -212,7 +212,7 @@ private:
}
// VISITORS - BOTH
virtual void visit(AstNodeModule* nodep) VL_OVERRIDE {
virtual void visit(AstNodeModule* nodep) override {
AstNodeModule* origModp = m_modp;
CheckState lastState = m_state;
{
@ -231,9 +231,9 @@ private:
m_state = lastState;
}
virtual void visit(AstNodeProcedure* nodep) VL_OVERRIDE { iterateProcedure(nodep); }
virtual void visit(AstWhile* nodep) VL_OVERRIDE { iterateProcedure(nodep); }
virtual void visit(AstNodeFTask* nodep) VL_OVERRIDE {
virtual void visit(AstNodeProcedure* nodep) override { iterateProcedure(nodep); }
virtual void visit(AstWhile* nodep) override { iterateProcedure(nodep); }
virtual void visit(AstNodeFTask* nodep) override {
if (!nodep->dpiImport()) iterateProcedure(nodep);
}
void iterateProcedure(AstNode* nodep) {
@ -264,7 +264,7 @@ private:
}
// VISITORS - TOGGLE COVERAGE
virtual void visit(AstVar* nodep) VL_OVERRIDE {
virtual void visit(AstVar* nodep) override {
iterateChildren(nodep);
if (m_modp && !m_inToggleOff && !m_state.m_inModOff && nodep->fileline()->coverageOn()
&& v3Global.opt.coverageToggle()) {
@ -387,7 +387,7 @@ private:
// VISITORS - LINE COVERAGE
// Note not AstNodeIf; other types don't get covered
virtual void visit(AstIf* nodep) VL_OVERRIDE {
virtual void visit(AstIf* nodep) override {
UINFO(4, " IF: " << nodep << endl);
if (m_state.m_on) {
// An else-if. When we iterate the if, use "elsif" marking
@ -463,7 +463,7 @@ private:
}
UINFO(9, " done HANDLE " << m_state.m_handle << " for " << nodep << endl);
}
virtual void visit(AstCaseItem* nodep) VL_OVERRIDE {
virtual void visit(AstCaseItem* nodep) override {
// We don't add an explicit "default" coverage if not provided,
// as we already have a warning when there is no default.
UINFO(4, " CASEI: " << nodep << endl);
@ -483,7 +483,7 @@ private:
m_state = lastState;
}
}
virtual void visit(AstCover* nodep) VL_OVERRIDE {
virtual void visit(AstCover* nodep) override {
UINFO(4, " COVER: " << nodep << endl);
CheckState lastState = m_state;
{
@ -500,11 +500,11 @@ private:
}
m_state = lastState;
}
virtual void visit(AstStop* nodep) VL_OVERRIDE {
virtual void visit(AstStop* nodep) override {
UINFO(4, " STOP: " << nodep << endl);
m_state.m_on = false;
}
virtual void visit(AstPragma* nodep) VL_OVERRIDE {
virtual void visit(AstPragma* nodep) override {
if (nodep->pragType() == AstPragmaType::COVERAGE_BLOCK_OFF) {
// Skip all NEXT nodes under this block, and skip this if/case branch
UINFO(4, " OFF: h" << m_state.m_handle << " " << nodep << endl);
@ -515,7 +515,7 @@ private:
lineTrack(nodep);
}
}
virtual void visit(AstBegin* nodep) VL_OVERRIDE {
virtual void visit(AstBegin* nodep) override {
// Record the hierarchy of any named begins, so we can apply to user
// coverage points. This is because there may be cov points inside
// generate blocks; each point should get separate consideration.
@ -536,7 +536,7 @@ private:
}
// VISITORS - BOTH
virtual void visit(AstNode* nodep) VL_OVERRIDE {
virtual void visit(AstNode* nodep) override {
iterateChildren(nodep);
lineTrack(nodep);
}

8
src/V3CoverageJoin.cpp
View File

@ -97,19 +97,19 @@ private:
}
// VISITORS
virtual void visit(AstNetlist* nodep) VL_OVERRIDE {
virtual void visit(AstNetlist* nodep) override {
// Find all Coverage's
iterateChildren(nodep);
// Simplify
detectDuplicates();
}
virtual void visit(AstCoverToggle* nodep) VL_OVERRIDE {
virtual void visit(AstCoverToggle* nodep) override {
m_toggleps.push_back(nodep);
iterateChildren(nodep);
}
//--------------------
virtual void visit(AstNodeMath*) VL_OVERRIDE {} // Accelerate
virtual void visit(AstNode* nodep) VL_OVERRIDE { iterateChildren(nodep); }
virtual void visit(AstNodeMath*) override {} // Accelerate
virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
public:
// CONSTRUCTORS

42
src/V3Dead.cpp
View File

@ -52,13 +52,13 @@ private:
// NODE STATE
// ** Shared with DeadVisitor **
// VISITORS
virtual void visit(AstCell* nodep) VL_OVERRIDE {
virtual void visit(AstCell* nodep) override {
iterateChildren(nodep);
nodep->modp()->user1Inc(-1);
}
//-----
virtual void visit(AstNodeMath*) VL_OVERRIDE {} // Accelerate
virtual void visit(AstNode* nodep) VL_OVERRIDE { iterateChildren(nodep); }
virtual void visit(AstNodeMath*) override {} // Accelerate
virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
public:
// CONSTRUCTORS
@ -119,7 +119,7 @@ private:
}
// VISITORS
virtual void visit(AstNodeModule* nodep) VL_OVERRIDE {
virtual void visit(AstNodeModule* nodep) override {
AstNodeModule* origModp = m_modp;
{
m_modp = nodep;
@ -137,12 +137,12 @@ private:
}
m_modp = origModp;
}
virtual void visit(AstCFunc* nodep) VL_OVERRIDE {
virtual void visit(AstCFunc* nodep) override {
iterateChildren(nodep);
checkAll(nodep);
if (nodep->scopep()) nodep->scopep()->user1Inc();
}
virtual void visit(AstScope* nodep) VL_OVERRIDE {
virtual void visit(AstScope* nodep) override {
iterateChildren(nodep);
checkAll(nodep);
if (nodep->aboveScopep()) nodep->aboveScopep()->user1Inc();
@ -153,14 +153,14 @@ private:
m_scopesp.push_back(nodep);
}
}
virtual void visit(AstCell* nodep) VL_OVERRIDE {
virtual void visit(AstCell* nodep) override {
iterateChildren(nodep);
checkAll(nodep);
m_cellsp.push_back(nodep);
nodep->modp()->user1Inc();
}
virtual void visit(AstNodeVarRef* nodep) VL_OVERRIDE {
virtual void visit(AstNodeVarRef* nodep) override {
iterateChildren(nodep);
checkAll(nodep);
if (nodep->varScopep()) {
@ -176,7 +176,7 @@ private:
}
}
}
virtual void visit(AstNodeFTaskRef* nodep) VL_OVERRIDE {
virtual void visit(AstNodeFTaskRef* nodep) override {
iterateChildren(nodep);
checkAll(nodep);
if (nodep->packagep()) {
@ -187,11 +187,11 @@ private:
}
}
}
virtual void visit(AstMethodCall* nodep) VL_OVERRIDE {
virtual void visit(AstMethodCall* nodep) override {
iterateChildren(nodep);
checkAll(nodep);
}
virtual void visit(AstRefDType* nodep) VL_OVERRIDE {
virtual void visit(AstRefDType* nodep) override {
iterateChildren(nodep);
checkDType(nodep);
checkAll(nodep);
@ -205,7 +205,7 @@ private:
}
}
}
virtual void visit(AstClassRefDType* nodep) VL_OVERRIDE {
virtual void visit(AstClassRefDType* nodep) override {
iterateChildren(nodep);
checkDType(nodep);
checkAll(nodep);
@ -218,12 +218,12 @@ private:
}
if (nodep->classp()) nodep->classp()->user1Inc();
}
virtual void visit(AstNodeDType* nodep) VL_OVERRIDE {
virtual void visit(AstNodeDType* nodep) override {
iterateChildren(nodep);
checkDType(nodep);
checkAll(nodep);
}
virtual void visit(AstEnumItemRef* nodep) VL_OVERRIDE {
virtual void visit(AstEnumItemRef* nodep) override {
iterateChildren(nodep);
checkAll(nodep);
if (nodep->packagep()) {
@ -235,13 +235,13 @@ private:
}
checkAll(nodep);
}
virtual void visit(AstMemberSel* nodep) VL_OVERRIDE {
virtual void visit(AstMemberSel* nodep) override {
iterateChildren(nodep);
if (nodep->varp()) nodep->varp()->user1Inc();
if (nodep->fromp()->dtypep()) nodep->fromp()->dtypep()->user1Inc(); // classref
checkAll(nodep);
}
virtual void visit(AstModport* nodep) VL_OVERRIDE {
virtual void visit(AstModport* nodep) override {
iterateChildren(nodep);
if (m_elimCells) {
if (!nodep->varsp()) {
@ -251,7 +251,7 @@ private:
}
checkAll(nodep);
}
virtual void visit(AstTypedef* nodep) VL_OVERRIDE {
virtual void visit(AstTypedef* nodep) override {
iterateChildren(nodep);
if (m_elimCells && !nodep->attrPublic()) {
VL_DO_DANGLING(pushDeletep(nodep->unlinkFrBack()), nodep);
@ -262,19 +262,19 @@ private:
// Normal modules may disappear, e.g. if they are parameterized then removed
if (nodep->attrPublic() && m_modp && VN_IS(m_modp, Package)) m_modp->user1Inc();
}
virtual void visit(AstVarScope* nodep) VL_OVERRIDE {
virtual void visit(AstVarScope* nodep) override {
iterateChildren(nodep);
checkAll(nodep);
if (nodep->scopep()) nodep->scopep()->user1Inc();
if (mightElimVar(nodep->varp())) m_vscsp.push_back(nodep);
}
virtual void visit(AstVar* nodep) VL_OVERRIDE {
virtual void visit(AstVar* nodep) override {
iterateChildren(nodep);
checkAll(nodep);
if (nodep->isSigPublic() && m_modp && VN_IS(m_modp, Package)) m_modp->user1Inc();
if (mightElimVar(nodep)) m_varsp.push_back(nodep);
}
virtual void visit(AstNodeAssign* nodep) VL_OVERRIDE {
virtual void visit(AstNodeAssign* nodep) override {
// See if simple assignments to variables may be eliminated because
// that variable is never used.
// Similar code in V3Life
@ -294,7 +294,7 @@ private:
}
//-----
virtual void visit(AstNode* nodep) VL_OVERRIDE {
virtual void visit(AstNode* nodep) override {
if (nodep->isOutputter()) m_sideEffect = true;
iterateChildren(nodep);
checkAll(nodep);

18
src/V3Delayed.cpp
View File

@ -344,22 +344,22 @@ private:
}
// VISITORS
virtual void visit(AstNetlist* nodep) VL_OVERRIDE {
virtual void visit(AstNetlist* nodep) override {
// VV***** We reset all userp() on the netlist
m_modVarMap.clear();
iterateChildren(nodep);
}
virtual void visit(AstScope* nodep) VL_OVERRIDE {
virtual void visit(AstScope* nodep) override {
UINFO(4, " MOD " << nodep << endl);
AstNode::user3ClearTree();
iterateChildren(nodep);
}
virtual void visit(AstCFunc* nodep) VL_OVERRIDE {
virtual void visit(AstCFunc* nodep) override {
m_cfuncp = nodep;
iterateChildren(nodep);
m_cfuncp = NULL;
}
virtual void visit(AstActive* nodep) VL_OVERRIDE {
virtual void visit(AstActive* nodep) override {
m_activep = nodep;
bool oldinit = m_inInitial;
m_inInitial = nodep->hasInitial();
@ -368,7 +368,7 @@ private:
iterateChildren(nodep);
m_inInitial = oldinit;
}
virtual void visit(AstAssignDly* nodep) VL_OVERRIDE {
virtual void visit(AstAssignDly* nodep) override {
m_inDly = true;
m_nextDlyp
= VN_CAST(nodep->nextp(), AssignDly); // Next assignment in same block, maybe NULL.
@ -402,7 +402,7 @@ private:
m_nextDlyp = NULL;
}
virtual void visit(AstVarRef* nodep) VL_OVERRIDE {
virtual void visit(AstVarRef* nodep) override {
if (!nodep->user2Inc()) { // Not done yet
if (m_inDly && nodep->lvalue()) {
UINFO(4, "AssignDlyVar: " << nodep << endl);
@ -459,11 +459,11 @@ private:
}
}
virtual void visit(AstNodeFor* nodep) VL_OVERRIDE { // LCOV_EXCL_LINE
virtual void visit(AstNodeFor* nodep) override { // LCOV_EXCL_LINE
nodep->v3fatalSrc(
"For statements should have been converted to while statements in V3Begin");
}
virtual void visit(AstWhile* nodep) VL_OVERRIDE {
virtual void visit(AstWhile* nodep) override {
bool oldloop = m_inLoop;
m_inLoop = true;
iterateChildren(nodep);
@ -471,7 +471,7 @@ private:
}
//--------------------
virtual void visit(AstNode* nodep) VL_OVERRIDE { iterateChildren(nodep); }
virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
public:
// CONSTRUCTORS

18
src/V3Depth.cpp
View File

@ -76,7 +76,7 @@ private:
}
// VISITORS
virtual void visit(AstNodeModule* nodep) VL_OVERRIDE {
virtual void visit(AstNodeModule* nodep) override {
UINFO(4, " MOD " << nodep << endl);
AstNodeModule* origModp = m_modp;
{
@ -86,7 +86,7 @@ private:
}
m_modp = origModp;
}
virtual void visit(AstCFunc* nodep) VL_OVERRIDE {
virtual void visit(AstCFunc* nodep) override {
m_funcp = nodep;
m_depth = 0;
m_maxdepth = 0;
@ -100,7 +100,7 @@ private:
iterateChildren(nodep);
m_stmtp = NULL;
}
virtual void visit(AstNodeStmt* nodep) VL_OVERRIDE {
virtual void visit(AstNodeStmt* nodep) override {
if (!nodep->isStatement()) {
iterateChildren(nodep);
} else {
@ -108,8 +108,8 @@ private:
}
}
// Operators
virtual void visit(AstNodeTermop* nodep) VL_OVERRIDE {}
virtual void visit(AstNodeMath* nodep) VL_OVERRIDE {
virtual void visit(AstNodeTermop* nodep) override {}
virtual void visit(AstNodeMath* nodep) override {
// We have some operator defines that use 2 parens, so += 2.
m_depth += 2;
if (m_depth > m_maxdepth) m_maxdepth = m_depth;
@ -135,19 +135,19 @@ private:
m_funcp->isStatic(false);
}
}
virtual void visit(AstUCFunc* nodep) VL_OVERRIDE {
virtual void visit(AstUCFunc* nodep) override {
needNonStaticFunc(nodep);
iterateChildren(nodep);
}
virtual void visit(AstUCStmt* nodep) VL_OVERRIDE {
virtual void visit(AstUCStmt* nodep) override {
needNonStaticFunc(nodep);
visitStmt(nodep);
}
//--------------------
// Default: Just iterate
virtual void visit(AstVar*) VL_OVERRIDE {} // Don't hit varrefs under vars
virtual void visit(AstNode* nodep) VL_OVERRIDE { iterateChildren(nodep); }
virtual void visit(AstVar*) override {} // Don't hit varrefs under vars
virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
public:
// CONSTRUCTORS

12
src/V3DepthBlock.cpp
View File

@ -66,7 +66,7 @@ private:
}
// VISITORS
virtual void visit(AstNodeModule* nodep) VL_OVERRIDE {
virtual void visit(AstNodeModule* nodep) override {
UINFO(4, " MOD " << nodep << endl);
AstNodeModule* origModp = m_modp;
{
@ -76,7 +76,7 @@ private:
}
m_modp = origModp;
}
virtual void visit(AstCFunc* nodep) VL_OVERRIDE {
virtual void visit(AstCFunc* nodep) override {
// We recurse into this.
int lastDepth = m_depth;
AstCFunc* lastFuncp = m_funcp;
@ -104,7 +104,7 @@ private:
}
m_depth--;
}
virtual void visit(AstNodeStmt* nodep) VL_OVERRIDE {
virtual void visit(AstNodeStmt* nodep) override {
if (!nodep->isStatement()) {
iterateChildren(nodep);
} else {
@ -112,10 +112,10 @@ private:
}
}
virtual void visit(AstNodeMath*) VL_OVERRIDE {} // Accelerate
virtual void visit(AstNodeMath*) override {} // Accelerate
//--------------------
virtual void visit(AstVar*) VL_OVERRIDE {} // Don't hit varrefs under vars
virtual void visit(AstNode* nodep) VL_OVERRIDE { iterateChildren(nodep); }
virtual void visit(AstVar*) override {} // Don't hit varrefs under vars
virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
public:
// CONSTRUCTORS

16
src/V3Descope.cpp
View File

@ -225,7 +225,7 @@ private:
}
// VISITORS
virtual void visit(AstNodeModule* nodep) VL_OVERRIDE {
virtual void visit(AstNodeModule* nodep) override {
AstNodeModule* origModp = m_modp;
{
m_modp = nodep;
@ -236,17 +236,17 @@ private:
}
m_modp = origModp;
}
virtual void visit(AstScope* nodep) VL_OVERRIDE {
virtual void visit(AstScope* nodep) override {
m_scopep = nodep;
iterateChildren(nodep);
m_scopep = NULL;
}
virtual void visit(AstVarScope* nodep) VL_OVERRIDE {
virtual void visit(AstVarScope* nodep) override {
// Delete the varscope when we're finished
nodep->unlinkFrBack();
pushDeletep(nodep);
}
virtual void visit(AstNodeVarRef* nodep) VL_OVERRIDE {
virtual void visit(AstNodeVarRef* nodep) override {
iterateChildren(nodep);
// Convert the hierch name
UASSERT_OBJ(m_scopep, nodep, "Node not under scope");
@ -256,7 +256,7 @@ private:
nodep->hierThis(hierThis);
nodep->varScopep(NULL);
}
virtual void visit(AstNodeCCall* nodep) VL_OVERRIDE {
virtual void visit(AstNodeCCall* nodep) override {
// UINFO(9, " " << nodep << endl);
iterateChildren(nodep);
// Convert the hierch name
@ -267,7 +267,7 @@ private:
// Can't do this, as we may have more calls later
// nodep->funcp()->scopep(NULL);
}
virtual void visit(AstCFunc* nodep) VL_OVERRIDE {
virtual void visit(AstCFunc* nodep) override {
if (!nodep->user1()) {
m_needThis = false;
m_allowThis = nodep->isStatic().falseUnknown(); // Non-static or unknown if static
@ -288,8 +288,8 @@ private:
}
}
}
virtual void visit(AstVar*) VL_OVERRIDE {}
virtual void visit(AstNode* nodep) VL_OVERRIDE { iterateChildren(nodep); }
virtual void visit(AstVar*) override {}
virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
public:
// CONSTRUCTORS

190
src/V3EmitC.cpp
View File

@ -28,7 +28,7 @@
#include <algorithm>
#include <map>
#include <vector>
#include VL_INCLUDE_UNORDERED_SET
#include <unordered_set>
#define VL_VALUE_STRING_MAX_WIDTH 8192 // We use a static char array in VL_VALUE_STRING
@ -266,7 +266,7 @@ public:
}
// VISITORS
virtual void visit(AstNodeAssign* nodep) VL_OVERRIDE {
virtual void visit(AstNodeAssign* nodep) override {
bool paren = true;
bool decind = false;
if (AstSel* selp = VN_CAST(nodep->lhsp(), Sel)) {
@ -347,8 +347,8 @@ public:
if (decind) ofp()->blockDec();
if (!m_suppressSemi) puts(";\n");
}
virtual void visit(AstAlwaysPublic*) VL_OVERRIDE {}
virtual void visit(AstAssocSel* nodep) VL_OVERRIDE {
virtual void visit(AstAlwaysPublic*) override {}
virtual void visit(AstAssocSel* nodep) override {
iterateAndNextNull(nodep->fromp());
putbs(".at(");
AstAssocArrayDType* adtypep = VN_CAST(nodep->fromp()->dtypep(), AssocArrayDType);
@ -363,7 +363,7 @@ public:
puts(".data()"); // Access returned std::array as C array
}
}
virtual void visit(AstNodeCCall* nodep) VL_OVERRIDE {
virtual void visit(AstNodeCCall* nodep) override {
if (AstCMethodCall* ccallp = VN_CAST(nodep, CMethodCall)) {
// make this a Ast type for future opt
iterate(ccallp->fromp());
@ -387,7 +387,7 @@ public:
puts(");\n");
}
}
virtual void visit(AstCMethodHard* nodep) VL_OVERRIDE {
virtual void visit(AstCMethodHard* nodep) override {
iterate(nodep->fromp());
puts(".");
puts(nodep->nameProtect());
@ -415,14 +415,14 @@ public:
UASSERT_OBJ(!nodep->isStatement() || VN_IS(nodep->dtypep(), VoidDType), nodep,
"Statement of non-void data type");
}
virtual void visit(AstIntfRef* nodep) VL_OVERRIDE {
virtual void visit(AstIntfRef* nodep) override {
putsQuoted(VIdProtect::protectWordsIf(AstNode::vcdName(nodep->name()), nodep->protect()));
}
virtual void visit(AstNodeCase* nodep) VL_OVERRIDE { // LCOV_EXCL_LINE
virtual void visit(AstNodeCase* nodep) override { // LCOV_EXCL_LINE
// In V3Case...
nodep->v3fatalSrc("Case statements should have been reduced out");
}
virtual void visit(AstComment* nodep) VL_OVERRIDE {
virtual void visit(AstComment* nodep) override {
string at;
if (nodep->showAt()) {
at = " at " + nodep->fileline()->ascii();
@ -434,7 +434,7 @@ public:
}
iterateChildren(nodep);
}
virtual void visit(AstCoverDecl* nodep) VL_OVERRIDE {
virtual void visit(AstCoverDecl* nodep) override {
puts("__vlCoverInsert("); // As Declared in emitCoverageDecl
puts("&(vlSymsp->__Vcoverage[");
puts(cvtToStr(nodep->dataDeclThisp()->binNum()));
@ -462,7 +462,7 @@ public:
putsQuoted(nodep->linescov());
puts(");\n");
}
virtual void visit(AstCoverInc* nodep) VL_OVERRIDE {
virtual void visit(AstCoverInc* nodep) override {
if (v3Global.opt.threads()) {
puts("vlSymsp->__Vcoverage[");
puts(cvtToStr(nodep->declp()->dataDeclThisp()->binNum()));
@ -473,17 +473,17 @@ public:
puts("]);\n");
}
}
virtual void visit(AstCReturn* nodep) VL_OVERRIDE {
virtual void visit(AstCReturn* nodep) override {
puts("return (");
iterateAndNextNull(nodep->lhsp());
puts(");\n");
}
virtual void visit(AstDisplay* nodep) VL_OVERRIDE {
virtual void visit(AstDisplay* nodep) override {
string text = nodep->fmtp()->text();
if (nodep->addNewline()) text += "\n";
displayNode(nodep, nodep->fmtp()->scopeNamep(), text, nodep->fmtp()->exprsp(), false);
}
virtual void visit(AstDumpCtl* nodep) VL_OVERRIDE {
virtual void visit(AstDumpCtl* nodep) override {
switch (nodep->ctlType()) {
case VDumpCtlType::FILE:
puts("vl_dumpctl_filenamep(true, ");
@ -522,7 +522,7 @@ public:
default: nodep->v3fatalSrc("Bad case, unexpected " << nodep->ctlType().ascii());
}
}
virtual void visit(AstScopeName* nodep) VL_OVERRIDE {
virtual void visit(AstScopeName* nodep) override {
// For use under AstCCalls for dpiImports. ScopeNames under
// displays are handled in AstDisplay
if (!nodep->dpiExport()) {
@ -531,20 +531,20 @@ public:
putbs("(&(vlSymsp->" + protect("__Vscope_" + scope) + "))");
}
}
virtual void visit(AstSFormat* nodep) VL_OVERRIDE {
virtual void visit(AstSFormat* nodep) override {
displayNode(nodep, nodep->fmtp()->scopeNamep(), nodep->fmtp()->text(),
nodep->fmtp()->exprsp(), false);
}
virtual void visit(AstSFormatF* nodep) VL_OVERRIDE {
virtual void visit(AstSFormatF* nodep) override {
displayNode(nodep, nodep->scopeNamep(), nodep->text(), nodep->exprsp(), false);
}
virtual void visit(AstFScanF* nodep) VL_OVERRIDE {
virtual void visit(AstFScanF* nodep) override {
displayNode(nodep, NULL, nodep->text(), nodep->exprsp(), true);
}
virtual void visit(AstSScanF* nodep) VL_OVERRIDE {
virtual void visit(AstSScanF* nodep) override {
displayNode(nodep, NULL, nodep->text(), nodep->exprsp(), true);
}
virtual void visit(AstValuePlusArgs* nodep) VL_OVERRIDE {
virtual void visit(AstValuePlusArgs* nodep) override {
puts("VL_VALUEPLUSARGS_IN");
emitIQW(nodep->outp());
puts("(");
@ -556,19 +556,19 @@ public:
iterateAndNextNull(nodep->outp());
puts(")");
}
virtual void visit(AstTestPlusArgs* nodep) VL_OVERRIDE {
virtual void visit(AstTestPlusArgs* nodep) override {
puts("VL_TESTPLUSARGS_I(");
putsQuoted(nodep->text());
puts(")");
}
virtual void visit(AstFError* nodep) VL_OVERRIDE {
virtual void visit(AstFError* nodep) override {
puts("VL_FERROR_IN(");
iterateAndNextNull(nodep->filep());
putbs(", ");
iterateAndNextNull(nodep->strp());
puts(")");
}
virtual void visit(AstFGetS* nodep) VL_OVERRIDE {
virtual void visit(AstFGetS* nodep) override {
checkMaxWords(nodep);
emitOpName(nodep, nodep->emitC(), nodep->lhsp(), nodep->rhsp(), NULL);
}
@ -581,7 +581,7 @@ public:
<< " bits exceeds hardcoded limit VL_TO_STRING_MAX_WORDS in verilatedos.h");
}
}
virtual void visit(AstFOpen* nodep) VL_OVERRIDE {
virtual void visit(AstFOpen* nodep) override {
iterateAndNextNull(nodep->filep());
puts(" = VL_FOPEN_NN(");
emitCvtPackStr(nodep->filenamep());
@ -591,13 +591,13 @@ public:
emitCvtPackStr(nodep->modep());
puts(");\n");
}
virtual void visit(AstFOpenMcd* nodep) VL_OVERRIDE {
virtual void visit(AstFOpenMcd* nodep) override {
iterateAndNextNull(nodep->filep());
puts(" = VL_FOPEN_MCD_N(");
emitCvtPackStr(nodep->filenamep());
puts(");\n");
}
virtual void visit(AstNodeReadWriteMem* nodep) VL_OVERRIDE {
virtual void visit(AstNodeReadWriteMem* nodep) override {
puts(nodep->cFuncPrefixp());
puts("N(");
puts(nodep->isHex() ? "true" : "false");
@ -641,14 +641,14 @@ public:
}
puts(");\n");
}
virtual void visit(AstFClose* nodep) VL_OVERRIDE {
virtual void visit(AstFClose* nodep) override {
puts("VL_FCLOSE_I(");
iterateAndNextNull(nodep->filep());
puts("); ");
iterateAndNextNull(nodep->filep()); // For safety, so user doesn't later WRITE with it.
puts(" = 0;\n");
}
virtual void visit(AstFFlush* nodep) VL_OVERRIDE {
virtual void visit(AstFFlush* nodep) override {
if (!nodep->filep()) {
puts("Verilated::runFlushCallbacks();\n");
} else {
@ -659,7 +659,7 @@ public:
puts("); }\n");
}
}
virtual void visit(AstFSeek* nodep) VL_OVERRIDE {
virtual void visit(AstFSeek* nodep) override {
puts("(VL_FSEEK_I(");
iterateAndNextNull(nodep->filep());
puts(",");
@ -668,17 +668,17 @@ public:
iterateAndNextNull(nodep->operation());
puts(")==-1?-1:0)");
}
virtual void visit(AstFTell* nodep) VL_OVERRIDE {
virtual void visit(AstFTell* nodep) override {
puts("VL_FTELL_I(");
iterateAndNextNull(nodep->filep());
puts(")");
}
virtual void visit(AstFRewind* nodep) VL_OVERRIDE {
virtual void visit(AstFRewind* nodep) override {
puts("(VL_FSEEK_I(");
iterateAndNextNull(nodep->filep());
puts(", 0, 0)==-1?-1:0)");
}
virtual void visit(AstFRead* nodep) VL_OVERRIDE {
virtual void visit(AstFRead* nodep) override {
puts("VL_FREAD_I(");
puts(cvtToStr(nodep->memp()->widthMin())); // Need real storage width
putbs(",");
@ -723,12 +723,12 @@ public:
}
puts(");\n");
}
virtual void visit(AstSysFuncAsTask* nodep) VL_OVERRIDE {
virtual void visit(AstSysFuncAsTask* nodep) override {
if (!nodep->lhsp()->isWide()) puts("(void)");
iterateAndNextNull(nodep->lhsp());
if (!nodep->lhsp()->isWide()) puts(";");
}
virtual void visit(AstSystemT* nodep) VL_OVERRIDE {
virtual void visit(AstSystemT* nodep) override {
puts("(void)VL_SYSTEM_I");
emitIQW(nodep->lhsp());
puts("(");
@ -740,7 +740,7 @@ public:
iterateAndNextNull(nodep->lhsp());
puts(");\n");
}
virtual void visit(AstSystemF* nodep) VL_OVERRIDE {
virtual void visit(AstSystemF* nodep) override {
puts("VL_SYSTEM_I");
emitIQW(nodep->lhsp());
puts("(");
@ -752,20 +752,20 @@ public:
iterateAndNextNull(nodep->lhsp());
puts(")");
}
virtual void visit(AstJumpBlock* nodep) VL_OVERRIDE {
virtual void visit(AstJumpBlock* nodep) override {
nodep->labelNum(++m_labelNum);
puts("{\n"); // Make it visually obvious label jumps outside these
iterateAndNextNull(nodep->stmtsp());
iterateAndNextNull(nodep->endStmtsp());
puts("}\n");
}
virtual void visit(AstJumpGo* nodep) VL_OVERRIDE {
virtual void visit(AstJumpGo* nodep) override {
puts("goto __Vlabel" + cvtToStr(nodep->labelp()->blockp()->labelNum()) + ";\n");
}
virtual void visit(AstJumpLabel* nodep) VL_OVERRIDE {
virtual void visit(AstJumpLabel* nodep) override {
puts("__Vlabel" + cvtToStr(nodep->blockp()->labelNum()) + ": ;\n");
}
virtual void visit(AstWhile* nodep) VL_OVERRIDE {
virtual void visit(AstWhile* nodep) override {
iterateAndNextNull(nodep->precondsp());
puts("while (");
iterateAndNextNull(nodep->condp());
@ -775,7 +775,7 @@ public:
iterateAndNextNull(nodep->precondsp()); // Need to recompute before next loop
puts("}\n");
}
virtual void visit(AstNodeIf* nodep) VL_OVERRIDE {
virtual void visit(AstNodeIf* nodep) override {
puts("if (");
if (!nodep->branchPred().unknown()) {
puts(nodep->branchPred().ascii());
@ -791,7 +791,7 @@ public:
}
puts("}\n");
}
virtual void visit(AstStop* nodep) VL_OVERRIDE {
virtual void visit(AstStop* nodep) override {
puts("VL_STOP_MT(");
putsQuoted(protect(nodep->fileline()->filename()));
puts(", ");
@ -799,35 +799,35 @@ public:
puts(", \"\"");
puts(");\n");
}
virtual void visit(AstFinish* nodep) VL_OVERRIDE {
virtual void visit(AstFinish* nodep) override {
puts("VL_FINISH_MT(");
putsQuoted(protect(nodep->fileline()->filename()));
puts(", ");
puts(cvtToStr(nodep->fileline()->lineno()));
puts(", \"\");\n");
}
virtual void visit(AstPrintTimeScale* nodep) VL_OVERRIDE {
virtual void visit(AstPrintTimeScale* nodep) override {
puts("VL_PRINTTIMESCALE(");
putsQuoted(protect(nodep->name()));
puts(", ");
putsQuoted(nodep->timeunit().ascii());
puts(");\n");
}
virtual void visit(AstTime* nodep) VL_OVERRIDE {
virtual void visit(AstTime* nodep) override {
puts("VL_TIME_UNITED_Q(");
if (nodep->timeunit().isNone()) nodep->v3fatalSrc("$time has no units");
puts(cvtToStr(nodep->timeunit().multiplier()
/ v3Global.rootp()->timeprecision().multiplier()));
puts(")");
}
virtual void visit(AstTimeD* nodep) VL_OVERRIDE {
virtual void visit(AstTimeD* nodep) override {
puts("VL_TIME_UNITED_D(");
if (nodep->timeunit().isNone()) nodep->v3fatalSrc("$realtime has no units");
puts(cvtToStr(nodep->timeunit().multiplier()
/ v3Global.rootp()->timeprecision().multiplier()));
puts(")");
}
virtual void visit(AstTimeFormat* nodep) VL_OVERRIDE {
virtual void visit(AstTimeFormat* nodep) override {
puts("VL_TIMEFORMAT_IINI(");
iterateAndNextNull(nodep->unitsp());
puts(", ");
@ -838,34 +838,34 @@ public:
iterateAndNextNull(nodep->widthp());
puts(");\n");
}
virtual void visit(AstNodeSimpleText* nodep) VL_OVERRIDE {
virtual void visit(AstNodeSimpleText* nodep) override {
if (nodep->tracking() || m_trackText) {
puts(nodep->text());
} else {
ofp()->putsNoTracking(nodep->text());
}
}
virtual void visit(AstTextBlock* nodep) VL_OVERRIDE {
virtual void visit(AstTextBlock* nodep) override {
visit(VN_CAST(nodep, NodeSimpleText));
for (AstNode* childp = nodep->nodesp(); childp; childp = childp->nextp()) {
iterate(childp);
if (nodep->commas() && childp->nextp()) puts(", ");
}
}
virtual void visit(AstCStmt* nodep) VL_OVERRIDE {
virtual void visit(AstCStmt* nodep) override {
putbs("");
iterateAndNextNull(nodep->bodysp());
}
virtual void visit(AstCMath* nodep) VL_OVERRIDE {
virtual void visit(AstCMath* nodep) override {
putbs("");
iterateAndNextNull(nodep->bodysp());
}
virtual void visit(AstUCStmt* nodep) VL_OVERRIDE {
virtual void visit(AstUCStmt* nodep) override {
putsDecoration(ifNoProtect("// $c statement at " + nodep->fileline()->ascii() + "\n"));
iterateAndNextNull(nodep->bodysp());
puts("\n");
}
virtual void visit(AstUCFunc* nodep) VL_OVERRIDE {
virtual void visit(AstUCFunc* nodep) override {
puts("\n");
putsDecoration(ifNoProtect("// $c function at " + nodep->fileline()->ascii() + "\n"));
iterateAndNextNull(nodep->bodysp());
@ -873,10 +873,10 @@ public:
}
// Operators
virtual void visit(AstNodeTermop* nodep) VL_OVERRIDE {
virtual void visit(AstNodeTermop* nodep) override {
emitOpName(nodep, nodep->emitC(), NULL, NULL, NULL);
}
virtual void visit(AstNodeUniop* nodep) VL_OVERRIDE {
virtual void visit(AstNodeUniop* nodep) override {
if (nodep->emitCheckMaxWords()
&& (nodep->widthWords() > VL_MULS_MAX_WORDS
|| nodep->lhsp()->widthWords() > VL_MULS_MAX_WORDS)) {
@ -896,7 +896,7 @@ public:
emitOpName(nodep, nodep->emitC(), nodep->lhsp(), NULL, NULL);
}
}
virtual void visit(AstNodeBiop* nodep) VL_OVERRIDE {
virtual void visit(AstNodeBiop* nodep) override {
if (nodep->emitCheckMaxWords() && nodep->widthWords() > VL_MULS_MAX_WORDS) {
nodep->v3warn(
E_UNSUPPORTED,
@ -916,11 +916,11 @@ public:
emitOpName(nodep, nodep->emitC(), nodep->lhsp(), nodep->rhsp(), NULL);
}
}
virtual void visit(AstNodeTriop* nodep) VL_OVERRIDE {
virtual void visit(AstNodeTriop* nodep) override {
UASSERT_OBJ(!emitSimpleOk(nodep), nodep, "Triop cannot be described in a simple way");
emitOpName(nodep, nodep->emitC(), nodep->lhsp(), nodep->rhsp(), nodep->thsp());
}
virtual void visit(AstRedXor* nodep) VL_OVERRIDE {
virtual void visit(AstRedXor* nodep) override {
if (nodep->lhsp()->isWide()) {
visit(VN_CAST(nodep, NodeUniop));
} else {
@ -931,7 +931,7 @@ public:
puts(")");
}
}
virtual void visit(AstCCast* nodep) VL_OVERRIDE {
virtual void visit(AstCCast* nodep) override {
// Extending a value of the same word width is just a NOP.
if (nodep->size() <= VL_IDATASIZE) {
puts("(IData)(");
@ -941,7 +941,7 @@ public:
iterateAndNextNull(nodep->lhsp());
puts(")");
}
virtual void visit(AstNodeCond* nodep) VL_OVERRIDE {
virtual void visit(AstNodeCond* nodep) override {
// Widths match up already, so we'll just use C++'s operator w/o any temps.
if (nodep->expr1p()->isWide()) {
emitOpName(nodep, nodep->emitC(), nodep->condp(), nodep->expr1p(), nodep->expr2p());
@ -955,12 +955,12 @@ public:
puts(")");
}
}
virtual void visit(AstMemberSel* nodep) VL_OVERRIDE {
virtual void visit(AstMemberSel* nodep) override {
iterateAndNextNull(nodep->fromp());
putbs("->");
puts(nodep->varp()->nameProtect());
}
virtual void visit(AstNullCheck* nodep) VL_OVERRIDE {
virtual void visit(AstNullCheck* nodep) override {
puts("VL_NULL_CHECK(");
iterateAndNextNull(nodep->lhsp());
puts(", ");
@ -969,24 +969,24 @@ public:
puts(cvtToStr(nodep->fileline()->lineno()));
puts(")");
}
virtual void visit(AstCNew* nodep) VL_OVERRIDE {
virtual void visit(AstCNew* nodep) override {
puts("std::make_shared<" + prefixNameProtect(nodep->dtypep()) + ">(");
puts("vlSymsp"); // TODO make this part of argsp, and eliminate when unnecessary
if (nodep->argsp()) puts(", ");
iterateAndNextNull(nodep->argsp());
puts(")");
}
virtual void visit(AstNewCopy* nodep) VL_OVERRIDE {
virtual void visit(AstNewCopy* nodep) override {
puts("std::make_shared<" + prefixNameProtect(nodep->dtypep()) + ">(");
puts("*"); // i.e. make into a reference
iterateAndNextNull(nodep->rhsp());
puts(")");
}
virtual void visit(AstSel* nodep) VL_OVERRIDE {
virtual void visit(AstSel* nodep) override {
// Note ASSIGN checks for this on a LHS
emitOpName(nodep, nodep->emitC(), nodep->fromp(), nodep->lsbp(), nodep->thsp());
}
virtual void visit(AstReplicate* nodep) VL_OVERRIDE {
virtual void visit(AstReplicate* nodep) override {
if (nodep->lhsp()->widthMin() == 1 && !nodep->isWide()) {
UASSERT_OBJ((static_cast<int>(VN_CAST(nodep->rhsp(), Const)->toUInt())
* nodep->lhsp()->widthMin())
@ -1007,7 +1007,7 @@ public:
emitOpName(nodep, nodep->emitC(), nodep->lhsp(), nodep->rhsp(), NULL);
}
}
virtual void visit(AstStreamL* nodep) VL_OVERRIDE {
virtual void visit(AstStreamL* nodep) override {
// Attempt to use a "fast" stream function for slice size = power of 2
if (!nodep->isWide()) {
uint32_t isPow2 = VN_CAST(nodep->rhsp(), Const)->num().countOnes() == 1;
@ -1031,7 +1031,7 @@ public:
emitOpName(nodep, "VL_STREAML_%nq%lq%rq(%nw,%lw,%rw, %P, %li, %ri)", nodep->lhsp(),
nodep->rhsp(), NULL);
}
virtual void visit(AstCountBits* nodep) VL_OVERRIDE {
virtual void visit(AstCountBits* nodep) override {
putbs("VL_COUNTBITS_");
emitIQW(nodep->lhsp());
puts("(");
@ -1052,7 +1052,7 @@ public:
puts(")");
}
// Terminals
virtual void visit(AstVarRef* nodep) VL_OVERRIDE {
virtual void visit(AstVarRef* nodep) override {
puts(nodep->hiernameProtect());
puts(nodep->varp()->nameProtect());
}
@ -1190,7 +1190,7 @@ public:
emitConstant(constp, NULL, assignString);
puts(";\n");
}
virtual void visit(AstConst* nodep) VL_OVERRIDE {
virtual void visit(AstConst* nodep) override {
if (nodep->isWide()) {
UASSERT_OBJ(m_wideTempRefp, nodep, "Wide Constant w/ no temp");
emitConstant(nodep, m_wideTempRefp, "");
@ -1201,22 +1201,22 @@ public:
}
// Just iterate
virtual void visit(AstNetlist* nodep) VL_OVERRIDE { iterateChildren(nodep); }
virtual void visit(AstTopScope* nodep) VL_OVERRIDE { iterateChildren(nodep); }
virtual void visit(AstScope* nodep) VL_OVERRIDE { iterateChildren(nodep); }
virtual void visit(AstNetlist* nodep) override { iterateChildren(nodep); }
virtual void visit(AstTopScope* nodep) override { iterateChildren(nodep); }
virtual void visit(AstScope* nodep) override { iterateChildren(nodep); }
// NOPs
virtual void visit(AstTypedef*) VL_OVERRIDE {}
virtual void visit(AstPragma*) VL_OVERRIDE {}
virtual void visit(AstCell*) VL_OVERRIDE {} // Handled outside the Visit class
virtual void visit(AstVar*) VL_OVERRIDE {} // Handled outside the Visit class
virtual void visit(AstNodeText*) VL_OVERRIDE {} // Handled outside the Visit class
virtual void visit(AstTraceDecl*) VL_OVERRIDE {} // Handled outside the Visit class
virtual void visit(AstTraceInc*) VL_OVERRIDE {} // Handled outside the Visit class
virtual void visit(AstCFile*) VL_OVERRIDE {} // Handled outside the Visit class
virtual void visit(AstCellInline*) VL_OVERRIDE {} // Handled outside visit (in EmitCSyms)
virtual void visit(AstCUse*) VL_OVERRIDE {} // Handled outside the Visit class
virtual void visit(AstTypedef*) override {}
virtual void visit(AstPragma*) override {}
virtual void visit(AstCell*) override {} // Handled outside the Visit class
virtual void visit(AstVar*) override {} // Handled outside the Visit class
virtual void visit(AstNodeText*) override {} // Handled outside the Visit class
virtual void visit(AstTraceDecl*) override {} // Handled outside the Visit class
virtual void visit(AstTraceInc*) override {} // Handled outside the Visit class
virtual void visit(AstCFile*) override {} // Handled outside the Visit class
virtual void visit(AstCellInline*) override {} // Handled outside visit (in EmitCSyms)
virtual void visit(AstCUse*) override {} // Handled outside the Visit class
// Default
virtual void visit(AstNode* nodep) VL_OVERRIDE {
virtual void visit(AstNode* nodep) override {
puts(string("\n???? // ") + nodep->prettyTypeName() + "\n");
iterateChildren(nodep);
nodep->v3fatalSrc("Unknown node type reached emitter: " << nodep->prettyTypeName());
@ -1445,7 +1445,7 @@ class EmitCImp : EmitCStmts {
}
}
virtual void visit(AstMTaskBody* nodep) VL_OVERRIDE {
virtual void visit(AstMTaskBody* nodep) override {
ExecMTask* mtp = nodep->execMTaskp();
puts("\n");
puts("void ");
@ -1464,7 +1464,7 @@ class EmitCImp : EmitCStmts {
//---------------------------------------
// VISITORS
using EmitCStmts::visit; // Suppress hidden overloaded virtual function warning
virtual void visit(AstCFunc* nodep) VL_OVERRIDE {
virtual void visit(AstCFunc* nodep) override {
// TRACE_* and DPI handled elsewhere
if (nodep->funcType().isTrace()) return;
if (nodep->dpiImport()) return;
@ -1563,16 +1563,16 @@ class EmitCImp : EmitCStmts {
}
}
virtual void visit(AstChangeDet* nodep) VL_OVERRIDE { //
virtual void visit(AstChangeDet* nodep) override { //
m_blkChangeDetVec.push_back(nodep);
}
virtual void visit(AstCReset* nodep) VL_OVERRIDE {
virtual void visit(AstCReset* nodep) override {
AstVar* varp = nodep->varrefp()->varp();
emitVarReset(varp);
}
virtual void visit(AstExecGraph* nodep) VL_OVERRIDE {
virtual void visit(AstExecGraph* nodep) override {
UASSERT_OBJ(nodep == v3Global.rootp()->execGraphp(), nodep,
"ExecGraph should be a singleton!");
// The location of the AstExecGraph within the containing _eval()
@ -3658,12 +3658,12 @@ class EmitCTrace : EmitCStmts {
// VISITORS
using EmitCStmts::visit; // Suppress hidden overloaded virtual function warning
virtual void visit(AstNetlist* nodep) VL_OVERRIDE {
virtual void visit(AstNetlist* nodep) override {
// Top module only
iterate(nodep->topModulep());
}
virtual void visit(AstNodeModule* nodep) VL_OVERRIDE { iterateChildren(nodep); }
virtual void visit(AstCFunc* nodep) VL_OVERRIDE {
virtual void visit(AstNodeModule* nodep) override { iterateChildren(nodep); }
virtual void visit(AstCFunc* nodep) override {
if (nodep->slow() != m_slow) return;
if (nodep->funcType().isTrace()) { // TRACE_*
m_funcp = nodep;
@ -3738,7 +3738,7 @@ class EmitCTrace : EmitCStmts {
}
m_funcp = NULL;
}
virtual void visit(AstTraceDecl* nodep) VL_OVERRIDE {
virtual void visit(AstTraceDecl* nodep) override {
int enumNum = emitTraceDeclDType(nodep->dtypep());
if (nodep->arrayRange().ranged()) {
puts("{int i; for (i=0; i<" + cvtToStr(nodep->arrayRange().elements()) + "; i++) {\n");
@ -3749,7 +3749,7 @@ class EmitCTrace : EmitCStmts {
puts("\n");
}
}
virtual void visit(AstTraceInc* nodep) VL_OVERRIDE {
virtual void visit(AstTraceInc* nodep) override {
if (nodep->declp()->arrayRange().ranged()) {
// It traces faster if we unroll the loop
for (int i = 0; i < nodep->declp()->arrayRange().elements(); i++) {
@ -3759,8 +3759,8 @@ class EmitCTrace : EmitCStmts {
emitTraceChangeOne(nodep, -1);
}
}
virtual void visit(AstCoverDecl* nodep) VL_OVERRIDE {}
virtual void visit(AstCoverInc* nodep) VL_OVERRIDE {}
virtual void visit(AstCoverDecl* nodep) override {}
virtual void visit(AstCoverInc* nodep) override {}
public:
explicit EmitCTrace(bool slow) {

2
src/V3EmitCBase.h
View File

@ -121,7 +121,7 @@ private:
// MEMBERS
int m_count; // Number of statements
// VISITORS
virtual void visit(AstNode* nodep) VL_OVERRIDE {
virtual void visit(AstNode* nodep) override {
m_count++;
iterateChildren(nodep);
}

8
src/V3EmitCInlines.cpp
View File

@ -35,25 +35,25 @@ class EmitCInlines : EmitCBaseVisitor {
}
// VISITORS
virtual void visit(AstClass* nodep) VL_OVERRIDE {
virtual void visit(AstClass* nodep) override {
checkHeavy(nodep);
v3Global.needC11(true);
iterateChildren(nodep);
}
virtual void visit(AstCNew* nodep) VL_OVERRIDE {
virtual void visit(AstCNew* nodep) override {
checkHeavy(nodep);
if (v3Global.opt.savable())
v3warn(E_UNSUPPORTED, "Unsupported: --savable with dynamic new");
iterateChildren(nodep);
}
virtual void visit(AstDumpCtl* nodep) VL_OVERRIDE {
virtual void visit(AstDumpCtl* nodep) override {
checkHeavy(nodep);
if (v3Global.opt.trace()) v3Global.needTraceDumper(true);
iterateChildren(nodep);
}
//---------------------------------------
virtual void visit(AstNode* nodep) VL_OVERRIDE {
virtual void visit(AstNode* nodep) override {
checkHeavy(nodep);
iterateChildren(nodep);
}

2
src/V3EmitCMake.cpp
View File

@ -78,7 +78,7 @@ class CMakeEmitter {
}
static void emitOverallCMake() {
const vl_unique_ptr<std::ofstream> of(
const std::unique_ptr<std::ofstream> of(
V3File::new_ofstream(v3Global.opt.makeDir() + "/" + v3Global.opt.prefix() + ".cmake"));
string name = v3Global.opt.prefix();

20
src/V3EmitCSyms.cpp
View File

@ -252,7 +252,7 @@ class EmitCSyms : EmitCBaseVisitor {
}
// VISITORS
virtual void visit(AstNetlist* nodep) VL_OVERRIDE {
virtual void visit(AstNetlist* nodep) override {
// Collect list of scopes
iterateChildren(nodep);
varsExpand();
@ -274,7 +274,7 @@ class EmitCSyms : EmitCBaseVisitor {
if (!m_dpiHdrOnly) emitDpiImp();
}
}
virtual void visit(AstNodeModule* nodep) VL_OVERRIDE {
virtual void visit(AstNodeModule* nodep) override {
nameCheck(nodep);
AstNodeModule* origModp = m_modp;
{
@ -283,7 +283,7 @@ class EmitCSyms : EmitCBaseVisitor {
}
m_modp = origModp;
}
virtual void visit(AstCellInline* nodep) VL_OVERRIDE {
virtual void visit(AstCellInline* nodep) override {
if (v3Global.opt.vpi()) {
string type = (nodep->origModName() == "__BEGIN__") ? "SCOPE_OTHER" : "SCOPE_MODULE";
string name = nodep->scopep()->name() + "__DOT__" + nodep->name();
@ -293,7 +293,7 @@ class EmitCSyms : EmitCBaseVisitor {
make_pair(name, ScopeData(scopeSymString(name), name_dedot, timeunit, type)));
}
}
virtual void visit(AstScope* nodep) VL_OVERRIDE {
virtual void visit(AstScope* nodep) override {
if (VN_IS(m_modp, Class)) return; // The ClassPackage is what is visible
nameCheck(nodep);
@ -307,7 +307,7 @@ class EmitCSyms : EmitCBaseVisitor {
timeunit, "SCOPE_MODULE")));
}
}
virtual void visit(AstScopeName* nodep) VL_OVERRIDE {
virtual void visit(AstScopeName* nodep) override {
string name = nodep->scopeSymName();
// UINFO(9,"scnameins sp "<<nodep->name()<<" sp "<<nodep->scopePrettySymName()
// <<" ss"<<name<<endl);
@ -329,18 +329,18 @@ class EmitCSyms : EmitCBaseVisitor {
}
}
}
virtual void visit(AstVar* nodep) VL_OVERRIDE {
virtual void visit(AstVar* nodep) override {
nameCheck(nodep);
iterateChildren(nodep);
if (nodep->isSigUserRdPublic()) { m_modVars.push_back(make_pair(m_modp, nodep)); }
}
virtual void visit(AstCoverDecl* nodep) VL_OVERRIDE {
virtual void visit(AstCoverDecl* nodep) override {
// Assign numbers to all bins, so we know how big of an array to use
if (!nodep->dataDeclNullp()) { // else duplicate we don't need code for
nodep->binNum(m_coverBins++);
}
}
virtual void visit(AstCFunc* nodep) VL_OVERRIDE {
virtual void visit(AstCFunc* nodep) override {
nameCheck(nodep);
if (nodep->dpiImport() || nodep->dpiExportWrapper()) m_dpis.push_back(nodep);
m_funcp = nodep;
@ -349,8 +349,8 @@ class EmitCSyms : EmitCBaseVisitor {
}
//---------------------------------------
virtual void visit(AstConst*) VL_OVERRIDE {}
virtual void visit(AstNode* nodep) VL_OVERRIDE { iterateChildren(nodep); }
virtual void visit(AstConst*) override {}
virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
public:
explicit EmitCSyms(AstNetlist* nodep, bool dpiHdrOnly)

178
src/V3EmitV.cpp
View File

@ -51,13 +51,13 @@ class EmitVBaseVisitor : public EmitCBaseVisitor {
}
// VISITORS
virtual void visit(AstNetlist* nodep) VL_OVERRIDE { iterateChildren(nodep); }
virtual void visit(AstNodeModule* nodep) VL_OVERRIDE {
virtual void visit(AstNetlist* nodep) override { iterateChildren(nodep); }
virtual void visit(AstNodeModule* nodep) override {
putfs(nodep, nodep->verilogKwd() + " " + prefixNameProtect(nodep) + ";\n");
iterateChildren(nodep);
putqs(nodep, "end" + nodep->verilogKwd() + "\n");
}
virtual void visit(AstNodeFTask* nodep) VL_OVERRIDE {
virtual void visit(AstNodeFTask* nodep) override {
putfs(nodep, nodep->isFunction() ? "function" : "task");
puts(" ");
puts(nodep->prettyName());
@ -68,7 +68,7 @@ class EmitVBaseVisitor : public EmitCBaseVisitor {
putqs(nodep, "end\n");
}
virtual void visit(AstBegin* nodep) VL_OVERRIDE {
virtual void visit(AstBegin* nodep) override {
if (nodep->name() == "") {
putbs("begin\n");
} else {
@ -77,7 +77,7 @@ class EmitVBaseVisitor : public EmitCBaseVisitor {
iterateChildren(nodep);
puts("end\n");
}
virtual void visit(AstFork* nodep) VL_OVERRIDE {
virtual void visit(AstFork* nodep) override {
if (nodep->name() == "") {
putbs("fork\n");
} else {
@ -87,17 +87,17 @@ class EmitVBaseVisitor : public EmitCBaseVisitor {
puts(nodep->joinType().verilogKwd());
puts("\n");
}
virtual void visit(AstFinal* nodep) VL_OVERRIDE {
virtual void visit(AstFinal* nodep) override {
putfs(nodep, "final begin\n");
iterateChildren(nodep);
putqs(nodep, "end\n");
}
virtual void visit(AstInitial* nodep) VL_OVERRIDE {
virtual void visit(AstInitial* nodep) override {
putfs(nodep, "initial begin\n");
iterateChildren(nodep);
putqs(nodep, "end\n");
}
virtual void visit(AstAlways* nodep) VL_OVERRIDE {
virtual void visit(AstAlways* nodep) override {
putfs(nodep, "always ");
if (m_sensesp) {
iterateAndNextNull(m_sensesp);
@ -109,7 +109,7 @@ class EmitVBaseVisitor : public EmitCBaseVisitor {
iterateAndNextNull(nodep->bodysp());
putqs(nodep, "end\n");
}
virtual void visit(AstAlwaysPublic* nodep) VL_OVERRIDE {
virtual void visit(AstAlwaysPublic* nodep) override {
putfs(nodep, "/*verilator public_flat_rw ");
if (m_sensesp) {
iterateAndNextNull(m_sensesp);
@ -121,37 +121,37 @@ class EmitVBaseVisitor : public EmitCBaseVisitor {
iterateAndNextNull(nodep->bodysp());
putqs(nodep, "*/\n");
}
virtual void visit(AstNodeAssign* nodep) VL_OVERRIDE {
virtual void visit(AstNodeAssign* nodep) override {
iterateAndNextNull(nodep->lhsp());
putfs(nodep, " " + nodep->verilogKwd() + " ");
iterateAndNextNull(nodep->rhsp());
if (!m_suppressSemi) puts(";\n");
}
virtual void visit(AstAssignDly* nodep) VL_OVERRIDE {
virtual void visit(AstAssignDly* nodep) override {
iterateAndNextNull(nodep->lhsp());
putfs(nodep, " <= ");
iterateAndNextNull(nodep->rhsp());
puts(";\n");
}
virtual void visit(AstAssignAlias* nodep) VL_OVERRIDE {
virtual void visit(AstAssignAlias* nodep) override {
putbs("alias ");
iterateAndNextNull(nodep->lhsp());
putfs(nodep, " = ");
iterateAndNextNull(nodep->rhsp());
if (!m_suppressSemi) puts(";\n");
}
virtual void visit(AstAssignW* nodep) VL_OVERRIDE {
virtual void visit(AstAssignW* nodep) override {
putfs(nodep, "assign ");
iterateAndNextNull(nodep->lhsp());
putbs(" = ");
iterateAndNextNull(nodep->rhsp());
if (!m_suppressSemi) puts(";\n");
}
virtual void visit(AstBreak* nodep) VL_OVERRIDE {
virtual void visit(AstBreak* nodep) override {
putbs("break");
if (!m_suppressSemi) puts(";\n");
}
virtual void visit(AstSenTree* nodep) VL_OVERRIDE {
virtual void visit(AstSenTree* nodep) override {
// AstSenItem is called for dumping in isolation by V3Order
putfs(nodep, "@(");
for (AstNode* expp = nodep->sensesp(); expp; expp = expp->nextp()) {
@ -160,13 +160,13 @@ class EmitVBaseVisitor : public EmitCBaseVisitor {
}
puts(")");
}
virtual void visit(AstSenItem* nodep) VL_OVERRIDE {
virtual void visit(AstSenItem* nodep) override {
putfs(nodep, "");
puts(nodep->edgeType().verilogKwd());
if (nodep->sensp()) puts(" ");
iterateChildren(nodep);
}
virtual void visit(AstNodeCase* nodep) VL_OVERRIDE {
virtual void visit(AstNodeCase* nodep) override {
putfs(nodep, "");
if (const AstCase* casep = VN_CAST(nodep, Case)) {
if (casep->priorityPragma()) puts("priority ");
@ -187,7 +187,7 @@ class EmitVBaseVisitor : public EmitCBaseVisitor {
iterateAndNextNull(nodep->itemsp());
putqs(nodep, "endcase\n");
}
virtual void visit(AstCaseItem* nodep) VL_OVERRIDE {
virtual void visit(AstCaseItem* nodep) override {
if (nodep->condsp()) {
iterateAndNextNull(nodep->condsp());
} else {
@ -197,17 +197,17 @@ class EmitVBaseVisitor : public EmitCBaseVisitor {
iterateAndNextNull(nodep->bodysp());
putqs(nodep, "end\n");
}
virtual void visit(AstComment* nodep) VL_OVERRIDE {
virtual void visit(AstComment* nodep) override {
puts(string("// ") + nodep->name() + "\n");
iterateChildren(nodep);
}
virtual void visit(AstContinue* nodep) VL_OVERRIDE {
virtual void visit(AstContinue* nodep) override {
putbs("continue");
if (!m_suppressSemi) puts(";\n");
}
virtual void visit(AstCoverDecl*) VL_OVERRIDE {} // N/A
virtual void visit(AstCoverInc*) VL_OVERRIDE {} // N/A
virtual void visit(AstCoverToggle*) VL_OVERRIDE {} // N/A
virtual void visit(AstCoverDecl*) override {} // N/A
virtual void visit(AstCoverInc*) override {} // N/A
virtual void visit(AstCoverToggle*) override {} // N/A
void visitNodeDisplay(AstNode* nodep, AstNode* fileOrStrgp, const string& text,
AstNode* exprsp) {
@ -224,28 +224,26 @@ class EmitVBaseVisitor : public EmitCBaseVisitor {
}
puts(");\n");
}
virtual void visit(AstDisable* nodep) VL_OVERRIDE {
putbs("disable " + nodep->name() + ";\n");
}
virtual void visit(AstDisplay* nodep) VL_OVERRIDE {
virtual void visit(AstDisable* nodep) override { putbs("disable " + nodep->name() + ";\n"); }
virtual void visit(AstDisplay* nodep) override {
visitNodeDisplay(nodep, nodep->filep(), nodep->fmtp()->text(), nodep->fmtp()->exprsp());
}
virtual void visit(AstElabDisplay* nodep) VL_OVERRIDE {
virtual void visit(AstElabDisplay* nodep) override {
visitNodeDisplay(nodep, NULL, nodep->fmtp()->text(), nodep->fmtp()->exprsp());
}
virtual void visit(AstFScanF* nodep) VL_OVERRIDE {
virtual void visit(AstFScanF* nodep) override {
visitNodeDisplay(nodep, nodep->filep(), nodep->text(), nodep->exprsp());
}
virtual void visit(AstSScanF* nodep) VL_OVERRIDE {
virtual void visit(AstSScanF* nodep) override {
visitNodeDisplay(nodep, nodep->fromp(), nodep->text(), nodep->exprsp());
}
virtual void visit(AstSFormat* nodep) VL_OVERRIDE {
virtual void visit(AstSFormat* nodep) override {
visitNodeDisplay(nodep, nodep->lhsp(), nodep->fmtp()->text(), nodep->fmtp()->exprsp());
}
virtual void visit(AstSFormatF* nodep) VL_OVERRIDE {
virtual void visit(AstSFormatF* nodep) override {
visitNodeDisplay(nodep, NULL, nodep->text(), nodep->exprsp());
}
virtual void visit(AstFOpen* nodep) VL_OVERRIDE {
virtual void visit(AstFOpen* nodep) override {
putfs(nodep, nodep->verilogKwd());
putbs("(");
iterateAndNextNull(nodep->filenamep());
@ -253,36 +251,36 @@ class EmitVBaseVisitor : public EmitCBaseVisitor {
iterateAndNextNull(nodep->modep());
puts(");\n");
}
virtual void visit(AstFOpenMcd* nodep) VL_OVERRIDE {
virtual void visit(AstFOpenMcd* nodep) override {
putfs(nodep, nodep->verilogKwd());
putbs("(");
iterateAndNextNull(nodep->filenamep());
puts(");\n");
}
virtual void visit(AstFClose* nodep) VL_OVERRIDE {
virtual void visit(AstFClose* nodep) override {
putfs(nodep, nodep->verilogKwd());
putbs(" (");
if (nodep->filep()) iterateAndNextNull(nodep->filep());
puts(");\n");
}
virtual void visit(AstFFlush* nodep) VL_OVERRIDE {
virtual void visit(AstFFlush* nodep) override {
putfs(nodep, nodep->verilogKwd());
putbs(" (");
if (nodep->filep()) iterateAndNextNull(nodep->filep());
puts(");\n");
}
virtual void visit(AstJumpBlock* nodep) VL_OVERRIDE {
virtual void visit(AstJumpBlock* nodep) override {
putbs("begin : label" + cvtToStr(nodep->labelNum()) + "\n");
if (nodep->stmtsp()) iterateAndNextNull(nodep->stmtsp());
puts("end\n");
}
virtual void visit(AstJumpGo* nodep) VL_OVERRIDE {
virtual void visit(AstJumpGo* nodep) override {
putbs("disable label" + cvtToStr(nodep->labelp()->blockp()->labelNum()) + ";\n");
}
virtual void visit(AstJumpLabel* nodep) VL_OVERRIDE {
virtual void visit(AstJumpLabel* nodep) override {
putbs("// " + cvtToStr(nodep->blockp()) + ":\n");
}
virtual void visit(AstNodeReadWriteMem* nodep) VL_OVERRIDE {
virtual void visit(AstNodeReadWriteMem* nodep) override {
putfs(nodep, nodep->verilogKwd());
putbs(" (");
if (nodep->filenamep()) iterateAndNextNull(nodep->filenamep());
@ -298,17 +296,17 @@ class EmitVBaseVisitor : public EmitCBaseVisitor {
}
puts(");\n");
}
virtual void visit(AstSysFuncAsTask* nodep) VL_OVERRIDE {
virtual void visit(AstSysFuncAsTask* nodep) override {
iterateAndNextNull(nodep->lhsp());
puts(";\n");
}
virtual void visit(AstSysIgnore* nodep) VL_OVERRIDE {
virtual void visit(AstSysIgnore* nodep) override {
putfs(nodep, nodep->verilogKwd());
putbs(" (");
iterateAndNextNull(nodep->exprsp());
puts(");\n");
}
virtual void visit(AstNodeFor* nodep) VL_OVERRIDE {
virtual void visit(AstNodeFor* nodep) override {
putfs(nodep, "for (");
m_suppressSemi = true;
iterateAndNextNull(nodep->initsp());
@ -321,14 +319,14 @@ class EmitVBaseVisitor : public EmitCBaseVisitor {
iterateAndNextNull(nodep->bodysp());
putqs(nodep, "end\n");
}
virtual void visit(AstRepeat* nodep) VL_OVERRIDE {
virtual void visit(AstRepeat* nodep) override {
putfs(nodep, "repeat (");
iterateAndNextNull(nodep->countp());
puts(") begin\n");
iterateAndNextNull(nodep->bodysp());
putfs(nodep, "end\n");
}
virtual void visit(AstWhile* nodep) VL_OVERRIDE {
virtual void visit(AstWhile* nodep) override {
iterateAndNextNull(nodep->precondsp());
putfs(nodep, "while (");
iterateAndNextNull(nodep->condp());
@ -338,7 +336,7 @@ class EmitVBaseVisitor : public EmitCBaseVisitor {
iterateAndNextNull(nodep->precondsp()); // Need to recompute before next loop
putfs(nodep, "end\n");
}
virtual void visit(AstNodeIf* nodep) VL_OVERRIDE {
virtual void visit(AstNodeIf* nodep) override {
putfs(nodep, "");
if (const AstIf* ifp = VN_CAST(nodep, If)) {
if (ifp->priorityPragma()) puts("priority ");
@ -356,7 +354,7 @@ class EmitVBaseVisitor : public EmitCBaseVisitor {
}
putqs(nodep, "end\n");
}
virtual void visit(AstPast* nodep) VL_OVERRIDE {
virtual void visit(AstPast* nodep) override {
putfs(nodep, "$past(");
iterateAndNextNull(nodep->exprp());
if (nodep->ticksp()) {
@ -365,44 +363,44 @@ class EmitVBaseVisitor : public EmitCBaseVisitor {
}
puts(")");
}
virtual void visit(AstReturn* nodep) VL_OVERRIDE {
virtual void visit(AstReturn* nodep) override {
putfs(nodep, "return ");
iterateAndNextNull(nodep->lhsp());
puts(";\n");
}
virtual void visit(AstStop* nodep) VL_OVERRIDE { putfs(nodep, "$stop;\n"); }
virtual void visit(AstFinish* nodep) VL_OVERRIDE { putfs(nodep, "$finish;\n"); }
virtual void visit(AstNodeSimpleText* nodep) VL_OVERRIDE {
virtual void visit(AstStop* nodep) override { putfs(nodep, "$stop;\n"); }
virtual void visit(AstFinish* nodep) override { putfs(nodep, "$finish;\n"); }
virtual void visit(AstNodeSimpleText* nodep) override {
if (nodep->tracking() || m_trackText) {
puts(nodep->text());
} else {
putsNoTracking(nodep->text());
}
}
virtual void visit(AstTextBlock* nodep) VL_OVERRIDE {
virtual void visit(AstTextBlock* nodep) override {
visit(VN_CAST(nodep, NodeSimpleText));
for (AstNode* childp = nodep->nodesp(); childp; childp = childp->nextp()) {
iterate(childp);
if (nodep->commas() && childp->nextp()) puts(", ");
}
}
virtual void visit(AstScopeName* nodep) VL_OVERRIDE {}
virtual void visit(AstCStmt* nodep) VL_OVERRIDE {
virtual void visit(AstScopeName* nodep) override {}
virtual void visit(AstCStmt* nodep) override {
putfs(nodep, "$_CSTMT(");
iterateAndNextNull(nodep->bodysp());
puts(");\n");
}
virtual void visit(AstCMath* nodep) VL_OVERRIDE {
virtual void visit(AstCMath* nodep) override {
putfs(nodep, "$_CMATH(");
iterateAndNextNull(nodep->bodysp());
puts(");\n");
}
virtual void visit(AstUCStmt* nodep) VL_OVERRIDE {
virtual void visit(AstUCStmt* nodep) override {
putfs(nodep, "$c(");
iterateAndNextNull(nodep->bodysp());
puts(");\n");
}
virtual void visit(AstUCFunc* nodep) VL_OVERRIDE {
virtual void visit(AstUCFunc* nodep) override {
putfs(nodep, "$c(");
iterateAndNextNull(nodep->bodysp());
puts(")");
@ -467,20 +465,20 @@ class EmitVBaseVisitor : public EmitCBaseVisitor {
}
}
virtual void visit(AstNodeTermop* nodep) VL_OVERRIDE {
virtual void visit(AstNodeTermop* nodep) override {
emitVerilogFormat(nodep, nodep->emitVerilog());
}
virtual void visit(AstNodeUniop* nodep) VL_OVERRIDE {
virtual void visit(AstNodeUniop* nodep) override {
emitVerilogFormat(nodep, nodep->emitVerilog(), nodep->lhsp());
}
virtual void visit(AstNodeBiop* nodep) VL_OVERRIDE {
virtual void visit(AstNodeBiop* nodep) override {
emitVerilogFormat(nodep, nodep->emitVerilog(), nodep->lhsp(), nodep->rhsp());
}
virtual void visit(AstNodeTriop* nodep) VL_OVERRIDE {
virtual void visit(AstNodeTriop* nodep) override {
emitVerilogFormat(nodep, nodep->emitVerilog(), nodep->lhsp(), nodep->rhsp(),
nodep->thsp());
}
virtual void visit(AstAttrOf* nodep) VL_OVERRIDE {
virtual void visit(AstAttrOf* nodep) override {
putfs(nodep, "$_ATTROF(");
iterateAndNextNull(nodep->fromp());
if (nodep->dimp()) {
@ -489,7 +487,7 @@ class EmitVBaseVisitor : public EmitCBaseVisitor {
}
puts(")");
}
virtual void visit(AstInitArray* nodep) VL_OVERRIDE {
virtual void visit(AstInitArray* nodep) override {
putfs(nodep, "`{");
int comma = 0;
const AstInitArray::KeyItemMap& mapr = nodep->map();
@ -502,7 +500,7 @@ class EmitVBaseVisitor : public EmitCBaseVisitor {
}
puts("}");
}
virtual void visit(AstNodeCond* nodep) VL_OVERRIDE {
virtual void visit(AstNodeCond* nodep) override {
putbs("(");
iterateAndNextNull(nodep->condp());
putfs(nodep, " ? ");
@ -511,7 +509,7 @@ class EmitVBaseVisitor : public EmitCBaseVisitor {
iterateAndNextNull(nodep->expr2p());
puts(")");
}
virtual void visit(AstRange* nodep) VL_OVERRIDE {
virtual void visit(AstRange* nodep) override {
puts("[");
if (VN_IS(nodep->msbp(), Const) && VN_IS(nodep->lsbp(), Const)) {
// Looks nicer if we print [1:0] rather than [32'sh1:32sh0]
@ -526,7 +524,7 @@ class EmitVBaseVisitor : public EmitCBaseVisitor {
puts("]");
}
}
virtual void visit(AstSel* nodep) VL_OVERRIDE {
virtual void visit(AstSel* nodep) override {
iterateAndNextNull(nodep->fromp());
puts("[");
if (VN_IS(nodep->lsbp(), Const)) {
@ -550,18 +548,18 @@ class EmitVBaseVisitor : public EmitCBaseVisitor {
}
puts("]");
}
virtual void visit(AstSliceSel* nodep) VL_OVERRIDE {
virtual void visit(AstSliceSel* nodep) override {
iterateAndNextNull(nodep->fromp());
puts(cvtToStr(nodep->declRange()));
}
virtual void visit(AstTypedef* nodep) VL_OVERRIDE {
virtual void visit(AstTypedef* nodep) override {
putfs(nodep, "typedef ");
iterateAndNextNull(nodep->dtypep());
puts(" ");
puts(nodep->prettyName());
puts(";\n");
}
virtual void visit(AstBasicDType* nodep) VL_OVERRIDE {
virtual void visit(AstBasicDType* nodep) override {
if (nodep->isSigned()) putfs(nodep, "signed ");
putfs(nodep, nodep->prettyName());
if (nodep->rangep()) {
@ -574,28 +572,28 @@ class EmitVBaseVisitor : public EmitCBaseVisitor {
puts(":0] ");
}
}
virtual void visit(AstConstDType* nodep) VL_OVERRIDE {
virtual void visit(AstConstDType* nodep) override {
putfs(nodep, "const ");
iterate(nodep->subDTypep());
}
virtual void visit(AstNodeArrayDType* nodep) VL_OVERRIDE {
virtual void visit(AstNodeArrayDType* nodep) override {
iterate(nodep->subDTypep());
iterateAndNextNull(nodep->rangep());
}
virtual void visit(AstNodeUOrStructDType* nodep) VL_OVERRIDE {
virtual void visit(AstNodeUOrStructDType* nodep) override {
puts(nodep->verilogKwd() + " ");
if (nodep->packed()) puts("packed ");
puts("\n");
iterateAndNextNull(nodep->membersp());
puts("}");
}
virtual void visit(AstMemberDType* nodep) VL_OVERRIDE {
virtual void visit(AstMemberDType* nodep) override {
iterate(nodep->subDTypep());
puts(" ");
puts(nodep->name());
puts("}");
}
virtual void visit(AstNodeFTaskRef* nodep) VL_OVERRIDE {
virtual void visit(AstNodeFTaskRef* nodep) override {
if (nodep->dotted() != "") {
putfs(nodep, nodep->dotted());
puts(".");
@ -607,9 +605,9 @@ class EmitVBaseVisitor : public EmitCBaseVisitor {
iterateAndNextNull(nodep->pinsp());
puts(")");
}
virtual void visit(AstArg* nodep) VL_OVERRIDE { iterateAndNextNull(nodep->exprp()); }
virtual void visit(AstArg* nodep) override { iterateAndNextNull(nodep->exprp()); }
// Terminals
virtual void visit(AstVarRef* nodep) VL_OVERRIDE {
virtual void visit(AstVarRef* nodep) override {
if (nodep->varScopep()) {
putfs(nodep, nodep->varScopep()->prettyName());
} else {
@ -617,19 +615,17 @@ class EmitVBaseVisitor : public EmitCBaseVisitor {
puts(nodep->varp()->prettyName());
}
}
virtual void visit(AstVarXRef* nodep) VL_OVERRIDE {
virtual void visit(AstVarXRef* nodep) override {
putfs(nodep, nodep->dotted());
puts(".");
puts(nodep->varp()->prettyName());
}
virtual void visit(AstConst* nodep) VL_OVERRIDE {
putfs(nodep, nodep->num().ascii(true, true));
}
virtual void visit(AstConst* nodep) override { putfs(nodep, nodep->num().ascii(true, true)); }
// Just iterate
virtual void visit(AstTopScope* nodep) VL_OVERRIDE { iterateChildren(nodep); }
virtual void visit(AstScope* nodep) VL_OVERRIDE { iterateChildren(nodep); }
virtual void visit(AstVar* nodep) VL_OVERRIDE {
virtual void visit(AstTopScope* nodep) override { iterateChildren(nodep); }
virtual void visit(AstScope* nodep) override { iterateChildren(nodep); }
virtual void visit(AstVar* nodep) override {
putfs(nodep, nodep->verilogKwd());
puts(" ");
iterate(nodep->dtypep());
@ -641,20 +637,20 @@ class EmitVBaseVisitor : public EmitCBaseVisitor {
puts("\n");
}
}
virtual void visit(AstActive* nodep) VL_OVERRIDE {
virtual void visit(AstActive* nodep) override {
m_sensesp = nodep->sensesp();
iterateAndNextNull(nodep->stmtsp());
m_sensesp = NULL;
}
virtual void visit(AstVarScope*) VL_OVERRIDE {}
virtual void visit(AstNodeText*) VL_OVERRIDE {}
virtual void visit(AstTraceDecl*) VL_OVERRIDE {}
virtual void visit(AstTraceInc*) VL_OVERRIDE {}
virtual void visit(AstVarScope*) override {}
virtual void visit(AstNodeText*) override {}
virtual void visit(AstTraceDecl*) override {}
virtual void visit(AstTraceInc*) override {}
// NOPs
virtual void visit(AstPragma*) VL_OVERRIDE {}
virtual void visit(AstCell*) VL_OVERRIDE {} // Handled outside the Visit class
virtual void visit(AstPragma*) override {}
virtual void visit(AstCell*) override {} // Handled outside the Visit class
// Default
virtual void visit(AstNode* nodep) VL_OVERRIDE {
virtual void visit(AstNode* nodep) override {
puts(string("\n???? // ") + nodep->prettyTypeName() + "\n");
iterateChildren(nodep);
// Not v3fatalSrc so we keep processing

44
src/V3EmitXml.cpp
View File

@ -100,11 +100,11 @@ class EmitXmlFileVisitor : public AstNVisitor {
}
// VISITORS
virtual void visit(AstAssignW* nodep) VL_OVERRIDE {
virtual void visit(AstAssignW* nodep) override {
outputTag(nodep, "contassign"); // IEEE: vpiContAssign
outputChildrenEnd(nodep, "contassign");
}
virtual void visit(AstCell* nodep) VL_OVERRIDE {
virtual void visit(AstCell* nodep) override {
outputTag(nodep, "instance"); // IEEE: vpiInstance
puts(" defName=");
putsQuoted(nodep->modName()); // IEEE vpiDefName
@ -112,12 +112,12 @@ class EmitXmlFileVisitor : public AstNVisitor {
putsQuoted(nodep->origName());
outputChildrenEnd(nodep, "instance");
}
virtual void visit(AstNetlist* nodep) VL_OVERRIDE {
virtual void visit(AstNetlist* nodep) override {
puts("<netlist>\n");
iterateChildren(nodep);
puts("</netlist>\n");
}
virtual void visit(AstNodeModule* nodep) VL_OVERRIDE {
virtual void visit(AstNodeModule* nodep) override {
outputTag(nodep, "");
puts(" origName=");
putsQuoted(nodep->origName());
@ -127,7 +127,7 @@ class EmitXmlFileVisitor : public AstNVisitor {
if (nodep->modPublic()) puts(" public=\"true\"");
outputChildrenEnd(nodep, "");
}
virtual void visit(AstVar* nodep) VL_OVERRIDE {
virtual void visit(AstVar* nodep) override {
AstVarType typ = nodep->varType();
string kw = nodep->verilogKwd();
string vt = nodep->dtypep()->name();
@ -162,7 +162,7 @@ class EmitXmlFileVisitor : public AstNVisitor {
if (nodep->attrSFormat()) puts(" sformat=\"true\"");
outputChildrenEnd(nodep, "");
}
virtual void visit(AstPin* nodep) VL_OVERRIDE {
virtual void visit(AstPin* nodep) override {
// What we call a pin in verilator is a port in the IEEE spec.
outputTag(nodep, "port"); // IEEE: vpiPort
if (nodep->modVarp()->isIO()) {
@ -172,12 +172,12 @@ class EmitXmlFileVisitor : public AstNVisitor {
// Children includes vpiHighConn and vpiLowConn; we don't support port bits (yet?)
outputChildrenEnd(nodep, "port");
}
virtual void visit(AstSenItem* nodep) VL_OVERRIDE {
virtual void visit(AstSenItem* nodep) override {
outputTag(nodep, "");
puts(" edgeType=\"" + cvtToStr(nodep->edgeType().ascii()) + "\""); // IEEE vpiTopModule
outputChildrenEnd(nodep, "");
}
virtual void visit(AstModportVarRef* nodep) VL_OVERRIDE {
virtual void visit(AstModportVarRef* nodep) override {
// Dump direction for Modport references
string kw = nodep->direction().xmlKwd();
outputTag(nodep, "");
@ -185,7 +185,7 @@ class EmitXmlFileVisitor : public AstNVisitor {
putsQuoted(kw);
outputChildrenEnd(nodep, "");
}
virtual void visit(AstVarXRef* nodep) VL_OVERRIDE {
virtual void visit(AstVarXRef* nodep) override {
outputTag(nodep, "");
puts(" dotted=");
putsQuoted(nodep->dotted());
@ -193,7 +193,7 @@ class EmitXmlFileVisitor : public AstNVisitor {
}
// Data types
virtual void visit(AstBasicDType* nodep) VL_OVERRIDE {
virtual void visit(AstBasicDType* nodep) override {
outputTag(nodep, "basicdtype");
if (nodep->isRanged()) {
puts(" left=\"" + cvtToStr(nodep->left()) + "\"");
@ -201,7 +201,7 @@ class EmitXmlFileVisitor : public AstNVisitor {
}
puts("/>\n");
}
virtual void visit(AstIfaceRefDType* nodep) VL_OVERRIDE {
virtual void visit(AstIfaceRefDType* nodep) override {
string mpn;
outputTag(nodep, "");
if (nodep->isModport()) mpn = nodep->modportName();
@ -209,19 +209,19 @@ class EmitXmlFileVisitor : public AstNVisitor {
putsQuoted(mpn);
outputChildrenEnd(nodep, "");
}
virtual void visit(AstDisplay* nodep) VL_OVERRIDE {
virtual void visit(AstDisplay* nodep) override {
outputTag(nodep, "");
puts(" displaytype=");
putsQuoted(nodep->verilogKwd());
outputChildrenEnd(nodep, "");
}
virtual void visit(AstElabDisplay* nodep) VL_OVERRIDE {
virtual void visit(AstElabDisplay* nodep) override {
outputTag(nodep, "");
puts(" displaytype=");
putsQuoted(nodep->verilogKwd());
outputChildrenEnd(nodep, "");
}
virtual void visit(AstExtend* nodep) VL_OVERRIDE {
virtual void visit(AstExtend* nodep) override {
outputTag(nodep, "");
puts(" width=");
putsQuoted(cvtToStr(nodep->width()));
@ -229,7 +229,7 @@ class EmitXmlFileVisitor : public AstNVisitor {
putsQuoted(cvtToStr(nodep->lhsp()->widthMinV()));
outputChildrenEnd(nodep, "");
}
virtual void visit(AstExtendS* nodep) VL_OVERRIDE {
virtual void visit(AstExtendS* nodep) override {
outputTag(nodep, "");
puts(" width=");
putsQuoted(cvtToStr(nodep->width()));
@ -239,7 +239,7 @@ class EmitXmlFileVisitor : public AstNVisitor {
}
// Default
virtual void visit(AstNode* nodep) VL_OVERRIDE {
virtual void visit(AstNode* nodep) override {
outputTag(nodep, "");
outputChildrenEnd(nodep, "");
}
@ -267,11 +267,11 @@ private:
VL_DEBUG_FUNC; // Declare debug()
// VISITORS
virtual void visit(AstNetlist* nodep) VL_OVERRIDE {
virtual void visit(AstNetlist* nodep) override {
// Children are iterated backwards to ensure correct compilation order
iterateChildrenBackwards(nodep);
}
virtual void visit(AstNodeModule* nodep) VL_OVERRIDE {
virtual void visit(AstNodeModule* nodep) override {
// Only list modules and interfaces
// Assumes modules and interfaces list is already sorted level wise
if (!nodep->dead() && (VN_IS(nodep, Module) || VN_IS(nodep, Iface))
@ -280,7 +280,7 @@ private:
}
}
//-----
virtual void visit(AstNode*) VL_OVERRIDE {
virtual void visit(AstNode*) override {
// All modules are present at root so no need to iterate on children
}
@ -318,7 +318,7 @@ private:
VL_DEBUG_FUNC; // Declare debug()
// VISITORS
virtual void visit(AstNodeModule* nodep) VL_OVERRIDE {
virtual void visit(AstNodeModule* nodep) override {
if (nodep->level() >= 0
&& nodep->level() <= 2) { // ==2 because we don't add wrapper when in XML mode
m_os << "<cells>\n";
@ -337,7 +337,7 @@ private:
m_os << "</cells>\n";
}
}
virtual void visit(AstCell* nodep) VL_OVERRIDE {
virtual void visit(AstCell* nodep) override {
if (nodep->modp()->dead()) { return; }
if (!m_hasChildren) m_os << ">\n";
m_os << "<cell " << nodep->fileline()->xml() << " "
@ -357,7 +357,7 @@ private:
m_hasChildren = true;
}
//-----
virtual void visit(AstNode* nodep) VL_OVERRIDE { iterateChildren(nodep); }
virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
public:
// CONSTRUCTORS

28
src/V3Expand.cpp
View File

@ -292,7 +292,7 @@ private:
}
// VISITORS
virtual void visit(AstExtend* nodep) VL_OVERRIDE {
virtual void visit(AstExtend* nodep) override {
if (nodep->user1SetOnce()) return; // Process once
iterateChildren(nodep);
if (nodep->isWide()) {
@ -318,7 +318,7 @@ private:
}
}
virtual void visit(AstSel* nodep) VL_OVERRIDE {
virtual void visit(AstSel* nodep) override {
if (nodep->user1SetOnce()) return; // Process once
iterateChildren(nodep);
// Remember, Sel's may have non-integer rhs, so need to optimize for that!
@ -600,7 +600,7 @@ private:
}
}
virtual void visit(AstConcat* nodep) VL_OVERRIDE {
virtual void visit(AstConcat* nodep) override {
if (nodep->user1SetOnce()) return; // Process once
iterateChildren(nodep);
if (nodep->isWide()) {
@ -642,7 +642,7 @@ private:
return true;
}
virtual void visit(AstReplicate* nodep) VL_OVERRIDE {
virtual void visit(AstReplicate* nodep) override {
if (nodep->user1SetOnce()) return; // Process once
iterateChildren(nodep);
if (nodep->isWide()) {
@ -705,7 +705,7 @@ private:
return true;
}
virtual void visit(AstChangeXor* nodep) VL_OVERRIDE {
virtual void visit(AstChangeXor* nodep) override {
if (nodep->user1SetOnce()) return; // Process once
iterateChildren(nodep);
UINFO(8, " Wordize ChangeXor " << nodep << endl);
@ -742,10 +742,10 @@ private:
VL_DO_DANGLING(replaceWithDelete(nodep, newp), nodep);
}
}
virtual void visit(AstEq* nodep) VL_OVERRIDE { visitEqNeq(nodep); }
virtual void visit(AstNeq* nodep) VL_OVERRIDE { visitEqNeq(nodep); }
virtual void visit(AstEq* nodep) override { visitEqNeq(nodep); }
virtual void visit(AstNeq* nodep) override { visitEqNeq(nodep); }
virtual void visit(AstRedOr* nodep) VL_OVERRIDE {
virtual void visit(AstRedOr* nodep) override {
if (nodep->user1SetOnce()) return; // Process once
iterateChildren(nodep);
if (nodep->lhsp()->isWide()) {
@ -769,7 +769,7 @@ private:
VL_DO_DANGLING(replaceWithDelete(nodep, newp), nodep);
}
}
virtual void visit(AstRedAnd* nodep) VL_OVERRIDE {
virtual void visit(AstRedAnd* nodep) override {
if (nodep->user1SetOnce()) return; // Process once
iterateChildren(nodep);
if (nodep->lhsp()->isWide()) {
@ -802,7 +802,7 @@ private:
VL_DO_DANGLING(replaceWithDelete(nodep, newp), nodep);
}
}
virtual void visit(AstRedXor* nodep) VL_OVERRIDE {
virtual void visit(AstRedXor* nodep) override {
if (nodep->user1SetOnce()) return; // Process once
iterateChildren(nodep);
if (nodep->lhsp()->isWide()) {
@ -821,7 +821,7 @@ private:
// which the inlined function does nicely.
}
virtual void visit(AstNodeStmt* nodep) VL_OVERRIDE {
virtual void visit(AstNodeStmt* nodep) override {
if (nodep->user1SetOnce()) return; // Process once
if (!nodep->isStatement()) {
iterateChildren(nodep);
@ -831,7 +831,7 @@ private:
iterateChildren(nodep);
m_stmtp = NULL;
}
virtual void visit(AstNodeAssign* nodep) VL_OVERRIDE {
virtual void visit(AstNodeAssign* nodep) override {
if (nodep->user1SetOnce()) return; // Process once
m_stmtp = nodep;
iterateChildren(nodep);
@ -873,8 +873,8 @@ private:
}
//--------------------
virtual void visit(AstVar*) VL_OVERRIDE {} // Don't hit varrefs under vars
virtual void visit(AstNode* nodep) VL_OVERRIDE { iterateChildren(nodep); }
virtual void visit(AstVar*) override {} // Don't hit varrefs under vars
virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
public:
// CONSTRUCTORS

8
src/V3File.cpp
View File

@ -146,7 +146,7 @@ V3FileDependImp dependImp; // Depend implementation class
// V3FileDependImp
inline void V3FileDependImp::writeDepend(const string& filename) {
const vl_unique_ptr<std::ofstream> ofp(V3File::new_ofstream(filename));
const std::unique_ptr<std::ofstream> ofp(V3File::new_ofstream(filename));
if (ofp->fail()) v3fatal("Can't write " << filename);
for (std::set<DependFile>::iterator iter = m_filenameList.begin();
@ -183,7 +183,7 @@ inline std::vector<string> V3FileDependImp::getAllDeps() const {
}
inline void V3FileDependImp::writeTimes(const string& filename, const string& cmdlineIn) {
const vl_unique_ptr<std::ofstream> ofp(V3File::new_ofstream(filename));
const std::unique_ptr<std::ofstream> ofp(V3File::new_ofstream(filename));
if (ofp->fail()) v3fatal("Can't write " << filename);
string cmdline = stripQuotes(cmdlineIn);
@ -219,7 +219,7 @@ inline void V3FileDependImp::writeTimes(const string& filename, const string& cm
}
inline bool V3FileDependImp::checkTimes(const string& filename, const string& cmdlineIn) {
const vl_unique_ptr<std::ifstream> ifp(V3File::new_ifstream_nodepend(filename));
const std::unique_ptr<std::ifstream> ifp(V3File::new_ifstream_nodepend(filename));
if (ifp->fail()) {
UINFO(2, " --check-times failed: no input " << filename << endl);
return false;
@ -975,7 +975,7 @@ class VIdProtectImp {
// MEMBERS
typedef std::map<string, string> IdMap;
IdMap m_nameMap; // Map of old name into new name
typedef vl_unordered_set<std::string> IdSet;
typedef std::unordered_set<std::string> IdSet;
IdSet m_newIdSet; // Which new names exist
protected:
// CONSTRUCTORS

4
src/V3FileLine.cpp
View File

@ -31,7 +31,7 @@
#include <algorithm>
#include <iomanip>
#include VL_INCLUDE_UNORDERED_SET
#include <unordered_set>
//######################################################################
// FileLineSingleton class functions
@ -442,7 +442,7 @@ string FileLine::warnContext(bool secondary) const {
}
#ifdef VL_LEAK_CHECKS
typedef vl_unordered_set<FileLine*> FileLineCheckSet;
typedef std::unordered_set<FileLine*> FileLineCheckSet;
FileLineCheckSet fileLineLeakChecks;
void* FileLine::operator new(size_t size) {

70
src/V3Gate.cpp
View File

@ -35,7 +35,7 @@
#include <algorithm>
#include <list>
#include <map>
#include VL_INCLUDE_UNORDERED_SET
#include <unordered_set>
typedef std::list<AstNodeVarRef*> GateVarRefList;
@ -213,7 +213,7 @@ private:
}
}
// VISITORS
virtual void visit(AstNodeVarRef* nodep) VL_OVERRIDE {
virtual void visit(AstNodeVarRef* nodep) override {
++m_ops;
iterateChildren(nodep);
// We only allow a LHS ref for the var being set, and a RHS ref for
@ -237,7 +237,7 @@ private:
m_rhsVarRefs.push_back(nodep);
}
}
virtual void visit(AstNodeAssign* nodep) VL_OVERRIDE {
virtual void visit(AstNodeAssign* nodep) override {
m_substTreep = nodep->rhsp();
if (!VN_IS(nodep->lhsp(), NodeVarRef)) {
clearSimple("ASSIGN(non-VARREF)");
@ -260,7 +260,7 @@ private:
}
}
//--------------------
virtual void visit(AstNode* nodep) VL_OVERRIDE {
virtual void visit(AstNode* nodep) override {
// *** Special iterator
if (!m_isSimple) return; // Fastpath
if (++m_ops > v3Global.opt.gateStmts()) { clearSimple("--gate-stmts exceeded"); }
@ -385,7 +385,7 @@ private:
void decomposeClkVectors();
// VISITORS
virtual void visit(AstNetlist* nodep) VL_OVERRIDE {
virtual void visit(AstNetlist* nodep) override {
iterateChildren(nodep);
// if (debug() > 6) m_graph.dump();
if (debug() > 6) m_graph.dumpDotFilePrefixed("gate_pre");
@ -416,7 +416,7 @@ private:
consumedMove();
replaceAssigns();
}
virtual void visit(AstNodeModule* nodep) VL_OVERRIDE {
virtual void visit(AstNodeModule* nodep) override {
AstNodeModule* origModp = m_modp;
{
m_modp = nodep;
@ -425,14 +425,14 @@ private:
}
m_modp = origModp;
}
virtual void visit(AstScope* nodep) VL_OVERRIDE {
virtual void visit(AstScope* nodep) override {
UINFO(4, " SCOPE " << nodep << endl);
m_scopep = nodep;
m_logicVertexp = NULL;
iterateChildren(nodep);
m_scopep = NULL;
}
virtual void visit(AstActive* nodep) VL_OVERRIDE {
virtual void visit(AstActive* nodep) override {
// Create required blocks and add to module
UINFO(4, " BLOCK " << nodep << endl);
m_activeReducible = !(nodep->hasClocked()); // Seq logic outputs aren't reducible
@ -443,7 +443,7 @@ private:
m_activep = NULL;
m_activeReducible = true;
}
virtual void visit(AstNodeVarRef* nodep) VL_OVERRIDE {
virtual void visit(AstNodeVarRef* nodep) override {
if (m_scopep) {
UASSERT_OBJ(m_logicVertexp, nodep, "Var ref not under a logic block");
AstVarScope* varscp = nodep->varScopep();
@ -470,19 +470,19 @@ private:
}
}
}
virtual void visit(AstAlways* nodep) VL_OVERRIDE {
virtual void visit(AstAlways* nodep) override {
iterateNewStmt(nodep, (nodep->isJustOneBodyStmt() ? NULL : "Multiple Stmts"), NULL);
}
virtual void visit(AstAlwaysPublic* nodep) VL_OVERRIDE {
virtual void visit(AstAlwaysPublic* nodep) override {
bool lastslow = m_inSlow;
m_inSlow = true;
iterateNewStmt(nodep, "AlwaysPublic", NULL);
m_inSlow = lastslow;
}
virtual void visit(AstCFunc* nodep) VL_OVERRIDE {
virtual void visit(AstCFunc* nodep) override {
iterateNewStmt(nodep, "User C Function", "User C Function");
}
virtual void visit(AstSenItem* nodep) VL_OVERRIDE {
virtual void visit(AstSenItem* nodep) override {
m_inSenItem = true;
if (m_logicVertexp) { // Already under logic; presumably a SenGate
iterateChildren(nodep);
@ -491,28 +491,28 @@ private:
}
m_inSenItem = false;
}
virtual void visit(AstInitial* nodep) VL_OVERRIDE {
virtual void visit(AstInitial* nodep) override {
bool lastslow = m_inSlow;
m_inSlow = true;
iterateNewStmt(nodep, (nodep->isJustOneBodyStmt() ? NULL : "Multiple Stmts"), NULL);
m_inSlow = lastslow;
}
virtual void visit(AstAssignAlias* nodep) VL_OVERRIDE { //
virtual void visit(AstAssignAlias* nodep) override { //
iterateNewStmt(nodep, NULL, NULL);
}
virtual void visit(AstAssignW* nodep) VL_OVERRIDE { //
virtual void visit(AstAssignW* nodep) override { //
iterateNewStmt(nodep, NULL, NULL);
}
virtual void visit(AstCoverToggle* nodep) VL_OVERRIDE {
virtual void visit(AstCoverToggle* nodep) override {
iterateNewStmt(nodep, "CoverToggle", "CoverToggle");
}
virtual void visit(AstTraceDecl* nodep) VL_OVERRIDE {
virtual void visit(AstTraceDecl* nodep) override {
const bool lastslow = m_inSlow;
m_inSlow = true;
iterateNewStmt(nodep, "Tracing", "Tracing");
m_inSlow = lastslow;
}
virtual void visit(AstConcat* nodep) VL_OVERRIDE {
virtual void visit(AstConcat* nodep) override {
UASSERT_OBJ(!(VN_IS(nodep->backp(), NodeAssign)
&& VN_CAST(nodep->backp(), NodeAssign)->lhsp() == nodep),
nodep, "Concat on LHS of assignment; V3Const should have deleted it");
@ -520,7 +520,7 @@ private:
}
//--------------------
virtual void visit(AstNode* nodep) VL_OVERRIDE {
virtual void visit(AstNode* nodep) override {
iterateChildren(nodep);
if (nodep->isOutputter() && m_logicVertexp) m_logicVertexp->setConsumed("outputter");
}
@ -693,7 +693,7 @@ bool GateVisitor::elimLogicOkOutputs(GateLogicVertex* consumeVertexp,
// Return true if can optimize
// Return false if the consuming logic has an output signal that the
// replacement logic has as an input
typedef vl_unordered_set<AstVarScope*> VarScopeSet;
typedef std::unordered_set<AstVarScope*> VarScopeSet;
// Use map to find duplicates between two lists
VarScopeSet varscopes;
// Replacement logic usually has shorter input list, so faster to build list based on it
@ -848,7 +848,7 @@ private:
void hashReplace(AstNode* oldp, AstNode* newp);
// VISITORS
virtual void visit(AstNodeVarRef* nodep) VL_OVERRIDE {
virtual void visit(AstNodeVarRef* nodep) override {
if (nodep->varScopep() == m_elimVarScp) {
// Substitute in the new tree
// It's possible we substitute into something that will be reduced more later,
@ -874,7 +874,7 @@ private:
VL_DO_DANGLING(nodep->deleteTree(), nodep);
}
}
virtual void visit(AstNode* nodep) VL_OVERRIDE { iterateChildren(nodep); }
virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
public:
// CONSTRUCTORS
@ -1048,7 +1048,7 @@ private:
bool m_dedupable; // Determined the assign to be dedupable
// VISITORS
virtual void visit(AstNodeAssign* assignp) VL_OVERRIDE {
virtual void visit(AstNodeAssign* assignp) override {
if (m_dedupable) {
// I think we could safely dedupe an always block with multiple
// non-blocking statements, but erring on side of caution here
@ -1059,7 +1059,7 @@ private:
}
}
}
virtual void visit(AstAlways* alwaysp) VL_OVERRIDE {
virtual void visit(AstAlways* alwaysp) override {
if (m_dedupable) {
if (!m_always) {
m_always = true;
@ -1073,7 +1073,7 @@ private:
// always @(...)
// if (...)
// foo = ...; // or foo <= ...;
virtual void visit(AstNodeIf* ifp) VL_OVERRIDE {
virtual void visit(AstNodeIf* ifp) override {
if (m_dedupable) {
if (m_always && !m_ifCondp && !ifp->elsesp()) {
// we're under an always, this is the first IF, and there's no else
@ -1085,9 +1085,9 @@ private:
}
}
virtual void visit(AstComment*) VL_OVERRIDE {} // NOP
virtual void visit(AstComment*) override {} // NOP
//--------------------
virtual void visit(AstNode*) VL_OVERRIDE { //
virtual void visit(AstNode*) override { //
m_dedupable = false;
}
@ -1404,7 +1404,7 @@ private:
bool m_found; // Offset found
// VISITORS
virtual void visit(AstNodeVarRef* nodep) VL_OVERRIDE {
virtual void visit(AstNodeVarRef* nodep) override {
UINFO(9, "CLK DECOMP Concat search var (off = " << m_offset << ") - " << nodep << endl);
if (nodep->varScopep() == m_vscp && !nodep->user2() && !m_found) {
// A concatenation may use the same var multiple times
@ -1416,13 +1416,13 @@ private:
}
m_offset += nodep->dtypep()->width();
}
virtual void visit(AstConcat* nodep) VL_OVERRIDE {
virtual void visit(AstConcat* nodep) override {
UINFO(9, "CLK DECOMP Concat search (off = " << m_offset << ") - " << nodep << endl);
iterate(nodep->rhsp());
iterate(nodep->lhsp());
}
//--------------------
virtual void visit(AstNode* nodep) VL_OVERRIDE { iterateChildren(nodep); }
virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
public:
// CONSTRUCTORS
@ -1603,7 +1603,7 @@ void GateVisitor::decomposeClkVectors() {
class GateDeassignVisitor : public GateBaseVisitor {
private:
// VISITORS
virtual void visit(AstVarScope* nodep) VL_OVERRIDE {
virtual void visit(AstVarScope* nodep) override {
if (AstNodeAssign* assp = VN_CAST(nodep->valuep(), NodeAssign)) {
UINFO(5, " Removeassign " << assp << endl);
AstNode* valuep = assp->rhsp();
@ -1613,9 +1613,9 @@ private:
}
}
// Speedups
virtual void visit(AstVar*) VL_OVERRIDE {} // Accelerate
virtual void visit(AstActive*) VL_OVERRIDE {} // Accelerate
virtual void visit(AstNode* nodep) VL_OVERRIDE { iterateChildren(nodep); }
virtual void visit(AstVar*) override {} // Accelerate
virtual void visit(AstActive*) override {} // Accelerate
virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
public:
// CONSTRUCTORS

28
src/V3GenClk.cpp
View File

@ -78,7 +78,7 @@ private:
}
// VISITORS
virtual void visit(AstTopScope* nodep) VL_OVERRIDE {
virtual void visit(AstTopScope* nodep) override {
AstNode::user2ClearTree(); // user2p() used on entire tree
AstScope* scopep = nodep->scopep();
@ -88,7 +88,7 @@ private:
iterateChildren(nodep);
}
//----
virtual void visit(AstVarRef* nodep) VL_OVERRIDE {
virtual void visit(AstVarRef* nodep) override {
// Consumption/generation of a variable,
AstVarScope* vscp = nodep->varScopep();
UASSERT_OBJ(vscp, nodep, "Scope not assigned");
@ -104,17 +104,17 @@ private:
}
}
}
virtual void visit(AstActive* nodep) VL_OVERRIDE {
virtual void visit(AstActive* nodep) override {
m_activep = nodep;
UASSERT_OBJ(nodep->sensesp(), nodep, "Unlinked");
iterateChildren(nodep->sensesp()); // iterateAndNext?
m_activep = NULL;
iterateChildren(nodep);
}
virtual void visit(AstCFunc* nodep) VL_OVERRIDE { iterateChildren(nodep); }
virtual void visit(AstCFunc* nodep) override { iterateChildren(nodep); }
//-----
virtual void visit(AstNode* nodep) VL_OVERRIDE { iterateChildren(nodep); }
virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
public:
// CONSTRUCTORS
@ -144,7 +144,7 @@ private:
AstNodeModule* m_topModp; // Top module
// VISITORS
virtual void visit(AstTopScope* nodep) VL_OVERRIDE {
virtual void visit(AstTopScope* nodep) override {
AstNode::user1ClearTree(); // user1p() used on entire tree
iterateChildren(nodep);
{
@ -153,14 +153,14 @@ private:
GenClkRenameVisitor visitor(nodep, m_topModp);
}
}
virtual void visit(AstNodeModule* nodep) VL_OVERRIDE {
virtual void visit(AstNodeModule* nodep) override {
// Only track the top scopes, not lower level functions
if (nodep->isTop()) {
m_topModp = nodep;
iterateChildren(nodep);
}
}
virtual void visit(AstNodeCCall* nodep) VL_OVERRIDE {
virtual void visit(AstNodeCCall* nodep) override {
iterateChildren(nodep);
if (!nodep->funcp()->entryPoint()) {
// Enter the function and trace it
@ -168,7 +168,7 @@ private:
iterate(nodep->funcp());
}
}
virtual void visit(AstCFunc* nodep) VL_OVERRIDE {
virtual void visit(AstCFunc* nodep) override {
if (!m_tracingCall && !nodep->entryPoint()) {
// Only consider logic within a CFunc when looking
// at the call to it, and not when scanning whatever
@ -180,7 +180,7 @@ private:
}
//----
virtual void visit(AstVarRef* nodep) VL_OVERRIDE {
virtual void visit(AstVarRef* nodep) override {
// Consumption/generation of a variable,
AstVarScope* vscp = nodep->varScopep();
UASSERT_OBJ(vscp, nodep, "Scope not assigned");
@ -195,13 +195,13 @@ private:
vscp->circular(true);
}
}
virtual void visit(AstNodeAssign* nodep) VL_OVERRIDE {
virtual void visit(AstNodeAssign* nodep) override {
// UINFO(8, "ASS " << nodep << endl);
m_assignp = nodep;
iterateChildren(nodep);
m_assignp = NULL;
}
virtual void visit(AstActive* nodep) VL_OVERRIDE {
virtual void visit(AstActive* nodep) override {
UINFO(8, "ACTIVE " << nodep << endl);
m_activep = nodep;
UASSERT_OBJ(nodep->sensesp(), nodep, "Unlinked");
@ -211,8 +211,8 @@ private:
}
//-----
virtual void visit(AstVar*) VL_OVERRIDE {} // Don't want varrefs under it
virtual void visit(AstNode* nodep) VL_OVERRIDE { iterateChildren(nodep); }
virtual void visit(AstVar*) override {} // Don't want varrefs under it
virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
public:
// CONSTRUCTORS

4
src/V3Global.h
View File

@ -31,7 +31,7 @@
#include "V3Options.h"
#include <string>
#include VL_INCLUDE_UNORDERED_MAP
#include <unordered_map>
class AstNetlist;
class V3HierBlockPlan;
@ -83,7 +83,7 @@ class V3Global {
bool m_useParallelBuild; // Use parallel build for model
// Memory address to short string mapping (for debug)
typedef vl_unordered_map<const void*, std::string> PtrToIdMap; // The map type
typedef std::unordered_map<const void*, std::string> PtrToIdMap; // The map type
PtrToIdMap m_ptrToId; // The actual 'address' <=> 'short string' bijection
public:

2
src/V3Graph.cpp
View File

@ -314,7 +314,7 @@ void V3Graph::dumpDotFilePrefixedAlways(const string& nameComment, bool colorAsS
void V3Graph::dumpDotFile(const string& filename, bool colorAsSubgraph) const {
// This generates a file used by graphviz, https://www.graphviz.org
// "hardcoded" parameters:
const vl_unique_ptr<std::ofstream> logp(V3File::new_ofstream(filename));
const std::unique_ptr<std::ofstream> logp(V3File::new_ofstream(filename));
if (logp->fail()) v3fatal("Can't write " << filename);
// Header

4
src/V3GraphStream.h
View File

@ -24,7 +24,7 @@
#include "V3Graph.h"
#include <set>
#include VL_INCLUDE_UNORDERED_MAP
#include <unordered_map>
//######################################################################
// GraphStream
@ -81,7 +81,7 @@ private:
};
typedef std::set<VxHolder, VxHolderCmp&> ReadyVertices;
typedef vl_unordered_map<const V3GraphVertex*, VxHolder> WaitingVertices;
typedef std::unordered_map<const V3GraphVertex*, VxHolder> WaitingVertices;
// MEMBERS
VxHolderCmp m_vxHolderCmp; // Vertext comparison functor

10
src/V3Hashed.cpp
View File

@ -83,10 +83,10 @@ private:
}
//--------------------
virtual void visit(AstVar*) VL_OVERRIDE {}
virtual void visit(AstTypedef*) VL_OVERRIDE {}
virtual void visit(AstParamTypeDType*) VL_OVERRIDE {}
virtual void visit(AstNode* nodep) VL_OVERRIDE {
virtual void visit(AstVar*) override {}
virtual void visit(AstTypedef*) override {}
virtual void visit(AstParamTypeDType*) override {}
virtual void visit(AstNode* nodep) override {
// Hash not just iterate
nodeHashIterate(nodep);
}
@ -151,7 +151,7 @@ void V3Hashed::dumpFilePrefixed(const string& nameComment, bool tree) {
}
void V3Hashed::dumpFile(const string& filename, bool tree) {
const vl_unique_ptr<std::ofstream> logp(V3File::new_ofstream(filename));
const std::unique_ptr<std::ofstream> logp(V3File::new_ofstream(filename));
if (logp->fail()) v3fatal("Can't write " << filename);
std::map<int, int> dist;

16
src/V3HierBlock.cpp
View File

@ -199,7 +199,7 @@ string V3HierBlock::hierGenerated(bool withDir) const {
}
void V3HierBlock::writeCommandArgsFile(bool forCMake) const {
vl_unique_ptr<std::ofstream> of(V3File::new_ofstream(commandArgsFileName(forCMake)));
std::unique_ptr<std::ofstream> of(V3File::new_ofstream(commandArgsFileName(forCMake)));
*of << "--cc\n";
if (!forCMake) {
@ -241,7 +241,7 @@ class HierBlockUsageCollectVisitor : public AstNVisitor {
ModuleSet m_referred; // Modules that have hier_block pragma
V3HierBlock::GParams m_gparams; // list of variables that is AstVarType::GPARAM
virtual void visit(AstModule* nodep) VL_OVERRIDE {
virtual void visit(AstModule* nodep) override {
// Don't visit twice
if (nodep->user1SetOnce()) return;
UINFO(5, "Checking " << nodep->prettyNameQ() << " from "
@ -271,7 +271,7 @@ class HierBlockUsageCollectVisitor : public AstNVisitor {
m_modp = prevModp;
m_gparams = prevGParams;
}
virtual void visit(AstCell* nodep) VL_OVERRIDE {
virtual void visit(AstCell* nodep) override {
// Visit used module here to know that the module is hier_block or not.
// This visitor behaves almost depth first search
if (AstModule* modp = VN_CAST(nodep->modp(), Module)) {
@ -281,15 +281,15 @@ class HierBlockUsageCollectVisitor : public AstNVisitor {
// Nothing to do for interface because hierarchical block does not exist
// beyond interface.
}
virtual void visit(AstVar* nodep) VL_OVERRIDE {
virtual void visit(AstVar* nodep) override {
if (m_modp && m_modp->hierBlock() && nodep->isIfaceRef() && !nodep->isIfaceParent()) {
nodep->v3error("Modport cannot be used at the hierarchical block boundary");
}
if (nodep->isGParam() && nodep->overriddenParam()) m_gparams.push_back(nodep);
}
virtual void visit(AstNodeMath*) VL_OVERRIDE {} // Accelerate
virtual void visit(AstNode* nodep) VL_OVERRIDE { iterateChildren(nodep); }
virtual void visit(AstNodeMath*) override {} // Accelerate
virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
public:
HierBlockUsageCollectVisitor(V3HierBlockPlan* planp, AstNetlist* netlist)
@ -345,7 +345,7 @@ void V3HierBlockPlan::createPlan(AstNetlist* nodep) {
modp->hierBlock(false);
}
vl_unique_ptr<V3HierBlockPlan> planp(new V3HierBlockPlan());
std::unique_ptr<V3HierBlockPlan> planp(new V3HierBlockPlan());
{ HierBlockUsageCollectVisitor visitor(planp.get(), nodep); }
V3Stats::addStat("HierBlock, Hierarchical blocks", planp->m_blocks.size());
@ -399,7 +399,7 @@ void V3HierBlockPlan::writeCommandArgsFiles(bool forCMake) const {
it->second->writeCommandArgsFile(forCMake);
}
// For the top module
vl_unique_ptr<std::ofstream> of(V3File::new_ofstream(topCommandArgsFileName(forCMake)));
std::unique_ptr<std::ofstream> of(V3File::new_ofstream(topCommandArgsFileName(forCMake)));
if (!forCMake) {
// Load wrappers first not to be overwritten by the original HDL
for (const_iterator it = begin(); it != end(); ++it) {

88
src/V3Inline.cpp
View File

@ -36,7 +36,7 @@
#include <algorithm>
#include <vector>
#include VL_INCLUDE_UNORDERED_SET
#include <unordered_set>
// CONFIG
static const int INLINE_MODS_SMALLER = 100; // If a mod is < this # nodes, can always inline it
@ -97,7 +97,7 @@ private:
}
// VISITORS
virtual void visit(AstNodeModule* nodep) VL_OVERRIDE {
virtual void visit(AstNodeModule* nodep) override {
UASSERT_OBJ(!m_modp, nodep, "Unsupported: Recursive modules");
m_modp = nodep;
m_allMods.push_back(nodep);
@ -113,18 +113,18 @@ private:
iterateChildren(nodep);
m_modp = NULL;
}
virtual void visit(AstClass* nodep) VL_OVERRIDE {
virtual void visit(AstClass* nodep) override {
// TODO allow inlining of modules that have classes
// (Probably wait for new inliner scheme)
cantInline("class", true);
iterateChildren(nodep);
}
virtual void visit(AstCell* nodep) VL_OVERRIDE {
virtual void visit(AstCell* nodep) override {
nodep->modp()->user3Inc(); // Inc refs
m_instances[m_modp][nodep->modp()]++;
iterateChildren(nodep);
}
virtual void visit(AstPragma* nodep) VL_OVERRIDE {
virtual void visit(AstPragma* nodep) override {
if (nodep->pragType() == AstPragmaType::INLINE_MODULE) {
// UINFO(0, "PRAG MARK " << m_modp << endl);
if (!m_modp) {
@ -146,28 +146,28 @@ private:
iterateChildren(nodep);
}
}
virtual void visit(AstVarXRef* nodep) VL_OVERRIDE {
virtual void visit(AstVarXRef* nodep) override {
// Cleanup link until V3LinkDot can correct it
nodep->varp(NULL);
}
virtual void visit(AstNodeFTaskRef* nodep) VL_OVERRIDE {
virtual void visit(AstNodeFTaskRef* nodep) override {
// Cleanup link until V3LinkDot can correct it
// MethodCalls not currently supported by inliner, so keep linked
if (!nodep->packagep() && !VN_IS(nodep, MethodCall)) nodep->taskp(NULL);
iterateChildren(nodep);
}
virtual void visit(AstAlways* nodep) VL_OVERRIDE {
virtual void visit(AstAlways* nodep) override {
iterateChildren(nodep);
m_modp->user4Inc(); // statement count
}
virtual void visit(AstNodeAssign* nodep) VL_OVERRIDE {
virtual void visit(AstNodeAssign* nodep) override {
// Don't count assignments, as they'll likely flatten out
// Still need to iterate though to nullify VarXRefs
int oldcnt = m_modp->user4();
iterateChildren(nodep);
m_modp->user4(oldcnt);
}
virtual void visit(AstNetlist* nodep) VL_OVERRIDE {
virtual void visit(AstNetlist* nodep) override {
// Build user2, user3, and user4 for all modules.
// Also build m_allMods and m_instances.
iterateChildren(nodep);
@ -210,7 +210,7 @@ private:
}
}
//--------------------
virtual void visit(AstNode* nodep) VL_OVERRIDE {
virtual void visit(AstNode* nodep) override {
iterateChildren(nodep);
if (m_modp) {
m_modp->user4Inc(); // Inc statement count
@ -246,11 +246,11 @@ private:
VL_DEBUG_FUNC; // Declare debug()
// VISITORS
virtual void visit(AstCell* nodep) VL_OVERRIDE { nodep->user4p(nodep->clonep()); }
virtual void visit(AstCell* nodep) override { nodep->user4p(nodep->clonep()); }
//--------------------
virtual void visit(AstNodeStmt*) VL_OVERRIDE {} // Accelerate
virtual void visit(AstNodeMath*) VL_OVERRIDE {} // Accelerate
virtual void visit(AstNode* nodep) VL_OVERRIDE { iterateChildren(nodep); }
virtual void visit(AstNodeStmt*) override {} // Accelerate
virtual void visit(AstNodeMath*) override {} // Accelerate
virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
public:
// CONSTRUCTORS
@ -265,7 +265,7 @@ public:
class InlineRelinkVisitor : public AstNVisitor {
private:
typedef vl_unordered_set<string> StringSet;
typedef std::unordered_set<string> StringSet;
// NODE STATE
// Input:
@ -280,7 +280,7 @@ private:
VL_DEBUG_FUNC; // Declare debug()
// VISITORS
virtual void visit(AstCellInline* nodep) VL_OVERRIDE {
virtual void visit(AstCellInline* nodep) override {
// Inlined cell under the inline cell, need to move to avoid conflicts
nodep->unlinkFrBack();
m_modp->addInlinesp(nodep);
@ -291,22 +291,22 @@ private:
// Do CellInlines under this, but don't move them
iterateChildren(nodep);
}
virtual void visit(AstCell* nodep) VL_OVERRIDE {
virtual void visit(AstCell* nodep) override {
// Cell under the inline cell, need to rename to avoid conflicts
string name = m_cellp->name() + "__DOT__" + nodep->name();
nodep->name(name);
iterateChildren(nodep);
}
virtual void visit(AstClass* nodep) VL_OVERRIDE {
virtual void visit(AstClass* nodep) override {
string name = m_cellp->name() + "__DOT__" + nodep->name();
nodep->name(name);
iterateChildren(nodep);
}
virtual void visit(AstModule* nodep) VL_OVERRIDE {
virtual void visit(AstModule* nodep) override {
m_renamedInterfaces.clear();
iterateChildren(nodep);
}
virtual void visit(AstVar* nodep) VL_OVERRIDE {
virtual void visit(AstVar* nodep) override {
if (nodep->user2p()) {
// Make an assignment, so we'll trace it properly
// user2p is either a const or a var.
@ -384,17 +384,17 @@ private:
if (debug() >= 9 && nodep->valuep()) { nodep->valuep()->dumpTree(cout, "varchangei:"); }
iterateChildren(nodep);
}
virtual void visit(AstNodeFTask* nodep) VL_OVERRIDE {
virtual void visit(AstNodeFTask* nodep) override {
// Function under the inline cell, need to rename to avoid conflicts
nodep->name(m_cellp->name() + "__DOT__" + nodep->name());
iterateChildren(nodep);
}
virtual void visit(AstTypedef* nodep) VL_OVERRIDE {
virtual void visit(AstTypedef* nodep) override {
// Typedef under the inline cell, need to rename to avoid conflicts
nodep->name(m_cellp->name() + "__DOT__" + nodep->name());
iterateChildren(nodep);
}
virtual void visit(AstVarRef* nodep) VL_OVERRIDE {
virtual void visit(AstVarRef* nodep) override {
if (nodep->varp()->user2p() // It's being converted to an alias.
&& !nodep->varp()->user3()
// Don't constant propagate aliases (we just made)
@ -414,7 +414,7 @@ private:
nodep->name(nodep->varp()->name());
iterateChildren(nodep);
}
virtual void visit(AstVarXRef* nodep) VL_OVERRIDE {
virtual void visit(AstVarXRef* nodep) override {
// Track what scope it was originally under so V3LinkDot can resolve it
string newdots = VString::dot(m_cellp->name(), ".", nodep->inlinedDots());
nodep->inlinedDots(newdots);
@ -433,7 +433,7 @@ private:
}
iterateChildren(nodep);
}
virtual void visit(AstNodeFTaskRef* nodep) VL_OVERRIDE {
virtual void visit(AstNodeFTaskRef* nodep) override {
// Track what scope it was originally under so V3LinkDot can resolve it
string newdots = VString::dot(m_cellp->name(), ".", nodep->inlinedDots());
nodep->inlinedDots(newdots);
@ -445,9 +445,9 @@ private:
}
// Not needed, as V3LinkDot doesn't care about typedefs
// virtual void visit(AstRefDType* nodep) VL_OVERRIDE {}
// virtual void visit(AstRefDType* nodep) override {}
virtual void visit(AstScopeName* nodep) VL_OVERRIDE {
virtual void visit(AstScopeName* nodep) override {
// If there's a %m in the display text, we add a special node that will contain the name()
// Similar code in V3Begin
// To keep correct visual order, must add before other Text's
@ -461,12 +461,12 @@ private:
if (afterp) nodep->scopeEntrp(afterp);
iterateChildren(nodep);
}
virtual void visit(AstCoverDecl* nodep) VL_OVERRIDE {
virtual void visit(AstCoverDecl* nodep) override {
// Fix path in coverage statements
nodep->hier(VString::dot(m_cellp->prettyName(), ".", nodep->hier()));
iterateChildren(nodep);
}
virtual void visit(AstNode* nodep) VL_OVERRIDE { iterateChildren(nodep); }
virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
public:
// CONSTRUCTORS
@ -508,11 +508,11 @@ private:
VL_DEBUG_FUNC; // Declare debug()
// VISITORS
virtual void visit(AstNetlist* nodep) VL_OVERRIDE {
virtual void visit(AstNetlist* nodep) override {
// Iterate modules backwards, in bottom-up order. Required!
iterateChildrenBackwards(nodep);
}
virtual void visit(AstIfaceRefDType* nodep) VL_OVERRIDE {
virtual void visit(AstIfaceRefDType* nodep) override {
if (nodep->user5()) {
// The cell has been removed so let's make sure we don't leave a reference to it
// This dtype may still be in use by the AstAssignVarScope created earlier
@ -520,7 +520,7 @@ private:
nodep->cellp(NULL);
}
}
virtual void visit(AstNodeModule* nodep) VL_OVERRIDE {
virtual void visit(AstNodeModule* nodep) override {
AstNodeModule* origModp = m_modp;
{
m_modp = nodep;
@ -528,7 +528,7 @@ private:
}
m_modp = origModp;
}
virtual void visit(AstCell* nodep) VL_OVERRIDE {
virtual void visit(AstCell* nodep) override {
if (nodep->modp()->user1()) { // Marked with inline request
UINFO(5, " Inline CELL " << nodep << endl);
UINFO(5, " To MOD " << m_modp << endl);
@ -608,9 +608,9 @@ private:
}
//--------------------
virtual void visit(AstNodeMath*) VL_OVERRIDE {} // Accelerate
virtual void visit(AstNodeStmt*) VL_OVERRIDE {} // Accelerate
virtual void visit(AstNode* nodep) VL_OVERRIDE { iterateChildren(nodep); }
virtual void visit(AstNodeMath*) override {} // Accelerate
virtual void visit(AstNodeStmt*) override {} // Accelerate
virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
public:
// CONSTRUCTORS
@ -639,11 +639,11 @@ private:
VL_DEBUG_FUNC; // Declare debug()
// VISITORS
virtual void visit(AstNetlist* nodep) VL_OVERRIDE { iterateChildren(nodep); }
virtual void visit(AstModule* nodep) VL_OVERRIDE {
virtual void visit(AstNetlist* nodep) override { iterateChildren(nodep); }
virtual void visit(AstModule* nodep) override {
if (nodep->isTop()) { iterateChildren(nodep); }
}
virtual void visit(AstCell* nodep) VL_OVERRIDE {
virtual void visit(AstCell* nodep) override {
string oldScope = m_scope;
if (m_scope.empty()) {
m_scope = nodep->name();
@ -677,7 +677,7 @@ private:
m_scope = oldScope;
}
virtual void visit(AstAssignVarScope* nodep) VL_OVERRIDE {
virtual void visit(AstAssignVarScope* nodep) override {
// Reference
AstVarRef* reflp = VN_CAST(nodep->lhsp(), VarRef);
// What the reference refers to
@ -702,9 +702,9 @@ private:
cellp->addIntfRefp(new AstIntfRef(varlp->fileline(), alias));
}
//--------------------
virtual void visit(AstNodeMath*) VL_OVERRIDE {} // Accelerate
virtual void visit(AstNodeStmt*) VL_OVERRIDE {} // Accelerate
virtual void visit(AstNode* nodep) VL_OVERRIDE { iterateChildren(nodep); }
virtual void visit(AstNodeMath*) override {} // Accelerate
virtual void visit(AstNodeStmt*) override {} // Accelerate
virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
public:
// CONSTRUCTORS

30
src/V3Inst.cpp
View File

@ -48,7 +48,7 @@ private:
VL_DEBUG_FUNC; // Declare debug()
// VISITORS
virtual void visit(AstCell* nodep) VL_OVERRIDE {
virtual void visit(AstCell* nodep) override {
UINFO(4, " CELL " << nodep << endl);
m_cellp = nodep;
// VV***** We reset user1p() on each cell!!!
@ -56,7 +56,7 @@ private:
iterateChildren(nodep);
m_cellp = NULL;
}
virtual void visit(AstPin* nodep) VL_OVERRIDE {
virtual void visit(AstPin* nodep) override {
// PIN(p,expr) -> ASSIGNW(VARXREF(p),expr) (if sub's input)
// or ASSIGNW(expr,VARXREF(p)) (if sub's output)
UINFO(4, " PIN " << nodep << endl);
@ -113,7 +113,7 @@ private:
VL_DO_DANGLING(nodep->unlinkFrBack()->deleteTree(), nodep);
}
virtual void visit(AstUdpTable* nodep) VL_OVERRIDE {
virtual void visit(AstUdpTable* nodep) override {
if (!v3Global.opt.bboxUnsup()) {
// If we support primitives, update V3Undriven to remove special case
nodep->v3warn(E_UNSUPPORTED, "Unsupported: Verilog 1995 UDP Tables. "
@ -122,12 +122,12 @@ private:
}
// Save some time
virtual void visit(AstNodeMath*) VL_OVERRIDE {}
virtual void visit(AstNodeAssign*) VL_OVERRIDE {}
virtual void visit(AstAlways*) VL_OVERRIDE {}
virtual void visit(AstNodeMath*) override {}
virtual void visit(AstNodeAssign*) override {}
virtual void visit(AstAlways*) override {}
//--------------------
virtual void visit(AstNode* nodep) VL_OVERRIDE { iterateChildren(nodep); }
virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
public:
// CONSTRUCTORS
@ -151,15 +151,15 @@ private:
VL_DEBUG_FUNC; // Declare debug()
// VISITORS
virtual void visit(AstVar* nodep) VL_OVERRIDE {
virtual void visit(AstVar* nodep) override {
if (VN_IS(nodep->dtypep(), IfaceRefDType)) {
UINFO(8, " dm-1-VAR " << nodep << endl);
insert(nodep);
}
iterateChildren(nodep);
}
virtual void visit(AstNodeMath*) VL_OVERRIDE {} // Accelerate
virtual void visit(AstNode* nodep) VL_OVERRIDE { iterateChildren(nodep); }
virtual void visit(AstNodeMath*) override {} // Accelerate
virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
public:
// METHODS
@ -206,7 +206,7 @@ private:
VL_DEBUG_FUNC; // Declare debug()
// VISITORS
virtual void visit(AstVar* nodep) VL_OVERRIDE {
virtual void visit(AstVar* nodep) override {
if (VN_IS(nodep->dtypep(), UnpackArrayDType)
&& VN_IS(VN_CAST(nodep->dtypep(), UnpackArrayDType)->subDTypep(), IfaceRefDType)) {
UINFO(8, " dv-vec-VAR " << nodep << endl);
@ -242,7 +242,7 @@ private:
iterateChildren(nodep);
}
virtual void visit(AstCell* nodep) VL_OVERRIDE {
virtual void visit(AstCell* nodep) override {
UINFO(4, " CELL " << nodep << endl);
// Find submodule vars
UASSERT_OBJ(nodep->modp(), nodep, "Unlinked");
@ -318,7 +318,7 @@ private:
}
}
virtual void visit(AstPin* nodep) VL_OVERRIDE {
virtual void visit(AstPin* nodep) override {
// Any non-direct pins need reconnection with a part-select
if (!nodep->exprp()) return; // No-connect
if (m_cellRangep) {
@ -461,8 +461,8 @@ private:
}
//--------------------
virtual void visit(AstNodeMath*) VL_OVERRIDE {} // Accelerate
virtual void visit(AstNode* nodep) VL_OVERRIDE { iterateChildren(nodep); }
virtual void visit(AstNodeMath*) override {} // Accelerate
virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
public:
// CONSTRUCTORS

24
src/V3InstrCount.cpp
View File

@ -119,7 +119,7 @@ private:
}
// VISITORS
virtual void visit(AstNodeSel* nodep) VL_OVERRIDE {
virtual void visit(AstNodeSel* nodep) override {
// This covers both AstArraySel and AstWordSel
//
// If some vector is a bazillion dwords long, and we're selecting 1
@ -130,7 +130,7 @@ private:
VisitBase vb(this, nodep);
iterateAndNextNull(nodep->bitp());
}
virtual void visit(AstSel* nodep) VL_OVERRIDE {
virtual void visit(AstSel* nodep) override {
// Similar to AstNodeSel above, a small select into a large vector
// is not expensive. Count the cost of the AstSel itself (scales with
// its width) and the cost of the lsbp() and widthp() nodes, but not
@ -139,13 +139,13 @@ private:
iterateAndNextNull(nodep->lsbp());
iterateAndNextNull(nodep->widthp());
}
virtual void visit(AstSliceSel* nodep) VL_OVERRIDE { // LCOV_EXCL_LINE
virtual void visit(AstSliceSel* nodep) override { // LCOV_EXCL_LINE
nodep->v3fatalSrc("AstSliceSel unhandled");
}
virtual void visit(AstMemberSel* nodep) VL_OVERRIDE { // LCOV_EXCL_LINE
virtual void visit(AstMemberSel* nodep) override { // LCOV_EXCL_LINE
nodep->v3fatalSrc("AstMemberSel unhandled");
}
virtual void visit(AstConcat* nodep) VL_OVERRIDE {
virtual void visit(AstConcat* nodep) override {
// Nop.
//
// Ignore concat. The problem with counting concat is that when we
@ -165,7 +165,7 @@ private:
// the widths of the operands (ignored here).
markCost(nodep);
}
virtual void visit(AstNodeIf* nodep) VL_OVERRIDE {
virtual void visit(AstNodeIf* nodep) override {
VisitBase vb(this, nodep);
iterateAndNextNull(nodep->condp());
uint32_t savedCount = m_instrCount;
@ -190,7 +190,7 @@ private:
if (nodep->ifsp()) nodep->ifsp()->user4(0); // Don't dump it
}
}
virtual void visit(AstNodeCond* nodep) VL_OVERRIDE {
virtual void visit(AstNodeCond* nodep) override {
// Just like if/else above, the ternary operator only evaluates
// one of the two expressions, so only count the max.
VisitBase vb(this, nodep);
@ -215,7 +215,7 @@ private:
if (nodep->expr2p()) nodep->expr2p()->user4(0); // Don't dump it
}
}
virtual void visit(AstActive* nodep) VL_OVERRIDE {
virtual void visit(AstActive* nodep) override {
// You'd think that the OrderLogicVertex's would be disjoint trees
// of stuff in the AST, but it isn't so: V3Order makes an
// OrderLogicVertex for each ACTIVE, and then also makes an
@ -231,14 +231,14 @@ private:
markCost(nodep);
UASSERT_OBJ(nodep == m_startNodep, nodep, "Multiple actives, or not start node");
}
virtual void visit(AstNodeCCall* nodep) VL_OVERRIDE {
virtual void visit(AstNodeCCall* nodep) override {
VisitBase vb(this, nodep);
iterateChildren(nodep);
m_tracingCall = true;
iterate(nodep->funcp());
UASSERT_OBJ(!m_tracingCall, nodep, "visit(AstCFunc) should have cleared m_tracingCall.");
}
virtual void visit(AstCFunc* nodep) VL_OVERRIDE {
virtual void visit(AstCFunc* nodep) override {
// Don't count a CFunc other than by tracing a call or counting it
// from the root
UASSERT_OBJ(m_tracingCall || nodep == m_startNodep, nodep,
@ -252,7 +252,7 @@ private:
}
m_inCFunc = saved_inCFunc;
}
virtual void visit(AstNode* nodep) VL_OVERRIDE {
virtual void visit(AstNode* nodep) override {
VisitBase vb(this, nodep);
iterateChildren(nodep);
}
@ -285,7 +285,7 @@ public:
private:
// METHODS
string indent() { return string(m_depth, ':') + " "; }
virtual void visit(AstNode* nodep) VL_OVERRIDE {
virtual void visit(AstNode* nodep) override {
++m_depth;
if (unsigned costPlus1 = nodep->user4()) {
*m_osp << " " << indent() << "cost " << std::setw(6) << std::left << (costPlus1 - 1)

36
src/V3Life.cpp
View File

@ -294,7 +294,7 @@ private:
VL_DEBUG_FUNC; // Declare debug()
// VISITORS
virtual void visit(AstVarRef* nodep) VL_OVERRIDE {
virtual void visit(AstVarRef* nodep) override {
// Consumption/generation of a variable,
// it's used so can't elim assignment before this use.
UASSERT_OBJ(nodep->varScopep(), nodep, "NULL");
@ -308,7 +308,7 @@ private:
VL_DO_DANGLING(m_lifep->varUsageReplace(vscp, nodep), nodep);
}
}
virtual void visit(AstNodeAssign* nodep) VL_OVERRIDE {
virtual void visit(AstNodeAssign* nodep) override {
// Collect any used variables first, as lhs may also be on rhs
// Similar code in V3Dead
vluint64_t lastEdit = AstNode::editCountGbl(); // When it was last edited
@ -328,13 +328,13 @@ private:
iterateAndNextNull(nodep->lhsp());
}
}
virtual void visit(AstAssignDly* nodep) VL_OVERRIDE {
virtual void visit(AstAssignDly* nodep) override {
// Don't treat as normal assign; V3Life doesn't understand time sense
iterateChildren(nodep);
}
//---- Track control flow changes
virtual void visit(AstNodeIf* nodep) VL_OVERRIDE {
virtual void visit(AstNodeIf* nodep) override {
UINFO(4, " IF " << nodep << endl);
// Condition is part of PREVIOUS block
iterateAndNextNull(nodep->condp());
@ -360,7 +360,7 @@ private:
VL_DO_DANGLING(delete elseLifep, elseLifep);
}
virtual void visit(AstWhile* nodep) VL_OVERRIDE {
virtual void visit(AstWhile* nodep) override {
// While's are a problem, as we don't allow loops in the graph. We
// may go around the cond/body multiple times. Thus a
// lifelication just in the body is ok, but we can't delete an
@ -389,7 +389,7 @@ private:
VL_DO_DANGLING(delete condLifep, condLifep);
VL_DO_DANGLING(delete bodyLifep, bodyLifep);
}
virtual void visit(AstJumpBlock* nodep) VL_OVERRIDE {
virtual void visit(AstJumpBlock* nodep) override {
// As with While's we can't predict if a JumpGo will kill us or not
// It's worse though as an IF(..., JUMPGO) may change the control flow.
// Just don't optimize blocks with labels; they're rare - so far.
@ -408,7 +408,7 @@ private:
bodyLifep->lifeToAbove();
VL_DO_DANGLING(delete bodyLifep, bodyLifep);
}
virtual void visit(AstNodeCCall* nodep) VL_OVERRIDE {
virtual void visit(AstNodeCCall* nodep) override {
// UINFO(4, " CCALL " << nodep << endl);
iterateChildren(nodep);
// Enter the function and trace it
@ -418,7 +418,7 @@ private:
iterate(nodep->funcp());
}
}
virtual void visit(AstCFunc* nodep) VL_OVERRIDE {
virtual void visit(AstCFunc* nodep) override {
// UINFO(4, " CFUNC " << nodep << endl);
if (!m_tracingCall && !nodep->entryPoint()) return;
m_tracingCall = false;
@ -427,17 +427,17 @@ private:
}
iterateChildren(nodep);
}
virtual void visit(AstUCFunc* nodep) VL_OVERRIDE {
virtual void visit(AstUCFunc* nodep) override {
m_sideEffect = true; // If appears on assign RHS, don't ever delete the assignment
iterateChildren(nodep);
}
virtual void visit(AstCMath* nodep) VL_OVERRIDE {
virtual void visit(AstCMath* nodep) override {
m_sideEffect = true; // If appears on assign RHS, don't ever delete the assignment
iterateChildren(nodep);
}
virtual void visit(AstVar*) VL_OVERRIDE {} // Don't want varrefs under it
virtual void visit(AstNode* nodep) VL_OVERRIDE { iterateChildren(nodep); }
virtual void visit(AstVar*) override {} // Don't want varrefs under it
virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
public:
// CONSTRUCTORS
@ -469,20 +469,20 @@ private:
LifeState* m_statep; // Current state
// VISITORS
virtual void visit(AstCFunc* nodep) VL_OVERRIDE {
virtual void visit(AstCFunc* nodep) override {
if (nodep->entryPoint()) {
// Usage model 1: Simulate all C code, doing lifetime analysis
LifeVisitor visitor(nodep, m_statep);
}
}
virtual void visit(AstNodeProcedure* nodep) VL_OVERRIDE {
virtual void visit(AstNodeProcedure* nodep) override {
// Usage model 2: Cleanup basic blocks
LifeVisitor visitor(nodep, m_statep);
}
virtual void visit(AstVar*) VL_OVERRIDE {} // Accelerate
virtual void visit(AstNodeStmt*) VL_OVERRIDE {} // Accelerate
virtual void visit(AstNodeMath*) VL_OVERRIDE {} // Accelerate
virtual void visit(AstNode* nodep) VL_OVERRIDE { iterateChildren(nodep); }
virtual void visit(AstVar*) override {} // Accelerate
virtual void visit(AstNodeStmt*) override {} // Accelerate
virtual void visit(AstNodeMath*) override {} // Accelerate
virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
public:
// CONSTRUCTORS

44
src/V3LifePost.cpp
View File

@ -34,8 +34,8 @@
#include "V3Stats.h"
#include "V3Ast.h"
#include <memory> // for vl_unique_ptr -> auto_ptr or unique_ptr
#include VL_INCLUDE_UNORDERED_MAP
#include <memory> // for std::unique_ptr -> auto_ptr or unique_ptr
#include <unordered_map>
//######################################################################
// LifePost class functions
@ -53,7 +53,7 @@ private:
VL_DEBUG_FUNC; // Declare debug()
// VISITORS
virtual void visit(AstVarRef* nodep) VL_OVERRIDE {
virtual void visit(AstVarRef* nodep) override {
AstVarScope* vscp = nodep->varScopep();
UASSERT_OBJ(vscp, nodep, "Scope not assigned");
if (AstVarScope* newvscp = reinterpret_cast<AstVarScope*>(vscp->user4p())) {
@ -63,11 +63,11 @@ private:
VL_DO_DANGLING(nodep->deleteTree(), nodep);
}
}
virtual void visit(AstNodeModule* nodep) VL_OVERRIDE {
virtual void visit(AstNodeModule* nodep) override {
// Only track the top scopes, not lower level functions
if (nodep->isTop()) iterateChildren(nodep);
}
virtual void visit(AstNodeCCall* nodep) VL_OVERRIDE {
virtual void visit(AstNodeCCall* nodep) override {
iterateChildren(nodep);
if (!nodep->funcp()->entryPoint()) {
// Enter the function and trace it
@ -75,18 +75,18 @@ private:
iterate(nodep->funcp());
}
}
virtual void visit(AstExecGraph* nodep) VL_OVERRIDE {
virtual void visit(AstExecGraph* nodep) override {
// Can just iterate across the MTask bodies in any order. Order
// isn't important for LifePostElimVisitor's simple substitution.
iterateChildren(nodep);
}
virtual void visit(AstCFunc* nodep) VL_OVERRIDE {
virtual void visit(AstCFunc* nodep) override {
if (!m_tracingCall && !nodep->entryPoint()) return;
m_tracingCall = false;
iterateChildren(nodep);
}
virtual void visit(AstVar*) VL_OVERRIDE {} // Don't want varrefs under it
virtual void visit(AstNode* nodep) VL_OVERRIDE { iterateChildren(nodep); }
virtual void visit(AstVar*) override {} // Don't want varrefs under it
virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
public:
// CONSTRUCTORS
@ -151,16 +151,16 @@ private:
// Map each varscope to one or more locations where it's accessed.
// These maps will not include any ASSIGNPOST accesses:
typedef vl_unordered_map<const AstVarScope*, std::set<LifeLocation>> LocMap;
typedef std::unordered_map<const AstVarScope*, std::set<LifeLocation>> LocMap;
LocMap m_reads; // VarScope read locations
LocMap m_writes; // VarScope write locations
// Map each dly var to its AstAssignPost* node and the location thereof
typedef vl_unordered_map<const AstVarScope*, LifePostLocation> PostLocMap;
typedef std::unordered_map<const AstVarScope*, LifePostLocation> PostLocMap;
PostLocMap m_assignposts; // AssignPost dly var locations
const V3Graph* m_mtasksGraphp; // Mtask tracking graph
vl_unique_ptr<GraphPathChecker> m_checker;
std::unique_ptr<GraphPathChecker> m_checker;
// METHODS
VL_DEBUG_FUNC; // Declare debug()
@ -257,7 +257,7 @@ private:
}
// VISITORS
virtual void visit(AstTopScope* nodep) VL_OVERRIDE {
virtual void visit(AstTopScope* nodep) override {
AstNode::user4ClearTree(); // user4p() used on entire tree
// First, build maps of every location (mtask and sequence
@ -281,7 +281,7 @@ private:
// Replace any node4p varscopes with the new scope
LifePostElimVisitor visitor(nodep);
}
virtual void visit(AstVarRef* nodep) VL_OVERRIDE {
virtual void visit(AstVarRef* nodep) override {
// Consumption/generation of a variable,
AstVarScope* vscp = nodep->varScopep();
UASSERT_OBJ(vscp, nodep, "Scope not assigned");
@ -293,14 +293,14 @@ private:
m_reads[vscp].insert(loc);
}
}
virtual void visit(AstAssignPre* nodep) VL_OVERRIDE {
virtual void visit(AstAssignPre* nodep) override {
// Do not record varrefs within assign pre.
//
// The pre-assignment into the dly var should not count as its
// first write; we only want to consider reads and writes that
// would still happen if the dly var were eliminated.
}
virtual void visit(AstAssignPost* nodep) VL_OVERRIDE {
virtual void visit(AstAssignPost* nodep) override {
// Don't record ASSIGNPOST in the read/write maps, record them in a
// separate map
if (AstVarRef* rhsp = VN_CAST(nodep->rhsp(), VarRef)) {
@ -312,11 +312,11 @@ private:
m_assignposts[dlyVarp] = LifePostLocation(loc, nodep);
}
}
virtual void visit(AstNodeModule* nodep) VL_OVERRIDE {
virtual void visit(AstNodeModule* nodep) override {
// Only track the top scopes, not lower level functions
if (nodep->isTop()) iterateChildren(nodep);
}
virtual void visit(AstNodeCCall* nodep) VL_OVERRIDE {
virtual void visit(AstNodeCCall* nodep) override {
iterateChildren(nodep);
if (!nodep->funcp()->entryPoint()) {
// Enter the function and trace it
@ -324,7 +324,7 @@ private:
iterate(nodep->funcp());
}
}
virtual void visit(AstExecGraph* nodep) VL_OVERRIDE {
virtual void visit(AstExecGraph* nodep) override {
// Treat the ExecGraph like a call to each mtask body
m_mtasksGraphp = nodep->depGraphp();
for (V3GraphVertex* mtaskVxp = m_mtasksGraphp->verticesBeginp(); mtaskVxp;
@ -336,14 +336,14 @@ private:
}
m_execMTaskp = NULL;
}
virtual void visit(AstCFunc* nodep) VL_OVERRIDE {
virtual void visit(AstCFunc* nodep) override {
if (!m_tracingCall && !nodep->entryPoint()) return;
m_tracingCall = false;
iterateChildren(nodep);
}
//-----
virtual void visit(AstVar*) VL_OVERRIDE {} // Don't want varrefs under it
virtual void visit(AstNode* nodep) VL_OVERRIDE { iterateChildren(nodep); }
virtual void visit(AstVar*) override {} // Don't want varrefs under it
virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
public:
// CONSTRUCTORS

22
src/V3LinkCells.cpp
View File

@ -36,7 +36,7 @@
#include <algorithm>
#include <map>
#include <vector>
#include VL_INCLUDE_UNORDERED_SET
#include <unordered_set>
//######################################################################
// Graph subclasses
@ -114,7 +114,7 @@ private:
LinkCellsGraph m_graph; // Linked graph of all cell interconnects
LibraryVertex* m_libVertexp; // Vertex at root of all libraries
V3GraphVertex* m_topVertexp; // Vertex of top module
vl_unordered_set<string> m_declfnWarned; // Files we issued DECLFILENAME on
std::unordered_set<string> m_declfnWarned; // Files we issued DECLFILENAME on
string m_origTopModuleName; // original name of the top module
VL_DEBUG_FUNC; // Declare debug()
@ -160,7 +160,7 @@ private:
}
// VISITs
virtual void visit(AstNetlist* nodep) VL_OVERRIDE {
virtual void visit(AstNetlist* nodep) override {
AstNode::user1ClearTree();
readModNames();
iterateChildren(nodep);
@ -193,7 +193,7 @@ private:
<< "' was not found in design.");
}
}
virtual void visit(AstNodeModule* nodep) VL_OVERRIDE {
virtual void visit(AstNodeModule* nodep) override {
// Module: Pick up modnames, so we can resolve cells later
AstNodeModule* oldModp = m_modp;
{
@ -235,7 +235,7 @@ private:
m_modp = oldModp;
}
virtual void visit(AstIfaceRefDType* nodep) VL_OVERRIDE {
virtual void visit(AstIfaceRefDType* nodep) override {
// Cell: Resolve its filename. If necessary, parse it.
UINFO(4, "Link IfaceRef: " << nodep << endl);
// Use findIdUpward instead of findIdFlat; it doesn't matter for now
@ -254,14 +254,14 @@ private:
// Note cannot do modport resolution here; modports are allowed underneath generates
}
virtual void visit(AstPackageImport* nodep) VL_OVERRIDE {
virtual void visit(AstPackageImport* nodep) override {
// Package Import: We need to do the package before the use of a package
iterateChildren(nodep);
UASSERT_OBJ(nodep->packagep(), nodep, "Unlinked package"); // Parser should set packagep
new V3GraphEdge(&m_graph, vertex(m_modp), vertex(nodep->packagep()), 1, false);
}
virtual void visit(AstBind* nodep) VL_OVERRIDE {
virtual void visit(AstBind* nodep) override {
// Bind: Has cells underneath that need to be put into the new
// module, and cells which need resolution
// TODO this doesn't allow bind to dotted hier names, that would require
@ -284,7 +284,7 @@ private:
pushDeletep(nodep->unlinkFrBack());
}
virtual void visit(AstCell* nodep) VL_OVERRIDE {
virtual void visit(AstCell* nodep) override {
// Cell: Resolve its filename. If necessary, parse it.
// Execute only once. Complication is that cloning may result in
// user1 being set (for pre-clone) so check if user1() matches the
@ -381,7 +381,7 @@ private:
if (nodep->modp()) {
nodep->modName(nodep->modp()->name());
// Note what pins exist
vl_unordered_set<string> ports; // Symbol table of all connected port names
std::unordered_set<string> ports; // Symbol table of all connected port names
for (AstPin* pinp = nodep->pinsp(); pinp; pinp = VN_CAST(pinp->nextp(), Pin)) {
if (pinp->name() == "")
pinp->v3error("Connect by position is illegal in .* connected cells");
@ -459,8 +459,8 @@ private:
// Accelerate the recursion
// Must do statements to support Generates, math though...
virtual void visit(AstNodeMath*) VL_OVERRIDE {}
virtual void visit(AstNode* nodep) VL_OVERRIDE { iterateChildren(nodep); }
virtual void visit(AstNodeMath*) override {}
virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
// METHODS
void readModNames() {

154
src/V3LinkDot.cpp
View File

@ -164,7 +164,7 @@ public:
void dump(const string& nameComment = "linkdot", bool force = false) {
if (debug() >= 6 || force) {
string filename = v3Global.debugFilename(nameComment) + ".txt";
const vl_unique_ptr<std::ofstream> logp(V3File::new_ofstream(filename));
const std::unique_ptr<std::ofstream> logp(V3File::new_ofstream(filename));
if (logp->fail()) v3fatal("Can't write " << filename);
std::ostream& os = *logp;
m_syms.dump(os);
@ -735,7 +735,7 @@ class LinkDotFindVisitor : public AstNVisitor {
}
// VISITs
virtual void visit(AstNetlist* nodep) VL_OVERRIDE {
virtual void visit(AstNetlist* nodep) override {
// Process $unit or other packages
// Not needed - dotted references not allowed from inside packages
// for (AstNodeModule* nodep = v3Global.rootp()->modulesp();
@ -763,8 +763,8 @@ class LinkDotFindVisitor : public AstNVisitor {
m_curSymp = m_modSymp = NULL;
}
}
virtual void visit(AstTypeTable*) VL_OVERRIDE {}
virtual void visit(AstNodeModule* nodep) VL_OVERRIDE {
virtual void visit(AstTypeTable*) override {}
virtual void visit(AstNodeModule* nodep) override {
// Called on top module from Netlist, other modules from the cell creating them,
// and packages
UINFO(8, " " << nodep << endl);
@ -837,7 +837,7 @@ class LinkDotFindVisitor : public AstNVisitor {
// Prep for next
m_packagep = NULL;
}
virtual void visit(AstClass* nodep) VL_OVERRIDE {
virtual void visit(AstClass* nodep) override {
UASSERT_OBJ(m_curSymp, nodep, "Class not under module/package/$unit");
UINFO(8, " " << nodep << endl);
string oldscope = m_scope;
@ -873,12 +873,12 @@ class LinkDotFindVisitor : public AstNVisitor {
m_blockNum = oldBlockNum;
m_modBlockNum = oldModBlockNum;
}
virtual void visit(AstScope* nodep) VL_OVERRIDE {
virtual void visit(AstScope* nodep) override {
UASSERT_OBJ(m_statep->forScopeCreation(), nodep,
"Scopes should only exist right after V3Scope");
// Ignored. Processed in next step
}
virtual void visit(AstCell* nodep) VL_OVERRIDE {
virtual void visit(AstCell* nodep) override {
UINFO(5, " CELL under " << m_scope << " is " << nodep << endl);
// Process XREFs/etc inside pins
if (nodep->recursive() && m_inRecursion) return;
@ -919,7 +919,7 @@ class LinkDotFindVisitor : public AstNVisitor {
m_paramNum = oldParamNum;
m_inRecursion = oldRecursion;
}
virtual void visit(AstCellInline* nodep) VL_OVERRIDE {
virtual void visit(AstCellInline* nodep) override {
UINFO(5, " CELLINLINE under " << m_scope << " is " << nodep << endl);
VSymEnt* aboveSymp = m_curSymp;
// If baz__DOT__foo__DOT__bar, we need to find baz__DOT__foo and add bar to it.
@ -939,11 +939,11 @@ class LinkDotFindVisitor : public AstNVisitor {
m_statep->insertInline(aboveSymp, m_modSymp, nodep, nodep->name());
}
}
virtual void visit(AstDefParam* nodep) VL_OVERRIDE {
virtual void visit(AstDefParam* nodep) override {
nodep->user1p(m_curSymp);
iterateChildren(nodep);
}
virtual void visit(AstNodeBlock* nodep) VL_OVERRIDE {
virtual void visit(AstNodeBlock* nodep) override {
UINFO(5, " " << nodep << endl);
// Rename "genblk"s to include a number
if (m_statep->forPrimary() && !nodep->user4SetOnce()) {
@ -986,7 +986,7 @@ class LinkDotFindVisitor : public AstNVisitor {
m_blockNum = oldNum;
}
}
virtual void visit(AstNodeFTask* nodep) VL_OVERRIDE {
virtual void visit(AstNodeFTask* nodep) override {
// NodeTask: Remember its name for later resolution
UINFO(5, " " << nodep << endl);
UASSERT_OBJ(m_curSymp && m_modSymp, nodep, "Function/Task not under module?");
@ -1026,7 +1026,7 @@ class LinkDotFindVisitor : public AstNVisitor {
}
m_curSymp = oldCurSymp;
}
virtual void visit(AstVar* nodep) VL_OVERRIDE {
virtual void visit(AstVar* nodep) override {
// Var: Remember its name for later resolution
UASSERT_OBJ(m_curSymp && m_modSymp, nodep, "Var not under module?");
iterateChildren(nodep);
@ -1151,27 +1151,27 @@ class LinkDotFindVisitor : public AstNVisitor {
}
}
}
virtual void visit(AstTypedef* nodep) VL_OVERRIDE {
virtual void visit(AstTypedef* nodep) override {
UASSERT_OBJ(m_curSymp, nodep, "Typedef not under module/package/$unit");
iterateChildren(nodep);
m_statep->insertSym(m_curSymp, nodep->name(), nodep, m_packagep);
}
virtual void visit(AstTypedefFwd* nodep) VL_OVERRIDE {
virtual void visit(AstTypedefFwd* nodep) override {
UASSERT_OBJ(m_curSymp, nodep, "Typedef not under module/package/$unit");
iterateChildren(nodep);
// No need to insert, only the real typedef matters, but need to track for errors
nodep->user1p(m_curSymp);
}
virtual void visit(AstParamTypeDType* nodep) VL_OVERRIDE {
virtual void visit(AstParamTypeDType* nodep) override {
UASSERT_OBJ(m_curSymp, nodep, "Parameter type not under module/package/$unit");
iterateChildren(nodep);
m_statep->insertSym(m_curSymp, nodep->name(), nodep, m_packagep);
}
virtual void visit(AstCFunc* nodep) VL_OVERRIDE {
virtual void visit(AstCFunc* nodep) override {
// For dotted resolution, ignore all AstVars under functions, otherwise shouldn't exist
UASSERT_OBJ(!m_statep->forScopeCreation(), nodep, "No CFuncs expected in tree yet");
}
virtual void visit(AstEnumItem* nodep) VL_OVERRIDE {
virtual void visit(AstEnumItem* nodep) override {
// EnumItem: Remember its name for later resolution
iterateChildren(nodep);
// Find under either a task or the module's vars
@ -1210,7 +1210,7 @@ class LinkDotFindVisitor : public AstNVisitor {
}
if (ins) m_statep->insertSym(m_curSymp, nodep->name(), nodep, m_packagep);
}
virtual void visit(AstPackageImport* nodep) VL_OVERRIDE {
virtual void visit(AstPackageImport* nodep) override {
UINFO(4, " Link: " << nodep << endl);
VSymEnt* srcp = m_statep->getNodeSym(nodep->packagep());
if (nodep->name() == "*") {
@ -1228,7 +1228,7 @@ class LinkDotFindVisitor : public AstNVisitor {
UINFO(9, " Link Done: " << nodep << endl);
// No longer needed, but can't delete until any multi-instantiated modules are expanded
}
virtual void visit(AstPackageExport* nodep) VL_OVERRIDE {
virtual void visit(AstPackageExport* nodep) override {
UINFO(9, " Link: " << nodep << endl);
VSymEnt* srcp = m_statep->getNodeSym(nodep->packagep());
if (nodep->name() != "*") {
@ -1242,13 +1242,13 @@ class LinkDotFindVisitor : public AstNVisitor {
UINFO(9, " Link Done: " << nodep << endl);
// No longer needed, but can't delete until any multi-instantiated modules are expanded
}
virtual void visit(AstPackageExportStarStar* nodep) VL_OVERRIDE {
virtual void visit(AstPackageExportStarStar* nodep) override {
UINFO(4, " Link: " << nodep << endl);
m_curSymp->exportStarStar(m_statep->symsp());
// No longer needed, but can't delete until any multi-instantiated modules are expanded
}
virtual void visit(AstNode* nodep) VL_OVERRIDE { iterateChildren(nodep); }
virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
public:
// CONSTRUCTORS
@ -1309,8 +1309,8 @@ private:
}
// VISITs
virtual void visit(AstTypeTable*) VL_OVERRIDE {}
virtual void visit(AstNodeModule* nodep) VL_OVERRIDE {
virtual void visit(AstTypeTable*) override {}
virtual void visit(AstNodeModule* nodep) override {
UINFO(5, " " << nodep << endl);
if (nodep->dead() || !nodep->user4()) {
UINFO(4, "Mark dead module " << nodep << endl);
@ -1327,7 +1327,7 @@ private:
m_modp = NULL;
}
}
virtual void visit(AstPin* nodep) VL_OVERRIDE {
virtual void visit(AstPin* nodep) override {
// Pin: Link to submodule's port
// Deal with implicit definitions - do before Resolve visitor as may
// be referenced above declaration
@ -1336,7 +1336,7 @@ private:
pinImplicitExprRecurse(nodep->exprp());
}
}
virtual void visit(AstDefParam* nodep) VL_OVERRIDE {
virtual void visit(AstDefParam* nodep) override {
iterateChildren(nodep);
nodep->v3warn(DEFPARAM, "Suggest replace defparam assignment with Verilog 2001 #(."
<< nodep->prettyName() << "(...etc...))");
@ -1356,7 +1356,7 @@ private:
VL_DO_DANGLING(nodep->unlinkFrBack()->deleteTree(), nodep);
}
}
virtual void visit(AstPort* nodep) VL_OVERRIDE {
virtual void visit(AstPort* nodep) override {
// Port: Stash the pin number
// Need to set pin numbers after varnames are created
// But before we do the final resolution based on names
@ -1384,14 +1384,14 @@ private:
// Ports not needed any more
VL_DO_DANGLING(nodep->unlinkFrBack()->deleteTree(), nodep);
}
virtual void visit(AstAssignW* nodep) VL_OVERRIDE {
virtual void visit(AstAssignW* nodep) override {
// Deal with implicit definitions
// We used to nodep->allowImplicit() here, but it turns out
// normal "assigns" can also make implicit wires. Yuk.
pinImplicitExprRecurse(nodep->lhsp());
iterateChildren(nodep);
}
virtual void visit(AstAssignAlias* nodep) VL_OVERRIDE {
virtual void visit(AstAssignAlias* nodep) override {
// tran gates need implicit creation
// As VarRefs don't exist in forPrimary, sanity check
UASSERT_OBJ(!m_statep->forPrimary(), nodep, "Assign aliases unexpected pre-dot");
@ -1403,13 +1403,13 @@ private:
}
iterateChildren(nodep);
}
virtual void visit(AstImplicit* nodep) VL_OVERRIDE {
virtual void visit(AstImplicit* nodep) override {
// Unsupported gates need implicit creation
pinImplicitExprRecurse(nodep);
// We're done with implicit gates
VL_DO_DANGLING(nodep->unlinkFrBack()->deleteTree(), nodep);
}
virtual void visit(AstTypedefFwd* nodep) VL_OVERRIDE {
virtual void visit(AstTypedefFwd* nodep) override {
VSymEnt* foundp = m_statep->getNodeSym(nodep)->findIdFallback(nodep->name());
if (!foundp && v3Global.opt.pedantic()) {
// We only check it was ever really defined in pedantic mode, as it
@ -1423,7 +1423,7 @@ private:
VL_DO_DANGLING(nodep->unlinkFrBack()->deleteTree(), nodep);
}
virtual void visit(AstNode* nodep) VL_OVERRIDE { iterateChildren(nodep); }
virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
public:
// CONSTRUCTORS
@ -1449,11 +1449,11 @@ class LinkDotScopeVisitor : public AstNVisitor {
int debug() { return LinkDotState::debug(); }
// VISITs
virtual void visit(AstNetlist* nodep) VL_OVERRIDE {
virtual void visit(AstNetlist* nodep) override {
// Recurse..., backward as must do packages before using packages
iterateChildrenBackwards(nodep);
}
virtual void visit(AstScope* nodep) VL_OVERRIDE {
virtual void visit(AstScope* nodep) override {
UINFO(8, " SCOPE " << nodep << endl);
UASSERT_OBJ(m_statep->forScopeCreation(), nodep,
"Scopes should only exist right after V3Scope");
@ -1465,7 +1465,7 @@ class LinkDotScopeVisitor : public AstNVisitor {
m_modSymp = NULL;
m_scopep = NULL;
}
virtual void visit(AstVarScope* nodep) VL_OVERRIDE {
virtual void visit(AstVarScope* nodep) override {
if (!nodep->varp()->isFuncLocal() && !nodep->varp()->isClassMember()) {
VSymEnt* varSymp = m_statep->insertSym(m_modSymp, nodep->varp()->name(), nodep, NULL);
if (nodep->varp()->isIfaceRef() && nodep->varp()->isIfaceParent()) {
@ -1501,12 +1501,12 @@ class LinkDotScopeVisitor : public AstNVisitor {
}
}
}
virtual void visit(AstNodeFTask* nodep) VL_OVERRIDE {
virtual void visit(AstNodeFTask* nodep) override {
VSymEnt* symp = m_statep->insertBlock(m_modSymp, nodep->name(), nodep, NULL);
symp->fallbackp(m_modSymp);
// No recursion, we don't want to pick up variables
}
virtual void visit(AstAssignAlias* nodep) VL_OVERRIDE {
virtual void visit(AstAssignAlias* nodep) override {
// Track aliases created by V3Inline; if we get a VARXREF(aliased_from)
// we'll need to replace it with a VARXREF(aliased_to)
if (debug() >= 9) nodep->dumpTree(cout, "- alias: ");
@ -1516,7 +1516,7 @@ class LinkDotScopeVisitor : public AstNVisitor {
fromVscp->user2p(toVscp);
iterateChildren(nodep);
}
virtual void visit(AstAssignVarScope* nodep) VL_OVERRIDE {
virtual void visit(AstAssignVarScope* nodep) override {
UINFO(5, "ASSIGNVARSCOPE " << nodep << endl);
if (debug() >= 9) nodep->dumpTree(cout, "- avs: ");
VSymEnt* rhsSymp;
@ -1574,10 +1574,10 @@ class LinkDotScopeVisitor : public AstNVisitor {
}
// For speed, don't recurse things that can't have scope
// Note we allow AstNodeStmt's as generates may be under them
virtual void visit(AstCell*) VL_OVERRIDE {}
virtual void visit(AstVar*) VL_OVERRIDE {}
virtual void visit(AstNodeMath*) VL_OVERRIDE {}
virtual void visit(AstNode* nodep) VL_OVERRIDE { iterateChildren(nodep); }
virtual void visit(AstCell*) override {}
virtual void visit(AstVar*) override {}
virtual void visit(AstNodeMath*) override {}
virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
public:
// CONSTRUCTORS
@ -1604,7 +1604,7 @@ class LinkDotIfaceVisitor : public AstNVisitor {
int debug() { return LinkDotState::debug(); }
// VISITs
virtual void visit(AstModport* nodep) VL_OVERRIDE {
virtual void visit(AstModport* nodep) override {
// Modport: Remember its name for later resolution
UINFO(5, " fiv: " << nodep << endl);
VSymEnt* oldCurSymp = m_curSymp;
@ -1616,7 +1616,7 @@ class LinkDotIfaceVisitor : public AstNVisitor {
}
m_curSymp = oldCurSymp;
}
virtual void visit(AstModportFTaskRef* nodep) VL_OVERRIDE {
virtual void visit(AstModportFTaskRef* nodep) override {
UINFO(5, " fif: " << nodep << endl);
iterateChildren(nodep);
if (nodep->isExport()) nodep->v3warn(E_UNSUPPORTED, "Unsupported: modport export");
@ -1639,7 +1639,7 @@ class LinkDotIfaceVisitor : public AstNVisitor {
VL_DO_DANGLING(pushDeletep(nodep), nodep);
}
}
virtual void visit(AstModportVarRef* nodep) VL_OVERRIDE {
virtual void visit(AstModportVarRef* nodep) override {
UINFO(5, " fiv: " << nodep << endl);
iterateChildren(nodep);
VSymEnt* symp = m_curSymp->findIdFallback(nodep->name());
@ -1664,7 +1664,7 @@ class LinkDotIfaceVisitor : public AstNVisitor {
VL_DO_DANGLING(pushDeletep(nodep), nodep);
}
}
virtual void visit(AstNode* nodep) VL_OVERRIDE { iterateChildren(nodep); }
virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
public:
// CONSTRUCTORS
@ -1845,12 +1845,12 @@ private:
}
// VISITs
virtual void visit(AstNetlist* nodep) VL_OVERRIDE {
virtual void visit(AstNetlist* nodep) override {
// Recurse..., backward as must do packages before using packages
iterateChildrenBackwards(nodep);
}
virtual void visit(AstTypeTable*) VL_OVERRIDE {}
virtual void visit(AstNodeModule* nodep) VL_OVERRIDE {
virtual void visit(AstTypeTable*) override {}
virtual void visit(AstNodeModule* nodep) override {
if (nodep->dead()) return;
checkNoDot(nodep);
UINFO(8, " " << nodep << endl);
@ -1864,7 +1864,7 @@ private:
m_modp = NULL;
m_ds.m_dotSymp = m_curSymp = m_modSymp = NULL;
}
virtual void visit(AstScope* nodep) VL_OVERRIDE {
virtual void visit(AstScope* nodep) override {
UINFO(8, " " << nodep << endl);
VSymEnt* oldModSymp = m_modSymp;
VSymEnt* oldCurSymp = m_curSymp;
@ -1875,14 +1875,14 @@ private:
m_modSymp = oldModSymp;
m_curSymp = oldCurSymp;
}
virtual void visit(AstCellInline* nodep) VL_OVERRIDE {
virtual void visit(AstCellInline* nodep) override {
checkNoDot(nodep);
if (m_statep->forScopeCreation() && !v3Global.opt.vpi()) {
nodep->unlinkFrBack();
VL_DO_DANGLING(pushDeletep(nodep), nodep);
}
}
virtual void visit(AstCell* nodep) VL_OVERRIDE {
virtual void visit(AstCell* nodep) override {
// Cell: Recurse inside or cleanup not founds
checkNoDot(nodep);
m_cellp = nodep;
@ -1911,7 +1911,7 @@ private:
// Parent module inherits child's publicity
// This is done bottom up in the LinkBotupVisitor stage
}
virtual void visit(AstPin* nodep) VL_OVERRIDE {
virtual void visit(AstPin* nodep) override {
// Pin: Link to submodule's port
checkNoDot(nodep);
iterateChildren(nodep);
@ -1950,7 +1950,7 @@ private:
}
// Early return() above when deleted
}
virtual void visit(AstDot* nodep) VL_OVERRIDE {
virtual void visit(AstDot* nodep) override {
// Legal under a DOT: AstDot, AstParseRef, AstPackageRef, AstNodeSel
// also a DOT can be part of an expression, but only above plus
// AstFTaskRef are legal children
@ -2017,7 +2017,7 @@ private:
m_ds.m_dotp = lastStates.m_dotp;
}
}
virtual void visit(AstParseRef* nodep) VL_OVERRIDE {
virtual void visit(AstParseRef* nodep) override {
if (nodep->user3SetOnce()) return;
UINFO(9, " linkPARSEREF " << m_ds.ascii() << " n=" << nodep << endl);
// m_curSymp is symbol table of outer expression
@ -2289,7 +2289,7 @@ private:
}
if (start) m_ds = lastStates;
}
virtual void visit(AstVarRef* nodep) VL_OVERRIDE {
virtual void visit(AstVarRef* nodep) override {
// VarRef: Resolve its reference
// ParseRefs are used the first pass (forPrimary) so we shouldn't get can't find
// errors here now that we have a VarRef.
@ -2309,7 +2309,7 @@ private:
}
}
}
virtual void visit(AstVarXRef* nodep) VL_OVERRIDE {
virtual void visit(AstVarXRef* nodep) override {
// VarRef: Resolve its reference
// We always link even if varp() is set, because the module we choose may change
// due to creating new modules, flattening, etc.
@ -2387,18 +2387,18 @@ private:
}
}
}
virtual void visit(AstEnumDType* nodep) VL_OVERRIDE {
virtual void visit(AstEnumDType* nodep) override {
iterateChildren(nodep);
AstRefDType* refdtypep = VN_CAST(nodep->subDTypep(), RefDType);
if (refdtypep && (nodep == refdtypep->subDTypep())) {
refdtypep->v3error("Self-referential enumerated type definition");
}
}
virtual void visit(AstEnumItemRef* nodep) VL_OVERRIDE {
virtual void visit(AstEnumItemRef* nodep) override {
// EnumItemRef may be under a dot. Should already be resolved.
iterateChildren(nodep);
}
virtual void visit(AstMethodCall* nodep) VL_OVERRIDE {
virtual void visit(AstMethodCall* nodep) override {
// Created here so should already be resolved.
DotStates lastStates = m_ds;
{
@ -2407,12 +2407,12 @@ private:
}
m_ds = lastStates;
}
virtual void visit(AstWith* nodep) VL_OVERRIDE {
virtual void visit(AstWith* nodep) override {
nodep->v3warn(E_UNSUPPORTED, "Unsupported: with statements");
nodep->replaceWith(nodep->funcrefp()->unlinkFrBack());
VL_DO_DANGLING(nodep->deleteTree(), nodep);
}
virtual void visit(AstVar* nodep) VL_OVERRIDE {
virtual void visit(AstVar* nodep) override {
checkNoDot(nodep);
iterateChildren(nodep);
if (m_statep->forPrimary() && nodep->isIO() && !m_ftaskp && !nodep->user4()) {
@ -2420,7 +2420,7 @@ private:
"Input/output/inout does not appear in port list: " << nodep->prettyNameQ());
}
}
virtual void visit(AstNodeFTaskRef* nodep) VL_OVERRIDE {
virtual void visit(AstNodeFTaskRef* nodep) override {
if (nodep->user3SetOnce()) return;
UINFO(8, " " << nodep << endl);
if (m_ds.m_dotp && m_ds.m_dotPos == DP_PACKAGE) {
@ -2576,7 +2576,7 @@ private:
}
m_ds = lastStates;
}
virtual void visit(AstSelBit* nodep) VL_OVERRIDE {
virtual void visit(AstSelBit* nodep) override {
if (nodep->user3SetOnce()) return;
iterateAndNextNull(nodep->lhsp());
if (m_ds.m_dotPos
@ -2603,7 +2603,7 @@ private:
VL_DO_DANGLING(pushDeletep(nodep), nodep);
}
}
virtual void visit(AstNodePreSel* nodep) VL_OVERRIDE {
virtual void visit(AstNodePreSel* nodep) override {
// Excludes simple AstSelBit, see above
if (nodep->user3SetOnce()) return;
if (m_ds.m_dotPos
@ -2623,11 +2623,11 @@ private:
}
m_ds = lastStates;
}
virtual void visit(AstMemberSel* nodep) VL_OVERRIDE {
virtual void visit(AstMemberSel* nodep) override {
// checkNoDot not appropriate, can be under a dot
iterateChildren(nodep);
}
virtual void visit(AstNodeBlock* nodep) VL_OVERRIDE {
virtual void visit(AstNodeBlock* nodep) override {
UINFO(5, " " << nodep << endl);
checkNoDot(nodep);
VSymEnt* oldCurSymp = m_curSymp;
@ -2641,7 +2641,7 @@ private:
m_ds.m_dotSymp = m_curSymp = oldCurSymp;
UINFO(5, " cur=se" << cvtToHex(m_curSymp) << endl);
}
virtual void visit(AstNodeFTask* nodep) VL_OVERRIDE {
virtual void visit(AstNodeFTask* nodep) override {
UINFO(5, " " << nodep << endl);
checkNoDot(nodep);
if (nodep->classMethod() && nodep->lifetime().isStatic()) {
@ -2659,7 +2659,7 @@ private:
m_ds.m_dotSymp = m_curSymp = oldCurSymp;
m_ftaskp = NULL;
}
virtual void visit(AstClass* nodep) VL_OVERRIDE {
virtual void visit(AstClass* nodep) override {
UINFO(5, " " << nodep << endl);
checkNoDot(nodep);
for (AstNode* itemp = nodep->membersp(); itemp; itemp = itemp->nextp()) {
@ -2697,7 +2697,7 @@ private:
m_curSymp = oldCurSymp;
m_modSymp = oldModSymp;
}
virtual void visit(AstRefDType* nodep) VL_OVERRIDE {
virtual void visit(AstRefDType* nodep) override {
// Resolve its reference
if (nodep->user3SetOnce()) return;
if (AstNode* cpackagep = nodep->classOrPackagep()) {
@ -2757,7 +2757,7 @@ private:
}
iterateChildren(nodep);
}
virtual void visit(AstDpiExport* nodep) VL_OVERRIDE {
virtual void visit(AstDpiExport* nodep) override {
// AstDpiExport: Make sure the function referenced exists, then dump it
iterateChildren(nodep);
checkNoDot(nodep);
@ -2775,35 +2775,35 @@ private:
}
VL_DO_DANGLING(nodep->unlinkFrBack()->deleteTree(), nodep);
}
virtual void visit(AstPackageImport* nodep) VL_OVERRIDE {
virtual void visit(AstPackageImport* nodep) override {
// No longer needed
checkNoDot(nodep);
VL_DO_DANGLING(nodep->unlinkFrBack()->deleteTree(), nodep);
}
virtual void visit(AstPackageExport* nodep) VL_OVERRIDE {
virtual void visit(AstPackageExport* nodep) override {
// No longer needed
checkNoDot(nodep);
VL_DO_DANGLING(nodep->unlinkFrBack()->deleteTree(), nodep);
}
virtual void visit(AstPackageExportStarStar* nodep) VL_OVERRIDE {
virtual void visit(AstPackageExportStarStar* nodep) override {
// No longer needed
checkNoDot(nodep);
VL_DO_DANGLING(nodep->unlinkFrBack()->deleteTree(), nodep);
}
virtual void visit(AstCellRef* nodep) VL_OVERRIDE {
virtual void visit(AstCellRef* nodep) override {
UINFO(5, " AstCellRef: " << nodep << " " << m_ds.ascii() << endl);
iterateChildren(nodep);
}
virtual void visit(AstCellArrayRef* nodep) VL_OVERRIDE {
virtual void visit(AstCellArrayRef* nodep) override {
UINFO(5, " AstCellArrayRef: " << nodep << " " << m_ds.ascii() << endl);
// Expression already iterated
}
virtual void visit(AstUnlinkedRef* nodep) VL_OVERRIDE {
virtual void visit(AstUnlinkedRef* nodep) override {
UINFO(5, " AstCellArrayRef: " << nodep << " " << m_ds.ascii() << endl);
// No need to iterate, if we have a UnlinkedVarXRef, we're already done
}
virtual void visit(AstNode* nodep) VL_OVERRIDE {
virtual void visit(AstNode* nodep) override {
checkNoDot(nodep);
iterateChildren(nodep);
}

32
src/V3LinkInc.cpp
View File

@ -86,12 +86,12 @@ private:
}
// VISITORS
virtual void visit(AstNodeModule* nodep) VL_OVERRIDE {
virtual void visit(AstNodeModule* nodep) override {
// Reset increments count
m_modIncrementsNum = 0;
iterateChildren(nodep);
}
virtual void visit(AstWhile* nodep) VL_OVERRIDE {
virtual void visit(AstWhile* nodep) override {
// Special, as statements need to be put in different places
// Preconditions insert first just before themselves (the normal
// rule for other statement types)
@ -108,7 +108,7 @@ private:
// Done the loop
m_insStmtp = NULL; // Next thing should be new statement
}
virtual void visit(AstNodeIf* nodep) VL_OVERRIDE {
virtual void visit(AstNodeIf* nodep) override {
m_insStmtp = nodep;
iterateAndNextNull(nodep->condp());
m_insStmtp = NULL;
@ -116,11 +116,11 @@ private:
iterateAndNextNull(nodep->elsesp());
m_insStmtp = NULL;
}
virtual void visit(AstNodeFor* nodep) VL_OVERRIDE { // LCOV_EXCL_LINE
virtual void visit(AstNodeFor* nodep) override { // LCOV_EXCL_LINE
nodep->v3fatalSrc(
"For statements should have been converted to while statements in V3Begin.cpp");
}
virtual void visit(AstNodeStmt* nodep) VL_OVERRIDE {
virtual void visit(AstNodeStmt* nodep) override {
if (!nodep->isStatement()) {
iterateChildren(nodep);
return;
@ -136,11 +136,11 @@ private:
iterateChildren(nodep);
m_unsupportedHere = false;
}
virtual void visit(AstLogAnd* nodep) VL_OVERRIDE { unsupported_visit(nodep); }
virtual void visit(AstLogOr* nodep) VL_OVERRIDE { unsupported_visit(nodep); }
virtual void visit(AstLogEq* nodep) VL_OVERRIDE { unsupported_visit(nodep); }
virtual void visit(AstLogIf* nodep) VL_OVERRIDE { unsupported_visit(nodep); }
virtual void visit(AstNodeCond* nodep) VL_OVERRIDE { unsupported_visit(nodep); }
virtual void visit(AstLogAnd* nodep) override { unsupported_visit(nodep); }
virtual void visit(AstLogOr* nodep) override { unsupported_visit(nodep); }
virtual void visit(AstLogEq* nodep) override { unsupported_visit(nodep); }
virtual void visit(AstLogIf* nodep) override { unsupported_visit(nodep); }
virtual void visit(AstNodeCond* nodep) override { unsupported_visit(nodep); }
void prepost_visit(AstNodeTriop* nodep) {
// Check if we are underneath a statement
if (!m_insStmtp) {
@ -225,12 +225,12 @@ private:
nodep->replaceWith(new AstVarRef(varrefp->fileline(), varp, true));
VL_DO_DANGLING(nodep->deleteTree(), nodep);
}
virtual void visit(AstPreAdd* nodep) VL_OVERRIDE { prepost_visit(nodep); }
virtual void visit(AstPostAdd* nodep) VL_OVERRIDE { prepost_visit(nodep); }
virtual void visit(AstPreSub* nodep) VL_OVERRIDE { prepost_visit(nodep); }
virtual void visit(AstPostSub* nodep) VL_OVERRIDE { prepost_visit(nodep); }
virtual void visit(AstGenFor* nodep) VL_OVERRIDE { iterateChildren(nodep); }
virtual void visit(AstNode* nodep) VL_OVERRIDE { iterateChildren(nodep); }
virtual void visit(AstPreAdd* nodep) override { prepost_visit(nodep); }
virtual void visit(AstPostAdd* nodep) override { prepost_visit(nodep); }
virtual void visit(AstPreSub* nodep) override { prepost_visit(nodep); }
virtual void visit(AstPostSub* nodep) override { prepost_visit(nodep); }
virtual void visit(AstGenFor* nodep) override { iterateChildren(nodep); }
virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
public:
// CONSTRUCTORS

26
src/V3LinkJump.cpp
View File

@ -117,7 +117,7 @@ private:
}
// VISITORS
virtual void visit(AstNodeModule* nodep) VL_OVERRIDE {
virtual void visit(AstNodeModule* nodep) override {
if (nodep->dead()) return;
AstNodeModule* origModp = m_modp;
int origRepeatNum = m_modRepeatNum;
@ -129,12 +129,12 @@ private:
m_modp = origModp;
m_modRepeatNum = origRepeatNum;
}
virtual void visit(AstNodeFTask* nodep) VL_OVERRIDE {
virtual void visit(AstNodeFTask* nodep) override {
m_ftaskp = nodep;
iterateChildren(nodep);
m_ftaskp = NULL;
}
virtual void visit(AstNodeBlock* nodep) VL_OVERRIDE {
virtual void visit(AstNodeBlock* nodep) override {
UINFO(8, " " << nodep << endl);
bool oldFork = m_inFork;
m_blockStack.push_back(nodep);
@ -145,7 +145,7 @@ private:
m_blockStack.pop_back();
m_inFork = oldFork;
}
virtual void visit(AstRepeat* nodep) VL_OVERRIDE {
virtual void visit(AstRepeat* nodep) override {
// So later optimizations don't need to deal with them,
// REPEAT(count,body) -> loop=count,WHILE(loop>0) { body, loop-- }
// Note var can be signed or unsigned based on original number.
@ -173,7 +173,7 @@ private:
nodep->replaceWith(newp);
VL_DO_DANGLING(nodep->deleteTree(), nodep);
}
virtual void visit(AstWait* nodep) VL_OVERRIDE {
virtual void visit(AstWait* nodep) override {
nodep->v3warn(E_UNSUPPORTED, "Unsupported: wait statements");
// Statements we'll just execute immediately; equivalent to if they followed this
if (AstNode* bodysp = nodep->bodysp()) {
@ -184,7 +184,7 @@ private:
}
VL_DO_DANGLING(nodep->deleteTree(), nodep);
}
virtual void visit(AstWhile* nodep) VL_OVERRIDE {
virtual void visit(AstWhile* nodep) override {
// Don't need to track AstRepeat/AstFor as they have already been converted
AstWhile* lastLoopp = m_loopp;
bool lastInc = m_loopInc;
@ -198,7 +198,7 @@ private:
m_loopInc = lastInc;
m_loopp = lastLoopp;
}
virtual void visit(AstReturn* nodep) VL_OVERRIDE {
virtual void visit(AstReturn* nodep) override {
iterateChildren(nodep);
AstFunc* funcp = VN_CAST(m_ftaskp, Func);
if (m_inFork) {
@ -226,7 +226,7 @@ private:
nodep->unlinkFrBack();
VL_DO_DANGLING(pushDeletep(nodep), nodep);
}
virtual void visit(AstBreak* nodep) VL_OVERRIDE {
virtual void visit(AstBreak* nodep) override {
iterateChildren(nodep);
if (!m_loopp) {
nodep->v3error("break isn't underneath a loop");
@ -238,7 +238,7 @@ private:
nodep->unlinkFrBack();
VL_DO_DANGLING(pushDeletep(nodep), nodep);
}
virtual void visit(AstContinue* nodep) VL_OVERRIDE {
virtual void visit(AstContinue* nodep) override {
iterateChildren(nodep);
if (!m_loopp) {
nodep->v3error("continue isn't underneath a loop");
@ -251,7 +251,7 @@ private:
nodep->unlinkFrBack();
VL_DO_DANGLING(pushDeletep(nodep), nodep);
}
virtual void visit(AstDisable* nodep) VL_OVERRIDE {
virtual void visit(AstDisable* nodep) override {
UINFO(8, " DISABLE " << nodep << endl);
iterateChildren(nodep);
AstNodeBlock* blockp = NULL;
@ -277,11 +277,11 @@ private:
VL_DO_DANGLING(pushDeletep(nodep), nodep);
// if (debug() >= 9) { UINFO(0, "\n"); beginp->dumpTree(cout, " labelo: "); }
}
virtual void visit(AstVarRef* nodep) VL_OVERRIDE {
virtual void visit(AstVarRef* nodep) override {
if (m_loopInc && nodep->varp()) nodep->varp()->usedLoopIdx(true);
}
virtual void visit(AstConst*) VL_OVERRIDE {}
virtual void visit(AstNode* nodep) VL_OVERRIDE { iterateChildren(nodep); }
virtual void visit(AstConst*) override {}
virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
public:
// CONSTRUCTORS

58
src/V3LinkLValue.cpp
View File

@ -43,7 +43,7 @@ private:
// VISITs
// Result handing
virtual void visit(AstNodeVarRef* nodep) VL_OVERRIDE {
virtual void visit(AstNodeVarRef* nodep) override {
// VarRef: LValue its reference
if (m_setRefLvalue) nodep->lvalue(true);
if (nodep->varp()) {
@ -56,7 +56,7 @@ private:
}
// Nodes that start propagating down lvalues
virtual void visit(AstPin* nodep) VL_OVERRIDE {
virtual void visit(AstPin* nodep) override {
if (nodep->modVarp() && nodep->modVarp()->isWritable()) {
// When the varref's were created, we didn't know the I/O state
// Now that we do, and it's from a output, we know it's a lvalue
@ -67,7 +67,7 @@ private:
iterateChildren(nodep);
}
}
virtual void visit(AstNodeAssign* nodep) VL_OVERRIDE {
virtual void visit(AstNodeAssign* nodep) override {
bool last_setRefLvalue = m_setRefLvalue;
{
m_setRefLvalue = true;
@ -77,7 +77,7 @@ private:
}
m_setRefLvalue = last_setRefLvalue;
}
virtual void visit(AstFOpen* nodep) VL_OVERRIDE {
virtual void visit(AstFOpen* nodep) override {
bool last_setRefLvalue = m_setRefLvalue;
{
m_setRefLvalue = true;
@ -88,7 +88,7 @@ private:
}
m_setRefLvalue = last_setRefLvalue;
}
virtual void visit(AstFOpenMcd* nodep) VL_OVERRIDE {
virtual void visit(AstFOpenMcd* nodep) override {
bool last_setRefLvalue = m_setRefLvalue;
{
m_setRefLvalue = true;
@ -98,7 +98,7 @@ private:
}
m_setRefLvalue = last_setRefLvalue;
}
virtual void visit(AstFClose* nodep) VL_OVERRIDE {
virtual void visit(AstFClose* nodep) override {
bool last_setRefLvalue = m_setRefLvalue;
{
m_setRefLvalue = true;
@ -106,7 +106,7 @@ private:
}
m_setRefLvalue = last_setRefLvalue;
}
virtual void visit(AstFError* nodep) VL_OVERRIDE {
virtual void visit(AstFError* nodep) override {
bool last_setRefLvalue = m_setRefLvalue;
{
m_setRefLvalue = true;
@ -115,7 +115,7 @@ private:
}
m_setRefLvalue = last_setRefLvalue;
}
virtual void visit(AstFFlush* nodep) VL_OVERRIDE {
virtual void visit(AstFFlush* nodep) override {
bool last_setRefLvalue = m_setRefLvalue;
{
m_setRefLvalue = true;
@ -123,7 +123,7 @@ private:
}
m_setRefLvalue = last_setRefLvalue;
}
virtual void visit(AstFGetC* nodep) VL_OVERRIDE {
virtual void visit(AstFGetC* nodep) override {
bool last_setRefLvalue = m_setRefLvalue;
{
m_setRefLvalue = true;
@ -131,7 +131,7 @@ private:
}
m_setRefLvalue = last_setRefLvalue;
}
virtual void visit(AstFGetS* nodep) VL_OVERRIDE {
virtual void visit(AstFGetS* nodep) override {
bool last_setRefLvalue = m_setRefLvalue;
{
m_setRefLvalue = true;
@ -140,7 +140,7 @@ private:
}
m_setRefLvalue = last_setRefLvalue;
}
virtual void visit(AstFRead* nodep) VL_OVERRIDE {
virtual void visit(AstFRead* nodep) override {
bool last_setRefLvalue = m_setRefLvalue;
{
m_setRefLvalue = true;
@ -149,7 +149,7 @@ private:
}
m_setRefLvalue = last_setRefLvalue;
}
virtual void visit(AstFScanF* nodep) VL_OVERRIDE {
virtual void visit(AstFScanF* nodep) override {
bool last_setRefLvalue = m_setRefLvalue;
{
m_setRefLvalue = true;
@ -158,7 +158,7 @@ private:
}
m_setRefLvalue = last_setRefLvalue;
}
virtual void visit(AstFUngetC* nodep) VL_OVERRIDE {
virtual void visit(AstFUngetC* nodep) override {
bool last_setRefLvalue = m_setRefLvalue;
{
m_setRefLvalue = true;
@ -166,7 +166,7 @@ private:
}
m_setRefLvalue = last_setRefLvalue;
}
virtual void visit(AstSScanF* nodep) VL_OVERRIDE {
virtual void visit(AstSScanF* nodep) override {
bool last_setRefLvalue = m_setRefLvalue;
{
m_setRefLvalue = true;
@ -174,13 +174,13 @@ private:
}
m_setRefLvalue = last_setRefLvalue;
}
virtual void visit(AstSysIgnore* nodep) VL_OVERRIDE {
virtual void visit(AstSysIgnore* nodep) override {
// Can't know if lvalue or not; presume so as stricter
bool last_setRefLvalue = m_setRefLvalue;
iterateChildren(nodep);
m_setRefLvalue = last_setRefLvalue;
}
virtual void visit(AstReadMem* nodep) VL_OVERRIDE {
virtual void visit(AstReadMem* nodep) override {
bool last_setRefLvalue = m_setRefLvalue;
{
m_setRefLvalue = true;
@ -192,7 +192,7 @@ private:
}
m_setRefLvalue = last_setRefLvalue;
}
virtual void visit(AstValuePlusArgs* nodep) VL_OVERRIDE {
virtual void visit(AstValuePlusArgs* nodep) override {
bool last_setRefLvalue = m_setRefLvalue;
{
m_setRefLvalue = false;
@ -202,7 +202,7 @@ private:
}
m_setRefLvalue = last_setRefLvalue;
}
virtual void visit(AstSFormat* nodep) VL_OVERRIDE {
virtual void visit(AstSFormat* nodep) override {
bool last_setRefLvalue = m_setRefLvalue;
{
m_setRefLvalue = true;
@ -223,13 +223,13 @@ private:
}
m_setRefLvalue = last_setRefLvalue;
}
virtual void visit(AstPreAdd* nodep) VL_OVERRIDE { prepost_visit(nodep); }
virtual void visit(AstPostAdd* nodep) VL_OVERRIDE { prepost_visit(nodep); }
virtual void visit(AstPreSub* nodep) VL_OVERRIDE { prepost_visit(nodep); }
virtual void visit(AstPostSub* nodep) VL_OVERRIDE { prepost_visit(nodep); }
virtual void visit(AstPreAdd* nodep) override { prepost_visit(nodep); }
virtual void visit(AstPostAdd* nodep) override { prepost_visit(nodep); }
virtual void visit(AstPreSub* nodep) override { prepost_visit(nodep); }
virtual void visit(AstPostSub* nodep) override { prepost_visit(nodep); }
// Nodes that change LValue state
virtual void visit(AstSel* nodep) VL_OVERRIDE {
virtual void visit(AstSel* nodep) override {
bool last_setRefLvalue = m_setRefLvalue;
{
iterateAndNextNull(nodep->lhsp());
@ -240,7 +240,7 @@ private:
}
m_setRefLvalue = last_setRefLvalue;
}
virtual void visit(AstNodeSel* nodep) VL_OVERRIDE {
virtual void visit(AstNodeSel* nodep) override {
bool last_setRefLvalue = m_setRefLvalue;
{ // Only set lvalues on the from
iterateAndNextNull(nodep->lhsp());
@ -249,7 +249,7 @@ private:
}
m_setRefLvalue = last_setRefLvalue;
}
virtual void visit(AstCellArrayRef* nodep) VL_OVERRIDE {
virtual void visit(AstCellArrayRef* nodep) override {
bool last_setRefLvalue = m_setRefLvalue;
{ // selp is not an lvalue
m_setRefLvalue = false;
@ -257,7 +257,7 @@ private:
}
m_setRefLvalue = last_setRefLvalue;
}
virtual void visit(AstNodePreSel* nodep) VL_OVERRIDE {
virtual void visit(AstNodePreSel* nodep) override {
bool last_setRefLvalue = m_setRefLvalue;
{ // Only set lvalues on the from
iterateAndNextNull(nodep->lhsp());
@ -267,12 +267,12 @@ private:
}
m_setRefLvalue = last_setRefLvalue;
}
virtual void visit(AstNodeFTask* nodep) VL_OVERRIDE {
virtual void visit(AstNodeFTask* nodep) override {
m_ftaskp = nodep;
iterateChildren(nodep);
m_ftaskp = NULL;
}
virtual void visit(AstNodeFTaskRef* nodep) VL_OVERRIDE {
virtual void visit(AstNodeFTaskRef* nodep) override {
AstNode* pinp = nodep->pinsp();
AstNodeFTask* taskp = nodep->taskp();
// We'll deal with mismatching pins later
@ -294,7 +294,7 @@ private:
}
}
virtual void visit(AstNode* nodep) VL_OVERRIDE { iterateChildren(nodep); }
virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
public:
// CONSTRUCTORS

2
src/V3LinkLevel.cpp
View File

@ -174,7 +174,7 @@ void V3LinkLevel::wrapTopCell(AstNetlist* rootp) {
UASSERT_OBJ(newmodp && newmodp->isTop(), rootp, "No TOP module found to insert under");
// Find all duplicate signal names (if multitop)
typedef vl_unordered_set<std::string> NameSet;
typedef std::unordered_set<std::string> NameSet;
NameSet ioNames;
NameSet dupNames;
// For all modules, skipping over new top

50
src/V3LinkParse.cpp
View File

@ -102,7 +102,7 @@ private:
}
// VISITs
virtual void visit(AstNodeFTask* nodep) VL_OVERRIDE {
virtual void visit(AstNodeFTask* nodep) override {
V3Config::applyFTask(m_modp, nodep);
if (!nodep->user1SetOnce()) { // Process only once.
@ -112,7 +112,7 @@ private:
m_ftaskp = NULL;
}
}
virtual void visit(AstNodeFTaskRef* nodep) VL_OVERRIDE {
virtual void visit(AstNodeFTaskRef* nodep) override {
if (!nodep->user1SetOnce()) { // Process only once.
cleanFileline(nodep);
UINFO(5, " " << nodep << endl);
@ -122,20 +122,20 @@ private:
m_valueModp = upperValueModp;
}
}
virtual void visit(AstNodeDType* nodep) VL_OVERRIDE { visitIterateNodeDType(nodep); }
virtual void visit(AstEnumDType* nodep) VL_OVERRIDE {
virtual void visit(AstNodeDType* nodep) override { visitIterateNodeDType(nodep); }
virtual void visit(AstEnumDType* nodep) override {
if (nodep->name() == "") {
nodep->name(nameFromTypedef(nodep)); // Might still remain ""
}
visitIterateNodeDType(nodep);
}
virtual void visit(AstNodeUOrStructDType* nodep) VL_OVERRIDE {
virtual void visit(AstNodeUOrStructDType* nodep) override {
if (nodep->name() == "") {
nodep->name(nameFromTypedef(nodep)); // Might still remain ""
}
visitIterateNodeDType(nodep);
}
virtual void visit(AstEnumItem* nodep) VL_OVERRIDE {
virtual void visit(AstEnumItem* nodep) override {
// Expand ranges
cleanFileline(nodep);
iterateChildren(nodep);
@ -168,7 +168,7 @@ private:
}
}
virtual void visit(AstVar* nodep) VL_OVERRIDE {
virtual void visit(AstVar* nodep) override {
cleanFileline(nodep);
if (nodep->isParam() && !nodep->valuep()
&& nodep->fileline()->language() < V3LangCode::L1800_2009) {
@ -256,7 +256,7 @@ private:
}
}
virtual void visit(AstAttrOf* nodep) VL_OVERRIDE {
virtual void visit(AstAttrOf* nodep) override {
cleanFileline(nodep);
iterateChildren(nodep);
if (nodep->attrType() == AstAttrType::DT_PUBLIC) {
@ -325,7 +325,7 @@ private:
}
}
virtual void visit(AstAlwaysPublic* nodep) VL_OVERRIDE {
virtual void visit(AstAlwaysPublic* nodep) override {
// AlwaysPublic was attached under a var, but it's a statement that should be
// at the same level as the var
cleanFileline(nodep);
@ -340,7 +340,7 @@ private:
}
}
virtual void visit(AstDefImplicitDType* nodep) VL_OVERRIDE {
virtual void visit(AstDefImplicitDType* nodep) override {
cleanFileline(nodep);
UINFO(8, " DEFIMPLICIT " << nodep << endl);
// Must remember what names we've already created, and combine duplicates
@ -381,7 +381,7 @@ private:
VL_DO_DANGLING(nodep->deleteTree(), nodep);
}
virtual void visit(AstForeach* nodep) VL_OVERRIDE {
virtual void visit(AstForeach* nodep) override {
// FOREACH(array,loopvars,body)
// -> BEGIN(declare vars, loopa=lowest; WHILE(loopa<=highest, ... body))
// nodep->dumpTree(cout, "-foreach-old:");
@ -479,7 +479,7 @@ private:
VL_DO_DANGLING(nodep->deleteTree(), nodep);
}
virtual void visit(AstNodeModule* nodep) VL_OVERRIDE {
virtual void visit(AstNodeModule* nodep) override {
V3Config::applyModule(nodep);
AstNodeModule* origModp = m_modp;
@ -503,16 +503,16 @@ private:
iterateChildren(nodep);
m_valueModp = upperValueModp;
}
virtual void visit(AstNodeProcedure* nodep) VL_OVERRIDE { visitIterateNoValueMod(nodep); }
virtual void visit(AstAlways* nodep) VL_OVERRIDE {
virtual void visit(AstNodeProcedure* nodep) override { visitIterateNoValueMod(nodep); }
virtual void visit(AstAlways* nodep) override {
m_inAlways = true;
visitIterateNoValueMod(nodep);
m_inAlways = false;
}
virtual void visit(AstCover* nodep) VL_OVERRIDE { visitIterateNoValueMod(nodep); }
virtual void visit(AstRestrict* nodep) VL_OVERRIDE { visitIterateNoValueMod(nodep); }
virtual void visit(AstCover* nodep) override { visitIterateNoValueMod(nodep); }
virtual void visit(AstRestrict* nodep) override { visitIterateNoValueMod(nodep); }
virtual void visit(AstBegin* nodep) VL_OVERRIDE {
virtual void visit(AstBegin* nodep) override {
V3Config::applyCoverageBlock(m_modp, nodep);
cleanFileline(nodep);
AstNode* backp = nodep->backp();
@ -530,39 +530,39 @@ private:
}
iterateChildren(nodep);
}
virtual void visit(AstCase* nodep) VL_OVERRIDE {
virtual void visit(AstCase* nodep) override {
V3Config::applyCase(nodep);
cleanFileline(nodep);
iterateChildren(nodep);
}
virtual void visit(AstPrintTimeScale* nodep) VL_OVERRIDE {
virtual void visit(AstPrintTimeScale* nodep) override {
// Inlining may change hierarchy, so just save timescale where needed
cleanFileline(nodep);
iterateChildren(nodep);
nodep->name(m_modp->name());
nodep->timeunit(m_modp->timeunit());
}
virtual void visit(AstSFormatF* nodep) VL_OVERRIDE {
virtual void visit(AstSFormatF* nodep) override {
cleanFileline(nodep);
iterateChildren(nodep);
nodep->timeunit(m_modp->timeunit());
}
virtual void visit(AstTime* nodep) VL_OVERRIDE {
virtual void visit(AstTime* nodep) override {
cleanFileline(nodep);
iterateChildren(nodep);
nodep->timeunit(m_modp->timeunit());
}
virtual void visit(AstTimeD* nodep) VL_OVERRIDE {
virtual void visit(AstTimeD* nodep) override {
cleanFileline(nodep);
iterateChildren(nodep);
nodep->timeunit(m_modp->timeunit());
}
virtual void visit(AstTimeImport* nodep) VL_OVERRIDE {
virtual void visit(AstTimeImport* nodep) override {
cleanFileline(nodep);
iterateChildren(nodep);
nodep->timeunit(m_modp->timeunit());
}
virtual void visit(AstTimingControl* nodep) VL_OVERRIDE {
virtual void visit(AstTimingControl* nodep) override {
cleanFileline(nodep);
iterateChildren(nodep);
AstAlways* alwaysp = VN_CAST(nodep->backp(), Always);
@ -587,7 +587,7 @@ private:
VL_DO_DANGLING(nodep->unlinkFrBack()->deleteTree(), nodep);
}
virtual void visit(AstNode* nodep) VL_OVERRIDE {
virtual void visit(AstNode* nodep) override {
// Default: Just iterate
cleanFileline(nodep);
iterateChildren(nodep);

62
src/V3LinkResolve.cpp
View File

@ -61,7 +61,7 @@ private:
// TODO: Most of these visitors are here for historical reasons.
// TODO: ExpectDecriptor can move to data type resolution, and the rest
// TODO: could move to V3LinkParse to get them out of the way of elaboration
virtual void visit(AstNodeModule* nodep) VL_OVERRIDE {
virtual void visit(AstNodeModule* nodep) override {
// Module: Create sim table for entire module and iterate
UINFO(8, "MODULE " << nodep << endl);
if (nodep->dead()) return;
@ -79,7 +79,7 @@ private:
m_senitemCvtNum = origSenitemCvtNum;
m_lifetime = origLifetime;
}
virtual void visit(AstClass* nodep) VL_OVERRIDE {
virtual void visit(AstClass* nodep) override {
AstClass* origClassp = m_classp;
VLifetime origLifetime = m_lifetime;
{
@ -91,7 +91,7 @@ private:
m_classp = origClassp;
m_lifetime = origLifetime;
}
virtual void visit(AstInitial* nodep) VL_OVERRIDE {
virtual void visit(AstInitial* nodep) override {
iterateChildren(nodep);
// Initial assignments under function/tasks can just be simple
// assignments without the initial
@ -99,13 +99,13 @@ private:
VL_DO_DANGLING(nodep->replaceWith(nodep->bodysp()->unlinkFrBackWithNext()), nodep);
}
}
virtual void visit(AstNodeCoverOrAssert* nodep) VL_OVERRIDE {
virtual void visit(AstNodeCoverOrAssert* nodep) override {
if (m_assertp) nodep->v3error("Assert not allowed under another assert");
m_assertp = nodep;
iterateChildren(nodep);
m_assertp = NULL;
}
virtual void visit(AstVar* nodep) VL_OVERRIDE {
virtual void visit(AstVar* nodep) override {
iterateChildren(nodep);
if (m_classp && !nodep->isParam()) nodep->varType(AstVarType::MEMBER);
if (m_classp && nodep->isParam())
@ -124,13 +124,13 @@ private:
}
}
virtual void visit(AstNodeVarRef* nodep) VL_OVERRIDE {
virtual void visit(AstNodeVarRef* nodep) override {
// VarRef: Resolve its reference
if (nodep->varp()) { nodep->varp()->usedParam(true); }
iterateChildren(nodep);
}
virtual void visit(AstNodeFTask* nodep) VL_OVERRIDE {
virtual void visit(AstNodeFTask* nodep) override {
// NodeTask: Remember its name for later resolution
// Remember the existing symbol table scope
if (m_classp) nodep->classMethod(true);
@ -145,14 +145,14 @@ private:
m_lifetime = origLifetime;
if (nodep->dpiExport()) { nodep->scopeNamep(new AstScopeName(nodep->fileline())); }
}
virtual void visit(AstNodeFTaskRef* nodep) VL_OVERRIDE {
virtual void visit(AstNodeFTaskRef* nodep) override {
iterateChildren(nodep);
if (nodep->taskp() && (nodep->taskp()->dpiContext() || nodep->taskp()->dpiExport())) {
nodep->scopeNamep(new AstScopeName(nodep->fileline()));
}
}
virtual void visit(AstSenItem* nodep) VL_OVERRIDE {
virtual void visit(AstSenItem* nodep) override {
// Remove bit selects, and bark if it's not a simple variable
iterateChildren(nodep);
if (nodep->isClocked()) {
@ -219,7 +219,7 @@ private:
}
}
virtual void visit(AstNodePreSel* nodep) VL_OVERRIDE {
virtual void visit(AstNodePreSel* nodep) override {
if (!nodep->attrp()) {
iterateChildren(nodep);
// Constification may change the fromp() to a constant, which will lose the
@ -253,7 +253,7 @@ private:
}
}
virtual void visit(AstCaseItem* nodep) VL_OVERRIDE {
virtual void visit(AstCaseItem* nodep) override {
// Move default caseItems to the bottom of the list
// That saves us from having to search each case list twice, for non-defaults and defaults
iterateChildren(nodep);
@ -265,7 +265,7 @@ private:
}
}
virtual void visit(AstPragma* nodep) VL_OVERRIDE {
virtual void visit(AstPragma* nodep) override {
if (nodep->pragType() == AstPragmaType::HIER_BLOCK) {
UASSERT_OBJ(m_modp, nodep, "HIER_BLOCK not under a module");
// If this is hierarchical mode which is to create protect-lib,
@ -416,39 +416,39 @@ private:
if (filep && filep->varp()) filep->varp()->attrFileDescr(true);
}
virtual void visit(AstFOpen* nodep) VL_OVERRIDE {
virtual void visit(AstFOpen* nodep) override {
iterateChildren(nodep);
expectDescriptor(nodep, VN_CAST(nodep->filep(), NodeVarRef));
}
virtual void visit(AstFOpenMcd* nodep) VL_OVERRIDE {
virtual void visit(AstFOpenMcd* nodep) override {
iterateChildren(nodep);
expectDescriptor(nodep, VN_CAST(nodep->filep(), NodeVarRef));
}
virtual void visit(AstFClose* nodep) VL_OVERRIDE {
virtual void visit(AstFClose* nodep) override {
iterateChildren(nodep);
expectDescriptor(nodep, VN_CAST(nodep->filep(), NodeVarRef));
}
virtual void visit(AstFError* nodep) VL_OVERRIDE {
virtual void visit(AstFError* nodep) override {
iterateChildren(nodep);
expectDescriptor(nodep, VN_CAST(nodep->filep(), NodeVarRef));
}
virtual void visit(AstFEof* nodep) VL_OVERRIDE {
virtual void visit(AstFEof* nodep) override {
iterateChildren(nodep);
expectDescriptor(nodep, VN_CAST(nodep->filep(), NodeVarRef));
}
virtual void visit(AstFRead* nodep) VL_OVERRIDE {
virtual void visit(AstFRead* nodep) override {
iterateChildren(nodep);
expectDescriptor(nodep, VN_CAST(nodep->filep(), NodeVarRef));
}
virtual void visit(AstFScanF* nodep) VL_OVERRIDE {
virtual void visit(AstFScanF* nodep) override {
iterateChildren(nodep);
expectFormat(nodep, nodep->text(), nodep->exprsp(), true);
}
virtual void visit(AstSScanF* nodep) VL_OVERRIDE {
virtual void visit(AstSScanF* nodep) override {
iterateChildren(nodep);
expectFormat(nodep, nodep->text(), nodep->exprsp(), true);
}
virtual void visit(AstSFormatF* nodep) VL_OVERRIDE {
virtual void visit(AstSFormatF* nodep) override {
iterateChildren(nodep);
// Cleanup old-school displays without format arguments
if (!nodep->hasFormat()) {
@ -471,7 +471,7 @@ private:
}
}
virtual void visit(AstUdpTable* nodep) VL_OVERRIDE {
virtual void visit(AstUdpTable* nodep) override {
UINFO(5, "UDPTABLE " << nodep << endl);
if (!v3Global.opt.bboxUnsup()) {
// We don't warn until V3Inst, so that UDPs that are in libraries and
@ -501,23 +501,23 @@ private:
}
}
virtual void visit(AstScCtor* nodep) VL_OVERRIDE {
virtual void visit(AstScCtor* nodep) override {
// Constructor info means the module must remain public
m_modp->modPublic(true);
iterateChildren(nodep);
}
virtual void visit(AstScDtor* nodep) VL_OVERRIDE {
virtual void visit(AstScDtor* nodep) override {
// Destructor info means the module must remain public
m_modp->modPublic(true);
iterateChildren(nodep);
}
virtual void visit(AstScInt* nodep) VL_OVERRIDE {
virtual void visit(AstScInt* nodep) override {
// Special class info means the module must remain public
m_modp->modPublic(true);
iterateChildren(nodep);
}
virtual void visit(AstNode* nodep) VL_OVERRIDE { iterateChildren(nodep); }
virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
public:
// CONSTRUCTORS
@ -547,11 +547,11 @@ private:
VL_DEBUG_FUNC; // Declare debug()
// VISITs
virtual void visit(AstNetlist* nodep) VL_OVERRIDE {
virtual void visit(AstNetlist* nodep) override {
// Iterate modules backwards, in bottom-up order.
iterateChildrenBackwards(nodep);
}
virtual void visit(AstNodeModule* nodep) VL_OVERRIDE {
virtual void visit(AstNodeModule* nodep) override {
AstNodeModule* origModp = m_modp;
{
m_modp = nodep;
@ -559,13 +559,13 @@ private:
}
m_modp = origModp;
}
virtual void visit(AstCell* nodep) VL_OVERRIDE {
virtual void visit(AstCell* nodep) override {
// Parent module inherits child's publicity
if (nodep->modp()->modPublic()) m_modp->modPublic(true);
//** No iteration for speed
}
virtual void visit(AstNodeMath*) VL_OVERRIDE {} // Accelerate
virtual void visit(AstNode* nodep) VL_OVERRIDE { iterateChildren(nodep); }
virtual void visit(AstNodeMath*) override {} // Accelerate
virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
public:
// CONSTRUCTORS

14
src/V3Localize.cpp
View File

@ -72,7 +72,7 @@ private:
// See above
// METHODS
virtual void visit(AstVarRef* nodep) VL_OVERRIDE {
virtual void visit(AstVarRef* nodep) override {
// cppcheck-suppress unreadVariable // cppcheck 1.90 bug
VarFlags flags(nodep->varp());
if (flags.m_done) {
@ -80,7 +80,7 @@ private:
nodep->hierThis(true);
}
}
virtual void visit(AstNode* nodep) VL_OVERRIDE { iterateChildren(nodep); }
virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
public:
// CONSTRUCTORS
@ -145,11 +145,11 @@ private:
}
// VISITORS
virtual void visit(AstNetlist* nodep) VL_OVERRIDE {
virtual void visit(AstNetlist* nodep) override {
iterateChildren(nodep);
moveVars();
}
virtual void visit(AstCFunc* nodep) VL_OVERRIDE {
virtual void visit(AstCFunc* nodep) override {
UINFO(4, " CFUNC " << nodep << endl);
m_cfuncp = nodep;
searchFuncStmts(nodep->argsp());
@ -180,7 +180,7 @@ private:
}
}
virtual void visit(AstVar* nodep) VL_OVERRIDE {
virtual void visit(AstVar* nodep) override {
if (!nodep->isSigPublic() && !nodep->isPrimaryIO()
&& !m_cfuncp) { // Not already inside a function
UINFO(4, " BLKVAR " << nodep << endl);
@ -188,7 +188,7 @@ private:
}
// No iterate; Don't want varrefs under it
}
virtual void visit(AstVarRef* nodep) VL_OVERRIDE {
virtual void visit(AstVarRef* nodep) override {
if (!VarFlags(nodep->varp()).m_notOpt) {
if (!m_cfuncp) { // Not in function, can't optimize
// Perhaps impossible, but better safe
@ -217,7 +217,7 @@ private:
}
// No iterate; Don't want varrefs under it
}
virtual void visit(AstNode* nodep) VL_OVERRIDE { iterateChildren(nodep); }
virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
public:
// CONSTRUCTORS

22
src/V3MergeCond.cpp
View File

@ -67,7 +67,7 @@ private:
}
// VISITORS
virtual void visit(AstNode* nodep) VL_OVERRIDE {
virtual void visit(AstNode* nodep) override {
if (!m_mergeable) return;
// Clear if node is impure
if (!nodep->isPure()) {
@ -76,7 +76,7 @@ private:
}
iterateChildrenConst(nodep);
}
virtual void visit(AstVarRef* nodep) VL_OVERRIDE {
virtual void visit(AstVarRef* nodep) override {
if (!m_mergeable) return;
// Clear if it's an LValue referencing a marked variable
if (nodep->lvalue() && nodep->varp()->user1()) {
@ -104,8 +104,8 @@ private:
VL_DEBUG_FUNC; // Declare debug()
// VISITORS
virtual void visit(AstVarRef* nodep) VL_OVERRIDE { nodep->varp()->user1(1); }
virtual void visit(AstNode* nodep) VL_OVERRIDE { iterateChildrenConst(nodep); }
virtual void visit(AstVarRef* nodep) override { nodep->varp()->user1(1); }
virtual void visit(AstNode* nodep) override { iterateChildrenConst(nodep); }
public:
// Remove marks from AstVars (clear user1)
@ -264,7 +264,7 @@ private:
}
// VISITORS
virtual void visit(AstNodeAssign* nodep) VL_OVERRIDE {
virtual void visit(AstNodeAssign* nodep) override {
AstNode* const rhsp = nodep->rhsp();
if (AstNodeCond* const condp = extractCond(rhsp)) {
if (!m_checkMergeable(nodep)) {
@ -306,17 +306,17 @@ private:
mergeEnd();
}
}
virtual void visit(AstComment*) VL_OVERRIDE {} // Skip over comments
virtual void visit(AstComment*) override {} // Skip over comments
// For speed, only iterate what is necessary.
virtual void visit(AstNetlist* nodep) VL_OVERRIDE { iterateAndNextNull(nodep->modulesp()); }
virtual void visit(AstNodeModule* nodep) VL_OVERRIDE { iterateAndNextNull(nodep->stmtsp()); }
virtual void visit(AstCFunc* nodep) VL_OVERRIDE {
virtual void visit(AstNetlist* nodep) override { iterateAndNextNull(nodep->modulesp()); }
virtual void visit(AstNodeModule* nodep) override { iterateAndNextNull(nodep->stmtsp()); }
virtual void visit(AstCFunc* nodep) override {
iterateChildren(nodep);
// Close list, if there is one at the end of the function
if (m_mgFirstp) mergeEnd();
}
virtual void visit(AstNodeStmt* nodep) VL_OVERRIDE { iterateChildren(nodep); }
virtual void visit(AstNode* nodep) VL_OVERRIDE {}
virtual void visit(AstNodeStmt* nodep) override { iterateChildren(nodep); }
virtual void visit(AstNode* nodep) override {}
public:
// CONSTRUCTORS

18
src/V3Name.cpp
View File

@ -67,7 +67,7 @@ private:
}
// VISITORS
virtual void visit(AstNodeModule* nodep) VL_OVERRIDE {
virtual void visit(AstNodeModule* nodep) override {
AstNodeModule* origModp = m_modp;
{
m_modp = nodep;
@ -76,44 +76,44 @@ private:
m_modp = origModp;
}
// Add __PVT__ to names of local signals
virtual void visit(AstVar* nodep) VL_OVERRIDE {
virtual void visit(AstVar* nodep) override {
// Don't iterate... Don't need temps for RANGES under the Var.
rename(nodep,
((!m_modp || !m_modp->isTop()) && !nodep->isSigPublic()
&& !nodep->isFuncLocal() // Isn't exposed, and would mess up dpi import wrappers
&& !nodep->isTemp())); // Don't bother to rename internal signals
}
virtual void visit(AstCFunc* nodep) VL_OVERRIDE {
virtual void visit(AstCFunc* nodep) override {
if (!nodep->user1()) {
iterateChildren(nodep);
rename(nodep, false);
}
}
virtual void visit(AstVarRef* nodep) VL_OVERRIDE {
virtual void visit(AstVarRef* nodep) override {
if (nodep->varp()) {
iterate(nodep->varp());
nodep->name(nodep->varp()->name());
}
}
virtual void visit(AstCell* nodep) VL_OVERRIDE {
virtual void visit(AstCell* nodep) override {
if (!nodep->user1()) {
rename(nodep, (!nodep->modp()->modPublic() && !VN_IS(nodep->modp(), ClassPackage)));
iterateChildren(nodep);
}
}
virtual void visit(AstMemberDType* nodep) VL_OVERRIDE {
virtual void visit(AstMemberDType* nodep) override {
if (!nodep->user1()) {
rename(nodep, false);
iterateChildren(nodep);
}
}
virtual void visit(AstMemberSel* nodep) VL_OVERRIDE {
virtual void visit(AstMemberSel* nodep) override {
if (!nodep->user1()) {
rename(nodep, false);
iterateChildren(nodep);
}
}
virtual void visit(AstScope* nodep) VL_OVERRIDE {
virtual void visit(AstScope* nodep) override {
if (!nodep->user1SetOnce()) {
if (nodep->aboveScopep()) iterate(nodep->aboveScopep());
if (nodep->aboveCellp()) iterate(nodep->aboveCellp());
@ -132,7 +132,7 @@ private:
}
//--------------------
virtual void visit(AstNode* nodep) VL_OVERRIDE { iterateChildren(nodep); }
virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
public:
// CONSTRUCTORS

2
src/V3Options.cpp
View File

@ -1586,7 +1586,7 @@ void V3Options::parseOptsFile(FileLine* fl, const string& filename, bool rel) {
// Read the specified -f filename and process as arguments
UINFO(1, "Reading Options File " << filename << endl);
const vl_unique_ptr<std::ifstream> ifp(V3File::new_ifstream(filename));
const std::unique_ptr<std::ifstream> ifp(V3File::new_ifstream(filename));
if (ifp->fail()) {
fl->v3error("Cannot open -f command file: " + filename);
return;

80
src/V3Order.cpp
View File

@ -100,8 +100,8 @@
#include <memory>
#include <sstream>
#include <vector>
#include VL_INCLUDE_UNORDERED_MAP
#include VL_INCLUDE_UNORDERED_SET
#include <unordered_map>
#include <unordered_set>
static bool domainsExclusive(const AstSenTree* fromp, const AstSenTree* top);
@ -264,7 +264,7 @@ private:
// METHODS
VL_DEBUG_FUNC; // Declare debug()
virtual void visit(AstNodeAssign* nodep) VL_OVERRIDE {
virtual void visit(AstNodeAssign* nodep) override {
m_hasClk = false;
if (AstVarRef* varrefp = VN_CAST(nodep->rhsp(), VarRef)) {
this->visit(varrefp);
@ -306,7 +306,7 @@ private:
}
}
virtual void visit(AstVarRef* nodep) VL_OVERRIDE {
virtual void visit(AstVarRef* nodep) override {
if (m_inAss && nodep->varp()->attrClocker() == VVarAttrClocker::CLOCKER_YES) {
if (m_inClocked) {
nodep->v3warn(CLKDATA,
@ -319,7 +319,7 @@ private:
}
}
}
virtual void visit(AstConcat* nodep) VL_OVERRIDE {
virtual void visit(AstConcat* nodep) override {
if (m_inAss) {
iterateAndNextNull(nodep->lhsp());
int lw = m_childClkWidth;
@ -328,20 +328,20 @@ private:
m_childClkWidth = lw + rw; // Pass up
}
}
virtual void visit(AstNodeSel* nodep) VL_OVERRIDE {
virtual void visit(AstNodeSel* nodep) override {
if (m_inAss) {
iterateChildren(nodep);
// Pass up result width
if (m_childClkWidth > nodep->width()) m_childClkWidth = nodep->width();
}
}
virtual void visit(AstSel* nodep) VL_OVERRIDE {
virtual void visit(AstSel* nodep) override {
if (m_inAss) {
iterateChildren(nodep);
if (m_childClkWidth > nodep->width()) m_childClkWidth = nodep->width();
}
}
virtual void visit(AstReplicate* nodep) VL_OVERRIDE {
virtual void visit(AstReplicate* nodep) override {
if (m_inAss) {
iterateChildren(nodep);
if (VN_IS(nodep->rhsp(), Const)) {
@ -351,12 +351,12 @@ private:
}
}
}
virtual void visit(AstActive* nodep) VL_OVERRIDE {
virtual void visit(AstActive* nodep) override {
m_inClocked = nodep->hasClocked();
iterateChildren(nodep);
m_inClocked = false;
}
virtual void visit(AstNode* nodep) VL_OVERRIDE { iterateChildren(nodep); }
virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
public:
// CONSTRUCTORS
@ -382,7 +382,7 @@ private:
bool m_clkAss; // There is signals marked as clocker in the assignment
// METHODS
VL_DEBUG_FUNC; // Declare debug()
virtual void visit(AstNodeAssign* nodep) VL_OVERRIDE {
virtual void visit(AstNodeAssign* nodep) override {
if (const AstVarRef* varrefp = VN_CAST(nodep->lhsp(), VarRef)) {
if (varrefp->varp()->attrClocker() == VVarAttrClocker::CLOCKER_YES) {
m_clkAss = true;
@ -391,13 +391,13 @@ private:
}
iterateChildren(nodep->rhsp());
}
virtual void visit(AstVarRef*) VL_OVERRIDE {
virtual void visit(AstVarRef*) override {
// Previous versions checked attrClocker() here, but this breaks
// the updated t_clocker VCD test.
// If reenable this visitor note AstNodeMath short circuit below
}
virtual void visit(AstNodeMath*) VL_OVERRIDE {} // Accelerate
virtual void visit(AstNode* nodep) VL_OVERRIDE { iterateChildren(nodep); }
virtual void visit(AstNodeMath*) override {} // Accelerate
virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
public:
// CONSTRUCTORS
@ -432,9 +432,9 @@ template <class T_MoveVertex> class ProcessMoveBuildGraph {
// TYPES
typedef std::pair<const V3GraphVertex*, const AstSenTree*> VxDomPair;
// Maps an (original graph vertex, domain) pair to a T_MoveVertex
// Not vl_unordered_map, because std::pair doesn't provide std::hash
// Not std::unordered_map, because std::pair doesn't provide std::hash
typedef std::map<VxDomPair, T_MoveVertex*> Var2Move;
typedef vl_unordered_map<const OrderLogicVertex*, T_MoveVertex*> Logic2Move;
typedef std::unordered_map<const OrderLogicVertex*, T_MoveVertex*> Logic2Move;
public:
class MoveVertexMaker {
@ -877,7 +877,7 @@ private:
// elements. Up to 10 of the widest
std::cerr << V3Error::warnMore() << "... Widest candidate vars to split:" << endl;
std::stable_sort(m_unoptflatVars.begin(), m_unoptflatVars.end(), OrderVarWidthCmp());
vl_unordered_set<const AstVar*> canSplitList;
std::unordered_set<const AstVar*> canSplitList;
int lim = m_unoptflatVars.size() < 10 ? m_unoptflatVars.size() : 10;
for (int i = 0; i < lim; i++) {
OrderVarStdVertex* vsvertexp = m_unoptflatVars[i];
@ -943,7 +943,7 @@ private:
}
}
// VISITORS
virtual void visit(AstNetlist* nodep) VL_OVERRIDE {
virtual void visit(AstNetlist* nodep) override {
{
AstUser4InUse m_inuser4; // Used only when building tree, so below
iterateChildren(nodep);
@ -954,7 +954,7 @@ private:
m_topScopep = NULL;
}
}
virtual void visit(AstTopScope* nodep) VL_OVERRIDE {
virtual void visit(AstTopScope* nodep) override {
// Process the last thing we're finishing
UASSERT_OBJ(!m_topScopep, nodep, "Only one topscope should ever be created");
UINFO(2, " Loading tree...\n");
@ -989,7 +989,7 @@ private:
AstNode::user3ClearTree();
AstNode::user4ClearTree();
}
virtual void visit(AstNodeModule* nodep) VL_OVERRIDE {
virtual void visit(AstNodeModule* nodep) override {
AstNodeModule* origModp = m_modp;
{
m_modp = nodep;
@ -997,8 +997,8 @@ private:
}
m_modp = origModp;
}
virtual void visit(AstClass*) VL_OVERRIDE {}
virtual void visit(AstScope* nodep) VL_OVERRIDE {
virtual void visit(AstClass*) override {}
virtual void visit(AstScope* nodep) override {
UINFO(4, " SCOPE " << nodep << endl);
m_scopep = nodep;
m_logicVxp = NULL;
@ -1008,7 +1008,7 @@ private:
iterateChildren(nodep);
m_scopep = NULL;
}
virtual void visit(AstActive* nodep) VL_OVERRIDE {
virtual void visit(AstActive* nodep) override {
// Create required activation blocks and add to module
UINFO(4, " ACTIVE " << nodep << endl);
m_activep = nodep;
@ -1024,7 +1024,7 @@ private:
m_activeSenVxp = NULL;
m_inClocked = false;
}
virtual void visit(AstVarScope* nodep) VL_OVERRIDE {
virtual void visit(AstVarScope* nodep) override {
// Create links to all input signals
UASSERT_OBJ(m_modp, nodep, "Scope not under module");
if (m_modp->isTop() && nodep->varp()->isNonOutput()) {
@ -1032,7 +1032,7 @@ private:
new OrderEdge(&m_graph, m_inputsVxp, varVxp, WEIGHT_INPUT);
}
}
virtual void visit(AstNodeVarRef* nodep) VL_OVERRIDE {
virtual void visit(AstNodeVarRef* nodep) override {
if (m_scopep) {
AstVarScope* varscp = nodep->varScopep();
UASSERT_OBJ(varscp, nodep, "Var didn't get varscoped in V3Scope.cpp");
@ -1159,7 +1159,7 @@ private:
}
}
}
virtual void visit(AstSenTree* nodep) VL_OVERRIDE {
virtual void visit(AstSenTree* nodep) override {
// Having a node derived from the sentree isn't required for
// correctness, it merely makes the graph better connected
// and improves graph algorithmic performance
@ -1174,21 +1174,21 @@ private:
m_inSenTree = false;
}
}
virtual void visit(AstAlwaysPost* nodep) VL_OVERRIDE {
virtual void visit(AstAlwaysPost* nodep) override {
m_inPost = true;
iterateNewStmt(nodep);
m_inPost = false;
}
virtual void visit(AstAlways* nodep) VL_OVERRIDE { iterateNewStmt(nodep); }
virtual void visit(AstAlwaysPublic* nodep) VL_OVERRIDE { iterateNewStmt(nodep); }
virtual void visit(AstAssignAlias* nodep) VL_OVERRIDE { iterateNewStmt(nodep); }
virtual void visit(AstAssignW* nodep) VL_OVERRIDE {
virtual void visit(AstAlways* nodep) override { iterateNewStmt(nodep); }
virtual void visit(AstAlwaysPublic* nodep) override { iterateNewStmt(nodep); }
virtual void visit(AstAssignAlias* nodep) override { iterateNewStmt(nodep); }
virtual void visit(AstAssignW* nodep) override {
OrderClkAssVisitor visitor(nodep);
m_inClkAss = visitor.isClkAss();
iterateNewStmt(nodep);
m_inClkAss = false;
}
virtual void visit(AstAssignPre* nodep) VL_OVERRIDE {
virtual void visit(AstAssignPre* nodep) override {
OrderClkAssVisitor visitor(nodep);
m_inClkAss = visitor.isClkAss();
m_inPre = true;
@ -1196,7 +1196,7 @@ private:
m_inPre = false;
m_inClkAss = false;
}
virtual void visit(AstAssignPost* nodep) VL_OVERRIDE {
virtual void visit(AstAssignPost* nodep) override {
OrderClkAssVisitor visitor(nodep);
m_inClkAss = visitor.isClkAss();
m_inPost = true;
@ -1204,20 +1204,20 @@ private:
m_inPost = false;
m_inClkAss = false;
}
virtual void visit(AstCoverToggle* nodep) VL_OVERRIDE { iterateNewStmt(nodep); }
virtual void visit(AstInitial* nodep) VL_OVERRIDE {
virtual void visit(AstCoverToggle* nodep) override { iterateNewStmt(nodep); }
virtual void visit(AstInitial* nodep) override {
// We use initials to setup parameters and static consts's which may be referenced
// in user initial blocks. So use ordering to sort them all out.
iterateNewStmt(nodep);
}
virtual void visit(AstCFunc*) VL_OVERRIDE {
virtual void visit(AstCFunc*) override {
// Ignore for now
// We should detect what variables are set in the function, and make
// settlement code for them, then set a global flag, so we call "settle"
// on the next evaluation loop.
}
//--------------------
virtual void visit(AstNode* nodep) VL_OVERRIDE { iterateChildren(nodep); }
virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
public:
// CONSTRUCTORS
@ -1571,7 +1571,7 @@ void OrderVisitor::processDomainsIterate(OrderEitherVertex* vertexp) {
void OrderVisitor::processEdgeReport() {
// Make report of all signal names and what clock edges they have
string filename = v3Global.debugFilename("order_edges.txt");
const vl_unique_ptr<std::ofstream> logp(V3File::new_ofstream(filename));
const std::unique_ptr<std::ofstream> logp(V3File::new_ofstream(filename));
if (logp->fail()) v3fatal("Can't write " << filename);
// Testing emitter: V3EmitV::verilogForTree(v3Global.rootp(), *logp);
@ -1846,7 +1846,7 @@ void OrderVisitor::processMTasks() {
V3Graph mtasks;
partitioner.go(&mtasks);
vl_unordered_map<unsigned /*mtask id*/, MTaskState> mtaskStates;
std::unordered_map<unsigned /*mtask id*/, MTaskState> mtaskStates;
// Iterate through the entire logicGraph. For each logic node,
// attach it to a per-MTask ordered list of logic nodes.
@ -2012,7 +2012,7 @@ void OrderVisitor::process() {
m_graph.dumpDotFilePrefixed("orderg_done");
if (false && debug()) {
string dfilename = v3Global.opt.makeDir() + "/" + v3Global.opt.prefix() + "_INT_order";
const vl_unique_ptr<std::ofstream> logp(V3File::new_ofstream(dfilename));
const std::unique_ptr<std::ofstream> logp(V3File::new_ofstream(dfilename));
if (logp->fail()) v3fatal("Can't write " << dfilename);
m_graph.dump(*logp);
}

2
src/V3OrderGraph.h
View File

@ -44,7 +44,7 @@
#include "V3Ast.h"
#include "V3Graph.h"
#include VL_INCLUDE_UNORDERED_MAP
#include <unordered_map>
class OrderVisitor;
class OrderMoveVertex;

28
src/V3Param.cpp
View File

@ -486,11 +486,11 @@ private:
}
// VISITORS
virtual void visit(AstNetlist* nodep) VL_OVERRIDE {
virtual void visit(AstNetlist* nodep) override {
// Modules must be done in top-down-order
iterateChildren(nodep);
}
virtual void visit(AstNodeModule* nodep) VL_OVERRIDE {
virtual void visit(AstNodeModule* nodep) override {
if (nodep->dead()) {
UINFO(4, " MOD-dead. " << nodep << endl); // Marked by LinkDot
} else if (nodep->recursiveClone()) {
@ -510,20 +510,20 @@ private:
UINFO(4, " MOD-dead? " << nodep << endl);
}
}
virtual void visit(AstCell* nodep) VL_OVERRIDE {
virtual void visit(AstCell* nodep) override {
// Must do ifaces first, so push to list and do in proper order
string* genHierNamep = new string(m_generateHierName);
nodep->user5p(genHierNamep);
m_cellps.push_back(nodep);
}
virtual void visit(AstNodeFTask* nodep) VL_OVERRIDE {
virtual void visit(AstNodeFTask* nodep) override {
m_ftaskp = nodep;
iterateChildren(nodep);
m_ftaskp = NULL;
}
// Make sure all parameters are constantified
virtual void visit(AstVar* nodep) VL_OVERRIDE {
virtual void visit(AstVar* nodep) override {
if (!nodep->user5SetOnce()) { // Process once
iterateChildren(nodep);
if (nodep->isParam()) {
@ -558,7 +558,7 @@ private:
}
}
// Make sure varrefs cause vars to constify before things above
virtual void visit(AstVarRef* nodep) VL_OVERRIDE {
virtual void visit(AstVarRef* nodep) override {
if (nodep->varp()) iterate(nodep->varp());
}
bool ifaceParamReplace(AstVarXRef* nodep, AstNode* candp) {
@ -578,7 +578,7 @@ private:
}
return false;
}
virtual void visit(AstVarXRef* nodep) VL_OVERRIDE {
virtual void visit(AstVarXRef* nodep) override {
// Check to see if the scope is just an interface because interfaces are special
string dotted = nodep->dotted();
if (!dotted.empty() && nodep->varp() && nodep->varp()->isParam()) {
@ -624,7 +624,7 @@ private:
nodep->varp(NULL); // Needs relink, as may remove pointed-to var
}
virtual void visit(AstUnlinkedRef* nodep) VL_OVERRIDE {
virtual void visit(AstUnlinkedRef* nodep) override {
AstVarXRef* varxrefp = VN_CAST(nodep->op1p(), VarXRef);
AstNodeFTaskRef* taskrefp = VN_CAST(nodep->op1p(), NodeFTaskRef);
if (varxrefp) {
@ -645,7 +645,7 @@ private:
nodep->replaceWith(nodep->op1p()->unlinkFrBack());
VL_DO_DANGLING(pushDeletep(nodep), nodep);
}
virtual void visit(AstCellArrayRef* nodep) VL_OVERRIDE {
virtual void visit(AstCellArrayRef* nodep) override {
V3Const::constifyParamsEdit(nodep->selp());
if (const AstConst* constp = VN_CAST(nodep->selp(), Const)) {
string index = AstNode::encodeNumber(constp->toSInt());
@ -664,7 +664,7 @@ private:
}
// Generate Statements
virtual void visit(AstGenIf* nodep) VL_OVERRIDE {
virtual void visit(AstGenIf* nodep) override {
UINFO(9, " GENIF " << nodep << endl);
iterateAndNextNull(nodep->condp());
// We suppress errors when widthing params since short-circuiting in
@ -692,7 +692,7 @@ private:
//! @todo Unlike generated IF, we don't have to worry about short-circuiting the conditional
//! expression, since this is currently restricted to simple comparisons. If we ever do
//! move to more generic constant expressions, such code will be needed here.
virtual void visit(AstBegin* nodep) VL_OVERRIDE {
virtual void visit(AstBegin* nodep) override {
if (nodep->genforp()) {
AstGenFor* forp = VN_CAST(nodep->genforp(), GenFor);
UASSERT_OBJ(forp, nodep, "Non-GENFOR under generate-for BEGIN");
@ -725,10 +725,10 @@ private:
m_generateHierName = rootHierName;
}
}
virtual void visit(AstGenFor* nodep) VL_OVERRIDE { // LCOV_EXCL_LINE
virtual void visit(AstGenFor* nodep) override { // LCOV_EXCL_LINE
nodep->v3fatalSrc("GENFOR should have been wrapped in BEGIN");
}
virtual void visit(AstGenCase* nodep) VL_OVERRIDE {
virtual void visit(AstGenCase* nodep) override {
UINFO(9, " GENCASE " << nodep << endl);
AstNode* keepp = NULL;
iterateAndNextNull(nodep->exprp());
@ -779,7 +779,7 @@ private:
VL_DO_DANGLING(nodep->deleteTree(), nodep);
}
virtual void visit(AstNode* nodep) VL_OVERRIDE { iterateChildren(nodep); }
virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
public:
// CONSTRUCTORS

32
src/V3Partition.cpp
View File

@ -29,7 +29,7 @@
#include <list>
#include <memory>
#include VL_INCLUDE_UNORDERED_SET
#include <unordered_set>
class MergeCandidate;
@ -271,7 +271,7 @@ private:
// MEMBERS
V3Graph m_graph; // A graph
V3GraphVertex* m_vx[50]; // All vertices within the graph
typedef vl_unordered_map<V3GraphVertex*, uint32_t> CpMap;
typedef std::unordered_map<V3GraphVertex*, uint32_t> CpMap;
CpMap m_cp; // Vertex-to-CP map
CpMap m_seen; // Set of vertices we've seen
@ -650,7 +650,7 @@ public:
static void dumpCpFilePrefixed(const V3Graph* graphp, const string& nameComment) {
string filename = v3Global.debugFilename(nameComment) + ".txt";
UINFO(1, "Writing " << filename << endl);
vl_unique_ptr<std::ofstream> ofp(V3File::new_ofstream(filename));
std::unique_ptr<std::ofstream> ofp(V3File::new_ofstream(filename));
std::ostream* osp = &(*ofp); // &* needed to deref unique_ptr
if (osp->fail()) v3fatalStatic("Can't write " << filename);
@ -754,7 +754,7 @@ private:
LogicMTask* m_ap;
LogicMTask* m_bp;
// CONSTRUCTORS
SiblingMC() VL_EQ_DELETE;
SiblingMC() = delete;
public:
SiblingMC(LogicMTask* ap, LogicMTask* bp) {
@ -881,7 +881,7 @@ public:
void traverse() {
// For each node, record the critical path cost from the start
// of the graph through the end of the node.
vl_unordered_map<const V3GraphVertex*, uint32_t> critPaths;
std::unordered_map<const V3GraphVertex*, uint32_t> critPaths;
GraphStreamUnordered serialize(m_graphp);
for (const V3GraphVertex* vertexp; (vertexp = serialize.nextp());) {
m_vertexCount++;
@ -938,7 +938,7 @@ static void partInitHalfCriticalPaths(GraphWay way, V3Graph* mtasksp, bool check
const LogicMTask* mtaskcp = dynamic_cast<const LogicMTask*>(vertexp);
LogicMTask* mtaskp = const_cast<LogicMTask*>(mtaskcp);
uint32_t cpCost = 0;
vl_unordered_set<V3GraphVertex*> relatives;
std::unordered_set<V3GraphVertex*> relatives;
for (V3GraphEdge* edgep = vertexp->beginp(rev); edgep; edgep = edgep->nextp(rev)) {
// Run a few asserts on the initial mtask graph,
// while we're iterating through...
@ -1066,11 +1066,11 @@ private:
// TYPES
// TODO: might get a little more speed by making this a
// vl_unordered_set and defining hash and equal_to functors for the
// std::unordered_set and defining hash and equal_to functors for the
// SiblingMC:
typedef std::set<SiblingMC> SibSet;
typedef vl_unordered_set<const SiblingMC*> SibpSet;
typedef vl_unordered_map<const LogicMTask*, SibpSet> MTask2Sibs;
typedef std::unordered_set<const SiblingMC*> SibpSet;
typedef std::unordered_map<const LogicMTask*, SibpSet> MTask2Sibs;
// New CP information for mtaskp reflecting an upcoming merge
struct NewCp {
@ -1121,7 +1121,7 @@ public:
// - Incrementally recompute critical paths near the merged mtask.
for (V3GraphVertex* itp = m_mtasksp->verticesBeginp(); itp; itp = itp->verticesNextp()) {
vl_unordered_set<const V3GraphVertex*> neighbors;
std::unordered_set<const V3GraphVertex*> neighbors;
for (V3GraphEdge* edgep = itp->outBeginp(); edgep; edgep = edgep->outNextp()) {
m_sb.addElem(MTaskEdge::cast(edgep));
UASSERT_OBJ(neighbors.find(edgep->top()) == neighbors.end(), itp,
@ -1675,7 +1675,7 @@ private:
// METHODS
VL_DEBUG_FUNC;
virtual void visit(AstCFunc* nodep) VL_OVERRIDE {
virtual void visit(AstCFunc* nodep) override {
if (!m_tracingCall) return;
m_tracingCall = false;
if (nodep->dpiImportWrapper()) {
@ -1686,13 +1686,13 @@ private:
}
iterateChildren(nodep);
}
virtual void visit(AstNodeCCall* nodep) VL_OVERRIDE {
virtual void visit(AstNodeCCall* nodep) override {
iterateChildren(nodep);
// Enter the function and trace it
m_tracingCall = true;
iterate(nodep->funcp());
}
virtual void visit(AstNode* nodep) VL_OVERRIDE { iterateChildren(nodep); }
virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
public:
// CONSTRUCTORS
@ -1798,7 +1798,7 @@ private:
typedef std::set<LogicMTask*, MTaskIdLessThan> LogicMTaskSet;
typedef std::map<uint32_t /*rank*/, LogicMTaskSet> TasksByRank;
typedef std::set<const OrderVarStdVertex*, OrderByPtrId&> OvvSet;
typedef vl_unordered_map<const OrderLogicVertex*, LogicMTask*> Olv2MTaskMap;
typedef std::unordered_map<const OrderLogicVertex*, LogicMTask*> Olv2MTaskMap;
// MEMBERS
V3Graph* m_mtasksp; // Mtask graph
@ -2071,7 +2071,7 @@ private:
uint32_t m_sandbagNumerator; // Numerator padding for est runtime
uint32_t m_sandbagDenom; // Denomerator padding for est runtime
typedef vl_unordered_map<const ExecMTask*, MTaskState> MTaskStateMap;
typedef std::unordered_map<const ExecMTask*, MTaskState> MTaskStateMap;
MTaskStateMap m_mtaskState; // State for each mtask.
MTaskCmp m_mtaskCmp; // Comparison functor
@ -2346,7 +2346,7 @@ void V3Partition::hashGraphDebug(const V3Graph* graphp, const char* debugName) {
// Disabled when there are no nondeterminism issues in flight.
if (!v3Global.opt.debugNondeterminism()) return;
vl_unordered_map<const V3GraphVertex*, uint32_t> vx2Id;
std::unordered_map<const V3GraphVertex*, uint32_t> vx2Id;
unsigned id = 0;
for (const V3GraphVertex* vxp = graphp->verticesBeginp(); vxp; vxp = vxp->verticesNextp()) {
vx2Id[vxp] = id++;

4
src/V3Partition.h
View File

@ -26,7 +26,7 @@
#include <list>
class LogicMTask;
typedef vl_unordered_map<const MTaskMoveVertex*, LogicMTask*> Vx2MTaskMap;
typedef std::unordered_map<const MTaskMoveVertex*, LogicMTask*> Vx2MTaskMap;
//*************************************************************************
/// V3Partition takes the fine-grained logic graph from V3Order and
@ -76,7 +76,7 @@ private:
class PartPtrIdMap {
private:
// TYPES
typedef vl_unordered_map<const void*, vluint64_t> PtrMap;
typedef std::unordered_map<const void*, vluint64_t> PtrMap;
// MEMBERS
mutable vluint64_t m_nextId;
mutable PtrMap m_id;

50
src/V3Premit.cpp
View File

@ -49,14 +49,14 @@ private:
VL_DEBUG_FUNC; // Declare debug()
// VISITORS
virtual void visit(AstNodeAssign* nodep) VL_OVERRIDE {
virtual void visit(AstNodeAssign* nodep) override {
// AstNode::user4ClearTree(); // Implied by AstUser4InUse
// LHS first as fewer varrefs
iterateAndNextNull(nodep->lhsp());
// Now find vars marked as lhs
iterateAndNextNull(nodep->rhsp());
}
virtual void visit(AstVarRef* nodep) VL_OVERRIDE {
virtual void visit(AstVarRef* nodep) override {
// it's LHS var is used so need a deep temporary
if (nodep->lvalue()) {
nodep->varp()->user4(true);
@ -67,7 +67,7 @@ private:
}
}
}
virtual void visit(AstNode* nodep) VL_OVERRIDE { iterateChildren(nodep); }
virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
public:
// CONSTRUCTORS
@ -185,7 +185,7 @@ private:
}
// VISITORS
virtual void visit(AstNodeModule* nodep) VL_OVERRIDE {
virtual void visit(AstNodeModule* nodep) override {
UINFO(4, " MOD " << nodep << endl);
AstNodeModule* origModp = m_modp;
{
@ -195,7 +195,7 @@ private:
}
m_modp = origModp;
}
virtual void visit(AstCFunc* nodep) VL_OVERRIDE {
virtual void visit(AstCFunc* nodep) override {
m_funcp = nodep;
iterateChildren(nodep);
m_funcp = NULL;
@ -204,7 +204,7 @@ private:
m_assignLhs = false;
if (m_funcp) m_stmtp = nodep;
}
virtual void visit(AstWhile* nodep) VL_OVERRIDE {
virtual void visit(AstWhile* nodep) override {
UINFO(4, " WHILE " << nodep << endl);
startStatement(nodep);
iterateAndNextNull(nodep->precondsp());
@ -217,7 +217,7 @@ private:
iterateAndNextNull(nodep->incsp());
m_stmtp = NULL;
}
virtual void visit(AstNodeAssign* nodep) VL_OVERRIDE {
virtual void visit(AstNodeAssign* nodep) override {
startStatement(nodep);
{
bool noopt = PremitAssignVisitor(nodep).noOpt();
@ -233,7 +233,7 @@ private:
m_assignLhs = false;
m_stmtp = NULL;
}
virtual void visit(AstNodeStmt* nodep) VL_OVERRIDE {
virtual void visit(AstNodeStmt* nodep) override {
if (!nodep->isStatement()) {
iterateChildren(nodep);
return;
@ -243,7 +243,7 @@ private:
iterateChildren(nodep);
m_stmtp = NULL;
}
virtual void visit(AstTraceInc* nodep) VL_OVERRIDE {
virtual void visit(AstTraceInc* nodep) override {
startStatement(nodep);
m_inTracep = nodep;
iterateChildren(nodep);
@ -296,27 +296,27 @@ private:
iterateChildren(nodep);
checkNode(nodep);
}
virtual void visit(AstShiftL* nodep) VL_OVERRIDE { visitShift(nodep); }
virtual void visit(AstShiftR* nodep) VL_OVERRIDE { visitShift(nodep); }
virtual void visit(AstShiftRS* nodep) VL_OVERRIDE { visitShift(nodep); }
virtual void visit(AstShiftL* nodep) override { visitShift(nodep); }
virtual void visit(AstShiftR* nodep) override { visitShift(nodep); }
virtual void visit(AstShiftRS* nodep) override { visitShift(nodep); }
// Operators
virtual void visit(AstNodeTermop* nodep) VL_OVERRIDE {
virtual void visit(AstNodeTermop* nodep) override {
iterateChildren(nodep);
checkNode(nodep);
}
virtual void visit(AstNodeUniop* nodep) VL_OVERRIDE {
virtual void visit(AstNodeUniop* nodep) override {
iterateChildren(nodep);
checkNode(nodep);
}
virtual void visit(AstNodeBiop* nodep) VL_OVERRIDE {
virtual void visit(AstNodeBiop* nodep) override {
iterateChildren(nodep);
checkNode(nodep);
}
virtual void visit(AstUCFunc* nodep) VL_OVERRIDE {
virtual void visit(AstUCFunc* nodep) override {
iterateChildren(nodep);
checkNode(nodep);
}
virtual void visit(AstSel* nodep) VL_OVERRIDE {
virtual void visit(AstSel* nodep) override {
iterateAndNextNull(nodep->fromp());
{ // Only the 'from' is part of the assignment LHS
bool prevAssign = m_assignLhs;
@ -327,7 +327,7 @@ private:
}
checkNode(nodep);
}
virtual void visit(AstArraySel* nodep) VL_OVERRIDE {
virtual void visit(AstArraySel* nodep) override {
iterateAndNextNull(nodep->fromp());
{ // Only the 'from' is part of the assignment LHS
bool prevAssign = m_assignLhs;
@ -337,7 +337,7 @@ private:
}
checkNode(nodep);
}
virtual void visit(AstAssocSel* nodep) VL_OVERRIDE {
virtual void visit(AstAssocSel* nodep) override {
iterateAndNextNull(nodep->fromp());
{ // Only the 'from' is part of the assignment LHS
bool prevAssign = m_assignLhs;
@ -347,11 +347,11 @@ private:
}
checkNode(nodep);
}
virtual void visit(AstConst* nodep) VL_OVERRIDE {
virtual void visit(AstConst* nodep) override {
iterateChildren(nodep);
checkNode(nodep);
}
virtual void visit(AstNodeCond* nodep) VL_OVERRIDE {
virtual void visit(AstNodeCond* nodep) override {
iterateChildren(nodep);
if (nodep->expr1p()->isWide() && !VN_IS(nodep->condp(), Const)
&& !VN_IS(nodep->condp(), VarRef)) {
@ -363,7 +363,7 @@ private:
}
// Autoflush
virtual void visit(AstDisplay* nodep) VL_OVERRIDE {
virtual void visit(AstDisplay* nodep) override {
startStatement(nodep);
iterateChildren(nodep);
m_stmtp = NULL;
@ -380,7 +380,7 @@ private:
}
}
}
virtual void visit(AstSFormatF* nodep) VL_OVERRIDE {
virtual void visit(AstSFormatF* nodep) override {
iterateChildren(nodep);
// Any strings sent to a display must be var of string data type,
// to avoid passing a pointer to a temporary.
@ -394,8 +394,8 @@ private:
//--------------------
// Default: Just iterate
virtual void visit(AstVar*) VL_OVERRIDE {} // Don't hit varrefs under vars
virtual void visit(AstNode* nodep) VL_OVERRIDE { iterateChildren(nodep); }
virtual void visit(AstVar*) override {} // Don't hit varrefs under vars
virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
public:
// CONSTRUCTORS

8
src/V3ProtectLib.cpp
View File

@ -63,7 +63,7 @@ private:
bool m_hasClk; // True if the top module has sequential logic
// VISITORS
virtual void visit(AstNetlist* nodep) VL_OVERRIDE {
virtual void visit(AstNetlist* nodep) override {
m_vfilep
= new AstVFile(nodep->fileline(), v3Global.opt.makeDir() + "/" + m_libName + ".sv");
nodep->addFilesp(m_vfilep);
@ -73,7 +73,7 @@ private:
iterateChildren(nodep);
}
virtual void visit(AstNodeModule* nodep) VL_OVERRIDE {
virtual void visit(AstNodeModule* nodep) override {
if (!nodep->isTop()) {
return;
} else {
@ -376,7 +376,7 @@ private:
m_cfilep->tblockp(txtp);
}
virtual void visit(AstVar* nodep) VL_OVERRIDE {
virtual void visit(AstVar* nodep) override {
if (!nodep->isIO()) return;
if (VN_IS(nodep->dtypep(), UnpackArrayDType)) {
nodep->v3warn(E_UNSUPPORTED, "Unsupported: unpacked arrays with protect-lib on "
@ -397,7 +397,7 @@ private:
}
}
virtual void visit(AstNode*) VL_OVERRIDE {}
virtual void visit(AstNode*) override {}
string cInputConnection(AstVar* varp) {
string frstmt;

10
src/V3Reloop.cpp
View File

@ -142,12 +142,12 @@ private:
}
// VISITORS
virtual void visit(AstCFunc* nodep) VL_OVERRIDE {
virtual void visit(AstCFunc* nodep) override {
m_cfuncp = nodep;
iterateChildren(nodep);
m_cfuncp = NULL;
}
virtual void visit(AstNodeAssign* nodep) VL_OVERRIDE {
virtual void visit(AstNodeAssign* nodep) override {
if (!m_cfuncp) return;
// Left select WordSel or ArraySel
@ -232,9 +232,9 @@ private:
UINFO(9, "Start merge i=" << index << " " << nodep << endl);
}
//--------------------
virtual void visit(AstVar*) VL_OVERRIDE {} // Accelerate
virtual void visit(AstNodeMath*) VL_OVERRIDE {} // Accelerate
virtual void visit(AstNode* nodep) VL_OVERRIDE { iterateChildren(nodep); }
virtual void visit(AstVar*) override {} // Accelerate
virtual void visit(AstNodeMath*) override {} // Accelerate
virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
public:
// CONSTRUCTORS

68
src/V3Scope.cpp
View File

@ -30,8 +30,8 @@
#include <algorithm>
#include <map>
#include VL_INCLUDE_UNORDERED_MAP
#include VL_INCLUDE_UNORDERED_SET
#include <unordered_map>
#include <unordered_set>
//######################################################################
// Scope class functions
@ -45,7 +45,7 @@ private:
AstUser2InUse m_inuser2;
// TYPES
typedef vl_unordered_map<AstNodeModule*, AstScope*> PackageScopeMap;
typedef std::unordered_map<AstNodeModule*, AstScope*> PackageScopeMap;
// These cannot be unordered unless make a specialized hashing pair (gcc-8)
typedef std::map<std::pair<AstVar*, AstScope*>, AstVarScope*> VarScopeMap;
typedef std::set<std::pair<AstVarRef*, AstScope*>> VarRefScopeSet;
@ -82,7 +82,7 @@ private:
}
// VISITORS
virtual void visit(AstNetlist* nodep) VL_OVERRIDE {
virtual void visit(AstNetlist* nodep) override {
AstNodeModule* modp = nodep->topModulep();
if (!modp) {
nodep->v3error("No top level module found");
@ -94,7 +94,7 @@ private:
iterate(modp);
cleanupVarRefs();
}
virtual void visit(AstNodeModule* nodep) VL_OVERRIDE {
virtual void visit(AstNodeModule* nodep) override {
// Create required blocks and add to module
string scopename;
if (!m_aboveScopep) {
@ -151,7 +151,7 @@ private:
// ***Note m_scopep is passed back to the caller of the routine (above)
}
virtual void visit(AstClass* nodep) VL_OVERRIDE {
virtual void visit(AstClass* nodep) override {
// Create required blocks and add to module
AstScope* oldScopep = m_scopep;
AstCell* oldAbCellp = m_aboveCellp;
@ -184,13 +184,13 @@ private:
m_aboveCellp = oldAbCellp;
m_aboveScopep = oldAbScopep;
}
virtual void visit(AstCellInline* nodep) VL_OVERRIDE { //
virtual void visit(AstCellInline* nodep) override { //
nodep->scopep(m_scopep);
}
virtual void visit(AstActive* nodep) VL_OVERRIDE { // LCOV_EXCL_LINE
virtual void visit(AstActive* nodep) override { // LCOV_EXCL_LINE
nodep->v3fatalSrc("Actives now made after scoping");
}
virtual void visit(AstNodeProcedure* nodep) VL_OVERRIDE {
virtual void visit(AstNodeProcedure* nodep) override {
// Add to list of blocks under this scope
UINFO(4, " Move " << nodep << endl);
AstNode* clonep = nodep->cloneTree(false);
@ -198,7 +198,7 @@ private:
m_scopep->addActivep(clonep);
iterateChildren(clonep); // We iterate under the *clone*
}
virtual void visit(AstAssignAlias* nodep) VL_OVERRIDE {
virtual void visit(AstAssignAlias* nodep) override {
// Add to list of blocks under this scope
UINFO(4, " Move " << nodep << endl);
AstNode* clonep = nodep->cloneTree(false);
@ -206,7 +206,7 @@ private:
m_scopep->addActivep(clonep);
iterateChildren(clonep); // We iterate under the *clone*
}
virtual void visit(AstAssignVarScope* nodep) VL_OVERRIDE {
virtual void visit(AstAssignVarScope* nodep) override {
// Copy under the scope but don't recurse
UINFO(4, " Move " << nodep << endl);
AstNode* clonep = nodep->cloneTree(false);
@ -214,7 +214,7 @@ private:
m_scopep->addActivep(clonep);
iterateChildren(clonep); // We iterate under the *clone*
}
virtual void visit(AstAssignW* nodep) VL_OVERRIDE {
virtual void visit(AstAssignW* nodep) override {
// Add to list of blocks under this scope
UINFO(4, " Move " << nodep << endl);
AstNode* clonep = nodep->cloneTree(false);
@ -222,7 +222,7 @@ private:
m_scopep->addActivep(clonep);
iterateChildren(clonep); // We iterate under the *clone*
}
virtual void visit(AstAlwaysPublic* nodep) VL_OVERRIDE {
virtual void visit(AstAlwaysPublic* nodep) override {
// Add to list of blocks under this scope
UINFO(4, " Move " << nodep << endl);
AstNode* clonep = nodep->cloneTree(false);
@ -230,7 +230,7 @@ private:
m_scopep->addActivep(clonep);
iterateChildren(clonep); // We iterate under the *clone*
}
virtual void visit(AstCoverToggle* nodep) VL_OVERRIDE {
virtual void visit(AstCoverToggle* nodep) override {
// Add to list of blocks under this scope
UINFO(4, " Move " << nodep << endl);
AstNode* clonep = nodep->cloneTree(false);
@ -238,7 +238,7 @@ private:
m_scopep->addActivep(clonep);
iterateChildren(clonep); // We iterate under the *clone*
}
virtual void visit(AstCFunc* nodep) VL_OVERRIDE {
virtual void visit(AstCFunc* nodep) override {
// Add to list of blocks under this scope
UINFO(4, " CFUNC " << nodep << endl);
AstCFunc* clonep = nodep->cloneTree(false);
@ -248,7 +248,7 @@ private:
// We iterate under the *clone*
iterateChildren(clonep);
}
virtual void visit(AstNodeFTask* nodep) VL_OVERRIDE {
virtual void visit(AstNodeFTask* nodep) override {
// Add to list of blocks under this scope
UINFO(4, " FTASK " << nodep << endl);
AstNodeFTask* clonep;
@ -264,7 +264,7 @@ private:
// We iterate under the *clone*
iterateChildren(clonep);
}
virtual void visit(AstVar* nodep) VL_OVERRIDE {
virtual void visit(AstVar* nodep) override {
// Make new scope variable
if (!nodep->user1p()) {
AstVarScope* varscp = new AstVarScope(nodep->fileline(), m_scopep, nodep);
@ -282,7 +282,7 @@ private:
m_scopep->addVarp(varscp);
}
}
virtual void visit(AstVarRef* nodep) VL_OVERRIDE {
virtual void visit(AstVarRef* nodep) override {
// VarRef needs to point to VarScope
// Make sure variable has made user1p.
UASSERT_OBJ(nodep->varp(), nodep, "Unlinked");
@ -295,7 +295,7 @@ private:
m_varRefScopes.insert(make_pair(nodep, m_scopep));
}
}
virtual void visit(AstScopeName* nodep) VL_OVERRIDE {
virtual void visit(AstScopeName* nodep) override {
// If there's a %m in the display text, we add a special node that will contain the name()
string prefix = string("__DOT__") + m_scopep->name();
// TOP and above will be the user's name().
@ -311,12 +311,12 @@ private:
if (afterp) nodep->scopeEntrp(afterp);
iterateChildren(nodep);
}
virtual void visit(AstScope* nodep) VL_OVERRIDE {
virtual void visit(AstScope* nodep) override {
// Scope that was made by this module for different cell;
// Want to ignore blocks under it, so just do nothing
}
//--------------------
virtual void visit(AstNode* nodep) VL_OVERRIDE { iterateChildren(nodep); }
virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
public:
// CONSTRUCTORS
@ -343,7 +343,7 @@ private:
VL_DEBUG_FUNC; // Declare debug()
// VISITORS
virtual void visit(AstScope* nodep) VL_OVERRIDE {
virtual void visit(AstScope* nodep) override {
// Want to ignore blocks under it
m_scopep = nodep;
iterateChildren(nodep);
@ -362,20 +362,20 @@ private:
}
}
virtual void visit(AstNodeProcedure* nodep) VL_OVERRIDE { movedDeleteOrIterate(nodep); }
virtual void visit(AstAssignAlias* nodep) VL_OVERRIDE { movedDeleteOrIterate(nodep); }
virtual void visit(AstAssignVarScope* nodep) VL_OVERRIDE { movedDeleteOrIterate(nodep); }
virtual void visit(AstAssignW* nodep) VL_OVERRIDE { movedDeleteOrIterate(nodep); }
virtual void visit(AstAlwaysPublic* nodep) VL_OVERRIDE { movedDeleteOrIterate(nodep); }
virtual void visit(AstCoverToggle* nodep) VL_OVERRIDE { movedDeleteOrIterate(nodep); }
virtual void visit(AstNodeFTask* nodep) VL_OVERRIDE { movedDeleteOrIterate(nodep); }
virtual void visit(AstCFunc* nodep) VL_OVERRIDE { movedDeleteOrIterate(nodep); }
virtual void visit(AstNodeProcedure* nodep) override { movedDeleteOrIterate(nodep); }
virtual void visit(AstAssignAlias* nodep) override { movedDeleteOrIterate(nodep); }
virtual void visit(AstAssignVarScope* nodep) override { movedDeleteOrIterate(nodep); }
virtual void visit(AstAssignW* nodep) override { movedDeleteOrIterate(nodep); }
virtual void visit(AstAlwaysPublic* nodep) override { movedDeleteOrIterate(nodep); }
virtual void visit(AstCoverToggle* nodep) override { movedDeleteOrIterate(nodep); }
virtual void visit(AstNodeFTask* nodep) override { movedDeleteOrIterate(nodep); }
virtual void visit(AstCFunc* nodep) override { movedDeleteOrIterate(nodep); }
virtual void visit(AstVarXRef* nodep) VL_OVERRIDE {
virtual void visit(AstVarXRef* nodep) override {
// The crossrefs are dealt with in V3LinkDot
nodep->varp(NULL);
}
virtual void visit(AstNodeFTaskRef* nodep) VL_OVERRIDE {
virtual void visit(AstNodeFTaskRef* nodep) override {
// The crossrefs are dealt with in V3LinkDot
UINFO(9, " Old pkg-taskref " << nodep << endl);
if (nodep->packagep()) {
@ -391,14 +391,14 @@ private:
}
iterateChildren(nodep);
}
virtual void visit(AstModportFTaskRef* nodep) VL_OVERRIDE {
virtual void visit(AstModportFTaskRef* nodep) override {
// The crossrefs are dealt with in V3LinkDot
nodep->ftaskp(NULL);
iterateChildren(nodep);
}
//--------------------
virtual void visit(AstNode* nodep) VL_OVERRIDE { iterateChildren(nodep); }
virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
public:
// CONSTRUCTORS

8
src/V3Scoreboard.h
View File

@ -30,8 +30,8 @@
#include "V3Error.h"
#include <map>
#include VL_INCLUDE_UNORDERED_MAP
#include VL_INCLUDE_UNORDERED_SET
#include <unordered_map>
#include <unordered_set>
//######################################################################
// SortByValueMap
@ -44,7 +44,7 @@ template <typename T_Key, typename T_Value, class T_KeyCompare = std::less<T_Key
class SortByValueMap {
// TYPES
private:
typedef vl_unordered_map<T_Key, T_Value> Key2Val;
typedef std::unordered_map<T_Key, T_Value> Key2Val;
typedef std::set<T_Key, T_KeyCompare> KeySet;
typedef std::map<T_Value, KeySet> Val2Keys;
@ -354,7 +354,7 @@ template <typename T_Elem, typename T_Score, class T_ElemCompare = std::less<T_E
class V3Scoreboard {
private:
// TYPES
typedef vl_unordered_set<const T_Elem*> NeedRescoreSet;
typedef std::unordered_set<const T_Elem*> NeedRescoreSet;
class CmpElems {
public:
bool operator()(const T_Elem* const& ap, const T_Elem* const& bp) const {

4
src/V3SenTree.h
View File

@ -25,7 +25,7 @@
#include "V3Ast.h"
#include "V3Hashed.h"
#include VL_INCLUDE_UNORDERED_SET
#include <unordered_set>
//######################################################################
// Collect SenTrees under the entire scope
@ -48,7 +48,7 @@ private:
};
// MEMBERS
typedef vl_unordered_set<AstSenTree*, HashSenTree, EqSenTree> Set;
typedef std::unordered_set<AstSenTree*, HashSenTree, EqSenTree> Set;
Set m_trees; // Set of sensitive blocks, for folding.
public:

70
src/V3Simulate.h
View File

@ -378,15 +378,15 @@ private:
}
// VISITORS
virtual void visit(AstAlways* nodep) VL_OVERRIDE {
virtual void visit(AstAlways* nodep) override {
if (jumpingOver(nodep)) return;
checkNodeInfo(nodep);
iterateChildren(nodep);
}
virtual void visit(AstSenTree* nodep) VL_OVERRIDE {
virtual void visit(AstSenTree* nodep) override {
// Sensitivities aren't inputs per se; we'll keep our tree under the same sens.
}
virtual void visit(AstVarRef* nodep) VL_OVERRIDE {
virtual void visit(AstVarRef* nodep) override {
if (jumpingOver(nodep)) return;
if (!optimizable()) return; // Accelerate
UASSERT_OBJ(nodep->varp(), nodep, "Unlinked");
@ -452,7 +452,7 @@ private:
}
}
}
virtual void visit(AstVarXRef* nodep) VL_OVERRIDE {
virtual void visit(AstVarXRef* nodep) override {
if (jumpingOver(nodep)) return;
if (m_scoped) {
badNodeType(nodep);
@ -462,7 +462,7 @@ private:
"allowed in constant functions");
}
}
virtual void visit(AstNodeFTask* nodep) VL_OVERRIDE {
virtual void visit(AstNodeFTask* nodep) override {
if (jumpingOver(nodep)) return;
if (!m_params) {
badNodeType(nodep);
@ -474,7 +474,7 @@ private:
checkNodeInfo(nodep);
iterateChildren(nodep);
}
virtual void visit(AstNodeIf* nodep) VL_OVERRIDE {
virtual void visit(AstNodeIf* nodep) override {
if (jumpingOver(nodep)) return;
UINFO(5, " IF " << nodep << endl);
checkNodeInfo(nodep);
@ -491,15 +491,15 @@ private:
}
}
}
virtual void visit(AstConst* nodep) VL_OVERRIDE {
virtual void visit(AstConst* nodep) override {
checkNodeInfo(nodep);
if (!m_checkOnly && optimizable()) newValue(nodep, nodep);
}
virtual void visit(AstInitArray* nodep) VL_OVERRIDE {
virtual void visit(AstInitArray* nodep) override {
checkNodeInfo(nodep);
if (!m_checkOnly && optimizable()) newValue(nodep, nodep);
}
virtual void visit(AstEnumItemRef* nodep) VL_OVERRIDE {
virtual void visit(AstEnumItemRef* nodep) override {
checkNodeInfo(nodep);
UASSERT_OBJ(nodep->itemp(), nodep, "Not linked");
if (!m_checkOnly && optimizable()) {
@ -512,7 +512,7 @@ private:
}
}
}
virtual void visit(AstNodeUniop* nodep) VL_OVERRIDE {
virtual void visit(AstNodeUniop* nodep) override {
if (!optimizable()) return; // Accelerate
checkNodeInfo(nodep);
iterateChildren(nodep);
@ -520,7 +520,7 @@ private:
nodep->numberOperate(newConst(nodep)->num(), fetchConst(nodep->lhsp())->num());
}
}
virtual void visit(AstNodeBiop* nodep) VL_OVERRIDE {
virtual void visit(AstNodeBiop* nodep) override {
if (!optimizable()) return; // Accelerate
checkNodeInfo(nodep);
iterateChildren(nodep);
@ -529,7 +529,7 @@ private:
fetchConst(nodep->rhsp())->num());
}
}
virtual void visit(AstNodeTriop* nodep) VL_OVERRIDE {
virtual void visit(AstNodeTriop* nodep) override {
if (!optimizable()) return; // Accelerate
checkNodeInfo(nodep);
iterateChildren(nodep);
@ -539,7 +539,7 @@ private:
fetchConst(nodep->thsp())->num());
}
}
virtual void visit(AstNodeQuadop* nodep) VL_OVERRIDE {
virtual void visit(AstNodeQuadop* nodep) override {
if (!optimizable()) return; // Accelerate
checkNodeInfo(nodep);
iterateChildren(nodep);
@ -550,7 +550,7 @@ private:
fetchConst(nodep->fhsp())->num());
}
}
virtual void visit(AstLogAnd* nodep) VL_OVERRIDE {
virtual void visit(AstLogAnd* nodep) override {
// Need to short circuit
if (!optimizable()) return; // Accelerate
checkNodeInfo(nodep);
@ -568,7 +568,7 @@ private:
}
}
}
virtual void visit(AstLogOr* nodep) VL_OVERRIDE {
virtual void visit(AstLogOr* nodep) override {
// Need to short circuit
if (!optimizable()) return; // Accelerate
checkNodeInfo(nodep);
@ -586,7 +586,7 @@ private:
}
}
}
virtual void visit(AstLogIf* nodep) VL_OVERRIDE {
virtual void visit(AstLogIf* nodep) override {
// Need to short circuit, same as (!A || B)
if (!optimizable()) return; // Accelerate
checkNodeInfo(nodep);
@ -605,7 +605,7 @@ private:
}
}
}
virtual void visit(AstNodeCond* nodep) VL_OVERRIDE {
virtual void visit(AstNodeCond* nodep) override {
// We could use above visit(AstNodeTriop), but need to do short circuiting.
// It's also slower even O(n^2) to evaluate both sides when we
// really only need to evaluate one side.
@ -724,7 +724,7 @@ private:
}
}
virtual void visit(AstNodeAssign* nodep) VL_OVERRIDE {
virtual void visit(AstNodeAssign* nodep) override {
if (jumpingOver(nodep)) return;
if (!optimizable()) return; // Accelerate
if (VN_IS(nodep, AssignDly)) {
@ -761,7 +761,7 @@ private:
}
m_inDlyAssign = false;
}
virtual void visit(AstArraySel* nodep) VL_OVERRIDE {
virtual void visit(AstArraySel* nodep) override {
checkNodeInfo(nodep);
iterateChildren(nodep);
if (AstInitArray* initp = VN_CAST(fetchValueNull(nodep->fromp()), InitArray)) {
@ -778,11 +778,11 @@ private:
clearOptimizable(nodep, "Array select of non-array");
}
}
virtual void visit(AstBegin* nodep) VL_OVERRIDE {
virtual void visit(AstBegin* nodep) override {
checkNodeInfo(nodep);
iterateChildren(nodep);
}
virtual void visit(AstNodeCase* nodep) VL_OVERRIDE {
virtual void visit(AstNodeCase* nodep) override {
if (jumpingOver(nodep)) return;
UINFO(5, " CASE " << nodep << endl);
checkNodeInfo(nodep);
@ -820,20 +820,20 @@ private:
}
}
virtual void visit(AstCaseItem* nodep) VL_OVERRIDE {
virtual void visit(AstCaseItem* nodep) override {
// Real handling is in AstNodeCase
if (jumpingOver(nodep)) return;
checkNodeInfo(nodep);
iterateChildren(nodep);
}
virtual void visit(AstComment*) VL_OVERRIDE {}
virtual void visit(AstComment*) override {}
virtual void visit(AstJumpBlock* nodep) VL_OVERRIDE {
virtual void visit(AstJumpBlock* nodep) override {
if (jumpingOver(nodep)) return;
iterateChildren(nodep);
}
virtual void visit(AstJumpGo* nodep) VL_OVERRIDE {
virtual void visit(AstJumpGo* nodep) override {
if (jumpingOver(nodep)) return;
checkNodeInfo(nodep);
if (!m_checkOnly) {
@ -841,7 +841,7 @@ private:
m_jumpp = nodep;
}
}
virtual void visit(AstJumpLabel* nodep) VL_OVERRIDE {
virtual void visit(AstJumpLabel* nodep) override {
// This only supports forward jumps. That's all we make at present,
// AstJumpGo::broken uses brokeExistsBelow() to check this.
if (jumpingOver(nodep)) return;
@ -852,7 +852,7 @@ private:
m_jumpp = NULL;
}
}
virtual void visit(AstStop* nodep) VL_OVERRIDE {
virtual void visit(AstStop* nodep) override {
if (jumpingOver(nodep)) return;
if (m_params) { // This message seems better than an obscure $stop
// The spec says $stop is just ignored, it seems evil to ignore assertions
@ -863,7 +863,7 @@ private:
checkNodeInfo(nodep);
}
virtual void visit(AstNodeFor* nodep) VL_OVERRIDE {
virtual void visit(AstNodeFor* nodep) override {
// Doing lots of Whiles is slow, so only for parameters
UINFO(5, " FOR " << nodep << endl);
if (!m_params) {
@ -895,7 +895,7 @@ private:
}
}
virtual void visit(AstWhile* nodep) VL_OVERRIDE {
virtual void visit(AstWhile* nodep) override {
// Doing lots of Whiles is slow, so only for parameters
if (jumpingOver(nodep)) return;
UINFO(5, " WHILE " << nodep << endl);
@ -935,7 +935,7 @@ private:
}
}
virtual void visit(AstFuncRef* nodep) VL_OVERRIDE {
virtual void visit(AstFuncRef* nodep) override {
if (jumpingOver(nodep)) return;
if (!optimizable()) return; // Accelerate
UINFO(5, " FUNCREF " << nodep << endl);
@ -987,7 +987,7 @@ private:
}
}
virtual void visit(AstVar* nodep) VL_OVERRIDE {
virtual void visit(AstVar* nodep) override {
if (jumpingOver(nodep)) return;
if (!m_params) {
badNodeType(nodep);
@ -995,12 +995,12 @@ private:
}
}
virtual void visit(AstScopeName* nodep) VL_OVERRIDE {
virtual void visit(AstScopeName* nodep) override {
if (jumpingOver(nodep)) return;
// Ignore
}
virtual void visit(AstSFormatF* nodep) VL_OVERRIDE {
virtual void visit(AstSFormatF* nodep) override {
if (jumpingOver(nodep)) return;
if (!optimizable()) return; // Accelerate
iterateChildren(nodep);
@ -1052,7 +1052,7 @@ private:
}
}
virtual void visit(AstDisplay* nodep) VL_OVERRIDE {
virtual void visit(AstDisplay* nodep) override {
if (jumpingOver(nodep)) return;
if (!optimizable()) return; // Accelerate
iterateChildren(nodep);
@ -1074,7 +1074,7 @@ private:
// These types are definitely not reducible
// AstCoverInc, AstFinish,
// AstRand, AstTime, AstUCFunc, AstCCall, AstCStmt, AstUCStmt
virtual void visit(AstNode* nodep) VL_OVERRIDE {
virtual void visit(AstNode* nodep) override {
if (jumpingOver(nodep)) return;
badNodeType(nodep);
}

14
src/V3Slice.cpp
View File

@ -123,7 +123,7 @@ class SliceVisitor : public AstNVisitor {
return newp;
}
virtual void visit(AstNodeAssign* nodep) VL_OVERRIDE {
virtual void visit(AstNodeAssign* nodep) override {
// Called recursively on newly created assignments
if (!nodep->user1() && !VN_IS(nodep, AssignAlias)) {
nodep->user1(true);
@ -156,7 +156,7 @@ class SliceVisitor : public AstNVisitor {
}
}
virtual void visit(AstInitArray* nodep) VL_OVERRIDE {
virtual void visit(AstInitArray* nodep) override {
UASSERT_OBJ(!m_assignp, nodep, "Array initialization should have been removed earlier");
}
@ -215,12 +215,12 @@ class SliceVisitor : public AstNVisitor {
iterateChildren(nodep);
}
}
virtual void visit(AstEq* nodep) VL_OVERRIDE { expandBiOp(nodep); }
virtual void visit(AstNeq* nodep) VL_OVERRIDE { expandBiOp(nodep); }
virtual void visit(AstEqCase* nodep) VL_OVERRIDE { expandBiOp(nodep); }
virtual void visit(AstNeqCase* nodep) VL_OVERRIDE { expandBiOp(nodep); }
virtual void visit(AstEq* nodep) override { expandBiOp(nodep); }
virtual void visit(AstNeq* nodep) override { expandBiOp(nodep); }
virtual void visit(AstEqCase* nodep) override { expandBiOp(nodep); }
virtual void visit(AstNeqCase* nodep) override { expandBiOp(nodep); }
virtual void visit(AstNode* nodep) VL_OVERRIDE { iterateChildren(nodep); }
virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
public:
// CONSTRUCTORS

54
src/V3Split.cpp
View File

@ -89,8 +89,8 @@
#include <algorithm>
#include <map>
#include <vector>
#include VL_INCLUDE_UNORDERED_MAP
#include VL_INCLUDE_UNORDERED_SET
#include <unordered_map>
#include <unordered_set>
//######################################################################
// Support classes
@ -339,19 +339,19 @@ protected:
virtual void makeRvalueEdges(SplitVarStdVertex* vstdp) = 0;
// VISITORS
virtual void visit(AstAlways* nodep) VL_OVERRIDE = 0;
virtual void visit(AstNodeIf* nodep) VL_OVERRIDE = 0;
virtual void visit(AstAlways* nodep) override = 0;
virtual void visit(AstNodeIf* nodep) override = 0;
// We don't do AstNodeFor/AstWhile loops, due to the standard question
// of what is before vs. after
virtual void visit(AstAssignDly* nodep) VL_OVERRIDE {
virtual void visit(AstAssignDly* nodep) override {
m_inDly = true;
UINFO(4, " ASSIGNDLY " << nodep << endl);
iterateChildren(nodep);
m_inDly = false;
}
virtual void visit(AstVarRef* nodep) VL_OVERRIDE {
virtual void visit(AstVarRef* nodep) override {
if (!m_stmtStackps.empty()) {
AstVarScope* vscp = nodep->varScopep();
UASSERT_OBJ(vscp, nodep, "Not linked");
@ -415,7 +415,7 @@ protected:
}
}
virtual void visit(AstJumpGo* nodep) VL_OVERRIDE {
virtual void visit(AstJumpGo* nodep) override {
// Jumps will disable reordering at all levels
// This is overly pessimistic; we could treat jumps as barriers, and
// reorder everything between jumps/labels, however jumps are rare
@ -427,7 +427,7 @@ protected:
//--------------------
// Default
virtual void visit(AstNode* nodep) VL_OVERRIDE {
virtual void visit(AstNode* nodep) override {
// **** SPECIAL default type that sets PLI_ORDERING
if (!m_stmtStackps.empty() && !nodep->isPure()) {
UINFO(9, " NotSplittable " << nodep << endl);
@ -448,7 +448,7 @@ public:
// METHODS
protected:
virtual void makeRvalueEdges(SplitVarStdVertex* vstdp) VL_OVERRIDE {
virtual void makeRvalueEdges(SplitVarStdVertex* vstdp) override {
for (VStack::iterator it = m_stmtStackps.begin(); it != m_stmtStackps.end(); ++it) {
new SplitRVEdge(&m_graph, *it, vstdp);
}
@ -502,7 +502,7 @@ protected:
m_graph.weaklyConnected(&SplitEdge::followScoreboard);
// Add hard orderings between all nodes of same color, in the order they appeared
vl_unordered_map<uint32_t, SplitLogicVertex*> lastOfColor;
std::unordered_map<uint32_t, SplitLogicVertex*> lastOfColor;
for (AstNode* nextp = nodep; nextp; nextp = nextp->nextp()) {
SplitLogicVertex* vvertexp = reinterpret_cast<SplitLogicVertex*>(nextp->user3p());
uint32_t color = vvertexp->color();
@ -603,7 +603,7 @@ protected:
firstp->user3p(oldBlockUser3);
}
virtual void visit(AstAlways* nodep) VL_OVERRIDE {
virtual void visit(AstAlways* nodep) override {
UINFO(4, " ALW " << nodep << endl);
if (debug() >= 9) nodep->dumpTree(cout, " alwIn:: ");
scoreboardClear();
@ -611,7 +611,7 @@ protected:
if (debug() >= 9) nodep->dumpTree(cout, " alwOut: ");
}
virtual void visit(AstNodeIf* nodep) VL_OVERRIDE {
virtual void visit(AstNodeIf* nodep) override {
UINFO(4, " IF " << nodep << endl);
iterateAndNextNull(nodep->condp());
processBlock(nodep->ifsp());
@ -622,7 +622,7 @@ private:
VL_UNCOPYABLE(ReorderVisitor);
};
typedef vl_unordered_set<uint32_t> ColorSet;
typedef std::unordered_set<uint32_t> ColorSet;
typedef std::vector<AstAlways*> AlwaysVec;
class IfColorVisitor : public AstNVisitor {
@ -632,7 +632,7 @@ class IfColorVisitor : public AstNVisitor {
typedef std::vector<AstNodeIf*> IfStack;
IfStack m_ifStack; // Stack of nested if-statements we're currently processing
typedef vl_unordered_map<AstNodeIf*, ColorSet> IfColorMap;
typedef std::unordered_map<AstNodeIf*, ColorSet> IfColorMap;
IfColorMap m_ifColors; // Map each if-statement to the set of colors (split blocks)
// that will get a copy of that if-statement
@ -667,13 +667,13 @@ private:
}
protected:
virtual void visit(AstNodeIf* nodep) VL_OVERRIDE {
virtual void visit(AstNodeIf* nodep) override {
m_ifStack.push_back(nodep);
trackNode(nodep);
iterateChildren(nodep);
m_ifStack.pop_back();
}
virtual void visit(AstNode* nodep) VL_OVERRIDE {
virtual void visit(AstNode* nodep) override {
trackNode(nodep);
iterateChildren(nodep);
}
@ -689,7 +689,7 @@ class EmitSplitVisitor : public AstNVisitor {
const IfColorVisitor* m_ifColorp; // Digest of results of prior coloring
// Map each color to our current place within the color's new always
typedef vl_unordered_map<uint32_t, AstNode*> LocMap;
typedef std::unordered_map<uint32_t, AstNode*> LocMap;
LocMap m_addAfter;
AlwaysVec* m_newBlocksp; // Split always blocks we have generated
@ -737,7 +737,7 @@ protected:
return new AstSplitPlaceholder(m_origAlwaysp->fileline());
}
virtual void visit(AstNode* nodep) VL_OVERRIDE {
virtual void visit(AstNode* nodep) override {
// Anything that's not an if/else we assume is a leaf
// (that is, something we won't split.) Don't visit further
// into the leaf.
@ -759,9 +759,9 @@ protected:
m_addAfter[color] = clonedp;
}
virtual void visit(AstNodeIf* nodep) VL_OVERRIDE {
virtual void visit(AstNodeIf* nodep) override {
const ColorSet& colors = m_ifColorp->colors(nodep);
typedef vl_unordered_map<uint32_t, AstNodeIf*> CloneMap;
typedef std::unordered_map<uint32_t, AstNodeIf*> CloneMap;
CloneMap clones;
for (ColorSet::const_iterator color = colors.begin(); color != colors.end(); ++color) {
@ -801,7 +801,7 @@ private:
};
class RemovePlaceholdersVisitor : public AstNVisitor {
typedef vl_unordered_set<AstNode*> NodeSet;
typedef std::unordered_set<AstNode*> NodeSet;
NodeSet m_removeSet; // placeholders to be removed
public:
explicit RemovePlaceholdersVisitor(AstNode* nodep) {
@ -813,8 +813,8 @@ public:
}
}
virtual ~RemovePlaceholdersVisitor() {}
virtual void visit(AstSplitPlaceholder* nodep) VL_OVERRIDE { m_removeSet.insert(nodep); }
virtual void visit(AstNode* nodep) VL_OVERRIDE { iterateChildren(nodep); }
virtual void visit(AstSplitPlaceholder* nodep) override { m_removeSet.insert(nodep); }
virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
private:
VL_UNCOPYABLE(RemovePlaceholdersVisitor);
@ -825,7 +825,7 @@ private:
// Keys are original always blocks pending delete,
// values are newly split always blocks pending insertion
// at the same position as the originals:
typedef vl_unordered_map<AstAlways*, AlwaysVec> ReplaceMap;
typedef std::unordered_map<AstAlways*, AlwaysVec> ReplaceMap;
ReplaceMap m_replaceBlocks;
// AstNodeIf* whose condition we're currently visiting
@ -857,7 +857,7 @@ public:
// METHODS
protected:
virtual void makeRvalueEdges(SplitVarStdVertex* vstdp) VL_OVERRIDE {
virtual void makeRvalueEdges(SplitVarStdVertex* vstdp) override {
// Each 'if' depends on rvalues in its own conditional ONLY,
// not rvalues in the if/else bodies.
for (VStack::const_iterator it = m_stmtStackps.begin(); it != m_stmtStackps.end(); ++it) {
@ -932,7 +932,7 @@ protected:
if (debug() >= 9) m_graph.dumpDotFilePrefixed("splitg_colored", false);
}
virtual void visit(AstAlways* nodep) VL_OVERRIDE {
virtual void visit(AstAlways* nodep) override {
// build the scoreboard
scoreboardClear();
scanBlock(nodep->bodysp());
@ -964,7 +964,7 @@ protected:
emitSplit.go();
}
}
virtual void visit(AstNodeIf* nodep) VL_OVERRIDE {
virtual void visit(AstNodeIf* nodep) override {
UINFO(4, " IF " << nodep << endl);
m_curIfConditional = nodep;
iterateAndNextNull(nodep->condp());

16
src/V3SplitAs.cpp
View File

@ -48,12 +48,12 @@ private:
AstVarScope* m_splitVscp; // Variable we want to split
// METHODS
virtual void visit(AstVarRef* nodep) VL_OVERRIDE {
virtual void visit(AstVarRef* nodep) override {
if (nodep->lvalue() && !m_splitVscp && nodep->varp()->attrIsolateAssign()) {
m_splitVscp = nodep->varScopep();
}
}
virtual void visit(AstNode* nodep) VL_OVERRIDE { iterateChildren(nodep); }
virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
public:
// CONSTRUCTORS
@ -78,7 +78,7 @@ private:
bool m_matches; // Statement below has matching lvalue reference
// METHODS
virtual void visit(AstVarRef* nodep) VL_OVERRIDE {
virtual void visit(AstVarRef* nodep) override {
if (nodep->lvalue()) {
if (nodep->varScopep() == m_splitVscp) {
UINFO(6, " CL VAR " << nodep << endl);
@ -86,7 +86,7 @@ private:
}
}
}
virtual void visit(AstNodeStmt* nodep) VL_OVERRIDE {
virtual void visit(AstNodeStmt* nodep) override {
if (!nodep->isStatement()) {
iterateChildren(nodep);
return;
@ -112,7 +112,7 @@ private:
m_keepStmt = oldKeep || m_keepStmt;
UINFO(9, " upKeep=" << m_keepStmt << " STMT " << nodep << endl);
}
virtual void visit(AstNode* nodep) VL_OVERRIDE { iterateChildren(nodep); }
virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
public:
// CONSTRUCTORS
@ -158,7 +158,7 @@ private:
}
}
virtual void visit(AstAlways* nodep) VL_OVERRIDE {
virtual void visit(AstAlways* nodep) override {
// Are there any lvalue references below this?
// There could be more than one. So, we process the first one found first.
AstVarScope* lastSplitVscp = NULL;
@ -183,8 +183,8 @@ private:
}
// Speedup; no always under math
virtual void visit(AstNodeMath*) VL_OVERRIDE {}
virtual void visit(AstNode* nodep) VL_OVERRIDE { iterateChildren(nodep); }
virtual void visit(AstNodeMath*) override {}
virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
public:
// CONSTRUCTORS

46
src/V3SplitVar.cpp
View File

@ -351,10 +351,10 @@ public:
void remove(AstNode* nodep) {
struct Visitor : public AstNVisitor {
RefsInModule& m_parent;
virtual void visit(AstNode* nodep) VL_OVERRIDE { iterateChildren(nodep); }
virtual void visit(AstVar* nodep) VL_OVERRIDE { m_parent.m_vars.erase(nodep); }
virtual void visit(AstVarRef* nodep) VL_OVERRIDE { m_parent.m_refs.erase(nodep); }
virtual void visit(AstSel* nodep) VL_OVERRIDE {
virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
virtual void visit(AstVar* nodep) override { m_parent.m_vars.erase(nodep); }
virtual void visit(AstVarRef* nodep) override { m_parent.m_refs.erase(nodep); }
virtual void visit(AstSel* nodep) override {
m_parent.m_sels.erase(nodep);
iterateChildren(nodep);
}
@ -447,8 +447,8 @@ class SplitUnpackedVarVisitor : public AstNVisitor, public SplitVarImpl {
return refp;
}
virtual void visit(AstNode* nodep) VL_OVERRIDE { iterateChildren(nodep); }
virtual void visit(AstNodeModule* nodep) VL_OVERRIDE {
virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
virtual void visit(AstNodeModule* nodep) override {
UINFO(4, "Start checking " << nodep->prettyNameQ() << "\n");
if (!VN_IS(nodep, Module)) {
UINFO(4, "Skip " << nodep->prettyNameQ() << "\n");
@ -461,21 +461,21 @@ class SplitUnpackedVarVisitor : public AstNVisitor, public SplitVarImpl {
split();
m_modp = NULL;
}
virtual void visit(AstNodeStmt* nodep) VL_OVERRIDE { setContextAndIterateChildren(nodep); }
virtual void visit(AstCell* nodep) VL_OVERRIDE { setContextAndIterateChildren(nodep); }
virtual void visit(AstAlways* nodep) VL_OVERRIDE {
virtual void visit(AstNodeStmt* nodep) override { setContextAndIterateChildren(nodep); }
virtual void visit(AstCell* nodep) override { setContextAndIterateChildren(nodep); }
virtual void visit(AstAlways* nodep) override {
if (nodep->sensesp()) { // When visiting sensitivity list, always is the context
setContextAndIterate(nodep, nodep->sensesp());
}
if (AstNode* bodysp = nodep->bodysp()) iterate(bodysp);
};
virtual void visit(AstAlwaysPublic* nodep) VL_OVERRIDE {
virtual void visit(AstAlwaysPublic* nodep) override {
if (nodep->sensesp()) { // When visiting sensitivity list, always is the context
setContextAndIterate(nodep, nodep->sensesp());
}
if (AstNode* bodysp = nodep->bodysp()) iterate(bodysp);
}
virtual void visit(AstNodeFTaskRef* nodep) VL_OVERRIDE {
virtual void visit(AstNodeFTaskRef* nodep) override {
AstNode* origContextp = m_contextp;
{
m_contextp = nodep;
@ -514,7 +514,7 @@ class SplitUnpackedVarVisitor : public AstNVisitor, public SplitVarImpl {
}
m_contextp = origContextp;
}
virtual void visit(AstPin* nodep) VL_OVERRIDE {
virtual void visit(AstPin* nodep) override {
UINFO(5, nodep->modVarp()->prettyNameQ() << " pin \n");
AstNode* exprp = nodep->exprp();
if (!exprp) return; // Not connected pin
@ -529,7 +529,7 @@ class SplitUnpackedVarVisitor : public AstNVisitor, public SplitVarImpl {
m_foundTargetVar.clear();
}
}
virtual void visit(AstNodeFTask* nodep) VL_OVERRIDE {
virtual void visit(AstNodeFTask* nodep) override {
UASSERT_OBJ(!m_inFTask, nodep, "Nested func/task");
if (!cannotSplitTaskReason(nodep)) {
m_inFTask = nodep;
@ -537,7 +537,7 @@ class SplitUnpackedVarVisitor : public AstNVisitor, public SplitVarImpl {
m_inFTask = NULL;
}
}
virtual void visit(AstVar* nodep) VL_OVERRIDE {
virtual void visit(AstVar* nodep) override {
if (!nodep->attrSplitVar()) return; // Nothing to do
if (!cannotSplitReason(nodep)) {
m_refs.registerVar(nodep);
@ -545,18 +545,18 @@ class SplitUnpackedVarVisitor : public AstNVisitor, public SplitVarImpl {
}
m_refsForPackedSplit[m_modp].add(nodep);
}
virtual void visit(AstVarRef* nodep) VL_OVERRIDE {
virtual void visit(AstVarRef* nodep) override {
if (!nodep->varp()->attrSplitVar()) return; // Nothing to do
if (m_refs.tryAdd(m_contextp, nodep, m_inFTask)) {
m_foundTargetVar.insert(nodep->varp());
}
m_refsForPackedSplit[m_modp].add(nodep);
}
virtual void visit(AstSel* nodep) VL_OVERRIDE {
virtual void visit(AstSel* nodep) override {
if (VN_IS(nodep->fromp(), VarRef)) m_refsForPackedSplit[m_modp].add(nodep);
iterateChildren(nodep);
}
virtual void visit(AstArraySel* nodep) VL_OVERRIDE {
virtual void visit(AstArraySel* nodep) override {
if (AstVarRef* refp = isTargetVref(nodep->fromp())) {
AstConst* indexp = VN_CAST(nodep->bitp(), Const);
if (indexp) { // OK
@ -580,7 +580,7 @@ class SplitUnpackedVarVisitor : public AstNVisitor, public SplitVarImpl {
iterateChildren(nodep);
}
}
virtual void visit(AstSliceSel* nodep) VL_OVERRIDE {
virtual void visit(AstSliceSel* nodep) override {
if (AstVarRef* refp = isTargetVref(nodep->fromp())) {
AstUnpackArrayDType* dtypep
= VN_CAST(refp->varp()->dtypep()->skipRefp(), UnpackArrayDType);
@ -970,10 +970,10 @@ class SplitPackedVarVisitor : public AstNVisitor, public SplitVarImpl {
int m_numSplit; // Total number of split variables
// key:variable to be split. value:location where the variable is referenced.
PackedVarRefMap m_refs;
virtual void visit(AstNodeFTask* nodep) VL_OVERRIDE {
virtual void visit(AstNodeFTask* nodep) override {
if (!cannotSplitTaskReason(nodep)) iterateChildren(nodep);
}
virtual void visit(AstVar* nodep) VL_OVERRIDE {
virtual void visit(AstVar* nodep) override {
if (!nodep->attrSplitVar()) return; // Nothing to do
if (const char* reason = cannotSplitReason(nodep, true)) {
nodep->v3warn(SPLITVAR, nodep->prettyNameQ() << notSplitMsg << reason);
@ -983,7 +983,7 @@ class SplitPackedVarVisitor : public AstNVisitor, public SplitVarImpl {
if (inserted) { UINFO(3, nodep->prettyNameQ() << " is added to candidate list.\n"); }
}
}
virtual void visit(AstVarRef* nodep) VL_OVERRIDE {
virtual void visit(AstVarRef* nodep) override {
AstVar* varp = nodep->varp();
visit(varp);
PackedVarRefMap::iterator refit = m_refs.find(varp);
@ -997,7 +997,7 @@ class SplitPackedVarVisitor : public AstNVisitor, public SplitVarImpl {
UINFO(5, varp->prettyName()
<< " Entire bit of [" << basicp->lsb() << ":+" << varp->width() << "] \n");
}
virtual void visit(AstSel* nodep) VL_OVERRIDE {
virtual void visit(AstSel* nodep) override {
AstVarRef* vrefp = VN_CAST(nodep->fromp(), VarRef);
if (!vrefp) {
iterateChildren(nodep);
@ -1036,7 +1036,7 @@ class SplitPackedVarVisitor : public AstNVisitor, public SplitVarImpl {
iterateChildren(nodep);
}
}
virtual void visit(AstNode* nodep) VL_OVERRIDE { iterateChildren(nodep); }
virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
// Extract necessary bit range from a newly created variable to meet ref
static AstNode* extractBits(const PackedVarRefEntry& ref, const SplitNewVar& var,

18
src/V3Stats.cpp
View File

@ -75,7 +75,7 @@ private:
}
// VISITORS
virtual void visit(AstNodeModule* nodep) VL_OVERRIDE {
virtual void visit(AstNodeModule* nodep) override {
allNodes(nodep);
if (!m_fast) {
// Count all CFuncs below this module
@ -84,7 +84,7 @@ private:
// Else we recursively trace fast CFuncs from the top _eval
// func, see visit(AstNetlist*)
}
virtual void visit(AstVar* nodep) VL_OVERRIDE {
virtual void visit(AstVar* nodep) override {
allNodes(nodep);
iterateChildrenConst(nodep);
if (m_counting && nodep->dtypep()) {
@ -110,7 +110,7 @@ private:
}
}
}
virtual void visit(AstVarScope* nodep) VL_OVERRIDE {
virtual void visit(AstVarScope* nodep) override {
allNodes(nodep);
iterateChildrenConst(nodep);
if (m_counting) {
@ -119,7 +119,7 @@ private:
}
}
}
virtual void visit(AstNodeIf* nodep) VL_OVERRIDE {
virtual void visit(AstNodeIf* nodep) override {
UINFO(4, " IF i=" << m_instrs << " " << nodep << endl);
allNodes(nodep);
// Condition is part of cost allocated to PREVIOUS block
@ -169,9 +169,9 @@ private:
}
}
// While's we assume evaluate once.
// virtual void visit(AstWhile* nodep) VL_OVERRIDE {
// virtual void visit(AstWhile* nodep) override {
virtual void visit(AstNodeCCall* nodep) VL_OVERRIDE {
virtual void visit(AstNodeCCall* nodep) override {
allNodes(nodep);
iterateChildrenConst(nodep);
if (m_fast && !nodep->funcp()->entryPoint()) {
@ -180,7 +180,7 @@ private:
iterate(nodep->funcp());
}
}
virtual void visit(AstCFunc* nodep) VL_OVERRIDE {
virtual void visit(AstCFunc* nodep) override {
if (m_fast) {
if (!m_tracingCall && !nodep->entryPoint()) return;
m_tracingCall = false;
@ -190,11 +190,11 @@ private:
iterateChildrenConst(nodep);
m_cfuncp = NULL;
}
virtual void visit(AstNode* nodep) VL_OVERRIDE {
virtual void visit(AstNode* nodep) override {
allNodes(nodep);
iterateChildrenConst(nodep);
}
virtual void visit(AstNetlist* nodep) VL_OVERRIDE {
virtual void visit(AstNetlist* nodep) override {
if (m_fast && nodep->evalp()) {
m_instrs = 0;
m_counting = true;

4
src/V3StatsReport.cpp
View File

@ -25,7 +25,7 @@
#include <iomanip>
#include <map>
#include VL_INCLUDE_UNORDERED_MAP
#include <unordered_map>
//######################################################################
// Stats dumping
@ -117,7 +117,7 @@ class StatsReport {
size_t maxWidth = 0;
typedef std::vector<string> Stages;
Stages stages;
vl_unordered_map<string, int> stageInt;
std::unordered_map<string, int> stageInt;
typedef std::multimap<string, const V3Statistic*> ByName;
ByName byName;
// * is always first

18
src/V3Subst.cpp
View File

@ -190,7 +190,7 @@ private:
return reinterpret_cast<SubstVarEntry*>(nodep->varp()->user1p()); // Might be NULL
}
// VISITORS
virtual void visit(AstVarRef* nodep) VL_OVERRIDE {
virtual void visit(AstVarRef* nodep) override {
SubstVarEntry* entryp = findEntryp(nodep);
if (entryp) {
// Don't sweat it. We assign a new temp variable for every new assignment,
@ -205,8 +205,8 @@ private:
}
}
}
virtual void visit(AstConst*) VL_OVERRIDE {} // Accelerate
virtual void visit(AstNode* nodep) VL_OVERRIDE { iterateChildren(nodep); }
virtual void visit(AstConst*) override {} // Accelerate
virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
public:
// CONSTRUCTORS
@ -259,7 +259,7 @@ private:
inline bool isSubstVar(AstVar* nodep) { return nodep->isStatementTemp() && !nodep->noSubst(); }
// VISITORS
virtual void visit(AstNodeAssign* nodep) VL_OVERRIDE {
virtual void visit(AstNodeAssign* nodep) override {
m_ops = 0;
m_assignStep++;
iterateAndNextNull(nodep->rhsp());
@ -305,7 +305,7 @@ private:
VL_DO_DANGLING(pushDeletep(nodep), nodep);
++m_statSubsts;
}
virtual void visit(AstWordSel* nodep) VL_OVERRIDE {
virtual void visit(AstWordSel* nodep) override {
iterate(nodep->rhsp());
AstVarRef* varrefp = VN_CAST(nodep->lhsp(), VarRef);
AstConst* constp = VN_CAST(nodep->rhsp(), Const);
@ -330,7 +330,7 @@ private:
iterate(nodep->lhsp());
}
}
virtual void visit(AstVarRef* nodep) VL_OVERRIDE {
virtual void visit(AstVarRef* nodep) override {
// Any variable
if (nodep->lvalue()) {
m_assignStep++;
@ -358,9 +358,9 @@ private:
}
}
}
virtual void visit(AstVar*) VL_OVERRIDE {}
virtual void visit(AstConst*) VL_OVERRIDE {}
virtual void visit(AstNode* nodep) VL_OVERRIDE {
virtual void visit(AstVar*) override {}
virtual void visit(AstConst*) override {}
virtual void visit(AstNode* nodep) override {
m_ops++;
if (!nodep->isSubstOptimizable()) m_ops = SUBST_MAX_OPS_NA;
iterateChildren(nodep);

2
src/V3SymTable.h
View File

@ -317,7 +317,7 @@ public:
if (v3Global.opt.dumpTree()) {
string filename = v3Global.debugFilename(nameComment) + ".txt";
UINFO(2, "Dumping " << filename << endl);
const vl_unique_ptr<std::ofstream> logp(V3File::new_ofstream(filename));
const std::unique_ptr<std::ofstream> logp(V3File::new_ofstream(filename));
if (logp->fail()) v3fatal("Can't write " << filename);
dump(*logp, "");
}

20
src/V3TSP.cpp
View File

@ -35,8 +35,8 @@
#include <sstream>
#include <string>
#include <vector>
#include VL_INCLUDE_UNORDERED_SET
#include VL_INCLUDE_UNORDERED_MAP
#include <unordered_set>
#include <unordered_map>
//######################################################################
// Support classes
@ -74,7 +74,7 @@ public:
typedef TspVertexTmpl<T_Key> Vertex;
// MEMBERS
typedef vl_unordered_map<T_Key, Vertex*> VMap;
typedef std::unordered_map<T_Key, Vertex*> VMap;
VMap m_vertices; // T_Key to Vertex lookup map
// CONSTRUCTORS
@ -149,7 +149,7 @@ public:
UASSERT(mstp->empty(), "Output graph must start empty");
// Use Prim's algorithm to efficiently construct the MST.
vl_unordered_set<Vertex*> visited_set;
std::unordered_set<Vertex*> visited_set;
EdgeCmp cmp;
typedef std::set<V3GraphEdge*, EdgeCmp&> PendingEdgeSet;
@ -221,7 +221,7 @@ public:
UASSERT(outp->empty(), "Output graph must start empty");
std::list<Vertex*> odds = keysToVertexList(oddKeys);
vl_unordered_set<Vertex*> unmatchedOdds;
std::unordered_set<Vertex*> unmatchedOdds;
typedef typename std::list<Vertex*>::iterator VertexListIt;
for (VertexListIt it = odds.begin(); it != odds.end(); ++it) {
outp->addVertex((*it)->key());
@ -274,7 +274,7 @@ public:
}
void combineGraph(const TspGraphTmpl& g) {
vl_unordered_set<vluint32_t> edges_done;
std::unordered_set<vluint32_t> edges_done;
for (V3GraphVertex* vxp = g.verticesBeginp(); vxp; vxp = vxp->verticesNextp()) {
Vertex* fromp = castVertexp(vxp);
for (V3GraphEdge* edgep = fromp->outBeginp(); edgep; edgep = edgep->outNextp()) {
@ -287,7 +287,7 @@ public:
}
}
void findEulerTourRecurse(vl_unordered_set<unsigned>* markedEdgesp, Vertex* startp,
void findEulerTourRecurse(std::unordered_set<unsigned>* markedEdgesp, Vertex* startp,
std::vector<T_Key>* sortedOutp) {
Vertex* cur_vertexp = startp;
@ -360,7 +360,7 @@ public:
void dumpGraphFilePrefixed(const string& nameComment) const {
if (v3Global.opt.dumpTree()) {
string filename = v3Global.debugFilename(nameComment) + ".txt";
const vl_unique_ptr<std::ofstream> logp(V3File::new_ofstream(filename));
const std::unique_ptr<std::ofstream> logp(V3File::new_ofstream(filename));
if (logp->fail()) v3fatal("Can't write " << filename);
dumpGraph(*logp, nameComment);
}
@ -369,7 +369,7 @@ public:
void findEulerTour(std::vector<T_Key>* sortedOutp) {
UASSERT(sortedOutp->empty(), "Output graph must start empty");
if (debug() >= 6) dumpDotFilePrefixed("findEulerTour");
vl_unordered_set<unsigned /*edgeID*/> markedEdges;
std::unordered_set<unsigned /*edgeID*/> markedEdges;
// Pick a start node
Vertex* start_vertexp = castVertexp(verticesBeginp());
findEulerTourRecurse(&markedEdges, start_vertexp, sortedOutp);
@ -446,7 +446,7 @@ void V3TSP::tspSort(const V3TSP::StateVec& states, V3TSP::StateVec* resultp) {
// Discard duplicate nodes that the Euler tour might contain.
{
vl_unordered_set<const TspStateBase*> seen;
std::unordered_set<const TspStateBase*> seen;
for (V3TSP::StateVec::iterator it = prelim_result.begin(); it != prelim_result.end();
++it) {
const TspStateBase* elemp = *it;

14
src/V3Table.cpp
View File

@ -413,8 +413,8 @@ private:
}
// VISITORS
virtual void visit(AstNetlist* nodep) VL_OVERRIDE { iterateChildren(nodep); }
virtual void visit(AstNodeModule* nodep) VL_OVERRIDE {
virtual void visit(AstNetlist* nodep) override { iterateChildren(nodep); }
virtual void visit(AstNodeModule* nodep) override {
AstNodeModule* origModp = m_modp;
int origModTables = m_modTables;
ModTableVector origModTableVscs = m_modTableVscs;
@ -428,26 +428,26 @@ private:
m_modTables = origModTables;
m_modTableVscs = origModTableVscs;
}
virtual void visit(AstScope* nodep) VL_OVERRIDE {
virtual void visit(AstScope* nodep) override {
UINFO(4, " SCOPE " << nodep << endl);
m_scopep = nodep;
iterateChildren(nodep);
m_scopep = NULL;
}
virtual void visit(AstAlways* nodep) VL_OVERRIDE {
virtual void visit(AstAlways* nodep) override {
UINFO(4, " ALWAYS " << nodep << endl);
if (treeTest(nodep)) {
// Well, then, I'll be a memory hog.
VL_DO_DANGLING(createTable(nodep), nodep);
}
}
virtual void visit(AstAssignAlias*) VL_OVERRIDE {}
virtual void visit(AstAssignW* nodep) VL_OVERRIDE {
virtual void visit(AstAssignAlias*) override {}
virtual void visit(AstAssignW* nodep) override {
// It's nearly impossible to have a large enough assign to make this worthwhile
// For now we won't bother.
// Accelerated: no iterate
}
virtual void visit(AstNode* nodep) VL_OVERRIDE { iterateChildren(nodep); }
virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
public:
// CONSTRUCTORS

42
src/V3Task.cpp
View File

@ -159,7 +159,7 @@ private:
}
// VISITORS
virtual void visit(AstScope* nodep) VL_OVERRIDE {
virtual void visit(AstScope* nodep) override {
// Each FTask is unique per-scope, so AstNodeFTaskRefs do not need
// pointers to what scope the FTask is to be invoked under.
// However, to create variables, we need to track the scopes involved.
@ -179,12 +179,12 @@ private:
}
iterateChildren(nodep);
}
virtual void visit(AstAssignW* nodep) VL_OVERRIDE {
virtual void visit(AstAssignW* nodep) override {
m_assignwp = nodep;
VL_DO_DANGLING(iterateChildren(nodep), nodep); // May delete nodep.
m_assignwp = NULL;
}
virtual void visit(AstNodeFTaskRef* nodep) VL_OVERRIDE {
virtual void visit(AstNodeFTaskRef* nodep) override {
// Includes handling AstMethodCall, AstNew
if (m_assignwp) {
// Wire assigns must become always statements to deal with insertion
@ -197,7 +197,7 @@ private:
UASSERT_OBJ(nodep->taskp(), nodep, "Unlinked task");
new TaskEdge(&m_callGraph, m_curVxp, getFTaskVertex(nodep->taskp()));
}
virtual void visit(AstNodeFTask* nodep) VL_OVERRIDE {
virtual void visit(AstNodeFTask* nodep) override {
UINFO(9, " TASK " << nodep << endl);
TaskBaseVertex* lastVxp = m_curVxp;
m_curVxp = getFTaskVertex(nodep);
@ -210,7 +210,7 @@ private:
iterateChildren(nodep);
m_curVxp = lastVxp;
}
virtual void visit(AstPragma* nodep) VL_OVERRIDE {
virtual void visit(AstPragma* nodep) override {
if (nodep->pragType() == AstPragmaType::NO_INLINE_TASK) {
// Just mark for the next steps, and we're done with it.
m_curVxp->noInline(true);
@ -219,17 +219,17 @@ private:
iterateChildren(nodep);
}
}
virtual void visit(AstVar* nodep) VL_OVERRIDE {
virtual void visit(AstVar* nodep) override {
iterateChildren(nodep);
nodep->user4p(m_curVxp); // Remember what task it's under
}
virtual void visit(AstVarRef* nodep) VL_OVERRIDE {
virtual void visit(AstVarRef* nodep) override {
iterateChildren(nodep);
if (nodep->varp()->user4u().toGraphVertex() != m_curVxp) {
if (m_curVxp->pure() && !nodep->varp()->isXTemp()) m_curVxp->impure(nodep);
}
}
virtual void visit(AstClass* nodep) VL_OVERRIDE {
virtual void visit(AstClass* nodep) override {
// Move initial statements into the constructor
m_initialps.clear();
m_ctorp = NULL;
@ -252,12 +252,12 @@ private:
m_initialps.clear();
m_ctorp = NULL;
}
virtual void visit(AstInitial* nodep) VL_OVERRIDE {
virtual void visit(AstInitial* nodep) override {
m_initialps.push_back(nodep);
iterateChildren(nodep);
}
//--------------------
virtual void visit(AstNode* nodep) VL_OVERRIDE { iterateChildren(nodep); }
virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
public:
// CONSTRUCTORS
@ -287,7 +287,7 @@ private:
// AstVar::user2p // AstVarScope* to replace varref with
// VISITORS
virtual void visit(AstVarRef* nodep) VL_OVERRIDE {
virtual void visit(AstVarRef* nodep) override {
// Similar code in V3Inline
if (nodep->varp()->user2p()) { // It's being converted to an alias.
UINFO(9,
@ -302,7 +302,7 @@ private:
}
//--------------------
virtual void visit(AstNode* nodep) VL_OVERRIDE { iterateChildren(nodep); }
virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
public:
// CONSTRUCTORS
@ -1175,7 +1175,7 @@ private:
}
// VISITORS
virtual void visit(AstNodeModule* nodep) VL_OVERRIDE {
virtual void visit(AstNodeModule* nodep) override {
AstNodeModule* origModp = m_modp;
int origNCalls = m_modNCalls;
{
@ -1187,17 +1187,17 @@ private:
m_modp = origModp;
m_modNCalls = origNCalls;
}
virtual void visit(AstTopScope* nodep) VL_OVERRIDE {
virtual void visit(AstTopScope* nodep) override {
m_topScopep = nodep;
iterateChildren(nodep);
}
virtual void visit(AstScope* nodep) VL_OVERRIDE {
virtual void visit(AstScope* nodep) override {
m_scopep = nodep;
m_insStmtp = NULL;
iterateChildren(nodep);
m_scopep = NULL;
}
virtual void visit(AstNodeFTaskRef* nodep) VL_OVERRIDE {
virtual void visit(AstNodeFTaskRef* nodep) override {
// Includes handling AstMethodCall, AstNew
UASSERT_OBJ(nodep->taskp(), nodep, "Unlinked?");
iterateIntoFTask(nodep->taskp()); // First, do hierarchical funcs
@ -1251,7 +1251,7 @@ private:
// Visit nodes that normal iteration won't find
if (visitp) iterateAndNextNull(visitp);
}
virtual void visit(AstNodeFTask* nodep) VL_OVERRIDE {
virtual void visit(AstNodeFTask* nodep) override {
UINFO(4, " Inline " << nodep << endl);
InsertMode prevInsMode = m_insMode;
AstNode* prevInsStmtp = m_insStmtp;
@ -1319,7 +1319,7 @@ private:
m_insMode = prevInsMode;
m_insStmtp = prevInsStmtp;
}
virtual void visit(AstWhile* nodep) VL_OVERRIDE {
virtual void visit(AstWhile* nodep) override {
// Special, as statements need to be put in different places
// Preconditions insert first just before themselves (the normal
// rule for other statement types)
@ -1336,11 +1336,11 @@ private:
// Done the loop
m_insStmtp = NULL; // Next thing should be new statement
}
virtual void visit(AstNodeFor* nodep) VL_OVERRIDE { // LCOV_EXCL_LINE
virtual void visit(AstNodeFor* nodep) override { // LCOV_EXCL_LINE
nodep->v3fatalSrc(
"For statements should have been converted to while statements in V3Begin.cpp");
}
virtual void visit(AstNodeStmt* nodep) VL_OVERRIDE {
virtual void visit(AstNodeStmt* nodep) override {
if (!nodep->isStatement()) {
iterateChildren(nodep);
return;
@ -1351,7 +1351,7 @@ private:
m_insStmtp = NULL; // Next thing should be new statement
}
//--------------------
virtual void visit(AstNode* nodep) VL_OVERRIDE { iterateChildren(nodep); }
virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
public:
// CONSTRUCTORS

16
src/V3Trace.cpp
View File

@ -773,7 +773,7 @@ private:
}
// VISITORS
virtual void visit(AstNetlist* nodep) VL_OVERRIDE {
virtual void visit(AstNetlist* nodep) override {
m_code = 1; // Multiple TopScopes will require fixing how code#s
// are assigned as duplicate varscopes must result in the same tracing code#.
@ -788,17 +788,17 @@ private:
// Create the trace functions and insert them into the tree
createTraceFunctions();
}
virtual void visit(AstNodeModule* nodep) VL_OVERRIDE {
virtual void visit(AstNodeModule* nodep) override {
if (nodep->isTop()) m_topModp = nodep;
iterateChildren(nodep);
}
virtual void visit(AstTopScope* nodep) VL_OVERRIDE {
virtual void visit(AstTopScope* nodep) override {
AstScope* const scopep = nodep->scopep();
UASSERT_OBJ(scopep, nodep, "No scope found on top level");
m_topScopep = scopep;
iterateChildren(nodep);
}
virtual void visit(AstCCall* nodep) VL_OVERRIDE {
virtual void visit(AstCCall* nodep) override {
UINFO(8, " CCALL " << nodep << endl);
if (!m_finding && !nodep->user2()) {
// See if there are other calls in same statement list;
@ -817,7 +817,7 @@ private:
}
iterateChildren(nodep);
}
virtual void visit(AstCFunc* nodep) VL_OVERRIDE {
virtual void visit(AstCFunc* nodep) override {
UINFO(8, " CFUNC " << nodep << endl);
V3GraphVertex* const funcVtxp = getCFuncVertexp(nodep);
if (!m_finding) { // If public, we need a unique activity code to allow for sets
@ -831,7 +831,7 @@ private:
iterateChildren(nodep);
m_funcp = NULL;
}
virtual void visit(AstTraceDecl* nodep) VL_OVERRIDE {
virtual void visit(AstTraceDecl* nodep) override {
UINFO(8, " TRACE " << nodep << endl);
if (!m_finding) {
V3GraphVertex* const vertexp = new TraceTraceVertex(&m_graph, nodep);
@ -843,7 +843,7 @@ private:
m_tracep = NULL;
}
}
virtual void visit(AstVarRef* nodep) VL_OVERRIDE {
virtual void visit(AstVarRef* nodep) override {
if (m_tracep) {
UASSERT_OBJ(nodep->varScopep(), nodep, "No var scope?");
UASSERT_OBJ(!nodep->lvalue(), nodep, "Lvalue in trace? Should be const.");
@ -868,7 +868,7 @@ private:
}
}
//--------------------
virtual void visit(AstNode* nodep) VL_OVERRIDE { iterateChildren(nodep); }
virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
public:
// CONSTRUCTORS

24
src/V3TraceDecl.cpp
View File

@ -124,7 +124,7 @@ private:
}
// VISITORS
virtual void visit(AstTopScope* nodep) VL_OVERRIDE {
virtual void visit(AstTopScope* nodep) override {
m_topScopep = nodep->scopep();
// Create the trace init function
m_initFuncp = newCFunc(AstCFuncType::TRACE_INIT, "traceInitTop");
@ -133,7 +133,7 @@ private:
// And find variables
iterateChildren(nodep);
}
virtual void visit(AstScope* nodep) VL_OVERRIDE {
virtual void visit(AstScope* nodep) override {
AstCell* const cellp = VN_CAST(nodep->aboveCellp(), Cell);
if (cellp && VN_IS(cellp->modp(), Iface)) {
AstCFunc* const origSubFunc = m_initSubFuncp;
@ -171,7 +171,7 @@ private:
iterateChildren(nodep);
}
}
virtual void visit(AstVarScope* nodep) VL_OVERRIDE {
virtual void visit(AstVarScope* nodep) override {
iterateChildren(nodep);
// Prefilter - things that get through this if will either get
// traced or get a comment as to why not traced.
@ -213,13 +213,13 @@ private:
}
}
// VISITORS - Data types when tracing
virtual void visit(AstConstDType* nodep) VL_OVERRIDE {
virtual void visit(AstConstDType* nodep) override {
if (m_traVscp) iterate(nodep->subDTypep()->skipRefToEnump());
}
virtual void visit(AstRefDType* nodep) VL_OVERRIDE {
virtual void visit(AstRefDType* nodep) override {
if (m_traVscp) iterate(nodep->subDTypep()->skipRefToEnump());
}
virtual void visit(AstUnpackArrayDType* nodep) VL_OVERRIDE {
virtual void visit(AstUnpackArrayDType* nodep) override {
// Note more specific dtypes above
if (m_traVscp) {
if (static_cast<int>(nodep->arrayUnpackedElements()) > v3Global.opt.traceMaxArray()) {
@ -256,7 +256,7 @@ private:
}
}
}
virtual void visit(AstPackArrayDType* nodep) VL_OVERRIDE {
virtual void visit(AstPackArrayDType* nodep) override {
if (m_traVscp) {
if (!v3Global.opt.traceStructs()) {
// Everything downstream is packed, so deal with as one trace unit.
@ -283,7 +283,7 @@ private:
}
}
}
virtual void visit(AstNodeUOrStructDType* nodep) VL_OVERRIDE {
virtual void visit(AstNodeUOrStructDType* nodep) override {
if (m_traVscp) {
if (nodep->packed() && !v3Global.opt.traceStructs()) {
// Everything downstream is packed, so deal with as one trace unit
@ -317,7 +317,7 @@ private:
}
}
}
virtual void visit(AstBasicDType* nodep) VL_OVERRIDE {
virtual void visit(AstBasicDType* nodep) override {
if (m_traVscp) {
if (nodep->isString()) {
addIgnore("Unsupported: strings");
@ -326,15 +326,15 @@ private:
}
}
}
virtual void visit(AstEnumDType* nodep) VL_OVERRIDE { iterate(nodep->skipRefp()); }
virtual void visit(AstNodeDType* nodep) VL_OVERRIDE {
virtual void visit(AstEnumDType* nodep) override { iterate(nodep->skipRefp()); }
virtual void visit(AstNodeDType* nodep) override {
// Note more specific dtypes above
if (!m_traVscp) return;
addIgnore("Unsupported: data type");
}
//--------------------
virtual void visit(AstNode* nodep) VL_OVERRIDE { iterateChildren(nodep); }
virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
public:
// CONSTRUCTORS

56
src/V3Tristate.cpp
View File

@ -278,7 +278,7 @@ class TristatePinVisitor : public TristateBaseVisitor {
TristateGraph& m_tgraph;
bool m_lvalue; // Flip to be an LVALUE
// VISITORS
virtual void visit(AstVarRef* nodep) VL_OVERRIDE {
virtual void visit(AstVarRef* nodep) override {
if (m_lvalue && !nodep->lvalue()) {
UINFO(9, " Flip-to-LValue " << nodep << endl);
nodep->lvalue(true);
@ -290,17 +290,17 @@ class TristatePinVisitor : public TristateBaseVisitor {
m_tgraph.setTristate(nodep->varp());
}
}
virtual void visit(AstArraySel* nodep) VL_OVERRIDE {
virtual void visit(AstArraySel* nodep) override {
// Doesn't work because we'd set lvalue on the array index's var
UASSERT_OBJ(!m_lvalue, nodep, "ArraySel conversion to output, under tristate node");
iterateChildren(nodep);
}
virtual void visit(AstSliceSel* nodep) VL_OVERRIDE {
virtual void visit(AstSliceSel* nodep) override {
// Doesn't work because we'd set lvalue on the array index's var
UASSERT_OBJ(!m_lvalue, nodep, "SliceSel conversion to output, under tristate node");
iterateChildren(nodep);
}
virtual void visit(AstNode* nodep) VL_OVERRIDE { iterateChildren(nodep); }
virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
public:
// CONSTRUCTORS
@ -639,7 +639,7 @@ class TristateVisitor : public TristateBaseVisitor {
}
// VISITORS
virtual void visit(AstConst* nodep) VL_OVERRIDE {
virtual void visit(AstConst* nodep) override {
UINFO(9, dbgState() << nodep << endl);
if (m_graphing) {
if (!m_alhs && nodep->num().hasZ()) m_tgraph.setTristate(nodep);
@ -672,7 +672,7 @@ class TristateVisitor : public TristateBaseVisitor {
}
}
virtual void visit(AstCond* nodep) VL_OVERRIDE {
virtual void visit(AstCond* nodep) override {
if (m_graphing) {
iterateChildren(nodep);
if (m_alhs) {
@ -716,7 +716,7 @@ class TristateVisitor : public TristateBaseVisitor {
}
}
virtual void visit(AstSel* nodep) VL_OVERRIDE {
virtual void visit(AstSel* nodep) override {
if (m_graphing) {
iterateChildren(nodep);
if (m_alhs) {
@ -755,7 +755,7 @@ class TristateVisitor : public TristateBaseVisitor {
}
}
virtual void visit(AstConcat* nodep) VL_OVERRIDE {
virtual void visit(AstConcat* nodep) override {
if (m_graphing) {
iterateChildren(nodep);
if (m_alhs) {
@ -801,7 +801,7 @@ class TristateVisitor : public TristateBaseVisitor {
}
}
virtual void visit(AstBufIf1* nodep) VL_OVERRIDE {
virtual void visit(AstBufIf1* nodep) override {
// For BufIf1, the enable is the LHS expression
iterateChildren(nodep);
UINFO(9, dbgState() << nodep << endl);
@ -885,8 +885,8 @@ class TristateVisitor : public TristateBaseVisitor {
expr2p->user1p(NULL);
}
}
virtual void visit(AstAnd* nodep) VL_OVERRIDE { visitAndOr(nodep, true); }
virtual void visit(AstOr* nodep) VL_OVERRIDE { visitAndOr(nodep, false); }
virtual void visit(AstAnd* nodep) override { visitAndOr(nodep, true); }
virtual void visit(AstOr* nodep) override { visitAndOr(nodep, false); }
void visitAssign(AstNodeAssign* nodep) {
if (m_graphing) {
@ -923,8 +923,8 @@ class TristateVisitor : public TristateBaseVisitor {
m_alhs = false;
}
}
virtual void visit(AstAssignW* nodep) VL_OVERRIDE { visitAssign(nodep); }
virtual void visit(AstAssign* nodep) VL_OVERRIDE { visitAssign(nodep); }
virtual void visit(AstAssignW* nodep) override { visitAssign(nodep); }
virtual void visit(AstAssign* nodep) override { visitAssign(nodep); }
void visitCaseEq(AstNodeBiop* nodep, bool neq) {
if (m_graphing) {
@ -976,12 +976,12 @@ class TristateVisitor : public TristateBaseVisitor {
return;
}
}
virtual void visit(AstEqCase* nodep) VL_OVERRIDE { visitCaseEq(nodep, false); }
virtual void visit(AstNeqCase* nodep) VL_OVERRIDE { visitCaseEq(nodep, true); }
virtual void visit(AstEqWild* nodep) VL_OVERRIDE { visitEqNeqWild(nodep); }
virtual void visit(AstNeqWild* nodep) VL_OVERRIDE { visitEqNeqWild(nodep); }
virtual void visit(AstEqCase* nodep) override { visitCaseEq(nodep, false); }
virtual void visit(AstNeqCase* nodep) override { visitCaseEq(nodep, true); }
virtual void visit(AstEqWild* nodep) override { visitEqNeqWild(nodep); }
virtual void visit(AstNeqWild* nodep) override { visitEqNeqWild(nodep); }
virtual void visit(AstPull* nodep) VL_OVERRIDE {
virtual void visit(AstPull* nodep) override {
UINFO(9, dbgState() << nodep << endl);
AstVarRef* varrefp = NULL;
if (VN_IS(nodep->lhsp(), VarRef)) {
@ -1056,7 +1056,7 @@ class TristateVisitor : public TristateBaseVisitor {
// __out(to-resolver-only)
// const inout Spec says illegal
// const output Unsupported; Illegal?
virtual void visit(AstPin* nodep) VL_OVERRIDE {
virtual void visit(AstPin* nodep) override {
if (m_graphing) {
if (nodep->user2() & U2_GRAPHING) return; // This pin is already expanded
nodep->user2(U2_GRAPHING);
@ -1215,7 +1215,7 @@ class TristateVisitor : public TristateBaseVisitor {
}
}
virtual void visit(AstVarRef* nodep) VL_OVERRIDE {
virtual void visit(AstVarRef* nodep) override {
UINFO(9, dbgState() << nodep << endl);
if (m_graphing) {
if (nodep->lvalue()) {
@ -1249,7 +1249,7 @@ class TristateVisitor : public TristateBaseVisitor {
}
}
virtual void visit(AstVar* nodep) VL_OVERRIDE {
virtual void visit(AstVar* nodep) override {
iterateChildren(nodep);
UINFO(9, dbgState() << nodep << endl);
if (m_graphing) {
@ -1282,7 +1282,7 @@ class TristateVisitor : public TristateBaseVisitor {
}
}
virtual void visit(AstNodeModule* nodep) VL_OVERRIDE {
virtual void visit(AstNodeModule* nodep) override {
UINFO(8, nodep << endl);
AstNodeModule* origModp = m_modp;
bool origGraphing = m_graphing;
@ -1318,29 +1318,29 @@ class TristateVisitor : public TristateBaseVisitor {
m_tgraph.clear(); // Recursion not supported
}
virtual void visit(AstClass* nodep) VL_OVERRIDE {
virtual void visit(AstClass* nodep) override {
// don't deal with classes
}
virtual void visit(AstNodeFTask* nodep) VL_OVERRIDE {
virtual void visit(AstNodeFTask* nodep) override {
// don't deal with functions
}
virtual void visit(AstCaseItem* nodep) VL_OVERRIDE {
virtual void visit(AstCaseItem* nodep) override {
// don't deal with casez compare '???? values
iterateAndNextNull(nodep->bodysp());
}
virtual void visit(AstCell* nodep) VL_OVERRIDE {
virtual void visit(AstCell* nodep) override {
m_cellp = nodep;
m_alhs = false;
iterateChildren(nodep);
m_cellp = NULL;
}
virtual void visit(AstNetlist* nodep) VL_OVERRIDE { iterateChildrenBackwards(nodep); }
virtual void visit(AstNetlist* nodep) override { iterateChildrenBackwards(nodep); }
// Default: Just iterate
virtual void visit(AstNode* nodep) VL_OVERRIDE {
virtual void visit(AstNode* nodep) override {
iterateChildren(nodep);
checkUnhandled(nodep);
}

38
src/V3Undriven.cpp
View File

@ -282,7 +282,7 @@ private:
}
// VISITORS
virtual void visit(AstVar* nodep) VL_OVERRIDE {
virtual void visit(AstVar* nodep) override {
for (int usr = 1; usr < (m_alwaysCombp ? 3 : 2); ++usr) {
// For assigns and non-combo always, do just usr==1, to look
// for module-wide undriven etc.
@ -303,15 +303,15 @@ private:
// Discover variables used in bit definitions, etc
iterateChildren(nodep);
}
virtual void visit(AstArraySel* nodep) VL_OVERRIDE {
virtual void visit(AstArraySel* nodep) override {
// Arrays are rarely constant assigned, so for now we punt and do all entries
iterateChildren(nodep);
}
virtual void visit(AstSliceSel* nodep) VL_OVERRIDE {
virtual void visit(AstSliceSel* nodep) override {
// Arrays are rarely constant assigned, so for now we punt and do all entries
iterateChildren(nodep);
}
virtual void visit(AstSel* nodep) VL_OVERRIDE {
virtual void visit(AstSel* nodep) override {
AstNodeVarRef* varrefp = VN_CAST(nodep->fromp(), NodeVarRef);
AstConst* constp = VN_CAST(nodep->lsbp(), Const);
if (varrefp && constp && !constp->num().isFourState()) {
@ -334,7 +334,7 @@ private:
iterateChildren(nodep);
}
}
virtual void visit(AstNodeVarRef* nodep) VL_OVERRIDE {
virtual void visit(AstNodeVarRef* nodep) override {
// Any variable
if (nodep->lvalue()
&& !VN_IS(nodep, VarXRef)) { // Ignore interface variables and similar ugly items
@ -369,14 +369,14 @@ private:
}
// Don't know what black boxed calls do, assume in+out
virtual void visit(AstSysIgnore* nodep) VL_OVERRIDE {
virtual void visit(AstSysIgnore* nodep) override {
bool prevMark = m_inBBox;
m_inBBox = true;
iterateChildren(nodep);
m_inBBox = prevMark;
}
virtual void visit(AstAssign* nodep) VL_OVERRIDE {
virtual void visit(AstAssign* nodep) override {
bool prevProc = m_inProcAssign;
{
m_inProcAssign = true;
@ -384,7 +384,7 @@ private:
}
m_inProcAssign = prevProc;
}
virtual void visit(AstAssignDly* nodep) VL_OVERRIDE {
virtual void visit(AstAssignDly* nodep) override {
bool prevProc = m_inProcAssign;
{
m_inProcAssign = true;
@ -392,7 +392,7 @@ private:
}
m_inProcAssign = prevProc;
}
virtual void visit(AstAssignW* nodep) VL_OVERRIDE {
virtual void visit(AstAssignW* nodep) override {
bool prevCont = m_inContAssign;
{
m_inContAssign = true;
@ -400,7 +400,7 @@ private:
}
m_inContAssign = prevCont;
}
virtual void visit(AstAlways* nodep) VL_OVERRIDE {
virtual void visit(AstAlways* nodep) override {
AstAlways* prevAlwp = m_alwaysCombp;
{
AstNode::user2ClearTree();
@ -416,7 +416,7 @@ private:
m_alwaysCombp = prevAlwp;
}
virtual void visit(AstNodeFTask* nodep) VL_OVERRIDE {
virtual void visit(AstNodeFTask* nodep) override {
AstNodeFTask* prevTaskp = m_taskp;
m_taskp = nodep;
iterateChildren(nodep);
@ -424,18 +424,18 @@ private:
}
// Until we support tables, primitives will have undriven and unused I/Os
virtual void visit(AstPrimitive*) VL_OVERRIDE {}
virtual void visit(AstPrimitive*) override {}
// Coverage artifacts etc shouldn't count as a sink
virtual void visit(AstCoverDecl*) VL_OVERRIDE {}
virtual void visit(AstCoverInc*) VL_OVERRIDE {}
virtual void visit(AstCoverToggle*) VL_OVERRIDE {}
virtual void visit(AstTraceDecl*) VL_OVERRIDE {}
virtual void visit(AstTraceInc*) VL_OVERRIDE {}
virtual void visit(AstCoverDecl*) override {}
virtual void visit(AstCoverInc*) override {}
virtual void visit(AstCoverToggle*) override {}
virtual void visit(AstTraceDecl*) override {}
virtual void visit(AstTraceInc*) override {}
// iterate
virtual void visit(AstConst* nodep) VL_OVERRIDE {}
virtual void visit(AstNode* nodep) VL_OVERRIDE { iterateChildren(nodep); }
virtual void visit(AstConst* nodep) override {}
virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
public:
// CONSTRUCTORS

28
src/V3Unknown.cpp
View File

@ -134,7 +134,7 @@ private:
}
// VISITORS
virtual void visit(AstNodeModule* nodep) VL_OVERRIDE {
virtual void visit(AstNodeModule* nodep) override {
UINFO(4, " MOD " << nodep << endl);
AstNodeModule* origModp = m_modp;
{
@ -144,23 +144,23 @@ private:
}
m_modp = origModp;
}
virtual void visit(AstAssignDly* nodep) VL_OVERRIDE {
virtual void visit(AstAssignDly* nodep) override {
m_assigndlyp = nodep;
VL_DO_DANGLING(iterateChildren(nodep), nodep); // May delete nodep.
m_assigndlyp = NULL;
}
virtual void visit(AstAssignW* nodep) VL_OVERRIDE {
virtual void visit(AstAssignW* nodep) override {
m_assignwp = nodep;
VL_DO_DANGLING(iterateChildren(nodep), nodep); // May delete nodep.
m_assignwp = NULL;
}
virtual void visit(AstCaseItem* nodep) VL_OVERRIDE {
virtual void visit(AstCaseItem* nodep) override {
m_constXCvt = false; // Avoid losing the X's in casex
iterateAndNextNull(nodep->condsp());
m_constXCvt = true;
iterateAndNextNull(nodep->bodysp());
}
virtual void visit(AstNodeDType* nodep) VL_OVERRIDE {
virtual void visit(AstNodeDType* nodep) override {
m_constXCvt = false; // Avoid losing the X's in casex
iterateChildren(nodep);
m_constXCvt = true;
@ -237,11 +237,11 @@ private:
}
}
virtual void visit(AstEqCase* nodep) VL_OVERRIDE { visitEqNeqCase(nodep); }
virtual void visit(AstNeqCase* nodep) VL_OVERRIDE { visitEqNeqCase(nodep); }
virtual void visit(AstEqWild* nodep) VL_OVERRIDE { visitEqNeqWild(nodep); }
virtual void visit(AstNeqWild* nodep) VL_OVERRIDE { visitEqNeqWild(nodep); }
virtual void visit(AstIsUnknown* nodep) VL_OVERRIDE {
virtual void visit(AstEqCase* nodep) override { visitEqNeqCase(nodep); }
virtual void visit(AstNeqCase* nodep) override { visitEqNeqCase(nodep); }
virtual void visit(AstEqWild* nodep) override { visitEqNeqWild(nodep); }
virtual void visit(AstNeqWild* nodep) override { visitEqNeqWild(nodep); }
virtual void visit(AstIsUnknown* nodep) override {
iterateChildren(nodep);
// Ahh, we're two state, so this is easy
UINFO(4, " ISUNKNOWN->0 " << nodep << endl);
@ -249,7 +249,7 @@ private:
nodep->replaceWith(newp);
VL_DO_DANGLING(nodep->deleteTree(), nodep);
}
virtual void visit(AstConst* nodep) VL_OVERRIDE {
virtual void visit(AstConst* nodep) override {
if (m_constXCvt && nodep->num().isFourState()) {
UINFO(4, " CONST4 " << nodep << endl);
if (debug() >= 9) nodep->dumpTree(cout, " Const_old: ");
@ -306,7 +306,7 @@ private:
}
}
virtual void visit(AstSel* nodep) VL_OVERRIDE {
virtual void visit(AstSel* nodep) override {
iterateChildren(nodep);
if (!nodep->user1SetOnce()) {
// Guard against reading/writing past end of bit vector array
@ -353,7 +353,7 @@ private:
// visit(AstSliceSel) not needed as its bounds are constant and checked
// in V3Width.
virtual void visit(AstArraySel* nodep) VL_OVERRIDE {
virtual void visit(AstArraySel* nodep) override {
iterateChildren(nodep);
if (!nodep->user1SetOnce()) {
if (debug() == 9) nodep->dumpTree(cout, "-in: ");
@ -424,7 +424,7 @@ private:
}
}
//--------------------
virtual void visit(AstNode* nodep) VL_OVERRIDE { iterateChildren(nodep); }
virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
public:
// CONSTRUCTORS

10
src/V3Unroll.cpp
View File

@ -373,7 +373,7 @@ private:
return true;
}
virtual void visit(AstWhile* nodep) VL_OVERRIDE {
virtual void visit(AstWhile* nodep) override {
iterateChildren(nodep);
if (m_varModeCheck || m_varModeReplace) {
} else {
@ -408,7 +408,7 @@ private:
}
}
}
virtual void visit(AstGenFor* nodep) VL_OVERRIDE {
virtual void visit(AstGenFor* nodep) override {
if (!m_generate || m_varModeReplace) {
iterateChildren(nodep);
} // else V3Param will recursively call each for loop to be unrolled for us
@ -435,7 +435,7 @@ private:
}
}
}
virtual void visit(AstNodeFor* nodep) VL_OVERRIDE {
virtual void visit(AstNodeFor* nodep) override {
if (m_generate) { // Ignore for's when expanding genfor's
iterateChildren(nodep);
} else {
@ -443,7 +443,7 @@ private:
}
}
virtual void visit(AstVarRef* nodep) VL_OVERRIDE {
virtual void visit(AstVarRef* nodep) override {
if (m_varModeCheck && nodep->varp() == m_forVarp && nodep->varScopep() == m_forVscp
&& nodep->lvalue()) {
UINFO(8, " Itervar assigned to: " << nodep << endl);
@ -460,7 +460,7 @@ private:
//--------------------
// Default: Just iterate
virtual void visit(AstNode* nodep) VL_OVERRIDE {
virtual void visit(AstNode* nodep) override {
if (m_varModeCheck && nodep == m_ignoreIncp) {
// Ignore subtree that is the increment
} else {

2
src/V3Waiver.cpp
View File

@ -30,7 +30,7 @@ void V3Waiver::addEntry(V3ErrorCode errorCode, const std::string& filename,
}
void V3Waiver::write(const std::string& filename) {
const vl_unique_ptr<std::ofstream> ofp(V3File::new_ofstream(filename));
const std::unique_ptr<std::ofstream> ofp(V3File::new_ofstream(filename));
if (ofp->fail()) v3fatal("Can't write " << filename);
*ofp << "// DESCR"

428
src/V3Width.cpp
View File

File diff suppressed because it is too large Load Diff

Some files were not shown because too many files have changed in this diff Show More