Mercurial > hg > truffle

comparison src/cpu/ppc/vm/templateInterpreter_ppc.cpp @ 17980:0bf37f737702

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
8032410: compiler/uncommontrap/TestStackBangRbp.java times out on Solaris-Sparc V9 Summary: make compiled code bang the stack by the worst case size of the interpreter frame at deoptimization points. Reviewed-by: twisti, kvn
author roland
date Tue, 01 Apr 2014 09:36:49 +0200
parents 63c5920a038d
children 5214669b01f2 b384ba33c9a0
comparison
equal deleted inserted replaced
17978:ad51f24671c2 17980:0bf37f737702
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