Changeset 28e58fd for src/CodeGen/CodeGenerator.cc

Timestamp:

Aug 25, 2017, 10:38:34 AM (8 years ago)

Author:

Thierry Delisle <tdelisle@…>

Branches:

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

Children:

800d275

Parents:

af08051 (diff), 3eab308c (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

File:

• src/CodeGen/CodeGenerator.cc (modified) (10 diffs)

src/CodeGen/CodeGenerator.cc

@@ -192 +192 @@
                         genCommaList( aggDecl->get_parameters().begin(), aggDecl->get_parameters().end() );
                         output << ")" << endl;
+                        output << indent;
                 }
 
@@ -205 +206 @@
                         for ( std::list< Declaration* >::iterator i = memb.begin(); i != memb.end(); i++ ) {
                                 updateLocation( *i );
+                                output << indent;
                                 (*i)->accept( *this );
                                 output << ";" << endl;
@@ -244 +246 @@
                                 assert( obj );
                                 updateLocation( obj );
-                                output << mangleName( obj );
+                                output << indent << mangleName( obj );
                                 if ( obj->get_init() ) {
                                         output << " = ";
@@ -332 +334 @@
         void CodeGenerator::visit( __attribute__((unused)) ConstructorInit * init ){
                 assertf( ! genC, "ConstructorInit nodes should not reach code generation." );
-                // xxx - generate something reasonable for constructor/destructor pairs
-                output << "<ctorinit>";
+                // pseudo-output for constructor/destructor pairs
+                output << "<ctorinit>{" << std::endl << ++indent << "ctor: ";
+                maybeAccept( init->get_ctor(), *this );
+                output << ", " << std::endl << indent << "dtor: ";
+                maybeAccept( init->get_dtor(), *this );
+                output << std::endl << --indent << "}";
         }
 
@@ -347 +353 @@
                         if ( varExpr->get_var()->get_linkage() == LinkageSpec::Intrinsic && operatorLookup( varExpr->get_var()->get_name(), opInfo ) ) {
                                 std::list< Expression* >::iterator arg = applicationExpr->get_args().begin();
-                                switch ( opInfo.type ) {
-                                  case OT_PREFIXASSIGN:
-                                  case OT_POSTFIXASSIGN:
-                                  case OT_INFIXASSIGN:
-                                  case OT_CTOR:
-                                  case OT_DTOR:
-                                        {
-                                                assert( arg != applicationExpr->get_args().end() );
-                                                if ( AddressExpr * addrExpr = dynamic_cast< AddressExpr * >( *arg ) ) {
-                                                        // remove & from first assignment/ctor argument
-                                                        *arg = addrExpr->get_arg();
-                                                } else {
-                                                        // no address-of operator, so must be a pointer - add dereference
-                                                        // NOTE: if the assertion starts to trigger, check that the application expr isn't being shared.
-                                                        // Since its arguments are modified here, this assertion most commonly triggers when the application
-                                                        // is visited multiple times.
-                                                        UntypedExpr * newExpr = new UntypedExpr( new NameExpr( "*?" ) );
-                                                        newExpr->get_args().push_back( *arg );
-                                                        Type * type = InitTweak::getPointerBase( (*arg)->get_result() );
-                                                        assertf( type, "First argument to a derefence must be a pointer. Ensure that expressions are not being shared." );
-                                                        newExpr->set_result( type->clone() );
-                                                        *arg = newExpr;
-                                                } // if
-                                                break;
-                                        }
-
-                                  default:
-                                        // do nothing
-                                        ;
-                                } // switch
-
                                 switch ( opInfo.type ) {
                                   case OT_INDEX:
@@ -584 +559 @@
                 if ( castExpr->get_result()->isVoid() ) {
                         output << "(void)" ;
-                } else if ( ! castExpr->get_result()->get_lvalue() ) {
-                        // at least one result type of cast, but not an lvalue
+                } else {
+                        // at least one result type of cast.
+                        // Note: previously, lvalue casts were skipped. Since it's now impossible for the user to write
+                        // an lvalue cast, this has been taken out.
                         output << "(";
                         output << genType( castExpr->get_result(), "", pretty, genC );
                         output << ")";
-                } else {
-                        // otherwise, the cast is to an lvalue type, so the cast should be dropped, since the result of a cast is
-                        // never an lvalue in C
                 } // if
                 castExpr->get_arg()->accept( *this );
@@ -706 +680 @@
                 extension( commaExpr );
                 output << "(";
+                if ( genC ) {
+                        // arg1 of a CommaExpr is never used, so it can be safely cast to void to reduce gcc warnings.
+                        commaExpr->set_arg1( new CastExpr( commaExpr->get_arg1() ) );
+                }
                 commaExpr->get_arg1()->accept( *this );
                 output << " , ";
                 commaExpr->get_arg2()->accept( *this );
                 output << ")";
+        }
+
+        void CodeGenerator::visit( TupleAssignExpr * tupleExpr ) {
+                assertf( ! genC, "TupleAssignExpr should not reach code generation." );
+                tupleExpr->stmtExpr->accept( *this );
         }
 
@@ -759 +742 @@
                 output << "(" << genType( compLitExpr->get_result(), "", pretty, genC ) << ")";
                 compLitExpr->get_initializer()->accept( *this );
+        }
+
+        void CodeGenerator::visit( UniqueExpr * unqExpr ) {
+                assertf( ! genC, "Unique expressions should not reach code generation." );
+                output << "unq<" << unqExpr->get_id() << ">{ ";
+                unqExpr->get_expr()->accept( *this );
+                output << " }";
         }
 
@@ -770 +760 @@
                 for ( Statement * stmt : stmts ) {
                         updateLocation( stmt );
-            output << printLabels( stmt->get_labels() );
+                        output << printLabels( stmt->get_labels() );
                         if ( i+1 == numStmts ) {
                                 // last statement in a statement expression needs to be handled specially -
@@ -815 +805 @@
         void CodeGenerator::visit( ExprStmt * exprStmt ) {
                 assert( exprStmt );
-                Expression * expr = exprStmt->get_expr();
                 if ( genC ) {
                         // cast the top-level expression to void to reduce gcc warnings.
-                        expr = new CastExpr( expr );
-                }
-                expr->accept( *this );
+                        exprStmt->set_expr( new CastExpr( exprStmt->get_expr() ) );
+                }
+                exprStmt->get_expr()->accept( *this );
                 output << ";";
         }