Mercurial > hg > graal-compiler

comparison graal/com.oracle.jvmci.hotspot/src/com/oracle/jvmci/hotspot/HotSpotReferenceMap.java @ 21551:5324104ac4f3

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
moved com.oracle.graal.hotspot.jvmci classes to com.oracle.jvmci.hotspot module (JBS:GRAAL-53)
author Doug Simon <doug.simon@oracle.com>
date Tue, 26 May 2015 17:13:37 +0200
parents
children
comparison
equal deleted inserted replaced
21550:f48a6cea31eb 21551:5324104ac4f3
1 /*
2 * Copyright (c) 2009, 2014, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation.
8 *
9 * This code is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
12 * version 2 for more details (a copy is included in the LICENSE file that
13 * accompanied this code).
14 *
15 * You should have received a copy of the GNU General Public License version
16 * 2 along with this work; if not, write to the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 */
23 package com.oracle.jvmci.hotspot;
24
25 import java.util.*;
26
27 import com.oracle.graal.api.code.CodeUtil.RefMapFormatter;
28 import com.oracle.graal.api.code.*;
29 import com.oracle.graal.api.meta.*;
30 import com.oracle.jvmci.common.*;
31
32 public final class HotSpotReferenceMap extends ReferenceMap {
33
34 static final int OOP64 = 0b1010;
35 static final int OOP32 = 0b01;
36 static final int NARROW_LOW = OOP32;
37 static final int NARROW_HIGH = OOP32 << 2;
38 static final int NARROW_BOTH = NARROW_LOW | NARROW_HIGH;
39
40 private enum MapEntry {
41 NoReference(0),
42 WideOop(OOP64),
43 NarrowOopLowerHalf(NARROW_LOW),
44 NarrowOopUpperHalf(NARROW_HIGH),
45 TwoNarrowOops(NARROW_BOTH),
46 Illegal(-1);
47
48 MapEntry(int pattern) {
49 this.pattern = pattern;
50 }
51
52 final int pattern;
53
54 /**
55 * Create enum values from OopMap.
56 * <p>
57 * These bits can have the following values (MSB first):
58 *
59 * <pre>
60 * 0000 - contains no references
61 * 1010 - contains a wide oop
62 * 0001 - contains a narrow oop in the lower half
63 * 0101 - contains a narrow oop in the upper half
64 * 0101 - contains two narrow oops
65 * </pre>
66 *
67 * @see HotSpotReferenceMap#registerRefMap
68 * @see HotSpotReferenceMap#frameRefMap
69 */
70 static MapEntry getFromBits(int idx, HotSpotOopMap set) {
71 int n = set.get(idx);
72 switch (n) {
73 case 0:
74 return NoReference;
75 case OOP64:
76 return WideOop;
77 case NARROW_LOW:
78 return NarrowOopLowerHalf;
79 case NARROW_HIGH:
80 return NarrowOopUpperHalf;
81 case NARROW_BOTH:
82 return TwoNarrowOops;
83 default:
84 return Illegal;
85 }
86 }
87
88 String toBitString() {
89 int bits = toBit(this);
90 if (bits == -1) {
91 return "---";
92 }
93 return String.format("%3s", Integer.toBinaryString(bits)).replace(' ', '0');
94 }
95
96 static int toBit(MapEntry type) {
97 return type.pattern;
98 }
99 }
100
101 /**
102 * A specialized bit set that represents both wide and narrow oops in an efficient manner. The
103 * map consists of 4 bit entries that represent 8 bytes of memory.
104 *
105 */
106 class HotSpotOopMap implements Cloneable {
107
108 /**
109 * Each entry is 4 bits long and covers 8 bytes of memory.
110 */
111 private static final int BITS_PER_ENTRY = 4;
112 private static final int BITS_PER_ELEMENT = 64;
113
114 public HotSpotOopMap(int i) {
115 words = new long[(i * BITS_PER_ENTRY + BITS_PER_ELEMENT) / BITS_PER_ELEMENT];
116 }
117
118 public HotSpotOopMap(HotSpotOopMap other) {
119 words = other.words.clone();
120 }
121
122 private long[] words;
123
124 private int get(int i) {
125 return getEntry(i);
126 }
127
128 public void or(HotSpotOopMap src) {
129 if (words.length < src.words.length) {
130 long[] newWords = new long[src.words.length];
131 System.arraycopy(src.words, 0, newWords, 0, src.words.length);
132 for (int i = 0; i < words.length; i++) {
133 newWords[i] |= words[i];
134 }
135 words = newWords;
136 } else {
137 for (int i = 0; i < src.words.length; i++) {
138 words[i] |= src.words[i];
139 }
140 }
141 }
142
143 private void setOop(int regIdx) {
144 setEntry(regIdx, OOP64);
145 }
146
147 public int size() {
148 return words.length * BITS_PER_ELEMENT / BITS_PER_ENTRY;
149 }
150
151 @Override
152 public HotSpotOopMap clone() {
153 return new HotSpotOopMap(this);
154 }
155
156 private void setNarrowOop(int offset) {
157 setNarrowEntry(offset, OOP32);
158 }
159
160 private void setEntry(int regIdx, int value) {
161 assert regIdx % 2 == 0 : "must be alinged";
162 int bitIndex = (regIdx >> 1) * BITS_PER_ENTRY;
163 int wordIndex = bitIndex / BITS_PER_ELEMENT;
164 int shift = bitIndex - wordIndex * BITS_PER_ELEMENT;
165 if (wordIndex >= words.length) {
166 if (value == 0) {
167 // Nothing to do since bits are clear
168 return;
169 }
170 words = Arrays.copyOf(words, wordIndex + 1);
171 }
172 assert verifyUpdate(this, this);
173 long orig = words[wordIndex];
174 words[wordIndex] = (orig & (~(0b1111L << shift))) | ((long) value << shift);
175 assert get(regIdx / 2) == value;
176 assert verifyUpdate(this, this);
177 }
178
179 private void setNarrowEntry(int offset, int value) {
180 int regIdx = offset >> 1;
181 boolean low = offset % 2 == 0;
182 int bitIndex = regIdx * BITS_PER_ENTRY;
183 int wordIndex = bitIndex / BITS_PER_ELEMENT;
184 int shift = bitIndex - wordIndex * BITS_PER_ELEMENT;
185 if (wordIndex >= words.length) {
186 if (value == 0) {
187 // Nothing to do since bits are clear
188 return;
189 }
190 words = Arrays.copyOf(words, wordIndex + 1);
191 }
192 long originalValue = words[wordIndex];
193 int current = ((int) (originalValue >> shift)) & 0b1111;
194 if (current == OOP64) {
195 current = 0;
196 }
197 long newValue;
198 if (value != 0) {
199 newValue = current | (low ? value : (value << 2));
200 } else {
201 newValue = current & (low ? 0b1100 : 0b0011);
202 }
203 long masked = originalValue & (~(0b1111L << shift));
204 words[wordIndex] = masked | (newValue << shift);
205 assert verifyUpdate(this, this);
206 }
207
208 private int getEntry(int regIdx) {
209 int bitIndex = regIdx * BITS_PER_ENTRY;
210 int wordIndex = bitIndex / BITS_PER_ELEMENT;
211 int shift = bitIndex - wordIndex * BITS_PER_ELEMENT;
212 return ((int) (words[wordIndex] >>> shift)) & 0b1111;
213 }
214
215 @Override
216 public boolean equals(Object other) {
217 if (this == other) {
218 return true;
219 }
220
221 if (other instanceof HotSpotOopMap) {
222 HotSpotOopMap otherMap = (HotSpotOopMap) other;
223 int limit = Math.min(words.length, otherMap.words.length);
224 for (int i = 0; i < limit; i++) {
225 if (words[i] != otherMap.words[i]) {
226 return false;
227 }
228 }
229 for (int i = limit; i < words.length; i++) {
230 if (words[i] != 0) {
231 return false;
232 }
233 }
234 for (int i = limit; i < otherMap.words.length; i++) {
235 if (otherMap.words[i] != 0) {
236 return false;
237 }
238 }
239 return true;
240 }
241 return false;
242 }
243
244 @Override
245 public int hashCode() {
246 long h = 1234;
247 for (int i = words.length; --i >= 0;) {
248 h ^= words[i] * (i + 1);
249 }
250 return (int) ((h >> 32) ^ h);
251 }
252
253 @Override
254 public String toString() {
255 int count = 0;
256 StringBuilder sb = new StringBuilder();
257 sb.append("[");
258 for (int idx = 0; idx < size(); idx++) {
259 MapEntry dstType = MapEntry.getFromBits(idx, this);
260 if (dstType == MapEntry.NoReference) {
261 continue;
262 }
263 if (count > 0) {
264 sb.append(", ");
265 }
266 if (dstType == MapEntry.Illegal) {
267 int value = get(idx);
268 sb.append("0x");
269 sb.append(Integer.toHexString(value));
270 } else {
271 sb.append(idx);
272 sb.append(':');
273 sb.append(dstType);
274 }
275 count++;
276 }
277 sb.append("]");
278 return sb.toString();
279 }
280 }
281
282 /**
283 * Contains 3 bits per scalar register, and n*3 bits per n-word vector register (e.g., on a
284 * 64-bit system, a 256-bit vector register requires 12 reference map bits).
285 * <p>
286 * These bits can have the following values (LSB first):
287 *
288 * <pre>
289 * 000 - contains no references
290 * 100 - contains a wide oop
291 * 110 - contains a narrow oop in the lower half
292 * 101 - contains a narrow oop in the upper half
293 * 111 - contains two narrow oops
294 * </pre>
295 */
296 private final HotSpotOopMap registerRefMap;
297
298 /**
299 * Contains 3 bits per stack word.
300 * <p>
301 * These bits can have the following values (LSB first):
302 *
303 * <pre>
304 * 000 - contains no references
305 * 100 - contains a wide oop
306 * 110 - contains a narrow oop in the lower half
307 * 101 - contains a narrow oop in the upper half
308 * 111 - contains two narrow oops
309 * </pre>
310 */
311 private final HotSpotOopMap frameRefMap;
312
313 private final TargetDescription target;
314
315 public HotSpotReferenceMap(int registerCount, int frameSlotCount, TargetDescription target) {
316 if (registerCount > 0) {
317 this.registerRefMap = new HotSpotOopMap(registerCount);
318 } else {
319 this.registerRefMap = null;
320 }
321 this.frameRefMap = new HotSpotOopMap(frameSlotCount);
322 this.target = target;
323 }
324
325 private HotSpotReferenceMap(HotSpotReferenceMap other) {
326 this.registerRefMap = other.registerRefMap.clone();
327 this.frameRefMap = other.frameRefMap.clone();
328 this.target = other.target;
329 }
330
331 @Override
332 public ReferenceMap clone() {
333 return new HotSpotReferenceMap(this);
334 }
335
336 // setters
337 @Override
338 public void setRegister(int idx, LIRKind kind) {
339 set(registerRefMap, idx * 2, kind);
340 }
341
342 @Override
343 public void setStackSlot(int offset, LIRKind kind) {
344 assert offset % bytesPerElement(kind) == 0 : "unaligned value in ReferenceMap";
345 set(frameRefMap, offset / 4, kind);
346 }
347
348 private void set(HotSpotOopMap refMap, int index, LIRKind kind) {
349 if (kind.isDerivedReference()) {
350 throw new JVMCIError("derived reference cannot be inserted in ReferenceMap");
351 }
352
353 int bytesPerElement = bytesPerElement(kind);
354 int length = kind.getPlatformKind().getVectorLength();
355 if (bytesPerElement == 8) {
356 for (int i = 0; i < length; i++) {
357 if (kind.isReference(i)) {
358 refMap.setOop(index + i * 2);
359 }
360 }
361 } else if (bytesPerElement == 4) {
362 for (int i = 0; i < length; i++) {
363 if (kind.isReference(i)) {
364 refMap.setNarrowOop(index + i);
365 }
366 }
367 } else {
368 assert kind.isValue() : "unknown reference kind " + kind;
369 }
370 }
371
372 private int bytesPerElement(LIRKind kind) {
373 PlatformKind platformKind = kind.getPlatformKind();
374 return target.getSizeInBytes(platformKind) / platformKind.getVectorLength();
375 }
376
377 public HotSpotOopMap getFrameMap() {
378 return frameRefMap == null ? null : (HotSpotOopMap) frameRefMap.clone();
379 }
380
381 public HotSpotOopMap getRegisterMap() {
382 return registerRefMap == null ? null : (HotSpotOopMap) registerRefMap.clone();
383 }
384
385 static MapEntry[] entries(HotSpotOopMap fixedMap) {
386 MapEntry[] result = new MapEntry[fixedMap.size()];
387 for (int idx = 0; idx < fixedMap.size(); idx++) {
388 MapEntry dstType = MapEntry.getFromBits(idx, fixedMap);
389 result[idx] = dstType;
390 }
391 return result;
392 }
393
394 private static boolean verifyUpdate(HotSpotOopMap dst, HotSpotOopMap src) {
395 return verifyUpdate(dst, src, true);
396 }
397
398 private static boolean verifyUpdate(HotSpotOopMap dst, HotSpotOopMap src, boolean doAssert) {
399 for (int idx = 0; idx < Math.min(src.size(), dst.size()); idx++) {
400 if (!verifyUpdateEntry(idx, dst, src, doAssert)) {
401 return false;
402 }
403 }
404 return true;
405 }
406
407 private static boolean verifyUpdateEntry(int idx, HotSpotOopMap dst, HotSpotOopMap src, boolean doAssert) {
408 MapEntry dstType = MapEntry.getFromBits(idx, dst);
409 MapEntry srcType = MapEntry.getFromBits(idx, src);
410
411 if (dstType == MapEntry.Illegal || srcType == MapEntry.Illegal) {
412 assert !doAssert : String.format("Illegal RefMap bit pattern: %s (0b%s), %s (0b%s)", dstType, dstType.toBitString(), srcType, srcType.toBitString());
413 return false;
414 }
415 switch (dstType) {
416 case NoReference:
417 return true;
418 case WideOop:
419 switch (srcType) {
420 case NoReference:
421 case WideOop:
422 return true;
423 default:
424 assert false : String.format("Illegal RefMap combination: %s (0b%s), %s (0b%s)", dstType, dstType.toBitString(), srcType, srcType.toBitString());
425 return false;
426 }
427 case TwoNarrowOops:
428 case NarrowOopLowerHalf:
429 case NarrowOopUpperHalf:
430 switch (srcType) {
431 case TwoNarrowOops:
432 case NarrowOopLowerHalf:
433 case NarrowOopUpperHalf:
434 case NoReference:
435 return true;
436 default:
437 assert false : String.format("Illegal RefMap combination: %s (0b%s), %s (0b%s)", dstType, dstType.toBitString(), srcType, srcType.toBitString());
438 return false;
439 }
440 default:
441 return false;
442 }
443 }
444
445 @Override
446 public int hashCode() {
447 throw new UnsupportedOperationException();
448 }
449
450 @Override
451 public boolean equals(Object obj) {
452 if (this == obj) {
453 return true;
454 }
455 if (obj instanceof HotSpotReferenceMap) {
456 HotSpotReferenceMap that = (HotSpotReferenceMap) obj;
457 if (this.frameRefMap.equals(that.frameRefMap) && Objects.equals(this.registerRefMap, that.registerRefMap) && this.target.equals(that.target)) {
458 return true;
459 }
460 }
461 return false;
462 }
463
464 @Override
465 public boolean hasRegisterRefMap() {
466 return registerRefMap != null && registerRefMap.size() > 0;
467 }
468
469 @Override
470 public boolean hasFrameRefMap() {
471 return frameRefMap != null && frameRefMap.size() > 0;
472 }
473
474 @Override
475 public void appendRegisterMap(StringBuilder sb, RefMapFormatter formatter) {
476 for (int idx = 0; idx < registerRefMap.size(); idx++) {
477 MapEntry dstType = MapEntry.getFromBits(idx, registerRefMap);
478 if (dstType != MapEntry.NoReference) {
479 sb.append(' ').append(formatter.formatRegister(idx)).append(':').append(dstType);
480 }
481 }
482 }
483
484 @Override
485 public void appendFrameMap(StringBuilder sb, RefMapFormatter formatter) {
486 for (int idx = 0; idx < frameRefMap.size(); idx++) {
487 MapEntry dstType = MapEntry.getFromBits(idx, frameRefMap);
488 if (dstType != MapEntry.NoReference) {
489 sb.append(' ').append(formatter.formatStackSlot(idx)).append(':').append(dstType);
490 }
491 }
492 }
493
494 @Override
495 public String toString() {
496 StringBuilder sb = new StringBuilder();
497 if (registerRefMap != null) {
498 sb.append("Registers = ");
499 sb.append(registerRefMap);
500 }
501 sb.append("Stack = ");
502 sb.append(frameRefMap);
503 return sb.toString();
504 }
505
506 public void verify() {
507 assert verifyUpdate(frameRefMap, frameRefMap);
508 assert registerRefMap == null || verifyUpdate(registerRefMap, registerRefMap);
509 }
510 }