blob: b6e31345e11403812fc68d8657dcd0e234668586 [file] [log] [blame]
Narayan Kamath9823e782016-08-03 12:46:58 +01001/*
2 * Copyright (C) 2016 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#ifndef ART_RUNTIME_METHOD_HANDLES_H_
18#define ART_RUNTIME_METHOD_HANDLES_H_
19
20#include <ostream>
21
David Sehr9e734c72018-01-04 17:56:19 -080022#include "dex/dex_instruction.h"
Orion Hodsonba28f9f2016-10-26 10:56:25 +010023#include "handle.h"
Narayan Kamath208f8572016-08-03 12:46:58 +010024#include "jvalue.h"
Orion Hodsonba28f9f2016-10-26 10:56:25 +010025#include "mirror/class.h"
Narayan Kamath208f8572016-08-03 12:46:58 +010026
Narayan Kamath9823e782016-08-03 12:46:58 +010027namespace art {
28
Vladimir Marko6ec2a1b2018-05-22 15:33:48 +010029class ShadowFrame;
30
Narayan Kamath208f8572016-08-03 12:46:58 +010031namespace mirror {
Igor Murashkin2ffb7032017-11-08 13:35:21 -080032class MethodHandle;
33class MethodType;
Andreas Gampedeae7db2017-05-30 09:56:41 -070034} // namespace mirror
Narayan Kamath208f8572016-08-03 12:46:58 +010035
Orion Hodson1a06f9f2016-11-09 08:32:42 +000036// Returns true if there is a possible conversion from |from| to |to|
37// for a MethodHandle parameter.
38bool IsParameterTypeConvertible(ObjPtr<mirror::Class> from,
39 ObjPtr<mirror::Class> to);
40
41// Returns true if there is a possible conversion from |from| to |to|
42// for the return type of a MethodHandle.
43bool IsReturnTypeConvertible(ObjPtr<mirror::Class> from,
44 ObjPtr<mirror::Class> to);
45
Orion Hodsonba28f9f2016-10-26 10:56:25 +010046// Performs a conversion from type |from| to a distinct type |to| as
47// part of conversion of |caller_type| to |callee_type|. The value to
48// be converted is in |value|. Returns true on success and updates
49// |value| with the converted value, false otherwise.
50bool ConvertJValueCommon(Handle<mirror::MethodType> callsite_type,
51 Handle<mirror::MethodType> callee_type,
52 ObjPtr<mirror::Class> from,
53 ObjPtr<mirror::Class> to,
54 JValue* value)
55 REQUIRES_SHARED(Locks::mutator_lock_);
56
57// Converts the value of the argument at position |index| from type
58// expected by |callee_type| to type used by |callsite_type|. |value|
59// represents the value to be converted. Returns true on success and
60// updates |value|, false otherwise.
61ALWAYS_INLINE bool ConvertArgumentValue(Handle<mirror::MethodType> callsite_type,
62 Handle<mirror::MethodType> callee_type,
63 int index,
64 JValue* value)
65 REQUIRES_SHARED(Locks::mutator_lock_);
66
67// Converts the return value from return type yielded by
68// |callee_type| to the return type yielded by
69// |callsite_type|. |value| represents the value to be
70// converted. Returns true on success and updates |value|, false
71// otherwise.
72ALWAYS_INLINE bool ConvertReturnValue(Handle<mirror::MethodType> callsite_type,
73 Handle<mirror::MethodType> callee_type,
74 JValue* value)
75 REQUIRES_SHARED(Locks::mutator_lock_);
Narayan Kamathda246502016-10-20 18:39:22 +010076
Narayan Kamath208f8572016-08-03 12:46:58 +010077// Perform argument conversions between |callsite_type| (the type of the
78// incoming arguments) and |callee_type| (the type of the method being
79// invoked). These include widening and narrowing conversions as well as
80// boxing and unboxing. Returns true on success, on false on failure. A
81// pending exception will always be set on failure.
Narayan Kamath000e1882016-10-24 17:14:25 +010082//
83// The values to be converted are read from an input source (of type G)
84// that provides three methods :
85//
86// class G {
87// // Used to read the next boolean/short/int or float value from the
88// // source.
89// uint32_t Get();
90//
91// // Used to the read the next reference value from the source.
92// ObjPtr<mirror::Object> GetReference();
93//
94// // Used to read the next double or long value from the source.
95// int64_t GetLong();
96// }
97//
98// After conversion, the values are written to an output sink (of type S)
99// that provides three methods :
100//
101// class S {
102// void Set(uint32_t);
103// void SetReference(ObjPtr<mirror::Object>)
104// void SetLong(int64_t);
105// }
106//
107// The semantics and usage of the Set methods are analagous to the getter
108// class.
109//
110// This method is instantiated in three different scenarions :
111// - <S = ShadowFrameSetter, G = ShadowFrameGetter> : copying from shadow
112// frame to shadow frame, used in a regular polymorphic non-exact invoke.
113// - <S = EmulatedShadowFrameAccessor, G = ShadowFrameGetter> : entering into
114// a transformer method from a polymorphic invoke.
115// - <S = ShadowFrameStter, G = EmulatedStackFrameAccessor> : entering into
116// a regular poly morphic invoke from a transformer method.
117//
118// TODO(narayan): If we find that the instantiations of this function take
119// up too much space, we can make G / S abstract base classes that are
120// overridden by concrete classes.
121template <typename G, typename S>
Narayan Kamath000e1882016-10-24 17:14:25 +0100122bool PerformConversions(Thread* self,
Orion Hodsonba28f9f2016-10-26 10:56:25 +0100123 Handle<mirror::MethodType> callsite_type,
124 Handle<mirror::MethodType> callee_type,
Narayan Kamath000e1882016-10-24 17:14:25 +0100125 G* getter,
126 S* setter,
Orion Hodsonb8b93872018-01-30 07:51:10 +0000127 int32_t start_index,
128 int32_t end_index) REQUIRES_SHARED(Locks::mutator_lock_);
Narayan Kamath000e1882016-10-24 17:14:25 +0100129
Orion Hodson43f0cdb2017-10-10 14:47:32 +0100130bool MethodHandleInvoke(Thread* self,
131 ShadowFrame& shadow_frame,
132 Handle<mirror::MethodHandle> method_handle,
133 Handle<mirror::MethodType> callsite_type,
Orion Hodson960d4f72017-11-10 15:32:38 +0000134 const InstructionOperands* const args,
Orion Hodson43f0cdb2017-10-10 14:47:32 +0100135 JValue* result)
136 REQUIRES_SHARED(Locks::mutator_lock_);
137
Orion Hodson43f0cdb2017-10-10 14:47:32 +0100138bool MethodHandleInvokeExact(Thread* self,
139 ShadowFrame& shadow_frame,
140 Handle<mirror::MethodHandle> method_handle,
141 Handle<mirror::MethodType> callsite_type,
Orion Hodson960d4f72017-11-10 15:32:38 +0000142 const InstructionOperands* const args,
Orion Hodson43f0cdb2017-10-10 14:47:32 +0100143 JValue* result)
Orion Hodson811bd5f2016-12-07 11:35:37 +0000144 REQUIRES_SHARED(Locks::mutator_lock_);
145
Narayan Kamath9823e782016-08-03 12:46:58 +0100146} // namespace art
147
148#endif // ART_RUNTIME_METHOD_HANDLES_H_