Changeset 5ccb10d


Ignore:
Timestamp:
Aug 22, 2017, 6:41:28 PM (4 years ago)
Author:
Rob Schluntz <rschlunt@…>
Branches:
aaron-thesis, arm-eh, cleanup-dtors, deferred_resn, demangler, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, resolv-new, with_gc
Children:
0b5d871
Parents:
d104b02
Message:

Set reference size to base size, clean up debug code, remove more old-style NULLs from prelude

Location:
src
Files:
9 edited

Legend:

Unmodified
Added
Removed
  • src/InitTweak/FixInit.cc

    rd104b02 r5ccb10d  
    591591
    592592                                Expression * retExpr = new CommaExpr( assign, new VariableExpr( returnDecl ) );
    593                                 if ( callExpr->get_result()->get_lvalue() ) {
    594                                         // lvalue returning functions are funny. Lvalue.cc inserts a *? in front of any lvalue returning
    595                                         // non-intrinsic function. Add an AddressExpr to the call to negate the derefence and change the
    596                                         // type of the return temporary from T to T* to properly capture the return value. Then dereference
    597                                         // the result of the comma expression, since the lvalue returning call was originally wrapped with
    598                                         // an AddressExpr.  Effectively, this turns
    599                                         //   lvalue T f();
    600                                         //   &*f();
    601                                         // into
    602                                         //   T * f();
    603                                         //   T * tmp_cp_retN;
    604                                         //   &*(tmp_cp_retN = &*f(), tmp_cp_retN);              // the first * and second & are generated here
    605                                         // which work out in terms of types, but is pretty messy. It would be nice to find a better way.
    606                                         assign->get_args().back() = new AddressExpr( assign->get_args().back() );
    607 
    608                                         returnDecl->set_type( new PointerType( Type::Qualifiers(), returnDecl->get_type() ) );
    609                                         retExpr->set_result( new PointerType( Type::Qualifiers(), retExpr->get_result() ) );
    610                                         retExpr = UntypedExpr::createDeref( retExpr );
    611                                 } // if
    612593                                // move env from callExpr to retExpr
    613594                                retExpr->set_env( callExpr->get_env() );
  • src/ResolvExpr/AlternativeFinder.cc

    rd104b02 r5ccb10d  
    845845                        // then excess components do not come out in the result expression (but UniqueExprs ensure that
    846846                        // side effects will still be done).
    847                         if ( Tuples::maybeImpure( argExpr ) && ! dynamic_cast< UniqueExpr * >( argExpr ) ) {
     847                        if ( Tuples::maybeImpureIgnoreUnique( argExpr ) ) {
    848848                                // expressions which may contain side effects require a single unique instance of the expression.
    849849                                argExpr = new UniqueExpr( argExpr );
  • src/ResolvExpr/CommonType.cc

    rd104b02 r5ccb10d  
    1818#include "Unify.h"
    1919
    20 /// #define DEBUG
     20// #define DEBUG
    2121
    2222namespace ResolvExpr {
  • src/ResolvExpr/ConversionCost.cc

    rd104b02 r5ccb10d  
    2828        const Cost Cost::reference = Cost( 0, 0, 0, 1 );
    2929
     30#if 0
     31#define PRINT(x) x
     32#else
     33#define PRINT(x)
     34#endif
    3035
    3136        Cost conversionCost( Type *src, Type *dest, const SymTab::Indexer &indexer, const TypeEnvironment &env ) {
     
    3338                        EqvClass eqvClass;
    3439                        NamedTypeDecl *namedType;
    35 ///     std::cout << "type inst " << destAsTypeInst->get_name();
     40                        PRINT( std::cerr << "type inst " << destAsTypeInst->get_name(); )
    3641                        if ( env.lookup( destAsTypeInst->get_name(), eqvClass ) ) {
    3742                                if ( eqvClass.type ) {
     
    4146                                }
    4247                        } else if ( ( namedType = indexer.lookupType( destAsTypeInst->get_name() ) ) ) {
    43 ///       std::cout << " found" << std::endl;
     48                                PRINT( std::cerr << " found" << std::endl; )
    4449                                TypeDecl *type = dynamic_cast< TypeDecl* >( namedType );
    4550                                // all typedefs should be gone by this point
     
    4954                                } // if
    5055                        } // if
    51 ///     std::cout << " not found" << std::endl;
    52                 } // if
    53 ///   std::cout << "src is ";
    54 ///   src->print( std::cout );
    55 ///   std::cout << std::endl << "dest is ";
    56 ///   dest->print( std::cout );
    57 ///   std::cout << std::endl << "env is" << std::endl;
    58 ///   env.print( std::cout, 8 );
     56                        PRINT( std::cerr << " not found" << std::endl; )
     57                } // if
     58                PRINT(
     59                        std::cerr << "src is ";
     60                        src->print( std::cerr );
     61                        std::cerr << std::endl << "dest is ";
     62                        dest->print( std::cerr );
     63                        std::cerr << std::endl << "env is" << std::endl;
     64                        env.print( std::cerr, 8 );
     65                )
    5966                if ( typesCompatibleIgnoreQualifiers( src, dest, indexer, env ) ) {
    60 ///     std::cout << "compatible!" << std::endl;
     67                        PRINT( std::cerr << "compatible!" << std::endl; )
    6168                        return Cost::zero;
    6269                } else if ( dynamic_cast< VoidType* >( dest ) ) {
    6370                        return Cost::safe;
    6471                } else if ( ReferenceType * refType = dynamic_cast< ReferenceType * > ( dest ) ) {
    65                         // std::cerr << "conversionCost: dest is reference" << std::endl;
     72                        PRINT( std::cerr << "conversionCost: dest is reference" << std::endl; )
    6673                        return convertToReferenceCost( src, refType, indexer, env );
    6774                } else {
     
    7784
    7885        Cost convertToReferenceCost( Type * src, Type * dest, int diff, const SymTab::Indexer & indexer, const TypeEnvironment & env ) {
    79                 // std::cerr << "convert to reference cost..." << std::endl;
     86                PRINT( std::cerr << "convert to reference cost..." << std::endl; )
    8087                if ( diff > 0 ) {
    8188                        // TODO: document this
     
    9299                        ReferenceType * destAsRef = dynamic_cast< ReferenceType * >( dest );
    93100                        if ( srcAsRef && destAsRef ) { // pointer-like conversions between references
    94                                 // std::cerr << "converting between references" << std::endl;
     101                                PRINT( std::cerr << "converting between references" << std::endl; )
    95102                                if ( srcAsRef->get_base()->get_qualifiers() <= destAsRef->get_base()->get_qualifiers() && typesCompatibleIgnoreQualifiers( srcAsRef->get_base(), destAsRef->get_base(), indexer, env ) ) {
    96103                                        return Cost::safe;
    97104                                } else {  // xxx - this discards reference qualifiers from consideration -- reducing qualifiers is a safe conversion; is this right?
    98105                                        int assignResult = ptrsAssignable( srcAsRef->get_base(), destAsRef->get_base(), env );
     106                                        PRINT( std::cerr << "comparing references: " << assignResult << " " << srcAsRef << " " << destAsRef << std::endl; )
    99107                                        if ( assignResult < 0 ) {
    100108                                                return Cost::safe;
     
    104112                                } // if
    105113                        } else {
    106                                 // std::cerr << "reference to rvalue conversion" << std::endl;
     114                                PRINT( std::cerr << "reference to rvalue conversion" << std::endl; )
    107115                                ConversionCost converter( dest, indexer, env );
    108116                                src->accept( converter );
     
    113121                        assert( diff == -1 && destAsRef );
    114122                        if ( typesCompatibleIgnoreQualifiers( src, destAsRef->get_base(), indexer, env ) ) {
    115                                 // std::cerr << "converting compatible base type" << std::endl;
     123                                PRINT( std::cerr << "converting compatible base type" << std::endl; )
    116124                                if ( src->get_lvalue() ) {
    117                                         // std::cerr << "lvalue to reference conversion" << std::endl;
     125                                        PRINT(
     126                                                std::cerr << "lvalue to reference conversion" << std::endl;
     127                                                std::cerr << src << " => " << destAsRef << std::endl;
     128                                        )
    118129                                        // lvalue-to-reference conversion:  cv lvalue T => cv T &
    119130                                        if ( src->get_qualifiers() == destAsRef->get_base()->get_qualifiers() ) {
     
    125136                                        } // if
    126137                                } else if ( destAsRef->get_base()->get_const() ) {
    127                                         // std::cerr << "rvalue to const ref conversion" << std::endl;
     138                                        PRINT( std::cerr << "rvalue to const ref conversion" << std::endl; )
    128139                                        // rvalue-to-const-reference conversion: T => const T &
    129140                                        return Cost::safe;
    130141                                } else {
    131                                         // std::cerr << "rvalue to non-const reference conversion" << std::endl;
     142                                        PRINT( std::cerr << "rvalue to non-const reference conversion" << std::endl; )
    132143                                        // rvalue-to-reference conversion: T => T &
    133144                                        return Cost::unsafe;
    134145                                } // if
    135146                        } // if
    136                         // std::cerr << "attempting to convert from incompatible base type -- fail" << std::endl;
     147                        PRINT( std::cerr << "attempting to convert from incompatible base type -- fail" << std::endl; )
    137148                }
    138149                return Cost::infinity;
     
    248259        void ConversionCost::visit(PointerType *pointerType) {
    249260                if ( PointerType *destAsPtr = dynamic_cast< PointerType* >( dest ) ) {
    250                         // std::cerr << pointerType << " ===> " << destAsPtr;
     261                        PRINT( std::cerr << pointerType << " ===> " << destAsPtr; )
    251262                        Type::Qualifiers tq1 = pointerType->get_base()->get_qualifiers();
    252263                        Type::Qualifiers tq2 = destAsPtr->get_base()->get_qualifiers();
     
    257268                                } else {
    258269                                        // types are the same, except otherPointer has more qualifiers
    259                                         // std::cerr << " :: compatible and good qualifiers" << std::endl;
     270                                        PRINT( std::cerr << " :: compatible and good qualifiers" << std::endl; )
    260271                                        cost = Cost::safe;
    261272                                }
    262273                        } else {  // xxx - this discards qualifiers from consideration -- reducing qualifiers is a safe conversion; is this right?
    263274                                int assignResult = ptrsAssignable( pointerType->get_base(), destAsPtr->get_base(), env );
    264                                 // std::cerr << " :: " << assignResult << std::endl;
     275                                PRINT( std::cerr << " :: " << assignResult << std::endl; )
    265276                                if ( assignResult < 0 && pointerType->get_base()->get_qualifiers() <= destAsPtr->get_qualifiers() ) {
    266277                                        cost = Cost::safe;
     
    291302                        cost.incUnsafe(); // lose qualifiers as last resort
    292303                }
    293                 // std::cerr << refType << " ==> " << dest << " " << cost << std::endl;
     304                PRINT( std::cerr << refType << " ==> " << dest << " " << cost << std::endl; )
    294305        }
    295306
  • src/ResolvExpr/PtrsAssignable.cc

    rd104b02 r5ccb10d  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // PtrsAssignable.cc -- 
     7// PtrsAssignable.cc --
    88//
    99// Author           : Richard C. Bilson
     
    8383        void PtrsAssignable::visit(  __attribute__((unused)) UnionInstType *inst ) {}
    8484
    85         void PtrsAssignable::visit( EnumInstType *inst ) {
    86                 if ( dynamic_cast< EnumInstType* >( inst ) ) {
     85        void PtrsAssignable::visit( EnumInstType * ) {
     86                if ( dynamic_cast< EnumInstType* >( dest ) ) {
    8787                        result = 1;
    88                 } else if ( BasicType *bt = dynamic_cast< BasicType* >( inst ) ) {
     88                } else if ( BasicType *bt = dynamic_cast< BasicType* >( dest ) ) {
    8989                        result = bt->get_kind() == BasicType::SignedInt;
    9090                }
     
    105105        void PtrsAssignable::visit(  __attribute__((unused)) ZeroType *zeroType ) {}
    106106        void PtrsAssignable::visit(  __attribute__((unused)) OneType *oneType ) {}
    107        
     107
    108108} // namespace ResolvExpr
    109109
  • src/SynTree/Expression.cc

    rd104b02 r5ccb10d  
    611611CompoundLiteralExpr::CompoundLiteralExpr( Type * type, Initializer * initializer ) : initializer( initializer ) {
    612612        assert( type && initializer );
     613        type->set_lvalue( true );
    613614        set_result( type );
    614615}
  • src/SynTree/TupleExpr.cc

    rd104b02 r5ccb10d  
    6060        assertf( type->size() > index, "TupleIndexExpr index out of bounds: tuple size %d, requested index %d in expr %s", type->size(), index, toString( tuple ).c_str() );
    6161        set_result( (*std::next( type->get_types().begin(), index ))->clone() );
    62         get_result()->set_lvalue( type->get_lvalue() );
     62        // like MemberExpr, TupleIndexExpr is always an lvalue
     63        get_result()->set_lvalue( true );
    6364}
    6465
  • src/SynTree/Type.h

    rd104b02 r5ccb10d  
    311311        virtual int referenceDepth() const;
    312312
     313        // Since reference types act like value types, their size is the size of the base.
     314        // This makes it simple to cast the empty tuple to a reference type, since casts that increase
     315        // the number of values are disallowed.
     316        virtual unsigned size() const { return base->size(); }
     317
    313318        virtual ReferenceType *clone() const { return new ReferenceType( *this ); }
    314319        virtual void accept( Visitor & v ) { v.visit( this ); }
  • src/prelude/prelude.cf

    rd104b02 r5ccb10d  
    456456forall( dtype DT ) const volatile DT *  ?=?( const volatile DT * volatile &, zero_t );
    457457
    458 forall( ftype FT ) FT *                 ?=?( FT *          &, forall( ftype FT2 ) FT2 * );
    459 forall( ftype FT ) FT *                 ?=?( FT * volatile &, forall( ftype FT2 ) FT2 * );
     458forall( ftype FT ) FT *                 ?=?( FT *          &, zero_t );
     459forall( ftype FT ) FT *                 ?=?( FT * volatile &, zero_t );
    460460
    461461forall( dtype T | sized(T) ) T *                        ?+=?(                T *          &, ptrdiff_t );
     
    806806forall( dtype DT ) void ?{}( const volatile DT *          &, zero_t );
    807807
    808 forall( ftype FT ) void ?{}( FT *          &, forall( ftype FT2 ) FT2 * );
     808forall( ftype FT ) void ?{}( FT *          &, zero_t );
    809809
    810810// default ctors
Note: See TracChangeset for help on using the changeset viewer.