156   } else if (reg != noreg) {
157     __ add(r0, from(), Interpreter::local_offset_in_bytes(offset()));
158     __ mov(reg, 0);
159     __ ldr(temp(), r0);
160     Label L;
161     __ cbz(temp(), L);
162     __ mov(reg, r0);
163     __ bind(L);
164   } else {
165     __ add(r0, from(), Interpreter::local_offset_in_bytes(offset()));
166     __ ldr(temp(), r0);
167     Label L;
168     __ cbnz(temp(), L);
169     __ mov(r0, zr);
170     __ bind(L);
171     static_assert(sizeof(jobject) == wordSize, "");
172     __ str(r0, Address(to(), next_stack_offset(sizeof(jobject))));
173   }
174 }
175 




176 void InterpreterRuntime::SignatureHandlerGenerator::generate(uint64_t fingerprint) {
177   // generate code to handle arguments
178   iterate(fingerprint);
179 
180   // return result handler
181   __ lea(r0, ExternalAddress(Interpreter::result_handler(method()->result_type())));
182   __ ret(lr);
183 
184   __ flush();
185 }
186 
187 
188 // Implementation of SignatureHandlerLibrary
189 
190 void SignatureHandlerLibrary::pd_set_handler(address handler) {}
191 
192 
193 class SlowSignatureHandler
194   : public NativeSignatureIterator {
195  private:

240     jbyte value = *(jbyte*)single_slot_addr();
241     if (pass_gpr(value) < 0) {
242       pass_stack<>(value);
243     }
244   }
245 
246   virtual void pass_short() {
247     jshort value = *(jshort*)single_slot_addr();
248     if (pass_gpr(value) < 0) {
249       pass_stack<>(value);
250     }
251   }
252 
253   virtual void pass_int() {
254     jint value = *(jint*)single_slot_addr();
255     if (pass_gpr(value) < 0) {
256       pass_stack<>(value);
257     }
258   }
259 





260   virtual void pass_long() {
261     intptr_t value = *double_slot_addr();
262     if (pass_gpr(value) < 0) {
263       pass_stack<>(value);
264     }
265   }
266 
267   virtual void pass_object() {
268     intptr_t* addr = single_slot_addr();
269     intptr_t value = *addr == 0 ? (intptr_t)0 : (intptr_t)addr;
270     if (pass_gpr(value) < 0) {
271       pass_stack<>(value);
272     }
273   }
274 
275   virtual void pass_float() {
276     jint value = *(jint*)single_slot_addr();
277     if (pass_fpr(value) < 0) {
278       pass_stack<>(value);
279     }

156   } else if (reg != noreg) {
157     __ add(r0, from(), Interpreter::local_offset_in_bytes(offset()));
158     __ mov(reg, 0);
159     __ ldr(temp(), r0);
160     Label L;
161     __ cbz(temp(), L);
162     __ mov(reg, r0);
163     __ bind(L);
164   } else {
165     __ add(r0, from(), Interpreter::local_offset_in_bytes(offset()));
166     __ ldr(temp(), r0);
167     Label L;
168     __ cbnz(temp(), L);
169     __ mov(r0, zr);
170     __ bind(L);
171     static_assert(sizeof(jobject) == wordSize, "");
172     __ str(r0, Address(to(), next_stack_offset(sizeof(jobject))));
173   }
174 }
175 
176 void InterpreterRuntime::SignatureHandlerGenerator::pass_valuetype() {
177    pass_object();
178 }
179 
180 void InterpreterRuntime::SignatureHandlerGenerator::generate(uint64_t fingerprint) {
181   // generate code to handle arguments
182   iterate(fingerprint);
183 
184   // return result handler
185   __ lea(r0, ExternalAddress(Interpreter::result_handler(method()->result_type())));
186   __ ret(lr);
187 
188   __ flush();
189 }
190 
191 
192 // Implementation of SignatureHandlerLibrary
193 
194 void SignatureHandlerLibrary::pd_set_handler(address handler) {}
195 
196 
197 class SlowSignatureHandler
198   : public NativeSignatureIterator {
199  private:

244     jbyte value = *(jbyte*)single_slot_addr();
245     if (pass_gpr(value) < 0) {
246       pass_stack<>(value);
247     }
248   }
249 
250   virtual void pass_short() {
251     jshort value = *(jshort*)single_slot_addr();
252     if (pass_gpr(value) < 0) {
253       pass_stack<>(value);
254     }
255   }
256 
257   virtual void pass_int() {
258     jint value = *(jint*)single_slot_addr();
259     if (pass_gpr(value) < 0) {
260       pass_stack<>(value);
261     }
262   }
263 
264   virtual void pass_valuetype() {
265     // values are handled with oops, like objects
266     pass_object();
267   }
268 
269   virtual void pass_long() {
270     intptr_t value = *double_slot_addr();
271     if (pass_gpr(value) < 0) {
272       pass_stack<>(value);
273     }
274   }
275 
276   virtual void pass_object() {
277     intptr_t* addr = single_slot_addr();
278     intptr_t value = *addr == 0 ? (intptr_t)0 : (intptr_t)addr;
279     if (pass_gpr(value) < 0) {
280       pass_stack<>(value);
281     }
282   }
283 
284   virtual void pass_float() {
285     jint value = *(jint*)single_slot_addr();
286     if (pass_fpr(value) < 0) {
287       pass_stack<>(value);
288     }