diff --git a/include/verilated_cov.cpp b/include/verilated_cov.cpp
index 9cf756532..aee6e08ed 100644
--- a/include/verilated_cov.cpp
+++ b/include/verilated_cov.cpp
@@ -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 {}
 };
 
 //=============================================================================
diff --git a/include/verilated_fst_c.h b/include/verilated_fst_c.h
index 9b935f763..50ec99c52 100644
--- a/include/verilated_fst_c.h
+++ b/include/verilated_fst_c.h
@@ -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.
diff --git a/include/verilated_heavy.h b/include/verilated_heavy.h
index 0a712a891..17e83e054 100644
--- a/include/verilated_heavy.h
+++ b/include/verilated_heavy.h
@@ -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) {
diff --git a/include/verilated_save.h b/include/verilated_save.h
index cf6c3a5a5..b4da0dbaf 100644
--- a/include/verilated_save.h
+++ b/include/verilated_save.h
@@ -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;
 };
 
 //=============================================================================
diff --git a/include/verilated_unordered_set_map.h b/include/verilated_unordered_set_map.h
deleted file mode 100644
index c8d9afcea..000000000
--- a/include/verilated_unordered_set_map.h
+++ /dev/null
@@ -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
diff --git a/include/verilated_vcd_c.h b/include/verilated_vcd_c.h
index 24f10ab7d..6c423765f 100644
--- a/include/verilated_vcd_c.h
+++ b/include/verilated_vcd_c.h
@@ -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.
diff --git a/include/verilatedos.h b/include/verilatedos.h
index 99cc42240..d71de904c 100644
--- a/include/verilatedos.h
+++ b/include/verilatedos.h
@@ -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
diff --git a/src/V3Active.cpp b/src/V3Active.cpp
index 26cf3f3aa..f8753e191 100644
--- a/src/V3Active.cpp
+++ b/src/V3Active.cpp
@@ -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
diff --git a/src/V3ActiveTop.cpp b/src/V3ActiveTop.cpp
index 07f7741d2..8a51b610b 100644
--- a/src/V3ActiveTop.cpp
+++ b/src/V3ActiveTop.cpp
@@ -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
diff --git a/src/V3Assert.cpp b/src/V3Assert.cpp
index 501c9039f..0ff3485da 100644
--- a/src/V3Assert.cpp
+++ b/src/V3Assert.cpp
@@ -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
diff --git a/src/V3AssertPre.cpp b/src/V3AssertPre.cpp
index ec1775503..8aaa633a5 100644
--- a/src/V3AssertPre.cpp
+++ b/src/V3AssertPre.cpp
@@ -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
diff --git a/src/V3Ast.cpp b/src/V3Ast.cpp
index 31d0b892d..685d6284e 100644
--- a/src/V3Ast.cpp
+++ b/src/V3Ast.cpp
@@ -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;
diff --git a/src/V3Ast.h b/src/V3Ast.h
index e508ef82b..82e4685b6 100644
--- a/src/V3Ast.h
+++ b/src/V3Ast.h
@@ -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:
diff --git a/src/V3AstNodes.cpp b/src/V3AstNodes.cpp
index bb313c823..29a12358d 100644
--- a/src/V3AstNodes.cpp
+++ b/src/V3AstNodes.cpp
@@ -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);
     }
diff --git a/src/V3Begin.cpp b/src/V3Begin.cpp
index 30ae3cbc5..5ef5991ac 100644
--- a/src/V3Begin.cpp
+++ b/src/V3Begin.cpp
@@ -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
diff --git a/src/V3Branch.cpp b/src/V3Branch.cpp
index 94123dd6a..c5d247937 100644
--- a/src/V3Branch.cpp
+++ b/src/V3Branch.cpp
@@ -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);
     }
diff --git a/src/V3Broken.cpp b/src/V3Broken.cpp
index e9371d2be..c40c9888b 100644
--- a/src/V3Broken.cpp
+++ b/src/V3Broken.cpp
@@ -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);
     }
diff --git a/src/V3CUse.cpp b/src/V3CUse.cpp
index 82a20e7a5..8f900b0cd 100644
--- a/src/V3CUse.cpp
+++ b/src/V3CUse.cpp
@@ -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
diff --git a/src/V3Case.cpp b/src/V3Case.cpp
index 01ba0b96d..489cc1d09 100644
--- a/src/V3Case.cpp
+++ b/src/V3Case.cpp
@@ -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
diff --git a/src/V3Cast.cpp b/src/V3Cast.cpp
index d8f24070f..cc74d2da6 100644
--- a/src/V3Cast.cpp
+++ b/src/V3Cast.cpp
@@ -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
diff --git a/src/V3Cdc.cpp b/src/V3Cdc.cpp
index 7369d3b63..f7522c219 100644
--- a/src/V3Cdc.cpp
+++ b/src/V3Cdc.cpp
@@ -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
diff --git a/src/V3Changed.cpp b/src/V3Changed.cpp
index 47be72d4c..e82a61e27 100644
--- a/src/V3Changed.cpp
+++ b/src/V3Changed.cpp
@@ -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
diff --git a/src/V3Class.cpp b/src/V3Class.cpp
index 59d30c97b..a6e8db039 100644
--- a/src/V3Class.cpp
+++ b/src/V3Class.cpp
@@ -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
diff --git a/src/V3Clean.cpp b/src/V3Clean.cpp
index 274c628c5..52d7ebd19 100644
--- a/src/V3Clean.cpp
+++ b/src/V3Clean.cpp
@@ -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);
     }
diff --git a/src/V3Clock.cpp b/src/V3Clock.cpp
index a37b2f922..72f0d0472 100644
--- a/src/V3Clock.cpp
+++ b/src/V3Clock.cpp
@@ -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
diff --git a/src/V3Combine.cpp b/src/V3Combine.cpp
index c38cc96f7..48b3eef39 100644
--- a/src/V3Combine.cpp
+++ b/src/V3Combine.cpp
@@ -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
diff --git a/src/V3Config.cpp b/src/V3Config.cpp
index aab3e6d62..365cb3131 100644
--- a/src/V3Config.cpp
+++ b/src/V3Config.cpp
@@ -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
diff --git a/src/V3Const.cpp b/src/V3Const.cpp
index 097562560..eca626950 100644
--- a/src/V3Const.cpp
+++ b/src/V3Const.cpp
@@ -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)) {
diff --git a/src/V3Coverage.cpp b/src/V3Coverage.cpp
index ccbd365cb..c3a7826fc 100644
--- a/src/V3Coverage.cpp
+++ b/src/V3Coverage.cpp
@@ -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);
     }
diff --git a/src/V3CoverageJoin.cpp b/src/V3CoverageJoin.cpp
index b0b1025ac..ed4f8cba2 100644
--- a/src/V3CoverageJoin.cpp
+++ b/src/V3CoverageJoin.cpp
@@ -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
diff --git a/src/V3Dead.cpp b/src/V3Dead.cpp
index 7a23c2b2c..275b70ced 100644
--- a/src/V3Dead.cpp
+++ b/src/V3Dead.cpp
@@ -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);
diff --git a/src/V3Delayed.cpp b/src/V3Delayed.cpp
index 87faab264..16eecba49 100644
--- a/src/V3Delayed.cpp
+++ b/src/V3Delayed.cpp
@@ -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
diff --git a/src/V3Depth.cpp b/src/V3Depth.cpp
index 9ca85d2ef..19c9ebb40 100644
--- a/src/V3Depth.cpp
+++ b/src/V3Depth.cpp
@@ -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
diff --git a/src/V3DepthBlock.cpp b/src/V3DepthBlock.cpp
index 55000a20a..666733803 100644
--- a/src/V3DepthBlock.cpp
+++ b/src/V3DepthBlock.cpp
@@ -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
diff --git a/src/V3Descope.cpp b/src/V3Descope.cpp
index d969ec144..c49c31078 100644
--- a/src/V3Descope.cpp
+++ b/src/V3Descope.cpp
@@ -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
diff --git a/src/V3EmitC.cpp b/src/V3EmitC.cpp
index 441ca96be..b61986f0b 100644
--- a/src/V3EmitC.cpp
+++ b/src/V3EmitC.cpp
@@ -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) {
diff --git a/src/V3EmitCBase.h b/src/V3EmitCBase.h
index 94a5e2d8e..247a82d54 100644
--- a/src/V3EmitCBase.h
+++ b/src/V3EmitCBase.h
@@ -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);
     }
diff --git a/src/V3EmitCInlines.cpp b/src/V3EmitCInlines.cpp
index b2b526f29..1a04d51bc 100644
--- a/src/V3EmitCInlines.cpp
+++ b/src/V3EmitCInlines.cpp
@@ -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);
     }
diff --git a/src/V3EmitCMake.cpp b/src/V3EmitCMake.cpp
index abc8510fe..e52f41494 100644
--- a/src/V3EmitCMake.cpp
+++ b/src/V3EmitCMake.cpp
@@ -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();
 
diff --git a/src/V3EmitCSyms.cpp b/src/V3EmitCSyms.cpp
index 978c56e2e..65a7e8d4a 100644
--- a/src/V3EmitCSyms.cpp
+++ b/src/V3EmitCSyms.cpp
@@ -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)
diff --git a/src/V3EmitV.cpp b/src/V3EmitV.cpp
index 07c9395d5..a87c17522 100644
--- a/src/V3EmitV.cpp
+++ b/src/V3EmitV.cpp
@@ -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
diff --git a/src/V3EmitXml.cpp b/src/V3EmitXml.cpp
index 671410316..caebcd4a2 100644
--- a/src/V3EmitXml.cpp
+++ b/src/V3EmitXml.cpp
@@ -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
diff --git a/src/V3Expand.cpp b/src/V3Expand.cpp
index 623f98c1f..0a9aed65a 100644
--- a/src/V3Expand.cpp
+++ b/src/V3Expand.cpp
@@ -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
diff --git a/src/V3File.cpp b/src/V3File.cpp
index ef1261b58..fdd822113 100644
--- a/src/V3File.cpp
+++ b/src/V3File.cpp
@@ -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
diff --git a/src/V3FileLine.cpp b/src/V3FileLine.cpp
index 23b07c4cd..6dcd53788 100644
--- a/src/V3FileLine.cpp
+++ b/src/V3FileLine.cpp
@@ -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) {
diff --git a/src/V3Gate.cpp b/src/V3Gate.cpp
index 8c3a785ad..44d0388bf 100644
--- a/src/V3Gate.cpp
+++ b/src/V3Gate.cpp
@@ -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
diff --git a/src/V3GenClk.cpp b/src/V3GenClk.cpp
index 135d1394a..53a4ec03c 100644
--- a/src/V3GenClk.cpp
+++ b/src/V3GenClk.cpp
@@ -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
diff --git a/src/V3Global.h b/src/V3Global.h
index b72718cc2..e52b62f73 100644
--- a/src/V3Global.h
+++ b/src/V3Global.h
@@ -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:
diff --git a/src/V3Graph.cpp b/src/V3Graph.cpp
index 0b91d6ac4..7d47d747f 100644
--- a/src/V3Graph.cpp
+++ b/src/V3Graph.cpp
@@ -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
diff --git a/src/V3GraphStream.h b/src/V3GraphStream.h
index 532282ad6..756ca921b 100644
--- a/src/V3GraphStream.h
+++ b/src/V3GraphStream.h
@@ -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
diff --git a/src/V3Hashed.cpp b/src/V3Hashed.cpp
index 8a3589234..622478d70 100644
--- a/src/V3Hashed.cpp
+++ b/src/V3Hashed.cpp
@@ -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;
diff --git a/src/V3HierBlock.cpp b/src/V3HierBlock.cpp
index da58c3d14..0c101d2fa 100644
--- a/src/V3HierBlock.cpp
+++ b/src/V3HierBlock.cpp
@@ -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) {
diff --git a/src/V3Inline.cpp b/src/V3Inline.cpp
index 301590f3b..3d78b7c83 100644
--- a/src/V3Inline.cpp
+++ b/src/V3Inline.cpp
@@ -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
diff --git a/src/V3Inst.cpp b/src/V3Inst.cpp
index 1fb8467cb..caca4865f 100644
--- a/src/V3Inst.cpp
+++ b/src/V3Inst.cpp
@@ -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
diff --git a/src/V3InstrCount.cpp b/src/V3InstrCount.cpp
index 972c791fd..01d079fdb 100644
--- a/src/V3InstrCount.cpp
+++ b/src/V3InstrCount.cpp
@@ -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)
diff --git a/src/V3Life.cpp b/src/V3Life.cpp
index 1462ee4c4..e6ab413b6 100644
--- a/src/V3Life.cpp
+++ b/src/V3Life.cpp
@@ -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
diff --git a/src/V3LifePost.cpp b/src/V3LifePost.cpp
index e09993029..00a016cbb 100644
--- a/src/V3LifePost.cpp
+++ b/src/V3LifePost.cpp
@@ -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
diff --git a/src/V3LinkCells.cpp b/src/V3LinkCells.cpp
index 858446c49..5d43405f6 100644
--- a/src/V3LinkCells.cpp
+++ b/src/V3LinkCells.cpp
@@ -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() {
diff --git a/src/V3LinkDot.cpp b/src/V3LinkDot.cpp
index bbe80cb5c..c257f0a1e 100644
--- a/src/V3LinkDot.cpp
+++ b/src/V3LinkDot.cpp
@@ -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);
     }
diff --git a/src/V3LinkInc.cpp b/src/V3LinkInc.cpp
index 55c7b24cf..fa2c747f8 100644
--- a/src/V3LinkInc.cpp
+++ b/src/V3LinkInc.cpp
@@ -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
diff --git a/src/V3LinkJump.cpp b/src/V3LinkJump.cpp
index 56ff84b93..7b23e48ca 100644
--- a/src/V3LinkJump.cpp
+++ b/src/V3LinkJump.cpp
@@ -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
diff --git a/src/V3LinkLValue.cpp b/src/V3LinkLValue.cpp
index 915501d51..ddfd4c98b 100644
--- a/src/V3LinkLValue.cpp
+++ b/src/V3LinkLValue.cpp
@@ -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
diff --git a/src/V3LinkLevel.cpp b/src/V3LinkLevel.cpp
index 70c997d6d..dd8ef3d50 100644
--- a/src/V3LinkLevel.cpp
+++ b/src/V3LinkLevel.cpp
@@ -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
diff --git a/src/V3LinkParse.cpp b/src/V3LinkParse.cpp
index 6d79174fa..efcfaf596 100644
--- a/src/V3LinkParse.cpp
+++ b/src/V3LinkParse.cpp
@@ -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);
diff --git a/src/V3LinkResolve.cpp b/src/V3LinkResolve.cpp
index 271defb2c..e2ff22660 100644
--- a/src/V3LinkResolve.cpp
+++ b/src/V3LinkResolve.cpp
@@ -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
diff --git a/src/V3Localize.cpp b/src/V3Localize.cpp
index 3a9b17946..bfdd49705 100644
--- a/src/V3Localize.cpp
+++ b/src/V3Localize.cpp
@@ -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
diff --git a/src/V3MergeCond.cpp b/src/V3MergeCond.cpp
index 2d8d39f36..98d7f6bad 100644
--- a/src/V3MergeCond.cpp
+++ b/src/V3MergeCond.cpp
@@ -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
diff --git a/src/V3Name.cpp b/src/V3Name.cpp
index d08e1776a..f68790964 100644
--- a/src/V3Name.cpp
+++ b/src/V3Name.cpp
@@ -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
diff --git a/src/V3Options.cpp b/src/V3Options.cpp
index 0ca65e114..4f37c6202 100644
--- a/src/V3Options.cpp
+++ b/src/V3Options.cpp
@@ -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;
diff --git a/src/V3Order.cpp b/src/V3Order.cpp
index 62f273d42..d1b197728 100644
--- a/src/V3Order.cpp
+++ b/src/V3Order.cpp
@@ -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);
     }
diff --git a/src/V3OrderGraph.h b/src/V3OrderGraph.h
index fc81aaf44..ecc889c47 100644
--- a/src/V3OrderGraph.h
+++ b/src/V3OrderGraph.h
@@ -44,7 +44,7 @@
 #include "V3Ast.h"
 #include "V3Graph.h"
 
-#include VL_INCLUDE_UNORDERED_MAP
+#include <unordered_map>
 
 class OrderVisitor;
 class OrderMoveVertex;
diff --git a/src/V3Param.cpp b/src/V3Param.cpp
index 4b4d773a0..927166e20 100644
--- a/src/V3Param.cpp
+++ b/src/V3Param.cpp
@@ -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
diff --git a/src/V3Partition.cpp b/src/V3Partition.cpp
index aca9696c1..b112dbff4 100644
--- a/src/V3Partition.cpp
+++ b/src/V3Partition.cpp
@@ -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++;
diff --git a/src/V3Partition.h b/src/V3Partition.h
index 9226cb666..b53a5d7df 100644
--- a/src/V3Partition.h
+++ b/src/V3Partition.h
@@ -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;
diff --git a/src/V3Premit.cpp b/src/V3Premit.cpp
index 2b75eafa6..99d2406fc 100644
--- a/src/V3Premit.cpp
+++ b/src/V3Premit.cpp
@@ -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
diff --git a/src/V3ProtectLib.cpp b/src/V3ProtectLib.cpp
index 5d6c2fe28..8349d2dc0 100644
--- a/src/V3ProtectLib.cpp
+++ b/src/V3ProtectLib.cpp
@@ -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;
diff --git a/src/V3Reloop.cpp b/src/V3Reloop.cpp
index 05b090a72..cf00a0193 100644
--- a/src/V3Reloop.cpp
+++ b/src/V3Reloop.cpp
@@ -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
diff --git a/src/V3Scope.cpp b/src/V3Scope.cpp
index 4dde0187f..e4ac81289 100644
--- a/src/V3Scope.cpp
+++ b/src/V3Scope.cpp
@@ -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
diff --git a/src/V3Scoreboard.h b/src/V3Scoreboard.h
index 19d0b8b41..1c918b26f 100644
--- a/src/V3Scoreboard.h
+++ b/src/V3Scoreboard.h
@@ -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 {
diff --git a/src/V3SenTree.h b/src/V3SenTree.h
index d4f5c3ecc..93794ed21 100644
--- a/src/V3SenTree.h
+++ b/src/V3SenTree.h
@@ -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:
diff --git a/src/V3Simulate.h b/src/V3Simulate.h
index d7cedc099..bde492f7e 100644
--- a/src/V3Simulate.h
+++ b/src/V3Simulate.h
@@ -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);
     }
diff --git a/src/V3Slice.cpp b/src/V3Slice.cpp
index 2c41c1db6..3364af781 100644
--- a/src/V3Slice.cpp
+++ b/src/V3Slice.cpp
@@ -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
diff --git a/src/V3Split.cpp b/src/V3Split.cpp
index bca88e300..72cb9b039 100644
--- a/src/V3Split.cpp
+++ b/src/V3Split.cpp
@@ -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());
diff --git a/src/V3SplitAs.cpp b/src/V3SplitAs.cpp
index 3aa5a4c2a..3d49e0d86 100644
--- a/src/V3SplitAs.cpp
+++ b/src/V3SplitAs.cpp
@@ -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
diff --git a/src/V3SplitVar.cpp b/src/V3SplitVar.cpp
index d95eb54a0..c2824a396 100644
--- a/src/V3SplitVar.cpp
+++ b/src/V3SplitVar.cpp
@@ -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,
diff --git a/src/V3Stats.cpp b/src/V3Stats.cpp
index c5d8e1d8c..56aca4cc0 100644
--- a/src/V3Stats.cpp
+++ b/src/V3Stats.cpp
@@ -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;
diff --git a/src/V3StatsReport.cpp b/src/V3StatsReport.cpp
index 11b660c93..b1926664f 100644
--- a/src/V3StatsReport.cpp
+++ b/src/V3StatsReport.cpp
@@ -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
diff --git a/src/V3Subst.cpp b/src/V3Subst.cpp
index d86f50864..f0e8de8d8 100644
--- a/src/V3Subst.cpp
+++ b/src/V3Subst.cpp
@@ -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);
diff --git a/src/V3SymTable.h b/src/V3SymTable.h
index a6d66421e..57fe9a40b 100644
--- a/src/V3SymTable.h
+++ b/src/V3SymTable.h
@@ -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, "");
         }
diff --git a/src/V3TSP.cpp b/src/V3TSP.cpp
index 617653c0e..7ee9e1770 100644
--- a/src/V3TSP.cpp
+++ b/src/V3TSP.cpp
@@ -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;
diff --git a/src/V3Table.cpp b/src/V3Table.cpp
index 43eeef696..d074f7195 100644
--- a/src/V3Table.cpp
+++ b/src/V3Table.cpp
@@ -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
diff --git a/src/V3Task.cpp b/src/V3Task.cpp
index 8b2fe6979..bc80219b2 100644
--- a/src/V3Task.cpp
+++ b/src/V3Task.cpp
@@ -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
diff --git a/src/V3Trace.cpp b/src/V3Trace.cpp
index de8e2e50d..b9be8a603 100644
--- a/src/V3Trace.cpp
+++ b/src/V3Trace.cpp
@@ -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
diff --git a/src/V3TraceDecl.cpp b/src/V3TraceDecl.cpp
index e404efda3..5e86041a2 100644
--- a/src/V3TraceDecl.cpp
+++ b/src/V3TraceDecl.cpp
@@ -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
diff --git a/src/V3Tristate.cpp b/src/V3Tristate.cpp
index feab69955..57cdbcc18 100644
--- a/src/V3Tristate.cpp
+++ b/src/V3Tristate.cpp
@@ -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);
     }
diff --git a/src/V3Undriven.cpp b/src/V3Undriven.cpp
index d0b48debc..d0d1ed597 100644
--- a/src/V3Undriven.cpp
+++ b/src/V3Undriven.cpp
@@ -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
diff --git a/src/V3Unknown.cpp b/src/V3Unknown.cpp
index 3ebaa05ec..90d1a1f1b 100644
--- a/src/V3Unknown.cpp
+++ b/src/V3Unknown.cpp
@@ -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
diff --git a/src/V3Unroll.cpp b/src/V3Unroll.cpp
index 795d5ec04..eff6bd57c 100644
--- a/src/V3Unroll.cpp
+++ b/src/V3Unroll.cpp
@@ -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 {
diff --git a/src/V3Waiver.cpp b/src/V3Waiver.cpp
index cc62c823b..aedb42391 100644
--- a/src/V3Waiver.cpp
+++ b/src/V3Waiver.cpp
@@ -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"
diff --git a/src/V3Width.cpp b/src/V3Width.cpp
index 194e46c18..1b78ab77d 100644
--- a/src/V3Width.cpp
+++ b/src/V3Width.cpp
@@ -217,125 +217,125 @@ private:
     //                  _Ox=anything
 
     // Widths: 1 bit out, lhs 1 bit; Real: converts via compare with 0
-    virtual void visit(AstLogNot* nodep) VL_OVERRIDE { visit_log_not(nodep); }
+    virtual void visit(AstLogNot* nodep) override { visit_log_not(nodep); }
     // Widths: 1 bit out, lhs 1 bit, rhs 1 bit; Real: converts via compare with 0
-    virtual void visit(AstLogAnd* nodep) VL_OVERRIDE { visit_log_and_or(nodep); }
-    virtual void visit(AstLogOr* nodep) VL_OVERRIDE { visit_log_and_or(nodep); }
-    virtual void visit(AstLogEq* nodep) VL_OVERRIDE {
+    virtual void visit(AstLogAnd* nodep) override { visit_log_and_or(nodep); }
+    virtual void visit(AstLogOr* nodep) override { visit_log_and_or(nodep); }
+    virtual void visit(AstLogEq* nodep) override {
         // Conversion from real not in IEEE, but a fallout
         visit_log_and_or(nodep);
     }
-    virtual void visit(AstLogIf* nodep) VL_OVERRIDE {
+    virtual void visit(AstLogIf* nodep) override {
         // Conversion from real not in IEEE, but a fallout
         visit_log_and_or(nodep);
     }
 
     // Widths: 1 bit out, Any width lhs
-    virtual void visit(AstRedAnd* nodep) VL_OVERRIDE { visit_red_and_or(nodep); }
-    virtual void visit(AstRedOr* nodep) VL_OVERRIDE { visit_red_and_or(nodep); }
-    virtual void visit(AstRedXnor* nodep) VL_OVERRIDE { visit_red_and_or(nodep); }
-    virtual void visit(AstRedXor* nodep) VL_OVERRIDE { visit_red_and_or(nodep); }
-    virtual void visit(AstOneHot* nodep) VL_OVERRIDE { visit_red_and_or(nodep); }
-    virtual void visit(AstOneHot0* nodep) VL_OVERRIDE { visit_red_and_or(nodep); }
-    virtual void visit(AstIsUnknown* nodep) VL_OVERRIDE {
+    virtual void visit(AstRedAnd* nodep) override { visit_red_and_or(nodep); }
+    virtual void visit(AstRedOr* nodep) override { visit_red_and_or(nodep); }
+    virtual void visit(AstRedXnor* nodep) override { visit_red_and_or(nodep); }
+    virtual void visit(AstRedXor* nodep) override { visit_red_and_or(nodep); }
+    virtual void visit(AstOneHot* nodep) override { visit_red_and_or(nodep); }
+    virtual void visit(AstOneHot0* nodep) override { visit_red_and_or(nodep); }
+    virtual void visit(AstIsUnknown* nodep) override {
         visit_red_unknown(nodep);  // Allow real
     }
 
     // These have different node types, as they operate differently
     // Must add to case statement below,
     // Widths: 1 bit out, lhs width == rhs width.  real if lhs|rhs real
-    virtual void visit(AstEq* nodep) VL_OVERRIDE { visit_cmp_eq_gt(nodep, true); }
-    virtual void visit(AstNeq* nodep) VL_OVERRIDE { visit_cmp_eq_gt(nodep, true); }
-    virtual void visit(AstGt* nodep) VL_OVERRIDE { visit_cmp_eq_gt(nodep, true); }
-    virtual void visit(AstGte* nodep) VL_OVERRIDE { visit_cmp_eq_gt(nodep, true); }
-    virtual void visit(AstLt* nodep) VL_OVERRIDE { visit_cmp_eq_gt(nodep, true); }
-    virtual void visit(AstLte* nodep) VL_OVERRIDE { visit_cmp_eq_gt(nodep, true); }
-    virtual void visit(AstGtS* nodep) VL_OVERRIDE { visit_cmp_eq_gt(nodep, true); }
-    virtual void visit(AstGteS* nodep) VL_OVERRIDE { visit_cmp_eq_gt(nodep, true); }
-    virtual void visit(AstLtS* nodep) VL_OVERRIDE { visit_cmp_eq_gt(nodep, true); }
-    virtual void visit(AstLteS* nodep) VL_OVERRIDE { visit_cmp_eq_gt(nodep, true); }
-    virtual void visit(AstEqCase* nodep) VL_OVERRIDE { visit_cmp_eq_gt(nodep, true); }
-    virtual void visit(AstNeqCase* nodep) VL_OVERRIDE { visit_cmp_eq_gt(nodep, true); }
+    virtual void visit(AstEq* nodep) override { visit_cmp_eq_gt(nodep, true); }
+    virtual void visit(AstNeq* nodep) override { visit_cmp_eq_gt(nodep, true); }
+    virtual void visit(AstGt* nodep) override { visit_cmp_eq_gt(nodep, true); }
+    virtual void visit(AstGte* nodep) override { visit_cmp_eq_gt(nodep, true); }
+    virtual void visit(AstLt* nodep) override { visit_cmp_eq_gt(nodep, true); }
+    virtual void visit(AstLte* nodep) override { visit_cmp_eq_gt(nodep, true); }
+    virtual void visit(AstGtS* nodep) override { visit_cmp_eq_gt(nodep, true); }
+    virtual void visit(AstGteS* nodep) override { visit_cmp_eq_gt(nodep, true); }
+    virtual void visit(AstLtS* nodep) override { visit_cmp_eq_gt(nodep, true); }
+    virtual void visit(AstLteS* nodep) override { visit_cmp_eq_gt(nodep, true); }
+    virtual void visit(AstEqCase* nodep) override { visit_cmp_eq_gt(nodep, true); }
+    virtual void visit(AstNeqCase* nodep) override { visit_cmp_eq_gt(nodep, true); }
     // ...    These comparisons don't allow reals
-    virtual void visit(AstEqWild* nodep) VL_OVERRIDE { visit_cmp_eq_gt(nodep, false); }
-    virtual void visit(AstNeqWild* nodep) VL_OVERRIDE { visit_cmp_eq_gt(nodep, false); }
+    virtual void visit(AstEqWild* nodep) override { visit_cmp_eq_gt(nodep, false); }
+    virtual void visit(AstNeqWild* nodep) override { visit_cmp_eq_gt(nodep, false); }
     // ...    Real compares
-    virtual void visit(AstEqD* nodep) VL_OVERRIDE { visit_cmp_real(nodep); }
-    virtual void visit(AstNeqD* nodep) VL_OVERRIDE { visit_cmp_real(nodep); }
-    virtual void visit(AstLtD* nodep) VL_OVERRIDE { visit_cmp_real(nodep); }
-    virtual void visit(AstLteD* nodep) VL_OVERRIDE { visit_cmp_real(nodep); }
-    virtual void visit(AstGtD* nodep) VL_OVERRIDE { visit_cmp_real(nodep); }
-    virtual void visit(AstGteD* nodep) VL_OVERRIDE { visit_cmp_real(nodep); }
+    virtual void visit(AstEqD* nodep) override { visit_cmp_real(nodep); }
+    virtual void visit(AstNeqD* nodep) override { visit_cmp_real(nodep); }
+    virtual void visit(AstLtD* nodep) override { visit_cmp_real(nodep); }
+    virtual void visit(AstLteD* nodep) override { visit_cmp_real(nodep); }
+    virtual void visit(AstGtD* nodep) override { visit_cmp_real(nodep); }
+    virtual void visit(AstGteD* nodep) override { visit_cmp_real(nodep); }
     // ...    String compares
-    virtual void visit(AstEqN* nodep) VL_OVERRIDE { visit_cmp_string(nodep); }
-    virtual void visit(AstNeqN* nodep) VL_OVERRIDE { visit_cmp_string(nodep); }
-    virtual void visit(AstLtN* nodep) VL_OVERRIDE { visit_cmp_string(nodep); }
-    virtual void visit(AstLteN* nodep) VL_OVERRIDE { visit_cmp_string(nodep); }
-    virtual void visit(AstGtN* nodep) VL_OVERRIDE { visit_cmp_string(nodep); }
-    virtual void visit(AstGteN* nodep) VL_OVERRIDE { visit_cmp_string(nodep); }
+    virtual void visit(AstEqN* nodep) override { visit_cmp_string(nodep); }
+    virtual void visit(AstNeqN* nodep) override { visit_cmp_string(nodep); }
+    virtual void visit(AstLtN* nodep) override { visit_cmp_string(nodep); }
+    virtual void visit(AstLteN* nodep) override { visit_cmp_string(nodep); }
+    virtual void visit(AstGtN* nodep) override { visit_cmp_string(nodep); }
+    virtual void visit(AstGteN* nodep) override { visit_cmp_string(nodep); }
 
     // Widths: out width = lhs width = rhs width
     // Signed: Output signed iff LHS & RHS signed.
     // Real: Not allowed
-    virtual void visit(AstAnd* nodep) VL_OVERRIDE { visit_boolmath_and_or(nodep); }
-    virtual void visit(AstOr* nodep) VL_OVERRIDE { visit_boolmath_and_or(nodep); }
-    virtual void visit(AstXnor* nodep) VL_OVERRIDE { visit_boolmath_and_or(nodep); }
-    virtual void visit(AstXor* nodep) VL_OVERRIDE { visit_boolmath_and_or(nodep); }
-    virtual void visit(AstBufIf1* nodep) VL_OVERRIDE {
+    virtual void visit(AstAnd* nodep) override { visit_boolmath_and_or(nodep); }
+    virtual void visit(AstOr* nodep) override { visit_boolmath_and_or(nodep); }
+    virtual void visit(AstXnor* nodep) override { visit_boolmath_and_or(nodep); }
+    virtual void visit(AstXor* nodep) override { visit_boolmath_and_or(nodep); }
+    virtual void visit(AstBufIf1* nodep) override {
         visit_boolmath_and_or(nodep);
     }  // Signed behavior changing in 3.814
     // Width: Max(Lhs,Rhs) sort of.
     // Real: If either side real
     // Signed: If both sides real
-    virtual void visit(AstAdd* nodep) VL_OVERRIDE { visit_add_sub_replace(nodep, true); }
-    virtual void visit(AstSub* nodep) VL_OVERRIDE { visit_add_sub_replace(nodep, true); }
-    virtual void visit(AstDiv* nodep) VL_OVERRIDE { visit_add_sub_replace(nodep, true); }
-    virtual void visit(AstMul* nodep) VL_OVERRIDE { visit_add_sub_replace(nodep, true); }
+    virtual void visit(AstAdd* nodep) override { visit_add_sub_replace(nodep, true); }
+    virtual void visit(AstSub* nodep) override { visit_add_sub_replace(nodep, true); }
+    virtual void visit(AstDiv* nodep) override { visit_add_sub_replace(nodep, true); }
+    virtual void visit(AstMul* nodep) override { visit_add_sub_replace(nodep, true); }
     // These can't promote to real
-    virtual void visit(AstModDiv* nodep) VL_OVERRIDE { visit_add_sub_replace(nodep, false); }
-    virtual void visit(AstModDivS* nodep) VL_OVERRIDE { visit_add_sub_replace(nodep, false); }
-    virtual void visit(AstMulS* nodep) VL_OVERRIDE { visit_add_sub_replace(nodep, false); }
-    virtual void visit(AstDivS* nodep) VL_OVERRIDE { visit_add_sub_replace(nodep, false); }
+    virtual void visit(AstModDiv* nodep) override { visit_add_sub_replace(nodep, false); }
+    virtual void visit(AstModDivS* nodep) override { visit_add_sub_replace(nodep, false); }
+    virtual void visit(AstMulS* nodep) override { visit_add_sub_replace(nodep, false); }
+    virtual void visit(AstDivS* nodep) override { visit_add_sub_replace(nodep, false); }
     // Widths: out width = lhs width, but upper matters
     // Signed: Output signed iff LHS signed; unary operator
     // Unary promote to real
-    virtual void visit(AstNegate* nodep) VL_OVERRIDE { visit_negate_not(nodep, true); }
+    virtual void visit(AstNegate* nodep) override { visit_negate_not(nodep, true); }
     // Unary never real
-    virtual void visit(AstNot* nodep) VL_OVERRIDE { visit_negate_not(nodep, false); }
+    virtual void visit(AstNot* nodep) override { visit_negate_not(nodep, false); }
 
     // Real: inputs and output real
-    virtual void visit(AstAddD* nodep) VL_OVERRIDE { visit_real_add_sub(nodep); }
-    virtual void visit(AstSubD* nodep) VL_OVERRIDE { visit_real_add_sub(nodep); }
-    virtual void visit(AstDivD* nodep) VL_OVERRIDE { visit_real_add_sub(nodep); }
-    virtual void visit(AstMulD* nodep) VL_OVERRIDE { visit_real_add_sub(nodep); }
-    virtual void visit(AstPowD* nodep) VL_OVERRIDE { visit_real_add_sub(nodep); }
-    virtual void visit(AstNodeSystemBiop* nodep) VL_OVERRIDE { visit_real_add_sub(nodep); }
+    virtual void visit(AstAddD* nodep) override { visit_real_add_sub(nodep); }
+    virtual void visit(AstSubD* nodep) override { visit_real_add_sub(nodep); }
+    virtual void visit(AstDivD* nodep) override { visit_real_add_sub(nodep); }
+    virtual void visit(AstMulD* nodep) override { visit_real_add_sub(nodep); }
+    virtual void visit(AstPowD* nodep) override { visit_real_add_sub(nodep); }
+    virtual void visit(AstNodeSystemBiop* nodep) override { visit_real_add_sub(nodep); }
     // Real: Output real
-    virtual void visit(AstNegateD* nodep) VL_OVERRIDE { visit_real_neg_ceil(nodep); }
-    virtual void visit(AstNodeSystemUniop* nodep) VL_OVERRIDE { visit_real_neg_ceil(nodep); }
+    virtual void visit(AstNegateD* nodep) override { visit_real_neg_ceil(nodep); }
+    virtual void visit(AstNodeSystemUniop* nodep) override { visit_real_neg_ceil(nodep); }
 
     // Widths: out signed/unsigned width = lhs width, input un|signed
-    virtual void visit(AstSigned* nodep) VL_OVERRIDE {
+    virtual void visit(AstSigned* nodep) override {
         visit_signed_unsigned(nodep, VSigning::SIGNED);
     }
-    virtual void visit(AstUnsigned* nodep) VL_OVERRIDE {
+    virtual void visit(AstUnsigned* nodep) override {
         visit_signed_unsigned(nodep, VSigning::UNSIGNED);
     }
 
     // Widths: Output width from lhs, rhs<33 bits
     // Signed: If lhs signed
-    virtual void visit(AstShiftL* nodep) VL_OVERRIDE { visit_shift(nodep); }
-    virtual void visit(AstShiftR* nodep) VL_OVERRIDE { visit_shift(nodep); }
+    virtual void visit(AstShiftL* nodep) override { visit_shift(nodep); }
+    virtual void visit(AstShiftR* nodep) override { visit_shift(nodep); }
     // ShiftRS converts to ShiftR, but not vice-versa
-    virtual void visit(AstShiftRS* nodep) VL_OVERRIDE { visit_shift(nodep); }
+    virtual void visit(AstShiftRS* nodep) override { visit_shift(nodep); }
 
     //========
     // Widths: Output real, input integer signed
-    virtual void visit(AstBitsToRealD* nodep) VL_OVERRIDE { visit_Or_Lu64(nodep); }
+    virtual void visit(AstBitsToRealD* nodep) override { visit_Or_Lu64(nodep); }
 
     // Widths: Output integer signed, input real
-    virtual void visit(AstRToIS* nodep) VL_OVERRIDE { visit_Os32_Lr(nodep); }
-    virtual void visit(AstRToIRoundS* nodep) VL_OVERRIDE {
+    virtual void visit(AstRToIS* nodep) override { visit_Os32_Lr(nodep); }
+    virtual void visit(AstRToIRoundS* nodep) override {
         // Only created here, size comes from upper expression
         if (m_vup->prelim()) {  // First stage evaluation
             iterateCheckReal(nodep, "LHS", nodep->lhsp(), BOTH);
@@ -344,11 +344,11 @@ private:
     }
 
     // Widths: Output integer unsigned, input real
-    virtual void visit(AstRealToBits* nodep) VL_OVERRIDE { visit_Ou64_Lr(nodep); }
+    virtual void visit(AstRealToBits* nodep) override { visit_Ou64_Lr(nodep); }
 
     // Output integer, input string
-    virtual void visit(AstLenN* nodep) VL_OVERRIDE { visit_Os32_string(nodep); }
-    virtual void visit(AstPutcN* nodep) VL_OVERRIDE {
+    virtual void visit(AstLenN* nodep) override { visit_Os32_string(nodep); }
+    virtual void visit(AstPutcN* nodep) override {
         // CALLER: str.putc()
         UASSERT_OBJ(nodep->rhsp() && nodep->thsp(), nodep, "For ternary ops only!");
         if (m_vup && m_vup->prelim()) {
@@ -360,7 +360,7 @@ private:
                                       // AstAssign
         }
     }
-    virtual void visit(AstGetcN* nodep) VL_OVERRIDE {
+    virtual void visit(AstGetcN* nodep) override {
         // CALLER: str.getc()
         UASSERT_OBJ(nodep->rhsp(), nodep, "For binary ops only!");
         if (m_vup && m_vup->prelim()) {
@@ -370,7 +370,7 @@ private:
             nodep->dtypeSetBitSized(8, VSigning::UNSIGNED);
         }
     }
-    virtual void visit(AstGetcRefN* nodep) VL_OVERRIDE {
+    virtual void visit(AstGetcRefN* nodep) override {
         // CALLER: str.getc()
         UASSERT_OBJ(nodep->rhsp(), nodep, "For binary ops only!");
         if (m_vup && m_vup->prelim()) {
@@ -380,7 +380,7 @@ private:
             nodep->dtypeSetBitSized(8, VSigning::UNSIGNED);
         }
     }
-    virtual void visit(AstSubstrN* nodep) VL_OVERRIDE {
+    virtual void visit(AstSubstrN* nodep) override {
         // CALLER: str.substr()
         UASSERT_OBJ(nodep->rhsp() && nodep->thsp(), nodep, "For ternary ops only!");
         if (m_vup && m_vup->prelim()) {
@@ -391,7 +391,7 @@ private:
             nodep->dtypeSetString();
         }
     }
-    virtual void visit(AstCompareNN* nodep) VL_OVERRIDE {
+    virtual void visit(AstCompareNN* nodep) override {
         // CALLER: str.compare(), str.icompare()
         // Widths: 32 bit out
         UASSERT_OBJ(nodep->rhsp(), nodep, "For binary ops only!");
@@ -402,7 +402,7 @@ private:
             nodep->dtypeSetSigned32();
         }
     }
-    virtual void visit(AstAtoN* nodep) VL_OVERRIDE {
+    virtual void visit(AstAtoN* nodep) override {
         // CALLER: str.atobin(), atoi(), atohex(), atooct(), atoreal()
         // Width: 64bit floating point for atoreal(), 32bit out for the others
         if (m_vup->prelim()) {
@@ -417,14 +417,14 @@ private:
     }
 
     // Widths: Constant, terminal
-    virtual void visit(AstTime* nodep) VL_OVERRIDE { nodep->dtypeSetUInt64(); }
-    virtual void visit(AstTimeD* nodep) VL_OVERRIDE { nodep->dtypeSetDouble(); }
-    virtual void visit(AstTestPlusArgs* nodep) VL_OVERRIDE { nodep->dtypeSetSigned32(); }
-    virtual void visit(AstScopeName* nodep) VL_OVERRIDE {
+    virtual void visit(AstTime* nodep) override { nodep->dtypeSetUInt64(); }
+    virtual void visit(AstTimeD* nodep) override { nodep->dtypeSetDouble(); }
+    virtual void visit(AstTestPlusArgs* nodep) override { nodep->dtypeSetSigned32(); }
+    virtual void visit(AstScopeName* nodep) override {
         nodep->dtypeSetUInt64();  // A pointer, but not that it matters
     }
 
-    virtual void visit(AstNodeCond* nodep) VL_OVERRIDE {
+    virtual void visit(AstNodeCond* nodep) override {
         // op = cond ? expr1 : expr2
         // See IEEE-2012 11.4.11 and Table 11-21.
         //   LHS is self-determined
@@ -465,7 +465,7 @@ private:
                          EXTEND_EXP);
         }
     }
-    virtual void visit(AstConcat* nodep) VL_OVERRIDE {
+    virtual void visit(AstConcat* nodep) override {
         // Real: Not allowed (assumed)
         // Signed: unsigned output, input either (assumed)
         // IEEE-2012 Table 11-21, and 11.8.1:
@@ -519,7 +519,7 @@ private:
             }
         }
     }
-    virtual void visit(AstConcatN* nodep) VL_OVERRIDE {
+    virtual void visit(AstConcatN* nodep) override {
         // String concatenate.
         // Already did AstConcat simplifications
         if (m_vup->prelim()) {
@@ -535,7 +535,7 @@ private:
             }
         }
     }
-    virtual void visit(AstDelay* nodep) VL_OVERRIDE {
+    virtual void visit(AstDelay* nodep) override {
         if (VN_IS(m_procedurep, Final)) {
             nodep->v3error("Delays are not legal in final blocks (IEEE 1800-2017 9.2.3)");
             VL_DO_DANGLING(pushDeletep(nodep->unlinkFrBack()), nodep);
@@ -550,7 +550,7 @@ private:
         nodep->v3warn(STMTDLY, "Unsupported: Ignoring delay on this delayed statement.");
         VL_DO_DANGLING(pushDeletep(nodep->unlinkFrBack()), nodep);
     }
-    virtual void visit(AstFork* nodep) VL_OVERRIDE {
+    virtual void visit(AstFork* nodep) override {
         if (VN_IS(m_ftaskp, Func) && !nodep->joinType().joinNone()) {
             nodep->v3error("Only fork .. join_none is legal in functions. "
                            "(IEEE 1800-2017 13.4.4)");
@@ -567,27 +567,27 @@ private:
             // TBD might support only normal join, if so complain about other join flavors
         }
     }
-    virtual void visit(AstDisableFork* nodep) VL_OVERRIDE {
+    virtual void visit(AstDisableFork* nodep) override {
         nodep->v3warn(E_UNSUPPORTED, "Unsupported: disable fork statements");
         VL_DO_DANGLING(nodep->unlinkFrBack()->deleteTree(), nodep);
     }
-    virtual void visit(AstWaitFork* nodep) VL_OVERRIDE {
+    virtual void visit(AstWaitFork* nodep) override {
         nodep->v3warn(E_UNSUPPORTED, "Unsupported: wait fork statements");
         VL_DO_DANGLING(nodep->unlinkFrBack()->deleteTree(), nodep);
     }
-    virtual void visit(AstToLowerN* nodep) VL_OVERRIDE {
+    virtual void visit(AstToLowerN* nodep) override {
         if (m_vup->prelim()) {
             iterateCheckString(nodep, "LHS", nodep->lhsp(), BOTH);
             nodep->dtypeSetString();
         }
     }
-    virtual void visit(AstToUpperN* nodep) VL_OVERRIDE {
+    virtual void visit(AstToUpperN* nodep) override {
         if (m_vup->prelim()) {
             iterateCheckString(nodep, "LHS", nodep->lhsp(), BOTH);
             nodep->dtypeSetString();
         }
     }
-    virtual void visit(AstReplicate* nodep) VL_OVERRIDE {
+    virtual void visit(AstReplicate* nodep) override {
         // IEEE-2012 Table 11-21:
         //   LHS, RHS is self-determined
         //   width: value(LHS) * width(RHS)
@@ -634,7 +634,7 @@ private:
             }
         }
     }
-    virtual void visit(AstReplicateN* nodep) VL_OVERRIDE {
+    virtual void visit(AstReplicateN* nodep) override {
         // Replicate with string
         if (m_vup->prelim()) {
             iterateCheckString(nodep, "LHS", nodep->lhsp(), BOTH);
@@ -661,7 +661,7 @@ private:
             }
         }
     }
-    virtual void visit(AstNodeStream* nodep) VL_OVERRIDE {
+    virtual void visit(AstNodeStream* nodep) override {
         if (m_vup->prelim()) {
             iterateCheckSizedSelf(nodep, "LHS", nodep->lhsp(), SELF, BOTH);
             iterateCheckSizedSelf(nodep, "RHS", nodep->rhsp(), SELF, BOTH);
@@ -694,7 +694,7 @@ private:
             }
         }
     }
-    virtual void visit(AstRange* nodep) VL_OVERRIDE {
+    virtual void visit(AstRange* nodep) override {
         // Real: Not allowed
         // Signed: unsigned output, input either
         // Convert all range values to constants
@@ -730,7 +730,7 @@ private:
         }
     }
 
-    virtual void visit(AstSel* nodep) VL_OVERRIDE {
+    virtual void visit(AstSel* nodep) override {
         // Signed: always unsigned; Real: Not allowed
         // LSB is self-determined (IEEE 2012 11.5.1)
         // We also use SELs to shorten a signed constant etc, in this case they are signed.
@@ -837,7 +837,7 @@ private:
         }
     }
 
-    virtual void visit(AstArraySel* nodep) VL_OVERRIDE {
+    virtual void visit(AstArraySel* nodep) override {
         // Signed/Real: Output signed iff LHS signed/real; binary operator
         // Note by contrast, bit extract selects are unsigned
         // LSB is self-determined (IEEE 2012 11.5.1)
@@ -899,7 +899,7 @@ private:
         }
     }
 
-    virtual void visit(AstAssocSel* nodep) VL_OVERRIDE {
+    virtual void visit(AstAssocSel* nodep) override {
         // Signed/Real: Output type based on array-declared type; binary operator
         if (m_vup->prelim()) {
             AstNodeDType* fromDtp = nodep->fromp()->dtypep()->skipRefp();
@@ -914,7 +914,7 @@ private:
         }
     }
 
-    virtual void visit(AstSliceSel* nodep) VL_OVERRIDE {
+    virtual void visit(AstSliceSel* nodep) override {
         // Always creates as output an unpacked array
         if (m_vup->prelim()) {
             userIterateAndNext(nodep->fromp(), WidthVP(SELF, BOTH).p());
@@ -954,7 +954,7 @@ private:
         }
     }
 
-    virtual void visit(AstSelBit* nodep) VL_OVERRIDE {
+    virtual void visit(AstSelBit* nodep) override {
         // Just a quick check as after V3Param these nodes instead are AstSel's
         userIterateAndNext(nodep->fromp(), WidthVP(CONTEXT, PRELIM).p());  // FINAL in AstSel
         userIterateAndNext(nodep->rhsp(), WidthVP(CONTEXT, PRELIM).p());  // FINAL in AstSel
@@ -968,7 +968,7 @@ private:
         }
         nodep->v3fatalSrc("AstSelBit should disappear after widthSel");
     }
-    virtual void visit(AstSelExtract* nodep) VL_OVERRIDE {
+    virtual void visit(AstSelExtract* nodep) override {
         // Just a quick check as after V3Param these nodes instead are AstSel's
         userIterateAndNext(nodep->fromp(), WidthVP(CONTEXT, PRELIM).p());  // FINAL in AstSel
         userIterateAndNext(nodep->rhsp(), WidthVP(CONTEXT, PRELIM).p());  // FINAL in AstSel
@@ -982,7 +982,7 @@ private:
         }
         nodep->v3fatalSrc("AstSelExtract should disappear after widthSel");
     }
-    virtual void visit(AstSelPlus* nodep) VL_OVERRIDE {
+    virtual void visit(AstSelPlus* nodep) override {
         userIterateAndNext(nodep->fromp(), WidthVP(CONTEXT, PRELIM).p());  // FINAL in AstSel
         userIterateAndNext(nodep->rhsp(), WidthVP(CONTEXT, PRELIM).p());  // FINAL in AstSel
         userIterateAndNext(nodep->thsp(), WidthVP(CONTEXT, PRELIM).p());  // FINAL in AstSel
@@ -995,7 +995,7 @@ private:
         }
         nodep->v3fatalSrc("AstSelPlus should disappear after widthSel");
     }
-    virtual void visit(AstSelMinus* nodep) VL_OVERRIDE {
+    virtual void visit(AstSelMinus* nodep) override {
         userIterateAndNext(nodep->fromp(), WidthVP(CONTEXT, PRELIM).p());  // FINAL in AstSel
         userIterateAndNext(nodep->rhsp(), WidthVP(CONTEXT, PRELIM).p());  // FINAL in AstSel
         userIterateAndNext(nodep->thsp(), WidthVP(CONTEXT, PRELIM).p());  // FINAL in AstSel
@@ -1009,13 +1009,13 @@ private:
         nodep->v3fatalSrc("AstSelMinus should disappear after widthSel");
     }
 
-    virtual void visit(AstExtend* nodep) VL_OVERRIDE {
+    virtual void visit(AstExtend* nodep) override {
         // Only created by this process, so we know width from here down is correct.
     }
-    virtual void visit(AstExtendS* nodep) VL_OVERRIDE {
+    virtual void visit(AstExtendS* nodep) override {
         // Only created by this process, so we know width from here down is correct.
     }
-    virtual void visit(AstConst* nodep) VL_OVERRIDE {
+    virtual void visit(AstConst* nodep) override {
         // The node got setup with the signed/real state of the node.
         // However a later operation may have changed the node->signed w/o changing
         // the number's sign.  So we don't: nodep->dtypeChgSigned(nodep->num().isSigned());
@@ -1031,13 +1031,13 @@ private:
         // We don't size the constant until we commit the widths, as need parameters
         // to remain unsized, and numbers to remain unsized to avoid backp() warnings
     }
-    virtual void visit(AstFell* nodep) VL_OVERRIDE {
+    virtual void visit(AstFell* nodep) override {
         if (m_vup->prelim()) {
             iterateCheckSizedSelf(nodep, "LHS", nodep->exprp(), SELF, BOTH);
             nodep->dtypeSetLogicBool();
         }
     }
-    virtual void visit(AstPast* nodep) VL_OVERRIDE {
+    virtual void visit(AstPast* nodep) override {
         if (m_vup->prelim()) {
             iterateCheckSizedSelf(nodep, "LHS", nodep->exprp(), SELF, BOTH);
             nodep->dtypeFrom(nodep->exprp());
@@ -1061,46 +1061,46 @@ private:
             }
         }
     }
-    virtual void visit(AstRose* nodep) VL_OVERRIDE {
+    virtual void visit(AstRose* nodep) override {
         if (m_vup->prelim()) {
             iterateCheckSizedSelf(nodep, "LHS", nodep->exprp(), SELF, BOTH);
             nodep->dtypeSetLogicBool();
         }
     }
 
-    virtual void visit(AstSampled* nodep) VL_OVERRIDE {
+    virtual void visit(AstSampled* nodep) override {
         if (m_vup->prelim()) {
             iterateCheckSizedSelf(nodep, "LHS", nodep->exprp(), SELF, BOTH);
             nodep->dtypeFrom(nodep->exprp());
         }
     }
 
-    virtual void visit(AstStable* nodep) VL_OVERRIDE {
+    virtual void visit(AstStable* nodep) override {
         if (m_vup->prelim()) {
             iterateCheckSizedSelf(nodep, "LHS", nodep->exprp(), SELF, BOTH);
             nodep->dtypeSetLogicBool();
         }
     }
 
-    virtual void visit(AstRand* nodep) VL_OVERRIDE {
+    virtual void visit(AstRand* nodep) override {
         if (m_vup->prelim()) {
             nodep->dtypeSetSigned32();  // Says the spec
         }
     }
-    virtual void visit(AstUnbounded* nodep) VL_OVERRIDE {
+    virtual void visit(AstUnbounded* nodep) override {
         nodep->dtypeSetSigned32();  // Used in int context
         if (!VN_IS(nodep->backp(), IsUnbounded) && !VN_IS(nodep->backp(), BracketArrayDType)
             && !(VN_IS(nodep->backp(), Var) && VN_CAST(nodep->backp(), Var)->isParam())) {
             nodep->v3warn(E_UNSUPPORTED, "Unsupported/illegal unbounded ('$') in this context.");
         }
     }
-    virtual void visit(AstIsUnbounded* nodep) VL_OVERRIDE {
+    virtual void visit(AstIsUnbounded* nodep) override {
         if (m_vup->prelim()) {
             userIterateAndNext(nodep->lhsp(), WidthVP(SELF, BOTH).p());
             nodep->dtypeSetLogicBool();
         }
     }
-    virtual void visit(AstUCFunc* nodep) VL_OVERRIDE {
+    virtual void visit(AstUCFunc* nodep) override {
         // Give it the size the user wants.
         if (m_vup && m_vup->prelim()) {
             nodep->dtypeSetLogicUnsized(32, 1, VSigning::UNSIGNED);  // We don't care
@@ -1115,13 +1115,13 @@ private:
             }
         }
     }
-    virtual void visit(AstCLog2* nodep) VL_OVERRIDE {
+    virtual void visit(AstCLog2* nodep) override {
         if (m_vup->prelim()) {
             iterateCheckSizedSelf(nodep, "LHS", nodep->lhsp(), SELF, BOTH);
             nodep->dtypeSetSigned32();
         }
     }
-    virtual void visit(AstPow* nodep) VL_OVERRIDE {
+    virtual void visit(AstPow* nodep) override {
         // Pow is special, output sign only depends on LHS sign, but
         // function result depends on both signs
         // RHS is self-determined (IEEE)
@@ -1165,25 +1165,25 @@ private:
             }
         }
     }
-    virtual void visit(AstPowSU* nodep) VL_OVERRIDE {
+    virtual void visit(AstPowSU* nodep) override {
         // POWSU/SS/US only created here, dtype already determined, so
         // nothing to do in this function
         userIterateAndNext(nodep->lhsp(), WidthVP(SELF, BOTH).p());
         userIterateAndNext(nodep->rhsp(), WidthVP(SELF, BOTH).p());
     }
-    virtual void visit(AstPowSS* nodep) VL_OVERRIDE {
+    virtual void visit(AstPowSS* nodep) override {
         // POWSU/SS/US only created here, dtype already determined, so
         // nothing to do in this function
         userIterateAndNext(nodep->lhsp(), WidthVP(SELF, BOTH).p());
         userIterateAndNext(nodep->rhsp(), WidthVP(SELF, BOTH).p());
     }
-    virtual void visit(AstPowUS* nodep) VL_OVERRIDE {
+    virtual void visit(AstPowUS* nodep) override {
         // POWSU/SS/US only created here, dtype already determined, so
         // nothing to do in this function
         userIterateAndNext(nodep->lhsp(), WidthVP(SELF, BOTH).p());
         userIterateAndNext(nodep->rhsp(), WidthVP(SELF, BOTH).p());
     }
-    virtual void visit(AstCountBits* nodep) VL_OVERRIDE {
+    virtual void visit(AstCountBits* nodep) override {
         if (m_vup->prelim()) {
             iterateCheckSizedSelf(nodep, "LHS", nodep->lhsp(), SELF, BOTH);
             iterateCheckSizedSelf(nodep, "RHS", nodep->rhsp(), SELF, BOTH);
@@ -1195,7 +1195,7 @@ private:
                                       VSigning::UNSIGNED);  // Spec doesn't indicate if an integer
         }
     }
-    virtual void visit(AstCountOnes* nodep) VL_OVERRIDE {
+    virtual void visit(AstCountOnes* nodep) override {
         if (m_vup->prelim()) {
             iterateCheckSizedSelf(nodep, "LHS", nodep->lhsp(), SELF, BOTH);
             // If it's a 32 bit number, we need a 6 bit number as we need to return '32'.
@@ -1204,12 +1204,12 @@ private:
                                       VSigning::UNSIGNED);  // Spec doesn't indicate if an integer
         }
     }
-    virtual void visit(AstCvtPackString* nodep) VL_OVERRIDE {
+    virtual void visit(AstCvtPackString* nodep) override {
         // Opaque returns, so arbitrary
         userIterateAndNext(nodep->lhsp(), WidthVP(SELF, BOTH).p());
         // Type set in constructor
     }
-    virtual void visit(AstTimeImport* nodep) VL_OVERRIDE {
+    virtual void visit(AstTimeImport* nodep) override {
         // LHS is a real number in seconds
         // Need to round to time units and precision
         userIterateAndNext(nodep->lhsp(), WidthVP(SELF, BOTH).p());
@@ -1224,7 +1224,7 @@ private:
         nodep->replaceWith(newp);
         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;
         userIterateAndNext(nodep->fromp(), WidthVP(SELF, BOTH).p());
@@ -1349,16 +1349,16 @@ private:
         }
         m_attrp = oldAttr;
     }
-    virtual void visit(AstPull* nodep) VL_OVERRIDE {
+    virtual void visit(AstPull* nodep) override {
         // May have select underneath, let seek natural size
         userIterateChildren(nodep, WidthVP(SELF, BOTH).p());
     }
-    virtual void visit(AstText* nodep) VL_OVERRIDE {
+    virtual void visit(AstText* nodep) override {
         // Only used in CStmts which don't care....
     }
 
     // DTYPES
-    virtual void visit(AstNodeArrayDType* nodep) VL_OVERRIDE {
+    virtual void visit(AstNodeArrayDType* nodep) override {
         if (nodep->didWidthAndSet()) return;  // This node is a dtype & not both PRELIMed+FINALed
         // Iterate into subDTypep() to resolve that type and update pointer.
         nodep->refDTypep(iterateEditMoveDTypep(nodep, nodep->subDTypep()));
@@ -1374,7 +1374,7 @@ private:
         }
         UINFO(4, "dtWidthed " << nodep << endl);
     }
-    virtual void visit(AstAssocArrayDType* nodep) VL_OVERRIDE {
+    virtual void visit(AstAssocArrayDType* nodep) override {
         if (nodep->didWidthAndSet()) return;  // This node is a dtype & not both PRELIMed+FINALed
         // Iterate into subDTypep() to resolve that type and update pointer.
         nodep->refDTypep(iterateEditMoveDTypep(nodep, nodep->subDTypep()));
@@ -1382,7 +1382,7 @@ private:
         nodep->dtypep(nodep);  // The array itself, not subDtype
         UINFO(4, "dtWidthed " << nodep << endl);
     }
-    virtual void visit(AstBracketArrayDType* nodep) VL_OVERRIDE {
+    virtual void visit(AstBracketArrayDType* nodep) override {
         // Type inserted only because parser didn't know elementsp() type
         // Resolve elementsp's type
         userIterateChildren(nodep, WidthVP(SELF, BOTH).p());
@@ -1411,14 +1411,14 @@ private:
         // visit
         VL_DO_DANGLING(userIterate(newp, NULL), newp);
     }
-    virtual void visit(AstDynArrayDType* nodep) VL_OVERRIDE {
+    virtual void visit(AstDynArrayDType* nodep) override {
         if (nodep->didWidthAndSet()) return;  // This node is a dtype & not both PRELIMed+FINALed
         // Iterate into subDTypep() to resolve that type and update pointer.
         nodep->refDTypep(iterateEditMoveDTypep(nodep, nodep->subDTypep()));
         nodep->dtypep(nodep);  // The array itself, not subDtype
         UINFO(4, "dtWidthed " << nodep << endl);
     }
-    virtual void visit(AstQueueDType* nodep) VL_OVERRIDE {
+    virtual void visit(AstQueueDType* nodep) override {
         if (nodep->didWidthAndSet()) return;  // This node is a dtype & not both PRELIMed+FINALed
         // Iterate into subDTypep() to resolve that type and update pointer.
         nodep->refDTypep(iterateEditMoveDTypep(nodep, nodep->subDTypep()));
@@ -1428,7 +1428,7 @@ private:
         }
         UINFO(4, "dtWidthed " << nodep << endl);
     }
-    virtual void visit(AstUnsizedArrayDType* nodep) VL_OVERRIDE {
+    virtual void visit(AstUnsizedArrayDType* nodep) override {
         if (nodep->didWidthAndSet()) return;  // This node is a dtype & not both PRELIMed+FINALed
         // Iterate into subDTypep() to resolve that type and update pointer.
         nodep->refDTypep(iterateEditMoveDTypep(nodep, nodep->subDTypep()));
@@ -1436,7 +1436,7 @@ private:
         nodep->dtypep(nodep);  // The array itself, not subDtype
         UINFO(4, "dtWidthed " << nodep << endl);
     }
-    virtual void visit(AstBasicDType* nodep) VL_OVERRIDE {
+    virtual void visit(AstBasicDType* nodep) override {
         if (nodep->didWidthAndSet()) return;  // This node is a dtype & not both PRELIMed+FINALed
         if (nodep->generic()) return;  // Already perfect
         if (nodep->rangep()) {
@@ -1459,7 +1459,7 @@ private:
         // dtype Instead for now doing this in V3WidthCommit
         UINFO(4, "dtWidthed " << nodep << endl);
     }
-    virtual void visit(AstConstDType* nodep) VL_OVERRIDE {
+    virtual void visit(AstConstDType* nodep) override {
         if (nodep->didWidthAndSet()) return;  // This node is a dtype & not both PRELIMed+FINALed
         // Iterate into subDTypep() to resolve that type and update pointer.
         nodep->refDTypep(iterateEditMoveDTypep(nodep, nodep->subDTypep()));
@@ -1468,7 +1468,7 @@ private:
         nodep->widthFromSub(nodep->subDTypep());
         UINFO(4, "dtWidthed " << nodep << endl);
     }
-    virtual void visit(AstRefDType* nodep) VL_OVERRIDE {
+    virtual void visit(AstRefDType* nodep) override {
         if (nodep->doingWidth()) {  // Early exit if have circular parameter definition
             nodep->v3error("Typedef's type is circular: " << nodep->prettyName());
             nodep->dtypeSetLogicBool();
@@ -1506,25 +1506,25 @@ private:
         UINFO(4, "dtWidthed " << nodep << endl);
         nodep->doingWidth(false);
     }
-    virtual void visit(AstTypedef* nodep) VL_OVERRIDE {
+    virtual void visit(AstTypedef* nodep) override {
         if (nodep->didWidthAndSet()) return;  // This node is a dtype & not both PRELIMed+FINALed
         nodep->dtypep(iterateEditMoveDTypep(nodep, nodep->subDTypep()));
         userIterateChildren(nodep, NULL);
     }
-    virtual void visit(AstParamTypeDType* nodep) VL_OVERRIDE {
+    virtual void visit(AstParamTypeDType* nodep) override {
         if (nodep->didWidthAndSet()) return;  // This node is a dtype & not both PRELIMed+FINALed
         nodep->dtypep(iterateEditMoveDTypep(nodep, nodep->subDTypep()));
         userIterateChildren(nodep, NULL);
         nodep->widthFromSub(nodep->subDTypep());
     }
-    virtual void visit(AstCastDynamic* nodep) VL_OVERRIDE {
+    virtual void visit(AstCastDynamic* nodep) override {
         nodep->v3warn(E_UNSUPPORTED, "Unsupported: $cast. Suggest try static cast.");
         AstNode* newp = new AstConst(nodep->fileline(), 1);
         newp->dtypeSetSigned32();  // Spec says integer return
         nodep->replaceWith(newp);
         VL_DO_DANGLING(pushDeletep(nodep), nodep);
     }
-    virtual void visit(AstCastParse* nodep) VL_OVERRIDE {
+    virtual void visit(AstCastParse* nodep) override {
         // nodep->dtp could be data type, or a primary_constant
         // Don't iterate lhsp, will deal with that once convert the type
         V3Const::constifyParamsEdit(nodep->dtp());  // itemp may change
@@ -1541,7 +1541,7 @@ private:
             nodep->replaceWith(nodep->lhsp()->unlinkFrBack());
         }
     }
-    virtual void visit(AstCast* nodep) VL_OVERRIDE {
+    virtual void visit(AstCast* nodep) override {
         nodep->dtypep(iterateEditMoveDTypep(nodep, nodep->subDTypep()));
         // if (debug()) nodep->dumpTree(cout, "  CastPre: ");
         userIterateAndNext(nodep->lhsp(), WidthVP(SELF, PRELIM).p());
@@ -1588,7 +1588,7 @@ private:
         VL_DO_DANGLING(pushDeletep(nodep), nodep);
         // if (debug()) newp->dumpTree(cout, "  CastOut: ");
     }
-    virtual void visit(AstCastSize* nodep) VL_OVERRIDE {
+    virtual void visit(AstCastSize* nodep) override {
         // IEEE: Signedness of result is same as self-determined signedness
         // However, the result is same as BITSEL, so we do not sign extend the LHS
         UASSERT_OBJ(VN_IS(nodep->rhsp(), Const), nodep, "Unsupported: Non-const cast of size");
@@ -1642,7 +1642,7 @@ private:
         }
         // if (debug()) nodep->dumpTree(cout, "  CastSizeOut: ");
     }
-    virtual void visit(AstVar* nodep) VL_OVERRIDE {
+    virtual void visit(AstVar* nodep) override {
         // if (debug()) nodep->dumpTree(cout, "  InitPre: ");
         // Must have deterministic constant width
         // We can't skip this step when width()!=0, as creating a AstVar
@@ -1751,7 +1751,7 @@ private:
         nodep->didWidth(true);
         nodep->doingWidth(false);
     }
-    virtual void visit(AstNodeVarRef* nodep) VL_OVERRIDE {
+    virtual void visit(AstNodeVarRef* nodep) override {
         if (nodep->didWidth()) return;
         if (!nodep->varp()) {
             if (m_paramsOnly && VN_IS(nodep, VarXRef)) {
@@ -1787,7 +1787,7 @@ private:
         nodep->didWidth(true);
     }
 
-    virtual void visit(AstEnumDType* nodep) VL_OVERRIDE {
+    virtual void visit(AstEnumDType* nodep) override {
         if (nodep->didWidthAndSet()) return;  // This node is a dtype & not both PRELIMed+FINALed
         UINFO(5, "  ENUMDTYPE " << nodep << endl);
         nodep->refDTypep(iterateEditMoveDTypep(nodep, nodep->subDTypep()));
@@ -1848,7 +1848,7 @@ private:
             num.opAdd(one, constp->num());
         }
     }
-    virtual void visit(AstEnumItem* nodep) VL_OVERRIDE {
+    virtual void visit(AstEnumItem* nodep) override {
         UINFO(5, "   ENUMITEM " << nodep << endl);
         AstNodeDType* vdtypep = m_vup->dtypep();
         UASSERT_OBJ(vdtypep, nodep, "ENUMITEM not under ENUM");
@@ -1862,7 +1862,7 @@ private:
                          EXTEND_EXP);
         }
     }
-    virtual void visit(AstEnumItemRef* nodep) VL_OVERRIDE {
+    virtual void visit(AstEnumItemRef* nodep) override {
         if (!nodep->itemp()->didWidth()) {
             // We need to do the whole enum en-mass
             AstNode* enump = nodep->itemp();
@@ -1875,10 +1875,10 @@ private:
         }
         nodep->dtypeFrom(nodep->itemp());
     }
-    virtual void visit(AstInitItem* nodep) VL_OVERRIDE {  //
+    virtual void visit(AstInitItem* nodep) override {  //
         userIterateChildren(nodep, m_vup);
     }
-    virtual void visit(AstInitArray* nodep) VL_OVERRIDE {
+    virtual void visit(AstInitArray* nodep) override {
         // InitArray has type of the array; children are array values
         if (m_vup->prelim()) {  // First stage evaluation
             AstNodeDType* vdtypep = m_vup->dtypep();
@@ -1891,7 +1891,7 @@ private:
             }
         }
     }
-    virtual void visit(AstInside* nodep) VL_OVERRIDE {
+    virtual void visit(AstInside* nodep) override {
         userIterateAndNext(nodep->exprp(), WidthVP(CONTEXT, PRELIM).p());
         for (AstNode *nextip, *itemp = nodep->itemsp(); itemp; itemp = nextip) {
             nextip = itemp->nextp();  // Prelim may cause the node to get replaced
@@ -1938,14 +1938,14 @@ private:
         nodep->replaceWith(newp);
         VL_DO_DANGLING(pushDeletep(nodep), nodep);
     }
-    virtual void visit(AstInsideRange* nodep) VL_OVERRIDE {
+    virtual void visit(AstInsideRange* nodep) override {
         // Just do each side; AstInside will rip these nodes out later
         userIterateAndNext(nodep->lhsp(), m_vup);
         userIterateAndNext(nodep->rhsp(), m_vup);
         nodep->dtypeFrom(nodep->lhsp());
     }
 
-    virtual void visit(AstIfaceRefDType* nodep) VL_OVERRIDE {
+    virtual void visit(AstIfaceRefDType* nodep) override {
         if (nodep->didWidthAndSet()) return;  // This node is a dtype & not both PRELIMed+FINALed
         UINFO(5, "   IFACEREF " << nodep << endl);
         userIterateChildren(nodep, m_vup);
@@ -1953,7 +1953,7 @@ private:
         nodep->widthForce(1, 1);  // Not really relevant
         UINFO(4, "dtWidthed " << nodep << endl);
     }
-    virtual void visit(AstNodeUOrStructDType* nodep) VL_OVERRIDE {
+    virtual void visit(AstNodeUOrStructDType* nodep) override {
         if (nodep->didWidthAndSet()) return;  // This node is a dtype & not both PRELIMed+FINALed
         UINFO(5, "   NODECLASS " << nodep << endl);
         // if (debug() >= 9) nodep->dumpTree("-class-in--");
@@ -1988,33 +1988,33 @@ private:
         nodep->widthForce(width, width);  // Signing stays as-is, as parsed from declaration
         // if (debug() >= 9) nodep->dumpTree("-class-out-");
     }
-    virtual void visit(AstClass* nodep) VL_OVERRIDE {
+    virtual void visit(AstClass* nodep) override {
         if (nodep->didWidthAndSet()) return;
         userIterateChildren(nodep, NULL);  // First size all members
         if (nodep->isVirtual()) nodep->v3warn(E_UNSUPPORTED, "Unsupported: virtual class");
         nodep->repairCache();
     }
-    virtual void visit(AstClassRefDType* nodep) VL_OVERRIDE {
+    virtual void visit(AstClassRefDType* nodep) override {
         if (nodep->didWidthAndSet()) return;
         // TODO this maybe eventually required to properly resolve members,
         // though causes problems with t_class_forward.v, so for now avoided
         // userIterateChildren(nodep->classp(), NULL);
     }
-    virtual void visit(AstClassExtends* nodep) VL_OVERRIDE {
+    virtual void visit(AstClassExtends* nodep) override {
         if (nodep->didWidthAndSet()) return;
         nodep->v3warn(E_UNSUPPORTED, "Unsupported: class extends");  // Member/meth access breaks
         VL_DO_DANGLING(nodep->unlinkFrBack()->deleteTree(), nodep);
         // nodep->dtypep(iterateEditMoveDTypep(nodep));  // data_type '{ pattern }
         // userIterateChildren(nodep, NULL);
     }
-    virtual void visit(AstMemberDType* nodep) VL_OVERRIDE {
+    virtual void visit(AstMemberDType* nodep) override {
         if (nodep->didWidthAndSet()) return;  // This node is a dtype & not both PRELIMed+FINALed
         // Iterate into subDTypep() to resolve that type and update pointer.
         nodep->refDTypep(iterateEditMoveDTypep(nodep, nodep->subDTypep()));
         nodep->dtypep(nodep);  // The member itself, not subDtype
         nodep->widthFromSub(nodep->subDTypep());
     }
-    virtual void visit(AstMemberSel* nodep) VL_OVERRIDE {
+    virtual void visit(AstMemberSel* nodep) override {
         UINFO(5, "   MEMBERSEL " << nodep << endl);
         if (debug() >= 9) nodep->dumpTree("-mbs-in: ");
         userIterateChildren(nodep, WidthVP(SELF, BOTH).p());
@@ -2116,12 +2116,12 @@ private:
         return false;
     }
 
-    virtual void visit(AstCMethodHard* nodep) VL_OVERRIDE {
+    virtual void visit(AstCMethodHard* nodep) override {
         // Never created before V3Width, so no need to redo it
         UASSERT_OBJ(nodep->dtypep(), nodep, "CMETHODCALLs should have already been sized");
     }
 
-    virtual void visit(AstMethodCall* nodep) VL_OVERRIDE {
+    virtual void visit(AstMethodCall* nodep) override {
         UINFO(5, "   METHODCALL " << nodep << endl);
         if (nodep->didWidth()) return;
         if (debug() >= 9) nodep->dumpTree("-mts-in: ");
@@ -2678,7 +2678,7 @@ private:
         }
     }
 
-    virtual void visit(AstNew* nodep) VL_OVERRIDE {
+    virtual void visit(AstNew* nodep) override {
         if (nodep->didWidthAndSet()) return;
         AstClassRefDType* refp = VN_CAST(m_vup->dtypeNullp(), ClassRefDType);
         if (!refp) {  // e.g. int a = new;
@@ -2701,7 +2701,7 @@ private:
         userIterateChildren(nodep, NULL);
         processFTaskRefArgs(nodep);
     }
-    virtual void visit(AstNewCopy* nodep) VL_OVERRIDE {
+    virtual void visit(AstNewCopy* nodep) override {
         if (nodep->didWidthAndSet()) return;
         AstClassRefDType* refp = VN_CAST(m_vup->dtypeNullp(), ClassRefDType);
         if (!refp) {  // e.g. int a = new;
@@ -2716,7 +2716,7 @@ private:
                                    << nodep->rhsp()->dtypep()->prettyTypeName() << "'");
         }
     }
-    virtual void visit(AstNewDynamic* nodep) VL_OVERRIDE {
+    virtual void visit(AstNewDynamic* nodep) override {
         if (nodep->didWidthAndSet()) return;
         AstDynArrayDType* adtypep = VN_CAST(m_vup->dtypeNullp(), DynArrayDType);
         if (!adtypep) {  // e.g. int a = new;
@@ -2741,7 +2741,7 @@ private:
         }
     }
 
-    virtual void visit(AstPattern* nodep) VL_OVERRIDE {
+    virtual void visit(AstPattern* nodep) override {
         if (nodep->didWidthAndSet()) return;
         UINFO(9, "PATTERN " << nodep << endl);
         if (nodep->childDTypep()) {  // data_type '{ pattern }
@@ -3033,7 +3033,7 @@ private:
         return valuep;
     }
 
-    virtual void visit(AstPatMember* nodep) VL_OVERRIDE {
+    virtual void visit(AstPatMember* nodep) override {
         AstNodeDType* vdtypep = m_vup->dtypeNullp();
         UASSERT_OBJ(vdtypep, nodep, "Pattern member type not assigned by AstPattern visitor");
         nodep->dtypep(vdtypep);
@@ -3067,7 +3067,7 @@ private:
         return times;
     }
 
-    virtual void visit(AstPropClocked* nodep) VL_OVERRIDE {
+    virtual void visit(AstPropClocked* nodep) override {
         if (m_vup->prelim()) {  // First stage evaluation
             iterateCheckBool(nodep, "Property", nodep->propp(), BOTH);
             userIterateAndNext(nodep->sensesp(), NULL);
@@ -3082,7 +3082,7 @@ private:
     //--------------------
     // Top levels
 
-    virtual void visit(AstNodeCase* nodep) VL_OVERRIDE {
+    virtual void visit(AstNodeCase* nodep) override {
         // IEEE-2012 12.5:
         //    Width: MAX(expr, all items)
         //    Signed: Only if expr, and all items signed
@@ -3127,7 +3127,7 @@ private:
             }
         }
     }
-    virtual void visit(AstNodeFor* nodep) VL_OVERRIDE {
+    virtual void visit(AstNodeFor* nodep) override {
         assertAtStatement(nodep);
         userIterateAndNext(nodep->initsp(), NULL);
         iterateCheckBool(nodep, "For Test Condition", nodep->condp(),
@@ -3135,12 +3135,12 @@ private:
         if (!VN_IS(nodep, GenFor)) userIterateAndNext(nodep->bodysp(), NULL);
         userIterateAndNext(nodep->incsp(), NULL);
     }
-    virtual void visit(AstRepeat* nodep) VL_OVERRIDE {
+    virtual void visit(AstRepeat* nodep) override {
         assertAtStatement(nodep);
         userIterateAndNext(nodep->countp(), WidthVP(SELF, BOTH).p());
         userIterateAndNext(nodep->bodysp(), NULL);
     }
-    virtual void visit(AstWhile* nodep) VL_OVERRIDE {
+    virtual void visit(AstWhile* nodep) override {
         assertAtStatement(nodep);
         userIterateAndNext(nodep->precondsp(), NULL);
         iterateCheckBool(nodep, "For Test Condition", nodep->condp(),
@@ -3148,7 +3148,7 @@ private:
         userIterateAndNext(nodep->bodysp(), NULL);
         userIterateAndNext(nodep->incsp(), NULL);
     }
-    virtual void visit(AstNodeIf* nodep) VL_OVERRIDE {
+    virtual void visit(AstNodeIf* nodep) override {
         assertAtStatement(nodep);
         // if (debug()) nodep->dumpTree(cout, "  IfPre: ");
         if (!VN_IS(nodep, GenIf)) {  // for m_paramsOnly
@@ -3159,7 +3159,7 @@ private:
         // if (debug()) nodep->dumpTree(cout, "  IfOut: ");
     }
 
-    virtual void visit(AstNodeAssign* nodep) VL_OVERRIDE {
+    virtual void visit(AstNodeAssign* nodep) override {
         // IEEE-2012 10.7, 11.8.2, 11.8.3, 11.5:  (Careful of 11.8.1 which is
         //                  only one step; final dtype depends on assign LHS.)
         //    Determine RHS type width and signing
@@ -3210,7 +3210,7 @@ private:
         }
     }
 
-    virtual void visit(AstSFormatF* nodep) VL_OVERRIDE {
+    virtual void visit(AstSFormatF* nodep) override {
         // Excludes NodeDisplay, see below
         if (m_vup && !m_vup->prelim()) return;  // Can be called as statement or function
         // Just let all arguments seek their natural sizes
@@ -3361,13 +3361,13 @@ private:
         nodep->text(newFormat);
         UINFO(9, "  Display out " << nodep->text() << endl);
     }
-    virtual void visit(AstDisplay* nodep) VL_OVERRIDE {
+    virtual void visit(AstDisplay* nodep) override {
         assertAtStatement(nodep);
         if (nodep->filep()) iterateCheckFileDesc(nodep, nodep->filep(), BOTH);
         // Just let all arguments seek their natural sizes
         userIterateChildren(nodep, WidthVP(SELF, BOTH).p());
     }
-    virtual void visit(AstElabDisplay* nodep) VL_OVERRIDE {
+    virtual void visit(AstElabDisplay* nodep) override {
         assertAtStatement(nodep);
         // Just let all arguments seek their natural sizes
         userIterateChildren(nodep, WidthVP(SELF, BOTH).p());
@@ -3383,28 +3383,28 @@ private:
             VL_DO_DANGLING(nodep->unlinkFrBack()->deleteTree(), nodep);
         }
     }
-    virtual void visit(AstDumpCtl* nodep) VL_OVERRIDE {
+    virtual void visit(AstDumpCtl* nodep) override {
         assertAtStatement(nodep);
         // Just let all arguments seek their natural sizes
         userIterateChildren(nodep, WidthVP(SELF, BOTH).p());
     }
-    virtual void visit(AstFOpen* nodep) VL_OVERRIDE {
+    virtual void visit(AstFOpen* nodep) override {
         // Although a system function in IEEE, here a statement which sets the file pointer (MCD)
         assertAtStatement(nodep);
         iterateCheckFileDesc(nodep, nodep->filep(), BOTH);
         userIterateAndNext(nodep->filenamep(), WidthVP(SELF, BOTH).p());
         userIterateAndNext(nodep->modep(), WidthVP(SELF, BOTH).p());
     }
-    virtual void visit(AstFOpenMcd* nodep) VL_OVERRIDE {
+    virtual void visit(AstFOpenMcd* nodep) override {
         assertAtStatement(nodep);
         iterateCheckFileDesc(nodep, nodep->filep(), BOTH);
         userIterateAndNext(nodep->filenamep(), WidthVP(SELF, BOTH).p());
     }
-    virtual void visit(AstFClose* nodep) VL_OVERRIDE {
+    virtual void visit(AstFClose* nodep) override {
         assertAtStatement(nodep);
         iterateCheckFileDesc(nodep, nodep->filep(), BOTH);
     }
-    virtual void visit(AstFError* nodep) VL_OVERRIDE {
+    virtual void visit(AstFError* nodep) override {
         if (m_vup->prelim()) {
             iterateCheckFileDesc(nodep, nodep->filep(), BOTH);
             // We only support string types, not packed array
@@ -3412,51 +3412,51 @@ private:
             nodep->dtypeSetLogicUnsized(32, 1, VSigning::SIGNED);  // Spec says integer return
         }
     }
-    virtual void visit(AstFEof* nodep) VL_OVERRIDE {
+    virtual void visit(AstFEof* nodep) override {
         if (m_vup->prelim()) {
             iterateCheckFileDesc(nodep, nodep->filep(), BOTH);
             nodep->dtypeSetLogicUnsized(32, 1, VSigning::SIGNED);  // Spec says integer return
         }
     }
-    virtual void visit(AstFFlush* nodep) VL_OVERRIDE {
+    virtual void visit(AstFFlush* nodep) override {
         assertAtStatement(nodep);
         if (nodep->filep()) iterateCheckFileDesc(nodep, nodep->filep(), BOTH);
     }
-    virtual void visit(AstFRewind* nodep) VL_OVERRIDE {
+    virtual void visit(AstFRewind* nodep) override {
         iterateCheckFileDesc(nodep, nodep->filep(), BOTH);
         nodep->dtypeSetLogicUnsized(32, 1, VSigning::SIGNED);  // Spec says integer return
     }
-    virtual void visit(AstFTell* nodep) VL_OVERRIDE {
+    virtual void visit(AstFTell* nodep) override {
         iterateCheckFileDesc(nodep, nodep->filep(), BOTH);
         nodep->dtypeSetLogicUnsized(32, 1, VSigning::SIGNED);  // Spec says integer return
     }
-    virtual void visit(AstFSeek* nodep) VL_OVERRIDE {
+    virtual void visit(AstFSeek* nodep) override {
         iterateCheckFileDesc(nodep, nodep->filep(), BOTH);
         iterateCheckSigned32(nodep, "$fseek offset", nodep->offset(), BOTH);
         iterateCheckSigned32(nodep, "$fseek operation", nodep->operation(), BOTH);
         nodep->dtypeSetLogicUnsized(32, 1, VSigning::SIGNED);  // Spec says integer return
     }
-    virtual void visit(AstFGetC* nodep) VL_OVERRIDE {
+    virtual void visit(AstFGetC* nodep) override {
         if (m_vup->prelim()) {
             iterateCheckFileDesc(nodep, nodep->filep(), BOTH);
             nodep->dtypeSetLogicUnsized(32, 8, VSigning::SIGNED);  // Spec says integer return
         }
     }
-    virtual void visit(AstFGetS* nodep) VL_OVERRIDE {
+    virtual void visit(AstFGetS* nodep) override {
         if (m_vup->prelim()) {
             nodep->dtypeSetSigned32();  // Spec says integer return
             iterateCheckFileDesc(nodep, nodep->filep(), BOTH);
             userIterateAndNext(nodep->strgp(), WidthVP(SELF, BOTH).p());
         }
     }
-    virtual void visit(AstFUngetC* nodep) VL_OVERRIDE {
+    virtual void visit(AstFUngetC* nodep) override {
         if (m_vup->prelim()) {
             iterateCheckFileDesc(nodep, nodep->filep(), BOTH);
             iterateCheckSigned32(nodep, "$fungetc character", nodep->charp(), BOTH);
             nodep->dtypeSetLogicUnsized(32, 8, VSigning::SIGNED);  // Spec says integer return
         }
     }
-    virtual void visit(AstFRead* nodep) VL_OVERRIDE {
+    virtual void visit(AstFRead* nodep) override {
         if (m_vup->prelim()) {
             nodep->dtypeSetSigned32();  // Spec says integer return
             userIterateAndNext(nodep->memp(), WidthVP(SELF, BOTH).p());
@@ -3469,38 +3469,38 @@ private:
             }
         }
     }
-    virtual void visit(AstFScanF* nodep) VL_OVERRIDE {
+    virtual void visit(AstFScanF* nodep) override {
         if (m_vup->prelim()) {
             nodep->dtypeSetSigned32();  // Spec says integer return
             iterateCheckFileDesc(nodep, nodep->filep(), BOTH);
             userIterateAndNext(nodep->exprsp(), WidthVP(SELF, BOTH).p());
         }
     }
-    virtual void visit(AstSScanF* nodep) VL_OVERRIDE {
+    virtual void visit(AstSScanF* nodep) override {
         if (m_vup->prelim()) {
             nodep->dtypeSetSigned32();  // Spec says integer return
             userIterateAndNext(nodep->fromp(), WidthVP(SELF, BOTH).p());
             userIterateAndNext(nodep->exprsp(), WidthVP(SELF, BOTH).p());
         }
     }
-    virtual void visit(AstSysIgnore* nodep) VL_OVERRIDE {
+    virtual void visit(AstSysIgnore* nodep) override {
         userIterateAndNext(nodep->exprsp(), WidthVP(SELF, BOTH).p());
     }
-    virtual void visit(AstSystemF* nodep) VL_OVERRIDE {
+    virtual void visit(AstSystemF* nodep) override {
         if (m_vup->prelim()) {
             userIterateAndNext(nodep->lhsp(), WidthVP(SELF, BOTH).p());
             nodep->dtypeSetSigned32();  // Spec says integer return
         }
     }
-    virtual void visit(AstSysFuncAsTask* nodep) VL_OVERRIDE {
+    virtual void visit(AstSysFuncAsTask* nodep) override {
         assertAtStatement(nodep);
         userIterateAndNext(nodep->lhsp(), WidthVP(SELF, BOTH).p());
     }
-    virtual void visit(AstSystemT* nodep) VL_OVERRIDE {
+    virtual void visit(AstSystemT* nodep) override {
         assertAtStatement(nodep);
         userIterateAndNext(nodep->lhsp(), WidthVP(SELF, BOTH).p());
     }
-    virtual void visit(AstNodeReadWriteMem* nodep) VL_OVERRIDE {
+    virtual void visit(AstNodeReadWriteMem* nodep) override {
         assertAtStatement(nodep);
         userIterateAndNext(nodep->filenamep(), WidthVP(SELF, BOTH).p());
         userIterateAndNext(nodep->memp(), WidthVP(SELF, BOTH).p());
@@ -3532,41 +3532,41 @@ private:
         userIterateAndNext(nodep->lsbp(), WidthVP(SELF, BOTH).p());
         userIterateAndNext(nodep->msbp(), WidthVP(SELF, BOTH).p());
     }
-    virtual void visit(AstValuePlusArgs* nodep) VL_OVERRIDE {
+    virtual void visit(AstValuePlusArgs* nodep) override {
         if (m_vup->prelim()) {
             userIterateAndNext(nodep->searchp(), WidthVP(SELF, BOTH).p());
             userIterateAndNext(nodep->outp(), WidthVP(SELF, BOTH).p());
             nodep->dtypeChgWidthSigned(32, 1, VSigning::SIGNED);  // Spec says integer return
         }
     }
-    virtual void visit(AstTimeFormat* nodep) VL_OVERRIDE {
+    virtual void visit(AstTimeFormat* nodep) override {
         assertAtStatement(nodep);
         iterateCheckSigned32(nodep, "units", nodep->unitsp(), BOTH);
         iterateCheckSigned32(nodep, "precision", nodep->precisionp(), BOTH);
         iterateCheckString(nodep, "suffix", nodep->suffixp(), BOTH);
         iterateCheckSigned32(nodep, "width", nodep->widthp(), BOTH);
     }
-    virtual void visit(AstUCStmt* nodep) VL_OVERRIDE {
+    virtual void visit(AstUCStmt* nodep) override {
         // Just let all arguments seek their natural sizes
         assertAtStatement(nodep);
         userIterateChildren(nodep, WidthVP(SELF, BOTH).p());
     }
-    virtual void visit(AstAssert* nodep) VL_OVERRIDE {
+    virtual void visit(AstAssert* nodep) override {
         assertAtStatement(nodep);
         iterateCheckBool(nodep, "Property", nodep->propp(), BOTH);  // it's like an if() condition.
         userIterateAndNext(nodep->passsp(), NULL);
         userIterateAndNext(nodep->failsp(), NULL);
     }
-    virtual void visit(AstCover* nodep) VL_OVERRIDE {
+    virtual void visit(AstCover* nodep) override {
         assertAtStatement(nodep);
         iterateCheckBool(nodep, "Property", nodep->propp(), BOTH);  // it's like an if() condition.
         userIterateAndNext(nodep->passsp(), NULL);
     }
-    virtual void visit(AstRestrict* nodep) VL_OVERRIDE {
+    virtual void visit(AstRestrict* nodep) override {
         assertAtStatement(nodep);
         iterateCheckBool(nodep, "Property", nodep->propp(), BOTH);  // it's like an if() condition.
     }
-    virtual void visit(AstPin* nodep) VL_OVERRIDE {
+    virtual void visit(AstPin* nodep) override {
         // if (debug()) nodep->dumpTree(cout, "-  PinPre: ");
         // TOP LEVEL NODE
         if (nodep->modVarp() && nodep->modVarp()->isGParam()) {
@@ -3677,7 +3677,7 @@ private:
         }
         // if (debug()) nodep->dumpTree(cout, "-  PinOut: ");
     }
-    virtual void visit(AstCell* nodep) VL_OVERRIDE {
+    virtual void visit(AstCell* nodep) override {
         if (!m_paramsOnly) {
             if (VN_IS(nodep->modp(), NotFoundModule)) {
                 // We've resolved parameters and hit a module that we couldn't resolve.  It's
@@ -3696,7 +3696,7 @@ private:
         userIterateAndNext(nodep->paramsp(), NULL);
         m_cellRangep = NULL;
     }
-    virtual void visit(AstGatePin* nodep) VL_OVERRIDE {
+    virtual void visit(AstGatePin* nodep) override {
         if (m_vup->prelim()) {
             userIterateAndNext(nodep->rangep(), WidthVP(SELF, BOTH).p());
             userIterateAndNext(nodep->exprp(), WidthVP(CONTEXT, PRELIM).p());
@@ -3720,7 +3720,7 @@ private:
             VL_DO_DANGLING(pushDeletep(nodep), nodep);
         }
     }
-    virtual void visit(AstNodeFTask* nodep) VL_OVERRIDE {
+    virtual void visit(AstNodeFTask* nodep) override {
         // Grab width from the output variable (if it's a function)
         if (nodep->didWidth()) return;
         if (nodep->doingWidth()) {
@@ -3754,7 +3754,7 @@ private:
                                         // func
         }
     }
-    virtual void visit(AstReturn* nodep) VL_OVERRIDE {
+    virtual void visit(AstReturn* nodep) override {
         // IEEE: Assignment-like context
         assertAtStatement(nodep);
         if (!m_funcp) {
@@ -3772,7 +3772,7 @@ private:
         }
     }
 
-    virtual void visit(AstFuncRef* nodep) VL_OVERRIDE {
+    virtual void visit(AstFuncRef* nodep) override {
         visit(VN_CAST(nodep, NodeFTaskRef));
         nodep->dtypeFrom(nodep->taskp());
         // if (debug()) nodep->dumpTree(cout, "  FuncOut: ");
@@ -3899,7 +3899,7 @@ private:
             }
         }
     }
-    virtual void visit(AstNodeFTaskRef* nodep) VL_OVERRIDE {
+    virtual void visit(AstNodeFTaskRef* nodep) override {
         // For arguments, is assignment-like context; see IEEE rules in AstNodeAssign
         // Function hasn't been widthed, so make it so.
         UINFO(5, "  FTASKREF " << nodep << endl);
@@ -3910,27 +3910,27 @@ private:
         processFTaskRefArgs(nodep);
         nodep->didWidth(true);
     }
-    virtual void visit(AstNodeProcedure* nodep) VL_OVERRIDE {
+    virtual void visit(AstNodeProcedure* nodep) override {
         assertAtStatement(nodep);
         m_procedurep = nodep;
         userIterateChildren(nodep, NULL);
         m_procedurep = NULL;
     }
-    virtual void visit(AstNetlist* nodep) VL_OVERRIDE {
+    virtual void visit(AstNetlist* nodep) override {
         // Iterate modules backwards, in bottom-up order.  That's faster
         userIterateChildrenBackwards(nodep, NULL);
     }
 
     //--------------------
     // Default
-    virtual void visit(AstNodeMath* nodep) VL_OVERRIDE {
+    virtual void visit(AstNodeMath* nodep) override {
         if (!nodep->didWidth()) {
             nodep->v3fatalSrc(
                 "Visit function missing? Widthed function missing for math node: " << nodep);
         }
         userIterateChildren(nodep, NULL);
     }
-    virtual void visit(AstNode* nodep) VL_OVERRIDE {
+    virtual void visit(AstNode* nodep) override {
         // Default: Just iterate
         UASSERT_OBJ(!m_vup, nodep,
                     "Visit function missing? Widthed expectation for this node: " << nodep);
@@ -3952,7 +3952,7 @@ private:
             iterateCheck(nodep, "LHS", nodep->lhsp(), SELF, FINAL, subDTypep, EXTEND_EXP);
         }
     }
-    virtual void visit(AstIToRD* nodep) VL_OVERRIDE {
+    virtual void visit(AstIToRD* nodep) override {
         // Real: Output real
         // LHS presumed self-determined, then coerced to real
         if (m_vup->prelim()) {  // First stage evaluation
@@ -3966,7 +3966,7 @@ private:
             }
         }
     }
-    virtual void visit(AstISToRD* nodep) VL_OVERRIDE {
+    virtual void visit(AstISToRD* nodep) override {
         // Real: Output real
         // LHS presumed self-determined, then coerced to real
         if (m_vup->prelim()) {  // First stage evaluation
diff --git a/src/V3WidthCommit.h b/src/V3WidthCommit.h
index 72436b9d1..86077d41c 100644
--- a/src/V3WidthCommit.h
+++ b/src/V3WidthCommit.h
@@ -45,13 +45,13 @@ private:
     }
 
     // VISITORS
-    virtual void visit(AstSigned* nodep) VL_OVERRIDE {
+    virtual void visit(AstSigned* nodep) override {
         VL_DO_DANGLING(replaceWithSignedVersion(nodep, nodep->lhsp()->unlinkFrBack()), nodep);
     }
-    virtual void visit(AstUnsigned* nodep) VL_OVERRIDE {
+    virtual void visit(AstUnsigned* nodep) override {
         VL_DO_DANGLING(replaceWithSignedVersion(nodep, nodep->lhsp()->unlinkFrBack()), nodep);
     }
-    virtual void visit(AstNode* nodep) VL_OVERRIDE { iterateChildren(nodep); }
+    virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
 
 public:
     // CONSTRUCTORS
@@ -113,7 +113,7 @@ private:
         return nodep;
     }
     // VISITORS
-    virtual void visit(AstConst* nodep) VL_OVERRIDE {
+    virtual void visit(AstConst* nodep) override {
         UASSERT_OBJ(nodep->dtypep(), nodep, "No dtype");
         iterate(nodep->dtypep());  // Do datatype first
         if (AstConst* newp = newIfConstCommitSize(nodep)) {
@@ -126,15 +126,15 @@ private:
         }
         editDType(nodep);
     }
-    virtual void visit(AstNodeDType* nodep) VL_OVERRIDE {  //
+    virtual void visit(AstNodeDType* nodep) override {  //
         visitIterateNodeDType(nodep);
     }
-    virtual void visit(AstNodeUOrStructDType* nodep) VL_OVERRIDE {
+    virtual void visit(AstNodeUOrStructDType* nodep) override {
         if (nodep->user1SetOnce()) return;  // Process once
         visitIterateNodeDType(nodep);
         nodep->clearCache();
     }
-    virtual void visit(AstParamTypeDType* nodep) VL_OVERRIDE {
+    virtual void visit(AstParamTypeDType* nodep) override {
         if (nodep->user1SetOnce()) return;  // Process once
         visitIterateNodeDType(nodep);
         // Move to type table as all dtype pointers must resolve there
@@ -153,11 +153,11 @@ private:
         nodep->virtRefDTypep(editOneDType(nodep->virtRefDTypep()));
         nodep->virtRefDType2p(editOneDType(nodep->virtRefDType2p()));
     }
-    virtual void visit(AstNodePreSel* nodep) VL_OVERRIDE {  // LCOV_EXCL_LINE
+    virtual void visit(AstNodePreSel* nodep) override {  // LCOV_EXCL_LINE
         // This check could go anywhere after V3Param
         nodep->v3fatalSrc("Presels should have been removed before this point");
     }
-    virtual void visit(AstNode* nodep) VL_OVERRIDE {
+    virtual void visit(AstNode* nodep) override {
         iterateChildren(nodep);
         editDType(nodep);
     }
diff --git a/src/V3WidthSel.cpp b/src/V3WidthSel.cpp
index 880b3bf80..550815863 100644
--- a/src/V3WidthSel.cpp
+++ b/src/V3WidthSel.cpp
@@ -199,7 +199,7 @@ private:
     // VISITORS
     // If adding new visitors, ensure V3Width's visit(TYPE) calls into here
 
-    virtual void visit(AstSelBit* nodep) VL_OVERRIDE {
+    virtual void visit(AstSelBit* nodep) override {
         // Select of a non-width specified part of an array, i.e. "array[2]"
         // This select style has a lsb and msb (no user specified width)
         UINFO(6, "SELBIT " << nodep << endl);
@@ -317,7 +317,7 @@ private:
         }
         if (!rhsp->backp()) { VL_DO_DANGLING(pushDeletep(rhsp), rhsp); }
     }
-    virtual void visit(AstSelExtract* nodep) VL_OVERRIDE {
+    virtual void visit(AstSelExtract* nodep) override {
         // Select of a range specified part of an array, i.e. "array[2:3]"
         // SELEXTRACT(from,msb,lsb) -> SEL(from, lsb, 1+msb-lsb)
         // This select style has a (msb or lsb) and width
@@ -556,13 +556,13 @@ private:
         if (!rhsp->backp()) { VL_DO_DANGLING(pushDeletep(rhsp), rhsp); }
         if (!widthp->backp()) { VL_DO_DANGLING(pushDeletep(widthp), widthp); }
     }
-    virtual void visit(AstSelPlus* nodep) VL_OVERRIDE { replaceSelPlusMinus(nodep); }
-    virtual void visit(AstSelMinus* nodep) VL_OVERRIDE { replaceSelPlusMinus(nodep); }
+    virtual void visit(AstSelPlus* nodep) override { replaceSelPlusMinus(nodep); }
+    virtual void visit(AstSelMinus* nodep) override { replaceSelPlusMinus(nodep); }
     // If adding new visitors, ensure V3Width's visit(TYPE) calls into here
 
     //--------------------
     // Default
-    virtual void visit(AstNode* nodep) VL_OVERRIDE {  // LCOV_EXCL_LINE
+    virtual void visit(AstNode* nodep) override {  // LCOV_EXCL_LINE
         // See notes above; we never iterate
         nodep->v3fatalSrc("Shouldn't iterate in V3WidthSel");
     }
diff --git a/src/VlcPoint.h b/src/VlcPoint.h
index 09e059ab7..6b3115188 100644
--- a/src/VlcPoint.h
+++ b/src/VlcPoint.h
@@ -24,7 +24,7 @@
 
 #include <vector>
 #include <iomanip>
-#include VL_INCLUDE_UNORDERED_MAP
+#include <unordered_map>
 
 //********************************************************************
 // VlcPoint - A coverage point (across all tests)
diff --git a/src/astgen b/src/astgen
index 8a7e02469..1e09a9a6c 100644
--- a/src/astgen
+++ b/src/astgen
@@ -709,7 +709,7 @@ sub tree_base {
         # saves one comparison.
         if ($out_for_type_sc[0]) {      # Short-circuited types
             $self->print("    // Generated by astgen with short-circuiting\n",
-                         "    virtual void visit(Ast${type}* nodep) VL_OVERRIDE {\n",
+                         "    virtual void visit(Ast${type}* nodep) override {\n",
                          "      iterateAndNextNull(nodep->lhsp());\n",
                          @out_for_type_sc);
             $self->print("      iterateAndNextNull(nodep->rhsp());\n",
@@ -720,7 +720,7 @@ sub tree_base {
         } elsif ($out_for_type[0]) {    # Other types with something to print
             my $skip = $self->{tree_skip_visit}{$type};
             my $gen = $skip ? "Gen" : "";
-            my $override = $skip ? "" : " VL_OVERRIDE";
+            my $override = $skip ? "" : " override";
             $self->print("    // Generated by astgen\n",
                          "    virtual void visit$gen(Ast${type}* nodep)${override} {\n",
                          ($skip?"":