1/* Warning: automatically generated code */ 2ir_node *new_rd_Add(dbg_info *dbgi, ir_node *block, ir_node * irn_left, ir_node * irn_right, ir_mode * mode) 3{ 4 ir_graph *irg = get_irn_irg(block); 5 6 ir_node *in[2]; 7 in[0] = irn_left; 8 in[1] = irn_right; 9 10 ir_node *res = new_ir_node(dbgi, irg, block, op_Add, mode, 2, in); 11 irn_verify_irg(res, irg); 12 res = optimize_node(res); 13 return res; 14} 15 16ir_node *new_r_Add(ir_node *block, ir_node * irn_left, ir_node * irn_right, ir_mode * mode) 17{ 18 return new_rd_Add(NULL, block, irn_left, irn_right, mode); 19} 20 21ir_node *new_d_Add(dbg_info *dbgi, ir_node * irn_left, ir_node * irn_right, ir_mode * mode) 22{ 23 assert(irg_is_constrained(current_ir_graph, IR_GRAPH_CONSTRAINT_CONSTRUCTION)); 24 ir_node *res = new_rd_Add(dbgi, current_ir_graph->current_block, irn_left, irn_right, mode); 25 return res; 26} 27 28ir_node *new_Add(ir_node * irn_left, ir_node * irn_right, ir_mode * mode) 29{ 30 return new_d_Add(NULL, irn_left, irn_right, mode); 31} 32 33ir_node *new_rd_Alloc(dbg_info *dbgi, ir_node *block, ir_node * irn_mem, ir_node * irn_count, ir_type* type, ir_where_alloc where) 34{ 35 ir_graph *irg = get_irn_irg(block); 36 37 ir_node *in[2]; 38 in[0] = irn_mem; 39 in[1] = irn_count; 40 41 ir_node *res = new_ir_node(dbgi, irg, block, op_Alloc, mode_T, 2, in); 42 res->attr.alloc.type = type; 43 res->attr.alloc.where = where; 44 res->attr.alloc.exc.pin_state = op_pin_state_pinned; 45 res->attr.alloc.exc.throws_exception = false; 46 irn_verify_irg(res, irg); 47 res = optimize_node(res); 48 return res; 49} 50 51ir_node *new_r_Alloc(ir_node *block, ir_node * irn_mem, ir_node * irn_count, ir_type* type, ir_where_alloc where) 52{ 53 return new_rd_Alloc(NULL, block, irn_mem, irn_count, type, where); 54} 55 56ir_node *new_d_Alloc(dbg_info *dbgi, ir_node * irn_mem, ir_node * irn_count, ir_type* type, ir_where_alloc where) 57{ 58 assert(irg_is_constrained(current_ir_graph, IR_GRAPH_CONSTRAINT_CONSTRUCTION)); 59 ir_node *res = new_rd_Alloc(dbgi, current_ir_graph->current_block, irn_mem, irn_count, type, where); 60 return res; 61} 62 63ir_node *new_Alloc(ir_node * irn_mem, ir_node * irn_count, ir_type* type, ir_where_alloc where) 64{ 65 return new_d_Alloc(NULL, irn_mem, irn_count, type, where); 66} 67 68ir_node *new_rd_And(dbg_info *dbgi, ir_node *block, ir_node * irn_left, ir_node * irn_right, ir_mode * mode) 69{ 70 ir_graph *irg = get_irn_irg(block); 71 72 ir_node *in[2]; 73 in[0] = irn_left; 74 in[1] = irn_right; 75 76 ir_node *res = new_ir_node(dbgi, irg, block, op_And, mode, 2, in); 77 irn_verify_irg(res, irg); 78 res = optimize_node(res); 79 return res; 80} 81 82ir_node *new_r_And(ir_node *block, ir_node * irn_left, ir_node * irn_right, ir_mode * mode) 83{ 84 return new_rd_And(NULL, block, irn_left, irn_right, mode); 85} 86 87ir_node *new_d_And(dbg_info *dbgi, ir_node * irn_left, ir_node * irn_right, ir_mode * mode) 88{ 89 assert(irg_is_constrained(current_ir_graph, IR_GRAPH_CONSTRAINT_CONSTRUCTION)); 90 ir_node *res = new_rd_And(dbgi, current_ir_graph->current_block, irn_left, irn_right, mode); 91 return res; 92} 93 94ir_node *new_And(ir_node * irn_left, ir_node * irn_right, ir_mode * mode) 95{ 96 return new_d_And(NULL, irn_left, irn_right, mode); 97} 98 99ir_node *new_rd_Bad(dbg_info *dbgi, ir_graph *irg, ir_mode * mode) 100{ 101 102 103 104 ir_node *res = new_ir_node(dbgi, irg, get_irg_start_block(irg), op_Bad, mode, 0, NULL); 105 res->attr.bad.irg.irg = irg; 106 107 irn_verify_irg(res, irg); 108 res = optimize_node(res); 109 return res; 110} 111 112ir_node *new_r_Bad(ir_graph *irg, ir_mode * mode) 113{ 114 return new_rd_Bad(NULL, irg, mode); 115} 116 117ir_node *new_d_Bad(dbg_info *dbgi, ir_mode * mode) 118{ 119 assert(irg_is_constrained(current_ir_graph, IR_GRAPH_CONSTRAINT_CONSTRUCTION)); 120 ir_node *res = new_rd_Bad(dbgi, current_ir_graph, mode); 121 return res; 122} 123 124ir_node *new_Bad(ir_mode * mode) 125{ 126 return new_d_Bad(NULL, mode); 127} 128 129ir_node *new_rd_Block(dbg_info *dbgi, ir_graph *irg, int arity, ir_node *const * in) 130{ 131 132 133 134 ir_node *res = new_ir_node(dbgi, irg, NULL, op_Block, mode_BB, arity, in); 135 res->attr.block.entity = NULL; 136 res->attr.block.irg.irg = irg; 137 res->attr.block.backedge = new_backedge_arr(irg->obst, arity); 138 set_Block_matured(res, 1); 139 140 /* Create and initialize array for Phi-node construction. */ 141 if (irg_is_constrained(irg, IR_GRAPH_CONSTRAINT_CONSTRUCTION)) { 142 res->attr.block.graph_arr = NEW_ARR_D(ir_node *, irg->obst, irg->n_loc); 143 memset(res->attr.block.graph_arr, 0, irg->n_loc * sizeof(ir_node*)); 144 } 145 146 irn_verify_irg(res, irg); 147 res = optimize_node(res); 148 return res; 149} 150 151ir_node *new_r_Block(ir_graph *irg, int arity, ir_node *const * in) 152{ 153 return new_rd_Block(NULL, irg, arity, in); 154} 155 156ir_node *new_d_Block(dbg_info *dbgi, int arity, ir_node *const * in) 157{ 158 assert(irg_is_constrained(current_ir_graph, IR_GRAPH_CONSTRAINT_CONSTRUCTION)); 159 ir_node *res = new_rd_Block(dbgi, current_ir_graph, arity, in); 160 return res; 161} 162 163ir_node *new_Block(int arity, ir_node *const * in) 164{ 165 return new_d_Block(NULL, arity, in); 166} 167 168ir_node *new_rd_Borrow(dbg_info *dbgi, ir_node *block, ir_node * irn_left, ir_node * irn_right, ir_mode * mode) 169{ 170 ir_graph *irg = get_irn_irg(block); 171 172 ir_node *in[2]; 173 in[0] = irn_left; 174 in[1] = irn_right; 175 176 ir_node *res = new_ir_node(dbgi, irg, block, op_Borrow, mode, 2, in); 177 irn_verify_irg(res, irg); 178 res = optimize_node(res); 179 return res; 180} 181 182ir_node *new_r_Borrow(ir_node *block, ir_node * irn_left, ir_node * irn_right, ir_mode * mode) 183{ 184 return new_rd_Borrow(NULL, block, irn_left, irn_right, mode); 185} 186 187ir_node *new_d_Borrow(dbg_info *dbgi, ir_node * irn_left, ir_node * irn_right, ir_mode * mode) 188{ 189 assert(irg_is_constrained(current_ir_graph, IR_GRAPH_CONSTRAINT_CONSTRUCTION)); 190 ir_node *res = new_rd_Borrow(dbgi, current_ir_graph->current_block, irn_left, irn_right, mode); 191 return res; 192} 193 194ir_node *new_Borrow(ir_node * irn_left, ir_node * irn_right, ir_mode * mode) 195{ 196 return new_d_Borrow(NULL, irn_left, irn_right, mode); 197} 198 199ir_node *new_rd_Bound(dbg_info *dbgi, ir_node *block, ir_node * irn_mem, ir_node * irn_index, ir_node * irn_lower, ir_node * irn_upper) 200{ 201 ir_graph *irg = get_irn_irg(block); 202 203 ir_node *in[4]; 204 in[0] = irn_mem; 205 in[1] = irn_index; 206 in[2] = irn_lower; 207 in[3] = irn_upper; 208 209 ir_node *res = new_ir_node(dbgi, irg, block, op_Bound, mode_T, 4, in); 210 res->attr.bound.exc.pin_state = op_pin_state_pinned; 211 res->attr.bound.exc.throws_exception = false; 212 irn_verify_irg(res, irg); 213 res = optimize_node(res); 214 return res; 215} 216 217ir_node *new_r_Bound(ir_node *block, ir_node * irn_mem, ir_node * irn_index, ir_node * irn_lower, ir_node * irn_upper) 218{ 219 return new_rd_Bound(NULL, block, irn_mem, irn_index, irn_lower, irn_upper); 220} 221 222ir_node *new_d_Bound(dbg_info *dbgi, ir_node * irn_mem, ir_node * irn_index, ir_node * irn_lower, ir_node * irn_upper) 223{ 224 assert(irg_is_constrained(current_ir_graph, IR_GRAPH_CONSTRAINT_CONSTRUCTION)); 225 ir_node *res = new_rd_Bound(dbgi, current_ir_graph->current_block, irn_mem, irn_index, irn_lower, irn_upper); 226 return res; 227} 228 229ir_node *new_Bound(ir_node * irn_mem, ir_node * irn_index, ir_node * irn_lower, ir_node * irn_upper) 230{ 231 return new_d_Bound(NULL, irn_mem, irn_index, irn_lower, irn_upper); 232} 233 234ir_node *new_rd_Builtin(dbg_info *dbgi, ir_node *block, ir_node * irn_mem, int arity, ir_node *const * in, ir_builtin_kind kind, ir_type* type) 235{ 236 ir_graph *irg = get_irn_irg(block); 237 238 int r_arity = arity + 1; 239 ir_node **r_in; 240 NEW_ARR_A(ir_node *, r_in, r_arity); 241 r_in[0] = irn_mem; 242 memcpy(&r_in[1], in, sizeof(ir_node *) * arity); 243 244 245 ir_node *res = new_ir_node(dbgi, irg, block, op_Builtin, mode_T, r_arity, r_in); 246 res->attr.builtin.kind = kind; 247 res->attr.builtin.type = type; 248 res->attr.builtin.exc.pin_state = op_pin_state_pinned; 249 assert((get_unknown_type() == type) || is_Method_type(type)); 250 251 irn_verify_irg(res, irg); 252 res = optimize_node(res); 253 return res; 254} 255 256ir_node *new_r_Builtin(ir_node *block, ir_node * irn_mem, int arity, ir_node *const * in, ir_builtin_kind kind, ir_type* type) 257{ 258 return new_rd_Builtin(NULL, block, irn_mem, arity, in, kind, type); 259} 260 261ir_node *new_d_Builtin(dbg_info *dbgi, ir_node * irn_mem, int arity, ir_node *const * in, ir_builtin_kind kind, ir_type* type) 262{ 263 assert(irg_is_constrained(current_ir_graph, IR_GRAPH_CONSTRAINT_CONSTRUCTION)); 264 ir_node *res = new_rd_Builtin(dbgi, current_ir_graph->current_block, irn_mem, arity, in, kind, type); 265 return res; 266} 267 268ir_node *new_Builtin(ir_node * irn_mem, int arity, ir_node *const * in, ir_builtin_kind kind, ir_type* type) 269{ 270 return new_d_Builtin(NULL, irn_mem, arity, in, kind, type); 271} 272 273ir_node *new_rd_Call(dbg_info *dbgi, ir_node *block, ir_node * irn_mem, ir_node * irn_ptr, int arity, ir_node *const * in, ir_type* type) 274{ 275 ir_graph *irg = get_irn_irg(block); 276 277 int r_arity = arity + 2; 278 ir_node **r_in; 279 NEW_ARR_A(ir_node *, r_in, r_arity); 280 r_in[0] = irn_mem; 281 r_in[1] = irn_ptr; 282 memcpy(&r_in[2], in, sizeof(ir_node *) * arity); 283 284 285 ir_node *res = new_ir_node(dbgi, irg, block, op_Call, mode_T, r_arity, r_in); 286 res->attr.call.type = type; 287 res->attr.call.exc.pin_state = op_pin_state_pinned; 288 res->attr.call.exc.throws_exception = false; 289 assert((get_unknown_type() == type) || is_Method_type(type)); 290 291 irn_verify_irg(res, irg); 292 res = optimize_node(res); 293 return res; 294} 295 296ir_node *new_r_Call(ir_node *block, ir_node * irn_mem, ir_node * irn_ptr, int arity, ir_node *const * in, ir_type* type) 297{ 298 return new_rd_Call(NULL, block, irn_mem, irn_ptr, arity, in, type); 299} 300 301ir_node *new_d_Call(dbg_info *dbgi, ir_node * irn_mem, ir_node * irn_ptr, int arity, ir_node *const * in, ir_type* type) 302{ 303 assert(irg_is_constrained(current_ir_graph, IR_GRAPH_CONSTRAINT_CONSTRUCTION)); 304 ir_node *res = new_rd_Call(dbgi, current_ir_graph->current_block, irn_mem, irn_ptr, arity, in, type); 305 return res; 306} 307 308ir_node *new_Call(ir_node * irn_mem, ir_node * irn_ptr, int arity, ir_node *const * in, ir_type* type) 309{ 310 return new_d_Call(NULL, irn_mem, irn_ptr, arity, in, type); 311} 312 313ir_node *new_rd_Carry(dbg_info *dbgi, ir_node *block, ir_node * irn_left, ir_node * irn_right, ir_mode * mode) 314{ 315 ir_graph *irg = get_irn_irg(block); 316 317 ir_node *in[2]; 318 in[0] = irn_left; 319 in[1] = irn_right; 320 321 ir_node *res = new_ir_node(dbgi, irg, block, op_Carry, mode, 2, in); 322 irn_verify_irg(res, irg); 323 res = optimize_node(res); 324 return res; 325} 326 327ir_node *new_r_Carry(ir_node *block, ir_node * irn_left, ir_node * irn_right, ir_mode * mode) 328{ 329 return new_rd_Carry(NULL, block, irn_left, irn_right, mode); 330} 331 332ir_node *new_d_Carry(dbg_info *dbgi, ir_node * irn_left, ir_node * irn_right, ir_mode * mode) 333{ 334 assert(irg_is_constrained(current_ir_graph, IR_GRAPH_CONSTRAINT_CONSTRUCTION)); 335 ir_node *res = new_rd_Carry(dbgi, current_ir_graph->current_block, irn_left, irn_right, mode); 336 return res; 337} 338 339ir_node *new_Carry(ir_node * irn_left, ir_node * irn_right, ir_mode * mode) 340{ 341 return new_d_Carry(NULL, irn_left, irn_right, mode); 342} 343 344ir_node *new_rd_Cast(dbg_info *dbgi, ir_node *block, ir_node * irn_op, ir_type* type) 345{ 346 ir_graph *irg = get_irn_irg(block); 347 348 ir_node *in[1]; 349 in[0] = irn_op; 350 351 ir_node *res = new_ir_node(dbgi, irg, block, op_Cast, get_irn_mode(irn_op), 1, in); 352 res->attr.cast.type = type;assert(is_atomic_type(type)); 353 irn_verify_irg(res, irg); 354 res = optimize_node(res); 355 return res; 356} 357 358ir_node *new_r_Cast(ir_node *block, ir_node * irn_op, ir_type* type) 359{ 360 return new_rd_Cast(NULL, block, irn_op, type); 361} 362 363ir_node *new_d_Cast(dbg_info *dbgi, ir_node * irn_op, ir_type* type) 364{ 365 assert(irg_is_constrained(current_ir_graph, IR_GRAPH_CONSTRAINT_CONSTRUCTION)); 366 ir_node *res = new_rd_Cast(dbgi, current_ir_graph->current_block, irn_op, type); 367 return res; 368} 369 370ir_node *new_Cast(ir_node * irn_op, ir_type* type) 371{ 372 return new_d_Cast(NULL, irn_op, type); 373} 374 375ir_node *new_rd_Cmp(dbg_info *dbgi, ir_node *block, ir_node * irn_left, ir_node * irn_right, ir_relation relation) 376{ 377 ir_graph *irg = get_irn_irg(block); 378 379 ir_node *in[2]; 380 in[0] = irn_left; 381 in[1] = irn_right; 382 383 ir_node *res = new_ir_node(dbgi, irg, block, op_Cmp, mode_b, 2, in); 384 res->attr.cmp.relation = relation; 385 irn_verify_irg(res, irg); 386 res = optimize_node(res); 387 return res; 388} 389 390ir_node *new_r_Cmp(ir_node *block, ir_node * irn_left, ir_node * irn_right, ir_relation relation) 391{ 392 return new_rd_Cmp(NULL, block, irn_left, irn_right, relation); 393} 394 395ir_node *new_d_Cmp(dbg_info *dbgi, ir_node * irn_left, ir_node * irn_right, ir_relation relation) 396{ 397 assert(irg_is_constrained(current_ir_graph, IR_GRAPH_CONSTRAINT_CONSTRUCTION)); 398 ir_node *res = new_rd_Cmp(dbgi, current_ir_graph->current_block, irn_left, irn_right, relation); 399 return res; 400} 401 402ir_node *new_Cmp(ir_node * irn_left, ir_node * irn_right, ir_relation relation) 403{ 404 return new_d_Cmp(NULL, irn_left, irn_right, relation); 405} 406 407ir_node *new_rd_Cond(dbg_info *dbgi, ir_node *block, ir_node * irn_selector) 408{ 409 ir_graph *irg = get_irn_irg(block); 410 411 ir_node *in[1]; 412 in[0] = irn_selector; 413 414 ir_node *res = new_ir_node(dbgi, irg, block, op_Cond, mode_T, 1, in); 415 res->attr.cond.jmp_pred = COND_JMP_PRED_NONE; 416 irn_verify_irg(res, irg); 417 res = optimize_node(res); 418 return res; 419} 420 421ir_node *new_r_Cond(ir_node *block, ir_node * irn_selector) 422{ 423 return new_rd_Cond(NULL, block, irn_selector); 424} 425 426ir_node *new_d_Cond(dbg_info *dbgi, ir_node * irn_selector) 427{ 428 assert(irg_is_constrained(current_ir_graph, IR_GRAPH_CONSTRAINT_CONSTRUCTION)); 429 ir_node *res = new_rd_Cond(dbgi, current_ir_graph->current_block, irn_selector); 430 return res; 431} 432 433ir_node *new_Cond(ir_node * irn_selector) 434{ 435 return new_d_Cond(NULL, irn_selector); 436} 437 438ir_node *new_rd_Confirm(dbg_info *dbgi, ir_node *block, ir_node * irn_value, ir_node * irn_bound, ir_relation relation) 439{ 440 ir_graph *irg = get_irn_irg(block); 441 442 ir_node *in[2]; 443 in[0] = irn_value; 444 in[1] = irn_bound; 445 446 ir_node *res = new_ir_node(dbgi, irg, block, op_Confirm, get_irn_mode(irn_value), 2, in); 447 res->attr.confirm.relation = relation; 448 irn_verify_irg(res, irg); 449 res = optimize_node(res); 450 return res; 451} 452 453ir_node *new_r_Confirm(ir_node *block, ir_node * irn_value, ir_node * irn_bound, ir_relation relation) 454{ 455 return new_rd_Confirm(NULL, block, irn_value, irn_bound, relation); 456} 457 458ir_node *new_d_Confirm(dbg_info *dbgi, ir_node * irn_value, ir_node * irn_bound, ir_relation relation) 459{ 460 assert(irg_is_constrained(current_ir_graph, IR_GRAPH_CONSTRAINT_CONSTRUCTION)); 461 ir_node *res = new_rd_Confirm(dbgi, current_ir_graph->current_block, irn_value, irn_bound, relation); 462 return res; 463} 464 465ir_node *new_Confirm(ir_node * irn_value, ir_node * irn_bound, ir_relation relation) 466{ 467 return new_d_Confirm(NULL, irn_value, irn_bound, relation); 468} 469 470ir_node *new_rd_Const(dbg_info *dbgi, ir_graph *irg, ir_tarval* tarval) 471{ 472 473 474 475 ir_node *res = new_ir_node(dbgi, irg, get_irg_start_block(irg), op_Const, get_tarval_mode(tarval), 0, NULL); 476 res->attr.con.tarval = tarval; 477 irn_verify_irg(res, irg); 478 res = optimize_node(res); 479 return res; 480} 481 482ir_node *new_r_Const(ir_graph *irg, ir_tarval* tarval) 483{ 484 return new_rd_Const(NULL, irg, tarval); 485} 486 487ir_node *new_d_Const(dbg_info *dbgi, ir_tarval* tarval) 488{ 489 assert(irg_is_constrained(current_ir_graph, IR_GRAPH_CONSTRAINT_CONSTRUCTION)); 490 ir_node *res = new_rd_Const(dbgi, current_ir_graph, tarval); 491 return res; 492} 493 494ir_node *new_Const(ir_tarval* tarval) 495{ 496 return new_d_Const(NULL, tarval); 497} 498 499ir_node *new_rd_Conv(dbg_info *dbgi, ir_node *block, ir_node * irn_op, ir_mode * mode) 500{ 501 ir_graph *irg = get_irn_irg(block); 502 503 ir_node *in[1]; 504 in[0] = irn_op; 505 506 ir_node *res = new_ir_node(dbgi, irg, block, op_Conv, mode, 1, in); 507 irn_verify_irg(res, irg); 508 res = optimize_node(res); 509 return res; 510} 511 512ir_node *new_r_Conv(ir_node *block, ir_node * irn_op, ir_mode * mode) 513{ 514 return new_rd_Conv(NULL, block, irn_op, mode); 515} 516 517ir_node *new_d_Conv(dbg_info *dbgi, ir_node * irn_op, ir_mode * mode) 518{ 519 assert(irg_is_constrained(current_ir_graph, IR_GRAPH_CONSTRAINT_CONSTRUCTION)); 520 ir_node *res = new_rd_Conv(dbgi, current_ir_graph->current_block, irn_op, mode); 521 return res; 522} 523 524ir_node *new_Conv(ir_node * irn_op, ir_mode * mode) 525{ 526 return new_d_Conv(NULL, irn_op, mode); 527} 528 529ir_node *new_rd_CopyB(dbg_info *dbgi, ir_node *block, ir_node * irn_mem, ir_node * irn_dst, ir_node * irn_src, ir_type* type) 530{ 531 ir_graph *irg = get_irn_irg(block); 532 533 ir_node *in[3]; 534 in[0] = irn_mem; 535 in[1] = irn_dst; 536 in[2] = irn_src; 537 538 ir_node *res = new_ir_node(dbgi, irg, block, op_CopyB, mode_T, 3, in); 539 res->attr.copyb.type = type; 540 res->attr.copyb.exc.pin_state = op_pin_state_pinned; 541 res->attr.copyb.exc.throws_exception = false; 542 irn_verify_irg(res, irg); 543 res = optimize_node(res); 544 return res; 545} 546 547ir_node *new_r_CopyB(ir_node *block, ir_node * irn_mem, ir_node * irn_dst, ir_node * irn_src, ir_type* type) 548{ 549 return new_rd_CopyB(NULL, block, irn_mem, irn_dst, irn_src, type); 550} 551 552ir_node *new_d_CopyB(dbg_info *dbgi, ir_node * irn_mem, ir_node * irn_dst, ir_node * irn_src, ir_type* type) 553{ 554 assert(irg_is_constrained(current_ir_graph, IR_GRAPH_CONSTRAINT_CONSTRUCTION)); 555 ir_node *res = new_rd_CopyB(dbgi, current_ir_graph->current_block, irn_mem, irn_dst, irn_src, type); 556 return res; 557} 558 559ir_node *new_CopyB(ir_node * irn_mem, ir_node * irn_dst, ir_node * irn_src, ir_type* type) 560{ 561 return new_d_CopyB(NULL, irn_mem, irn_dst, irn_src, type); 562} 563 564ir_node *new_rd_Div(dbg_info *dbgi, ir_node *block, ir_node * irn_mem, ir_node * irn_left, ir_node * irn_right, ir_mode* resmode, op_pin_state pin_state) 565{ 566 ir_graph *irg = get_irn_irg(block); 567 568 ir_node *in[3]; 569 in[0] = irn_mem; 570 in[1] = irn_left; 571 in[2] = irn_right; 572 573 ir_node *res = new_ir_node(dbgi, irg, block, op_Div, mode_T, 3, in); 574 res->attr.div.resmode = resmode; 575 res->attr.div.no_remainder = 0; 576 res->attr.div.exc.pin_state = pin_state; 577 res->attr.div.exc.throws_exception = false; 578 irn_verify_irg(res, irg); 579 res = optimize_node(res); 580 return res; 581} 582 583ir_node *new_r_Div(ir_node *block, ir_node * irn_mem, ir_node * irn_left, ir_node * irn_right, ir_mode* resmode, op_pin_state pin_state) 584{ 585 return new_rd_Div(NULL, block, irn_mem, irn_left, irn_right, resmode, pin_state); 586} 587 588ir_node *new_d_Div(dbg_info *dbgi, ir_node * irn_mem, ir_node * irn_left, ir_node * irn_right, ir_mode* resmode, op_pin_state pin_state) 589{ 590 assert(irg_is_constrained(current_ir_graph, IR_GRAPH_CONSTRAINT_CONSTRUCTION)); 591 ir_node *res = new_rd_Div(dbgi, current_ir_graph->current_block, irn_mem, irn_left, irn_right, resmode, pin_state); 592 return res; 593} 594 595ir_node *new_Div(ir_node * irn_mem, ir_node * irn_left, ir_node * irn_right, ir_mode* resmode, op_pin_state pin_state) 596{ 597 return new_d_Div(NULL, irn_mem, irn_left, irn_right, resmode, pin_state); 598} 599 600ir_node *new_rd_Dummy(dbg_info *dbgi, ir_graph *irg, ir_mode * mode) 601{ 602 603 604 605 ir_node *res = new_ir_node(dbgi, irg, get_irg_start_block(irg), op_Dummy, mode, 0, NULL); 606 irn_verify_irg(res, irg); 607 res = optimize_node(res); 608 return res; 609} 610 611ir_node *new_r_Dummy(ir_graph *irg, ir_mode * mode) 612{ 613 return new_rd_Dummy(NULL, irg, mode); 614} 615 616ir_node *new_d_Dummy(dbg_info *dbgi, ir_mode * mode) 617{ 618 assert(irg_is_constrained(current_ir_graph, IR_GRAPH_CONSTRAINT_CONSTRUCTION)); 619 ir_node *res = new_rd_Dummy(dbgi, current_ir_graph, mode); 620 return res; 621} 622 623ir_node *new_Dummy(ir_mode * mode) 624{ 625 return new_d_Dummy(NULL, mode); 626} 627 628ir_node *new_rd_End(dbg_info *dbgi, ir_graph *irg, int arity, ir_node *const * in) 629{ 630 631 632 633 ir_node *res = new_ir_node(dbgi, irg, get_irg_end_block(irg), op_End, mode_X, -1, NULL); 634 for (int i = 0; i < arity; ++i) { 635 add_irn_n(res, in[i]); 636 } 637 irn_verify_irg(res, irg); 638 res = optimize_node(res); 639 return res; 640} 641 642ir_node *new_r_End(ir_graph *irg, int arity, ir_node *const * in) 643{ 644 return new_rd_End(NULL, irg, arity, in); 645} 646 647ir_node *new_d_End(dbg_info *dbgi, int arity, ir_node *const * in) 648{ 649 assert(irg_is_constrained(current_ir_graph, IR_GRAPH_CONSTRAINT_CONSTRUCTION)); 650 ir_node *res = new_rd_End(dbgi, current_ir_graph, arity, in); 651 return res; 652} 653 654ir_node *new_End(int arity, ir_node *const * in) 655{ 656 return new_d_End(NULL, arity, in); 657} 658 659ir_node *new_rd_Eor(dbg_info *dbgi, ir_node *block, ir_node * irn_left, ir_node * irn_right, ir_mode * mode) 660{ 661 ir_graph *irg = get_irn_irg(block); 662 663 ir_node *in[2]; 664 in[0] = irn_left; 665 in[1] = irn_right; 666 667 ir_node *res = new_ir_node(dbgi, irg, block, op_Eor, mode, 2, in); 668 irn_verify_irg(res, irg); 669 res = optimize_node(res); 670 return res; 671} 672 673ir_node *new_r_Eor(ir_node *block, ir_node * irn_left, ir_node * irn_right, ir_mode * mode) 674{ 675 return new_rd_Eor(NULL, block, irn_left, irn_right, mode); 676} 677 678ir_node *new_d_Eor(dbg_info *dbgi, ir_node * irn_left, ir_node * irn_right, ir_mode * mode) 679{ 680 assert(irg_is_constrained(current_ir_graph, IR_GRAPH_CONSTRAINT_CONSTRUCTION)); 681 ir_node *res = new_rd_Eor(dbgi, current_ir_graph->current_block, irn_left, irn_right, mode); 682 return res; 683} 684 685ir_node *new_Eor(ir_node * irn_left, ir_node * irn_right, ir_mode * mode) 686{ 687 return new_d_Eor(NULL, irn_left, irn_right, mode); 688} 689 690ir_node *new_rd_Free(dbg_info *dbgi, ir_node *block, ir_node * irn_mem, ir_node * irn_ptr, ir_node * irn_count, ir_type* type, ir_where_alloc where) 691{ 692 ir_graph *irg = get_irn_irg(block); 693 694 ir_node *in[3]; 695 in[0] = irn_mem; 696 in[1] = irn_ptr; 697 in[2] = irn_count; 698 699 ir_node *res = new_ir_node(dbgi, irg, block, op_Free, mode_M, 3, in); 700 res->attr.free.type = type; 701 res->attr.free.where = where; 702 irn_verify_irg(res, irg); 703 res = optimize_node(res); 704 return res; 705} 706 707ir_node *new_r_Free(ir_node *block, ir_node * irn_mem, ir_node * irn_ptr, ir_node * irn_count, ir_type* type, ir_where_alloc where) 708{ 709 return new_rd_Free(NULL, block, irn_mem, irn_ptr, irn_count, type, where); 710} 711 712ir_node *new_d_Free(dbg_info *dbgi, ir_node * irn_mem, ir_node * irn_ptr, ir_node * irn_count, ir_type* type, ir_where_alloc where) 713{ 714 assert(irg_is_constrained(current_ir_graph, IR_GRAPH_CONSTRAINT_CONSTRUCTION)); 715 ir_node *res = new_rd_Free(dbgi, current_ir_graph->current_block, irn_mem, irn_ptr, irn_count, type, where); 716 return res; 717} 718 719ir_node *new_Free(ir_node * irn_mem, ir_node * irn_ptr, ir_node * irn_count, ir_type* type, ir_where_alloc where) 720{ 721 return new_d_Free(NULL, irn_mem, irn_ptr, irn_count, type, where); 722} 723 724ir_node *new_rd_IJmp(dbg_info *dbgi, ir_node *block, ir_node * irn_target) 725{ 726 ir_graph *irg = get_irn_irg(block); 727 728 ir_node *in[1]; 729 in[0] = irn_target; 730 731 ir_node *res = new_ir_node(dbgi, irg, block, op_IJmp, mode_X, 1, in); 732 irn_verify_irg(res, irg); 733 res = optimize_node(res); 734 return res; 735} 736 737ir_node *new_r_IJmp(ir_node *block, ir_node * irn_target) 738{ 739 return new_rd_IJmp(NULL, block, irn_target); 740} 741 742ir_node *new_d_IJmp(dbg_info *dbgi, ir_node * irn_target) 743{ 744 assert(irg_is_constrained(current_ir_graph, IR_GRAPH_CONSTRAINT_CONSTRUCTION)); 745 ir_node *res = new_rd_IJmp(dbgi, current_ir_graph->current_block, irn_target); 746 return res; 747} 748 749ir_node *new_IJmp(ir_node * irn_target) 750{ 751 return new_d_IJmp(NULL, irn_target); 752} 753 754ir_node *new_rd_Id(dbg_info *dbgi, ir_node *block, ir_node * irn_pred, ir_mode * mode) 755{ 756 ir_graph *irg = get_irn_irg(block); 757 758 ir_node *in[1]; 759 in[0] = irn_pred; 760 761 ir_node *res = new_ir_node(dbgi, irg, block, op_Id, mode, 1, in); 762 irn_verify_irg(res, irg); 763 res = optimize_node(res); 764 return res; 765} 766 767ir_node *new_r_Id(ir_node *block, ir_node * irn_pred, ir_mode * mode) 768{ 769 return new_rd_Id(NULL, block, irn_pred, mode); 770} 771 772ir_node *new_d_Id(dbg_info *dbgi, ir_node * irn_pred, ir_mode * mode) 773{ 774 assert(irg_is_constrained(current_ir_graph, IR_GRAPH_CONSTRAINT_CONSTRUCTION)); 775 ir_node *res = new_rd_Id(dbgi, current_ir_graph->current_block, irn_pred, mode); 776 return res; 777} 778 779ir_node *new_Id(ir_node * irn_pred, ir_mode * mode) 780{ 781 return new_d_Id(NULL, irn_pred, mode); 782} 783 784ir_node *new_rd_InstOf(dbg_info *dbgi, ir_node *block, ir_node * irn_store, ir_node * irn_obj, ir_type* type) 785{ 786 ir_graph *irg = get_irn_irg(block); 787 788 ir_node *in[2]; 789 in[0] = irn_store; 790 in[1] = irn_obj; 791 792 ir_node *res = new_ir_node(dbgi, irg, block, op_InstOf, mode_T, 2, in); 793 res->attr.instof.type = type; 794 res->attr.instof.exc.pin_state = op_pin_state_floats; 795 irn_verify_irg(res, irg); 796 res = optimize_node(res); 797 return res; 798} 799 800ir_node *new_r_InstOf(ir_node *block, ir_node * irn_store, ir_node * irn_obj, ir_type* type) 801{ 802 return new_rd_InstOf(NULL, block, irn_store, irn_obj, type); 803} 804 805ir_node *new_d_InstOf(dbg_info *dbgi, ir_node * irn_store, ir_node * irn_obj, ir_type* type) 806{ 807 assert(irg_is_constrained(current_ir_graph, IR_GRAPH_CONSTRAINT_CONSTRUCTION)); 808 ir_node *res = new_rd_InstOf(dbgi, current_ir_graph->current_block, irn_store, irn_obj, type); 809 return res; 810} 811 812ir_node *new_InstOf(ir_node * irn_store, ir_node * irn_obj, ir_type* type) 813{ 814 return new_d_InstOf(NULL, irn_store, irn_obj, type); 815} 816 817ir_node *new_rd_Jmp(dbg_info *dbgi, ir_node *block) 818{ 819 ir_graph *irg = get_irn_irg(block); 820 821 822 823 ir_node *res = new_ir_node(dbgi, irg, block, op_Jmp, mode_X, 0, NULL); 824 irn_verify_irg(res, irg); 825 res = optimize_node(res); 826 return res; 827} 828 829ir_node *new_r_Jmp(ir_node *block) 830{ 831 return new_rd_Jmp(NULL, block); 832} 833 834ir_node *new_d_Jmp(dbg_info *dbgi) 835{ 836 assert(irg_is_constrained(current_ir_graph, IR_GRAPH_CONSTRAINT_CONSTRUCTION)); 837 ir_node *res = new_rd_Jmp(dbgi, current_ir_graph->current_block); 838 return res; 839} 840 841ir_node *new_Jmp(void) 842{ 843 return new_d_Jmp(NULL); 844} 845 846ir_node *new_rd_Load(dbg_info *dbgi, ir_node *block, ir_node * irn_mem, ir_node * irn_ptr, ir_mode* mode, ir_cons_flags flags) 847{ 848 ir_graph *irg = get_irn_irg(block); 849 850 ir_node *in[2]; 851 in[0] = irn_mem; 852 in[1] = irn_ptr; 853 854 ir_node *res = new_ir_node(dbgi, irg, block, op_Load, mode_T, 2, in); 855 res->attr.load.mode = mode; 856 res->attr.load.volatility = flags & cons_volatile ? volatility_is_volatile : volatility_non_volatile; 857 res->attr.load.unaligned = flags & cons_unaligned ? align_non_aligned : align_is_aligned; 858 res->attr.load.exc.pin_state = flags & cons_floats ? op_pin_state_floats : op_pin_state_pinned; 859 res->attr.load.exc.throws_exception = (flags & cons_throws_exception) != 0; 860 irn_verify_irg(res, irg); 861 res = optimize_node(res); 862 return res; 863} 864 865ir_node *new_r_Load(ir_node *block, ir_node * irn_mem, ir_node * irn_ptr, ir_mode* mode, ir_cons_flags flags) 866{ 867 return new_rd_Load(NULL, block, irn_mem, irn_ptr, mode, flags); 868} 869 870ir_node *new_d_Load(dbg_info *dbgi, ir_node * irn_mem, ir_node * irn_ptr, ir_mode* mode, ir_cons_flags flags) 871{ 872 assert(irg_is_constrained(current_ir_graph, IR_GRAPH_CONSTRAINT_CONSTRUCTION)); 873 ir_node *res = new_rd_Load(dbgi, current_ir_graph->current_block, irn_mem, irn_ptr, mode, flags); 874 return res; 875} 876 877ir_node *new_Load(ir_node * irn_mem, ir_node * irn_ptr, ir_mode* mode, ir_cons_flags flags) 878{ 879 return new_d_Load(NULL, irn_mem, irn_ptr, mode, flags); 880} 881 882ir_node *new_rd_Minus(dbg_info *dbgi, ir_node *block, ir_node * irn_op, ir_mode * mode) 883{ 884 ir_graph *irg = get_irn_irg(block); 885 886 ir_node *in[1]; 887 in[0] = irn_op; 888 889 ir_node *res = new_ir_node(dbgi, irg, block, op_Minus, mode, 1, in); 890 irn_verify_irg(res, irg); 891 res = optimize_node(res); 892 return res; 893} 894 895ir_node *new_r_Minus(ir_node *block, ir_node * irn_op, ir_mode * mode) 896{ 897 return new_rd_Minus(NULL, block, irn_op, mode); 898} 899 900ir_node *new_d_Minus(dbg_info *dbgi, ir_node * irn_op, ir_mode * mode) 901{ 902 assert(irg_is_constrained(current_ir_graph, IR_GRAPH_CONSTRAINT_CONSTRUCTION)); 903 ir_node *res = new_rd_Minus(dbgi, current_ir_graph->current_block, irn_op, mode); 904 return res; 905} 906 907ir_node *new_Minus(ir_node * irn_op, ir_mode * mode) 908{ 909 return new_d_Minus(NULL, irn_op, mode); 910} 911 912ir_node *new_rd_Mod(dbg_info *dbgi, ir_node *block, ir_node * irn_mem, ir_node * irn_left, ir_node * irn_right, ir_mode* resmode, op_pin_state pin_state) 913{ 914 ir_graph *irg = get_irn_irg(block); 915 916 ir_node *in[3]; 917 in[0] = irn_mem; 918 in[1] = irn_left; 919 in[2] = irn_right; 920 921 ir_node *res = new_ir_node(dbgi, irg, block, op_Mod, mode_T, 3, in); 922 res->attr.mod.resmode = resmode; 923 res->attr.mod.exc.pin_state = pin_state; 924 res->attr.mod.exc.throws_exception = false; 925 irn_verify_irg(res, irg); 926 res = optimize_node(res); 927 return res; 928} 929 930ir_node *new_r_Mod(ir_node *block, ir_node * irn_mem, ir_node * irn_left, ir_node * irn_right, ir_mode* resmode, op_pin_state pin_state) 931{ 932 return new_rd_Mod(NULL, block, irn_mem, irn_left, irn_right, resmode, pin_state); 933} 934 935ir_node *new_d_Mod(dbg_info *dbgi, ir_node * irn_mem, ir_node * irn_left, ir_node * irn_right, ir_mode* resmode, op_pin_state pin_state) 936{ 937 assert(irg_is_constrained(current_ir_graph, IR_GRAPH_CONSTRAINT_CONSTRUCTION)); 938 ir_node *res = new_rd_Mod(dbgi, current_ir_graph->current_block, irn_mem, irn_left, irn_right, resmode, pin_state); 939 return res; 940} 941 942ir_node *new_Mod(ir_node * irn_mem, ir_node * irn_left, ir_node * irn_right, ir_mode* resmode, op_pin_state pin_state) 943{ 944 return new_d_Mod(NULL, irn_mem, irn_left, irn_right, resmode, pin_state); 945} 946 947ir_node *new_rd_Mul(dbg_info *dbgi, ir_node *block, ir_node * irn_left, ir_node * irn_right, ir_mode * mode) 948{ 949 ir_graph *irg = get_irn_irg(block); 950 951 ir_node *in[2]; 952 in[0] = irn_left; 953 in[1] = irn_right; 954 955 ir_node *res = new_ir_node(dbgi, irg, block, op_Mul, mode, 2, in); 956 irn_verify_irg(res, irg); 957 res = optimize_node(res); 958 return res; 959} 960 961ir_node *new_r_Mul(ir_node *block, ir_node * irn_left, ir_node * irn_right, ir_mode * mode) 962{ 963 return new_rd_Mul(NULL, block, irn_left, irn_right, mode); 964} 965 966ir_node *new_d_Mul(dbg_info *dbgi, ir_node * irn_left, ir_node * irn_right, ir_mode * mode) 967{ 968 assert(irg_is_constrained(current_ir_graph, IR_GRAPH_CONSTRAINT_CONSTRUCTION)); 969 ir_node *res = new_rd_Mul(dbgi, current_ir_graph->current_block, irn_left, irn_right, mode); 970 return res; 971} 972 973ir_node *new_Mul(ir_node * irn_left, ir_node * irn_right, ir_mode * mode) 974{ 975 return new_d_Mul(NULL, irn_left, irn_right, mode); 976} 977 978ir_node *new_rd_Mulh(dbg_info *dbgi, ir_node *block, ir_node * irn_left, ir_node * irn_right, ir_mode * mode) 979{ 980 ir_graph *irg = get_irn_irg(block); 981 982 ir_node *in[2]; 983 in[0] = irn_left; 984 in[1] = irn_right; 985 986 ir_node *res = new_ir_node(dbgi, irg, block, op_Mulh, mode, 2, in); 987 irn_verify_irg(res, irg); 988 res = optimize_node(res); 989 return res; 990} 991 992ir_node *new_r_Mulh(ir_node *block, ir_node * irn_left, ir_node * irn_right, ir_mode * mode) 993{ 994 return new_rd_Mulh(NULL, block, irn_left, irn_right, mode); 995} 996 997ir_node *new_d_Mulh(dbg_info *dbgi, ir_node * irn_left, ir_node * irn_right, ir_mode * mode) 998{ 999 assert(irg_is_constrained(current_ir_graph, IR_GRAPH_CONSTRAINT_CONSTRUCTION)); 1000 ir_node *res = new_rd_Mulh(dbgi, current_ir_graph->current_block, irn_left, irn_right, mode); 1001 return res; 1002} 1003 1004ir_node *new_Mulh(ir_node * irn_left, ir_node * irn_right, ir_mode * mode) 1005{ 1006 return new_d_Mulh(NULL, irn_left, irn_right, mode); 1007} 1008 1009ir_node *new_rd_Mux(dbg_info *dbgi, ir_node *block, ir_node * irn_sel, ir_node * irn_false, ir_node * irn_true, ir_mode * mode) 1010{ 1011 ir_graph *irg = get_irn_irg(block); 1012 1013 ir_node *in[3]; 1014 in[0] = irn_sel; 1015 in[1] = irn_false; 1016 in[2] = irn_true; 1017 1018 ir_node *res = new_ir_node(dbgi, irg, block, op_Mux, mode, 3, in); 1019 irn_verify_irg(res, irg); 1020 res = optimize_node(res); 1021 return res; 1022} 1023 1024ir_node *new_r_Mux(ir_node *block, ir_node * irn_sel, ir_node * irn_false, ir_node * irn_true, ir_mode * mode) 1025{ 1026 return new_rd_Mux(NULL, block, irn_sel, irn_false, irn_true, mode); 1027} 1028 1029ir_node *new_d_Mux(dbg_info *dbgi, ir_node * irn_sel, ir_node * irn_false, ir_node * irn_true, ir_mode * mode) 1030{ 1031 assert(irg_is_constrained(current_ir_graph, IR_GRAPH_CONSTRAINT_CONSTRUCTION)); 1032 ir_node *res = new_rd_Mux(dbgi, current_ir_graph->current_block, irn_sel, irn_false, irn_true, mode); 1033 return res; 1034} 1035 1036ir_node *new_Mux(ir_node * irn_sel, ir_node * irn_false, ir_node * irn_true, ir_mode * mode) 1037{ 1038 return new_d_Mux(NULL, irn_sel, irn_false, irn_true, mode); 1039} 1040 1041ir_node *new_rd_NoMem(dbg_info *dbgi, ir_graph *irg) 1042{ 1043 1044 1045 1046 ir_node *res = new_ir_node(dbgi, irg, get_irg_start_block(irg), op_NoMem, mode_M, 0, NULL); 1047 irn_verify_irg(res, irg); 1048 res = optimize_node(res); 1049 return res; 1050} 1051 1052ir_node *new_r_NoMem(ir_graph *irg) 1053{ 1054 return new_rd_NoMem(NULL, irg); 1055} 1056 1057ir_node *new_d_NoMem(dbg_info *dbgi) 1058{ 1059 assert(irg_is_constrained(current_ir_graph, IR_GRAPH_CONSTRAINT_CONSTRUCTION)); 1060 ir_node *res = new_rd_NoMem(dbgi, current_ir_graph); 1061 return res; 1062} 1063 1064ir_node *new_NoMem(void) 1065{ 1066 return new_d_NoMem(NULL); 1067} 1068 1069ir_node *new_rd_Not(dbg_info *dbgi, ir_node *block, ir_node * irn_op, ir_mode * mode) 1070{ 1071 ir_graph *irg = get_irn_irg(block); 1072 1073 ir_node *in[1]; 1074 in[0] = irn_op; 1075 1076 ir_node *res = new_ir_node(dbgi, irg, block, op_Not, mode, 1, in); 1077 irn_verify_irg(res, irg); 1078 res = optimize_node(res); 1079 return res; 1080} 1081 1082ir_node *new_r_Not(ir_node *block, ir_node * irn_op, ir_mode * mode) 1083{ 1084 return new_rd_Not(NULL, block, irn_op, mode); 1085} 1086 1087ir_node *new_d_Not(dbg_info *dbgi, ir_node * irn_op, ir_mode * mode) 1088{ 1089 assert(irg_is_constrained(current_ir_graph, IR_GRAPH_CONSTRAINT_CONSTRUCTION)); 1090 ir_node *res = new_rd_Not(dbgi, current_ir_graph->current_block, irn_op, mode); 1091 return res; 1092} 1093 1094ir_node *new_Not(ir_node * irn_op, ir_mode * mode) 1095{ 1096 return new_d_Not(NULL, irn_op, mode); 1097} 1098 1099ir_node *new_rd_Or(dbg_info *dbgi, ir_node *block, ir_node * irn_left, ir_node * irn_right, ir_mode * mode) 1100{ 1101 ir_graph *irg = get_irn_irg(block); 1102 1103 ir_node *in[2]; 1104 in[0] = irn_left; 1105 in[1] = irn_right; 1106 1107 ir_node *res = new_ir_node(dbgi, irg, block, op_Or, mode, 2, in); 1108 irn_verify_irg(res, irg); 1109 res = optimize_node(res); 1110 return res; 1111} 1112 1113ir_node *new_r_Or(ir_node *block, ir_node * irn_left, ir_node * irn_right, ir_mode * mode) 1114{ 1115 return new_rd_Or(NULL, block, irn_left, irn_right, mode); 1116} 1117 1118ir_node *new_d_Or(dbg_info *dbgi, ir_node * irn_left, ir_node * irn_right, ir_mode * mode) 1119{ 1120 assert(irg_is_constrained(current_ir_graph, IR_GRAPH_CONSTRAINT_CONSTRUCTION)); 1121 ir_node *res = new_rd_Or(dbgi, current_ir_graph->current_block, irn_left, irn_right, mode); 1122 return res; 1123} 1124 1125ir_node *new_Or(ir_node * irn_left, ir_node * irn_right, ir_mode * mode) 1126{ 1127 return new_d_Or(NULL, irn_left, irn_right, mode); 1128} 1129 1130ir_node *new_rd_Phi(dbg_info *dbgi, ir_node *block, int arity, ir_node *const * in, ir_mode * mode) 1131{ 1132 ir_graph *irg = get_irn_irg(block); 1133 1134 1135 1136 ir_node *res = new_ir_node(dbgi, irg, block, op_Phi, mode, arity, in); 1137 res->attr.phi.u.backedge = new_backedge_arr(irg->obst, arity); 1138 irn_verify_irg(res, irg); 1139 res = optimize_node(res); 1140 return res; 1141} 1142 1143ir_node *new_r_Phi(ir_node *block, int arity, ir_node *const * in, ir_mode * mode) 1144{ 1145 return new_rd_Phi(NULL, block, arity, in, mode); 1146} 1147 1148ir_node *new_d_Phi(dbg_info *dbgi, int arity, ir_node *const * in, ir_mode * mode) 1149{ 1150 assert(irg_is_constrained(current_ir_graph, IR_GRAPH_CONSTRAINT_CONSTRUCTION)); 1151 ir_node *res = new_rd_Phi(dbgi, current_ir_graph->current_block, arity, in, mode); 1152 return res; 1153} 1154 1155ir_node *new_Phi(int arity, ir_node *const * in, ir_mode * mode) 1156{ 1157 return new_d_Phi(NULL, arity, in, mode); 1158} 1159 1160ir_node *new_rd_Pin(dbg_info *dbgi, ir_node *block, ir_node * irn_op) 1161{ 1162 ir_graph *irg = get_irn_irg(block); 1163 1164 ir_node *in[1]; 1165 in[0] = irn_op; 1166 1167 ir_node *res = new_ir_node(dbgi, irg, block, op_Pin, get_irn_mode(irn_op), 1, in); 1168 irn_verify_irg(res, irg); 1169 res = optimize_node(res); 1170 return res; 1171} 1172 1173ir_node *new_r_Pin(ir_node *block, ir_node * irn_op) 1174{ 1175 return new_rd_Pin(NULL, block, irn_op); 1176} 1177 1178ir_node *new_d_Pin(dbg_info *dbgi, ir_node * irn_op) 1179{ 1180 assert(irg_is_constrained(current_ir_graph, IR_GRAPH_CONSTRAINT_CONSTRUCTION)); 1181 ir_node *res = new_rd_Pin(dbgi, current_ir_graph->current_block, irn_op); 1182 return res; 1183} 1184 1185ir_node *new_Pin(ir_node * irn_op) 1186{ 1187 return new_d_Pin(NULL, irn_op); 1188} 1189 1190ir_node *new_rd_Proj(dbg_info *dbgi, ir_node * irn_pred, ir_mode * mode, long proj) 1191{ 1192 ir_graph *irg = get_irn_irg(irn_pred); 1193 1194 ir_node *in[1]; 1195 in[0] = irn_pred; 1196 1197 ir_node *res = new_ir_node(dbgi, irg, get_nodes_block(irn_pred), op_Proj, mode, 1, in); 1198 res->attr.proj.proj = proj; 1199 irn_verify_irg(res, irg); 1200 res = optimize_node(res); 1201 return res; 1202} 1203 1204ir_node *new_r_Proj(ir_node * irn_pred, ir_mode * mode, long proj) 1205{ 1206 return new_rd_Proj(NULL, irn_pred, mode, proj); 1207} 1208 1209ir_node *new_d_Proj(dbg_info *dbgi, ir_node * irn_pred, ir_mode * mode, long proj) 1210{ 1211 assert(irg_is_constrained(current_ir_graph, IR_GRAPH_CONSTRAINT_CONSTRUCTION)); 1212 ir_node *res = new_rd_Proj(dbgi, irn_pred, mode, proj); 1213 return res; 1214} 1215 1216ir_node *new_Proj(ir_node * irn_pred, ir_mode * mode, long proj) 1217{ 1218 return new_d_Proj(NULL, irn_pred, mode, proj); 1219} 1220 1221ir_node *new_rd_Raise(dbg_info *dbgi, ir_node *block, ir_node * irn_mem, ir_node * irn_exo_ptr) 1222{ 1223 ir_graph *irg = get_irn_irg(block); 1224 1225 ir_node *in[2]; 1226 in[0] = irn_mem; 1227 in[1] = irn_exo_ptr; 1228 1229 ir_node *res = new_ir_node(dbgi, irg, block, op_Raise, mode_T, 2, in); 1230 irn_verify_irg(res, irg); 1231 res = optimize_node(res); 1232 return res; 1233} 1234 1235ir_node *new_r_Raise(ir_node *block, ir_node * irn_mem, ir_node * irn_exo_ptr) 1236{ 1237 return new_rd_Raise(NULL, block, irn_mem, irn_exo_ptr); 1238} 1239 1240ir_node *new_d_Raise(dbg_info *dbgi, ir_node * irn_mem, ir_node * irn_exo_ptr) 1241{ 1242 assert(irg_is_constrained(current_ir_graph, IR_GRAPH_CONSTRAINT_CONSTRUCTION)); 1243 ir_node *res = new_rd_Raise(dbgi, current_ir_graph->current_block, irn_mem, irn_exo_ptr); 1244 return res; 1245} 1246 1247ir_node *new_Raise(ir_node * irn_mem, ir_node * irn_exo_ptr) 1248{ 1249 return new_d_Raise(NULL, irn_mem, irn_exo_ptr); 1250} 1251 1252ir_node *new_rd_Return(dbg_info *dbgi, ir_node *block, ir_node * irn_mem, int arity, ir_node *const * in) 1253{ 1254 ir_graph *irg = get_irn_irg(block); 1255 1256 int r_arity = arity + 1; 1257 ir_node **r_in; 1258 NEW_ARR_A(ir_node *, r_in, r_arity); 1259 r_in[0] = irn_mem; 1260 memcpy(&r_in[1], in, sizeof(ir_node *) * arity); 1261 1262 1263 ir_node *res = new_ir_node(dbgi, irg, block, op_Return, mode_X, r_arity, r_in); 1264 irn_verify_irg(res, irg); 1265 res = optimize_node(res); 1266 return res; 1267} 1268 1269ir_node *new_r_Return(ir_node *block, ir_node * irn_mem, int arity, ir_node *const * in) 1270{ 1271 return new_rd_Return(NULL, block, irn_mem, arity, in); 1272} 1273 1274ir_node *new_d_Return(dbg_info *dbgi, ir_node * irn_mem, int arity, ir_node *const * in) 1275{ 1276 assert(irg_is_constrained(current_ir_graph, IR_GRAPH_CONSTRAINT_CONSTRUCTION)); 1277 ir_node *res = new_rd_Return(dbgi, current_ir_graph->current_block, irn_mem, arity, in); 1278 return res; 1279} 1280 1281ir_node *new_Return(ir_node * irn_mem, int arity, ir_node *const * in) 1282{ 1283 return new_d_Return(NULL, irn_mem, arity, in); 1284} 1285 1286ir_node *new_rd_Rotl(dbg_info *dbgi, ir_node *block, ir_node * irn_left, ir_node * irn_right, ir_mode * mode) 1287{ 1288 ir_graph *irg = get_irn_irg(block); 1289 1290 ir_node *in[2]; 1291 in[0] = irn_left; 1292 in[1] = irn_right; 1293 1294 ir_node *res = new_ir_node(dbgi, irg, block, op_Rotl, mode, 2, in); 1295 irn_verify_irg(res, irg); 1296 res = optimize_node(res); 1297 return res; 1298} 1299 1300ir_node *new_r_Rotl(ir_node *block, ir_node * irn_left, ir_node * irn_right, ir_mode * mode) 1301{ 1302 return new_rd_Rotl(NULL, block, irn_left, irn_right, mode); 1303} 1304 1305ir_node *new_d_Rotl(dbg_info *dbgi, ir_node * irn_left, ir_node * irn_right, ir_mode * mode) 1306{ 1307 assert(irg_is_constrained(current_ir_graph, IR_GRAPH_CONSTRAINT_CONSTRUCTION)); 1308 ir_node *res = new_rd_Rotl(dbgi, current_ir_graph->current_block, irn_left, irn_right, mode); 1309 return res; 1310} 1311 1312ir_node *new_Rotl(ir_node * irn_left, ir_node * irn_right, ir_mode * mode) 1313{ 1314 return new_d_Rotl(NULL, irn_left, irn_right, mode); 1315} 1316 1317ir_node *new_rd_Sel(dbg_info *dbgi, ir_node *block, ir_node * irn_mem, ir_node * irn_ptr, int arity, ir_node *const * in, ir_entity* entity) 1318{ 1319 ir_graph *irg = get_irn_irg(block); 1320 1321 int r_arity = arity + 2; 1322 ir_node **r_in; 1323 NEW_ARR_A(ir_node *, r_in, r_arity); 1324 r_in[0] = irn_mem; 1325 r_in[1] = irn_ptr; 1326 memcpy(&r_in[2], in, sizeof(ir_node *) * arity); 1327 1328 1329 ir_node *res = new_ir_node(dbgi, irg, block, op_Sel, is_Method_type(get_entity_type(entity)) ? mode_P_code : mode_P_data, r_arity, r_in); 1330 res->attr.sel.entity = entity; 1331 irn_verify_irg(res, irg); 1332 res = optimize_node(res); 1333 return res; 1334} 1335 1336ir_node *new_r_Sel(ir_node *block, ir_node * irn_mem, ir_node * irn_ptr, int arity, ir_node *const * in, ir_entity* entity) 1337{ 1338 return new_rd_Sel(NULL, block, irn_mem, irn_ptr, arity, in, entity); 1339} 1340 1341ir_node *new_d_Sel(dbg_info *dbgi, ir_node * irn_mem, ir_node * irn_ptr, int arity, ir_node *const * in, ir_entity* entity) 1342{ 1343 assert(irg_is_constrained(current_ir_graph, IR_GRAPH_CONSTRAINT_CONSTRUCTION)); 1344 ir_node *res = new_rd_Sel(dbgi, current_ir_graph->current_block, irn_mem, irn_ptr, arity, in, entity); 1345 return res; 1346} 1347 1348ir_node *new_Sel(ir_node * irn_mem, ir_node * irn_ptr, int arity, ir_node *const * in, ir_entity* entity) 1349{ 1350 return new_d_Sel(NULL, irn_mem, irn_ptr, arity, in, entity); 1351} 1352 1353ir_node *new_rd_Shl(dbg_info *dbgi, ir_node *block, ir_node * irn_left, ir_node * irn_right, ir_mode * mode) 1354{ 1355 ir_graph *irg = get_irn_irg(block); 1356 1357 ir_node *in[2]; 1358 in[0] = irn_left; 1359 in[1] = irn_right; 1360 1361 ir_node *res = new_ir_node(dbgi, irg, block, op_Shl, mode, 2, in); 1362 irn_verify_irg(res, irg); 1363 res = optimize_node(res); 1364 return res; 1365} 1366 1367ir_node *new_r_Shl(ir_node *block, ir_node * irn_left, ir_node * irn_right, ir_mode * mode) 1368{ 1369 return new_rd_Shl(NULL, block, irn_left, irn_right, mode); 1370} 1371 1372ir_node *new_d_Shl(dbg_info *dbgi, ir_node * irn_left, ir_node * irn_right, ir_mode * mode) 1373{ 1374 assert(irg_is_constrained(current_ir_graph, IR_GRAPH_CONSTRAINT_CONSTRUCTION)); 1375 ir_node *res = new_rd_Shl(dbgi, current_ir_graph->current_block, irn_left, irn_right, mode); 1376 return res; 1377} 1378 1379ir_node *new_Shl(ir_node * irn_left, ir_node * irn_right, ir_mode * mode) 1380{ 1381 return new_d_Shl(NULL, irn_left, irn_right, mode); 1382} 1383 1384ir_node *new_rd_Shr(dbg_info *dbgi, ir_node *block, ir_node * irn_left, ir_node * irn_right, ir_mode * mode) 1385{ 1386 ir_graph *irg = get_irn_irg(block); 1387 1388 ir_node *in[2]; 1389 in[0] = irn_left; 1390 in[1] = irn_right; 1391 1392 ir_node *res = new_ir_node(dbgi, irg, block, op_Shr, mode, 2, in); 1393 irn_verify_irg(res, irg); 1394 res = optimize_node(res); 1395 return res; 1396} 1397 1398ir_node *new_r_Shr(ir_node *block, ir_node * irn_left, ir_node * irn_right, ir_mode * mode) 1399{ 1400 return new_rd_Shr(NULL, block, irn_left, irn_right, mode); 1401} 1402 1403ir_node *new_d_Shr(dbg_info *dbgi, ir_node * irn_left, ir_node * irn_right, ir_mode * mode) 1404{ 1405 assert(irg_is_constrained(current_ir_graph, IR_GRAPH_CONSTRAINT_CONSTRUCTION)); 1406 ir_node *res = new_rd_Shr(dbgi, current_ir_graph->current_block, irn_left, irn_right, mode); 1407 return res; 1408} 1409 1410ir_node *new_Shr(ir_node * irn_left, ir_node * irn_right, ir_mode * mode) 1411{ 1412 return new_d_Shr(NULL, irn_left, irn_right, mode); 1413} 1414 1415ir_node *new_rd_Shrs(dbg_info *dbgi, ir_node *block, ir_node * irn_left, ir_node * irn_right, ir_mode * mode) 1416{ 1417 ir_graph *irg = get_irn_irg(block); 1418 1419 ir_node *in[2]; 1420 in[0] = irn_left; 1421 in[1] = irn_right; 1422 1423 ir_node *res = new_ir_node(dbgi, irg, block, op_Shrs, mode, 2, in); 1424 irn_verify_irg(res, irg); 1425 res = optimize_node(res); 1426 return res; 1427} 1428 1429ir_node *new_r_Shrs(ir_node *block, ir_node * irn_left, ir_node * irn_right, ir_mode * mode) 1430{ 1431 return new_rd_Shrs(NULL, block, irn_left, irn_right, mode); 1432} 1433 1434ir_node *new_d_Shrs(dbg_info *dbgi, ir_node * irn_left, ir_node * irn_right, ir_mode * mode) 1435{ 1436 assert(irg_is_constrained(current_ir_graph, IR_GRAPH_CONSTRAINT_CONSTRUCTION)); 1437 ir_node *res = new_rd_Shrs(dbgi, current_ir_graph->current_block, irn_left, irn_right, mode); 1438 return res; 1439} 1440 1441ir_node *new_Shrs(ir_node * irn_left, ir_node * irn_right, ir_mode * mode) 1442{ 1443 return new_d_Shrs(NULL, irn_left, irn_right, mode); 1444} 1445 1446ir_node *new_rd_Start(dbg_info *dbgi, ir_graph *irg) 1447{ 1448 1449 1450 1451 ir_node *res = new_ir_node(dbgi, irg, get_irg_start_block(irg), op_Start, mode_T, 0, NULL); 1452 irn_verify_irg(res, irg); 1453 res = optimize_node(res); 1454 return res; 1455} 1456 1457ir_node *new_r_Start(ir_graph *irg) 1458{ 1459 return new_rd_Start(NULL, irg); 1460} 1461 1462ir_node *new_d_Start(dbg_info *dbgi) 1463{ 1464 assert(irg_is_constrained(current_ir_graph, IR_GRAPH_CONSTRAINT_CONSTRUCTION)); 1465 ir_node *res = new_rd_Start(dbgi, current_ir_graph); 1466 return res; 1467} 1468 1469ir_node *new_Start(void) 1470{ 1471 return new_d_Start(NULL); 1472} 1473 1474ir_node *new_rd_Store(dbg_info *dbgi, ir_node *block, ir_node * irn_mem, ir_node * irn_ptr, ir_node * irn_value, ir_cons_flags flags) 1475{ 1476 ir_graph *irg = get_irn_irg(block); 1477 1478 ir_node *in[3]; 1479 in[0] = irn_mem; 1480 in[1] = irn_ptr; 1481 in[2] = irn_value; 1482 1483 ir_node *res = new_ir_node(dbgi, irg, block, op_Store, mode_T, 3, in); 1484 res->attr.store.volatility = flags & cons_volatile ? volatility_is_volatile : volatility_non_volatile; 1485 res->attr.store.unaligned = flags & cons_unaligned ? align_non_aligned : align_is_aligned; 1486 res->attr.store.exc.pin_state = flags & cons_floats ? op_pin_state_floats : op_pin_state_pinned; 1487 res->attr.store.exc.throws_exception = (flags & cons_throws_exception) != 0; 1488 irn_verify_irg(res, irg); 1489 res = optimize_node(res); 1490 return res; 1491} 1492 1493ir_node *new_r_Store(ir_node *block, ir_node * irn_mem, ir_node * irn_ptr, ir_node * irn_value, ir_cons_flags flags) 1494{ 1495 return new_rd_Store(NULL, block, irn_mem, irn_ptr, irn_value, flags); 1496} 1497 1498ir_node *new_d_Store(dbg_info *dbgi, ir_node * irn_mem, ir_node * irn_ptr, ir_node * irn_value, ir_cons_flags flags) 1499{ 1500 assert(irg_is_constrained(current_ir_graph, IR_GRAPH_CONSTRAINT_CONSTRUCTION)); 1501 ir_node *res = new_rd_Store(dbgi, current_ir_graph->current_block, irn_mem, irn_ptr, irn_value, flags); 1502 return res; 1503} 1504 1505ir_node *new_Store(ir_node * irn_mem, ir_node * irn_ptr, ir_node * irn_value, ir_cons_flags flags) 1506{ 1507 return new_d_Store(NULL, irn_mem, irn_ptr, irn_value, flags); 1508} 1509 1510ir_node *new_rd_Sub(dbg_info *dbgi, ir_node *block, ir_node * irn_left, ir_node * irn_right, ir_mode * mode) 1511{ 1512 ir_graph *irg = get_irn_irg(block); 1513 1514 ir_node *in[2]; 1515 in[0] = irn_left; 1516 in[1] = irn_right; 1517 1518 ir_node *res = new_ir_node(dbgi, irg, block, op_Sub, mode, 2, in); 1519 irn_verify_irg(res, irg); 1520 res = optimize_node(res); 1521 return res; 1522} 1523 1524ir_node *new_r_Sub(ir_node *block, ir_node * irn_left, ir_node * irn_right, ir_mode * mode) 1525{ 1526 return new_rd_Sub(NULL, block, irn_left, irn_right, mode); 1527} 1528 1529ir_node *new_d_Sub(dbg_info *dbgi, ir_node * irn_left, ir_node * irn_right, ir_mode * mode) 1530{ 1531 assert(irg_is_constrained(current_ir_graph, IR_GRAPH_CONSTRAINT_CONSTRUCTION)); 1532 ir_node *res = new_rd_Sub(dbgi, current_ir_graph->current_block, irn_left, irn_right, mode); 1533 return res; 1534} 1535 1536ir_node *new_Sub(ir_node * irn_left, ir_node * irn_right, ir_mode * mode) 1537{ 1538 return new_d_Sub(NULL, irn_left, irn_right, mode); 1539} 1540 1541ir_node *new_rd_Switch(dbg_info *dbgi, ir_node *block, ir_node * irn_selector, unsigned n_outs, ir_switch_table* table) 1542{ 1543 ir_graph *irg = get_irn_irg(block); 1544 1545 ir_node *in[1]; 1546 in[0] = irn_selector; 1547 1548 ir_node *res = new_ir_node(dbgi, irg, block, op_Switch, mode_T, 1, in); 1549 res->attr.switcha.n_outs = n_outs; 1550 res->attr.switcha.table = table; 1551 irn_verify_irg(res, irg); 1552 res = optimize_node(res); 1553 return res; 1554} 1555 1556ir_node *new_r_Switch(ir_node *block, ir_node * irn_selector, unsigned n_outs, ir_switch_table* table) 1557{ 1558 return new_rd_Switch(NULL, block, irn_selector, n_outs, table); 1559} 1560 1561ir_node *new_d_Switch(dbg_info *dbgi, ir_node * irn_selector, unsigned n_outs, ir_switch_table* table) 1562{ 1563 assert(irg_is_constrained(current_ir_graph, IR_GRAPH_CONSTRAINT_CONSTRUCTION)); 1564 ir_node *res = new_rd_Switch(dbgi, current_ir_graph->current_block, irn_selector, n_outs, table); 1565 return res; 1566} 1567 1568ir_node *new_Switch(ir_node * irn_selector, unsigned n_outs, ir_switch_table* table) 1569{ 1570 return new_d_Switch(NULL, irn_selector, n_outs, table); 1571} 1572 1573ir_node *new_rd_Sync(dbg_info *dbgi, ir_node *block, int arity, ir_node *const * in) 1574{ 1575 ir_graph *irg = get_irn_irg(block); 1576 1577 1578 1579 ir_node *res = new_ir_node(dbgi, irg, block, op_Sync, mode_M, -1, NULL); 1580 for (int i = 0; i < arity; ++i) { 1581 add_irn_n(res, in[i]); 1582 } 1583 irn_verify_irg(res, irg); 1584 res = optimize_node(res); 1585 return res; 1586} 1587 1588ir_node *new_r_Sync(ir_node *block, int arity, ir_node *const * in) 1589{ 1590 return new_rd_Sync(NULL, block, arity, in); 1591} 1592 1593ir_node *new_d_Sync(dbg_info *dbgi, int arity, ir_node *const * in) 1594{ 1595 assert(irg_is_constrained(current_ir_graph, IR_GRAPH_CONSTRAINT_CONSTRUCTION)); 1596 ir_node *res = new_rd_Sync(dbgi, current_ir_graph->current_block, arity, in); 1597 return res; 1598} 1599 1600ir_node *new_Sync(int arity, ir_node *const * in) 1601{ 1602 return new_d_Sync(NULL, arity, in); 1603} 1604 1605ir_node *new_rd_Tuple(dbg_info *dbgi, ir_node *block, int arity, ir_node *const * in) 1606{ 1607 ir_graph *irg = get_irn_irg(block); 1608 1609 1610 1611 ir_node *res = new_ir_node(dbgi, irg, block, op_Tuple, mode_T, arity, in); 1612 irn_verify_irg(res, irg); 1613 res = optimize_node(res); 1614 return res; 1615} 1616 1617ir_node *new_r_Tuple(ir_node *block, int arity, ir_node *const * in) 1618{ 1619 return new_rd_Tuple(NULL, block, arity, in); 1620} 1621 1622ir_node *new_d_Tuple(dbg_info *dbgi, int arity, ir_node *const * in) 1623{ 1624 assert(irg_is_constrained(current_ir_graph, IR_GRAPH_CONSTRAINT_CONSTRUCTION)); 1625 ir_node *res = new_rd_Tuple(dbgi, current_ir_graph->current_block, arity, in); 1626 return res; 1627} 1628 1629ir_node *new_Tuple(int arity, ir_node *const * in) 1630{ 1631 return new_d_Tuple(NULL, arity, in); 1632} 1633 1634ir_node *new_rd_Unknown(dbg_info *dbgi, ir_graph *irg, ir_mode * mode) 1635{ 1636 1637 1638 1639 ir_node *res = new_ir_node(dbgi, irg, get_irg_start_block(irg), op_Unknown, mode, 0, NULL); 1640 irn_verify_irg(res, irg); 1641 res = optimize_node(res); 1642 return res; 1643} 1644 1645ir_node *new_r_Unknown(ir_graph *irg, ir_mode * mode) 1646{ 1647 return new_rd_Unknown(NULL, irg, mode); 1648} 1649 1650ir_node *new_d_Unknown(dbg_info *dbgi, ir_mode * mode) 1651{ 1652 assert(irg_is_constrained(current_ir_graph, IR_GRAPH_CONSTRAINT_CONSTRUCTION)); 1653 ir_node *res = new_rd_Unknown(dbgi, current_ir_graph, mode); 1654 return res; 1655} 1656 1657ir_node *new_Unknown(ir_mode * mode) 1658{ 1659 return new_d_Unknown(NULL, mode); 1660} 1661