Changeset 00675a1 for src

Timestamp:

May 10, 2022, 12:25:05 PM (4 years ago)

Author:

Thierry Delisle <tdelisle@…>

Branches:

ADT, ast-experimental, master, pthread-emulation, qualifiedEnum

Children:

8faa6612

Parents:

3b80db8 (diff), 7edd5c1 (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

Location:

src

Files:

• AST/Convert.cpp (modified) (3 diffs)
• AST/Copy.cpp (modified) (2 diffs)
• AST/Decl.cpp (modified) (3 diffs)
• AST/Decl.hpp (modified) (2 diffs)
• AST/Expr.hpp (modified) (1 diff)
• AST/Node.hpp (modified) (2 diffs)
• AST/Stmt.cpp (modified) (2 diffs)
• Common/SemanticError.h (modified) (4 diffs)
• ControlStruct/MultiLevelExit.cpp (modified) (1 diff)
• Parser/parser.yy (modified) (7 diffs)
• Validate/Autogen.cpp (modified) (2 diffs)

src/AST/Convert.cpp

@@ -93 +93 @@
         };
 
-    template<typename T>
-    Getter<T> get() {
-        return Getter<T>{ *this };
-    }
+        template<typename T>
+        Getter<T> get() {
+                return Getter<T>{ *this };
+        }
 
         Label makeLabel(Statement * labelled, const ast::Label& label) {
@@ -1651 +1651 @@
                         // GET_ACCEPT_1(type, FunctionType),
                         std::move(forall),
+                        std::move(assertions),
                         std::move(paramVars),
                         std::move(returnVars),
@@ -1664 +1665 @@
                 cache.emplace( old, decl );
 
-                decl->assertions = std::move(assertions);
                 decl->withExprs = GET_ACCEPT_V(withExprs, Expr);
                 decl->stmts = GET_ACCEPT_1(statements, CompoundStmt);

src/AST/Copy.cpp

@@ -10 +10 @@
 // Created On       : Thr Nov 11  9:16:00 2019
 // Last Modified By : Andrew Beach
-// Last Modified On : Thr Nov 11  9:28:00 2021
-// Update Count     : 0
+// Last Modified On : Tue May  3 16:28:00 2022
+// Update Count     : 1
 //
 
@@ -77 +77 @@
         }
 
+        void postvisit( const UniqueExpr * node ) {
+                readonlyInsert( &node->object );
+        }
+
         void postvisit( const MemberExpr * node ) {
                 readonlyInsert( &node->member );

src/AST/Decl.cpp

@@ -9 +9 @@
 // Author           : Aaron B. Moss
 // Created On       : Thu May 9 10:00:00 2019
-// Last Modified By : Peter A. Buhr
-// Last Modified On : Tue Jan 12 16:54:55 2021
-// Update Count     : 23
+// Last Modified By : Andrew Beach
+// Last Modified On : Thu May  5 12:10:00 2022
+// Update Count     : 24
 //
 
@@ -53 +53 @@
 // --- FunctionDecl
 
-FunctionDecl::FunctionDecl( const CodeLocation & loc, const std::string & name, 
+FunctionDecl::FunctionDecl( const CodeLocation & loc, const std::string & name,
         std::vector<ptr<TypeDecl>>&& forall,
         std::vector<ptr<DeclWithType>>&& params, std::vector<ptr<DeclWithType>>&& returns,
@@ -74 +74 @@
         }
         this->type = ftype;
+}
+
+FunctionDecl::FunctionDecl( const CodeLocation & location, const std::string & name,
+        std::vector<ptr<TypeDecl>>&& forall, std::vector<ptr<DeclWithType>>&& assertions,
+        std::vector<ptr<DeclWithType>>&& params, std::vector<ptr<DeclWithType>>&& returns,
+        CompoundStmt * stmts, Storage::Classes storage, Linkage::Spec linkage,
+        std::vector<ptr<Attribute>>&& attrs, Function::Specs fs, bool isVarArgs)
+: DeclWithType( location, name, storage, linkage, std::move(attrs), fs ),
+                params( std::move(params) ), returns( std::move(returns) ),
+                type_params( std::move( forall) ), assertions( std::move( assertions ) ),
+                type( nullptr ), stmts( stmts ) {
+        FunctionType * type = new FunctionType( (isVarArgs) ? VariableArgs : FixedArgs );
+        for ( auto & param : this->params ) {
+                type->params.emplace_back( param->get_type() );
+        }
+        for ( auto & ret : this->returns ) {
+                type->returns.emplace_back( ret->get_type() );
+        }
+        for ( auto & param : this->type_params ) {
+                type->forall.emplace_back( new TypeInstType( param ) );
+        }
+        for ( auto & assertion : this->assertions ) {
+                type->assertions.emplace_back(
+                        new VariableExpr( assertion->location, assertion ) );
+        }
+        this->type = type;
 }
 

src/AST/Decl.hpp

@@ -9 +9 @@
 // Author           : Aaron B. Moss
 // Created On       : Thu May 9 10:00:00 2019
-// Last Modified By : Peter A. Buhr
-// Last Modified On : Fri Mar 12 18:25:05 2021
-// Update Count     : 32
+// Last Modified By : Andrew Beach
+// Last Modified On : Thu May  5 12:09:00 2022
+// Update Count     : 33
 //
 
@@ -135 +135 @@
         std::vector< ptr<Expr> > withExprs;
 
+        // The difference between the two constructors is in how they handle
+        // assertions. The first constructor uses the assertions from the type
+        // parameters, in the style of the old ast, and puts them on the type.
+        // The second takes an explicite list of assertions and builds a list of
+        // references to them on the type.
+
         FunctionDecl( const CodeLocation & loc, const std::string & name, std::vector<ptr<TypeDecl>>&& forall,
                 std::vector<ptr<DeclWithType>>&& params, std::vector<ptr<DeclWithType>>&& returns,
                 CompoundStmt * stmts, Storage::Classes storage = {}, Linkage::Spec linkage = Linkage::C,
                 std::vector<ptr<Attribute>>&& attrs = {}, Function::Specs fs = {}, bool isVarArgs = false);
-        // : DeclWithType( loc, name, storage, linkage, std::move(attrs), fs ), params(std::move(params)), returns(std::move(returns)),
-        //  stmts( stmts ) {}
+
+        FunctionDecl( const CodeLocation & location, const std::string & name,
+                std::vector<ptr<TypeDecl>>&& forall, std::vector<ptr<DeclWithType>>&& assertions,
+                std::vector<ptr<DeclWithType>>&& params, std::vector<ptr<DeclWithType>>&& returns,
+                CompoundStmt * stmts, Storage::Classes storage = {}, Linkage::Spec linkage = Linkage::C,
+                std::vector<ptr<Attribute>>&& attrs = {}, Function::Specs fs = {}, bool isVarArgs = false);
 
         const Type * get_type() const override;

src/AST/Expr.hpp

@@ -784 +784 @@
 public:
         ptr<Expr> expr;
-        ptr<ObjectDecl> object;
+        readonly<ObjectDecl> object;
         ptr<VariableExpr> var;
         unsigned long long id;

src/AST/Node.hpp

@@ -10 +10 @@
 // Created On       : Wed May 8 10:27:04 2019
 // Last Modified By : Andrew Beach
-// Last Modified On : Fri Mar 25 10:33:00 2022
-// Update Count     : 7
+// Last Modified On : Mon May  9 10:20:00 2022
+// Update Count     : 8
 //
 
@@ -49 +49 @@
 
         bool unique() const { return strong_count == 1; }
-        bool isManaged() const {return strong_count > 0; }
+        bool isManaged() const { return strong_count > 0; }
+        bool isReferenced() const { return weak_count > 0; }
 
 private:

src/AST/Stmt.cpp

@@ -9 +9 @@
 // Author           : Aaron B. Moss
 // Created On       : Wed May  8 13:00:00 2019
-// Last Modified By : Peter A. Buhr
-// Last Modified On : Wed Feb  2 19:01:20 2022
-// Update Count     : 3
+// Last Modified By : Andrew Beach
+// Last Modified On : Tue May  3 15:18:20 2022
+// Update Count     : 4
 //
 
 #include "Stmt.hpp"
 
-
+#include "Copy.hpp"
 #include "DeclReplacer.hpp"
 #include "Type.hpp"
@@ -23 +23 @@
 
 // --- CompoundStmt
-CompoundStmt::CompoundStmt( const CompoundStmt& other ) : Stmt(other), kids(other.kids) {
+CompoundStmt::CompoundStmt( const CompoundStmt& other ) : Stmt(other), kids() {
+        // Statements can have weak references to them, if that happens inserting
+        // the original node into the new list will put the original node in a
+        // bad state, where it cannot be mutated. To avoid this, just perform an
+        // additional shallow copy on the statement.
+        for ( const Stmt * kid : other.kids ) {
+                if ( kid->isReferenced() ) {
+                        kids.emplace_back( ast::shallowCopy( kid ) );
+                } else {
+                        kids.emplace_back( kid );
+                }
+        }
+
         // when cloning a compound statement, we may end up cloning declarations which
         // are referred to by VariableExprs throughout the block. Cloning a VariableExpr

src/Common/SemanticError.h

@@ -10 +10 @@
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Thu Jul 19 10:09:17 2018
-// Update Count     : 31
+// Last Modified On : Wed May  4 14:08:26 2022
+// Update Count     : 35
 //
 
@@ -59 +59 @@
         {"aggregate-forward-decl" , Severity::Warn    , "forward declaration of nested aggregate: %s"                },
         {"superfluous-decl"       , Severity::Warn    , "declaration does not allocate storage: %s"                  },
+        {"superfluous-else"       , Severity::Warn    , "else clause never executed for empty loop conditional"      },
         {"gcc-attributes"         , Severity::Warn    , "invalid attribute: %s"                                      },
         {"c++-like-copy"          , Severity::Warn    , "Constructor from reference is not a valid copy constructor" },
@@ -69 +70 @@
         AggrForwardDecl,
         SuperfluousDecl,
+        SuperfluousElse,
         GccAttributes,
         CppCopy,
@@ -79 +81 @@
 );
 
-#define SemanticWarning(loc, id, ...) SemanticWarningImpl(loc, id, WarningFormats[(int)id].message, __VA_ARGS__)
+#define SemanticWarning(loc, id, ...) SemanticWarningImpl(loc, id, WarningFormats[(int)id].message, ##__VA_ARGS__)
 
 void SemanticWarningImpl (CodeLocation loc, Warning warn, const char * const fmt, ...) __attribute__((format(printf, 3, 4)));

src/ControlStruct/MultiLevelExit.cpp

@@ -594 +594 @@
                 }
 
+                // check if loop node and if so add else clause if it exists
+                const WhileDoStmt * whilePtr = dynamic_cast<const WhileDoStmt *>(kid.get());
+                if ( whilePtr && whilePtr->else_) ret.push_back(whilePtr->else_);
+                const ForStmt * forPtr = dynamic_cast<const ForStmt *>(kid.get());
+                if ( forPtr && forPtr->else_) ret.push_back(forPtr->else_);
+
                 if ( ! break_label.empty() ) {
                         ret.push_back( labelledNullStmt( ret.back()->location, break_label ) );

src/Parser/parser.yy

@@ -10 +10 @@
 // Created On       : Sat Sep  1 20:22:55 2001
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Mon Mar 14 16:35:29 2022
-// Update Count     : 5276
+// Last Modified On : Wed May  4 17:22:48 2022
+// Update Count     : 5279
 //
 
@@ -111 +111 @@
 
 void distInl( DeclarationNode * declaration ) {
-        // distribute EXTENSION across all declarations
+        // distribute INLINE across all declarations
         for ( DeclarationNode *iter = declaration; iter != nullptr; iter = (DeclarationNode *)iter->get_next() ) {
                 iter->set_inLine( true );
@@ -1221 +1221 @@
 
 iteration_statement:
-        WHILE '(' ')' statement                                                         // CFA => while ( 1 )
+        WHILE '(' ')' statement                                                         %prec THEN // CFA => while ( 1 )
                 { $$ = new StatementNode( build_while( new CondCtl( nullptr, new ExpressionNode( build_constantInteger( *new string( "1" ) ) ) ), maybe_build_compound( $4 ) ) ); }
+        | WHILE '(' ')' statement ELSE statement                        // CFA
+                {
+                        $$ = new StatementNode( build_while( new CondCtl( nullptr, new ExpressionNode( build_constantInteger( *new string( "1" ) ) ) ), maybe_build_compound( $4 ) ) );
+                        SemanticWarning( yylloc, Warning::SuperfluousElse );
+                }
         | WHILE '(' conditional_declaration ')' statement       %prec THEN
                 { $$ = new StatementNode( build_while( $3, maybe_build_compound( $5 ) ) ); }
@@ -1229 +1234 @@
         | DO statement WHILE '(' ')' ';'                                        // CFA => do while( 1 )
                 { $$ = new StatementNode( build_do_while( new ExpressionNode( build_constantInteger( *new string( "1" ) ) ), maybe_build_compound( $2 ) ) ); }
-        | DO statement WHILE '(' comma_expression ')' ';'       %prec THEN
+        | DO statement WHILE '(' ')' ELSE statement                     // CFA
+                {
+                        $$ = new StatementNode( build_do_while( new ExpressionNode( build_constantInteger( *new string( "1" ) ) ), maybe_build_compound( $2 ) ) );
+                        SemanticWarning( yylloc, Warning::SuperfluousElse );
+                }
+        | DO statement WHILE '(' comma_expression ')' ';'
                 { $$ = new StatementNode( build_do_while( $5, maybe_build_compound( $2 ) ) ); }
         | DO statement WHILE '(' comma_expression ')' ELSE statement // CFA
                 { $$ = new StatementNode( build_do_while( $5, maybe_build_compound( $2 ), $8 ) ); }
-        | FOR '(' ')' statement                                                         // CFA => for ( ;; )
+        | FOR '(' ')' statement                                                         %prec THEN // CFA => for ( ;; )
                 { $$ = new StatementNode( build_for( new ForCtrl( (ExpressionNode * )nullptr, (ExpressionNode * )nullptr, (ExpressionNode * )nullptr ), maybe_build_compound( $4 ) ) ); }
+        | FOR '(' ')' statement ELSE statement                          // CFA
+                {
+                        $$ = new StatementNode( build_for( new ForCtrl( (ExpressionNode * )nullptr, (ExpressionNode * )nullptr, (ExpressionNode * )nullptr ), maybe_build_compound( $4 ) ) );
+                        SemanticWarning( yylloc, Warning::SuperfluousElse );
+                }
         | FOR '(' for_control_expression_list ')' statement     %prec THEN
                 { $$ = new StatementNode( build_for( $3, maybe_build_compound( $5 ) ) ); }
@@ -2318 +2333 @@
                         { SemanticError( yylloc, "storage-class and CV qualifiers are not meaningful for enumeration constants, which are const." ); }
 
-                        $$ = DeclarationNode::newEnum( nullptr, $7, true, $3 ) ->addQualifiers( $5 );
+                        $$ = DeclarationNode::newEnum( nullptr, $7, true, $3 )->addQualifiers( $5 );
                 }
         | ENUM '(' cfa_abstract_parameter_declaration ')' attribute_list_opt identifier attribute_list_opt
@@ -2327 +2342 @@
           '{' enumerator_list comma_opt '}'
                 {
-                        $$ = DeclarationNode::newEnum( $6, $10, true, $3 ) -> addQualifiers( $5 ) -> addQualifiers( $7 );
+                        $$ = DeclarationNode::newEnum( $6, $10, true, $3 )->addQualifiers( $5 )->addQualifiers( $7 );
                 }
         | ENUM '(' cfa_abstract_parameter_declaration ')' attribute_list_opt typedef_name attribute_list_opt '{' enumerator_list comma_opt '}'
@@ -2333 +2348 @@
                         if ( $3->storageClasses.val != 0 || $3->type->qualifiers.val != 0 ) { SemanticError( yylloc, "storage-class and CV qualifiers are not meaningful for enumeration constants, which are const." ); }
                         typedefTable.makeTypedef( *$6->name );
-                        $$ = DeclarationNode::newEnum( $6->name, $9, true, $3 ) -> addQualifiers( $5 ) -> addQualifiers( $7 );
+                        $$ = DeclarationNode::newEnum( $6->name, $9, true, $3 )->addQualifiers( $5 )->addQualifiers( $7 );
                 }
         | enum_type_nobody

src/Validate/Autogen.cpp

@@ -350 +350 @@
                 name,
                 std::move( type_params ),
+                std::move( assertions ),
                 std::move( params ),
                 std::move( returns ),
@@ -360 +361 @@
                 // Auto-generated routines are inline to avoid conflicts.
                 ast::Function::Specs( ast::Function::Inline ) );
-        decl->assertions = std::move( assertions );
         decl->fixUniqueId();
         return decl;