Changeset 9ea38de

Timestamp:

Jun 25, 2019, 11:26:30 AM (4 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

Files:

• Jenkinsfile (deleted)
• src/AST/Node.cpp (modified) (2 diffs)
• src/AST/Node.hpp (modified) (1 diff)
• src/AST/Pass.hpp (modified) (2 diffs)
• src/AST/Pass.impl.hpp (modified) (2 diffs)
• src/AST/Pass.proto.hpp (modified) (2 diffs)
• src/ResolvExpr/AdjustExprType.cc (modified) (1 diff)
• src/ResolvExpr/CandidateFinder.cpp (modified) (5 diffs)
• src/ResolvExpr/CandidateFinder.hpp (modified) (1 diff)
• src/ResolvExpr/PolyCost.cc (modified) (1 diff)
• src/Tuples/TupleAssignment.cc (modified) (6 diffs)
• src/main.cc (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();
                 }

src/ResolvExpr/AdjustExprType.cc

@@ -100 +100 @@
 
 namespace {
-        struct AdjustExprType_new final : public ast::WithShortCircuiting {
+        class AdjustExprType_new final : public ast::WithShortCircuiting {
+                const ast::SymbolTable & symtab;
+        public:
                 const ast::TypeEnvironment & tenv;
-                const ast::SymbolTable & symtab;
 
                 AdjustExprType_new( const ast::TypeEnvironment & e, const ast::SymbolTable & syms )
-                : tenv( e ), symtab( syms ) {}
+                : symtab( syms ), tenv( e ) {}
 
                 void premutate( const ast::VoidType * ) { visit_children = false; }

src/ResolvExpr/CandidateFinder.cpp

@@ -594 +594 @@
 
         /// Actually visits expressions to find their candidate interpretations
-        struct Finder final : public ast::WithShortCircuiting {
+        class Finder final : public ast::WithShortCircuiting {
+                const ast::SymbolTable & symtab;
+        public:
                 CandidateFinder & selfFinder;
-                const ast::SymbolTable & symtab;
                 CandidateList & candidates;
                 const ast::TypeEnvironment & tenv;
@@ -602 +603 @@
 
                 Finder( CandidateFinder & f )
-                : selfFinder( f ), symtab( f.symtab ), candidates( f.candidates ), tenv( f.env ), 
+                : symtab( f.localSyms ), selfFinder( f ), candidates( f.candidates ), tenv( f.env ), 
                   targetType( f.targetType ) {}
                 
@@ -1558 +1559 @@
                 std::vector< std::string > errors;
                 for ( CandidateRef & candidate : candidates ) {
-                        satisfyAssertions( candidate, symtab, satisfied, errors );
+                        satisfyAssertions( candidate, localSyms, satisfied, errors );
                 }
 
@@ -1613 +1614 @@
                         r->expr = ast::mutate_field( 
                                 r->expr.get(), &ast::Expr::result, 
-                                adjustExprType( r->expr->result, r->env, symtab ) );
+                                adjustExprType( r->expr->result, r->env, localSyms ) );
                 }
         }
@@ -1631 +1632 @@
 
         for ( const auto & x : xs ) {
-                out.emplace_back( symtab, env );
+                out.emplace_back( localSyms, env );
                 out.back().find( x, ResolvMode::withAdjustment() );
                 

src/ResolvExpr/CandidateFinder.hpp

@@ -28 +28 @@
 struct CandidateFinder {
         CandidateList candidates;          ///< List of candidate resolutions
-        const ast::SymbolTable & symtab;   ///< Symbol table to lookup candidates
+        const ast::SymbolTable & localSyms;   ///< Symbol table to lookup candidates
         const ast::TypeEnvironment & env;  ///< Substitutions performed in this resolution
         ast::ptr< ast::Type > targetType;  ///< Target type for resolution
 
         CandidateFinder( 
-                const ast::SymbolTable & symtab, const ast::TypeEnvironment & env, 
+                const ast::SymbolTable & syms, const ast::TypeEnvironment & env, 
                 const ast::Type * tt = nullptr )
-        : candidates(), symtab( symtab ), env( env ), targetType( tt ) {}
+        : candidates(), localSyms( syms ), env( env ), targetType( tt ) {}
 
         /// Fill candidates with feasible resolutions for `expr`

src/ResolvExpr/PolyCost.cc

@@ -58 +58 @@
 
 // TODO: When the old PolyCost is torn out get rid of the _new suffix.
-struct PolyCost_new {
+class PolyCost_new {
+        const ast::SymbolTable &symtab;
+public:
         int result;
-        const ast::SymbolTable &symtab;
         const ast::TypeEnvironment &env_;
 
-        PolyCost_new( const ast::SymbolTable & symtab, const ast::TypeEnvironment & env ) :
-                result( 0 ), symtab( symtab ), env_( env ) {}
+        PolyCost_new( const ast::SymbolTable & symtab, const ast::TypeEnvironment & env ) 
+        : symtab( symtab ), result( 0 ), env_( env ) {}
 
         void previsit( const ast::TypeInstType * type ) {

src/Tuples/TupleAssignment.cc

@@ -464 +464 @@
                                         // resolve ctor/dtor for the new object
                                         ast::ptr< ast::Init > ctorInit = ResolvExpr::resolveCtorInit( 
-                                                        InitTweak::genCtorInit( location, ret ), spotter.crntFinder.symtab );
+                                                        InitTweak::genCtorInit( location, ret ), spotter.crntFinder.localSyms );
                                         // remove environments from subexpressions of stmtExpr
                                         ast::Pass< EnvRemover > rm{ env };
@@ -559 +559 @@
                                         // resolve the cast expression so that rhsCand return type is bound by the cast 
                                         // type as needed, and transfer the resulting environment
-                                        ResolvExpr::CandidateFinder finder{ spotter.crntFinder.symtab, env };
+                                        ResolvExpr::CandidateFinder finder{ spotter.crntFinder.localSyms, env };
                                         finder.find( rhsCand->expr, ResolvExpr::ResolvMode::withAdjustment() );
                                         assert( finder.candidates.size() == 1 );
@@ -608 +608 @@
                                         // explode the LHS so that each field of a tuple-valued expr is assigned
                                         ResolvExpr::CandidateList lhs;
-                                        explode( *lhsCand, crntFinder.symtab, back_inserter(lhs), true );
+                                        explode( *lhsCand, crntFinder.localSyms, back_inserter(lhs), true );
                                         for ( ResolvExpr::CandidateRef & cand : lhs ) {
                                                 // each LHS value must be a reference - some come in with a cast, if not 
@@ -628 +628 @@
                                                         if ( isTuple( rhsCand->expr ) ) {
                                                                 // multiple assignment
-                                                                explode( *rhsCand, crntFinder.symtab, back_inserter(rhs), true );
+                                                                explode( *rhsCand, crntFinder.localSyms, back_inserter(rhs), true );
                                                                 matcher.reset( 
                                                                         new MultipleAssignMatcher{ *this, expr->location, lhs, rhs } );
@@ -647 +647 @@
                                                         // multiple assignment
                                                         ResolvExpr::CandidateList rhs;
-                                                        explode( rhsCand, crntFinder.symtab, back_inserter(rhs), true );
+                                                        explode( rhsCand, crntFinder.localSyms, back_inserter(rhs), true );
                                                         matcher.reset( 
                                                                 new MultipleAssignMatcher{ *this, expr->location, lhs, rhs } );
@@ -677 +677 @@
                                 )
 
-                                ResolvExpr::CandidateFinder finder{ crntFinder.symtab, matcher->env };
+                                ResolvExpr::CandidateFinder finder{ crntFinder.localSyms, matcher->env };
 
                                 try {

src/main.cc

@@ -29 +29 @@
 #include <string>                           // for char_traits, operator<<
 
+#include "AST/Convert.hpp"
 #include "CompilationState.h"
 #include "../config.h"                      // for CFA_LIBDIR
@@ -302 +303 @@
                 } // if
 
-                PASS( "Resolve", ResolvExpr::resolve( translationUnit ) );
+                // PASS( "Resolve", ResolvExpr::resolve( translationUnit ) );
+                {
+                        auto transUnit = convert( move( translationUnit ) );
+                        PASS( "Resolve", ResolvExpr::resolve( transUnit ) );
+                        translationUnit = convert( move( transUnit ) );
+                }
                 if ( exprp ) {
                         dump( translationUnit );