jdk-sandbox: comparison hotspot/src/cpu/sparc/vm/sharedRuntime

equal deleted inserted replaced

-:a3919f5e8d2b
+:750c6edff33b
 // vararg's layout space and the like.  Briefly holds the caller's
 // register save area.
 call_args_area = frame::register_save_words_sp_offset +
 frame::memory_parameter_word_sp_offset*wordSize,
 // Make sure save locations are always 8 byte aligned.
-// can't use round_to because it doesn't produce compile time constant
+// can't use align_up because it doesn't produce compile time constant
 start_of_extra_save_area = ((call_args_area + 7) & ~7),
 g1_offset = start_of_extra_save_area, // g-regs needing saving
 g3_offset = g1_offset+8,
 g4_offset = g3_offset+8,
 g5_offset = g4_offset+8,
 // deoptimization; see compiledVFrame::create_stack_value).  The caller's I, L and O registers
 // are saved in register windows - I's and L's in the caller's frame and O's in the stub frame
 // (as the stub's I's) when the runtime routine called by the stub creates its frame.
 int i;
 // Always make the frame size 16 byte aligned.
-int frame_size = round_to(additional_frame_words + register_save_size, 16);
+int frame_size = align_up(additional_frame_words + register_save_size, 16);
 // OopMap frame size is in c2 stack slots (sizeof(jint)) not bytes or words
 int frame_size_in_slots = frame_size / sizeof(jint);
 // CodeBlob frame size is in words.
 *total_frame_words = frame_size / wordSize;
 // OopMap* map = new OopMap(*total_frame_words, 0);
 case T_ADDRESS: // Used, e.g., in slow-path locking for the lock's stack address
 if (int_reg < int_reg_max) {
 Register r = is_outgoing ? as_oRegister(int_reg++) : as_iRegister(int_reg++);
 regs[i].set2(r->as_VMReg());
 } else {
-slot = round_to(slot, 2);  // align
+slot = align_up(slot, 2);  // align
 regs[i].set2(VMRegImpl::stack2reg(slot));
 slot += 2;
 }
 break;
 }
 break;
 case T_DOUBLE:
 assert((i + 1) < total_args_passed && sig_bt[i+1] == T_VOID, "expecting half");
-if (round_to(flt_reg, 2) + 1 < flt_reg_max) {
+if (align_up(flt_reg, 2) + 1 < flt_reg_max) {
-flt_reg = round_to(flt_reg, 2);  // align
+flt_reg = align_up(flt_reg, 2);  // align
 FloatRegister r = as_FloatRegister(flt_reg);
 regs[i].set2(r->as_VMReg());
 flt_reg += 2;
 } else {
-slot = round_to(slot, 2);  // align
+slot = align_up(slot, 2);  // align
 regs[i].set2(VMRegImpl::stack2reg(slot));
 slot += 2;
 }
 break;
 // space we need.  Add in varargs area needed by the interpreter. Round up
 // to stack alignment.
 const int arg_size = total_args_passed * Interpreter::stackElementSize;
 const int varargs_area =
 (frame::varargs_offset - frame::register_save_words)*wordSize;
-const int extraspace = round_to(arg_size + varargs_area, 2*wordSize);
+const int extraspace = align_up(arg_size + varargs_area, 2*wordSize);
 const int bias = STACK_BIAS;
 const int interp_arg_offset = frame::varargs_offset*wordSize +
 (total_args_passed-1)*Interpreter::stackElementSize;
 // Cut-out for having no stack args.  Since up to 6 args are passed
 // in registers, we will commonly have no stack args.
 if (comp_args_on_stack > 0) {
 // Convert VMReg stack slots to words.
-int comp_words_on_stack = round_to(comp_args_on_stack*VMRegImpl::stack_slot_size, wordSize)>>LogBytesPerWord;
+int comp_words_on_stack = align_up(comp_args_on_stack*VMRegImpl::stack_slot_size, wordSize)>>LogBytesPerWord;
 // Round up to miminum stack alignment, in wordSize
-comp_words_on_stack = round_to(comp_words_on_stack, 2);
+comp_words_on_stack = align_up(comp_words_on_stack, 2);
 // Now compute the distance from Lesp to SP.  This calculation does not
 // include the space for total_args_passed because Lesp has not yet popped
 // the arguments.
 __ sub(SP, (comp_words_on_stack)*wordSize, SP);
 }
 if (param_array_reg.second()->is_stack()) {
 int off = param_array_reg.second()->reg2stack();
 if (off > max_stack_slots) max_stack_slots = off;
 }
 }
-return round_to(max_stack_slots + 1, 2);
+return align_up(max_stack_slots + 1, 2);
 }
 // ---------------------------------------------------------------------------
 // First count the abi requirement plus all of the outgoing args
 int stack_slots = SharedRuntime::out_preserve_stack_slots() + out_arg_slots;
 // Now the space for the inbound oop handle area
-int oop_handle_offset = round_to(stack_slots, 2);
+int oop_handle_offset = align_up(stack_slots, 2);
 stack_slots += total_save_slots;
 // Now any space we need for handlizing a klass if static method
 int klass_slot_offset = 0;
 //
 // Now compute actual number of stack words we need rounding to make
 // stack properly aligned.
-stack_slots = round_to(stack_slots, 2 * VMRegImpl::slots_per_word);
+stack_slots = align_up(stack_slots, 2 * VMRegImpl::slots_per_word);
 int stack_size = stack_slots * VMRegImpl::stack_slot_size;
 // Generate stack overflow check before creating frame
 __ generate_stack_overflow_check(stack_size);
 assert(callee_locals >= callee_parameters,
 "test and remove; got more parms than locals");
 if (callee_locals < callee_parameters)
 return 0;                   // No adjustment for negative locals
 int diff = (callee_locals - callee_parameters) * Interpreter::stackElementWords;
-return round_to(diff, WordsPerLong);
+return align_up(diff, WordsPerLong);
 }
 // "Top of Stack" slots that may be unused by the calling convention but must
 // otherwise be preserved.
 // On Intel these are not necessary and the value can be zero.

changeset 46620	750c6edff33b
parent 46462	f92a713126b1
child 46625	edefffab74e2