Changeset 10a7775

Timestamp:

Jun 3, 2016, 2:02:29 PM (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, gc_noraii, 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:

e365cb5

Parents:

e01bfbc

Message:

can use intrinsic constructors on const objects

Location:

src

Files:

• CodeGen/CodeGenerator.cc (modified) (3 diffs)
• GenPoly/Box.cc (modified) (1 diff)
• InitTweak/InitTweak.cc (modified) (1 diff)
• InitTweak/InitTweak.h (modified) (1 diff)
• ResolvExpr/Resolver.cc (modified) (2 diffs)

src/CodeGen/CodeGenerator.cc

@@ -33 +33 @@
 #include "OperatorTable.h"
 #include "GenType.h"
+
+#include "InitTweak/InitTweak.h"
 
 using namespace std;
@@ -255 +257 @@
                                 std::list< Expression* >::iterator arg = applicationExpr->get_args().begin();
                                 switch ( opInfo.type ) {
+                                  case OT_CTOR:
+                                  case OT_DTOR:
+                                        {
+                                                // if the first argument's type is const then GCC complains. In this
+                                                // case, output an explicit ctor/dtor call and exit, rather than following
+                                                // the normal path
+                                                assert( arg != applicationExpr->get_args().end() );
+                                                assert( (*arg)->get_results().size() >= 1 );
+                                                Type * baseType = InitTweak::getPointerBase( (*arg)->get_results().front() );
+                                                if ( baseType->get_isConst() ) {
+                                                        // cast away the qualifiers, to eliminate warnings
+                                                        Type * newType = baseType->clone();
+                                                        newType->get_qualifiers() = Type::Qualifiers();
+                                                        *arg = new CastExpr( *arg, new PointerType( Type::Qualifiers(), newType ) );
+                                                        varExpr->accept( *this );
+                                                        output << "(";
+                                                        genCommaList( applicationExpr->get_args().begin(), applicationExpr->get_args().end() );
+                                                        output << ")";
+                                                        return;
+                                                }
+                                        }
+                                        // intentional fallthrough - instrinsic ctor/dtor for non-const objects should
+                                        // be handled the same way as assignment
                                   case OT_PREFIXASSIGN:
                                   case OT_POSTFIXASSIGN:
                                   case OT_INFIXASSIGN:
-                                  case OT_CTOR:
-                                  case OT_DTOR:
                                         {
                                                 assert( arg != applicationExpr->get_args().end() );
@@ -269 +292 @@
                                                         UntypedExpr *newExpr = new UntypedExpr( new NameExpr( "*?" ) );
                                                         newExpr->get_args().push_back( *arg );
+                                                        assert( (*arg)->get_results().size() == 1 );
+                                                        Type * type = InitTweak::getPointerBase( (*arg)->get_results().front() );
+                                                        assert( type );
+                                                        newExpr->get_results().push_back( type );
                                                         *arg = newExpr;
                                                 } // if

src/GenPoly/Box.cc

@@ -1947 +1947 @@
                                 UntypedExpr *derefExpr = new UntypedExpr( new NameExpr( "*?" ) );
                                 derefExpr->get_args().push_back( derefdVar );
+                                // xxx - should set results on derefExpr
                                 derefdVar = derefExpr;
                         }

src/InitTweak/InitTweak.cc

@@ -137 +137 @@
     }
   }
+
+  Type * getPointerBase( Type * type ) {
+    if ( PointerType * ptrType = dynamic_cast< PointerType * >( type ) ) {
+      return ptrType->get_base();
+    } else if ( ArrayType * arrayType = dynamic_cast< ArrayType * >( type ) ) {
+      return arrayType->get_base();
+    } else {
+      return NULL;
+    }
+  }
+
 }

src/InitTweak/InitTweak.h

@@ -48 +48 @@
   /// returns the argument to a call expression in position N indexed from 0
   Expression * getCallArg( Expression * callExpr, unsigned int pos );
+
+  /// returns the base type of a PointerType or ArrayType
+  Type * getPointerBase( Type * );
 } // namespace
 

src/ResolvExpr/Resolver.cc

@@ -531 +531 @@
                         assert( dynamic_cast< VariableExpr * >( arr ) );
                         assert( arr && arr->get_results().size() == 1 );
-                        ArrayType * arrType = dynamic_cast< ArrayType * >( arr->get_results().front() );
-                        assert( arrType );
-                        type = arrType->get_base();
+                        type = InitTweak::getPointerBase( arr->get_results().front() );
+                        assert( type );
                 } else {
                         // otherwise, constructing a plain object, which means the object's address is being taken.
@@ -557 +556 @@
                 impCtorDtorStmt->get_callStmt()->accept( *this );
 
-                // and reset type qualifiers after resolving
-                type->get_qualifiers() = qualifiers;
+                // reset type qualifiers, but first need to figure out where everything is again
+                // because the expressions are often changed by the resolver.
+                callExpr = InitTweak::getCtorDtorCall( impCtorDtorStmt );
+                assert( callExpr );
+                constructee = InitTweak::getCallArg( callExpr, 0 );
+                if ( ApplicationExpr * plusExpr = dynamic_cast< ApplicationExpr * >( 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 ) );
+                        assert( arr && arr->get_results().size() == 1 );
+                        type = InitTweak::getPointerBase( arr->get_results().front() );
+                        assert( type );
+                        type->get_qualifiers() = qualifiers;
+                } else {
+                        // otherwise constructing a plain object
+                        // replace qualifiers on AddressExpr and on inner VariableExpr
+                        assert( constructee->get_results().size() == 1 );
+                        AddressExpr * addrExpr = dynamic_cast< AddressExpr * > ( constructee );
+                        assert( addrExpr );
+                        type = InitTweak::getPointerBase( addrExpr->get_results().front() );
+                        assert( type );
+                        type->get_qualifiers() = qualifiers;
+
+                        VariableExpr * varExpr = dynamic_cast< VariableExpr * >( addrExpr->get_arg() );
+                        assert( varExpr && varExpr->get_results().size() == 1 );
+                        type = varExpr->get_results().front();
+                        type->get_qualifiers() = qualifiers;
+                }
         }
 } // namespace ResolvExpr