[1931bb01] | 1 | // |
---|
| 2 | // Cforall Version 1.0.0 Copyright (C) 2018 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 | // |
---|
[11df881] | 7 | // ReplaceTypedef.cpp -- Fill in all typedefs with the underlying type. |
---|
[1931bb01] | 8 | // |
---|
| 9 | // Author : Andrew Beach |
---|
| 10 | // Created On : Tue Jun 29 14:59:00 2022 |
---|
| 11 | // Last Modified By : Andrew Beach |
---|
[af75a87] | 12 | // Last Modified On : Wed Jul 13 14:45:00 2022 |
---|
| 13 | // Update Count : 1 |
---|
[1931bb01] | 14 | // |
---|
| 15 | |
---|
| 16 | #include "ReplaceTypedef.hpp" |
---|
| 17 | |
---|
| 18 | #include "AST/Pass.hpp" |
---|
| 19 | #include "Common/ScopedMap.h" |
---|
| 20 | #include "Common/UniqueName.h" |
---|
| 21 | #include "Common/utility.h" |
---|
| 22 | #include "ResolvExpr/typeops.h" |
---|
| 23 | |
---|
| 24 | namespace Validate { |
---|
| 25 | |
---|
| 26 | namespace { |
---|
| 27 | |
---|
| 28 | bool isNonParameterAttribute( ast::Attribute const * attr ) { |
---|
| 29 | static const std::vector<std::string> bad_names = { |
---|
| 30 | "aligned", "__aligned__", |
---|
| 31 | }; |
---|
| 32 | for ( auto name : bad_names ) { |
---|
| 33 | if ( name == attr->name ) { |
---|
| 34 | return true; |
---|
| 35 | } |
---|
| 36 | } |
---|
| 37 | return false; |
---|
| 38 | } |
---|
| 39 | |
---|
| 40 | struct ReplaceTypedefCore final : |
---|
| 41 | public ast::WithVisitorRef<ReplaceTypedefCore>, |
---|
| 42 | public ast::WithGuards, |
---|
| 43 | public ast::WithShortCircuiting, |
---|
| 44 | public ast::WithDeclsToAdd<> { |
---|
| 45 | |
---|
| 46 | void previsit( ast::ParseNode const * node ); |
---|
| 47 | void previsit( ast::QualifiedType const * ); |
---|
| 48 | ast::Type const * postvisit( ast::QualifiedType const * ); |
---|
| 49 | ast::Type const * postvisit( ast::TypeInstType const * ); |
---|
| 50 | ast::Decl const * postvisit( ast::TypedefDecl const * ); |
---|
| 51 | void previsit( ast::TypeDecl const * ); |
---|
| 52 | void previsit( ast::FunctionDecl const * ); |
---|
| 53 | void previsit( ast::ObjectDecl const * ); |
---|
| 54 | ast::DeclWithType const * postvisit( ast::ObjectDecl const * ); |
---|
| 55 | |
---|
| 56 | void previsit( ast::CastExpr const * ); |
---|
| 57 | void previsit( ast::CompoundStmt const * ); |
---|
| 58 | void postvisit( ast::CompoundStmt const * ); |
---|
| 59 | |
---|
| 60 | ast::StructDecl const * previsit( ast::StructDecl const * ); |
---|
| 61 | ast::UnionDecl const * previsit( ast::UnionDecl const * ); |
---|
| 62 | void previsit( ast::EnumDecl const * ); |
---|
| 63 | void previsit( ast::TraitDecl const * ); |
---|
| 64 | |
---|
| 65 | template<typename AggrDecl> |
---|
| 66 | void addImplicitTypedef( AggrDecl * aggDecl ); |
---|
| 67 | template<typename AggrDecl> |
---|
| 68 | AggrDecl const * handleAggregate( AggrDecl const * aggDecl ); |
---|
| 69 | |
---|
| 70 | using TypedefDeclPtr = ast::ptr<ast::TypedefDecl>; |
---|
| 71 | using TypedefMap = ScopedMap<std::string, std::pair<TypedefDeclPtr, int>>; |
---|
| 72 | using TypeDeclMap = ScopedMap<std::string, ast::TypeDecl const *>; |
---|
| 73 | |
---|
| 74 | TypedefMap typedefNames; |
---|
| 75 | TypeDeclMap typedeclNames; |
---|
| 76 | CodeLocation const * nearestLocation = nullptr; |
---|
| 77 | int scopeLevel; |
---|
[af75a87] | 78 | bool isAtFunctionTop = false; |
---|
[1931bb01] | 79 | }; |
---|
| 80 | |
---|
| 81 | void ReplaceTypedefCore::previsit( ast::ParseNode const * node ) { |
---|
| 82 | GuardValue( nearestLocation ) = &node->location; |
---|
| 83 | } |
---|
| 84 | |
---|
| 85 | void ReplaceTypedefCore::previsit( ast::QualifiedType const * ) { |
---|
| 86 | visit_children = false; |
---|
| 87 | } |
---|
| 88 | |
---|
| 89 | ast::Type const * ReplaceTypedefCore::postvisit( |
---|
| 90 | ast::QualifiedType const * type ) { |
---|
| 91 | // Replacing typedefs only makes sense for the 'oldest ancestor' |
---|
| 92 | // of the qualified type. |
---|
| 93 | return ast::mutate_field( type, &ast::QualifiedType::parent, |
---|
| 94 | type->parent->accept( *visitor ) ); |
---|
| 95 | } |
---|
| 96 | |
---|
| 97 | ast::Type const * ReplaceTypedefCore::postvisit( |
---|
| 98 | ast::TypeInstType const * type ) { |
---|
| 99 | // Instances of typedef types will come here. If it is an instance |
---|
| 100 | // of a typedef type, link the instance to its actual type. |
---|
| 101 | TypedefMap::const_iterator def = typedefNames.find( type->name ); |
---|
| 102 | if ( def != typedefNames.end() ) { |
---|
| 103 | ast::Type * ret = ast::deepCopy( def->second.first->base ); |
---|
| 104 | ret->qualifiers |= type->qualifiers; |
---|
[af75a87] | 105 | // We ignore certain attributes on function parameters if they arrive |
---|
| 106 | // by typedef. GCC appears to do the same thing. |
---|
| 107 | if ( isAtFunctionTop ) { |
---|
[1931bb01] | 108 | erase_if( ret->attributes, isNonParameterAttribute ); |
---|
| 109 | } |
---|
| 110 | for ( const auto & attribute : type->attributes ) { |
---|
| 111 | ret->attributes.push_back( attribute ); |
---|
| 112 | } |
---|
| 113 | // Place instance parameters on the typedef'd type. |
---|
| 114 | if ( !type->params.empty() ) { |
---|
| 115 | auto rtt = dynamic_cast<ast::BaseInstType *>( ret ); |
---|
| 116 | if ( !rtt ) { |
---|
| 117 | assert( nearestLocation ); |
---|
| 118 | SemanticError( *nearestLocation, "Cannot apply type parameters to base type of " + type->name ); |
---|
| 119 | } |
---|
| 120 | rtt->params.clear(); |
---|
| 121 | for ( auto it : type->params ) { |
---|
| 122 | rtt->params.push_back( ast::deepCopy( it ) ); |
---|
| 123 | } |
---|
| 124 | // Recursively fix typedefs on parameters. |
---|
| 125 | ast::mutate_each( rtt, &ast::BaseInstType::params, *visitor ); |
---|
| 126 | } |
---|
| 127 | return ret; |
---|
| 128 | } else { |
---|
| 129 | TypeDeclMap::const_iterator base = typedeclNames.find( type->name ); |
---|
| 130 | if ( base == typedeclNames.end() ) { |
---|
| 131 | assert( nearestLocation ); |
---|
| 132 | SemanticError( *nearestLocation, toString( "Use of undefined type ", type->name ) ); |
---|
| 133 | } |
---|
| 134 | return ast::mutate_field( type, &ast::TypeInstType::base, base->second ); |
---|
| 135 | } |
---|
| 136 | } |
---|
| 137 | |
---|
| 138 | struct VarLenChecker : public ast::WithShortCircuiting { |
---|
| 139 | bool result = false; |
---|
| 140 | void previsit( ast::FunctionType const * ) { visit_children = false; } |
---|
| 141 | void previsit( ast::ArrayType const * at ) { result |= at->isVarLen; } |
---|
| 142 | }; |
---|
| 143 | |
---|
| 144 | ast::Decl const * ReplaceTypedefCore::postvisit( |
---|
| 145 | ast::TypedefDecl const * decl ) { |
---|
| 146 | if ( 1 == typedefNames.count( decl->name ) && |
---|
| 147 | typedefNames[ decl->name ].second == scopeLevel ) { |
---|
| 148 | ast::Type const * t0 = decl->base; |
---|
| 149 | ast::Type const * t1 = typedefNames[ decl->name ].first->base; |
---|
| 150 | // Cannot redefine VLA typedefs. Note: this is slightly incorrect, |
---|
| 151 | // because our notion of VLAs at this point in the translator is |
---|
| 152 | // imprecise. In particular, this will disallow redefining typedefs |
---|
| 153 | // with arrays whose dimension is an enumerator or a cast of a |
---|
| 154 | // constant/enumerator. The effort required to fix this corner case |
---|
| 155 | // likely outweighs the utility of allowing it. |
---|
| 156 | if ( !ResolvExpr::typesCompatible( t0, t1, ast::SymbolTable() ) |
---|
| 157 | || ast::Pass<VarLenChecker>::read( t0 ) |
---|
| 158 | || ast::Pass<VarLenChecker>::read( t1 ) ) { |
---|
| 159 | SemanticError( decl->location, "Cannot redefine typedef: " + decl->name ); |
---|
| 160 | } |
---|
| 161 | } else { |
---|
| 162 | typedefNames[ decl->name ] = |
---|
| 163 | std::make_pair( TypedefDeclPtr( decl ), scopeLevel ); |
---|
| 164 | } |
---|
| 165 | |
---|
| 166 | // When a typedef is a forward declaration: |
---|
| 167 | // > typedef struct screen SCREEN; |
---|
| 168 | // the declaration portion must be retained: |
---|
| 169 | // > struct screen; |
---|
| 170 | // because the expansion of the typedef is: |
---|
| 171 | // > void func( SCREEN * p ) -> void func( struct screen * p ); |
---|
| 172 | // hence type name "screen" must be defined. |
---|
| 173 | // Note: qualifiers on the typedef are not used for the forward declaration. |
---|
| 174 | |
---|
| 175 | ast::Type const * designatorType = decl->base->stripDeclarator(); |
---|
| 176 | if ( auto structType = dynamic_cast<ast::StructInstType const *>( designatorType ) ) { |
---|
| 177 | declsToAddBefore.push_back( new ast::StructDecl( |
---|
| 178 | decl->location, structType->name, ast::AggregateDecl::Struct, {}, |
---|
| 179 | decl->linkage ) ); |
---|
| 180 | } else if ( auto unionType = dynamic_cast<ast::UnionInstType const *>( designatorType ) ) { |
---|
| 181 | declsToAddBefore.push_back( new ast::UnionDecl( |
---|
| 182 | decl->location, unionType->name, {}, decl->linkage ) ); |
---|
| 183 | } else if ( auto enumType = dynamic_cast<ast::EnumInstType const *>( designatorType ) ) { |
---|
| 184 | declsToAddBefore.push_back( new ast::EnumDecl( |
---|
| 185 | decl->location, enumType->name, {}, decl->linkage, |
---|
| 186 | ( (enumType->base) ? enumType->base->base : nullptr ) |
---|
| 187 | ) ); |
---|
| 188 | } |
---|
| 189 | return ast::deepCopy( decl ); |
---|
| 190 | } |
---|
| 191 | |
---|
| 192 | void ReplaceTypedefCore::previsit( ast::TypeDecl const * decl ) { |
---|
| 193 | previsit( (ast::ParseNode const *)decl ); |
---|
| 194 | TypedefMap::iterator iter = typedefNames.find( decl->name ); |
---|
| 195 | if ( iter != typedefNames.end() ) { |
---|
| 196 | typedefNames.erase( iter ); |
---|
| 197 | } |
---|
| 198 | typedeclNames.insert( decl->name, decl ); |
---|
| 199 | } |
---|
| 200 | |
---|
| 201 | void ReplaceTypedefCore::previsit( ast::FunctionDecl const * decl ) { |
---|
| 202 | previsit( (ast::ParseNode const *)decl ); |
---|
| 203 | GuardScope( typedefNames ); |
---|
| 204 | GuardScope( typedeclNames ); |
---|
[af75a87] | 205 | GuardValue( isAtFunctionTop ) = true; |
---|
[1931bb01] | 206 | } |
---|
| 207 | |
---|
| 208 | void ReplaceTypedefCore::previsit( ast::ObjectDecl const * decl ) { |
---|
| 209 | previsit( (ast::ParseNode const *)decl ); |
---|
| 210 | GuardScope( typedefNames ); |
---|
| 211 | GuardScope( typedeclNames ); |
---|
| 212 | } |
---|
| 213 | |
---|
| 214 | ast::DeclWithType const * ReplaceTypedefCore::postvisit( |
---|
| 215 | ast::ObjectDecl const * decl ) { |
---|
| 216 | if ( ast::FunctionType const * type = decl->type.as<ast::FunctionType>() ) { |
---|
| 217 | using DWTVector = std::vector<ast::ptr<ast::DeclWithType>>; |
---|
| 218 | using DeclVector = std::vector<ast::ptr<ast::TypeDecl>>; |
---|
| 219 | CodeLocation const & location = decl->location; |
---|
| 220 | UniqueName paramNamer( decl->name + "Param" ); |
---|
| 221 | |
---|
| 222 | // Replace the current object declaration with a function declaration. |
---|
| 223 | ast::FunctionDecl const * newDecl = new ast::FunctionDecl( |
---|
| 224 | location, |
---|
| 225 | decl->name, |
---|
| 226 | map_range<DeclVector>( type->forall, []( const ast::TypeInstType * inst ) { |
---|
| 227 | return ast::deepCopy( inst->base ); |
---|
| 228 | } ), |
---|
| 229 | map_range<DWTVector>( type->assertions, []( const ast::VariableExpr * expr ) { |
---|
| 230 | return ast::deepCopy( expr->var ); |
---|
| 231 | } ), |
---|
| 232 | map_range<DWTVector>( type->params, [&location, ¶mNamer]( const ast::Type * type ) { |
---|
| 233 | assert( type ); |
---|
| 234 | return new ast::ObjectDecl( location, paramNamer.newName(), ast::deepCopy( type ) ); |
---|
| 235 | } ), |
---|
| 236 | map_range<DWTVector>( type->returns, [&location, ¶mNamer]( const ast::Type * type ) { |
---|
| 237 | assert( type ); |
---|
| 238 | return new ast::ObjectDecl( location, paramNamer.newName(), ast::deepCopy( type ) ); |
---|
| 239 | } ), |
---|
| 240 | nullptr, |
---|
| 241 | decl->storage, |
---|
| 242 | decl->linkage, |
---|
| 243 | {/* attributes */}, |
---|
| 244 | decl->funcSpec |
---|
| 245 | ); |
---|
| 246 | return newDecl; |
---|
| 247 | } |
---|
| 248 | return decl; |
---|
| 249 | } |
---|
| 250 | |
---|
| 251 | void ReplaceTypedefCore::previsit( ast::CastExpr const * expr ) { |
---|
| 252 | previsit( (ast::ParseNode const *)expr ); |
---|
| 253 | GuardScope( typedefNames ); |
---|
| 254 | GuardScope( typedeclNames ); |
---|
| 255 | } |
---|
| 256 | |
---|
| 257 | void ReplaceTypedefCore::previsit( ast::CompoundStmt const * expr ) { |
---|
| 258 | previsit( (ast::ParseNode const *)expr ); |
---|
| 259 | GuardScope( typedefNames ); |
---|
| 260 | GuardScope( typedeclNames ); |
---|
[af75a87] | 261 | GuardValue( isAtFunctionTop ) = false; |
---|
[1931bb01] | 262 | scopeLevel += 1; |
---|
| 263 | } |
---|
| 264 | |
---|
| 265 | void ReplaceTypedefCore::postvisit( ast::CompoundStmt const * ) { |
---|
| 266 | scopeLevel -= 1; |
---|
| 267 | } |
---|
| 268 | |
---|
| 269 | ast::StructDecl const * ReplaceTypedefCore::previsit( ast::StructDecl const * decl ) { |
---|
| 270 | previsit( (ast::ParseNode const *)decl ); |
---|
| 271 | visit_children = false; |
---|
| 272 | addImplicitTypedef( decl ); |
---|
| 273 | return handleAggregate( decl ); |
---|
| 274 | } |
---|
| 275 | |
---|
| 276 | ast::UnionDecl const * ReplaceTypedefCore::previsit( ast::UnionDecl const * decl ) { |
---|
| 277 | previsit( (ast::ParseNode const *)decl ); |
---|
| 278 | visit_children = false; |
---|
| 279 | addImplicitTypedef( decl ); |
---|
| 280 | return handleAggregate( decl ); |
---|
| 281 | } |
---|
| 282 | |
---|
| 283 | void ReplaceTypedefCore::previsit( ast::EnumDecl const * decl ) { |
---|
| 284 | previsit( (ast::ParseNode const *)decl ); |
---|
| 285 | addImplicitTypedef( decl ); |
---|
| 286 | } |
---|
| 287 | |
---|
| 288 | void ReplaceTypedefCore::previsit( ast::TraitDecl const * decl ) { |
---|
| 289 | previsit( (ast::ParseNode const *)decl ); |
---|
| 290 | GuardScope( typedefNames ); |
---|
| 291 | GuardScope( typedeclNames ); |
---|
| 292 | } |
---|
| 293 | |
---|
| 294 | template<typename AggrDecl> |
---|
| 295 | void ReplaceTypedefCore::addImplicitTypedef( AggrDecl * aggrDecl ) { |
---|
| 296 | if ( 0 != typedefNames.count( aggrDecl->name ) ) { |
---|
| 297 | return; |
---|
| 298 | } |
---|
| 299 | ast::Type * type = nullptr; |
---|
| 300 | if ( auto structDecl = dynamic_cast<const ast::StructDecl *>( aggrDecl ) ) { |
---|
| 301 | type = new ast::StructInstType( structDecl->name ); |
---|
| 302 | } else if ( auto unionDecl = dynamic_cast<const ast::UnionDecl *>( aggrDecl ) ) { |
---|
| 303 | type = new ast::UnionInstType( unionDecl->name ); |
---|
| 304 | } else if ( auto enumDecl = dynamic_cast<const ast::EnumDecl *>( aggrDecl ) ) { |
---|
| 305 | type = new ast::EnumInstType( enumDecl->name ); |
---|
| 306 | } |
---|
| 307 | assert( type ); |
---|
| 308 | |
---|
| 309 | TypedefDeclPtr typeDecl = new ast::TypedefDecl( aggrDecl->location, |
---|
| 310 | aggrDecl->name, ast::Storage::Classes(), type, aggrDecl->linkage ); |
---|
| 311 | // Add the implicit typedef to the AST. |
---|
| 312 | declsToAddBefore.push_back( ast::deepCopy( typeDecl.get() ) ); |
---|
| 313 | // Shore the name in the map of names. |
---|
| 314 | typedefNames[ aggrDecl->name ] = |
---|
| 315 | std::make_pair( std::move( typeDecl ), scopeLevel ); |
---|
| 316 | } |
---|
| 317 | |
---|
| 318 | template<typename AggrDecl> |
---|
| 319 | AggrDecl const * ReplaceTypedefCore::handleAggregate( AggrDecl const * decl ) { |
---|
| 320 | SemanticErrorException errors; |
---|
| 321 | |
---|
| 322 | ValueGuard<decltype(declsToAddBefore)> oldBeforeDecls( declsToAddBefore ); |
---|
| 323 | ValueGuard<decltype(declsToAddAfter )> oldAfterDecls( declsToAddAfter ); |
---|
| 324 | declsToAddBefore.clear(); |
---|
| 325 | declsToAddAfter.clear(); |
---|
| 326 | |
---|
| 327 | GuardScope( typedefNames ); |
---|
| 328 | GuardScope( typedeclNames ); |
---|
| 329 | decl = mutate_each( decl, &ast::AggregateDecl::params, *visitor ); |
---|
| 330 | decl = mutate_each( decl, &ast::AggregateDecl::attributes, *visitor ); |
---|
| 331 | |
---|
| 332 | auto mut = ast::mutate( decl ); |
---|
| 333 | |
---|
| 334 | std::vector<ast::ptr<ast::Decl>> members; |
---|
| 335 | // Unroll accept_all for decl->members so that implicit typedefs for |
---|
| 336 | // nested types are added to the aggregate body. |
---|
| 337 | for ( ast::ptr<ast::Decl> const & member : mut->members ) { |
---|
| 338 | assert( declsToAddAfter.empty() ); |
---|
| 339 | ast::Decl const * newMember = nullptr; |
---|
| 340 | try { |
---|
| 341 | newMember = member->accept( *visitor ); |
---|
| 342 | } catch ( SemanticErrorException & e ) { |
---|
| 343 | errors.append( e ); |
---|
| 344 | } |
---|
| 345 | if ( !declsToAddBefore.empty() ) { |
---|
| 346 | for ( auto declToAdd : declsToAddBefore ) { |
---|
| 347 | members.push_back( declToAdd ); |
---|
| 348 | } |
---|
| 349 | declsToAddBefore.clear(); |
---|
| 350 | } |
---|
| 351 | members.push_back( newMember ); |
---|
| 352 | } |
---|
| 353 | assert( declsToAddAfter.empty() ); |
---|
| 354 | if ( !errors.isEmpty() ) { throw errors; } |
---|
| 355 | |
---|
| 356 | mut->members.clear(); |
---|
| 357 | for ( auto member : members ) { |
---|
| 358 | mut->members.push_back( member ); |
---|
| 359 | } |
---|
| 360 | |
---|
| 361 | return mut; |
---|
| 362 | } |
---|
| 363 | |
---|
| 364 | } // namespace |
---|
| 365 | |
---|
| 366 | void replaceTypedef( ast::TranslationUnit & translationUnit ) { |
---|
| 367 | ast::Pass<ReplaceTypedefCore> pass; |
---|
| 368 | ast::accept_all( translationUnit, pass ); |
---|
| 369 | if ( pass.core.typedefNames.count( "size_t" ) ) { |
---|
| 370 | translationUnit.global.sizeType = |
---|
| 371 | ast::deepCopy( pass.core.typedefNames["size_t"].first->base ); |
---|
| 372 | } else { |
---|
| 373 | // Missing the global definition, default to long unsigned int. |
---|
| 374 | // Perhaps this should be a warning instead. |
---|
| 375 | translationUnit.global.sizeType = |
---|
| 376 | new ast::BasicType( ast::BasicType::LongUnsignedInt ); |
---|
| 377 | } |
---|
| 378 | } |
---|
| 379 | |
---|
| 380 | } // namespace Validate |
---|
| 381 | |
---|
| 382 | // Local Variables: // |
---|
| 383 | // tab-width: 4 // |
---|
| 384 | // mode: c++ // |
---|
| 385 | // compile-command: "make install" // |
---|
| 386 | // End: // |
---|