source: src/Common/CodeLocationTools.cpp

Last change on this file was 71806e0, checked in by JiadaL <j82liang@…>, 4 weeks ago

Rename InlineValueDecl? to InlineMemberDecl?

  • Property mode set to 100644
File size: 8.0 KB
Line 
1//
2// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo
3//
4// The contents of this file are covered under the licence agreement in the
5// file "LICENCE" distributed with Cforall.
6//
7// CodeLocationTools.cpp -- Additional tools for code locations.
8//
9// Author           : Andrew Beach
10// Created On       : Fri Dec  4 15:42:00 2020
11// Last Modified By : Andrew Beach
12// Last Modified On : Wed May 11 16:16:00 2022
13// Update Count     : 5
14//
15
16#include "CodeLocationTools.hpp"
17
18#include <type_traits>
19
20#include "AST/Pass.hpp"
21#include "AST/TranslationUnit.hpp"
22#include "Common/CodeLocation.h"
23
24namespace {
25
26// Fill every location with a nearby (parent) location.
27class FillCore : public ast::WithGuards {
28        CodeLocation const * parent;
29
30        template<typename node_t>
31        node_t const * parse_visit( node_t const * node ) {
32                if ( node->location.isUnset() ) {
33                        assert( parent );
34                        node_t * newNode = ast::mutate( node );
35                        newNode->location = *parent;
36                        return newNode;
37                }
38                GuardValue( parent ) = &node->location;
39                return node;
40        }
41
42        bool hasUnsetLabels( const ast::Stmt * stmt ) {
43                for ( const ast::Label& label : stmt->labels ) {
44                        if ( label.location.isUnset() ) {
45                                return true;
46                        }
47                }
48                return false;
49        }
50
51        template<typename node_t>
52        node_t const * stmt_visit( node_t const * node ) {
53                assert( node->location.isSet() );
54
55                if ( hasUnsetLabels( node ) ) {
56                        node_t * newNode = ast::mutate( node );
57                        for ( ast::Label& label : newNode->labels ) {
58                                if ( label.location.isUnset() ) {
59                                        label.location = newNode->location;
60                                }
61                        }
62                        return newNode;
63                }
64                return node;
65        }
66
67        template<typename node_t>
68        auto visit( node_t const * node, long ) {
69                return node;
70        }
71
72        template<typename node_t>
73        auto visit( node_t const * node, int ) -> typename
74                        std::remove_reference< decltype( node->location, node ) >::type {
75                return parse_visit( node );
76        }
77
78        template<typename node_t>
79        auto visit( node_t const * node, char ) -> typename
80                        std::remove_reference< decltype( node->labels, node ) >::type {
81                return stmt_visit( parse_visit( node ) );
82        }
83
84public:
85        FillCore() : parent( nullptr ) {}
86        FillCore( const CodeLocation& location ) : parent( &location ) {
87                assert( location.isSet() );
88        }
89
90        template<typename node_t>
91        node_t const * previsit( node_t const * node ) {
92                return visit( node, '\0' );
93        }
94};
95
96// ALL_VISITS(macro)
97// Expands `macro(node_type, return_type)` for every visit method of the
98// ast::Visitor class where node_type is the name of the parameter and
99// return_type is the name of the return type; not including the namespace,
100// pointer or const qualifiers.
101#define ALL_VISITS(macro) \
102    macro(ObjectDecl, DeclWithType) \
103    macro(FunctionDecl, DeclWithType) \
104    macro(StructDecl, Decl) \
105    macro(UnionDecl, Decl) \
106    macro(EnumDecl, Decl) \
107    macro(TraitDecl, Decl) \
108    macro(TypeDecl, Decl) \
109    macro(TypedefDecl, Decl) \
110    macro(AsmDecl, AsmDecl) \
111    macro(DirectiveDecl, DirectiveDecl) \
112    macro(StaticAssertDecl, StaticAssertDecl) \
113    macro(InlineMemberDecl, DeclWithType) \
114    macro(CompoundStmt, CompoundStmt) \
115    macro(ExprStmt, Stmt) \
116    macro(AsmStmt, Stmt) \
117    macro(DirectiveStmt, Stmt) \
118    macro(IfStmt, Stmt) \
119    macro(WhileDoStmt, Stmt) \
120    macro(ForStmt, Stmt) \
121    macro(SwitchStmt, Stmt) \
122    macro(CaseClause, CaseClause) \
123    macro(BranchStmt, Stmt) \
124    macro(ReturnStmt, Stmt) \
125    macro(ThrowStmt, Stmt) \
126    macro(TryStmt, Stmt) \
127    macro(CatchClause, CatchClause) \
128    macro(FinallyClause, FinallyClause) \
129    macro(SuspendStmt, Stmt) \
130    macro(WaitForStmt, Stmt) \
131    macro(WaitForClause, WaitForClause) \
132    macro(WithStmt, Decl) \
133    macro(NullStmt, NullStmt) \
134    macro(DeclStmt, Stmt) \
135    macro(ImplicitCtorDtorStmt, Stmt) \
136    macro(MutexStmt, Stmt) \
137    macro(ApplicationExpr, Expr) \
138    macro(UntypedExpr, Expr) \
139    macro(NameExpr, Expr) \
140        macro(QualifiedNameExpr, Expr) \
141    macro(AddressExpr, Expr) \
142    macro(LabelAddressExpr, Expr) \
143    macro(CastExpr, Expr) \
144    macro(KeywordCastExpr, Expr) \
145    macro(VirtualCastExpr, Expr) \
146    macro(UntypedMemberExpr, Expr) \
147    macro(MemberExpr, Expr) \
148    macro(VariableExpr, Expr) \
149    macro(ConstantExpr, Expr) \
150    macro(SizeofExpr, Expr) \
151    macro(AlignofExpr, Expr) \
152    macro(UntypedOffsetofExpr, Expr) \
153    macro(OffsetofExpr, Expr) \
154    macro(OffsetPackExpr, Expr) \
155    macro(LogicalExpr, Expr) \
156    macro(ConditionalExpr, Expr) \
157    macro(CommaExpr, Expr) \
158    macro(TypeExpr, Expr) \
159    macro(DimensionExpr, Expr) \
160    macro(AsmExpr, Expr) \
161    macro(ImplicitCopyCtorExpr, Expr) \
162    macro(ConstructorExpr, Expr) \
163    macro(CompoundLiteralExpr, Expr) \
164    macro(RangeExpr, Expr) \
165    macro(UntypedTupleExpr, Expr) \
166    macro(TupleExpr, Expr) \
167    macro(TupleIndexExpr, Expr) \
168    macro(TupleAssignExpr, Expr) \
169    macro(StmtExpr, Expr) \
170    macro(UniqueExpr, Expr) \
171    macro(UntypedInitExpr, Expr) \
172    macro(InitExpr, Expr) \
173    macro(DeletedExpr, Expr) \
174    macro(DefaultArgExpr, Expr) \
175    macro(GenericExpr, Expr) \
176    macro(VoidType, Type) \
177    macro(BasicType, Type) \
178    macro(PointerType, Type) \
179    macro(ArrayType, Type) \
180    macro(ReferenceType, Type) \
181    macro(QualifiedType, Type) \
182    macro(FunctionType, Type) \
183    macro(StructInstType, Type) \
184    macro(UnionInstType, Type) \
185    macro(EnumInstType, Type) \
186    macro(TraitInstType, Type) \
187    macro(TypeInstType, Type) \
188    macro(TupleType, Type) \
189    macro(TypeofType, Type) \
190    macro(VTableType, Type) \
191    macro(VarArgsType, Type) \
192    macro(ZeroType, Type) \
193    macro(OneType, Type) \
194    macro(GlobalScopeType, Type) \
195    macro(Designation, Designation) \
196    macro(SingleInit, Init) \
197    macro(ListInit, Init) \
198    macro(ConstructorInit, Init) \
199    macro(Attribute, Attribute) \
200    macro(TypeSubstitution, TypeSubstitution)
201
202// These could even go into the ast namespace.
203enum class LeafKind {
204#define VISIT(node_type, return_type) node_type,
205        ALL_VISITS(VISIT)
206#undef VISIT
207};
208
209struct LeafKindVisitor : public ast::Visitor {
210        LeafKind kind;
211
212#define VISIT(node_type, return_type) \
213        const ast::return_type * visit( const ast::node_type * ) final { \
214                kind = LeafKind::node_type; \
215                return nullptr; \
216        }
217        ALL_VISITS(VISIT)
218#undef VISIT
219};
220
221constexpr size_t leaf_kind_count = (1 + (size_t)LeafKind::TypeSubstitution);
222
223LeafKind get_leaf_kind( ast::Node const * node ) {
224        LeafKindVisitor visitor;
225        node->accept( visitor );
226        return visitor.kind;
227}
228
229const char * leaf_kind_names[leaf_kind_count] = {
230#define VISIT(node_type, return_type) #node_type,
231        ALL_VISITS(VISIT)
232#undef VISIT
233};
234
235// Collect pointers to all the nodes with unset code locations.
236class CollectCore {
237        std::list< ast::ptr< ast::Node > > & unset;
238public:
239        CollectCore( std::list< ast::ptr< ast::Node > > & unset ) :
240                unset( unset )
241        {}
242
243        template<typename node_t>
244        auto previsit( node_t const * node ) -> decltype( node->location, void() ) {
245                if ( node->location.isUnset() ) {
246                        unset.push_back( node );
247                }
248        }
249};
250
251} // namespace
252
253void checkAllCodeLocations( ast::TranslationUnit const & unit ) {
254        checkAllCodeLocations( "unknown location", unit );
255}
256
257void checkAllCodeLocations( char const * label, ast::TranslationUnit const & unit ) {
258        std::list< ast::ptr< ast::Node > > unsetNodes;
259        {
260                ast::Pass<CollectCore> collector( unsetNodes );
261                for ( auto node : unit.decls ) {
262                        node->accept( collector );
263                }
264        }
265        if ( unsetNodes.empty() ) {
266                return;
267        }
268
269        std::cerr << "Code Location check at " << label << " failed." << std::endl;
270        std::cerr << "Total nodes without a set code location: "
271                << unsetNodes.size() << std::endl;
272
273        size_t node_counts[leaf_kind_count] = {0};
274        for ( auto unset : unsetNodes ) {
275                node_counts[(size_t)get_leaf_kind(unset)] += 1;
276        }
277        for ( size_t i = 0 ; i < leaf_kind_count ; ++i ) {
278                if ( node_counts[i] ) {
279                        std::cerr << '\t' << node_counts[i]
280                                << " of type " << leaf_kind_names[i] << std::endl;
281                }
282        }
283
284        assert( unsetNodes.empty() );
285}
286
287void forceFillCodeLocations( ast::TranslationUnit & unit ) {
288        ast::Pass<FillCore>::run( unit );
289}
290
291ast::Node const * localFillCodeLocations(
292                CodeLocation const & location , ast::Node const * node ) {
293        ast::Pass<FillCore> visitor( location );
294        return node->accept( visitor );
295}
Note: See TracBrowser for help on using the repository browser.