1965   __ push(lr);
1966   __ push(state);
1967   __ push(RegSet::range(r0, r15), sp);
1968   __ mov(c_rarg2, r0);  // Pass itos
1969   __ call_VM(noreg,
1970              CAST_FROM_FN_PTR(address, SharedRuntime::trace_bytecode),
1971              c_rarg1, c_rarg2, c_rarg3);
1972   __ pop(RegSet::range(r0, r15), sp);
1973   __ pop(state);
1974   __ pop(lr);
1975   __ ret(lr);                                   // return from result handler
1976 
1977   return entry;
1978 }
1979 
1980 void TemplateInterpreterGenerator::count_bytecode() {
1981   Register rscratch3 = r0;
1982   __ push(rscratch1);
1983   __ push(rscratch2);
1984   __ push(rscratch3);
1985   Label L;
1986   __ mov(rscratch2, (address) &BytecodeCounter::_counter_value);
1987   __ prfm(Address(rscratch2), PSTL1STRM);
1988   __ bind(L);
1989   __ ldxr(rscratch1, rscratch2);
1990   __ add(rscratch1, rscratch1, 1);
1991   __ stxr(rscratch3, rscratch1, rscratch2);
1992   __ cbnzw(rscratch3, L);
1993   __ pop(rscratch3);
1994   __ pop(rscratch2);
1995   __ pop(rscratch1);
1996 }
1997 
1998 void TemplateInterpreterGenerator::histogram_bytecode(Template* t) { ; }
1999 
2000 void TemplateInterpreterGenerator::histogram_bytecode_pair(Template* t) { ; }
2001 
2002 
2003 void TemplateInterpreterGenerator::trace_bytecode(Template* t) {
2004   // Call a little run-time stub to avoid blow-up for each bytecode.
2005   // The run-time runtime saves the right registers, depending on
2006   // the tosca in-state for the given template.
2007 
2008   assert(Interpreter::trace_code(t->tos_in()) != NULL,
2009          "entry must have been generated");
2010   __ bl(Interpreter::trace_code(t->tos_in()));
2011   __ reinit_heapbase();
2012 }

1965   __ push(lr);
1966   __ push(state);
1967   __ push(RegSet::range(r0, r15), sp);
1968   __ mov(c_rarg2, r0);  // Pass itos
1969   __ call_VM(noreg,
1970              CAST_FROM_FN_PTR(address, SharedRuntime::trace_bytecode),
1971              c_rarg1, c_rarg2, c_rarg3);
1972   __ pop(RegSet::range(r0, r15), sp);
1973   __ pop(state);
1974   __ pop(lr);
1975   __ ret(lr);                                   // return from result handler
1976 
1977   return entry;
1978 }
1979 
1980 void TemplateInterpreterGenerator::count_bytecode() {
1981   Register rscratch3 = r0;
1982   __ push(rscratch1);
1983   __ push(rscratch2);
1984   __ push(rscratch3);
1985   __ mov(rscratch3, (address) &BytecodeCounter::_counter_value);
1986   __ atomic_add(noreg, 1, rscratch3);






1987   __ pop(rscratch3);
1988   __ pop(rscratch2);
1989   __ pop(rscratch1);
1990 }
1991 
1992 void TemplateInterpreterGenerator::histogram_bytecode(Template* t) { ; }
1993 
1994 void TemplateInterpreterGenerator::histogram_bytecode_pair(Template* t) { ; }
1995 
1996 
1997 void TemplateInterpreterGenerator::trace_bytecode(Template* t) {
1998   // Call a little run-time stub to avoid blow-up for each bytecode.
1999   // The run-time runtime saves the right registers, depending on
2000   // the tosca in-state for the given template.
2001 
2002   assert(Interpreter::trace_code(t->tos_in()) != NULL,
2003          "entry must have been generated");
2004   __ bl(Interpreter::trace_code(t->tos_in()));
2005   __ reinit_heapbase();
2006 }