source: src/Tuples/TupleExpansion.cc @ 3c13c03

ADTaaron-thesisarm-ehast-experimentalcleanup-dtorsdeferred_resndemanglerenumforall-pointer-decayjacob/cs343-translationjenkins-sandboxnew-astnew-ast-unique-exprnew-envno_listpersistent-indexerpthread-emulationqualifiedEnumresolv-newwith_gc
Last change on this file since 3c13c03 was 3c13c03, checked in by Rob Schluntz <rschlunt@…>, 7 years ago

expand TupleExpr? and TupleIndexExpr?, add UniqueExpr?

  • Property mode set to 100644
File size: 6.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// TupleAssignment.cc --
8//
9// Author           : Rodolfo G. Esteves
10// Created On       : Mon May 18 07:44:20 2015
11// Last Modified By : Peter A. Buhr
12// Last Modified On : Mon May 18 15:02:53 2015
13// Update Count     : 2
14//
15
16#include <iterator>
17#include <iostream>
18#include <cassert>
19#include "Tuples.h"
20#include "GenPoly/DeclMutator.h"
21#include "SynTree/Mutator.h"
22#include "SynTree/Statement.h"
23#include "SynTree/Declaration.h"
24#include "SynTree/Type.h"
25#include "SynTree/Expression.h"
26#include "SynTree/Initializer.h"
27#include "SymTab/Mangler.h"
28#include "Common/ScopedMap.h"
29
30namespace Tuples {
31        namespace {
32                class UniqueExprExpander : public GenPoly::DeclMutator {
33                public:
34                        typedef GenPoly::DeclMutator Parent;
35                        virtual Expression * mutate( UniqueExpr * unqExpr );
36                        std::map< Expression *, ObjectDecl * > decls;
37                };
38
39                class TupleAssignExpander : public Mutator {
40                public:
41                        typedef Mutator Parent;
42                        virtual Expression * mutate( TupleAssignExpr * tupleExpr );
43                };
44
45                class TupleTypeReplacer : public GenPoly::DeclMutator {
46                  public:
47                        typedef GenPoly::DeclMutator Parent;
48
49                        virtual Type * mutate( TupleType * tupleType );
50
51                        virtual CompoundStmt * mutate( CompoundStmt * stmt ) {
52                                typeMap.beginScope();
53                                stmt = Parent::mutate( stmt );
54                                typeMap.endScope();
55                                return stmt;
56                        }
57                  private:
58                        ScopedMap< std::string, StructDecl * > typeMap;
59                };
60
61                class TupleIndexExpander : public Mutator {
62                public:
63                        typedef Mutator Parent;
64                        virtual Expression * mutate( TupleIndexExpr * tupleExpr );
65                };
66
67                class TupleExprExpander : public Mutator {
68                public:
69                        typedef Mutator Parent;
70                        virtual Expression * mutate( TupleExpr * tupleExpr );
71                };
72        }
73
74        void expandTuples( std::list< Declaration * > & translationUnit ) {
75                UniqueExprExpander unqExpander;
76                unqExpander.mutateDeclarationList( translationUnit );
77
78                TupleAssignExpander assnExpander;
79                mutateAll( translationUnit, assnExpander );
80
81                TupleTypeReplacer replacer;
82                replacer.mutateDeclarationList( translationUnit );
83
84                TupleIndexExpander idxExpander;
85                mutateAll( translationUnit, idxExpander );
86
87                TupleExprExpander exprExpander;
88                mutateAll( translationUnit, exprExpander );
89        }
90
91        Expression * UniqueExprExpander::mutate( UniqueExpr * unqExpr ) {
92                static UniqueName tempNamer( "_unq_expr_" );
93                unqExpr = safe_dynamic_cast< UniqueExpr * > ( Parent::mutate( unqExpr ) );
94                if ( ! decls.count( unqExpr->get_expr() ) ) {
95                        // xxx - it's possible (likely?) that expressions can appear in the wrong order because of this. Need to ensure they're placed in the correct location.
96                        ObjectDecl * decl = new ObjectDecl( tempNamer.newName(), DeclarationNode::NoStorageClass, LinkageSpec::Cforall, nullptr, unqExpr->get_result()->clone(), new SingleInit( unqExpr->get_expr()->clone() ) );
97                        decls[unqExpr->get_expr()] = decl;
98                        addDeclaration( decl );
99                }
100                return new VariableExpr( decls[unqExpr->get_expr()] );
101        }
102
103        Expression * TupleAssignExpander::mutate( TupleAssignExpr * assnExpr ) {
104                // xxx - Parent::mutate?
105                CompoundStmt * compoundStmt = new CompoundStmt( noLabels );
106                std::list< Statement * > & stmts = compoundStmt->get_kids();
107                for ( ObjectDecl * obj : assnExpr->get_tempDecls() ) {
108                        stmts.push_back( new DeclStmt( noLabels, obj ) );
109                }
110                TupleExpr * tupleExpr = new TupleExpr( assnExpr->get_assigns() );
111                assert( tupleExpr->get_result() );
112                stmts.push_back( new ExprStmt( noLabels, tupleExpr ) );
113                assnExpr->get_tempDecls().clear();
114                assnExpr->get_assigns().clear();
115                delete assnExpr;
116                return new StmtExpr( compoundStmt );
117        }
118
119        Type * TupleTypeReplacer::mutate( TupleType * tupleType ) {
120                std::string mangleName = SymTab::Mangler::mangleType( tupleType );
121                TupleType * newType = safe_dynamic_cast< TupleType * > ( Parent::mutate( tupleType ) );
122                if ( ! typeMap.count( mangleName ) ) {
123                        // generate struct type to replace tuple type
124                        StructDecl * decl = new StructDecl( "_tuple_type_" + mangleName );
125                        decl->set_body( true );
126                        int cnt = 0;
127                        for ( Type * t : *newType ) {
128                                decl->get_members().push_back( new ObjectDecl( "field_"+std::to_string(++cnt), DeclarationNode::NoStorageClass, LinkageSpec::C, nullptr, t->clone(), nullptr ) );
129                        }
130                        typeMap[mangleName] = decl;
131                        addDeclaration( decl );
132                }
133                Type::Qualifiers qualifiers = newType->get_qualifiers();
134                delete newType;
135                return new StructInstType( qualifiers, typeMap[mangleName] );
136        }
137
138        Expression * TupleIndexExpander::mutate( TupleIndexExpr * tupleExpr ) {
139                Expression * tuple = maybeMutate( tupleExpr->get_tuple(), *this );
140                assert( tuple );
141                tupleExpr->set_tuple( nullptr );
142                unsigned int idx = tupleExpr->get_index();
143                delete tupleExpr;
144
145                StructInstType * type = safe_dynamic_cast< StructInstType * >( tuple->get_result() );
146                StructDecl * structDecl = type->get_baseStruct();
147                assert( structDecl->get_members().size() > idx );
148                Declaration * member = *std::next(structDecl->get_members().begin(), idx);
149                return new MemberExpr( safe_dynamic_cast< DeclarationWithType * >( member ), tuple );
150        }
151
152        Expression * TupleExprExpander::mutate( TupleExpr * tupleExpr ) {
153                assert( tupleExpr->get_result() );
154                std::list< Initializer * > inits;
155                for ( Expression * expr : tupleExpr->get_exprs() ) {
156                        inits.push_back( new SingleInit( expr ) );
157                }
158                return new CompoundLiteralExpr( tupleExpr->get_result(), new ListInit( inits ) );
159        }
160
161        TupleType * makeTupleType( const std::list< Expression * > & exprs ) {
162                TupleType *tupleType = new TupleType( Type::Qualifiers(true, true, true, true, true, false) );
163                Type::Qualifiers &qualifiers = tupleType->get_qualifiers();
164                for ( Expression * expr : exprs ) {
165                        assert( expr->get_result() );
166                        Type * type = expr->get_result()->clone();
167                        tupleType->get_types().push_back( type );
168                        qualifiers &= type->get_qualifiers();
169                } // for
170                return tupleType;
171        }
172} // namespace Tuples
173
174// Local Variables: //
175// tab-width: 4 //
176// mode: c++ //
177// compile-command: "make install" //
178// End: //
179
Note: See TracBrowser for help on using the repository browser.