Mercurial > hg > graal-compiler

comparison src/cpu/zero/vm/nativeInst_zero.hpp @ 12077:e16282db4946

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
8022956: Clang: enable return type warnings on BSD Reviewed-by: coleenp, sla
author twisti
date Tue, 20 Aug 2013 10:57:50 -0700
parents f95d63e2154a
children de6a9e811145
comparison
equal deleted inserted replaced
12076:6725044c5725 12077:e16282db4946
49 49
50 class NativeInstruction VALUE_OBJ_CLASS_SPEC { 50 class NativeInstruction VALUE_OBJ_CLASS_SPEC {
51 public: 51 public:
52 bool is_jump() { 52 bool is_jump() {
53 ShouldNotCallThis(); 53 ShouldNotCallThis();
54 return false;
54 } 55 }
55 56
56 bool is_safepoint_poll() { 57 bool is_safepoint_poll() {
57 ShouldNotCallThis(); 58 ShouldNotCallThis();
59 return false;
58 } 60 }
59 }; 61 };
60 62
61 inline NativeInstruction* nativeInstruction_at(address address) { 63 inline NativeInstruction* nativeInstruction_at(address address) {
62 ShouldNotCallThis(); 64 ShouldNotCallThis();
65 return NULL;
63 } 66 }
64 67
65 class NativeCall : public NativeInstruction { 68 class NativeCall : public NativeInstruction {
66 public: 69 public:
67 enum zero_specific_constants { 70 enum zero_specific_constants {
68 instruction_size = 0 // not used within the interpreter 71 instruction_size = 0 // not used within the interpreter
69 }; 72 };
70 73
71 address instruction_address() const { 74 address instruction_address() const {
72 ShouldNotCallThis(); 75 ShouldNotCallThis();
76 return NULL;
73 } 77 }
74 78
75 address next_instruction_address() const { 79 address next_instruction_address() const {
76 ShouldNotCallThis(); 80 ShouldNotCallThis();
81 return NULL;
77 } 82 }
78 83
79 address return_address() const { 84 address return_address() const {
80 ShouldNotCallThis(); 85 ShouldNotCallThis();
86 return NULL;
81 } 87 }
82 88
83 address destination() const { 89 address destination() const {
84 ShouldNotCallThis(); 90 ShouldNotCallThis();
91 return NULL;
85 } 92 }
86 93
87 void set_destination_mt_safe(address dest) { 94 void set_destination_mt_safe(address dest) {
88 ShouldNotCallThis(); 95 ShouldNotCallThis();
89 } 96 }
96 ShouldNotCallThis(); 103 ShouldNotCallThis();
97 } 104 }
98 105
99 static bool is_call_before(address return_address) { 106 static bool is_call_before(address return_address) {
100 ShouldNotCallThis(); 107 ShouldNotCallThis();
108 return false;
101 } 109 }
102 }; 110 };
103 111
104 inline NativeCall* nativeCall_before(address return_address) { 112 inline NativeCall* nativeCall_before(address return_address) {
105 ShouldNotCallThis(); 113 ShouldNotCallThis();
114 return NULL;
106 } 115 }
107 116
108 inline NativeCall* nativeCall_at(address address) { 117 inline NativeCall* nativeCall_at(address address) {
109 ShouldNotCallThis(); 118 ShouldNotCallThis();
119 return NULL;
110 } 120 }
111 121
112 class NativeMovConstReg : public NativeInstruction { 122 class NativeMovConstReg : public NativeInstruction {
113 public: 123 public:
114 address next_instruction_address() const { 124 address next_instruction_address() const {
115 ShouldNotCallThis(); 125 ShouldNotCallThis();
126 return NULL;
116 } 127 }
117 128
118 intptr_t data() const { 129 intptr_t data() const {
119 ShouldNotCallThis(); 130 ShouldNotCallThis();
131 return 0;
120 } 132 }
121 133
122 void set_data(intptr_t x) { 134 void set_data(intptr_t x) {
123 ShouldNotCallThis(); 135 ShouldNotCallThis();
124 } 136 }
125 }; 137 };
126 138
127 inline NativeMovConstReg* nativeMovConstReg_at(address address) { 139 inline NativeMovConstReg* nativeMovConstReg_at(address address) {
128 ShouldNotCallThis(); 140 ShouldNotCallThis();
141 return NULL;
129 } 142 }
130 143
131 class NativeMovRegMem : public NativeInstruction { 144 class NativeMovRegMem : public NativeInstruction {
132 public: 145 public:
133 int offset() const { 146 int offset() const {
134 ShouldNotCallThis(); 147 ShouldNotCallThis();
148 return 0;
135 } 149 }
136 150
137 void set_offset(intptr_t x) { 151 void set_offset(intptr_t x) {
138 ShouldNotCallThis(); 152 ShouldNotCallThis();
139 } 153 }
143 } 157 }
144 }; 158 };
145 159
146 inline NativeMovRegMem* nativeMovRegMem_at(address address) { 160 inline NativeMovRegMem* nativeMovRegMem_at(address address) {
147 ShouldNotCallThis(); 161 ShouldNotCallThis();
162 return NULL;
148 } 163 }
149 164
150 class NativeJump : public NativeInstruction { 165 class NativeJump : public NativeInstruction {
151 public: 166 public:
152 enum zero_specific_constants { 167 enum zero_specific_constants {
153 instruction_size = 0 // not used within the interpreter 168 instruction_size = 0 // not used within the interpreter
154 }; 169 };
155 170
156 address jump_destination() const { 171 address jump_destination() const {
157 ShouldNotCallThis(); 172 ShouldNotCallThis();
173 return NULL;
158 } 174 }
159 175
160 void set_jump_destination(address dest) { 176 void set_jump_destination(address dest) {
161 ShouldNotCallThis(); 177 ShouldNotCallThis();
162 } 178 }
170 address dest); 186 address dest);
171 }; 187 };
172 188
173 inline NativeJump* nativeJump_at(address address) { 189 inline NativeJump* nativeJump_at(address address) {
174 ShouldNotCallThis(); 190 ShouldNotCallThis();
191 return NULL;
175 } 192 }
176 193
177 class NativeGeneralJump : public NativeInstruction { 194 class NativeGeneralJump : public NativeInstruction {
178 public: 195 public:
179 address jump_destination() const { 196 address jump_destination() const {
180 ShouldNotCallThis(); 197 ShouldNotCallThis();
198 return NULL;
181 } 199 }
182 200
183 static void insert_unconditional(address code_pos, address entry) { 201 static void insert_unconditional(address code_pos, address entry) {
184 ShouldNotCallThis(); 202 ShouldNotCallThis();
185 } 203 }
189 } 207 }
190 }; 208 };
191 209
192 inline NativeGeneralJump* nativeGeneralJump_at(address address) { 210 inline NativeGeneralJump* nativeGeneralJump_at(address address) {
193 ShouldNotCallThis(); 211 ShouldNotCallThis();
212 return NULL;
194 } 213 }
195 214
196 #endif // CPU_ZERO_VM_NATIVEINST_ZERO_HPP 215 #endif // CPU_ZERO_VM_NATIVEINST_ZERO_HPP