quick_trampoline_entrypoints.cc revision 8d5ead52a92675c258113d3dfa71bf8fceba5d9f 
1/*
2 * Copyright (C) 2012 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *      http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17#include "callee_save_frame.h"
18#include "common_throws.h"
19#include "dex_file-inl.h"
20#include "dex_instruction-inl.h"
21#include "entrypoints/entrypoint_utils.h"
22#include "gc/accounting/card_table-inl.h"
23#include "interpreter/interpreter.h"
24#include "mirror/art_method-inl.h"
25#include "mirror/class-inl.h"
26#include "mirror/dex_cache-inl.h"
27#include "mirror/object-inl.h"
28#include "mirror/object_array-inl.h"
29#include "object_utils.h"
30#include "runtime.h"
31#include "scoped_thread_state_change.h"
32
33namespace art {
34
35// Visits the arguments as saved to the stack by a Runtime::kRefAndArgs callee save frame.
36class QuickArgumentVisitor {
37  // Size of each spilled GPR.
38#ifdef __LP64__
39  static constexpr size_t kBytesPerGprSpillLocation = 8;
40#else
41  static constexpr size_t kBytesPerGprSpillLocation = 4;
42#endif
43  // Number of bytes for each out register in the caller method's frame.
44  static constexpr size_t kBytesStackArgLocation = 4;
45#if defined(__arm__)
46  // The callee save frame is pointed to by SP.
47  // | argN       |  |
48  // | ...        |  |
49  // | arg4       |  |
50  // | arg3 spill |  |  Caller's frame
51  // | arg2 spill |  |
52  // | arg1 spill |  |
53  // | Method*    | ---
54  // | LR         |
55  // | ...        |    callee saves
56  // | R3         |    arg3
57  // | R2         |    arg2
58  // | R1         |    arg1
59  // | R0         |    padding
60  // | Method*    |  <- sp
61  static constexpr bool kQuickSoftFloatAbi = true;  // This is a soft float ABI.
62  static constexpr size_t kNumQuickGprArgs = 3;  // 3 arguments passed in GPRs.
63  static constexpr size_t kNumQuickFprArgs = 0;  // 0 arguments passed in FPRs.
64  static constexpr size_t kBytesPerFprSpillLocation = 4;  // FPR spill size is 4 bytes.
65  static constexpr size_t kQuickCalleeSaveFrame_RefAndArgs_Fpr1Offset = 0;  // Offset of first FPR arg.
66  static constexpr size_t kQuickCalleeSaveFrame_RefAndArgs_Gpr1Offset = 8;  // Offset of first GPR arg.
67  static constexpr size_t kQuickCalleeSaveFrame_RefAndArgs_LrOffset = 44;  // Offset of return address.
68  static constexpr size_t kQuickCalleeSaveFrame_RefAndArgs_FrameSize = 48;  // Frame size.
69  static size_t GprIndexToGprOffset(uint32_t gpr_index) {
70    return gpr_index * kBytesPerGprSpillLocation;
71  }
72#elif defined(__aarch64__)
73  // The callee save frame is pointed to by SP.
74  // | argN       |  |
75  // | ...        |  |
76  // | arg4       |  |
77  // | arg3 spill |  |  Caller's frame
78  // | arg2 spill |  |
79  // | arg1 spill |  |
80  // | Method*    | ---
81  // | LR         |
82  // | X28        |
83  // |  :         |
84  // | X19        |
85  // | X7         |
86  // | :          |
87  // | X1         |
88  // | D15        |
89  // |  :         |
90  // | D0         |
91  // |            |    padding
92  // | Method*    |  <- sp
93  static constexpr bool kQuickSoftFloatAbi = false;  // This is a hard float ABI.
94  static constexpr size_t kNumQuickGprArgs = 7;  // 7 arguments passed in GPRs.
95  static constexpr size_t kNumQuickFprArgs = 8;  // 8 arguments passed in FPRs.
96  static constexpr size_t kBytesPerFprSpillLocation = 8;  // FPR spill size is 8 bytes.
97  static constexpr size_t kQuickCalleeSaveFrame_RefAndArgs_Fpr1Offset =16;  // Offset of first FPR arg.
98  static constexpr size_t kQuickCalleeSaveFrame_RefAndArgs_Gpr1Offset = 144;  // Offset of first GPR arg.
99  static constexpr size_t kQuickCalleeSaveFrame_RefAndArgs_LrOffset = 296;  // Offset of return address.
100  static constexpr size_t kQuickCalleeSaveFrame_RefAndArgs_FrameSize = 304;  // Frame size.
101  static size_t GprIndexToGprOffset(uint32_t gpr_index) {
102    return gpr_index * kBytesPerGprSpillLocation;
103  }
104#elif defined(__mips__)
105  // The callee save frame is pointed to by SP.
106  // | argN       |  |
107  // | ...        |  |
108  // | arg4       |  |
109  // | arg3 spill |  |  Caller's frame
110  // | arg2 spill |  |
111  // | arg1 spill |  |
112  // | Method*    | ---
113  // | RA         |
114  // | ...        |    callee saves
115  // | A3         |    arg3
116  // | A2         |    arg2
117  // | A1         |    arg1
118  // | A0/Method* |  <- sp
119  static constexpr bool kQuickSoftFloatAbi = true;  // This is a soft float ABI.
120  static constexpr size_t kNumQuickGprArgs = 3;  // 3 arguments passed in GPRs.
121  static constexpr size_t kNumQuickFprArgs = 0;  // 0 arguments passed in FPRs.
122  static constexpr size_t kBytesPerFprSpillLocation = 4;  // FPR spill size is 4 bytes.
123  static constexpr size_t kQuickCalleeSaveFrame_RefAndArgs_Fpr1Offset = 0;  // Offset of first FPR arg.
124  static constexpr size_t kQuickCalleeSaveFrame_RefAndArgs_Gpr1Offset = 4;  // Offset of first GPR arg.
125  static constexpr size_t kQuickCalleeSaveFrame_RefAndArgs_LrOffset = 60;  // Offset of return address.
126  static constexpr size_t kQuickCalleeSaveFrame_RefAndArgs_FrameSize = 64;  // Frame size.
127  static size_t GprIndexToGprOffset(uint32_t gpr_index) {
128    return gpr_index * kBytesPerGprSpillLocation;
129  }
130#elif defined(__i386__)
131  // The callee save frame is pointed to by SP.
132  // | argN        |  |
133  // | ...         |  |
134  // | arg4        |  |
135  // | arg3 spill  |  |  Caller's frame
136  // | arg2 spill  |  |
137  // | arg1 spill  |  |
138  // | Method*     | ---
139  // | Return      |
140  // | EBP,ESI,EDI |    callee saves
141  // | EBX         |    arg3
142  // | EDX         |    arg2
143  // | ECX         |    arg1
144  // | EAX/Method* |  <- sp
145  static constexpr bool kQuickSoftFloatAbi = true;  // This is a soft float ABI.
146  static constexpr size_t kNumQuickGprArgs = 3;  // 3 arguments passed in GPRs.
147  static constexpr size_t kNumQuickFprArgs = 0;  // 0 arguments passed in FPRs.
148  static constexpr size_t kBytesPerFprSpillLocation = 8;  // FPR spill size is 8 bytes.
149  static constexpr size_t kQuickCalleeSaveFrame_RefAndArgs_Fpr1Offset = 0;  // Offset of first FPR arg.
150  static constexpr size_t kQuickCalleeSaveFrame_RefAndArgs_Gpr1Offset = 4;  // Offset of first GPR arg.
151  static constexpr size_t kQuickCalleeSaveFrame_RefAndArgs_LrOffset = 28;  // Offset of return address.
152  static constexpr size_t kQuickCalleeSaveFrame_RefAndArgs_FrameSize = 32;  // Frame size.
153  static size_t GprIndexToGprOffset(uint32_t gpr_index) {
154    return gpr_index * kBytesPerGprSpillLocation;
155  }
156#elif defined(__x86_64__)
157  // The callee save frame is pointed to by SP.
158  // | argN            |  |
159  // | ...             |  |
160  // | reg. arg spills |  |  Caller's frame
161  // | Method*         | ---
162  // | Return          |
163  // | R15             |    callee save
164  // | R14             |    callee save
165  // | R13             |    callee save
166  // | R12             |    callee save
167  // | R9              |    arg5
168  // | R8              |    arg4
169  // | RSI/R6          |    arg1
170  // | RBP/R5          |    callee save
171  // | RBX/R3          |    callee save
172  // | RDX/R2          |    arg2
173  // | RCX/R1          |    arg3
174  // | XMM7            |    float arg 8
175  // | XMM6            |    float arg 7
176  // | XMM5            |    float arg 6
177  // | XMM4            |    float arg 5
178  // | XMM3            |    float arg 4
179  // | XMM2            |    float arg 3
180  // | XMM1            |    float arg 2
181  // | XMM0            |    float arg 1
182  // | Padding         |
183  // | RDI/Method*     |  <- sp
184  static constexpr bool kQuickSoftFloatAbi = false;  // This is a hard float ABI.
185  static constexpr size_t kNumQuickGprArgs = 5;  // 3 arguments passed in GPRs.
186  static constexpr size_t kNumQuickFprArgs = 8;  // 0 arguments passed in FPRs.
187  static constexpr size_t kBytesPerFprSpillLocation = 8;  // FPR spill size is 8 bytes.
188  static constexpr size_t kQuickCalleeSaveFrame_RefAndArgs_Fpr1Offset = 16;  // Offset of first FPR arg.
189  static constexpr size_t kQuickCalleeSaveFrame_RefAndArgs_Gpr1Offset = 80;  // Offset of first GPR arg.
190  static constexpr size_t kQuickCalleeSaveFrame_RefAndArgs_LrOffset = 168;  // Offset of return address.
191  static constexpr size_t kQuickCalleeSaveFrame_RefAndArgs_FrameSize = 176;  // Frame size.
192  static size_t GprIndexToGprOffset(uint32_t gpr_index) {
193    switch (gpr_index) {
194      case 0: return (4 * kBytesPerGprSpillLocation);
195      case 1: return (1 * kBytesPerGprSpillLocation);
196      case 2: return (0 * kBytesPerGprSpillLocation);
197      case 3: return (5 * kBytesPerGprSpillLocation);
198      case 4: return (6 * kBytesPerGprSpillLocation);
199      default:
200        LOG(FATAL) << "Unexpected GPR index: " << gpr_index;
201        return 0;
202    }
203  }
204#else
205#error "Unsupported architecture"
206#endif
207
208 public:
209  static mirror::ArtMethod* GetCallingMethod(mirror::ArtMethod** sp)
210      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
211    DCHECK((*sp)->IsCalleeSaveMethod());
212    byte* previous_sp = reinterpret_cast<byte*>(sp) + kQuickCalleeSaveFrame_RefAndArgs_FrameSize;
213    return *reinterpret_cast<mirror::ArtMethod**>(previous_sp);
214  }
215
216  // For the given quick ref and args quick frame, return the caller's PC.
217  static uintptr_t GetCallingPc(mirror::ArtMethod** sp)
218      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
219    DCHECK((*sp)->IsCalleeSaveMethod());
220    byte* lr = reinterpret_cast<byte*>(sp) + kQuickCalleeSaveFrame_RefAndArgs_LrOffset;
221    return *reinterpret_cast<uintptr_t*>(lr);
222  }
223
224  QuickArgumentVisitor(mirror::ArtMethod** sp, bool is_static,
225                       const char* shorty, uint32_t shorty_len)
226      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) :
227      is_static_(is_static), shorty_(shorty), shorty_len_(shorty_len),
228      gpr_args_(reinterpret_cast<byte*>(sp) + kQuickCalleeSaveFrame_RefAndArgs_Gpr1Offset),
229      fpr_args_(reinterpret_cast<byte*>(sp) + kQuickCalleeSaveFrame_RefAndArgs_Fpr1Offset),
230      stack_args_(reinterpret_cast<byte*>(sp) + kQuickCalleeSaveFrame_RefAndArgs_FrameSize
231                  + StackArgumentStartFromShorty(is_static, shorty, shorty_len)),
232      gpr_index_(0), fpr_index_(0), stack_index_(0), cur_type_(Primitive::kPrimVoid),
233      is_split_long_or_double_(false) {
234    DCHECK_EQ(kQuickCalleeSaveFrame_RefAndArgs_FrameSize,
235              Runtime::Current()->GetCalleeSaveMethod(Runtime::kRefsAndArgs)->GetFrameSizeInBytes());
236  }
237
238  virtual ~QuickArgumentVisitor() {}
239
240  virtual void Visit() = 0;
241
242  Primitive::Type GetParamPrimitiveType() const {
243    return cur_type_;
244  }
245
246  byte* GetParamAddress() const {
247    if (!kQuickSoftFloatAbi) {
248      Primitive::Type type = GetParamPrimitiveType();
249      if (UNLIKELY((type == Primitive::kPrimDouble) || (type == Primitive::kPrimFloat))) {
250        if ((kNumQuickFprArgs != 0) && (fpr_index_ + 1 < kNumQuickFprArgs + 1)) {
251          return fpr_args_ + (fpr_index_ * kBytesPerFprSpillLocation);
252        }
253        return stack_args_ + (stack_index_ * kBytesStackArgLocation);
254      }
255    }
256    if (gpr_index_ < kNumQuickGprArgs) {
257      return gpr_args_ + GprIndexToGprOffset(gpr_index_);
258    }
259    return stack_args_ + (stack_index_ * kBytesStackArgLocation);
260  }
261
262  bool IsSplitLongOrDouble() const {
263    if ((kBytesPerGprSpillLocation == 4) || (kBytesPerFprSpillLocation == 4)) {
264      return is_split_long_or_double_;
265    } else {
266      return false;  // An optimization for when GPR and FPRs are 64bit.
267    }
268  }
269
270  bool IsParamAReference() const {
271    return GetParamPrimitiveType() == Primitive::kPrimNot;
272  }
273
274  bool IsParamALongOrDouble() const {
275    Primitive::Type type = GetParamPrimitiveType();
276    return type == Primitive::kPrimLong || type == Primitive::kPrimDouble;
277  }
278
279  uint64_t ReadSplitLongParam() const {
280    DCHECK(IsSplitLongOrDouble());
281    uint64_t low_half = *reinterpret_cast<uint32_t*>(GetParamAddress());
282    uint64_t high_half = *reinterpret_cast<uint32_t*>(stack_args_);
283    return (low_half & 0xffffffffULL) | (high_half << 32);
284  }
285
286  void VisitArguments() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
287    // This implementation doesn't support reg-spill area for hard float
288    // ABI targets such as x86_64 and aarch64. So, for those targets whose
289    // 'kQuickSoftFloatAbi' is 'false':
290    //     (a) 'stack_args_' should point to the first method's argument
291    //     (b) whatever the argument type it is, the 'stack_index_' should
292    //         be moved forward along with every visiting.
293    gpr_index_ = 0;
294    fpr_index_ = 0;
295    stack_index_ = 0;
296    if (!is_static_) {  // Handle this.
297      cur_type_ = Primitive::kPrimNot;
298      is_split_long_or_double_ = false;
299      Visit();
300      if (!kQuickSoftFloatAbi || kNumQuickGprArgs == 0) {
301        stack_index_++;
302      }
303      if (kNumQuickGprArgs > 0) {
304        gpr_index_++;
305      }
306    }
307    for (uint32_t shorty_index = 1; shorty_index < shorty_len_; ++shorty_index) {
308      cur_type_ = Primitive::GetType(shorty_[shorty_index]);
309      switch (cur_type_) {
310        case Primitive::kPrimNot:
311        case Primitive::kPrimBoolean:
312        case Primitive::kPrimByte:
313        case Primitive::kPrimChar:
314        case Primitive::kPrimShort:
315        case Primitive::kPrimInt:
316          is_split_long_or_double_ = false;
317          Visit();
318          if (!kQuickSoftFloatAbi || kNumQuickGprArgs == gpr_index_) {
319            stack_index_++;
320          }
321          if (gpr_index_ < kNumQuickGprArgs) {
322            gpr_index_++;
323          }
324          break;
325        case Primitive::kPrimFloat:
326          is_split_long_or_double_ = false;
327          Visit();
328          if (kQuickSoftFloatAbi) {
329            if (gpr_index_ < kNumQuickGprArgs) {
330              gpr_index_++;
331            } else {
332              stack_index_++;
333            }
334          } else {
335            if ((kNumQuickFprArgs != 0) && (fpr_index_ + 1 < kNumQuickFprArgs + 1)) {
336              fpr_index_++;
337            }
338            stack_index_++;
339          }
340          break;
341        case Primitive::kPrimDouble:
342        case Primitive::kPrimLong:
343          if (kQuickSoftFloatAbi || (cur_type_ == Primitive::kPrimLong)) {
344            is_split_long_or_double_ = (kBytesPerGprSpillLocation == 4) &&
345                ((gpr_index_ + 1) == kNumQuickGprArgs);
346            Visit();
347            if (!kQuickSoftFloatAbi || kNumQuickGprArgs == gpr_index_) {
348              if (kBytesStackArgLocation == 4) {
349                stack_index_+= 2;
350              } else {
351                CHECK_EQ(kBytesStackArgLocation, 8U);
352                stack_index_++;
353              }
354            }
355            if (gpr_index_ < kNumQuickGprArgs) {
356              gpr_index_++;
357              if (kBytesPerGprSpillLocation == 4) {
358                if (gpr_index_ < kNumQuickGprArgs) {
359                  gpr_index_++;
360                } else if (kQuickSoftFloatAbi) {
361                  stack_index_++;
362                }
363              }
364            }
365          } else {
366            is_split_long_or_double_ = (kBytesPerFprSpillLocation == 4) &&
367                ((fpr_index_ + 1) == kNumQuickFprArgs);
368            Visit();
369            if ((kNumQuickFprArgs != 0) && (fpr_index_ + 1 < kNumQuickFprArgs + 1)) {
370              fpr_index_++;
371              if (kBytesPerFprSpillLocation == 4) {
372                if ((kNumQuickFprArgs != 0) && (fpr_index_ + 1 < kNumQuickFprArgs + 1)) {
373                  fpr_index_++;
374                }
375              }
376            }
377            if (kBytesStackArgLocation == 4) {
378              stack_index_+= 2;
379            } else {
380              CHECK_EQ(kBytesStackArgLocation, 8U);
381              stack_index_++;
382            }
383          }
384          break;
385        default:
386          LOG(FATAL) << "Unexpected type: " << cur_type_ << " in " << shorty_;
387      }
388    }
389  }
390
391 private:
392  static size_t StackArgumentStartFromShorty(bool is_static, const char* shorty,
393                                             uint32_t shorty_len) {
394    if (kQuickSoftFloatAbi) {
395      CHECK_EQ(kNumQuickFprArgs, 0U);
396      return (kNumQuickGprArgs * kBytesPerGprSpillLocation) + kBytesPerGprSpillLocation /* ArtMethod* */;
397    } else {
398      // For now, there is no reg-spill area for the targets with
399      // hard float ABI. So, the offset pointing to the first method's
400      // parameter ('this' for non-static methods) should be returned.
401      return kBytesPerGprSpillLocation;  // Skip Method*.
402    }
403  }
404
405  const bool is_static_;
406  const char* const shorty_;
407  const uint32_t shorty_len_;
408  byte* const gpr_args_;  // Address of GPR arguments in callee save frame.
409  byte* const fpr_args_;  // Address of FPR arguments in callee save frame.
410  byte* const stack_args_;  // Address of stack arguments in caller's frame.
411  uint32_t gpr_index_;  // Index into spilled GPRs.
412  uint32_t fpr_index_;  // Index into spilled FPRs.
413  uint32_t stack_index_;  // Index into arguments on the stack.
414  // The current type of argument during VisitArguments.
415  Primitive::Type cur_type_;
416  // Does a 64bit parameter straddle the register and stack arguments?
417  bool is_split_long_or_double_;
418};
419
420// Visits arguments on the stack placing them into the shadow frame.
421class BuildQuickShadowFrameVisitor FINAL : public QuickArgumentVisitor {
422 public:
423  BuildQuickShadowFrameVisitor(mirror::ArtMethod** sp, bool is_static, const char* shorty,
424                               uint32_t shorty_len, ShadowFrame* sf, size_t first_arg_reg) :
425    QuickArgumentVisitor(sp, is_static, shorty, shorty_len), sf_(sf), cur_reg_(first_arg_reg) {}
426
427  void Visit() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) OVERRIDE;
428
429 private:
430  ShadowFrame* const sf_;
431  uint32_t cur_reg_;
432
433  DISALLOW_COPY_AND_ASSIGN(BuildQuickShadowFrameVisitor);
434};
435
436void BuildQuickShadowFrameVisitor::Visit()  {
437  Primitive::Type type = GetParamPrimitiveType();
438  switch (type) {
439    case Primitive::kPrimLong:  // Fall-through.
440    case Primitive::kPrimDouble:
441      if (IsSplitLongOrDouble()) {
442        sf_->SetVRegLong(cur_reg_, ReadSplitLongParam());
443      } else {
444        sf_->SetVRegLong(cur_reg_, *reinterpret_cast<jlong*>(GetParamAddress()));
445      }
446      ++cur_reg_;
447      break;
448    case Primitive::kPrimNot: {
449        StackReference<mirror::Object>* stack_ref =
450            reinterpret_cast<StackReference<mirror::Object>*>(GetParamAddress());
451        sf_->SetVRegReference(cur_reg_, stack_ref->AsMirrorPtr());
452      }
453      break;
454    case Primitive::kPrimBoolean:  // Fall-through.
455    case Primitive::kPrimByte:     // Fall-through.
456    case Primitive::kPrimChar:     // Fall-through.
457    case Primitive::kPrimShort:    // Fall-through.
458    case Primitive::kPrimInt:      // Fall-through.
459    case Primitive::kPrimFloat:
460      sf_->SetVReg(cur_reg_, *reinterpret_cast<jint*>(GetParamAddress()));
461      break;
462    case Primitive::kPrimVoid:
463      LOG(FATAL) << "UNREACHABLE";
464      break;
465  }
466  ++cur_reg_;
467}
468
469extern "C" uint64_t artQuickToInterpreterBridge(mirror::ArtMethod* method, Thread* self,
470                                                mirror::ArtMethod** sp)
471    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
472  // Ensure we don't get thread suspension until the object arguments are safely in the shadow
473  // frame.
474  FinishCalleeSaveFrameSetup(self, sp, Runtime::kRefsAndArgs);
475
476  if (method->IsAbstract()) {
477    ThrowAbstractMethodError(method);
478    return 0;
479  } else {
480    DCHECK(!method->IsNative()) << PrettyMethod(method);
481    const char* old_cause = self->StartAssertNoThreadSuspension("Building interpreter shadow frame");
482    MethodHelper mh(method);
483    const DexFile::CodeItem* code_item = mh.GetCodeItem();
484    DCHECK(code_item != nullptr) << PrettyMethod(method);
485    uint16_t num_regs = code_item->registers_size_;
486    void* memory = alloca(ShadowFrame::ComputeSize(num_regs));
487    ShadowFrame* shadow_frame(ShadowFrame::Create(num_regs, NULL,  // No last shadow coming from quick.
488                                                  method, 0, memory));
489    size_t first_arg_reg = code_item->registers_size_ - code_item->ins_size_;
490    BuildQuickShadowFrameVisitor shadow_frame_builder(sp, mh.IsStatic(), mh.GetShorty(),
491                                                      mh.GetShortyLength(),
492                                                      shadow_frame, first_arg_reg);
493    shadow_frame_builder.VisitArguments();
494    // Push a transition back into managed code onto the linked list in thread.
495    ManagedStack fragment;
496    self->PushManagedStackFragment(&fragment);
497    self->PushShadowFrame(shadow_frame);
498    self->EndAssertNoThreadSuspension(old_cause);
499
500    if (method->IsStatic() && !method->GetDeclaringClass()->IsInitializing()) {
501      // Ensure static method's class is initialized.
502      SirtRef<mirror::Class> sirt_c(self, method->GetDeclaringClass());
503      if (!Runtime::Current()->GetClassLinker()->EnsureInitialized(sirt_c, true, true)) {
504        DCHECK(Thread::Current()->IsExceptionPending()) << PrettyMethod(method);
505        self->PopManagedStackFragment(fragment);
506        return 0;
507      }
508    }
509
510    JValue result = interpreter::EnterInterpreterFromStub(self, mh, code_item, *shadow_frame);
511    // Pop transition.
512    self->PopManagedStackFragment(fragment);
513    // No need to restore the args since the method has already been run by the interpreter.
514    return result.GetJ();
515  }
516}
517
518// Visits arguments on the stack placing them into the args vector, Object* arguments are converted
519// to jobjects.
520class BuildQuickArgumentVisitor FINAL : public QuickArgumentVisitor {
521 public:
522  BuildQuickArgumentVisitor(mirror::ArtMethod** sp, bool is_static, const char* shorty,
523                            uint32_t shorty_len, ScopedObjectAccessUnchecked* soa,
524                            std::vector<jvalue>* args) :
525    QuickArgumentVisitor(sp, is_static, shorty, shorty_len), soa_(soa), args_(args) {}
526
527  void Visit() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) OVERRIDE;
528
529  void FixupReferences() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
530
531 private:
532  ScopedObjectAccessUnchecked* const soa_;
533  std::vector<jvalue>* const args_;
534  // References which we must update when exiting in case the GC moved the objects.
535  std::vector<std::pair<jobject, StackReference<mirror::Object>*> > references_;
536
537  DISALLOW_COPY_AND_ASSIGN(BuildQuickArgumentVisitor);
538};
539
540void BuildQuickArgumentVisitor::Visit() {
541  jvalue val;
542  Primitive::Type type = GetParamPrimitiveType();
543  switch (type) {
544    case Primitive::kPrimNot: {
545      StackReference<mirror::Object>* stack_ref =
546          reinterpret_cast<StackReference<mirror::Object>*>(GetParamAddress());
547      val.l = soa_->AddLocalReference<jobject>(stack_ref->AsMirrorPtr());
548      references_.push_back(std::make_pair(val.l, stack_ref));
549      break;
550    }
551    case Primitive::kPrimLong:  // Fall-through.
552    case Primitive::kPrimDouble:
553      if (IsSplitLongOrDouble()) {
554        val.j = ReadSplitLongParam();
555      } else {
556        val.j = *reinterpret_cast<jlong*>(GetParamAddress());
557      }
558      break;
559    case Primitive::kPrimBoolean:  // Fall-through.
560    case Primitive::kPrimByte:     // Fall-through.
561    case Primitive::kPrimChar:     // Fall-through.
562    case Primitive::kPrimShort:    // Fall-through.
563    case Primitive::kPrimInt:      // Fall-through.
564    case Primitive::kPrimFloat:
565      val.i = *reinterpret_cast<jint*>(GetParamAddress());
566      break;
567    case Primitive::kPrimVoid:
568      LOG(FATAL) << "UNREACHABLE";
569      val.j = 0;
570      break;
571  }
572  args_->push_back(val);
573}
574
575void BuildQuickArgumentVisitor::FixupReferences() {
576  // Fixup any references which may have changed.
577  for (const auto& pair : references_) {
578    pair.second->Assign(soa_->Decode<mirror::Object*>(pair.first));
579    soa_->Env()->DeleteLocalRef(pair.first);
580  }
581}
582
583// Handler for invocation on proxy methods. On entry a frame will exist for the proxy object method
584// which is responsible for recording callee save registers. We explicitly place into jobjects the
585// incoming reference arguments (so they survive GC). We invoke the invocation handler, which is a
586// field within the proxy object, which will box the primitive arguments and deal with error cases.
587extern "C" uint64_t artQuickProxyInvokeHandler(mirror::ArtMethod* proxy_method,
588                                               mirror::Object* receiver,
589                                               Thread* self, mirror::ArtMethod** sp)
590    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
591  DCHECK(proxy_method->IsProxyMethod()) << PrettyMethod(proxy_method);
592  DCHECK(receiver->GetClass()->IsProxyClass()) << PrettyMethod(proxy_method);
593  // Ensure we don't get thread suspension until the object arguments are safely in jobjects.
594  const char* old_cause =
595      self->StartAssertNoThreadSuspension("Adding to IRT proxy object arguments");
596  // Register the top of the managed stack, making stack crawlable.
597  DCHECK_EQ(*sp, proxy_method) << PrettyMethod(proxy_method);
598  self->SetTopOfStack(sp, 0);
599  DCHECK_EQ(proxy_method->GetFrameSizeInBytes(),
600            Runtime::Current()->GetCalleeSaveMethod(Runtime::kRefsAndArgs)->GetFrameSizeInBytes())
601      << PrettyMethod(proxy_method);
602  self->VerifyStack();
603  // Start new JNI local reference state.
604  JNIEnvExt* env = self->GetJniEnv();
605  ScopedObjectAccessUnchecked soa(env);
606  ScopedJniEnvLocalRefState env_state(env);
607  // Create local ref. copies of proxy method and the receiver.
608  jobject rcvr_jobj = soa.AddLocalReference<jobject>(receiver);
609
610  // Placing arguments into args vector and remove the receiver.
611  MethodHelper proxy_mh(proxy_method);
612  DCHECK(!proxy_mh.IsStatic()) << PrettyMethod(proxy_method);
613  std::vector<jvalue> args;
614  BuildQuickArgumentVisitor local_ref_visitor(sp, proxy_mh.IsStatic(), proxy_mh.GetShorty(),
615                                              proxy_mh.GetShortyLength(), &soa, &args);
616
617  local_ref_visitor.VisitArguments();
618  DCHECK_GT(args.size(), 0U) << PrettyMethod(proxy_method);
619  args.erase(args.begin());
620
621  // Convert proxy method into expected interface method.
622  mirror::ArtMethod* interface_method = proxy_method->FindOverriddenMethod();
623  DCHECK(interface_method != NULL) << PrettyMethod(proxy_method);
624  DCHECK(!interface_method->IsProxyMethod()) << PrettyMethod(interface_method);
625  jobject interface_method_jobj = soa.AddLocalReference<jobject>(interface_method);
626
627  // All naked Object*s should now be in jobjects, so its safe to go into the main invoke code
628  // that performs allocations.
629  self->EndAssertNoThreadSuspension(old_cause);
630  JValue result = InvokeProxyInvocationHandler(soa, proxy_mh.GetShorty(),
631                                               rcvr_jobj, interface_method_jobj, args);
632  // Restore references which might have moved.
633  local_ref_visitor.FixupReferences();
634  return result.GetJ();
635}
636
637// Read object references held in arguments from quick frames and place in a JNI local references,
638// so they don't get garbage collected.
639class RememberForGcArgumentVisitor FINAL : public QuickArgumentVisitor {
640 public:
641  RememberForGcArgumentVisitor(mirror::ArtMethod** sp, bool is_static, const char* shorty,
642                               uint32_t shorty_len, ScopedObjectAccessUnchecked* soa) :
643    QuickArgumentVisitor(sp, is_static, shorty, shorty_len), soa_(soa) {}
644
645  void Visit() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) OVERRIDE;
646
647  void FixupReferences() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
648
649 private:
650  ScopedObjectAccessUnchecked* const soa_;
651  // References which we must update when exiting in case the GC moved the objects.
652  std::vector<std::pair<jobject, StackReference<mirror::Object>*> > references_;
653  DISALLOW_COPY_AND_ASSIGN(RememberForGcArgumentVisitor);
654};
655
656void RememberForGcArgumentVisitor::Visit() {
657  if (IsParamAReference()) {
658    StackReference<mirror::Object>* stack_ref =
659        reinterpret_cast<StackReference<mirror::Object>*>(GetParamAddress());
660    jobject reference =
661        soa_->AddLocalReference<jobject>(stack_ref->AsMirrorPtr());
662    references_.push_back(std::make_pair(reference, stack_ref));
663  }
664}
665
666void RememberForGcArgumentVisitor::FixupReferences() {
667  // Fixup any references which may have changed.
668  for (const auto& pair : references_) {
669    pair.second->Assign(soa_->Decode<mirror::Object*>(pair.first));
670    soa_->Env()->DeleteLocalRef(pair.first);
671  }
672}
673
674
675// Lazily resolve a method for quick. Called by stub code.
676extern "C" const void* artQuickResolutionTrampoline(mirror::ArtMethod* called,
677                                                    mirror::Object* receiver,
678                                                    Thread* self, mirror::ArtMethod** sp)
679    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
680  FinishCalleeSaveFrameSetup(self, sp, Runtime::kRefsAndArgs);
681  // Start new JNI local reference state
682  JNIEnvExt* env = self->GetJniEnv();
683  ScopedObjectAccessUnchecked soa(env);
684  ScopedJniEnvLocalRefState env_state(env);
685  const char* old_cause = self->StartAssertNoThreadSuspension("Quick method resolution set up");
686
687  // Compute details about the called method (avoid GCs)
688  ClassLinker* linker = Runtime::Current()->GetClassLinker();
689  mirror::ArtMethod* caller = QuickArgumentVisitor::GetCallingMethod(sp);
690  InvokeType invoke_type;
691  const DexFile* dex_file;
692  uint32_t dex_method_idx;
693  if (called->IsRuntimeMethod()) {
694    uint32_t dex_pc = caller->ToDexPc(QuickArgumentVisitor::GetCallingPc(sp));
695    const DexFile::CodeItem* code;
696    {
697      MethodHelper mh(caller);
698      dex_file = &mh.GetDexFile();
699      code = mh.GetCodeItem();
700    }
701    CHECK_LT(dex_pc, code->insns_size_in_code_units_);
702    const Instruction* instr = Instruction::At(&code->insns_[dex_pc]);
703    Instruction::Code instr_code = instr->Opcode();
704    bool is_range;
705    switch (instr_code) {
706      case Instruction::INVOKE_DIRECT:
707        invoke_type = kDirect;
708        is_range = false;
709        break;
710      case Instruction::INVOKE_DIRECT_RANGE:
711        invoke_type = kDirect;
712        is_range = true;
713        break;
714      case Instruction::INVOKE_STATIC:
715        invoke_type = kStatic;
716        is_range = false;
717        break;
718      case Instruction::INVOKE_STATIC_RANGE:
719        invoke_type = kStatic;
720        is_range = true;
721        break;
722      case Instruction::INVOKE_SUPER:
723        invoke_type = kSuper;
724        is_range = false;
725        break;
726      case Instruction::INVOKE_SUPER_RANGE:
727        invoke_type = kSuper;
728        is_range = true;
729        break;
730      case Instruction::INVOKE_VIRTUAL:
731        invoke_type = kVirtual;
732        is_range = false;
733        break;
734      case Instruction::INVOKE_VIRTUAL_RANGE:
735        invoke_type = kVirtual;
736        is_range = true;
737        break;
738      case Instruction::INVOKE_INTERFACE:
739        invoke_type = kInterface;
740        is_range = false;
741        break;
742      case Instruction::INVOKE_INTERFACE_RANGE:
743        invoke_type = kInterface;
744        is_range = true;
745        break;
746      default:
747        LOG(FATAL) << "Unexpected call into trampoline: " << instr->DumpString(NULL);
748        // Avoid used uninitialized warnings.
749        invoke_type = kDirect;
750        is_range = false;
751    }
752    dex_method_idx = (is_range) ? instr->VRegB_3rc() : instr->VRegB_35c();
753
754  } else {
755    invoke_type = kStatic;
756    dex_file = &MethodHelper(called).GetDexFile();
757    dex_method_idx = called->GetDexMethodIndex();
758  }
759  uint32_t shorty_len;
760  const char* shorty =
761      dex_file->GetMethodShorty(dex_file->GetMethodId(dex_method_idx), &shorty_len);
762  RememberForGcArgumentVisitor visitor(sp, invoke_type == kStatic, shorty, shorty_len, &soa);
763  visitor.VisitArguments();
764  self->EndAssertNoThreadSuspension(old_cause);
765  bool virtual_or_interface = invoke_type == kVirtual || invoke_type == kInterface;
766  // Resolve method filling in dex cache.
767  if (called->IsRuntimeMethod()) {
768    SirtRef<mirror::Object> sirt_receiver(soa.Self(), virtual_or_interface ? receiver : nullptr);
769    called = linker->ResolveMethod(dex_method_idx, caller, invoke_type);
770    receiver = sirt_receiver.get();
771  }
772  const void* code = NULL;
773  if (LIKELY(!self->IsExceptionPending())) {
774    // Incompatible class change should have been handled in resolve method.
775    CHECK(!called->CheckIncompatibleClassChange(invoke_type))
776        << PrettyMethod(called) << " " << invoke_type;
777    if (virtual_or_interface) {
778      // Refine called method based on receiver.
779      CHECK(receiver != nullptr) << invoke_type;
780      if (invoke_type == kVirtual) {
781        called = receiver->GetClass()->FindVirtualMethodForVirtual(called);
782      } else {
783        called = receiver->GetClass()->FindVirtualMethodForInterface(called);
784      }
785      // We came here because of sharpening. Ensure the dex cache is up-to-date on the method index
786      // of the sharpened method.
787      if (called->GetDexCacheResolvedMethods() == caller->GetDexCacheResolvedMethods()) {
788        caller->GetDexCacheResolvedMethods()->Set<false>(called->GetDexMethodIndex(), called);
789      } else {
790        // Calling from one dex file to another, need to compute the method index appropriate to
791        // the caller's dex file. Since we get here only if the original called was a runtime
792        // method, we've got the correct dex_file and a dex_method_idx from above.
793        DCHECK(&MethodHelper(caller).GetDexFile() == dex_file);
794        uint32_t method_index =
795            MethodHelper(called).FindDexMethodIndexInOtherDexFile(*dex_file, dex_method_idx);
796        if (method_index != DexFile::kDexNoIndex) {
797          caller->GetDexCacheResolvedMethods()->Set<false>(method_index, called);
798        }
799      }
800    }
801    // Ensure that the called method's class is initialized.
802    SirtRef<mirror::Class> called_class(soa.Self(), called->GetDeclaringClass());
803    linker->EnsureInitialized(called_class, true, true);
804    if (LIKELY(called_class->IsInitialized())) {
805      code = called->GetEntryPointFromQuickCompiledCode();
806    } else if (called_class->IsInitializing()) {
807      if (invoke_type == kStatic) {
808        // Class is still initializing, go to oat and grab code (trampoline must be left in place
809        // until class is initialized to stop races between threads).
810        code = linker->GetQuickOatCodeFor(called);
811      } else {
812        // No trampoline for non-static methods.
813        code = called->GetEntryPointFromQuickCompiledCode();
814      }
815    } else {
816      DCHECK(called_class->IsErroneous());
817    }
818  }
819  CHECK_EQ(code == NULL, self->IsExceptionPending());
820  // Fixup any locally saved objects may have moved during a GC.
821  visitor.FixupReferences();
822  // Place called method in callee-save frame to be placed as first argument to quick method.
823  *sp = called;
824  return code;
825}
826
827
828
829/*
830 * This class uses a couple of observations to unite the different calling conventions through
831 * a few constants.
832 *
833 * 1) Number of registers used for passing is normally even, so counting down has no penalty for
834 *    possible alignment.
835 * 2) Known 64b architectures store 8B units on the stack, both for integral and floating point
836 *    types, so using uintptr_t is OK. Also means that we can use kRegistersNeededX to denote
837 *    when we have to split things
838 * 3) The only soft-float, Arm, is 32b, so no widening needs to be taken into account for floats
839 *    and we can use Int handling directly.
840 * 4) Only 64b architectures widen, and their stack is aligned 8B anyways, so no padding code
841 *    necessary when widening. Also, widening of Ints will take place implicitly, and the
842 *    extension should be compatible with Aarch64, which mandates copying the available bits
843 *    into LSB and leaving the rest unspecified.
844 * 5) Aligning longs and doubles is necessary on arm only, and it's the same in registers and on
845 *    the stack.
846 * 6) There is only little endian.
847 *
848 *
849 * Actual work is supposed to be done in a delegate of the template type. The interface is as
850 * follows:
851 *
852 * void PushGpr(uintptr_t):   Add a value for the next GPR
853 *
854 * void PushFpr4(float):      Add a value for the next FPR of size 32b. Is only called if we need
855 *                            padding, that is, think the architecture is 32b and aligns 64b.
856 *
857 * void PushFpr8(uint64_t):   Push a double. We _will_ call this on 32b, it's the callee's job to
858 *                            split this if necessary. The current state will have aligned, if
859 *                            necessary.
860 *
861 * void PushStack(uintptr_t): Push a value to the stack.
862 *
863 * uintptr_t PushSirt(mirror::Object* ref): Add a reference to the Sirt. This _will_ have nullptr,
864 *                                          as this might be important for null initialization.
865 *                                          Must return the jobject, that is, the reference to the
866 *                                          entry in the Sirt (nullptr if necessary).
867 *
868 */
869template <class T> class BuildGenericJniFrameStateMachine {
870 public:
871#if defined(__arm__)
872  // TODO: These are all dummy values!
873  static constexpr bool kNativeSoftFloatAbi = true;
874  static constexpr size_t kNumNativeGprArgs = 4;  // 4 arguments passed in GPRs, r0-r3
875  static constexpr size_t kNumNativeFprArgs = 0;  // 0 arguments passed in FPRs.
876
877  static constexpr size_t kRegistersNeededForLong = 2;
878  static constexpr size_t kRegistersNeededForDouble = 2;
879  static constexpr bool kMultiRegistersAligned = true;
880  static constexpr bool kMultiRegistersWidened = false;
881  static constexpr bool kAlignLongOnStack = true;
882  static constexpr bool kAlignDoubleOnStack = true;
883#elif defined(__aarch64__)
884  static constexpr bool kNativeSoftFloatAbi = false;  // This is a hard float ABI.
885  static constexpr size_t kNumNativeGprArgs = 8;  // 6 arguments passed in GPRs.
886  static constexpr size_t kNumNativeFprArgs = 8;  // 8 arguments passed in FPRs.
887
888  static constexpr size_t kRegistersNeededForLong = 1;
889  static constexpr size_t kRegistersNeededForDouble = 1;
890  static constexpr bool kMultiRegistersAligned = false;
891  static constexpr bool kMultiRegistersWidened = false;
892  static constexpr bool kAlignLongOnStack = false;
893  static constexpr bool kAlignDoubleOnStack = false;
894#elif defined(__mips__)
895  // TODO: These are all dummy values!
896  static constexpr bool kNativeSoftFloatAbi = true;  // This is a hard float ABI.
897  static constexpr size_t kNumNativeGprArgs = 0;  // 6 arguments passed in GPRs.
898  static constexpr size_t kNumNativeFprArgs = 0;  // 8 arguments passed in FPRs.
899
900  static constexpr size_t kRegistersNeededForLong = 2;
901  static constexpr size_t kRegistersNeededForDouble = 2;
902  static constexpr bool kMultiRegistersAligned = true;
903  static constexpr bool kMultiRegistersWidened = true;
904  static constexpr bool kAlignLongOnStack = false;
905  static constexpr bool kAlignDoubleOnStack = false;
906#elif defined(__i386__)
907  // TODO: Check these!
908  static constexpr bool kNativeSoftFloatAbi = false;  // Not using int registers for fp
909  static constexpr size_t kNumNativeGprArgs = 0;  // 6 arguments passed in GPRs.
910  static constexpr size_t kNumNativeFprArgs = 0;  // 8 arguments passed in FPRs.
911
912  static constexpr size_t kRegistersNeededForLong = 2;
913  static constexpr size_t kRegistersNeededForDouble = 2;
914  static constexpr bool kMultiRegistersAligned = false;       // x86 not using regs, anyways
915  static constexpr bool kMultiRegistersWidened = false;
916  static constexpr bool kAlignLongOnStack = false;
917  static constexpr bool kAlignDoubleOnStack = false;
918#elif defined(__x86_64__)
919  static constexpr bool kNativeSoftFloatAbi = false;  // This is a hard float ABI.
920  static constexpr size_t kNumNativeGprArgs = 6;  // 6 arguments passed in GPRs.
921  static constexpr size_t kNumNativeFprArgs = 8;  // 8 arguments passed in FPRs.
922
923  static constexpr size_t kRegistersNeededForLong = 1;
924  static constexpr size_t kRegistersNeededForDouble = 1;
925  static constexpr bool kMultiRegistersAligned = false;
926  static constexpr bool kMultiRegistersWidened = false;
927  static constexpr bool kAlignLongOnStack = false;
928  static constexpr bool kAlignDoubleOnStack = false;
929#else
930#error "Unsupported architecture"
931#endif
932
933 public:
934  explicit BuildGenericJniFrameStateMachine(T* delegate) : gpr_index_(kNumNativeGprArgs),
935                                                           fpr_index_(kNumNativeFprArgs),
936                                                           stack_entries_(0),
937                                                           delegate_(delegate) {
938    // For register alignment, we want to assume that counters (gpr_index_, fpr_index_) are even iff
939    // the next register is even; counting down is just to make the compiler happy...
940    CHECK_EQ(kNumNativeGprArgs % 2, 0U);
941    CHECK_EQ(kNumNativeFprArgs % 2, 0U);
942  }
943
944  virtual ~BuildGenericJniFrameStateMachine() {}
945
946  bool HavePointerGpr() {
947    return gpr_index_ > 0;
948  }
949
950  void AdvancePointer(void* val) {
951    if (HavePointerGpr()) {
952      gpr_index_--;
953      PushGpr(reinterpret_cast<uintptr_t>(val));
954    } else {
955      stack_entries_++;         // TODO: have a field for pointer length as multiple of 32b
956      PushStack(reinterpret_cast<uintptr_t>(val));
957      gpr_index_ = 0;
958    }
959  }
960
961
962  bool HaveSirtGpr() {
963    return gpr_index_ > 0;
964  }
965
966  void AdvanceSirt(mirror::Object* ptr) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
967    uintptr_t sirtRef = PushSirt(ptr);
968    if (HaveSirtGpr()) {
969      gpr_index_--;
970      PushGpr(sirtRef);
971    } else {
972      stack_entries_++;
973      PushStack(sirtRef);
974      gpr_index_ = 0;
975    }
976  }
977
978
979  bool HaveIntGpr() {
980    return gpr_index_ > 0;
981  }
982
983  void AdvanceInt(uint32_t val) {
984    if (HaveIntGpr()) {
985      gpr_index_--;
986      PushGpr(val);
987    } else {
988      stack_entries_++;
989      PushStack(val);
990      gpr_index_ = 0;
991    }
992  }
993
994
995  bool HaveLongGpr() {
996    return gpr_index_ >= kRegistersNeededForLong + (LongGprNeedsPadding() ? 1 : 0);
997  }
998
999  bool LongGprNeedsPadding() {
1000    return kRegistersNeededForLong > 1 &&     // only pad when using multiple registers
1001        kAlignLongOnStack &&                  // and when it needs alignment
1002        (gpr_index_ & 1) == 1;                // counter is odd, see constructor
1003  }
1004
1005  bool LongStackNeedsPadding() {
1006    return kRegistersNeededForLong > 1 &&     // only pad when using multiple registers
1007        kAlignLongOnStack &&                  // and when it needs 8B alignment
1008        (stack_entries_ & 1) == 1;            // counter is odd
1009  }
1010
1011  void AdvanceLong(uint64_t val) {
1012    if (HaveLongGpr()) {
1013      if (LongGprNeedsPadding()) {
1014        PushGpr(0);
1015        gpr_index_--;
1016      }
1017      if (kRegistersNeededForLong == 1) {
1018        PushGpr(static_cast<uintptr_t>(val));
1019      } else {
1020        PushGpr(static_cast<uintptr_t>(val & 0xFFFFFFFF));
1021        PushGpr(static_cast<uintptr_t>((val >> 32) & 0xFFFFFFFF));
1022      }
1023      gpr_index_ -= kRegistersNeededForLong;
1024    } else {
1025      if (LongStackNeedsPadding()) {
1026        PushStack(0);
1027        stack_entries_++;
1028      }
1029      if (kRegistersNeededForLong == 1) {
1030        PushStack(static_cast<uintptr_t>(val));
1031        stack_entries_++;
1032      } else {
1033        PushStack(static_cast<uintptr_t>(val & 0xFFFFFFFF));
1034        PushStack(static_cast<uintptr_t>((val >> 32) & 0xFFFFFFFF));
1035        stack_entries_ += 2;
1036      }
1037      gpr_index_ = 0;
1038    }
1039  }
1040
1041
1042  bool HaveFloatFpr() {
1043    return fpr_index_ > 0;
1044  }
1045
1046  template <typename U, typename V> V convert(U in) {
1047    CHECK_LE(sizeof(U), sizeof(V));
1048    union { U u; V v; } tmp;
1049    tmp.u = in;
1050    return tmp.v;
1051  }
1052
1053  void AdvanceFloat(float val) {
1054    if (kNativeSoftFloatAbi) {
1055      AdvanceInt(convert<float, uint32_t>(val));
1056    } else {
1057      if (HaveFloatFpr()) {
1058        fpr_index_--;
1059        if (kRegistersNeededForDouble == 1) {
1060          if (kMultiRegistersWidened) {
1061            PushFpr8(convert<double, uint64_t>(val));
1062          } else {
1063            // No widening, just use the bits.
1064            PushFpr8(convert<float, uint64_t>(val));
1065          }
1066        } else {
1067          PushFpr4(val);
1068        }
1069      } else {
1070        stack_entries_++;
1071        if (kRegistersNeededForDouble == 1 && kMultiRegistersWidened) {
1072          // Need to widen before storing: Note the "double" in the template instantiation.
1073          PushStack(convert<double, uintptr_t>(val));
1074        } else {
1075          PushStack(convert<float, uintptr_t>(val));
1076        }
1077        fpr_index_ = 0;
1078      }
1079    }
1080  }
1081
1082
1083  bool HaveDoubleFpr() {
1084    return fpr_index_ >= kRegistersNeededForDouble + (DoubleFprNeedsPadding() ? 1 : 0);
1085  }
1086
1087  bool DoubleFprNeedsPadding() {
1088    return kRegistersNeededForDouble > 1 &&     // only pad when using multiple registers
1089        kAlignDoubleOnStack &&                  // and when it needs alignment
1090        (fpr_index_ & 1) == 1;                  // counter is odd, see constructor
1091  }
1092
1093  bool DoubleStackNeedsPadding() {
1094    return kRegistersNeededForDouble > 1 &&     // only pad when using multiple registers
1095        kAlignDoubleOnStack &&                  // and when it needs 8B alignment
1096        (stack_entries_ & 1) == 1;              // counter is odd
1097  }
1098
1099  void AdvanceDouble(uint64_t val) {
1100    if (kNativeSoftFloatAbi) {
1101      AdvanceLong(val);
1102    } else {
1103      if (HaveDoubleFpr()) {
1104        if (DoubleFprNeedsPadding()) {
1105          PushFpr4(0);
1106          fpr_index_--;
1107        }
1108        PushFpr8(val);
1109        fpr_index_ -= kRegistersNeededForDouble;
1110      } else {
1111        if (DoubleStackNeedsPadding()) {
1112          PushStack(0);
1113          stack_entries_++;
1114        }
1115        if (kRegistersNeededForDouble == 1) {
1116          PushStack(static_cast<uintptr_t>(val));
1117          stack_entries_++;
1118        } else {
1119          PushStack(static_cast<uintptr_t>(val & 0xFFFFFFFF));
1120          PushStack(static_cast<uintptr_t>((val >> 32) & 0xFFFFFFFF));
1121          stack_entries_ += 2;
1122        }
1123        fpr_index_ = 0;
1124      }
1125    }
1126  }
1127
1128  uint32_t getStackEntries() {
1129    return stack_entries_;
1130  }
1131
1132  uint32_t getNumberOfUsedGprs() {
1133    return kNumNativeGprArgs - gpr_index_;
1134  }
1135
1136  uint32_t getNumberOfUsedFprs() {
1137    return kNumNativeFprArgs - fpr_index_;
1138  }
1139
1140 private:
1141  void PushGpr(uintptr_t val) {
1142    delegate_->PushGpr(val);
1143  }
1144  void PushFpr4(float val) {
1145    delegate_->PushFpr4(val);
1146  }
1147  void PushFpr8(uint64_t val) {
1148    delegate_->PushFpr8(val);
1149  }
1150  void PushStack(uintptr_t val) {
1151    delegate_->PushStack(val);
1152  }
1153  uintptr_t PushSirt(mirror::Object* ref) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
1154    return delegate_->PushSirt(ref);
1155  }
1156
1157  uint32_t gpr_index_;      // Number of free GPRs
1158  uint32_t fpr_index_;      // Number of free FPRs
1159  uint32_t stack_entries_;  // Stack entries are in multiples of 32b, as floats are usually not
1160                            // extended
1161  T* delegate_;             // What Push implementation gets called
1162};
1163
1164class ComputeGenericJniFrameSize FINAL {
1165 public:
1166  ComputeGenericJniFrameSize() : num_sirt_references_(0), num_stack_entries_(0) {}
1167
1168  uint32_t GetStackSize() {
1169    return num_stack_entries_ * sizeof(uintptr_t);
1170  }
1171
1172  // WARNING: After this, *sp won't be pointing to the method anymore!
1173  void ComputeLayout(mirror::ArtMethod*** m, bool is_static, const char* shorty, uint32_t shorty_len,
1174                     void* sp, StackIndirectReferenceTable** table, uint32_t* sirt_entries,
1175                     uintptr_t** start_stack, uintptr_t** start_gpr, uint32_t** start_fpr,
1176                     void** code_return, size_t* overall_size)
1177      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
1178    ComputeAll(is_static, shorty, shorty_len);
1179
1180    mirror::ArtMethod* method = **m;
1181
1182    uint8_t* sp8 = reinterpret_cast<uint8_t*>(sp);
1183
1184    // First, fix up the layout of the callee-save frame.
1185    // We have to squeeze in the Sirt, and relocate the method pointer.
1186
1187    // "Free" the slot for the method.
1188    sp8 += kPointerSize;
1189
1190    // Add the Sirt.
1191    *sirt_entries = num_sirt_references_;
1192    size_t sirt_size = StackIndirectReferenceTable::GetAlignedSirtSize(num_sirt_references_);
1193    sp8 -= sirt_size;
1194    *table = reinterpret_cast<StackIndirectReferenceTable*>(sp8);
1195    (*table)->SetNumberOfReferences(num_sirt_references_);
1196
1197    // Add a slot for the method pointer, and fill it. Fix the pointer-pointer given to us.
1198    sp8 -= kPointerSize;
1199    uint8_t* method_pointer = sp8;
1200    *(reinterpret_cast<mirror::ArtMethod**>(method_pointer)) = method;
1201    *m = reinterpret_cast<mirror::ArtMethod**>(method_pointer);
1202
1203    // Reference cookie and padding
1204    sp8 -= 8;
1205    // Store Sirt size
1206    *reinterpret_cast<uint32_t*>(sp8) = static_cast<uint32_t>(sirt_size & 0xFFFFFFFF);
1207
1208    // Next comes the native call stack.
1209    sp8 -= GetStackSize();
1210    // Now align the call stack below. This aligns by 16, as AArch64 seems to require.
1211    uintptr_t mask = ~0x0F;
1212    sp8 = reinterpret_cast<uint8_t*>(reinterpret_cast<uintptr_t>(sp8) & mask);
1213    *start_stack = reinterpret_cast<uintptr_t*>(sp8);
1214
1215    // put fprs and gprs below
1216    // Assumption is OK right now, as we have soft-float arm
1217    size_t fregs = BuildGenericJniFrameStateMachine<ComputeGenericJniFrameSize>::kNumNativeFprArgs;
1218    sp8 -= fregs * sizeof(uintptr_t);
1219    *start_fpr = reinterpret_cast<uint32_t*>(sp8);
1220    size_t iregs = BuildGenericJniFrameStateMachine<ComputeGenericJniFrameSize>::kNumNativeGprArgs;
1221    sp8 -= iregs * sizeof(uintptr_t);
1222    *start_gpr = reinterpret_cast<uintptr_t*>(sp8);
1223
1224    // reserve space for the code pointer
1225    sp8 -= kPointerSize;
1226    *code_return = reinterpret_cast<void*>(sp8);
1227
1228    *overall_size = reinterpret_cast<uint8_t*>(sp) - sp8;
1229
1230    // The new SP is stored at the end of the alloca, so it can be immediately popped
1231    sp8 = reinterpret_cast<uint8_t*>(sp) - 5 * KB;
1232    *(reinterpret_cast<uint8_t**>(sp8)) = method_pointer;
1233  }
1234
1235  void ComputeSirtOffset() { }  // nothing to do, static right now
1236
1237  void ComputeAll(bool is_static, const char* shorty, uint32_t shorty_len)
1238      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
1239    BuildGenericJniFrameStateMachine<ComputeGenericJniFrameSize> sm(this);
1240
1241    // JNIEnv
1242    sm.AdvancePointer(nullptr);
1243
1244    // Class object or this as first argument
1245    sm.AdvanceSirt(reinterpret_cast<mirror::Object*>(0x12345678));
1246
1247    for (uint32_t i = 1; i < shorty_len; ++i) {
1248      Primitive::Type cur_type_ = Primitive::GetType(shorty[i]);
1249      switch (cur_type_) {
1250        case Primitive::kPrimNot:
1251          sm.AdvanceSirt(reinterpret_cast<mirror::Object*>(0x12345678));
1252          break;
1253
1254        case Primitive::kPrimBoolean:
1255        case Primitive::kPrimByte:
1256        case Primitive::kPrimChar:
1257        case Primitive::kPrimShort:
1258        case Primitive::kPrimInt:
1259          sm.AdvanceInt(0);
1260          break;
1261        case Primitive::kPrimFloat:
1262          sm.AdvanceFloat(0);
1263          break;
1264        case Primitive::kPrimDouble:
1265          sm.AdvanceDouble(0);
1266          break;
1267        case Primitive::kPrimLong:
1268          sm.AdvanceLong(0);
1269          break;
1270        default:
1271          LOG(FATAL) << "Unexpected type: " << cur_type_ << " in " << shorty;
1272      }
1273    }
1274
1275    num_stack_entries_ = sm.getStackEntries();
1276  }
1277
1278  void PushGpr(uintptr_t /* val */) {
1279    // not optimizing registers, yet
1280  }
1281
1282  void PushFpr4(float /* val */) {
1283    // not optimizing registers, yet
1284  }
1285
1286  void PushFpr8(uint64_t /* val */) {
1287    // not optimizing registers, yet
1288  }
1289
1290  void PushStack(uintptr_t /* val */) {
1291    // counting is already done in the superclass
1292  }
1293
1294  uintptr_t PushSirt(mirror::Object* /* ptr */) {
1295    num_sirt_references_++;
1296    return reinterpret_cast<uintptr_t>(nullptr);
1297  }
1298
1299 private:
1300  uint32_t num_sirt_references_;
1301  uint32_t num_stack_entries_;
1302};
1303
1304// Visits arguments on the stack placing them into a region lower down the stack for the benefit
1305// of transitioning into native code.
1306class BuildGenericJniFrameVisitor FINAL : public QuickArgumentVisitor {
1307 public:
1308  BuildGenericJniFrameVisitor(mirror::ArtMethod*** sp, bool is_static, const char* shorty,
1309                              uint32_t shorty_len, Thread* self) :
1310      QuickArgumentVisitor(*sp, is_static, shorty, shorty_len), sm_(this) {
1311    ComputeGenericJniFrameSize fsc;
1312    fsc.ComputeLayout(sp, is_static, shorty, shorty_len, *sp, &sirt_, &sirt_expected_refs_,
1313                      &cur_stack_arg_, &cur_gpr_reg_, &cur_fpr_reg_, &code_return_,
1314                      &alloca_used_size_);
1315    sirt_number_of_references_ = 0;
1316    cur_sirt_entry_ = reinterpret_cast<StackReference<mirror::Object>*>(GetFirstSirtEntry());
1317
1318    // jni environment is always first argument
1319    sm_.AdvancePointer(self->GetJniEnv());
1320
1321    if (is_static) {
1322      sm_.AdvanceSirt((**sp)->GetDeclaringClass());
1323    }
1324  }
1325
1326  void Visit() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) OVERRIDE;
1327
1328  void FinalizeSirt(Thread* self) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
1329
1330  jobject GetFirstSirtEntry() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
1331    return reinterpret_cast<jobject>(sirt_->GetStackReference(0));
1332  }
1333
1334  void PushGpr(uintptr_t val) {
1335    *cur_gpr_reg_ = val;
1336    cur_gpr_reg_++;
1337  }
1338
1339  void PushFpr4(float val) {
1340    *cur_fpr_reg_ = val;
1341    cur_fpr_reg_++;
1342  }
1343
1344  void PushFpr8(uint64_t val) {
1345    uint64_t* tmp = reinterpret_cast<uint64_t*>(cur_fpr_reg_);
1346    *tmp = val;
1347    cur_fpr_reg_ += 2;
1348  }
1349
1350  void PushStack(uintptr_t val) {
1351    *cur_stack_arg_ = val;
1352    cur_stack_arg_++;
1353  }
1354
1355  uintptr_t PushSirt(mirror::Object* ref) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
1356    uintptr_t tmp;
1357    if (ref == nullptr) {
1358      *cur_sirt_entry_ = StackReference<mirror::Object>();
1359      tmp = reinterpret_cast<uintptr_t>(nullptr);
1360    } else {
1361      *cur_sirt_entry_ = StackReference<mirror::Object>::FromMirrorPtr(ref);
1362      tmp = reinterpret_cast<uintptr_t>(cur_sirt_entry_);
1363    }
1364    cur_sirt_entry_++;
1365    sirt_number_of_references_++;
1366    return tmp;
1367  }
1368
1369  // Size of the part of the alloca that we actually need.
1370  size_t GetAllocaUsedSize() {
1371    return alloca_used_size_;
1372  }
1373
1374  void* GetCodeReturn() {
1375    return code_return_;
1376  }
1377
1378 private:
1379  uint32_t sirt_number_of_references_;
1380  StackReference<mirror::Object>* cur_sirt_entry_;
1381  StackIndirectReferenceTable* sirt_;
1382  uint32_t sirt_expected_refs_;
1383  uintptr_t* cur_gpr_reg_;
1384  uint32_t* cur_fpr_reg_;
1385  uintptr_t* cur_stack_arg_;
1386  // StackReference<mirror::Object>* top_of_sirt_;
1387  void* code_return_;
1388  size_t alloca_used_size_;
1389
1390  BuildGenericJniFrameStateMachine<BuildGenericJniFrameVisitor> sm_;
1391
1392  DISALLOW_COPY_AND_ASSIGN(BuildGenericJniFrameVisitor);
1393};
1394
1395void BuildGenericJniFrameVisitor::Visit() {
1396  Primitive::Type type = GetParamPrimitiveType();
1397  switch (type) {
1398    case Primitive::kPrimLong: {
1399      jlong long_arg;
1400      if (IsSplitLongOrDouble()) {
1401        long_arg = ReadSplitLongParam();
1402      } else {
1403        long_arg = *reinterpret_cast<jlong*>(GetParamAddress());
1404      }
1405      sm_.AdvanceLong(long_arg);
1406      break;
1407    }
1408    case Primitive::kPrimDouble: {
1409      uint64_t double_arg;
1410      if (IsSplitLongOrDouble()) {
1411        // Read into union so that we don't case to a double.
1412        double_arg = ReadSplitLongParam();
1413      } else {
1414        double_arg = *reinterpret_cast<uint64_t*>(GetParamAddress());
1415      }
1416      sm_.AdvanceDouble(double_arg);
1417      break;
1418    }
1419    case Primitive::kPrimNot: {
1420      StackReference<mirror::Object>* stack_ref =
1421          reinterpret_cast<StackReference<mirror::Object>*>(GetParamAddress());
1422      sm_.AdvanceSirt(stack_ref->AsMirrorPtr());
1423      break;
1424    }
1425    case Primitive::kPrimFloat:
1426      sm_.AdvanceFloat(*reinterpret_cast<float*>(GetParamAddress()));
1427      break;
1428    case Primitive::kPrimBoolean:  // Fall-through.
1429    case Primitive::kPrimByte:     // Fall-through.
1430    case Primitive::kPrimChar:     // Fall-through.
1431    case Primitive::kPrimShort:    // Fall-through.
1432    case Primitive::kPrimInt:      // Fall-through.
1433      sm_.AdvanceInt(*reinterpret_cast<jint*>(GetParamAddress()));
1434      break;
1435    case Primitive::kPrimVoid:
1436      LOG(FATAL) << "UNREACHABLE";
1437      break;
1438  }
1439}
1440
1441void BuildGenericJniFrameVisitor::FinalizeSirt(Thread* self) {
1442  // Initialize padding entries.
1443  while (sirt_number_of_references_ < sirt_expected_refs_) {
1444    *cur_sirt_entry_ = StackReference<mirror::Object>();
1445    cur_sirt_entry_++;
1446    sirt_number_of_references_++;
1447  }
1448  sirt_->SetNumberOfReferences(sirt_expected_refs_);
1449  DCHECK_NE(sirt_expected_refs_, 0U);
1450  // Install Sirt.
1451  self->PushSirt(sirt_);
1452}
1453
1454extern "C" void* artFindNativeMethod();
1455
1456uint64_t artQuickGenericJniEndJNIRef(Thread* self, uint32_t cookie, jobject l, jobject lock) {
1457  if (lock != nullptr) {
1458    return reinterpret_cast<uint64_t>(JniMethodEndWithReferenceSynchronized(l, cookie, lock, self));
1459  } else {
1460    return reinterpret_cast<uint64_t>(JniMethodEndWithReference(l, cookie, self));
1461  }
1462}
1463
1464void artQuickGenericJniEndJNINonRef(Thread* self, uint32_t cookie, jobject lock) {
1465  if (lock != nullptr) {
1466    JniMethodEndSynchronized(cookie, lock, self);
1467  } else {
1468    JniMethodEnd(cookie, self);
1469  }
1470}
1471
1472/*
1473 * Initializes an alloca region assumed to be directly below sp for a native call:
1474 * Create a Sirt and call stack and fill a mini stack with values to be pushed to registers.
1475 * The final element on the stack is a pointer to the native code.
1476 *
1477 * On entry, the stack has a standard callee-save frame above sp, and an alloca below it.
1478 * We need to fix this, as the Sirt needs to go into the callee-save frame.
1479 *
1480 * The return of this function denotes:
1481 * 1) How many bytes of the alloca can be released, if the value is non-negative.
1482 * 2) An error, if the value is negative.
1483 */
1484extern "C" ssize_t artQuickGenericJniTrampoline(Thread* self, mirror::ArtMethod** sp)
1485    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
1486  mirror::ArtMethod* called = *sp;
1487  DCHECK(called->IsNative()) << PrettyMethod(called, true);
1488
1489  // run the visitor
1490  MethodHelper mh(called);
1491
1492  BuildGenericJniFrameVisitor visitor(&sp, called->IsStatic(), mh.GetShorty(), mh.GetShortyLength(),
1493                                      self);
1494  visitor.VisitArguments();
1495  visitor.FinalizeSirt(self);
1496
1497  // fix up managed-stack things in Thread
1498  self->SetTopOfStack(sp, 0);
1499
1500  self->VerifyStack();
1501
1502  // Start JNI, save the cookie.
1503  uint32_t cookie;
1504  if (called->IsSynchronized()) {
1505    cookie = JniMethodStartSynchronized(visitor.GetFirstSirtEntry(), self);
1506    if (self->IsExceptionPending()) {
1507      self->PopSirt();
1508      // A negative value denotes an error.
1509      return -1;
1510    }
1511  } else {
1512    cookie = JniMethodStart(self);
1513  }
1514  uint32_t* sp32 = reinterpret_cast<uint32_t*>(sp);
1515  *(sp32 - 1) = cookie;
1516
1517  // Retrieve the stored native code.
1518  const void* nativeCode = called->GetNativeMethod();
1519
1520  // There are two cases for the content of nativeCode:
1521  // 1) Pointer to the native function.
1522  // 2) Pointer to the trampoline for native code binding.
1523  // In the second case, we need to execute the binding and continue with the actual native function
1524  // pointer.
1525  DCHECK(nativeCode != nullptr);
1526  if (nativeCode == GetJniDlsymLookupStub()) {
1527    nativeCode = artFindNativeMethod();
1528
1529    if (nativeCode == nullptr) {
1530      DCHECK(self->IsExceptionPending());    // There should be an exception pending now.
1531
1532      // End JNI, as the assembly will move to deliver the exception.
1533      jobject lock = called->IsSynchronized() ? visitor.GetFirstSirtEntry() : nullptr;
1534      if (mh.GetShorty()[0] == 'L') {
1535        artQuickGenericJniEndJNIRef(self, cookie, nullptr, lock);
1536      } else {
1537        artQuickGenericJniEndJNINonRef(self, cookie, lock);
1538      }
1539
1540      return -1;
1541    }
1542    // Note that the native code pointer will be automatically set by artFindNativeMethod().
1543  }
1544
1545  // Store the native code pointer in the stack at the right location.
1546  uintptr_t* code_pointer = reinterpret_cast<uintptr_t*>(visitor.GetCodeReturn());
1547  *code_pointer = reinterpret_cast<uintptr_t>(nativeCode);
1548
1549  // 5K reserved, window_size + frame pointer used.
1550  size_t window_size = visitor.GetAllocaUsedSize();
1551  return (5 * KB) - window_size - kPointerSize;
1552}
1553
1554/*
1555 * Is called after the native JNI code. Responsible for cleanup (SIRT, saved state) and
1556 * unlocking.
1557 */
1558extern "C" uint64_t artQuickGenericJniEndTrampoline(Thread* self, mirror::ArtMethod** sp,
1559                                                    jvalue result, uint64_t result_f)
1560    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
1561  uint32_t* sp32 = reinterpret_cast<uint32_t*>(sp);
1562  mirror::ArtMethod* called = *sp;
1563  uint32_t cookie = *(sp32 - 1);
1564
1565  jobject lock = nullptr;
1566  if (called->IsSynchronized()) {
1567    StackIndirectReferenceTable* table =
1568        reinterpret_cast<StackIndirectReferenceTable*>(
1569            reinterpret_cast<uint8_t*>(sp) + kPointerSize);
1570    lock = reinterpret_cast<jobject>(table->GetStackReference(0));
1571  }
1572
1573  MethodHelper mh(called);
1574  char return_shorty_char = mh.GetShorty()[0];
1575
1576  if (return_shorty_char == 'L') {
1577    return artQuickGenericJniEndJNIRef(self, cookie, result.l, lock);
1578  } else {
1579    artQuickGenericJniEndJNINonRef(self, cookie, lock);
1580
1581    switch (return_shorty_char) {
1582      case 'F':  // Fall-through.
1583      case 'D':
1584        return result_f;
1585      case 'Z':
1586        return result.z;
1587      case 'B':
1588        return result.b;
1589      case 'C':
1590        return result.c;
1591      case 'S':
1592        return result.s;
1593      case 'I':
1594        return result.i;
1595      case 'J':
1596        return result.j;
1597      case 'V':
1598        return 0;
1599      default:
1600        LOG(FATAL) << "Unexpected return shorty character " << return_shorty_char;
1601        return 0;
1602    }
1603  }
1604}
1605
1606template<InvokeType type, bool access_check>
1607static uint64_t artInvokeCommon(uint32_t method_idx, mirror::Object* this_object,
1608                                mirror::ArtMethod* caller_method,
1609                                Thread* self, mirror::ArtMethod** sp);
1610
1611template<InvokeType type, bool access_check>
1612static uint64_t artInvokeCommon(uint32_t method_idx, mirror::Object* this_object,
1613                                mirror::ArtMethod* caller_method,
1614                                Thread* self, mirror::ArtMethod** sp) {
1615  mirror::ArtMethod* method = FindMethodFast(method_idx, this_object, caller_method, access_check,
1616                                             type);
1617  if (UNLIKELY(method == nullptr)) {
1618    FinishCalleeSaveFrameSetup(self, sp, Runtime::kRefsAndArgs);
1619    const DexFile* dex_file = caller_method->GetDeclaringClass()->GetDexCache()->GetDexFile();
1620    uint32_t shorty_len;
1621    const char* shorty =
1622        dex_file->GetMethodShorty(dex_file->GetMethodId(method_idx), &shorty_len);
1623    {
1624      // Remember the args in case a GC happens in FindMethodFromCode.
1625      ScopedObjectAccessUnchecked soa(self->GetJniEnv());
1626      RememberForGcArgumentVisitor visitor(sp, type == kStatic, shorty, shorty_len, &soa);
1627      visitor.VisitArguments();
1628      method = FindMethodFromCode<type, access_check>(method_idx, this_object, caller_method, self);
1629      visitor.FixupReferences();
1630    }
1631
1632    if (UNLIKELY(method == NULL)) {
1633      CHECK(self->IsExceptionPending());
1634      return 0;  // failure
1635    }
1636  }
1637  DCHECK(!self->IsExceptionPending());
1638  const void* code = method->GetEntryPointFromQuickCompiledCode();
1639
1640  // When we return, the caller will branch to this address, so it had better not be 0!
1641  DCHECK(code != nullptr) << "Code was NULL in method: " << PrettyMethod(method) << " location: "
1642      << MethodHelper(method).GetDexFile().GetLocation();
1643#ifdef __LP64__
1644  UNIMPLEMENTED(FATAL);
1645  return 0;
1646#else
1647  uint32_t method_uint = reinterpret_cast<uint32_t>(method);
1648  uint64_t code_uint = reinterpret_cast<uint32_t>(code);
1649  uint64_t result = ((code_uint << 32) | method_uint);
1650  return result;
1651#endif
1652}
1653
1654// Explicit artInvokeCommon template function declarations to please analysis tool.
1655#define EXPLICIT_INVOKE_COMMON_TEMPLATE_DECL(type, access_check)                                \
1656  template SHARED_LOCKS_REQUIRED(Locks::mutator_lock_)                                          \
1657  uint64_t artInvokeCommon<type, access_check>(uint32_t method_idx,                             \
1658                                               mirror::Object* this_object,                     \
1659                                               mirror::ArtMethod* caller_method,                \
1660                                               Thread* self, mirror::ArtMethod** sp)            \
1661
1662EXPLICIT_INVOKE_COMMON_TEMPLATE_DECL(kVirtual, false);
1663EXPLICIT_INVOKE_COMMON_TEMPLATE_DECL(kVirtual, true);
1664EXPLICIT_INVOKE_COMMON_TEMPLATE_DECL(kInterface, false);
1665EXPLICIT_INVOKE_COMMON_TEMPLATE_DECL(kInterface, true);
1666EXPLICIT_INVOKE_COMMON_TEMPLATE_DECL(kDirect, false);
1667EXPLICIT_INVOKE_COMMON_TEMPLATE_DECL(kDirect, true);
1668EXPLICIT_INVOKE_COMMON_TEMPLATE_DECL(kStatic, false);
1669EXPLICIT_INVOKE_COMMON_TEMPLATE_DECL(kStatic, true);
1670EXPLICIT_INVOKE_COMMON_TEMPLATE_DECL(kSuper, false);
1671EXPLICIT_INVOKE_COMMON_TEMPLATE_DECL(kSuper, true);
1672#undef EXPLICIT_INVOKE_COMMON_TEMPLATE_DECL
1673
1674
1675// See comments in runtime_support_asm.S
1676extern "C" uint64_t artInvokeInterfaceTrampolineWithAccessCheck(uint32_t method_idx,
1677                                                                mirror::Object* this_object,
1678                                                                mirror::ArtMethod* caller_method,
1679                                                                Thread* self,
1680                                                                mirror::ArtMethod** sp)
1681    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
1682  return artInvokeCommon<kInterface, true>(method_idx, this_object, caller_method, self, sp);
1683}
1684
1685
1686extern "C" uint64_t artInvokeDirectTrampolineWithAccessCheck(uint32_t method_idx,
1687                                                             mirror::Object* this_object,
1688                                                             mirror::ArtMethod* caller_method,
1689                                                             Thread* self,
1690                                                             mirror::ArtMethod** sp)
1691    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
1692  return artInvokeCommon<kDirect, true>(method_idx, this_object, caller_method, self, sp);
1693}
1694
1695extern "C" uint64_t artInvokeStaticTrampolineWithAccessCheck(uint32_t method_idx,
1696                                                             mirror::Object* this_object,
1697                                                             mirror::ArtMethod* caller_method,
1698                                                             Thread* self,
1699                                                             mirror::ArtMethod** sp)
1700    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
1701  return artInvokeCommon<kStatic, true>(method_idx, this_object, caller_method, self, sp);
1702}
1703
1704extern "C" uint64_t artInvokeSuperTrampolineWithAccessCheck(uint32_t method_idx,
1705                                                            mirror::Object* this_object,
1706                                                            mirror::ArtMethod* caller_method,
1707                                                            Thread* self,
1708                                                            mirror::ArtMethod** sp)
1709    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
1710  return artInvokeCommon<kSuper, true>(method_idx, this_object, caller_method, self, sp);
1711}
1712
1713extern "C" uint64_t artInvokeVirtualTrampolineWithAccessCheck(uint32_t method_idx,
1714                                                              mirror::Object* this_object,
1715                                                              mirror::ArtMethod* caller_method,
1716                                                              Thread* self,
1717                                                              mirror::ArtMethod** sp)
1718    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
1719  return artInvokeCommon<kVirtual, true>(method_idx, this_object, caller_method, self, sp);
1720}
1721
1722// Determine target of interface dispatch. This object is known non-null.
1723extern "C" uint64_t artInvokeInterfaceTrampoline(mirror::ArtMethod* interface_method,
1724                                                 mirror::Object* this_object,
1725                                                 mirror::ArtMethod* caller_method,
1726                                                 Thread* self, mirror::ArtMethod** sp)
1727    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
1728  mirror::ArtMethod* method;
1729  if (LIKELY(interface_method->GetDexMethodIndex() != DexFile::kDexNoIndex)) {
1730    method = this_object->GetClass()->FindVirtualMethodForInterface(interface_method);
1731    if (UNLIKELY(method == NULL)) {
1732      FinishCalleeSaveFrameSetup(self, sp, Runtime::kRefsAndArgs);
1733      ThrowIncompatibleClassChangeErrorClassForInterfaceDispatch(interface_method, this_object,
1734                                                                 caller_method);
1735      return 0;  // Failure.
1736    }
1737  } else {
1738    FinishCalleeSaveFrameSetup(self, sp, Runtime::kRefsAndArgs);
1739    DCHECK(interface_method == Runtime::Current()->GetResolutionMethod());
1740    // Determine method index from calling dex instruction.
1741#if defined(__arm__)
1742    // On entry the stack pointed by sp is:
1743    // | argN       |  |
1744    // | ...        |  |
1745    // | arg4       |  |
1746    // | arg3 spill |  |  Caller's frame
1747    // | arg2 spill |  |
1748    // | arg1 spill |  |
1749    // | Method*    | ---
1750    // | LR         |
1751    // | ...        |    callee saves
1752    // | R3         |    arg3
1753    // | R2         |    arg2
1754    // | R1         |    arg1
1755    // | R0         |
1756    // | Method*    |  <- sp
1757    DCHECK_EQ(48U, Runtime::Current()->GetCalleeSaveMethod(Runtime::kRefsAndArgs)->GetFrameSizeInBytes());
1758    uintptr_t* regs = reinterpret_cast<uintptr_t*>(reinterpret_cast<byte*>(sp) + kPointerSize);
1759    uintptr_t caller_pc = regs[10];
1760#elif defined(__i386__)
1761    // On entry the stack pointed by sp is:
1762    // | argN        |  |
1763    // | ...         |  |
1764    // | arg4        |  |
1765    // | arg3 spill  |  |  Caller's frame
1766    // | arg2 spill  |  |
1767    // | arg1 spill  |  |
1768    // | Method*     | ---
1769    // | Return      |
1770    // | EBP,ESI,EDI |    callee saves
1771    // | EBX         |    arg3
1772    // | EDX         |    arg2
1773    // | ECX         |    arg1
1774    // | EAX/Method* |  <- sp
1775    DCHECK_EQ(32U, Runtime::Current()->GetCalleeSaveMethod(Runtime::kRefsAndArgs)->GetFrameSizeInBytes());
1776    uintptr_t* regs = reinterpret_cast<uintptr_t*>(reinterpret_cast<byte*>(sp));
1777    uintptr_t caller_pc = regs[7];
1778#elif defined(__mips__)
1779    // On entry the stack pointed by sp is:
1780    // | argN       |  |
1781    // | ...        |  |
1782    // | arg4       |  |
1783    // | arg3 spill |  |  Caller's frame
1784    // | arg2 spill |  |
1785    // | arg1 spill |  |
1786    // | Method*    | ---
1787    // | RA         |
1788    // | ...        |    callee saves
1789    // | A3         |    arg3
1790    // | A2         |    arg2
1791    // | A1         |    arg1
1792    // | A0/Method* |  <- sp
1793    DCHECK_EQ(64U, Runtime::Current()->GetCalleeSaveMethod(Runtime::kRefsAndArgs)->GetFrameSizeInBytes());
1794    uintptr_t* regs = reinterpret_cast<uintptr_t*>(reinterpret_cast<byte*>(sp));
1795    uintptr_t caller_pc = regs[15];
1796#else
1797    UNIMPLEMENTED(FATAL);
1798    uintptr_t caller_pc = 0;
1799#endif
1800    uint32_t dex_pc = caller_method->ToDexPc(caller_pc);
1801    const DexFile::CodeItem* code = MethodHelper(caller_method).GetCodeItem();
1802    CHECK_LT(dex_pc, code->insns_size_in_code_units_);
1803    const Instruction* instr = Instruction::At(&code->insns_[dex_pc]);
1804    Instruction::Code instr_code = instr->Opcode();
1805    CHECK(instr_code == Instruction::INVOKE_INTERFACE ||
1806          instr_code == Instruction::INVOKE_INTERFACE_RANGE)
1807        << "Unexpected call into interface trampoline: " << instr->DumpString(NULL);
1808    uint32_t dex_method_idx;
1809    if (instr_code == Instruction::INVOKE_INTERFACE) {
1810      dex_method_idx = instr->VRegB_35c();
1811    } else {
1812      DCHECK_EQ(instr_code, Instruction::INVOKE_INTERFACE_RANGE);
1813      dex_method_idx = instr->VRegB_3rc();
1814    }
1815
1816    const DexFile* dex_file = caller_method->GetDeclaringClass()->GetDexCache()->GetDexFile();
1817    uint32_t shorty_len;
1818    const char* shorty =
1819        dex_file->GetMethodShorty(dex_file->GetMethodId(dex_method_idx), &shorty_len);
1820    {
1821      // Remember the args in case a GC happens in FindMethodFromCode.
1822      ScopedObjectAccessUnchecked soa(self->GetJniEnv());
1823      RememberForGcArgumentVisitor visitor(sp, false, shorty, shorty_len, &soa);
1824      visitor.VisitArguments();
1825      method = FindMethodFromCode<kInterface, false>(dex_method_idx, this_object, caller_method,
1826                                                     self);
1827      visitor.FixupReferences();
1828    }
1829
1830    if (UNLIKELY(method == nullptr)) {
1831      CHECK(self->IsExceptionPending());
1832      return 0;  // Failure.
1833    }
1834  }
1835  const void* code = method->GetEntryPointFromQuickCompiledCode();
1836
1837  // When we return, the caller will branch to this address, so it had better not be 0!
1838  DCHECK(code != nullptr) << "Code was NULL in method: " << PrettyMethod(method) << " location: "
1839      << MethodHelper(method).GetDexFile().GetLocation();
1840#ifdef __LP64__
1841  UNIMPLEMENTED(FATAL);
1842  return 0;
1843#else
1844  uint32_t method_uint = reinterpret_cast<uint32_t>(method);
1845  uint64_t code_uint = reinterpret_cast<uint32_t>(code);
1846  uint64_t result = ((code_uint << 32) | method_uint);
1847  return result;
1848#endif
1849}
1850
1851}  // namespace art
1852