1 /*
2 * Copyright (c) 1999, 2010, 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 #ifndef SHARE_VM_SHARK_SHARKSTATE_HPP
27 #define SHARE_VM_SHARK_SHARKSTATE_HPP
28
29 #include "ci/ciMethod.hpp"
30 #include "memory/allocation.hpp"
31 #include "shark/llvmHeaders.hpp"
32 #include "shark/sharkBuilder.hpp"
33 #include "shark/sharkInvariants.hpp"
34 #include "shark/sharkValue.hpp"
35
36 class SharkState : public SharkTargetInvariants {
37 public:
38 SharkState(const SharkTargetInvariants* parent)
39 : SharkTargetInvariants(parent),
40 _method(NULL),
41 _oop_tmp(NULL),
42 _has_safepointed(false) { initialize(NULL); }
43
44 SharkState(const SharkState* state)
45 : SharkTargetInvariants(state),
46 _method(state->_method),
47 _oop_tmp(state->_oop_tmp),
48 _has_safepointed(state->_has_safepointed) { initialize(state); }
49
50 private:
51 void initialize(const SharkState* state);
52
53 private:
54 llvm::Value* _method;
55 SharkValue** _locals;
56 SharkValue** _stack;
57 SharkValue** _sp;
58 int _num_monitors;
59 llvm::Value* _oop_tmp;
60 bool _has_safepointed;
61
62 // Method
63 public:
64 llvm::Value** method_addr() {
65 return &_method;
66 }
67 llvm::Value* method() const {
68 return _method;
69 }
70 protected:
71 void set_method(llvm::Value* method) {
72 _method = method;
73 }
74
75 // Local variables
76 public:
77 SharkValue** local_addr(int index) const {
78 assert(index >= 0 && index < max_locals(), "bad local variable index");
79 return &_locals[index];
80 }
81 SharkValue* local(int index) const {
82 return *local_addr(index);
83 }
84 void set_local(int index, SharkValue* value) {
85 *local_addr(index) = value;
86 }
87
88 // Expression stack
89 public:
90 SharkValue** stack_addr(int slot) const {
91 assert(slot >= 0 && slot < stack_depth(), "bad stack slot");
92 return &_sp[-(slot + 1)];
93 }
94 SharkValue* stack(int slot) const {
95 return *stack_addr(slot);
96 }
97 protected:
98 void set_stack(int slot, SharkValue* value) {
99 *stack_addr(slot) = value;
100 }
101 public:
102 int stack_depth() const {
103 return _sp - _stack;
104 }
105 void push(SharkValue* value) {
106 assert(stack_depth() < max_stack(), "stack overrun");
107 *(_sp++) = value;
108 }
109 SharkValue* pop() {
110 assert(stack_depth() > 0, "stack underrun");
111 return *(--_sp);
112 }
113
114 // Monitors
115 public:
116 int num_monitors() const {
117 return _num_monitors;
118 }
119 void set_num_monitors(int num_monitors) {
120 _num_monitors = num_monitors;
121 }
122
123 // Temporary oop slot
124 public:
125 llvm::Value** oop_tmp_addr() {
126 return &_oop_tmp;
127 }
128 llvm::Value* oop_tmp() const {
129 return _oop_tmp;
130 }
131 void set_oop_tmp(llvm::Value* oop_tmp) {
132 _oop_tmp = oop_tmp;
133 }
134
135 // Safepointed status
136 public:
137 bool has_safepointed() const {
138 return _has_safepointed;
139 }
140 void set_has_safepointed(bool has_safepointed) {
141 _has_safepointed = has_safepointed;
142 }
143
144 // Comparison
145 public:
146 bool equal_to(SharkState* other);
147
148 // Copy and merge
149 public:
150 SharkState* copy() const {
151 return new SharkState(this);
152 }
153 void merge(SharkState* other,
154 llvm::BasicBlock* other_block,
155 llvm::BasicBlock* this_block);
156
157 // Value replacement
158 public:
159 void replace_all(SharkValue* old_value, SharkValue* new_value);
160 };
161
162 class SharkTopLevelBlock;
163
164 // SharkNormalEntryState objects are used to create the state
165 // that the method will be entered with for a normal invocation.
166 class SharkNormalEntryState : public SharkState {
167 public:
168 SharkNormalEntryState(SharkTopLevelBlock* block,
169 llvm::Value* method);
170 };
171
172 // SharkOSREntryState objects are used to create the state
173 // that the method will be entered with for an OSR invocation.
174 class SharkOSREntryState : public SharkState {
175 public:
176 SharkOSREntryState(SharkTopLevelBlock* block,
177 llvm::Value* method,
178 llvm::Value* osr_buf);
179 };
180
181 // SharkPHIState objects are used to manage the entry state
182 // for blocks with more than one entry path or for blocks
183 // entered from blocks that will be compiled later.
184 class SharkPHIState : public SharkState {
185 public:
186 SharkPHIState(SharkTopLevelBlock* block);
187
188 private:
189 SharkTopLevelBlock* _block;
190
191 private:
192 SharkTopLevelBlock* block() const {
193 return _block;
194 }
195
196 public:
197 void add_incoming(SharkState* incoming_state);
198 };
199
200 #endif // SHARE_VM_SHARK_SHARKSTATE_HPP