Changes in src/CodeGen/CodeGenerator.cc [e04ef3a:888cbe4]

File:

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

src/CodeGen/CodeGenerator.cc

@@ -26 +26 @@
 #include "SynTree/Statement.h"
 #include "SynTree/Type.h"
+#include "SynTree/Attribute.h"
 
 #include "Common/utility.h"
@@ -33 +34 @@
 #include "OperatorTable.h"
 #include "GenType.h"
+
+#include "InitTweak/InitTweak.h"
 
 using namespace std;
@@ -45 +48 @@
         }
 
-        ostream & CodeGenerator::Indenter::operator()( ostream & output ) {
+        ostream & CodeGenerator::Indenter::operator()( ostream & output ) const {
           return output << string( cg.cur_indent, ' ' );
         }
 
-        ostream & operator<<( ostream & output, CodeGenerator::Indenter &indent ) {
+        ostream & operator<<( ostream & output, const CodeGenerator::Indenter &indent ) {
                 return indent( output );
         }
 
-        CodeGenerator::CodeGenerator( std::ostream &os ) : indent( *this), cur_indent( 0 ), insideFunction( false ), output( os ) { }
+        CodeGenerator::LabelPrinter & CodeGenerator::LabelPrinter::operator()( std::list< Label > & l ) {
+                labels = &l;
+                return *this;
+        }
+
+        ostream & operator<<( ostream & output, CodeGenerator::LabelPrinter &printLabels ) {
+                std::list< Label > & labs = *printLabels.labels;
+                // l.unique(); // assumes a sorted list. Why not use set? Does order matter?
+                for ( Label & l : labs ) {
+                        output << l.get_name() + ": ";
+                        printLabels.cg.genAttributes( l.get_attributes() );
+                }
+                return output;
+        }
+
+        CodeGenerator::CodeGenerator( std::ostream &os ) : indent( *this), cur_indent( 0 ), insideFunction( false ), output( os ), printLabels( *this ) { }
 
         CodeGenerator::CodeGenerator( std::ostream &os, std::string init, int indentation, bool infunp )
-                        : indent( *this), cur_indent( indentation ), insideFunction( infunp ), output( os ) {
+                        : indent( *this), cur_indent( indentation ), insideFunction( infunp ), output( os ), printLabels( *this ) {
                 //output << std::string( init );
         }
 
         CodeGenerator::CodeGenerator( std::ostream &os, char *init, int indentation, bool infunp )
-                        : indent( *this ), cur_indent( indentation ), insideFunction( infunp ), output( os ) {
+                        : indent( *this ), cur_indent( indentation ), insideFunction( infunp ), output( os ), printLabels( *this ) {
                 //output << std::string( init );
         }
@@ -74 +92 @@
         }
 
+        void CodeGenerator::genAttributes( std::list< Attribute * > & attributes ) {
+                if ( ! attributes.empty() ) {
+                        output << "__attribute__ ((";
+                        for ( Attribute *& attr : attributes ) {
+                                if ( ! attr->empty() ) {
+                                        output << attr->get_name() << "(";
+                                        genCommaList( attr->get_parameters().begin(), attr->get_parameters().end() );
+                                        output << ")";
+                                }
+                                output << ",";
+                        }
+                        output << ")) ";
+                }
+        }
+
+
         //*** Declarations
         void CodeGenerator::visit( FunctionDecl *functionDecl ) {
-                // generalize this
-                FunctionDecl::Attribute attr = functionDecl->get_attribute();
-                switch ( attr.type ) {
-                        case FunctionDecl::Attribute::Constructor:
-                                output << "__attribute__ ((constructor";
-                                if ( attr.priority != FunctionDecl::Attribute::Default ) {
-                                        output << "(" << attr.priority << ")";
-                                }
-                                output << ")) ";
-                                break;
-                        case FunctionDecl::Attribute::Destructor:
-                                output << "__attribute__ ((destructor";
-                                if ( attr.priority != FunctionDecl::Attribute::Default ) {
-                                        output << "(" << attr.priority << ")";
-                                }
-                                output << ")) ";
-                                break;
-                        default:
-                                break;
-                }
+                genAttributes( functionDecl->get_attributes() );
+
                 handleStorageClass( functionDecl );
                 if ( functionDecl->get_isInline() ) {
@@ -270 +286 @@
                                                         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
@@ -298 +318 @@
                                         if ( applicationExpr->get_args().size() == 1 ) {
                                                 // the expression fed into a single parameter constructor or destructor
-                                                // may contain side effects - output as a void expression
-                                                output << "((void)(";
+                                                // may contain side effects, so must still output this expression
+                                                output << "(";
                                                 (*arg++)->accept( *this );
-                                                output << ")) /* " << opInfo.inputName << " */";
+                                                output << ") /* " << opInfo.inputName << " */";
                                         } else if ( applicationExpr->get_args().size() == 2 ) {
                                                 // intrinsic two parameter constructors are essentially bitwise assignment
@@ -384 +404 @@
                                         if ( untypedExpr->get_args().size() == 1 ) {
                                                 // the expression fed into a single parameter constructor or destructor
-                                                // may contain side effects - output as a void expression
-                                                output << "((void)(";
+                                                // may contain side effects, so must still output this expression
+                                                output << "(";
                                                 (*arg++)->accept( *this );
-                                                output << ")) /* " << opInfo.inputName << " */";
+                                                output << ") /* " << opInfo.inputName << " */";
                                         } else if ( untypedExpr->get_args().size() == 2 ) {
                                                 // intrinsic two parameter constructors are essentially bitwise assignment
@@ -626 +646 @@
 
         void CodeGenerator::visit( ExprStmt *exprStmt ) {
-                // I don't see why this check is necessary.
-                // If this starts to cause problems then put it back in,
-                // with an explanation
                 assert( exprStmt );
-
-                // if ( exprStmt != 0 ) {
-                exprStmt->get_expr()->accept( *this );
-                output << ";" ;
-                // } // if
+                // cast the top-level expression to void to reduce gcc warnings.
+                Expression * expr = new CastExpr( exprStmt->get_expr() );
+                expr->accept( *this );
+                output << ";";
         }
 
@@ -743 +759 @@
 
         void CodeGenerator::visit( WhileStmt *whileStmt ) {
-                if ( whileStmt->get_isDoWhile() )
+                if ( whileStmt->get_isDoWhile() ) {
                         output << "do" ;
-                else {
+                } else {
                         output << "while (" ;
                         whileStmt->get_condition()->accept( *this );
@@ -769 +785 @@
                 output << "for (;";
 
-                if ( forStmt->get_condition() != 0 )
+                if ( forStmt->get_condition() != 0 ) {
                         forStmt->get_condition()->accept( *this );
+                }
                 output << ";";
 
-                if ( forStmt->get_increment() != 0 )
-                        forStmt->get_increment()->accept( *this );
+                if ( forStmt->get_increment() != 0 ) {
+                        // cast the top-level expression to void to reduce gcc warnings.
+                        Expression * expr = new CastExpr( forStmt->get_increment() );
+                        expr->accept( *this );
+                }
                 output << ") ";
 
@@ -794 +814 @@
                         output << ";";
                 } // if
-        }
-
-        std::string CodeGenerator::printLabels( std::list< Label > &l ) {
-                std::string str( "" );
-                l.unique(); // assumes a sorted list. Why not use set?
-
-                for ( std::list< Label >::iterator i = l.begin(); i != l.end(); i++ )
-                        str += *i + ": ";
-
-                return str;
         }