1 /*
2 * Copyright (c) 2011, Oracle and/or its affiliates. All rights reserved.
3 * SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
4 *
5 *
6 *
7 *
8 *
9 *
10 *
11 *
12 *
13 *
14 *
15 *
16 *
17 *
18 *
19 *
20 *
21 *
22 *
23 */
24
25 package sun.jvm.hotspot.oops;
26
27 import java.io.*;
28 import java.util.*;
29 import sun.jvm.hotspot.debugger.*;
30 import sun.jvm.hotspot.runtime.*;
31 import sun.jvm.hotspot.types.*;
32 import sun.jvm.hotspot.utilities.*;
33
34 public class DataLayout {
35 public static final int noTag = 0;
36 public static final int bitDataTag = 1;
37 public static final int counterDataTag = 2;
38 public static final int jumpDataTag= 3;
39 public static final int receiverTypeDataTag = 4;
40 public static final int virtualCallDataTag = 5;
41 public static final int retDataTag = 6;
42 public static final int branchDataTag = 7;
43 public static final int multiBranchDataTag = 8;
44
45 // The _struct._flags word is formatted as [trapState:4 | flags:4].
46 // The trap state breaks down further as [recompile:1 | reason:3].
47 // This further breakdown is defined in deoptimization.cpp.
48 // See Deoptimization.trapStateReason for an assert that
49 // trapBits is big enough to hold reasons < reasonRecordedLimit.
50 //
51 // The trapState is collected only if ProfileTraps is true.
52 public static final int trapBits = 1+3; // 3: enough to distinguish [0..reasonRecordedLimit].
53 public static final int trapShift = 8 - trapBits;
54 public static final int trapMask = Bits.rightNBits(trapBits);
55 public static final int trapMaskInPlace = (trapMask << trapShift);
56 public static final int flagLimit = trapShift;
57 public static final int flagMask = Bits.rightNBits(flagLimit);
58 public static final int firstFlag = 0;
59
60 private Address data;
61
62 private int offset;
63
64 private boolean handlized;
65
66 public DataLayout(MethodData d, int o) {
67 data = d.getHandle();
68 offset = o;
69 }
70
71 public DataLayout(Address d, int o) {
72 data = d;
73 offset = o;
74 handlized = true;
75 }
76
77 public int dp() { return offset; }
78
79 private int getU11(int at) {
80 return data.getJByteAt(offset + at) & 0xff;
81 }
82
83 private int getU22(int at) {
84 return data.getJShortAt(offset + at) & 0xffff;
85 }
86
87 int cellAt(int index) {
88 // Cells are intptr_t sized but only contain ints as raw values
89 return (int)data.getCIntegerAt(offset + cellOffset(index), MethodData.cellSize, false);
90 }
91
92 Oop oopAt(int index) {
93 OopHandle handle;
94 if (handlized) {
95 throw new InternalError("unsupported");
96 }
97 handle = data.getOopHandleAt(offset + cellOffset(index));
98 return VM.getVM().getObjectHeap().newOop(handle);
99 }
100
101 public Address addressAt(int index) {
102 OopHandle handle;
103 if (handlized) {
104 return data.getAddressAt(offset + cellOffset(index));
105 } else {
106 return data.getOopHandleAt(offset + cellOffset(index));
107 }
108 }
109
110 // Every data layout begins with a header. This header
111 // contains a tag, which is used to indicate the size/layout
112 // of the data, 4 bits of flags, which can be used in any way,
113 // 4 bits of trap history (none/one reason/many reasons),
114 // and a bci, which is used to tie this piece of data to a
115 // specific bci in the bytecodes.
116 // union {
117 // intptrT _bits;
118 // struct {
119 // u1 _tag;
120 // u1 _flags;
121 // u2 _bci;
122 // } _struct;
123 // } _header;
124
125 // Some types of data layouts need a length field.
126 static boolean needsArrayLen(int tag) {
127 return (tag == multiBranchDataTag);
128 }
129
130 public static final int counterIncrement = 1;
131
132 // Size computation
133 static int headerSizeInBytes() {
134 return MethodData.cellSize;
135 }
136 static int headerSizeInCells() {
137 return 1;
138 }
139
140 static int computeSizeInBytes(int cellCount) {
141 return headerSizeInBytes() + cellCount * MethodData.cellSize;
142 }
143
144 // Initialization
145 // void initialize(int tag, int bci, int cellCount);
146
147 // Accessors
148 public int tag() {
149 return getU11(0);
150 }
151
152 // Return a few bits of trap state. Range is [0..trapMask].
153 // The state tells if traps with zero, one, or many reasons have occurred.
154 // It also tells whether zero or many recompilations have occurred.
155 // The associated trap histogram in the MDO itself tells whether
156 // traps are common or not. If a BCI shows that a trap X has
157 // occurred, and the MDO shows N occurrences of X, we make the
158 // simplifying assumption that all N occurrences can be blamed
159 // on that BCI.
160 int trapState() {
161 return (flags() >> trapShift) & trapMask;
162 }
163
164 int flags() {
165 return getU11(1);
166 }
167
168 int bci() {
169 return getU22(2);
170 }
171
172 boolean flagAt(int flagNumber) {
173 // assert(flagNumber < flagLimit, "oob");
174 return (flags() & (0x1 << flagNumber)) != 0;
175 }
176
177 // Low-level support for code generation.
178 static int headerOffset() {
179 return 0;
180 }
181 static int tagOffset() {
182 return 0;
183 }
184 static int flagsOffset() {
185 return 1;
186 }
187 static int bciOffset() {
188 return 2;
189 }
190 public static int cellOffset(int index) {
191 return MethodData.cellSize + index * MethodData.cellSize;
192 }
193 // // Return a value which, when or-ed as a byte into _flags, sets the flag.
194 // static int flagNumberToByteConstant(int flagNumber) {
195 // assert(0 <= flagNumber && flagNumber < flagLimit, "oob");
196 // DataLayout temp; temp.setHeader(0);
197 // temp.setFlagAt(flagNumber);
198 // return temp._header._struct._flags;
199 // }
200 // // Return a value which, when or-ed as a word into _header, sets the flag.
201 // static intptrT flagMaskToHeaderMask(int byteConstant) {
202 // DataLayout temp; temp.setHeader(0);
203 // temp._header._struct._flags = byteConstant;
204 // return temp._header._bits;
205 // }
206 }