Mercurial > hg > truffle

comparison src/share/vm/shark/sharkState.hpp @ 1692:d2ede61b7a12

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
6976186: integrate Shark HotSpot changes Summary: Shark is a JIT compiler for Zero that uses the LLVM compiler infrastructure. Reviewed-by: kvn, twisti Contributed-by: Gary Benson <gbenson@redhat.com>
author twisti
date Wed, 11 Aug 2010 05:51:21 -0700
parents
children f95d63e2154a
comparison
equal deleted inserted replaced
1691:4a665be40fd3 1692:d2ede61b7a12
1 /*
2 * Copyright (c) 1999, 2007, Oracle and/or its affiliates. All rights reserved.
3 * Copyright 2008, 2009 Red Hat, Inc.
4 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
5 *
6 * This code is free software; you can redistribute it and/or modify it
7 * under the terms of the GNU General Public License version 2 only, as
8 * published by the Free Software Foundation.
9 *
10 * This code is distributed in the hope that it will be useful, but WITHOUT
11 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
12 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
13 * version 2 for more details (a copy is included in the LICENSE file that
14 * accompanied this code).
15 *
16 * You should have received a copy of the GNU General Public License version
17 * 2 along with this work; if not, write to the Free Software Foundation,
18 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
19 *
20 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
21 * or visit www.oracle.com if you need additional information or have any
22 * questions.
23 *
24 */
25
26 class SharkState : public SharkTargetInvariants {
27 public:
28 SharkState(const SharkTargetInvariants* parent)
29 : SharkTargetInvariants(parent),
30 _method(NULL),
31 _oop_tmp(NULL),
32 _has_safepointed(false) { initialize(NULL); }
33
34 SharkState(const SharkState* state)
35 : SharkTargetInvariants(state),
36 _method(state->_method),
37 _oop_tmp(state->_oop_tmp),
38 _has_safepointed(state->_has_safepointed) { initialize(state); }
39
40 private:
41 void initialize(const SharkState* state);
42
43 private:
44 llvm::Value* _method;
45 SharkValue** _locals;
46 SharkValue** _stack;
47 SharkValue** _sp;
48 int _num_monitors;
49 llvm::Value* _oop_tmp;
50 bool _has_safepointed;
51
52 // Method
53 public:
54 llvm::Value** method_addr() {
55 return &_method;
56 }
57 llvm::Value* method() const {
58 return _method;
59 }
60 protected:
61 void set_method(llvm::Value* method) {
62 _method = method;
63 }
64
65 // Local variables
66 public:
67 SharkValue** local_addr(int index) const {
68 assert(index >= 0 && index < max_locals(), "bad local variable index");
69 return &_locals[index];
70 }
71 SharkValue* local(int index) const {
72 return *local_addr(index);
73 }
74 void set_local(int index, SharkValue* value) {
75 *local_addr(index) = value;
76 }
77
78 // Expression stack
79 public:
80 SharkValue** stack_addr(int slot) const {
81 assert(slot >= 0 && slot < stack_depth(), "bad stack slot");
82 return &_sp[-(slot + 1)];
83 }
84 SharkValue* stack(int slot) const {
85 return *stack_addr(slot);
86 }
87 protected:
88 void set_stack(int slot, SharkValue* value) {
89 *stack_addr(slot) = value;
90 }
91 public:
92 int stack_depth() const {
93 return _sp - _stack;
94 }
95 void push(SharkValue* value) {
96 assert(stack_depth() < max_stack(), "stack overrun");
97 *(_sp++) = value;
98 }
99 SharkValue* pop() {
100 assert(stack_depth() > 0, "stack underrun");
101 return *(--_sp);
102 }
103
104 // Monitors
105 public:
106 int num_monitors() const {
107 return _num_monitors;
108 }
109 void set_num_monitors(int num_monitors) {
110 _num_monitors = num_monitors;
111 }
112
113 // Temporary oop slot
114 public:
115 llvm::Value** oop_tmp_addr() {
116 return &_oop_tmp;
117 }
118 llvm::Value* oop_tmp() const {
119 return _oop_tmp;
120 }
121 void set_oop_tmp(llvm::Value* oop_tmp) {
122 _oop_tmp = oop_tmp;
123 }
124
125 // Safepointed status
126 public:
127 bool has_safepointed() const {
128 return _has_safepointed;
129 }
130 void set_has_safepointed(bool has_safepointed) {
131 _has_safepointed = has_safepointed;
132 }
133
134 // Comparison
135 public:
136 bool equal_to(SharkState* other);
137
138 // Copy and merge
139 public:
140 SharkState* copy() const {
141 return new SharkState(this);
142 }
143 void merge(SharkState* other,
144 llvm::BasicBlock* other_block,
145 llvm::BasicBlock* this_block);
146
147 // Value replacement
148 public:
149 void replace_all(SharkValue* old_value, SharkValue* new_value);
150 };
151
152 class SharkTopLevelBlock;
153
154 // SharkNormalEntryState objects are used to create the state
155 // that the method will be entered with for a normal invocation.
156 class SharkNormalEntryState : public SharkState {
157 public:
158 SharkNormalEntryState(SharkTopLevelBlock* block,
159 llvm::Value* method);
160 };
161
162 // SharkOSREntryState objects are used to create the state
163 // that the method will be entered with for an OSR invocation.
164 class SharkOSREntryState : public SharkState {
165 public:
166 SharkOSREntryState(SharkTopLevelBlock* block,
167 llvm::Value* method,
168 llvm::Value* osr_buf);
169 };
170
171 // SharkPHIState objects are used to manage the entry state
172 // for blocks with more than one entry path or for blocks
173 // entered from blocks that will be compiled later.
174 class SharkPHIState : public SharkState {
175 public:
176 SharkPHIState(SharkTopLevelBlock* block);
177
178 private:
179 SharkTopLevelBlock* _block;
180
181 private:
182 SharkTopLevelBlock* block() const {
183 return _block;
184 }
185
186 public:
187 void add_incoming(SharkState* incoming_state);
188 };