Changeset f1b1e4c for src/InitTweak

Timestamp:

Jun 1, 2016, 11:54:23 AM (9 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:

be945ac

Parents:

70f89d00

Message:

can construct global const objects, except with intrinsic constructors

Location:

src/InitTweak

Files:

• FixGlobalInit.cc (modified) (2 diffs)
• FixInit.cc (modified) (1 diff)
• GenInit.cc (modified) (3 diffs)
• InitTweak.cc (modified) (2 diffs)
• InitTweak.h (modified) (1 diff)

src/InitTweak/FixGlobalInit.cc

@@ -125 +125 @@
                 std::list< Statement * > & destroyStatements = destroyFunction->get_statements()->get_kids();
 
-                // if ( objDecl->get_init() == NULL ) return;
                 if ( ! tryConstruct( objDecl ) ) return; // don't construct @= or designated objects
-                if ( objDecl->get_type()->get_isConst() ) return; // temporary: can't assign to a const variable
                 if ( objDecl->get_storageClass() == DeclarationNode::Extern ) return;
                 // C allows you to initialize objects with constant expressions
@@ -146 +144 @@
                         init->get_args().push_back( new AddressExpr( new VariableExpr( objDecl ) ) );
                         init->get_args().push_back( new VariableExpr( newObj ) );
-                        initStatements.push_back( new ExprStmt( noLabels, init ) );
+                        initStatements.push_back( new ImplicitCtorDtorStmt( new ExprStmt( noLabels, init ) ) );
 
                         // add destructor calls to global destroy function
                         UntypedExpr * destroy = new UntypedExpr( new NameExpr( "^?{}" ) );
                         destroy->get_args().push_back( new AddressExpr( new VariableExpr( objDecl ) ) );
-                        destroyStatements.push_front( new ExprStmt( noLabels, destroy ) );
+                        destroyStatements.push_front( new ImplicitCtorDtorStmt( new ExprStmt( noLabels, destroy ) ) );
                 }
         }

src/InitTweak/FixInit.cc

@@ -132 +132 @@
                                 return appExpr;
                         } else if ( DeclarationWithType * funcDecl = dynamic_cast< DeclarationWithType * > ( function->get_var() ) ) {
-                                // FunctionType * ftype = funcDecl->get_functionType();
                                 FunctionType * ftype = dynamic_cast< FunctionType * >( GenPoly::getFunctionType( funcDecl->get_type() ) );
                                 assert( ftype );

src/InitTweak/GenInit.cc

@@ -143 +143 @@
                 if ( tryConstruct( objDecl ) ) {
                         if ( inFunction ) {
-                                // remove qualifiers so that const objects can be initialized, and attach the
-                                // qualifiers to ConstructorInit so that they can be replaced after resolving
-                                Type * type = objDecl->get_type();
-                                Type::Qualifiers qualifiers = type->get_qualifiers();
-                                type->get_qualifiers() = Type::Qualifiers();
-
                                 if ( ArrayType * at = dynamic_cast< ArrayType * >( objDecl->get_type() ) ) {
                                         // call into makeArrayFunction from validate.cc to generate calls to ctor/dtor for each element of array
@@ -170 +164 @@
                                                 assert( ctor.size() == 1 );
                                                 assert( dtor.size() == 1 );
-
-                                                objDecl->set_init( new ConstructorInit( ctor.front(), dtor.front(), objDecl->get_init(), objDecl, qualifiers ) );
+                                                objDecl->set_init( new ConstructorInit( new ImplicitCtorDtorStmt( ctor.front() ), new ImplicitCtorDtorStmt( dtor.front() ), objDecl->get_init() ) );
                                         } else {
                                                 // array came with an initializer list: initialize each element
@@ -191 +184 @@
                                         ExprStmt * ctorStmt = new ExprStmt( noLabels, ctor );
                                         ExprStmt * dtorStmt = new ExprStmt( noLabels, dtor );
-                                        objDecl->set_init( new ConstructorInit( ctorStmt, dtorStmt, objDecl->get_init(), objDecl, qualifiers ) );
+                                        objDecl->set_init( new ConstructorInit( new ImplicitCtorDtorStmt( ctorStmt ), new ImplicitCtorDtorStmt( dtorStmt ), objDecl->get_init() ) );
                                 }
                         }

src/InitTweak/InitTweak.cc

@@ -60 +60 @@
   }
 
-  bool isInstrinsicSingleArgCallStmt( Statement * stmt ) {
-    if ( stmt == NULL ) return false;
+  Expression * getCtorDtorCall( Statement * stmt ) {
+    if ( stmt == NULL ) return NULL;
     if ( ExprStmt * exprStmt = dynamic_cast< ExprStmt * >( stmt ) ) {
-      ApplicationExpr * appExpr = dynamic_cast< ApplicationExpr * >( exprStmt->get_expr() );
-      assert( appExpr );
-      VariableExpr * function = dynamic_cast< VariableExpr * >( appExpr->get_function() );
-      assert( function );
-      // check for Intrinsic only - don't want to remove all overridable ctor/dtors because autogenerated ctor/dtor
-      // will call all member dtors, and some members may have a user defined dtor.
-      FunctionType * funcType = GenPoly::getFunctionType( function->get_var()->get_type() );
-      assert( funcType );
-      return function->get_var()->get_linkage() == LinkageSpec::Intrinsic && funcType->get_parameters().size() == 1;
+      return exprStmt->get_expr();
     } else if ( CompoundStmt * compoundStmt = dynamic_cast< CompoundStmt * >( stmt ) ) {
       // could also be a compound statement with a loop, in the case of an array
@@ -77 +69 @@
       ForStmt * forStmt = dynamic_cast< ForStmt * >( compoundStmt->get_kids().back() );
       assert( forStmt && forStmt->get_body() );
-      return isInstrinsicSingleArgCallStmt( forStmt->get_body() );
+      return getCtorDtorCall( forStmt->get_body() );
+    } if ( ImplicitCtorDtorStmt * impCtorDtorStmt = dynamic_cast< ImplicitCtorDtorStmt * > ( stmt ) ) {
+      return getCtorDtorCall( impCtorDtorStmt->get_callStmt() );
     } else {
       // should never get here
       assert( false && "encountered unknown call statement" );
+    }
+  }
+
+  bool isInstrinsicSingleArgCallStmt( Statement * stmt ) {
+    Expression * callExpr = getCtorDtorCall( stmt );
+    if ( ! callExpr ) return false;
+    ApplicationExpr * appExpr = dynamic_cast< ApplicationExpr * >( callExpr );
+    assert( appExpr );
+    VariableExpr * function = dynamic_cast< VariableExpr * >( appExpr->get_function() );
+    assert( function );
+    // check for Intrinsic only - don't want to remove all overridable ctor/dtors because autogenerated ctor/dtor
+    // will call all member dtors, and some members may have a user defined dtor.
+    FunctionType * funcType = GenPoly::getFunctionType( function->get_var()->get_type() );
+    assert( funcType );
+    return function->get_var()->get_linkage() == LinkageSpec::Intrinsic && funcType->get_parameters().size() == 1;
+  }
+
+  namespace {
+    template<typename CallExpr>
+    Expression * callArg( CallExpr * callExpr, unsigned int pos ) {
+      if ( pos >= callExpr->get_args().size() ) assert( false && "asking for argument that doesn't exist. Return NULL/throw exception?" );
+      for ( Expression * arg : callExpr->get_args() ) {
+        if ( pos == 0 ) return arg;
+        pos--;
+      }
+      assert( false );
+    }
+  }
+
+  Expression * getCallArg( Expression * callExpr, unsigned int pos ) {
+    if ( ApplicationExpr * appExpr = dynamic_cast< ApplicationExpr * >( callExpr ) ) {
+      return callArg( appExpr, pos );
+    } else if ( UntypedExpr * untypedExpr = dynamic_cast< UntypedExpr * >( callExpr ) ) {
+      return callArg( untypedExpr, pos );
+    } else {
+      assert( false && "Unexpected expression type passed to getCallArg" );
     }
   }

src/InitTweak/InitTweak.h

@@ -40 +40 @@
   bool isInstrinsicSingleArgCallStmt( Statement * expr );
 
+  /// get the Ctor/Dtor call expression from a Statement that looks like a generated ctor/dtor call
+  Expression * getCtorDtorCall( Statement * stmt );
+
   /// returns the name of the function being called
-  std::string getFunctionName(Expression * expr);
+  std::string getFunctionName( Expression * expr );
+
+  /// returns the argument to a call expression in position N indexed from 0
+  Expression * getCallArg( Expression * callExpr, unsigned int pos );
 } // namespace