Mercurial > hg > truffle
annotate src/share/vm/code/stubs.hpp @ 1721:413ad0331a0c
6977924: Changes for 6975078 produce build error with certain gcc versions
Summary: The changes introduced for 6975078 assign badHeapOopVal to the _allocation field in the ResourceObj class. In 32 bit linux builds with certain versions of gcc this assignment will be flagged as an error while compiling allocation.cpp. In 32 bit builds the constant value badHeapOopVal (which is cast to an intptr_t) is negative. The _allocation field is typed as an unsigned intptr_t and gcc catches this as an error.
Reviewed-by: jcoomes, ysr, phh
author | johnc |
---|---|
date | Wed, 18 Aug 2010 10:59:06 -0700 |
parents | c18cbe5936b8 |
children | f95d63e2154a |
rev | line source |
---|---|
0 | 1 /* |
1552
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
0
diff
changeset
|
2 * Copyright (c) 1997, 2002, Oracle and/or its affiliates. All rights reserved. |
0 | 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 * | |
1552
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
0
diff
changeset
|
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
0
diff
changeset
|
20 * or visit www.oracle.com if you need additional information or have any |
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
0
diff
changeset
|
21 * questions. |
0 | 22 * |
23 */ | |
24 | |
25 // The classes in this file provide a simple framework for the | |
26 // management of little pieces of machine code - or stubs - | |
27 // created on the fly and frequently discarded. In this frame- | |
28 // work stubs are stored in a queue. | |
29 | |
30 | |
31 // Stub serves as abstract base class. A concrete stub | |
32 // implementation is a subclass of Stub, implementing | |
33 // all (non-virtual!) functions required sketched out | |
34 // in the Stub class. | |
35 // | |
36 // A concrete stub layout may look like this (both data | |
37 // and code sections could be empty as well): | |
38 // | |
39 // ________ | |
40 // stub -->| | <--+ | |
41 // | data | | | |
42 // |________| | | |
43 // code_begin -->| | | | |
44 // | | | | |
45 // | code | | size | |
46 // | | | | |
47 // |________| | | |
48 // code_end -->| | | | |
49 // | data | | | |
50 // |________| | | |
51 // <--+ | |
52 | |
53 | |
54 class Stub VALUE_OBJ_CLASS_SPEC { | |
55 public: | |
56 // Initialization/finalization | |
57 void initialize(int size) { ShouldNotCallThis(); } // called to initialize/specify the stub's size | |
58 void finalize() { ShouldNotCallThis(); } // called before the stub is deallocated | |
59 | |
60 // General info/converters | |
61 int size() const { ShouldNotCallThis(); return 0; } // must return the size provided by initialize | |
62 static int code_size_to_size(int code_size) { ShouldNotCallThis(); return 0; } // computes the size given the code size | |
63 | |
64 // Code info | |
65 address code_begin() const { ShouldNotCallThis(); return NULL; } // points to the first byte of the code | |
66 address code_end() const { ShouldNotCallThis(); return NULL; } // points to the first byte after the code | |
67 | |
68 // Debugging | |
69 void verify() { ShouldNotCallThis(); } // verifies the Stub | |
70 void print() { ShouldNotCallThis(); } // prints some information about the stub | |
71 }; | |
72 | |
73 | |
74 // A stub interface defines the interface between a stub queue | |
75 // and the stubs it queues. In order to avoid a vtable and | |
76 // (and thus the extra word) in each stub, a concrete stub | |
77 // interface object is created and associated with a stub | |
78 // buffer which in turn uses the stub interface to interact | |
79 // with its stubs. | |
80 // | |
81 // StubInterface serves as an abstract base class. A concrete | |
82 // stub interface implementation is a subclass of StubInterface, | |
83 // forwarding its virtual function calls to non-virtual calls | |
84 // of the concrete stub (see also macro below). There's exactly | |
85 // one stub interface instance required per stub queue. | |
86 | |
87 class StubInterface: public CHeapObj { | |
88 public: | |
89 // Initialization/finalization | |
90 virtual void initialize(Stub* self, int size) = 0; // called after creation (called twice if allocated via (request, commit)) | |
91 virtual void finalize(Stub* self) = 0; // called before deallocation | |
92 | |
93 // General info/converters | |
94 virtual int size(Stub* self) const = 0; // the total size of the stub in bytes (must be a multiple of CodeEntryAlignment) | |
95 virtual int code_size_to_size(int code_size) const = 0; // computes the total stub size in bytes given the code size in bytes | |
96 | |
97 // Code info | |
98 virtual address code_begin(Stub* self) const = 0; // points to the first code byte | |
99 virtual address code_end(Stub* self) const = 0; // points to the first byte after the code | |
100 | |
101 // Debugging | |
102 virtual void verify(Stub* self) = 0; // verifies the stub | |
103 virtual void print(Stub* self) = 0; // prints information about the stub | |
104 }; | |
105 | |
106 | |
107 // DEF_STUB_INTERFACE is used to create a concrete stub interface | |
108 // class, forwarding stub interface calls to the corresponding | |
109 // stub calls. | |
110 | |
111 #define DEF_STUB_INTERFACE(stub) \ | |
112 class stub##Interface: public StubInterface { \ | |
113 private: \ | |
114 static stub* cast(Stub* self) { return (stub*)self; } \ | |
115 \ | |
116 public: \ | |
117 /* Initialization/finalization */ \ | |
118 virtual void initialize(Stub* self, int size) { cast(self)->initialize(size); } \ | |
119 virtual void finalize(Stub* self) { cast(self)->finalize(); } \ | |
120 \ | |
121 /* General info */ \ | |
122 virtual int size(Stub* self) const { return cast(self)->size(); } \ | |
123 virtual int code_size_to_size(int code_size) const { return stub::code_size_to_size(code_size); } \ | |
124 \ | |
125 /* Code info */ \ | |
126 virtual address code_begin(Stub* self) const { return cast(self)->code_begin(); } \ | |
127 virtual address code_end(Stub* self) const { return cast(self)->code_end(); } \ | |
128 \ | |
129 /* Debugging */ \ | |
130 virtual void verify(Stub* self) { cast(self)->verify(); } \ | |
131 virtual void print(Stub* self) { cast(self)->print(); } \ | |
132 }; | |
133 | |
134 | |
135 // A StubQueue maintains a queue of stubs. | |
136 // Note: All sizes (spaces) are given in bytes. | |
137 | |
138 class StubQueue: public CHeapObj { | |
139 friend class VMStructs; | |
140 private: | |
141 StubInterface* _stub_interface; // the interface prototype | |
142 address _stub_buffer; // where all stubs are stored | |
143 int _buffer_size; // the buffer size in bytes | |
144 int _buffer_limit; // the (byte) index of the actual buffer limit (_buffer_limit <= _buffer_size) | |
145 int _queue_begin; // the (byte) index of the first queue entry (word-aligned) | |
146 int _queue_end; // the (byte) index of the first entry after the queue (word-aligned) | |
147 int _number_of_stubs; // the number of buffered stubs | |
148 Mutex* const _mutex; // the lock used for a (request, commit) transaction | |
149 | |
150 void check_index(int i) const { assert(0 <= i && i < _buffer_limit && i % CodeEntryAlignment == 0, "illegal index"); } | |
151 bool is_contiguous() const { return _queue_begin <= _queue_end; } | |
152 int index_of(Stub* s) const { int i = (address)s - _stub_buffer; check_index(i); return i; } | |
153 Stub* stub_at(int i) const { check_index(i); return (Stub*)(_stub_buffer + i); } | |
154 Stub* current_stub() const { return stub_at(_queue_end); } | |
155 | |
156 // Stub functionality accessed via interface | |
157 void stub_initialize(Stub* s, int size) { assert(size % CodeEntryAlignment == 0, "size not aligned"); _stub_interface->initialize(s, size); } | |
158 void stub_finalize(Stub* s) { _stub_interface->finalize(s); } | |
159 int stub_size(Stub* s) const { return _stub_interface->size(s); } | |
160 bool stub_contains(Stub* s, address pc) const { return _stub_interface->code_begin(s) <= pc && pc < _stub_interface->code_end(s); } | |
161 int stub_code_size_to_size(int code_size) const { return _stub_interface->code_size_to_size(code_size); } | |
162 void stub_verify(Stub* s) { _stub_interface->verify(s); } | |
163 void stub_print(Stub* s) { _stub_interface->print(s); } | |
164 | |
165 static void register_queue(StubQueue*); | |
166 | |
167 public: | |
168 StubQueue(StubInterface* stub_interface, int buffer_size, Mutex* lock, | |
169 const char* name); | |
170 ~StubQueue(); | |
171 | |
172 // General queue info | |
173 bool is_empty() const { return _queue_begin == _queue_end; } | |
174 int total_space() const { return _buffer_size - 1; } | |
175 int available_space() const { int d = _queue_begin - _queue_end - 1; return d < 0 ? d + _buffer_size : d; } | |
176 int used_space() const { return total_space() - available_space(); } | |
177 int number_of_stubs() const { return _number_of_stubs; } | |
178 bool contains(address pc) const { return _stub_buffer <= pc && pc < _stub_buffer + _buffer_limit; } | |
179 Stub* stub_containing(address pc) const; | |
180 address code_start() const { return _stub_buffer; } | |
181 address code_end() const { return _stub_buffer + _buffer_limit; } | |
182 | |
183 // Stub allocation (atomic transactions) | |
184 Stub* request_committed(int code_size); // request a stub that provides exactly code_size space for code | |
185 Stub* request(int requested_code_size); // request a stub with a (maximum) code space - locks the queue | |
186 void commit (int committed_code_size); // commit the previously requested stub - unlocks the queue | |
187 | |
188 // Stub deallocation | |
189 void remove_first(); // remove the first stub in the queue | |
190 void remove_first(int n); // remove the first n stubs in the queue | |
191 void remove_all(); // remove all stubs in the queue | |
192 | |
193 // Iteration | |
194 static void queues_do(void f(StubQueue* s)); // call f with each StubQueue | |
195 void stubs_do(void f(Stub* s)); // call f with all stubs | |
196 Stub* first() const { return number_of_stubs() > 0 ? stub_at(_queue_begin) : NULL; } | |
197 Stub* next(Stub* s) const { int i = index_of(s) + stub_size(s); | |
198 if (i == _buffer_limit) i = 0; | |
199 return (i == _queue_end) ? NULL : stub_at(i); | |
200 } | |
201 | |
202 address stub_code_begin(Stub* s) const { return _stub_interface->code_begin(s); } | |
203 address stub_code_end(Stub* s) const { return _stub_interface->code_end(s); } | |
204 | |
205 // Debugging/printing | |
206 void verify(); // verifies the stub queue | |
207 void print(); // prints information about the stub queue | |
208 }; |