Changeset f5bace8


Ignore:
Timestamp:
Mar 25, 2022, 1:50:46 PM (2 years ago)
Author:
Thierry Delisle <tdelisle@…>
Branches:
ADT, ast-experimental, enum, master, pthread-emulation, qualifiedEnum
Children:
400b8be
Parents:
64bdacc (diff), 8631c84 (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:
6 edited

Legend:

Unmodified
Added
Removed
  • src/AST/Node.cpp

    r64bdacc rf5bace8  
    99// Author           : Thierry Delisle
    1010// Created On       : Thu May 16 14:16:00 2019
    11 // Last Modified By : Peter A. Buhr
    12 // Last Modified On : Tue Feb  1 09:09:39 2022
    13 // Update Count     : 3
     11// Last Modified By : Andrew Beach
     12// Last Modified On : Fri Mar 25 10:30:00 2022
     13// Update Count     : 4
    1414//
    1515
     
    1919#include <csignal>  // MEMORY DEBUG -- for raise
    2020#include <iostream>
     21#include <utility>
    2122
    2223#include "Attribute.hpp"
     
    7677void ast::ptr_base<node_t, ref_t>::_check() const {
    7778        // if(node) assert(node->was_ever_strong == false || node->strong_count > 0);
     79}
     80
     81template< typename node_t, enum ast::Node::ref_type ref_t >
     82void ast::ptr_base<node_t, ref_t>::swap( ptr_base & other ) noexcept {
     83        std::swap( this->node, other.node );
     84        _trap( this->node );
     85        _trap( other.node );
    7886}
    7987
  • src/AST/Node.hpp

    r64bdacc rf5bace8  
    1010// Created On       : Wed May 8 10:27:04 2019
    1111// Last Modified By : Andrew Beach
    12 // Last Modified On : Fri Jun 5 9:47:00 2020
    13 // Update Count     : 6
     12// Last Modified On : Fri Mar 25 10:33:00 2022
     13// Update Count     : 7
    1414//
    1515
     
    230230        }
    231231
     232        /// Swaps the nodes contained within two pointers.
     233        void swap( ptr_base & other ) noexcept;
     234
    232235        const node_t * get() const { _check(); return  node; }
    233236        const node_t * operator->() const { _check(); return  node; }
     
    292295template< typename node_t >
    293296using readonly = ptr_base< node_t, Node::ref_type::weak >;
     297
     298/// Non-member swap that an participate in overload resolution.
     299template< typename node_t, enum Node::ref_type ref_t >
     300void swap( ptr_base< node_t, ref_t > & l, ptr_base< node_t, ref_t > & r ) {
     301        l.swap( r );
     302}
     303
    294304}
    295305
  • src/AST/Pass.impl.hpp

    r64bdacc rf5bace8  
    354354                        // Take all the elements that are different in 'values'
    355355                        // and swap them into 'container'
    356                         if( values[i] != nullptr ) std::swap(container[i], values[i]);
     356                        if( values[i] != nullptr ) swap(container[i], values[i]);
    357357                }
    358358
     
    10541054                        auto n = __pass::mutate<core_t>(node);
    10551055                        for(size_t i = 0; i < new_clauses.size(); i++) {
    1056                                 if(new_clauses.at(i).target.func != nullptr) std::swap(n->clauses.at(i).target.func, new_clauses.at(i).target.func);
     1056                                if(new_clauses.at(i).target.func != nullptr) swap(n->clauses.at(i).target.func, new_clauses.at(i).target.func);
    10571057
    10581058                                for(size_t j = 0; j < new_clauses.at(i).target.args.size(); j++) {
    1059                                         if(new_clauses.at(i).target.args.at(j) != nullptr) std::swap(n->clauses.at(i).target.args.at(j), new_clauses.at(i).target.args.at(j));
     1059                                        if(new_clauses.at(i).target.args.at(j) != nullptr) swap(n->clauses.at(i).target.args.at(j), new_clauses.at(i).target.args.at(j));
    10601060                                }
    10611061
    1062                                 if(new_clauses.at(i).stmt != nullptr) std::swap(n->clauses.at(i).stmt, new_clauses.at(i).stmt);
    1063                                 if(new_clauses.at(i).cond != nullptr) std::swap(n->clauses.at(i).cond, new_clauses.at(i).cond);
     1062                                if(new_clauses.at(i).stmt != nullptr) swap(n->clauses.at(i).stmt, new_clauses.at(i).stmt);
     1063                                if(new_clauses.at(i).cond != nullptr) swap(n->clauses.at(i).cond, new_clauses.at(i).cond);
    10641064                        }
    10651065                        node = n;
     
    21512151
    21522152        if ( __visit_children() ) {
    2153                 {
    2154                         bool mutated = false;
    2155                         std::unordered_map< ast::TypeInstType::TypeEnvKey, ast::ptr< ast::Type > > new_map;
    2156                         for ( const auto & p : node->typeEnv ) {
    2157                                 guard_symtab guard { *this };
    2158                                 auto new_node = p.second->accept( *this );
    2159                                 if (new_node != p.second) mutated = true;
    2160                                 new_map.insert({ p.first, new_node });
    2161                         }
    2162                         if (mutated) {
    2163                                 auto new_node = __pass::mutate<core_t>( node );
    2164                                 new_node->typeEnv.swap( new_map );
    2165                                 node = new_node;
    2166                         }
     2153                bool mutated = false;
     2154                std::unordered_map< ast::TypeInstType::TypeEnvKey, ast::ptr< ast::Type > > new_map;
     2155                for ( const auto & p : node->typeEnv ) {
     2156                        guard_symtab guard { *this };
     2157                        auto new_node = p.second->accept( *this );
     2158                        if (new_node != p.second) mutated = true;
     2159                        new_map.insert({ p.first, new_node });
     2160                }
     2161                if (mutated) {
     2162                        auto new_node = __pass::mutate<core_t>( node );
     2163                        new_node->typeEnv.swap( new_map );
     2164                        node = new_node;
    21672165                }
    21682166        }
  • src/ResolvExpr/RenameVars.h

    r64bdacc rf5bace8  
    3636        };
    3737        const ast::Type * renameTyVars( const ast::Type *, RenameMode mode = GEN_USAGE, bool reset = true );
    38        
    3938
    4039        /// resets internal state of renamer to avoid overflow
    4140        void resetTyVarRenaming();
    42 
    43        
    4441} // namespace ResolvExpr
    4542
  • src/ResolvExpr/ResolveTypeof.cc

    r64bdacc rf5bace8  
    169169
    170170struct FixArrayDimension {
    171         // should not require a mutable symbol table - prevent pass template instantiation
    172171        const ResolveContext & context;
    173172        FixArrayDimension(const ResolveContext & context) : context( context ) {}
     
    196195
    197196const ast::ObjectDecl * fixObjectType( const ast::ObjectDecl * decl , const ResolveContext & context ) {
    198         if (!decl->isTypeFixed) {
    199                 auto mutDecl = mutate(decl);
     197        if (decl->isTypeFixed) {
     198                return decl;
     199        }
     200
     201        auto mutDecl = mutate(decl);
     202        {
    200203                auto resolvedType = resolveTypeof(decl->type, context);
    201204                resolvedType = fixArrayType(resolvedType, context);
    202205                mutDecl->type = resolvedType;
    203 
    204                 // check variable length if object is an array.
    205                 // xxx - should this be part of fixObjectType?
    206 
    207                 /*
    208                 if (auto arrayType = dynamic_cast<const ast::ArrayType *>(resolvedType)) {
    209                         auto dimExpr = findSingleExpression(arrayType->dimension, ast::sizeType, symtab);
    210                         if (auto varexpr = arrayType->dimension.as<ast::VariableExpr>()) {// hoisted previously
    211                                 if (InitTweak::isConstExpr(varexpr->var.strict_as<ast::ObjectDecl>()->init)) {
    212                                         auto mutType = mutate(arrayType);
    213                                         mutType->isVarLen = ast::LengthFlag::VariableLen;
    214                                         mutDecl->type = mutType;
    215                                 }
    216                         }
    217                 }
    218                 */
    219 
    220 
    221                 if (!mutDecl->name.empty())
    222                         mutDecl->mangleName = Mangle::mangle(mutDecl); // do not mangle unnamed variables
    223                
    224                 mutDecl->type = renameTyVars(mutDecl->type, RenameMode::GEN_EXPR_ID);
    225                 mutDecl->isTypeFixed = true;
    226                 return mutDecl;
    227         }
    228         return decl;
     206        }
     207
     208        // Do not mangle unnamed variables.
     209        if (!mutDecl->name.empty()) {
     210                mutDecl->mangleName = Mangle::mangle(mutDecl);
     211        }
     212
     213        mutDecl->type = renameTyVars(mutDecl->type, RenameMode::GEN_EXPR_ID);
     214        mutDecl->isTypeFixed = true;
     215        return mutDecl;
    229216}
    230217
  • src/ResolvExpr/ResolveTypeof.h

    r64bdacc rf5bace8  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // ResolveTypeof.h -- 
     7// ResolveTypeof.h --
    88//
    99// Author           : Richard C. Bilson
Note: See TracChangeset for help on using the changeset viewer.