Changeset 47534159


Ignore:
Timestamp:
Dec 4, 2015, 2:55:22 PM (6 years ago)
Author:
Aaron Moss <a3moss@…>
Branches:
aaron-thesis, arm-eh, cleanup-dtors, ctor, deferred_resn, demangler, gc_noraii, jacob/cs343-translation, jenkins-sandbox, master, memory, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, resolv-new, string, with_gc
Children:
000b914, 63db3d7
Parents:
f8b961b
Message:

Added support for alignof expressions for everything but polymorphic types

Location:
src
Files:
17 edited

Legend:

Unmodified
Added
Removed
  • src/CodeGen/CodeGenerator.cc

    rf8b961b r47534159  
    442442                output << ")";
    443443        }
     444
     445        void CodeGenerator::visit( AlignofExpr *sizeofExpr ) {
     446                // use GCC extension to avoid bumping std to C11
     447                output << "__alignof__(";
     448                if ( sizeofExpr->get_isType() ) {
     449                        output << genType( sizeofExpr->get_type(), "" );
     450                } else {
     451                        sizeofExpr->get_expr()->accept( *this );
     452                } // if
     453                output << ")";
     454        }
    444455 
    445456        void CodeGenerator::visit( LogicalExpr *logicalExpr ) {
  • src/CodeGen/CodeGenerator.h

    rf8b961b r47534159  
    6060                virtual void visit( ConstantExpr *constantExpr );
    6161                virtual void visit( SizeofExpr *sizeofExpr );
     62                virtual void visit( AlignofExpr *alignofExpr );
    6263                virtual void visit( LogicalExpr *logicalExpr );
    6364                virtual void visit( ConditionalExpr *conditionalExpr );
  • src/InitTweak/InitModel.h

    rf8b961b r47534159  
    7272                        void visit( ConstantExpr * );
    7373                        void visit( SizeofExpr * ) { throw 0; }
     74                        void visit( AlignofExpr * ) { throw 0; }
    7475                        void visit( AttrExpr * ) { throw 0; }
    7576                        void visit( LogicalExpr * ) { throw 0; }
  • src/Parser/ExpressionNode.cc

    rf8b961b r47534159  
    586586                }
    587587          case OperatorNode::AlignOf:
     588                {
     589                        if ( TypeValueNode * arg = dynamic_cast<TypeValueNode *>( get_args()) ) {
     590                                return new AlignofExpr( arg->get_decl()->buildType());
     591                        } else {
     592                                return new AlignofExpr( args.front());
     593                        } // if
     594                }
    588595          case OperatorNode::SizeOf:
    589596                {
    590 ///     bool isSizeOf = ( op->get_type() == OperatorNode::SizeOf );
    591 
    592597                        if ( TypeValueNode * arg = dynamic_cast<TypeValueNode *>( get_args()) ) {
    593598                                return new SizeofExpr( arg->get_decl()->buildType());
  • src/ResolvExpr/AlternativeFinder.cc

    rf8b961b r47534159  
    792792        }
    793793
     794        void AlternativeFinder::visit( AlignofExpr *alignofExpr ) {
     795                if ( alignofExpr->get_isType() ) {
     796                        alternatives.push_back( Alternative( alignofExpr->clone(), env, Cost::zero ) );
     797                } else {
     798                        // find all alternatives for the argument to sizeof
     799                        AlternativeFinder finder( indexer, env );
     800                        finder.find( alignofExpr->get_expr() );
     801                        // find the lowest cost alternative among the alternatives, otherwise ambiguous
     802                        AltList winners;
     803                        findMinCost( finder.alternatives.begin(), finder.alternatives.end(), back_inserter( winners ) );
     804                        if ( winners.size() != 1 ) {
     805                                throw SemanticError( "Ambiguous expression in alignof operand: ", alignofExpr->get_expr() );
     806                        } // if
     807                        // return the lowest cost alternative for the argument
     808                        Alternative &choice = winners.front();
     809                        alternatives.push_back( Alternative( new AlignofExpr( choice.expr->clone() ), choice.env, Cost::zero ) );
     810                } // if
     811        }
     812
    794813        void AlternativeFinder::resolveAttr( DeclarationWithType *funcDecl, FunctionType *function, Type *argType, const TypeEnvironment &env ) {
    795814                // assume no polymorphism
  • src/ResolvExpr/AlternativeFinder.h

    rf8b961b r47534159  
    5656                virtual void visit( ConstantExpr *constantExpr );
    5757                virtual void visit( SizeofExpr *sizeofExpr );
     58                virtual void visit( AlignofExpr *sizeofExpr );
    5859                virtual void visit( AttrExpr *attrExpr );
    5960                virtual void visit( LogicalExpr *logicalExpr );
  • src/SymTab/Indexer.cc

    rf8b961b r47534159  
    215215                } else {
    216216                        maybeAccept( sizeofExpr->get_expr(), *this );
     217                }
     218        }
     219
     220        void Indexer::visit( AlignofExpr *alignofExpr ) {
     221                acceptAllNewScope( alignofExpr->get_results(), *this );
     222                if ( alignofExpr->get_isType() ) {
     223                        maybeAccept( alignofExpr->get_type(), *this );
     224                } else {
     225                        maybeAccept( alignofExpr->get_expr(), *this );
    217226                }
    218227        }
  • src/SymTab/Indexer.h

    rf8b961b r47534159  
    5454                virtual void visit( ConstantExpr *constantExpr );
    5555                virtual void visit( SizeofExpr *sizeofExpr );
     56                virtual void visit( AlignofExpr *alignofExpr );
    5657                virtual void visit( AttrExpr *attrExpr );
    5758                virtual void visit( LogicalExpr *logicalExpr );
  • src/SynTree/Expression.cc

    rf8b961b r47534159  
    122122void SizeofExpr::print( std::ostream &os, int indent) const {
    123123        os << std::string( indent, ' ' ) << "Sizeof Expression on: ";
     124
     125        if (isType)
     126                type->print(os, indent + 2);
     127        else
     128                expr->print(os, indent + 2);
     129
     130        os << std::endl;
     131        Expression::print( os, indent );
     132}
     133
     134AlignofExpr::AlignofExpr( Expression *expr_, Expression *_aname ) :
     135                Expression( _aname ), expr(expr_), type(0), isType(false) {
     136        add_result( new BasicType( Type::Qualifiers(), BasicType::UnsignedInt ) );
     137}
     138
     139AlignofExpr::AlignofExpr( Type *type_, Expression *_aname ) :
     140                Expression( _aname ), expr(0), type(type_), isType(true) {
     141        add_result( new BasicType( Type::Qualifiers(), BasicType::UnsignedInt ) );
     142}
     143
     144AlignofExpr::AlignofExpr( const AlignofExpr &other ) :
     145        Expression( other ), expr( maybeClone( other.expr ) ), type( maybeClone( other.type ) ), isType( other.isType ) {
     146}
     147
     148AlignofExpr::~AlignofExpr() {
     149        delete expr;
     150        delete type;
     151}
     152
     153void AlignofExpr::print( std::ostream &os, int indent) const {
     154        os << std::string( indent, ' ' ) << "Alignof Expression on: ";
    124155
    125156        if (isType)
  • src/SynTree/Expression.h

    rf8b961b r47534159  
    2323#include "Constant.h"
    2424
     25/// Expression is the root type for all expressions
    2526class Expression {
    2627  public:
     
    4748};
    4849
    49 // ParamEntry contains the i.d. of a declaration and a type that is derived from that declaration,
    50 // but subject to decay-to-pointer and type parameter renaming
    51 
     50/// ParamEntry contains the i.d. of a declaration and a type that is derived from that declaration,
     51/// but subject to decay-to-pointer and type parameter renaming
    5252struct ParamEntry {
    5353        ParamEntry(): decl( 0 ), actualType( 0 ), formalType( 0 ), expr( 0 ) {}
     
    6565typedef std::map< UniqueId, ParamEntry > InferredParams;
    6666
    67 // ApplicationExpr represents the application of a function to a set of parameters.  This is the
    68 // result of running an UntypedExpr through the expression analyzer.
    69 
     67/// ApplicationExpr represents the application of a function to a set of parameters.  This is the
     68/// result of running an UntypedExpr through the expression analyzer.
    7069class ApplicationExpr : public Expression {
    7170  public:
     
    8988};
    9089
    91 // UntypedExpr represents the application of a function to a set of parameters, but where the
    92 // particular overload for the function name has not yet been determined.  Most operators are
    93 // converted into functional form automatically, to permit operator overloading.
    94 
     90/// UntypedExpr represents the application of a function to a set of parameters, but where the
     91/// particular overload for the function name has not yet been determined.  Most operators are
     92/// converted into functional form automatically, to permit operator overloading.
    9593class UntypedExpr : public Expression {
    9694  public:
     
    118116};
    119117
    120 // this class contains a name whose meaning is still not determined
     118/// NameExpr contains a name whose meaning is still not determined
    121119class NameExpr : public Expression {
    122120  public:
     
    139137// function-call format.
    140138
    141 // AddressExpr represents a address-of expression, e.g. &e
     139/// AddressExpr represents a address-of expression, e.g. &e
    142140class AddressExpr : public Expression {
    143141  public:
     
    174172};
    175173
    176 // CastExpr represents a type cast expression, e.g. (int)e
     174/// CastExpr represents a type cast expression, e.g. (int)e
    177175class CastExpr : public Expression {
    178176  public:
     
    193191};
    194192
    195 // UntypedMemberExpr represents a member selection operation, e.g. q.p before processing by the expression analyzer
     193/// UntypedMemberExpr represents a member selection operation, e.g. q.p before processing by the expression analyzer
    196194class UntypedMemberExpr : public Expression {
    197195  public:
     
    214212};
    215213
    216 // MemberExpr represents a member selection operation, e.g. q.p after processing by the expression analyzer
     214/// MemberExpr represents a member selection operation, e.g. q.p after processing by the expression analyzer
    217215class MemberExpr : public Expression {
    218216  public:
     
    235233};
    236234
    237 // VariableExpr represents an expression that simply refers to the value of a named variable
     235/// VariableExpr represents an expression that simply refers to the value of a named variable
    238236class VariableExpr : public Expression {
    239237  public:
     
    253251};
    254252
    255 // ConstantExpr represents an expression that simply refers to the value of a constant
     253/// ConstantExpr represents an expression that simply refers to the value of a constant
    256254class ConstantExpr : public Expression {
    257255  public:
     
    271269};
    272270
    273 // SizeofExpr represents a sizeof expression (could be sizeof(int) or sizeof 3+4)
     271/// SizeofExpr represents a sizeof expression (could be sizeof(int) or sizeof 3+4)
    274272class SizeofExpr : public Expression {
    275273  public:
     
    296294};
    297295
    298 // AttrExpr represents an @attribute expression (like sizeof, but user-defined)
     296/// AlignofExpr represents an alignof expression
     297class AlignofExpr : public Expression {
     298  public:
     299        AlignofExpr( Expression *expr, Expression *_aname = 0 );
     300        AlignofExpr( const AlignofExpr &other );
     301        AlignofExpr( Type *type, Expression *_aname = 0 );
     302        virtual ~AlignofExpr();
     303
     304        Expression *get_expr() const { return expr; }
     305        void set_expr( Expression *newValue ) { expr = newValue; }
     306        Type *get_type() const { return type; }
     307        void set_type( Type *newValue ) { type = newValue; }
     308        bool get_isType() const { return isType; }
     309        void set_isType( bool newValue ) { isType = newValue; }
     310
     311        virtual AlignofExpr *clone() const { return new AlignofExpr( *this ); }
     312        virtual void accept( Visitor &v ) { v.visit( this ); }
     313        virtual Expression *acceptMutator( Mutator &m ) { return m.mutate( this ); }
     314        virtual void print( std::ostream &os, int indent = 0 ) const;
     315  private:
     316        Expression *expr;
     317        Type *type;
     318        bool isType;
     319};
     320
     321/// AttrExpr represents an @attribute expression (like sizeof, but user-defined)
    299322class AttrExpr : public Expression {
    300323  public:
     
    324347};
    325348
    326 // LogicalExpr represents a short-circuit boolean expression (&& or ||)
     349/// LogicalExpr represents a short-circuit boolean expression (&& or ||)
    327350class LogicalExpr : public Expression {
    328351  public:
     
    347370};
    348371
    349 // ConditionalExpr represents the three-argument conditional ( p ? a : b )
     372/// ConditionalExpr represents the three-argument conditional ( p ? a : b )
    350373class ConditionalExpr : public Expression {
    351374  public:
     
    371394};
    372395
    373 // CommaExpr represents the sequence operator ( a, b )
     396/// CommaExpr represents the sequence operator ( a, b )
    374397class CommaExpr : public Expression {
    375398  public:
     
    392415};
    393416
    394 // TupleExpr represents a tuple expression ( [a, b, c] )
     417/// TupleExpr represents a tuple expression ( [a, b, c] )
    395418class TupleExpr : public Expression {
    396419  public:
     
    410433};
    411434
    412 // SolvedTupleExpr represents a TupleExpr whose components have been type-resolved. It is effectively a shell for the code generator to work on
     435/// SolvedTupleExpr represents a TupleExpr whose components have been type-resolved. It is effectively a shell for the code generator to work on
    413436class SolvedTupleExpr : public Expression {
    414437  public:
     
    428451};
    429452
    430 // TypeExpr represents a type used in an expression (e.g. as a type generator parameter)
     453/// TypeExpr represents a type used in an expression (e.g. as a type generator parameter)
    431454class TypeExpr : public Expression {
    432455  public:
     
    446469};
    447470
    448 // AsmExpr represents a GCC 'asm constraint operand' used in an asm statement: [output] "=f" (result)
     471/// AsmExpr represents a GCC 'asm constraint operand' used in an asm statement: [output] "=f" (result)
    449472class AsmExpr : public Expression {
    450473  public:
     
    472495};
    473496
    474 // ValofExpr represents a GCC 'lambda expression'
     497/// ValofExpr represents a GCC 'lambda expression'
    475498class UntypedValofExpr : public Expression {
    476499  public:
  • src/SynTree/Mutator.cc

    rf8b961b r47534159  
    251251}
    252252
     253Expression *Mutator::mutate( AlignofExpr *alignofExpr ) {
     254        mutateAll( alignofExpr->get_results(), *this );
     255        if ( alignofExpr->get_isType() ) {
     256                alignofExpr->set_type( maybeMutate( alignofExpr->get_type(), *this ) );
     257        } else {
     258                alignofExpr->set_expr( maybeMutate( alignofExpr->get_expr(), *this ) );
     259        }
     260        return alignofExpr;
     261}
     262
    253263Expression *Mutator::mutate( AttrExpr *attrExpr ) {
    254264        mutateAll( attrExpr->get_results(), *this );
  • src/SynTree/Mutator.h

    rf8b961b r47534159  
    6464        virtual Expression* mutate( ConstantExpr *constantExpr );
    6565        virtual Expression* mutate( SizeofExpr *sizeofExpr );
     66        virtual Expression* mutate( AlignofExpr *alignofExpr );
    6667        virtual Expression* mutate( AttrExpr *attrExpr );
    6768        virtual Expression* mutate( LogicalExpr *logicalExpr );
  • src/SynTree/SynTree.h

    rf8b961b r47534159  
    6969class ConstantExpr;
    7070class SizeofExpr;
     71class AlignofExpr;
    7172class AttrExpr;
    7273class LogicalExpr;
  • src/SynTree/Visitor.cc

    rf8b961b r47534159  
    210210}
    211211
     212void Visitor::visit( AlignofExpr *alignofExpr ) {
     213        acceptAll( alignofExpr->get_results(), *this );
     214        if ( alignofExpr->get_isType() ) {
     215                maybeAccept( alignofExpr->get_type(), *this );
     216        } else {
     217                maybeAccept( alignofExpr->get_expr(), *this );
     218        }
     219}
     220
    212221void Visitor::visit( AttrExpr *attrExpr ) {
    213222        acceptAll( attrExpr->get_results(), *this );
  • src/SynTree/Visitor.h

    rf8b961b r47534159  
    6464        virtual void visit( ConstantExpr *constantExpr );
    6565        virtual void visit( SizeofExpr *sizeofExpr );
     66        virtual void visit( AlignofExpr *alignofExpr );
    6667        virtual void visit( AttrExpr *attrExpr );
    6768        virtual void visit( LogicalExpr *logicalExpr );
  • src/Tuples/FlattenTuple.cc

    rf8b961b r47534159  
    4646        void FlattenTuple::CollectArgs::visit( ConstantExpr      *expr )  {  currentArgs.insert( currentArgs.end(), expr );  }
    4747        void FlattenTuple::CollectArgs::visit( SizeofExpr        *expr )  {  currentArgs.insert( currentArgs.end(), expr );  }
     48        void FlattenTuple::CollectArgs::visit( AlignofExpr       *expr )  {  currentArgs.insert( currentArgs.end(), expr );  }
    4849        void FlattenTuple::CollectArgs::visit( AttrExpr          *expr )  {  currentArgs.insert( currentArgs.end(), expr );  }
    4950        void FlattenTuple::CollectArgs::visit( LogicalExpr       *expr )  {  currentArgs.insert( currentArgs.end(), expr );  }
  • src/Tuples/FlattenTuple.h

    rf8b961b r47534159  
    4242                        virtual void visit( ConstantExpr * );
    4343                        virtual void visit( SizeofExpr * );
     44                        virtual void visit( AlignofExpr * );
    4445                        virtual void visit( AttrExpr * );
    4546                        virtual void visit( LogicalExpr * );
Note: See TracChangeset for help on using the changeset viewer.