Changeset 28e58fd for src/CodeGen

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

Location:

src/CodeGen

Files:

• CodeGenerator.cc (modified) (10 diffs)
• CodeGenerator.h (modified) (1 diff)
• GenType.cc (modified) (3 diffs)
• OperatorTable.cc (modified) (2 diffs)
• OperatorTable.h (modified) (2 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 << ";";
         }

src/CodeGen/CodeGenerator.h

@@ -74 +74 @@
                 virtual void visit( CommaExpr *commaExpr );
                 virtual void visit( CompoundLiteralExpr *compLitExpr );
+                virtual void visit( UniqueExpr * );
+                virtual void visit( TupleAssignExpr * tupleExpr );
                 virtual void visit( UntypedTupleExpr *tupleExpr );
                 virtual void visit( TupleExpr *tupleExpr );

src/CodeGen/GenType.cc

@@ -37 +37 @@
                 virtual void visit( PointerType *pointerType );
                 virtual void visit( ArrayType *arrayType );
+                virtual void visit( ReferenceType *refType );
                 virtual void visit( StructInstType *structInst );
                 virtual void visit( UnionInstType *unionInst );
@@ -145 +146 @@
         void GenType::visit( ArrayType *arrayType ) {
                 genArray( arrayType->get_qualifiers(), arrayType->get_base(), arrayType->get_dimension(), arrayType->get_isVarLen(), arrayType->get_isStatic() );
+        }
+
+        void GenType::visit( ReferenceType *refType ) {
+                assert( refType->get_base() != 0);
+                assertf( ! genC, "Reference types should not reach code generation." );
+                handleQualifiers( refType );
+                typeString = "&" + typeString;
+                refType->get_base()->accept( *this );
         }
 
@@ -278 +287 @@
                         typeString = "_Atomic " + typeString;
                 } // if
+                if ( type->get_lvalue() && ! genC ) {
+                        // when not generating C code, print lvalue for debugging.
+                        typeString = "lvalue " + typeString;
+                }
         }
 } // namespace CodeGen

src/CodeGen/OperatorTable.cc

@@ -14 +14 @@
 //
 
-#include <map>      // for map, _Rb_tree_const_iterator, map<>::const_iterator
-#include <utility>  // for pair
+#include <algorithm>  // for any_of
+#include <map>        // for map, _Rb_tree_const_iterator, map<>::const_iterator
+#include <utility>    // for pair
 
 #include "OperatorTable.h"
@@ -93 +94 @@
                 } // if
         }
+
+        /// determines if a given function name is one of the operator types between [begin, end)
+        template<typename Iterator>
+        bool isOperatorType( const std::string & funcName, Iterator begin, Iterator end ) {
+                OperatorInfo info;
+                if ( operatorLookup( funcName, info ) ) {
+                        return std::find( begin, end, info.type ) != end;
+                }
+                return false;
+        }
+
+        bool isConstructor( const std::string & funcName ) {
+                static OperatorType types[] = { OT_CTOR };
+                return isOperatorType( funcName, std::begin(types), std::end(types) );
+        }
+
+        bool isDestructor( const std::string & funcName ) {
+                static OperatorType types[] = { OT_DTOR };
+                return isOperatorType( funcName, std::begin(types), std::end(types) );
+        }
+
+        bool isAssignment( const std::string & funcName ) {
+                static OperatorType types[] = { OT_PREFIXASSIGN, OT_POSTFIXASSIGN, OT_INFIXASSIGN };
+                return isOperatorType( funcName, std::begin(types), std::end(types) );
+        }
+
+        bool isCtorDtor( const std::string & funcName ) {
+                static OperatorType types[] = { OT_CTOR, OT_DTOR };
+                return isOperatorType( funcName, std::begin(types), std::end(types) );
+        }
+
+        bool isCtorDtorAssign( const std::string & funcName ) {
+                static OperatorType types[] = { OT_CTOR, OT_DTOR, OT_PREFIXASSIGN, OT_POSTFIXASSIGN, OT_INFIXASSIGN };
+                return isOperatorType( funcName, std::begin(types), std::end(types) );
+        }
 } // namespace CodeGen
 

src/CodeGen/OperatorTable.h

@@ -5 +5 @@
 // file "LICENCE" distributed with Cforall.
 //
-// OperatorTable.h -- 
+// OperatorTable.h --
 //
 // Author           : Richard C. Bilson
@@ -42 +42 @@
 
         bool operatorLookup( std::string funcName, OperatorInfo &info );
+
+        bool isConstructor( const std::string & );
+        bool isDestructor( const std::string & );
+        bool isAssignment( const std::string & );
+        bool isCtorDtor( const std::string & );
+        bool isCtorDtorAssign( const std::string & );
 } // namespace CodeGen