Lines Matching defs:assert
97 assert(this->ir() != NULL, "check if valid");
98 assert(this->compilation() != NULL, "check if valid");
99 assert(this->gen() != NULL, "check if valid");
100 assert(this->frame_map() != NULL, "check if valid");
116 assert(opr->is_register(), "should not call this otherwise");
119 assert(opr->vreg_number() >= nof_regs, "found a virtual register with a fixed-register number");
142 assert(opr->is_register(), "should not call this otherwise");
221 assert(_unused_spill_slot == -1, "wasting a spill slot");
273 assert(_intervals.at(reg_num) == NULL, "overwriting exisiting interval");
312 assert(interval->is_split_parent(), "can only be called for split parents");
316 assert(interval->spill_definition_pos() == -1, "must no be set before");
322 assert(def_pos <= interval->spill_definition_pos(), "positions are processed in reverse order when intervals are created");
328 assert(block_of_op_with_id(def_pos) == block_of_op_with_id(interval->spill_definition_pos()), "block must be equal");
337 assert(false, "other states not allowed at this time");
376 assert(false, "other states not allowed at this time");
400 assert(temp->spill_definition_pos() > 0, "invalid spill definition pos");
402 assert(temp->from() >= prev->from(), "intervals not sorted");
403 assert(temp->spill_definition_pos() >= prev->spill_definition_pos(), "when intervals are sorted by from, then they must also be sorted by spill_definition_pos");
406 assert(temp->canonical_spill_slot() >= LinearScan::nof_regs, "interval has no spill slot assigned");
407 assert(temp->spill_definition_pos() >= temp->from(), "invalid order");
408 assert(temp->spill_definition_pos() <= temp->from() + 2, "only intervals defined once at their start-pos can be optimized");
432 assert(op->code() == lir_move, "only moves can have a op_id of -1");
433 assert(op->as_Op1() != NULL, "move must be LIR_Op1");
434 assert(op->as_Op1()->result_opr()->is_virtual(), "LinearScan inserts only moves to virtual registers");
447 assert(interval == Interval::end() || interval->spill_definition_pos() >= op_id, "invalid order");
448 assert(interval == Interval::end() || (interval->is_split_parent() && interval->spill_state() == storeAtDefinition), "invalid interval");
459 assert(from_opr->is_fixed_cpu() || from_opr->is_fixed_fpu(), "from operand must be a register");
460 assert(to_opr->is_stack(), "to operand must be a stack slot");
475 assert(interval == Interval::end(), "missed an interval");
517 assert(lir_op_with_id(op_id) == op, "must match");
524 assert(idx == num_instructions, "must match");
525 assert(idx * 2 == op_id, "must match");
540 assert(!value->type()->is_illegal(), "if this local is used by the interpreter it shouldn't be of indeterminate type");
541 assert(con == NULL || opr->is_virtual() || opr->is_constant() || opr->is_illegal(), "asumption: Constant instructions have only constant operands");
542 assert(con != NULL || opr->is_virtual(), "asumption: non-Constant instructions have only virtual operands");
545 assert(reg_num(opr) == opr->vreg_number() && !is_valid_reg_num(reg_numHi(opr)), "invalid optimization below");
585 assert(visitor.no_operands(instructions->at(0)), "first operation must always be a label");
605 assert(opr->is_register(), "visitor should only return register operands");
608 assert(reg_num(opr) == opr->vreg_number() && !is_valid_reg_num(reg_numHi(opr)), "invalid optimization below");
628 assert(live_kill.at(reg), "using fixed register that is not defined in this block");
632 assert(live_kill.at(reg), "using fixed register that is not defined in this block");
652 assert(opr->is_register(), "visitor should only return register operands");
655 assert(reg_num(opr) == opr->vreg_number() && !is_valid_reg_num(reg_numHi(opr)), "invalid optimization below");
685 assert(opr->is_register(), "visitor should only return register operands");
688 assert(reg_num(opr) == opr->vreg_number() && !is_valid_reg_num(reg_numHi(opr)), "invalid optimization below");
820 assert(block->live_in().at(j) == false, "live_in set of fixed register must be empty");
821 assert(block->live_out().at(j) == false, "live_out set of fixed register must be empty");
822 assert(block->live_gen().at(j) == false, "live_gen set of fixed register must be empty");
855 assert(false, "live_in set of first block must be empty");
866 assert(!value->type()->is_illegal(), "if this value is used by the interpreter it shouldn't be of indeterminate type");
871 assert(reg_num(opr) == opr->vreg_number() && !is_valid_reg_num(reg_numHi(opr)), "invalid optimization below");
879 assert(opr->is_register(), "should not be called otherwise");
882 assert(reg_num(opr) == opr->vreg_number() && !is_valid_reg_num(reg_numHi(opr)), "invalid optimization below");
899 assert(opr->is_register(), "should not be called otherwise");
902 assert(reg_num(opr) == opr->vreg_number() && !is_valid_reg_num(reg_numHi(opr)), "invalid optimization below");
919 assert(opr->is_register(), "should not be called otherwise");
922 assert(reg_num(opr) == opr->vreg_number() && !is_valid_reg_num(reg_numHi(opr)), "invalid optimization below");
941 assert(interval->reg_num() == reg_num, "wrong interval");
988 assert(interval->reg_num() == reg_num, "wrong interval");
1003 assert(interval->reg_num() == reg_num, "wrong interval");
1019 assert(op->as_Op1() != NULL, "lir_move must be LIR_Op1");
1055 assert(op->as_Op1() != NULL, "lir_move must be LIR_Op1");
1083 assert(op->result_opr()->is_register(), "result must always be in a register");
1100 assert(op->as_Op2() != NULL, "must be LIR_Op2");
1103 assert((op2->result_opr()->is_register() || op->code() == lir_cmp) && op2->in_opr1()->is_register(), "cannot mark second operand as stack if others are not in register");
1118 assert(op->as_Op2() != NULL, "must be LIR_Op2");
1121 assert((op2->result_opr()->is_register() || op->code() == lir_cmp) && op2->in_opr1()->is_register(), "cannot mark second operand as stack if others are not in register");
1142 assert(op->as_Op2() != NULL, "must be LIR_Op2");
1145 assert((op2->result_opr()->is_register() || op->code() == lir_cmp) && op2->in_opr1()->is_register(), "cannot mark second operand as stack if others are not in register");
1166 assert(op->as_Op1() != NULL, "must be LIR_Op1");
1174 assert(o->single_stack_ix() >= 0 && o->single_stack_ix() < arg_size, "out of range");
1176 assert(o->double_stack_ix() >= 0 && o->double_stack_ix() < arg_size, "out of range");
1181 assert(move->id() > 0, "invalid id");
1182 assert(block_of_op_with_id(move->id())->number_of_preds() == 0, "move from stack must be in first block");
1183 assert(move->result_opr()->is_virtual(), "result of move must be a virtual register");
1202 assert(op->as_Op1() != NULL, "must be LIR_Op1");
1223 assert(op->as_Op1() != NULL, "lir_move, lir_convert must be LIR_Op1");
1240 assert(op->as_Op2() != NULL, "lir_cmove must be LIR_Op2");
1279 assert(opr->is_valid() && opr->is_register(), "FrameMap should not return invalid operands");
1280 assert(reg_numHi(opr) == -1, "missing addition of range for hi-register");
1293 assert(opr->is_valid() && opr->is_register(), "FrameMap should not return invalid operands");
1294 assert(reg_numHi(opr) == -1, "missing addition of range for hi-register");
1303 assert(opr->is_valid() && opr->is_register(), "FrameMap should not return invalid operands");
1304 assert(reg_numHi(opr) == -1, "missing addition of range for hi-register");
1310 assert(num_caller_save_registers <= LinearScan::nof_regs, "out of bounds");
1322 assert(block_from == instructions->at(0)->id(), "must be");
1323 assert(block_to == instructions->at(instructions->length() - 1)->id(), "must be");
1329 assert(live.at(number), "should not stop here otherwise");
1330 assert(number >= LIR_OprDesc::vreg_base, "fixed intervals must not be live on block bounds");
1349 assert(visitor.no_operands(instructions->at(0)), "first operation must always be a label");
1373 assert(opr->is_register(), "visitor should only return register operands");
1380 assert(opr->is_register(), "visitor should only return register operands");
1388 assert(opr->is_register(), "visitor should only return register operands");
1489 assert(from <= it->from(), "Intervals are unordered");
1496 assert(null_count == 0, "Sorted intervals should not contain nulls");
1503 assert(find_interval(interval, intervals), "Lists do not contain same intervals");
1509 assert(interval_count() - null_count == intervals->length(),
1526 assert(is_sorted(_sorted_intervals), "interval list is not sorted");
1549 assert(list1_prev == NULL || list1_prev->next() == Interval::end(), "linear list ends not with sentinel");
1550 assert(list2_prev == NULL || list2_prev->next() == Interval::end(), "linear list ends not with sentinel");
1559 assert(false, "should never occur");
1604 assert(is_sorted(_sorted_intervals), "intervals unsorted");
1623 assert(is_sorted(_sorted_intervals), "intervals unsorted");
1647 assert(is_sorted(_sorted_intervals), "intervals unsorted");
1691 assert(false, "must find an interval, but do a clean bailout in product mode");
1700 assert(LinearScan::nof_regs <= reg_num && reg_num < num_virtual_regs(), "register number out of bounds");
1701 assert(interval_at(reg_num) != NULL, "no interval found");
1707 assert(LinearScan::nof_regs <= reg_num && reg_num < num_virtual_regs(), "register number out of bounds");
1708 assert(interval_at(reg_num) != NULL, "no interval found");
1714 assert(LinearScan::nof_regs <= reg_num && reg_num < num_virtual_regs(), "register number out of bounds");
1715 assert(interval_at(reg_num) != NULL, "no interval found");
1730 assert(r < num_regs, "live information set for not exisiting interval");
1731 assert(from_block->live_out().at(r) && to_block->live_in().at(r), "interval not live at this edge");
1752 assert(branch->cond() == lir_cond_always, "block does not end with an unconditional jump");
1761 assert(from_block->lir()->instructions_list()->at(0)->as_OpLabel() != NULL, "block does not start with a label");
1768 assert(from_block == to_block->pred_at(i), "all critical edges must be broken");
1793 assert(instructions->at(0)->code() == lir_label, "block must start with label");
1794 assert(instructions->last()->code() == lir_branch, "block with successors must end with branch");
1795 assert(instructions->last()->as_OpBranch()->cond() == lir_cond_always, "block with successor must end with unconditional branch");
1869 assert(interval->from() <= from_op_id && interval->to() >= to_op_id,
1880 assert(interval->from() == from_op_id, "must be true now");
1891 assert(spilled_part->from() == from_op_id && spilled_part->to() == to_op_id, "just checking");
1896 assert(block->is_set(BlockBegin::exception_entry_flag), "should not call otherwise");
1968 assert(handler->lir_op_id() == -1, "already processed this xhandler");
1970 assert(handler->entry_code() == NULL, "code already present");
2014 assert(visitor.no_operands(ops->at(0)), "first operation must always be a label");
2022 assert(visitor.info_count() > 0, "should not visit otherwise");
2033 assert(visitor.all_xhandler()->length() == 0, "missed exception handler");
2050 assert(reg == vm_reg_for_operand(operand_for_interval(interval)), "wrong cached value");
2055 assert(opr->is_oop(), "currently only implemented for oop operands");
2067 assert(opr == calc_operand_for_interval(interval), "wrong cached value");
2077 assert(interval->assigned_regHi() == any_reg, "must not have hi register");
2084 assert(assigned_reg >= pd_first_cpu_reg && assigned_reg <= pd_last_cpu_reg, "no cpu register");
2085 assert(interval->assigned_regHi() == any_reg, "must not have hi register");
2090 assert(assigned_reg >= pd_first_cpu_reg && assigned_reg <= pd_last_cpu_reg, "no cpu register");
2091 assert(interval->assigned_regHi() == any_reg, "must not have hi register");
2096 assert(assigned_reg >= pd_first_cpu_reg && assigned_reg <= pd_last_cpu_reg, "no cpu register");
2097 assert(interval->assigned_regHi() == any_reg, "must not have hi register");
2105 assert(assigned_reg >= pd_first_cpu_reg && assigned_reg <= pd_last_cpu_reg, "no cpu register");
2106 assert(interval->assigned_regHi() == any_reg, "must not have hi register");
2115 assert(assigned_reg >= pd_first_cpu_reg && assigned_reg <= pd_last_cpu_reg, "no cpu register");
2116 assert(num_physical_regs(T_LONG) == 1 ||
2119 assert(assigned_reg != assigned_regHi, "invalid allocation");
2120 assert(num_physical_regs(T_LONG) == 1 || assigned_reg < assigned_regHi,
2122 assert((assigned_regHi != any_reg) ^ (num_physical_regs(T_LONG) == 1), "must be match");
2124 assert(assigned_reg % 2 == 0 && assigned_reg + 1 == assigned_regHi, "must be sequential and even");
2148 assert(assigned_reg >= pd_first_xmm_reg && assigned_reg <= last_xmm_reg, "no xmm register");
2149 assert(interval->assigned_regHi() == any_reg, "must not have hi register");
2154 assert(assigned_reg >= pd_first_fpu_reg && assigned_reg <= pd_last_fpu_reg, "no fpu register");
2155 assert(interval->assigned_regHi() == any_reg, "must not have hi register");
2168 assert(assigned_reg >= pd_first_xmm_reg && assigned_reg <= last_xmm_reg, "no xmm register");
2169 assert(interval->assigned_regHi() == any_reg, "must not have hi register (double xmm values are stored in one register)");
2175 assert(assigned_reg >= pd_first_fpu_reg && assigned_reg <= pd_last_fpu_reg, "no fpu register");
2176 assert(interval->assigned_regHi() >= pd_first_fpu_reg && interval->assigned_regHi() <= pd_last_fpu_reg, "no fpu register");
2177 assert(assigned_reg % 2 == 0 && assigned_reg + 1 == interval->assigned_regHi(), "must be sequential and even");
2180 assert(assigned_reg >= pd_first_fpu_reg && assigned_reg <= pd_last_fpu_reg, "no fpu register");
2181 assert(interval->assigned_regHi() >= pd_first_fpu_reg && interval->assigned_regHi() <= pd_last_fpu_reg, "no fpu register");
2182 assert(assigned_reg % 2 == 0 && assigned_reg + 1 == interval->assigned_regHi(), "must be sequential and even");
2185 assert(assigned_reg >= pd_first_fpu_reg && assigned_reg <= pd_last_fpu_reg, "no fpu register");
2186 assert(interval->assigned_regHi() == any_reg, "must not have hi register (double fpu values are stored in one register on Intel)");
2202 assert(interval->canonical_spill_slot() >= nof_regs, "canonical spill slot not set");
2207 assert(opr->is_virtual(), "should not call this otherwise");
2210 assert(interval != NULL, "interval must exist");
2222 assert(branch->cond() == lir_cond_always, "block does not end with an unconditional jump");
2223 assert(false, "can't get split child for the last branch of a block because the information would be incorrect (moves are inserted before the branch in resolve_data_flow)");
2244 assert(op_id == -1 || !is_block_begin(op_id), "holes at begin of block may also result from control flow");
2250 assert(!gen()->is_vreg_flag_set(opr->vreg_number(), LIRGenerator::callee_saved) || !FrameMap::is_caller_save_register(res), "bad allocation");
2269 assert(location.where() == Location::on_stack, "value is in register");
2284 assert(location.where() == Location::on_stack, "owner is in register");
2286 assert(value->basic_lock().where() == Location::on_stack, "basic_lock is in register");
2291 assert(l1.where() == l2.where() && l1.type() == l2.type() && l1.offset() == l2.offset(), "");
2296 assert(v2->is_location(), "");
2299 assert(v2->is_constant_int(), "");
2300 assert(((ConstantIntValue*)v1)->value() == ((ConstantIntValue*)v2)->value(), "");
2302 assert(v2->is_constant_double(), "");
2303 assert(((ConstantDoubleValue*)v1)->value() == ((ConstantDoubleValue*)v2)->value(), "");
2305 assert(v2->is_constant_long(), "");
2306 assert(((ConstantLongValue*)v1)->value() == ((ConstantLongValue*)v2)->value(), "");
2308 assert(v2->is_constant_oop(), "");
2309 assert(((ConstantOopWriteValue*)v1)->value() == ((ConstantOopWriteValue*)v2)->value(), "");
2321 assert(d1->scope() == d2->scope(), "not equal");
2322 assert(d1->bci() == d2->bci(), "not equal");
2325 assert(d1->locals() != NULL && d2->locals() != NULL, "not equal");
2326 assert(d1->locals()->length() == d2->locals()->length(), "not equal");
2331 assert(d1->locals() == NULL && d2->locals() == NULL, "not equal");
2335 assert(d1->expressions() != NULL && d2->expressions() != NULL, "not equal");
2336 assert(d1->expressions()->length() == d2->expressions()->length(), "not equal");
2341 assert(d1->expressions() == NULL && d2->expressions() == NULL, "not equal");
2345 assert(d1->monitors() != NULL && d2->monitors() != NULL, "not equal");
2346 assert(d1->monitors()->length() == d2->monitors()->length(), "not equal");
2351 assert(d1->monitors() == NULL && d2->monitors() == NULL, "not equal");
2355 assert(d1->caller() != NULL && d2->caller() != NULL, "not equal");
2358 assert(d1->caller() == NULL && d2->caller() == NULL, "not equal");
2382 assert(stack_end >= -Bytecodes::depth(code), "must have non-empty expression stack at if bytecode");
2426 assert(interval->current_from() <= op->id() && op->id() <= interval->current_to(), "interval should not be active otherwise");
2427 assert(interval->assigned_regHi() == any_reg, "oop must be single word");
2428 assert(interval->reg_num() >= LIR_OprDesc::vreg_base, "fixed interval found");
2439 assert(!is_call_site || assigned_reg >= nof_regs || !is_caller_save(assigned_reg), "interval is in a caller-save register at a call -> register will be overwritten");
2449 assert(interval->spill_definition_pos() > 0, "position not set correctly");
2450 assert(interval->canonical_spill_slot() >= LinearScan::nof_regs, "no spill slot assigned");
2451 assert(interval->assigned_reg() < LinearScan::nof_regs, "interval is on stack, so stack slot is registered twice");
2459 assert(info->stack() != NULL, "CodeEmitInfo must always have a stack");
2470 assert(visitor.info_count() > 0, "no oop map needed");
2498 assert(info->_oop_map == oop_map, "same CodeEmitInfo used for multiple LIR instructions");
2545 assert(opr->is_constant(), "should not be called otherwise");
2657 assert(use_fpu_stack_allocation(), "should not have float stack values without fpu stack allocation (all floats must be SSE2)");
2658 assert(_fpu_stack_allocator != NULL, "must be present");
2741 assert(opr->fpu_regnrLo() == opr->fpu_regnrHi(), "assumed in calculation");
2768 assert(use_fpu_stack_allocation(), "should not have float stack values without fpu stack allocation (all floats must be SSE2)");
2769 assert(_fpu_stack_allocator != NULL, "must be present");
2772 assert(opr->fpu_regnrLo() == opr->fpu_regnrHi(), "assumed in calculation (only fpu_regnrLo is used)");
2775 assert(opr->fpu_regnrLo() == opr->fpu_regnrHi() + 1, "assumed in calculation (only fpu_regnrHi is used)");
2778 assert(opr->fpu_regnrHi() == opr->fpu_regnrLo() + 1, "assumed in calculation (only fpu_regnrLo is used)");
2781 assert(opr->fpu_regnrLo() == opr->fpu_regnrHi(), "assumed in calculation (only fpu_regnrHi is used)");
2808 assert(first != NULL && second != NULL, "must be set");
2827 assert(con == NULL || opr->is_virtual() || opr->is_constant() || opr->is_illegal(), "asumption: Constant instructions have only constant operands (or illegal if constant is optimized away)");
2828 assert(con != NULL || opr->is_virtual(), "asumption: non-Constant instructions have only virtual operands");
2836 assert(opr->is_virtual() || opr->is_constant(), "other cases not allowed here");
2860 assert(!has_call(op_id) || opr->is_stack() || !is_caller_save(reg_num(opr)), "can not have caller-save register operands at calls");
2866 assert(value->as_Constant() != NULL, "all other instructions have only virtual operands");
2867 assert(opr->is_constant(), "operand must be constant");
2902 assert(pos < cur_state->locals_size(), "why not?");
2907 assert(locals->length() == pos, "must match");
2909 assert(locals->length() == cur_scope->method()->max_locals(), "wrong number of locals");
2910 assert(locals->length() == cur_state->locals_size(), "wrong number of locals");
2912 assert(cur_state->kind() == ValueStack::EmptyExceptionState, "should be");
2930 assert(expressions->length() == pos, "must match");
2932 assert(expressions->length() == cur_state->stack_size(), "wrong number of stack entries");
2955 assert(innermost_scope != NULL && innermost_state != NULL, "why is it missing?");
3008 assert(visitor.all_xhandler()->length() == 0, "missed exception handler");
3012 assert(iw != NULL, "needed for compute_oop_map");
3035 assert(op->as_Op1() != NULL, "move must be LIR_Op1");
3296 assert(has_error == false, "register allocation invalid");
3365 assert(ok, "fixed intervals should never be live across an oopmap point");
3384 assert(interval != NULL, "no interval");
3388 assert(interval->to() < op_id + 2 ||
3394 assert(interval->has_hole_between(op_id - 1, op_id),
3422 assert(value != NULL, "all intervals live across block boundaries must have Value");
3423 assert(value->operand()->is_register() && value->operand()->is_virtual(), "value must have virtual operand");
3424 assert(value->operand()->vreg_number() == r, "register number must match");
3425 // TKR assert(value->as_Constant() == NULL || value->is_pinned(), "only pinned constants can be alive accross block boundaries");
3709 assert(has_error == false, "Error in register allocation");
3738 assert(_mapping_from.length() == 0 && _mapping_from_opr.length() == 0 && _mapping_to.length() == 0, "list must be empty before and after processing");
3740 assert(register_blocked(i) == 0, "register map must be empty before and after processing");
3742 assert(_multiple_reads_allowed == false, "must have default value");
3746 assert(_mapping_from.length() == _mapping_from_opr.length(), "length must be equal");
3747 assert(_mapping_from.length() == _mapping_to.length(), "length must be equal");
3748 assert(_insert_list != NULL && _insert_idx != -1, "insert position not set");
3754 assert(_mapping_from.at(i) == NULL || _mapping_from.at(i) != _mapping_from.at(j), "cannot read from same interval twice");
3761 assert(_mapping_to.at(i) != _mapping_to.at(j), "cannot write to same interval twice");
3771 assert(!used_regs.at(it->assigned_reg()), "cannot read from same register twice");
3775 assert(!used_regs.at(it->assigned_regHi()), "cannot read from same register twice");
3785 assert(!used_regs.at(it->assigned_reg()), "cannot write to same register twice");
3789 assert(!used_regs.at(it->assigned_regHi()), "cannot write to same register twice");
3803 assert(!used_regs.at(it->assigned_reg()) || it->assigned_reg() == _mapping_from.at(i)->assigned_reg(), "stack slots used in _mapping_from must be disjoint to _mapping_to");
3814 assert(_multiple_reads_allowed || register_blocked(reg) == 0, "register already marked as used");
3819 assert(_multiple_reads_allowed || register_blocked(reg) == 0, "register already marked as used");
3828 assert(register_blocked(reg) > 0, "register already marked as unused");
3833 assert(register_blocked(reg) > 0, "register already marked as unused");
3865 assert(!_insertion_buffer.initialized(), "overwriting existing buffer");
3873 assert(!_insertion_buffer.initialized(), "must be uninitialized now");
3880 assert(from_interval->reg_num() != to_interval->reg_num(), "from and to interval equal");
3881 assert(from_interval->type() == to_interval->type(), "move between different types");
3882 assert(_insert_list != NULL && _insert_idx != -1, "must setup insert position first");
3883 assert(_insertion_buffer.lir_list() == _insert_list, "wrong insertion buffer");
3900 assert(from_opr->type() == to_interval->type(), "move between different types");
3901 assert(_insert_list != NULL && _insert_idx != -1, "must setup insert position first");
3902 assert(_insertion_buffer.lir_list() == _insert_list, "wrong insertion buffer");
3957 assert(spill_candidate != -1, "no interval in register for spilling found");
3998 assert(_insert_list == NULL && _insert_idx == -1, "use move_insert_position instead of set_insert_position when data already set");
4035 assert(from_opr->is_constant(), "only for constants");
4069 assert(r1 != NULL && r2 != NULL, "null ranges not allowed");
4070 assert(r1 != _end && r2 != _end, "empty ranges not allowed");
4139 assert(_first != Range::end(), "interval has no range");
4153 assert(is_split_parent(), "only split parents can have children");
4158 assert(i1->split_parent() == this, "not a split child of this interval");
4159 assert(i1->type() == type(), "must be equal for all split children");
4160 assert(i1->canonical_spill_slot() == canonical_spill_slot(), "must be equal for all split children");
4165 assert(i1->reg_num() != i2->reg_num(), "same register number");
4168 assert(i1->to() <= i2->from() && i1->to() < i2->to(), "intervals overlapping");
4170 assert(i2->from() < i1->from(), "intervals start at same op_id");
4171 assert(i2->to() <= i1->from() && i2->to() < i1->to(), "intervals overlapping");
4185 assert(_register_hint->is_split_parent(), "ony split parents are valid hint registers");
4209 assert(is_split_parent(), "can only be called for split parents");
4210 assert(op_id >= 0, "invalid op_id (method can not be called for spill moves)");
4245 assert(false, "two valid result intervals found");
4251 assert(result != NULL, "no matching interval found");
4252 assert(result->covers(op_id, mode), "op_id not covered by interval");
4260 assert(op_id >= 0, "invalid op_id");
4266 assert(len > 0, "no split children available");
4275 assert(result != NULL, "no split child found");
4282 assert(is_split_parent(), "can only be called for split parents");
4283 assert(op_id >= 0, "invalid op_id (method can not be called for spill moves)");
4305 assert(LinearScan::is_virtual_interval(this), "cannot access use positions for fixed intervals");
4316 assert(LinearScan::is_virtual_interval(this), "cannot access use positions for fixed intervals");
4327 assert(LinearScan::is_virtual_interval(this), "cannot access use positions for fixed intervals");
4338 assert(LinearScan::is_virtual_interval(this), "cannot access use positions for fixed intervals");
4353 assert(covers(pos, LIR_OpVisitState::inputMode), "use position not covered by live range");
4359 assert(_use_pos_and_kinds.length() % 2 == 0, "must be");
4361 assert(pos <= _use_pos_and_kinds.at(i), "already added a use-position with lower position");
4362 assert(_use_pos_and_kinds.at(i + 1) >= firstValidKind && _use_pos_and_kinds.at(i + 1) <= lastValidKind, "invalid use kind");
4364 assert(_use_pos_and_kinds.at(i) < _use_pos_and_kinds.at(i - 2), "not sorted descending");
4376 assert(_use_pos_and_kinds.at(len - 2) == pos, "list not sorted correctly");
4383 assert(from < to, "invalid range");
4384 assert(first() == Range::end() || to < first()->next()->from(), "not inserting at begin of interval");
4385 assert(from <= first()->to(), "not inserting at begin of interval");
4408 assert(is_split_parent(), "list must be initialized at first split");
4429 assert(LinearScan::is_virtual_interval(this), "cannot split fixed intervals");
4441 assert(cur != Range::end(), "split interval after end of last range");
4449 assert(prev != NULL, "split before start of first range");
4474 assert(_use_pos_and_kinds.length() % 2 == 0, "must have use kind for each use pos");
4475 assert(result->_use_pos_and_kinds.length() % 2 == 0, "must have use kind for each use pos");
4476 assert(_use_pos_and_kinds.length() + result->_use_pos_and_kinds.length() == total_len, "missed some entries");
4479 assert(_use_pos_and_kinds.at(i) < split_pos, "must be");
4480 assert(_use_pos_and_kinds.at(i + 1) >= firstValidKind && _use_pos_and_kinds.at(i + 1) <= lastValidKind, "invalid use kind");
4483 assert(result->_use_pos_and_kinds.at(i) >= split_pos, "must be");
4484 assert(result->_use_pos_and_kinds.at(i + 1) >= firstValidKind && result->_use_pos_and_kinds.at(i + 1) <= lastValidKind, "invalid use kind");
4497 assert(LinearScan::is_virtual_interval(this), "cannot split fixed intervals");
4498 assert(split_pos > from() && split_pos < to(), "can only split inside interval");
4499 assert(split_pos > _first->from() && split_pos <= _first->to(), "can only split inside first range");
4500 assert(first_usage(noUse) > split_pos, "can not split when use positions are present");
4510 assert(_first->next() != Range::end(), "must not be at end");
4528 assert(cur->to() != cur->next()->from(), "ranges not separated");
4542 assert(hole_from < hole_to, "check");
4543 assert(from() <= hole_from && hole_to <= to(), "index out of interval");
4547 assert(cur->to() < cur->next()->from(), "no space between ranges");
4619 assert(cur != NULL, "range list not closed with range sentinel");
4624 assert(_use_pos_and_kinds.length() % 2 == 0, "must be");
4626 assert(_use_pos_and_kinds.at(i + 1) >= firstValidKind && _use_pos_and_kinds.at(i + 1) <= lastValidKind, "invalid use kind");
4627 assert(prev < _use_pos_and_kinds.at(i), "use positions not sorted");
4680 assert(interval->from() >= current()->current_from(), "cannot append new interval before current walk position");
4701 assert(*list == i, "check");
4715 assert(i->state() == inactiveState, "invalid state");
4719 assert(deleted, "interval has not been found in list");
4724 assert (state == activeState || state == inactiveState, "wrong state");
4753 assert(state == activeState, "check");
4762 assert(state == inactiveState, "check");
4785 assert (kind == fixedKind && fixed->from() <= any->from() ||
4787 assert(any == Interval::end() || fixed == Interval::end() || any->from() != fixed->from() || kind == fixedKind, "if fixed and any-Interval start at same position, fixed must be processed first");
4803 assert(_current_position <= lir_op_id, "can not walk backwards");
4878 assert(reg < LinearScan::nof_regs, "interval must have a register assigned (stack slots not allowed)");
4884 assert(i->assigned_reg() != any_reg, "interval has no register assigned");
4891 assert(use_pos != 0, "must use exclude_from_use to set use_pos to 0");
4903 assert(i->assigned_reg() != any_reg, "interval has no register assigned");
4921 assert(i->assigned_reg() != any_reg, "interval has no register assigned");
4932 assert(list->assigned_reg() < LinearScan::nof_regs, "active interval must have a register assigned");
4950 assert(list->current_intersects_at(cur) == -1, "must not intersect");
5000 assert(list->current_intersects_at(cur) == -1, "invalid optimization: intervals intersect");
5032 assert(op_id > 0 && allocator()->block_of_op_with_id(op_id - 2) == op_block, "cannot insert move at block boundary");
5041 assert(list->at(index)->id() <= op_id, "error in calculation");
5045 assert(0 <= index && index < list->length(), "index out of bounds");
5047 assert(1 <= index && index < list->length(), "index out of bounds");
5048 assert(list->at(index)->id() == op_id, "error in calculation");
5060 assert(0 <= from_block_nr && from_block_nr < block_count(), "out of range");
5061 assert(0 <= to_block_nr && to_block_nr < block_count(), "out of range");
5062 assert(from_block_nr < to_block_nr, "must cross block boundary");
5081 assert(optimal_split_pos > allocator()->max_lir_op_id() || allocator()->is_block_begin(optimal_split_pos), "algorithm must move split pos to block boundary");
5095 assert(min_split_pos < max_split_pos, "must be true then");
5096 assert(min_split_pos > 0, "cannot access min_split_pos - 1 otherwise");
5109 assert(min_block->linear_scan_number() <= max_block->linear_scan_number(), "invalid order");
5133 assert(loop_end_pos > min_split_pos, "invalid order");
5143 assert(loop_block != min_block, "loop_block and min_block must be different because block boundary is needed between");
5177 assert(it->from() < min_split_pos, "cannot split at start of interval");
5178 assert(current_position() < min_split_pos, "cannot split before current position");
5179 assert(min_split_pos <= max_split_pos, "invalid order");
5180 assert(max_split_pos <= it->to(), "cannot split after end of interval");
5184 assert(min_split_pos <= optimal_split_pos && optimal_split_pos <= max_split_pos, "out of range");
5185 assert(optimal_split_pos <= it->to(), "cannot split after end of interval");
5186 assert(optimal_split_pos > it->from(), "cannot split at start of interval");
5204 assert(allocator()->is_block_begin(optimal_split_pos) || (optimal_split_pos % 2 == 1), "split pos must be odd when not on block boundary");
5205 assert(!allocator()->is_block_begin(optimal_split_pos) || (optimal_split_pos % 2 == 0), "split pos must be even on block boundary");
5233 assert(it->state() == activeState, "why spill interval that is not active?");
5234 assert(it->from() <= min_split_pos, "cannot split before start of interval");
5235 assert(min_split_pos <= max_split_pos, "invalid order");
5236 assert(max_split_pos < it->to(), "cannot split at end end of interval");
5237 assert(current_position() < it->to(), "interval must not end before current position");
5242 assert(it->first_usage(shouldHaveRegister) > current_position(), "interval must not have use position before current_position");
5270 assert(min_split_pos <= optimal_split_pos && optimal_split_pos <= max_split_pos, "out of range");
5271 assert(optimal_split_pos < it->to(), "cannot split at end of interval");
5272 assert(optimal_split_pos >= it->from(), "cannot split before start of interval");
5280 assert(allocator()->is_block_begin(optimal_split_pos) || (optimal_split_pos % 2 == 1), "split pos must be odd when not on block boundary");
5281 assert(!allocator()->is_block_begin(optimal_split_pos) || (optimal_split_pos % 2 == 0), "split pos must be even on block boundary");
5294 assert(spilled_part->current_split_child() == it, "overwriting wrong current_split_child");
5319 assert(it->state() == activeState || it->state() == inactiveState, "other states not allowed");
5326 assert(it->has_hole_between(current_pos - 1, current_pos + 1), "interval can not be inactive otherwise");
5339 assert(it->next_usage(mustHaveRegister, current_pos) == max_jint, "the remaining part is spilled to stack and therefore has no register");
5377 assert((_last_reg - _first_reg + 1) % 2 == 0, "adjust algorithm");
5416 assert(unhandled_first(fixedKind) == Interval::end(), "must not have unhandled fixed intervals because all fixed intervals have a use at position 0");
5431 assert(hint_reg != any_reg && hint_regHi == any_reg, "must be for fixed intervals");
5440 assert(hint_reg == any_reg || hint_reg != hint_regHi, "hint reg and regHi equal");
5441 assert(cur->assigned_reg() == any_reg && cur->assigned_regHi() == any_reg, "register already assigned to interval");
5492 assert(split_pos > 0, "invalid split_pos");
5525 assert((_last_reg - _first_reg + 1) % 2 == 0, "adjust algorithm");
5546 assert(reg != any_reg, "no register assigned");
5575 assert(unhandled_first(fixedKind) == Interval::end(), "must not have unhandled fixed intervals because all fixed intervals have a use at position 0");
5596 assert (reg_needed_until > 0 && reg_needed_until < max_jint, "interval has no use");
5646 assert(false, "cannot spill interval that is used in first instruction (possible reason: no register found)");
5655 assert(reg != any_reg && (_num_phys_regs == 1 || regHi != any_reg), "no register found");
5656 assert(split_pos > 0, "invalid split_pos");
5657 assert(need_split == false || split_pos > cur->from(), "splitting interval at from");
5685 assert(alloc_free_reg(cur) == false, "found a register for this interval");
5709 assert(0 <= _first_reg && _first_reg < LinearScan::nof_regs, "out of range");
5710 assert(0 <= _last_reg && _last_reg < LinearScan::nof_regs, "out of range");
5718 assert(op->as_Op1() != NULL, "move must be LIR_Op1");
5738 assert(register_hint->is_split_parent(), "register hint must be split parent");
5765 assert(begin_hint->assigned_reg() != any_reg, "must have register assigned");
5766 assert(end_hint->assigned_reg() == any_reg, "must not have register assigned");
5767 assert(cur->first_usage(mustHaveRegister) == begin_pos, "must have use position at begin of interval because of move");
5768 assert(end_hint->first_usage(mustHaveRegister) == end_pos, "must have use position at begin of interval because of move");
5774 assert(register_hint->canonical_spill_slot() != -1, "must be set when part of interval was spilled");
5804 assert(cur->assigned_reg() == any_reg && cur->assigned_regHi() == any_reg, "register already assigned");
5833 assert(cur->is_split_child(), "must be");
5834 assert(cur->current_split_child() != NULL, "must be");
5835 assert(cur->current_split_child()->reg_num() != cur->reg_num(), "cannot insert move between same interval");
5914 assert(op1->as_Op1() != NULL, "move must be LIR_Op1");
5915 assert(op2->as_Op1() != NULL, "move must be LIR_Op1");
5924 assert(op1->as_Op1() != NULL, "fxch must be LIR_Op1");
5925 assert(op2->as_Op1() != NULL, "fxch must be LIR_Op1");
5952 assert(num_preds > 1, "do not call otherwise");
5953 assert(!block->is_set(BlockBegin::exception_entry_flag), "exception handlers not allowed");
5967 assert(pred->number_of_sux() == 1, "can handle only one successor");
5968 assert(pred->sux_at(0) == block, "invalid control flow");
5969 assert(pred_instructions->last()->code() == lir_branch, "block with successor must end with branch");
5970 assert(pred_instructions->last()->as_OpBranch() != NULL, "branch must be LIR_OpBranch");
5971 assert(pred_instructions->last()->as_OpBranch()->cond() == lir_cond_always, "block must end with unconditional branch");
6015 assert(num_sux == 2, "method should not be called otherwise");
6016 assert(cur_instructions->last()->code() == lir_branch, "block with successor must end with branch");
6017 assert(cur_instructions->last()->as_OpBranch() != NULL, "branch must be LIR_OpBranch");
6018 assert(cur_instructions->last()->as_OpBranch()->cond() == lir_cond_always, "block must end with unconditional branch");
6042 assert(false, "block with two successors can have only two branch instructions");
6052 assert(sux_instructions->at(0)->code() == lir_label, "block must start with label");
6059 assert(sux->pred_at(0) == block, "invalid control flow");
6060 assert(!sux->is_set(BlockBegin::exception_entry_flag), "exception handlers not allowed");
6105 assert(code->at(index) == osr_entry, "wrong index");
6140 assert(code->at(end_idx)->is_set(BlockBegin::backward_branch_target_flag), "must be backward branch target");
6168 assert(instructions->length() >= 2, "block must have label and branch");
6169 assert(instructions->at(0)->code() == lir_label, "first instruction must always be a label");
6170 assert(instructions->last()->as_OpBranch() != NULL, "last instrcution must always be a branch");
6171 assert(instructions->last()->as_OpBranch()->cond() == lir_cond_always, "branch must be unconditional");
6172 assert(instructions->last()->as_OpBranch()->block() == block->sux_at(0), "branch target must be the successor");
6188 assert(instructions->at(0)->code() == lir_label, "first instruction must always be a label");
6193 assert(op->as_OpBranch() != NULL, "branch must be of type LIR_OpBranch");
6262 assert(last_op->as_OpBranch() != NULL, "branch must be of type LIR_OpBranch");
6265 assert(last_branch->block() != NULL, "last branch must always have a block as target");
6266 assert(last_branch->label() == last_branch->block()->label(), "must be equal");
6279 assert(prev_op->as_OpBranch() != NULL, "branch must be of type LIR_OpBranch");
6294 assert(prev_op->as_Op2() != NULL, "cmove must be of type LIR_Op2");
6296 assert(prev_branch->cond() == prev_cmove->condition(), "should be the same");
6299 assert(prev_op->as_Op2() != NULL, "branch must be of type LIR_Op2");
6301 assert(prev_branch->cond() == prev_cmp->condition(), "should be the same");
6304 assert(prev_cmp != NULL, "should have found comp instruction for branch");
6342 assert(cur_instructions->at(0)->code() == lir_label, "first instruction must always be a label");
6352 assert(cur_last_op->info() == NULL, "return instructions do not have debug information");
6353 assert(block->number_of_sux() == 0 ||
6357 assert(cur_last_op->as_Op1() != NULL, "return must be LIR_Op1");
6366 assert(pred_last_op->as_OpBranch() != NULL, "branch must be LIR_OpBranch");
6395 assert(op_branch->block() == NULL || code->find(op_branch->block()) != -1, "branch target not valid");
6396 assert(op_branch->ublock() == NULL || code->find(op_branch->ublock()) != -1, "branch target not valid");
6402 assert(code->find(sux) != -1, "successor not valid");
6407 assert(code->find(pred) != -1, "successor not valid");
6617 assert(res->is_register(), "must be");