1 /* 2 * Copyright (c) 2019, 2023, Oracle and/or its affiliates. All rights reserved. 3 * Copyright (c) 2019 SAP SE. All rights reserved. 4 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 5 * 6 * This code is free software; you can redistribute it and/or modify it 7 * under the terms of the GNU General Public License version 2 only, as 8 * published by the Free Software Foundation. 9 * 10 * This code is distributed in the hope that it will be useful, but WITHOUT 11 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 12 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 13 * version 2 for more details (a copy is included in the LICENSE file that 14 * accompanied this code). 15 * 16 * You should have received a copy of the GNU General Public License version 17 * 2 along with this work; if not, write to the Free Software Foundation, 18 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 19 * 20 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 21 * or visit www.oracle.com if you need additional information or have any 22 * questions. 23 * 24 */ 25 26 #include "precompiled.hpp" 27 #include "classfile/vmClasses.hpp" 28 #include "classfile/vmSymbols.hpp" 29 #include "gc/shared/gcLocker.hpp" 30 #include "interpreter/bytecodeUtils.hpp" 31 #include "memory/resourceArea.hpp" 32 #include "runtime/signature.hpp" 33 #include "runtime/safepointVerifiers.hpp" 34 #include "utilities/events.hpp" 35 #include "utilities/ostream.hpp" 36 37 class SimulatedOperandStack; 38 class ExceptionMessageBuilder; 39 40 // The entries of a SimulatedOperandStack. They carry the analysis 41 // information gathered for the slot. 42 class StackSlotAnalysisData { 43 private: 44 45 friend class SimulatedOperandStack; 46 friend class ExceptionMessageBuilder; 47 48 unsigned int _bci:17; // The bci of the bytecode that pushed the current value on the operand stack. 49 // INVALID if ambiguous, e.g. after a control flow merge. 50 // 16 bits for bci (max bytecode size) and one for INVALID. 51 unsigned int _type:15; // The BasicType of the value on the operand stack. 52 53 // Merges this slot data with the given one and returns the result. If 54 // the bcis of the two merged objects are different, the bci of the result 55 // will be undefined. If the types are different, the result type is T_CONFLICT. 56 // (An exception is if one type is an array and the other is object, then 57 // the result type will be T_OBJECT). 58 StackSlotAnalysisData merge(StackSlotAnalysisData other); 59 60 public: 61 62 // Creates a new object with an invalid bci and the given type. 63 StackSlotAnalysisData(BasicType type = T_CONFLICT); 64 65 // Creates a new object with the given bci and type. 66 StackSlotAnalysisData(int bci, BasicType type); 67 68 enum { 69 // An invalid bytecode index, as > 65535. 70 INVALID = 0x1FFFF 71 }; 72 73 // Returns the bci. If the bci is invalid, INVALID is returned. 74 unsigned int get_bci(); 75 76 // Returns true, if the bci is not invalid. 77 bool has_bci() { return get_bci() != INVALID; } 78 79 // Returns the type of the slot data. 80 BasicType get_type(); 81 }; 82 83 // A stack consisting of SimulatedOperandStackEntries. 84 // This represents the analysis information for the operand stack 85 // for a given bytecode at a given bci. 86 // It also holds an additional field that serves to collect 87 // information whether local slots were written. 88 class SimulatedOperandStack: CHeapObj<mtInternal> { 89 90 private: 91 92 friend class ExceptionMessageBuilder; 93 friend class StackSlotAnalysisData; 94 95 // The stack. 96 GrowableArray<StackSlotAnalysisData> _stack; 97 98 // Optimized bytecode can reuse local variable slots for several 99 // local variables. 100 // If there is no variable name information, we print 'parameter<i>' 101 // if a parameter maps to a local slot. Once a local slot has been 102 // written, we don't know any more whether it was written as the 103 // corresponding parameter, or whether another local has been 104 // mapped to the slot. So we don't want to print 'parameter<i>' any 105 // more, but 'local<i>'. Similarly for 'this'. 106 // Therefore, during the analysis, we mark a bit for local slots that 107 // get written and propagate this information. 108 // We only run the analysis for 64 slots. If a method has more 109 // parameters, we print 'local<i>' in all cases. 110 uint64_t _written_local_slots; 111 112 SimulatedOperandStack(): _written_local_slots(0) { }; 113 SimulatedOperandStack(const SimulatedOperandStack ©); 114 115 // Pushes the given slot data. 116 void push_raw(StackSlotAnalysisData slotData); 117 118 // Like push_raw, but if the slotData has type long or double, we push two. 119 void push(StackSlotAnalysisData slotData); 120 121 // Like push(slotData), but using bci/type to create an instance of 122 // StackSlotAnalysisData first. 123 void push(int bci, BasicType type); 124 125 // Pops the given number of entries. 126 void pop(int slots); 127 128 // Merges this with the given stack by merging all entries. The 129 // size of the stacks must be the same. 130 void merge(SimulatedOperandStack const& other); 131 132 public: 133 134 // Returns the size of the stack. 135 int get_size() const; 136 137 // Returns the slot data at the given index. Slot 0 is top of stack. 138 StackSlotAnalysisData get_slot_data(int slot); 139 140 // Mark that local slot i was written. 141 void set_local_slot_written(int i); 142 143 // Check whether local slot i was written by this or a previous bytecode. 144 bool local_slot_was_written(int i); 145 }; 146 147 // Helper class to build internal exception messages for exceptions 148 // that are thrown because prerequisites to execute a bytecode 149 // are not met. 150 // E.g., if a NPE is thrown because an iload can not be executed 151 // by the VM because the reference to load from is null. 152 // 153 // It analyses the bytecode to assemble Java-like message text 154 // to give precise information where in a larger expression the 155 // exception occurred. 156 // 157 // To assemble this message text, it is needed to know how 158 // operand stack slot entries were pushed on the operand stack. 159 // This class contains an analysis over the bytecodes to compute 160 // this information. The information is stored in a 161 // SimulatedOperandStack for each bytecode. 162 class ExceptionMessageBuilder : public StackObj { 163 164 // The stacks for each bytecode. 165 GrowableArray<SimulatedOperandStack*>* _stacks; 166 167 // The method. 168 Method* _method; 169 170 // The number of entries used (the sum of all entries of all stacks). 171 int _nr_of_entries; 172 173 // If true, we have added at least one new stack. 174 bool _added_one; 175 176 // If true, we have processed all bytecodes. 177 bool _all_processed; 178 179 // The maximum number of entries we want to use. This is used to 180 // limit the amount of memory we waste for insane methods (as they 181 // appear in JCK tests). 182 static const int _max_entries = 1000000; 183 184 static const int _max_cause_detail = 5; 185 186 // Merges the stack at the given bci with the given stack. If there 187 // is no stack at the bci, we just put the given stack there. This 188 // method doesn't takes ownership of the stack. 189 void merge(int bci, SimulatedOperandStack* stack); 190 191 // Processes the instruction at the given bci in the method. Returns 192 // the size of the instruction. 193 int do_instruction(int bci); 194 195 bool print_NPE_cause0(outputStream *os, int bci, int slot, int max_detail, 196 bool inner_expr = false, const char *prefix = nullptr); 197 198 public: 199 200 // Creates an ExceptionMessageBuilder object and runs the analysis 201 // building SimulatedOperandStacks for each bytecode in the given 202 // method (the method must be rewritten already). Note that you're 203 // not allowed to use this object when crossing a safepoint! If the 204 // bci is != -1, we only create the stacks as far as needed to get a 205 // stack for the bci. 206 ExceptionMessageBuilder(Method* method, int bci = -1); 207 208 // Releases the resources. 209 ~ExceptionMessageBuilder(); 210 211 // Returns the number of stacks (this is the size of the method). 212 int get_size() { return _stacks->length() - 1; } 213 214 // Assuming that a NullPointerException was thrown at the given bci, 215 // we return the nr of the slot holding the null reference. If this 216 // NPE is created by hand, we return -2 as the slot. If there 217 // cannot be a NullPointerException at the bci, -1 is returned. 218 int get_NPE_null_slot(int bci); 219 220 // Prints a java-like expression for the bytecode that pushed 221 // the value to the given slot being live at the given bci. 222 // It constructs the expression by recursing backwards over the 223 // bytecode using the results of the analysis done in the 224 // constructor of ExceptionMessageBuilder. 225 // os: The stream to print the message to. 226 // bci: The index of the bytecode that caused the NPE. 227 // slot: The slot on the operand stack that contains null. 228 // The slots are numbered from TOS downwards, i.e., 229 // TOS has the slot number 0, that below 1 and so on. 230 // 231 // Returns false if nothing was printed, else true. 232 bool print_NPE_cause(outputStream *os, int bci, int slot); 233 234 // Prints a string describing the failed action. 235 void print_NPE_failed_action(outputStream *os, int bci); 236 }; 237 238 // Replaces the following well-known class names: 239 // java.lang.Object -> Object 240 // java.lang.String -> String 241 static char *trim_well_known_class_names_from_signature(char *signature) { 242 size_t len = strlen(signature); 243 size_t skip_len = strlen("java.lang."); 244 size_t min_pattern_len = strlen("java.lang.String"); 245 if (len < min_pattern_len) return signature; 246 247 for (size_t isrc = 0, idst = 0; isrc <= len; isrc++, idst++) { 248 // We must be careful not to trim names like test.java.lang.String. 249 if ((isrc == 0 && strncmp(signature + isrc, "java.lang.Object", min_pattern_len) == 0) || 250 (isrc == 0 && strncmp(signature + isrc, "java.lang.String", min_pattern_len) == 0) || 251 (isrc > 1 && strncmp(signature + isrc-2, ", java.lang.Object", min_pattern_len+2) == 0) || 252 (isrc > 1 && strncmp(signature + isrc-2, ", java.lang.String", min_pattern_len+2) == 0) ) { 253 isrc += skip_len; 254 } 255 if (idst != isrc) { 256 signature[idst] = signature[isrc]; 257 } 258 } 259 return signature; 260 } 261 262 // Replaces the following well-known class names: 263 // java.lang.Object -> Object 264 // java.lang.String -> String 265 static void print_klass_name(outputStream *os, Symbol *klass) { 266 const char *name = klass->as_klass_external_name(); 267 if (strcmp(name, "java.lang.Object") == 0) name = "Object"; 268 if (strcmp(name, "java.lang.String") == 0) name = "String"; 269 os->print("%s", name); 270 } 271 272 // Prints the name of the method that is described at constant pool 273 // index cp_index in the constant pool of method 'method'. 274 static void print_method_name(outputStream *os, Method* method, int cp_index, Bytecodes::Code bc) { 275 ResourceMark rm; 276 ConstantPool* cp = method->constants(); 277 Symbol* klass = cp->klass_ref_at_noresolve(cp_index, bc); 278 Symbol* name = cp->name_ref_at(cp_index, bc); 279 Symbol* signature = cp->signature_ref_at(cp_index, bc); 280 281 print_klass_name(os, klass); 282 os->print(".%s(", name->as_C_string()); 283 stringStream sig; 284 signature->print_as_signature_external_parameters(&sig); 285 os->print("%s)", trim_well_known_class_names_from_signature(sig.as_string())); 286 } 287 288 // Prints the name of the field that is described at constant pool 289 // index cp_index in the constant pool of method 'method'. 290 static void print_field_and_class(outputStream *os, Method* method, int cp_index, Bytecodes::Code bc) { 291 ResourceMark rm; 292 ConstantPool* cp = method->constants(); 293 Symbol* klass = cp->klass_ref_at_noresolve(cp_index, bc); 294 Symbol *name = cp->name_ref_at(cp_index, bc); 295 print_klass_name(os, klass); 296 os->print(".%s", name->as_C_string()); 297 } 298 299 // Returns the name of the field that is described at constant pool 300 // index cp_index in the constant pool of method 'method'. 301 static char const* get_field_name(Method* method, int cp_index, Bytecodes::Code bc) { 302 Symbol* name = method->constants()->name_ref_at(cp_index, bc); 303 return name->as_C_string(); 304 } 305 306 static void print_local_var(outputStream *os, unsigned int bci, Method* method, int slot, bool is_parameter) { 307 if (method->has_localvariable_table()) { 308 for (int i = 0; i < method->localvariable_table_length(); i++) { 309 LocalVariableTableElement* elem = method->localvariable_table_start() + i; 310 unsigned int start = elem->start_bci; 311 unsigned int end = start + elem->length; 312 313 if ((bci >= start) && (bci < end) && (elem->slot == slot)) { 314 ConstantPool* cp = method->constants(); 315 char *var = cp->symbol_at(elem->name_cp_index)->as_C_string(); 316 os->print("%s", var); 317 318 return; 319 } 320 } 321 } 322 323 // Handle at least some cases we know. 324 if (!method->is_static() && (slot == 0) && is_parameter) { 325 os->print("this"); 326 } else { 327 int curr = method->is_static() ? 0 : 1; 328 SignatureStream ss(method->signature()); 329 int param_index = 1; 330 bool found = false; 331 332 for (SignatureStream ss(method->signature()); !ss.is_done(); ss.next()) { 333 if (ss.at_return_type()) { 334 continue; 335 } 336 int size = type2size[ss.type()]; 337 if ((slot >= curr) && (slot < curr + size)) { 338 found = true; 339 break; 340 } 341 param_index += 1; 342 curr += size; 343 } 344 345 if (found && is_parameter) { 346 os->print("<parameter%d>", param_index); 347 } else { 348 // This is the best we can do. 349 os->print("<local%d>", slot); 350 } 351 } 352 } 353 354 StackSlotAnalysisData::StackSlotAnalysisData(BasicType type) : _bci(INVALID), _type(type) {} 355 356 StackSlotAnalysisData::StackSlotAnalysisData(int bci, BasicType type) : _bci((u2)bci), _type(type) { 357 assert(bci >= 0, "BCI must be >= 0"); 358 assert(bci < 65536, "BCI must be < 65536"); 359 } 360 361 unsigned int StackSlotAnalysisData::get_bci() { 362 return _bci; 363 } 364 365 BasicType StackSlotAnalysisData::get_type() { 366 return (BasicType)_type; 367 } 368 369 StackSlotAnalysisData StackSlotAnalysisData::merge(StackSlotAnalysisData other) { 370 if (get_type() != other.get_type()) { 371 if (((get_type() == T_OBJECT) || (get_type() == T_ARRAY)) && 372 ((other.get_type() == T_OBJECT) || (other.get_type() == T_ARRAY))) { 373 if (get_bci() == other.get_bci()) { 374 return StackSlotAnalysisData(get_bci(), T_OBJECT); 375 } else { 376 return StackSlotAnalysisData(T_OBJECT); 377 } 378 } else { 379 return StackSlotAnalysisData(T_CONFLICT); 380 } 381 } 382 383 if (get_bci() == other.get_bci()) { 384 return *this; 385 } else { 386 return StackSlotAnalysisData(get_type()); 387 } 388 } 389 390 SimulatedOperandStack::SimulatedOperandStack(const SimulatedOperandStack ©) { 391 for (int i = 0; i < copy.get_size(); i++) { 392 push_raw(copy._stack.at(i)); 393 } 394 _written_local_slots = copy._written_local_slots; 395 } 396 397 void SimulatedOperandStack::push_raw(StackSlotAnalysisData slotData) { 398 if (slotData.get_type() == T_VOID) { 399 return; 400 } 401 402 _stack.push(slotData); 403 } 404 405 void SimulatedOperandStack::push(StackSlotAnalysisData slotData) { 406 if (type2size[slotData.get_type()] == 2) { 407 push_raw(slotData); 408 push_raw(slotData); 409 } else { 410 push_raw(slotData); 411 } 412 } 413 414 void SimulatedOperandStack::push(int bci, BasicType type) { 415 push(StackSlotAnalysisData(bci, type)); 416 } 417 418 void SimulatedOperandStack::pop(int slots) { 419 for (int i = 0; i < slots; ++i) { 420 _stack.pop(); 421 } 422 423 assert(get_size() >= 0, "Popped too many slots"); 424 } 425 426 void SimulatedOperandStack::merge(SimulatedOperandStack const& other) { 427 assert(get_size() == other.get_size(), "Stacks not of same size"); 428 429 for (int i = get_size() - 1; i >= 0; --i) { 430 _stack.at_put(i, _stack.at(i).merge(other._stack.at(i))); 431 } 432 _written_local_slots = _written_local_slots | other._written_local_slots; 433 } 434 435 int SimulatedOperandStack::get_size() const { 436 return _stack.length(); 437 } 438 439 StackSlotAnalysisData SimulatedOperandStack::get_slot_data(int slot) { 440 assert(slot >= 0, "Slot=%d < 0", slot); 441 assert(slot < get_size(), "Slot=%d >= size=%d", slot, get_size()); 442 443 return _stack.at(get_size() - slot - 1); 444 } 445 446 void SimulatedOperandStack::set_local_slot_written(int i) { 447 // Local slots > 63 are very unlikely. Consider these 448 // as written all the time. Saves space and complexity 449 // for dynamic data size. 450 if (i > 63) return; 451 _written_local_slots = _written_local_slots | (1ULL << i); 452 } 453 454 bool SimulatedOperandStack::local_slot_was_written(int i) { 455 if (i > 63) return true; 456 return (_written_local_slots & (1ULL << i)) != 0; 457 } 458 459 ExceptionMessageBuilder::ExceptionMessageBuilder(Method* method, int bci) : 460 _method(method), _nr_of_entries(0), 461 _added_one(true), _all_processed(false) { 462 463 ConstMethod* const_method = method->constMethod(); 464 const int len = const_method->code_size(); 465 466 assert(bci >= 0, "BCI too low: %d", bci); 467 assert(bci < len, "BCI too large: %d size: %d", bci, len); 468 469 _stacks = new GrowableArray<SimulatedOperandStack*> (len + 1); 470 471 for (int i = 0; i <= len; ++i) { 472 _stacks->push(nullptr); 473 } 474 475 // Initialize stack a bci 0. 476 _stacks->at_put(0, new SimulatedOperandStack()); 477 478 // And initialize the start of all exception handlers. 479 if (const_method->has_exception_table()) { 480 ExceptionTableElement *et = const_method->exception_table_start(); 481 for (int i = 0; i < const_method->exception_table_length(); ++i) { 482 u2 index = et[i].handler_pc; 483 484 if (_stacks->at(index) == nullptr) { 485 _stacks->at_put(index, new SimulatedOperandStack()); 486 _stacks->at(index)->push(index, T_OBJECT); 487 } 488 } 489 } 490 491 // Do this until each bytecode has a stack or we haven't 492 // added a new stack in one iteration. 493 while (!_all_processed && _added_one) { 494 _all_processed = true; 495 _added_one = false; 496 497 for (int i = 0; i < len; ) { 498 // Analyse bytecode i. Step by size of the analyzed bytecode to next bytecode. 499 i += do_instruction(i); 500 501 // If we want the data only for a certain bci, we can possibly end early. 502 if ((bci == i) && (_stacks->at(i) != nullptr)) { 503 _all_processed = true; 504 break; 505 } 506 507 if (_nr_of_entries > _max_entries) { 508 return; 509 } 510 } 511 } 512 } 513 514 ExceptionMessageBuilder::~ExceptionMessageBuilder() { 515 if (_stacks != nullptr) { 516 for (int i = 0; i < _stacks->length(); ++i) { 517 delete _stacks->at(i); 518 } 519 } 520 } 521 522 void ExceptionMessageBuilder::merge(int bci, SimulatedOperandStack* stack) { 523 assert(stack != _stacks->at(bci), "Cannot merge itself"); 524 525 if (_stacks->at(bci) != nullptr) { 526 stack->merge(*_stacks->at(bci)); 527 } else { 528 // Got a new stack, so count the entries. 529 _nr_of_entries += stack->get_size(); 530 } 531 532 // Replace the stack at this bci with a copy of our new merged stack. 533 delete _stacks->at(bci); 534 _stacks->at_put(bci, new SimulatedOperandStack(*stack)); 535 } 536 537 int ExceptionMessageBuilder::do_instruction(int bci) { 538 ConstMethod* const_method = _method->constMethod(); 539 address code_base = _method->constMethod()->code_base(); 540 541 // We use the java code, since we don't want to cope with all the fast variants. 542 int len = Bytecodes::java_length_at(_method, code_base + bci); 543 544 // If we have no stack for this bci, we cannot process the bytecode now. 545 if (_stacks->at(bci) == nullptr) { 546 _all_processed = false; 547 return len; 548 } 549 550 // Make a local copy of the stack for this bci to work on. 551 SimulatedOperandStack* stack = new SimulatedOperandStack(*_stacks->at(bci)); 552 553 // dest_bci is != -1 if we branch. 554 int dest_bci = -1; 555 556 // This is for table and lookup switch. 557 static const int initial_length = 2; 558 GrowableArray<int> dests(initial_length); 559 560 bool flow_ended = false; 561 562 // Get the bytecode. 563 bool is_wide = false; 564 Bytecodes::Code raw_code = Bytecodes::code_at(_method, code_base + bci); 565 Bytecodes::Code code = Bytecodes::java_code_at(_method, code_base + bci); 566 int pos = bci + 1; 567 568 if (code == Bytecodes::_wide) { 569 is_wide = true; 570 code = Bytecodes::java_code_at(_method, code_base + bci + 1); 571 pos += 1; 572 } 573 574 // Now simulate the action of each bytecode. 575 switch (code) { 576 case Bytecodes::_nop: 577 case Bytecodes::_aconst_null: 578 case Bytecodes::_iconst_m1: 579 case Bytecodes::_iconst_0: 580 case Bytecodes::_iconst_1: 581 case Bytecodes::_iconst_2: 582 case Bytecodes::_iconst_3: 583 case Bytecodes::_iconst_4: 584 case Bytecodes::_iconst_5: 585 case Bytecodes::_lconst_0: 586 case Bytecodes::_lconst_1: 587 case Bytecodes::_fconst_0: 588 case Bytecodes::_fconst_1: 589 case Bytecodes::_fconst_2: 590 case Bytecodes::_dconst_0: 591 case Bytecodes::_dconst_1: 592 case Bytecodes::_bipush: 593 case Bytecodes::_sipush: 594 case Bytecodes::_iload: 595 case Bytecodes::_lload: 596 case Bytecodes::_fload: 597 case Bytecodes::_dload: 598 case Bytecodes::_aload: 599 case Bytecodes::_iload_0: 600 case Bytecodes::_iload_1: 601 case Bytecodes::_iload_2: 602 case Bytecodes::_iload_3: 603 case Bytecodes::_lload_0: 604 case Bytecodes::_lload_1: 605 case Bytecodes::_lload_2: 606 case Bytecodes::_lload_3: 607 case Bytecodes::_fload_0: 608 case Bytecodes::_fload_1: 609 case Bytecodes::_fload_2: 610 case Bytecodes::_fload_3: 611 case Bytecodes::_dload_0: 612 case Bytecodes::_dload_1: 613 case Bytecodes::_dload_2: 614 case Bytecodes::_dload_3: 615 case Bytecodes::_aload_0: 616 case Bytecodes::_aload_1: 617 case Bytecodes::_aload_2: 618 case Bytecodes::_aload_3: 619 case Bytecodes::_iinc: 620 case Bytecodes::_new: 621 stack->push(bci, Bytecodes::result_type(code)); 622 break; 623 624 case Bytecodes::_ldc: 625 case Bytecodes::_ldc_w: 626 case Bytecodes::_ldc2_w: { 627 int cp_index; 628 ConstantPool* cp = _method->constants(); 629 630 if (code == Bytecodes::_ldc) { 631 cp_index = *(uint8_t*) (code_base + pos); 632 633 if (raw_code == Bytecodes::_fast_aldc) { 634 cp_index = cp->object_to_cp_index(cp_index); 635 } 636 } else { 637 if (raw_code == Bytecodes::_fast_aldc_w) { 638 cp_index = Bytes::get_native_u2(code_base + pos); 639 cp_index = cp->object_to_cp_index(cp_index); 640 } 641 else { 642 cp_index = Bytes::get_Java_u2(code_base + pos); 643 } 644 } 645 646 constantTag tag = cp->constant_tag_at(cp_index); 647 if (tag.is_klass() || tag.is_unresolved_klass() || 648 tag.is_method() || tag.is_interface_method() || 649 tag.is_field() || tag.is_string()) { 650 stack->push(bci, T_OBJECT); 651 } else if (tag.is_int()) { 652 stack->push(bci, T_INT); 653 } else if (tag.is_long()) { 654 stack->push(bci, T_LONG); 655 } else if (tag.is_float()) { 656 stack->push(bci, T_FLOAT); 657 } else if (tag.is_double()) { 658 stack->push(bci, T_DOUBLE); 659 } else { 660 assert(false, "Unexpected tag"); 661 } 662 break; 663 } 664 665 case Bytecodes::_iaload: 666 case Bytecodes::_faload: 667 case Bytecodes::_aaload: 668 case Bytecodes::_baload: 669 case Bytecodes::_caload: 670 case Bytecodes::_saload: 671 case Bytecodes::_laload: 672 case Bytecodes::_daload: 673 stack->pop(2); 674 stack->push(bci, Bytecodes::result_type(code)); 675 break; 676 677 case Bytecodes::_istore: 678 case Bytecodes::_lstore: 679 case Bytecodes::_fstore: 680 case Bytecodes::_dstore: 681 case Bytecodes::_astore: 682 int index; 683 if (is_wide) { 684 index = Bytes::get_Java_u2(code_base + bci + 2); 685 } else { 686 index = *(uint8_t*) (code_base + bci + 1); 687 } 688 stack->set_local_slot_written(index); 689 stack->pop(-Bytecodes::depth(code)); 690 break; 691 case Bytecodes::_istore_0: 692 case Bytecodes::_lstore_0: 693 case Bytecodes::_fstore_0: 694 case Bytecodes::_dstore_0: 695 case Bytecodes::_astore_0: 696 stack->set_local_slot_written(0); 697 stack->pop(-Bytecodes::depth(code)); 698 break; 699 case Bytecodes::_istore_1: 700 case Bytecodes::_fstore_1: 701 case Bytecodes::_lstore_1: 702 case Bytecodes::_dstore_1: 703 case Bytecodes::_astore_1: 704 stack->set_local_slot_written(1); 705 stack->pop(-Bytecodes::depth(code)); 706 break; 707 case Bytecodes::_istore_2: 708 case Bytecodes::_lstore_2: 709 case Bytecodes::_fstore_2: 710 case Bytecodes::_dstore_2: 711 case Bytecodes::_astore_2: 712 stack->set_local_slot_written(2); 713 stack->pop(-Bytecodes::depth(code)); 714 break; 715 case Bytecodes::_istore_3: 716 case Bytecodes::_lstore_3: 717 case Bytecodes::_fstore_3: 718 case Bytecodes::_dstore_3: 719 case Bytecodes::_astore_3: 720 stack->set_local_slot_written(3); 721 stack->pop(-Bytecodes::depth(code)); 722 break; 723 case Bytecodes::_iastore: 724 case Bytecodes::_lastore: 725 case Bytecodes::_fastore: 726 case Bytecodes::_dastore: 727 case Bytecodes::_aastore: 728 case Bytecodes::_bastore: 729 case Bytecodes::_castore: 730 case Bytecodes::_sastore: 731 case Bytecodes::_pop: 732 case Bytecodes::_pop2: 733 case Bytecodes::_monitorenter: 734 case Bytecodes::_monitorexit: 735 case Bytecodes::_breakpoint: 736 stack->pop(-Bytecodes::depth(code)); 737 break; 738 739 case Bytecodes::_dup: 740 stack->push_raw(stack->get_slot_data(0)); 741 break; 742 743 case Bytecodes::_dup_x1: { 744 StackSlotAnalysisData top1 = stack->get_slot_data(0); 745 StackSlotAnalysisData top2 = stack->get_slot_data(1); 746 stack->pop(2); 747 stack->push_raw(top1); 748 stack->push_raw(top2); 749 stack->push_raw(top1); 750 break; 751 } 752 753 case Bytecodes::_dup_x2: { 754 StackSlotAnalysisData top1 = stack->get_slot_data(0); 755 StackSlotAnalysisData top2 = stack->get_slot_data(1); 756 StackSlotAnalysisData top3 = stack->get_slot_data(2); 757 stack->pop(3); 758 stack->push_raw(top1); 759 stack->push_raw(top3); 760 stack->push_raw(top2); 761 stack->push_raw(top1); 762 break; 763 } 764 765 case Bytecodes::_dup2: 766 stack->push_raw(stack->get_slot_data(1)); 767 // The former '0' entry is now at '1'. 768 stack->push_raw(stack->get_slot_data(1)); 769 break; 770 771 case Bytecodes::_dup2_x1: { 772 StackSlotAnalysisData top1 = stack->get_slot_data(0); 773 StackSlotAnalysisData top2 = stack->get_slot_data(1); 774 StackSlotAnalysisData top3 = stack->get_slot_data(2); 775 stack->pop(3); 776 stack->push_raw(top2); 777 stack->push_raw(top1); 778 stack->push_raw(top3); 779 stack->push_raw(top2); 780 stack->push_raw(top1); 781 break; 782 } 783 784 case Bytecodes::_dup2_x2: { 785 StackSlotAnalysisData top1 = stack->get_slot_data(0); 786 StackSlotAnalysisData top2 = stack->get_slot_data(1); 787 StackSlotAnalysisData top3 = stack->get_slot_data(2); 788 StackSlotAnalysisData top4 = stack->get_slot_data(3); 789 stack->pop(4); 790 stack->push_raw(top2); 791 stack->push_raw(top1); 792 stack->push_raw(top4); 793 stack->push_raw(top3); 794 stack->push_raw(top2); 795 stack->push_raw(top1); 796 break; 797 } 798 799 case Bytecodes::_swap: { 800 StackSlotAnalysisData top1 = stack->get_slot_data(0); 801 StackSlotAnalysisData top2 = stack->get_slot_data(1); 802 stack->pop(2); 803 stack->push(top1); 804 stack->push(top2); 805 break; 806 } 807 808 case Bytecodes::_iadd: 809 case Bytecodes::_ladd: 810 case Bytecodes::_fadd: 811 case Bytecodes::_dadd: 812 case Bytecodes::_isub: 813 case Bytecodes::_lsub: 814 case Bytecodes::_fsub: 815 case Bytecodes::_dsub: 816 case Bytecodes::_imul: 817 case Bytecodes::_lmul: 818 case Bytecodes::_fmul: 819 case Bytecodes::_dmul: 820 case Bytecodes::_idiv: 821 case Bytecodes::_ldiv: 822 case Bytecodes::_fdiv: 823 case Bytecodes::_ddiv: 824 case Bytecodes::_irem: 825 case Bytecodes::_lrem: 826 case Bytecodes::_frem: 827 case Bytecodes::_drem: 828 case Bytecodes::_iand: 829 case Bytecodes::_land: 830 case Bytecodes::_ior: 831 case Bytecodes::_lor: 832 case Bytecodes::_ixor: 833 case Bytecodes::_lxor: 834 stack->pop(2 * type2size[Bytecodes::result_type(code)]); 835 stack->push(bci, Bytecodes::result_type(code)); 836 break; 837 838 case Bytecodes::_ineg: 839 case Bytecodes::_lneg: 840 case Bytecodes::_fneg: 841 case Bytecodes::_dneg: 842 stack->pop(type2size[Bytecodes::result_type(code)]); 843 stack->push(bci, Bytecodes::result_type(code)); 844 break; 845 846 case Bytecodes::_ishl: 847 case Bytecodes::_lshl: 848 case Bytecodes::_ishr: 849 case Bytecodes::_lshr: 850 case Bytecodes::_iushr: 851 case Bytecodes::_lushr: 852 stack->pop(1 + type2size[Bytecodes::result_type(code)]); 853 stack->push(bci, Bytecodes::result_type(code)); 854 break; 855 856 case Bytecodes::_i2l: 857 case Bytecodes::_i2f: 858 case Bytecodes::_i2d: 859 case Bytecodes::_f2i: 860 case Bytecodes::_f2l: 861 case Bytecodes::_f2d: 862 case Bytecodes::_i2b: 863 case Bytecodes::_i2c: 864 case Bytecodes::_i2s: 865 stack->pop(1); 866 stack->push(bci, Bytecodes::result_type(code)); 867 break; 868 869 case Bytecodes::_l2i: 870 case Bytecodes::_l2f: 871 case Bytecodes::_l2d: 872 case Bytecodes::_d2i: 873 case Bytecodes::_d2l: 874 case Bytecodes::_d2f: 875 stack->pop(2); 876 stack->push(bci, Bytecodes::result_type(code)); 877 break; 878 879 case Bytecodes::_lcmp: 880 case Bytecodes::_fcmpl: 881 case Bytecodes::_fcmpg: 882 case Bytecodes::_dcmpl: 883 case Bytecodes::_dcmpg: 884 stack->pop(1 - Bytecodes::depth(code)); 885 stack->push(bci, T_INT); 886 break; 887 888 case Bytecodes::_ifeq: 889 case Bytecodes::_ifne: 890 case Bytecodes::_iflt: 891 case Bytecodes::_ifge: 892 case Bytecodes::_ifgt: 893 case Bytecodes::_ifle: 894 case Bytecodes::_if_icmpeq: 895 case Bytecodes::_if_icmpne: 896 case Bytecodes::_if_icmplt: 897 case Bytecodes::_if_icmpge: 898 case Bytecodes::_if_icmpgt: 899 case Bytecodes::_if_icmple: 900 case Bytecodes::_if_acmpeq: 901 case Bytecodes::_if_acmpne: 902 case Bytecodes::_ifnull: 903 case Bytecodes::_ifnonnull: 904 stack->pop(-Bytecodes::depth(code)); 905 dest_bci = bci + (int16_t) Bytes::get_Java_u2(code_base + pos); 906 break; 907 908 case Bytecodes::_jsr: 909 // NOTE: Bytecodes has wrong depth for jsr. 910 stack->push(bci, T_ADDRESS); 911 dest_bci = bci + (int16_t) Bytes::get_Java_u2(code_base + pos); 912 flow_ended = true; 913 break; 914 915 case Bytecodes::_jsr_w: { 916 // NOTE: Bytecodes has wrong depth for jsr. 917 stack->push(bci, T_ADDRESS); 918 dest_bci = bci + (int32_t) Bytes::get_Java_u4(code_base + pos); 919 flow_ended = true; 920 break; 921 } 922 923 case Bytecodes::_ret: 924 // We don't track local variables, so we cannot know were we 925 // return. This makes the stacks imprecise, but we have to 926 // live with that. 927 flow_ended = true; 928 break; 929 930 case Bytecodes::_tableswitch: { 931 stack->pop(1); 932 pos = (pos + 3) & ~3; 933 dest_bci = bci + (int32_t) Bytes::get_Java_u4(code_base + pos); 934 int low = (int32_t) Bytes::get_Java_u4(code_base + pos + 4); 935 int high = (int32_t) Bytes::get_Java_u4(code_base + pos + 8); 936 937 for (int64_t i = low; i <= high; ++i) { 938 dests.push(bci + (int32_t) Bytes::get_Java_u4(code_base + pos + 12 + 4 * (i - low))); 939 } 940 941 break; 942 } 943 944 case Bytecodes::_lookupswitch: { 945 stack->pop(1); 946 pos = (pos + 3) & ~3; 947 dest_bci = bci + (int32_t) Bytes::get_Java_u4(code_base + pos); 948 int nr_of_dests = (int32_t) Bytes::get_Java_u4(code_base + pos + 4); 949 950 for (int i = 0; i < nr_of_dests; ++i) { 951 dests.push(bci + (int32_t) Bytes::get_Java_u4(code_base + pos + 12 + 8 * i)); 952 } 953 954 break; 955 } 956 957 case Bytecodes::_ireturn: 958 case Bytecodes::_lreturn: 959 case Bytecodes::_freturn: 960 case Bytecodes::_dreturn: 961 case Bytecodes::_areturn: 962 case Bytecodes::_return: 963 case Bytecodes::_athrow: 964 stack->pop(-Bytecodes::depth(code)); 965 flow_ended = true; 966 break; 967 968 case Bytecodes::_getstatic: 969 case Bytecodes::_getfield: { 970 // Find out the type of the field accessed. 971 int cp_index = Bytes::get_native_u2(code_base + pos); 972 ConstantPool* cp = _method->constants(); 973 int name_and_type_index = cp->name_and_type_ref_index_at(cp_index, code); 974 int type_index = cp->signature_ref_index_at(name_and_type_index); 975 Symbol* signature = cp->symbol_at(type_index); 976 // Simulate the bytecode: pop the address, push the 'value' loaded 977 // from the field. 978 stack->pop(1 - Bytecodes::depth(code)); 979 stack->push(bci, Signature::basic_type(signature)); 980 break; 981 } 982 983 case Bytecodes::_putstatic: 984 case Bytecodes::_putfield: { 985 int cp_index = Bytes::get_native_u2(code_base + pos); 986 ConstantPool* cp = _method->constants(); 987 int name_and_type_index = cp->name_and_type_ref_index_at(cp_index, code); 988 int type_index = cp->signature_ref_index_at(name_and_type_index); 989 Symbol* signature = cp->symbol_at(type_index); 990 BasicType bt = Signature::basic_type(signature); 991 stack->pop(type2size[bt] - Bytecodes::depth(code) - 1); 992 break; 993 } 994 995 case Bytecodes::_invokevirtual: 996 case Bytecodes::_invokespecial: 997 case Bytecodes::_invokestatic: 998 case Bytecodes::_invokeinterface: 999 case Bytecodes::_invokedynamic: { 1000 ConstantPool* cp = _method->constants(); 1001 int cp_index; 1002 1003 if (code == Bytecodes::_invokedynamic) { 1004 cp_index = ((int) Bytes::get_native_u4(code_base + pos)); 1005 } else { 1006 cp_index = Bytes::get_native_u2(code_base + pos); 1007 } 1008 1009 int name_and_type_index = cp->name_and_type_ref_index_at(cp_index, code); 1010 int type_index = cp->signature_ref_index_at(name_and_type_index); 1011 Symbol* signature = cp->symbol_at(type_index); 1012 1013 if ((code != Bytecodes::_invokestatic) && (code != Bytecodes::_invokedynamic)) { 1014 // Pop receiver. 1015 stack->pop(1); 1016 } 1017 1018 stack->pop(ArgumentSizeComputer(signature).size()); 1019 ResultTypeFinder result_type(signature); 1020 stack->push(bci, result_type.type()); 1021 break; 1022 } 1023 1024 case Bytecodes::_newarray: 1025 case Bytecodes::_anewarray: 1026 case Bytecodes::_instanceof: 1027 stack->pop(1); 1028 stack->push(bci, Bytecodes::result_type(code)); 1029 break; 1030 1031 case Bytecodes::_arraylength: 1032 stack->pop(1); 1033 stack->push(bci, T_INT); 1034 break; 1035 1036 case Bytecodes::_checkcast: 1037 break; 1038 1039 case Bytecodes::_multianewarray: 1040 stack->pop(*(uint8_t*) (code_base + pos + 2)); 1041 stack->push(bci, T_OBJECT); 1042 break; 1043 1044 case Bytecodes::_goto: 1045 stack->pop(-Bytecodes::depth(code)); 1046 dest_bci = bci + (int16_t) Bytes::get_Java_u2(code_base + pos); 1047 flow_ended = true; 1048 break; 1049 1050 1051 case Bytecodes::_goto_w: 1052 stack->pop(-Bytecodes::depth(code)); 1053 dest_bci = bci + (int32_t) Bytes::get_Java_u4(code_base + pos); 1054 flow_ended = true; 1055 break; 1056 1057 default: 1058 // Allow at least the bcis which have stack info to work. 1059 _all_processed = false; 1060 _added_one = false; 1061 delete stack; 1062 1063 return len; 1064 } 1065 1066 // Put new stack to the next instruction, if we might reach it from 1067 // this bci. 1068 if (!flow_ended) { 1069 if (_stacks->at(bci + len) == nullptr) { 1070 _added_one = true; 1071 } 1072 merge(bci + len, stack); 1073 } 1074 1075 // Put the stack to the branch target too. 1076 if (dest_bci != -1) { 1077 if (_stacks->at(dest_bci) == nullptr) { 1078 _added_one = true; 1079 } 1080 merge(dest_bci, stack); 1081 } 1082 1083 // If we have more than one branch target, process these too. 1084 for (int i = 0; i < dests.length(); ++i) { 1085 if (_stacks->at(dests.at(i)) == nullptr) { 1086 _added_one = true; 1087 } 1088 merge(dests.at(i), stack); 1089 } 1090 1091 delete stack; 1092 1093 return len; 1094 } 1095 1096 #define INVALID_BYTECODE_ENCOUNTERED -1 1097 #define NPE_EXPLICIT_CONSTRUCTED -2 1098 int ExceptionMessageBuilder::get_NPE_null_slot(int bci) { 1099 // Get the bytecode. 1100 address code_base = _method->constMethod()->code_base(); 1101 Bytecodes::Code code = Bytecodes::java_code_at(_method, code_base + bci); 1102 int pos = bci + 1; // Position of argument of the bytecode. 1103 if (code == Bytecodes::_wide) { 1104 code = Bytecodes::java_code_at(_method, code_base + bci + 1); 1105 pos += 1; 1106 } 1107 1108 switch (code) { 1109 case Bytecodes::_getfield: 1110 case Bytecodes::_arraylength: 1111 case Bytecodes::_athrow: 1112 case Bytecodes::_monitorenter: 1113 case Bytecodes::_monitorexit: 1114 case Bytecodes::_checkcast: 1115 return 0; 1116 case Bytecodes::_iaload: 1117 case Bytecodes::_faload: 1118 case Bytecodes::_aaload: 1119 case Bytecodes::_baload: 1120 case Bytecodes::_caload: 1121 case Bytecodes::_saload: 1122 case Bytecodes::_laload: 1123 case Bytecodes::_daload: 1124 return 1; 1125 case Bytecodes::_iastore: 1126 case Bytecodes::_fastore: 1127 case Bytecodes::_aastore: 1128 case Bytecodes::_bastore: 1129 case Bytecodes::_castore: 1130 case Bytecodes::_sastore: 1131 return 2; 1132 case Bytecodes::_lastore: 1133 case Bytecodes::_dastore: 1134 return 3; 1135 case Bytecodes::_putfield: { 1136 int cp_index = Bytes::get_native_u2(code_base + pos); 1137 ConstantPool* cp = _method->constants(); 1138 int name_and_type_index = cp->name_and_type_ref_index_at(cp_index, code); 1139 int type_index = cp->signature_ref_index_at(name_and_type_index); 1140 Symbol* signature = cp->symbol_at(type_index); 1141 BasicType bt = Signature::basic_type(signature); 1142 return type2size[bt]; 1143 } 1144 case Bytecodes::_invokevirtual: 1145 case Bytecodes::_invokespecial: 1146 case Bytecodes::_invokeinterface: { 1147 int cp_index = Bytes::get_native_u2(code_base+ pos); 1148 ConstantPool* cp = _method->constants(); 1149 int name_and_type_index = cp->name_and_type_ref_index_at(cp_index, code); 1150 int name_index = cp->name_ref_index_at(name_and_type_index); 1151 Symbol* name = cp->symbol_at(name_index); 1152 1153 // Assume the call of a constructor can never cause a NullPointerException 1154 // (which is true in Java). This is mainly used to avoid generating wrong 1155 // messages for NullPointerExceptions created explicitly by new in Java code. 1156 if (name != vmSymbols::object_initializer_name()) { 1157 int type_index = cp->signature_ref_index_at(name_and_type_index); 1158 Symbol* signature = cp->symbol_at(type_index); 1159 // The 'this' parameter was null. Return the slot of it. 1160 return ArgumentSizeComputer(signature).size(); 1161 } else { 1162 return NPE_EXPLICIT_CONSTRUCTED; 1163 } 1164 } 1165 1166 default: 1167 break; 1168 } 1169 1170 return INVALID_BYTECODE_ENCOUNTERED; 1171 } 1172 1173 bool ExceptionMessageBuilder::print_NPE_cause(outputStream* os, int bci, int slot) { 1174 if (print_NPE_cause0(os, bci, slot, _max_cause_detail, false, " because \"")) { 1175 address code_base = _method->constMethod()->code_base(); 1176 Bytecodes::Code code = Bytecodes::java_code_at(_method, code_base + bci); 1177 if (code == Bytecodes::_aastore) { 1178 os->print("\" is null or is a null-free array and there's an attempt to store null in it"); 1179 } else { 1180 os->print("\" is null"); 1181 } 1182 return true; 1183 } 1184 return false; 1185 } 1186 1187 // Recursively print what was null. 1188 // 1189 // Go to the bytecode that pushed slot 'slot' on the operand stack 1190 // at bytecode 'bci'. Compute a message for that bytecode. If 1191 // necessary (array, field), recur further. 1192 // At most do max_detail recursions. 1193 // Prefix is used to print a proper beginning of the whole 1194 // sentence. 1195 // inner_expr is used to omit some text, like 'static' in 1196 // inner expressions like array subscripts. 1197 // 1198 // Returns true if something was printed. 1199 // 1200 bool ExceptionMessageBuilder::print_NPE_cause0(outputStream* os, int bci, int slot, 1201 int max_detail, 1202 bool inner_expr, const char *prefix) { 1203 assert(bci >= 0, "BCI too low"); 1204 assert(bci < get_size(), "BCI too large"); 1205 1206 if (max_detail <= 0) { 1207 return false; 1208 } 1209 1210 if (_stacks->at(bci) == nullptr) { 1211 return false; 1212 } 1213 1214 SimulatedOperandStack* stack = _stacks->at(bci); 1215 assert(slot >= 0, "Slot nr. too low"); 1216 assert(slot < stack->get_size(), "Slot nr. too large"); 1217 1218 StackSlotAnalysisData slotData = stack->get_slot_data(slot); 1219 1220 if (!slotData.has_bci()) { 1221 return false; 1222 } 1223 1224 // Get the bytecode. 1225 unsigned int source_bci = slotData.get_bci(); 1226 address code_base = _method->constMethod()->code_base(); 1227 Bytecodes::Code code = Bytecodes::java_code_at(_method, code_base + source_bci); 1228 bool is_wide = false; 1229 int pos = source_bci + 1; 1230 1231 if (code == Bytecodes::_wide) { 1232 is_wide = true; 1233 code = Bytecodes::java_code_at(_method, code_base + source_bci + 1); 1234 pos += 1; 1235 } 1236 1237 if (max_detail == _max_cause_detail && 1238 prefix != nullptr && 1239 code != Bytecodes::_invokevirtual && 1240 code != Bytecodes::_invokespecial && 1241 code != Bytecodes::_invokestatic && 1242 code != Bytecodes::_invokeinterface) { 1243 os->print("%s", prefix); 1244 } 1245 1246 switch (code) { 1247 case Bytecodes::_iload_0: 1248 case Bytecodes::_aload_0: 1249 print_local_var(os, source_bci, _method, 0, !stack->local_slot_was_written(0)); 1250 return true; 1251 1252 case Bytecodes::_iload_1: 1253 case Bytecodes::_aload_1: 1254 print_local_var(os, source_bci, _method, 1, !stack->local_slot_was_written(1)); 1255 return true; 1256 1257 case Bytecodes::_iload_2: 1258 case Bytecodes::_aload_2: 1259 print_local_var(os, source_bci, _method, 2, !stack->local_slot_was_written(2)); 1260 return true; 1261 1262 case Bytecodes::_iload_3: 1263 case Bytecodes::_aload_3: 1264 print_local_var(os, source_bci, _method, 3, !stack->local_slot_was_written(3)); 1265 return true; 1266 1267 case Bytecodes::_iload: 1268 case Bytecodes::_aload: { 1269 int index; 1270 if (is_wide) { 1271 index = Bytes::get_Java_u2(code_base + source_bci + 2); 1272 } else { 1273 index = *(uint8_t*) (code_base + source_bci + 1); 1274 } 1275 print_local_var(os, source_bci, _method, index, !stack->local_slot_was_written(index)); 1276 return true; 1277 } 1278 1279 case Bytecodes::_aconst_null: 1280 os->print("null"); 1281 return true; 1282 case Bytecodes::_iconst_m1: 1283 os->print("-1"); 1284 return true; 1285 case Bytecodes::_iconst_0: 1286 os->print("0"); 1287 return true; 1288 case Bytecodes::_iconst_1: 1289 os->print("1"); 1290 return true; 1291 case Bytecodes::_iconst_2: 1292 os->print("2"); 1293 return true; 1294 case Bytecodes::_iconst_3: 1295 os->print("3"); 1296 return true; 1297 case Bytecodes::_iconst_4: 1298 os->print("4"); 1299 return true; 1300 case Bytecodes::_iconst_5: 1301 os->print("5"); 1302 return true; 1303 case Bytecodes::_bipush: { 1304 jbyte con = *(jbyte*) (code_base + source_bci + 1); 1305 os->print("%d", con); 1306 return true; 1307 } 1308 case Bytecodes::_sipush: { 1309 u2 con = Bytes::get_Java_u2(code_base + source_bci + 1); 1310 os->print("%d", con); 1311 return true; 1312 } 1313 case Bytecodes::_iaload: 1314 case Bytecodes::_aaload: { 1315 // Print the 'name' of the array. Go back to the bytecode that 1316 // pushed the array reference on the operand stack. 1317 if (!print_NPE_cause0(os, source_bci, 1, max_detail - 1, inner_expr)) { 1318 // Returned false. Max recursion depth was reached. Print dummy. 1319 os->print("<array>"); 1320 } 1321 os->print("["); 1322 // Print the index expression. Go back to the bytecode that 1323 // pushed the index on the operand stack. 1324 // inner_expr == true so we don't print unwanted strings 1325 // as "The return value of'". And don't decrement max_detail so we always 1326 // get a value here and only cancel out on the dereference. 1327 if (!print_NPE_cause0(os, source_bci, 0, max_detail, true)) { 1328 // Returned false. We don't print complex array index expressions. Print placeholder. 1329 os->print("..."); 1330 } 1331 os->print("]"); 1332 return true; 1333 } 1334 1335 case Bytecodes::_getstatic: { 1336 int cp_index = Bytes::get_native_u2(code_base + pos); 1337 print_field_and_class(os, _method, cp_index, code); 1338 return true; 1339 } 1340 1341 case Bytecodes::_getfield: { 1342 // Print the sender. Go back to the bytecode that 1343 // pushed the sender on the operand stack. 1344 if (print_NPE_cause0(os, source_bci, 0, max_detail - 1, inner_expr)) { 1345 os->print("."); 1346 } 1347 int cp_index = Bytes::get_native_u2(code_base + pos); 1348 os->print("%s", get_field_name(_method, cp_index, code)); 1349 return true; 1350 } 1351 1352 case Bytecodes::_invokevirtual: 1353 case Bytecodes::_invokespecial: 1354 case Bytecodes::_invokestatic: 1355 case Bytecodes::_invokeinterface: { 1356 int cp_index = Bytes::get_native_u2(code_base + pos); 1357 if (max_detail == _max_cause_detail && !inner_expr) { 1358 os->print(" because the return value of \""); 1359 } 1360 print_method_name(os, _method, cp_index, code); 1361 return true; 1362 } 1363 1364 default: break; 1365 } 1366 return false; 1367 } 1368 1369 void ExceptionMessageBuilder::print_NPE_failed_action(outputStream *os, int bci) { 1370 1371 // Get the bytecode. 1372 address code_base = _method->constMethod()->code_base(); 1373 Bytecodes::Code code = Bytecodes::java_code_at(_method, code_base + bci); 1374 int pos = bci + 1; 1375 if (code == Bytecodes::_wide) { 1376 code = Bytecodes::java_code_at(_method, code_base + bci + 1); 1377 pos += 1; 1378 } 1379 1380 switch (code) { 1381 case Bytecodes::_iaload: 1382 os->print("Cannot load from int array"); break; 1383 case Bytecodes::_faload: 1384 os->print("Cannot load from float array"); break; 1385 case Bytecodes::_aaload: 1386 os->print("Cannot load from object array"); break; 1387 case Bytecodes::_baload: 1388 os->print("Cannot load from byte/boolean array"); break; 1389 case Bytecodes::_caload: 1390 os->print("Cannot load from char array"); break; 1391 case Bytecodes::_saload: 1392 os->print("Cannot load from short array"); break; 1393 case Bytecodes::_laload: 1394 os->print("Cannot load from long array"); break; 1395 case Bytecodes::_daload: 1396 os->print("Cannot load from double array"); break; 1397 1398 case Bytecodes::_iastore: 1399 os->print("Cannot store to int array"); break; 1400 case Bytecodes::_fastore: 1401 os->print("Cannot store to float array"); break; 1402 case Bytecodes::_aastore: 1403 os->print("Cannot store to object array"); break; 1404 case Bytecodes::_bastore: 1405 os->print("Cannot store to byte/boolean array"); break; 1406 case Bytecodes::_castore: 1407 os->print("Cannot store to char array"); break; 1408 case Bytecodes::_sastore: 1409 os->print("Cannot store to short array"); break; 1410 case Bytecodes::_lastore: 1411 os->print("Cannot store to long array"); break; 1412 case Bytecodes::_dastore: 1413 os->print("Cannot store to double array"); break; 1414 1415 case Bytecodes::_arraylength: 1416 os->print("Cannot read the array length"); break; 1417 case Bytecodes::_athrow: 1418 os->print("Cannot throw exception"); break; 1419 case Bytecodes::_monitorenter: 1420 os->print("Cannot enter synchronized block"); break; 1421 case Bytecodes::_monitorexit: 1422 os->print("Cannot exit synchronized block"); break; 1423 case Bytecodes::_getfield: { 1424 int cp_index = Bytes::get_native_u2(code_base + pos); 1425 ConstantPool* cp = _method->constants(); 1426 int name_and_type_index = cp->name_and_type_ref_index_at(cp_index, code); 1427 int name_index = cp->name_ref_index_at(name_and_type_index); 1428 Symbol* name = cp->symbol_at(name_index); 1429 os->print("Cannot read field \"%s\"", name->as_C_string()); 1430 } break; 1431 case Bytecodes::_putfield: { 1432 int cp_index = Bytes::get_native_u2(code_base + pos); 1433 os->print("Cannot assign field \"%s\"", get_field_name(_method, cp_index, code)); 1434 } break; 1435 case Bytecodes::_invokevirtual: 1436 case Bytecodes::_invokespecial: 1437 case Bytecodes::_invokeinterface: { 1438 int cp_index = Bytes::get_native_u2(code_base+ pos); 1439 os->print("Cannot invoke \""); 1440 print_method_name(os, _method, cp_index, code); 1441 os->print("\""); 1442 } break; 1443 case Bytecodes::_checkcast: { 1444 int cp_index = Bytes::get_Java_u2(code_base + pos); 1445 ConstantPool* cp = _method->constants(); 1446 os->print("Cannot cast to null-free type \"%s\"", cp->klass_at_noresolve(cp_index)->as_C_string()); 1447 } break; 1448 1449 default: 1450 assert(0, "We should have checked this bytecode in get_NPE_null_slot()."); 1451 break; 1452 } 1453 } 1454 1455 // Main API 1456 bool BytecodeUtils::get_NPE_message_at(outputStream* ss, Method* method, int bci) { 1457 1458 NoSafepointVerifier _nsv; // Cannot use this object over a safepoint. 1459 1460 // If this NPE was created via reflection, we have no real NPE. 1461 if (method->method_holder() == 1462 vmClasses::reflect_DirectConstructorHandleAccessor_NativeAccessor_klass()) { 1463 return false; 1464 } 1465 1466 // Analyse the bytecodes. 1467 ResourceMark rm; 1468 ExceptionMessageBuilder emb(method, bci); 1469 1470 // The slot of the operand stack that contains the null reference. 1471 // Also checks for NPE explicitly constructed and returns NPE_EXPLICIT_CONSTRUCTED. 1472 int slot = emb.get_NPE_null_slot(bci); 1473 1474 // Build the message. 1475 if (slot == NPE_EXPLICIT_CONSTRUCTED) { 1476 // We don't want to print a message. 1477 return false; 1478 } else if (slot == INVALID_BYTECODE_ENCOUNTERED) { 1479 // We encountered a bytecode that does not dereference a reference. 1480 DEBUG_ONLY(ss->print("There cannot be a NullPointerException at bci %d of method %s", 1481 bci, method->external_name())); 1482 NOT_DEBUG(return false); 1483 } else { 1484 // Print string describing which action (bytecode) could not be 1485 // performed because of the null reference. 1486 emb.print_NPE_failed_action(ss, bci); 1487 // Print a description of what is null. 1488 if (!emb.print_NPE_cause(ss, bci, slot)) { 1489 // Nothing was printed. End the sentence without the 'because' 1490 // subordinate sentence. 1491 } 1492 } 1493 return true; 1494 } --- EOF ---