1326 // We must calc this exactly like in generate_fixed_frame. |
1326 // We must calc this exactly like in generate_fixed_frame. |
1327 // Note: This returns the conservative size assuming maximum alignment. |
1327 // Note: This returns the conservative size assuming maximum alignment. |
1328 int AbstractInterpreter::size_top_interpreter_activation(Method* method) { |
1328 int AbstractInterpreter::size_top_interpreter_activation(Method* method) { |
1329 const int max_alignment_size = 2; |
1329 const int max_alignment_size = 2; |
1330 const int abi_scratch = frame::abi_reg_args_size; |
1330 const int abi_scratch = frame::abi_reg_args_size; |
1331 return method->max_locals() + method->max_stack() + frame::interpreter_frame_monitor_size() + max_alignment_size + abi_scratch; |
1331 return method->max_locals() + method->max_stack() + |
1332 } |
1332 frame::interpreter_frame_monitor_size() + max_alignment_size + abi_scratch; |
1333 |
1333 } |
1334 // Fills a sceletal interpreter frame generated during deoptimizations |
1334 |
1335 // and returns the frame size in slots. |
1335 // Returns number of stackElementWords needed for the interpreter frame with the |
|
1336 // given sections. |
|
1337 // This overestimates the stack by one slot in case of alignments. |
|
1338 int AbstractInterpreter::size_activation(int max_stack, |
|
1339 int temps, |
|
1340 int extra_args, |
|
1341 int monitors, |
|
1342 int callee_params, |
|
1343 int callee_locals, |
|
1344 bool is_top_frame) { |
|
1345 // Note: This calculation must exactly parallel the frame setup |
|
1346 // in AbstractInterpreterGenerator::generate_method_entry. |
|
1347 assert(Interpreter::stackElementWords == 1, "sanity"); |
|
1348 const int max_alignment_space = StackAlignmentInBytes / Interpreter::stackElementSize; |
|
1349 const int abi_scratch = is_top_frame ? (frame::abi_reg_args_size / Interpreter::stackElementSize) : |
|
1350 (frame::abi_minframe_size / Interpreter::stackElementSize); |
|
1351 const int size = |
|
1352 max_stack + |
|
1353 (callee_locals - callee_params) + |
|
1354 monitors * frame::interpreter_frame_monitor_size() + |
|
1355 max_alignment_space + |
|
1356 abi_scratch + |
|
1357 frame::ijava_state_size / Interpreter::stackElementSize; |
|
1358 |
|
1359 // Fixed size of an interpreter frame, align to 16-byte. |
|
1360 return (size & -2); |
|
1361 } |
|
1362 |
|
1363 // Fills a sceletal interpreter frame generated during deoptimizations. |
1336 // |
1364 // |
1337 // Parameters: |
1365 // Parameters: |
1338 // |
|
1339 // interpreter_frame == NULL: |
|
1340 // Only calculate the size of an interpreter activation, no actual layout. |
|
1341 // Note: This calculation must exactly parallel the frame setup |
|
1342 // in TemplateInterpreter::generate_normal_entry. But it does not |
|
1343 // account for the SP alignment, that might further enhance the |
|
1344 // frame size, depending on FP. |
|
1345 // |
1366 // |
1346 // interpreter_frame != NULL: |
1367 // interpreter_frame != NULL: |
1347 // set up the method, locals, and monitors. |
1368 // set up the method, locals, and monitors. |
1348 // The frame interpreter_frame, if not NULL, is guaranteed to be the |
1369 // The frame interpreter_frame, if not NULL, is guaranteed to be the |
1349 // right size, as determined by a previous call to this method. |
1370 // right size, as determined by a previous call to this method. |
1357 // off the callee frame. We want to re-execute the call that called the |
1378 // off the callee frame. We want to re-execute the call that called the |
1358 // callee interpreted, but since the return to the interpreter would pop |
1379 // callee interpreted, but since the return to the interpreter would pop |
1359 // the arguments off advance the esp by dummy popframe_extra_args slots. |
1380 // the arguments off advance the esp by dummy popframe_extra_args slots. |
1360 // Popping off those will establish the stack layout as it was before the call. |
1381 // Popping off those will establish the stack layout as it was before the call. |
1361 // |
1382 // |
1362 int AbstractInterpreter::layout_activation(Method* method, |
1383 void AbstractInterpreter::layout_activation(Method* method, |
1363 int tempcount, |
1384 int tempcount, |
1364 int popframe_extra_args, |
1385 int popframe_extra_args, |
1365 int moncount, |
1386 int moncount, |
1366 int caller_actual_parameters, |
1387 int caller_actual_parameters, |
1367 int callee_param_count, |
1388 int callee_param_count, |
1368 int callee_locals, |
1389 int callee_locals_count, |
1369 frame* caller, |
1390 frame* caller, |
1370 frame* interpreter_frame, |
1391 frame* interpreter_frame, |
1371 bool is_top_frame, |
1392 bool is_top_frame, |
1372 bool is_bottom_frame) { |
1393 bool is_bottom_frame) { |
1373 |
1394 |
1374 const int max_alignment_space = 2; |
|
1375 const int abi_scratch = is_top_frame ? (frame::abi_reg_args_size / Interpreter::stackElementSize) : |
1395 const int abi_scratch = is_top_frame ? (frame::abi_reg_args_size / Interpreter::stackElementSize) : |
1376 (frame::abi_minframe_size / Interpreter::stackElementSize) ; |
1396 (frame::abi_minframe_size / Interpreter::stackElementSize); |
1377 const int conservative_framesize_in_slots = |
1397 |
1378 method->max_stack() + callee_locals - callee_param_count + |
1398 intptr_t* locals_base = (caller->is_interpreted_frame()) ? |
1379 (moncount * frame::interpreter_frame_monitor_size()) + max_alignment_space + |
1399 caller->interpreter_frame_esp() + caller_actual_parameters : |
1380 abi_scratch + frame::ijava_state_size / Interpreter::stackElementSize; |
1400 caller->sp() + method->max_locals() - 1 + (frame::abi_minframe_size / Interpreter::stackElementSize) ; |
1381 |
1401 |
1382 assert(!is_top_frame || conservative_framesize_in_slots * 8 > frame::abi_reg_args_size + frame::ijava_state_size, "frame too small"); |
1402 intptr_t* monitor_base = caller->sp() - frame::ijava_state_size / Interpreter::stackElementSize ; |
1383 |
1403 intptr_t* monitor = monitor_base - (moncount * frame::interpreter_frame_monitor_size()); |
1384 if (interpreter_frame == NULL) { |
1404 intptr_t* esp_base = monitor - 1; |
1385 // Since we don't know the exact alignment, we return the conservative size. |
1405 intptr_t* esp = esp_base - tempcount - popframe_extra_args; |
1386 return (conservative_framesize_in_slots & -2); |
1406 intptr_t* sp = (intptr_t *) (((intptr_t) (esp_base - callee_locals_count + callee_param_count - method->max_stack()- abi_scratch)) & -StackAlignmentInBytes); |
1387 } else { |
1407 intptr_t* sender_sp = caller->sp() + (frame::abi_minframe_size - frame::abi_reg_args_size) / Interpreter::stackElementSize; |
1388 // Now we know our caller, calc the exact frame layout and size. |
1408 intptr_t* top_frame_sp = is_top_frame ? sp : sp + (frame::abi_minframe_size - frame::abi_reg_args_size) / Interpreter::stackElementSize; |
1389 intptr_t* locals_base = (caller->is_interpreted_frame()) ? |
1409 |
1390 caller->interpreter_frame_esp() + caller_actual_parameters : |
1410 interpreter_frame->interpreter_frame_set_method(method); |
1391 caller->sp() + method->max_locals() - 1 + (frame::abi_minframe_size / Interpreter::stackElementSize) ; |
1411 interpreter_frame->interpreter_frame_set_locals(locals_base); |
1392 |
1412 interpreter_frame->interpreter_frame_set_cpcache(method->constants()->cache()); |
1393 intptr_t* monitor_base = caller->sp() - frame::ijava_state_size / Interpreter::stackElementSize ; |
1413 interpreter_frame->interpreter_frame_set_esp(esp); |
1394 intptr_t* monitor = monitor_base - (moncount * frame::interpreter_frame_monitor_size()); |
1414 interpreter_frame->interpreter_frame_set_monitor_end((BasicObjectLock *)monitor); |
1395 intptr_t* esp_base = monitor - 1; |
1415 interpreter_frame->interpreter_frame_set_top_frame_sp(top_frame_sp); |
1396 intptr_t* esp = esp_base - tempcount - popframe_extra_args; |
1416 if (!is_bottom_frame) { |
1397 intptr_t* sp = (intptr_t *) (((intptr_t) (esp_base- callee_locals + callee_param_count - method->max_stack()- abi_scratch)) & -StackAlignmentInBytes); |
1417 interpreter_frame->interpreter_frame_set_sender_sp(sender_sp); |
1398 intptr_t* sender_sp = caller->sp() + (frame::abi_minframe_size - frame::abi_reg_args_size) / Interpreter::stackElementSize; |
|
1399 intptr_t* top_frame_sp = is_top_frame ? sp : sp + (frame::abi_minframe_size - frame::abi_reg_args_size) / Interpreter::stackElementSize; |
|
1400 |
|
1401 interpreter_frame->interpreter_frame_set_method(method); |
|
1402 interpreter_frame->interpreter_frame_set_locals(locals_base); |
|
1403 interpreter_frame->interpreter_frame_set_cpcache(method->constants()->cache()); |
|
1404 interpreter_frame->interpreter_frame_set_esp(esp); |
|
1405 interpreter_frame->interpreter_frame_set_monitor_end((BasicObjectLock *)monitor); |
|
1406 interpreter_frame->interpreter_frame_set_top_frame_sp(top_frame_sp); |
|
1407 if (!is_bottom_frame) { |
|
1408 interpreter_frame->interpreter_frame_set_sender_sp(sender_sp); |
|
1409 } |
|
1410 |
|
1411 int framesize_in_slots = caller->sp() - sp; |
|
1412 assert(!is_top_frame ||framesize_in_slots >= (frame::abi_reg_args_size / Interpreter::stackElementSize) + frame::ijava_state_size / Interpreter::stackElementSize, "frame too small"); |
|
1413 assert(framesize_in_slots <= conservative_framesize_in_slots, "exact frame size must be smaller than the convervative size!"); |
|
1414 return framesize_in_slots; |
|
1415 } |
1418 } |
1416 } |
1419 } |
1417 |
1420 |
1418 // ============================================================================= |
1421 // ============================================================================= |
1419 // Exceptions |
1422 // Exceptions |