Changeset 3d618a0

Timestamp:

Sep 9, 2024, 6:16:09 PM (6 months ago)

Author:

JiadaL <j82liang@…>

Branches:

master

Children:

aa14aafe

Parents:

d93b813 (diff), f5dbc8d (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge branch 'master' of plg.uwaterloo.ca:software/cfa/cfa-cc

Files:

• src/AST/Expr.cpp (modified) (2 diffs)
• src/AST/Expr.hpp (modified) (2 diffs)
• src/AST/Pass.hpp (modified) (1 diff)
• src/AST/Pass.impl.hpp (modified) (2 diffs)
• src/AST/Print.cpp (modified) (2 diffs)
• src/AST/Util.cpp (modified) (2 diffs)
• src/CodeGen/CodeGenerator.cpp (modified) (2 diffs)
• src/Concurrency/Waitfor.cpp (modified) (1 diff)
• src/GenPoly/Box.cpp (modified) (2 diffs)
• src/GenPoly/GenPoly.cpp (modified) (1 diff)
• src/GenPoly/Lvalue.cpp (modified) (2 diffs)
• src/Parser/StatementNode.cpp (modified) (2 diffs)
• src/Parser/TypeData.cpp (modified) (1 diff)
• src/Parser/parser.yy (modified) (1 diff)
• src/ResolvExpr/CandidateFinder.cpp (modified) (4 diffs)
• src/ResolvExpr/ConversionCost.cpp (modified) (2 diffs)
• src/ResolvExpr/Unify.cpp (modified) (1 diff)
• src/Validate/InitializerLength.cpp (modified) (1 diff)
• tests/.expect/alloc-ERROR.txt (modified) (1 diff)
• tests/.expect/extension.arm64.txt (modified) (2 diffs)
• tests/.expect/extension.x64.txt (modified) (2 diffs)
• tests/.expect/extension.x86.txt (modified) (2 diffs)

src/AST/Expr.cpp ¶

@@ -276 +276 @@
 // --- SizeofExpr
 
-SizeofExpr::SizeofExpr( const CodeLocation & loc, const Expr * e )
-: Expr( loc, new BasicType{ BasicKind::LongUnsignedInt } ), expr( e ), type( nullptr ) {}
-
 SizeofExpr::SizeofExpr( const CodeLocation & loc, const Type * t )
-: Expr( loc, new BasicType{ BasicKind::LongUnsignedInt } ), expr( nullptr ), type( t ) {}
+: Expr( loc, new BasicType{ BasicKind::LongUnsignedInt } ), type( t ) {}
 
 // --- CountExpr
@@ -292 +289 @@
 // --- AlignofExpr
 
-AlignofExpr::AlignofExpr( const CodeLocation & loc, const Expr * e )
-: Expr( loc, new BasicType{ BasicKind::LongUnsignedInt } ), expr( e ), type( nullptr ) {}
-
 AlignofExpr::AlignofExpr( const CodeLocation & loc, const Type * t )
-: Expr( loc, new BasicType{ BasicKind::LongUnsignedInt } ), expr( nullptr ), type( t ) {}
+: Expr( loc, new BasicType{ BasicKind::LongUnsignedInt } ), type( t ) {}
 
 // --- OffsetofExpr

src/AST/Expr.hpp ¶

@@ -480 +480 @@
 class SizeofExpr final : public Expr {
 public:
+        ptr<Type> type;
+
+        SizeofExpr( const CodeLocation & loc, const Type * t );
+
+        const Expr * accept( Visitor & v ) const override { return v.visit( this ); }
+private:
+        SizeofExpr * clone() const override { return new SizeofExpr{ *this }; }
+        MUTATE_FRIEND
+};
+
+class CountExpr final : public Expr {
+public:
         ptr<Expr> expr;
         ptr<Type> type;
 
-        SizeofExpr( const CodeLocation & loc, const Expr * e );
-        SizeofExpr( const CodeLocation & loc, const Type * t );
-        // deliberately no disambiguating overload for nullptr_t
-
-        const Expr * accept( Visitor & v ) const override { return v.visit( this ); }
-private:
-        SizeofExpr * clone() const override { return new SizeofExpr{ *this }; }
-        MUTATE_FRIEND
-};
-
-class CountExpr final : public Expr {
-public:
-        ptr<Expr> expr;
-        ptr<Type> type;
-
         CountExpr( const CodeLocation & loc, const Expr * t );
         CountExpr( const CodeLocation & loc, const Type * t );
@@ -510 +507 @@
 class AlignofExpr final : public Expr {
 public:
-        ptr<Expr> expr;
         ptr<Type> type;
 
-        AlignofExpr( const CodeLocation & loc, const Expr * e );
         AlignofExpr( const CodeLocation & loc, const Type * t );
-        // deliberately no disambiguating overload for nullptr_t
 
         const Expr * accept( Visitor & v ) const override { return v.visit( this ); }

src/AST/Pass.hpp ¶

@@ -342 +342 @@
 /// set visit_children false of all child nodes should be ignored
 struct WithShortCircuiting {
-        bool visit_children;
+        bool visit_children = true;
 };
 

src/AST/Pass.impl.hpp ¶

@@ -1319 +1319 @@
                         maybe_accept( node, &SizeofExpr::result );
                 }
-                if ( node->type ) {
-                        maybe_accept( node, &SizeofExpr::type );
-                } else {
-                        maybe_accept( node, &SizeofExpr::expr );
-                }
+                maybe_accept( node, &SizeofExpr::type );
         }
 
@@ -1359 +1355 @@
                         maybe_accept( node, &AlignofExpr::result );
                 }
-                if ( node->type ) {
-                        maybe_accept( node, &AlignofExpr::type );
-                } else {
-                        maybe_accept( node, &AlignofExpr::expr );
-                }
+                maybe_accept( node, &AlignofExpr::type );
         }
 

src/AST/Print.cpp ¶

@@ -1152 +1152 @@
                 os << "Sizeof Expression on: ";
                 ++indent;
+                node->type->accept( *this );
+                --indent;
+                postprint( node );
+
+                return node;
+        }
+
+        virtual const ast::Expr * visit( const ast::CountExpr * node ) override final {
+                os << "Count Expression on: ";
+                ++indent;
                 if ( node->type ) node->type->accept( *this );
                 else safe_print( node->expr );
                 --indent;
                 postprint( node );
-
-                return node;
-        }
-
-        virtual const ast::Expr * visit( const ast::CountExpr * node ) override final {
-                os << "Count Expression on: ";
-                ++indent;
-                if ( node->type ) node->type->accept( *this );
-                else safe_print( node->expr );
-                --indent;
-                postprint( node );
                 return node;
         }
@@ -1173 +1172 @@
                 os << "Alignof Expression on: ";
                 ++indent;
-                if ( node->type ) node->type->accept( *this );
-                else safe_print( node->expr );
+                node->type->accept( *this );
                 --indent;
                 postprint( node );

src/AST/Util.cpp ¶

@@ -104 +104 @@
         }
         assertf( false, "Member not found." );
-}
-
-template<typename node_t>
-void oneOfExprOrType( const node_t * node ) {
-        if ( node->expr ) {
-                assertf( node->expr && !node->type, "Exactly one of expr or type should be set." );
-        } else {
-                assertf( !node->expr && node->type, "Exactly one of expr or type should be set." );
-        }
 }
 
@@ -159 +150 @@
                 previsit( (const ParseNode *)node );
                 memberMatchesAggregate( node );
-        }
-
-        void previsit( const SizeofExpr * node ) {
-                previsit( (const ParseNode *)node );
-                oneOfExprOrType( node );
-        }
-
-        void previsit( const AlignofExpr * node ) {
-                previsit( (const ParseNode *)node );
-                oneOfExprOrType( node );
         }
 

src/CodeGen/CodeGenerator.cpp ¶

@@ -744 +744 @@
         extension( expr );
         output << "sizeof(";
-        if ( expr->type ) {
+        if ( auto type = expr->type.as<ast::TypeofType>() ) {
+                type->expr->accept( *visitor );
+        } else {
                 output << genType( expr->type, "", options );
-        } else {
-                expr->expr->accept( *visitor );
         }
         output << ")";
@@ -756 +756 @@
         extension( expr );
         output << "__alignof__(";
-        if ( expr->type ) {
+        if ( auto type = expr->type.as<ast::TypeofType>() ) {
+                type->expr->accept( *visitor );
+        } else {
                 output << genType( expr->type, "", options );
-        } else {
-                expr->expr->accept( *visitor );
         }
         output << ")";

src/Concurrency/Waitfor.cpp ¶

@@ -230 +230 @@
                         ast::ConstantExpr::from_int( location, 0 ),
                         new ast::SizeofExpr( location,
-                                new ast::VariableExpr( location, acceptables ) ),
+                                new ast::TypeofType(
+                                        new ast::VariableExpr( location, acceptables ) ) ),
                 }
         );

src/GenPoly/Box.cpp ¶

@@ -1925 +1925 @@
 ast::Expr const * PolyGenericCalculator::postvisit(
                 ast::SizeofExpr const * expr ) {
-        ast::Type const * type = expr->type ? expr->type : expr->expr->result;
-        ast::Expr const * gen = genSizeof( expr->location, type );
+        ast::Expr const * gen = genSizeof( expr->location, expr->type );
         return ( gen ) ? gen : expr;
 }
@@ -1932 +1931 @@
 ast::Expr const * PolyGenericCalculator::postvisit(
                 ast::AlignofExpr const * expr ) {
-        ast::Type const * type = expr->type ? expr->type : expr->expr->result;
-        ast::Expr const * gen = genAlignof( expr->location, type );
+        ast::Expr const * gen = genAlignof( expr->location, expr->type );
         return ( gen ) ? gen : expr;
 }

src/GenPoly/GenPoly.cpp ¶

@@ -299 +299 @@
                 ast::SizeofExpr const * r = as<ast::SizeofExpr>(rhs);
 
-                assert((l->type != nullptr) ^ (l->expr != nullptr));
-                assert((r->type != nullptr) ^ (r->expr != nullptr));
-                if ( !(l->type && r->type) ) return false;
+                assert( l->type );
+                assert( r->type );
 
                 // mutual recursion with type poly compatibility

src/GenPoly/Lvalue.cpp ¶

@@ -607 +607 @@
 ast::SizeofExpr const * ReferenceTypeElimination::previsit(
                 ast::SizeofExpr const * expr ) {
-        if ( expr->expr ) return expr;
         return ast::mutate_field( expr, &ast::SizeofExpr::type,
                 expr->type->stripReferences() );
@@ -614 +613 @@
 ast::AlignofExpr const * ReferenceTypeElimination::previsit(
                 ast::AlignofExpr const * expr ) {
-        if ( expr->expr ) return expr;
         return ast::mutate_field( expr, &ast::AlignofExpr::type,
                 expr->type->stripReferences() );

src/Parser/StatementNode.cpp ¶

@@ -11 +11 @@
 // Created On       : Sat May 16 14:59:41 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Fri Aug 11 11:44:15 2023
-// Update Count     : 429
+// Last Modified On : Mon Sep  9 11:28:07 2024
+// Update Count     : 430
 //
 
@@ -208 +208 @@
 
 ast::Stmt * build_for( const CodeLocation & location, ForCtrl * forctl, StatementNode * stmt, StatementNode * else_ ) {
-        std::vector<ast::ptr<ast::Stmt>> astinit;                                               // maybe empty
+        std::vector<ast::ptr<ast::Stmt>> astinit;                       // maybe empty
         buildMoveList( forctl->init, astinit );
 
         if ( forctl->range_over ) {
                 ast::Expr * range_over = maybeMoveBuild( forctl->range_over );
+                auto kind = forctl->kind;                                               // save before delete, used in return
                 delete forctl;
                 return new ast::ForStmt( location,
                         std::move( astinit ),
-                        range_over, forctl->kind == OperKinds::LEThan,
+                        range_over, kind == OperKinds::LEThan,
                         buildMoveSingle( stmt ),
                         buildMoveOptional( else_ )

src/Parser/TypeData.cpp ¶

@@ -1476 +1476 @@
                 } else if ( cur->has_enumeratorValue() ) {
                         ast::Expr * initValue;
-                        if (ret->isCfa && ret->base) {
-                                initValue = new ast::CastExpr( cur->enumeratorValue->location, maybeMoveBuild( cur->consume_enumeratorValue() ), ret->base  );
+                        if ( ret->isCfa && ret->base ) {
+                                CodeLocation location = cur->enumeratorValue->location;
+                                initValue = new ast::CastExpr( location, maybeMoveBuild( cur->consume_enumeratorValue() ), ret->base );
                         } else {
                                 initValue = maybeMoveBuild( cur->consume_enumeratorValue() );

src/Parser/parser.yy ¶

@@ -927 +927 @@
                 { $$ = new ExpressionNode( build_unary_val( yylloc, OperKinds::Decr, $2 ) ); }
         | SIZEOF unary_expression
-                { $$ = new ExpressionNode( new ast::SizeofExpr( yylloc, maybeMoveBuild( $2 ) ) ); }
+                { $$ = new ExpressionNode( new ast::SizeofExpr( yylloc, new ast::TypeofType( maybeMoveBuild( $2 ) ) ) ); }
         | SIZEOF '(' type_no_function ')'
                 { $$ = new ExpressionNode( new ast::SizeofExpr( yylloc, maybeMoveBuildType( $3 ) ) ); }
         | ALIGNOF unary_expression                                                      // GCC, variable alignment
-                { $$ = new ExpressionNode( new ast::AlignofExpr( yylloc, maybeMoveBuild( $2 ) ) ); }
+                { $$ = new ExpressionNode( new ast::AlignofExpr( yylloc, new ast::TypeofType( maybeMoveBuild( $2 ) ) ) ); }
         | ALIGNOF '(' type_no_function ')'                                      // GCC, type alignment
                 { $$ = new ExpressionNode( new ast::AlignofExpr( yylloc, maybeMoveBuildType( $3 ) ) ); }

src/ResolvExpr/CandidateFinder.cpp ¶

@@ -10 +10 @@
 // Created On       : Wed Jun 5 14:30:00 2019
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Sat Jun 22 08:07:26 2024
-// Update Count     : 4
+// Last Modified On : Mon Sep  9 11:30:11 2024
+// Update Count     : 5
 //
 
@@ -1239 +1239 @@
                 CandidateList matches;
                 Cost minExprCost = Cost::infinity;
-                Cost minCastCost = Cost::infinity;
+                // Cost minCastCost = Cost::infinity;
                 for ( CandidateRef & cand : finder.candidates ) {
                         ast::ptr< ast::Type > fromType = cand->expr->result;
@@ -1482 +1482 @@
 
         void Finder::postvisit( const ast::SizeofExpr * sizeofExpr ) {
-                if ( sizeofExpr->type ) {
-                        addCandidate(
-                                new ast::SizeofExpr{
-                                        sizeofExpr->location, resolveTypeof( sizeofExpr->type, context ) },
-                                tenv );
-                } else {
-                        // find all candidates for the argument to sizeof
-                        CandidateFinder finder( context, tenv );
-                        finder.find( sizeofExpr->expr );
-                        // find the lowest-cost candidate, otherwise ambiguous
-                        CandidateList winners = findMinCost( finder.candidates );
-                        if ( winners.size() != 1 ) {
-                                SemanticError(
-                                        sizeofExpr->expr.get(), "Ambiguous expression in sizeof operand: " );
-                        }
-                        // return the lowest-cost candidate
-                        CandidateRef & choice = winners.front();
-                        choice->expr = referenceToRvalueConversion( choice->expr, choice->cost );
-                        choice->cost = Cost::zero;
-                        addCandidate( *choice, new ast::SizeofExpr{ sizeofExpr->location, choice->expr } );
-                }
+                addCandidate(
+                        new ast::SizeofExpr{
+                                sizeofExpr->location, resolveTypeof( sizeofExpr->type, context ) },
+                        tenv );
         }
 
@@ -1537 +1520 @@
 
         void Finder::postvisit( const ast::AlignofExpr * alignofExpr ) {
-                if ( alignofExpr->type ) {
-                        addCandidate(
-                                new ast::AlignofExpr{
-                                        alignofExpr->location, resolveTypeof( alignofExpr->type, context ) },
-                                tenv );
-                } else {
-                        // find all candidates for the argument to alignof
-                        CandidateFinder finder( context, tenv );
-                        finder.find( alignofExpr->expr );
-                        // find the lowest-cost candidate, otherwise ambiguous
-                        CandidateList winners = findMinCost( finder.candidates );
-                        if ( winners.size() != 1 ) {
-                                SemanticError(
-                                        alignofExpr->expr.get(), "Ambiguous expression in alignof operand: " );
-                        }
-                        // return the lowest-cost candidate
-                        CandidateRef & choice = winners.front();
-                        choice->expr = referenceToRvalueConversion( choice->expr, choice->cost );
-                        choice->cost = Cost::zero;
-                        addCandidate(
-                                *choice, new ast::AlignofExpr{ alignofExpr->location, choice->expr } );
-                }
+                addCandidate(
+                        new ast::AlignofExpr{
+                                alignofExpr->location, resolveTypeof( alignofExpr->type, context ) },
+                        tenv );
         }
 

src/ResolvExpr/ConversionCost.cpp ¶

@@ -192 +192 @@
 
 Cost enumCastCost (
-        const ast::EnumInstType * src, const ast::EnumInstType * dst, 
+        const ast::EnumInstType * src, const ast::EnumInstType * dst,
         const ast::SymbolTable & symtab, const ast::TypeEnvironment & env
 );
@@ -488 +488 @@
 // (dst) src is safe is src is a subtype of dst, or dst {inline src, ...}
 Cost enumCastCost (
-        const ast::EnumInstType * src, const ast::EnumInstType * dst, 
+        const ast::EnumInstType * src, const ast::EnumInstType * dst,
         const ast::SymbolTable & symtab, const ast::TypeEnvironment & env
 ) {

src/ResolvExpr/Unify.cpp ¶

@@ -234 +234 @@
                         if ( !e2so ) return;
 
-                        assert((e1->type != nullptr) ^ (e1->expr != nullptr));
-                        assert((e2so->type != nullptr) ^ (e2so->expr != nullptr));
-                        if ( !(e1->type && e2so->type) ) return;
-
                         // expression unification calls type unification (mutual recursion)
                         result = unifyExact( e1->type, e2so->type, tenv, need, have, open, widen );

src/Validate/InitializerLength.cpp ¶

@@ -29 +29 @@
 ///   int x[] = { 1, 2, 3 };
 ///   int y[][2] = { { 1, 2, 3 }, { 1, 2, 3 } };
+///   char z[] = "hello";
 /// here x and y are known at compile-time to have length 3, so change this into
 ///   int x[3] = { 1, 2, 3 };
 ///   int y[3][2] = { { 1, 2, 3 }, { 1, 2, 3 } };
+///   char z[6] = "hello";
 struct InitializerLength {
         const ast::ObjectDecl * previsit( const ast::ObjectDecl * decl );
 };
 
+ast::ConstantExpr * makeDimension( const ast::ObjectDecl * decl ) {
+        if ( auto init = decl->init.as<ast::ListInit>() ) {
+                return ast::ConstantExpr::from_ulong( decl->location, init->size() );
+        } else if ( auto init = decl->init.as<ast::SingleInit>() ) {
+                if ( auto constant = init->value.as<ast::ConstantExpr>() ) {
+                        if ( auto type = constant->result.as<ast::ArrayType>() ) {
+                                if ( auto dim = type->dimension.as<ast::ConstantExpr>() ) {
+                                        ast::ConstantExpr * dimension = ast::deepCopy( dim );
+                                        dimension->location = decl->location;
+                                        return dimension;
+                                }
+                        }
+                }
+        }
+        return nullptr;
+}
+
 const ast::ObjectDecl * InitializerLength::previsit( const ast::ObjectDecl * decl ) {
         if ( auto type = decl->type.as<ast::ArrayType>() ) {
                 if ( type->dimension ) return decl;
-                if ( auto init = decl->init.as<ast::ListInit>() ) {
+                if ( auto dimension = makeDimension( decl ) ) {
                         ast::ObjectDecl * mutDecl = ast::mutate( decl );
                         ast::ArrayType * mutType = ast::mutate( type );
-                        mutType->dimension = ast::ConstantExpr::from_ulong(
-                                mutDecl->location, init->size() );
+                        mutType->dimension = dimension;
                         mutDecl->type = mutType;
                         return mutDecl;

tests/.expect/alloc-ERROR.txt ¶

@@ -11 +11 @@
     ...to:
       Name: dim
-      Sizeof Expression on: Applying untyped:
+      Sizeof Expression on: type-of expression Applying untyped:
           Name: *?
         ...to:

tests/.expect/extension.arm64.txt ¶

@@ -465 +465 @@
     }
     {
-        ((void)__extension__ sizeof(3));
+        ((void)__extension__ sizeof(signed int ));
     }
 
@@ -473 +473 @@
 
     {
-        ((void)__extension__ __alignof__(__extension__ _X1ai_2));
+        ((void)__extension__ __alignof__(signed int ));
     }
 

tests/.expect/extension.x64.txt ¶

@@ -465 +465 @@
     }
     {
-        ((void)__extension__ sizeof(3));
+        ((void)__extension__ sizeof(signed int ));
     }
 
@@ -473 +473 @@
 
     {
-        ((void)__extension__ __alignof__(__extension__ _X1ai_2));
+        ((void)__extension__ __alignof__(signed int ));
     }
 

tests/.expect/extension.x86.txt ¶

@@ -465 +465 @@
     }
     {
-        ((void)__extension__ sizeof(3));
+        ((void)__extension__ sizeof(signed int ));
     }
 
@@ -473 +473 @@
 
     {
-        ((void)__extension__ __alignof__(__extension__ _X1ai_2));
+        ((void)__extension__ __alignof__(signed int ));
     }