Mercurial Mercurial > jdk-sandbox / comparison
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help
Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
hotspot/src/share/vm/classfile/javaClasses.cpp
changeset 34280 72bfaaffee36
parent 34273 8598d07915d9
child 34317 e93b85bf4cc2
equal deleted inserted replaced
34277:d457b9400c99 34280:72bfaaffee36 
  1516 }
 
  1516 }
 
  1517 
  1517 
  1518 // After this many redefines, the stack trace is unreliable.
 
  1518 // After this many redefines, the stack trace is unreliable.
 
  1519 const int MAX_VERSION = USHRT_MAX;
 
  1519 const int MAX_VERSION = USHRT_MAX;
 
  1520 
  1520 
  1521 // Helper backtrace functions to store bci|version together.
 
       
  1522 static inline int merge_bci_and_version(int bci, int version) {
 
       
  1523   // only store u2 for version, checking for overflow.
 
       
  1524   if (version > USHRT_MAX || version < 0) version = MAX_VERSION;
 
       
  1525   assert((jushort)bci == bci, "bci should be short");
 
       
  1526   return build_int_from_shorts(version, bci);
 
       
  1527 }
 
       
  1528 
       
  1529 static inline int bci_at(unsigned int merged) {
 
       
  1530   return extract_high_short_from_int(merged);
 
       
  1531 }
 
       
  1532 static inline int version_at(unsigned int merged) {
 
       
  1533   return extract_low_short_from_int(merged);
 
       
  1534 }
 
       
  1535 
       
  1536 static inline bool version_matches(Method* method, int version) {
 
  1521 static inline bool version_matches(Method* method, int version) {
 
  1537   assert(version < MAX_VERSION, "version is too big");
 
  1522   assert(version < MAX_VERSION, "version is too big");
 
  1538   return method != NULL && (method->constants()->version() == version);
 
  1523   return method != NULL && (method->constants()->version() == version);
 
  1539 }
 
       
  1540 
       
  1541 static inline int get_line_number(Method* method, int bci) {
 
       
  1542   int line_number = 0;
 
       
  1543   if (method->is_native()) {
 
       
  1544     // Negative value different from -1 below, enabling Java code in
 
       
  1545     // class java.lang.StackTraceElement to distinguish "native" from
 
       
  1546     // "no LineNumberTable".  JDK tests for -2.
 
       
  1547     line_number = -2;
 
       
  1548   } else {
 
       
  1549     // Returns -1 if no LineNumberTable, and otherwise actual line number
 
       
  1550     line_number = method->line_number_from_bci(bci);
 
       
  1551     if (line_number == -1 && ShowHiddenFrames) {
 
       
  1552       line_number = bci + 1000000;
 
       
  1553     }
 
       
  1554   }
 
       
  1555   return line_number;
 
       
  1556 }
 
  1524 }
 
  1557 
  1525 
  1558 // This class provides a simple wrapper over the internal structure of
 
  1526 // This class provides a simple wrapper over the internal structure of
 
  1559 // exception backtrace to insulate users of the backtrace from needing
 
  1527 // exception backtrace to insulate users of the backtrace from needing
 
  1560 // to know what it looks like.
 
  1528 // to know what it looks like.
 
  1674       expand(CHECK);
 
  1642       expand(CHECK);
 
  1675       method = mhandle();
 
  1643       method = mhandle();
 
  1676     }
 
  1644     }
 
  1677 
  1645 
  1678     _methods->short_at_put(_index, method->orig_method_idnum());
 
  1646     _methods->short_at_put(_index, method->orig_method_idnum());
 
  1679     _bcis->int_at_put(_index, merge_bci_and_version(bci, method->constants()->version()));
 
  1647     _bcis->int_at_put(_index, Backtrace::merge_bci_and_version(bci, method->constants()->version()));
 
  1680     _cprefs->short_at_put(_index, method->name_index());
 
  1648     _cprefs->short_at_put(_index, method->name_index());
 
  1681 
  1649 
  1682     // We need to save the mirrors in the backtrace to keep the class
 
  1650     // We need to save the mirrors in the backtrace to keep the class
 
  1683     // from being unloaded while we still have this stack trace.
 
  1651     // from being unloaded while we still have this stack trace.
 
  1684     assert(method->method_holder()->java_mirror() != NULL, "never push null for mirror");
 
  1652     assert(method->method_holder()->java_mirror() != NULL, "never push null for mirror");
 
  1686     _index++;
 
  1654     _index++;
 
  1687   }
 
  1655   }
 
  1688 
  1656 
  1689 };
 
  1657 };
 
  1690 
  1658 
  1691 Symbol* get_source_file_name(InstanceKlass* holder, int version) {
 
       
  1692   // Find the specific ik version that contains this source_file_name_index
 
       
  1693   // via the previous versions list, but use the current version's
 
       
  1694   // constant pool to look it up.  The previous version's index has been
 
       
  1695   // merged for the current constant pool.
 
       
  1696   InstanceKlass* ik = holder->get_klass_version(version);
 
       
  1697   // This version has been cleaned up.
 
       
  1698   if (ik == NULL) return NULL;
 
       
  1699   int source_file_name_index = ik->source_file_name_index();
 
       
  1700   return (source_file_name_index == 0) ?
 
       
  1701       (Symbol*)NULL : holder->constants()->symbol_at(source_file_name_index);
 
       
  1702 }
 
       
  1703 
       
  1704 // Print stack trace element to resource allocated buffer
 
  1659 // Print stack trace element to resource allocated buffer
 
  1705 char* java_lang_Throwable::print_stack_element_to_buffer(Handle mirror,
 
  1660 char* java_lang_Throwable::print_stack_element_to_buffer(Handle mirror,
 
  1706                                   int method_id, int version, int bci, int cpref) {
 
  1661                                   int method_id, int version, int bci, int cpref) {
 
  1707 
  1662 
  1708   // Get strings and string lengths
 
  1663   // Get strings and string lengths
 
  1716   Symbol* sym = (method != NULL) ? method->name() : holder->constants()->symbol_at(cpref);
 
  1671   Symbol* sym = (method != NULL) ? method->name() : holder->constants()->symbol_at(cpref);
 
  1717   char* method_name = sym->as_C_string();
 
  1672   char* method_name = sym->as_C_string();
 
  1718   buf_len += (int)strlen(method_name);
 
  1673   buf_len += (int)strlen(method_name);
 
  1719 
  1674 
  1720   char* source_file_name = NULL;
 
  1675   char* source_file_name = NULL;
 
  1721   Symbol* source = get_source_file_name(holder, version);
 
  1676   Symbol* source = Backtrace::get_source_file_name(holder, version);
 
  1722   if (source != NULL) {
 
  1677   if (source != NULL) {
 
  1723     source_file_name = source->as_C_string();
 
  1678     source_file_name = source->as_C_string();
 
  1724     buf_len += (int)strlen(source_file_name);
 
  1679     buf_len += (int)strlen(source_file_name);
 
  1725   }
 
  1680   }
 
  1726 
  1681 
  1731   sprintf(buf, "\tat %s.%s", klass_name, method_name);
 
  1686   sprintf(buf, "\tat %s.%s", klass_name, method_name);
 
  1732 
  1687 
  1733   if (!version_matches(method, version)) {
 
  1688   if (!version_matches(method, version)) {
 
  1734     strcat(buf, "(Redefined)");
 
  1689     strcat(buf, "(Redefined)");
 
  1735   } else {
 
  1690   } else {
 
  1736     int line_number = get_line_number(method, bci);
 
  1691     int line_number = Backtrace::get_line_number(method, bci);
 
  1737     if (line_number == -2) {
 
  1692     if (line_number == -2) {
 
  1738       strcat(buf, "(Native Method)");
 
  1693       strcat(buf, "(Native Method)");
 
  1739     } else {
 
  1694     } else {
 
  1740       if (source_file_name != NULL && (line_number != -1)) {
 
  1695       if (source_file_name != NULL && (line_number != -1)) {
 
  1741         // Sourcename and linenumber
 
  1696         // Sourcename and linenumber
 
  1800       for (int index = 0; index < length; index++) {
 
  1755       for (int index = 0; index < length; index++) {
 
  1801         Handle mirror(THREAD, mirrors->obj_at(index));
 
  1756         Handle mirror(THREAD, mirrors->obj_at(index));
 
  1802         // NULL mirror means end of stack trace
 
  1757         // NULL mirror means end of stack trace
 
  1803         if (mirror.is_null()) goto handle_cause;
 
  1758         if (mirror.is_null()) goto handle_cause;
 
  1804         int method = methods->short_at(index);
 
  1759         int method = methods->short_at(index);
 
  1805         int version = version_at(bcis->int_at(index));
 
  1760         int version = Backtrace::version_at(bcis->int_at(index));
 
  1806         int bci = bci_at(bcis->int_at(index));
 
  1761         int bci = Backtrace::bci_at(bcis->int_at(index));
 
  1807         int cpref = cprefs->short_at(index);
 
  1762         int cpref = cprefs->short_at(index);
 
  1808         print_stack_element(st, mirror, method, version, bci, cpref);
 
  1763         print_stack_element(st, mirror, method, version, bci, cpref);
 
  1809       }
 
  1764       }
 
  1810       result = objArrayHandle(THREAD, objArrayOop(result->obj_at(trace_next_offset)));
 
  1765       result = objArrayHandle(THREAD, objArrayOop(result->obj_at(trace_next_offset)));
 
  1811     }
 
  1766     }
 
  2088   typeArrayOop cprefs = BacktraceBuilder::get_cprefs(chunk);
 
  2043   typeArrayOop cprefs = BacktraceBuilder::get_cprefs(chunk);
 
  2089 
  2044 
  2090   assert(methods != NULL && bcis != NULL && mirrors != NULL, "sanity check");
 
  2045   assert(methods != NULL && bcis != NULL && mirrors != NULL, "sanity check");
 
  2091 
  2046 
  2092   int method = methods->short_at(chunk_index);
 
  2047   int method = methods->short_at(chunk_index);
 
  2093   int version = version_at(bcis->int_at(chunk_index));
 
  2048   int version = Backtrace::version_at(bcis->int_at(chunk_index));
 
  2094   int bci = bci_at(bcis->int_at(chunk_index));
 
  2049   int bci = Backtrace::bci_at(bcis->int_at(chunk_index));
 
  2095   int cpref = cprefs->short_at(chunk_index);
 
  2050   int cpref = cprefs->short_at(chunk_index);
 
  2096   Handle mirror(THREAD, mirrors->obj_at(chunk_index));
 
  2051   Handle mirror(THREAD, mirrors->obj_at(chunk_index));
 
  2097 
  2052 
  2098   // Chunk can be partial full
 
  2053   // Chunk can be partial full
 
  2099   if (mirror.is_null()) {
 
  2054   if (mirror.is_null()) {
 
  2112   if (ik->should_be_initialized()) {
 
  2067   if (ik->should_be_initialized()) {
 
  2113     ik->initialize(CHECK_0);
 
  2068     ik->initialize(CHECK_0);
 
  2114   }
 
  2069   }
 
  2115 
  2070 
  2116   Handle element = ik->allocate_instance_handle(CHECK_0);
 
  2071   Handle element = ik->allocate_instance_handle(CHECK_0);
 
       
  2072 
  2117   // Fill in class name
 
  2073   // Fill in class name
 
  2118   ResourceMark rm(THREAD);
 
  2074   ResourceMark rm(THREAD);
 
  2119   InstanceKlass* holder = InstanceKlass::cast(java_lang_Class::as_Klass(mirror()));
 
  2075   InstanceKlass* holder = InstanceKlass::cast(java_lang_Class::as_Klass(mirror()));
 
  2120   const char* str = holder->external_name();
 
  2076   const char* str = holder->external_name();
 
  2121   oop classname = StringTable::intern((char*) str, CHECK_0);
 
  2077   oop classname = StringTable::intern((char*) str, CHECK_0);
 
  2134     // The method was redefined, accurate line number information isn't available
 
  2090     // The method was redefined, accurate line number information isn't available
 
  2135     java_lang_StackTraceElement::set_fileName(element(), NULL);
 
  2091     java_lang_StackTraceElement::set_fileName(element(), NULL);
 
  2136     java_lang_StackTraceElement::set_lineNumber(element(), -1);
 
  2092     java_lang_StackTraceElement::set_lineNumber(element(), -1);
 
  2137   } else {
 
  2093   } else {
 
  2138     // Fill in source file name and line number.
 
  2094     // Fill in source file name and line number.
 
  2139     Symbol* source = get_source_file_name(holder, version);
 
  2095     Symbol* source = Backtrace::get_source_file_name(holder, version);
 
  2140     if (ShowHiddenFrames && source == NULL)
 
  2096     if (ShowHiddenFrames && source == NULL)
 
  2141       source = vmSymbols::unknown_class_name();
 
  2097       source = vmSymbols::unknown_class_name();
 
  2142     oop filename = StringTable::intern(source, CHECK_0);
 
  2098     oop filename = StringTable::intern(source, CHECK_0);
 
  2143     java_lang_StackTraceElement::set_fileName(element(), filename);
 
  2099     java_lang_StackTraceElement::set_fileName(element(), filename);
 
  2144 
  2100 
  2145     int line_number = get_line_number(method, bci);
 
  2101     int line_number = Backtrace::get_line_number(method, bci);
 
  2146     java_lang_StackTraceElement::set_lineNumber(element(), line_number);
 
  2102     java_lang_StackTraceElement::set_lineNumber(element(), line_number);
 
  2147   }
 
  2103   }
 
  2148   return element();
 
  2104   return element();
 
  2149 }
 
  2105 }
 
  2150 
  2106 
  2151 oop java_lang_StackTraceElement::create(const methodHandle& method, int bci, TRAPS) {
 
  2107 oop java_lang_StackTraceElement::create(const methodHandle& method, int bci, TRAPS) {
 
  2152   Handle mirror (THREAD, method->method_holder()->java_mirror());
 
  2108   Handle mirror (THREAD, method->method_holder()->java_mirror());
 
  2153   int method_id = method->orig_method_idnum();
 
  2109   int method_id = method->orig_method_idnum();
 
  2154   int cpref = method->name_index();
 
  2110   int cpref = method->name_index();
 
  2155   return create(mirror, method_id, method->constants()->version(), bci, cpref, THREAD);
 
  2111   return create(mirror, method_id, method->constants()->version(), bci, cpref, THREAD);
 
       
  2112 }
 
       
  2113 
       
  2114 Method* java_lang_StackFrameInfo::get_method(Handle stackFrame, InstanceKlass* holder, TRAPS) {
 
       
  2115   if (MemberNameInStackFrame) {
 
       
  2116     Handle mname(THREAD, stackFrame->obj_field(_memberName_offset));
 
       
  2117     Method* method = (Method*)java_lang_invoke_MemberName::vmtarget(mname());
 
       
  2118     // we should expand MemberName::name when Throwable uses StackTrace
 
       
  2119     // MethodHandles::expand_MemberName(mname, MethodHandles::_suppress_defc|MethodHandles::_suppress_type, CHECK_NULL);
 
       
  2120     return method;
 
       
  2121   } else {
 
       
  2122     short mid       = stackFrame->short_field(_mid_offset);
 
       
  2123     short version   = stackFrame->short_field(_version_offset);
 
       
  2124     return holder->method_with_orig_idnum(mid, version);
 
       
  2125   }
 
       
  2126 }
 
       
  2127 
       
  2128 Symbol* java_lang_StackFrameInfo::get_file_name(Handle stackFrame, InstanceKlass* holder) {
 
       
  2129   if (MemberNameInStackFrame) {
 
       
  2130     return holder->source_file_name();
 
       
  2131   } else {
 
       
  2132     short version = stackFrame->short_field(_version_offset);
 
       
  2133     return Backtrace::get_source_file_name(holder, version);
 
       
  2134   }
 
       
  2135 }
 
       
  2136 
       
  2137 void java_lang_StackFrameInfo::set_method_and_bci(Handle stackFrame, const methodHandle& method, int bci) {
 
       
  2138   // set Method* or mid/cpref
 
       
  2139   if (MemberNameInStackFrame) {
 
       
  2140     oop mname = stackFrame->obj_field(_memberName_offset);
 
       
  2141     InstanceKlass* ik = method->method_holder();
 
       
  2142     CallInfo info(method(), ik);
 
       
  2143     MethodHandles::init_method_MemberName(mname, info);
 
       
  2144   } else {
 
       
  2145     int mid = method->orig_method_idnum();
 
       
  2146     int cpref = method->name_index();
 
       
  2147     assert((jushort)mid == mid,        "mid should be short");
 
       
  2148     assert((jushort)cpref == cpref,    "cpref should be short");
 
       
  2149     java_lang_StackFrameInfo::set_mid(stackFrame(),     (short)mid);
 
       
  2150     java_lang_StackFrameInfo::set_cpref(stackFrame(),   (short)cpref);
 
       
  2151   }
 
       
  2152   // set bci
 
       
  2153   java_lang_StackFrameInfo::set_bci(stackFrame(), bci);
 
       
  2154   // method may be redefined; store the version
 
       
  2155   int version = method->constants()->version();
 
       
  2156   assert((jushort)version == version, "version should be short");
 
       
  2157   java_lang_StackFrameInfo::set_version(stackFrame(), (short)version);
 
       
  2158 }
 
       
  2159 
       
  2160 void java_lang_StackFrameInfo::fill_methodInfo(Handle stackFrame, TRAPS) {
 
       
  2161   ResourceMark rm(THREAD);
 
       
  2162   oop k = stackFrame->obj_field(_declaringClass_offset);
 
       
  2163   InstanceKlass* holder = InstanceKlass::cast(java_lang_Class::as_Klass(k));
 
       
  2164   Method* method = java_lang_StackFrameInfo::get_method(stackFrame, holder, CHECK);
 
       
  2165   int bci = stackFrame->int_field(_bci_offset);
 
       
  2166 
       
  2167   // The method can be NULL if the requested class version is gone
 
       
  2168   Symbol* sym = (method != NULL) ? method->name() : NULL;
 
       
  2169   if (MemberNameInStackFrame) {
 
       
  2170     assert(sym != NULL, "MemberName must have method name");
 
       
  2171   } else {
 
       
  2172       // The method can be NULL if the requested class version is gone
 
       
  2173     if (sym == NULL) {
 
       
  2174       short cpref   = stackFrame->short_field(_cpref_offset);
 
       
  2175       sym = holder->constants()->symbol_at(cpref);
 
       
  2176     }
 
       
  2177   }
 
       
  2178 
       
  2179   // set method name
 
       
  2180   oop methodname = StringTable::intern(sym, CHECK);
 
       
  2181   java_lang_StackFrameInfo::set_methodName(stackFrame(), methodname);
 
       
  2182 
       
  2183   // set file name and line number
 
       
  2184   Symbol* source = get_file_name(stackFrame, holder);
 
       
  2185   if (source != NULL) {
 
       
  2186     oop filename = StringTable::intern(source, CHECK);
 
       
  2187     java_lang_StackFrameInfo::set_fileName(stackFrame(), filename);
 
       
  2188   }
 
       
  2189 
       
  2190   // if the method has been redefined, the bci is no longer applicable
 
       
  2191   short version = stackFrame->short_field(_version_offset);
 
       
  2192   if (version_matches(method, version)) {
 
       
  2193     int line_number = Backtrace::get_line_number(method, bci);
 
       
  2194     java_lang_StackFrameInfo::set_lineNumber(stackFrame(), line_number);
 
       
  2195   }
 
       
  2196 }
 
       
  2197 
       
  2198 void java_lang_StackFrameInfo::compute_offsets() {
 
       
  2199   Klass* k = SystemDictionary::StackFrameInfo_klass();
 
       
  2200   compute_offset(_declaringClass_offset, k, vmSymbols::declaringClass_name(),  vmSymbols::class_signature());
 
       
  2201   compute_offset(_memberName_offset,     k, vmSymbols::memberName_name(),  vmSymbols::object_signature());
 
       
  2202   compute_offset(_bci_offset,            k, vmSymbols::bci_name(),         vmSymbols::int_signature());
 
       
  2203   compute_offset(_methodName_offset,     k, vmSymbols::methodName_name(),  vmSymbols::string_signature());
 
       
  2204   compute_offset(_fileName_offset,       k, vmSymbols::fileName_name(),    vmSymbols::string_signature());
 
       
  2205   compute_offset(_lineNumber_offset,     k, vmSymbols::lineNumber_name(),  vmSymbols::int_signature());
 
       
  2206   STACKFRAMEINFO_INJECTED_FIELDS(INJECTED_FIELD_COMPUTE_OFFSET);
 
       
  2207 }
 
       
  2208 
       
  2209 void java_lang_LiveStackFrameInfo::compute_offsets() {
 
       
  2210   Klass* k = SystemDictionary::LiveStackFrameInfo_klass();
 
       
  2211   compute_offset(_monitors_offset,   k, vmSymbols::monitors_name(),    vmSymbols::object_array_signature());
 
       
  2212   compute_offset(_locals_offset,     k, vmSymbols::locals_name(),      vmSymbols::object_array_signature());
 
       
  2213   compute_offset(_operands_offset,   k, vmSymbols::operands_name(),    vmSymbols::object_array_signature());
 
  2156 }
 
  2214 }
 
  2157 
  2215 
  2158 void java_lang_reflect_AccessibleObject::compute_offsets() {
 
  2216 void java_lang_reflect_AccessibleObject::compute_offsets() {
 
  2159   Klass* k = SystemDictionary::reflect_AccessibleObject_klass();
 
  2217   Klass* k = SystemDictionary::reflect_AccessibleObject_klass();
 
  2160   compute_offset(override_offset, k, vmSymbols::override_name(), vmSymbols::bool_signature());
 
  2218   compute_offset(override_offset, k, vmSymbols::override_name(), vmSymbols::bool_signature());
 
  3469 int java_lang_System::static_security_offset;
 
  3527 int java_lang_System::static_security_offset;
 
  3470 int java_lang_StackTraceElement::declaringClass_offset;
 
  3528 int java_lang_StackTraceElement::declaringClass_offset;
 
  3471 int java_lang_StackTraceElement::methodName_offset;
 
  3529 int java_lang_StackTraceElement::methodName_offset;
 
  3472 int java_lang_StackTraceElement::fileName_offset;
 
  3530 int java_lang_StackTraceElement::fileName_offset;
 
  3473 int java_lang_StackTraceElement::lineNumber_offset;
 
  3531 int java_lang_StackTraceElement::lineNumber_offset;
 
       
  3532 int java_lang_StackFrameInfo::_declaringClass_offset;
 
       
  3533 int java_lang_StackFrameInfo::_memberName_offset;
 
       
  3534 int java_lang_StackFrameInfo::_bci_offset;
 
       
  3535 int java_lang_StackFrameInfo::_methodName_offset;
 
       
  3536 int java_lang_StackFrameInfo::_fileName_offset;
 
       
  3537 int java_lang_StackFrameInfo::_lineNumber_offset;
 
       
  3538 int java_lang_StackFrameInfo::_mid_offset;
 
       
  3539 int java_lang_StackFrameInfo::_version_offset;
 
       
  3540 int java_lang_StackFrameInfo::_cpref_offset;
 
       
  3541 int java_lang_LiveStackFrameInfo::_monitors_offset;
 
       
  3542 int java_lang_LiveStackFrameInfo::_locals_offset;
 
       
  3543 int java_lang_LiveStackFrameInfo::_operands_offset;
 
  3474 int java_lang_AssertionStatusDirectives::classes_offset;
 
  3544 int java_lang_AssertionStatusDirectives::classes_offset;
 
  3475 int java_lang_AssertionStatusDirectives::classEnabled_offset;
 
  3545 int java_lang_AssertionStatusDirectives::classEnabled_offset;
 
  3476 int java_lang_AssertionStatusDirectives::packages_offset;
 
  3546 int java_lang_AssertionStatusDirectives::packages_offset;
 
  3477 int java_lang_AssertionStatusDirectives::packageEnabled_offset;
 
  3547 int java_lang_AssertionStatusDirectives::packageEnabled_offset;
 
  3478 int java_lang_AssertionStatusDirectives::deflt_offset;
 
  3548 int java_lang_AssertionStatusDirectives::deflt_offset;
 
  3498 
  3568 
  3499 void java_lang_StackTraceElement::set_lineNumber(oop element, int value) {
 
  3569 void java_lang_StackTraceElement::set_lineNumber(oop element, int value) {
 
  3500   element->int_field_put(lineNumber_offset, value);
 
  3570   element->int_field_put(lineNumber_offset, value);
 
  3501 }
 
  3571 }
 
  3502 
  3572 
       
  3573 // Support for java_lang_StackFrameInfo
 
       
  3574 void java_lang_StackFrameInfo::set_declaringClass(oop element, oop value) {
 
       
  3575   element->obj_field_put(_declaringClass_offset, value);
 
       
  3576 }
 
       
  3577 
       
  3578 void java_lang_StackFrameInfo::set_mid(oop element, short value) {
 
       
  3579   element->short_field_put(_mid_offset, value);
 
       
  3580 }
 
       
  3581 
       
  3582 void java_lang_StackFrameInfo::set_version(oop element, short value) {
 
       
  3583   element->short_field_put(_version_offset, value);
 
       
  3584 }
 
       
  3585 
       
  3586 void java_lang_StackFrameInfo::set_cpref(oop element, short value) {
 
       
  3587   element->short_field_put(_cpref_offset, value);
 
       
  3588 }
 
       
  3589 
       
  3590 void java_lang_StackFrameInfo::set_bci(oop element, int value) {
 
       
  3591   element->int_field_put(_bci_offset, value);
 
       
  3592 }
 
       
  3593 
       
  3594 void java_lang_StackFrameInfo::set_fileName(oop element, oop value) {
 
       
  3595   element->obj_field_put(_fileName_offset, value);
 
       
  3596 }
 
       
  3597 
       
  3598 void java_lang_StackFrameInfo::set_methodName(oop element, oop value) {
 
       
  3599   element->obj_field_put(_methodName_offset, value);
 
       
  3600 }
 
       
  3601 
       
  3602 void java_lang_StackFrameInfo::set_lineNumber(oop element, int value) {
 
       
  3603   element->int_field_put(_lineNumber_offset, value);
 
       
  3604 }
 
       
  3605 
       
  3606 void java_lang_LiveStackFrameInfo::set_monitors(oop element, oop value) {
 
       
  3607   element->obj_field_put(_monitors_offset, value);
 
       
  3608 }
 
       
  3609 
       
  3610 void java_lang_LiveStackFrameInfo::set_locals(oop element, oop value) {
 
       
  3611   element->obj_field_put(_locals_offset, value);
 
       
  3612 }
 
       
  3613 
       
  3614 void java_lang_LiveStackFrameInfo::set_operands(oop element, oop value) {
 
       
  3615   element->obj_field_put(_operands_offset, value);
 
       
  3616 }
 
  3503 
  3617 
  3504 // Support for java Assertions - java_lang_AssertionStatusDirectives.
 
  3618 // Support for java Assertions - java_lang_AssertionStatusDirectives.
 
  3505 
  3619 
  3506 void java_lang_AssertionStatusDirectives::set_classes(oop o, oop val) {
 
  3620 void java_lang_AssertionStatusDirectives::set_classes(oop o, oop val) {
 
  3507   o->obj_field_put(classes_offset, val);
 
  3621   o->obj_field_put(classes_offset, val);
 
  3631   java_lang_reflect_Field::compute_offsets();
 
  3745   java_lang_reflect_Field::compute_offsets();
 
  3632   java_nio_Buffer::compute_offsets();
 
  3746   java_nio_Buffer::compute_offsets();
 
  3633   sun_reflect_ConstantPool::compute_offsets();
 
  3747   sun_reflect_ConstantPool::compute_offsets();
 
  3634   sun_reflect_UnsafeStaticFieldAccessorImpl::compute_offsets();
 
  3748   sun_reflect_UnsafeStaticFieldAccessorImpl::compute_offsets();
 
  3635   java_lang_reflect_Parameter::compute_offsets();
 
  3749   java_lang_reflect_Parameter::compute_offsets();
 
       
  3750   java_lang_StackFrameInfo::compute_offsets();
 
       
  3751   java_lang_LiveStackFrameInfo::compute_offsets();
 
  3636 
  3752 
  3637   // generated interpreter code wants to know about the offsets we just computed:
 
  3753   // generated interpreter code wants to know about the offsets we just computed:
 
  3638   AbstractAssembler::update_delayed_values();
 
  3754   AbstractAssembler::update_delayed_values();
 
  3639 }
 
  3755 }
 
  3640 
  3756
jdk-sandbox