Changeset 8c0d801 for src

Timestamp:

Jun 6, 2019, 3:40:56 PM (5 years ago)

Author:

Aaron Moss <a3moss@…>

Branches:

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

Children:

1a4323e

Parents:

b7d92b96 (diff), 546e712 (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 branch 'master' of plg.uwaterloo.ca:software/cfa/cfa-cc

Location:

src

Files:

• AST/Convert.cpp (modified) (14 diffs)
• AST/Expr.cpp (modified) (1 diff)
• AST/Expr.hpp (modified) (1 diff)
• AST/Node.hpp (modified) (1 diff)
• InitTweak/FixInit.cc (modified) (3 diffs)
• SynTree/DeclReplacer.h (modified) (1 diff)
• SynTree/Expression.cc (modified) (1 diff)
• SynTree/Expression.h (modified) (1 diff)

src/AST/Convert.cpp

@@ -10 +10 @@
 // Created On       : Thu May 09 15::37::05 2019
 // Last Modified By : Andrew Beach
-// Last Modified On : Wed May 29 17:05:00 2019
-// Update Count     : 9
+// Last Modified On : Thu May 06 19:51:00 2019
+// Update Count     : 10
 //
 
@@ -49 +49 @@
 // This is to preserve the FindSpecialDecls hack. It does not (and perhaps should not)
 // allow us to use the same stratagy in the new ast.
+ast::Type * sizeType = nullptr;
 ast::FunctionDecl * dereferenceOperator = nullptr;
 ast::StructDecl   * dtorStruct = nullptr;
@@ -147 +148 @@
 
         const ast::DeclWithType * visit( const ast::ObjectDecl * node ) override final {
-                if ( inCache( node ) ) return nullptr;
+                auto&& bfwd = get<Expression>().accept1( node->bitfieldWidth );
+                auto&& type = get<Type>().accept1( node->type );
+                auto&& init = get<Initializer>().accept1( node->init );
+                auto&& attr = get<Attribute>().acceptL( node->attributes );
+                if ( inCache( node ) ) {
+                        if(node->name == "tmp") {
+                                std::cerr << (void*)node << "(new) in cache " << (void*)this->node << "(old)" << std::endl;
+                        }
+                        return nullptr;
+                }
                 auto decl = new ObjectDecl(
                         node->name,
                         Type::StorageClasses( node->storage.val ),
                         LinkageSpec::Spec( node->linkage.val ),
-                        get<Expression>().accept1( node->bitfieldWidth ),
-                        get<Type>().accept1( node->type ),
-                        get<Initializer>().accept1( node->init ),
-                        get<Attribute>().acceptL( node->attributes ),
+                        bfwd,
+                        type,
+                        init,
+                        attr,
                         Type::FuncSpecifiers( node->funcSpec.val )
                 );
+                if(node->name == "tmp") {
+                        std::cerr << (void*)node << "(new) created " << (void*)decl << "(old)" << std::endl;
+                }
                 return declWithTypePostamble( decl, node );
         }
@@ -709 +722 @@
                 auto expr = visitBaseExpr( node,
                         new MemberExpr(
-                                inCache(node->member) ?
-                                        dynamic_cast<DeclarationWithType *>(this->node) :
-                                        get<DeclarationWithType>().accept1(node->member),
+                                get<DeclarationWithType>().accept1(node->member),
                                 get<Expression>().accept1(node->aggregate)
                         )
@@ -720 +731 @@
 
         const ast::Expr * visit( const ast::VariableExpr * node ) override final {
-                auto expr = visitBaseExpr( node,
-                        new VariableExpr(
-                                inCache(node->var) ?
-                                        dynamic_cast<DeclarationWithType *>(this->node) :
-                                        get<DeclarationWithType>().accept1(node->var)
-                        )
-                );
+                auto expr = new VariableExpr();
+                visitBaseExpr( node, expr );
+                expr->var = get<DeclarationWithType>().accept1(node->var);
+                Type * type = expr->var->get_type()->clone();
+                type->set_lvalue( true );
+                expr->set_result( type );
                 this->node = expr;
                 return nullptr;
@@ -819 +829 @@
                         new OffsetofExpr(
                                 get<Type>().accept1(node->type),
-                                inCache(node->member) ?
-                                        dynamic_cast<DeclarationWithType *>(this->node) :
-                                        get<DeclarationWithType>().accept1(node->member)
+                                get<DeclarationWithType>().accept1(node->member)
                         )
                 );
@@ -1082 +1090 @@
 
         const ast::Type * visit( const ast::BasicType * node ) override final {
-                this->node = new BasicType{ cv( node ), (BasicType::Kind)(unsigned)node->kind };
+                auto type = new BasicType{ cv( node ), (BasicType::Kind)(unsigned)node->kind };
+                // I believe this should always be a BasicType.
+                if ( sizeType == node ) {
+                        Validate::SizeType = type;
+                }
+                this->node = type;
                 return nullptr;
         }
@@ -1356 +1369 @@
                 return strict_dynamic_cast< ast::Decl * >( node );
         }
+
+        ConverterOldToNew() = default;
+        ConverterOldToNew(const ConverterOldToNew &) = delete;
+        ConverterOldToNew(ConverterOldToNew &&) = delete;
 private:
         /// conversion output
-        ast::Node * node;
+        ast::Node * node = nullptr;
         /// cache of nodes that might be referenced by readonly<> for de-duplication
-        std::unordered_map< BaseSyntaxNode *, ast::Node * > cache;
+        std::unordered_map< BaseSyntaxNode *, ast::Node * > cache = {};
 
         // Local Utilities:
+
+        #define construct(T, key, ...) ({ \
+                void * data = ::operator new(sizeof(T)); \
+                cache.emplace( key, (T*)data ); \
+                new (data) T( __VA_ARGS__ ); \
+        })
 
         template<typename NewT, typename OldT>
@@ -1424 +1447 @@
 
         virtual void visit( ObjectDecl * old ) override final {
-                if ( inCache( old ) ) return;
+                if( old->name == "tmp" ) {
+                        std::cerr << "building parameters for" << (void*)old << std::endl;
+                }
+                auto&& type = GET_ACCEPT_1(type, Type);
+                auto&& init = GET_ACCEPT_1(init, Init);
+                auto&& bfwd = GET_ACCEPT_1(bitfieldWidth, Expr);
+                auto&& attr = GET_ACCEPT_V(attributes, Attribute);
+                if( old->name == "tmp" ) {
+                        std::cerr << "checking cache for " << (void*)old << std::endl;
+                }
+                if ( inCache( old ) ) {
+                        if( old->name == "tmp" ) {
+                                std::cerr << (void*)old << "(old) in cache " << (void*)this->node << "(new)" << std::endl;
+                        }
+                        return;
+                }
                 auto decl = new ast::ObjectDecl(
                         old->location,
                         old->name,
-                        GET_ACCEPT_1(type, Type),
-                        GET_ACCEPT_1(init, Init),
+                        type,
+                        init,
                         { old->get_storageClasses().val },
                         { old->linkage.val },
-                        GET_ACCEPT_1(bitfieldWidth, Expr),
-                        GET_ACCEPT_V(attributes, Attribute),
+                        bfwd,
+                        std::move(attr),
                         { old->get_funcSpec().val }
                 );
-                cache.emplace( old, decl );
+                cache.emplace(old, decl);
+                if( old->name == "tmp" ) {
+                        std::cerr << (void*)old << "(old) added to cache with " << (void*)decl << "(new)" << std::endl;
+                }
+                assert(cache.find( old ) != cache.end());
                 decl->scopeLevel = old->scopeLevel;
                 decl->mangleName = old->mangleName;
@@ -1444 +1486 @@
 
                 this->node = decl;
+
+                if( old->name == "tmp" ) {
+                        std::cerr << (void*)old << "(old) created " << (void*)this->node << "(new)" << std::endl;
+                }
         }
 
@@ -2092 +2138 @@
                         new ast::MemberExpr(
                                 old->location,
-                                inCache(old->member) ?
-                                        dynamic_cast<ast::DeclWithType *>(this->node) :
-                                        GET_ACCEPT_1(member, DeclWithType),
+                                GET_ACCEPT_1(member, DeclWithType),
                                 GET_ACCEPT_1(aggregate, Expr)
                         )
@@ -2101 +2145 @@
 
         virtual void visit( VariableExpr * old ) override final {
-                this->node = visitBaseExpr( old,
-                        new ast::VariableExpr(
-                                old->location,
-                                inCache(old->var) ?
-                                        dynamic_cast<ast::DeclWithType *>(this->node) :
-                                        GET_ACCEPT_1(var, DeclWithType)
-                        )
-                );
+                auto expr = new ast::VariableExpr(
+                        old->location
+                );
+
+                visitBaseExpr( old,
+                        expr
+                );
+
+                expr->var = GET_ACCEPT_1(var, DeclWithType);
+                expr->result = expr->var->get_type();
+                add_qualifiers( expr->result, ast::CV::Lvalue );
+                this->node = expr;
         }
 
@@ -2234 +2282 @@
                                 old->location,
                                 GET_ACCEPT_1(type, Type),
-                                inCache(old->member) ?
-                                        dynamic_cast<ast::DeclWithType *>(this->node) :
-                                        GET_ACCEPT_1(member, DeclWithType)
+                                GET_ACCEPT_1(member, DeclWithType)
                         )
                 );
@@ -2472 +2518 @@
 
         virtual void visit( BasicType * old ) override final {
-                this->node = new ast::BasicType{ (ast::BasicType::Kind)(unsigned)old->kind, cv( old ) };
+                auto type = new ast::BasicType{ (ast::BasicType::Kind)(unsigned)old->kind, cv( old ) };
+                // I believe this should always be a BasicType.
+                if ( Validate::SizeType == old ) {
+                        sizeType = type;
+                }
+                this->node = type;
         }
 

src/AST/Expr.cpp

@@ -170 +170 @@
 // --- VariableExpr
 
+VariableExpr::VariableExpr( const CodeLocation & loc )
+: Expr( loc ), var( nullptr ) {}
+
 VariableExpr::VariableExpr( const CodeLocation & loc, const DeclWithType * v )
 : Expr( loc ), var( v ) {

src/AST/Expr.hpp

@@ -315 +315 @@
         readonly<DeclWithType> var;
 
+        VariableExpr( const CodeLocation & loc );
         VariableExpr( const CodeLocation & loc, const DeclWithType * v );
 

src/AST/Node.hpp

@@ -206 +206 @@
         /// wrapper for convenient access to strict_dynamic_cast
         template<typename o_node_t>
-        const o_node_t * strict_as() const { return strict_dynamic_cast<const o_node_t *>(node); }
+        const o_node_t * strict_as() const { _check(); return strict_dynamic_cast<const o_node_t *>(node); }
 
         /// Returns a mutable version of the pointer in this node.

src/InitTweak/FixInit.cc

@@ -262 +262 @@
                         // unwrap implicit statement wrapper
                         Statement * dtor = input;
-                        if ( ImplicitCtorDtorStmt * implicit = dynamic_cast< ImplicitCtorDtorStmt * >( input ) ) {
-                                // dtor = implicit->callStmt;
-                                // implicit->callStmt = nullptr;
-                        }
                         assert( dtor );
                         std::list< Expression * > matches;
@@ -291 +287 @@
                         // wraps the more complicated code.
                         static UniqueName dtorNamer( "__cleanup_dtor" );
-                        FunctionDecl * dtorFunc = FunctionDecl::newFunction( dtorNamer.newName(), SymTab::genDefaultType( objDecl->type->stripReferences(), false ), new CompoundStmt() );
+                        std::string name = dtorNamer.newName();
+                        if(name == "__cleanup_dtor8") {
+                                objDecl->print(std::cerr);
+                                std::cerr << "-----" << std::endl;
+                                dtor->print(std::cerr);
+                        }
+                        FunctionDecl * dtorFunc = FunctionDecl::newFunction( name, SymTab::genDefaultType( objDecl->type->stripReferences(), false ), new CompoundStmt() );
                         stmtsToAdd.push_back( new DeclStmt( dtorFunc ) );
 
@@ -304 +306 @@
                                 replacement = new CastExpr( replacement, base->clone() );
                         }
-                        DeclReplacer::replace( dtor, { std::make_pair( objDecl, replacement ) } );
+                        size_t replaced = DeclReplacer::replace( dtor, { std::make_pair( objDecl, replacement ) } );
+                        if(replaced == 0) {
+                                std::cerr << "Failed to replace " << objDecl << std::endl;
+                                abort();
+                        }
                         dtorFunc->statements->push_back( strict_dynamic_cast<Statement *>( dtor ) );
 

src/SynTree/DeclReplacer.h

@@ -33 +33 @@
 
         size_t replace( BaseSyntaxNode *& node, const ExprMap & exprMap, bool debug = false);
+
         template<typename T>
-                void replace( T *& node, const ExprMap & exprMap, bool debug = false ) {
-                if ( ! node ) return;
+        size_t replace( T *& node, const ExprMap & exprMap, bool debug = false ) {
+                if ( ! node ) return 0ul;
                 BaseSyntaxNode * arg = node;
-                replace( arg, exprMap, debug );
+                size_t replaced = replace( arg, exprMap, debug );
                 node = dynamic_cast<T *>( arg );
                 assertf( node, "DeclReplacer fundamentally changed the type of its argument." );
+                return replaced;
         }
 }

src/SynTree/Expression.cc

@@ -102 +102 @@
         SemanticError( this, "Constant expression of non-integral type " );
 }
+
+VariableExpr::VariableExpr() : Expression(), var( nullptr ) {}
 
 VariableExpr::VariableExpr( DeclarationWithType *_var ) : Expression(), var( _var ) {

src/SynTree/Expression.h

@@ -299 +299 @@
         DeclarationWithType * var;
 
+        VariableExpr();
         VariableExpr( DeclarationWithType * var );
         VariableExpr( const VariableExpr & other );