1/* Warning: automatically generated code */ 2 3int (is_ASM)(const ir_node *node) 4{ 5 return is_ASM_(node); 6} 7 8int (is_Add)(const ir_node *node) 9{ 10 return is_Add_(node); 11} 12 13int (is_Alloc)(const ir_node *node) 14{ 15 return is_Alloc_(node); 16} 17 18int (is_Anchor)(const ir_node *node) 19{ 20 return is_Anchor_(node); 21} 22 23int (is_And)(const ir_node *node) 24{ 25 return is_And_(node); 26} 27 28int (is_Bad)(const ir_node *node) 29{ 30 return is_Bad_(node); 31} 32 33int (is_Block)(const ir_node *node) 34{ 35 return is_Block_(node); 36} 37 38int (is_Borrow)(const ir_node *node) 39{ 40 return is_Borrow_(node); 41} 42 43int (is_Bound)(const ir_node *node) 44{ 45 return is_Bound_(node); 46} 47 48int (is_Builtin)(const ir_node *node) 49{ 50 return is_Builtin_(node); 51} 52 53int (is_Call)(const ir_node *node) 54{ 55 return is_Call_(node); 56} 57 58int (is_Carry)(const ir_node *node) 59{ 60 return is_Carry_(node); 61} 62 63int (is_Cast)(const ir_node *node) 64{ 65 return is_Cast_(node); 66} 67 68int (is_Cmp)(const ir_node *node) 69{ 70 return is_Cmp_(node); 71} 72 73int (is_Cond)(const ir_node *node) 74{ 75 return is_Cond_(node); 76} 77 78int (is_Confirm)(const ir_node *node) 79{ 80 return is_Confirm_(node); 81} 82 83int (is_Const)(const ir_node *node) 84{ 85 return is_Const_(node); 86} 87 88int (is_Conv)(const ir_node *node) 89{ 90 return is_Conv_(node); 91} 92 93int (is_CopyB)(const ir_node *node) 94{ 95 return is_CopyB_(node); 96} 97 98int (is_Deleted)(const ir_node *node) 99{ 100 return is_Deleted_(node); 101} 102 103int (is_Div)(const ir_node *node) 104{ 105 return is_Div_(node); 106} 107 108int (is_Dummy)(const ir_node *node) 109{ 110 return is_Dummy_(node); 111} 112 113int (is_End)(const ir_node *node) 114{ 115 return is_End_(node); 116} 117 118int (is_Eor)(const ir_node *node) 119{ 120 return is_Eor_(node); 121} 122 123int (is_Free)(const ir_node *node) 124{ 125 return is_Free_(node); 126} 127 128int (is_IJmp)(const ir_node *node) 129{ 130 return is_IJmp_(node); 131} 132 133int (is_Id)(const ir_node *node) 134{ 135 return is_Id_(node); 136} 137 138int (is_InstOf)(const ir_node *node) 139{ 140 return is_InstOf_(node); 141} 142 143int (is_Jmp)(const ir_node *node) 144{ 145 return is_Jmp_(node); 146} 147 148int (is_Load)(const ir_node *node) 149{ 150 return is_Load_(node); 151} 152 153int (is_Minus)(const ir_node *node) 154{ 155 return is_Minus_(node); 156} 157 158int (is_Mod)(const ir_node *node) 159{ 160 return is_Mod_(node); 161} 162 163int (is_Mul)(const ir_node *node) 164{ 165 return is_Mul_(node); 166} 167 168int (is_Mulh)(const ir_node *node) 169{ 170 return is_Mulh_(node); 171} 172 173int (is_Mux)(const ir_node *node) 174{ 175 return is_Mux_(node); 176} 177 178int (is_NoMem)(const ir_node *node) 179{ 180 return is_NoMem_(node); 181} 182 183int (is_Not)(const ir_node *node) 184{ 185 return is_Not_(node); 186} 187 188int (is_Or)(const ir_node *node) 189{ 190 return is_Or_(node); 191} 192 193int (is_Phi)(const ir_node *node) 194{ 195 return is_Phi_(node); 196} 197 198int (is_Pin)(const ir_node *node) 199{ 200 return is_Pin_(node); 201} 202 203int (is_Proj)(const ir_node *node) 204{ 205 return is_Proj_(node); 206} 207 208int (is_Raise)(const ir_node *node) 209{ 210 return is_Raise_(node); 211} 212 213int (is_Return)(const ir_node *node) 214{ 215 return is_Return_(node); 216} 217 218int (is_Rotl)(const ir_node *node) 219{ 220 return is_Rotl_(node); 221} 222 223int (is_Sel)(const ir_node *node) 224{ 225 return is_Sel_(node); 226} 227 228int (is_Shl)(const ir_node *node) 229{ 230 return is_Shl_(node); 231} 232 233int (is_Shr)(const ir_node *node) 234{ 235 return is_Shr_(node); 236} 237 238int (is_Shrs)(const ir_node *node) 239{ 240 return is_Shrs_(node); 241} 242 243int (is_Start)(const ir_node *node) 244{ 245 return is_Start_(node); 246} 247 248int (is_Store)(const ir_node *node) 249{ 250 return is_Store_(node); 251} 252 253int (is_Sub)(const ir_node *node) 254{ 255 return is_Sub_(node); 256} 257 258int (is_Switch)(const ir_node *node) 259{ 260 return is_Switch_(node); 261} 262 263int (is_SymConst)(const ir_node *node) 264{ 265 return is_SymConst_(node); 266} 267 268int (is_Sync)(const ir_node *node) 269{ 270 return is_Sync_(node); 271} 272 273int (is_Tuple)(const ir_node *node) 274{ 275 return is_Tuple_(node); 276} 277 278int (is_Unknown)(const ir_node *node) 279{ 280 return is_Unknown_(node); 281} 282 283ir_asm_constraint* (get_ASM_input_constraints)(const ir_node *node) 284{ 285 assert(is_ASM(node)); 286 return node->attr.assem.input_constraints; 287} 288 289void (set_ASM_input_constraints)(ir_node *node, ir_asm_constraint* input_constraints) 290{ 291 assert(is_ASM(node)); 292 node->attr.assem.input_constraints = input_constraints; 293} 294 295ir_asm_constraint* (get_ASM_output_constraints)(const ir_node *node) 296{ 297 assert(is_ASM(node)); 298 return node->attr.assem.output_constraints; 299} 300 301void (set_ASM_output_constraints)(ir_node *node, ir_asm_constraint* output_constraints) 302{ 303 assert(is_ASM(node)); 304 node->attr.assem.output_constraints = output_constraints; 305} 306 307ident** (get_ASM_clobbers)(const ir_node *node) 308{ 309 assert(is_ASM(node)); 310 return node->attr.assem.clobbers; 311} 312 313void (set_ASM_clobbers)(ir_node *node, ident** clobbers) 314{ 315 assert(is_ASM(node)); 316 node->attr.assem.clobbers = clobbers; 317} 318 319ident* (get_ASM_text)(const ir_node *node) 320{ 321 assert(is_ASM(node)); 322 return node->attr.assem.text; 323} 324 325void (set_ASM_text)(ir_node *node, ident* text) 326{ 327 assert(is_ASM(node)); 328 node->attr.assem.text = text; 329} 330 331ir_type* (get_Alloc_type)(const ir_node *node) 332{ 333 assert(is_Alloc(node)); 334 return node->attr.alloc.type; 335} 336 337void (set_Alloc_type)(ir_node *node, ir_type* type) 338{ 339 assert(is_Alloc(node)); 340 node->attr.alloc.type = type; 341} 342 343ir_where_alloc (get_Alloc_where)(const ir_node *node) 344{ 345 assert(is_Alloc(node)); 346 return node->attr.alloc.where; 347} 348 349void (set_Alloc_where)(ir_node *node, ir_where_alloc where) 350{ 351 assert(is_Alloc(node)); 352 node->attr.alloc.where = where; 353} 354 355ir_entity* (get_Block_entity)(const ir_node *node) 356{ 357 assert(is_Block(node)); 358 return node->attr.block.entity; 359} 360 361void (set_Block_entity)(ir_node *node, ir_entity* entity) 362{ 363 assert(is_Block(node)); 364 node->attr.block.entity = entity; 365} 366 367ir_builtin_kind (get_Builtin_kind)(const ir_node *node) 368{ 369 assert(is_Builtin(node)); 370 return node->attr.builtin.kind; 371} 372 373void (set_Builtin_kind)(ir_node *node, ir_builtin_kind kind) 374{ 375 assert(is_Builtin(node)); 376 node->attr.builtin.kind = kind; 377} 378 379ir_type* (get_Builtin_type)(const ir_node *node) 380{ 381 assert(is_Builtin(node)); 382 return node->attr.builtin.type; 383} 384 385void (set_Builtin_type)(ir_node *node, ir_type* type) 386{ 387 assert(is_Builtin(node)); 388 node->attr.builtin.type = type; 389} 390 391ir_type* (get_Call_type)(const ir_node *node) 392{ 393 assert(is_Call(node)); 394 return node->attr.call.type; 395} 396 397void (set_Call_type)(ir_node *node, ir_type* type) 398{ 399 assert(is_Call(node)); 400 node->attr.call.type = type; 401} 402 403ir_type* (get_Cast_type)(const ir_node *node) 404{ 405 assert(is_Cast(node)); 406 return node->attr.cast.type; 407} 408 409void (set_Cast_type)(ir_node *node, ir_type* type) 410{ 411 assert(is_Cast(node)); 412 node->attr.cast.type = type; 413} 414 415ir_relation (get_Cmp_relation)(const ir_node *node) 416{ 417 assert(is_Cmp(node)); 418 return node->attr.cmp.relation; 419} 420 421void (set_Cmp_relation)(ir_node *node, ir_relation relation) 422{ 423 assert(is_Cmp(node)); 424 node->attr.cmp.relation = relation; 425} 426 427cond_jmp_predicate (get_Cond_jmp_pred)(const ir_node *node) 428{ 429 assert(is_Cond(node)); 430 return node->attr.cond.jmp_pred; 431} 432 433void (set_Cond_jmp_pred)(ir_node *node, cond_jmp_predicate jmp_pred) 434{ 435 assert(is_Cond(node)); 436 node->attr.cond.jmp_pred = jmp_pred; 437} 438 439ir_relation (get_Confirm_relation)(const ir_node *node) 440{ 441 assert(is_Confirm(node)); 442 return node->attr.confirm.relation; 443} 444 445void (set_Confirm_relation)(ir_node *node, ir_relation relation) 446{ 447 assert(is_Confirm(node)); 448 node->attr.confirm.relation = relation; 449} 450 451ir_tarval* (get_Const_tarval)(const ir_node *node) 452{ 453 assert(is_Const(node)); 454 return node->attr.con.tarval; 455} 456 457void (set_Const_tarval)(ir_node *node, ir_tarval* tarval) 458{ 459 assert(is_Const(node)); 460 node->attr.con.tarval = tarval; 461} 462 463ir_type* (get_CopyB_type)(const ir_node *node) 464{ 465 assert(is_CopyB(node)); 466 return node->attr.copyb.type; 467} 468 469void (set_CopyB_type)(ir_node *node, ir_type* type) 470{ 471 assert(is_CopyB(node)); 472 node->attr.copyb.type = type; 473} 474 475ir_mode* (get_Div_resmode)(const ir_node *node) 476{ 477 assert(is_Div(node)); 478 return node->attr.div.resmode; 479} 480 481void (set_Div_resmode)(ir_node *node, ir_mode* resmode) 482{ 483 assert(is_Div(node)); 484 node->attr.div.resmode = resmode; 485} 486 487int (get_Div_no_remainder)(const ir_node *node) 488{ 489 assert(is_Div(node)); 490 return node->attr.div.no_remainder; 491} 492 493void (set_Div_no_remainder)(ir_node *node, int no_remainder) 494{ 495 assert(is_Div(node)); 496 node->attr.div.no_remainder = no_remainder; 497} 498 499ir_type* (get_Free_type)(const ir_node *node) 500{ 501 assert(is_Free(node)); 502 return node->attr.free.type; 503} 504 505void (set_Free_type)(ir_node *node, ir_type* type) 506{ 507 assert(is_Free(node)); 508 node->attr.free.type = type; 509} 510 511ir_where_alloc (get_Free_where)(const ir_node *node) 512{ 513 assert(is_Free(node)); 514 return node->attr.free.where; 515} 516 517void (set_Free_where)(ir_node *node, ir_where_alloc where) 518{ 519 assert(is_Free(node)); 520 node->attr.free.where = where; 521} 522 523ir_type* (get_InstOf_type)(const ir_node *node) 524{ 525 assert(is_InstOf(node)); 526 return node->attr.instof.type; 527} 528 529void (set_InstOf_type)(ir_node *node, ir_type* type) 530{ 531 assert(is_InstOf(node)); 532 node->attr.instof.type = type; 533} 534 535ir_mode* (get_Load_mode)(const ir_node *node) 536{ 537 assert(is_Load(node)); 538 return node->attr.load.mode; 539} 540 541void (set_Load_mode)(ir_node *node, ir_mode* mode) 542{ 543 assert(is_Load(node)); 544 node->attr.load.mode = mode; 545} 546 547ir_volatility (get_Load_volatility)(const ir_node *node) 548{ 549 assert(is_Load(node)); 550 return node->attr.load.volatility; 551} 552 553void (set_Load_volatility)(ir_node *node, ir_volatility volatility) 554{ 555 assert(is_Load(node)); 556 node->attr.load.volatility = volatility; 557} 558 559ir_align (get_Load_unaligned)(const ir_node *node) 560{ 561 assert(is_Load(node)); 562 return node->attr.load.unaligned; 563} 564 565void (set_Load_unaligned)(ir_node *node, ir_align unaligned) 566{ 567 assert(is_Load(node)); 568 node->attr.load.unaligned = unaligned; 569} 570 571ir_mode* (get_Mod_resmode)(const ir_node *node) 572{ 573 assert(is_Mod(node)); 574 return node->attr.mod.resmode; 575} 576 577void (set_Mod_resmode)(ir_node *node, ir_mode* resmode) 578{ 579 assert(is_Mod(node)); 580 node->attr.mod.resmode = resmode; 581} 582 583long (get_Proj_proj)(const ir_node *node) 584{ 585 assert(is_Proj(node)); 586 return node->attr.proj.proj; 587} 588 589void (set_Proj_proj)(ir_node *node, long proj) 590{ 591 assert(is_Proj(node)); 592 node->attr.proj.proj = proj; 593} 594 595ir_entity* (get_Sel_entity)(const ir_node *node) 596{ 597 assert(is_Sel(node)); 598 return node->attr.sel.entity; 599} 600 601void (set_Sel_entity)(ir_node *node, ir_entity* entity) 602{ 603 assert(is_Sel(node)); 604 node->attr.sel.entity = entity; 605} 606 607ir_volatility (get_Store_volatility)(const ir_node *node) 608{ 609 assert(is_Store(node)); 610 return node->attr.store.volatility; 611} 612 613void (set_Store_volatility)(ir_node *node, ir_volatility volatility) 614{ 615 assert(is_Store(node)); 616 node->attr.store.volatility = volatility; 617} 618 619ir_align (get_Store_unaligned)(const ir_node *node) 620{ 621 assert(is_Store(node)); 622 return node->attr.store.unaligned; 623} 624 625void (set_Store_unaligned)(ir_node *node, ir_align unaligned) 626{ 627 assert(is_Store(node)); 628 node->attr.store.unaligned = unaligned; 629} 630 631unsigned (get_Switch_n_outs)(const ir_node *node) 632{ 633 assert(is_Switch(node)); 634 return node->attr.switcha.n_outs; 635} 636 637void (set_Switch_n_outs)(ir_node *node, unsigned n_outs) 638{ 639 assert(is_Switch(node)); 640 node->attr.switcha.n_outs = n_outs; 641} 642 643ir_switch_table* (get_Switch_table)(const ir_node *node) 644{ 645 assert(is_Switch(node)); 646 return node->attr.switcha.table; 647} 648 649void (set_Switch_table)(ir_node *node, ir_switch_table* table) 650{ 651 assert(is_Switch(node)); 652 node->attr.switcha.table = table; 653} 654 655ir_node *(get_ASM_mem)(const ir_node *node) 656{ 657 assert(is_ASM(node)); 658 return get_irn_n(node, n_ASM_mem); 659} 660 661void (set_ASM_mem)(ir_node *node, ir_node *mem) 662{ 663 assert(is_ASM(node)); 664 set_irn_n(node, n_ASM_mem, mem); 665} 666 667 668ir_node *(get_Add_left)(const ir_node *node) 669{ 670 assert(is_Add(node)); 671 return get_irn_n(node, n_Add_left); 672} 673 674void (set_Add_left)(ir_node *node, ir_node *left) 675{ 676 assert(is_Add(node)); 677 set_irn_n(node, n_Add_left, left); 678} 679 680ir_node *(get_Add_right)(const ir_node *node) 681{ 682 assert(is_Add(node)); 683 return get_irn_n(node, n_Add_right); 684} 685 686void (set_Add_right)(ir_node *node, ir_node *right) 687{ 688 assert(is_Add(node)); 689 set_irn_n(node, n_Add_right, right); 690} 691 692 693ir_node *(get_Alloc_mem)(const ir_node *node) 694{ 695 assert(is_Alloc(node)); 696 return get_irn_n(node, n_Alloc_mem); 697} 698 699void (set_Alloc_mem)(ir_node *node, ir_node *mem) 700{ 701 assert(is_Alloc(node)); 702 set_irn_n(node, n_Alloc_mem, mem); 703} 704 705ir_node *(get_Alloc_count)(const ir_node *node) 706{ 707 assert(is_Alloc(node)); 708 return get_irn_n(node, n_Alloc_count); 709} 710 711void (set_Alloc_count)(ir_node *node, ir_node *count) 712{ 713 assert(is_Alloc(node)); 714 set_irn_n(node, n_Alloc_count, count); 715} 716 717 718 719ir_node *(get_And_left)(const ir_node *node) 720{ 721 assert(is_And(node)); 722 return get_irn_n(node, n_And_left); 723} 724 725void (set_And_left)(ir_node *node, ir_node *left) 726{ 727 assert(is_And(node)); 728 set_irn_n(node, n_And_left, left); 729} 730 731ir_node *(get_And_right)(const ir_node *node) 732{ 733 assert(is_And(node)); 734 return get_irn_n(node, n_And_right); 735} 736 737void (set_And_right)(ir_node *node, ir_node *right) 738{ 739 assert(is_And(node)); 740 set_irn_n(node, n_And_right, right); 741} 742 743 744 745 746ir_node *(get_Borrow_left)(const ir_node *node) 747{ 748 assert(is_Borrow(node)); 749 return get_irn_n(node, n_Borrow_left); 750} 751 752void (set_Borrow_left)(ir_node *node, ir_node *left) 753{ 754 assert(is_Borrow(node)); 755 set_irn_n(node, n_Borrow_left, left); 756} 757 758ir_node *(get_Borrow_right)(const ir_node *node) 759{ 760 assert(is_Borrow(node)); 761 return get_irn_n(node, n_Borrow_right); 762} 763 764void (set_Borrow_right)(ir_node *node, ir_node *right) 765{ 766 assert(is_Borrow(node)); 767 set_irn_n(node, n_Borrow_right, right); 768} 769 770 771ir_node *(get_Bound_mem)(const ir_node *node) 772{ 773 assert(is_Bound(node)); 774 return get_irn_n(node, n_Bound_mem); 775} 776 777void (set_Bound_mem)(ir_node *node, ir_node *mem) 778{ 779 assert(is_Bound(node)); 780 set_irn_n(node, n_Bound_mem, mem); 781} 782 783ir_node *(get_Bound_index)(const ir_node *node) 784{ 785 assert(is_Bound(node)); 786 return get_irn_n(node, n_Bound_index); 787} 788 789void (set_Bound_index)(ir_node *node, ir_node *index) 790{ 791 assert(is_Bound(node)); 792 set_irn_n(node, n_Bound_index, index); 793} 794 795ir_node *(get_Bound_lower)(const ir_node *node) 796{ 797 assert(is_Bound(node)); 798 return get_irn_n(node, n_Bound_lower); 799} 800 801void (set_Bound_lower)(ir_node *node, ir_node *lower) 802{ 803 assert(is_Bound(node)); 804 set_irn_n(node, n_Bound_lower, lower); 805} 806 807ir_node *(get_Bound_upper)(const ir_node *node) 808{ 809 assert(is_Bound(node)); 810 return get_irn_n(node, n_Bound_upper); 811} 812 813void (set_Bound_upper)(ir_node *node, ir_node *upper) 814{ 815 assert(is_Bound(node)); 816 set_irn_n(node, n_Bound_upper, upper); 817} 818 819 820ir_node *(get_Builtin_mem)(const ir_node *node) 821{ 822 assert(is_Builtin(node)); 823 return get_irn_n(node, n_Builtin_mem); 824} 825 826void (set_Builtin_mem)(ir_node *node, ir_node *mem) 827{ 828 assert(is_Builtin(node)); 829 set_irn_n(node, n_Builtin_mem, mem); 830} 831 832 833ir_node *(get_Call_mem)(const ir_node *node) 834{ 835 assert(is_Call(node)); 836 return get_irn_n(node, n_Call_mem); 837} 838 839void (set_Call_mem)(ir_node *node, ir_node *mem) 840{ 841 assert(is_Call(node)); 842 set_irn_n(node, n_Call_mem, mem); 843} 844 845ir_node *(get_Call_ptr)(const ir_node *node) 846{ 847 assert(is_Call(node)); 848 return get_irn_n(node, n_Call_ptr); 849} 850 851void (set_Call_ptr)(ir_node *node, ir_node *ptr) 852{ 853 assert(is_Call(node)); 854 set_irn_n(node, n_Call_ptr, ptr); 855} 856 857 858ir_node *(get_Carry_left)(const ir_node *node) 859{ 860 assert(is_Carry(node)); 861 return get_irn_n(node, n_Carry_left); 862} 863 864void (set_Carry_left)(ir_node *node, ir_node *left) 865{ 866 assert(is_Carry(node)); 867 set_irn_n(node, n_Carry_left, left); 868} 869 870ir_node *(get_Carry_right)(const ir_node *node) 871{ 872 assert(is_Carry(node)); 873 return get_irn_n(node, n_Carry_right); 874} 875 876void (set_Carry_right)(ir_node *node, ir_node *right) 877{ 878 assert(is_Carry(node)); 879 set_irn_n(node, n_Carry_right, right); 880} 881 882 883ir_node *(get_Cast_op)(const ir_node *node) 884{ 885 assert(is_Cast(node)); 886 return get_irn_n(node, n_Cast_op); 887} 888 889void (set_Cast_op)(ir_node *node, ir_node *op) 890{ 891 assert(is_Cast(node)); 892 set_irn_n(node, n_Cast_op, op); 893} 894 895 896ir_node *(get_Cmp_left)(const ir_node *node) 897{ 898 assert(is_Cmp(node)); 899 return get_irn_n(node, n_Cmp_left); 900} 901 902void (set_Cmp_left)(ir_node *node, ir_node *left) 903{ 904 assert(is_Cmp(node)); 905 set_irn_n(node, n_Cmp_left, left); 906} 907 908ir_node *(get_Cmp_right)(const ir_node *node) 909{ 910 assert(is_Cmp(node)); 911 return get_irn_n(node, n_Cmp_right); 912} 913 914void (set_Cmp_right)(ir_node *node, ir_node *right) 915{ 916 assert(is_Cmp(node)); 917 set_irn_n(node, n_Cmp_right, right); 918} 919 920 921ir_node *(get_Cond_selector)(const ir_node *node) 922{ 923 assert(is_Cond(node)); 924 return get_irn_n(node, n_Cond_selector); 925} 926 927void (set_Cond_selector)(ir_node *node, ir_node *selector) 928{ 929 assert(is_Cond(node)); 930 set_irn_n(node, n_Cond_selector, selector); 931} 932 933 934ir_node *(get_Confirm_value)(const ir_node *node) 935{ 936 assert(is_Confirm(node)); 937 return get_irn_n(node, n_Confirm_value); 938} 939 940void (set_Confirm_value)(ir_node *node, ir_node *value) 941{ 942 assert(is_Confirm(node)); 943 set_irn_n(node, n_Confirm_value, value); 944} 945 946ir_node *(get_Confirm_bound)(const ir_node *node) 947{ 948 assert(is_Confirm(node)); 949 return get_irn_n(node, n_Confirm_bound); 950} 951 952void (set_Confirm_bound)(ir_node *node, ir_node *bound) 953{ 954 assert(is_Confirm(node)); 955 set_irn_n(node, n_Confirm_bound, bound); 956} 957 958 959 960ir_node *(get_Conv_op)(const ir_node *node) 961{ 962 assert(is_Conv(node)); 963 return get_irn_n(node, n_Conv_op); 964} 965 966void (set_Conv_op)(ir_node *node, ir_node *op) 967{ 968 assert(is_Conv(node)); 969 set_irn_n(node, n_Conv_op, op); 970} 971 972 973ir_node *(get_CopyB_mem)(const ir_node *node) 974{ 975 assert(is_CopyB(node)); 976 return get_irn_n(node, n_CopyB_mem); 977} 978 979void (set_CopyB_mem)(ir_node *node, ir_node *mem) 980{ 981 assert(is_CopyB(node)); 982 set_irn_n(node, n_CopyB_mem, mem); 983} 984 985ir_node *(get_CopyB_dst)(const ir_node *node) 986{ 987 assert(is_CopyB(node)); 988 return get_irn_n(node, n_CopyB_dst); 989} 990 991void (set_CopyB_dst)(ir_node *node, ir_node *dst) 992{ 993 assert(is_CopyB(node)); 994 set_irn_n(node, n_CopyB_dst, dst); 995} 996 997ir_node *(get_CopyB_src)(const ir_node *node) 998{ 999 assert(is_CopyB(node)); 1000 return get_irn_n(node, n_CopyB_src); 1001} 1002 1003void (set_CopyB_src)(ir_node *node, ir_node *src) 1004{ 1005 assert(is_CopyB(node)); 1006 set_irn_n(node, n_CopyB_src, src); 1007} 1008 1009 1010 1011ir_node *(get_Div_mem)(const ir_node *node) 1012{ 1013 assert(is_Div(node)); 1014 return get_irn_n(node, n_Div_mem); 1015} 1016 1017void (set_Div_mem)(ir_node *node, ir_node *mem) 1018{ 1019 assert(is_Div(node)); 1020 set_irn_n(node, n_Div_mem, mem); 1021} 1022 1023ir_node *(get_Div_left)(const ir_node *node) 1024{ 1025 assert(is_Div(node)); 1026 return get_irn_n(node, n_Div_left); 1027} 1028 1029void (set_Div_left)(ir_node *node, ir_node *left) 1030{ 1031 assert(is_Div(node)); 1032 set_irn_n(node, n_Div_left, left); 1033} 1034 1035ir_node *(get_Div_right)(const ir_node *node) 1036{ 1037 assert(is_Div(node)); 1038 return get_irn_n(node, n_Div_right); 1039} 1040 1041void (set_Div_right)(ir_node *node, ir_node *right) 1042{ 1043 assert(is_Div(node)); 1044 set_irn_n(node, n_Div_right, right); 1045} 1046 1047 1048 1049 1050ir_node *(get_Eor_left)(const ir_node *node) 1051{ 1052 assert(is_Eor(node)); 1053 return get_irn_n(node, n_Eor_left); 1054} 1055 1056void (set_Eor_left)(ir_node *node, ir_node *left) 1057{ 1058 assert(is_Eor(node)); 1059 set_irn_n(node, n_Eor_left, left); 1060} 1061 1062ir_node *(get_Eor_right)(const ir_node *node) 1063{ 1064 assert(is_Eor(node)); 1065 return get_irn_n(node, n_Eor_right); 1066} 1067 1068void (set_Eor_right)(ir_node *node, ir_node *right) 1069{ 1070 assert(is_Eor(node)); 1071 set_irn_n(node, n_Eor_right, right); 1072} 1073 1074 1075ir_node *(get_Free_mem)(const ir_node *node) 1076{ 1077 assert(is_Free(node)); 1078 return get_irn_n(node, n_Free_mem); 1079} 1080 1081void (set_Free_mem)(ir_node *node, ir_node *mem) 1082{ 1083 assert(is_Free(node)); 1084 set_irn_n(node, n_Free_mem, mem); 1085} 1086 1087ir_node *(get_Free_ptr)(const ir_node *node) 1088{ 1089 assert(is_Free(node)); 1090 return get_irn_n(node, n_Free_ptr); 1091} 1092 1093void (set_Free_ptr)(ir_node *node, ir_node *ptr) 1094{ 1095 assert(is_Free(node)); 1096 set_irn_n(node, n_Free_ptr, ptr); 1097} 1098 1099ir_node *(get_Free_count)(const ir_node *node) 1100{ 1101 assert(is_Free(node)); 1102 return get_irn_n(node, n_Free_count); 1103} 1104 1105void (set_Free_count)(ir_node *node, ir_node *count) 1106{ 1107 assert(is_Free(node)); 1108 set_irn_n(node, n_Free_count, count); 1109} 1110 1111 1112ir_node *(get_IJmp_target)(const ir_node *node) 1113{ 1114 assert(is_IJmp(node)); 1115 return get_irn_n(node, n_IJmp_target); 1116} 1117 1118void (set_IJmp_target)(ir_node *node, ir_node *target) 1119{ 1120 assert(is_IJmp(node)); 1121 set_irn_n(node, n_IJmp_target, target); 1122} 1123 1124 1125ir_node *(get_Id_pred)(const ir_node *node) 1126{ 1127 assert(is_Id(node)); 1128 return get_irn_n(node, n_Id_pred); 1129} 1130 1131void (set_Id_pred)(ir_node *node, ir_node *pred) 1132{ 1133 assert(is_Id(node)); 1134 set_irn_n(node, n_Id_pred, pred); 1135} 1136 1137 1138ir_node *(get_InstOf_store)(const ir_node *node) 1139{ 1140 assert(is_InstOf(node)); 1141 return get_irn_n(node, n_InstOf_store); 1142} 1143 1144void (set_InstOf_store)(ir_node *node, ir_node *store) 1145{ 1146 assert(is_InstOf(node)); 1147 set_irn_n(node, n_InstOf_store, store); 1148} 1149 1150ir_node *(get_InstOf_obj)(const ir_node *node) 1151{ 1152 assert(is_InstOf(node)); 1153 return get_irn_n(node, n_InstOf_obj); 1154} 1155 1156void (set_InstOf_obj)(ir_node *node, ir_node *obj) 1157{ 1158 assert(is_InstOf(node)); 1159 set_irn_n(node, n_InstOf_obj, obj); 1160} 1161 1162 1163 1164ir_node *(get_Load_mem)(const ir_node *node) 1165{ 1166 assert(is_Load(node)); 1167 return get_irn_n(node, n_Load_mem); 1168} 1169 1170void (set_Load_mem)(ir_node *node, ir_node *mem) 1171{ 1172 assert(is_Load(node)); 1173 set_irn_n(node, n_Load_mem, mem); 1174} 1175 1176ir_node *(get_Load_ptr)(const ir_node *node) 1177{ 1178 assert(is_Load(node)); 1179 return get_irn_n(node, n_Load_ptr); 1180} 1181 1182void (set_Load_ptr)(ir_node *node, ir_node *ptr) 1183{ 1184 assert(is_Load(node)); 1185 set_irn_n(node, n_Load_ptr, ptr); 1186} 1187 1188 1189ir_node *(get_Minus_op)(const ir_node *node) 1190{ 1191 assert(is_Minus(node)); 1192 return get_irn_n(node, n_Minus_op); 1193} 1194 1195void (set_Minus_op)(ir_node *node, ir_node *op) 1196{ 1197 assert(is_Minus(node)); 1198 set_irn_n(node, n_Minus_op, op); 1199} 1200 1201 1202ir_node *(get_Mod_mem)(const ir_node *node) 1203{ 1204 assert(is_Mod(node)); 1205 return get_irn_n(node, n_Mod_mem); 1206} 1207 1208void (set_Mod_mem)(ir_node *node, ir_node *mem) 1209{ 1210 assert(is_Mod(node)); 1211 set_irn_n(node, n_Mod_mem, mem); 1212} 1213 1214ir_node *(get_Mod_left)(const ir_node *node) 1215{ 1216 assert(is_Mod(node)); 1217 return get_irn_n(node, n_Mod_left); 1218} 1219 1220void (set_Mod_left)(ir_node *node, ir_node *left) 1221{ 1222 assert(is_Mod(node)); 1223 set_irn_n(node, n_Mod_left, left); 1224} 1225 1226ir_node *(get_Mod_right)(const ir_node *node) 1227{ 1228 assert(is_Mod(node)); 1229 return get_irn_n(node, n_Mod_right); 1230} 1231 1232void (set_Mod_right)(ir_node *node, ir_node *right) 1233{ 1234 assert(is_Mod(node)); 1235 set_irn_n(node, n_Mod_right, right); 1236} 1237 1238 1239ir_node *(get_Mul_left)(const ir_node *node) 1240{ 1241 assert(is_Mul(node)); 1242 return get_irn_n(node, n_Mul_left); 1243} 1244 1245void (set_Mul_left)(ir_node *node, ir_node *left) 1246{ 1247 assert(is_Mul(node)); 1248 set_irn_n(node, n_Mul_left, left); 1249} 1250 1251ir_node *(get_Mul_right)(const ir_node *node) 1252{ 1253 assert(is_Mul(node)); 1254 return get_irn_n(node, n_Mul_right); 1255} 1256 1257void (set_Mul_right)(ir_node *node, ir_node *right) 1258{ 1259 assert(is_Mul(node)); 1260 set_irn_n(node, n_Mul_right, right); 1261} 1262 1263 1264ir_node *(get_Mulh_left)(const ir_node *node) 1265{ 1266 assert(is_Mulh(node)); 1267 return get_irn_n(node, n_Mulh_left); 1268} 1269 1270void (set_Mulh_left)(ir_node *node, ir_node *left) 1271{ 1272 assert(is_Mulh(node)); 1273 set_irn_n(node, n_Mulh_left, left); 1274} 1275 1276ir_node *(get_Mulh_right)(const ir_node *node) 1277{ 1278 assert(is_Mulh(node)); 1279 return get_irn_n(node, n_Mulh_right); 1280} 1281 1282void (set_Mulh_right)(ir_node *node, ir_node *right) 1283{ 1284 assert(is_Mulh(node)); 1285 set_irn_n(node, n_Mulh_right, right); 1286} 1287 1288 1289ir_node *(get_Mux_sel)(const ir_node *node) 1290{ 1291 assert(is_Mux(node)); 1292 return get_irn_n(node, n_Mux_sel); 1293} 1294 1295void (set_Mux_sel)(ir_node *node, ir_node *sel) 1296{ 1297 assert(is_Mux(node)); 1298 set_irn_n(node, n_Mux_sel, sel); 1299} 1300 1301ir_node *(get_Mux_false)(const ir_node *node) 1302{ 1303 assert(is_Mux(node)); 1304 return get_irn_n(node, n_Mux_false); 1305} 1306 1307void (set_Mux_false)(ir_node *node, ir_node *false_) 1308{ 1309 assert(is_Mux(node)); 1310 set_irn_n(node, n_Mux_false, false_); 1311} 1312 1313ir_node *(get_Mux_true)(const ir_node *node) 1314{ 1315 assert(is_Mux(node)); 1316 return get_irn_n(node, n_Mux_true); 1317} 1318 1319void (set_Mux_true)(ir_node *node, ir_node *true_) 1320{ 1321 assert(is_Mux(node)); 1322 set_irn_n(node, n_Mux_true, true_); 1323} 1324 1325 1326 1327ir_node *(get_Not_op)(const ir_node *node) 1328{ 1329 assert(is_Not(node)); 1330 return get_irn_n(node, n_Not_op); 1331} 1332 1333void (set_Not_op)(ir_node *node, ir_node *op) 1334{ 1335 assert(is_Not(node)); 1336 set_irn_n(node, n_Not_op, op); 1337} 1338 1339 1340ir_node *(get_Or_left)(const ir_node *node) 1341{ 1342 assert(is_Or(node)); 1343 return get_irn_n(node, n_Or_left); 1344} 1345 1346void (set_Or_left)(ir_node *node, ir_node *left) 1347{ 1348 assert(is_Or(node)); 1349 set_irn_n(node, n_Or_left, left); 1350} 1351 1352ir_node *(get_Or_right)(const ir_node *node) 1353{ 1354 assert(is_Or(node)); 1355 return get_irn_n(node, n_Or_right); 1356} 1357 1358void (set_Or_right)(ir_node *node, ir_node *right) 1359{ 1360 assert(is_Or(node)); 1361 set_irn_n(node, n_Or_right, right); 1362} 1363 1364 1365 1366ir_node *(get_Pin_op)(const ir_node *node) 1367{ 1368 assert(is_Pin(node)); 1369 return get_irn_n(node, n_Pin_op); 1370} 1371 1372void (set_Pin_op)(ir_node *node, ir_node *op) 1373{ 1374 assert(is_Pin(node)); 1375 set_irn_n(node, n_Pin_op, op); 1376} 1377 1378 1379ir_node *(get_Proj_pred)(const ir_node *node) 1380{ 1381 assert(is_Proj(node)); 1382 return get_irn_n(node, n_Proj_pred); 1383} 1384 1385void (set_Proj_pred)(ir_node *node, ir_node *pred) 1386{ 1387 assert(is_Proj(node)); 1388 set_irn_n(node, n_Proj_pred, pred); 1389} 1390 1391 1392ir_node *(get_Raise_mem)(const ir_node *node) 1393{ 1394 assert(is_Raise(node)); 1395 return get_irn_n(node, n_Raise_mem); 1396} 1397 1398void (set_Raise_mem)(ir_node *node, ir_node *mem) 1399{ 1400 assert(is_Raise(node)); 1401 set_irn_n(node, n_Raise_mem, mem); 1402} 1403 1404ir_node *(get_Raise_exo_ptr)(const ir_node *node) 1405{ 1406 assert(is_Raise(node)); 1407 return get_irn_n(node, n_Raise_exo_ptr); 1408} 1409 1410void (set_Raise_exo_ptr)(ir_node *node, ir_node *exo_ptr) 1411{ 1412 assert(is_Raise(node)); 1413 set_irn_n(node, n_Raise_exo_ptr, exo_ptr); 1414} 1415 1416 1417ir_node *(get_Return_mem)(const ir_node *node) 1418{ 1419 assert(is_Return(node)); 1420 return get_irn_n(node, n_Return_mem); 1421} 1422 1423void (set_Return_mem)(ir_node *node, ir_node *mem) 1424{ 1425 assert(is_Return(node)); 1426 set_irn_n(node, n_Return_mem, mem); 1427} 1428 1429 1430ir_node *(get_Rotl_left)(const ir_node *node) 1431{ 1432 assert(is_Rotl(node)); 1433 return get_irn_n(node, n_Rotl_left); 1434} 1435 1436void (set_Rotl_left)(ir_node *node, ir_node *left) 1437{ 1438 assert(is_Rotl(node)); 1439 set_irn_n(node, n_Rotl_left, left); 1440} 1441 1442ir_node *(get_Rotl_right)(const ir_node *node) 1443{ 1444 assert(is_Rotl(node)); 1445 return get_irn_n(node, n_Rotl_right); 1446} 1447 1448void (set_Rotl_right)(ir_node *node, ir_node *right) 1449{ 1450 assert(is_Rotl(node)); 1451 set_irn_n(node, n_Rotl_right, right); 1452} 1453 1454 1455ir_node *(get_Sel_mem)(const ir_node *node) 1456{ 1457 assert(is_Sel(node)); 1458 return get_irn_n(node, n_Sel_mem); 1459} 1460 1461void (set_Sel_mem)(ir_node *node, ir_node *mem) 1462{ 1463 assert(is_Sel(node)); 1464 set_irn_n(node, n_Sel_mem, mem); 1465} 1466 1467ir_node *(get_Sel_ptr)(const ir_node *node) 1468{ 1469 assert(is_Sel(node)); 1470 return get_irn_n(node, n_Sel_ptr); 1471} 1472 1473void (set_Sel_ptr)(ir_node *node, ir_node *ptr) 1474{ 1475 assert(is_Sel(node)); 1476 set_irn_n(node, n_Sel_ptr, ptr); 1477} 1478 1479 1480ir_node *(get_Shl_left)(const ir_node *node) 1481{ 1482 assert(is_Shl(node)); 1483 return get_irn_n(node, n_Shl_left); 1484} 1485 1486void (set_Shl_left)(ir_node *node, ir_node *left) 1487{ 1488 assert(is_Shl(node)); 1489 set_irn_n(node, n_Shl_left, left); 1490} 1491 1492ir_node *(get_Shl_right)(const ir_node *node) 1493{ 1494 assert(is_Shl(node)); 1495 return get_irn_n(node, n_Shl_right); 1496} 1497 1498void (set_Shl_right)(ir_node *node, ir_node *right) 1499{ 1500 assert(is_Shl(node)); 1501 set_irn_n(node, n_Shl_right, right); 1502} 1503 1504 1505ir_node *(get_Shr_left)(const ir_node *node) 1506{ 1507 assert(is_Shr(node)); 1508 return get_irn_n(node, n_Shr_left); 1509} 1510 1511void (set_Shr_left)(ir_node *node, ir_node *left) 1512{ 1513 assert(is_Shr(node)); 1514 set_irn_n(node, n_Shr_left, left); 1515} 1516 1517ir_node *(get_Shr_right)(const ir_node *node) 1518{ 1519 assert(is_Shr(node)); 1520 return get_irn_n(node, n_Shr_right); 1521} 1522 1523void (set_Shr_right)(ir_node *node, ir_node *right) 1524{ 1525 assert(is_Shr(node)); 1526 set_irn_n(node, n_Shr_right, right); 1527} 1528 1529 1530ir_node *(get_Shrs_left)(const ir_node *node) 1531{ 1532 assert(is_Shrs(node)); 1533 return get_irn_n(node, n_Shrs_left); 1534} 1535 1536void (set_Shrs_left)(ir_node *node, ir_node *left) 1537{ 1538 assert(is_Shrs(node)); 1539 set_irn_n(node, n_Shrs_left, left); 1540} 1541 1542ir_node *(get_Shrs_right)(const ir_node *node) 1543{ 1544 assert(is_Shrs(node)); 1545 return get_irn_n(node, n_Shrs_right); 1546} 1547 1548void (set_Shrs_right)(ir_node *node, ir_node *right) 1549{ 1550 assert(is_Shrs(node)); 1551 set_irn_n(node, n_Shrs_right, right); 1552} 1553 1554 1555 1556ir_node *(get_Store_mem)(const ir_node *node) 1557{ 1558 assert(is_Store(node)); 1559 return get_irn_n(node, n_Store_mem); 1560} 1561 1562void (set_Store_mem)(ir_node *node, ir_node *mem) 1563{ 1564 assert(is_Store(node)); 1565 set_irn_n(node, n_Store_mem, mem); 1566} 1567 1568ir_node *(get_Store_ptr)(const ir_node *node) 1569{ 1570 assert(is_Store(node)); 1571 return get_irn_n(node, n_Store_ptr); 1572} 1573 1574void (set_Store_ptr)(ir_node *node, ir_node *ptr) 1575{ 1576 assert(is_Store(node)); 1577 set_irn_n(node, n_Store_ptr, ptr); 1578} 1579 1580ir_node *(get_Store_value)(const ir_node *node) 1581{ 1582 assert(is_Store(node)); 1583 return get_irn_n(node, n_Store_value); 1584} 1585 1586void (set_Store_value)(ir_node *node, ir_node *value) 1587{ 1588 assert(is_Store(node)); 1589 set_irn_n(node, n_Store_value, value); 1590} 1591 1592 1593ir_node *(get_Sub_left)(const ir_node *node) 1594{ 1595 assert(is_Sub(node)); 1596 return get_irn_n(node, n_Sub_left); 1597} 1598 1599void (set_Sub_left)(ir_node *node, ir_node *left) 1600{ 1601 assert(is_Sub(node)); 1602 set_irn_n(node, n_Sub_left, left); 1603} 1604 1605ir_node *(get_Sub_right)(const ir_node *node) 1606{ 1607 assert(is_Sub(node)); 1608 return get_irn_n(node, n_Sub_right); 1609} 1610 1611void (set_Sub_right)(ir_node *node, ir_node *right) 1612{ 1613 assert(is_Sub(node)); 1614 set_irn_n(node, n_Sub_right, right); 1615} 1616 1617 1618ir_node *(get_Switch_selector)(const ir_node *node) 1619{ 1620 assert(is_Switch(node)); 1621 return get_irn_n(node, n_Switch_selector); 1622} 1623 1624void (set_Switch_selector)(ir_node *node, ir_node *selector) 1625{ 1626 assert(is_Switch(node)); 1627 set_irn_n(node, n_Switch_selector, selector); 1628} 1629 1630 1631 1632 1633 1634