truffle: src/share/vm/code/relocInfo.hpp comparison

comparison src/share/vm/code/relocInfo.hpp @ 1930:2d26b0046e0d

Merge.

author	Thomas Wuerthinger <wuerthinger@ssw.jku.at>
date	Tue, 30 Nov 2010 14:53:30 +0100
parents	0878d7bae69f
children	f95d63e2154a

comparison

equal deleted inserted replaced

-:6b7001391c97
+:2d26b0046e0d
 /*
-* Copyright 1997-2008 Sun Microsystems, Inc.  All Rights Reserved.
+* Copyright (c) 1997, 2010, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.
 *
 * You should have received a copy of the GNU General Public License version
 * 2 along with this work; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 *
-* Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
+* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
-* CA 95054 USA or visit www.sun.com if you need additional information or
+* or visit www.oracle.com if you need additional information or have any
-* have any questions.
+* questions.
 *
 */
 // Types in this file:
 //    relocInfo
 //      ...
 //     }
 //   }
 class RelocIterator : public StackObj {
-enum { SECT_CONSTS = 2,
+enum { SECT_LIMIT = 3 };  // must be equal to CodeBuffer::SECT_LIMIT, checked in ctor
-SECT_LIMIT = 3 };  // must be equal to CodeBuffer::SECT_LIMIT
 friend class Relocation;
 friend class relocInfo;       // for change_reloc_info_for_address only
 typedef relocInfo::relocType relocType;
 private:
 address    _limit;   // stop producing relocations after this _addr
 relocInfo* _current; // the current relocation information
 relocInfo* _end;     // end marker; we're done iterating when _current == _end
-CodeBlob*  _code;    // compiled method containing _addr
+nmethod*   _code;    // compiled method containing _addr
 address    _addr;    // instruction to which the relocation applies
 short      _databuf; // spare buffer for compressed data
 short*     _data;    // pointer to the relocation's data
 short      _datalen; // number of halfwords in _data
 char       _format;  // position within the instruction
 // Base addresses needed to compute targets of section_word_type relocs.
 address    _section_start[SECT_LIMIT];
+address    _section_end  [SECT_LIMIT];
 void set_has_current(bool b) {
 _datalen = !b ? -1 : 0;
 debug_only(_data = NULL);
 }
 void set_limits(address begin, address limit);
 void advance_over_prefix();    // helper method
-void initialize_misc() {
+void initialize_misc();
-set_has_current(false);
-for (int i = 0; i < SECT_LIMIT; i++) {
+void initialize(nmethod* nm, address begin, address limit);
-_section_start[i] = NULL;  // these will be lazily computed, if needed
-}
-}
-address compute_section_start(int n) const;  // out-of-line helper
-void initialize(CodeBlob* nm, address begin, address limit);
 friend class PatchingRelocIterator;
 // make an uninitialized one, for PatchingRelocIterator:
 RelocIterator() { initialize_misc(); }
 public:
 // constructor
-RelocIterator(CodeBlob* cb,    address begin = NULL, address limit = NULL);
+RelocIterator(nmethod* nm,     address begin = NULL, address limit = NULL);
 RelocIterator(CodeSection* cb, address begin = NULL, address limit = NULL);
 // get next reloc info, return !eos
 bool next() {
 _current++;
 address      limit()        const { return _limit; }
 void     set_limit(address x);
 relocType    type()         const { return current()->type(); }
 int          format()       const { return (relocInfo::have_format) ? current()->format() : 0; }
 address      addr()         const { return _addr; }
-CodeBlob*    code()         const { return _code; }
+nmethod*     code()         const { return _code; }
 short*       data()         const { return _data; }
 int          datalen()      const { return _datalen; }
 bool     has_current()      const { return _datalen >= 0; }
 void       set_addr(address addr) { _addr = addr; }
-bool   addr_in_const()      const { return addr() >= section_start(SECT_CONSTS); }
+bool   addr_in_const()      const;
 address section_start(int n) const {
-address res = _section_start[n];
+assert(_section_start[n], "must be initialized");
-return (res != NULL) ? res : compute_section_start(n);
+return _section_start[n];
+}
+address section_end(int n) const {
+assert(_section_end[n], "must be initialized");
+return _section_end[n];
 }
 // The address points to the affected displacement part of the instruction.
 // For RISC, this is just the whole instruction.
 // For Intel, this is an unaligned 32-bit word.
 address new_addr_for(address olda, const CodeBuffer* src, CodeBuffer* dest);
 void normalize_address(address& addr, const CodeSection* dest, bool allow_other_sections = false);
 public:
 // accessors which only make sense for a bound Relocation
-address   addr()         const { return binding()->addr(); }
+address  addr()         const { return binding()->addr(); }
-CodeBlob* code()         const { return binding()->code(); }
+nmethod* code()         const { return binding()->code(); }
-bool      addr_in_const() const { return binding()->addr_in_const(); }
+bool     addr_in_const() const { return binding()->addr_in_const(); }
 protected:
 short*   data()         const { return binding()->data(); }
 int      datalen()      const { return binding()->datalen(); }
 int      format()       const { return binding()->format(); }
 void clear_inline_cache();
 // Figure out where an ic_call is hiding, given a set-oop or call.
 // Either ic_call or first_oop must be non-null; the other is deduced.
-// Code if non-NULL must be the CodeBlob, else it is deduced.
+// Code if non-NULL must be the nmethod, else it is deduced.
 // The address of the patchable oop is also deduced.
 // The returned iterator will enumerate over the oops and the ic_call,
 // as well as any other relocations that happen to be in that span of code.
 // Recognize relevant set_oops with:  oop_reloc()->oop_addr() == oop_addr.
-static RelocIterator parse_ic(CodeBlob* &code, address &ic_call, address &first_oop, oop* &oop_addr, bool *is_optimized);
+static RelocIterator parse_ic(nmethod* &nm, address &ic_call, address &first_oop, oop* &oop_addr, bool *is_optimized);
 };
 class opt_virtual_call_Relocation : public CallRelocation {
 relocInfo::relocType type() { return relocInfo::opt_virtual_call_type; }
 return r;                                                     \
 }
 APPLY_TO_RELOCATIONS(EACH_CASE);
 #undef EACH_CASE
-inline RelocIterator::RelocIterator(CodeBlob* cb, address begin, address limit) {
+inline RelocIterator::RelocIterator(nmethod* nm, address begin, address limit) {
-initialize(cb, begin, limit);
+initialize(nm, begin, limit);
 }
 // if you are going to patch code, you should use this subclass of
 // RelocIterator
 class PatchingRelocIterator : public RelocIterator {
 // these are private and have no bodies defined because they should not be called
 PatchingRelocIterator(const RelocIterator&);
 void        operator=(const RelocIterator&);
 public:
-PatchingRelocIterator(CodeBlob* cb, address begin =NULL, address limit =NULL)
+PatchingRelocIterator(nmethod* nm, address begin = NULL, address limit = NULL)
-: RelocIterator(cb, begin, limit)                { prepass();  }
+: RelocIterator(nm, begin, limit)                { prepass();  }
 ~PatchingRelocIterator()                           { postpass(); }
 };

Mercurial > hg > truffle

comparison src/share/vm/code/relocInfo.hpp @ 1930:2d26b0046e0d