source: src/CodeGen/CodeGenerator.cpp @ 9b55aa3

//
// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo
//
// The contents of this file are covered under the licence agreement in the
// file "LICENCE" distributed with Cforall.
//
// CodeGenerator.cpp --
//
// Author           : Andrew Beach
// Created On       : Tue Oct 17 15:54:00 2023
// Last Modified By : Andrew Beach
// Last Modified On : Wed Oct 25 18:28:00 2023
// Update Count     : 0
//

#include "CodeGenerator.hpp"

#include "AST/Print.hpp"
#include "OperatorTable.hpp"         // for OperatorInfo, operatorLookup
#include "CodeGen/GenType.hpp"       // for genType
#include "Common/ToString.hpp"       // for toString
#include "Common/UniqueName.hpp"     // for UniqueName

namespace CodeGen {

int CodeGenerator::tabsize = 4;

// The kinds of statements that should be followed by whitespace.
static bool wantSpacing( ast::Stmt const * stmt ) {
        return dynamic_cast<ast::IfStmt const *>( stmt )
                || dynamic_cast<ast::CompoundStmt const *>( stmt )
                || dynamic_cast<ast::WhileDoStmt const *>( stmt )
                || dynamic_cast<ast::ForStmt const *>( stmt )
                || dynamic_cast<ast::SwitchStmt const *>( stmt );
}

void CodeGenerator::extension( ast::Expr const * expr ) {
        if ( expr->extension ) output << "__extension__ ";
}

void CodeGenerator::extension( ast::Decl const * decl ) {
        if ( decl->extension ) output << "__extension__ ";
}

void CodeGenerator::asmName( ast::DeclWithType const * decl ) {
        if ( auto asmName = decl->asmName.as<ast::ConstantExpr>() ) {
                output << " asm ( " << asmName->rep << " )";
        }
}

CodeGenerator::LabelPrinter & CodeGenerator::LabelPrinter::operator()(
                std::vector<ast::Label> const & l ) {
        labels = &l;
        return *this;
}

std::ostream & CodeGenerator::LabelPrinter::operator()( std::ostream & output ) const {
        const std::vector<ast::Label> & labels = *this->labels;
        for ( const ast::Label & label : labels ) {
                output << label.name + ": ";
                this->cg.genAttributes( label.attributes );
        }
        return output;
}

// Using updateLocation at the beginning of a node and endl within a node
// should become the method of formating.
void CodeGenerator::updateLocation( CodeLocation const & to ) {
        // Skip if linemarks shouldn't appear or if location is unset.
        if ( !options.lineMarks || to.isUnset() ) return;

        if ( currentLocation.followedBy( to, 0 ) ) {
                return;
        } else if ( currentLocation.followedBy( to, 1 ) ) {
                output << "\n" << indent;
                currentLocation.first_line += 1;
        } else if ( currentLocation.followedBy( to, 2 ) ) {
                output << "\n\n" << indent;
                currentLocation.first_line += 2;
        } else {
                output << "\n# " << to.first_line << " \"" << to.filename.c_str()
                       << "\"\n" << indent;
                currentLocation = to;
        }
        output << std::flush;
}

void CodeGenerator::updateLocation( ast::ParseNode const * to ) {
        updateLocation( to->location );
}

std::ostream & CodeGenerator::LineEnder::operator()( std::ostream & os ) const {
        os << "\n" << std::flush;
        cg.currentLocation.first_line++;
        return os;
}

CodeGenerator::CodeGenerator( std::ostream & os, const Options & options ) :
                indent( 0, CodeGenerator::tabsize ), output( os ),
                options( options ), printLabels( *this ), endl( *this )
{}

std::string CodeGenerator::mangleName( ast::DeclWithType const * decl ) {
        if ( !options.pretty && decl->linkage.is_mangled && decl->mangleName != "" ) {
                return decl->scopedMangleName();
        } else {
                return decl->name;
        }
}

void CodeGenerator::genAttributes(
                const std::vector<ast::ptr<ast::Attribute>> & attributes ) {
        if ( attributes.empty() ) return;
        output << "__attribute__ ((";
        for ( auto attr = attributes.begin() ;; ) {
                output << (*attr)->name;
                if ( !(*attr)->params.empty() ) {
                        output << "(";
                        genCommaList( (*attr)->params );
                        output << ")";
                }
                if ( ++attr == attributes.end() ) break;
                output << ",";
        }
        output << ")) ";
}

void CodeGenerator::previsit( ast::Node const * ) {
        // All traversal is manual.
        // TODO: Which means the ast::Pass is just providing a default no visit?
        visit_children = false;
}

void CodeGenerator::previsit( ast::ParseNode const * node ) {
        previsit( (ast::Node const *)node );
        updateLocation( node );
}

void CodeGenerator::postvisit( ast::Node const * node ) {
        std::stringstream ss;
        ast::print( ss, node );
        assertf( false, "Unhandled node reached in CodeGenerator: %s", ss.str().c_str() );
}

void CodeGenerator::previsit( ast::Expr const * expr ) {
        previsit( (ast::ParseNode const *)expr );
        GuardAction( [this, expr](){
                if ( options.printExprTypes && expr->result ) {
                        output << " /* " << genType( expr->result, "", options ) << " */ ";
                }
        } );
}

void CodeGenerator::postvisit( ast::FunctionDecl const * decl ) {
        // Deleted decls should never be used, so don't print them in C.
        if ( decl->isDeleted && options.genC ) return;
        extension( decl );
        genAttributes( decl->attributes );

        handleStorageClass( decl );
        ast::print( output, decl->funcSpec );

        Options subOptions = options;
        subOptions.anonymousUnused = decl->stmts;

        std::ostringstream acc;
        ast::Pass<CodeGenerator> subCG( acc, subOptions );
        // Add the forall clause.
        if ( !decl->type_params.empty() ) {
                assertf( !options.genC, "FunctionDecl forall should not reach code generation." );
                acc << "forall(";
                subCG.core.genCommaList( decl->type_params );
                acc << ")" << std::endl;
        }
        // The forall clause should be printed early as part of the preamble.
        output << acc.str();
        acc.str("");

        acc << mangleName( decl );

        if ( 0 == decl->params.size() ) {
                if ( !decl->type->isVarArgs ) {
                        acc << "(void)";
                } else if ( options.genC ) {
                        acc << "()";
                } else {
                        acc << "(...)";
                }
        } else {
                acc << "(";
                subCG.core.genCommaList( decl->params );
                if ( decl->type->isVarArgs ) {
                        acc << ", ...";
                }
                acc << ")";
        }

        if ( 1 == decl->returns.size() ) {
                ast::ptr<ast::Type> const & type = decl->returns[0]->get_type();
                output << genTypeNoAttr( type, acc.str(), subOptions );
        } else if ( 0 == decl->returns.size() ) {
                output << "void " + acc.str();
        } else {
                assertf( !options.genC, "Multi-return should not reach code generation." );
                ast::ptr<ast::Type> type = new ast::TupleType( copy( decl->type->returns ) );
                output << genTypeNoAttr( type, acc.str(), subOptions );
        }

        asmName( decl );

        if ( decl->stmts ) {
                decl->stmts->accept( *visitor );
        }
        if ( decl->isDeleted ) {
                output << " = void";
        }
}

ast::ObjectDecl const * CodeGenerator::postvisit(
                ast::ObjectDecl const * decl ) {
        // Deleted decls should never be used, so don't print them in C.
        if ( decl->isDeleted && options.genC ) return decl;

        // GCC allows an empty declarator (no name) for bit-fields and C
        // states: 6.7.2.1 Structure and union specifiers, point 4, page 113:
        // If the (bit field) value is zero, the declaration shall have no
        // declarator. For anything else, the anonymous name refers to the
        // anonymous object for plan9 inheritance.
        if ( decl->name.empty() && options.genC && !decl->bitfieldWidth ) {
                // TODO: Should this be changed in a pervious pass?
                auto mutDecl = ast::mutate( decl );
                // Only generate an anonymous name when generating C code,
                // otherwise it clutters the output too much.
                static UniqueName name = { "__anonymous_object" };
                mutDecl->name = name.newName();
                // Stops unused parameter warnings.
                if ( options.anonymousUnused ) {
                        mutDecl->attributes.push_back( new ast::Attribute( "unused" ) );
                }
                decl = mutDecl;
        }

        extension( decl );
        genAttributes( decl->attributes );

        handleStorageClass( decl );
        output << genType( decl->type, mangleName( decl ),
                Options( options.pretty, options.genC, false, false ) );

        asmName( decl );

        if ( decl->init ) {
                output << " = ";
                decl->init->accept( *visitor );
        }
        if ( decl->isDeleted ) {
                output << " = void";
        }

        if ( decl->bitfieldWidth ) {
                output << ":";
                decl->bitfieldWidth->accept( *visitor );
        }
        return decl;
}

void CodeGenerator::handleStorageClass( ast::DeclWithType const * decl ) {
        if ( decl->storage.any() ) {
                ast::print( output, decl->storage );
        }
}

void CodeGenerator::handleAggregate(
                ast::AggregateDecl const * decl, std::string const & kind ) {
        if ( !decl->params.empty() && !options.genC ) {
                output << "forall(";
                genCommaList( decl->params );
                output << ")\n" << indent << std::flush;
        }

        output << kind;
        genAttributes( decl->attributes );
        output << decl->name;

        if ( decl->body ) {
                auto & members = decl->members;
                output << " {" << endl;

                ++indent;
                for ( auto & member : members ) {
                        output << indent;
                        member->accept( *visitor );
                        output << ";" << endl;
                }
                --indent;

                output << indent << "}";
        }
}

void CodeGenerator::postvisit( ast::StructDecl const * decl ) {
        extension( decl );
        handleAggregate( decl, "struct " );
}

void CodeGenerator::postvisit( ast::UnionDecl const * decl ) {
        extension( decl );
        handleAggregate( decl, "union " );
}

template<typename pass_type>
inline void genEnumInitializer( ast::Pass<pass_type> * visitor,
                ast::Type const * baseType, std::ostream & output,
                ast::Init const * init, long long * curVal, Options options ) {
        auto baseTypeAsBasic = dynamic_cast<ast::BasicType const *>( baseType );
        // Value is provided.
        if ( init ) {
                output << " = (" << genType( baseType, "", options ) << ")";
                init->accept( *visitor );
                // If it is an integral type and initilizer offered,
                // need to update the curVal.
                if ( baseTypeAsBasic && baseTypeAsBasic->isInteger() ) {
                        ast::Expr const * expr = ((ast::SingleInit const *)(init))->value;
                        // Unwrap introduced cast.
                        while ( auto temp = dynamic_cast<ast::CastExpr const *>( expr ) ) {
                                expr = temp->arg;
                        }
                        *curVal = ((ast::ConstantExpr const *)(expr))->intValue() + 1;
                }
        // Generate next value from previous value.
        } else if ( baseTypeAsBasic && baseTypeAsBasic->isInteger() ) {
                output << " = (" << genType( baseType, "", options ) << ")";
                output << (*curVal)++;
        }
}

void CodeGenerator::postvisit( ast::EnumDecl const * decl ) {
        extension( decl );
        auto members = decl->members;
        // if ( decl->base && !members.empty() ) {
        //      long long curVal = 0;
        //      for ( auto member : members ) {
        //              auto obj = member.strict_as<ast::ObjectDecl>();
        //              output << "static ";
        //              output << genType( decl->base, mangleName( obj ), options );
        //              genEnumInitializer( visitor, decl->base, output, obj->init, &curVal, options );
        //              output << ";" << endl;
        //      }
        // } else {
                output << "enum ";
                genAttributes( decl->attributes );

                output << decl->name;

                if ( !members.empty() ) {
                        output << " {" << endl;

                        ++indent;
                        for ( auto member : members ) {
                                auto obj = member.strict_as<ast::ObjectDecl>();
                                output << indent << mangleName( obj );
                                if ( !decl->base && obj->init ) {
                                        output << " = ";
                                        obj->init->accept( *visitor );
                                }
                                output << "," << endl;
                        }
                        --indent;

                        output << indent << "}";
                }
        // }
}

void CodeGenerator::postvisit( ast::TraitDecl const * decl ) {
        assertf( !options.genC, "TraitDecls should not reach code generation." );
        extension( decl );
        handleAggregate( decl, "trait " );
}

void CodeGenerator::postvisit( ast::TypedefDecl const * decl ) {
        assertf( !options.genC, "Typedefs should not reach code generation." );
        output << "typedef " << genType( decl->base, decl->name, options ) << endl;
}

void CodeGenerator::postvisit( ast::TypeDecl const * decl ) {
        assertf( !options.genC, "TypeDecls should not reach code generation." );
        output << decl->genTypeString() << " " << decl->name;
        if ( decl->sized ) {
                output << " | sized(" << decl->name << ")";
        }
        if ( !decl->assertions.empty() ) {
                output << " | { ";
                for ( ast::DeclWithType const * assert : decl->assertions ) {
                        assert->accept( *visitor );
                        output << "; ";
                }
                output << " }";
        }
}

void CodeGenerator::postvisit( ast::StaticAssertDecl const * decl ) {
        output << "_Static_assert(";
        decl->cond->accept( *visitor );
        output << ", ";
        decl->msg->accept( *visitor );
        output << ")";
}

void CodeGenerator::postvisit( ast::Designation const * designation ) {
        auto designators = designation->designators;
        if ( 0 == designators.size() ) return;
        for ( ast::ptr<ast::Expr> const & des : designators ) {
                // If the expression is a NameExpr or VariableExpr, then it is a field.
                if ( des.as<ast::NameExpr>() || des.as<ast::VariableExpr>() ) {
                        output << ".";
                        des->accept( *visitor );
                // Otherwise, it is a ConstantExpr or CastExpr, then it is an index.
                } else {
                        output << "[";
                        des->accept( *visitor );
                        output << "]";
                }
        }
        output << " = ";
}

void CodeGenerator::postvisit( ast::SingleInit const * init ) {
        init->value->accept( *visitor );
}

void CodeGenerator::postvisit( ast::ListInit const * init ) {
        auto initBegin = init->initializers.begin();
        auto initEnd = init->initializers.end();
        auto desigBegin = init->designations.begin();
        auto desigEnd = init->designations.end();

        output << "{ ";
        if ( initBegin != initEnd ) while (true) {
                (*desigBegin)->accept( *visitor );
                (*initBegin)->accept( *visitor );
                ++initBegin, ++desigBegin;
                if ( initBegin == initEnd ) break;
                output << ", ";
        }
        output << " }";
        assertf( initBegin == initEnd && desigBegin == desigEnd,
                "Initializers and designators not the same length. %s", toCString( init ) );
}

void CodeGenerator::postvisit( ast::ConstructorInit const * init ) {
        assertf( !options.genC, "ConstructorInit nodes should not reach code generation." );
        // This isn't actual code, but labels the constructor/destructor pairs.
        output << "<ctorinit>{" << endl << ++indent << "ctor: ";
        if ( init->ctor ) init->ctor->accept( *visitor );
        output << ", " << endl << indent << "dtor: ";
        if ( init->dtor ) init->dtor->accept( *visitor );
        output << endl << --indent << "}";
}

void CodeGenerator::postvisit( ast::ApplicationExpr const * expr ) {
        extension( expr );
        if ( auto var = expr->func.as<ast::VariableExpr>() ) {
                const OperatorInfo * opInfo;
                if ( var->var->linkage == ast::Linkage::Intrinsic &&
                                ( opInfo = operatorLookup( var->var->name ) ) ) {
                        auto arg = expr->args.begin();
                        switch ( opInfo->type ) {
                        case OT_INDEX:
                                assert( 2 == expr->args.size() );
                                (*arg++)->accept( *visitor );
                                output << "[";
                                (*arg)->accept( *visitor );
                                output << "]";
                                break;

                        // There are no intrinsic definitions of the function call operator.
                        case OT_CALL:
                                assert( false );
                                break;

                        case OT_CTOR:
                        case OT_DTOR:
                                // No-op constructor, but run the internal expression.
                                if ( 1 == expr->args.size() ) {
                                        output << "(";
                                        (*arg++)->accept( *visitor );
                                        output << ") /* " << opInfo->inputName << " */";
                                // These are all implemented as some form of assignment.
                                } else if ( 2 == expr->args.size() ) {
                                        output << "(";
                                        (*arg++)->accept( *visitor );
                                        output << opInfo->symbol;
                                        (*arg)->accept( *visitor );
                                        output << ") /* " << opInfo->inputName << " */";
                                // No constructors with 0 or more than 2 parameters.
                                } else {
                                        assert( false );
                                }
                                break;

                        case OT_PREFIX:
                        case OT_PREFIXASSIGN:
                                assert( 1 == expr->args.size() );
                                output << "(" << opInfo->symbol;
                                (*arg)->accept( *visitor );
                                output << ")";
                                break;

                        case OT_POSTFIX:
                        case OT_POSTFIXASSIGN:
                                assert( 1 == expr->args.size() );
                                (*arg)->accept( *visitor );
                                output << opInfo->symbol;
                                break;

                        case OT_INFIX:
                        case OT_INFIXASSIGN:
                                assert( 2 == expr->args.size() );
                                output << "(";
                                (*arg++)->accept( *visitor );
                                output << opInfo->symbol;
                                (*arg)->accept( *visitor );
                                output << ")";
                                break;

                        // There are no intrinsic definitions of 0/1 or label address
                        // as function.
                        case OT_CONSTANT:
                        case OT_LABELADDRESS:
                                assert( false );
                        }
                // TODO: This is a work-around to make it a constant until a proper
                // constexpr solution is created.
                } else if ( var->var->linkage == ast::Linkage::BuiltinCFA &&
                                var->var->name == "intptr" ) {
                        output << "((void*)";
                        auto arg = expr->args.begin();
                        (*arg++)->accept( *visitor );
                        output << ")";
                } else {
                        var->accept( *visitor );
                        output << "(";
                        genCommaList( expr->args );
                        output << ")";
                }
        } else {
                expr->func->accept( *visitor );
                output << "(";
                genCommaList( expr->args );
                output << ")";
        }
}

void CodeGenerator::postvisit( ast::UntypedExpr const * expr ) {
        extension( expr );
        if ( auto name = expr->func.as<ast::NameExpr>() ) {
                if ( const OperatorInfo * opInfo = operatorLookup( name->name ) ) {
                        auto arg = expr->args.begin();
                        switch ( opInfo->type ) {
                        case OT_INDEX:
                                assert( 2 == expr->args.size() );
                                (*arg++)->accept( *visitor );
                                output << "[";
                                (*arg)->accept( *visitor );
                                output << "]";
                                break;

                        case OT_CALL:
                                assert( false );

                        case OT_CTOR:
                        case OT_DTOR:
                                // No-op constructor, but run the internal expression.
                                if ( 1 == expr->args.size() ) {
                                        output << "(";
                                        (*arg++)->accept( *visitor );
                                        output << ")";
                                // These are all implemented as some form of assignment.
                                } else if ( 2 == expr->args.size() ) {
                                        output << "(";
                                        (*arg++)->accept( *visitor );
                                        output << opInfo->symbol;
                                        (*arg)->accept( *visitor );
                                        output << ") /* " << opInfo->inputName << " */";
                                // No constructors with 0 or more than 2 parameters.
                                } else {
                                        assertf( !options.genC, "UntypedExpr constructor/destructor with 0 or more than 2 parameters." );
                                        output << "(";
                                        (*arg++)->accept( *visitor );
                                        output << opInfo->symbol << "{ ";
                                        genCommaList( arg, expr->args.end() );
                                        output << "}) /* " << opInfo->inputName << " */";
                                }
                                break;

                        case OT_PREFIX:
                        case OT_PREFIXASSIGN:
                        case OT_LABELADDRESS:
                                assert( 1 == expr->args.size() );
                                output << "(" << opInfo->symbol;
                                (*arg)->accept( *visitor );
                                output << ")";
                                break;

                        case OT_POSTFIX:
                        case OT_POSTFIXASSIGN:
                                assert( 1 == expr->args.size() );
                                (*arg)->accept( *visitor );
                                output << opInfo->symbol;
                                break;

                        case OT_INFIX:
                        case OT_INFIXASSIGN:
                                assert( 2 == expr->args.size() );
                                output << "(";
                                (*arg++)->accept( *visitor );
                                output << opInfo->symbol;
                                (*arg)->accept( *visitor );
                                output << ")";
                                break;

                        // There are no intrinsic definitions of 0/1 or label address
                        // as function.
                        case OT_CONSTANT:
                                assert( false );
                        }
                // builtin routines
                } else {
                        name->accept( *visitor );
                        output << "(";
                        genCommaList( expr->args );
                        output << ")";
                }
        } else {
                expr->func->accept( *visitor );
                output << "(";
                genCommaList( expr->args );
                output << ")";
        }
}

void CodeGenerator::postvisit( ast::RangeExpr const * expr ) {
        expr->low->accept( *visitor );
        output << " ... ";
        expr->high->accept( *visitor );
}

void CodeGenerator::postvisit( ast::NameExpr const * expr ) {
        extension( expr );
        if ( const OperatorInfo * opInfo = operatorLookup( expr->name ) ) {
                if ( OT_CONSTANT == opInfo->type ) {
                        output << opInfo->symbol;
                } else {
                        output << opInfo->outputName;
                }
        } else {
                output << expr->name;
        }
}

void CodeGenerator::postvisit( ast::DimensionExpr const * expr ) {
        extension( expr );
        output << "/*non-type*/" << expr->name;
}

void CodeGenerator::postvisit( ast::AddressExpr const * expr ) {
        extension( expr );
        output << "(&";
        expr->arg->accept( *visitor );
        output << ")";
}

void CodeGenerator::postvisit( ast::LabelAddressExpr const * expr ) {
        extension( expr );
        output << "(&&" << expr->arg << ")";
}

void CodeGenerator::postvisit( ast::CastExpr const * expr ) {
        extension( expr );
        output << "(";
        switch ( expr->kind ) {
        case ast::CCast:
                if ( expr->result->isVoid() ) {
                        output << "(void)";
                } else {
                        output << "(";
                        output << genType( expr->result, "", options );
                        output << ")";
                }
                break;
        case ast::CoerceCast:
                assertf( ast::CoerceCast != expr->kind, "Coercion cast is not implemented." );
                // And likely shouldn't reach code generation when it is implemented.
                break;
        case ast::ReturnCast:
                // This should be invisible in the resulting C code.
                // Can we insert a check here?
                //assert( ResolvExpr::typesCompatable(???) );
                if ( options.genC ) break;
                output << "(return ";
                output << genType( expr->result, "", options );
                output << ")";
                break;
        }
        expr->arg->accept( *visitor );
        output << ")";
}

void CodeGenerator::postvisit( ast::KeywordCastExpr const * expr ) {
        assertf( !options.genC, "KeywordCastExpr should not reach code generation." );
        extension( expr );
        output << "((" << expr->targetString() << " &)";
        expr->arg->accept( *visitor );
        output << ")";
}

void CodeGenerator::postvisit( ast::VirtualCastExpr const * expr ) {
        assertf( !options.genC, "VirtualCastExpr should not reach code generation." );
        extension( expr );
        // TODO: Is this busted?
        output << "(virtual ";
        expr->arg->accept( *visitor );
        output << ")";
}

void CodeGenerator::postvisit( ast::UntypedMemberExpr const * expr ) {
        assertf( !options.genC, "UntypedMemberExpr should not reach code generation." );
        extension( expr );
        expr->aggregate->accept( *visitor );
        output << ".";
        expr->member->accept( *visitor );
}

void CodeGenerator::postvisit( ast::MemberExpr const * expr ) {
        extension( expr );
        expr->aggregate->accept( *visitor );
        output << "." << mangleName( expr->member );
}

void CodeGenerator::postvisit( ast::VariableExpr const * expr ) {
        extension( expr );
        const OperatorInfo * opInfo;
        if ( dynamic_cast<ast::ZeroType const *>( expr->var->get_type() ) ) {
                output << "0";
        } else if ( expr->var->linkage == ast::Linkage::Intrinsic
                        && ( opInfo = operatorLookup( expr->var->name ) )
                        && opInfo->type == OT_CONSTANT ) {
                output << opInfo->symbol;
        } else {
                output << mangleName( expr->var );
        }
}

void CodeGenerator::postvisit( ast::ConstantExpr const * expr ) {
        extension( expr );
        output << expr->rep;
}

void CodeGenerator::postvisit( ast::SizeofExpr const * expr ) {
        extension( expr );
        output << "sizeof(";
        if ( auto type = expr->type.as<ast::TypeofType>() ) {
                type->expr->accept( *visitor );
        } else {
                output << genType( expr->type, "", options );
        }
        output << ")";
}

void CodeGenerator::postvisit( ast::AlignofExpr const * expr ) {
        // Using the GCC extension to avoid changing the std to C11.
        extension( expr );
        output << "__alignof__(";
        if ( auto type = expr->type.as<ast::TypeofType>() ) {
                type->expr->accept( *visitor );
        } else {
                output << genType( expr->type, "", options );
        }
        output << ")";
}

void CodeGenerator::postvisit( ast::UntypedOffsetofExpr const * expr ) {
        assertf( !options.genC, "UntypedOffsetofExpr should not reach code generation." );
        output << "offsetof(";
        output << genType( expr->type, "", options );
        output << ", " << expr->member;
        output << ")";
}

void CodeGenerator::postvisit( ast::OffsetofExpr const * expr ) {
        // Use GCC builtin
        output << "__builtin_offsetof(";
        output << genType( expr->type, "", options );
        output << ", " << mangleName( expr->member );
        output << ")";
}

void CodeGenerator::postvisit( ast::OffsetPackExpr const * expr ) {
        assertf( !options.genC, "OffsetPackExpr should not reach code generation." );
        output << "__CFA_offsetpack(" << genType( expr->type, "", options ) << ")";
}

void CodeGenerator::postvisit( ast::LogicalExpr const * expr ) {
        extension( expr );
        output << "(";
        expr->arg1->accept( *visitor );
        output << ( ( expr->isAnd ) ? " && " : " || " );
        expr->arg2->accept( *visitor );
        output << ")";
}

void CodeGenerator::postvisit( ast::ConditionalExpr const * expr ) {
        extension( expr );
        output << "(";
        expr->arg1->accept( *visitor );
        output << " ? ";
        expr->arg2->accept( *visitor );
        output << " : ";
        expr->arg3->accept( *visitor );
        output << ")";
}

void CodeGenerator::postvisit( ast::CommaExpr const * expr ) {
        extension( expr );
        output << "(";
        if ( options.genC ) {
                // arg1 of a comma expression is never used, so it can be safely cast
                // to void to reduce gcc warnings.
                ast::ptr<ast::Expr> arg1 = new ast::CastExpr( expr->location, expr->arg1 );
                arg1->accept( *visitor );
        } else {
                expr->arg1->accept( *visitor );
        }
        output << " , ";
        expr->arg2->accept( *visitor );
        output << ")";
}

void CodeGenerator::postvisit( ast::TupleAssignExpr const * expr ) {
        assertf( !options.genC, "TupleAssignExpr should not reach code generation." );
        expr->stmtExpr->accept( *visitor );
}

void CodeGenerator::postvisit( ast::UntypedTupleExpr const * expr ) {
        assertf( !options.genC, "UntypedTupleExpr should not reach code generation." );
        extension( expr );
        output << "[";
        genCommaList( expr->exprs );
        output << "]";
}

void CodeGenerator::postvisit( ast::TupleExpr const * expr ) {
        assertf( !options.genC, "TupleExpr should not reach code generation." );
        extension( expr );
        output << "[";
        genCommaList( expr->exprs );
        output << "]";
}

void CodeGenerator::postvisit( ast::TupleIndexExpr const * expr ) {
        assertf( !options.genC, "TupleIndexExpr should not reach code generation." );
        extension( expr );
        expr->tuple->accept( *visitor );
        output << "." << expr->index;
}

void CodeGenerator::postvisit( ast::TypeExpr const * expr ) {
        // TODO: Should there be an assertion there?
        if ( !options.genC ) {
                output << genType( expr->type, "", options );
        }
}

void CodeGenerator::postvisit( ast::AsmExpr const * expr ) {
        if ( !expr->inout.empty() ) {
                output << "[ " << expr->inout << " ] ";
        }
        expr->constraint->accept( *visitor );
        output << " ( ";
        expr->operand->accept( *visitor );
        output << " )";
}

void CodeGenerator::postvisit( ast::CompoundLiteralExpr const * expr ) {
        //assert( expr->result && dynamic_cast<ast::ListInit const *>( expr->init ) );
        assert( expr->result && expr->init.as<ast::ListInit>() );
        output << "(" << genType( expr->result, "", options ) << ")";
        expr->init->accept( *visitor );
}

void CodeGenerator::postvisit( ast::UniqueExpr const * expr ) {
        assertf( !options.genC, "UniqueExpr should not reach code generation." );
        output << "unq<" << expr->id << ">{ ";
        expr->expr->accept( *visitor );
        output << " }";
}

void CodeGenerator::postvisit( ast::StmtExpr const * expr ) {
        auto stmts = expr->stmts->kids;
        output << "({" << endl;
        ++indent;
        unsigned int numStmts = stmts.size();
        unsigned int i = 0;
        for ( ast::ptr<ast::Stmt> const & stmt : stmts ) {
                output << indent << printLabels( stmt->labels );
                if ( i + 1 == numStmts ) {
                        // Last statement in a statement expression needs to be handled
                        // specially - cannot cast to void, otherwise the expression
                        // statement has no value.
                        if ( ast::ExprStmt const * exprStmt = stmt.as<ast::ExprStmt>() ) {
                                exprStmt->expr->accept( *visitor );
                                output << ";" << endl;
                                ++i;
                                break;
                        }
                }
                stmt->accept( *visitor );
                output << endl;
                if ( wantSpacing( stmt ) ) output << endl;
                ++i;
        }
        --indent;
        output << indent << "})";
}

void CodeGenerator::postvisit( ast::ConstructorExpr const * expr ) {
        assertf( !options.genC, "ConstructorExpr should not reach code generation." );
        expr->callExpr->accept( *visitor );
}

void CodeGenerator::postvisit( ast::DeletedExpr const * expr ) {
        assertf( !options.genC, "DeletedExpr should not reach code generation." );
        expr->expr->accept( *visitor );
}

void CodeGenerator::postvisit( ast::DefaultArgExpr const * expr ) {
        assertf( !options.genC, "DefaultArgExpr should not reach code generation." );
        expr->expr->accept( *visitor );
}

void CodeGenerator::postvisit( ast::GenericExpr const * expr ) {
        assertf( !options.genC, "GenericExpr should not reach code generation." );
        output << "_Generic(";
        expr->control->accept( *visitor );
        output << ", ";
        unsigned int numAssocs = expr->associations.size();
        unsigned int i = 0;
        for ( const ast::GenericExpr::Association & assoc : expr->associations ) {
                if ( nullptr == assoc.type ) {
                        output << "default: ";
                } else {
                        output << genType( assoc.type, "", options ) << ": ";
                }
                assoc.expr->accept( *visitor );
                ++i;
                if ( i != numAssocs ) output << ", ";
        }
        output << ")";
}

void CodeGenerator::postvisit( ast::CompoundStmt const * stmt ) {
        output << "{" << endl;

        ++indent;
        for ( auto kid : stmt->kids ) {
                output << indent << printLabels( kid->labels );
                kid->accept( *visitor );
                output << endl;
                if ( wantSpacing( kid ) ) output << endl;
        }
        --indent;

        output << indent << "}";
}

void CodeGenerator::postvisit( ast::ExprStmt const * stmt ) {
        assert( stmt );
        // Cast the top-level expression to void to reduce gcc warnings.
        if ( options.genC ) {
                ast::ptr<ast::Expr> expr = new ast::CastExpr( stmt->location, stmt->expr );
                expr->accept( *visitor );
        } else {
                stmt->expr->accept( *visitor );
        }
        output << ";";
}

void CodeGenerator::postvisit( ast::AsmStmt const * stmt ) {
        output << "asm ";
        if ( stmt->isVolatile ) output << "volatile ";
        if ( !stmt->gotoLabels.empty() ) output << "goto ";
        output << "( ";
        if ( stmt->instruction ) stmt->instruction->accept( *visitor );
        output << " : ";
        genCommaList( stmt->output );
        output << " : ";
        genCommaList( stmt->input );
        output << " : ";
        genCommaList( stmt->clobber );
        if ( !stmt->gotoLabels.empty() ) {
                output << " : ";
                auto it = stmt->gotoLabels.begin();
                while (true) {
                        output << *it++;
                        if ( stmt->gotoLabels.end() == it ) break;
                        output << ", ";
                }
        }
        output << " );";
}

void CodeGenerator::postvisit( ast::AsmDecl const * decl ) {
        output << "asm ";
        ast::AsmStmt const * stmt = decl->stmt;
        output << "( ";
        if ( stmt->instruction ) stmt->instruction->accept( *visitor );
        output << " )";
}

void CodeGenerator::postvisit( ast::DirectiveDecl const * decl ) {
        // endl prevents spaces before the directive.
        output << endl << decl->stmt->directive;
}

void CodeGenerator::postvisit( ast::DirectiveStmt const * stmt ) {
        // endl prevents spaces before the directive.
        output << endl << stmt->directive;
}

void CodeGenerator::postvisit( ast::IfStmt const * stmt ) {
        output << "if ( ";
        stmt->cond->accept( *visitor );
        output << " ) ";

        stmt->then->accept( *visitor );

        if ( nullptr != stmt->else_ ) {
                output << " else ";
                stmt->else_->accept( *visitor );
        }
}

void CodeGenerator::postvisit( ast::SwitchStmt const * stmt ) {
        output << "switch ( ";
        stmt->cond->accept( *visitor );
        output << " ) ";

        output << "{" << endl;
        ++indent;
        for ( auto node : stmt->cases ) {
                node->accept( *visitor );
        }
        --indent;
        output << indent << "}";
}

void CodeGenerator::postvisit( ast::CaseClause const * clause ) {
        updateLocation( clause );
        output << indent;
        if ( clause->isDefault() ) {
                output << "default";
        } else {
                output << "case ";
                clause->cond->accept( *visitor );
        }
        output << ":" << endl;

        ++indent;
        for ( auto stmt : clause->stmts ) {
                output << indent << printLabels( stmt->labels ) ;
                stmt->accept( *visitor );
                output << endl;
        }
        --indent;
}

void CodeGenerator::postvisit( ast::BranchStmt const * stmt ) {
        switch ( stmt->kind ) {
        case ast::BranchStmt::Goto:
                if ( !stmt->target.empty() ) {
                        output << "goto " << stmt->target;
                } else if ( nullptr != stmt->computedTarget ) {
                        output << "goto *";
                        stmt->computedTarget->accept( *visitor );
                }
                break;
        case ast::BranchStmt::Break:
                output << "break";
                break;
        case ast::BranchStmt::Continue:
                output << "continue";
                break;
        case ast::BranchStmt::FallThrough:
        case ast::BranchStmt::FallThroughDefault:
                assertf( !options.genC, "fallthru should not reach code generation." );
                output << "fallthru";
                break;
        default:
                assertf( false, "Bad BranchStmt value." );
        }
        // Print branch target for labelled break/continue/fallthru in debug mode.
        if ( !options.genC && stmt->kind != ast::BranchStmt::Goto ) {
                if ( !stmt->target.empty() ) {
                        output << " " << stmt->target;
                } else if ( stmt->kind == ast::BranchStmt::FallThrough ) {
                        output << " default";
                }
        }
        output << ";";
}

void CodeGenerator::postvisit( ast::ReturnStmt const * stmt ) {
        output << "return ";
        if ( stmt->expr ) stmt->expr->accept( *visitor );
        output << ";";
}

void CodeGenerator::postvisit( ast::ThrowStmt const * stmt ) {
        assertf( !options.genC, "ThrowStmt should not reach code generation." );

        output << ((stmt->kind == ast::Terminate) ? "throw" : "throwResume");
        if ( stmt->expr ) {
                output << " ";
                stmt->expr->accept( *visitor );
        }
        if ( stmt->target ) {
                output << " _At ";
                stmt->target->accept( *visitor );
        }
        output << ";";
}

void CodeGenerator::postvisit( ast::CatchClause const * stmt ) {
        assertf( !options.genC, "CatchClause should not reach code generation." );

        output << ((stmt->kind == ast::Terminate) ? "catch" : "catchResume");
        output << "( ";
        stmt->decl->accept( *visitor );
        if ( stmt->cond ) {
                output << " ; ";
                stmt->cond->accept( *visitor );
        }
        output << " ) ";
        stmt->body->accept( *visitor );
}

void CodeGenerator::postvisit( ast::WaitForStmt const * stmt ) {
        assertf( !options.genC, "WaitforStmt should not reach code generation." );

        bool first = true;
        for ( ast::ptr<ast::WaitForClause> const & clause : stmt->clauses ) {
                if (first) { output << "or "; first = false; }
                if ( clause->when_cond ) {
                        output << "when(";
                        clause->when_cond->accept( *visitor );
                        output << ") ";
                }
                output << "waitfor(";
                clause->target->accept( *visitor );
                for ( ast::ptr<ast::Expr> const & expr : clause->target_args ) {
                        output << ",";
                        expr->accept( *visitor );
                }
                output << ") ";
                clause->stmt->accept( *visitor );
        }

        if ( stmt->timeout_stmt ) {
                output << "or ";
                if ( stmt->timeout_cond ) {
                        output << "when(";
                        stmt->timeout_cond->accept( *visitor );
                        output << ") ";
                }
                output << "timeout(";
                stmt->timeout_time->accept( *visitor );
                output << ") ";
                stmt->timeout_stmt->accept( *visitor );
        }

        if ( stmt->else_stmt ) {
                output << "or ";
                if ( stmt->else_cond ) {
                        output << "when(";
                        stmt->else_cond->accept( *visitor );
                        output << ")";
                }
                output << "else ";
                stmt->else_stmt->accept( *visitor );
        }
}

void CodeGenerator::postvisit( ast::WithStmt const * stmt ) {
        assertf( !options.genC, "WithStmt should not reach code generation." );

        output << "with ( ";
        genCommaList( stmt->exprs );
        output << " ) ";
        stmt->stmt->accept( *visitor );
}

void CodeGenerator::postvisit( ast::WhileDoStmt const * stmt ) {
        if ( stmt->isDoWhile ) {
                output << "do";
        } else {
                output << "while (";
                stmt->cond->accept( *visitor );
                output << ")";
        }
        output << " ";

        output << CodeGenerator::printLabels( stmt->body->labels );
        stmt->body->accept( *visitor );

        if ( stmt->isDoWhile ) {
                output << " while (";
                stmt->cond->accept( *visitor );
                output << ( ( nullptr == stmt->else_ ) ? ");" : ")" );
        }
        if ( stmt->else_ ) {
                output << " else ";
                stmt->else_->accept( *visitor );
        }
}

void CodeGenerator::postvisit( ast::ForStmt const * stmt ) {
        // Initializer is always hoised so don't generate it.
        // TODO: Do an assertion check?
        output << "for (;";

        if ( nullptr != stmt->cond ) {
                stmt->cond->accept( *visitor );
        }
        output << ";";

        if ( nullptr != stmt->inc ) {
                // cast the top-level expression to void to reduce gcc warnings.
                ast::Expr * expr = new ast::CastExpr( stmt->inc );
                expr->accept( *visitor );
        }
        output << ") ";

        if ( nullptr != stmt->body ) {
                output << printLabels( stmt->body->labels );
                stmt->body->accept( *visitor );
        }

        if ( nullptr != stmt->else_ ) {
                assertf( !options.genC, "Loop else should not reach code generation." );
                output << " else ";
                stmt->else_->accept( *visitor );
        }
}

void CodeGenerator::postvisit( ast::NullStmt const * ) {
        output << "/* null statement */ ;";
}

void CodeGenerator::postvisit( ast::DeclStmt const * stmt ) {
        stmt->decl->accept( *visitor );

        if ( doSemicolon( stmt->decl ) ) output << ";";
}

void CodeGenerator::postvisit( ast::ImplicitCtorDtorStmt const * stmt ) {
        assertf( !options.genC, "ImplicitCtorCtorStmt should not reach code generation." );
        stmt->callStmt->accept( *visitor );
}

void CodeGenerator::postvisit( ast::MutexStmt const * stmt ) {
        assertf( !options.genC, "MutexStmt should not reach code generation." );
        // TODO: But this isn't what a mutex statement looks like.
        stmt->stmt->accept( *visitor );
}

std::string genName( ast::DeclWithType const * decl ) {
        if ( const OperatorInfo * opInfo = operatorLookup( decl->name ) ) {
                return opInfo->outputName;
        } else {
                return decl->name;
        }
}

} // namespace CodeGen