1 /* 2 * Copyright (c) 2017, 2019, Oracle and/or its affiliates. All rights reserved. 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 4 * 5 * This code is free software; you can redistribute it and/or modify it 6 * under the terms of the GNU General Public License version 2 only, as 7 * published by the Free Software Foundation. 8 * 9 * This code is distributed in the hope that it will be useful, but WITHOUT 10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 12 * version 2 for more details (a copy is included in the LICENSE file that 13 * accompanied this code). 14 * 15 * You should have received a copy of the GNU General Public License version 16 * 2 along with this work; if not, write to the Free Software Foundation, 17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 18 * 19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 20 * or visit www.oracle.com if you need additional information or have any 21 * questions. 22 * 23 */ 24 25 #include "precompiled.hpp" 26 #include "classfile/symbolTable.hpp" 27 #include "classfile/systemDictionary.hpp" 28 #include "jfr/jni/jfrJavaCall.hpp" 29 #include "jfr/jni/jfrJavaSupport.hpp" 30 #include "memory/resourceArea.hpp" 31 #include "runtime/handles.inline.hpp" 32 #include "runtime/javaCalls.hpp" 33 #include "utilities/globalDefinitions.hpp" 34 35 #ifdef ASSERT 36 static bool is_large_value(const JavaValue& value) { 37 return value.get_type() == T_LONG || value.get_type() == T_DOUBLE; 38 } 39 #endif // ASSERT 40 41 static Symbol* resolve(const char* str, TRAPS) { 42 assert(str != NULL, "invariant"); 43 return SymbolTable::lookup(str, (int)strlen(str), THREAD); 44 } 45 46 static Klass* resolve(Symbol* k_sym, TRAPS) { 47 assert(k_sym != NULL, "invariant"); 48 return SystemDictionary::resolve_or_fail(k_sym, true, THREAD); 49 } 50 51 JfrJavaArguments::Parameters::Parameters() : _storage_index(0), _java_stack_slots(0) { 52 JavaValue value(T_VOID); 53 push(value); 54 } 55 56 void JfrJavaArguments::Parameters::push(const JavaValue& value) { 57 assert(_storage != NULL, "invariant"); 58 assert(!is_large_value(value), "invariant"); 59 assert(_storage_index < SIZE, "invariant"); 60 _storage[_storage_index++] = value; 61 _java_stack_slots++; 62 } 63 64 void JfrJavaArguments::Parameters::push_large(const JavaValue& value) { 65 assert(_storage != NULL, "invariant"); 66 assert(is_large_value(value), "invariant"); 67 assert(_storage_index < SIZE, "invariant"); 68 _storage[_storage_index++] = value; 69 _java_stack_slots += 2; 70 } 71 72 void JfrJavaArguments::Parameters::set_receiver(const oop receiver) { 73 assert(_storage != NULL, "invariant"); 74 assert(receiver != NULL, "invariant"); 75 JavaValue value(T_OBJECT); 76 value.set_jobject((jobject)receiver); 77 _storage[0] = value; 78 } 79 80 void JfrJavaArguments::Parameters::set_receiver(Handle receiver) { 81 set_receiver(receiver()); 82 } 83 84 oop JfrJavaArguments::Parameters::receiver() const { 85 assert(has_receiver(), "invariant"); 86 assert(_storage[0].get_type() == T_OBJECT, "invariant"); 87 return (oop)_storage[0].get_jobject(); 88 } 89 90 bool JfrJavaArguments::Parameters::has_receiver() const { 91 assert(_storage != NULL, "invariant"); 92 assert(_storage_index >= 1, "invariant"); 93 assert(_java_stack_slots >= 1, "invariant"); 94 return _storage[0].get_type() == T_OBJECT; 95 } 96 97 void JfrJavaArguments::Parameters::push_oop(const oop obj) { 98 JavaValue value(T_OBJECT); 99 value.set_jobject((jobject)obj); 100 push(value); 101 } 102 103 void JfrJavaArguments::Parameters::push_oop(Handle h_obj) { 104 push_oop(h_obj()); 105 } 106 107 void JfrJavaArguments::Parameters::push_jobject(jobject h) { 108 JavaValue value(T_ADDRESS); 109 value.set_jobject(h); 110 push(value); 111 } 112 113 void JfrJavaArguments::Parameters::push_jint(jint i) { 114 JavaValue value(T_INT); 115 value.set_jint(i); 116 push(value); 117 } 118 119 void JfrJavaArguments::Parameters::push_jfloat(jfloat f) { 120 JavaValue value(T_FLOAT); 121 value.set_jfloat(f); 122 push(value); 123 } 124 125 void JfrJavaArguments::Parameters::push_jdouble(jdouble d) { 126 JavaValue value(T_DOUBLE); 127 value.set_jdouble(d); 128 push_large(value); 129 } 130 131 void JfrJavaArguments::Parameters::push_jlong(jlong l) { 132 JavaValue value(T_LONG); 133 value.set_jlong(l); 134 push_large(value); 135 } 136 137 // including receiver (even if there is none) 138 inline int JfrJavaArguments::Parameters::length() const { 139 assert(_storage_index >= 1, "invariant"); 140 return _storage_index; 141 } 142 143 inline int JfrJavaArguments::Parameters::java_stack_slots() const { 144 return _java_stack_slots; 145 } 146 147 const JavaValue& JfrJavaArguments::Parameters::values(int idx) const { 148 assert(idx >= 0, "invariant"); 149 assert(idx < SIZE, "invariant"); 150 return _storage[idx]; 151 } 152 153 void JfrJavaArguments::Parameters::copy(JavaCallArguments& args, TRAPS) const { 154 DEBUG_ONLY(JfrJavaSupport::check_java_thread_in_vm(THREAD)); 155 if (has_receiver()) { 156 args.set_receiver(Handle(THREAD, receiver())); 157 } 158 for (int i = 1; i < length(); ++i) { 159 switch(values(i).get_type()) { 160 case T_BOOLEAN: 161 case T_CHAR: 162 case T_SHORT: 163 case T_INT: 164 args.push_int(values(i).get_jint()); 165 break; 166 case T_LONG: 167 args.push_long(values(i).get_jlong()); 168 break; 169 case T_FLOAT: 170 args.push_float(values(i).get_jfloat()); 171 break; 172 case T_DOUBLE: 173 args.push_double(values(i).get_jdouble()); 174 break; 175 case T_OBJECT: 176 args.push_oop(Handle(THREAD, (oop)values(i).get_jobject())); 177 break; 178 case T_ADDRESS: 179 args.push_jobject(values(i).get_jobject()); 180 break; 181 default: 182 ShouldNotReachHere(); 183 } 184 } 185 } 186 187 JfrJavaArguments::JfrJavaArguments(JavaValue* result) : _result(result), _klass(NULL), _name(NULL), _signature(NULL), _array_length(0) { 188 assert(result != NULL, "invariant"); 189 } 190 191 JfrJavaArguments::JfrJavaArguments(JavaValue* result, const char* klass_name, const char* name, const char* signature, TRAPS) : 192 _result(result), 193 _klass(NULL), 194 _name(NULL), 195 _signature(NULL), 196 _array_length(0) { 197 assert(result != NULL, "invariant"); 198 if (klass_name != NULL) { 199 set_klass(klass_name, CHECK); 200 } 201 if (name != NULL) { 202 set_name(name, CHECK); 203 } 204 if (signature != NULL) { 205 set_signature(signature, THREAD); 206 } 207 } 208 209 JfrJavaArguments::JfrJavaArguments(JavaValue* result, const Klass* klass, const Symbol* name, const Symbol* signature) : _result(result), 210 _klass(NULL), 211 _name(NULL), 212 _signature(NULL), 213 _array_length(0) { 214 assert(result != NULL, "invariant"); 215 if (klass != NULL) { 216 set_klass(klass); 217 } 218 if (name != NULL) { 219 set_name(name); 220 } 221 if (signature != NULL) { 222 set_signature(signature); 223 } 224 } 225 226 Klass* JfrJavaArguments::klass() const { 227 assert(_klass != NULL, "invariant"); 228 return const_cast<Klass*>(_klass); 229 } 230 231 void JfrJavaArguments::set_klass(const char* klass_name, TRAPS) { 232 assert(klass_name != NULL, "invariant"); 233 Symbol* const k_sym = resolve(klass_name, CHECK); 234 assert(k_sym != NULL, "invariant"); 235 const Klass* const klass = resolve(k_sym, CHECK); 236 set_klass(klass); 237 } 238 239 void JfrJavaArguments::set_klass(const Klass* klass) { 240 assert(klass != NULL, "invariant"); 241 _klass = klass; 242 } 243 244 Symbol* JfrJavaArguments::name() const { 245 assert(_name != NULL, "invariant"); 246 return const_cast<Symbol*>(_name); 247 } 248 249 void JfrJavaArguments::set_name(const char* name, TRAPS) { 250 assert(name != NULL, "invariant"); 251 const Symbol* const sym = resolve(name, CHECK); 252 set_name(sym); 253 } 254 255 void JfrJavaArguments::set_name(const Symbol* name) { 256 assert(name != NULL, "invariant"); 257 _name = name; 258 } 259 260 Symbol* JfrJavaArguments::signature() const { 261 assert(_signature != NULL, "invariant"); 262 return const_cast<Symbol*>(_signature); 263 } 264 265 void JfrJavaArguments::set_signature(const char* signature, TRAPS) { 266 assert(signature != NULL, "invariant"); 267 const Symbol* const sym = resolve(signature, CHECK); 268 set_signature(sym); 269 } 270 271 void JfrJavaArguments::set_signature(const Symbol* signature) { 272 assert(signature != NULL, "invariant"); 273 _signature = signature; 274 } 275 276 int JfrJavaArguments::array_length() const { 277 return _array_length; 278 } 279 280 void JfrJavaArguments::set_array_length(int length) { 281 assert(length >= 0, "invariant"); 282 _array_length = length; 283 } 284 285 JavaValue* JfrJavaArguments::result() const { 286 assert(_result != NULL, "invariant"); 287 return const_cast<JavaValue*>(_result); 288 } 289 290 int JfrJavaArguments::length() const { 291 return _params.length(); 292 } 293 294 bool JfrJavaArguments::has_receiver() const { 295 return _params.has_receiver(); 296 } 297 298 oop JfrJavaArguments::receiver() const { 299 return _params.receiver(); 300 } 301 302 void JfrJavaArguments::set_receiver(const oop receiver) { 303 _params.set_receiver(receiver); 304 } 305 306 void JfrJavaArguments::set_receiver(Handle receiver) { 307 _params.set_receiver(receiver); 308 } 309 310 void JfrJavaArguments::push_oop(const oop obj) { 311 _params.push_oop(obj); 312 } 313 314 void JfrJavaArguments::push_oop(Handle h_obj) { 315 _params.push_oop(h_obj); 316 } 317 318 void JfrJavaArguments::push_jobject(jobject h) { 319 _params.push_jobject(h); 320 } 321 322 void JfrJavaArguments::push_int(jint i) { 323 _params.push_jint(i); 324 } 325 326 void JfrJavaArguments::push_float(jfloat f) { 327 _params.push_jfloat(f); 328 } 329 330 void JfrJavaArguments::push_double(jdouble d) { 331 _params.push_jdouble(d); 332 } 333 334 void JfrJavaArguments::push_long(jlong l) { 335 _params.push_jlong(l); 336 } 337 338 const JavaValue& JfrJavaArguments::param(int idx) const { 339 return _params.values(idx); 340 } 341 342 int JfrJavaArguments::java_call_arg_slots() const { 343 return _params.java_stack_slots(); 344 } 345 346 void JfrJavaArguments::copy(JavaCallArguments& args, TRAPS) { 347 _params.copy(args, THREAD); 348 } 349 350 void JfrJavaCall::call_static(JfrJavaArguments* args, TRAPS) { 351 assert(args != NULL, "invariant"); 352 DEBUG_ONLY(JfrJavaSupport::check_java_thread_in_vm(THREAD)); 353 ResourceMark rm(THREAD); 354 HandleMark hm(THREAD); 355 JavaCallArguments jcas(args->java_call_arg_slots()); 356 args->copy(jcas, CHECK); 357 JavaCalls::call_static(args->result(), args->klass(), args->name(), args->signature(), &jcas, THREAD); 358 } 359 360 void JfrJavaCall::call_special(JfrJavaArguments* args, TRAPS) { 361 assert(args != NULL, "invariant"); 362 assert(args->has_receiver(), "invariant"); 363 DEBUG_ONLY(JfrJavaSupport::check_java_thread_in_vm(THREAD)); 364 ResourceMark rm(THREAD); 365 HandleMark hm(THREAD); 366 JavaCallArguments jcas(args->java_call_arg_slots()); 367 args->copy(jcas, CHECK); 368 JavaCalls::call_special(args->result(), args->klass(), args->name(), args->signature(), &jcas, THREAD); 369 } 370 371 void JfrJavaCall::call_virtual(JfrJavaArguments* args, TRAPS) { 372 assert(args != NULL, "invariant"); 373 assert(args->has_receiver(), "invariant"); 374 DEBUG_ONLY(JfrJavaSupport::check_java_thread_in_vm(THREAD)); 375 ResourceMark rm(THREAD); 376 HandleMark hm(THREAD); 377 JavaCallArguments jcas(args->java_call_arg_slots()); 378 args->copy(jcas, CHECK); 379 JavaCalls::call_virtual(args->result(), args->klass(), args->name(), args->signature(), &jcas, THREAD); 380 }