Mercurial > hg > graal-compiler

comparison agent/src/share/classes/sun/jvm/hotspot/runtime/ia64/cInterpreter.java @ 0:a61af66fc99e jdk7-b24

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Initial load
author duke
date Sat, 01 Dec 2007 00:00:00 +0000
parents
children c18cbe5936b8
comparison
equal deleted inserted replaced
-1:000000000000 0:a61af66fc99e
1 /*
2 * Copyright 2003 Sun Microsystems, Inc. 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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
20 * CA 95054 USA or visit www.sun.com if you need additional information or
21 * have any questions.
22 *
23 */
24
25 package sun.jvm.hotspot.runtime.ia64;
26
27 import java.util.*;
28 // import sun.jvm.hotspot.asm.ia64.*;
29 import sun.jvm.hotspot.code.*;
30 import sun.jvm.hotspot.compiler.*;
31 import sun.jvm.hotspot.debugger.*;
32 import sun.jvm.hotspot.oops.*;
33 import sun.jvm.hotspot.runtime.*;
34 import sun.jvm.hotspot.types.*;
35 import sun.jvm.hotspot.utilities.*;
36
37 /** Specialization of and implementation of abstract methods of the
38 Frame class for the ia64 family of CPUs. */
39
40 public class cInterpreter extends VMObject {
41 private static final boolean DEBUG = true;
42
43 private static AddressField bcpField;
44 private static AddressField localsField;
45 private static AddressField constantsField;
46 private static AddressField methodField;
47 private static AddressField stackField; // i.e. tos
48 private static AddressField stackBaseField; // ultimate bottom of stack
49 private static AddressField stackLimitField; // ultimate top of stack
50 private static AddressField monitorBaseField;
51 private static CIntegerField messageField;
52 private static AddressField prevFieldField;
53 private static AddressField wrapperField;
54 private static AddressField prevField;
55
56 private static int NO_REQUEST;
57 private static int INITIALIZE;
58 private static int METHOD_ENTRY;
59 private static int METHOD_RESUME;
60 private static int GOT_MONITORS;
61 private static int RETHROW_EXCEPTION;
62 private static int CALL_METHOD;
63 private static int RETURN_FROM_METHOD;
64 private static int RETRY_METHOD;
65 private static int MORE_MONITORS;
66 private static int THROWING_EXCEPTION;
67 private static int POPPING_FRAME;
68
69 static {
70 VM.registerVMInitializedObserver(new Observer() {
71 public void update(Observable o, Object data) {
72 initialize(VM.getVM().getTypeDataBase());
73 }
74 });
75 }
76
77 private static synchronized void initialize(TypeDataBase db) {
78
79 Type cInterpreterType = db.lookupType("cInterpreter");
80 bcpField = cInterpreterType.getAddressField("_bcp");
81 localsField = cInterpreterType.getAddressField("_locals");
82 constantsField = cInterpreterType.getAddressField("_constants");
83 methodField = cInterpreterType.getAddressField("_method");
84 stackField = cInterpreterType.getAddressField("_stack");
85 stackBaseField = cInterpreterType.getAddressField("_stack_base");
86 stackLimitField = cInterpreterType.getAddressField("_stack_limit");
87 monitorBaseField = cInterpreterType.getAddressField("_monitor_base");
88 // messageField = cInterpreterType.getCIntegerField("_msg");
89 messageField = null;
90 wrapperField = cInterpreterType.getAddressField("_wrapper");
91 prevField = cInterpreterType.getAddressField("_prev_link");
92
93 /*
94 NO_REQUEST = db.lookupIntConstant("no_request").intValue();
95 INITIALIZE = db.lookupIntConstant("initialize").intValue();
96 METHOD_ENTRY = db.lookupIntConstant("method_entry").intValue();
97 METHOD_RESUME = db.lookupIntConstant("method_resume").intValue();
98 GOT_MONITORS = db.lookupIntConstant("got_monitors").intValue();
99 RETHROW_EXCEPTION = db.lookupIntConstant("rethrow_exception").intValue();
100 CALL_METHOD = db.lookupIntConstant("call_method").intValue();
101 RETURN_FROM_METHOD = db.lookupIntConstant("return_from_method").intValue();
102 RETRY_METHOD = db.lookupIntConstant("retry_method").intValue();
103 MORE_MONITORS = db.lookupIntConstant("more_monitors").intValue();
104 THROWING_EXCEPTION = db.lookupIntConstant("throwing_exception").intValue();
105 POPPING_FRAME = db.lookupIntConstant("popping_frame").intValue();
106 */
107 }
108
109
110 public cInterpreter(Address addr) {
111 super(addr);
112 }
113
114 public Address prev() {
115 return prevField.getValue(addr);
116 }
117
118 public Address locals() {
119
120 Address val = localsField.getValue(addr);
121 return val;
122 }
123
124 public Address localsAddr() {
125
126 Address localsAddr = localsField.getValue(addr);
127 return localsAddr;
128 }
129
130 public Address bcp() {
131
132 Address val = bcpField.getValue(addr);
133 return val;
134 }
135
136 public Address bcpAddr() {
137
138 Address bcpAddr = addr.addOffsetTo(bcpField.getOffset());
139 return bcpAddr;
140 }
141
142 public Address constants() {
143
144 Address val = constantsField.getValue(addr);
145 return val;
146 }
147
148 public Address constantsAddr() {
149
150 Address constantsAddr = constantsField.getValue(addr);
151 return constantsAddr;
152 }
153
154 public Address method() {
155
156 Address val = methodField.getValue(addr);
157 return val;
158 }
159 public Address methodAddr() {
160
161 Address methodAddr = addr.addOffsetTo(methodField.getOffset());
162 return methodAddr;
163 }
164
165 public Address stack() {
166
167 Address val = stackField.getValue(addr);
168 return val;
169 }
170
171 public Address stackBase() {
172
173 Address val = stackBaseField.getValue(addr);
174 return val;
175 }
176
177 public Address stackLimit() {
178
179 Address val = stackLimitField.getValue(addr);
180 return val;
181 }
182
183 public Address monitorBase() {
184
185 Address val = monitorBaseField.getValue(addr);
186 return val;
187 }
188
189 public Address wrapper() {
190
191 return wrapperField.getValue(addr);
192 }
193
194 public int message() {
195 int val = (int) messageField.getValue(addr);
196 return val;
197 }
198
199 }