Changeset ff29f08 for src/Common

Timestamp:

May 18, 2018, 2:09:21 PM (6 years ago)

Author:

Aaron Moss <a3moss@…>

Branches:

new-env, with_gc

Children:

2472a19

Parents:

f6f0cca3 (diff), c7d8100c (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge remote-tracking branch 'origin/master' into with_gc

Location:

src/Common

Files:

• Heap.cc (added)
• Heap.h (added)
• PassVisitor.h (modified) (2 diffs)
• PassVisitor.impl.h (modified) (3 diffs)
• PassVisitor.proto.h (modified) (4 diffs)
• SemanticError.cc (modified) (3 diffs)
• SemanticError.h (modified) (4 diffs)
• module.mk (modified) (1 diff)
• utility.h (modified) (2 diffs)

src/Common/PassVisitor.h

@@ -71 +71 @@
         virtual void visit( ExprStmt * exprStmt ) override final;
         virtual void visit( AsmStmt * asmStmt ) override final;
+        virtual void visit( DirectiveStmt * dirStmt ) override final;
         virtual void visit( IfStmt * ifStmt ) override final;
         virtual void visit( WhileStmt * whileStmt ) override final;
@@ -170 +171 @@
         virtual Statement * mutate( ExprStmt * exprStmt ) override final;
         virtual Statement * mutate( AsmStmt * asmStmt ) override final;
+        virtual Statement * mutate( DirectiveStmt * dirStmt ) override final;
         virtual Statement * mutate( IfStmt * ifStmt ) override final;
         virtual Statement * mutate( WhileStmt * whileStmt ) override final;

src/Common/PassVisitor.impl.h

@@ -690 +690 @@
         VISIT_START( node );
 
-        maybeAccept_impl( node->condition, *this );
-        maybeAccept_impl( node->message  , *this );
+        node->condition = visitExpression( node->condition );
+        maybeAccept_impl( node->message, *this );
 
         VISIT_END( node );
@@ -700 +700 @@
         MUTATE_START( node );
 
-        maybeMutate_impl( node->condition, *this );
-        maybeMutate_impl( node->message  , *this );
+        node->condition = mutateExpression( node->condition );
+        maybeMutate_impl( node->message, *this );
 
         MUTATE_END( StaticAssertDecl, node );
@@ -772 +772 @@
         maybeMutate_impl( node->input, *this );
         maybeMutate_impl( node->clobber, *this );
+
+        MUTATE_END( Statement, node );
+}
+
+//--------------------------------------------------------------------------
+// AsmStmt
+template< typename pass_type >
+void PassVisitor< pass_type >::visit( DirectiveStmt * node ) {
+        VISIT_START( node )
+
+        VISIT_END( node );
+}
+
+template< typename pass_type >
+Statement * PassVisitor< pass_type >::mutate( DirectiveStmt * node ) {
+        MUTATE_START( node );
 
         MUTATE_END( Statement, node );

src/Common/PassVisitor.proto.h

@@ -47 +47 @@
 
         operator bool() { return m_ref ? *m_ref : true; }
-        bool operator=( bool val ) { return *m_ref = val; }
+        bool operator=( bool val ) { assert(m_ref); return *m_ref = val; }
 
 private:
@@ -53 +53 @@
         friend class ChildrenGuard;
 
-        bool * set( bool & val ) {
+        bool * set( bool * val ) {
                 bool * prev = m_ref;
-                m_ref = &val;
+                m_ref = val;
                 return prev;
         }
@@ -67 +67 @@
         ChildrenGuard( bool_ref * ref )
                 : m_val ( true )
-                , m_prev( ref ? ref->set( m_val ) : nullptr )
+                , m_prev( ref ? ref->set( &m_val ) : nullptr )
                 , m_ref ( ref )
         {}
@@ -73 +73 @@
         ~ChildrenGuard() {
                 if( m_ref ) {
-                        m_ref->set( *m_prev );
+                        m_ref->set( m_prev );
                 }
         }

src/Common/SemanticError.cc

@@ -7 +7 @@
 // SemanticError.cc --
 //
-// Author           : Richard C. Bilson
+// Author           : Thierry Delisle
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Tue Aug 29 18:17:35 2017
-// Update Count     : 3
+// Last Modified On : Wed May 16 15:01:20 2018
+// Update Count     : 9
 //
 
 #include <cstdarg>
 #include <cstdio>                                                                               // for fileno, stderr
+#include <cstring>
 #include <unistd.h>                                                                             // for isatty
 #include <iostream>                                                                             // for basic_ostream, operator<<, ostream
 #include <list>                                                                                 // for list, _List_iterator
 #include <string>                                                                               // for string, operator<<, operator+, to_string
+#include <vector>
 
 #include "Common/utility.h"                                                             // for to_string, CodeLocation (ptr only)
 #include "SemanticError.h"
+
+//-----------------------------------------------------------------------------
+// Severity Handling
+std::vector<Severity> & get_severities() {
+        static std::vector<Severity> severities;
+        if(severities.empty()) {
+                severities.reserve((size_t)Warning::NUMBER_OF_WARNINGS);
+                for ( const auto w : WarningFormats ) {
+                        severities.push_back( w.default_severity );
+                } // for
+        }
+        return severities;
+}
+
+void SemanticWarning_SuppressAll() {
+        for( auto & s : get_severities() ) {
+                s = Severity::Suppress;
+        }
+}
+
+void SemanticWarning_EnableAll() {
+        for( auto & s : get_severities() ) {
+                s = Severity::Warn;
+        }
+}
+
+void SemanticWarning_WarningAsError() {
+        for( auto & s : get_severities() ) {
+                if(s == Severity::Warn) s = Severity::Error;
+        }
+}
+
+void SemanticWarning_Set(const char * const name, Severity s) {
+        size_t idx = 0;
+        for ( const auto & w : WarningFormats ) {
+                if ( std::strcmp( name, w.name ) == 0 ) {
+                        get_severities()[idx] = s;
+                        break;
+                }
+                idx++;
+        }
+}
+
+//-----------------------------------------------------------------------------
+// Semantic Error
+bool SemanticErrorThrow = false;
 
 SemanticErrorException::SemanticErrorException( CodeLocation location, std::string error ) {
@@ -48 +96 @@
 
 void SemanticError( CodeLocation location, std::string error ) {
+        SemanticErrorThrow = true;
         throw SemanticErrorException(location, error);
 }
@@ -69 +118 @@
 
 void SemanticWarningImpl( CodeLocation location, Warning warning, const char * const fmt, ... ) {
-        Severity severity = WarningFormats[(int)warning].severity;
+        Severity severity = get_severities()[(int)warning];
         switch(severity) {
         case Severity::Suppress :

src/Common/SemanticError.h

@@ -7 +7 @@
 // SemanticError.h --
 //
-// Author           : Richard C. Bilson
+// Author           : Thierry Delisle
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Thu Apr 19 17:52:03 2018
-// Update Count     : 19
+// Last Modified On : Wed May 16 15:01:23 2018
+// Update Count     : 30
 //
 
@@ -17 +17 @@
 
 #include "ErrorObjects.h"
+#include <cstring>
 
 //-----------------------------------------------------------------------------
 // Errors
+
+extern bool SemanticErrorThrow;
 
 __attribute__((noreturn)) void SemanticError( CodeLocation location, std::string error );
@@ -46 +49 @@
         const char * const name;
         const char * const message;
-        mutable Severity severity;
+        const Severity default_severity;
 };
 
-constexpr const WarningData WarningFormats[] = {
-        {"self-assign"         , "self assignment of expression: %s"           , Severity::Warn},
-        {"reference-conversion", "rvalue to reference conversion of rvalue: %s", Severity::Warn},
+constexpr WarningData WarningFormats[] = {
+        {"self-assign"            , "self assignment of expression: %s"            , Severity::Warn},
+        {"reference-conversion"   , "rvalue to reference conversion of rvalue: %s" , Severity::Warn},
         {"qualifiers-zero_t-one_t", "questionable use of type qualifier %s with %s", Severity::Warn},
 };
@@ -71 +74 @@
 void SemanticWarningImpl (CodeLocation loc, Warning warn, const char * const fmt, ...) __attribute__((format(printf, 3, 4)));
 
+void SemanticWarning_SuppressAll   ();
+void SemanticWarning_EnableAll     ();
+void SemanticWarning_WarningAsError();
+void SemanticWarning_Set           (const char * const name, Severity s);
+
+// SKULLDUGGERY: cfa.cc is built before SemanticError.cc but needs this routine.
+static inline bool SemanticWarning_Exist(const char * const name) {
+        for ( const auto & w : WarningFormats ) {
+                if ( std::strcmp( name, w.name ) == 0 ) return true;
+        }
+        return false;
+}
 
 //-----------------------------------------------------------------------------

src/Common/module.mk

@@ -19 +19 @@
        Common/DebugMalloc.cc \
        Common/GC.cc \
-       Common/Assert.cc
+       Common/Assert.cc \
+       Common/Heap.cc

src/Common/utility.h

@@ -10 +10 @@
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Fri Apr 20 22:35:33 2018
-// Update Count     : 38
+// Last Modified On : Sun May  6 22:24:16 2018
+// Update Count     : 40
 //
 
@@ -438 +438 @@
 
 template<typename T>
-inline constexpr T ilog2(const T & t) {
-        if ( std::is_integral<T>::value ) {
+inline
+#if defined(__GNUC__) && __GNUC__ > 4
+constexpr
+#endif
+T ilog2(const T & t) {
+        if(std::is_integral<T>::value) {
                 const constexpr int r = sizeof(t) * __CHAR_BIT__ - 1;
-                if ( sizeof(T) == sizeof(unsigned int ) ) return r - __builtin_clz( t );
-                if ( sizeof(T) == sizeof(unsigned long) ) return r - __builtin_clzl( t );
-                if ( sizeof(T) == sizeof(unsigned long long) ) return r - __builtin_clzll( t );
-        } // if
+                if( sizeof(T) == sizeof(unsigned       int) ) return r - __builtin_clz  ( t );
+                if( sizeof(T) == sizeof(unsigned      long) ) return r - __builtin_clzl ( t );
+                if( sizeof(T) == sizeof(unsigned long long) ) return r - __builtin_clzll( t );
+        }
+        assert(false);
         return -1;
-} // ilong2
+} // ilog2