Changeset 71a3593 for src/ResolvExpr/Resolver.cc

Timestamp:

Aug 5, 2016, 12:06:29 PM (8 years ago)

Author:

Peter A. Buhr <pabuhr@…>

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:

d9e2280

Parents:

9706554 (diff), a2f920f (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 plg2:software/cfa/cfa-cc

File:

• src/ResolvExpr/Resolver.cc (modified) (7 diffs)

src/ResolvExpr/Resolver.cc

@@ -24 +24 @@
 #include "SynTree/Initializer.h"
 #include "SymTab/Indexer.h"
+#include "SymTab/Autogen.h"
 #include "Common/utility.h"
 #include "InitTweak/InitTweak.h"
@@ -41 +42 @@
 
                 virtual void visit( ArrayType * at );
+                virtual void visit( PointerType * at );
 
                 virtual void visit( ExprStmt *exprStmt );
@@ -52 +54 @@
                 virtual void visit( BranchStmt *branchStmt );
                 virtual void visit( ReturnStmt *returnStmt );
-                virtual void visit( ImplicitCtorDtorStmt * impCtorDtorStmt );
 
                 virtual void visit( SingleInit *singleInit );
@@ -59 +60 @@
           private:
         typedef std::list< Initializer * >::iterator InitIterator;
+
+                template< typename PtrType >
+                void handlePtrType( PtrType * type );
 
           void resolveAggrInit( AggregateDecl *, InitIterator &, InitIterator & );
@@ -192 +196 @@
         }
 
+        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() ) {
-                        BasicType arrayLenType = BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt );
-                        CastExpr *castExpr = new CastExpr( at->get_dimension(), arrayLenType.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 );
         }
 
@@ -422 +435 @@
 
         void Resolver::visit( ListInit * listInit ) {
-                InitIterator iter = listInit->begin_initializers();
-                InitIterator end = listInit->end_initializers();
+                InitIterator iter = listInit->begin();
+                InitIterator end = listInit->end();
 
                 if ( ArrayType * at = dynamic_cast< ArrayType * >( initContext ) ) {
@@ -521 +534 @@
                 // implicitly generated, there's no way for it to have side effects, so get rid of it
                 // to clean up generated code.
-                if ( InitTweak::isInstrinsicSingleArgCallStmt( ctorInit->get_ctor() ) ) {
+                if ( InitTweak::isIntrinsicSingleArgCallStmt( ctorInit->get_ctor() ) ) {
                         delete ctorInit->get_ctor();
                         ctorInit->set_ctor( NULL );
                 }
-                if ( InitTweak::isInstrinsicSingleArgCallStmt( ctorInit->get_ctor() ) ) {
+
+                // xxx - todo
+                // if ( InitTweak::isIntrinsicCallStmt( ctorInit->get_ctor() ) ) {
+                //      // can reduce the constructor down to a SingleInit using the
+                //      // second argument from the ctor call
+                // }
+
+                if ( InitTweak::isIntrinsicSingleArgCallStmt( ctorInit->get_dtor() ) ) {
                         delete ctorInit->get_dtor();
                         ctorInit->set_dtor( NULL );
                 }
-        }
-
-        void Resolver::visit( ImplicitCtorDtorStmt * impCtorDtorStmt ) {
-                // before resolving ctor/dtor, need to remove type qualifiers from the first argument (the object being constructed).
-                // Do this through a cast expression to greatly simplify the code.
-                Expression * callExpr = InitTweak::getCtorDtorCall( impCtorDtorStmt );
-                assert( callExpr );
-                Expression *& constructee = InitTweak::getCallArg( callExpr, 0 );
-                Type * type = 0;
-
-                // need to find the type of the first argument, which is unfortunately not uniform since array construction
-                // includes an untyped '+' expression.
-                if ( UntypedExpr * plusExpr = dynamic_cast< UntypedExpr * >( constructee ) ) {
-                        // constructee is <array>+<index>
-                        // get Variable <array>, then get the base type of the VariableExpr - this is the type that needs to be fixed
-                        Expression * arr = InitTweak::getCallArg( plusExpr, 0 );
-                        assert( dynamic_cast< VariableExpr * >( arr ) || dynamic_cast< MemberExpr *>( arr ) );
-                        assert( arr && arr->get_results().size() == 1 );
-                        type = arr->get_results().front()->clone();
-                } else {
-                        // otherwise, constructing a plain object, which means the object's address is being taken.
-                        // Need to get the type of the VariableExpr object, because the AddressExpr is rebuilt and uses the
-                        // type of the VariableExpr to do so.
-                        assert( constructee->get_results().size() == 1 );
-                        AddressExpr * addrExpr = dynamic_cast< AddressExpr * > ( constructee );
-                        assert( addrExpr && addrExpr->get_results().size() == 1 );
-                        type = addrExpr->get_results().front()->clone();
-                }
-                // cast to T* with qualifiers removed.
-                // unfortunately, lvalue is considered a qualifier. For AddressExpr to resolve, its argument
-                // must have an lvalue qualified type, so remove all qualifiers except lvalue. If we ever
-                // remove lvalue as a qualifier, this can change to
-                //   type->get_qualifiers() = Type::Qualifiers();
-                Type * base = InitTweak::getPointerBase( type );
-                assert( base );
-                base->get_qualifiers() -= Type::Qualifiers(true, true, true, false, true, true);
-                // if pointer has lvalue qualifier, cast won't appear in output
-                type->set_isLvalue( false );
-                constructee = new CastExpr( constructee, type );
-
-                // finally, resolve the ctor/dtor
-                impCtorDtorStmt->get_callStmt()->accept( *this );
         }
 } // namespace ResolvExpr