- Timestamp:
- Oct 4, 2023, 5:30:12 PM (11 months ago)
- Branches:
- master
- Children:
- 04db9f6
- Parents:
- 15b5abac
- File:
-
- 1 edited
Legend:
- Unmodified
- Added
- Removed
-
src/GenPoly/BoxNew.cpp
r15b5abac r045cda3 77 77 }; 78 78 79 // Formally takeOtypeOnly80 79 /// Get all sized type declarations; those that affect a layout function. 81 80 ast::vector<ast::TypeDecl> takeSizedParams( … … 510 509 ast::FunctionType const * function, 511 510 TypeVarMap const & typeVars ) { 512 // TODO513 // NOTE: This function previously used isPolyObj, which failed to produce514 // the correct thing in some situations. It's not clear to [Rob Schluntz]515 // why this wasn't working.516 517 511 // If the return type or a parameter type involved polymorphic types, 518 512 // then the adapter will need to take those polymorphic types as pointers. … … 587 581 ast::FunctionType const * type = decl->type; 588 582 if ( isDynRet( type ) && decl->linkage != ast::Linkage::C ) { 589 //retval = type->returns.front();590 583 retval = decl->returns.front(); 591 584 … … 748 741 ast::Expr const * CallAdapter::postvisit( ast::UntypedExpr const * expr ) { 749 742 if ( isPolyDeref( expr, scopeTypeVars, typeSubs ) ) { 750 // TODO Pretty sure this is just a memory management change.751 // Also, I don't understand what this is doing.752 //ast::Expr const * ret = expr->args.front();753 //expr->args.clear();754 //return ret;755 743 return expr->args.front(); 756 744 } … … 1063 1051 ast::ptr<ast::Type> newType = ast::deepCopy( param ); 1064 1052 if ( typeSubs ) typeSubs->apply( newType ); 1065 // TODO: Is this right? (Why wouldn't it be?)1066 // I think this is to make sure we can write to the temporary.1067 //newType.get_and_mutate()->qt = ast::CV::Qualifiers();1068 //reset_qualifiers( newType );1069 1053 ast::ObjectDecl * newObj = makeTemporary( location, newType ); 1070 1054 auto assign = ast::UntypedExpr::createCall( location, "?=?", { … … 1245 1229 } 1246 1230 return new ast::ObjectDecl( location, pNamer.newName(), param ); 1247 } ), // params1231 } ), 1248 1232 map_range<ast::vector<ast::DeclWithType>>( adapterType->returns, 1249 1233 [&rNamer, &location]( ast::ptr<ast::Type> const & retval ) { 1250 1234 return new ast::ObjectDecl( location, rNamer.newName(), retval ); 1251 } ), // returns1235 } ), 1252 1236 nullptr, // stmts 1253 ast::Storage::Classes(), // storage 1254 ast::Linkage::C // linkage 1255 // attrs 1256 // fs 1257 // isVarArgs 1237 {}, // storage 1238 ast::Linkage::C 1258 1239 ); 1259 1240 … … 1314 1295 // Returns a polymorphic type. 1315 1296 } else if ( isDynType( adaptee->returns.front(), typeVars ) ) { 1316 if ( "" == (*paramDecl)->name ) {1317 // TODO: Is it easier to make sure it has a name in the first1318 // place? - I believe this is done, however, I could remove the1319 // condition and just rename for clarity.1320 assertf( false, "Wasn't expecting to get here." );1321 auto mutParam = paramDecl->get_and_mutate();1322 mutParam->name = "_ret";1323 mutParam->linkage = ast::Linkage::C;1324 }1325 1297 ast::UntypedExpr * assign = new ast::UntypedExpr( location, 1326 1298 new ast::NameExpr( location, "?=?" ) ); … … 1546 1518 1547 1519 // -------------------------------------------------------------------------- 1548 /// Creates the adapter functions. TODO1520 /// Modifies declarations to accept implicit parameters. 1549 1521 /// * Move polymorphic returns in function types to pointer-type parameters. 1550 1522 /// * Adds type size and assertion parameters to parameter lists. … … 1559 1531 void previsit( ast::TypeDecl const * decl ); 1560 1532 void previsit( ast::PointerType const * type ); 1561 void previsit( ast::FunctionType const * type );1562 1533 ast::FunctionDecl const * previsit( ast::FunctionDecl const * decl ); 1563 ast:: DeclWithTypeconst * postvisit( ast::FunctionDecl const * decl );1534 ast::FunctionDecl const * postvisit( ast::FunctionDecl const * decl ); 1564 1535 void previsit( ast::CompoundStmt const * stmt ); 1565 1536 private: … … 1616 1587 } 1617 1588 1618 // TODO: I think this code is redundent. 1619 void DeclAdapter::previsit( ast::FunctionType const * type ) { 1620 GuardScope( scopeTypeVars ); 1621 makeTypeVarMap( type, scopeTypeVars ); 1589 // size/align/offset parameters may not be used, so add the unused attribute. 1590 ast::ObjectDecl * makeObj( 1591 CodeLocation const & location, std::string const & name ) { 1592 return new ast::ObjectDecl( location, name, 1593 makeSizeAlignType(), 1594 nullptr, ast::Storage::Classes(), ast::Linkage::C, nullptr, 1595 { new ast::Attribute( "unused" ) } ); 1596 } 1597 1598 ast::ObjectDecl * makePtr( 1599 CodeLocation const & location, std::string const & name ) { 1600 return new ast::ObjectDecl( location, name, 1601 new ast::PointerType( makeSizeAlignType() ), 1602 nullptr, ast::Storage::Classes(), ast::Linkage::C, nullptr ); 1622 1603 } 1623 1604 … … 1639 1620 1640 1621 // Add size/align and assertions for type parameters to parameter list. 1641 std::vector<ast::ptr<ast::DeclWithType>>::iterator last = mutDecl->params.begin(); 1642 std::vector<ast::ptr<ast::DeclWithType>> inferredParams; 1643 // size/align/offset parameters may not be used in body, pass along with unused attribute. 1644 // TODO: These should be created with proper location and name. 1645 // TODO: makeSizeAlign[Out]Type are the same as these types, but they may 1646 // be logically different. 1647 ast::ObjectDecl newObj( mutDecl->location, "", 1648 new ast::BasicType( ast::BasicType::LongUnsignedInt ), 1649 nullptr, ast::Storage::Classes(), ast::Linkage::C, nullptr, 1650 { new ast::Attribute( "unused" ) } ); 1651 ast::ObjectDecl newPtr( mutDecl->location, "", 1652 new ast::PointerType( new ast::BasicType( ast::BasicType::LongUnsignedInt ) ), 1653 nullptr, ast::Storage::Classes(), ast::Linkage::C, nullptr ); 1622 ast::vector<ast::DeclWithType>::iterator last = mutDecl->params.begin(); 1623 ast::vector<ast::DeclWithType> inferredParams; 1654 1624 for ( ast::ptr<ast::TypeDecl> & typeParam : mutDecl->type_params ) { 1655 1625 auto mutParam = mutate( typeParam.get() ); 1656 1626 // Add all size and alignment parameters to parameter list. 1657 1627 if ( mutParam->isComplete() ) { 1658 //ast::TypeInstType paramType( typeParam->name, typeParam );1659 1628 ast::TypeInstType paramType( mutParam ); 1660 1629 std::string paramName = Mangle::mangleType( ¶mType ); 1661 1630 1662 ast::ObjectDecl * sizeParam = ast::deepCopy( &newObj ); 1663 sizeParam->location = typeParam->location; 1664 sizeParam->name = sizeofName( paramName ); 1631 auto sizeParam = makeObj( typeParam->location, sizeofName( paramName ) ); 1665 1632 last = mutDecl->params.insert( last, sizeParam ); 1666 1633 ++last; 1667 1634 1668 ast::ObjectDecl * alignParam = ast::deepCopy( &newObj ); 1669 alignParam->location = typeParam->location; 1670 alignParam->name = alignofName( paramName ); 1635 auto alignParam = makeObj( typeParam->location, alignofName( paramName ) ); 1671 1636 last = mutDecl->params.insert( last, alignParam ); 1672 1637 ++last; … … 1696 1661 // Add size/align for generic parameter types to parameter list. 1697 1662 std::set<std::string> seenTypes; 1698 std::vector<ast::ptr<ast::DeclWithType>> otypeParams;1663 ast::vector<ast::DeclWithType> otypeParams; 1699 1664 for ( ast::ptr<ast::DeclWithType> & funcParam : mutDecl->params ) { 1700 1665 ast::Type const * polyType = isPolyType( funcParam->get_type(), scopeTypeVars ); … … 1705 1670 if ( seenTypes.count( typeName ) ) continue; 1706 1671 1707 ast::ObjectDecl * sizeParam = ast::deepCopy( &newObj ); 1708 sizeParam->location = funcParam->location; 1709 sizeParam->name = sizeofName( typeName ); 1672 auto sizeParam = makeObj( funcParam->location, sizeofName( typeName ) ); 1710 1673 otypeParams.emplace_back( sizeParam ); 1711 1674 1712 ast::ObjectDecl * alignParam = ast::deepCopy( &newObj ); 1713 alignParam->location = funcParam->location; 1714 alignParam->name = alignofName( typeName ); 1675 auto alignParam = makeObj( funcParam->location, alignofName( typeName ) ); 1715 1676 otypeParams.emplace_back( alignParam ); 1716 1677 … … 1720 1681 // offset array. 1721 1682 if ( !polyStruct->base->members.empty() ) { 1722 ast::ObjectDecl * offsetParam = ast::deepCopy( &newPtr ); 1723 offsetParam->location = funcParam->location; 1724 offsetParam->name = offsetofName( typeName ); 1683 auto offsetParam = makePtr( funcParam->location, offsetofName( typeName ) ); 1725 1684 otypeParams.emplace_back( offsetParam ); 1726 1685 } … … 1739 1698 } 1740 1699 1741 ast:: DeclWithTypeconst * DeclAdapter::postvisit(1700 ast::FunctionDecl const * DeclAdapter::postvisit( 1742 1701 ast::FunctionDecl const * decl ) { 1743 1702 ast::FunctionDecl * mutDecl = mutate( decl ); … … 1788 1747 // It actually does mutate in-place, but does the return for consistency. 1789 1748 ast::FunctionDecl * DeclAdapter::addAdapters( ast::FunctionDecl * mutDecl ) { 1790 std::vector<ast::ptr<ast::FunctionType>> functions;1749 ast::vector<ast::FunctionType> functions; 1791 1750 for ( ast::ptr<ast::DeclWithType> & arg : mutDecl->params ) { 1792 1751 ast::Type const * type = arg->get_type(); … … 1926 1885 /// Namer for VLA (variable length array) buffers. 1927 1886 UniqueName bufNamer; 1928 /// AddressExpr argument is MemberExpr? (TODO: What?)1929 ast:: Expr const * addrMember = nullptr;1887 /// If the argument of an AddressExpr is MemberExpr, it is stored here. 1888 ast::MemberExpr const * addrMember = nullptr; 1930 1889 /// Used to avoid recursing too deep in type declarations. 1931 1890 bool expect_func_type = false; … … 1959 1918 beginTypeScope( decl->type ); 1960 1919 1961 // - Tried inserting this code. 1962 // Make sure that any type information passed into the function is 1963 // accounted for. 1964 // TODO: For some reason going through decl->params/->get_type() does 1965 // not work. Possibly something is not getting updated. 1920 // TODO: Going though dec->params does not work for some reason. 1966 1921 for ( ast::ptr<ast::Type> const & funcParam : decl->type->params ) { 1967 1922 // Condition here duplicates that in `DeclAdapter::previsit( FunctionDecl const * )` … … 2019 1974 ast::StructDecl const * PolyGenericCalculator::previsit( 2020 1975 ast::StructDecl const * decl ) { 2021 //return strict_dynamic_cast<ast::StructDecl *>( mutateMembers( decl ) );2022 1976 auto mutDecl = mutate( decl ); 2023 1977 mutateMembers( mutDecl ); … … 2027 1981 ast::UnionDecl const * PolyGenericCalculator::previsit( 2028 1982 ast::UnionDecl const * decl ) { 2029 //return strict_dynamic_cast<ast::UnionDecl *>( mutateMembers( decl ) );2030 1983 auto mutDecl = mutate( decl ); 2031 1984 mutateMembers( mutDecl ); … … 2088 2041 auto mutDecl = mutate( decl ); 2089 2042 2090 //mutDecl->attributes.remove_if( matchAndMove ); 2091 // TODO: This common helper might work, but does not officially support 2092 // side effects. 2043 // Forally, side effects are not safe in this function. But it works. 2093 2044 erase_if( mutDecl->attributes, matchAndMove ); 2094 2045 … … 2198 2149 // the substitution manually. For some reason this is not currently the 2199 2150 // case. This requires more investigation. 2200 ast:: Type const *memberType = deepCopy( expr->member->get_type() );2151 ast::ptr<ast::Type> memberType = deepCopy( expr->member->get_type() ); 2201 2152 ast::TypeSubstitution sub = genericSubstitution( objectType ); 2202 auto result =sub.apply( memberType );2203 memberType = result.node.get(); // .release(); 2153 sub.apply( memberType ); 2154 2204 2155 // Not all members of a polymorphic type are themselves of a polymorphic 2205 2156 // type; in this cas the member expression should be wrapped and … … 2217 2168 2218 2169 void PolyGenericCalculator::previsit( ast::AddressExpr const * expr ) { 2219 // Is the argument a MemberExpr before mutating?2220 2170 GuardValue( addrMember ) = expr->arg.as<ast::MemberExpr>(); 2221 2171 } … … 2233 2183 // MemberExpr was converted to pointer + offset; and it is not valid C to 2234 2184 // take the address of an addition, so stript the address-of. 2235 // TODO: should expr->arg->result be changed to expr->result? 2236 ast::Expr * ret = mutate( expr->arg.get() ); 2237 ret->env = expr->env; 2238 return ret; 2185 // It also preserves the env value. 2186 return ast::mutate_field( expr->arg.get(), &ast::Expr::env, expr->env ); 2239 2187 } 2240 2188 … … 2572 2520 public BoxPass, 2573 2521 public ast::WithGuards { 2574 template<typename decl_t> 2575 decl_t const * handleDecl( decl_t const * decl, ast::Type const * type ); 2522 void guardTypeVarMap( ast::Type const * type ) { 2523 GuardScope( scopeTypeVars ); 2524 makeTypeVarMap( type, scopeTypeVars ); 2525 } 2576 2526 2577 2527 ast::ObjectDecl const * previsit( ast::ObjectDecl const * decl ); … … 2585 2535 }; 2586 2536 2587 template<typename decl_t> 2588 decl_t const * Eraser::handleDecl( 2589 decl_t const * decl, ast::Type const * type ) { 2590 GuardScope( scopeTypeVars ); 2591 makeTypeVarMap( type, scopeTypeVars ); 2537 ast::ObjectDecl const * Eraser::previsit( ast::ObjectDecl const * decl ) { 2538 guardTypeVarMap( decl->type ); 2592 2539 return scrubAllTypeVars( decl ); 2593 2540 } 2594 2541 2595 ast::ObjectDecl const * Eraser::previsit( ast::ObjectDecl const * decl ) {2596 return handleDecl( decl, decl->type );2597 }2598 2599 2542 ast::FunctionDecl const * Eraser::previsit( ast::FunctionDecl const * decl ) { 2600 return handleDecl( decl, decl->type ); 2543 guardTypeVarMap( decl->type ); 2544 return scrubAllTypeVars( decl ); 2601 2545 } 2602 2546 2603 2547 ast::TypedefDecl const * Eraser::previsit( ast::TypedefDecl const * decl ) { 2604 return handleDecl( decl, decl->base ); 2548 guardTypeVarMap( decl->base ); 2549 return scrubAllTypeVars( decl ); 2605 2550 } 2606 2551 … … 2608 2553 template<typename node_t> 2609 2554 node_t const * stripGenericMembers( node_t const * decl ) { 2610 if ( !decl->params.empty() ) { 2611 auto mutDecl = ast::mutate( decl ); 2612 mutDecl->members.clear(); 2613 return mutDecl; 2614 } 2615 return decl; 2555 if ( decl->params.empty() ) return decl; 2556 auto mutDecl = ast::mutate( decl ); 2557 mutDecl->members.clear(); 2558 return mutDecl; 2616 2559 } 2617 2560 … … 2629 2572 2630 2573 void Eraser::previsit( ast::PointerType const * type ) { 2631 GuardScope( scopeTypeVars ); 2632 makeTypeVarMap( type, scopeTypeVars ); 2574 guardTypeVarMap( type ); 2633 2575 } 2634 2576 2635 2577 void Eraser::previsit( ast::FunctionType const * type ) { 2636 GuardScope( scopeTypeVars ); 2637 makeTypeVarMap( type, scopeTypeVars ); 2578 guardTypeVarMap( type ); 2638 2579 } 2639 2580
Note: See TracChangeset
for help on using the changeset viewer.