portable_field_entrypoints.cc revision 7655f29fabc0a12765de828914a18314382e5a35 
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 "entrypoints/entrypoint_utils.h"
18#include "mirror/abstract_method-inl.h"
19#include "mirror/field-inl.h"
20#include "mirror/object-inl.h"
21
22namespace art {
23
24extern "C" int32_t art_portable_set32_static_from_code(uint32_t field_idx,
25                                                       mirror::AbstractMethod* referrer,
26                                                       int32_t new_value)
27    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
28  mirror::Field* field = FindFieldFast(field_idx,
29                               referrer,
30                               StaticPrimitiveWrite,
31                               sizeof(uint32_t));
32  if (LIKELY(field != NULL)) {
33    field->Set32(field->GetDeclaringClass(), new_value);
34    return 0;
35  }
36  field = FindFieldFromCode(field_idx,
37                            referrer,
38                            Thread::Current(),
39                            StaticPrimitiveWrite,
40                            sizeof(uint32_t),
41                            true);
42  if (LIKELY(field != NULL)) {
43    field->Set32(field->GetDeclaringClass(), new_value);
44    return 0;
45  }
46  return -1;
47}
48
49extern "C" int32_t art_portable_set64_static_from_code(uint32_t field_idx,
50                                                       mirror::AbstractMethod* referrer,
51                                                       int64_t new_value)
52    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
53  mirror::Field* field = FindFieldFast(field_idx, referrer, StaticPrimitiveWrite, sizeof(uint64_t));
54  if (LIKELY(field != NULL)) {
55    field->Set64(field->GetDeclaringClass(), new_value);
56    return 0;
57  }
58  field = FindFieldFromCode(field_idx,
59                            referrer,
60                            Thread::Current(),
61                            StaticPrimitiveWrite,
62                            sizeof(uint64_t),
63                            true);
64  if (LIKELY(field != NULL)) {
65    field->Set64(field->GetDeclaringClass(), new_value);
66    return 0;
67  }
68  return -1;
69}
70
71extern "C" int32_t art_portable_set_obj_static_from_code(uint32_t field_idx,
72                                                         mirror::AbstractMethod* referrer,
73                                                         mirror::Object* new_value)
74    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
75  mirror::Field* field = FindFieldFast(field_idx, referrer, StaticObjectWrite,
76                                       sizeof(mirror::Object*));
77  if (LIKELY(field != NULL)) {
78    field->SetObj(field->GetDeclaringClass(), new_value);
79    return 0;
80  }
81  field = FindFieldFromCode(field_idx, referrer, Thread::Current(),
82                            StaticObjectWrite, sizeof(mirror::Object*), true);
83  if (LIKELY(field != NULL)) {
84    field->SetObj(field->GetDeclaringClass(), new_value);
85    return 0;
86  }
87  return -1;
88}
89
90extern "C" int32_t art_portable_get32_static_from_code(uint32_t field_idx,
91                                                       mirror::AbstractMethod* referrer)
92    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
93  mirror::Field* field = FindFieldFast(field_idx, referrer, StaticPrimitiveRead, sizeof(uint32_t));
94  if (LIKELY(field != NULL)) {
95    return field->Get32(field->GetDeclaringClass());
96  }
97  field = FindFieldFromCode(field_idx, referrer, Thread::Current(),
98                            StaticPrimitiveRead, sizeof(uint32_t), true);
99  if (LIKELY(field != NULL)) {
100    return field->Get32(field->GetDeclaringClass());
101  }
102  return 0;
103}
104
105extern "C" int64_t art_portable_get64_static_from_code(uint32_t field_idx,
106                                                       mirror::AbstractMethod* referrer)
107    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
108  mirror::Field* field = FindFieldFast(field_idx, referrer, StaticPrimitiveRead, sizeof(uint64_t));
109  if (LIKELY(field != NULL)) {
110    return field->Get64(field->GetDeclaringClass());
111  }
112  field = FindFieldFromCode(field_idx, referrer, Thread::Current(),
113                            StaticPrimitiveRead, sizeof(uint64_t), true);
114  if (LIKELY(field != NULL)) {
115    return field->Get64(field->GetDeclaringClass());
116  }
117  return 0;
118}
119
120extern "C" mirror::Object* art_portable_get_obj_static_from_code(uint32_t field_idx,
121                                                                 mirror::AbstractMethod* referrer)
122    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
123  mirror::Field* field = FindFieldFast(field_idx, referrer, StaticObjectRead,
124                                       sizeof(mirror::Object*));
125  if (LIKELY(field != NULL)) {
126    return field->GetObj(field->GetDeclaringClass());
127  }
128  field = FindFieldFromCode(field_idx, referrer, Thread::Current(),
129                            StaticObjectRead, sizeof(mirror::Object*), true);
130  if (LIKELY(field != NULL)) {
131    return field->GetObj(field->GetDeclaringClass());
132  }
133  return 0;
134}
135
136extern "C" int32_t art_portable_set32_instance_from_code(uint32_t field_idx,
137                                                         mirror::AbstractMethod* referrer,
138                                                         mirror::Object* obj, uint32_t new_value)
139    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
140  mirror::Field* field = FindFieldFast(field_idx, referrer, InstancePrimitiveWrite, sizeof(uint32_t));
141  if (LIKELY(field != NULL)) {
142    field->Set32(obj, new_value);
143    return 0;
144  }
145  field = FindFieldFromCode(field_idx, referrer, Thread::Current(),
146                            InstancePrimitiveWrite, sizeof(uint32_t), true);
147  if (LIKELY(field != NULL)) {
148    field->Set32(obj, new_value);
149    return 0;
150  }
151  return -1;
152}
153
154extern "C" int32_t art_portable_set64_instance_from_code(uint32_t field_idx,
155                                                         mirror::AbstractMethod* referrer,
156                                                         mirror::Object* obj, int64_t new_value)
157    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
158  mirror::Field* field = FindFieldFast(field_idx, referrer, InstancePrimitiveWrite, sizeof(uint64_t));
159  if (LIKELY(field != NULL)) {
160    field->Set64(obj, new_value);
161    return 0;
162  }
163  field = FindFieldFromCode(field_idx, referrer, Thread::Current(),
164                            InstancePrimitiveWrite, sizeof(uint64_t), true);
165  if (LIKELY(field != NULL)) {
166    field->Set64(obj, new_value);
167    return 0;
168  }
169  return -1;
170}
171
172extern "C" int32_t art_portable_set_obj_instance_from_code(uint32_t field_idx,
173                                                           mirror::AbstractMethod* referrer,
174                                                           mirror::Object* obj,
175                                                           mirror::Object* new_value)
176    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
177  mirror::Field* field = FindFieldFast(field_idx, referrer, InstanceObjectWrite,
178                                       sizeof(mirror::Object*));
179  if (LIKELY(field != NULL)) {
180    field->SetObj(obj, new_value);
181    return 0;
182  }
183  field = FindFieldFromCode(field_idx, referrer, Thread::Current(),
184                            InstanceObjectWrite, sizeof(mirror::Object*), true);
185  if (LIKELY(field != NULL)) {
186    field->SetObj(obj, new_value);
187    return 0;
188  }
189  return -1;
190}
191
192extern "C" int32_t art_portable_get32_instance_from_code(uint32_t field_idx,
193                                                         mirror::AbstractMethod* referrer,
194                                                         mirror::Object* obj)
195    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
196  mirror::Field* field = FindFieldFast(field_idx, referrer, InstancePrimitiveRead, sizeof(uint32_t));
197  if (LIKELY(field != NULL)) {
198    return field->Get32(obj);
199  }
200  field = FindFieldFromCode(field_idx, referrer, Thread::Current(),
201                            InstancePrimitiveRead, sizeof(uint32_t), true);
202  if (LIKELY(field != NULL)) {
203    return field->Get32(obj);
204  }
205  return 0;
206}
207
208extern "C" int64_t art_portable_get64_instance_from_code(uint32_t field_idx,
209                                                         mirror::AbstractMethod* referrer,
210                                                         mirror::Object* obj)
211    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
212  mirror::Field* field = FindFieldFast(field_idx, referrer, InstancePrimitiveRead, sizeof(uint64_t));
213  if (LIKELY(field != NULL)) {
214    return field->Get64(obj);
215  }
216  field = FindFieldFromCode(field_idx, referrer, Thread::Current(),
217                            InstancePrimitiveRead, sizeof(uint64_t), true);
218  if (LIKELY(field != NULL)) {
219    return field->Get64(obj);
220  }
221  return 0;
222}
223
224extern "C" mirror::Object* art_portable_get_obj_instance_from_code(uint32_t field_idx,
225                                                                   mirror::AbstractMethod* referrer,
226                                                                   mirror::Object* obj)
227    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
228  mirror::Field* field = FindFieldFast(field_idx, referrer, InstanceObjectRead,
229                                       sizeof(mirror::Object*));
230  if (LIKELY(field != NULL)) {
231    return field->GetObj(obj);
232  }
233  field = FindFieldFromCode(field_idx, referrer, Thread::Current(),
234                            InstanceObjectRead, sizeof(mirror::Object*), true);
235  if (LIKELY(field != NULL)) {
236    return field->GetObj(obj);
237  }
238  return 0;
239}
240
241}  // namespace art
242