Changeset 23a08aa0 for src/AST

Timestamp:

Sep 19, 2022, 8:11:02 PM (3 years ago)

Author:

Peter A. Buhr <pabuhr@…>

Branches:

ADT, ast-experimental, master, pthread-emulation

Children:

aa9f215

Parents:

ebf8ca5 (diff), ae1d151 (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:

fix merge conflict

Location:

src/AST

Files:

• Decl.hpp (modified) (1 diff)
• DeclReplacer.cpp (modified) (1 diff)
• Pass.hpp (modified) (1 diff)
• Pass.impl.hpp (modified) (1 diff)
• Pass.proto.hpp (modified) (1 diff)
• Print.cpp (modified) (4 diffs)
• StorageClasses.hpp (modified) (3 diffs)
• Type.cpp (modified) (3 diffs)
• Type.hpp (modified) (4 diffs)

src/AST/Decl.hpp

@@ -217 +217 @@
 
         /// convenience accessor to match Type::isComplete()
-        bool isComplete() { return sized; }
+        bool isComplete() const { return sized; }
 
         const Decl * accept( Visitor & v ) const override { return v.visit( this ); }

src/AST/DeclReplacer.cpp

@@ -9 +9 @@
 // Author           : Aaron B. Moss
 // Created On       : Wed May 8 13:00:00 2019
-// Last Modified By : Aaron B. Moss
-// Last Modified On : Wed May 8 13:00:00 2019
-// Update Count     : 1
+// Last Modified By : Andrew Beach
+// Last Modified On : Thr Sep 15 11:55:00 2022
+// Update Count     : 2
 //
 
 #include "DeclReplacer.hpp"
+
 #include "Expr.hpp"
+#include "Pass.hpp"
 #include "Type.hpp"
-
-#include "Pass.hpp"
 
 namespace ast {
 
 namespace DeclReplacer {
-        namespace {
-                struct DeclReplacer {
-                private:
-                        const DeclMap & declMap;
-                        const TypeMap & typeMap;
-                        bool debug;
 
-                public:
-                        DeclReplacer(const DeclMap & declMap, const TypeMap & typeMap, bool debug)
-                                : declMap( declMap ), typeMap( typeMap ), debug( debug )
-                        {}
+namespace {
+        struct DeclReplacer {
+        private:
+                const DeclMap & declMap;
+                const TypeMap & typeMap;
+                bool debug;
 
-                        const ast::VariableExpr * previsit( const ast::VariableExpr * );
-                        const ast::TypeInstType * previsit( const ast::TypeInstType * );
-                };
+        public:
+                DeclReplacer( const DeclMap & declMap, const TypeMap & typeMap, bool debug )
+                        : declMap( declMap ), typeMap( typeMap ), debug( debug )
+                {}
 
-                struct VarExprReplacer {
-                private:
-                        const ExprMap & exprMap;
-                        
-                public:
-                        VarExprReplacer(const ExprMap & exprMap): exprMap (exprMap) {}
+                const ast::VariableExpr * previsit( const ast::VariableExpr * );
+                const ast::TypeInstType * previsit( const ast::TypeInstType * );
+        };
 
-                        const Expr * postvisit (const VariableExpr *);
-                };
+        struct VarExprReplacer {
+        private:
+                const ExprMap & exprMap;
+
+        public:
+                VarExprReplacer( const ExprMap & exprMap ) : exprMap( exprMap ) {}
+
+                const Expr * postvisit( const VariableExpr * );
+        };
+} // namespace
+
+const ast::Node * replace( const ast::Node * node, const DeclMap & declMap, const TypeMap & typeMap, bool debug ) {
+        if(!node) return nullptr;
+        Pass<DeclReplacer> replacer = { declMap, typeMap, debug };
+        return node->accept( replacer );
+}
+
+const ast::Node * replace( const ast::Node * node, const DeclMap & declMap, bool debug ) {
+        TypeMap typeMap;
+        return replace( node, declMap, typeMap, debug );
+}
+
+const ast::Node * replace( const ast::Node * node, const TypeMap & typeMap, bool debug ) {
+        DeclMap declMap;
+        return replace( node, declMap, typeMap, debug );
+}
+
+const ast::Node * replace( const ast::Node * node, const ExprMap & exprMap ) {
+        Pass<VarExprReplacer> replacer = {exprMap};
+        return node->accept( replacer );
+}
+
+namespace {
+        // replace variable with new node from decl map
+        const ast::VariableExpr * DeclReplacer::previsit( const VariableExpr * varExpr ) {
+                // xxx - assertions and parameters aren't accounted for in this... (i.e. they aren't inserted into the map when it's made, only DeclStmts are)
+                if ( !declMap.count( varExpr->var ) ) return varExpr;
+
+                auto replacement = declMap.at( varExpr->var );
+                if ( debug ) {
+                        std::cerr << "replacing variable reference: "
+                                << (void*)varExpr->var.get() << " " << varExpr->var
+                                << " with " << (void*)replacement << " " << replacement
+                                << std::endl;
+                }
+                auto nexpr = mutate(varExpr);
+                nexpr->var = replacement;
+                return nexpr;
         }
 
-        const ast::Node * replace( const ast::Node * node, const DeclMap & declMap, const TypeMap & typeMap, bool debug ) {
-                if(!node) return nullptr;
-                Pass<DeclReplacer> replacer = { declMap, typeMap, debug };
-                return node->accept( replacer );
+        const TypeInstType * DeclReplacer::previsit( const TypeInstType * inst ) {
+                if ( !typeMap.count( inst->base ) ) return inst;
+
+                auto replacement = typeMap.at( inst->base );
+                if ( debug ) {
+                        std::cerr << "replacing type reference: "
+                                << (void*)inst->base.get() << " " << inst->base
+                                << " with " << (void*)replacement << " " << replacement
+                                << std::endl;
+                }
+                auto ninst = mutate(inst);
+                ninst->base = replacement;
+                return ninst;
         }
 
-        const ast::Node * replace( const ast::Node * node, const DeclMap & declMap, bool debug ) {
-                TypeMap typeMap;
-                return replace( node, declMap, typeMap, debug );
+        const Expr * VarExprReplacer::postvisit( const VariableExpr * expr ) {
+                if ( !exprMap.count( expr->var ) ) return expr;
+                return exprMap.at( expr->var );
         }
+} // namespace
 
-        const ast::Node * replace( const ast::Node * node, const TypeMap & typeMap, bool debug ) {
-                DeclMap declMap;
-                return replace( node, declMap, typeMap, debug );
-        }
+} // namespace DeclReplacer
 
-        const ast::Node * replace( const ast::Node * node, const ExprMap & exprMap) {
-                Pass<VarExprReplacer> replacer = {exprMap};
-                return node->accept( replacer );
-        }
-
-        namespace {
-                // replace variable with new node from decl map
-                const ast::VariableExpr * DeclReplacer::previsit( const VariableExpr * varExpr ) {
-                        // xxx - assertions and parameters aren't accounted for in this... (i.e. they aren't inserted into the map when it's made, only DeclStmts are)
-                        if ( !declMap.count( varExpr->var ) ) return varExpr;
-
-                        auto replacement = declMap.at( varExpr->var );
-                        if ( debug ) {
-                                std::cerr << "replacing variable reference: "
-                                        << (void*)varExpr->var.get() << " " << varExpr->var
-                                        << " with " << (void*)replacement << " " << replacement
-                                        << std::endl;
-                        }
-                        auto nexpr = mutate(varExpr);
-                        nexpr->var = replacement;
-                        return nexpr;
-                }
-
-                const TypeInstType * DeclReplacer::previsit( const TypeInstType * inst ) {
-                        if ( !typeMap.count( inst->base ) ) return inst;
-
-                        auto replacement = typeMap.at( inst->base );
-                        if ( debug ) {
-                                std::cerr << "replacing type reference: "
-                                        << (void*)inst->base.get() << " " << inst->base
-                                        << " with " << (void*)replacement << " " << replacement
-                                        << std::endl;
-                        }
-                        auto ninst = mutate(inst);
-                        ninst->base = replacement;
-                        return ninst;
-                }
-
-                const Expr * VarExprReplacer::postvisit( const VariableExpr * expr ) {
-                        if (!exprMap.count(expr->var)) return expr;
-
-                        return exprMap.at(expr->var);
-                }
-
-        }
-}
-
-}
+} // namespace ast
 
 // Local Variables: //

src/AST/Pass.hpp

@@ -327 +327 @@
 struct PureVisitor {};
 
+struct WithCodeLocation {
+        const CodeLocation * location = nullptr;
+};
+
 /// Keep track of the polymorphic const TypeSubstitution * typeSubs for the current expression.
 struct WithConstTypeSubstitution {

src/AST/Pass.impl.hpp

@@ -25 +25 @@
 #define VISIT_START( node ) \
         using namespace ast; \
+        /* back-up the last known code location */ \
+        __attribute__((unused)) auto loc_guard = ast::__pass::make_location_guard( core, node, 0 ); \
         /* back-up the visit children */ \
         __attribute__((unused)) ast::__pass::visit_children_guard guard1( ast::__pass::visit_children(core, 0) ); \

src/AST/Pass.proto.hpp

@@ -326 +326 @@
         }
 
+        template< typename core_t, typename node_t >
+        static auto make_location_guard( core_t & core, node_t * node, int )
+                        -> decltype( node->location, ValueGuardPtr<const CodeLocation *>( &core.location ) ) {
+                ValueGuardPtr<const CodeLocation *> guard( &core.location );
+                core.location = &node->location;
+                return guard;
+        }
+
+        template< typename core_t, typename node_t >
+        static auto make_location_guard( core_t &, node_t *, long ) -> int {
+                return 0;
+        }
+
         // Another feature of the templated visitor is that it calls beginScope()/endScope() for compound statement.
         // All passes which have such functions are assumed desire this behaviour

src/AST/Print.cpp

@@ -33 +33 @@
 {
         return array<C,sizeof...(T)>{
-                forward<T>(values)...
+                std::forward<T>(values)...
         };
 }
@@ -86 +86 @@
 
                 static constexpr auto StorageClasses = make_array<const char*>(
-                        "extern", "static", "auto", "register", "_Thread_local"
+                        "extern", "static", "auto", "register", "__thread", "_Thread_local"
                 );
 
@@ -215 +215 @@
                         ++indent;
                         ptrToEnum->base->accept( *this );
-                        --indent;  
+                        --indent;
                 }
 
@@ -1623 +1623 @@
 // if the wrong size is specified
 constexpr array<const char*, 3> Printer::Names::FuncSpecifiers;
-constexpr array<const char*, 5> Printer::Names::StorageClasses;
+constexpr array<const char*, 6> Printer::Names::StorageClasses;
 constexpr array<const char*, 6> Printer::Names::Qualifiers;
 }

src/AST/StorageClasses.hpp

@@ -24 +24 @@
         /// Bitflags for storage classes
         enum {
-                Extern      = 1 << 0,
-                Static      = 1 << 1,
-                Auto        = 1 << 2,
-                Register    = 1 << 3,
-                ThreadLocal = 1 << 4,
-                NumClasses       = 5
+                Extern         = 1 << 0,
+                Static         = 1 << 1,
+                Auto           = 1 << 2,
+                Register       = 1 << 3,
+                ThreadLocalGcc = 1 << 4,
+                ThreadLocalC11 = 1 << 5,
+                NumClasses          = 6
         };
 
@@ -37 +38 @@
                         unsigned int val;
                         struct {
-                                bool is_extern      : 1;
-                                bool is_static      : 1;
-                                bool is_auto        : 1;
-                                bool is_register    : 1;
-                                bool is_threadlocal : 1;
+                                bool is_extern         : 1;
+                                bool is_static         : 1;
+                                bool is_auto           : 1;
+                                bool is_register       : 1;
+                                bool is_threadlocalGcc : 1;
+                                bool is_threadlocalC11 : 1;
                         };
 
@@ -48 +50 @@
 
                 constexpr class_flags( unsigned int val = 0 ) : val(val) {}
+
+                bool is_threadlocal_any() { return this->is_threadlocalC11 || this->is_threadlocalGcc; }
         };
 

src/AST/Type.cpp

@@ -143 +143 @@
 TraitInstType::TraitInstType(
         const TraitDecl * b, CV::Qualifiers q, std::vector<ptr<Attribute>>&& as )
-: BaseInstType( b->name, q, move(as) ), base( b ) {}
+: BaseInstType( b->name, q, std::move(as) ), base( b ) {}
 
 // --- TypeInstType
@@ -149 +149 @@
 TypeInstType::TypeInstType( const TypeDecl * b,
         CV::Qualifiers q, std::vector<ptr<Attribute>> && as )
-: BaseInstType( b->name, q, move(as) ), base( b ), kind( b->kind ) {}
+: BaseInstType( b->name, q, std::move(as) ), base( b ), kind( b->kind ) {}
 
 void TypeInstType::set_base( const TypeDecl * b ) {
@@ -161 +161 @@
 
 TupleType::TupleType( std::vector<ptr<Type>> && ts, CV::Qualifiers q )
-: Type( q ), types( move(ts) ), members() {
+: Type( q ), types( std::move(ts) ), members() {
         // This constructor is awkward. `TupleType` needs to contain objects so that members can be
         // named, but members without initializer nodes end up getting constructors, which breaks

src/AST/Type.hpp

@@ -83 +83 @@
 template< enum Node::ref_type ref_t >
 void reset_qualifiers( ptr_base< Type, ref_t > & p, CV::Qualifiers q = {} ) {
-        if ( p->qualifiers.val != q.val ) p.get_and_mutate()->qualifiers = q;
+        if ( p->qualifiers != q ) p.get_and_mutate()->qualifiers = q;
 }
 
@@ -89 +89 @@
 template< enum Node::ref_type ref_t >
 void add_qualifiers( ptr_base< Type, ref_t > & p, CV::Qualifiers q ) {
-        if ( ( p->qualifiers.val & q.val ) != q.val ) p.get_and_mutate()->qualifiers |= q;
+        if ( ( p->qualifiers & q ) != q ) p.get_and_mutate()->qualifiers |= q;
 }
 
@@ -95 +95 @@
 template< enum Node::ref_type ref_t >
 void remove_qualifiers( ptr_base< Type, ref_t > & p, CV::Qualifiers q ) {
-        if ( ( p->qualifiers.val & q.val ) != 0 ) p.get_and_mutate()->qualifiers -= q;
+        if ( ( p->qualifiers & q ) != 0 ) p.get_and_mutate()->qualifiers -= q;
 }
 
@@ -412 +412 @@
                 std::string typeString() const { return std::string("_") + std::to_string(formal_usage) + "_" + std::to_string(expr_id) + "_" + base->name; }
                 bool operator==(const TypeEnvKey & other) const { return base == other.base && formal_usage == other.formal_usage && expr_id == other.expr_id; }
-
         };