1/* Warning: automatically generated code */ 2static ir_node *read_Add(read_env_t *env) 3{ 4 ir_node *block = read_node_ref(env); 5 ir_node *in_left = read_node_ref(env); 6 ir_node *in_right = read_node_ref(env); 7 ir_mode *mode = read_mode_ref(env); 8 ir_node *res; 9 res = new_r_Add(block, in_left, in_right, mode); 10 return res; 11} 12 13static ir_node *read_Alloc(read_env_t *env) 14{ 15 ir_node *block = read_node_ref(env); 16 ir_node *in_mem = read_node_ref(env); 17 ir_node *in_count = read_node_ref(env); 18 ir_type* type = read_type_ref(env); 19 ir_where_alloc where = read_where_alloc(env); 20 op_pin_state pin_state = read_pin_state(env); 21 bool throws = read_throws(env); 22 ir_node *res; 23 res = new_r_Alloc(block, in_mem, in_count, type, where); 24 set_irn_pinned(res, pin_state); 25 ir_set_throws_exception(res, throws); 26 return res; 27} 28 29static ir_node *read_And(read_env_t *env) 30{ 31 ir_node *block = read_node_ref(env); 32 ir_node *in_left = read_node_ref(env); 33 ir_node *in_right = read_node_ref(env); 34 ir_mode *mode = read_mode_ref(env); 35 ir_node *res; 36 res = new_r_And(block, in_left, in_right, mode); 37 return res; 38} 39 40static ir_node *read_Bad(read_env_t *env) 41{ 42 ir_mode *mode = read_mode_ref(env); 43 ir_node *res; 44 res = new_r_Bad(env->irg, mode); 45 return res; 46} 47 48static ir_node *read_Borrow(read_env_t *env) 49{ 50 ir_node *block = read_node_ref(env); 51 ir_node *in_left = read_node_ref(env); 52 ir_node *in_right = read_node_ref(env); 53 ir_mode *mode = read_mode_ref(env); 54 ir_node *res; 55 res = new_r_Borrow(block, in_left, in_right, mode); 56 return res; 57} 58 59static ir_node *read_Bound(read_env_t *env) 60{ 61 ir_node *block = read_node_ref(env); 62 ir_node *in_mem = read_node_ref(env); 63 ir_node *in_index = read_node_ref(env); 64 ir_node *in_lower = read_node_ref(env); 65 ir_node *in_upper = read_node_ref(env); 66 op_pin_state pin_state = read_pin_state(env); 67 bool throws = read_throws(env); 68 ir_node *res; 69 res = new_r_Bound(block, in_mem, in_index, in_lower, in_upper); 70 set_irn_pinned(res, pin_state); 71 ir_set_throws_exception(res, throws); 72 return res; 73} 74 75static ir_node *read_Builtin(read_env_t *env) 76{ 77 ir_node *block = read_node_ref(env); 78 ir_node *in_mem = read_node_ref(env); 79 ir_builtin_kind kind = read_builtin_kind(env); 80 ir_type* type = read_type_ref(env); 81 op_pin_state pin_state = read_pin_state(env); 82 int n_preds = read_preds(env); 83 ir_node **preds = (ir_node**)obstack_finish(&env->preds_obst); 84 ir_node *res; 85 res = new_r_Builtin(block, in_mem, n_preds, preds, kind, type); 86 obstack_free(&env->preds_obst, preds); 87 set_irn_pinned(res, pin_state); 88 return res; 89} 90 91static ir_node *read_Call(read_env_t *env) 92{ 93 ir_node *block = read_node_ref(env); 94 ir_node *in_mem = read_node_ref(env); 95 ir_node *in_ptr = read_node_ref(env); 96 ir_type* type = read_type_ref(env); 97 op_pin_state pin_state = read_pin_state(env); 98 bool throws = read_throws(env); 99 int n_preds = read_preds(env); 100 ir_node **preds = (ir_node**)obstack_finish(&env->preds_obst); 101 ir_node *res; 102 res = new_r_Call(block, in_mem, in_ptr, n_preds, preds, type); 103 obstack_free(&env->preds_obst, preds); 104 set_irn_pinned(res, pin_state); 105 ir_set_throws_exception(res, throws); 106 return res; 107} 108 109static ir_node *read_Carry(read_env_t *env) 110{ 111 ir_node *block = read_node_ref(env); 112 ir_node *in_left = read_node_ref(env); 113 ir_node *in_right = read_node_ref(env); 114 ir_mode *mode = read_mode_ref(env); 115 ir_node *res; 116 res = new_r_Carry(block, in_left, in_right, mode); 117 return res; 118} 119 120static ir_node *read_Cast(read_env_t *env) 121{ 122 ir_node *block = read_node_ref(env); 123 ir_node *in_op = read_node_ref(env); 124 ir_type* type = read_type_ref(env); 125 ir_node *res; 126 res = new_r_Cast(block, in_op, type); 127 return res; 128} 129 130static ir_node *read_Cmp(read_env_t *env) 131{ 132 ir_node *block = read_node_ref(env); 133 ir_node *in_left = read_node_ref(env); 134 ir_node *in_right = read_node_ref(env); 135 ir_relation relation = read_relation(env); 136 ir_node *res; 137 res = new_r_Cmp(block, in_left, in_right, relation); 138 return res; 139} 140 141static ir_node *read_Cond(read_env_t *env) 142{ 143 ir_node *block = read_node_ref(env); 144 ir_node *in_selector = read_node_ref(env); 145 cond_jmp_predicate jmp_pred = read_cond_jmp_predicate(env); 146 ir_node *res; 147 res = new_r_Cond(block, in_selector); 148 set_Cond_jmp_pred(res, jmp_pred); 149 return res; 150} 151 152static ir_node *read_Confirm(read_env_t *env) 153{ 154 ir_node *block = read_node_ref(env); 155 ir_node *in_value = read_node_ref(env); 156 ir_node *in_bound = read_node_ref(env); 157 ir_relation relation = read_relation(env); 158 ir_node *res; 159 res = new_r_Confirm(block, in_value, in_bound, relation); 160 return res; 161} 162 163static ir_node *read_Const(read_env_t *env) 164{ 165 ir_tarval* tarval = read_tarval(env); 166 ir_node *res; 167 res = new_r_Const(env->irg, tarval); 168 return res; 169} 170 171static ir_node *read_Conv(read_env_t *env) 172{ 173 ir_node *block = read_node_ref(env); 174 ir_node *in_op = read_node_ref(env); 175 ir_mode *mode = read_mode_ref(env); 176 ir_node *res; 177 res = new_r_Conv(block, in_op, mode); 178 return res; 179} 180 181static ir_node *read_CopyB(read_env_t *env) 182{ 183 ir_node *block = read_node_ref(env); 184 ir_node *in_mem = read_node_ref(env); 185 ir_node *in_dst = read_node_ref(env); 186 ir_node *in_src = read_node_ref(env); 187 ir_type* type = read_type_ref(env); 188 op_pin_state pin_state = read_pin_state(env); 189 bool throws = read_throws(env); 190 ir_node *res; 191 res = new_r_CopyB(block, in_mem, in_dst, in_src, type); 192 set_irn_pinned(res, pin_state); 193 ir_set_throws_exception(res, throws); 194 return res; 195} 196 197static ir_node *read_Div(read_env_t *env) 198{ 199 ir_node *block = read_node_ref(env); 200 ir_node *in_mem = read_node_ref(env); 201 ir_node *in_left = read_node_ref(env); 202 ir_node *in_right = read_node_ref(env); 203 ir_mode* resmode = read_mode_ref(env); 204 int no_remainder = read_int(env); 205 op_pin_state pin_state = read_pin_state(env); 206 bool throws = read_throws(env); 207 ir_node *res; 208 res = new_r_Div(block, in_mem, in_left, in_right, resmode, pin_state); 209 set_Div_no_remainder(res, no_remainder); 210 ir_set_throws_exception(res, throws); 211 return res; 212} 213 214static ir_node *read_Dummy(read_env_t *env) 215{ 216 ir_mode *mode = read_mode_ref(env); 217 ir_node *res; 218 res = new_r_Dummy(env->irg, mode); 219 return res; 220} 221 222static ir_node *read_End(read_env_t *env) 223{ 224 int n_preds = read_preds(env); 225 ir_node **preds = (ir_node**)obstack_finish(&env->preds_obst); 226 ir_node *res; 227 res = new_r_End(env->irg, n_preds, preds); 228 obstack_free(&env->preds_obst, preds); 229 return res; 230} 231 232static ir_node *read_Eor(read_env_t *env) 233{ 234 ir_node *block = read_node_ref(env); 235 ir_node *in_left = read_node_ref(env); 236 ir_node *in_right = read_node_ref(env); 237 ir_mode *mode = read_mode_ref(env); 238 ir_node *res; 239 res = new_r_Eor(block, in_left, in_right, mode); 240 return res; 241} 242 243static ir_node *read_Free(read_env_t *env) 244{ 245 ir_node *block = read_node_ref(env); 246 ir_node *in_mem = read_node_ref(env); 247 ir_node *in_ptr = read_node_ref(env); 248 ir_node *in_count = read_node_ref(env); 249 ir_type* type = read_type_ref(env); 250 ir_where_alloc where = read_where_alloc(env); 251 ir_node *res; 252 res = new_r_Free(block, in_mem, in_ptr, in_count, type, where); 253 return res; 254} 255 256static ir_node *read_IJmp(read_env_t *env) 257{ 258 ir_node *block = read_node_ref(env); 259 ir_node *in_target = read_node_ref(env); 260 ir_node *res; 261 res = new_r_IJmp(block, in_target); 262 return res; 263} 264 265static ir_node *read_Id(read_env_t *env) 266{ 267 ir_node *block = read_node_ref(env); 268 ir_node *in_pred = read_node_ref(env); 269 ir_mode *mode = read_mode_ref(env); 270 ir_node *res; 271 res = new_r_Id(block, in_pred, mode); 272 return res; 273} 274 275static ir_node *read_InstOf(read_env_t *env) 276{ 277 ir_node *block = read_node_ref(env); 278 ir_node *in_store = read_node_ref(env); 279 ir_node *in_obj = read_node_ref(env); 280 ir_type* type = read_type_ref(env); 281 op_pin_state pin_state = read_pin_state(env); 282 ir_node *res; 283 res = new_r_InstOf(block, in_store, in_obj, type); 284 set_irn_pinned(res, pin_state); 285 return res; 286} 287 288static ir_node *read_Jmp(read_env_t *env) 289{ 290 ir_node *block = read_node_ref(env); 291 ir_node *res; 292 res = new_r_Jmp(block); 293 return res; 294} 295 296static ir_node *read_Load(read_env_t *env) 297{ 298 ir_node *block = read_node_ref(env); 299 ir_node *in_mem = read_node_ref(env); 300 ir_node *in_ptr = read_node_ref(env); 301 ir_mode* mode = read_mode_ref(env); 302 ir_volatility volatility = read_volatility(env); 303 ir_align unaligned = read_align(env); 304 op_pin_state pin_state = read_pin_state(env); 305 bool throws = read_throws(env); 306 ir_cons_flags flags = cons_none; 307 ir_node *res; 308 flags |= volatility == volatility_is_volatile ? cons_volatile : cons_none; 309 flags |= unaligned == align_non_aligned ? cons_unaligned : cons_none; 310 flags |= pin_state == op_pin_state_floats ? cons_floats : cons_none; 311 flags |= throws ? cons_throws_exception : cons_none; 312 res = new_r_Load(block, in_mem, in_ptr, mode, flags); 313 return res; 314} 315 316static ir_node *read_Minus(read_env_t *env) 317{ 318 ir_node *block = read_node_ref(env); 319 ir_node *in_op = read_node_ref(env); 320 ir_mode *mode = read_mode_ref(env); 321 ir_node *res; 322 res = new_r_Minus(block, in_op, mode); 323 return res; 324} 325 326static ir_node *read_Mod(read_env_t *env) 327{ 328 ir_node *block = read_node_ref(env); 329 ir_node *in_mem = read_node_ref(env); 330 ir_node *in_left = read_node_ref(env); 331 ir_node *in_right = read_node_ref(env); 332 ir_mode* resmode = read_mode_ref(env); 333 op_pin_state pin_state = read_pin_state(env); 334 bool throws = read_throws(env); 335 ir_node *res; 336 res = new_r_Mod(block, in_mem, in_left, in_right, resmode, pin_state); 337 ir_set_throws_exception(res, throws); 338 return res; 339} 340 341static ir_node *read_Mul(read_env_t *env) 342{ 343 ir_node *block = read_node_ref(env); 344 ir_node *in_left = read_node_ref(env); 345 ir_node *in_right = read_node_ref(env); 346 ir_mode *mode = read_mode_ref(env); 347 ir_node *res; 348 res = new_r_Mul(block, in_left, in_right, mode); 349 return res; 350} 351 352static ir_node *read_Mulh(read_env_t *env) 353{ 354 ir_node *block = read_node_ref(env); 355 ir_node *in_left = read_node_ref(env); 356 ir_node *in_right = read_node_ref(env); 357 ir_mode *mode = read_mode_ref(env); 358 ir_node *res; 359 res = new_r_Mulh(block, in_left, in_right, mode); 360 return res; 361} 362 363static ir_node *read_Mux(read_env_t *env) 364{ 365 ir_node *block = read_node_ref(env); 366 ir_node *in_sel = read_node_ref(env); 367 ir_node *in_false = read_node_ref(env); 368 ir_node *in_true = read_node_ref(env); 369 ir_mode *mode = read_mode_ref(env); 370 ir_node *res; 371 res = new_r_Mux(block, in_sel, in_false, in_true, mode); 372 return res; 373} 374 375static ir_node *read_NoMem(read_env_t *env) 376{ 377 ir_node *res; 378 res = new_r_NoMem(env->irg); 379 return res; 380} 381 382static ir_node *read_Not(read_env_t *env) 383{ 384 ir_node *block = read_node_ref(env); 385 ir_node *in_op = read_node_ref(env); 386 ir_mode *mode = read_mode_ref(env); 387 ir_node *res; 388 res = new_r_Not(block, in_op, mode); 389 return res; 390} 391 392static ir_node *read_Or(read_env_t *env) 393{ 394 ir_node *block = read_node_ref(env); 395 ir_node *in_left = read_node_ref(env); 396 ir_node *in_right = read_node_ref(env); 397 ir_mode *mode = read_mode_ref(env); 398 ir_node *res; 399 res = new_r_Or(block, in_left, in_right, mode); 400 return res; 401} 402 403static ir_node *read_Pin(read_env_t *env) 404{ 405 ir_node *block = read_node_ref(env); 406 ir_node *in_op = read_node_ref(env); 407 ir_node *res; 408 res = new_r_Pin(block, in_op); 409 return res; 410} 411 412static ir_node *read_Proj(read_env_t *env) 413{ 414 ir_node *in_pred = read_node_ref(env); 415 ir_mode *mode = read_mode_ref(env); 416 long proj = read_long(env); 417 ir_node *res; 418 res = new_r_Proj(in_pred, mode, proj); 419 return res; 420} 421 422static ir_node *read_Raise(read_env_t *env) 423{ 424 ir_node *block = read_node_ref(env); 425 ir_node *in_mem = read_node_ref(env); 426 ir_node *in_exo_ptr = read_node_ref(env); 427 ir_node *res; 428 res = new_r_Raise(block, in_mem, in_exo_ptr); 429 return res; 430} 431 432static ir_node *read_Return(read_env_t *env) 433{ 434 ir_node *block = read_node_ref(env); 435 ir_node *in_mem = read_node_ref(env); 436 int n_preds = read_preds(env); 437 ir_node **preds = (ir_node**)obstack_finish(&env->preds_obst); 438 ir_node *res; 439 res = new_r_Return(block, in_mem, n_preds, preds); 440 obstack_free(&env->preds_obst, preds); 441 return res; 442} 443 444static ir_node *read_Rotl(read_env_t *env) 445{ 446 ir_node *block = read_node_ref(env); 447 ir_node *in_left = read_node_ref(env); 448 ir_node *in_right = read_node_ref(env); 449 ir_mode *mode = read_mode_ref(env); 450 ir_node *res; 451 res = new_r_Rotl(block, in_left, in_right, mode); 452 return res; 453} 454 455static ir_node *read_Sel(read_env_t *env) 456{ 457 ir_node *block = read_node_ref(env); 458 ir_node *in_mem = read_node_ref(env); 459 ir_node *in_ptr = read_node_ref(env); 460 ir_entity* entity = read_entity_ref(env); 461 int n_preds = read_preds(env); 462 ir_node **preds = (ir_node**)obstack_finish(&env->preds_obst); 463 ir_node *res; 464 res = new_r_Sel(block, in_mem, in_ptr, n_preds, preds, entity); 465 obstack_free(&env->preds_obst, preds); 466 return res; 467} 468 469static ir_node *read_Shl(read_env_t *env) 470{ 471 ir_node *block = read_node_ref(env); 472 ir_node *in_left = read_node_ref(env); 473 ir_node *in_right = read_node_ref(env); 474 ir_mode *mode = read_mode_ref(env); 475 ir_node *res; 476 res = new_r_Shl(block, in_left, in_right, mode); 477 return res; 478} 479 480static ir_node *read_Shr(read_env_t *env) 481{ 482 ir_node *block = read_node_ref(env); 483 ir_node *in_left = read_node_ref(env); 484 ir_node *in_right = read_node_ref(env); 485 ir_mode *mode = read_mode_ref(env); 486 ir_node *res; 487 res = new_r_Shr(block, in_left, in_right, mode); 488 return res; 489} 490 491static ir_node *read_Shrs(read_env_t *env) 492{ 493 ir_node *block = read_node_ref(env); 494 ir_node *in_left = read_node_ref(env); 495 ir_node *in_right = read_node_ref(env); 496 ir_mode *mode = read_mode_ref(env); 497 ir_node *res; 498 res = new_r_Shrs(block, in_left, in_right, mode); 499 return res; 500} 501 502static ir_node *read_Start(read_env_t *env) 503{ 504 ir_node *res; 505 res = new_r_Start(env->irg); 506 return res; 507} 508 509static ir_node *read_Store(read_env_t *env) 510{ 511 ir_node *block = read_node_ref(env); 512 ir_node *in_mem = read_node_ref(env); 513 ir_node *in_ptr = read_node_ref(env); 514 ir_node *in_value = read_node_ref(env); 515 ir_volatility volatility = read_volatility(env); 516 ir_align unaligned = read_align(env); 517 op_pin_state pin_state = read_pin_state(env); 518 bool throws = read_throws(env); 519 ir_cons_flags flags = cons_none; 520 ir_node *res; 521 flags |= volatility == volatility_is_volatile ? cons_volatile : cons_none; 522 flags |= unaligned == align_non_aligned ? cons_unaligned : cons_none; 523 flags |= pin_state == op_pin_state_floats ? cons_floats : cons_none; 524 flags |= throws ? cons_throws_exception : cons_none; 525 res = new_r_Store(block, in_mem, in_ptr, in_value, flags); 526 return res; 527} 528 529static ir_node *read_Sub(read_env_t *env) 530{ 531 ir_node *block = read_node_ref(env); 532 ir_node *in_left = read_node_ref(env); 533 ir_node *in_right = read_node_ref(env); 534 ir_mode *mode = read_mode_ref(env); 535 ir_node *res; 536 res = new_r_Sub(block, in_left, in_right, mode); 537 return res; 538} 539 540static ir_node *read_Switch(read_env_t *env) 541{ 542 ir_node *block = read_node_ref(env); 543 ir_node *in_selector = read_node_ref(env); 544 unsigned n_outs = read_unsigned(env); 545 ir_switch_table* table = read_switch_table(env); 546 ir_node *res; 547 res = new_r_Switch(block, in_selector, n_outs, table); 548 return res; 549} 550 551static ir_node *read_Sync(read_env_t *env) 552{ 553 ir_node *block = read_node_ref(env); 554 int n_preds = read_preds(env); 555 ir_node **preds = (ir_node**)obstack_finish(&env->preds_obst); 556 ir_node *res; 557 res = new_r_Sync(block, n_preds, preds); 558 obstack_free(&env->preds_obst, preds); 559 return res; 560} 561 562static ir_node *read_Tuple(read_env_t *env) 563{ 564 ir_node *block = read_node_ref(env); 565 int n_preds = read_preds(env); 566 ir_node **preds = (ir_node**)obstack_finish(&env->preds_obst); 567 ir_node *res; 568 res = new_r_Tuple(block, n_preds, preds); 569 obstack_free(&env->preds_obst, preds); 570 return res; 571} 572 573static ir_node *read_Unknown(read_env_t *env) 574{ 575 ir_mode *mode = read_mode_ref(env); 576 ir_node *res; 577 res = new_r_Unknown(env->irg, mode); 578 return res; 579} 580 581static void write_Add(write_env_t *env, const ir_node *node) 582{ 583 write_symbol(env, "Add"); 584 write_node_nr(env, node); 585 write_node_ref(env, get_nodes_block(node)); 586 write_node_ref(env, get_Add_left(node)); 587 write_node_ref(env, get_Add_right(node)); 588 write_mode_ref(env, get_irn_mode(node)); 589} 590 591static void write_Alloc(write_env_t *env, const ir_node *node) 592{ 593 write_symbol(env, "Alloc"); 594 write_node_nr(env, node); 595 write_node_ref(env, get_nodes_block(node)); 596 write_node_ref(env, get_Alloc_mem(node)); 597 write_node_ref(env, get_Alloc_count(node)); 598 write_type_ref(env, get_Alloc_type(node)); 599 write_where_alloc(env, get_Alloc_where(node)); 600 write_pin_state(env, get_irn_pinned(node)); 601 write_throws(env, ir_throws_exception(node)); 602} 603 604static void write_And(write_env_t *env, const ir_node *node) 605{ 606 write_symbol(env, "And"); 607 write_node_nr(env, node); 608 write_node_ref(env, get_nodes_block(node)); 609 write_node_ref(env, get_And_left(node)); 610 write_node_ref(env, get_And_right(node)); 611 write_mode_ref(env, get_irn_mode(node)); 612} 613 614static void write_Bad(write_env_t *env, const ir_node *node) 615{ 616 write_symbol(env, "Bad"); 617 write_node_nr(env, node); 618 write_mode_ref(env, get_irn_mode(node)); 619} 620 621static void write_Borrow(write_env_t *env, const ir_node *node) 622{ 623 write_symbol(env, "Borrow"); 624 write_node_nr(env, node); 625 write_node_ref(env, get_nodes_block(node)); 626 write_node_ref(env, get_Borrow_left(node)); 627 write_node_ref(env, get_Borrow_right(node)); 628 write_mode_ref(env, get_irn_mode(node)); 629} 630 631static void write_Bound(write_env_t *env, const ir_node *node) 632{ 633 write_symbol(env, "Bound"); 634 write_node_nr(env, node); 635 write_node_ref(env, get_nodes_block(node)); 636 write_node_ref(env, get_Bound_mem(node)); 637 write_node_ref(env, get_Bound_index(node)); 638 write_node_ref(env, get_Bound_lower(node)); 639 write_node_ref(env, get_Bound_upper(node)); 640 write_pin_state(env, get_irn_pinned(node)); 641 write_throws(env, ir_throws_exception(node)); 642} 643 644static void write_Builtin(write_env_t *env, const ir_node *node) 645{ 646 write_symbol(env, "Builtin"); 647 write_node_nr(env, node); 648 write_node_ref(env, get_nodes_block(node)); 649 write_node_ref(env, get_Builtin_mem(node)); 650 write_builtin_kind(env, node); 651 write_type_ref(env, get_Builtin_type(node)); 652 write_pin_state(env, get_irn_pinned(node)); 653 write_pred_refs(env, node, n_Builtin_max+1); 654} 655 656static void write_Call(write_env_t *env, const ir_node *node) 657{ 658 write_symbol(env, "Call"); 659 write_node_nr(env, node); 660 write_node_ref(env, get_nodes_block(node)); 661 write_node_ref(env, get_Call_mem(node)); 662 write_node_ref(env, get_Call_ptr(node)); 663 write_type_ref(env, get_Call_type(node)); 664 write_pin_state(env, get_irn_pinned(node)); 665 write_throws(env, ir_throws_exception(node)); 666 write_pred_refs(env, node, n_Call_max+1); 667} 668 669static void write_Carry(write_env_t *env, const ir_node *node) 670{ 671 write_symbol(env, "Carry"); 672 write_node_nr(env, node); 673 write_node_ref(env, get_nodes_block(node)); 674 write_node_ref(env, get_Carry_left(node)); 675 write_node_ref(env, get_Carry_right(node)); 676 write_mode_ref(env, get_irn_mode(node)); 677} 678 679static void write_Cast(write_env_t *env, const ir_node *node) 680{ 681 write_symbol(env, "Cast"); 682 write_node_nr(env, node); 683 write_node_ref(env, get_nodes_block(node)); 684 write_node_ref(env, get_Cast_op(node)); 685 write_type_ref(env, get_Cast_type(node)); 686} 687 688static void write_Cmp(write_env_t *env, const ir_node *node) 689{ 690 write_symbol(env, "Cmp"); 691 write_node_nr(env, node); 692 write_node_ref(env, get_nodes_block(node)); 693 write_node_ref(env, get_Cmp_left(node)); 694 write_node_ref(env, get_Cmp_right(node)); 695 write_relation(env, get_Cmp_relation(node)); 696} 697 698static void write_Cond(write_env_t *env, const ir_node *node) 699{ 700 write_symbol(env, "Cond"); 701 write_node_nr(env, node); 702 write_node_ref(env, get_nodes_block(node)); 703 write_node_ref(env, get_Cond_selector(node)); 704 write_cond_jmp_predicate(env, node); 705} 706 707static void write_Confirm(write_env_t *env, const ir_node *node) 708{ 709 write_symbol(env, "Confirm"); 710 write_node_nr(env, node); 711 write_node_ref(env, get_nodes_block(node)); 712 write_node_ref(env, get_Confirm_value(node)); 713 write_node_ref(env, get_Confirm_bound(node)); 714 write_relation(env, get_Confirm_relation(node)); 715} 716 717static void write_Const(write_env_t *env, const ir_node *node) 718{ 719 write_symbol(env, "Const"); 720 write_node_nr(env, node); 721 write_tarval(env, get_Const_tarval(node)); 722} 723 724static void write_Conv(write_env_t *env, const ir_node *node) 725{ 726 write_symbol(env, "Conv"); 727 write_node_nr(env, node); 728 write_node_ref(env, get_nodes_block(node)); 729 write_node_ref(env, get_Conv_op(node)); 730 write_mode_ref(env, get_irn_mode(node)); 731} 732 733static void write_CopyB(write_env_t *env, const ir_node *node) 734{ 735 write_symbol(env, "CopyB"); 736 write_node_nr(env, node); 737 write_node_ref(env, get_nodes_block(node)); 738 write_node_ref(env, get_CopyB_mem(node)); 739 write_node_ref(env, get_CopyB_dst(node)); 740 write_node_ref(env, get_CopyB_src(node)); 741 write_type_ref(env, get_CopyB_type(node)); 742 write_pin_state(env, get_irn_pinned(node)); 743 write_throws(env, ir_throws_exception(node)); 744} 745 746static void write_Div(write_env_t *env, const ir_node *node) 747{ 748 write_symbol(env, "Div"); 749 write_node_nr(env, node); 750 write_node_ref(env, get_nodes_block(node)); 751 write_node_ref(env, get_Div_mem(node)); 752 write_node_ref(env, get_Div_left(node)); 753 write_node_ref(env, get_Div_right(node)); 754 write_mode_ref(env, get_Div_resmode(node)); 755 write_int(env, get_Div_no_remainder(node)); 756 write_pin_state(env, get_irn_pinned(node)); 757 write_throws(env, ir_throws_exception(node)); 758} 759 760static void write_Dummy(write_env_t *env, const ir_node *node) 761{ 762 write_symbol(env, "Dummy"); 763 write_node_nr(env, node); 764 write_mode_ref(env, get_irn_mode(node)); 765} 766 767static void write_End(write_env_t *env, const ir_node *node) 768{ 769 write_symbol(env, "End"); 770 write_node_nr(env, node); 771 write_pred_refs(env, node, 0); 772} 773 774static void write_Eor(write_env_t *env, const ir_node *node) 775{ 776 write_symbol(env, "Eor"); 777 write_node_nr(env, node); 778 write_node_ref(env, get_nodes_block(node)); 779 write_node_ref(env, get_Eor_left(node)); 780 write_node_ref(env, get_Eor_right(node)); 781 write_mode_ref(env, get_irn_mode(node)); 782} 783 784static void write_Free(write_env_t *env, const ir_node *node) 785{ 786 write_symbol(env, "Free"); 787 write_node_nr(env, node); 788 write_node_ref(env, get_nodes_block(node)); 789 write_node_ref(env, get_Free_mem(node)); 790 write_node_ref(env, get_Free_ptr(node)); 791 write_node_ref(env, get_Free_count(node)); 792 write_type_ref(env, get_Free_type(node)); 793 write_where_alloc(env, get_Free_where(node)); 794} 795 796static void write_IJmp(write_env_t *env, const ir_node *node) 797{ 798 write_symbol(env, "IJmp"); 799 write_node_nr(env, node); 800 write_node_ref(env, get_nodes_block(node)); 801 write_node_ref(env, get_IJmp_target(node)); 802} 803 804static void write_Id(write_env_t *env, const ir_node *node) 805{ 806 write_symbol(env, "Id"); 807 write_node_nr(env, node); 808 write_node_ref(env, get_nodes_block(node)); 809 write_node_ref(env, get_Id_pred(node)); 810 write_mode_ref(env, get_irn_mode(node)); 811} 812 813static void write_InstOf(write_env_t *env, const ir_node *node) 814{ 815 write_symbol(env, "InstOf"); 816 write_node_nr(env, node); 817 write_node_ref(env, get_nodes_block(node)); 818 write_node_ref(env, get_InstOf_store(node)); 819 write_node_ref(env, get_InstOf_obj(node)); 820 write_type_ref(env, get_InstOf_type(node)); 821 write_pin_state(env, get_irn_pinned(node)); 822} 823 824static void write_Jmp(write_env_t *env, const ir_node *node) 825{ 826 write_symbol(env, "Jmp"); 827 write_node_nr(env, node); 828 write_node_ref(env, get_nodes_block(node)); 829} 830 831static void write_Load(write_env_t *env, const ir_node *node) 832{ 833 write_symbol(env, "Load"); 834 write_node_nr(env, node); 835 write_node_ref(env, get_nodes_block(node)); 836 write_node_ref(env, get_Load_mem(node)); 837 write_node_ref(env, get_Load_ptr(node)); 838 write_mode_ref(env, get_Load_mode(node)); 839 write_volatility(env, get_Load_volatility(node)); 840 write_align(env, get_Load_unaligned(node)); 841 write_pin_state(env, get_irn_pinned(node)); 842 write_throws(env, ir_throws_exception(node)); 843} 844 845static void write_Minus(write_env_t *env, const ir_node *node) 846{ 847 write_symbol(env, "Minus"); 848 write_node_nr(env, node); 849 write_node_ref(env, get_nodes_block(node)); 850 write_node_ref(env, get_Minus_op(node)); 851 write_mode_ref(env, get_irn_mode(node)); 852} 853 854static void write_Mod(write_env_t *env, const ir_node *node) 855{ 856 write_symbol(env, "Mod"); 857 write_node_nr(env, node); 858 write_node_ref(env, get_nodes_block(node)); 859 write_node_ref(env, get_Mod_mem(node)); 860 write_node_ref(env, get_Mod_left(node)); 861 write_node_ref(env, get_Mod_right(node)); 862 write_mode_ref(env, get_Mod_resmode(node)); 863 write_pin_state(env, get_irn_pinned(node)); 864 write_throws(env, ir_throws_exception(node)); 865} 866 867static void write_Mul(write_env_t *env, const ir_node *node) 868{ 869 write_symbol(env, "Mul"); 870 write_node_nr(env, node); 871 write_node_ref(env, get_nodes_block(node)); 872 write_node_ref(env, get_Mul_left(node)); 873 write_node_ref(env, get_Mul_right(node)); 874 write_mode_ref(env, get_irn_mode(node)); 875} 876 877static void write_Mulh(write_env_t *env, const ir_node *node) 878{ 879 write_symbol(env, "Mulh"); 880 write_node_nr(env, node); 881 write_node_ref(env, get_nodes_block(node)); 882 write_node_ref(env, get_Mulh_left(node)); 883 write_node_ref(env, get_Mulh_right(node)); 884 write_mode_ref(env, get_irn_mode(node)); 885} 886 887static void write_Mux(write_env_t *env, const ir_node *node) 888{ 889 write_symbol(env, "Mux"); 890 write_node_nr(env, node); 891 write_node_ref(env, get_nodes_block(node)); 892 write_node_ref(env, get_Mux_sel(node)); 893 write_node_ref(env, get_Mux_false(node)); 894 write_node_ref(env, get_Mux_true(node)); 895 write_mode_ref(env, get_irn_mode(node)); 896} 897 898static void write_NoMem(write_env_t *env, const ir_node *node) 899{ 900 write_symbol(env, "NoMem"); 901 write_node_nr(env, node); 902} 903 904static void write_Not(write_env_t *env, const ir_node *node) 905{ 906 write_symbol(env, "Not"); 907 write_node_nr(env, node); 908 write_node_ref(env, get_nodes_block(node)); 909 write_node_ref(env, get_Not_op(node)); 910 write_mode_ref(env, get_irn_mode(node)); 911} 912 913static void write_Or(write_env_t *env, const ir_node *node) 914{ 915 write_symbol(env, "Or"); 916 write_node_nr(env, node); 917 write_node_ref(env, get_nodes_block(node)); 918 write_node_ref(env, get_Or_left(node)); 919 write_node_ref(env, get_Or_right(node)); 920 write_mode_ref(env, get_irn_mode(node)); 921} 922 923static void write_Pin(write_env_t *env, const ir_node *node) 924{ 925 write_symbol(env, "Pin"); 926 write_node_nr(env, node); 927 write_node_ref(env, get_nodes_block(node)); 928 write_node_ref(env, get_Pin_op(node)); 929} 930 931static void write_Proj(write_env_t *env, const ir_node *node) 932{ 933 write_symbol(env, "Proj"); 934 write_node_nr(env, node); 935 write_node_ref(env, get_Proj_pred(node)); 936 write_mode_ref(env, get_irn_mode(node)); 937 write_long(env, get_Proj_proj(node)); 938} 939 940static void write_Raise(write_env_t *env, const ir_node *node) 941{ 942 write_symbol(env, "Raise"); 943 write_node_nr(env, node); 944 write_node_ref(env, get_nodes_block(node)); 945 write_node_ref(env, get_Raise_mem(node)); 946 write_node_ref(env, get_Raise_exo_ptr(node)); 947} 948 949static void write_Return(write_env_t *env, const ir_node *node) 950{ 951 write_symbol(env, "Return"); 952 write_node_nr(env, node); 953 write_node_ref(env, get_nodes_block(node)); 954 write_node_ref(env, get_Return_mem(node)); 955 write_pred_refs(env, node, n_Return_max+1); 956} 957 958static void write_Rotl(write_env_t *env, const ir_node *node) 959{ 960 write_symbol(env, "Rotl"); 961 write_node_nr(env, node); 962 write_node_ref(env, get_nodes_block(node)); 963 write_node_ref(env, get_Rotl_left(node)); 964 write_node_ref(env, get_Rotl_right(node)); 965 write_mode_ref(env, get_irn_mode(node)); 966} 967 968static void write_Sel(write_env_t *env, const ir_node *node) 969{ 970 write_symbol(env, "Sel"); 971 write_node_nr(env, node); 972 write_node_ref(env, get_nodes_block(node)); 973 write_node_ref(env, get_Sel_mem(node)); 974 write_node_ref(env, get_Sel_ptr(node)); 975 write_entity_ref(env, get_Sel_entity(node)); 976 write_pred_refs(env, node, n_Sel_max+1); 977} 978 979static void write_Shl(write_env_t *env, const ir_node *node) 980{ 981 write_symbol(env, "Shl"); 982 write_node_nr(env, node); 983 write_node_ref(env, get_nodes_block(node)); 984 write_node_ref(env, get_Shl_left(node)); 985 write_node_ref(env, get_Shl_right(node)); 986 write_mode_ref(env, get_irn_mode(node)); 987} 988 989static void write_Shr(write_env_t *env, const ir_node *node) 990{ 991 write_symbol(env, "Shr"); 992 write_node_nr(env, node); 993 write_node_ref(env, get_nodes_block(node)); 994 write_node_ref(env, get_Shr_left(node)); 995 write_node_ref(env, get_Shr_right(node)); 996 write_mode_ref(env, get_irn_mode(node)); 997} 998 999static void write_Shrs(write_env_t *env, const ir_node *node) 1000{ 1001 write_symbol(env, "Shrs"); 1002 write_node_nr(env, node); 1003 write_node_ref(env, get_nodes_block(node)); 1004 write_node_ref(env, get_Shrs_left(node)); 1005 write_node_ref(env, get_Shrs_right(node)); 1006 write_mode_ref(env, get_irn_mode(node)); 1007} 1008 1009static void write_Start(write_env_t *env, const ir_node *node) 1010{ 1011 write_symbol(env, "Start"); 1012 write_node_nr(env, node); 1013} 1014 1015static void write_Store(write_env_t *env, const ir_node *node) 1016{ 1017 write_symbol(env, "Store"); 1018 write_node_nr(env, node); 1019 write_node_ref(env, get_nodes_block(node)); 1020 write_node_ref(env, get_Store_mem(node)); 1021 write_node_ref(env, get_Store_ptr(node)); 1022 write_node_ref(env, get_Store_value(node)); 1023 write_volatility(env, get_Store_volatility(node)); 1024 write_align(env, get_Store_unaligned(node)); 1025 write_pin_state(env, get_irn_pinned(node)); 1026 write_throws(env, ir_throws_exception(node)); 1027} 1028 1029static void write_Sub(write_env_t *env, const ir_node *node) 1030{ 1031 write_symbol(env, "Sub"); 1032 write_node_nr(env, node); 1033 write_node_ref(env, get_nodes_block(node)); 1034 write_node_ref(env, get_Sub_left(node)); 1035 write_node_ref(env, get_Sub_right(node)); 1036 write_mode_ref(env, get_irn_mode(node)); 1037} 1038 1039static void write_Switch(write_env_t *env, const ir_node *node) 1040{ 1041 write_symbol(env, "Switch"); 1042 write_node_nr(env, node); 1043 write_node_ref(env, get_nodes_block(node)); 1044 write_node_ref(env, get_Switch_selector(node)); 1045 write_unsigned(env, get_Switch_n_outs(node)); 1046 write_switch_table(env, get_Switch_table(node)); 1047} 1048 1049static void write_Sync(write_env_t *env, const ir_node *node) 1050{ 1051 write_symbol(env, "Sync"); 1052 write_node_nr(env, node); 1053 write_node_ref(env, get_nodes_block(node)); 1054 write_pred_refs(env, node, 0); 1055} 1056 1057static void write_Tuple(write_env_t *env, const ir_node *node) 1058{ 1059 write_symbol(env, "Tuple"); 1060 write_node_nr(env, node); 1061 write_node_ref(env, get_nodes_block(node)); 1062 write_pred_refs(env, node, 0); 1063} 1064 1065static void write_Unknown(write_env_t *env, const ir_node *node) 1066{ 1067 write_symbol(env, "Unknown"); 1068 write_node_nr(env, node); 1069 write_mode_ref(env, get_irn_mode(node)); 1070} 1071 1072 1073static void register_generated_node_readers(void) 1074{ 1075 register_node_reader(new_id_from_str("Add"), read_Add); 1076 register_node_reader(new_id_from_str("Alloc"), read_Alloc); 1077 register_node_reader(new_id_from_str("And"), read_And); 1078 register_node_reader(new_id_from_str("Bad"), read_Bad); 1079 register_node_reader(new_id_from_str("Borrow"), read_Borrow); 1080 register_node_reader(new_id_from_str("Bound"), read_Bound); 1081 register_node_reader(new_id_from_str("Builtin"), read_Builtin); 1082 register_node_reader(new_id_from_str("Call"), read_Call); 1083 register_node_reader(new_id_from_str("Carry"), read_Carry); 1084 register_node_reader(new_id_from_str("Cast"), read_Cast); 1085 register_node_reader(new_id_from_str("Cmp"), read_Cmp); 1086 register_node_reader(new_id_from_str("Cond"), read_Cond); 1087 register_node_reader(new_id_from_str("Confirm"), read_Confirm); 1088 register_node_reader(new_id_from_str("Const"), read_Const); 1089 register_node_reader(new_id_from_str("Conv"), read_Conv); 1090 register_node_reader(new_id_from_str("CopyB"), read_CopyB); 1091 register_node_reader(new_id_from_str("Div"), read_Div); 1092 register_node_reader(new_id_from_str("Dummy"), read_Dummy); 1093 register_node_reader(new_id_from_str("End"), read_End); 1094 register_node_reader(new_id_from_str("Eor"), read_Eor); 1095 register_node_reader(new_id_from_str("Free"), read_Free); 1096 register_node_reader(new_id_from_str("IJmp"), read_IJmp); 1097 register_node_reader(new_id_from_str("Id"), read_Id); 1098 register_node_reader(new_id_from_str("InstOf"), read_InstOf); 1099 register_node_reader(new_id_from_str("Jmp"), read_Jmp); 1100 register_node_reader(new_id_from_str("Load"), read_Load); 1101 register_node_reader(new_id_from_str("Minus"), read_Minus); 1102 register_node_reader(new_id_from_str("Mod"), read_Mod); 1103 register_node_reader(new_id_from_str("Mul"), read_Mul); 1104 register_node_reader(new_id_from_str("Mulh"), read_Mulh); 1105 register_node_reader(new_id_from_str("Mux"), read_Mux); 1106 register_node_reader(new_id_from_str("NoMem"), read_NoMem); 1107 register_node_reader(new_id_from_str("Not"), read_Not); 1108 register_node_reader(new_id_from_str("Or"), read_Or); 1109 register_node_reader(new_id_from_str("Pin"), read_Pin); 1110 register_node_reader(new_id_from_str("Proj"), read_Proj); 1111 register_node_reader(new_id_from_str("Raise"), read_Raise); 1112 register_node_reader(new_id_from_str("Return"), read_Return); 1113 register_node_reader(new_id_from_str("Rotl"), read_Rotl); 1114 register_node_reader(new_id_from_str("Sel"), read_Sel); 1115 register_node_reader(new_id_from_str("Shl"), read_Shl); 1116 register_node_reader(new_id_from_str("Shr"), read_Shr); 1117 register_node_reader(new_id_from_str("Shrs"), read_Shrs); 1118 register_node_reader(new_id_from_str("Start"), read_Start); 1119 register_node_reader(new_id_from_str("Store"), read_Store); 1120 register_node_reader(new_id_from_str("Sub"), read_Sub); 1121 register_node_reader(new_id_from_str("Switch"), read_Switch); 1122 register_node_reader(new_id_from_str("Sync"), read_Sync); 1123 register_node_reader(new_id_from_str("Tuple"), read_Tuple); 1124 register_node_reader(new_id_from_str("Unknown"), read_Unknown); 1125} 1126 1127static void register_generated_node_writers(void) 1128{ 1129 register_node_writer(op_Add, write_Add); 1130 register_node_writer(op_Alloc, write_Alloc); 1131 register_node_writer(op_And, write_And); 1132 register_node_writer(op_Bad, write_Bad); 1133 register_node_writer(op_Borrow, write_Borrow); 1134 register_node_writer(op_Bound, write_Bound); 1135 register_node_writer(op_Builtin, write_Builtin); 1136 register_node_writer(op_Call, write_Call); 1137 register_node_writer(op_Carry, write_Carry); 1138 register_node_writer(op_Cast, write_Cast); 1139 register_node_writer(op_Cmp, write_Cmp); 1140 register_node_writer(op_Cond, write_Cond); 1141 register_node_writer(op_Confirm, write_Confirm); 1142 register_node_writer(op_Const, write_Const); 1143 register_node_writer(op_Conv, write_Conv); 1144 register_node_writer(op_CopyB, write_CopyB); 1145 register_node_writer(op_Div, write_Div); 1146 register_node_writer(op_Dummy, write_Dummy); 1147 register_node_writer(op_End, write_End); 1148 register_node_writer(op_Eor, write_Eor); 1149 register_node_writer(op_Free, write_Free); 1150 register_node_writer(op_IJmp, write_IJmp); 1151 register_node_writer(op_Id, write_Id); 1152 register_node_writer(op_InstOf, write_InstOf); 1153 register_node_writer(op_Jmp, write_Jmp); 1154 register_node_writer(op_Load, write_Load); 1155 register_node_writer(op_Minus, write_Minus); 1156 register_node_writer(op_Mod, write_Mod); 1157 register_node_writer(op_Mul, write_Mul); 1158 register_node_writer(op_Mulh, write_Mulh); 1159 register_node_writer(op_Mux, write_Mux); 1160 register_node_writer(op_NoMem, write_NoMem); 1161 register_node_writer(op_Not, write_Not); 1162 register_node_writer(op_Or, write_Or); 1163 register_node_writer(op_Pin, write_Pin); 1164 register_node_writer(op_Proj, write_Proj); 1165 register_node_writer(op_Raise, write_Raise); 1166 register_node_writer(op_Return, write_Return); 1167 register_node_writer(op_Rotl, write_Rotl); 1168 register_node_writer(op_Sel, write_Sel); 1169 register_node_writer(op_Shl, write_Shl); 1170 register_node_writer(op_Shr, write_Shr); 1171 register_node_writer(op_Shrs, write_Shrs); 1172 register_node_writer(op_Start, write_Start); 1173 register_node_writer(op_Store, write_Store); 1174 register_node_writer(op_Sub, write_Sub); 1175 register_node_writer(op_Switch, write_Switch); 1176 register_node_writer(op_Sync, write_Sync); 1177 register_node_writer(op_Tuple, write_Tuple); 1178 register_node_writer(op_Unknown, write_Unknown); 1179} 1180