Changeset c4c8571 for src

Timestamp:

Jul 28, 2022, 12:04:25 PM (3 years ago)

Author:

Thierry Delisle <tdelisle@…>

Branches:

ADT, ast-experimental, master, pthread-emulation

Children:

32d1383, d0fcc82

Parents:

3f95dab (diff), 2af1943 (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/Decl.hpp (modified) (2 diffs)
• GenPoly/SpecializeNew.cpp (modified) (3 diffs)
• InitTweak/InitTweak.cc (modified) (10 diffs)
• SymTab/Autogen.cc (modified) (1 diff)

src/AST/Decl.hpp

@@ -143 +143 @@
         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,
+                CompoundStmt * stmts, Storage::Classes storage = {}, Linkage::Spec linkage = Linkage::Cforall,
                 std::vector<ptr<Attribute>>&& attrs = {}, Function::Specs fs = {}, bool isVarArgs = false);
 
@@ -149 +149 @@
                 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,
+                CompoundStmt * stmts, Storage::Classes storage = {}, Linkage::Spec linkage = Linkage::Cforall,
                 std::vector<ptr<Attribute>>&& attrs = {}, Function::Specs fs = {}, bool isVarArgs = false);
 

src/GenPoly/SpecializeNew.cpp

@@ -230 +230 @@
         if ( auto tuple = type.as<ast::TupleType>() ) {
                 std::vector<ast::ptr<ast::Expr>> exprs;
-                for ( const ast::Type * t : *tuple ) {
+                for ( const ast::ptr<ast::Type> & t : *tuple ) {
                         exprs.push_back( structureArg( location, t, begin, end ) );
                 }
@@ -248 +248 @@
                         if (typeMap.count(typeInst->base)) {
                                 ast::TypeInstType * newInst = mutate(typeInst);
-                                newInst->expr_id = typeMap[typeInst->base].first;
-                                newInst->formal_usage = typeMap[typeInst->base].second;
+                                auto const & pair = typeMap[typeInst->base];
+                                newInst->expr_id = pair.first;
+                                newInst->formal_usage = pair.second;
                                 return newInst;
                         }
@@ -462 +463 @@
         if ( specialized != expr->arg ) {
                 // Assume that the specialization incorporates the cast.
-                std::cerr << expr <<std::endl;
                 return specialized;
         } else {

src/InitTweak/InitTweak.cc

@@ -27 +27 @@
 #include "AST/Stmt.hpp"
 #include "AST/Type.hpp"
+#include "CodeGen/OperatorTable.h" // for isConstructor, isDestructor, isCto...
 #include "Common/PassVisitor.h"
 #include "Common/SemanticError.h"  // for SemanticError
@@ -770 +771 @@
                         std::list< Expression * > callExprs;
                         collectCtorDtorCalls( stmt, callExprs );
-                        // if ( callExprs.empty() ) return false; // xxx - do I still need this check?
                         return std::all_of( callExprs.begin(), callExprs.end(), pred);
                 }
@@ -901 +901 @@
                         } else if ( VariableExpr * varExpr = dynamic_cast< VariableExpr * >( func ) ) {
                                 return varExpr->get_var()->get_name();
-                        }       else if ( CastExpr * castExpr = dynamic_cast< CastExpr * >( func ) ) {
+                        } else if ( CastExpr * castExpr = dynamic_cast< CastExpr * >( func ) ) {
                                 return funcName( castExpr->get_arg() );
                         } else if ( MemberExpr * memberExpr = dynamic_cast< MemberExpr * >( func ) ) {
@@ -923 +923 @@
                         } else if ( const ast::VariableExpr * varExpr = dynamic_cast< const ast::VariableExpr * >( func ) ) {
                                 return varExpr->var->name;
-                        }       else if ( const ast::CastExpr * castExpr = dynamic_cast< const ast::CastExpr * >( func ) ) {
+                        } else if ( const ast::CastExpr * castExpr = dynamic_cast< const ast::CastExpr * >( func ) ) {
                                 return funcName( castExpr->arg );
                         } else if ( const ast::MemberExpr * memberExpr = dynamic_cast< const ast::MemberExpr * >( func ) ) {
@@ -991 +991 @@
 
         Type * isPointerType( Type * type ) {
-                if ( getPointerBase( type ) ) return type;
-                else return nullptr;
+                return getPointerBase( type ) ? type : nullptr;
         }
 
@@ -1014 +1013 @@
                                 src = new AddressExpr( src );
                         }
-                        // src = new CastExpr( src, new ReferenceType( noQualifiers, src->result->stripReferences()->clone() ) );
                 }
                 return new ApplicationExpr( VariableExpr::functionPointer( assign ), { dst, src } );
@@ -1167 +1165 @@
         }
 
-        bool isConstructor( const std::string & str ) { return str == "?{}"; }
-        bool isDestructor( const std::string & str ) { return str == "^?{}"; }
-        bool isAssignment( const std::string & str ) { return str == "?=?"; }
-        bool isCtorDtor( const std::string & str ) { return isConstructor( str ) || isDestructor( str ); }
-        bool isCtorDtorAssign( const std::string & str ) { return isCtorDtor( str ) || isAssignment( str ); }
-
         const FunctionDecl * isCopyFunction( const Declaration * decl, const std::string & fname ) {
                 const FunctionDecl * function = dynamic_cast< const FunctionDecl * >( decl );
@@ -1192 +1184 @@
 
 bool isAssignment( const ast::FunctionDecl * decl ) {
-        return isAssignment( decl->name ) && isCopyFunction( decl );
+        return CodeGen::isAssignment( decl->name ) && isCopyFunction( decl );
 }
 
 bool isDestructor( const ast::FunctionDecl * decl ) {
-        return isDestructor( decl->name );
+        return CodeGen::isDestructor( decl->name );
 }
 
 bool isDefaultConstructor( const ast::FunctionDecl * decl ) {
-        return isConstructor( decl->name ) && 1 == decl->params.size();
+        return CodeGen::isConstructor( decl->name ) && 1 == decl->params.size();
 }
 
 bool isCopyConstructor( const ast::FunctionDecl * decl ) {
-        return isConstructor( decl->name ) && 2 == decl->params.size();
+        return CodeGen::isConstructor( decl->name ) && 2 == decl->params.size();
 }
 
@@ -1222 +1214 @@
         }
         const FunctionDecl * isDestructor( const Declaration * decl ) {
-                if ( isDestructor( decl->name ) ) {
+                if ( CodeGen::isDestructor( decl->name ) ) {
                         return dynamic_cast< const FunctionDecl * >( decl );
                 }
@@ -1228 +1220 @@
         }
         const FunctionDecl * isDefaultConstructor( const Declaration * decl ) {
-                if ( isConstructor( decl->name ) ) {
+                if ( CodeGen::isConstructor( decl->name ) ) {
                         if ( const FunctionDecl * func = dynamic_cast< const FunctionDecl * >( decl ) ) {
                                 if ( func->type->parameters.size() == 1 ) {

src/SymTab/Autogen.cc

@@ -258 +258 @@
         }
 
-        /// 
+        /// Given type T, generate type of default ctor/dtor, i.e. function type void (*) (T &).
         ast::FunctionDecl * genDefaultFunc(const CodeLocation loc, const std::string fname, const ast::Type * paramType, bool maybePolymorphic) {
                 std::vector<ast::ptr<ast::TypeDecl>> typeParams;
                 if (maybePolymorphic) typeParams = getGenericParams(paramType);
                 auto dstParam = new ast::ObjectDecl(loc, "_dst", new ast::ReferenceType(paramType), nullptr, {}, ast::Linkage::Cforall);
-                return new ast::FunctionDecl(loc, fname, std::move(typeParams), {dstParam}, {}, new ast::CompoundStmt(loc));
+                return new ast::FunctionDecl(loc, fname, std::move(typeParams), {dstParam}, {}, new ast::CompoundStmt(loc), {}, ast::Linkage::Cforall);
         }