Changeset e39241b for src

Timestamp:

Apr 17, 2017, 5:43:01 PM (8 years ago)

Author:

Rob Schluntz <rschlunt@…>

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:

7069652

Parents:

4ae83a4b

Message:

allow codegen as an alternative to AST dump after any pass with the -z option

Location:

src

Files:

• CodeGen/CodeGenerator.cc (modified) (16 diffs)
• CodeGen/CodeGenerator.h (modified) (2 diffs)
• CodeGen/GenType.cc (modified) (8 diffs)
• CodeGen/GenType.h (modified) (1 diff)
• CodeGen/Generate.cc (modified) (1 diff)
• CodeGen/Generate.h (modified) (1 diff)
• SynTree/Declaration.h (modified) (3 diffs)
• main.cc (modified) (4 diffs)
• tests/.expect/memberCtors-ERR1.txt (modified) (1 diff)

src/CodeGen/CodeGenerator.cc

@@ -89 +89 @@
         }
 
-        CodeGenerator::CodeGenerator( std::ostream & os, bool pretty ) : indent( *this), cur_indent( 0 ), insideFunction( false ), output( os ), printLabels( *this ), pretty( pretty ) {}
+        CodeGenerator::CodeGenerator( std::ostream & os, bool pretty, bool genC ) : indent( *this), cur_indent( 0 ), insideFunction( false ), output( os ), printLabels( *this ), pretty( pretty ), genC( genC ) {}
 
         CodeGenerator::CodeGenerator( std::ostream & os, std::string init, int indentation, bool infunp )
@@ -136 +136 @@
                 functionDecl->get_funcSpec().print( output );
 
-                output << genType( functionDecl->get_functionType(), mangleName( functionDecl ), pretty );
+                output << genType( functionDecl->get_functionType(), mangleName( functionDecl ), pretty, genC );
 
                 asmName( functionDecl );
@@ -147 +147 @@
 
         void CodeGenerator::visit( ObjectDecl * objectDecl ) {
-                if (objectDecl->get_name().empty()) {
+                if (objectDecl->get_name().empty() && genC ) {
+                        // only generate an anonymous name when generating C code, otherwise it clutters the output too much
                         static UniqueName name = { "__anonymous_object" };
                         objectDecl->set_name( name.newName() );
@@ -156 +157 @@
 
                 handleStorageClass( objectDecl );
-                output << genType( objectDecl->get_type(), mangleName( objectDecl ), pretty );
+                output << genType( objectDecl->get_type(), mangleName( objectDecl ), pretty, genC );
 
                 asmName( objectDecl );
@@ -174 +175 @@
                 genAttributes( aggDecl->get_attributes() );
 
+                if( ! aggDecl->get_parameters().empty() && ! genC ) {
+                        // assertf( ! genC, "Aggregate type parameters should not reach code generation." );
+                        output << "forall(";
+                        genCommaList( aggDecl->get_parameters().begin(), aggDecl->get_parameters().end() );
+                        output << ")" << endl;
+                }
+
                 if ( aggDecl->get_name() != "" )
                         output << aggDecl->get_name();
 
-                // std::list< Declaration * > & memb = aggDecl->get_members();
-                // if ( ! memb.empty() ) {
                 if ( aggDecl->has_body() ) {
                         std::list< Declaration * > & memb = aggDecl->get_members();
@@ -242 +248 @@
 
         void CodeGenerator::visit( TypedefDecl * typeDecl ) {
-                assert( false && "Typedefs are removed and substituted in earlier passes." );
-                //output << "typedef ";
-                //output << genType( typeDecl->get_base(), typeDecl->get_name(), pretty );
+                assertf( ! genC, "Typedefs are removed and substituted in earlier passes." );
+                output << "typedef ";
+                output << genType( typeDecl->get_base(), typeDecl->get_name(), pretty, genC ) << endl;
         }
 
         void CodeGenerator::visit( TypeDecl * typeDecl ) {
-                // really, we should mutate this into something that isn't a TypeDecl but that requires large-scale changes,
-                // still to be done
-                extension( typeDecl );
-                output << "extern unsigned long " << typeDecl->get_name();
-                if ( typeDecl->get_base() ) {
-                        output << " = sizeof( " << genType( typeDecl->get_base(), "", pretty ) << " )";
-                } // if
+                if ( genC ) {
+                        // really, we should mutate this into something that isn't a TypeDecl but that requires large-scale changes,
+                        // still to be done
+                        extension( typeDecl );
+                        output << "extern unsigned long " << typeDecl->get_name();
+                        if ( typeDecl->get_base() ) {
+                                output << " = sizeof( " << genType( typeDecl->get_base(), "", pretty, genC ) << " )";
+                        } // if
+                } else {
+                        output << typeDecl->typeString() << " " << typeDecl->get_name();
+                        if ( ! typeDecl->get_assertions().empty() ) {
+                                output << " | { ";
+                                genCommaList( typeDecl->get_assertions().begin(), typeDecl->get_assertions().end() );
+                                output << " }";
+                        }
+                }
         }
 
@@ -293 +308 @@
 
         void CodeGenerator::visit( ConstructorInit * init ){
-                assertf( false, "ConstructorInit nodes should not make it to CodeGen." );
+                assertf( ! genC, "ConstructorInit nodes should not reach code generation." );
+                // xxx - generate something reasonable for constructor/destructor pairs
+                output << "<ctorinit>";
         }
 
@@ -547 +564 @@
                         // at least one result type of cast, but not an lvalue
                         output << "(";
-                        output << genType( castExpr->get_result(), "", pretty );
+                        output << genType( castExpr->get_result(), "", pretty, genC );
                         output << ")";
                 } else {
@@ -558 +575 @@
 
         void CodeGenerator::visit( UntypedMemberExpr * memberExpr ) {
-                assert( false );
+                assertf( ! genC, "UntypedMemberExpr should not reach code generation." );
+                extension( memberExpr );
+                memberExpr->get_aggregate()->accept( *this );
+                output << "." << memberExpr->get_member();
         }
 
@@ -587 +607 @@
                 output << "sizeof(";
                 if ( sizeofExpr->get_isType() ) {
-                        output << genType( sizeofExpr->get_type(), "", pretty );
+                        output << genType( sizeofExpr->get_type(), "", pretty, genC );
                 } else {
                         sizeofExpr->get_expr()->accept( *this );
@@ -599 +619 @@
                 output << "__alignof__(";
                 if ( alignofExpr->get_isType() ) {
-                        output << genType( alignofExpr->get_type(), "", pretty );
+                        output << genType( alignofExpr->get_type(), "", pretty, genC );
                 } else {
                         alignofExpr->get_expr()->accept( *this );
@@ -607 +627 @@
 
         void CodeGenerator::visit( UntypedOffsetofExpr * offsetofExpr ) {
-                assert( false && "UntypedOffsetofExpr should not reach code generation." );
+                assertf( ! genC, "UntypedOffsetofExpr should not reach code generation." );
+                output << "offsetof(";
+                output << genType( offsetofExpr->get_type(), "", pretty, genC );
+                output << ", " << offsetofExpr->get_member();
+                output << ")";
         }
 
@@ -613 +637 @@
                 // use GCC builtin
                 output << "__builtin_offsetof(";
-                output << genType( offsetofExpr->get_type(), "", pretty );
+                output << genType( offsetofExpr->get_type(), "", pretty, genC );
                 output << ", " << mangleName( offsetofExpr->get_member() );
                 output << ")";
@@ -619 +643 @@
 
         void CodeGenerator::visit( OffsetPackExpr * offsetPackExpr ) {
-                assert( false && "OffsetPackExpr should not reach code generation." );
+                assertf( ! genC, "OffsetPackExpr should not reach code generation." );
+                output << "__CFA_offsetpack(" << genType( offsetPackExpr->get_type(), "", pretty, genC ) << ")";
         }
 
@@ -655 +680 @@
         }
 
-        void CodeGenerator::visit( UntypedTupleExpr * tupleExpr ) { assertf( false, "UntypedTupleExpr should not make it to Code Gen" ); }
-
-        void CodeGenerator::visit( TupleExpr * tupleExpr ) { assertf( false, "TupleExpr should not make it to Code Gen" ); }
-
-        void CodeGenerator::visit( TypeExpr * typeExpr ) {}
+        void CodeGenerator::visit( UntypedTupleExpr * tupleExpr ) {
+                assertf( ! genC, "UntypedTupleExpr should not reach code generation." );
+                output << "[";
+                genCommaList( tupleExpr->get_exprs().begin(), tupleExpr->get_exprs().end() );
+                output << "]";
+        }
+
+        void CodeGenerator::visit( TupleExpr * tupleExpr ) {
+                assertf( ! genC, "TupleExpr should not reach code generation." );
+                output << "[";
+                genCommaList( tupleExpr->get_exprs().begin(), tupleExpr->get_exprs().end() );
+                output << "]";
+        }
+
+        void CodeGenerator::visit( TypeExpr * typeExpr ) {
+                assertf( ! genC, "TypeExpr should not reach code generation." );
+                output<< genType( typeExpr->get_type(), "", pretty, genC );
+        }
 
         void CodeGenerator::visit( AsmExpr * asmExpr ) {
@@ -675 +713 @@
         void CodeGenerator::visit( CompoundLiteralExpr *compLitExpr ) {
                 assert( compLitExpr->get_result() && dynamic_cast< ListInit * > ( compLitExpr->get_initializer() ) );
-                output << "(" << genType( compLitExpr->get_result(), "", pretty ) << ")";
+                output << "(" << genType( compLitExpr->get_result(), "", pretty, genC ) << ")";
                 compLitExpr->get_initializer()->accept( *this );
         }

src/CodeGen/CodeGenerator.h

@@ -30 +30 @@
                 static int tabsize;
 
-                CodeGenerator( std::ostream &os, bool pretty = false );
+                CodeGenerator( std::ostream &os, bool pretty = false, bool genC = false );
                 CodeGenerator( std::ostream &os, std::string, int indent = 0, bool infun = false );
                 CodeGenerator( std::ostream &os, char *, int indent = 0, bool infun = false );
@@ -121 +121 @@
                 LabelPrinter printLabels;
                 bool pretty = false;  // pretty print
+                bool genC = false;    // true if output has to be C code
 
                 void printDesignators( std::list< Expression * > & );

src/CodeGen/GenType.cc

@@ -28 +28 @@
         class GenType : public Visitor {
           public:
-                GenType( const std::string &typeString, bool pretty = false );
+                GenType( const std::string &typeString, bool pretty = false, bool genC = false );
                 std::string get_typeString() const { return typeString; }
                 void set_typeString( const std::string &newValue ) { typeString = newValue; }
@@ -48 +48 @@
           private:
                 void handleQualifiers( Type *type );
+                std::string handleGeneric( ReferenceToType * refType );
                 void genArray( const Type::Qualifiers &qualifiers, Type *base, Expression *dimension, bool isVarLen, bool isStatic );
 
                 std::string typeString;
                 bool pretty = false; // pretty print
+                bool genC = false;   // generating C code?
         };
 
-        std::string genType( Type *type, const std::string &baseString, bool pretty ) {
-                GenType gt( baseString, pretty );
+        std::string genType( Type *type, const std::string &baseString, bool pretty, bool genC ) {
+                GenType gt( baseString, pretty, genC );
                 std::ostringstream os;
 
                 if ( ! type->get_attributes().empty() ) {
-                        CodeGenerator cg( os, pretty );
+                        CodeGenerator cg( os, pretty, genC );
                         cg.genAttributes( type->get_attributes() );
                 } // if
@@ -68 +70 @@
 
   std::string genPrettyType( Type * type, const std::string & baseString ) {
-        return genType( type, baseString, true );
+        return genType( type, baseString, true, false );
   }
 
-        GenType::GenType( const std::string &typeString, bool pretty ) : typeString( typeString ), pretty( pretty ) {}
+        GenType::GenType( const std::string &typeString, bool pretty, bool genC ) : typeString( typeString ), pretty( pretty ), genC( genC ) {}
 
         void GenType::visit( VoidType *voidType ) {
@@ -112 +114 @@
                 } // if
                 if ( dimension != 0 ) {
-                        CodeGenerator cg( os, pretty );
+                        CodeGenerator cg( os, pretty, genC );
                         dimension->accept( cg );
                 } else if ( isVarLen ) {
@@ -166 +168 @@
                         } // if
                 } else {
-                        CodeGenerator cg( os, pretty );
+                        CodeGenerator cg( os, pretty, genC );
                         os << "(" ;
 
@@ -186 +188 @@
         }
 
+        std::string GenType::handleGeneric( ReferenceToType * refType ) {
+                if ( ! refType->get_parameters().empty() ) {
+                        std::ostringstream os;
+                        CodeGenerator cg( os, pretty, genC );
+                        os << "(";
+                        cg.genCommaList( refType->get_parameters().begin(), refType->get_parameters().end() );
+                        os << ") ";
+                        return os.str();
+                }
+                return "";
+        }
+
         void GenType::visit( StructInstType *structInst )  {
-                typeString = "struct " + structInst->get_name() + " " + typeString;
+                typeString = structInst->get_name() + handleGeneric( structInst ) + " " + typeString;
+                if ( genC ) typeString = "struct " + typeString;
                 handleQualifiers( structInst );
         }
 
         void GenType::visit( UnionInstType *unionInst ) {
-                typeString = "union " + unionInst->get_name() + " " + typeString;
+                typeString = unionInst->get_name() + handleGeneric( unionInst ) + " " + typeString;
+                if ( genC ) typeString = "union " + typeString;
                 handleQualifiers( unionInst );
         }
 
         void GenType::visit( EnumInstType *enumInst ) {
-                typeString = "enum " + enumInst->get_name() + " " + typeString;
+                typeString = enumInst->get_name() + " " + typeString;
+                if ( genC ) typeString = "enum " + typeString;
                 handleQualifiers( enumInst );
         }
@@ -207 +224 @@
 
         void GenType::visit( TupleType * tupleType ) {
-                assertf( pretty, "Tuple types should not make it to Code Gen." );
+                assertf( ! genC, "Tuple types should not reach code generation." );
                 Visitor::visit( tupleType );
                 unsigned int i = 0;
@@ -214 +231 @@
                 for ( Type * t : *tupleType ) {
                         i++;
-                        os << genType( t, "", pretty ) << (i == tupleType->size() ? "" : ", ");
+                        os << genType( t, "", pretty, genC ) << (i == tupleType->size() ? "" : ", ");
                 }
                 os << "]";

src/CodeGen/GenType.h

@@ -21 +21 @@
 
 namespace CodeGen {
-        std::string genType( Type *type, const std::string &baseString, bool pretty = false );
+        std::string genType( Type *type, const std::string &baseString, bool pretty = false, bool genC = false );
   std::string genPrettyType( Type * type, const std::string & baseString );
 } // namespace CodeGen

src/CodeGen/Generate.cc

@@ -27 +27 @@
 
 namespace CodeGen {
-        void generate( std::list< Declaration* > translationUnit, std::ostream &os, bool doIntrinsics, bool pretty ) {
-                CodeGen::CodeGenerator cgv( os, pretty );
+        void generate( std::list< Declaration* > translationUnit, std::ostream &os, bool doIntrinsics, bool pretty, bool generateC ) {
+                CodeGen::CodeGenerator cgv( os, pretty, generateC );
                 for ( auto & dcl : translationUnit ) {
                         if ( LinkageSpec::isGeneratable( dcl->get_linkage() ) && (doIntrinsics || ! LinkageSpec::isBuiltin( dcl->get_linkage() ) ) ) {

src/CodeGen/Generate.h

@@ -23 +23 @@
 
 namespace CodeGen {
-        /// Generates code
-        void generate( std::list< Declaration* > translationUnit, std::ostream &os, bool doIntrinsics, bool pretty );
+        /// 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 );
 } // namespace CodeGen
 

src/SynTree/Declaration.h

@@ -167 +167 @@
         std::list< DeclarationWithType* >& get_assertions() { return assertions; }
 
+        virtual std::string typeString() const = 0;
+
         virtual NamedTypeDecl *clone() const = 0;
         virtual void print( std::ostream &os, int indent = 0 ) const;
         virtual void printShort( std::ostream &os, int indent = 0 ) const;
   protected:
-        virtual std::string typeString() const = 0;
   private:
         Type *base;
@@ -202 +203 @@
         TypeDecl * set_sized( bool newValue ) { sized = newValue; return this; }
 
+        virtual std::string typeString() const;
+
         virtual TypeDecl *clone() const { return new TypeDecl( *this ); }
         virtual void accept( Visitor &v ) { v.visit( this ); }
         virtual TypeDecl *acceptMutator( Mutator &m ) { return m.mutate( this ); }
   private:
-        virtual std::string typeString() const;
         Kind kind;
         bool sized;
@@ -217 +219 @@
         TypedefDecl( const TypedefDecl &other ) : Parent( other ) {}
 
+        virtual std::string typeString() const;
+
         virtual TypedefDecl *clone() const { return new TypedefDecl( *this ); }
         virtual void accept( Visitor &v ) { v.visit( this ); }
         virtual Declaration *acceptMutator( Mutator &m ) { return m.mutate( this ); }
   private:
-        virtual std::string typeString() const;
 };
 

src/main.cc

@@ -304 +304 @@
                 GenPoly::box( translationUnit );
 
-                // print tree right before code generation
-                if ( codegenp ) {
-                        dump( translationUnit );
-                        return 0;
-                } // if
-
                 if ( optind < argc ) {                                                  // any commands after the flags and input file ? => output file name
                         output = new ofstream( argv[ optind ] );
                 } // if
 
-                CodeGen::generate( translationUnit, *output, ! noprotop, prettycodegenp );
+                CodeGen::generate( translationUnit, *output, ! noprotop, prettycodegenp, true );
 
                 CodeGen::FixMain::fix( *output, treep ? "../prelude/bootloader.c" : CFA_LIBDIR "/bootloader.c" );
@@ -393 +387 @@
                         break;
                   case CtorInitFix:
-                  case 'c':
+                  case 'c':                                                                             // print after constructors and destructors are replaced
                         ctorinitp = true;
                         break;
@@ -450 +444 @@
                         validp = true;
                         break;
-                  case 'y':
+                  case 'y':                                                                             // dump AST on error
                         errorp = true;
                         break;
-                  case 'z':
+                  case 'z':                                                                             // dump as codegen rather than AST
                         codegenp = true;
-                        case 'Z':
+                        break;
+                        case 'Z':                                                                       // prettyprint during codegen (i.e. print unmangled names, etc.)
                         prettycodegenp = true;
                         break;
@@ -501 +496 @@
         } // if
 
-        printAll( decls, out );
+        // depending on commandline options, either generate code or dump the AST
+        if ( codegenp ) {
+                CodeGen::generate( decls, out, ! noprotop, prettycodegenp );
+        } else {
+                printAll( decls, out );
+        }
         deleteAll( translationUnit );
 } // dump

src/tests/.expect/memberCtors-ERR1.txt

@@ -1 @@
-memberCtors.c:62 error: in void ?{}(struct B *b), field a2 used before being constructed
+memberCtors.c:62 error: in void ?{}(B *b), field a2 used before being constructed
 make: *** [memberCtors-ERR1] Error 1