Changeset 9ea38de for src/AST

Timestamp:

Jun 25, 2019, 11:26:30 AM (5 years ago)

Author:

Aaron Moss <a3moss@…>

Branches:

ADT, arm-eh, ast-experimental, enum, forall-pointer-decay, jacob/cs343-translation, master, new-ast, new-ast-unique-expr, pthread-emulation, qualifiedEnum

Children:

bcb311b

Parents:

28af389

Message:

Fix ast::Pass guard classes

Location:

src/AST

Files:

• Node.cpp (modified) (2 diffs)
• Node.hpp (modified) (1 diff)
• Pass.hpp (modified) (2 diffs)
• Pass.impl.hpp (modified) (2 diffs)
• Pass.proto.hpp (modified) (2 diffs)

src/AST/Node.cpp

@@ -17 +17 @@
 #include "Fwd.hpp"
 
+#include <csignal>  // MEMORY DEBUG -- for raise
 #include <iostream>
 
@@ -28 +29 @@
 
 #include "Print.hpp"
+
+/// MEMORY DEBUG -- allows breaking on construction/destruction of dynamically chosen object.
+/// Process to use in GDB:
+///   break ast::Node::_trap()
+///   run
+///   set variable MEM_TRAP_OBJ = <target>
+///   disable <first breakpoint>
+///   continue
+void * MEM_TRAP_OBJ = nullptr;
+
+void ast::Node::_trap() {
+        if ( this == MEM_TRAP_OBJ ) std::raise(SIGTRAP);
+}
 
 template< typename node_t, enum ast::Node::ref_type ref_t >

src/AST/Node.hpp

@@ -30 +30 @@
 /// Keeps both strong and weak reference counts.
 class Node {
+        /// call to debug on node creation/deletion
+        void _trap();
 public:
         // override defaults to ensure assignment doesn't
         // change/share reference counts
-        Node() = default;
-        Node(const Node&) : strong_count(0), weak_count(0) {}
-        Node(Node&&) : strong_count(0), weak_count(0) {}
+        Node() { _trap(); }
+        Node(const Node&) : strong_count(0), weak_count(0) { _trap(); }
+        Node(Node&&) : strong_count(0), weak_count(0) { _trap(); }
         Node& operator= (const Node&) = delete;
         Node& operator= (Node&&) = delete;
-        virtual ~Node() = default;
+        virtual ~Node() { _trap(); }
 
         virtual const Node * accept( Visitor & v ) const = 0;

src/AST/Pass.hpp

@@ -209 +209 @@
         /// Internal RAII guard for symbol table features
         struct guard_symtab {
-                guard_symtab( Pass<pass_t> & pass ): pass( pass ) { __pass::symtab::enter(pass, 0); }
-                ~guard_symtab()                                   { __pass::symtab::leave(pass, 0); }
+                guard_symtab( Pass<pass_t> & pass ): pass( pass ) { __pass::symtab::enter(pass.pass, 0); }
+                ~guard_symtab()                                   { __pass::symtab::leave(pass.pass, 0); }
                 Pass<pass_t> & pass;
         };
@@ -216 +216 @@
         /// Internal RAII guard for scope features
         struct guard_scope {
-                guard_scope( Pass<pass_t> & pass ): pass( pass ) { __pass::scope::enter(pass, 0); }
-                ~guard_scope()                                   { __pass::scope::leave(pass, 0); }
+                guard_scope( Pass<pass_t> & pass ): pass( pass ) { __pass::scope::enter(pass.pass, 0); }
+                ~guard_scope()                                   { __pass::scope::leave(pass.pass, 0); }
                 Pass<pass_t> & pass;
         };

src/AST/Pass.impl.hpp

@@ -429 +429 @@
                         guard_symtab guard { *this };
                         // implicit add __func__ identifier as specified in the C manual 6.4.2.2
-                        static ast::ObjectDecl func(
-                                node->location, "__func__",
-                                new ast::ArrayType(
-                                        new ast::BasicType( ast::BasicType::Char, ast::CV::Qualifiers( ast::CV::Const ) ),
+                        static ast::ptr< ast::ObjectDecl > func{ new ast::ObjectDecl{ 
+                                CodeLocation{}, "__func__",
+                                new ast::ArrayType{
+                                        new ast::BasicType{ ast::BasicType::Char, ast::CV::Const },
                                         nullptr, VariableLen, DynamicDim
-                                )
-                        );
-                        __pass::symtab::addId( pass, 0, &func );
+                                }
+                        } };
+                        __pass::symtab::addId( pass, 0, func );
                         VISIT(
                                 maybe_accept( node, &FunctionDecl::type );
@@ -610 +610 @@
         VISIT({
                 // do not enter a new scope if inFunction is true - needs to check old state before the assignment
-                auto guard1 = makeFuncGuard( [this, inFunction = this->inFunction]() {
-                        if ( ! inFunction ) __pass::symtab::enter(pass, 0);
-                }, [this, inFunction = this->inFunction]() {
-                        if ( ! inFunction ) __pass::symtab::leave(pass, 0);
+                auto guard1 = makeFuncGuard( [this, inFunctionCpy = this->inFunction]() {
+                        if ( ! inFunctionCpy ) __pass::symtab::enter(pass, 0);
+                }, [this, inFunctionCpy = this->inFunction]() {
+                        if ( ! inFunctionCpy ) __pass::symtab::leave(pass, 0);
                 });
                 ValueGuard< bool > guard2( inFunction );

src/AST/Pass.proto.hpp

@@ -270 +270 @@
                 // Some simple scoping rules
                 template<typename pass_t>
-                static inline auto enter( pass_t & pass, int ) -> decltype( pass.symtab.enterScope(), void() ) {
+                static inline auto enter( pass_t & pass, int ) -> decltype( pass.symtab, void() ) {
                         pass.symtab.enterScope();
                 }
@@ -278 +278 @@
 
                 template<typename pass_t>
-                static inline auto leave( pass_t & pass, int ) -> decltype( pass.symtab.leaveScope(), void() ) {
+                static inline auto leave( pass_t & pass, int ) -> decltype( pass.symtab, void() ) {
                         pass.symtab.leaveScope();
                 }