Changeset 982ed5b

Timestamp:

May 5, 2017, 1:38:42 PM (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:

805c167, c352893

Parents:

43426d4 (diff), 4f9636f (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 branches 'master' and 'master' of plg.uwaterloo.ca:software/cfa/cfa-cc

Location:

src

Files:

• CodeGen/CodeGenerator.cc (modified) (2 diffs)
• CodeGen/Generate.cc (modified) (2 diffs)
• CodeGen/Generate.h (modified) (1 diff)
• GenPoly/PolyMutator.cc (modified) (2 diffs)
• ResolvExpr/AlternativeFinder.cc (modified) (1 diff)
• SynTree/BaseSyntaxNode.h (modified) (1 diff)
• SynTree/Declaration.h (modified) (1 diff)
• SynTree/SynTree.h (modified) (1 diff)
• SynTree/TypeDecl.cc (modified) (1 diff)

src/CodeGen/CodeGenerator.cc

@@ -262 +262 @@
                         } // if
                 } else {
-                        output << typeDecl->typeString() << " " << typeDecl->get_name();
+                        output << typeDecl->genTypeString() << " " << typeDecl->get_name();
+                        if ( typeDecl->get_kind() != TypeDecl::Any && typeDecl->get_sized() ) {
+                                output << " | sized(" << typeDecl->get_name() << ")";
+                        }
                         if ( ! typeDecl->get_assertions().empty() ) {
                                 output << " | { ";
@@ -769 +772 @@
         void CodeGenerator::visit( ExprStmt * exprStmt ) {
                 assert( exprStmt );
-                // cast the top-level expression to void to reduce gcc warnings.
-                Expression * expr = new CastExpr( exprStmt->get_expr() );
+                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 );
                 output << ";";

src/CodeGen/Generate.cc

@@ -22 +22 @@
 #include "SynTree/Declaration.h"
 #include "CodeGenerator.h"
-#include "Tuples/Tuples.h"
+#include "GenType.h"
+#include "SynTree/SynTree.h"
+#include "SynTree/Type.h"
+#include "SynTree/BaseSyntaxNode.h"
+// #include "Tuples/Tuples.h"
 
 using namespace std;
@@ -39 +43 @@
                 } // for
         }
+
+        void generate( BaseSyntaxNode * node, std::ostream & os ) {
+                if ( Type * type = dynamic_cast< Type * >( node ) ) {
+                        os << CodeGen::genPrettyType( type, "" );
+                } else {
+                        CodeGen::CodeGenerator cgv( os, true, false );
+                        node->accept( cgv );
+                }
+                os << std::endl;
+        }
 } // namespace CodeGen
 

src/CodeGen/Generate.h

@@ -25 +25 @@
         /// Generates code. doIntrinsics determines if intrinsic functions are printed, pretty formats output nicely (e.g., uses unmangled names, etc.), generateC is true when the output must consist only of C code (allows some assertions, etc.)
         void generate( std::list< Declaration* > translationUnit, std::ostream &os, bool doIntrinsics, bool pretty, bool generateC = false );
+
+        /// Generate code for a single node -- helpful for debugging in gdb
+        void generate( BaseSyntaxNode * node, std::ostream & os );
 } // namespace CodeGen
 

src/GenPoly/PolyMutator.cc

@@ -50 +50 @@
 
         Statement * PolyMutator::mutateStatement( Statement *stmt ) {
+                // don't want statements from outer CompoundStmts to be added to this CompoundStmt
+                ValueGuard< std::list< Statement* > > oldStmtsToAdd( stmtsToAdd );
+                ValueGuard< std::list< Statement* > > oldStmtsToAddAfter( stmtsToAddAfter );
+                ValueGuard< TypeSubstitution * > oldEnv( env );
+                stmtsToAdd.clear();
+                stmtsToAddAfter.clear();
+
                 Statement *newStmt = maybeMutate( stmt, *this );
                 if ( ! stmtsToAdd.empty() || ! stmtsToAddAfter.empty() ) {
@@ -83 +90 @@
 
         Statement * PolyMutator::mutate(IfStmt *ifStmt) {
+                ifStmt->set_condition(  mutateExpression( ifStmt->get_condition() ) );
                 ifStmt->set_thenPart(  mutateStatement( ifStmt->get_thenPart() ) );
                 ifStmt->set_elsePart(  mutateStatement( ifStmt->get_elsePart() ) );
-                ifStmt->set_condition(  mutateExpression( ifStmt->get_condition() ) );
                 return ifStmt;
         }
 
         Statement * PolyMutator::mutate(WhileStmt *whileStmt) {
+                whileStmt->set_condition(  mutateExpression( whileStmt->get_condition() ) );
                 whileStmt->set_body(  mutateStatement( whileStmt->get_body() ) );
-                whileStmt->set_condition(  mutateExpression( whileStmt->get_condition() ) );
                 return whileStmt;
         }
 
         Statement * PolyMutator::mutate(ForStmt *forStmt) {
-                forStmt->set_body(  mutateStatement( forStmt->get_body() ) );
                 mutateAll( forStmt->get_initialization(), *this );
                 forStmt->set_condition(  mutateExpression( forStmt->get_condition() ) );
                 forStmt->set_increment(  mutateExpression( forStmt->get_increment() ) );
+                forStmt->set_body(  mutateStatement( forStmt->get_body() ) );
                 return forStmt;
         }
 
         Statement * PolyMutator::mutate(SwitchStmt *switchStmt) {
+                switchStmt->set_condition( mutateExpression( switchStmt->get_condition() ) );
                 mutateStatementList( switchStmt->get_statements() );
-                switchStmt->set_condition( mutateExpression( switchStmt->get_condition() ) );
                 return switchStmt;
         }
 
         Statement * PolyMutator::mutate(CaseStmt *caseStmt) {
+                caseStmt->set_condition(  mutateExpression( caseStmt->get_condition() ) );
                 mutateStatementList( caseStmt->get_statements() );
-                caseStmt->set_condition(  mutateExpression( caseStmt->get_condition() ) );
                 return caseStmt;
         }

src/ResolvExpr/AlternativeFinder.cc

@@ -766 +766 @@
                         } // if
                 } // for
-                // function may return struct or union value, in which case we need to add alternatives for implicit conversions to each of the anonymous members
+
+                candidates.clear();
+                candidates.splice( candidates.end(), alternatives );
+
+                findMinCost( candidates.begin(), candidates.end(), std::back_inserter( alternatives ) );
+
+                // function may return struct or union value, in which case we need to add alternatives for implicit
+                // conversions to each of the anonymous members, must happen after findMinCost since anon conversions
+                // are never the cheapest expression
                 for ( const Alternative & alt : alternatives ) {
                         addAnonConversions( alt );
                 }
-
-                candidates.clear();
-                candidates.splice( candidates.end(), alternatives );
-
-                findMinCost( candidates.begin(), candidates.end(), std::back_inserter( alternatives ) );
 
                 if ( alternatives.empty() && targetType && ! targetType->isVoid() ) {

src/SynTree/BaseSyntaxNode.h

@@ -18 +18 @@
 
 #include "Common/utility.h"
+#include "Visitor.h"
 
 class BaseSyntaxNode {
   public:
         CodeLocation location;
+
+        virtual void accept( Visitor & v ) = 0; // temporary -- needs to be here so that BaseSyntaxNode is polymorphic and can be dynamic_cast
 };
 

src/SynTree/Declaration.h

@@ -204 +204 @@
 
         virtual std::string typeString() const;
+        virtual std::string genTypeString() const;
 
         virtual TypeDecl *clone() const { return new TypeDecl( *this ); }

src/SynTree/SynTree.h

@@ -21 +21 @@
 #include <map>
 #include <iostream>
+
+class BaseSyntaxNode;
 
 class Declaration;

src/SynTree/TypeDecl.cc

@@ -29 +29 @@
 }
 
+std::string TypeDecl::genTypeString() const {
+        static const std::string kindNames[] = { "otype", "dtype", "ftype", "ttype" };
+        return kindNames[ kind ];
+}
+
 std::ostream & operator<<( std::ostream & os, const TypeDecl::Data & data ) {
   return os << data.kind << ", " << data.isComplete;