Changeset c935c3a
- Timestamp:
- Sep 13, 2017, 3:03:32 PM (8 years ago)
- Branches:
- ADT, aaron-thesis, arm-eh, ast-experimental, cleanup-dtors, deferred_resn, demangler, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, pthread-emulation, qualifiedEnum, resolv-new, with_gc
- Children:
- ed235b6
- Parents:
- b2e2e34 (diff), 982832e (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the(diff)
links above to see all the changes relative to each parent. - Location:
- src
- Files:
-
- 3 added
- 48 edited
Legend:
- Unmodified
- Added
- Removed
-
src/CodeGen/CodeGenerator.cc
rb2e2e34 rc935c3a 258 258 259 259 void CodeGenerator::visit( TraitDecl * traitDecl ) { 260 assertf( ! genC, "TraitDecl nodes should not reach code generation." );260 assertf( ! genC, "TraitDecls should not reach code generation." ); 261 261 extension( traitDecl ); 262 262 handleAggregate( traitDecl, "trait " ); … … 271 271 272 272 void CodeGenerator::visit( TypeDecl * typeDecl ) { 273 if ( genC ) { 274 // really, we should mutate this into something that isn't a TypeDecl but that requires large-scale changes, 275 // still to be done 276 extension( typeDecl ); 277 output << "extern unsigned long " << typeDecl->get_name(); 278 if ( typeDecl->get_base() ) { 279 output << " = sizeof( " << genType( typeDecl->get_base(), "", pretty, genC ) << " )"; 280 } // if 281 } else { 282 output << typeDecl->genTypeString() << " " << typeDecl->get_name(); 283 if ( typeDecl->get_kind() != TypeDecl::Any && typeDecl->get_sized() ) { 284 output << " | sized(" << typeDecl->get_name() << ")"; 285 } 286 if ( ! typeDecl->get_assertions().empty() ) { 287 output << " | { "; 288 genCommaList( typeDecl->get_assertions().begin(), typeDecl->get_assertions().end() ); 289 output << " }"; 290 } 273 assertf( ! genC, "TypeDecls should not reach code generation." ); 274 output << typeDecl->genTypeString() << " " << typeDecl->get_name(); 275 if ( typeDecl->get_kind() != TypeDecl::Any && typeDecl->get_sized() ) { 276 output << " | sized(" << typeDecl->get_name() << ")"; 277 } 278 if ( ! typeDecl->get_assertions().empty() ) { 279 output << " | { "; 280 genCommaList( typeDecl->get_assertions().begin(), typeDecl->get_assertions().end() ); 281 output << " }"; 291 282 } 292 283 } -
src/Common/PassVisitor.h
rb2e2e34 rc935c3a 7 7 #include "SynTree/Mutator.h" 8 8 #include "SynTree/Visitor.h" 9 10 #include "SymTab/Indexer.h" 9 11 10 12 #include "SynTree/Initializer.h" … … 145 147 virtual Declaration* mutate( EnumDecl *aggregateDecl ) override final; 146 148 virtual Declaration* mutate( TraitDecl *aggregateDecl ) override final; 147 virtual TypeDecl* mutate( TypeDecl *typeDecl ) override final;149 virtual Declaration* mutate( TypeDecl *typeDecl ) override final; 148 150 virtual Declaration* mutate( TypedefDecl *typeDecl ) override final; 149 151 virtual AsmDecl* mutate( AsmDecl *asmDecl ) override final; … … 265 267 266 268 void set_visit_children( bool& ref ) { bool_ref * ptr = visit_children_impl(pass, 0); if(ptr) ptr->set( ref ); } 269 270 void indexerScopeEnter () { indexer_impl_enterScope ( pass, 0 ); } 271 void indexerScopeLeave () { indexer_impl_leaveScope ( pass, 0 ); } 272 void indexerAddId ( DeclarationWithType * node ) { indexer_impl_addId ( pass, 0, node ); } 273 void indexerAddType ( NamedTypeDecl * node ) { indexer_impl_addType ( pass, 0, node ); } 274 void indexerAddStruct ( const std::string & id ) { indexer_impl_addStruct ( pass, 0, id ); } 275 void indexerAddStruct ( StructDecl * node ) { indexer_impl_addStruct ( pass, 0, node ); } 276 void indexerAddStructFwd( StructDecl * node ) { indexer_impl_addStructFwd( pass, 0, node ); } 277 void indexerAddEnum ( EnumDecl * node ) { indexer_impl_addEnum ( pass, 0, node ); } 278 void indexerAddUnion ( const std::string & id ) { indexer_impl_addUnion ( pass, 0, id ); } 279 void indexerAddUnion ( UnionDecl * node ) { indexer_impl_addUnion ( pass, 0, node ); } 280 void indexerAddUnionFwd ( UnionDecl * node ) { indexer_impl_addUnionFwd ( pass, 0, node ); } 281 void indexerAddTrait ( TraitDecl * node ) { indexer_impl_addTrait ( pass, 0, node ); } 282 283 template< typename TreeType, typename VisitorType > 284 friend inline void indexerScopedAccept( TreeType * tree, VisitorType &visitor ); 285 286 template< typename TreeType, typename VisitorType > 287 friend inline void indexerScopedMutate( TreeType *& tree, VisitorType &visitor ); 267 288 }; 268 289 … … 296 317 protected: 297 318 WithDeclsToAdd() = default; 298 ~WithDeclsToAdd() = default; 319 ~WithDeclsToAdd() { 320 assert( declsToAddBefore.empty() ); 321 } 299 322 300 323 public: … … 351 374 }; 352 375 376 class WithIndexer { 377 protected: 378 WithIndexer() {} 379 ~WithIndexer() {} 380 381 public: 382 SymTab::Indexer indexer; 383 }; 384 353 385 #include "PassVisitor.impl.h" -
src/Common/PassVisitor.impl.h
rb2e2e34 rc935c3a 101 101 } 102 102 103 template< typename Container, typename VisitorType > 104 inline void maybeAccept( Container &container, VisitorType &visitor ) { 105 SemanticError errors; 106 for ( typename Container::iterator i = container.begin(); i != container.end(); ++i ) { 107 try { 108 if ( *i ) { 109 (*i)->accept( visitor ); 110 } 111 } catch( SemanticError &e ) { 112 e.set_location( (*i)->location ); 113 errors.append( e ); 114 } 115 } 116 if ( ! errors.isEmpty() ) { 117 throw errors; 118 } 119 } 120 121 template< typename Container, typename MutatorType > 122 inline void maybeMutateRef( Container &container, MutatorType &mutator ) { 123 SemanticError errors; 124 for ( typename Container::iterator i = container.begin(); i != container.end(); ++i ) { 125 try { 126 if ( *i ) { 127 /// *i = (*i)->acceptMutator( mutator ); 128 *i = dynamic_cast< typename Container::value_type >( (*i)->acceptMutator( mutator ) ); 129 assert( *i ); 130 } // if 131 } catch( SemanticError &e ) { 132 e.set_location( (*i)->location ); 133 errors.append( e ); 134 } // try 135 } // for 136 if ( ! errors.isEmpty() ) { 137 throw errors; 138 } // if 139 } 140 103 141 template< typename pass_type > 104 142 template< typename func_t > … … 230 268 231 269 //------------------------------------------------------------------------------------------------------------------------------------------------------------------------ 232 270 //======================================================================================================================================================================== 271 //======================================================================================================================================================================== 272 //======================================================================================================================================================================== 273 //======================================================================================================================================================================== 274 //======================================================================================================================================================================== 275 //------------------------------------------------------------------------------------------------------------------------------------------------------------------------ 276 277 278 //-------------------------------------------------------------------------- 279 // ObjectDecl 233 280 template< typename pass_type > 234 281 void PassVisitor< pass_type >::visit( ObjectDecl * node ) { 235 VISIT_BODY( node ); 236 } 237 282 VISIT_START( node ); 283 284 indexerScopedAccept( node->type , *this ); 285 maybeAccept ( node->init , *this ); 286 maybeAccept ( node->bitfieldWidth, *this ); 287 288 if ( node->name != "" ) { 289 indexerAddId( node ); 290 } 291 292 VISIT_END( node ); 293 } 294 295 template< typename pass_type > 296 DeclarationWithType * PassVisitor< pass_type >::mutate( ObjectDecl * node ) { 297 MUTATE_START( node ); 298 299 indexerScopedMutate( node->type , *this ); 300 maybeMutateRef ( node->init , *this ); 301 maybeMutateRef ( node->bitfieldWidth, *this ); 302 303 if ( node->name != "" ) { 304 indexerAddId( node ); 305 } 306 307 MUTATE_END( DeclarationWithType, node ); 308 } 309 310 //-------------------------------------------------------------------------- 311 // FunctionDecl 238 312 template< typename pass_type > 239 313 void PassVisitor< pass_type >::visit( FunctionDecl * node ) { 240 VISIT_BODY( node ); 241 } 242 314 VISIT_START( node ); 315 316 if ( node->name != "" ) { 317 indexerAddId( node ); 318 } 319 320 { 321 auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } ); 322 maybeAccept( node->type, *this ); 323 maybeAccept( node->statements, *this ); 324 } 325 326 VISIT_END( node ); 327 } 328 329 template< typename pass_type > 330 DeclarationWithType * PassVisitor< pass_type >::mutate( FunctionDecl * node ) { 331 MUTATE_START( node ); 332 333 if ( node->name != "" ) { 334 indexerAddId( node ); 335 } 336 337 { 338 auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } ); 339 maybeMutateRef( node->type, *this ); 340 maybeMutateRef( node->statements, *this ); 341 } 342 343 MUTATE_END( DeclarationWithType, node ); 344 } 345 346 //-------------------------------------------------------------------------- 347 // StructDecl 243 348 template< typename pass_type > 244 349 void PassVisitor< pass_type >::visit( StructDecl * node ) { 245 VISIT_BODY( node ); 246 } 247 350 VISIT_START( node ); 351 352 // make up a forward declaration and add it before processing the members 353 // needs to be on the heap because addStruct saves the pointer 354 indexerAddStructFwd( node ); 355 356 { 357 auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } ); 358 maybeAccept( node->parameters, *this ); 359 maybeAccept( node->members , *this ); 360 } 361 362 // this addition replaces the forward declaration 363 indexerAddStruct( node ); 364 365 VISIT_END( node ); 366 } 367 368 template< typename pass_type > 369 Declaration * PassVisitor< pass_type >::mutate( StructDecl * node ) { 370 MUTATE_START( node ); 371 372 // make up a forward declaration and add it before processing the members 373 // needs to be on the heap because addStruct saves the pointer 374 indexerAddStructFwd( node ); 375 376 { 377 auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } ); 378 maybeMutateRef( node->parameters, *this ); 379 maybeMutateRef( node->members , *this ); 380 } 381 382 // this addition replaces the forward declaration 383 indexerAddStruct( node ); 384 385 MUTATE_END( Declaration, node ); 386 } 387 388 //-------------------------------------------------------------------------- 389 // UnionDecl 248 390 template< typename pass_type > 249 391 void PassVisitor< pass_type >::visit( UnionDecl * node ) { 250 VISIT_BODY( node ); 251 } 252 392 VISIT_START( node ); 393 394 // make up a forward declaration and add it before processing the members 395 indexerAddUnionFwd( node ); 396 397 { 398 auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } ); 399 maybeAccept( node->parameters, *this ); 400 maybeAccept( node->members , *this ); 401 } 402 403 indexerAddUnion( node ); 404 405 VISIT_END( node ); 406 } 407 408 template< typename pass_type > 409 Declaration * PassVisitor< pass_type >::mutate( UnionDecl * node ) { 410 MUTATE_START( node ); 411 412 // make up a forward declaration and add it before processing the members 413 indexerAddUnionFwd( node ); 414 415 { 416 auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } ); 417 maybeMutateRef( node->parameters, *this ); 418 maybeMutateRef( node->members , *this ); 419 } 420 421 indexerAddUnion( node ); 422 423 MUTATE_END( Declaration, node ); 424 } 425 426 //-------------------------------------------------------------------------- 427 // EnumDecl 253 428 template< typename pass_type > 254 429 void PassVisitor< pass_type >::visit( EnumDecl * node ) { 255 VISIT_BODY( node ); 256 } 257 430 VISIT_START( node ); 431 432 indexerAddEnum( node ); 433 434 // unlike structs, contexts, and unions, enums inject their members into the global scope 435 maybeAccept( node->parameters, *this ); 436 maybeAccept( node->members , *this ); 437 438 VISIT_END( node ); 439 } 440 441 template< typename pass_type > 442 Declaration * PassVisitor< pass_type >::mutate( EnumDecl * node ) { 443 MUTATE_START( node ); 444 445 indexerAddEnum( node ); 446 447 // unlike structs, contexts, and unions, enums inject their members into the global scope 448 maybeMutateRef( node->parameters, *this ); 449 maybeMutateRef( node->members , *this ); 450 451 MUTATE_END( Declaration, node ); 452 } 453 454 //-------------------------------------------------------------------------- 455 // TraitDecl 258 456 template< typename pass_type > 259 457 void PassVisitor< pass_type >::visit( TraitDecl * node ) { 260 VISIT_BODY( node ); 261 } 262 458 VISIT_START( node ); 459 460 { 461 auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } ); 462 maybeAccept( node->parameters, *this ); 463 maybeAccept( node->members , *this ); 464 } 465 466 indexerAddTrait( node ); 467 468 VISIT_END( node ); 469 } 470 471 template< typename pass_type > 472 Declaration * PassVisitor< pass_type >::mutate( TraitDecl * node ) { 473 MUTATE_START( node ); 474 475 { 476 auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } ); 477 maybeMutateRef( node->parameters, *this ); 478 maybeMutateRef( node->members , *this ); 479 } 480 481 indexerAddTrait( node ); 482 483 MUTATE_END( Declaration, node ); 484 } 485 486 //-------------------------------------------------------------------------- 487 // TypeDecl 263 488 template< typename pass_type > 264 489 void PassVisitor< pass_type >::visit( TypeDecl * node ) { 265 VISIT_BODY( node ); 266 } 267 490 VISIT_START( node ); 491 492 { 493 auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } ); 494 maybeAccept( node->parameters, *this ); 495 maybeAccept( node->base , *this ); 496 } 497 498 indexerAddType( node ); 499 500 maybeAccept( node->assertions, *this ); 501 502 indexerScopedAccept( node->init, *this ); 503 504 VISIT_END( node ); 505 } 506 507 template< typename pass_type > 508 Declaration * PassVisitor< pass_type >::mutate( TypeDecl * node ) { 509 MUTATE_START( node ); 510 511 { 512 auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } ); 513 maybeMutateRef( node->parameters, *this ); 514 maybeMutateRef( node->base , *this ); 515 } 516 517 indexerAddType( node ); 518 519 maybeMutateRef( node->assertions, *this ); 520 521 indexerScopedMutate( node->init, *this ); 522 523 MUTATE_END( Declaration, node ); 524 } 525 526 //-------------------------------------------------------------------------- 527 // TypedefDecl 268 528 template< typename pass_type > 269 529 void PassVisitor< pass_type >::visit( TypedefDecl * node ) { 270 VISIT_BODY( node ); 271 } 272 530 VISIT_START( node ); 531 532 { 533 auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } ); 534 maybeAccept( node->parameters, *this ); 535 maybeAccept( node->base , *this ); 536 } 537 538 indexerAddType( node ); 539 540 maybeAccept( node->assertions, *this ); 541 542 VISIT_END( node ); 543 } 544 545 template< typename pass_type > 546 Declaration * PassVisitor< pass_type >::mutate( TypedefDecl * node ) { 547 MUTATE_START( node ); 548 549 { 550 auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } ); 551 maybeMutateRef ( node->parameters, *this ); 552 maybeMutateRef( node->base , *this ); 553 } 554 555 indexerAddType( node ); 556 557 maybeMutateRef( node->assertions, *this ); 558 559 MUTATE_END( Declaration, node ); 560 } 561 562 //-------------------------------------------------------------------------- 563 // AsmDecl 273 564 template< typename pass_type > 274 565 void PassVisitor< pass_type >::visit( AsmDecl * node ) { 275 VISIT_BODY( node ); 566 VISIT_START( node ); 567 568 maybeAccept( node->stmt, *this ); 569 570 VISIT_END( node ); 571 } 572 573 template< typename pass_type > 574 AsmDecl * PassVisitor< pass_type >::mutate( AsmDecl * node ) { 575 MUTATE_START( node ); 576 577 maybeMutateRef( node->stmt, *this ); 578 579 MUTATE_END( AsmDecl, node ); 276 580 } 277 581 … … 281 585 void PassVisitor< pass_type >::visit( CompoundStmt * node ) { 282 586 VISIT_START( node ); 283 call_beginScope();284 285 visitStatementList( node->get_kids());286 287 call_endScope();587 { 588 auto guard1 = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } ); 589 auto guard2 = makeFuncGuard( [this]() { call_beginScope(); }, [this]() { call_endScope(); } ); 590 visitStatementList( node->kids ); 591 } 288 592 VISIT_END( node ); 289 593 } … … 292 596 CompoundStmt * PassVisitor< pass_type >::mutate( CompoundStmt * node ) { 293 597 MUTATE_START( node ); 294 call_beginScope();295 296 mutateStatementList( node->get_kids());297 298 call_endScope();598 { 599 auto guard1 = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } ); 600 auto guard2 = makeFuncGuard( [this]() { call_beginScope(); }, [this]() { call_endScope(); } ); 601 mutateStatementList( node->kids ); 602 } 299 603 MUTATE_END( CompoundStmt, node ); 300 604 } … … 306 610 VISIT_START( node ); 307 611 308 visitExpression( node-> get_expr());612 visitExpression( node->expr ); 309 613 310 614 VISIT_END( node ); … … 315 619 MUTATE_START( node ); 316 620 317 node-> set_expr( mutateExpression( node->get_expr() ));621 node->expr = mutateExpression( node->expr ); 318 622 319 623 MUTATE_END( Statement, node ); … … 338 642 VISIT_START( node ); 339 643 340 visitExpression( node-> get_condition());341 node-> set_thenPart ( visitStatement( node->get_thenPart() ));342 node-> set_elsePart ( visitStatement( node->get_elsePart() ));644 visitExpression( node->condition ); 645 node->thenPart = visitStatement( node->thenPart ); 646 node->elsePart = visitStatement( node->elsePart ); 343 647 344 648 VISIT_END( node ); … … 348 652 Statement * PassVisitor< pass_type >::mutate( IfStmt * node ) { 349 653 MUTATE_START( node ); 350 351 node->set_condition( mutateExpression( node->get_condition() ) ); 352 node->set_thenPart ( mutateStatement ( node->get_thenPart() ) ); 353 node->set_elsePart ( mutateStatement ( node->get_elsePart() ) ); 354 654 { 655 auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } ); 656 node->condition = mutateExpression( node->condition ); 657 node->thenPart = mutateStatement ( node->thenPart ); 658 node->elsePart = mutateStatement ( node->elsePart ); 659 } 355 660 MUTATE_END( Statement, node ); 356 661 } … … 362 667 VISIT_START( node ); 363 668 364 visitExpression( node-> get_condition());365 node-> set_body( visitStatement( node->get_body() ));669 visitExpression( node->condition ); 670 node->body = visitStatement( node->body ); 366 671 367 672 VISIT_END( node ); … … 372 677 MUTATE_START( node ); 373 678 374 node-> set_condition( mutateExpression( node->get_condition() ));375 node-> set_body( mutateStatement( node->get_body() ));679 node->condition = mutateExpression( node->condition ); 680 node->body = mutateStatement ( node->body ); 376 681 377 682 MUTATE_END( Statement, node ); … … 383 688 void PassVisitor< pass_type >::visit( ForStmt * node ) { 384 689 VISIT_START( node ); 385 386 acceptAll( node->get_initialization(), *this ); 387 visitExpression( node->get_condition() ); 388 visitExpression( node->get_increment() ); 389 node->set_body( visitStatement( node->get_body() ) ); 390 690 { 691 auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } ); 692 maybeAccept( node->initialization, *this ); 693 visitExpression( node->condition ); 694 visitExpression( node->increment ); 695 node->body = visitStatement( node->body ); 696 } 391 697 VISIT_END( node ); 392 698 } … … 395 701 Statement * PassVisitor< pass_type >::mutate( ForStmt * node ) { 396 702 MUTATE_START( node ); 397 398 mutateAll( node->get_initialization(), *this ); 399 node->set_condition( mutateExpression( node->get_condition() ) ); 400 node->set_increment( mutateExpression( node->get_increment() ) ); 401 node->set_body( mutateStatement( node->get_body() ) ); 402 703 { 704 auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } ); 705 maybeMutateRef( node->initialization, *this ); 706 node->condition = mutateExpression( node->condition ); 707 node->increment = mutateExpression( node->increment ); 708 node->body = mutateStatement ( node->body ); 709 } 403 710 MUTATE_END( Statement, node ); 404 711 } … … 410 717 VISIT_START( node ); 411 718 412 visitExpression ( node->get_condition());413 visitStatementList( node-> get_statements());719 visitExpression ( node->condition ); 720 visitStatementList( node->statements ); 414 721 415 722 VISIT_END( node ); … … 420 727 MUTATE_START( node ); 421 728 422 node-> set_condition( mutateExpression( node->get_condition() ));423 mutateStatementList( node-> get_statements());729 node->condition = mutateExpression( node->condition ); 730 mutateStatementList( node->statements ); 424 731 425 732 MUTATE_END( Statement, node ); … … 432 739 VISIT_START( node ); 433 740 434 visitExpression ( node->get_condition());435 visitStatementList( node-> get_statements());741 visitExpression ( node->condition ); 742 visitStatementList( node->stmts ); 436 743 437 744 VISIT_END( node ); … … 442 749 MUTATE_START( node ); 443 750 444 node-> set_condition( mutateExpression( node->get_condition() ));445 mutateStatementList( node-> get_statements());751 node->condition = mutateExpression( node->condition ); 752 mutateStatementList( node->stmts ); 446 753 447 754 MUTATE_END( Statement, node ); … … 466 773 VISIT_START( node ); 467 774 468 visitExpression( node-> get_expr());775 visitExpression( node->expr ); 469 776 470 777 VISIT_END( node ); … … 475 782 MUTATE_START( node ); 476 783 477 node-> set_expr( mutateExpression( node->get_expr() ));784 node->expr = mutateExpression( node->expr ); 478 785 479 786 MUTATE_END( Statement, node ); … … 499 806 VISIT_START( node ); 500 807 501 maybeAccept( node-> get_block(), *this );502 acceptAll( node->get_catchers(), *this );503 maybeAccept( node-> get_finally(), *this );808 maybeAccept( node->block , *this ); 809 maybeAccept( node->handlers , *this ); 810 maybeAccept( node->finallyBlock, *this ); 504 811 505 812 VISIT_END( node ); … … 510 817 MUTATE_START( node ); 511 818 512 node->set_block( maybeMutate( node->get_block(), *this ));513 m utateAll( node->get_catchers(), *this );514 node->set_finally( maybeMutate( node->get_finally(), *this ));819 maybeMutateRef( node->block , *this ); 820 maybeMutateRef( node->handlers , *this ); 821 maybeMutateRef( node->finallyBlock, *this ); 515 822 516 823 MUTATE_END( Statement, node ); … … 522 829 void PassVisitor< pass_type >::visit( CatchStmt * node ) { 523 830 VISIT_START( node ); 524 525 maybeAccept( node->get_decl(), *this ); 526 node->set_cond( visitExpression( node->get_cond() ) ); 527 node->set_body( visitStatement( node->get_body() ) ); 528 831 { 832 auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } ); 833 maybeAccept( node->decl, *this ); 834 node->cond = visitExpression( node->cond ); 835 node->body = visitStatement ( node->body ); 836 } 529 837 VISIT_END( node ); 530 838 } … … 533 841 Statement * PassVisitor< pass_type >::mutate( CatchStmt * node ) { 534 842 MUTATE_START( node ); 535 536 node->set_decl( maybeMutate( node->get_decl(), *this ) ); 537 node->set_cond( mutateExpression( node->get_cond() ) ); 538 node->set_body( mutateStatement( node->get_body() ) ); 539 843 { 844 auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } ); 845 maybeMutateRef( node->decl, *this ); 846 node->cond = mutateExpression( node->cond ); 847 node->body = mutateStatement ( node->body ); 848 } 540 849 MUTATE_END( Statement, node ); 541 850 } … … 605 914 template< typename pass_type > 606 915 void PassVisitor< pass_type >::visit( ApplicationExpr * node ) { 607 VISIT_BODY( node ); 916 VISIT_START( node ); 917 918 indexerScopedAccept( node->result , *this ); 919 maybeAccept ( node->function, *this ); 920 maybeAccept ( node->args , *this ); 921 922 VISIT_END( node ); 608 923 } 609 924 610 925 template< typename pass_type > 611 926 Expression * PassVisitor< pass_type >::mutate( ApplicationExpr * node ) { 612 MUTATE_BODY( Expression, node ); 927 MUTATE_START( node ); 928 929 indexerScopedMutate( node->env , *this ); 930 indexerScopedMutate( node->result , *this ); 931 maybeMutateRef ( node->function, *this ); 932 maybeMutateRef ( node->args , *this ); 933 934 MUTATE_END( Expression, node ); 613 935 } 614 936 … … 620 942 621 943 // maybeAccept( node->get_env(), *this ); 622 maybeAccept( node->get_result(), *this );623 624 for ( auto expr : node-> get_args()) {944 indexerScopedAccept( node->result, *this ); 945 946 for ( auto expr : node->args ) { 625 947 visitExpression( expr ); 626 948 } … … 633 955 MUTATE_START( node ); 634 956 635 node->set_env( maybeMutate( node->get_env(), *this ));636 node->set_result( maybeMutate( node->get_result(), *this ));637 638 for ( auto& expr : node-> get_args()) {957 indexerScopedMutate( node->env , *this ); 958 indexerScopedMutate( node->result, *this ); 959 960 for ( auto& expr : node->args ) { 639 961 expr = mutateExpression( expr ); 640 962 } … … 643 965 } 644 966 967 //-------------------------------------------------------------------------- 968 // NameExpr 645 969 template< typename pass_type > 646 970 void PassVisitor< pass_type >::visit( NameExpr * node ) { 647 VISIT_BODY( node ); 648 } 649 971 VISIT_START( node ); 972 973 indexerScopedAccept( node->result, *this ); 974 975 VISIT_END( node ); 976 } 977 978 template< typename pass_type > 979 Expression * PassVisitor< pass_type >::mutate( NameExpr * node ) { 980 MUTATE_START( node ); 981 982 indexerScopedMutate( node->env , *this ); 983 indexerScopedMutate( node->result, *this ); 984 985 MUTATE_END( Expression, node ); 986 } 987 988 //-------------------------------------------------------------------------- 989 // CastExpr 650 990 template< typename pass_type > 651 991 void PassVisitor< pass_type >::visit( CastExpr * node ) { 652 VISIT_BODY( node ); 653 } 654 992 VISIT_START( node ); 993 994 indexerScopedAccept( node->result, *this ); 995 maybeAccept ( node->arg , *this ); 996 997 VISIT_END( node ); 998 } 999 1000 template< typename pass_type > 1001 Expression * PassVisitor< pass_type >::mutate( CastExpr * node ) { 1002 MUTATE_START( node ); 1003 1004 indexerScopedMutate( node->env , *this ); 1005 indexerScopedMutate( node->result, *this ); 1006 maybeMutateRef ( node->arg , *this ); 1007 1008 MUTATE_END( Expression, node ); 1009 } 1010 1011 //-------------------------------------------------------------------------- 1012 // VirtualCastExpr 655 1013 template< typename pass_type > 656 1014 void PassVisitor< pass_type >::visit( VirtualCastExpr * node ) { 657 VISIT_BODY( node ); 658 } 659 1015 VISIT_START( node ); 1016 1017 indexerScopedAccept( node->result, *this ); 1018 maybeAccept( node->arg, *this ); 1019 1020 VISIT_END( node ); 1021 } 1022 1023 template< typename pass_type > 1024 Expression * PassVisitor< pass_type >::mutate( VirtualCastExpr * node ) { 1025 MUTATE_START( node ); 1026 1027 indexerScopedMutate( node->env , *this ); 1028 indexerScopedMutate( node->result, *this ); 1029 maybeMutateRef ( node->arg , *this ); 1030 1031 MUTATE_END( Expression, node ); 1032 } 1033 1034 //-------------------------------------------------------------------------- 1035 // AddressExpr 660 1036 template< typename pass_type > 661 1037 void PassVisitor< pass_type >::visit( AddressExpr * node ) { 662 VISIT_BODY( node ); 663 } 664 1038 VISIT_START( node ); 1039 1040 indexerScopedAccept( node->result, *this ); 1041 maybeAccept ( node->arg , *this ); 1042 1043 VISIT_END( node ); 1044 } 1045 1046 template< typename pass_type > 1047 Expression * PassVisitor< pass_type >::mutate( AddressExpr * node ) { 1048 MUTATE_START( node ); 1049 1050 indexerScopedMutate( node->env , *this ); 1051 indexerScopedMutate( node->result, *this ); 1052 maybeMutateRef ( node->arg , *this ); 1053 1054 MUTATE_END( Expression, node ); 1055 } 1056 1057 //-------------------------------------------------------------------------- 1058 // LabelAddressExpr 665 1059 template< typename pass_type > 666 1060 void PassVisitor< pass_type >::visit( LabelAddressExpr * node ) { 667 VISIT_BODY( node ); 668 } 669 1061 VISIT_START( node ); 1062 1063 indexerScopedAccept( node->result, *this ); 1064 1065 VISIT_END( node ); 1066 } 1067 1068 template< typename pass_type > 1069 Expression * PassVisitor< pass_type >::mutate( LabelAddressExpr * node ) { 1070 MUTATE_START( node ); 1071 1072 indexerScopedMutate( node->env , *this ); 1073 indexerScopedMutate( node->result, *this ); 1074 1075 MUTATE_END( Expression, node ); 1076 } 1077 1078 //-------------------------------------------------------------------------- 1079 // UntypedMemberExpr 670 1080 template< typename pass_type > 671 1081 void PassVisitor< pass_type >::visit( UntypedMemberExpr * node ) { 672 VISIT_BODY( node ); 673 } 674 1082 VISIT_START( node ); 1083 1084 indexerScopedAccept( node->result , *this ); 1085 maybeAccept ( node->aggregate, *this ); 1086 maybeAccept ( node->member , *this ); 1087 1088 VISIT_END( node ); 1089 } 1090 1091 template< typename pass_type > 1092 Expression * PassVisitor< pass_type >::mutate( UntypedMemberExpr * node ) { 1093 MUTATE_START( node ); 1094 1095 indexerScopedMutate( node->env , *this ); 1096 indexerScopedMutate( node->result , *this ); 1097 maybeMutateRef ( node->aggregate, *this ); 1098 maybeMutateRef ( node->member , *this ); 1099 1100 MUTATE_END( Expression, node ); 1101 } 1102 1103 //-------------------------------------------------------------------------- 1104 // MemberExpr 675 1105 template< typename pass_type > 676 1106 void PassVisitor< pass_type >::visit( MemberExpr * node ) { 677 VISIT_BODY( node ); 678 } 679 1107 VISIT_START( node ); 1108 1109 indexerScopedAccept( node->result , *this ); 1110 maybeAccept ( node->aggregate, *this ); 1111 1112 VISIT_END( node ); 1113 } 1114 1115 template< typename pass_type > 1116 Expression * PassVisitor< pass_type >::mutate( MemberExpr * node ) { 1117 MUTATE_START( node ); 1118 1119 indexerScopedMutate( node->env , *this ); 1120 indexerScopedMutate( node->result , *this ); 1121 maybeMutateRef ( node->aggregate, *this ); 1122 1123 MUTATE_END( Expression, node ); 1124 } 1125 1126 //-------------------------------------------------------------------------- 1127 // VariableExpr 680 1128 template< typename pass_type > 681 1129 void PassVisitor< pass_type >::visit( VariableExpr * node ) { 682 VISIT_BODY( node ); 683 } 684 1130 VISIT_START( node ); 1131 1132 indexerScopedAccept( node->result, *this ); 1133 1134 VISIT_END( node ); 1135 } 1136 1137 template< typename pass_type > 1138 Expression * PassVisitor< pass_type >::mutate( VariableExpr * node ) { 1139 MUTATE_START( node ); 1140 1141 indexerScopedMutate( node->env , *this ); 1142 indexerScopedMutate( node->result, *this ); 1143 1144 MUTATE_END( Expression, node ); 1145 } 1146 1147 //-------------------------------------------------------------------------- 1148 // ConstantExpr 685 1149 template< typename pass_type > 686 1150 void PassVisitor< pass_type >::visit( ConstantExpr * node ) { 687 VISIT_BODY( node ); 688 } 689 1151 VISIT_START( node ); 1152 1153 indexerScopedAccept( node->result , *this ); 1154 maybeAccept ( &node->constant, *this ); 1155 1156 VISIT_END( node ); 1157 } 1158 1159 template< typename pass_type > 1160 Expression * PassVisitor< pass_type >::mutate( ConstantExpr * node ) { 1161 MUTATE_START( node ); 1162 1163 indexerScopedMutate( node->env , *this ); 1164 indexerScopedMutate( node->result, *this ); 1165 node->constant = *maybeMutate( &node->constant, *this ); 1166 1167 MUTATE_END( Expression, node ); 1168 } 1169 1170 //-------------------------------------------------------------------------- 1171 // SizeofExpr 690 1172 template< typename pass_type > 691 1173 void PassVisitor< pass_type >::visit( SizeofExpr * node ) { 692 VISIT_BODY( node ); 693 } 694 1174 VISIT_START( node ); 1175 1176 indexerScopedAccept( node->result, *this ); 1177 if ( node->get_isType() ) { 1178 maybeAccept( node->type, *this ); 1179 } else { 1180 maybeAccept( node->expr, *this ); 1181 } 1182 1183 VISIT_END( node ); 1184 } 1185 1186 template< typename pass_type > 1187 Expression * PassVisitor< pass_type >::mutate( SizeofExpr * node ) { 1188 MUTATE_START( node ); 1189 1190 indexerScopedMutate( node->env , *this ); 1191 indexerScopedMutate( node->result, *this ); 1192 if ( node->get_isType() ) { 1193 maybeMutateRef( node->type, *this ); 1194 } else { 1195 maybeMutateRef( node->expr, *this ); 1196 } 1197 1198 MUTATE_END( Expression, node ); 1199 } 1200 1201 //-------------------------------------------------------------------------- 1202 // AlignofExpr 695 1203 template< typename pass_type > 696 1204 void PassVisitor< pass_type >::visit( AlignofExpr * node ) { 697 VISIT_BODY( node ); 698 } 699 1205 VISIT_START( node ); 1206 1207 indexerScopedAccept( node->result, *this ); 1208 if ( node->get_isType() ) { 1209 maybeAccept( node->type, *this ); 1210 } else { 1211 maybeAccept( node->expr, *this ); 1212 } 1213 1214 VISIT_END( node ); 1215 } 1216 1217 template< typename pass_type > 1218 Expression * PassVisitor< pass_type >::mutate( AlignofExpr * node ) { 1219 MUTATE_START( node ); 1220 1221 indexerScopedMutate( node->env , *this ); 1222 indexerScopedMutate( node->result, *this ); 1223 if ( node->get_isType() ) { 1224 maybeMutateRef( node->type, *this ); 1225 } else { 1226 maybeMutateRef( node->expr, *this ); 1227 } 1228 1229 MUTATE_END( Expression, node ); 1230 } 1231 1232 //-------------------------------------------------------------------------- 1233 // UntypedOffsetofExpr 700 1234 template< typename pass_type > 701 1235 void PassVisitor< pass_type >::visit( UntypedOffsetofExpr * node ) { 702 VISIT_BODY( node ); 703 } 704 1236 VISIT_START( node ); 1237 1238 indexerScopedAccept( node->result, *this ); 1239 maybeAccept ( node->type , *this ); 1240 1241 VISIT_END( node ); 1242 } 1243 1244 template< typename pass_type > 1245 Expression * PassVisitor< pass_type >::mutate( UntypedOffsetofExpr * node ) { 1246 MUTATE_START( node ); 1247 1248 indexerScopedMutate( node->env , *this ); 1249 indexerScopedMutate( node->result, *this ); 1250 maybeMutateRef ( node->type , *this ); 1251 1252 MUTATE_END( Expression, node ); 1253 } 1254 1255 //-------------------------------------------------------------------------- 1256 // OffsetofExpr 705 1257 template< typename pass_type > 706 1258 void PassVisitor< pass_type >::visit( OffsetofExpr * node ) { 707 VISIT_BODY( node ); 708 } 709 1259 VISIT_START( node ); 1260 1261 indexerScopedAccept( node->result, *this ); 1262 maybeAccept ( node->type , *this ); 1263 maybeAccept ( node->member, *this ); 1264 1265 VISIT_END( node ); 1266 } 1267 1268 template< typename pass_type > 1269 Expression * PassVisitor< pass_type >::mutate( OffsetofExpr * node ) { 1270 MUTATE_START( node ); 1271 1272 indexerScopedMutate( node->env , *this ); 1273 indexerScopedMutate( node->result, *this ); 1274 maybeMutateRef ( node->type , *this ); 1275 maybeMutateRef ( node->member, *this ); 1276 1277 MUTATE_END( Expression, node ); 1278 } 1279 1280 //-------------------------------------------------------------------------- 1281 // OffsetPackExpr 710 1282 template< typename pass_type > 711 1283 void PassVisitor< pass_type >::visit( OffsetPackExpr * node ) { 712 VISIT_BODY( node ); 713 } 714 1284 VISIT_START( node ); 1285 1286 indexerScopedAccept( node->result, *this ); 1287 maybeAccept ( node->type , *this ); 1288 1289 VISIT_END( node ); 1290 } 1291 1292 template< typename pass_type > 1293 Expression * PassVisitor< pass_type >::mutate( OffsetPackExpr * node ) { 1294 MUTATE_START( node ); 1295 1296 indexerScopedMutate( node->env , *this ); 1297 indexerScopedMutate( node->result, *this ); 1298 maybeMutateRef ( node->type , *this ); 1299 1300 MUTATE_END( Expression, node ); 1301 } 1302 1303 //-------------------------------------------------------------------------- 1304 // AttrExpr 715 1305 template< typename pass_type > 716 1306 void PassVisitor< pass_type >::visit( AttrExpr * node ) { 717 VISIT_BODY( node ); 718 } 719 1307 VISIT_START( node ); 1308 1309 indexerScopedAccept( node->result, *this ); 1310 if ( node->get_isType() ) { 1311 maybeAccept( node->type, *this ); 1312 } else { 1313 maybeAccept( node->expr, *this ); 1314 } 1315 1316 VISIT_END( node ); 1317 } 1318 1319 template< typename pass_type > 1320 Expression * PassVisitor< pass_type >::mutate( AttrExpr * node ) { 1321 MUTATE_START( node ); 1322 1323 indexerScopedMutate( node->env , *this ); 1324 indexerScopedMutate( node->result, *this ); 1325 if ( node->get_isType() ) { 1326 maybeMutateRef( node->type, *this ); 1327 } else { 1328 maybeMutateRef( node->expr, *this ); 1329 } 1330 1331 MUTATE_END( Expression, node ); 1332 } 1333 1334 //-------------------------------------------------------------------------- 1335 // LogicalExpr 720 1336 template< typename pass_type > 721 1337 void PassVisitor< pass_type >::visit( LogicalExpr * node ) { 722 VISIT_BODY( node ); 723 } 724 1338 VISIT_START( node ); 1339 1340 indexerScopedAccept( node->result, *this ); 1341 maybeAccept ( node->arg1 , *this ); 1342 maybeAccept ( node->arg2 , *this ); 1343 1344 VISIT_END( node ); 1345 } 1346 1347 template< typename pass_type > 1348 Expression * PassVisitor< pass_type >::mutate( LogicalExpr * node ) { 1349 MUTATE_START( node ); 1350 1351 indexerScopedMutate( node->env , *this ); 1352 indexerScopedMutate( node->result, *this ); 1353 maybeMutateRef ( node->arg1 , *this ); 1354 maybeMutateRef ( node->arg2 , *this ); 1355 1356 MUTATE_END( Expression, node ); 1357 } 1358 1359 //-------------------------------------------------------------------------- 1360 // ConditionalExpr 725 1361 template< typename pass_type > 726 1362 void PassVisitor< pass_type >::visit( ConditionalExpr * node ) { 727 VISIT_BODY( node ); 728 } 729 1363 VISIT_START( node ); 1364 1365 indexerScopedAccept( node->result, *this ); 1366 maybeAccept ( node->arg1 , *this ); 1367 maybeAccept ( node->arg2 , *this ); 1368 maybeAccept ( node->arg3 , *this ); 1369 1370 VISIT_END( node ); 1371 } 1372 1373 template< typename pass_type > 1374 Expression * PassVisitor< pass_type >::mutate( ConditionalExpr * node ) { 1375 MUTATE_START( node ); 1376 1377 indexerScopedMutate( node->env , *this ); 1378 indexerScopedMutate( node->result, *this ); 1379 maybeMutateRef ( node->arg1 , *this ); 1380 maybeMutateRef ( node->arg2 , *this ); 1381 maybeMutateRef ( node->arg3 , *this ); 1382 1383 MUTATE_END( Expression, node ); 1384 } 1385 1386 //-------------------------------------------------------------------------- 1387 // CommaExpr 730 1388 template< typename pass_type > 731 1389 void PassVisitor< pass_type >::visit( CommaExpr * node ) { 732 VISIT_BODY( node ); 733 } 734 1390 VISIT_START( node ); 1391 1392 indexerScopedAccept( node->result, *this ); 1393 maybeAccept ( node->arg1 , *this ); 1394 maybeAccept ( node->arg2 , *this ); 1395 1396 VISIT_END( node ); 1397 } 1398 1399 template< typename pass_type > 1400 Expression * PassVisitor< pass_type >::mutate( CommaExpr * node ) { 1401 MUTATE_START( node ); 1402 1403 indexerScopedMutate( node->env , *this ); 1404 indexerScopedMutate( node->result, *this ); 1405 maybeMutateRef ( node->arg1 , *this ); 1406 maybeMutateRef ( node->arg2 , *this ); 1407 1408 MUTATE_END( Expression, node ); 1409 } 1410 1411 //-------------------------------------------------------------------------- 1412 // TypeExpr 735 1413 template< typename pass_type > 736 1414 void PassVisitor< pass_type >::visit( TypeExpr * node ) { 737 VISIT_BODY( node ); 738 } 739 1415 VISIT_START( node ); 1416 1417 indexerScopedAccept( node->result, *this ); 1418 maybeAccept ( node->type, *this ); 1419 1420 VISIT_END( node ); 1421 } 1422 1423 template< typename pass_type > 1424 Expression * PassVisitor< pass_type >::mutate( TypeExpr * node ) { 1425 MUTATE_START( node ); 1426 1427 indexerScopedMutate( node->env , *this ); 1428 indexerScopedMutate( node->result, *this ); 1429 maybeMutateRef ( node->type , *this ); 1430 1431 MUTATE_END( Expression, node ); 1432 } 1433 1434 //-------------------------------------------------------------------------- 1435 // AsmExpr 740 1436 template< typename pass_type > 741 1437 void PassVisitor< pass_type >::visit( AsmExpr * node ) { 742 VISIT_BODY( node ); 743 } 744 1438 VISIT_START( node ); 1439 1440 indexerScopedAccept( node->result , *this ); 1441 maybeAccept ( node->inout , *this ); 1442 maybeAccept ( node->constraint, *this ); 1443 maybeAccept ( node->operand , *this ); 1444 1445 VISIT_END( node ); 1446 } 1447 1448 template< typename pass_type > 1449 Expression * PassVisitor< pass_type >::mutate( AsmExpr * node ) { 1450 MUTATE_START( node ); 1451 1452 indexerScopedMutate( node->env , *this ); 1453 indexerScopedMutate( node->result , *this ); 1454 maybeMutateRef ( node->inout , *this ); 1455 maybeMutateRef ( node->constraint, *this ); 1456 maybeMutateRef ( node->operand , *this ); 1457 1458 MUTATE_END( Expression, node ); 1459 } 1460 1461 //-------------------------------------------------------------------------- 1462 // ImplicitCopyCtorExpr 745 1463 template< typename pass_type > 746 1464 void PassVisitor< pass_type >::visit( ImplicitCopyCtorExpr * node ) { 747 VISIT_BODY( node ); 748 } 749 1465 VISIT_START( node ); 1466 1467 indexerScopedAccept( node->result , *this ); 1468 maybeAccept ( node->callExpr , *this ); 1469 maybeAccept ( node->tempDecls , *this ); 1470 maybeAccept ( node->returnDecls, *this ); 1471 maybeAccept ( node->dtors , *this ); 1472 1473 VISIT_END( node ); 1474 } 1475 1476 template< typename pass_type > 1477 Expression * PassVisitor< pass_type >::mutate( ImplicitCopyCtorExpr * node ) { 1478 MUTATE_START( node ); 1479 1480 indexerScopedMutate( node->env , *this ); 1481 indexerScopedMutate( node->result , *this ); 1482 maybeMutateRef ( node->callExpr , *this ); 1483 maybeMutateRef ( node->tempDecls , *this ); 1484 maybeMutateRef ( node->returnDecls, *this ); 1485 maybeMutateRef ( node->dtors , *this ); 1486 1487 MUTATE_END( Expression, node ); 1488 } 1489 1490 //-------------------------------------------------------------------------- 1491 // ConstructorExpr 750 1492 template< typename pass_type > 751 1493 void PassVisitor< pass_type >::visit( ConstructorExpr * node ) { 752 VISIT_BODY( node ); 753 } 754 1494 VISIT_START( node ); 1495 1496 indexerScopedAccept( node->result , *this ); 1497 maybeAccept ( node->callExpr, *this ); 1498 1499 VISIT_END( node ); 1500 } 1501 1502 template< typename pass_type > 1503 Expression * PassVisitor< pass_type >::mutate( ConstructorExpr * node ) { 1504 MUTATE_START( node ); 1505 1506 indexerScopedMutate( node->env , *this ); 1507 indexerScopedMutate( node->result , *this ); 1508 maybeMutateRef ( node->callExpr, *this ); 1509 1510 MUTATE_END( Expression, node ); 1511 } 1512 1513 //-------------------------------------------------------------------------- 1514 // CompoundLiteralExpr 755 1515 template< typename pass_type > 756 1516 void PassVisitor< pass_type >::visit( CompoundLiteralExpr * node ) { 757 VISIT_BODY( node ); 758 } 759 1517 VISIT_START( node ); 1518 1519 indexerScopedAccept( node->result , *this ); 1520 maybeAccept ( node->initializer, *this ); 1521 1522 VISIT_END( node ); 1523 } 1524 1525 template< typename pass_type > 1526 Expression * PassVisitor< pass_type >::mutate( CompoundLiteralExpr * node ) { 1527 MUTATE_START( node ); 1528 1529 indexerScopedMutate( node->env , *this ); 1530 indexerScopedMutate( node->result , *this ); 1531 maybeMutateRef ( node->initializer, *this ); 1532 1533 MUTATE_END( Expression, node ); 1534 } 1535 1536 //-------------------------------------------------------------------------- 1537 // RangeExpr 760 1538 template< typename pass_type > 761 1539 void PassVisitor< pass_type >::visit( RangeExpr * node ) { 762 VISIT_BODY( node ); 763 } 764 1540 VISIT_START( node ); 1541 1542 indexerScopedAccept( node->result, *this ); 1543 maybeAccept ( node->low , *this ); 1544 maybeAccept ( node->high , *this ); 1545 1546 VISIT_END( node ); 1547 } 1548 1549 template< typename pass_type > 1550 Expression * PassVisitor< pass_type >::mutate( RangeExpr * node ) { 1551 MUTATE_START( node ); 1552 1553 indexerScopedMutate( node->env , *this ); 1554 indexerScopedMutate( node->result, *this ); 1555 maybeMutateRef ( node->low , *this ); 1556 maybeMutateRef ( node->high , *this ); 1557 1558 MUTATE_END( Expression, node ); 1559 } 1560 1561 //-------------------------------------------------------------------------- 1562 // UntypedTupleExpr 765 1563 template< typename pass_type > 766 1564 void PassVisitor< pass_type >::visit( UntypedTupleExpr * node ) { 767 VISIT_BODY( node ); 768 } 769 1565 VISIT_START( node ); 1566 1567 indexerScopedAccept( node->result, *this ); 1568 maybeAccept ( node->exprs , *this ); 1569 1570 VISIT_END( node ); 1571 } 1572 1573 template< typename pass_type > 1574 Expression * PassVisitor< pass_type >::mutate( UntypedTupleExpr * node ) { 1575 MUTATE_START( node ); 1576 1577 indexerScopedMutate( node->env , *this ); 1578 indexerScopedMutate( node->result, *this ); 1579 maybeMutateRef ( node->exprs , *this ); 1580 1581 MUTATE_END( Expression, node ); 1582 } 1583 1584 //-------------------------------------------------------------------------- 1585 // TupleExpr 770 1586 template< typename pass_type > 771 1587 void PassVisitor< pass_type >::visit( TupleExpr * node ) { 772 VISIT_BODY( node ); 773 } 774 1588 VISIT_START( node ); 1589 1590 indexerScopedAccept( node->result, *this ); 1591 maybeAccept ( node->exprs , *this ); 1592 1593 VISIT_END( node ); 1594 } 1595 1596 template< typename pass_type > 1597 Expression * PassVisitor< pass_type >::mutate( TupleExpr * node ) { 1598 MUTATE_START( node ); 1599 1600 indexerScopedMutate( node->env , *this ); 1601 indexerScopedMutate( node->result, *this ); 1602 maybeMutateRef ( node->exprs , *this ); 1603 1604 MUTATE_END( Expression, node ); 1605 } 1606 1607 //-------------------------------------------------------------------------- 1608 // TupleIndexExpr 775 1609 template< typename pass_type > 776 1610 void PassVisitor< pass_type >::visit( TupleIndexExpr * node ) { 777 VISIT_BODY( node ); 778 } 779 1611 VISIT_START( node ); 1612 1613 indexerScopedAccept( node->result, *this ); 1614 maybeAccept ( node->tuple , *this ); 1615 1616 VISIT_END( node ); 1617 } 1618 1619 template< typename pass_type > 1620 Expression * PassVisitor< pass_type >::mutate( TupleIndexExpr * node ) { 1621 MUTATE_START( node ); 1622 1623 indexerScopedMutate( node->env , *this ); 1624 indexerScopedMutate( node->result, *this ); 1625 maybeMutateRef ( node->tuple , *this ); 1626 1627 MUTATE_END( Expression, node ); 1628 } 1629 1630 //-------------------------------------------------------------------------- 1631 // TupleAssignExpr 780 1632 template< typename pass_type > 781 1633 void PassVisitor< pass_type >::visit( TupleAssignExpr * node ) { 782 VISIT_BODY( node ); 783 } 784 785 //-------------------------------------------------------------------------- 786 // UntypedExpr 1634 VISIT_START( node ); 1635 1636 indexerScopedAccept( node->result , *this ); 1637 maybeAccept ( node->stmtExpr, *this ); 1638 1639 VISIT_END( node ); 1640 } 1641 1642 template< typename pass_type > 1643 Expression * PassVisitor< pass_type >::mutate( TupleAssignExpr * node ) { 1644 MUTATE_START( node ); 1645 1646 indexerScopedMutate( node->env , *this ); 1647 indexerScopedMutate( node->result , *this ); 1648 maybeMutateRef ( node->stmtExpr, *this ); 1649 1650 MUTATE_END( Expression, node ); 1651 } 1652 1653 //-------------------------------------------------------------------------- 1654 // StmtExpr 787 1655 template< typename pass_type > 788 1656 void PassVisitor< pass_type >::visit( StmtExpr * node ) { … … 794 1662 ValueGuardPtr< std::list< Statement* > > oldAfterStmts ( get_afterStmts () ); 795 1663 796 Visitor::visit( node ); 1664 indexerScopedAccept( node->result , *this ); 1665 maybeAccept ( node->statements , *this ); 1666 maybeAccept ( node->returnDecls, *this ); 1667 maybeAccept ( node->dtors , *this ); 797 1668 798 1669 VISIT_END( node ); … … 808 1679 ValueGuardPtr< std::list< Statement* > > oldAfterStmts ( get_afterStmts () ); 809 1680 810 Mutator::mutate( node ); 811 812 MUTATE_END( Expression, node ); 813 } 814 1681 indexerScopedMutate( node->result , *this ); 1682 maybeMutateRef ( node->statements , *this ); 1683 maybeMutateRef ( node->returnDecls, *this ); 1684 maybeMutateRef ( node->dtors , *this ); 1685 1686 MUTATE_END( Expression, node ); 1687 } 1688 1689 //-------------------------------------------------------------------------- 1690 // UniqueExpr 815 1691 template< typename pass_type > 816 1692 void PassVisitor< pass_type >::visit( UniqueExpr * node ) { 817 VISIT_BODY( node ); 1693 VISIT_START( node ); 1694 1695 indexerScopedAccept( node->result, *this ); 1696 maybeAccept ( node->expr , *this ); 1697 1698 VISIT_END( node ); 1699 } 1700 1701 template< typename pass_type > 1702 Expression * PassVisitor< pass_type >::mutate( UniqueExpr * node ) { 1703 MUTATE_START( node ); 1704 1705 indexerScopedMutate( node->env , *this ); 1706 indexerScopedMutate( node->result, *this ); 1707 maybeMutateRef ( node->expr , *this ); 1708 1709 MUTATE_END( Expression, node ); 818 1710 } 819 1711 … … 848 1740 } 849 1741 1742 //-------------------------------------------------------------------------- 1743 // StructInstType 850 1744 template< typename pass_type > 851 1745 void PassVisitor< pass_type >::visit( StructInstType * node ) { 852 VISIT_BODY( node ); 853 } 854 1746 VISIT_START( node ); 1747 1748 indexerAddStruct( node->name ); 1749 1750 { 1751 auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } ); 1752 maybeAccept( node->forall , *this ); 1753 maybeAccept( node->parameters, *this ); 1754 } 1755 1756 VISIT_END( node ); 1757 } 1758 1759 template< typename pass_type > 1760 Type * PassVisitor< pass_type >::mutate( StructInstType * node ) { 1761 MUTATE_START( node ); 1762 1763 indexerAddStruct( node->name ); 1764 1765 { 1766 auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } ); 1767 maybeMutateRef( node->forall , *this ); 1768 maybeMutateRef( node->parameters, *this ); 1769 } 1770 1771 MUTATE_END( Type, node ); 1772 } 1773 1774 //-------------------------------------------------------------------------- 1775 // UnionInstType 855 1776 template< typename pass_type > 856 1777 void PassVisitor< pass_type >::visit( UnionInstType * node ) { 857 VISIT_BODY( node ); 858 } 859 1778 VISIT_START( node ); 1779 1780 indexerAddStruct( node->name ); 1781 1782 { 1783 auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } ); 1784 maybeAccept( node->forall , *this ); 1785 maybeAccept( node->parameters, *this ); 1786 } 1787 1788 VISIT_END( node ); 1789 } 1790 1791 template< typename pass_type > 1792 Type * PassVisitor< pass_type >::mutate( UnionInstType * node ) { 1793 MUTATE_START( node ); 1794 1795 indexerAddStruct( node->name ); 1796 1797 { 1798 auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } ); 1799 maybeMutateRef( node->forall , *this ); 1800 maybeMutateRef( node->parameters, *this ); 1801 } 1802 1803 MUTATE_END( Type, node ); 1804 } 1805 1806 //-------------------------------------------------------------------------- 1807 // EnumInstType 860 1808 template< typename pass_type > 861 1809 void PassVisitor< pass_type >::visit( EnumInstType * node ) { … … 864 1812 865 1813 template< typename pass_type > 1814 Type * PassVisitor< pass_type >::mutate( EnumInstType * node ) { 1815 MUTATE_BODY( Type, node ); 1816 } 1817 1818 //-------------------------------------------------------------------------- 1819 // TraitInstType 1820 template< typename pass_type > 866 1821 void PassVisitor< pass_type >::visit( TraitInstType * node ) { 867 VISIT_BODY( node ); 868 } 869 1822 VISIT_START( node ); 1823 1824 maybeAccept( node->forall , *this ); 1825 maybeAccept( node->parameters, *this ); 1826 1827 VISIT_END( node ); 1828 } 1829 1830 template< typename pass_type > 1831 Type * PassVisitor< pass_type >::mutate( TraitInstType * node ) { 1832 MUTATE_START( node ); 1833 1834 maybeMutateRef( node->forall , *this ); 1835 maybeMutateRef( node->parameters, *this ); 1836 1837 MUTATE_END( Type, node ); 1838 } 1839 1840 //-------------------------------------------------------------------------- 1841 // TypeInstType 870 1842 template< typename pass_type > 871 1843 void PassVisitor< pass_type >::visit( TypeInstType * node ) { … … 904 1876 905 1877 //-------------------------------------------------------------------------- 906 // UntypedExpr1878 // SingleInit 907 1879 template< typename pass_type > 908 1880 void PassVisitor< pass_type >::visit( SingleInit * node ) { … … 944 1916 945 1917 //--------------------------------------------------------------------------------------------------------------- 946 947 template< typename pass_type >948 DeclarationWithType * PassVisitor< pass_type >::mutate( ObjectDecl * node ) {949 MUTATE_BODY( DeclarationWithType, node );950 }951 952 template< typename pass_type >953 DeclarationWithType * PassVisitor< pass_type >::mutate( FunctionDecl * node ) {954 MUTATE_BODY( DeclarationWithType, node );955 }956 957 template< typename pass_type >958 Declaration * PassVisitor< pass_type >::mutate( StructDecl * node ) {959 MUTATE_BODY( Declaration, node );960 }961 962 template< typename pass_type >963 Declaration * PassVisitor< pass_type >::mutate( UnionDecl * node ) {964 MUTATE_BODY( Declaration, node );965 }966 967 template< typename pass_type >968 Declaration * PassVisitor< pass_type >::mutate( EnumDecl * node ) {969 MUTATE_BODY( Declaration, node );970 }971 972 template< typename pass_type >973 Declaration * PassVisitor< pass_type >::mutate( TraitDecl * node ) {974 MUTATE_BODY( Declaration, node );975 }976 977 template< typename pass_type >978 TypeDecl * PassVisitor< pass_type >::mutate( TypeDecl * node ) {979 MUTATE_BODY( TypeDecl, node );980 }981 982 template< typename pass_type >983 Declaration * PassVisitor< pass_type >::mutate( TypedefDecl * node ) {984 MUTATE_BODY( Declaration, node );985 }986 987 template< typename pass_type >988 AsmDecl * PassVisitor< pass_type >::mutate( AsmDecl * node ) {989 MUTATE_BODY( AsmDecl, node );990 }991 992 template< typename pass_type >993 Expression * PassVisitor< pass_type >::mutate( NameExpr * node ) {994 MUTATE_BODY( Expression, node );995 }996 997 template< typename pass_type >998 Expression * PassVisitor< pass_type >::mutate( AddressExpr * node ) {999 MUTATE_BODY( Expression, node );1000 }1001 1002 template< typename pass_type >1003 Expression * PassVisitor< pass_type >::mutate( LabelAddressExpr * node ) {1004 MUTATE_BODY( Expression, node );1005 }1006 1007 template< typename pass_type >1008 Expression * PassVisitor< pass_type >::mutate( CastExpr * node ) {1009 MUTATE_BODY( Expression, node );1010 }1011 1012 template< typename pass_type >1013 Expression * PassVisitor< pass_type >::mutate( VirtualCastExpr * node ) {1014 MUTATE_BODY( Expression, node );1015 }1016 1017 template< typename pass_type >1018 Expression * PassVisitor< pass_type >::mutate( UntypedMemberExpr * node ) {1019 MUTATE_BODY( Expression, node );1020 }1021 1022 template< typename pass_type >1023 Expression * PassVisitor< pass_type >::mutate( MemberExpr * node ) {1024 MUTATE_BODY( Expression, node );1025 }1026 1027 template< typename pass_type >1028 Expression * PassVisitor< pass_type >::mutate( VariableExpr * node ) {1029 MUTATE_BODY( Expression, node );1030 }1031 1032 template< typename pass_type >1033 Expression * PassVisitor< pass_type >::mutate( ConstantExpr * node ) {1034 MUTATE_BODY( Expression, node );1035 }1036 1037 template< typename pass_type >1038 Expression * PassVisitor< pass_type >::mutate( SizeofExpr * node ) {1039 MUTATE_BODY( Expression, node );1040 }1041 1042 template< typename pass_type >1043 Expression * PassVisitor< pass_type >::mutate( AlignofExpr * node ) {1044 MUTATE_BODY( Expression, node );1045 }1046 1047 template< typename pass_type >1048 Expression * PassVisitor< pass_type >::mutate( UntypedOffsetofExpr * node ) {1049 MUTATE_BODY( Expression, node );1050 }1051 1052 template< typename pass_type >1053 Expression * PassVisitor< pass_type >::mutate( OffsetofExpr * node ) {1054 MUTATE_BODY( Expression, node );1055 }1056 1057 template< typename pass_type >1058 Expression * PassVisitor< pass_type >::mutate( OffsetPackExpr * node ) {1059 MUTATE_BODY( Expression, node );1060 }1061 1062 template< typename pass_type >1063 Expression * PassVisitor< pass_type >::mutate( AttrExpr * node ) {1064 MUTATE_BODY( Expression, node );1065 }1066 1067 template< typename pass_type >1068 Expression * PassVisitor< pass_type >::mutate( LogicalExpr * node ) {1069 MUTATE_BODY( Expression, node );1070 }1071 1072 template< typename pass_type >1073 Expression * PassVisitor< pass_type >::mutate( ConditionalExpr * node ) {1074 MUTATE_BODY( Expression, node );1075 }1076 1077 template< typename pass_type >1078 Expression * PassVisitor< pass_type >::mutate( CommaExpr * node ) {1079 MUTATE_BODY( Expression, node );1080 }1081 1082 template< typename pass_type >1083 Expression * PassVisitor< pass_type >::mutate( TypeExpr * node ) {1084 MUTATE_BODY( Expression, node );1085 }1086 1087 template< typename pass_type >1088 Expression * PassVisitor< pass_type >::mutate( AsmExpr * node ) {1089 MUTATE_BODY( Expression, node );1090 }1091 1092 template< typename pass_type >1093 Expression * PassVisitor< pass_type >::mutate( ImplicitCopyCtorExpr * node ) {1094 MUTATE_BODY( Expression, node );1095 }1096 1097 template< typename pass_type >1098 Expression * PassVisitor< pass_type >::mutate( ConstructorExpr * node ) {1099 MUTATE_BODY( Expression, node );1100 }1101 1102 template< typename pass_type >1103 Expression * PassVisitor< pass_type >::mutate( CompoundLiteralExpr * node ) {1104 MUTATE_BODY( Expression, node );1105 }1106 1107 template< typename pass_type >1108 Expression * PassVisitor< pass_type >::mutate( RangeExpr * node ) {1109 MUTATE_BODY( Expression, node );1110 }1111 1112 template< typename pass_type >1113 Expression * PassVisitor< pass_type >::mutate( UntypedTupleExpr * node ) {1114 MUTATE_BODY( Expression, node );1115 }1116 1117 template< typename pass_type >1118 Expression * PassVisitor< pass_type >::mutate( TupleExpr * node ) {1119 MUTATE_BODY( Expression, node );1120 }1121 1122 template< typename pass_type >1123 Expression * PassVisitor< pass_type >::mutate( TupleIndexExpr * node ) {1124 MUTATE_BODY( Expression, node );1125 }1126 1127 template< typename pass_type >1128 Expression * PassVisitor< pass_type >::mutate( TupleAssignExpr * node ) {1129 MUTATE_BODY( Expression, node );1130 }1131 1132 template< typename pass_type >1133 Expression * PassVisitor< pass_type >::mutate( UniqueExpr * node ) {1134 MUTATE_BODY( Expression, node );1135 }1136 1137 1918 template< typename pass_type > 1138 1919 Type * PassVisitor< pass_type >::mutate( VoidType * node ) { … … 1166 1947 1167 1948 template< typename pass_type > 1168 Type * PassVisitor< pass_type >::mutate( StructInstType * node ) {1169 MUTATE_BODY( Type, node );1170 }1171 1172 template< typename pass_type >1173 Type * PassVisitor< pass_type >::mutate( UnionInstType * node ) {1174 MUTATE_BODY( Type, node );1175 }1176 1177 template< typename pass_type >1178 Type * PassVisitor< pass_type >::mutate( EnumInstType * node ) {1179 MUTATE_BODY( Type, node );1180 }1181 1182 template< typename pass_type >1183 Type * PassVisitor< pass_type >::mutate( TraitInstType * node ) {1184 MUTATE_BODY( Type, node );1185 }1186 1187 template< typename pass_type >1188 1949 Type * PassVisitor< pass_type >::mutate( TypeInstType * node ) { 1189 1950 MUTATE_BODY( Type, node ); -
src/Common/PassVisitor.proto.h
rb2e2e34 rc935c3a 41 41 }; 42 42 43 44 43 class bool_ref { 45 44 public: … … 59 58 bool * m_ref; 60 59 }; 60 61 template< typename TreeType, typename VisitorType > 62 inline void indexerScopedAccept( TreeType * tree, VisitorType & visitor ) { 63 auto guard = makeFuncGuard( 64 [&visitor]() { visitor.indexerScopeEnter(); }, 65 [&visitor]() { visitor.indexerScopeLeave(); } 66 ); 67 maybeAccept( tree, visitor ); 68 } 69 70 template< typename TreeType, typename MutatorType > 71 inline void indexerScopedMutate( TreeType *& tree, MutatorType & mutator ) { 72 auto guard = makeFuncGuard( 73 [&mutator]() { mutator.indexerScopeEnter(); }, 74 [&mutator]() { mutator.indexerScopeLeave(); } 75 ); 76 tree = maybeMutate( tree, mutator ); 77 } 78 79 template< typename TreeType, typename MutatorType > 80 inline void maybeMutateRef( TreeType *& tree, MutatorType & mutator ) { 81 tree = maybeMutate( tree, mutator ); 82 } 61 83 62 84 //------------------------------------------------------------------------------------------------------------------------------------------------------------------------- … … 93 115 static inline void postvisit_impl( __attribute__((unused)) pass_type& pass, __attribute__((unused)) node_type * node, __attribute__((unused)) long unused ) {} 94 116 117 //--------------------------------------------------------- 95 118 // Mutate 96 119 template<typename pass_type, typename node_type> … … 111 134 static inline return_type postmutate_impl( __attribute__((unused)) pass_type& pass, node_type * node, __attribute__((unused)) long unused ) { return node; } 112 135 136 //--------------------------------------------------------- 113 137 // Begin/End scope 114 138 template<typename pass_type> … … 129 153 static inline void end_scope_impl( __attribute__((unused)) pass_type& pass, __attribute__((unused)) long unused ) {} 130 154 155 //--------------------------------------------------------- 131 156 // Fields 132 157 #define FIELD_PTR( type, name ) \ … … 145 170 FIELD_PTR( at_cleanup_t, at_cleanup ) 146 171 FIELD_PTR( PassVisitor<pass_type> * const, visitor ) 172 173 //--------------------------------------------------------- 174 // Indexer 175 template<typename pass_type> 176 static inline auto indexer_impl_enterScope( pass_type & pass, int ) -> decltype( pass.indexer.enterScope(), void() ) { 177 pass.indexer.enterScope(); 178 } 179 180 template<typename pass_type> 181 static inline auto indexer_impl_enterScope( pass_type &, int ) {} 182 183 template<typename pass_type> 184 static inline auto indexer_impl_leaveScope( pass_type & pass, int ) -> decltype( pass.indexer.leaveScope(), void() ) { 185 pass.indexer.leaveScope(); 186 } 187 188 template<typename pass_type> 189 static inline auto indexer_impl_leaveScope( pass_type &, int ) {} 190 191 192 #define INDEXER_FUNC( func, type ) \ 193 template<typename pass_type> \ 194 static inline auto indexer_impl_##func ( pass_type & pass, int, type arg ) -> decltype( pass.indexer.func( arg ), void() ) { \ 195 pass.indexer.func( arg ); \ 196 } \ 197 \ 198 template<typename pass_type> \ 199 static inline void indexer_impl_##func ( pass_type &, long, type ) {} \ 200 201 INDEXER_FUNC( addId , DeclarationWithType * ); 202 INDEXER_FUNC( addType , NamedTypeDecl * ); 203 INDEXER_FUNC( addStruct , StructDecl * ); 204 INDEXER_FUNC( addEnum , EnumDecl * ); 205 INDEXER_FUNC( addUnion , UnionDecl * ); 206 INDEXER_FUNC( addTrait , TraitDecl * ); 207 208 209 template<typename pass_type> 210 static inline auto indexer_impl_addStructFwd( pass_type & pass, int, StructDecl * decl ) -> decltype( pass.indexer.addStruct( decl ), void() ) { 211 StructDecl * fwd = new StructDecl( decl->name ); 212 cloneAll( decl->parameters, fwd->parameters ); 213 pass.indexer.addStruct( fwd ); 214 } 215 216 template<typename pass_type> 217 static inline auto indexer_impl_addStructFwd( pass_type &, int, StructDecl * ) {} 218 219 template<typename pass_type> 220 static inline auto indexer_impl_addUnionFwd( pass_type & pass, int, UnionDecl * decl ) -> decltype( pass.indexer.addUnion( decl ), void() ) { 221 UnionDecl * fwd = new UnionDecl( decl->name ); 222 cloneAll( decl->parameters, fwd->parameters ); 223 pass.indexer.addUnion( fwd ); 224 } 225 226 template<typename pass_type> 227 static inline auto indexer_impl_addUnionFwd( pass_type &, int, UnionDecl * ) {} 228 229 template<typename pass_type> 230 static inline auto indexer_impl_addStruct( pass_type & pass, int, const std::string & str ) -> decltype( pass.indexer.addStruct( str ), void() ) { 231 if ( ! pass.indexer.lookupStruct( str ) ) { 232 pass.indexer.addStruct( str ); 233 } 234 } 235 236 template<typename pass_type> 237 static inline auto indexer_impl_addStruct( pass_type &, int, const std::string & ) {} 238 239 template<typename pass_type> 240 static inline auto indexer_impl_addUnion( pass_type & pass, int, const std::string & str ) -> decltype( pass.indexer.addUnion( str ), void() ) { 241 if ( ! pass.indexer.lookupUnion( str ) ) { 242 pass.indexer.addUnion( str ); 243 } 244 } 245 246 template<typename pass_type> 247 static inline auto indexer_impl_addUnion( pass_type &, int, const std::string & ) {} -
src/Common/utility.h
rb2e2e34 rc935c3a 277 277 ~ValueGuardPtr() { if( ref ) *ref = old; } 278 278 }; 279 280 template< typename aT > 281 struct FuncGuard { 282 aT m_after; 283 284 template< typename bT > 285 FuncGuard( bT before, aT after ) : m_after( after ) { 286 before(); 287 } 288 289 ~FuncGuard() { 290 m_after(); 291 } 292 }; 293 294 template< typename bT, typename aT > 295 FuncGuard<aT> makeFuncGuard( bT && before, aT && after ) { 296 return FuncGuard<aT>( std::forward<bT>(before), std::forward<aT>(after) ); 297 } 279 298 280 299 template< typename T > … … 370 389 } 371 390 391 // ----------------------------------------------------------------------------- 392 // Helper struct and function to support 393 // for ( val : lazy_map( container1, f ) ) {} 394 // syntax to have a for each that iterates a container, mapping each element by applying f 395 template< typename T, typename Func > 396 struct lambda_iterate_t { 397 const T & ref; 398 std::function<Func> f; 399 400 struct iterator { 401 typedef decltype(begin(ref)) Iter; 402 Iter it; 403 std::function<Func> f; 404 iterator( Iter it, std::function<Func> f ) : it(it), f(f) {} 405 iterator & operator++() { 406 ++it; return *this; 407 } 408 bool operator!=( const iterator &other ) const { return it != other.it; } 409 auto operator*() const -> decltype(f(*it)) { return f(*it); } 410 }; 411 412 lambda_iterate_t( const T & ref, std::function<Func> f ) : ref(ref), f(f) {} 413 414 auto begin() const -> decltype(iterator(std::begin(ref), f)) { return iterator(std::begin(ref), f); } 415 auto end() const -> decltype(iterator(std::end(ref), f)) { return iterator(std::end(ref), f); } 416 }; 417 418 template< typename... Args > 419 lambda_iterate_t<Args...> lazy_map( const Args &... args ) { 420 return lambda_iterate_t<Args...>( args...); 421 } 422 423 424 372 425 // Local Variables: // 373 426 // tab-width: 4 // -
src/Concurrency/Keywords.cc
rb2e2e34 rc935c3a 259 259 //============================================================================================= 260 260 void ConcurrentSueKeyword::postvisit(StructDecl * decl) { 261 if( decl-> get_name() == type_name && decl->has_body()) {261 if( decl->name == type_name && decl->body ) { 262 262 assert( !type_decl ); 263 263 type_decl = decl; … … 270 270 271 271 void ConcurrentSueKeyword::handle( StructDecl * decl ) { 272 if( ! decl-> has_body()) return;272 if( ! decl->body ) return; 273 273 274 274 if( !type_decl ) throw SemanticError( context_error, decl ); … … 418 418 void MutexKeyword::postvisit(StructDecl* decl) { 419 419 420 if( decl-> get_name()== "monitor_desc" ) {420 if( decl->name == "monitor_desc" ) { 421 421 assert( !monitor_decl ); 422 422 monitor_decl = decl; 423 423 } 424 else if( decl-> get_name()== "monitor_guard_t" ) {424 else if( decl->name == "monitor_guard_t" ) { 425 425 assert( !guard_decl ); 426 426 guard_decl = decl; … … 524 524 //============================================================================================= 525 525 void ThreadStarter::postvisit(FunctionDecl * decl) { 526 if( ! CodeGen::isConstructor(decl-> get_name()) ) return;526 if( ! CodeGen::isConstructor(decl->name) ) return; 527 527 528 528 DeclarationWithType * param = decl->get_functionType()->get_parameters().front(); -
src/Concurrency/module.mk
rb2e2e34 rc935c3a 6 6 ## file "LICENCE" distributed with Cforall. 7 7 ## 8 ## module.mk -- 8 ## module.mk -- 9 9 ## 10 10 ## Author : Thierry Delisle 11 11 ## Created On : Mon Mar 13 12:48:40 2017 12 ## Last Modified By : 13 ## Last Modified On : 12 ## Last Modified By : 13 ## Last Modified On : 14 14 ## Update Count : 0 15 15 ############################################################################### 16 16 17 SRC += Concurrency/Keywords.cc 17 SRC += Concurrency/Keywords.cc \ 18 Concurrency/Waitfor.cc 18 19 -
src/GenPoly/Box.cc
rb2e2e34 rc935c3a 15 15 16 16 #include <algorithm> // for mismatch 17 #include <cassert> // for assert, s afe_dynamic_cast17 #include <cassert> // for assert, strict_dynamic_cast 18 18 #include <iostream> // for operator<<, stringstream 19 19 #include <list> // for list, list<>::iterator, _Lis... … … 27 27 28 28 #include "CodeGen/OperatorTable.h" 29 #include "Common/PassVisitor.h" // for PassVisitor 29 30 #include "Common/ScopedMap.h" // for ScopedMap, ScopedMap<>::iter... 30 31 #include "Common/SemanticError.h" // for SemanticError … … 157 158 /// * Calculates polymorphic offsetof expressions from offset array 158 159 /// * Inserts dynamic calculation of polymorphic type layouts where needed 159 class PolyGenericCalculator final : public PolyMutator{160 class PolyGenericCalculator final : public WithGuards, public WithVisitorRef<PolyGenericCalculator>, public WithStmtsToAdd, public WithDeclsToAdd, public WithTypeSubstitution { 160 161 public: 161 typedef PolyMutator Parent;162 using Parent::mutate;163 164 162 PolyGenericCalculator(); 165 163 166 template< typename DeclClass > 167 DeclClass *handleDecl( DeclClass *decl, Type *type ); 168 virtual DeclarationWithType *mutate( FunctionDecl *functionDecl ) override; 169 virtual ObjectDecl *mutate( ObjectDecl *objectDecl ) override; 170 virtual TypedefDecl *mutate( TypedefDecl *objectDecl ) override; 171 virtual TypeDecl *mutate( TypeDecl *objectDecl ) override; 172 virtual Statement *mutate( DeclStmt *declStmt ) override; 173 virtual Type *mutate( PointerType *pointerType ) override; 174 virtual Type *mutate( FunctionType *funcType ) override; 175 virtual Expression *mutate( MemberExpr *memberExpr ) override; 176 virtual Expression *mutate( SizeofExpr *sizeofExpr ) override; 177 virtual Expression *mutate( AlignofExpr *alignofExpr ) override; 178 virtual Expression *mutate( OffsetofExpr *offsetofExpr ) override; 179 virtual Expression *mutate( OffsetPackExpr *offsetPackExpr ) override; 180 181 virtual void doBeginScope() override; 182 virtual void doEndScope() override; 164 void premutate( ObjectDecl *objectDecl ); 165 void premutate( FunctionDecl *functionDecl ); 166 void premutate( TypedefDecl *objectDecl ); 167 void premutate( TypeDecl *objectDecl ); 168 Declaration * postmutate( TypeDecl *TraitDecl ); 169 void premutate( PointerType *pointerType ); 170 void premutate( FunctionType *funcType ); 171 void premutate( DeclStmt *declStmt ); 172 Expression *postmutate( MemberExpr *memberExpr ); 173 Expression *postmutate( SizeofExpr *sizeofExpr ); 174 Expression *postmutate( AlignofExpr *alignofExpr ); 175 Expression *postmutate( OffsetofExpr *offsetofExpr ); 176 Expression *postmutate( OffsetPackExpr *offsetPackExpr ); 177 178 void beginScope(); 179 void endScope(); 183 180 184 181 private: … … 194 191 /// Exits the type-variable scope 195 192 void endTypeScope(); 193 /// Enters a new scope for knowLayouts and knownOffsets and queues exit calls 194 void beginGenericScope(); 196 195 197 196 ScopedSet< std::string > knownLayouts; ///< Set of generic type layouts known in the current scope, indexed by sizeofName 198 197 ScopedSet< std::string > knownOffsets; ///< Set of non-generic types for which the offset array exists in the current scope, indexed by offsetofName 199 198 UniqueName bufNamer; ///< Namer for VLA buffers 199 TyVarMap scopeTyVars; 200 200 }; 201 201 … … 250 250 Pass1 pass1; 251 251 Pass2 pass2; 252 P olyGenericCalculatorpolyCalculator;252 PassVisitor<PolyGenericCalculator> polyCalculator; 253 253 Pass3 pass3; 254 254 … … 256 256 mutateTranslationUnit/*All*/( translationUnit, pass1 ); 257 257 mutateTranslationUnit/*All*/( translationUnit, pass2 ); 258 mutate TranslationUnit/*All*/( translationUnit, polyCalculator );258 mutateAll( translationUnit, polyCalculator ); 259 259 mutateTranslationUnit/*All*/( translationUnit, pass3 ); 260 260 } … … 555 555 TypeDecl *Pass1::mutate( TypeDecl *typeDecl ) { 556 556 addToTyVarMap( typeDecl, scopeTyVars ); 557 return Mutator::mutate( typeDecl);557 return dynamic_cast<TypeDecl*>( Mutator::mutate( typeDecl ) ); 558 558 } 559 559 … … 762 762 } else if ( arg->get_result()->get_lvalue() ) { 763 763 // argument expression may be CFA lvalue, but not C lvalue -- apply generalizedLvalue transformations. 764 // if ( VariableExpr * varExpr = dynamic_cast< VariableExpr * >( arg ) ) { 765 // if ( dynamic_cast<ArrayType *>( varExpr->var->get_type() ) ){ 766 // // temporary hack - don't box arrays, because &arr is not the same as &arr[0] 767 // return; 768 // } 769 // } 764 770 arg = generalizedLvalue( new AddressExpr( arg ) ); 765 771 if ( ! ResolvExpr::typesCompatible( param, arg->get_result(), SymTab::Indexer() ) ) { … … 1299 1305 1300 1306 DeclarationWithType * Pass2::mutate( FunctionDecl *functionDecl ) { 1301 functionDecl = s afe_dynamic_cast< FunctionDecl * > ( handleDecl( functionDecl ) );1307 functionDecl = strict_dynamic_cast< FunctionDecl * > ( handleDecl( functionDecl ) ); 1302 1308 FunctionType * ftype = functionDecl->get_functionType(); 1303 1309 if ( ! ftype->get_returnVals().empty() && functionDecl->get_statements() ) { … … 1353 1359 return handleDecl( typeDecl ); 1354 1360 } else { 1355 return Parent::mutate( typeDecl);1361 return dynamic_cast<TypeDecl*>( Parent::mutate( typeDecl ) ); 1356 1362 } 1357 1363 } … … 1378 1384 // move polymorphic return type to parameter list 1379 1385 if ( isDynRet( funcType ) ) { 1380 ObjectDecl *ret = s afe_dynamic_cast< ObjectDecl* >( funcType->get_returnVals().front() );1386 ObjectDecl *ret = strict_dynamic_cast< ObjectDecl* >( funcType->get_returnVals().front() ); 1381 1387 ret->set_type( new PointerType( Type::Qualifiers(), ret->get_type() ) ); 1382 1388 funcType->get_parameters().push_front( ret ); … … 1466 1472 1467 1473 PolyGenericCalculator::PolyGenericCalculator() 1468 : Parent(), knownLayouts(), knownOffsets(), bufNamer( "_buf") {}1474 : knownLayouts(), knownOffsets(), bufNamer( "_buf" ), scopeTyVars( TypeDecl::Data{} ) {} 1469 1475 1470 1476 void PolyGenericCalculator::beginTypeScope( Type *ty ) { 1471 scopeTyVars.beginScope();1477 GuardScope( scopeTyVars ); 1472 1478 makeTyVarMap( ty, scopeTyVars ); 1473 1479 } 1474 1480 1475 void PolyGenericCalculator::endTypeScope() { 1476 scopeTyVars.endScope(); 1477 } 1478 1479 template< typename DeclClass > 1480 DeclClass * PolyGenericCalculator::handleDecl( DeclClass *decl, Type *type ) { 1481 beginTypeScope( type ); 1482 // knownLayouts.beginScope(); 1483 // knownOffsets.beginScope(); 1484 1485 DeclClass *ret = static_cast< DeclClass *>( Parent::mutate( decl ) ); 1486 1487 // knownOffsets.endScope(); 1488 // knownLayouts.endScope(); 1489 endTypeScope(); 1490 return ret; 1491 } 1492 1493 ObjectDecl * PolyGenericCalculator::mutate( ObjectDecl *objectDecl ) { 1494 return handleDecl( objectDecl, objectDecl->get_type() ); 1495 } 1496 1497 DeclarationWithType * PolyGenericCalculator::mutate( FunctionDecl *functionDecl ) { 1498 knownLayouts.beginScope(); 1499 knownOffsets.beginScope(); 1500 1501 DeclarationWithType * decl = handleDecl( functionDecl, functionDecl->get_functionType() ); 1502 knownOffsets.endScope(); 1503 knownLayouts.endScope(); 1504 return decl; 1505 } 1506 1507 TypedefDecl * PolyGenericCalculator::mutate( TypedefDecl *typedefDecl ) { 1508 return handleDecl( typedefDecl, typedefDecl->get_base() ); 1509 } 1510 1511 TypeDecl * PolyGenericCalculator::mutate( TypeDecl *typeDecl ) { 1481 void PolyGenericCalculator::beginGenericScope() { 1482 GuardScope( *this ); 1483 } 1484 1485 void PolyGenericCalculator::premutate( ObjectDecl *objectDecl ) { 1486 beginTypeScope( objectDecl->get_type() ); 1487 } 1488 1489 void PolyGenericCalculator::premutate( FunctionDecl *functionDecl ) { 1490 beginGenericScope(); 1491 1492 beginTypeScope( functionDecl->get_functionType() ); 1493 } 1494 1495 void PolyGenericCalculator::premutate( TypedefDecl *typedefDecl ) { 1496 beginTypeScope( typedefDecl->get_base() ); 1497 } 1498 1499 void PolyGenericCalculator::premutate( TypeDecl * typeDecl ) { 1512 1500 addToTyVarMap( typeDecl, scopeTyVars ); 1513 return Parent::mutate( typeDecl ); 1514 } 1515 1516 Type * PolyGenericCalculator::mutate( PointerType *pointerType ) { 1501 } 1502 1503 Declaration * PolyGenericCalculator::postmutate( TypeDecl *typeDecl ) { 1504 if ( Type * base = typeDecl->base ) { 1505 // add size/align variables for opaque type declarations 1506 TypeInstType inst( Type::Qualifiers(), typeDecl->name, typeDecl ); 1507 std::string typeName = mangleType( &inst ); 1508 Type *layoutType = new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ); 1509 1510 ObjectDecl * sizeDecl = ObjectDecl::newObject( sizeofName( typeName ), layoutType, new SingleInit( new SizeofExpr( base->clone() ) ) ); 1511 ObjectDecl * alignDecl = ObjectDecl::newObject( alignofName( typeName ), layoutType->clone(), new SingleInit( new AlignofExpr( base->clone() ) ) ); 1512 1513 // ensure that the initializing sizeof/alignof exprs are properly mutated 1514 sizeDecl->acceptMutator( *visitor ); 1515 alignDecl->acceptMutator( *visitor ); 1516 1517 // can't use makeVar, because it inserts into stmtsToAdd and TypeDecls can occur at global scope 1518 declsToAddAfter.push_back( alignDecl ); 1519 // replace with sizeDecl 1520 return sizeDecl; 1521 } 1522 return typeDecl; 1523 } 1524 1525 void PolyGenericCalculator::premutate( PointerType *pointerType ) { 1517 1526 beginTypeScope( pointerType ); 1518 1519 Type *ret = Parent::mutate( pointerType ); 1520 1521 endTypeScope(); 1522 return ret; 1523 } 1524 1525 Type * PolyGenericCalculator::mutate( FunctionType *funcType ) { 1527 } 1528 1529 void PolyGenericCalculator::premutate( FunctionType *funcType ) { 1526 1530 beginTypeScope( funcType ); 1527 1531 … … 1534 1538 } 1535 1539 } 1536 1537 Type *ret = Parent::mutate( funcType ); 1538 1539 endTypeScope(); 1540 return ret; 1541 } 1542 1543 Statement *PolyGenericCalculator::mutate( DeclStmt *declStmt ) { 1540 } 1541 1542 void PolyGenericCalculator::premutate( DeclStmt *declStmt ) { 1544 1543 if ( ObjectDecl *objectDecl = dynamic_cast< ObjectDecl *>( declStmt->get_decl() ) ) { 1545 1544 if ( findGeneric( objectDecl->get_type() ) ) { … … 1550 1549 new ArrayType( Type::Qualifiers(), new BasicType( Type::Qualifiers(), BasicType::Kind::Char), new NameExpr( sizeofName( mangleType(declType) ) ), 1551 1550 true, false, std::list<Attribute*>{ new Attribute( "aligned", std::list<Expression*>{ new ConstantExpr( Constant::from_int(8) ) } ) } ), 0 ); 1552 stmtsToAdd .push_back( new DeclStmt( noLabels, newBuf ) );1551 stmtsToAddBefore.push_back( new DeclStmt( noLabels, newBuf ) ); 1553 1552 1554 1553 delete objectDecl->get_init(); … … 1556 1555 } 1557 1556 } 1558 return Parent::mutate( declStmt );1559 1557 } 1560 1558 … … 1583 1581 } 1584 1582 1585 Expression *PolyGenericCalculator::mutate( MemberExpr *memberExpr ) { 1586 // mutate, exiting early if no longer MemberExpr 1587 Expression *expr = Parent::mutate( memberExpr ); 1588 memberExpr = dynamic_cast< MemberExpr* >( expr ); 1589 if ( ! memberExpr ) return expr; 1590 1583 Expression *PolyGenericCalculator::postmutate( MemberExpr *memberExpr ) { 1591 1584 // only mutate member expressions for polymorphic types 1592 1585 int tyDepth; … … 1635 1628 ObjectDecl *PolyGenericCalculator::makeVar( const std::string &name, Type *type, Initializer *init ) { 1636 1629 ObjectDecl *newObj = new ObjectDecl( name, Type::StorageClasses(), LinkageSpec::C, 0, type, init ); 1637 stmtsToAdd .push_back( new DeclStmt( noLabels, newObj ) );1630 stmtsToAddBefore.push_back( new DeclStmt( noLabels, newObj ) ); 1638 1631 return newObj; 1639 1632 } … … 1714 1707 addOtypeParamsToLayoutCall( layoutCall, otypeParams ); 1715 1708 1716 stmtsToAdd .push_back( new ExprStmt( noLabels, layoutCall ) );1709 stmtsToAddBefore.push_back( new ExprStmt( noLabels, layoutCall ) ); 1717 1710 } 1718 1711 … … 1740 1733 addOtypeParamsToLayoutCall( layoutCall, otypeParams ); 1741 1734 1742 stmtsToAdd .push_back( new ExprStmt( noLabels, layoutCall ) );1735 stmtsToAddBefore.push_back( new ExprStmt( noLabels, layoutCall ) ); 1743 1736 1744 1737 return true; … … 1748 1741 } 1749 1742 1750 Expression *PolyGenericCalculator:: mutate( SizeofExpr *sizeofExpr ) {1743 Expression *PolyGenericCalculator::postmutate( SizeofExpr *sizeofExpr ) { 1751 1744 Type *ty = sizeofExpr->get_isType() ? sizeofExpr->get_type() : sizeofExpr->get_expr()->get_result(); 1752 1745 if ( findGeneric( ty ) ) { … … 1758 1751 } 1759 1752 1760 Expression *PolyGenericCalculator:: mutate( AlignofExpr *alignofExpr ) {1753 Expression *PolyGenericCalculator::postmutate( AlignofExpr *alignofExpr ) { 1761 1754 Type *ty = alignofExpr->get_isType() ? alignofExpr->get_type() : alignofExpr->get_expr()->get_result(); 1762 1755 if ( findGeneric( ty ) ) { … … 1768 1761 } 1769 1762 1770 Expression *PolyGenericCalculator::mutate( OffsetofExpr *offsetofExpr ) { 1771 // mutate, exiting early if no longer OffsetofExpr 1772 Expression *expr = Parent::mutate( offsetofExpr ); 1773 offsetofExpr = dynamic_cast< OffsetofExpr* >( expr ); 1774 if ( ! offsetofExpr ) return expr; 1775 1763 Expression *PolyGenericCalculator::postmutate( OffsetofExpr *offsetofExpr ) { 1776 1764 // only mutate expressions for polymorphic structs/unions 1777 1765 Type *ty = offsetofExpr->get_type(); … … 1793 1781 } 1794 1782 1795 Expression *PolyGenericCalculator:: mutate( OffsetPackExpr *offsetPackExpr ) {1783 Expression *PolyGenericCalculator::postmutate( OffsetPackExpr *offsetPackExpr ) { 1796 1784 StructInstType *ty = offsetPackExpr->get_type(); 1797 1785 … … 1832 1820 } 1833 1821 1834 void PolyGenericCalculator:: doBeginScope() {1822 void PolyGenericCalculator::beginScope() { 1835 1823 knownLayouts.beginScope(); 1836 1824 knownOffsets.beginScope(); 1837 1825 } 1838 1826 1839 void PolyGenericCalculator:: doEndScope() {1827 void PolyGenericCalculator::endScope() { 1840 1828 knownLayouts.endScope(); 1841 1829 knownOffsets.endScope(); … … 1894 1882 1895 1883 addToTyVarMap( typeDecl, scopeTyVars ); 1896 return Mutator::mutate( typeDecl);1884 return dynamic_cast<TypeDecl*>( Mutator::mutate( typeDecl ) ); 1897 1885 } 1898 1886 -
src/GenPoly/InstantiateGeneric.cc
rb2e2e34 rc935c3a 459 459 Declaration * member = *std::next( aggr->members.begin(), memberIndex ); 460 460 assertf( member->name == memberExpr->member->name, "Instantiation has different member order than the generic type. %s / %s", toString( member ).c_str(), toString( memberExpr->member ).c_str() ); 461 DeclarationWithType * field = s afe_dynamic_cast< DeclarationWithType * >( member );461 DeclarationWithType * field = strict_dynamic_cast< DeclarationWithType * >( member ); 462 462 MemberExpr * ret = new MemberExpr( field, memberExpr->aggregate->clone() ); 463 463 std::swap( ret->env, memberExpr->env ); -
src/GenPoly/Lvalue.cc
rb2e2e34 rc935c3a 14 14 // 15 15 16 #include <cassert> // for s afe_dynamic_cast16 #include <cassert> // for strict_dynamic_cast 17 17 #include <string> // for string 18 18 -
src/InitTweak/FixInit.cc
rb2e2e34 rc935c3a 17 17 #include <stddef.h> // for NULL 18 18 #include <algorithm> // for set_difference, copy_if 19 #include <cassert> // for assert, s afe_dynamic_cast19 #include <cassert> // for assert, strict_dynamic_cast 20 20 #include <iostream> // for operator<<, ostream, basic_ost... 21 21 #include <iterator> // for insert_iterator, back_inserter … … 424 424 // arrays are not copy constructed, so this should always be an ExprStmt 425 425 ImplicitCtorDtorStmt * stmt = genCtorDtor( fname, var, cpArg ); 426 ExprStmt * exprStmt = s afe_dynamic_cast< ExprStmt * >( stmt->get_callStmt() );426 ExprStmt * exprStmt = strict_dynamic_cast< ExprStmt * >( stmt->get_callStmt() ); 427 427 Expression * untyped = exprStmt->get_expr(); 428 428 … … 532 532 assert( ! body->get_kids().empty() ); 533 533 // must be an ExprStmt, otherwise it wouldn't have a result 534 ExprStmt * last = s afe_dynamic_cast< ExprStmt * >( body->get_kids().back() );534 ExprStmt * last = strict_dynamic_cast< ExprStmt * >( body->get_kids().back() ); 535 535 last->set_expr( makeCtorDtor( "?{}", ret, last->get_expr() ) ); 536 536 … … 566 566 CP_CTOR_PRINT( std::cerr << "FixCopyCtors: " << impCpCtorExpr << std::endl; ) 567 567 568 impCpCtorExpr = s afe_dynamic_cast< ImplicitCopyCtorExpr * >( Parent::mutate( impCpCtorExpr ) );568 impCpCtorExpr = strict_dynamic_cast< ImplicitCopyCtorExpr * >( Parent::mutate( impCpCtorExpr ) ); 569 569 std::list< ObjectDecl * > & tempDecls = impCpCtorExpr->get_tempDecls(); 570 570 std::list< ObjectDecl * > & returnDecls = impCpCtorExpr->get_returnDecls(); … … 627 627 stmt = stmt->acceptMutator( *this ); 628 628 } // for 629 // stmtExpr = s afe_dynamic_cast< StmtExpr * >( Parent::mutate( stmtExpr ) );629 // stmtExpr = strict_dynamic_cast< StmtExpr * >( Parent::mutate( stmtExpr ) ); 630 630 assert( stmtExpr->get_result() ); 631 631 Type * result = stmtExpr->get_result(); … … 791 791 } 792 792 } else { 793 ImplicitCtorDtorStmt * implicit = s afe_dynamic_cast< ImplicitCtorDtorStmt * > ( ctor );793 ImplicitCtorDtorStmt * implicit = strict_dynamic_cast< ImplicitCtorDtorStmt * > ( ctor ); 794 794 ExprStmt * ctorStmt = dynamic_cast< ExprStmt * >( implicit->get_callStmt() ); 795 795 ApplicationExpr * ctorCall = nullptr; … … 996 996 FunctionType * type = function->get_functionType(); 997 997 assert( ! type->get_parameters().empty() ); 998 thisParam = s afe_dynamic_cast< ObjectDecl * >( type->get_parameters().front() );998 thisParam = strict_dynamic_cast< ObjectDecl * >( type->get_parameters().front() ); 999 999 Type * thisType = getPointerBase( thisParam->get_type() ); 1000 1000 StructInstType * structType = dynamic_cast< StructInstType * >( thisType ); … … 1166 1166 1167 1167 Expression* MutatingResolver::mutate( UntypedExpr *untypedExpr ) { 1168 return s afe_dynamic_cast< ApplicationExpr * >( ResolvExpr::findVoidExpression( untypedExpr, indexer ) );1168 return strict_dynamic_cast< ApplicationExpr * >( ResolvExpr::findVoidExpression( untypedExpr, indexer ) ); 1169 1169 } 1170 1170 … … 1179 1179 1180 1180 // xxx - this can be TupleAssignExpr now. Need to properly handle this case. 1181 ApplicationExpr * callExpr = s afe_dynamic_cast< ApplicationExpr * > ( ctorExpr->get_callExpr() );1181 ApplicationExpr * callExpr = strict_dynamic_cast< ApplicationExpr * > ( ctorExpr->get_callExpr() ); 1182 1182 TypeSubstitution * env = ctorExpr->get_env(); 1183 1183 ctorExpr->set_callExpr( nullptr ); -
src/InitTweak/GenInit.cc
rb2e2e34 rc935c3a 17 17 #include <stddef.h> // for NULL 18 18 #include <algorithm> // for any_of 19 #include <cassert> // for assert, s afe_dynamic_cast, assertf19 #include <cassert> // for assert, strict_dynamic_cast, assertf 20 20 #include <iterator> // for back_inserter, inserter, back_inse... 21 21 #include <list> // for _List_iterator, list … … 255 255 SymTab::genImplicitCall( srcParam, new VariableExpr( objDecl ), fname, back_inserter( stmts ), objDecl ); 256 256 assert( stmts.size() <= 1 ); 257 return stmts.size() == 1 ? s afe_dynamic_cast< ImplicitCtorDtorStmt * >( stmts.front() ) : nullptr;257 return stmts.size() == 1 ? strict_dynamic_cast< ImplicitCtorDtorStmt * >( stmts.front() ) : nullptr; 258 258 } 259 259 -
src/InitTweak/InitTweak.cc
rb2e2e34 rc935c3a 1 1 #include <stddef.h> // for NULL 2 2 #include <algorithm> // for find, all_of 3 #include <cassert> // for assertf, assert, s afe_dynamic_cast3 #include <cassert> // for assertf, assert, strict_dynamic_cast 4 4 #include <iostream> // for ostream, cerr, endl 5 5 #include <iterator> // for back_insert_iterator, back_inserter … … 414 414 std::list< Statement * > & stmts = tupleExpr->get_stmtExpr()->get_statements()->get_kids(); 415 415 assertf( ! stmts.empty(), "TupleAssignExpr somehow has no statements." ); 416 ExprStmt * stmt = s afe_dynamic_cast< ExprStmt * >( stmts.back() );417 TupleExpr * tuple = s afe_dynamic_cast< TupleExpr * >( stmt->get_expr() );416 ExprStmt * stmt = strict_dynamic_cast< ExprStmt * >( stmts.back() ); 417 TupleExpr * tuple = strict_dynamic_cast< TupleExpr * >( stmt->get_expr() ); 418 418 assertf( ! tuple->get_exprs().empty(), "TupleAssignExpr somehow has empty tuple expr." ); 419 419 return getCallArg( tuple->get_exprs().front(), pos ); -
src/Makefile.in
rb2e2e34 rc935c3a 159 159 CodeTools/driver_cfa_cpp-TrackLoc.$(OBJEXT) \ 160 160 Concurrency/driver_cfa_cpp-Keywords.$(OBJEXT) \ 161 Concurrency/driver_cfa_cpp-Waitfor.$(OBJEXT) \ 161 162 Common/driver_cfa_cpp-SemanticError.$(OBJEXT) \ 162 163 Common/driver_cfa_cpp-UniqueName.$(OBJEXT) \ … … 490 491 CodeGen/OperatorTable.cc CodeTools/DeclStats.cc \ 491 492 CodeTools/TrackLoc.cc Concurrency/Keywords.cc \ 492 Co mmon/SemanticError.cc Common/UniqueName.cc \493 Common/ DebugMalloc.cc Common/Assert.cc \493 Concurrency/Waitfor.cc Common/SemanticError.cc \ 494 Common/UniqueName.cc Common/DebugMalloc.cc Common/Assert.cc \ 494 495 ControlStruct/LabelGenerator.cc ControlStruct/LabelFixer.cc \ 495 496 ControlStruct/MLEMutator.cc ControlStruct/Mutate.cc \ … … 663 664 @: > Concurrency/$(DEPDIR)/$(am__dirstamp) 664 665 Concurrency/driver_cfa_cpp-Keywords.$(OBJEXT): \ 666 Concurrency/$(am__dirstamp) \ 667 Concurrency/$(DEPDIR)/$(am__dirstamp) 668 Concurrency/driver_cfa_cpp-Waitfor.$(OBJEXT): \ 665 669 Concurrency/$(am__dirstamp) \ 666 670 Concurrency/$(DEPDIR)/$(am__dirstamp) … … 995 999 @AMDEP_TRUE@@am__include@ @am__quote@Common/$(DEPDIR)/driver_cfa_cpp-UniqueName.Po@am__quote@ 996 1000 @AMDEP_TRUE@@am__include@ @am__quote@Concurrency/$(DEPDIR)/driver_cfa_cpp-Keywords.Po@am__quote@ 1001 @AMDEP_TRUE@@am__include@ @am__quote@Concurrency/$(DEPDIR)/driver_cfa_cpp-Waitfor.Po@am__quote@ 997 1002 @AMDEP_TRUE@@am__include@ @am__quote@ControlStruct/$(DEPDIR)/driver_cfa_cpp-ExceptTranslate.Po@am__quote@ 998 1003 @AMDEP_TRUE@@am__include@ @am__quote@ControlStruct/$(DEPDIR)/driver_cfa_cpp-ForExprMutator.Po@am__quote@ … … 1263 1268 @am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o Concurrency/driver_cfa_cpp-Keywords.obj `if test -f 'Concurrency/Keywords.cc'; then $(CYGPATH_W) 'Concurrency/Keywords.cc'; else $(CYGPATH_W) '$(srcdir)/Concurrency/Keywords.cc'; fi` 1264 1269 1270 Concurrency/driver_cfa_cpp-Waitfor.o: Concurrency/Waitfor.cc 1271 @am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT Concurrency/driver_cfa_cpp-Waitfor.o -MD -MP -MF Concurrency/$(DEPDIR)/driver_cfa_cpp-Waitfor.Tpo -c -o Concurrency/driver_cfa_cpp-Waitfor.o `test -f 'Concurrency/Waitfor.cc' || echo '$(srcdir)/'`Concurrency/Waitfor.cc 1272 @am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) Concurrency/$(DEPDIR)/driver_cfa_cpp-Waitfor.Tpo Concurrency/$(DEPDIR)/driver_cfa_cpp-Waitfor.Po 1273 @AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='Concurrency/Waitfor.cc' object='Concurrency/driver_cfa_cpp-Waitfor.o' libtool=no @AMDEPBACKSLASH@ 1274 @AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@ 1275 @am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o Concurrency/driver_cfa_cpp-Waitfor.o `test -f 'Concurrency/Waitfor.cc' || echo '$(srcdir)/'`Concurrency/Waitfor.cc 1276 1277 Concurrency/driver_cfa_cpp-Waitfor.obj: Concurrency/Waitfor.cc 1278 @am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT Concurrency/driver_cfa_cpp-Waitfor.obj -MD -MP -MF Concurrency/$(DEPDIR)/driver_cfa_cpp-Waitfor.Tpo -c -o Concurrency/driver_cfa_cpp-Waitfor.obj `if test -f 'Concurrency/Waitfor.cc'; then $(CYGPATH_W) 'Concurrency/Waitfor.cc'; else $(CYGPATH_W) '$(srcdir)/Concurrency/Waitfor.cc'; fi` 1279 @am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) Concurrency/$(DEPDIR)/driver_cfa_cpp-Waitfor.Tpo Concurrency/$(DEPDIR)/driver_cfa_cpp-Waitfor.Po 1280 @AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='Concurrency/Waitfor.cc' object='Concurrency/driver_cfa_cpp-Waitfor.obj' libtool=no @AMDEPBACKSLASH@ 1281 @AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@ 1282 @am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o Concurrency/driver_cfa_cpp-Waitfor.obj `if test -f 'Concurrency/Waitfor.cc'; then $(CYGPATH_W) 'Concurrency/Waitfor.cc'; else $(CYGPATH_W) '$(srcdir)/Concurrency/Waitfor.cc'; fi` 1283 1265 1284 Common/driver_cfa_cpp-SemanticError.o: Common/SemanticError.cc 1266 1285 @am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT Common/driver_cfa_cpp-SemanticError.o -MD -MP -MF Common/$(DEPDIR)/driver_cfa_cpp-SemanticError.Tpo -c -o Common/driver_cfa_cpp-SemanticError.o `test -f 'Common/SemanticError.cc' || echo '$(srcdir)/'`Common/SemanticError.cc -
src/Parser/DeclarationNode.cc
rb2e2e34 rc935c3a 14 14 // 15 15 16 #include <cassert> // for assert, assertf, s afe_dynamic_cast16 #include <cassert> // for assert, assertf, strict_dynamic_cast 17 17 #include <iterator> // for back_insert_iterator 18 18 #include <list> // for list … … 333 333 DeclarationNode * DeclarationNode::newTypeDecl( string * name, DeclarationNode * typeParams ) { 334 334 DeclarationNode * newnode = new DeclarationNode; 335 newnode->name = name; 335 336 newnode->type = new TypeData( TypeData::Symbolic ); 336 337 newnode->type->symbolic.isTypedef = false; 337 338 newnode->type->symbolic.params = typeParams; 338 newnode->type->symbolic.name = name;339 339 return newnode; 340 340 } // DeclarationNode::newTypeDecl … … 1027 1027 1028 1028 if ( asmStmt ) { 1029 return new AsmDecl( s afe_dynamic_cast<AsmStmt *>( asmStmt->build() ) );1029 return new AsmDecl( strict_dynamic_cast<AsmStmt *>( asmStmt->build() ) ); 1030 1030 } // if 1031 1031 -
src/Parser/StatementNode.cc
rb2e2e34 rc935c3a 14 14 // 15 15 16 #include <cassert> // for assert, s afe_dynamic_cast, assertf16 #include <cassert> // for assert, strict_dynamic_cast, assertf 17 17 #include <list> // for list 18 18 #include <memory> // for unique_ptr … … 57 57 // find end of list and maintain previous pointer 58 58 for ( StatementNode * curr = prev; curr != nullptr; curr = (StatementNode *)curr->get_next() ) { 59 StatementNode *node = s afe_dynamic_cast< StatementNode * >(curr);59 StatementNode *node = strict_dynamic_cast< StatementNode * >(curr); 60 60 assert( dynamic_cast< CaseStmt * >(node->stmt.get()) ); 61 61 prev = curr; … … 106 106 for ( Statement * stmt : init ) { 107 107 // build the && of all of the declared variables compared against 0 108 DeclStmt * declStmt = s afe_dynamic_cast< DeclStmt * >( stmt );109 DeclarationWithType * dwt = s afe_dynamic_cast< DeclarationWithType * >( declStmt->decl );108 DeclStmt * declStmt = strict_dynamic_cast< DeclStmt * >( stmt ); 109 DeclarationWithType * dwt = strict_dynamic_cast< DeclarationWithType * >( declStmt->decl ); 110 110 Expression * nze = notZeroExpr( new VariableExpr( dwt ) ); 111 111 cond = cond ? new LogicalExpr( cond, nze, true ) : nze; … … 202 202 std::list< CatchStmt * > branches; 203 203 buildMoveList< CatchStmt, StatementNode >( catch_stmt, branches ); 204 CompoundStmt *tryBlock = s afe_dynamic_cast< CompoundStmt * >(maybeMoveBuild< Statement >(try_stmt));204 CompoundStmt *tryBlock = strict_dynamic_cast< CompoundStmt * >(maybeMoveBuild< Statement >(try_stmt)); 205 205 FinallyStmt *finallyBlock = dynamic_cast< FinallyStmt * >(maybeMoveBuild< Statement >(finally_stmt) ); 206 206 return new TryStmt( noLabels, tryBlock, branches, finallyBlock ); -
src/ResolvExpr/AlternativeFinder.cc
rb2e2e34 rc935c3a 15 15 16 16 #include <algorithm> // for copy 17 #include <cassert> // for s afe_dynamic_cast, assert, assertf17 #include <cassert> // for strict_dynamic_cast, assert, assertf 18 18 #include <iostream> // for operator<<, cerr, ostream, endl 19 19 #include <iterator> // for back_insert_iterator, back_inserter … … 336 336 337 337 Cost computeApplicationConversionCost( Alternative &alt, const SymTab::Indexer &indexer ) { 338 ApplicationExpr *appExpr = s afe_dynamic_cast< ApplicationExpr* >( alt.expr );339 PointerType *pointer = s afe_dynamic_cast< PointerType* >( appExpr->get_function()->get_result() );340 FunctionType *function = s afe_dynamic_cast< FunctionType* >( pointer->get_base() );338 ApplicationExpr *appExpr = strict_dynamic_cast< ApplicationExpr* >( alt.expr ); 339 PointerType *pointer = strict_dynamic_cast< PointerType* >( appExpr->get_function()->get_result() ); 340 FunctionType *function = strict_dynamic_cast< FunctionType* >( pointer->get_base() ); 341 341 342 342 Cost convCost = Cost::zero; … … 494 494 Cost cost = Cost::zero; 495 495 std::list< Expression * > newExprs; 496 ObjectDecl * obj = s afe_dynamic_cast< ObjectDecl * >( formal );496 ObjectDecl * obj = strict_dynamic_cast< ObjectDecl * >( formal ); 497 497 if ( ! instantiateArgument( obj->get_type(), obj->get_init(), actualExpr, actualEnd, openVars, resultEnv, resultNeed, resultHave, indexer, cost, back_inserter( newExprs ) ) ) { 498 498 deleteAll( newExprs ); … … 787 787 788 788 PRINT( 789 ApplicationExpr *appExpr = s afe_dynamic_cast< ApplicationExpr* >( withFunc->expr );790 PointerType *pointer = s afe_dynamic_cast< PointerType* >( appExpr->get_function()->get_result() );791 FunctionType *function = s afe_dynamic_cast< FunctionType* >( pointer->get_base() );789 ApplicationExpr *appExpr = strict_dynamic_cast< ApplicationExpr* >( withFunc->expr ); 790 PointerType *pointer = strict_dynamic_cast< PointerType* >( appExpr->get_function()->get_result() ); 791 FunctionType *function = strict_dynamic_cast< FunctionType* >( pointer->get_base() ); 792 792 std::cerr << "Case +++++++++++++ " << appExpr->get_function() << std::endl; 793 793 std::cerr << "formals are:" << std::endl; -
src/ResolvExpr/CastCost.cc
rb2e2e34 rc935c3a 45 45 } 46 46 } else if ( ( namedType = indexer.lookupType( destAsTypeInst->get_name() ) ) ) { 47 TypeDecl *type = dynamic_cast< TypeDecl* >( namedType );48 47 // all typedefs should be gone by this point 49 assert( type );48 TypeDecl *type = strict_dynamic_cast< TypeDecl* >( namedType ); 50 49 if ( type->get_base() ) { 51 50 return castCost( src, type->get_base(), indexer, env ) + Cost::safe; -
src/ResolvExpr/CommonType.cc
rb2e2e34 rc935c3a 14 14 // 15 15 16 #include <cassert> // for s afe_dynamic_cast16 #include <cassert> // for strict_dynamic_cast 17 17 #include <map> // for _Rb_tree_const_iterator 18 18 #include <utility> // for pair … … 100 100 // special case where one type has a reference depth of 1 larger than the other 101 101 if ( diff > 0 ) { 102 return handleReference( s afe_dynamic_cast<ReferenceType *>( type1 ), type2, widenFirst, widenSecond, indexer, env, openVars );102 return handleReference( strict_dynamic_cast<ReferenceType *>( type1 ), type2, widenFirst, widenSecond, indexer, env, openVars ); 103 103 } else if ( diff < 0 ) { 104 return handleReference( s afe_dynamic_cast<ReferenceType *>( type2 ), type1, widenSecond, widenFirst, indexer, env, openVars );104 return handleReference( strict_dynamic_cast<ReferenceType *>( type2 ), type1, widenSecond, widenFirst, indexer, env, openVars ); 105 105 } 106 106 // otherwise, both are reference types of the same depth and this is handled by the CommonType visitor. … … 114 114 if ( TypeInstType *inst = dynamic_cast< TypeInstType* >( type2 ) ) { 115 115 if ( NamedTypeDecl *nt = indexer.lookupType( inst->get_name() ) ) { 116 TypeDecl *type = s afe_dynamic_cast< TypeDecl* >( nt );116 TypeDecl *type = strict_dynamic_cast< TypeDecl* >( nt ); 117 117 if ( type->get_base() ) { 118 118 Type::Qualifiers tq1 = type1->get_qualifiers(), tq2 = type2->get_qualifiers(); … … 301 301 NamedTypeDecl *nt = indexer.lookupType( inst->get_name() ); 302 302 if ( nt ) { 303 TypeDecl *type = s afe_dynamic_cast< TypeDecl* >( nt );303 TypeDecl *type = strict_dynamic_cast< TypeDecl* >( nt ); 304 304 if ( type->get_base() ) { 305 305 Type::Qualifiers tq1 = inst->get_qualifiers(), tq2 = type2->get_qualifiers(); -
src/ResolvExpr/ConversionCost.cc
rb2e2e34 rc935c3a 92 92 93 93 Cost convertToReferenceCost( Type * src, Type * dest, int diff, const SymTab::Indexer & indexer, const TypeEnvironment & env, PtrsFunction func ) { 94 PRINT( std::cerr << "convert to reference cost... "<< std::endl; )94 PRINT( std::cerr << "convert to reference cost... diff " << diff << std::endl; ) 95 95 if ( diff > 0 ) { 96 96 // TODO: document this 97 Cost cost = convertToReferenceCost( s afe_dynamic_cast< ReferenceType * >( src )->get_base(), dest, diff-1, indexer, env, func );97 Cost cost = convertToReferenceCost( strict_dynamic_cast< ReferenceType * >( src )->get_base(), dest, diff-1, indexer, env, func ); 98 98 cost.incReference(); 99 99 return cost; 100 100 } else if ( diff < -1 ) { 101 101 // TODO: document this 102 Cost cost = convertToReferenceCost( src, s afe_dynamic_cast< ReferenceType * >( dest )->get_base(), diff+1, indexer, env, func );102 Cost cost = convertToReferenceCost( src, strict_dynamic_cast< ReferenceType * >( dest )->get_base(), diff+1, indexer, env, func ); 103 103 cost.incReference(); 104 104 return cost; … … 128 128 ReferenceType * destAsRef = dynamic_cast< ReferenceType * >( dest ); 129 129 assert( diff == -1 && destAsRef ); 130 PRINT( std::cerr << "dest is: " << dest << " / src is: " << src << std::endl; ) 130 131 if ( typesCompatibleIgnoreQualifiers( src, destAsRef->get_base(), indexer, env ) ) { 131 132 PRINT( std::cerr << "converting compatible base type" << std::endl; ) -
src/ResolvExpr/CurrentObject.cc
rb2e2e34 rc935c3a 286 286 for ( InitAlternative & alt : ret ) { 287 287 PRINT( std::cerr << "iterating and adding designators" << std::endl; ) 288 alt.designation->get_designators().push_front( new VariableExpr( s afe_dynamic_cast< ObjectDecl * >( *curMember ) ) );288 alt.designation->get_designators().push_front( new VariableExpr( strict_dynamic_cast< ObjectDecl * >( *curMember ) ) ); 289 289 // need to substitute for generic types, so that casts are to concrete types 290 290 PRINT( std::cerr << " type is: " << alt.type; ) … … 346 346 for ( InitAlternative & alt : ret ) { 347 347 PRINT( std::cerr << "iterating and adding designators" << std::endl; ) 348 alt.designation->get_designators().push_front( new VariableExpr( s afe_dynamic_cast< ObjectDecl * >( *curMember ) ) );348 alt.designation->get_designators().push_front( new VariableExpr( strict_dynamic_cast< ObjectDecl * >( *curMember ) ) ); 349 349 } 350 350 } -
src/ResolvExpr/Resolver.cc
rb2e2e34 rc935c3a 15 15 16 16 #include <stddef.h> // for NULL 17 #include <cassert> // for s afe_dynamic_cast, assert17 #include <cassert> // for strict_dynamic_cast, assert 18 18 #include <memory> // for allocator, allocator_traits<... 19 19 #include <tuple> // for get … … 342 342 CastExpr * castExpr = new CastExpr( caseStmt->get_condition(), initAlts.front().type->clone() ); 343 343 Expression * newExpr = findSingleExpression( castExpr, *this ); 344 castExpr = s afe_dynamic_cast< CastExpr * >( newExpr );344 castExpr = strict_dynamic_cast< CastExpr * >( newExpr ); 345 345 caseStmt->set_condition( castExpr->get_arg() ); 346 346 castExpr->set_arg( nullptr ); … … 398 398 Parent::enterScope(); 399 399 Visitor::visit( catchStmt ); 400 400 401 401 if ( catchStmt->get_cond() ) { 402 402 Expression * wrapped = new CastExpr( … … 423 423 UntypedInitExpr * untyped = new UntypedInitExpr( singleInit->get_value(), currentObject.getOptions() ); 424 424 Expression * newExpr = findSingleExpression( untyped, *this ); 425 InitExpr * initExpr = s afe_dynamic_cast< InitExpr * >( newExpr );425 InitExpr * initExpr = strict_dynamic_cast< InitExpr * >( newExpr ); 426 426 427 427 // move cursor to the object that is actually initialized … … 445 445 if ( isCharType( pt->get_base() ) ) { 446 446 // strip cast if we're initializing a char[] with a char *, e.g. char x[] = "hello"; 447 CastExpr *ce = s afe_dynamic_cast< CastExpr * >( newExpr );447 CastExpr *ce = strict_dynamic_cast< CastExpr * >( newExpr ); 448 448 newExpr = ce->get_arg(); 449 449 ce->set_arg( nullptr ); -
src/SymTab/Autogen.cc
rb2e2e34 rc935c3a 18 18 #include <cstddef> // for NULL 19 19 #include <algorithm> // for count_if 20 #include <cassert> // for s afe_dynamic_cast, assert, assertf20 #include <cassert> // for strict_dynamic_cast, assert, assertf 21 21 #include <iterator> // for back_insert_iterator, back_inserter 22 22 #include <list> // for list, _List_iterator, list<>::iter... … … 163 163 // Routines at global scope marked "static" to prevent multiple definitions in separate translation units 164 164 // because each unit generates copies of the default routines for each aggregate. 165 // DeclarationNode::StorageClass sc = functionNesting > 0 ? DeclarationNode::NoStorageClass : DeclarationNode::Static;166 165 Type::StorageClasses scs = functionNesting > 0 ? Type::StorageClasses() : Type::StorageClasses( Type::Static ); 167 166 LinkageSpec::Spec spec = isIntrinsic ? LinkageSpec::Intrinsic : LinkageSpec::AutoGen; … … 186 185 /// using map and t, determines if is constructable, etc. 187 186 bool lookup( const TypeMap & map, Type * t ) { 187 assertf( t, "Autogenerate lookup was given non-type: %s", toString( t ).c_str() ); 188 188 if ( dynamic_cast< PointerType * >( t ) ) { 189 189 // will need more complicated checking if we want this to work with pointer types, since currently … … 200 200 201 201 /// using map and aggr, examines each member to determine if constructor, etc. should be generated 202 template<typename AggrDecl> 203 bool shouldGenerate( const TypeMap & map, AggrDecl * aggr ) { 204 for ( Declaration * dcl : aggr->get_members() ) { 205 if ( DeclarationWithType * dwt = dynamic_cast< DeclarationWithType * >( dcl ) ) { 206 if ( ! lookup( map, dwt->get_type() ) ) return false; 207 } 202 template<typename Container> 203 bool shouldGenerate( const TypeMap & map, const Container & container ) { 204 for ( Type * t : container ) { 205 if ( ! lookup( map, t ) ) return false; 208 206 } 209 207 return true; … … 211 209 212 210 /// data structure for abstracting the generation of special functions 213 template< typename OutputIterator >211 template< typename OutputIterator, typename Container > 214 212 struct FuncGenerator { 215 StructDecl *aggregateDecl;216 StructInstType *refType;213 const Container & container; 214 Type *refType; 217 215 unsigned int functionNesting; 218 216 const std::list< TypeDecl* > & typeParams; 219 217 OutputIterator out; 220 FuncGenerator( StructDecl *aggregateDecl, StructInstType *refType, unsigned int functionNesting, const std::list< TypeDecl* > & typeParams, OutputIterator out ) : aggregateDecl( aggregateDecl), refType( refType ), functionNesting( functionNesting ), typeParams( typeParams ), out( out ) {}218 FuncGenerator( const Container & container, Type *refType, unsigned int functionNesting, const std::list< TypeDecl* > & typeParams, OutputIterator out ) : container( container ), refType( refType ), functionNesting( functionNesting ), typeParams( typeParams ), out( out ) {} 221 219 222 220 /// generates a function (?{}, ?=?, ^?{}) based on the data argument and members. If function is generated, inserts the type into the map. 223 221 void gen( const FuncData & data, bool concurrent_type ) { 224 if ( ! shouldGenerate( data.map, aggregateDecl) ) return;222 if ( ! shouldGenerate( data.map, container ) ) return; 225 223 FunctionType * ftype = data.genType( refType ); 226 224 227 225 if(concurrent_type && CodeGen::isDestructor( data.fname )) { 228 ftype-> get_parameters().front()->get_type()->set_mutex( true );229 } 230 231 cloneAll( typeParams, ftype-> get_forall());226 ftype->parameters.front()->get_type()->set_mutex( true ); 227 } 228 229 cloneAll( typeParams, ftype->forall ); 232 230 *out++ = genFunc( data.fname, ftype, functionNesting ); 233 231 data.map.insert( Mangler::mangleType( refType ), true ); … … 235 233 }; 236 234 237 template< typename OutputIterator >238 FuncGenerator<OutputIterator > makeFuncGenerator( StructDecl *aggregateDecl, StructInstType *refType, unsigned int functionNesting, const std::list< TypeDecl* > & typeParams, OutputIterator out ) {239 return FuncGenerator<OutputIterator >( aggregateDecl, refType, functionNesting, typeParams, out );235 template< typename OutputIterator, typename Container > 236 FuncGenerator<OutputIterator, Container> makeFuncGenerator( const Container & container, Type *refType, unsigned int functionNesting, const std::list< TypeDecl* > & typeParams, OutputIterator out ) { 237 return FuncGenerator<OutputIterator, Container>( container, refType, functionNesting, typeParams, out ); 240 238 } 241 239 … … 250 248 // parameters) are using in the variable exprs 251 249 assert( ftype->get_parameters().size() == 2 ); 252 ObjectDecl * dstParam = s afe_dynamic_cast< ObjectDecl * >( ftype->get_parameters().front() );253 ObjectDecl * srcParam = s afe_dynamic_cast< ObjectDecl * >( ftype->get_parameters().back() );250 ObjectDecl * dstParam = strict_dynamic_cast< ObjectDecl * >( ftype->get_parameters().front() ); 251 ObjectDecl * srcParam = strict_dynamic_cast< ObjectDecl * >( ftype->get_parameters().back() ); 254 252 255 253 VariableExpr * assignVarExpr = new VariableExpr( assignDecl ); … … 307 305 308 306 // assign to destination 309 Expression *dstselect = new MemberExpr( field, new CastExpr( new VariableExpr( dstParam ), s afe_dynamic_cast< ReferenceType* >( dstParam->get_type() )->get_base()->clone() ) );307 Expression *dstselect = new MemberExpr( field, new CastExpr( new VariableExpr( dstParam ), strict_dynamic_cast< ReferenceType* >( dstParam->get_type() )->get_base()->clone() ) ); 310 308 genImplicitCall( srcParam, dstselect, func->get_name(), back_inserter( func->get_statements()->get_kids() ), field, forward ); 311 309 } … … 393 391 } 394 392 393 Type * declToType( Declaration * decl ) { 394 if ( DeclarationWithType * dwt = dynamic_cast< DeclarationWithType * >( decl ) ) { 395 return dwt->get_type(); 396 } 397 return nullptr; 398 } 399 395 400 /// generates struct constructors, destructor, and assignment functions 396 401 void makeStructFunctions( StructDecl *aggregateDecl, StructInstType *refType, unsigned int functionNesting, std::list< Declaration * > & declsToAdd, const std::vector< FuncData > & data ) { … … 406 411 // generate each of the functions based on the supplied FuncData objects 407 412 std::list< FunctionDecl * > newFuncs; 408 auto generator = makeFuncGenerator( aggregateDecl, refType, functionNesting, typeParams, back_inserter( newFuncs ) ); 413 // structure that iterates aggregate decl members, returning their types 414 auto generator = makeFuncGenerator( lazy_map( aggregateDecl->members, declToType ), refType, functionNesting, typeParams, back_inserter( newFuncs ) ); 409 415 for ( const FuncData & d : data ) { 410 416 generator.gen( d, aggregateDecl->is_thread() || aggregateDecl->is_monitor() ); … … 436 442 FunctionType * assignType = dcl->get_functionType(); 437 443 assert( assignType->get_parameters().size() == 2 ); 438 ObjectDecl * srcParam = s afe_dynamic_cast< ObjectDecl * >( assignType->get_parameters().back() );444 ObjectDecl * srcParam = strict_dynamic_cast< ObjectDecl * >( assignType->get_parameters().back() ); 439 445 dcl->get_statements()->get_kids().push_back( new ReturnStmt( noLabels, new VariableExpr( srcParam ) ) ); 440 446 } … … 487 493 FunctionType * ftype = funcDecl->get_functionType(); 488 494 assert( ftype->get_parameters().size() == 2 ); 489 ObjectDecl * dstParam = s afe_dynamic_cast< ObjectDecl * >( ftype->get_parameters().front() );490 ObjectDecl * srcParam = s afe_dynamic_cast< ObjectDecl * >( ftype->get_parameters().back() );495 ObjectDecl * dstParam = strict_dynamic_cast< ObjectDecl * >( ftype->get_parameters().front() ); 496 ObjectDecl * srcParam = strict_dynamic_cast< ObjectDecl * >( ftype->get_parameters().back() ); 491 497 492 498 makeUnionFieldsAssignment( srcParam, dstParam, back_inserter( funcDecl->get_statements()->get_kids() ) ); … … 605 611 } 606 612 613 Type * declToTypeDeclBase( Declaration * decl ) { 614 if ( TypeDecl * td = dynamic_cast< TypeDecl * >( decl ) ) { 615 return td->base; 616 } 617 return nullptr; 618 } 619 620 // generate ctor/dtors/assign for typedecls, e.g., otype T = int *; 607 621 void AutogenerateRoutines::visit( TypeDecl *typeDecl ) { 608 TypeInstType *typeInst = new TypeInstType( Type::Qualifiers(), typeDecl->get_name(), false ); 609 typeInst->set_baseType( typeDecl ); 610 ObjectDecl *src = new ObjectDecl( "_src", Type::StorageClasses(), LinkageSpec::Cforall, nullptr, typeInst->clone(), nullptr ); 611 ObjectDecl *dst = new ObjectDecl( "_dst", Type::StorageClasses(), LinkageSpec::Cforall, nullptr, new PointerType( Type::Qualifiers(), typeInst->clone() ), nullptr ); 612 613 std::list< Statement * > stmts; 614 if ( typeDecl->get_base() ) { 615 // xxx - generate ctor/dtors for typedecls, e.g. 616 // otype T = int *; 617 UntypedExpr *assign = new UntypedExpr( new NameExpr( "?=?" ) ); 618 assign->get_args().push_back( new CastExpr( new VariableExpr( dst ), new PointerType( Type::Qualifiers(), typeDecl->get_base()->clone() ) ) ); 619 assign->get_args().push_back( new CastExpr( new VariableExpr( src ), typeDecl->get_base()->clone() ) ); 620 stmts.push_back( new ReturnStmt( std::list< Label >(), assign ) ); 621 } // if 622 FunctionType *type = new FunctionType( Type::Qualifiers(), false ); 623 type->get_returnVals().push_back( new ObjectDecl( "", Type::StorageClasses(), LinkageSpec::Cforall, 0, typeInst, 0 ) ); 624 type->get_parameters().push_back( dst ); 625 type->get_parameters().push_back( src ); 626 FunctionDecl *func = genFunc( "?=?", type, functionNesting ); 627 func->get_statements()->get_kids() = stmts; 628 declsToAddAfter.push_back( func ); 622 if ( ! typeDecl->base ) return; 623 624 // generate each of the functions based on the supplied FuncData objects 625 std::list< FunctionDecl * > newFuncs; 626 std::list< Declaration * > tds { typeDecl }; 627 std::list< TypeDecl * > typeParams; 628 TypeInstType refType( Type::Qualifiers(), typeDecl->name, typeDecl ); 629 auto generator = makeFuncGenerator( lazy_map( tds, declToTypeDeclBase ), &refType, functionNesting, typeParams, back_inserter( newFuncs ) ); 630 for ( const FuncData & d : data ) { 631 generator.gen( d, false ); 632 } 633 634 if ( functionNesting == 0 ) { 635 // forward declare if top-level struct, so that 636 // type is complete as soon as its body ends 637 // Note: this is necessary if we want structs which contain 638 // generic (otype) structs as members. 639 for ( FunctionDecl * dcl : newFuncs ) { 640 addForwardDecl( dcl, declsToAddAfter ); 641 } 642 } 643 644 for ( FunctionDecl * dcl : newFuncs ) { 645 FunctionType * ftype = dcl->type; 646 assertf( ftype->parameters.size() == 1 || ftype->parameters.size() == 2, "Incorrect number of parameters in autogenerated typedecl function: %zd", ftype->parameters.size() ); 647 DeclarationWithType * dst = ftype->parameters.front(); 648 DeclarationWithType * src = ftype->parameters.size() == 2 ? ftype->parameters.back() : nullptr; 649 // generate appropriate calls to member ctor, assignment 650 // destructor needs to do everything in reverse, so pass "forward" based on whether the function is a destructor 651 UntypedExpr * expr = new UntypedExpr( new NameExpr( dcl->name ) ); 652 expr->args.push_back( new CastExpr( new VariableExpr( dst ), new ReferenceType( Type::Qualifiers(), typeDecl->base->clone() ) ) ); 653 if ( src ) expr->args.push_back( new CastExpr( new VariableExpr( src ), typeDecl->base->clone() ) ); 654 dcl->statements->kids.push_back( new ExprStmt( noLabels, expr ) ); 655 if ( CodeGen::isAssignment( dcl->get_name() ) ) { 656 // assignment needs to return a value 657 FunctionType * assignType = dcl->type; 658 assert( assignType->parameters.size() == 2 ); 659 ObjectDecl * srcParam = strict_dynamic_cast< ObjectDecl * >( assignType->parameters.back() ); 660 dcl->statements->kids.push_back( new ReturnStmt( noLabels, new VariableExpr( srcParam ) ) ); 661 } 662 declsToAddAfter.push_back( dcl ); 663 } 629 664 } 630 665 … … 700 735 701 736 Type * AutogenTupleRoutines::mutate( TupleType * tupleType ) { 702 tupleType = s afe_dynamic_cast< TupleType * >( Parent::mutate( tupleType ) );737 tupleType = strict_dynamic_cast< TupleType * >( Parent::mutate( tupleType ) ); 703 738 std::string mangleName = SymTab::Mangler::mangleType( tupleType ); 704 739 if ( seenTuples.find( mangleName ) != seenTuples.end() ) return tupleType; … … 768 803 CompoundStmt * AutogenTupleRoutines::mutate( CompoundStmt *compoundStmt ) { 769 804 seenTuples.beginScope(); 770 compoundStmt = s afe_dynamic_cast< CompoundStmt * >( Parent::mutate( compoundStmt ) );805 compoundStmt = strict_dynamic_cast< CompoundStmt * >( Parent::mutate( compoundStmt ) ); 771 806 seenTuples.endScope(); 772 807 return compoundStmt; -
src/SymTab/Indexer.cc
rb2e2e34 rc935c3a 16 16 #include "Indexer.h" 17 17 18 #include <cassert> // for assert, s afe_dynamic_cast18 #include <cassert> // for assert, strict_dynamic_cast 19 19 #include <iostream> // for operator<<, basic_ostream, ostream 20 20 #include <string> // for string, operator<<, operator!= -
src/SymTab/Validate.cc
rb2e2e34 rc935c3a 176 176 }; 177 177 178 class EliminateTypedef : public Mutator { 179 public: 178 struct EliminateTypedef final : public WithVisitorRef<EliminateTypedef>, public WithGuards { 180 179 EliminateTypedef() : scopeLevel( 0 ) {} 181 180 /// Replaces typedefs by forward declarations 182 181 static void eliminateTypedef( std::list< Declaration * > &translationUnit ); 182 183 Type * postmutate( TypeInstType * aggregateUseType ); 184 Declaration * postmutate( TypedefDecl * typeDecl ); 185 void premutate( TypeDecl * typeDecl ); 186 void premutate( FunctionDecl * funcDecl ); 187 void premutate( ObjectDecl * objDecl ); 188 DeclarationWithType * postmutate( ObjectDecl * objDecl ); 189 190 void premutate( CastExpr * castExpr ); 191 192 void premutate( CompoundStmt * compoundStmt ); 193 CompoundStmt * postmutate( CompoundStmt * compoundStmt ); 194 195 void premutate( StructDecl * structDecl ); 196 Declaration * postmutate( StructDecl * structDecl ); 197 void premutate( UnionDecl * unionDecl ); 198 Declaration * postmutate( UnionDecl * unionDecl ); 199 void premutate( EnumDecl * enumDecl ); 200 Declaration * postmutate( EnumDecl * enumDecl ); 201 Declaration * postmutate( TraitDecl * contextDecl ); 202 183 203 private: 184 virtual Declaration *mutate( TypedefDecl *typeDecl );185 virtual TypeDecl *mutate( TypeDecl *typeDecl );186 virtual DeclarationWithType *mutate( FunctionDecl *funcDecl );187 virtual DeclarationWithType *mutate( ObjectDecl *objDecl );188 virtual CompoundStmt *mutate( CompoundStmt *compoundStmt );189 virtual Type *mutate( TypeInstType *aggregateUseType );190 virtual Expression *mutate( CastExpr *castExpr );191 192 virtual Declaration *mutate( StructDecl * structDecl );193 virtual Declaration *mutate( UnionDecl * unionDecl );194 virtual Declaration *mutate( EnumDecl * enumDecl );195 virtual Declaration *mutate( TraitDecl * contextDecl );196 197 204 template<typename AggDecl> 198 205 AggDecl *handleAggregate( AggDecl * aggDecl ); … … 486 493 std::list< DeclarationWithType * > asserts; 487 494 for ( Declaration * decl : inst->baseTrait->members ) { 488 asserts.push_back( s afe_dynamic_cast<DeclarationWithType *>( decl->clone() ) );495 asserts.push_back( strict_dynamic_cast<DeclarationWithType *>( decl->clone() ) ); 489 496 } 490 497 // substitute trait decl parameters for instance parameters … … 530 537 // need to carry over the 'sized' status of each decl in the instance 531 538 for ( auto p : group_iterate( traitDecl->get_parameters(), traitInst->get_parameters() ) ) { 532 TypeExpr * expr = s afe_dynamic_cast< TypeExpr * >( std::get<1>(p) );539 TypeExpr * expr = strict_dynamic_cast< TypeExpr * >( std::get<1>(p) ); 533 540 if ( TypeInstType * inst = dynamic_cast< TypeInstType * >( expr->get_type() ) ) { 534 541 TypeDecl * formalDecl = std::get<0>(p); … … 667 674 668 675 void EliminateTypedef::eliminateTypedef( std::list< Declaration * > &translationUnit ) { 669 EliminateTypedefeliminator;676 PassVisitor<EliminateTypedef> eliminator; 670 677 mutateAll( translationUnit, eliminator ); 671 if ( eliminator. typedefNames.count( "size_t" ) ) {678 if ( eliminator.pass.typedefNames.count( "size_t" ) ) { 672 679 // grab and remember declaration of size_t 673 SizeType = eliminator. typedefNames["size_t"].first->get_base()->clone();680 SizeType = eliminator.pass.typedefNames["size_t"].first->get_base()->clone(); 674 681 } else { 675 682 // xxx - missing global typedef for size_t - default to long unsigned int, even though that may be wrong … … 681 688 } 682 689 683 Type * EliminateTypedef::mutate( TypeInstType * typeInst ) {690 Type * EliminateTypedef::postmutate( TypeInstType * typeInst ) { 684 691 // instances of typedef types will come here. If it is an instance 685 692 // of a typdef type, link the instance to its actual type. … … 696 703 rtt->get_parameters().clear(); 697 704 cloneAll( typeInst->get_parameters(), rtt->get_parameters() ); 698 mutateAll( rtt->get_parameters(), * this); // recursively fix typedefs on parameters705 mutateAll( rtt->get_parameters(), *visitor ); // recursively fix typedefs on parameters 699 706 } // if 700 707 delete typeInst; … … 708 715 } 709 716 710 Declaration *EliminateTypedef::mutate( TypedefDecl * tyDecl ) { 711 Declaration *ret = Mutator::mutate( tyDecl ); 712 717 Declaration *EliminateTypedef::postmutate( TypedefDecl * tyDecl ) { 713 718 if ( typedefNames.count( tyDecl->get_name() ) == 1 && typedefNames[ tyDecl->get_name() ].second == scopeLevel ) { 714 719 // typedef to the same name from the same scope … … 741 746 return new EnumDecl( enumDecl->get_name(), noAttributes, tyDecl->get_linkage() ); 742 747 } else { 743 return ret->clone();744 } // if 745 } 746 747 TypeDecl *EliminateTypedef::mutate( TypeDecl * typeDecl ) {748 return tyDecl->clone(); 749 } // if 750 } 751 752 void EliminateTypedef::premutate( TypeDecl * typeDecl ) { 748 753 TypedefMap::iterator i = typedefNames.find( typeDecl->get_name() ); 749 754 if ( i != typedefNames.end() ) { … … 752 757 753 758 typedeclNames[ typeDecl->get_name() ] = typeDecl; 754 return Mutator::mutate( typeDecl ); 755 } 756 757 DeclarationWithType *EliminateTypedef::mutate( FunctionDecl * funcDecl ) { 758 typedefNames.beginScope(); 759 DeclarationWithType *ret = Mutator::mutate( funcDecl ); 760 typedefNames.endScope(); 761 return ret; 762 } 763 764 DeclarationWithType *EliminateTypedef::mutate( ObjectDecl * objDecl ) { 765 typedefNames.beginScope(); 766 DeclarationWithType *ret = Mutator::mutate( objDecl ); 767 typedefNames.endScope(); 768 769 if ( FunctionType *funtype = dynamic_cast<FunctionType *>( ret->get_type() ) ) { // function type? 759 } 760 761 void EliminateTypedef::premutate( FunctionDecl * ) { 762 GuardScope( typedefNames ); 763 } 764 765 void EliminateTypedef::premutate( ObjectDecl * ) { 766 GuardScope( typedefNames ); 767 } 768 769 DeclarationWithType *EliminateTypedef::postmutate( ObjectDecl * objDecl ) { 770 if ( FunctionType *funtype = dynamic_cast<FunctionType *>( objDecl->get_type() ) ) { // function type? 770 771 // replace the current object declaration with a function declaration 771 FunctionDecl * newDecl = new FunctionDecl( ret->get_name(), ret->get_storageClasses(), ret->get_linkage(), funtype, 0, objDecl->get_attributes(), ret->get_funcSpec() );772 FunctionDecl * newDecl = new FunctionDecl( objDecl->get_name(), objDecl->get_storageClasses(), objDecl->get_linkage(), funtype, 0, objDecl->get_attributes(), objDecl->get_funcSpec() ); 772 773 objDecl->get_attributes().clear(); 773 774 objDecl->set_type( nullptr ); … … 775 776 return newDecl; 776 777 } // if 777 return ret; 778 } 779 780 Expression *EliminateTypedef::mutate( CastExpr * castExpr ) { 781 typedefNames.beginScope(); 782 Expression *ret = Mutator::mutate( castExpr ); 783 typedefNames.endScope(); 784 return ret; 785 } 786 787 CompoundStmt *EliminateTypedef::mutate( CompoundStmt * compoundStmt ) { 788 typedefNames.beginScope(); 778 return objDecl; 779 } 780 781 void EliminateTypedef::premutate( CastExpr * ) { 782 GuardScope( typedefNames ); 783 } 784 785 void EliminateTypedef::premutate( CompoundStmt * ) { 786 GuardScope( typedefNames ); 789 787 scopeLevel += 1; 790 CompoundStmt *ret = Mutator::mutate( compoundStmt ); 791 scopeLevel -= 1; 788 GuardAction( [this](){ scopeLevel -= 1; } ); 789 } 790 791 CompoundStmt *EliminateTypedef::postmutate( CompoundStmt * compoundStmt ) { 792 792 // remove and delete decl stmts 793 793 filter( compoundStmt->kids, [](Statement * stmt) { … … 799 799 return false; 800 800 }, true); 801 typedefNames.endScope(); 802 return ret; 801 return compoundStmt; 803 802 } 804 803 … … 827 826 } 828 827 829 Declaration *EliminateTypedef::mutate( StructDecl * structDecl ) {828 void EliminateTypedef::premutate( StructDecl * structDecl ) { 830 829 addImplicitTypedef( structDecl ); 831 Mutator::mutate( structDecl ); 830 } 831 832 833 Declaration *EliminateTypedef::postmutate( StructDecl * structDecl ) { 832 834 return handleAggregate( structDecl ); 833 835 } 834 836 835 Declaration *EliminateTypedef::mutate( UnionDecl * unionDecl ) {837 void EliminateTypedef::premutate( UnionDecl * unionDecl ) { 836 838 addImplicitTypedef( unionDecl ); 837 Mutator::mutate( unionDecl ); 839 } 840 841 Declaration *EliminateTypedef::postmutate( UnionDecl * unionDecl ) { 838 842 return handleAggregate( unionDecl ); 839 843 } 840 844 841 Declaration *EliminateTypedef::mutate( EnumDecl * enumDecl ) {845 void EliminateTypedef::premutate( EnumDecl * enumDecl ) { 842 846 addImplicitTypedef( enumDecl ); 843 Mutator::mutate( enumDecl ); 847 } 848 849 Declaration *EliminateTypedef::postmutate( EnumDecl * enumDecl ) { 844 850 return handleAggregate( enumDecl ); 845 851 } 846 852 847 Declaration *EliminateTypedef::mutate( TraitDecl * contextDecl ) { 848 Mutator::mutate( contextDecl ); 849 return handleAggregate( contextDecl ); 853 Declaration *EliminateTypedef::postmutate( TraitDecl * traitDecl ) { 854 return handleAggregate( traitDecl ); 850 855 } 851 856 … … 892 897 for ( size_t i = 0; paramIter != params->end(); ++paramIter, ++i ) { 893 898 if ( i < args.size() ) { 894 TypeExpr * expr = s afe_dynamic_cast< TypeExpr * >( *std::next( args.begin(), i ) );899 TypeExpr * expr = strict_dynamic_cast< TypeExpr * >( *std::next( args.begin(), i ) ); 895 900 sub.add( (*paramIter)->get_name(), expr->get_type()->clone() ); 896 901 } else if ( i == args.size() ) { … … 962 967 if ( retVals.size() > 1 ) { 963 968 // generate a single return parameter which is the tuple of all of the return values 964 TupleType * tupleType = s afe_dynamic_cast< TupleType * >( ResolvExpr::extractResultType( ftype ) );969 TupleType * tupleType = strict_dynamic_cast< TupleType * >( ResolvExpr::extractResultType( ftype ) ); 965 970 // ensure return value is not destructed by explicitly creating an empty ListInit node wherein maybeConstruct is false. 966 971 ObjectDecl * newRet = new ObjectDecl( "", Type::StorageClasses(), LinkageSpec::Cforall, 0, tupleType, new ListInit( std::list<Initializer*>(), noDesignators, false ) ); -
src/SynTree/AddressExpr.cc
rb2e2e34 rc935c3a 47 47 } else { 48 48 // taking address of non-lvalue -- must be a reference, loses one layer of reference 49 ReferenceType * refType = s afe_dynamic_cast< ReferenceType * >( arg->get_result() );49 ReferenceType * refType = strict_dynamic_cast< ReferenceType * >( arg->get_result() ); 50 50 set_result( addrType( refType->get_base() ) ); 51 51 } -
src/SynTree/ApplicationExpr.cc
rb2e2e34 rc935c3a 14 14 // 15 15 16 #include <cassert> // for s afe_dynamic_cast, assert16 #include <cassert> // for strict_dynamic_cast, assert 17 17 #include <list> // for list 18 18 #include <map> // for _Rb_tree_const_iterator, map, map<>:... … … 50 50 51 51 ApplicationExpr::ApplicationExpr( Expression *funcExpr, const std::list<Expression *> & args ) : function( funcExpr ), args( args ) { 52 PointerType *pointer = s afe_dynamic_cast< PointerType* >( funcExpr->get_result() );53 FunctionType *function = s afe_dynamic_cast< FunctionType* >( pointer->get_base() );52 PointerType *pointer = strict_dynamic_cast< PointerType* >( funcExpr->get_result() ); 53 FunctionType *function = strict_dynamic_cast< FunctionType* >( pointer->get_base() ); 54 54 55 55 set_result( ResolvExpr::extractResultType( function ) ); -
src/SynTree/CompoundStmt.cc
rb2e2e34 rc935c3a 14 14 // 15 15 16 #include <cassert> // for assert, s afe_dynamic_cast16 #include <cassert> // for assert, strict_dynamic_cast 17 17 #include <list> // for list, _List_const_iterator, lis... 18 18 #include <ostream> // for operator<<, ostream, basic_ostream … … 52 52 Statement * origStmt = *origit++; 53 53 if ( DeclStmt * declStmt = dynamic_cast< DeclStmt * >( s ) ) { 54 DeclStmt * origDeclStmt = s afe_dynamic_cast< DeclStmt * >( origStmt );54 DeclStmt * origDeclStmt = strict_dynamic_cast< DeclStmt * >( origStmt ); 55 55 if ( DeclarationWithType * dwt = dynamic_cast< DeclarationWithType * > ( declStmt->get_decl() ) ) { 56 DeclarationWithType * origdwt = s afe_dynamic_cast< DeclarationWithType * > ( origDeclStmt->get_decl() );56 DeclarationWithType * origdwt = strict_dynamic_cast< DeclarationWithType * > ( origDeclStmt->get_decl() ); 57 57 assert( dwt->get_name() == origdwt->get_name() ); 58 58 declMap[ origdwt ] = dwt; -
src/SynTree/Constant.cc
rb2e2e34 rc935c3a 14 14 // 15 15 16 #include <cassert> // for s afe_dynamic_cast, assertf16 #include <cassert> // for strict_dynamic_cast, assertf 17 17 #include <iostream> // for operator<<, ostream, basic_ostream 18 18 #include <string> // for to_string, string, char_traits, operator<< … … 58 58 59 59 unsigned long long Constant::get_ival() const { 60 assertf( s afe_dynamic_cast<BasicType*>(type)->isInteger(), "Attempt to retrieve ival from non-integer constant." );60 assertf( strict_dynamic_cast<BasicType*>(type)->isInteger(), "Attempt to retrieve ival from non-integer constant." ); 61 61 return val.ival; 62 62 } 63 63 64 64 double Constant::get_dval() const { 65 assertf( ! s afe_dynamic_cast<BasicType*>(type)->isInteger(), "Attempt to retrieve dval from integer constant." );65 assertf( ! strict_dynamic_cast<BasicType*>(type)->isInteger(), "Attempt to retrieve dval from integer constant." ); 66 66 return val.dval; 67 67 } -
src/SynTree/Declaration.h
rb2e2e34 rc935c3a 137 137 void set_bitfieldWidth( Expression *newValue ) { bitfieldWidth = newValue; } 138 138 139 static ObjectDecl * newObject( const std::string & name, Type * type, Initializer * init ); 140 139 141 virtual ObjectDecl *clone() const { return new ObjectDecl( *this ); } 140 142 virtual void accept( Visitor &v ) { v.visit( this ); } … … 155 157 virtual ~FunctionDecl(); 156 158 157 Type * get_type() const ;158 virtual void set_type(Type * );159 Type * get_type() const { return type; } 160 virtual void set_type(Type * t) { type = strict_dynamic_cast< FunctionType* >( t ); } 159 161 160 162 FunctionType * get_functionType() const { return type; } … … 230 232 virtual TypeDecl *clone() const { return new TypeDecl( *this ); } 231 233 virtual void accept( Visitor &v ) { v.visit( this ); } 232 virtual TypeDecl*acceptMutator( Mutator &m ) { return m.mutate( this ); }234 virtual Declaration *acceptMutator( Mutator &m ) { return m.mutate( this ); } 233 235 virtual void print( std::ostream &os, int indent = 0 ) const; 234 236 -
src/SynTree/Expression.h
rb2e2e34 rc935c3a 86 86 public: 87 87 Expression * function; 88 std::list<Expression *> args; 89 InferredParams inferParams; 88 90 89 91 ApplicationExpr( Expression * function, const std::list<Expression *> & args = std::list< Expression * >() ); … … 100 102 virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); } 101 103 virtual void print( std::ostream & os, int indent = 0 ) const; 102 103 private:104 std::list<Expression *> args;105 InferredParams inferParams;106 104 }; 107 105 -
src/SynTree/FunctionDecl.cc
rb2e2e34 rc935c3a 44 44 delete type; 45 45 delete statements; 46 }47 48 Type * FunctionDecl::get_type() const {49 return type;50 }51 52 void FunctionDecl::set_type( Type *t ) {53 type = dynamic_cast< FunctionType* >( t );54 assert( type );55 46 } 56 47 -
src/SynTree/Mutator.cc
rb2e2e34 rc935c3a 78 78 } 79 79 80 TypeDecl* Mutator::mutate( TypeDecl *typeDecl ) {80 Declaration * Mutator::mutate( TypeDecl *typeDecl ) { 81 81 handleNamedTypeDecl( typeDecl ); 82 82 typeDecl->set_init( maybeMutate( typeDecl->get_init(), *this ) ); -
src/SynTree/Mutator.h
rb2e2e34 rc935c3a 31 31 virtual Declaration* mutate( EnumDecl *aggregateDecl ); 32 32 virtual Declaration* mutate( TraitDecl *aggregateDecl ); 33 virtual TypeDecl* mutate( TypeDecl *typeDecl );33 virtual Declaration* mutate( TypeDecl *typeDecl ); 34 34 virtual Declaration* mutate( TypedefDecl *typeDecl ); 35 35 virtual AsmDecl* mutate( AsmDecl *asmDecl ); -
src/SynTree/ObjectDecl.cc
rb2e2e34 rc935c3a 38 38 delete init; 39 39 delete bitfieldWidth; 40 } 41 42 ObjectDecl * ObjectDecl::newObject( const std::string & name, Type * type, Initializer * init ) { 43 return new ObjectDecl( name, Type::StorageClasses(), LinkageSpec::C, 0, type, init ); 40 44 } 41 45 -
src/SynTree/Statement.cc
rb2e2e34 rc935c3a 472 472 } 473 473 474 NullStmt::NullStmt( std::list<Label> labels ) : CompoundStmt( labels ) {}475 NullStmt::NullStmt() : CompoundStmt( std::list<Label>() ) {}474 NullStmt::NullStmt( std::list<Label> labels ) : Statement( labels ) {} 475 NullStmt::NullStmt() : Statement( std::list<Label>() ) {} 476 476 477 477 void NullStmt::print( std::ostream &os, __attribute__((unused)) int indent ) const { -
src/SynTree/Statement.h
rb2e2e34 rc935c3a 67 67 }; 68 68 69 class NullStmt : public CompoundStmt {69 class NullStmt : public Statement { 70 70 public: 71 71 NullStmt(); … … 155 155 public: 156 156 Expression * condition; 157 std::list<Statement *> statements; 157 158 158 159 SwitchStmt( std::list<Label> labels, Expression *condition, std::list<Statement *> &statements ); … … 170 171 virtual SwitchStmt *clone() const { return new SwitchStmt( *this ); } 171 172 virtual void print( std::ostream &os, int indent = 0 ) const; 172 private: 173 std::list<Statement *> statements; 173 174 174 }; 175 175 … … 327 327 class TryStmt : public Statement { 328 328 public: 329 CompoundStmt * block;329 CompoundStmt * block; 330 330 std::list<CatchStmt *> handlers; 331 FinallyStmt * finallyBlock;331 FinallyStmt * finallyBlock; 332 332 333 333 TryStmt( std::list<Label> labels, CompoundStmt *tryBlock, std::list<CatchStmt *> &handlers, FinallyStmt *finallyBlock = 0 ); -
src/SynTree/TupleExpr.cc
rb2e2e34 rc935c3a 14 14 // 15 15 16 #include <cassert> // for assert, s afe_dynamic_cast, assertf16 #include <cassert> // for assert, strict_dynamic_cast, assertf 17 17 #include <iterator> // for next 18 18 #include <list> // for list, _List_iterator … … 64 64 65 65 TupleIndexExpr::TupleIndexExpr( Expression * tuple, unsigned int index ) : tuple( tuple ), index( index ) { 66 TupleType * type = s afe_dynamic_cast< TupleType * >( tuple->get_result() );66 TupleType * type = strict_dynamic_cast< TupleType * >( tuple->get_result() ); 67 67 assertf( type->size() > index, "TupleIndexExpr index out of bounds: tuple size %d, requested index %d in expr %s", type->size(), index, toString( tuple ).c_str() ); 68 68 set_result( (*std::next( type->get_types().begin(), index ))->clone() ); -
src/SynTree/Visitor.h
rb2e2e34 rc935c3a 148 148 } 149 149 150 template< typename Container, typename VisitorType >151 void acceptAllFold( Container &container, VisitorType &visitor, VisitorType &around ) {152 SemanticError errors;153 for ( typename Container::iterator i = container.begin(); i != container.end(); ++i ) {154 try {155 if ( *i ) {156 VisitorType *v = new VisitorType;157 (*i)->accept( *v );158 159 typename Container::iterator nxt = i; nxt++; // forward_iterator160 if ( nxt == container.end() )161 visitor += *v;162 else163 visitor += *v + around;164 165 delete v;166 } // if167 } catch( SemanticError &e ) {168 e.set_location( (*i)->location );169 errors.append( e );170 } // try171 } // for172 if ( ! errors.isEmpty() ) {173 throw errors;174 } // if175 }176 177 150 // Local Variables: // 178 151 // tab-width: 4 // -
src/Tuples/TupleExpansion.cc
rb2e2e34 rc935c3a 168 168 // steal the already generated assignment to var from the unqExpr - this has been generated by FixInit 169 169 Expression * expr = unqExpr->get_expr(); 170 CommaExpr * commaExpr = s afe_dynamic_cast< CommaExpr * >( expr );170 CommaExpr * commaExpr = strict_dynamic_cast< CommaExpr * >( expr ); 171 171 assignUnq = commaExpr->get_arg1(); 172 172 commaExpr->set_arg1( nullptr ); … … 237 237 delete tupleExpr; 238 238 239 StructInstType * type = s afe_dynamic_cast< StructInstType * >( tuple->get_result() );239 StructInstType * type = strict_dynamic_cast< StructInstType * >( tuple->get_result() ); 240 240 StructDecl * structDecl = type->get_baseStruct(); 241 241 assert( structDecl->get_members().size() > idx ); 242 242 Declaration * member = *std::next(structDecl->get_members().begin(), idx); 243 MemberExpr * memExpr = new MemberExpr( s afe_dynamic_cast< DeclarationWithType * >( member ), tuple );243 MemberExpr * memExpr = new MemberExpr( strict_dynamic_cast< DeclarationWithType * >( member ), tuple ); 244 244 memExpr->set_env( env ); 245 245 return memExpr; -
src/include/cassert
rb2e2e34 rc935c3a 31 31 __ASSERT_FUNCTION, fmt, ## __VA_ARGS__ )) 32 32 33 void __assert_fail_f( const char *assertion, const char *file, 34 unsigned int line, const char *function, 35 const char *fmt, ... 33 void __assert_fail_f( const char *assertion, const char *file, 34 unsigned int line, const char *function, 35 const char *fmt, ... 36 36 ) __attribute__((noreturn, format(printf, 5, 6))); 37 37 … … 39 39 40 40 template<typename T, typename U> 41 static inline T s afe_dynamic_cast( const U & src ) {41 static inline T strict_dynamic_cast( const U & src ) { 42 42 T ret = dynamic_cast<T>(src); 43 43 assert(ret); -
src/libcfa/concurrency/monitor
rb2e2e34 rc935c3a 103 103 unsigned short count; 104 104 monitor_desc ** monitors; 105 bool is_dtor; 105 106 }; 106 107 -
src/main.cc
rb2e2e34 rc935c3a 39 39 #include "Common/UnimplementedError.h" // for UnimplementedError 40 40 #include "Common/utility.h" // for deleteAll, filter, printAll 41 #include "Concurrency/Waitfor.h" // for generateWaitfor 41 42 #include "ControlStruct/ExceptTranslate.h" // for translateEHM 42 43 #include "ControlStruct/Mutate.h" // for mutate … … 304 305 ControlStruct::translateEHM( translationUnit ); 305 306 307 OPTPRINT( "generateWaitfor" ); 308 Concurrency::generateWaitFor( translationUnit ); 309 306 310 OPTPRINT( "convertSpecializations" ) // needs to happen before tuple types are expanded 307 311 GenPoly::convertSpecializations( translationUnit ); -
src/tests/.expect/32/KRfunctions.txt
rb2e2e34 rc935c3a 2 2 __attribute__ ((__nothrow__,__leaf__)) extern void free(void *__ptr); 3 3 __attribute__ ((__nothrow__,__leaf__,__noreturn__)) extern void abort(void); 4 __attribute__ ((__nothrow__,__leaf__,__nonnull__(1))) extern int atexit(void (*__func)(void));5 __attribute__ ((__nothrow__,__leaf__,__noreturn__)) extern void exit( int __status);6 extern int printf(const char *__restrict __format, ...);7 int __f0__Fi_iPCii__1(int __a__i_1, const int *__b__PCi_1,int __c__i_1){8 __attribute__ ((unused)) int ___retval_f0__i_1;4 __attribute__ ((__nothrow__,__leaf__,__nonnull__(1))) extern signed int atexit(void (*__func)(void)); 5 __attribute__ ((__nothrow__,__leaf__,__noreturn__)) extern void exit(signed int __status); 6 extern signed int printf(const char *__restrict __format, ...); 7 signed int __f0__Fi_iPCii__1(signed int __a__i_1, const signed int *__b__PCi_1, signed int __c__i_1){ 8 __attribute__ ((unused)) signed int ___retval_f0__i_1; 9 9 } 10 int __f1__Fi_PiiPi__1(int *__a__Pi_1, __attribute__ ((unused)) int __b__i_1,int *__c__Pi_1){11 __attribute__ ((unused)) int ___retval_f1__i_1;10 signed int __f1__Fi_PiiPi__1(signed int *__a__Pi_1, __attribute__ ((unused)) signed int __b__i_1, signed int *__c__Pi_1){ 11 __attribute__ ((unused)) signed int ___retval_f1__i_1; 12 12 } 13 int __f2__Fi_iPiPi__1(int __a__i_1, int *__b__Pi_1,int *__c__Pi_1){14 __attribute__ ((unused)) int ___retval_f2__i_1;13 signed int __f2__Fi_iPiPi__1(signed int __a__i_1, signed int *__b__Pi_1, signed int *__c__Pi_1){ 14 __attribute__ ((unused)) signed int ___retval_f2__i_1; 15 15 } 16 16 struct S { 17 int __i__i_1;17 signed int __i__i_1; 18 18 }; 19 19 static inline void ___constructor__F_R2sS_autogen___1(struct S *___dst__R2sS_1); … … 36 36 return ((struct S )___ret__2sS_1); 37 37 } 38 static inline void ___constructor__F_R2sSi_autogen___1(struct S *___dst__R2sS_1, int __i__i_1){38 static inline void ___constructor__F_R2sSi_autogen___1(struct S *___dst__R2sS_1, signed int __i__i_1){ 39 39 ((void)((*___dst__R2sS_1).__i__i_1=__i__i_1) /* ?{} */); 40 40 } 41 int __f3__Fi_2sS2sSPi__1(struct S __a__2sS_1, struct S __b__2sS_1,int *__c__Pi_1){42 __attribute__ ((unused)) int ___retval_f3__i_1;41 signed int __f3__Fi_2sS2sSPi__1(struct S __a__2sS_1, struct S __b__2sS_1, signed int *__c__Pi_1){ 42 __attribute__ ((unused)) signed int ___retval_f3__i_1; 43 43 struct S __s__2sS_2; 44 44 } 45 int __f4__Fi_iPiPi__1(int __a__i_1, int *__b__Pi_1,int *__c__Pi_1){46 __attribute__ ((unused)) int ___retval_f4__i_1;45 signed int __f4__Fi_iPiPi__1(signed int __a__i_1, signed int *__b__Pi_1, signed int *__c__Pi_1){ 46 __attribute__ ((unused)) signed int ___retval_f4__i_1; 47 47 } 48 int __f5__Fi_iPiPi__1(int __a__i_1, int *__b__Pi_1,int *__c__Pi_1){49 __attribute__ ((unused)) int ___retval_f5__i_1;48 signed int __f5__Fi_iPiPi__1(signed int __a__i_1, signed int *__b__Pi_1, signed int *__c__Pi_1){ 49 __attribute__ ((unused)) signed int ___retval_f5__i_1; 50 50 } 51 int (*__f6__FPFi_i__iPiPi__1(int __a__i_1, int *__b__Pi_1, int *__c__Pi_1))(int __anonymous_object0){52 __attribute__ ((unused)) int (*___retval_f6__PFi_i__1)(int __anonymous_object1);51 signed int (*__f6__FPFi_i__iPiPi__1(signed int __a__i_1, signed int *__b__Pi_1, signed int *__c__Pi_1))(signed int __anonymous_object0){ 52 __attribute__ ((unused)) signed int (*___retval_f6__PFi_i__1)(signed int __anonymous_object1); 53 53 } 54 int (*__f7__FPFi_ii__iPiPi__1(int __a__i_1, int *__b__Pi_1, int *__c__Pi_1))(int __a__i_1,int __b__i_1){55 __attribute__ ((unused)) int (*___retval_f7__PFi_ii__1)(int __a__i_1,int __b__i_1);54 signed int (*__f7__FPFi_ii__iPiPi__1(signed int __a__i_1, signed int *__b__Pi_1, signed int *__c__Pi_1))(signed int __a__i_1, signed int __b__i_1){ 55 __attribute__ ((unused)) signed int (*___retval_f7__PFi_ii__1)(signed int __a__i_1, signed int __b__i_1); 56 56 } 57 int *__f8__FPi_iPiPi__1(int __a__i_1, int *__b__Pi_1,int *__c__Pi_1){58 __attribute__ ((unused)) int *___retval_f8__Pi_1;57 signed int *__f8__FPi_iPiPi__1(signed int __a__i_1, signed int *__b__Pi_1, signed int *__c__Pi_1){ 58 __attribute__ ((unused)) signed int *___retval_f8__Pi_1; 59 59 } 60 int *const __f9__FCPi_PiiPi__1(int *__a__Pi_1, int __b__i_1,int *__c__Pi_1){61 __attribute__ ((unused)) int *const ___retval_f9__CPi_1;60 signed int *const __f9__FCPi_PiiPi__1(signed int *__a__Pi_1, signed int __b__i_1, signed int *__c__Pi_1){ 61 __attribute__ ((unused)) signed int *const ___retval_f9__CPi_1; 62 62 } 63 int *(*__f10__FPFPi_ii__iPiPid__1(int __a__i_1, int *__b__Pi_1, int *__c__Pi_1, double __y__d_1))(int __x__i_1,int __y__i_1){64 __attribute__ ((unused)) int *(*___retval_f10__PFPi_ii__1)(int __x__i_1,int __y__i_1);65 int *__x__FPi_ii__2(int __anonymous_object2,int __anonymous_object3);63 signed int *(*__f10__FPFPi_ii__iPiPid__1(signed int __a__i_1, signed int *__b__Pi_1, signed int *__c__Pi_1, double __y__d_1))(signed int __x__i_1, signed int __y__i_1){ 64 __attribute__ ((unused)) signed int *(*___retval_f10__PFPi_ii__1)(signed int __x__i_1, signed int __y__i_1); 65 signed int *__x__FPi_ii__2(signed int __anonymous_object2, signed int __anonymous_object3); 66 66 ((void)(___retval_f10__PFPi_ii__1=__x__FPi_ii__2) /* ?{} */); 67 return (( int *(*)(int __x__i_1,int __y__i_1))___retval_f10__PFPi_ii__1);67 return ((signed int *(*)(signed int __x__i_1, signed int __y__i_1))___retval_f10__PFPi_ii__1); 68 68 } 69 int (*__f11__FPA0i_iPiPi__1(int __a__i_1, int *__b__Pi_1,int *__c__Pi_1))[]{70 __attribute__ ((unused)) int (*___retval_f11__PA0i_1)[];69 signed int (*__f11__FPA0i_iPiPi__1(signed int __a__i_1, signed int *__b__Pi_1, signed int *__c__Pi_1))[]{ 70 __attribute__ ((unused)) signed int (*___retval_f11__PA0i_1)[]; 71 71 } 72 int (*__f12__FPA0A0i_iPiPi__1(int __a__i_1, int *__b__Pi_1,int *__c__Pi_1))[][((unsigned int )10)]{73 __attribute__ ((unused)) int (*___retval_f12__PA0A0i_1)[][((unsigned int )10)];72 signed int (*__f12__FPA0A0i_iPiPi__1(signed int __a__i_1, signed int *__b__Pi_1, signed int *__c__Pi_1))[][((unsigned int )10)]{ 73 __attribute__ ((unused)) signed int (*___retval_f12__PA0A0i_1)[][((unsigned int )10)]; 74 74 } 75 int (*__f13__FPA0A0i_iPiPi__1(int __a__i_1, int *__b__Pi_1,int *__c__Pi_1))[][((unsigned int )10)]{76 __attribute__ ((unused)) int (*___retval_f13__PA0A0i_1)[][((unsigned int )10)];75 signed int (*__f13__FPA0A0i_iPiPi__1(signed int __a__i_1, signed int *__b__Pi_1, signed int *__c__Pi_1))[][((unsigned int )10)]{ 76 __attribute__ ((unused)) signed int (*___retval_f13__PA0A0i_1)[][((unsigned int )10)]; 77 77 } 78 int (*__f14__FPA0A0i_iPiPi__1(int __a__i_1, int *__b__Pi_1,int *__c__Pi_1))[][((unsigned int )10)]{79 __attribute__ ((unused)) int (*___retval_f14__PA0A0i_1)[][((unsigned int )10)];78 signed int (*__f14__FPA0A0i_iPiPi__1(signed int __a__i_1, signed int *__b__Pi_1, signed int *__c__Pi_1))[][((unsigned int )10)]{ 79 __attribute__ ((unused)) signed int (*___retval_f14__PA0A0i_1)[][((unsigned int )10)]; 80 80 } 81 int __f15__Fi_iii__1(int __a__i_1, int __b__i_1,int __c__i_1){82 __attribute__ ((unused)) int ___retval_f15__i_1;81 signed int __f15__Fi_iii__1(signed int __a__i_1, signed int __b__i_1, signed int __c__i_1){ 82 __attribute__ ((unused)) signed int ___retval_f15__i_1; 83 83 } 84 const int __fred__FCi___1(){85 __attribute__ ((unused)) const int ___retval_fred__Ci_1;86 int *(*__x__PFPi_ii__2)(int __anonymous_object4,int __anonymous_object5);87 int __a__i_2;88 int __b__i_2;89 int *(*_tmp_cp_ret0)(int __x__i_1,int __y__i_1);84 const signed int __fred__FCi___1(){ 85 __attribute__ ((unused)) const signed int ___retval_fred__Ci_1; 86 signed int *(*__x__PFPi_ii__2)(signed int __anonymous_object4, signed int __anonymous_object5); 87 signed int __a__i_2; 88 signed int __b__i_2; 89 signed int *(*_tmp_cp_ret0)(signed int __x__i_1, signed int __y__i_1); 90 90 ((void)(__x__PFPi_ii__2=(((void)(_tmp_cp_ret0=__f10__FPFPi_ii__iPiPid__1(3, (&__a__i_2), (&__b__i_2), 3.5))) , _tmp_cp_ret0))); 91 91 ((void)(_tmp_cp_ret0) /* ^?{} */); 92 const int __f1__FCi_iPiPi__2(int __a__i_2, int *__b__Pi_2,int *__c__Pi_2){93 __attribute__ ((unused)) const int ___retval_f1__Ci_2;92 const signed int __f1__FCi_iPiPi__2(signed int __a__i_2, signed int *__b__Pi_2, signed int *__c__Pi_2){ 93 __attribute__ ((unused)) const signed int ___retval_f1__Ci_2; 94 94 } 95 const int __f2__FCi_iii__2(int __a__i_2, int __b__i_2,int __c__i_2){96 __attribute__ ((unused)) const int ___retval_f2__Ci_2;95 const signed int __f2__FCi_iii__2(signed int __a__i_2, signed int __b__i_2, signed int __c__i_2){ 96 __attribute__ ((unused)) const signed int ___retval_f2__Ci_2; 97 97 } 98 98 } -
src/tests/.expect/32/attributes.txt
rb2e2e34 rc935c3a 2 2 __attribute__ ((__nothrow__,__leaf__)) extern void free(void *__ptr); 3 3 __attribute__ ((__nothrow__,__leaf__,__noreturn__)) extern void abort(void); 4 __attribute__ ((__nothrow__,__leaf__,__nonnull__(1))) extern int atexit(void (*__func)(void));5 __attribute__ ((__nothrow__,__leaf__,__noreturn__)) extern void exit( int __status);6 extern int printf(const char *__restrict __format, ...);7 int __la__Fi___1(){8 __attribute__ ((unused)) int ___retval_la__i_1;4 __attribute__ ((__nothrow__,__leaf__,__nonnull__(1))) extern signed int atexit(void (*__func)(void)); 5 __attribute__ ((__nothrow__,__leaf__,__noreturn__)) extern void exit(signed int __status); 6 extern signed int printf(const char *__restrict __format, ...); 7 signed int __la__Fi___1(){ 8 __attribute__ ((unused)) signed int ___retval_la__i_1; 9 9 L: __attribute__ ((unused)) ((void)1); 10 10 } … … 54 54 __attribute__ ((unused)) struct __anonymous3; 55 55 struct Fdl { 56 __attribute__ ((unused)) int __f1__i_1;57 __attribute__ ((unused)) int __f2__i_1;58 __attribute__ ((unused,unused)) int __f3__i_1;59 __attribute__ ((unused)) int __f4__i_1;60 __attribute__ ((unused,unused)) int __f5__i_1;61 __attribute__ ((used,packed)) int __f6__i_1;62 __attribute__ ((used,unused,unused)) int __f7__i_1;63 __attribute__ ((used,used,unused)) int __f8__i_1;64 __attribute__ ((unused)) int __anonymous_object0;65 __attribute__ ((unused,unused)) int *__f9__Pi_1;56 __attribute__ ((unused)) signed int __f1__i_1; 57 __attribute__ ((unused)) signed int __f2__i_1; 58 __attribute__ ((unused,unused)) signed int __f3__i_1; 59 __attribute__ ((unused)) signed int __f4__i_1; 60 __attribute__ ((unused,unused)) signed int __f5__i_1; 61 __attribute__ ((used,packed)) signed int __f6__i_1; 62 __attribute__ ((used,unused,unused)) signed int __f7__i_1; 63 __attribute__ ((used,used,unused)) signed int __f8__i_1; 64 __attribute__ ((unused)) signed int __anonymous_object0; 65 __attribute__ ((unused,unused)) signed int *__f9__Pi_1; 66 66 }; 67 67 static inline void ___constructor__F_R4sFdl_autogen___1(struct Fdl *___dst__R4sFdl_1); … … 116 116 return ((struct Fdl )___ret__4sFdl_1); 117 117 } 118 static inline void ___constructor__F_R4sFdli_autogen___1(struct Fdl *___dst__R4sFdl_1, int __f1__i_1){118 static inline void ___constructor__F_R4sFdli_autogen___1(struct Fdl *___dst__R4sFdl_1, signed int __f1__i_1){ 119 119 ((void)((*___dst__R4sFdl_1).__f1__i_1=__f1__i_1) /* ?{} */); 120 120 ((void)((*___dst__R4sFdl_1).__f2__i_1) /* ?{} */); … … 127 127 ((void)((*___dst__R4sFdl_1).__f9__Pi_1) /* ?{} */); 128 128 } 129 static inline void ___constructor__F_R4sFdlii_autogen___1(struct Fdl *___dst__R4sFdl_1, int __f1__i_1,int __f2__i_1){129 static inline void ___constructor__F_R4sFdlii_autogen___1(struct Fdl *___dst__R4sFdl_1, signed int __f1__i_1, signed int __f2__i_1){ 130 130 ((void)((*___dst__R4sFdl_1).__f1__i_1=__f1__i_1) /* ?{} */); 131 131 ((void)((*___dst__R4sFdl_1).__f2__i_1=__f2__i_1) /* ?{} */); … … 138 138 ((void)((*___dst__R4sFdl_1).__f9__Pi_1) /* ?{} */); 139 139 } 140 static inline void ___constructor__F_R4sFdliii_autogen___1(struct Fdl *___dst__R4sFdl_1, int __f1__i_1, int __f2__i_1,int __f3__i_1){140 static inline void ___constructor__F_R4sFdliii_autogen___1(struct Fdl *___dst__R4sFdl_1, signed int __f1__i_1, signed int __f2__i_1, signed int __f3__i_1){ 141 141 ((void)((*___dst__R4sFdl_1).__f1__i_1=__f1__i_1) /* ?{} */); 142 142 ((void)((*___dst__R4sFdl_1).__f2__i_1=__f2__i_1) /* ?{} */); … … 149 149 ((void)((*___dst__R4sFdl_1).__f9__Pi_1) /* ?{} */); 150 150 } 151 static inline void ___constructor__F_R4sFdliiii_autogen___1(struct Fdl *___dst__R4sFdl_1, int __f1__i_1, int __f2__i_1, int __f3__i_1,int __f4__i_1){152 ((void)((*___dst__R4sFdl_1).__f1__i_1=__f1__i_1) /* ?{} */); 153 ((void)((*___dst__R4sFdl_1).__f2__i_1=__f2__i_1) /* ?{} */); 154 ((void)((*___dst__R4sFdl_1).__f3__i_1=__f3__i_1) /* ?{} */); 155 ((void)((*___dst__R4sFdl_1).__f4__i_1=__f4__i_1) /* ?{} */); 156 ((void)((*___dst__R4sFdl_1).__f5__i_1) /* ?{} */); 157 ((void)((*___dst__R4sFdl_1).__f6__i_1) /* ?{} */); 158 ((void)((*___dst__R4sFdl_1).__f7__i_1) /* ?{} */); 159 ((void)((*___dst__R4sFdl_1).__f8__i_1) /* ?{} */); 160 ((void)((*___dst__R4sFdl_1).__f9__Pi_1) /* ?{} */); 161 } 162 static inline void ___constructor__F_R4sFdliiiii_autogen___1(struct Fdl *___dst__R4sFdl_1, int __f1__i_1, int __f2__i_1, int __f3__i_1, int __f4__i_1,int __f5__i_1){163 ((void)((*___dst__R4sFdl_1).__f1__i_1=__f1__i_1) /* ?{} */); 164 ((void)((*___dst__R4sFdl_1).__f2__i_1=__f2__i_1) /* ?{} */); 165 ((void)((*___dst__R4sFdl_1).__f3__i_1=__f3__i_1) /* ?{} */); 166 ((void)((*___dst__R4sFdl_1).__f4__i_1=__f4__i_1) /* ?{} */); 167 ((void)((*___dst__R4sFdl_1).__f5__i_1=__f5__i_1) /* ?{} */); 168 ((void)((*___dst__R4sFdl_1).__f6__i_1) /* ?{} */); 169 ((void)((*___dst__R4sFdl_1).__f7__i_1) /* ?{} */); 170 ((void)((*___dst__R4sFdl_1).__f8__i_1) /* ?{} */); 171 ((void)((*___dst__R4sFdl_1).__f9__Pi_1) /* ?{} */); 172 } 173 static inline void ___constructor__F_R4sFdliiiiii_autogen___1(struct Fdl *___dst__R4sFdl_1, int __f1__i_1, int __f2__i_1, int __f3__i_1, int __f4__i_1, int __f5__i_1,int __f6__i_1){151 static inline void ___constructor__F_R4sFdliiii_autogen___1(struct Fdl *___dst__R4sFdl_1, signed int __f1__i_1, signed int __f2__i_1, signed int __f3__i_1, signed int __f4__i_1){ 152 ((void)((*___dst__R4sFdl_1).__f1__i_1=__f1__i_1) /* ?{} */); 153 ((void)((*___dst__R4sFdl_1).__f2__i_1=__f2__i_1) /* ?{} */); 154 ((void)((*___dst__R4sFdl_1).__f3__i_1=__f3__i_1) /* ?{} */); 155 ((void)((*___dst__R4sFdl_1).__f4__i_1=__f4__i_1) /* ?{} */); 156 ((void)((*___dst__R4sFdl_1).__f5__i_1) /* ?{} */); 157 ((void)((*___dst__R4sFdl_1).__f6__i_1) /* ?{} */); 158 ((void)((*___dst__R4sFdl_1).__f7__i_1) /* ?{} */); 159 ((void)((*___dst__R4sFdl_1).__f8__i_1) /* ?{} */); 160 ((void)((*___dst__R4sFdl_1).__f9__Pi_1) /* ?{} */); 161 } 162 static inline void ___constructor__F_R4sFdliiiii_autogen___1(struct Fdl *___dst__R4sFdl_1, signed int __f1__i_1, signed int __f2__i_1, signed int __f3__i_1, signed int __f4__i_1, signed int __f5__i_1){ 163 ((void)((*___dst__R4sFdl_1).__f1__i_1=__f1__i_1) /* ?{} */); 164 ((void)((*___dst__R4sFdl_1).__f2__i_1=__f2__i_1) /* ?{} */); 165 ((void)((*___dst__R4sFdl_1).__f3__i_1=__f3__i_1) /* ?{} */); 166 ((void)((*___dst__R4sFdl_1).__f4__i_1=__f4__i_1) /* ?{} */); 167 ((void)((*___dst__R4sFdl_1).__f5__i_1=__f5__i_1) /* ?{} */); 168 ((void)((*___dst__R4sFdl_1).__f6__i_1) /* ?{} */); 169 ((void)((*___dst__R4sFdl_1).__f7__i_1) /* ?{} */); 170 ((void)((*___dst__R4sFdl_1).__f8__i_1) /* ?{} */); 171 ((void)((*___dst__R4sFdl_1).__f9__Pi_1) /* ?{} */); 172 } 173 static inline void ___constructor__F_R4sFdliiiiii_autogen___1(struct Fdl *___dst__R4sFdl_1, signed int __f1__i_1, signed int __f2__i_1, signed int __f3__i_1, signed int __f4__i_1, signed int __f5__i_1, signed int __f6__i_1){ 174 174 ((void)((*___dst__R4sFdl_1).__f1__i_1=__f1__i_1) /* ?{} */); 175 175 ((void)((*___dst__R4sFdl_1).__f2__i_1=__f2__i_1) /* ?{} */); … … 182 182 ((void)((*___dst__R4sFdl_1).__f9__Pi_1) /* ?{} */); 183 183 } 184 static inline void ___constructor__F_R4sFdliiiiiii_autogen___1(struct Fdl *___dst__R4sFdl_1, int __f1__i_1, int __f2__i_1, int __f3__i_1, int __f4__i_1, int __f5__i_1, int __f6__i_1,int __f7__i_1){184 static inline void ___constructor__F_R4sFdliiiiiii_autogen___1(struct Fdl *___dst__R4sFdl_1, signed int __f1__i_1, signed int __f2__i_1, signed int __f3__i_1, signed int __f4__i_1, signed int __f5__i_1, signed int __f6__i_1, signed int __f7__i_1){ 185 185 ((void)((*___dst__R4sFdl_1).__f1__i_1=__f1__i_1) /* ?{} */); 186 186 ((void)((*___dst__R4sFdl_1).__f2__i_1=__f2__i_1) /* ?{} */); … … 193 193 ((void)((*___dst__R4sFdl_1).__f9__Pi_1) /* ?{} */); 194 194 } 195 static inline void ___constructor__F_R4sFdliiiiiiii_autogen___1(struct Fdl *___dst__R4sFdl_1, int __f1__i_1, int __f2__i_1, int __f3__i_1, int __f4__i_1, int __f5__i_1, int __f6__i_1, int __f7__i_1,int __f8__i_1){195 static inline void ___constructor__F_R4sFdliiiiiiii_autogen___1(struct Fdl *___dst__R4sFdl_1, signed int __f1__i_1, signed int __f2__i_1, signed int __f3__i_1, signed int __f4__i_1, signed int __f5__i_1, signed int __f6__i_1, signed int __f7__i_1, signed int __f8__i_1){ 196 196 ((void)((*___dst__R4sFdl_1).__f1__i_1=__f1__i_1) /* ?{} */); 197 197 ((void)((*___dst__R4sFdl_1).__f2__i_1=__f2__i_1) /* ?{} */); … … 204 204 ((void)((*___dst__R4sFdl_1).__f9__Pi_1) /* ?{} */); 205 205 } 206 static inline void ___constructor__F_R4sFdliiiiiiiiPi_autogen___1(struct Fdl *___dst__R4sFdl_1, int __f1__i_1, int __f2__i_1, int __f3__i_1, int __f4__i_1, int __f5__i_1, int __f6__i_1, int __f7__i_1, int __f8__i_1,int *__f9__Pi_1){206 static inline void ___constructor__F_R4sFdliiiiiiiiPi_autogen___1(struct Fdl *___dst__R4sFdl_1, signed int __f1__i_1, signed int __f2__i_1, signed int __f3__i_1, signed int __f4__i_1, signed int __f5__i_1, signed int __f6__i_1, signed int __f7__i_1, signed int __f8__i_1, signed int *__f9__Pi_1){ 207 207 ((void)((*___dst__R4sFdl_1).__f1__i_1=__f1__i_1) /* ?{} */); 208 208 ((void)((*___dst__R4sFdl_1).__f2__i_1=__f2__i_1) /* ?{} */); … … 215 215 ((void)((*___dst__R4sFdl_1).__f9__Pi_1=__f9__Pi_1) /* ?{} */); 216 216 } 217 __attribute__ ((unused)) int __f__Fi___1() asm ( "xyz" );218 __attribute__ ((used,used)) const int __vd1__Ci_1;219 __attribute__ ((used,unused)) const int __vd2__Ci_1;220 __attribute__ ((used,used,used,used)) const int *__vd3__PCi_1;221 __attribute__ ((used,used,unused,used,unused)) const int *__vd4__PCi_1;222 __attribute__ ((used,used,used)) const int __vd5__A0Ci_1[((unsigned int )5)];223 __attribute__ ((used,used,unused,used)) const int __vd6__A0Ci_1[((unsigned int )5)];224 __attribute__ ((used,used,used,used)) const int (*__vd7__PFCi___1)();225 __attribute__ ((used,used,unused,used,used)) const int (*__vd8__PFCi___1)();226 __attribute__ ((unused,used)) int __f1__Fi___1();227 __attribute__ ((unused)) int __f1__Fi___1(){228 __attribute__ ((unused)) int ___retval_f1__i_1;229 } 230 __attribute__ ((unused,unused,unused,used)) int **const __f2__FCPPi___1();231 __attribute__ ((unused,unused,unused)) int **const __f2__FCPPi___1(){232 __attribute__ ((unused)) int **const ___retval_f2__CPPi_1;233 } 234 __attribute__ ((unused,used,unused)) int (*__f3__FPA0i_i__1(int __anonymous_object1))[];235 __attribute__ ((unused,unused)) int (*__f3__FPA0i_i__1(int __p__i_1))[]{236 __attribute__ ((unused)) int (*___retval_f3__PA0i_1)[];237 } 238 __attribute__ ((unused,used,unused)) int (*__f4__FPFi_i____1())(int __anonymous_object2);239 __attribute__ ((unused,unused)) int (*__f4__FPFi_i____1())(int __anonymous_object3){240 __attribute__ ((unused)) int (*___retval_f4__PFi_i__1)(int __anonymous_object4);241 } 242 int __vtr__Fi___1(){243 __attribute__ ((unused)) int ___retval_vtr__i_1;244 __attribute__ ((unused,unused,used)) int __t1__i_2;245 __attribute__ ((unused,unused,unused,unused,unused)) int **__t2__PPi_2;246 __attribute__ ((unused,unused,unused)) int __t3__A0i_2[((unsigned int )5)];247 __attribute__ ((unused,unused,unused,unused,unused)) int **__t4__A0PPi_2[((unsigned int )5)];248 __attribute__ ((unused,unused,unused)) int __t5__Fi___2();249 __attribute__ ((unused,unused,unused,unused)) int *__t6__FPi___2();250 } 251 int __ipd1__Fi_ii__1(__attribute__ ((unused,unused,unused)) int __p__i_1, __attribute__ ((unused,unused,unused))int __q__i_1);252 int __ipd1__Fi_ii__1(__attribute__ ((unused,unused,unused)) int __p__i_1, __attribute__ ((unused,unused,unused))int __q__i_1){253 __attribute__ ((unused)) int ___retval_ipd1__i_1;254 } 255 int __ipd2__Fi_PiPi__1(__attribute__ ((unused,unused,unused,unused)) int *__p__Pi_1, __attribute__ ((unused,unused,unused))int *__q__Pi_1);256 int __ipd2__Fi_PiPi__1(__attribute__ ((unused,unused,unused,unused)) int *__p__Pi_1, __attribute__ ((unused,unused,unused))int *__q__Pi_1){257 __attribute__ ((unused)) int ___retval_ipd2__i_1;258 } 259 int __ipd3__Fi_PiPi__1(__attribute__ ((unused,unused,unused)) int *__p__Pi_1, __attribute__ ((unused,unused,unused))int *__q__Pi_1);260 int __ipd3__Fi_PiPi__1(__attribute__ ((unused,unused,unused)) int *__p__Pi_1, __attribute__ ((unused,unused,unused))int *__q__Pi_1){261 __attribute__ ((unused)) int ___retval_ipd3__i_1;262 } 263 int __ipd4__Fi_PFi__PFi____1(__attribute__ ((unused,unused,unused)) int (*__p__PFi___1)(), __attribute__ ((unused,unused,unused))int (*__q__PFi___1)());264 int __ipd4__Fi_PFi__PFi____1(__attribute__ ((unused,unused,unused)) int (*__p__PFi___1)(), __attribute__ ((unused,unused,unused))int (*__q__PFi___1)()){265 __attribute__ ((unused)) int ___retval_ipd4__i_1;266 } 267 int __tpr1__Fi_i__1(__attribute__ ((unused,unused,unused))int __Foo__i_1);268 int __tpr2__Fi_PPi__1(__attribute__ ((unused,unused,unused,unused,unused,unused))int **__Foo__PPi_1);269 int __tpr3__Fi_Pi__1(__attribute__ ((unused,unused,unused))int *__Foo__Pi_1);270 int __tpr4__Fi_PFi_Pi___1(__attribute__ ((unused,unused)) int (*__anonymous_object5)(__attribute__ ((unused,unused))int __anonymous_object6[((unsigned int )5)]));271 int __tpr5__Fi_PFi____1(__attribute__ ((unused,unused,unused))int (*__Foo__PFi___1)());272 int __tpr6__Fi_PFi____1(__attribute__ ((unused,unused,unused))int (*__Foo__PFi___1)());273 int __tpr7__Fi_PFi_PFi_i____1(__attribute__ ((unused,unused)) int (*__anonymous_object7)(__attribute__ ((unused)) int (*__anonymous_object8)(__attribute__ ((unused,unused))int __anonymous_object9)));274 int __ad__Fi___1(){275 __attribute__ ((unused)) int ___retval_ad__i_1;276 __attribute__ ((used,unused)) int __ad1__i_2;277 __attribute__ ((unused,unused,unused)) int *__ad2__Pi_2;278 __attribute__ ((unused,unused,unused)) int __ad3__A0i_2[((unsigned int )5)];279 __attribute__ ((unused,unused,unused,unused,unused)) int (*__ad4__PA0i_2)[((unsigned int )10)];280 __attribute__ ((unused,unused,unused,unused,used)) int __ad5__i_2;281 __attribute__ ((unused,unused,unused,unused,unused)) int __ad6__Fi___2();282 ((void)sizeof(__attribute__ ((unused,unused)) int ));283 ((void)sizeof(__attribute__ ((unused,unused,unused,unused)) int **));284 ((void)sizeof(__attribute__ ((unused,unused,unused)) int [5]));285 ((void)sizeof(__attribute__ ((unused,unused,unused)) int (*)[10]));286 ((void)sizeof(__attribute__ ((unused,unused,unused)) int ()));217 __attribute__ ((unused)) signed int __f__Fi___1() asm ( "xyz" ); 218 __attribute__ ((used,used)) const signed int __vd1__Ci_1; 219 __attribute__ ((used,unused)) const signed int __vd2__Ci_1; 220 __attribute__ ((used,used,used,used)) const signed int *__vd3__PCi_1; 221 __attribute__ ((used,used,unused,used,unused)) const signed int *__vd4__PCi_1; 222 __attribute__ ((used,used,used)) const signed int __vd5__A0Ci_1[((unsigned int )5)]; 223 __attribute__ ((used,used,unused,used)) const signed int __vd6__A0Ci_1[((unsigned int )5)]; 224 __attribute__ ((used,used,used,used)) const signed int (*__vd7__PFCi___1)(); 225 __attribute__ ((used,used,unused,used,used)) const signed int (*__vd8__PFCi___1)(); 226 __attribute__ ((unused,used)) signed int __f1__Fi___1(); 227 __attribute__ ((unused)) signed int __f1__Fi___1(){ 228 __attribute__ ((unused)) signed int ___retval_f1__i_1; 229 } 230 __attribute__ ((unused,unused,unused,used)) signed int **const __f2__FCPPi___1(); 231 __attribute__ ((unused,unused,unused)) signed int **const __f2__FCPPi___1(){ 232 __attribute__ ((unused)) signed int **const ___retval_f2__CPPi_1; 233 } 234 __attribute__ ((unused,used,unused)) signed int (*__f3__FPA0i_i__1(signed int __anonymous_object1))[]; 235 __attribute__ ((unused,unused)) signed int (*__f3__FPA0i_i__1(signed int __p__i_1))[]{ 236 __attribute__ ((unused)) signed int (*___retval_f3__PA0i_1)[]; 237 } 238 __attribute__ ((unused,used,unused)) signed int (*__f4__FPFi_i____1())(signed int __anonymous_object2); 239 __attribute__ ((unused,unused)) signed int (*__f4__FPFi_i____1())(signed int __anonymous_object3){ 240 __attribute__ ((unused)) signed int (*___retval_f4__PFi_i__1)(signed int __anonymous_object4); 241 } 242 signed int __vtr__Fi___1(){ 243 __attribute__ ((unused)) signed int ___retval_vtr__i_1; 244 __attribute__ ((unused,unused,used)) signed int __t1__i_2; 245 __attribute__ ((unused,unused,unused,unused,unused)) signed int **__t2__PPi_2; 246 __attribute__ ((unused,unused,unused)) signed int __t3__A0i_2[((unsigned int )5)]; 247 __attribute__ ((unused,unused,unused,unused,unused)) signed int **__t4__A0PPi_2[((unsigned int )5)]; 248 __attribute__ ((unused,unused,unused)) signed int __t5__Fi___2(); 249 __attribute__ ((unused,unused,unused,unused)) signed int *__t6__FPi___2(); 250 } 251 signed int __ipd1__Fi_ii__1(__attribute__ ((unused,unused,unused)) signed int __p__i_1, __attribute__ ((unused,unused,unused)) signed int __q__i_1); 252 signed int __ipd1__Fi_ii__1(__attribute__ ((unused,unused,unused)) signed int __p__i_1, __attribute__ ((unused,unused,unused)) signed int __q__i_1){ 253 __attribute__ ((unused)) signed int ___retval_ipd1__i_1; 254 } 255 signed int __ipd2__Fi_PiPi__1(__attribute__ ((unused,unused,unused,unused)) signed int *__p__Pi_1, __attribute__ ((unused,unused,unused)) signed int *__q__Pi_1); 256 signed int __ipd2__Fi_PiPi__1(__attribute__ ((unused,unused,unused,unused)) signed int *__p__Pi_1, __attribute__ ((unused,unused,unused)) signed int *__q__Pi_1){ 257 __attribute__ ((unused)) signed int ___retval_ipd2__i_1; 258 } 259 signed int __ipd3__Fi_PiPi__1(__attribute__ ((unused,unused,unused)) signed int *__p__Pi_1, __attribute__ ((unused,unused,unused)) signed int *__q__Pi_1); 260 signed int __ipd3__Fi_PiPi__1(__attribute__ ((unused,unused,unused)) signed int *__p__Pi_1, __attribute__ ((unused,unused,unused)) signed int *__q__Pi_1){ 261 __attribute__ ((unused)) signed int ___retval_ipd3__i_1; 262 } 263 signed int __ipd4__Fi_PFi__PFi____1(__attribute__ ((unused,unused,unused)) signed int (*__p__PFi___1)(), __attribute__ ((unused,unused,unused)) signed int (*__q__PFi___1)()); 264 signed int __ipd4__Fi_PFi__PFi____1(__attribute__ ((unused,unused,unused)) signed int (*__p__PFi___1)(), __attribute__ ((unused,unused,unused)) signed int (*__q__PFi___1)()){ 265 __attribute__ ((unused)) signed int ___retval_ipd4__i_1; 266 } 267 signed int __tpr1__Fi_i__1(__attribute__ ((unused,unused,unused)) signed int __Foo__i_1); 268 signed int __tpr2__Fi_PPi__1(__attribute__ ((unused,unused,unused,unused,unused,unused)) signed int **__Foo__PPi_1); 269 signed int __tpr3__Fi_Pi__1(__attribute__ ((unused,unused,unused)) signed int *__Foo__Pi_1); 270 signed int __tpr4__Fi_PFi_Pi___1(__attribute__ ((unused,unused)) signed int (*__anonymous_object5)(__attribute__ ((unused,unused)) signed int __anonymous_object6[((unsigned int )5)])); 271 signed int __tpr5__Fi_PFi____1(__attribute__ ((unused,unused,unused)) signed int (*__Foo__PFi___1)()); 272 signed int __tpr6__Fi_PFi____1(__attribute__ ((unused,unused,unused)) signed int (*__Foo__PFi___1)()); 273 signed int __tpr7__Fi_PFi_PFi_i____1(__attribute__ ((unused,unused)) signed int (*__anonymous_object7)(__attribute__ ((unused)) signed int (*__anonymous_object8)(__attribute__ ((unused,unused)) signed int __anonymous_object9))); 274 signed int __ad__Fi___1(){ 275 __attribute__ ((unused)) signed int ___retval_ad__i_1; 276 __attribute__ ((used,unused)) signed int __ad1__i_2; 277 __attribute__ ((unused,unused,unused)) signed int *__ad2__Pi_2; 278 __attribute__ ((unused,unused,unused)) signed int __ad3__A0i_2[((unsigned int )5)]; 279 __attribute__ ((unused,unused,unused,unused,unused)) signed int (*__ad4__PA0i_2)[((unsigned int )10)]; 280 __attribute__ ((unused,unused,unused,unused,used)) signed int __ad5__i_2; 281 __attribute__ ((unused,unused,unused,unused,unused)) signed int __ad6__Fi___2(); 282 ((void)sizeof(__attribute__ ((unused,unused)) signed int )); 283 ((void)sizeof(__attribute__ ((unused,unused,unused,unused)) signed int **)); 284 ((void)sizeof(__attribute__ ((unused,unused,unused)) signed int [5])); 285 ((void)sizeof(__attribute__ ((unused,unused,unused)) signed int (*)[10])); 286 ((void)sizeof(__attribute__ ((unused,unused,unused)) signed int ())); 287 287 __attribute__ ((unused)) struct __anonymous4 { 288 int __i__i_2;288 signed int __i__i_2; 289 289 }; 290 290 inline void ___constructor__F_R13s__anonymous4_autogen___2(struct __anonymous4 *___dst__R13s__anonymous4_2){ … … 303 303 return ((struct __anonymous4 )___ret__13s__anonymous4_2); 304 304 } 305 inline void ___constructor__F_R13s__anonymous4i_autogen___2(struct __anonymous4 *___dst__R13s__anonymous4_2, int __i__i_2){305 inline void ___constructor__F_R13s__anonymous4i_autogen___2(struct __anonymous4 *___dst__R13s__anonymous4_2, signed int __i__i_2){ 306 306 ((void)((*___dst__R13s__anonymous4_2).__i__i_2=__i__i_2) /* ?{} */); 307 307 } … … 324 324 ((void)sizeof(enum __anonymous5 )); 325 325 } 326 int __apd1__Fi_PiPi__1(__attribute__ ((unused,unused,unused)) int *__anonymous_object10, __attribute__ ((unused,unused,unused))int *__anonymous_object11);327 int __apd2__Fi_PPiPPi__1(__attribute__ ((unused,unused,unused,unused)) int **__anonymous_object12, __attribute__ ((unused,unused,unused,unused))int **__anonymous_object13);328 int __apd3__Fi_PiPi__1(__attribute__ ((unused,unused,unused)) int *__anonymous_object14, __attribute__ ((unused,unused,unused))int *__anonymous_object15);329 int __apd4__Fi_PFi__PFi____1(__attribute__ ((unused,unused,unused)) int (*__anonymous_object16)(), __attribute__ ((unused,unused,unused))int (*__anonymous_object17)());330 int __apd5__Fi_PFi_i_PFi_i___1(__attribute__ ((unused,unused,unused)) int (*__anonymous_object18)(__attribute__ ((unused)) int __anonymous_object19), __attribute__ ((unused,unused,unused)) int (*__anonymous_object20)(__attribute__ ((unused))int __anonymous_object21));331 int __apd6__Fi_PFi__PFi____1(__attribute__ ((unused,unused,unused)) int (*__anonymous_object22)(), __attribute__ ((unused,unused,unused))int (*__anonymous_object23)());332 int __apd7__Fi_PFi_i_PFi_i___1(__attribute__ ((unused,unused,unused)) int (*__anonymous_object24)(__attribute__ ((unused)) int __anonymous_object25), __attribute__ ((unused,unused,unused)) int (*__anonymous_object26)(__attribute__ ((unused))int __anonymous_object27));326 signed int __apd1__Fi_PiPi__1(__attribute__ ((unused,unused,unused)) signed int *__anonymous_object10, __attribute__ ((unused,unused,unused)) signed int *__anonymous_object11); 327 signed int __apd2__Fi_PPiPPi__1(__attribute__ ((unused,unused,unused,unused)) signed int **__anonymous_object12, __attribute__ ((unused,unused,unused,unused)) signed int **__anonymous_object13); 328 signed int __apd3__Fi_PiPi__1(__attribute__ ((unused,unused,unused)) signed int *__anonymous_object14, __attribute__ ((unused,unused,unused)) signed int *__anonymous_object15); 329 signed int __apd4__Fi_PFi__PFi____1(__attribute__ ((unused,unused,unused)) signed int (*__anonymous_object16)(), __attribute__ ((unused,unused,unused)) signed int (*__anonymous_object17)()); 330 signed int __apd5__Fi_PFi_i_PFi_i___1(__attribute__ ((unused,unused,unused)) signed int (*__anonymous_object18)(__attribute__ ((unused)) signed int __anonymous_object19), __attribute__ ((unused,unused,unused)) signed int (*__anonymous_object20)(__attribute__ ((unused)) signed int __anonymous_object21)); 331 signed int __apd6__Fi_PFi__PFi____1(__attribute__ ((unused,unused,unused)) signed int (*__anonymous_object22)(), __attribute__ ((unused,unused,unused)) signed int (*__anonymous_object23)()); 332 signed int __apd7__Fi_PFi_i_PFi_i___1(__attribute__ ((unused,unused,unused)) signed int (*__anonymous_object24)(__attribute__ ((unused)) signed int __anonymous_object25), __attribute__ ((unused,unused,unused)) signed int (*__anonymous_object26)(__attribute__ ((unused)) signed int __anonymous_object27)); 333 333 struct Vad { 334 __attribute__ ((unused)) int __anonymous_object28;335 __attribute__ ((unused,unused)) int *__anonymous_object29;336 __attribute__ ((unused,unused)) int __anonymous_object30[((unsigned int )10)];337 __attribute__ ((unused,unused)) int (*__anonymous_object31)();334 __attribute__ ((unused)) signed int __anonymous_object28; 335 __attribute__ ((unused,unused)) signed int *__anonymous_object29; 336 __attribute__ ((unused,unused)) signed int __anonymous_object30[((unsigned int )10)]; 337 __attribute__ ((unused,unused)) signed int (*__anonymous_object31)(); 338 338 }; 339 339 static inline void ___constructor__F_R4sVad_autogen___1(struct Vad *___dst__R4sVad_1); -
src/tests/.expect/32/declarationSpecifier.txt
rb2e2e34 rc935c3a 2 2 __attribute__ ((__nothrow__,__leaf__)) extern void free(void *__ptr); 3 3 __attribute__ ((__nothrow__,__leaf__,__noreturn__)) extern void abort(void); 4 __attribute__ ((__nothrow__,__leaf__,__nonnull__(1))) extern int atexit(void (*__func)(void));5 __attribute__ ((__nothrow__,__leaf__,__noreturn__)) extern void exit( int __status);6 extern int printf(const char *__restrict __format, ...);7 volatile const s hort __x1__CVs_1;8 static volatile const s hort __x2__CVs_1;9 static volatile const s hort __x3__CVs_1;10 static volatile const s hort __x4__CVs_1;11 static volatile const s hort __x5__CVs_1;12 static volatile const s hort __x6__CVs_1;13 static volatile const s hort __x7__CVs_1;14 static volatile const s hort __x8__CVs_1;4 __attribute__ ((__nothrow__,__leaf__,__nonnull__(1))) extern signed int atexit(void (*__func)(void)); 5 __attribute__ ((__nothrow__,__leaf__,__noreturn__)) extern void exit(signed int __status); 6 extern signed int printf(const char *__restrict __format, ...); 7 volatile const signed short int __x1__CVs_1; 8 static volatile const signed short int __x2__CVs_1; 9 static volatile const signed short int __x3__CVs_1; 10 static volatile const signed short int __x4__CVs_1; 11 static volatile const signed short int __x5__CVs_1; 12 static volatile const signed short int __x6__CVs_1; 13 static volatile const signed short int __x7__CVs_1; 14 static volatile const signed short int __x8__CVs_1; 15 15 struct __anonymous0 { 16 int __i__i_1;16 signed int __i__i_1; 17 17 }; 18 18 static inline void ___constructor__F_R13s__anonymous0_autogen___1(struct __anonymous0 *___dst__R13s__anonymous0_1); … … 35 35 return ((struct __anonymous0 )___ret__13s__anonymous0_1); 36 36 } 37 static inline void ___constructor__F_R13s__anonymous0i_autogen___1(struct __anonymous0 *___dst__R13s__anonymous0_1, int __i__i_1){37 static inline void ___constructor__F_R13s__anonymous0i_autogen___1(struct __anonymous0 *___dst__R13s__anonymous0_1, signed int __i__i_1){ 38 38 ((void)((*___dst__R13s__anonymous0_1).__i__i_1=__i__i_1) /* ?{} */); 39 39 } 40 40 volatile const struct __anonymous0 __x10__CV13s__anonymous0_1; 41 41 struct __anonymous1 { 42 int __i__i_1;42 signed int __i__i_1; 43 43 }; 44 44 static inline void ___constructor__F_R13s__anonymous1_autogen___1(struct __anonymous1 *___dst__R13s__anonymous1_1); … … 61 61 return ((struct __anonymous1 )___ret__13s__anonymous1_1); 62 62 } 63 static inline void ___constructor__F_R13s__anonymous1i_autogen___1(struct __anonymous1 *___dst__R13s__anonymous1_1, int __i__i_1){63 static inline void ___constructor__F_R13s__anonymous1i_autogen___1(struct __anonymous1 *___dst__R13s__anonymous1_1, signed int __i__i_1){ 64 64 ((void)((*___dst__R13s__anonymous1_1).__i__i_1=__i__i_1) /* ?{} */); 65 65 } 66 66 volatile const struct __anonymous1 __x11__CV13s__anonymous1_1; 67 67 struct __anonymous2 { 68 int __i__i_1;68 signed int __i__i_1; 69 69 }; 70 70 static inline void ___constructor__F_R13s__anonymous2_autogen___1(struct __anonymous2 *___dst__R13s__anonymous2_1); … … 87 87 return ((struct __anonymous2 )___ret__13s__anonymous2_1); 88 88 } 89 static inline void ___constructor__F_R13s__anonymous2i_autogen___1(struct __anonymous2 *___dst__R13s__anonymous2_1, int __i__i_1){89 static inline void ___constructor__F_R13s__anonymous2i_autogen___1(struct __anonymous2 *___dst__R13s__anonymous2_1, signed int __i__i_1){ 90 90 ((void)((*___dst__R13s__anonymous2_1).__i__i_1=__i__i_1) /* ?{} */); 91 91 } 92 92 volatile const struct __anonymous2 __x12__CV13s__anonymous2_1; 93 93 struct __anonymous3 { 94 int __i__i_1;94 signed int __i__i_1; 95 95 }; 96 96 static inline void ___constructor__F_R13s__anonymous3_autogen___1(struct __anonymous3 *___dst__R13s__anonymous3_1); … … 113 113 return ((struct __anonymous3 )___ret__13s__anonymous3_1); 114 114 } 115 static inline void ___constructor__F_R13s__anonymous3i_autogen___1(struct __anonymous3 *___dst__R13s__anonymous3_1, int __i__i_1){115 static inline void ___constructor__F_R13s__anonymous3i_autogen___1(struct __anonymous3 *___dst__R13s__anonymous3_1, signed int __i__i_1){ 116 116 ((void)((*___dst__R13s__anonymous3_1).__i__i_1=__i__i_1) /* ?{} */); 117 117 } 118 118 static volatile const struct __anonymous3 __x13__CV13s__anonymous3_1; 119 119 struct __anonymous4 { 120 int __i__i_1;120 signed int __i__i_1; 121 121 }; 122 122 static inline void ___constructor__F_R13s__anonymous4_autogen___1(struct __anonymous4 *___dst__R13s__anonymous4_1); … … 139 139 return ((struct __anonymous4 )___ret__13s__anonymous4_1); 140 140 } 141 static inline void ___constructor__F_R13s__anonymous4i_autogen___1(struct __anonymous4 *___dst__R13s__anonymous4_1, int __i__i_1){141 static inline void ___constructor__F_R13s__anonymous4i_autogen___1(struct __anonymous4 *___dst__R13s__anonymous4_1, signed int __i__i_1){ 142 142 ((void)((*___dst__R13s__anonymous4_1).__i__i_1=__i__i_1) /* ?{} */); 143 143 } 144 144 static volatile const struct __anonymous4 __x14__CV13s__anonymous4_1; 145 145 struct __anonymous5 { 146 int __i__i_1;146 signed int __i__i_1; 147 147 }; 148 148 static inline void ___constructor__F_R13s__anonymous5_autogen___1(struct __anonymous5 *___dst__R13s__anonymous5_1); … … 165 165 return ((struct __anonymous5 )___ret__13s__anonymous5_1); 166 166 } 167 static inline void ___constructor__F_R13s__anonymous5i_autogen___1(struct __anonymous5 *___dst__R13s__anonymous5_1, int __i__i_1){167 static inline void ___constructor__F_R13s__anonymous5i_autogen___1(struct __anonymous5 *___dst__R13s__anonymous5_1, signed int __i__i_1){ 168 168 ((void)((*___dst__R13s__anonymous5_1).__i__i_1=__i__i_1) /* ?{} */); 169 169 } 170 170 static volatile const struct __anonymous5 __x15__CV13s__anonymous5_1; 171 171 struct __anonymous6 { 172 int __i__i_1;172 signed int __i__i_1; 173 173 }; 174 174 static inline void ___constructor__F_R13s__anonymous6_autogen___1(struct __anonymous6 *___dst__R13s__anonymous6_1); … … 191 191 return ((struct __anonymous6 )___ret__13s__anonymous6_1); 192 192 } 193 static inline void ___constructor__F_R13s__anonymous6i_autogen___1(struct __anonymous6 *___dst__R13s__anonymous6_1, int __i__i_1){193 static inline void ___constructor__F_R13s__anonymous6i_autogen___1(struct __anonymous6 *___dst__R13s__anonymous6_1, signed int __i__i_1){ 194 194 ((void)((*___dst__R13s__anonymous6_1).__i__i_1=__i__i_1) /* ?{} */); 195 195 } 196 196 static volatile const struct __anonymous6 __x16__CV13s__anonymous6_1; 197 197 struct __anonymous7 { 198 int __i__i_1;198 signed int __i__i_1; 199 199 }; 200 200 static inline void ___constructor__F_R13s__anonymous7_autogen___1(struct __anonymous7 *___dst__R13s__anonymous7_1); … … 217 217 return ((struct __anonymous7 )___ret__13s__anonymous7_1); 218 218 } 219 static inline void ___constructor__F_R13s__anonymous7i_autogen___1(struct __anonymous7 *___dst__R13s__anonymous7_1, int __i__i_1){219 static inline void ___constructor__F_R13s__anonymous7i_autogen___1(struct __anonymous7 *___dst__R13s__anonymous7_1, signed int __i__i_1){ 220 220 ((void)((*___dst__R13s__anonymous7_1).__i__i_1=__i__i_1) /* ?{} */); 221 221 } 222 222 static volatile const struct __anonymous7 __x17__CV13s__anonymous7_1; 223 volatile const s hort __x20__CVs_1;224 static volatile const s hort __x21__CVs_1;225 static volatile const s hort __x22__CVs_1;226 static volatile const s hort __x23__CVs_1;227 static volatile const s hort __x24__CVs_1;228 static volatile const s hort __x25__CVs_1;229 static volatile const s hort __x26__CVs_1;230 static volatile const s hort __x27__CVs_1;223 volatile const signed short int __x20__CVs_1; 224 static volatile const signed short int __x21__CVs_1; 225 static volatile const signed short int __x22__CVs_1; 226 static volatile const signed short int __x23__CVs_1; 227 static volatile const signed short int __x24__CVs_1; 228 static volatile const signed short int __x25__CVs_1; 229 static volatile const signed short int __x26__CVs_1; 230 static volatile const signed short int __x27__CVs_1; 231 231 struct __anonymous8 { 232 s hort __i__s_1;232 signed short int __i__s_1; 233 233 }; 234 234 static inline void ___constructor__F_R13s__anonymous8_autogen___1(struct __anonymous8 *___dst__R13s__anonymous8_1); … … 251 251 return ((struct __anonymous8 )___ret__13s__anonymous8_1); 252 252 } 253 static inline void ___constructor__F_R13s__anonymous8s_autogen___1(struct __anonymous8 *___dst__R13s__anonymous8_1, s hort __i__s_1){253 static inline void ___constructor__F_R13s__anonymous8s_autogen___1(struct __anonymous8 *___dst__R13s__anonymous8_1, signed short int __i__s_1){ 254 254 ((void)((*___dst__R13s__anonymous8_1).__i__s_1=__i__s_1) /* ?{} */); 255 255 } 256 256 volatile const struct __anonymous8 __x29__CV13s__anonymous8_1; 257 257 struct __anonymous9 { 258 s hort __i__s_1;258 signed short int __i__s_1; 259 259 }; 260 260 static inline void ___constructor__F_R13s__anonymous9_autogen___1(struct __anonymous9 *___dst__R13s__anonymous9_1); … … 277 277 return ((struct __anonymous9 )___ret__13s__anonymous9_1); 278 278 } 279 static inline void ___constructor__F_R13s__anonymous9s_autogen___1(struct __anonymous9 *___dst__R13s__anonymous9_1, s hort __i__s_1){279 static inline void ___constructor__F_R13s__anonymous9s_autogen___1(struct __anonymous9 *___dst__R13s__anonymous9_1, signed short int __i__s_1){ 280 280 ((void)((*___dst__R13s__anonymous9_1).__i__s_1=__i__s_1) /* ?{} */); 281 281 } 282 282 volatile const struct __anonymous9 __x30__CV13s__anonymous9_1; 283 283 struct __anonymous10 { 284 s hort __i__s_1;284 signed short int __i__s_1; 285 285 }; 286 286 static inline void ___constructor__F_R14s__anonymous10_autogen___1(struct __anonymous10 *___dst__R14s__anonymous10_1); … … 303 303 return ((struct __anonymous10 )___ret__14s__anonymous10_1); 304 304 } 305 static inline void ___constructor__F_R14s__anonymous10s_autogen___1(struct __anonymous10 *___dst__R14s__anonymous10_1, s hort __i__s_1){305 static inline void ___constructor__F_R14s__anonymous10s_autogen___1(struct __anonymous10 *___dst__R14s__anonymous10_1, signed short int __i__s_1){ 306 306 ((void)((*___dst__R14s__anonymous10_1).__i__s_1=__i__s_1) /* ?{} */); 307 307 } 308 308 volatile const struct __anonymous10 __x31__CV14s__anonymous10_1; 309 309 struct __anonymous11 { 310 s hort __i__s_1;310 signed short int __i__s_1; 311 311 }; 312 312 static inline void ___constructor__F_R14s__anonymous11_autogen___1(struct __anonymous11 *___dst__R14s__anonymous11_1); … … 329 329 return ((struct __anonymous11 )___ret__14s__anonymous11_1); 330 330 } 331 static inline void ___constructor__F_R14s__anonymous11s_autogen___1(struct __anonymous11 *___dst__R14s__anonymous11_1, s hort __i__s_1){331 static inline void ___constructor__F_R14s__anonymous11s_autogen___1(struct __anonymous11 *___dst__R14s__anonymous11_1, signed short int __i__s_1){ 332 332 ((void)((*___dst__R14s__anonymous11_1).__i__s_1=__i__s_1) /* ?{} */); 333 333 } 334 334 static volatile const struct __anonymous11 __x32__CV14s__anonymous11_1; 335 335 struct __anonymous12 { 336 s hort __i__s_1;336 signed short int __i__s_1; 337 337 }; 338 338 static inline void ___constructor__F_R14s__anonymous12_autogen___1(struct __anonymous12 *___dst__R14s__anonymous12_1); … … 355 355 return ((struct __anonymous12 )___ret__14s__anonymous12_1); 356 356 } 357 static inline void ___constructor__F_R14s__anonymous12s_autogen___1(struct __anonymous12 *___dst__R14s__anonymous12_1, s hort __i__s_1){357 static inline void ___constructor__F_R14s__anonymous12s_autogen___1(struct __anonymous12 *___dst__R14s__anonymous12_1, signed short int __i__s_1){ 358 358 ((void)((*___dst__R14s__anonymous12_1).__i__s_1=__i__s_1) /* ?{} */); 359 359 } 360 360 static volatile const struct __anonymous12 __x33__CV14s__anonymous12_1; 361 361 struct __anonymous13 { 362 s hort __i__s_1;362 signed short int __i__s_1; 363 363 }; 364 364 static inline void ___constructor__F_R14s__anonymous13_autogen___1(struct __anonymous13 *___dst__R14s__anonymous13_1); … … 381 381 return ((struct __anonymous13 )___ret__14s__anonymous13_1); 382 382 } 383 static inline void ___constructor__F_R14s__anonymous13s_autogen___1(struct __anonymous13 *___dst__R14s__anonymous13_1, s hort __i__s_1){383 static inline void ___constructor__F_R14s__anonymous13s_autogen___1(struct __anonymous13 *___dst__R14s__anonymous13_1, signed short int __i__s_1){ 384 384 ((void)((*___dst__R14s__anonymous13_1).__i__s_1=__i__s_1) /* ?{} */); 385 385 } 386 386 static volatile const struct __anonymous13 __x34__CV14s__anonymous13_1; 387 387 struct __anonymous14 { 388 s hort __i__s_1;388 signed short int __i__s_1; 389 389 }; 390 390 static inline void ___constructor__F_R14s__anonymous14_autogen___1(struct __anonymous14 *___dst__R14s__anonymous14_1); … … 407 407 return ((struct __anonymous14 )___ret__14s__anonymous14_1); 408 408 } 409 static inline void ___constructor__F_R14s__anonymous14s_autogen___1(struct __anonymous14 *___dst__R14s__anonymous14_1, s hort __i__s_1){409 static inline void ___constructor__F_R14s__anonymous14s_autogen___1(struct __anonymous14 *___dst__R14s__anonymous14_1, signed short int __i__s_1){ 410 410 ((void)((*___dst__R14s__anonymous14_1).__i__s_1=__i__s_1) /* ?{} */); 411 411 } 412 412 static volatile const struct __anonymous14 __x35__CV14s__anonymous14_1; 413 413 struct __anonymous15 { 414 s hort __i__s_1;414 signed short int __i__s_1; 415 415 }; 416 416 static inline void ___constructor__F_R14s__anonymous15_autogen___1(struct __anonymous15 *___dst__R14s__anonymous15_1); … … 433 433 return ((struct __anonymous15 )___ret__14s__anonymous15_1); 434 434 } 435 static inline void ___constructor__F_R14s__anonymous15s_autogen___1(struct __anonymous15 *___dst__R14s__anonymous15_1, s hort __i__s_1){435 static inline void ___constructor__F_R14s__anonymous15s_autogen___1(struct __anonymous15 *___dst__R14s__anonymous15_1, signed short int __i__s_1){ 436 436 ((void)((*___dst__R14s__anonymous15_1).__i__s_1=__i__s_1) /* ?{} */); 437 437 } 438 438 static volatile const struct __anonymous15 __x36__CV14s__anonymous15_1; 439 static inline volatile const int __f11__FCVi___1();440 static inline volatile const int __f12__FCVi___1();441 static inline volatile const int __f13__FCVi___1();442 static inline volatile const int __f14__FCVi___1();443 static inline volatile const int __f15__FCVi___1();444 static inline volatile const int __f16__FCVi___1();445 static inline volatile const int __f17__FCVi___1();446 static inline volatile const int __f18__FCVi___1();447 static inline volatile const s hort __f21__FCVs___1();448 static inline volatile const s hort __f22__FCVs___1();449 static inline volatile const s hort __f23__FCVs___1();450 static inline volatile const s hort __f24__FCVs___1();451 static inline volatile const s hort __f25__FCVs___1();452 static inline volatile const s hort __f26__FCVs___1();453 static inline volatile const s hort __f27__FCVs___1();454 static inline volatile const s hort __f28__FCVs___1();439 static inline volatile const signed int __f11__FCVi___1(); 440 static inline volatile const signed int __f12__FCVi___1(); 441 static inline volatile const signed int __f13__FCVi___1(); 442 static inline volatile const signed int __f14__FCVi___1(); 443 static inline volatile const signed int __f15__FCVi___1(); 444 static inline volatile const signed int __f16__FCVi___1(); 445 static inline volatile const signed int __f17__FCVi___1(); 446 static inline volatile const signed int __f18__FCVi___1(); 447 static inline volatile const signed short int __f21__FCVs___1(); 448 static inline volatile const signed short int __f22__FCVs___1(); 449 static inline volatile const signed short int __f23__FCVs___1(); 450 static inline volatile const signed short int __f24__FCVs___1(); 451 static inline volatile const signed short int __f25__FCVs___1(); 452 static inline volatile const signed short int __f26__FCVs___1(); 453 static inline volatile const signed short int __f27__FCVs___1(); 454 static inline volatile const signed short int __f28__FCVs___1(); 455 455 struct __anonymous16 { 456 int __i__i_1;456 signed int __i__i_1; 457 457 }; 458 458 static inline void ___constructor__F_R14s__anonymous16_autogen___1(struct __anonymous16 *___dst__R14s__anonymous16_1); … … 475 475 return ((struct __anonymous16 )___ret__14s__anonymous16_1); 476 476 } 477 static inline void ___constructor__F_R14s__anonymous16i_autogen___1(struct __anonymous16 *___dst__R14s__anonymous16_1, int __i__i_1){477 static inline void ___constructor__F_R14s__anonymous16i_autogen___1(struct __anonymous16 *___dst__R14s__anonymous16_1, signed int __i__i_1){ 478 478 ((void)((*___dst__R14s__anonymous16_1).__i__i_1=__i__i_1) /* ?{} */); 479 479 } 480 480 static inline volatile const struct __anonymous16 __f31__FCV14s__anonymous16___1(); 481 481 struct __anonymous17 { 482 int __i__i_1;482 signed int __i__i_1; 483 483 }; 484 484 static inline void ___constructor__F_R14s__anonymous17_autogen___1(struct __anonymous17 *___dst__R14s__anonymous17_1); … … 501 501 return ((struct __anonymous17 )___ret__14s__anonymous17_1); 502 502 } 503 static inline void ___constructor__F_R14s__anonymous17i_autogen___1(struct __anonymous17 *___dst__R14s__anonymous17_1, int __i__i_1){503 static inline void ___constructor__F_R14s__anonymous17i_autogen___1(struct __anonymous17 *___dst__R14s__anonymous17_1, signed int __i__i_1){ 504 504 ((void)((*___dst__R14s__anonymous17_1).__i__i_1=__i__i_1) /* ?{} */); 505 505 } 506 506 static inline volatile const struct __anonymous17 __f32__FCV14s__anonymous17___1(); 507 507 struct __anonymous18 { 508 int __i__i_1;508 signed int __i__i_1; 509 509 }; 510 510 static inline void ___constructor__F_R14s__anonymous18_autogen___1(struct __anonymous18 *___dst__R14s__anonymous18_1); … … 527 527 return ((struct __anonymous18 )___ret__14s__anonymous18_1); 528 528 } 529 static inline void ___constructor__F_R14s__anonymous18i_autogen___1(struct __anonymous18 *___dst__R14s__anonymous18_1, int __i__i_1){529 static inline void ___constructor__F_R14s__anonymous18i_autogen___1(struct __anonymous18 *___dst__R14s__anonymous18_1, signed int __i__i_1){ 530 530 ((void)((*___dst__R14s__anonymous18_1).__i__i_1=__i__i_1) /* ?{} */); 531 531 } 532 532 static inline volatile const struct __anonymous18 __f33__FCV14s__anonymous18___1(); 533 533 struct __anonymous19 { 534 int __i__i_1;534 signed int __i__i_1; 535 535 }; 536 536 static inline void ___constructor__F_R14s__anonymous19_autogen___1(struct __anonymous19 *___dst__R14s__anonymous19_1); … … 553 553 return ((struct __anonymous19 )___ret__14s__anonymous19_1); 554 554 } 555 static inline void ___constructor__F_R14s__anonymous19i_autogen___1(struct __anonymous19 *___dst__R14s__anonymous19_1, int __i__i_1){555 static inline void ___constructor__F_R14s__anonymous19i_autogen___1(struct __anonymous19 *___dst__R14s__anonymous19_1, signed int __i__i_1){ 556 556 ((void)((*___dst__R14s__anonymous19_1).__i__i_1=__i__i_1) /* ?{} */); 557 557 } 558 558 static inline volatile const struct __anonymous19 __f34__FCV14s__anonymous19___1(); 559 559 struct __anonymous20 { 560 int __i__i_1;560 signed int __i__i_1; 561 561 }; 562 562 static inline void ___constructor__F_R14s__anonymous20_autogen___1(struct __anonymous20 *___dst__R14s__anonymous20_1); … … 579 579 return ((struct __anonymous20 )___ret__14s__anonymous20_1); 580 580 } 581 static inline void ___constructor__F_R14s__anonymous20i_autogen___1(struct __anonymous20 *___dst__R14s__anonymous20_1, int __i__i_1){581 static inline void ___constructor__F_R14s__anonymous20i_autogen___1(struct __anonymous20 *___dst__R14s__anonymous20_1, signed int __i__i_1){ 582 582 ((void)((*___dst__R14s__anonymous20_1).__i__i_1=__i__i_1) /* ?{} */); 583 583 } 584 584 static inline volatile const struct __anonymous20 __f35__FCV14s__anonymous20___1(); 585 585 struct __anonymous21 { 586 int __i__i_1;586 signed int __i__i_1; 587 587 }; 588 588 static inline void ___constructor__F_R14s__anonymous21_autogen___1(struct __anonymous21 *___dst__R14s__anonymous21_1); … … 605 605 return ((struct __anonymous21 )___ret__14s__anonymous21_1); 606 606 } 607 static inline void ___constructor__F_R14s__anonymous21i_autogen___1(struct __anonymous21 *___dst__R14s__anonymous21_1, int __i__i_1){607 static inline void ___constructor__F_R14s__anonymous21i_autogen___1(struct __anonymous21 *___dst__R14s__anonymous21_1, signed int __i__i_1){ 608 608 ((void)((*___dst__R14s__anonymous21_1).__i__i_1=__i__i_1) /* ?{} */); 609 609 } 610 610 static inline volatile const struct __anonymous21 __f36__FCV14s__anonymous21___1(); 611 611 struct __anonymous22 { 612 int __i__i_1;612 signed int __i__i_1; 613 613 }; 614 614 static inline void ___constructor__F_R14s__anonymous22_autogen___1(struct __anonymous22 *___dst__R14s__anonymous22_1); … … 631 631 return ((struct __anonymous22 )___ret__14s__anonymous22_1); 632 632 } 633 static inline void ___constructor__F_R14s__anonymous22i_autogen___1(struct __anonymous22 *___dst__R14s__anonymous22_1, int __i__i_1){633 static inline void ___constructor__F_R14s__anonymous22i_autogen___1(struct __anonymous22 *___dst__R14s__anonymous22_1, signed int __i__i_1){ 634 634 ((void)((*___dst__R14s__anonymous22_1).__i__i_1=__i__i_1) /* ?{} */); 635 635 } 636 636 static inline volatile const struct __anonymous22 __f37__FCV14s__anonymous22___1(); 637 637 struct __anonymous23 { 638 int __i__i_1;638 signed int __i__i_1; 639 639 }; 640 640 static inline void ___constructor__F_R14s__anonymous23_autogen___1(struct __anonymous23 *___dst__R14s__anonymous23_1); … … 657 657 return ((struct __anonymous23 )___ret__14s__anonymous23_1); 658 658 } 659 static inline void ___constructor__F_R14s__anonymous23i_autogen___1(struct __anonymous23 *___dst__R14s__anonymous23_1, int __i__i_1){659 static inline void ___constructor__F_R14s__anonymous23i_autogen___1(struct __anonymous23 *___dst__R14s__anonymous23_1, signed int __i__i_1){ 660 660 ((void)((*___dst__R14s__anonymous23_1).__i__i_1=__i__i_1) /* ?{} */); 661 661 } 662 662 static inline volatile const struct __anonymous23 __f38__FCV14s__anonymous23___1(); 663 static inline volatile const s hort __f41__FCVs___1();664 static inline volatile const s hort __f42__FCVs___1();665 static inline volatile const s hort __f43__FCVs___1();666 static inline volatile const s hort __f44__FCVs___1();667 static inline volatile const s hort __f45__FCVs___1();668 static inline volatile const s hort __f46__FCVs___1();669 static inline volatile const s hort __f47__FCVs___1();670 static inline volatile const s hort __f48__FCVs___1();671 int __main__Fi_iPPCc__1(int __argc__i_1, const char **__argv__PPCc_1){672 __attribute__ ((unused)) int ___retval_main__i_1;673 ((void)(___retval_main__i_1=(( int )0)) /* ?{} */);674 return (( int )___retval_main__i_1);663 static inline volatile const signed short int __f41__FCVs___1(); 664 static inline volatile const signed short int __f42__FCVs___1(); 665 static inline volatile const signed short int __f43__FCVs___1(); 666 static inline volatile const signed short int __f44__FCVs___1(); 667 static inline volatile const signed short int __f45__FCVs___1(); 668 static inline volatile const signed short int __f46__FCVs___1(); 669 static inline volatile const signed short int __f47__FCVs___1(); 670 static inline volatile const signed short int __f48__FCVs___1(); 671 signed int __main__Fi_iPPCc__1(signed int __argc__i_1, const char **__argv__PPCc_1){ 672 __attribute__ ((unused)) signed int ___retval_main__i_1; 673 ((void)(___retval_main__i_1=((signed int )0)) /* ?{} */); 674 return ((signed int )___retval_main__i_1); 675 675 ((void)(___retval_main__i_1=0) /* ?{} */); 676 return (( int )___retval_main__i_1);676 return ((signed int )___retval_main__i_1); 677 677 } 678 678 static inline int invoke_main(int argc, char* argv[], char* envp[]) { (void)argc; (void)argv; (void)envp; return __main__Fi_iPPCc__1(argc, argv); } … … 680 680 __attribute__ ((__nothrow__,__leaf__)) extern void free(void *__ptr); 681 681 __attribute__ ((__nothrow__,__leaf__,__noreturn__)) extern void abort(void); 682 __attribute__ ((__nothrow__,__leaf__,__nonnull__(1))) extern int atexit(void (*__func)(void));683 __attribute__ ((__nothrow__,__leaf__,__noreturn__)) extern void exit( int __status);684 extern int printf(const char *__restrict __format, ...);685 static inline int invoke_main(int argc, char **argv, char **envp);686 int main(int __argc__i_1, char **__argv__PPc_1, char **__envp__PPc_1){687 __attribute__ ((unused)) int ___retval_main__i_1;688 int _tmp_cp_ret0;682 __attribute__ ((__nothrow__,__leaf__,__nonnull__(1))) extern signed int atexit(void (*__func)(void)); 683 __attribute__ ((__nothrow__,__leaf__,__noreturn__)) extern void exit(signed int __status); 684 extern signed int printf(const char *__restrict __format, ...); 685 static inline signed int invoke_main(signed int argc, char **argv, char **envp); 686 signed int main(signed int __argc__i_1, char **__argv__PPc_1, char **__envp__PPc_1){ 687 __attribute__ ((unused)) signed int ___retval_main__i_1; 688 signed int _tmp_cp_ret0; 689 689 ((void)(___retval_main__i_1=(((void)(_tmp_cp_ret0=invoke_main(__argc__i_1, __argv__PPc_1, __envp__PPc_1))) , _tmp_cp_ret0)) /* ?{} */); 690 690 ((void)(_tmp_cp_ret0) /* ^?{} */); 691 return (( int )___retval_main__i_1);692 } 691 return ((signed int )___retval_main__i_1); 692 } -
src/tests/.expect/32/extension.txt
rb2e2e34 rc935c3a 2 2 __attribute__ ((__nothrow__,__leaf__)) extern void free(void *__ptr); 3 3 __attribute__ ((__nothrow__,__leaf__,__noreturn__)) extern void abort(void); 4 __attribute__ ((__nothrow__,__leaf__,__nonnull__(1))) extern int atexit(void (*__func)(void));5 __attribute__ ((__nothrow__,__leaf__,__noreturn__)) extern void exit( int __status);6 extern int printf(const char *__restrict __format, ...);7 __extension__ int __a__i_1;8 __extension__ int __b__i_1;9 __extension__ int __c__i_1;4 __attribute__ ((__nothrow__,__leaf__,__nonnull__(1))) extern signed int atexit(void (*__func)(void)); 5 __attribute__ ((__nothrow__,__leaf__,__noreturn__)) extern void exit(signed int __status); 6 extern signed int printf(const char *__restrict __format, ...); 7 __extension__ signed int __a__i_1; 8 __extension__ signed int __b__i_1; 9 __extension__ signed int __c__i_1; 10 10 __extension__ struct S { 11 __extension__ int __a__i_1;12 __extension__ int __b__i_1;13 __extension__ int __c__i_1;11 __extension__ signed int __a__i_1; 12 __extension__ signed int __b__i_1; 13 __extension__ signed int __c__i_1; 14 14 }; 15 15 static inline void ___constructor__F_R2sS_autogen___1(struct S *___dst__R2sS_1); … … 40 40 return ((struct S )___ret__2sS_1); 41 41 } 42 static inline void ___constructor__F_R2sSi_autogen___1(struct S *___dst__R2sS_1, int __a__i_1){42 static inline void ___constructor__F_R2sSi_autogen___1(struct S *___dst__R2sS_1, signed int __a__i_1){ 43 43 ((void)((*___dst__R2sS_1).__a__i_1=__a__i_1) /* ?{} */); 44 44 ((void)((*___dst__R2sS_1).__b__i_1) /* ?{} */); 45 45 ((void)((*___dst__R2sS_1).__c__i_1) /* ?{} */); 46 46 } 47 static inline void ___constructor__F_R2sSii_autogen___1(struct S *___dst__R2sS_1, int __a__i_1,int __b__i_1){47 static inline void ___constructor__F_R2sSii_autogen___1(struct S *___dst__R2sS_1, signed int __a__i_1, signed int __b__i_1){ 48 48 ((void)((*___dst__R2sS_1).__a__i_1=__a__i_1) /* ?{} */); 49 49 ((void)((*___dst__R2sS_1).__b__i_1=__b__i_1) /* ?{} */); 50 50 ((void)((*___dst__R2sS_1).__c__i_1) /* ?{} */); 51 51 } 52 static inline void ___constructor__F_R2sSiii_autogen___1(struct S *___dst__R2sS_1, int __a__i_1, int __b__i_1,int __c__i_1){52 static inline void ___constructor__F_R2sSiii_autogen___1(struct S *___dst__R2sS_1, signed int __a__i_1, signed int __b__i_1, signed int __c__i_1){ 53 53 ((void)((*___dst__R2sS_1).__a__i_1=__a__i_1) /* ?{} */); 54 54 ((void)((*___dst__R2sS_1).__b__i_1=__b__i_1) /* ?{} */); … … 56 56 } 57 57 __extension__ union U { 58 __extension__ int __a__i_1;59 __extension__ int __b__i_1;60 __extension__ int __c__i_1;58 __extension__ signed int __a__i_1; 59 __extension__ signed int __b__i_1; 60 __extension__ signed int __c__i_1; 61 61 }; 62 62 static inline void ___constructor__F_R2uU_autogen___1(__attribute__ ((unused)) union U *___dst__R2uU_1){ … … 73 73 return ((union U )___ret__2uU_1); 74 74 } 75 static inline void ___constructor__F_R2uUi_autogen___1(__attribute__ ((unused)) union U *___dst__R2uU_1, int __src__i_1){76 ((void)__builtin_memcpy(((void *)___dst__R2uU_1), ((const void *)(&__src__i_1)), sizeof( int )));75 static inline void ___constructor__F_R2uUi_autogen___1(__attribute__ ((unused)) union U *___dst__R2uU_1, signed int __src__i_1){ 76 ((void)__builtin_memcpy(((void *)___dst__R2uU_1), ((const void *)(&__src__i_1)), sizeof(signed int ))); 77 77 } 78 78 __extension__ enum E { … … 81 81 __B__C2eE_1, 82 82 }; 83 __extension__ int __f__Fi___1();84 __extension__ int i;85 __extension__ int j;86 __extension__ int __fred__Fi_i__1(int __p__i_1){87 __attribute__ ((unused)) int ___retval_fred__i_1;83 __extension__ signed int __f__Fi___1(); 84 __extension__ signed int i; 85 __extension__ signed int j; 86 __extension__ signed int __fred__Fi_i__1(signed int __p__i_1){ 87 __attribute__ ((unused)) signed int ___retval_fred__i_1; 88 88 __extension__ struct S { 89 __extension__ int __a__i_2;90 __extension__ int __b__i_2;91 __extension__ int __c__i_2;92 __extension__ int *__x__Pi_2;93 __extension__ int *__y__Pi_2;94 __extension__ int *__z__Pi_2;89 __extension__ signed int __a__i_2; 90 __extension__ signed int __b__i_2; 91 __extension__ signed int __c__i_2; 92 __extension__ signed int *__x__Pi_2; 93 __extension__ signed int *__y__Pi_2; 94 __extension__ signed int *__z__Pi_2; 95 95 }; 96 int __i__i_2 = ((int )(__extension__ __a__i_1+__extension__ 3));96 signed int __i__i_2 = ((signed int )(__extension__ __a__i_1+__extension__ 3)); 97 97 ((void)__extension__ 3); 98 98 ((void)__extension__ __a__i_1); 99 __extension__ int __a__i_2;100 __extension__ int __b__i_2;101 __extension__ int __c__i_2;99 __extension__ signed int __a__i_2; 100 __extension__ signed int __b__i_2; 101 __extension__ signed int __c__i_2; 102 102 ((void)(__extension__ __a__i_2=(__extension__ __b__i_2+__extension__ __c__i_2))); 103 int _tmp_cp_ret0;103 signed int _tmp_cp_ret0; 104 104 ((void)(((void)(_tmp_cp_ret0=__extension__ __fred__Fi_i__1(3))) , _tmp_cp_ret0)); 105 105 ((void)(_tmp_cp_ret0) /* ^?{} */); 106 __extension__ int __mary__Fi_i__2(int __p__i_2){107 __attribute__ ((unused)) int ___retval_mary__i_2;106 __extension__ signed int __mary__Fi_i__2(signed int __p__i_2){ 107 __attribute__ ((unused)) signed int ___retval_mary__i_2; 108 108 } 109 109 ((void)__extension__ sizeof(3)); 110 ((void)__extension__ ((( int )(3!=((int )0))) || ((int )(4!=((int )0)))));110 ((void)__extension__ (((signed int )(3!=((signed int )0))) || ((signed int )(4!=((signed int )0))))); 111 111 ((void)__extension__ __alignof__(__extension__ __a__i_2)); 112 ((void)((( int )(__extension__ __a__i_2!=((int )0))) || ((int )((((int )(__extension__ __b__i_2!=((int )0))) && ((int )(__extension__ __c__i_2!=((int )0))))!=((int )0)))));113 ((void)((( int )((__extension__ __a__i_2>__extension__ __b__i_2)!=((int )0))) ? __extension__ __c__i_2 : __extension__ __c__i_2));112 ((void)(((signed int )(__extension__ __a__i_2!=((signed int )0))) || ((signed int )((((signed int )(__extension__ __b__i_2!=((signed int )0))) && ((signed int )(__extension__ __c__i_2!=((signed int )0))))!=((signed int )0))))); 113 ((void)(((signed int )((__extension__ __a__i_2>__extension__ __b__i_2)!=((signed int )0))) ? __extension__ __c__i_2 : __extension__ __c__i_2)); 114 114 ((void)(__extension__ __a__i_2=__extension__ (__extension__ __b__i_2+__extension__ __c__i_2))); 115 115 ((void)(((void)(((void)__extension__ __a__i_2) , __extension__ __b__i_2)) , __extension__ __c__i_2)); -
src/tests/.expect/32/gccExtensions.txt
rb2e2e34 rc935c3a 2 2 __attribute__ ((__nothrow__,__leaf__)) extern void free(void *__ptr); 3 3 __attribute__ ((__nothrow__,__leaf__,__noreturn__)) extern void abort(void); 4 __attribute__ ((__nothrow__,__leaf__,__nonnull__(1))) extern int atexit(void (*__func)(void));5 __attribute__ ((__nothrow__,__leaf__,__noreturn__)) extern void exit( int __status);6 extern int printf(const char *__restrict __format, ...);7 extern int __x__i_1 asm ( "xx" );8 int __main__Fi_iPPCc__1(int __argc__i_1, const char **__argv__PPCc_1){9 __attribute__ ((unused)) int ___retval_main__i_1;4 __attribute__ ((__nothrow__,__leaf__,__nonnull__(1))) extern signed int atexit(void (*__func)(void)); 5 __attribute__ ((__nothrow__,__leaf__,__noreturn__)) extern void exit(signed int __status); 6 extern signed int printf(const char *__restrict __format, ...); 7 extern signed int __x__i_1 asm ( "xx" ); 8 signed int __main__Fi_iPPCc__1(signed int __argc__i_1, const char **__argv__PPCc_1){ 9 __attribute__ ((unused)) signed int ___retval_main__i_1; 10 10 asm ( "nop" : : : ); 11 11 asm ( "nop" : : : ); 12 12 asm ( "nop" : : : ); 13 static int __y__i_2 asm ( "yy" );14 static int *__z__Pi_2 asm ( "zz" );15 int __src__i_2;16 int __dst__i_2;17 asm volatile ( "mov %1, %0\n\t add $1, %0" : : : );18 asm volatile ( "mov %1, %0\n\t add $1, %0" : "=r" ( __dst__i_2 ) : : );19 asm volatile ( "mov %1, %0\n\t add $1, %0" : "=r" ( __dst__i_2 ) : "r" ( __src__i_2 ) : );20 asm ( "mov %1, %0\n\t add $1, %0" : "=r" ( __dst__i_2 ), "=r" ( __src__i_2 ) : [ __src__i_2 ] "r" ( __dst__i_2 ) : "r0" );13 static signed int __y__i_2 asm ( "yy" ); 14 static signed int *__z__Pi_2 asm ( "zz" ); 15 signed int __src__i_2; 16 signed int __dst__i_2; 17 asm volatile ( "mov %1, %0\n\t" "add $1, %0" : : : ); 18 asm volatile ( "mov %1, %0\n\t" "add $1, %0" : "=" "r" ( __dst__i_2 ) : : ); 19 asm volatile ( "mov %1, %0\n\t" "add $1, %0" : "=r" ( __dst__i_2 ) : "r" ( __src__i_2 ) : ); 20 asm ( "mov %1, %0\n\t" "add $1, %0" : "=r" ( __dst__i_2 ), "=r" ( __src__i_2 ) : [ __src__i_2 ] "r" ( __dst__i_2 ) : "r0" ); 21 21 L2: L1: asm goto ( "frob %%r5, %1; jc %l[L1]; mov (%2), %%r5" : : "r" ( __src__i_2 ), "r" ( (&__dst__i_2) ) : "r5", "memory" : L1, L2 ); 22 22 double _Complex __c1__Xd_2; 23 23 double _Complex __c2__Xd_2; 24 const int __i1__Ci_2;25 const int __i2__Ci_2;26 const int __i3__Ci_2;27 inline int __f1__Fi___2(){28 __attribute__ ((unused)) int ___retval_f1__i_2;24 const signed int __i1__Ci_2; 25 const signed int __i2__Ci_2; 26 const signed int __i3__Ci_2; 27 inline signed int __f1__Fi___2(){ 28 __attribute__ ((unused)) signed int ___retval_f1__i_2; 29 29 } 30 inline int __f2__Fi___2(){31 __attribute__ ((unused)) int ___retval_f2__i_2;30 inline signed int __f2__Fi___2(){ 31 __attribute__ ((unused)) signed int ___retval_f2__i_2; 32 32 } 33 int __s1__i_2;34 int __s2__i_2;35 volatile int __v1__Vi_2;36 volatile int __v2__Vi_2;37 int __t1___2;38 int __t2___2;39 __extension__ const int __ex__Ci_2;33 signed int __s1__i_2; 34 signed int __s2__i_2; 35 volatile signed int __v1__Vi_2; 36 volatile signed int __v2__Vi_2; 37 signed int __t1___2; 38 signed int __t2___2; 39 __extension__ const signed int __ex__Ci_2; 40 40 struct S { 41 __extension__ int __a__i_2;42 __extension__ int __b__i_2;43 __extension__ int __c__i_2;41 __extension__ signed int __a__i_2; 42 __extension__ signed int __b__i_2; 43 __extension__ signed int __c__i_2; 44 44 }; 45 45 inline void ___constructor__F_R2sS_autogen___2(struct S *___dst__R2sS_2){ … … 66 66 return ((struct S )___ret__2sS_2); 67 67 } 68 inline void ___constructor__F_R2sSi_autogen___2(struct S *___dst__R2sS_2, int __a__i_2){68 inline void ___constructor__F_R2sSi_autogen___2(struct S *___dst__R2sS_2, signed int __a__i_2){ 69 69 ((void)((*___dst__R2sS_2).__a__i_2=__a__i_2) /* ?{} */); 70 70 ((void)((*___dst__R2sS_2).__b__i_2) /* ?{} */); 71 71 ((void)((*___dst__R2sS_2).__c__i_2) /* ?{} */); 72 72 } 73 inline void ___constructor__F_R2sSii_autogen___2(struct S *___dst__R2sS_2, int __a__i_2,int __b__i_2){73 inline void ___constructor__F_R2sSii_autogen___2(struct S *___dst__R2sS_2, signed int __a__i_2, signed int __b__i_2){ 74 74 ((void)((*___dst__R2sS_2).__a__i_2=__a__i_2) /* ?{} */); 75 75 ((void)((*___dst__R2sS_2).__b__i_2=__b__i_2) /* ?{} */); 76 76 ((void)((*___dst__R2sS_2).__c__i_2) /* ?{} */); 77 77 } 78 inline void ___constructor__F_R2sSiii_autogen___2(struct S *___dst__R2sS_2, int __a__i_2, int __b__i_2,int __c__i_2){78 inline void ___constructor__F_R2sSiii_autogen___2(struct S *___dst__R2sS_2, signed int __a__i_2, signed int __b__i_2, signed int __c__i_2){ 79 79 ((void)((*___dst__R2sS_2).__a__i_2=__a__i_2) /* ?{} */); 80 80 ((void)((*___dst__R2sS_2).__b__i_2=__b__i_2) /* ?{} */); 81 81 ((void)((*___dst__R2sS_2).__c__i_2=__c__i_2) /* ?{} */); 82 82 } 83 int __i__i_2 = ((int )__extension__ 3);84 __extension__ int __a__i_2;85 __extension__ int __b__i_2;86 __extension__ int __c__i_2;83 signed int __i__i_2 = ((signed int )__extension__ 3); 84 __extension__ signed int __a__i_2; 85 __extension__ signed int __b__i_2; 86 __extension__ signed int __c__i_2; 87 87 ((void)(((void)(((void)__extension__ __a__i_2) , __extension__ __b__i_2)) , __extension__ __c__i_2)); 88 88 ((void)(__extension__ __a__i_2=(__extension__ __b__i_2+__extension__ __c__i_2))); 89 89 ((void)(__extension__ __a__i_2=__extension__ (__extension__ __b__i_2+__extension__ __c__i_2))); 90 int __a1__i_2;91 const int __a2__Ci_2;92 static const int __a3__Ci_2;93 static const int __a4__Ci_2;94 static const int __a5__Ci_2;95 static const int __a6__Ci_2;96 static const int __a7__Ci_2;97 int *__p1__Pi_2;98 int *__p2__Pi_2;90 signed int __a1__i_2; 91 const signed int __a2__Ci_2; 92 static const signed int __a3__Ci_2; 93 static const signed int __a4__Ci_2; 94 static const signed int __a5__Ci_2; 95 static const signed int __a6__Ci_2; 96 static const signed int __a7__Ci_2; 97 signed int *__p1__Pi_2; 98 signed int *__p2__Pi_2; 99 99 struct s1; 100 100 struct s2 { 101 int __i__i_2;101 signed int __i__i_2; 102 102 }; 103 103 inline void ___constructor__F_R3ss2_autogen___2(struct s2 *___dst__R3ss2_2){ … … 116 116 return ((struct s2 )___ret__3ss2_2); 117 117 } 118 inline void ___constructor__F_R3ss2i_autogen___2(struct s2 *___dst__R3ss2_2, int __i__i_2){118 inline void ___constructor__F_R3ss2i_autogen___2(struct s2 *___dst__R3ss2_2, signed int __i__i_2){ 119 119 ((void)((*___dst__R3ss2_2).__i__i_2=__i__i_2) /* ?{} */); 120 120 } 121 121 struct s3 { 122 int __i__i_2;122 signed int __i__i_2; 123 123 }; 124 124 inline void ___constructor__F_R3ss3_autogen___2(struct s3 *___dst__R3ss3_2){ … … 137 137 return ((struct s3 )___ret__3ss3_2); 138 138 } 139 inline void ___constructor__F_R3ss3i_autogen___2(struct s3 *___dst__R3ss3_2, int __i__i_2){139 inline void ___constructor__F_R3ss3i_autogen___2(struct s3 *___dst__R3ss3_2, signed int __i__i_2){ 140 140 ((void)((*___dst__R3ss3_2).__i__i_2=__i__i_2) /* ?{} */); 141 141 } … … 143 143 struct s3 __y1__3ss3_2; 144 144 struct s4 { 145 int __i__i_2;145 signed int __i__i_2; 146 146 }; 147 147 inline void ___constructor__F_R3ss4_autogen___2(struct s4 *___dst__R3ss4_2){ … … 160 160 return ((struct s4 )___ret__3ss4_2); 161 161 } 162 inline void ___constructor__F_R3ss4i_autogen___2(struct s4 *___dst__R3ss4_2, int __i__i_2){162 inline void ___constructor__F_R3ss4i_autogen___2(struct s4 *___dst__R3ss4_2, signed int __i__i_2){ 163 163 ((void)((*___dst__R3ss4_2).__i__i_2=__i__i_2) /* ?{} */); 164 164 } 165 165 struct s4 __x2__3ss4_2; 166 166 struct s4 __y2__3ss4_2; 167 int __m1__A0i_2[((unsigned int )10)];168 int __m2__A0A0i_2[((unsigned int )10)][((unsigned int )10)];169 int __m3__A0A0i_2[((unsigned int )10)][((unsigned int )10)];170 ((void)(___retval_main__i_1=(( int )0)) /* ?{} */);171 return (( int )___retval_main__i_1);167 signed int __m1__A0i_2[((unsigned int )10)]; 168 signed int __m2__A0A0i_2[((unsigned int )10)][((unsigned int )10)]; 169 signed int __m3__A0A0i_2[((unsigned int )10)][((unsigned int )10)]; 170 ((void)(___retval_main__i_1=((signed int )0)) /* ?{} */); 171 return ((signed int )___retval_main__i_1); 172 172 ((void)(___retval_main__i_1=0) /* ?{} */); 173 return (( int )___retval_main__i_1);173 return ((signed int )___retval_main__i_1); 174 174 } 175 175 static inline int invoke_main(int argc, char* argv[], char* envp[]) { (void)argc; (void)argv; (void)envp; return __main__Fi_iPPCc__1(argc, argv); } … … 177 177 __attribute__ ((__nothrow__,__leaf__)) extern void free(void *__ptr); 178 178 __attribute__ ((__nothrow__,__leaf__,__noreturn__)) extern void abort(void); 179 __attribute__ ((__nothrow__,__leaf__,__nonnull__(1))) extern int atexit(void (*__func)(void));180 __attribute__ ((__nothrow__,__leaf__,__noreturn__)) extern void exit( int __status);181 extern int printf(const char *__restrict __format, ...);182 static inline int invoke_main(int argc, char **argv, char **envp);183 int main(int __argc__i_1, char **__argv__PPc_1, char **__envp__PPc_1){184 __attribute__ ((unused)) int ___retval_main__i_1;185 int _tmp_cp_ret0;179 __attribute__ ((__nothrow__,__leaf__,__nonnull__(1))) extern signed int atexit(void (*__func)(void)); 180 __attribute__ ((__nothrow__,__leaf__,__noreturn__)) extern void exit(signed int __status); 181 extern signed int printf(const char *__restrict __format, ...); 182 static inline signed int invoke_main(signed int argc, char **argv, char **envp); 183 signed int main(signed int __argc__i_1, char **__argv__PPc_1, char **__envp__PPc_1){ 184 __attribute__ ((unused)) signed int ___retval_main__i_1; 185 signed int _tmp_cp_ret0; 186 186 ((void)(___retval_main__i_1=(((void)(_tmp_cp_ret0=invoke_main(__argc__i_1, __argv__PPc_1, __envp__PPc_1))) , _tmp_cp_ret0)) /* ?{} */); 187 187 ((void)(_tmp_cp_ret0) /* ^?{} */); 188 return (( int )___retval_main__i_1);188 return ((signed int )___retval_main__i_1); 189 189 }
Note: See TracChangeset
for help on using the changeset viewer.