Changeset 40e636a

Timestamp:

Jul 21, 2016, 11:19:24 AM (8 years ago)

Author:

Rob Schluntz <rschlunt@…>

Branches:

ADT, aaron-thesis, arm-eh, ast-experimental, cleanup-dtors, ctor, deferred_resn, demangler, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, memory, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, pthread-emulation, qualifiedEnum, resolv-new, with_gc

Children:

b81adcc4

Parents:

5f98ce5

Message:

only generate array dimension constant inside of functions, recursively mutate array types into pointer types in function parameter lists, fix bug where global compound literal object is lost

Location:

src

Files:

• InitTweak/FixGlobalInit.cc (modified) (2 diffs)
• InitTweak/GenInit.cc (modified) (5 diffs)
• InitTweak/InitTweak.cc (modified) (1 diff)
• ResolvExpr/Resolver.cc (modified) (3 diffs)
• SymTab/FixFunction.cc (modified) (2 diffs)
• SymTab/Validate.cc (modified) (2 diffs)

src/InitTweak/FixGlobalInit.cc

@@ -46 +46 @@
                 FunctionDecl * destroyFunction;
         };
-
-        class ConstExprChecker : public Visitor {
-        public:
-                ConstExprChecker() : isConstExpr( true ) {}
-
-                virtual void visit( ApplicationExpr *applicationExpr ) { isConstExpr = false; }
-                virtual void visit( UntypedExpr *untypedExpr ) { isConstExpr = false; }
-                virtual void visit( NameExpr *nameExpr ) { isConstExpr = false; }
-                virtual void visit( CastExpr *castExpr ) { isConstExpr = false; }
-                virtual void visit( LabelAddressExpr *labAddressExpr ) { isConstExpr = false; }
-                virtual void visit( UntypedMemberExpr *memberExpr ) { isConstExpr = false; }
-                virtual void visit( MemberExpr *memberExpr ) { isConstExpr = false; }
-                virtual void visit( VariableExpr *variableExpr ) { isConstExpr = false; }
-                virtual void visit( ConstantExpr *constantExpr ) { /* bottom out */ }
-                // these might be okay?
-                // virtual void visit( SizeofExpr *sizeofExpr );
-                // virtual void visit( AlignofExpr *alignofExpr );
-                // virtual void visit( UntypedOffsetofExpr *offsetofExpr );
-                // virtual void visit( OffsetofExpr *offsetofExpr );
-                // virtual void visit( OffsetPackExpr *offsetPackExpr );
-                // virtual void visit( AttrExpr *attrExpr );
-                // virtual void visit( CommaExpr *commaExpr );
-                // virtual void visit( LogicalExpr *logicalExpr );
-                // virtual void visit( ConditionalExpr *conditionalExpr );
-                virtual void visit( TupleExpr *tupleExpr ) { isConstExpr = false; }
-                virtual void visit( SolvedTupleExpr *tupleExpr ) { isConstExpr = false; }
-                virtual void visit( TypeExpr *typeExpr ) { isConstExpr = false; }
-                virtual void visit( AsmExpr *asmExpr ) { isConstExpr = false; }
-                virtual void visit( UntypedValofExpr *valofExpr ) { isConstExpr = false; }
-                virtual void visit( CompoundLiteralExpr *compLitExpr ) { isConstExpr = false; }
-
-                bool isConstExpr;
-        };
-
-        bool isConstExpr( Expression * expr ) {
-                if ( expr ) {
-                        ConstExprChecker checker;
-                        expr->accept( checker );
-                        return checker.isConstExpr;
-                }
-                return true;
-        }
-
-        bool isConstExpr( Initializer * init ) {
-                if ( init ) {
-                        ConstExprChecker checker;
-                        init->accept( checker );
-                        return checker.isConstExpr;
-                } // if
-                // for all intents and purposes, no initializer means const expr
-                return true;
-        }
 
         void fixGlobalInit( std::list< Declaration * > & translationUnit, const std::string & name, bool inLibrary ) {
@@ -159 +107 @@
                         // xxx - initialize each element of the array
                 } else {
-                        // steal initializer from object and attach it to a new temporary
-                        ObjectDecl *newObj = new ObjectDecl( tempNamer.newName(), DeclarationNode::NoStorageClass, LinkageSpec::C, 0, objDecl->get_type()->clone(), objDecl->get_init() );
-                        objDecl->set_init( NULL );
-                        initStatements.push_back( new DeclStmt( noLabels, newObj ) );
-
-                        // copy construct objDecl using temporary
+                        // insert constructor for objDecl into global init function
                         UntypedExpr * init = new UntypedExpr( new NameExpr( "?{}" ) );
                         init->get_args().push_back( new AddressExpr( new VariableExpr( objDecl ) ) );
-                        init->get_args().push_back( new VariableExpr( newObj ) );
+                        init->get_args().splice( init->get_args().end(), makeInitList( objDecl->get_init() ) );
+                        objDecl->set_init( NULL );
                         initStatements.push_back( new ImplicitCtorDtorStmt( new ExprStmt( noLabels, init ) ) );
 

src/InitTweak/GenInit.cc

@@ -90 +90 @@
 
           private:
-                DeclarationWithType * mutate( ObjectDecl * objectDecl );
+                virtual DeclarationWithType * mutate( ObjectDecl * objectDecl );
+                virtual DeclarationWithType * mutate( FunctionDecl *functionDecl );
                 // should not traverse into any of these declarations to find objects
                 // that need to be constructed or destructed
@@ -105 +106 @@
 
                 DeclarationNode::StorageClass storageclass = DeclarationNode::NoStorageClass;
+                bool inFunction = false;
         };
 
@@ -157 +159 @@
         void HoistArrayDimension::hoistArrayDimension( std::list< Declaration * > & translationUnit ) {
                 HoistArrayDimension hoister;
-                mutateAll( translationUnit, hoister );
+                hoister.mutateDeclarationList( translationUnit );
         }
 
@@ -169 +171 @@
 
         void HoistArrayDimension::hoist( Type * type ) {
+                // if in function, generate const size_t var
                 static UniqueName dimensionName( "_array_dim" );
                 if ( ArrayType * arrayType = dynamic_cast< ArrayType * >( type ) ) {
+                        if ( ! inFunction ) return;
+
                         if ( ! arrayType->get_dimension() ) return; // xxx - recursive call to hoist?
 
@@ -186 +191 @@
                         return;
                 }
+        }
+
+        DeclarationWithType * HoistArrayDimension::mutate( FunctionDecl *functionDecl ) {
+                bool oldInFunc = inFunction;
+                inFunction = true;
+                DeclarationWithType * decl = Parent::mutate( functionDecl );
+                inFunction = oldInFunc;
+                return decl;
         }
 

src/InitTweak/InitTweak.cc

@@ -160 +160 @@
                 else return NULL;
         }
+
+        class ConstExprChecker : public Visitor {
+        public:
+                ConstExprChecker() : isConstExpr( true ) {}
+
+                virtual void visit( ApplicationExpr *applicationExpr ) { isConstExpr = false; }
+                virtual void visit( UntypedExpr *untypedExpr ) { isConstExpr = false; }
+                virtual void visit( NameExpr *nameExpr ) { isConstExpr = false; }
+                virtual void visit( CastExpr *castExpr ) { isConstExpr = false; }
+                virtual void visit( LabelAddressExpr *labAddressExpr ) { isConstExpr = false; }
+                virtual void visit( UntypedMemberExpr *memberExpr ) { isConstExpr = false; }
+                virtual void visit( MemberExpr *memberExpr ) { isConstExpr = false; }
+                virtual void visit( VariableExpr *variableExpr ) { isConstExpr = false; }
+                virtual void visit( ConstantExpr *constantExpr ) { /* bottom out */ }
+                // these might be okay?
+                // virtual void visit( SizeofExpr *sizeofExpr );
+                // virtual void visit( AlignofExpr *alignofExpr );
+                // virtual void visit( UntypedOffsetofExpr *offsetofExpr );
+                // virtual void visit( OffsetofExpr *offsetofExpr );
+                // virtual void visit( OffsetPackExpr *offsetPackExpr );
+                // virtual void visit( AttrExpr *attrExpr );
+                // virtual void visit( CommaExpr *commaExpr );
+                // virtual void visit( LogicalExpr *logicalExpr );
+                // virtual void visit( ConditionalExpr *conditionalExpr );
+                virtual void visit( TupleExpr *tupleExpr ) { isConstExpr = false; }
+                virtual void visit( SolvedTupleExpr *tupleExpr ) { isConstExpr = false; }
+                virtual void visit( TypeExpr *typeExpr ) { isConstExpr = false; }
+                virtual void visit( AsmExpr *asmExpr ) { isConstExpr = false; }
+                virtual void visit( UntypedValofExpr *valofExpr ) { isConstExpr = false; }
+                virtual void visit( CompoundLiteralExpr *compLitExpr ) { isConstExpr = false; }
+
+                bool isConstExpr;
+        };
+
+        bool isConstExpr( Expression * expr ) {
+                if ( expr ) {
+                        ConstExprChecker checker;
+                        expr->accept( checker );
+                        return checker.isConstExpr;
+                }
+                return true;
+        }
+
+        bool isConstExpr( Initializer * init ) {
+                if ( init ) {
+                        ConstExprChecker checker;
+                        init->accept( checker );
+                        return checker.isConstExpr;
+                } // if
+                // for all intents and purposes, no initializer means const expr
+                return true;
+        }
+
 }

src/ResolvExpr/Resolver.cc

@@ -42 +42 @@
 
                 virtual void visit( ArrayType * at );
+                virtual void visit( PointerType * at );
 
                 virtual void visit( ExprStmt *exprStmt );
@@ -60 +61 @@
           private:
         typedef std::list< Initializer * >::iterator InitIterator;
+
+                template< typename PtrType >
+                void handlePtrType( PtrType * type );
 
           void resolveAggrInit( AggregateDecl *, InitIterator &, InitIterator & );
@@ -193 +197 @@
         }
 
+        template< typename PtrType >
+        void Resolver::handlePtrType( PtrType * type ) {
+                if ( type->get_dimension() ) {
+                        CastExpr *castExpr = new CastExpr( type->get_dimension(), SymTab::SizeType->clone() );
+                        Expression *newExpr = findSingleExpression( castExpr, *this );
+                        delete type->get_dimension();
+                        type->set_dimension( newExpr );
+                }
+        }
+
         void Resolver::visit( ArrayType * at ) {
-                if ( at->get_dimension() ) {
-                        CastExpr *castExpr = new CastExpr( at->get_dimension(), SymTab::SizeType->clone() );
-                        Expression *newExpr = findSingleExpression( castExpr, *this );
-                        delete at->get_dimension();
-                        at->set_dimension( newExpr );
-                }
+                handlePtrType( at );
                 Visitor::visit( at );
+        }
+
+        void Resolver::visit( PointerType * pt ) {
+                handlePtrType( pt );
+                Visitor::visit( pt );
         }
 

src/SymTab/FixFunction.cc

@@ -5 +5 @@
 // file "LICENCE" distributed with Cforall.
 //
-// FixFunction.cc -- 
+// FixFunction.cc --
 //
 // Author           : Richard C. Bilson
@@ -44 +44 @@
 
         Type * FixFunction::mutate(ArrayType *arrayType) {
-                PointerType *pointerType = new PointerType( arrayType->get_qualifiers(), maybeClone( arrayType->get_base()->clone() ), maybeClone( arrayType->get_dimension() ), arrayType->get_isVarLen(), arrayType->get_isStatic() );
+                // need to recursively mutate the base type in order for multi-dimensional arrays to work.
+                PointerType *pointerType = new PointerType( arrayType->get_qualifiers(), arrayType->get_base()->clone()->acceptMutator( *this ), maybeClone( arrayType->get_dimension() ), arrayType->get_isVarLen(), arrayType->get_isStatic() );
                 delete arrayType;
                 return pointerType;

src/SymTab/Validate.cc

@@ -191 +191 @@
                 EliminateTypedef::eliminateTypedef( translationUnit );
                 HoistStruct::hoistStruct( translationUnit );
+                autogenerateRoutines( translationUnit ); // moved up, used to be below compoundLiteral - currently needs Pass1
                 acceptAll( translationUnit, pass1 );
                 acceptAll( translationUnit, pass2 );
                 ReturnChecker::checkFunctionReturns( translationUnit );
-                mutateAll( translationUnit, compoundliteral );
-                autogenerateRoutines( translationUnit );
+                compoundliteral.mutateDeclarationList( translationUnit );
                 acceptAll( translationUnit, pass3 );
                 VerifyCtorDtor::verify( translationUnit );
@@ -494 +494 @@
                         SizeType = eliminator.typedefNames["size_t"].first->get_base()->clone();
                 } else {
-                        assert( false && "missing global typedef for size_t" );
+                        // xxx - missing global typedef for size_t - default to long unsigned int, even though that may be wrong
+                        // eventually should have a warning for this case.
+                        SizeType = new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt );
                 }
                 filter( translationUnit, isTypedef, true );