1 /*
2 * Copyright (c) 2003, 2010, Oracle and/or its affiliates. All rights reserved.
3 * Copyright 2007 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 CPU_ZERO_VM_NATIVEINST_ZERO_HPP
27 #define CPU_ZERO_VM_NATIVEINST_ZERO_HPP
28
29 #include "asm/assembler.hpp"
30 #include "memory/allocation.hpp"
31 #include "runtime/icache.hpp"
32 #include "runtime/os.hpp"
33 #include "utilities/top.hpp"
34
35 // We have interfaces for the following instructions:
36 // - NativeInstruction
37 // - - NativeCall
38 // - - NativeMovConstReg
39 // - - NativeMovConstRegPatching
40 // - - NativeJump
41 // - - NativeIllegalOpCode
42 // - - NativeReturn
43 // - - NativeReturnX (return with argument)
44 // - - NativePushConst
45 // - - NativeTstRegMem
46
47 // The base class for different kinds of native instruction abstractions.
48 // Provides the primitive operations to manipulate code relative to this.
49
50 class NativeInstruction VALUE_OBJ_CLASS_SPEC {
51 public:
52 bool is_jump() {
53 ShouldNotCallThis();
54 return false;
55 }
56
57 bool is_safepoint_poll() {
58 ShouldNotCallThis();
59 return false;
60 }
61 };
62
63 inline NativeInstruction* nativeInstruction_at(address address) {
64 ShouldNotCallThis();
65 return NULL;
66 }
67
68 class NativeCall : public NativeInstruction {
69 public:
70 enum zero_specific_constants {
71 instruction_size = 0 // not used within the interpreter
72 };
73
74 address instruction_address() const {
75 ShouldNotCallThis();
76 return NULL;
77 }
78
79 address next_instruction_address() const {
80 ShouldNotCallThis();
81 return NULL;
82 }
83
84 address return_address() const {
85 ShouldNotCallThis();
86 return NULL;
87 }
88
89 address destination() const {
90 ShouldNotCallThis();
91 return NULL;
92 }
93
94 void set_destination_mt_safe(address dest) {
95 ShouldNotCallThis();
96 }
97
98 void verify_alignment() {
99 ShouldNotCallThis();
100 }
101
102 void verify() {
103 ShouldNotCallThis();
104 }
105
106 static bool is_call_before(address return_address) {
107 ShouldNotCallThis();
108 return false;
109 }
110 };
111
112 inline NativeCall* nativeCall_before(address return_address) {
113 ShouldNotCallThis();
114 return NULL;
115 }
116
117 inline NativeCall* nativeCall_at(address address) {
118 ShouldNotCallThis();
119 return NULL;
120 }
121
122 class NativeMovConstReg : public NativeInstruction {
123 public:
124 address next_instruction_address() const {
125 ShouldNotCallThis();
126 return NULL;
127 }
128
129 intptr_t data() const {
130 ShouldNotCallThis();
131 return 0;
132 }
133
134 void set_data(intptr_t x) {
135 ShouldNotCallThis();
136 }
137 };
138
139 inline NativeMovConstReg* nativeMovConstReg_at(address address) {
140 ShouldNotCallThis();
141 return NULL;
142 }
143
144 class NativeMovRegMem : public NativeInstruction {
145 public:
146 int offset() const {
147 ShouldNotCallThis();
148 return 0;
149 }
150
151 void set_offset(intptr_t x) {
152 ShouldNotCallThis();
153 }
154
155 void add_offset_in_bytes(int add_offset) {
156 ShouldNotCallThis();
157 }
158 };
159
160 inline NativeMovRegMem* nativeMovRegMem_at(address address) {
161 ShouldNotCallThis();
162 return NULL;
163 }
164
165 class NativeJump : public NativeInstruction {
166 public:
167 enum zero_specific_constants {
168 instruction_size = 0 // not used within the interpreter
169 };
170
171 address jump_destination() const {
172 ShouldNotCallThis();
173 return NULL;
174 }
175
176 void set_jump_destination(address dest) {
177 ShouldNotCallThis();
178 }
179
180 static void check_verified_entry_alignment(address entry,
181 address verified_entry) {
182 }
183
184 static void patch_verified_entry(address entry,
185 address verified_entry,
186 address dest);
187 };
188
189 inline NativeJump* nativeJump_at(address address) {
190 ShouldNotCallThis();
191 return NULL;
192 }
193
194 class NativeGeneralJump : public NativeInstruction {
195 public:
196 address jump_destination() const {
197 ShouldNotCallThis();
198 return NULL;
199 }
200
201 static void insert_unconditional(address code_pos, address entry) {
202 ShouldNotCallThis();
203 }
204
205 static void replace_mt_safe(address instr_addr, address code_buffer) {
206 ShouldNotCallThis();
207 }
208 };
209
210 inline NativeGeneralJump* nativeGeneralJump_at(address address) {
211 ShouldNotCallThis();
212 return NULL;
213 }
214
215 #endif // CPU_ZERO_VM_NATIVEINST_ZERO_HPP