source: src/Tuples/Tuples.cc @ 045cda3

Last change on this file since 045cda3 was e01eb4a, checked in by Andrew Beach <ajbeach@…>, 2 years ago

Moved some functions from InitTweak? to Inspect.

  • Property mode set to 100644
File size: 3.5 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// Tuples.cc -- A collection of tuple operations.
8//
9// Author           : Andrew Beach
10// Created On       : Mon Jun 17 14:41:00 2019
11// Last Modified By : Andrew Beach
12// Last Modified On : Mon May 16 16:15:00 2022
13// Update Count     : 2
14//
15
16#include "Tuples.h"
17
18#include "AST/Pass.hpp"
19#include "AST/Inspect.hpp"
20#include "AST/LinkageSpec.hpp"
21#include "Common/PassVisitor.h"
22#include "InitTweak/InitTweak.h"
23
24namespace Tuples {
25
26namespace {
27        /// Checks if impurity (read: side-effects) may exist in a piece of code.
28        /// Currently gives a very crude approximation, wherein any function
29        /// call expression means the code may be impure.
30        struct ImpurityDetector_old : public WithShortCircuiting {
31                bool const ignoreUnique;
32                bool maybeImpure;
33
34                ImpurityDetector_old( bool ignoreUnique ) :
35                        ignoreUnique( ignoreUnique ), maybeImpure( false )
36                {}
37
38                void previsit( const ApplicationExpr * appExpr ) {
39                        visit_children = false;
40                        if ( const DeclarationWithType * function =
41                                        InitTweak::getFunction( appExpr ) ) {
42                                if ( function->linkage == LinkageSpec::Intrinsic ) {
43                                        if ( function->name == "*?" || function->name == "?[?]" ) {
44                                                // intrinsic dereference, subscript are pure,
45                                                // but need to recursively look for impurity
46                                                visit_children = true;
47                                                return;
48                                        }
49                                }
50                        }
51                        maybeImpure = true;
52                }
53
54                void previsit( const UntypedExpr * ) {
55                        maybeImpure = true;
56                        visit_children = false;
57                }
58
59                void previsit( const UniqueExpr * ) {
60                        if ( ignoreUnique ) {
61                                // bottom out at unique expression.
62                                // The existence of a unique expression doesn't change the purity of an expression.
63                                // That is, even if the wrapped expression is impure, the wrapper protects the rest of the expression.
64                                visit_children = false;
65                                return;
66                        }
67                }
68        };
69
70        bool detectImpurity( const Expression * expr, bool ignoreUnique ) {
71                PassVisitor<ImpurityDetector_old> detector( ignoreUnique );
72                expr->accept( detector );
73                return detector.pass.maybeImpure;
74        }
75
76        /// Determines if impurity (read: side-effects) may exist in a piece of code. Currently gives
77        /// a very crude approximation, wherein any function call expression means the code may be
78        /// impure.
79    struct ImpurityDetector : public ast::WithShortCircuiting {
80                bool result = false;
81
82                void previsit( ast::ApplicationExpr const * appExpr ) {
83                        if ( ast::DeclWithType const * function = ast::getFunction( appExpr ) ) {
84                                if ( function->linkage == ast::Linkage::Intrinsic
85                                                && ( function->name == "*?" || function->name == "?[?]" ) ) {
86                                        return;
87                                }
88                        }
89                        result = true; visit_children = false;
90                }
91                void previsit( ast::UntypedExpr const * ) {
92                        result = true; visit_children = false;
93                }
94        };
95
96        struct ImpurityDetectorIgnoreUnique : public ImpurityDetector {
97                using ImpurityDetector::previsit;
98                void previsit( ast::UniqueExpr const * ) {
99                        visit_children = false;
100                }
101        };
102} // namespace
103
104bool maybeImpure( const ast::Expr * expr ) {
105        return ast::Pass<ImpurityDetector>::read( expr );
106}
107
108bool maybeImpureIgnoreUnique( const ast::Expr * expr ) {
109        return ast::Pass<ImpurityDetectorIgnoreUnique>::read( expr );
110}
111
112bool maybeImpure( const Expression * expr ) {
113        return detectImpurity( expr, false );
114}
115
116bool maybeImpureIgnoreUnique( const Expression * expr ) {
117        return detectImpurity( expr, true );
118}
119
120} // namespace Tuples
121
122// Local Variables: //
123// tab-width: 4 //
124// mode: c++ //
125// compile-command: "make install" //
126// End: //
Note: See TracBrowser for help on using the repository browser.