OLD | NEW |
1 // Copyright (c) 2012, the Dart project authors. Please see the AUTHORS file | 1 // Copyright (c) 2013, the Dart project authors. Please see the AUTHORS file |
2 // for details. All rights reserved. Use of this source code is governed by a | 2 // for details. All rights reserved. Use of this source code is governed by a |
3 // BSD-style license that can be found in the LICENSE file. | 3 // BSD-style license that can be found in the LICENSE file. |
4 | 4 |
5 #include "vm/globals.h" // Needed here to get TARGET_ARCH_ARM. | 5 #include "vm/globals.h" // Needed here to get TARGET_ARCH_ARM. |
6 #if defined(TARGET_ARCH_ARM) | 6 #if defined(TARGET_ARCH_ARM) |
7 | 7 |
8 #include "vm/flow_graph_compiler.h" | 8 #include "vm/flow_graph_compiler.h" |
9 | 9 |
10 #include "vm/longjump.h" | 10 #include "vm/longjump.h" |
11 | 11 |
12 namespace dart { | 12 namespace dart { |
13 | 13 |
| 14 FlowGraphCompiler::~FlowGraphCompiler() { |
| 15 // BlockInfos are zone-allocated, so their destructors are not called. |
| 16 // Verify the labels explicitly here. |
| 17 for (int i = 0; i < block_info_.length(); ++i) { |
| 18 ASSERT(!block_info_[i]->label.IsLinked()); |
| 19 } |
| 20 } |
| 21 |
| 22 |
| 23 bool FlowGraphCompiler::SupportsUnboxedMints() { |
| 24 return false; |
| 25 } |
| 26 |
| 27 |
| 28 void CompilerDeoptInfoWithStub::GenerateCode(FlowGraphCompiler* compiler, |
| 29 intptr_t stub_ix) { |
| 30 UNIMPLEMENTED(); |
| 31 } |
| 32 |
| 33 |
| 34 void FlowGraphCompiler::GenerateBoolToJump(Register bool_register, |
| 35 Label* is_true, |
| 36 Label* is_false) { |
| 37 UNIMPLEMENTED(); |
| 38 } |
| 39 |
| 40 |
| 41 RawSubtypeTestCache* FlowGraphCompiler::GenerateCallSubtypeTestStub( |
| 42 TypeTestStubKind test_kind, |
| 43 Register instance_reg, |
| 44 Register type_arguments_reg, |
| 45 Register temp_reg, |
| 46 Label* is_instance_lbl, |
| 47 Label* is_not_instance_lbl) { |
| 48 UNIMPLEMENTED(); |
| 49 return NULL; |
| 50 } |
| 51 |
| 52 |
| 53 RawSubtypeTestCache* |
| 54 FlowGraphCompiler::GenerateInstantiatedTypeWithArgumentsTest( |
| 55 intptr_t token_pos, |
| 56 const AbstractType& type, |
| 57 Label* is_instance_lbl, |
| 58 Label* is_not_instance_lbl) { |
| 59 UNIMPLEMENTED(); |
| 60 return NULL; |
| 61 } |
| 62 |
| 63 |
| 64 void FlowGraphCompiler::CheckClassIds(Register class_id_reg, |
| 65 const GrowableArray<intptr_t>& class_ids, |
| 66 Label* is_equal_lbl, |
| 67 Label* is_not_equal_lbl) { |
| 68 UNIMPLEMENTED(); |
| 69 } |
| 70 |
| 71 |
| 72 bool FlowGraphCompiler::GenerateInstantiatedTypeNoArgumentsTest( |
| 73 intptr_t token_pos, |
| 74 const AbstractType& type, |
| 75 Label* is_instance_lbl, |
| 76 Label* is_not_instance_lbl) { |
| 77 UNIMPLEMENTED(); |
| 78 return false; |
| 79 } |
| 80 |
| 81 |
| 82 RawSubtypeTestCache* FlowGraphCompiler::GenerateSubtype1TestCacheLookup( |
| 83 intptr_t token_pos, |
| 84 const Class& type_class, |
| 85 Label* is_instance_lbl, |
| 86 Label* is_not_instance_lbl) { |
| 87 UNIMPLEMENTED(); |
| 88 return NULL; |
| 89 } |
| 90 |
| 91 |
| 92 RawSubtypeTestCache* FlowGraphCompiler::GenerateUninstantiatedTypeTest( |
| 93 intptr_t token_pos, |
| 94 const AbstractType& type, |
| 95 Label* is_instance_lbl, |
| 96 Label* is_not_instance_lbl) { |
| 97 UNIMPLEMENTED(); |
| 98 return NULL; |
| 99 } |
| 100 |
| 101 |
| 102 RawSubtypeTestCache* FlowGraphCompiler::GenerateInlineInstanceof( |
| 103 intptr_t token_pos, |
| 104 const AbstractType& type, |
| 105 Label* is_instance_lbl, |
| 106 Label* is_not_instance_lbl) { |
| 107 UNIMPLEMENTED(); |
| 108 return NULL; |
| 109 } |
| 110 |
| 111 |
| 112 void FlowGraphCompiler::GenerateInstanceOf(intptr_t token_pos, |
| 113 const AbstractType& type, |
| 114 bool negate_result, |
| 115 LocationSummary* locs) { |
| 116 UNIMPLEMENTED(); |
| 117 } |
| 118 |
| 119 |
| 120 void FlowGraphCompiler::GenerateAssertAssignable(intptr_t token_pos, |
| 121 const AbstractType& dst_type, |
| 122 const String& dst_name, |
| 123 LocationSummary* locs) { |
| 124 UNIMPLEMENTED(); |
| 125 } |
| 126 |
| 127 |
| 128 void FlowGraphCompiler::EmitInstructionPrologue(Instruction* instr) { |
| 129 UNIMPLEMENTED(); |
| 130 } |
| 131 |
| 132 |
| 133 void FlowGraphCompiler::EmitInstructionEpilogue(Instruction* instr) { |
| 134 UNIMPLEMENTED(); |
| 135 } |
| 136 |
| 137 |
| 138 void FlowGraphCompiler::CopyParameters() { |
| 139 UNIMPLEMENTED(); |
| 140 } |
| 141 |
| 142 |
| 143 void FlowGraphCompiler::GenerateInlinedGetter(intptr_t offset) { |
| 144 UNIMPLEMENTED(); |
| 145 } |
| 146 |
| 147 |
| 148 void FlowGraphCompiler::GenerateInlinedSetter(intptr_t offset) { |
| 149 UNIMPLEMENTED(); |
| 150 } |
| 151 |
| 152 |
| 153 void FlowGraphCompiler::EmitFrameEntry() { |
| 154 UNIMPLEMENTED(); |
| 155 } |
| 156 |
| 157 |
14 void FlowGraphCompiler::CompileGraph() { | 158 void FlowGraphCompiler::CompileGraph() { |
15 UNIMPLEMENTED(); | 159 UNIMPLEMENTED(); |
16 } | 160 } |
17 | 161 |
18 | 162 |
19 void FlowGraphCompiler::FinalizePcDescriptors(const Code& code) { | 163 void FlowGraphCompiler::GenerateCall(intptr_t token_pos, |
20 UNIMPLEMENTED(); | 164 const ExternalLabel* label, |
21 } | 165 PcDescriptors::Kind kind, |
22 | 166 LocationSummary* locs) { |
23 | 167 UNIMPLEMENTED(); |
24 void FlowGraphCompiler::FinalizeStackmaps(const Code& code) { | 168 } |
25 UNIMPLEMENTED(); | 169 |
26 } | 170 |
27 | 171 void FlowGraphCompiler::GenerateDartCall(intptr_t deopt_id, |
28 | 172 intptr_t token_pos, |
29 void FlowGraphCompiler::FinalizeVarDescriptors(const Code& code) { | 173 const ExternalLabel* label, |
30 UNIMPLEMENTED(); | 174 PcDescriptors::Kind kind, |
31 } | 175 LocationSummary* locs) { |
32 | 176 UNIMPLEMENTED(); |
33 | 177 } |
34 void FlowGraphCompiler::FinalizeExceptionHandlers(const Code& code) { | 178 |
35 UNIMPLEMENTED(); | 179 |
36 } | 180 void FlowGraphCompiler::GenerateCallRuntime(intptr_t token_pos, |
37 | 181 const RuntimeEntry& entry, |
38 | 182 LocationSummary* locs) { |
39 void FlowGraphCompiler::FinalizeComments(const Code& code) { | 183 UNIMPLEMENTED(); |
40 UNIMPLEMENTED(); | 184 } |
41 } | 185 |
| 186 |
| 187 void FlowGraphCompiler::EmitOptimizedInstanceCall( |
| 188 ExternalLabel* target_label, |
| 189 const ICData& ic_data, |
| 190 const Array& arguments_descriptor, |
| 191 intptr_t argument_count, |
| 192 intptr_t deopt_id, |
| 193 intptr_t token_pos, |
| 194 LocationSummary* locs) { |
| 195 UNIMPLEMENTED(); |
| 196 } |
| 197 |
| 198 |
| 199 void FlowGraphCompiler::EmitInstanceCall(ExternalLabel* target_label, |
| 200 const ICData& ic_data, |
| 201 const Array& arguments_descriptor, |
| 202 intptr_t argument_count, |
| 203 intptr_t deopt_id, |
| 204 intptr_t token_pos, |
| 205 LocationSummary* locs) { |
| 206 UNIMPLEMENTED(); |
| 207 } |
| 208 |
| 209 |
| 210 void FlowGraphCompiler::EmitMegamorphicInstanceCall( |
| 211 const ICData& ic_data, |
| 212 const Array& arguments_descriptor, |
| 213 intptr_t argument_count, |
| 214 intptr_t deopt_id, |
| 215 intptr_t token_pos, |
| 216 LocationSummary* locs) { |
| 217 UNIMPLEMENTED(); |
| 218 } |
| 219 |
| 220 |
| 221 void FlowGraphCompiler::EmitStaticCall(const Function& function, |
| 222 const Array& arguments_descriptor, |
| 223 intptr_t argument_count, |
| 224 intptr_t deopt_id, |
| 225 intptr_t token_pos, |
| 226 LocationSummary* locs) { |
| 227 UNIMPLEMENTED(); |
| 228 } |
| 229 |
| 230 |
| 231 void FlowGraphCompiler::EmitEqualityRegConstCompare(Register reg, |
| 232 const Object& obj, |
| 233 bool needs_number_check) { |
| 234 UNIMPLEMENTED(); |
| 235 } |
| 236 |
| 237 |
| 238 void FlowGraphCompiler::EmitEqualityRegRegCompare(Register left, |
| 239 Register right, |
| 240 bool needs_number_check) { |
| 241 UNIMPLEMENTED(); |
| 242 } |
| 243 |
| 244 |
| 245 void FlowGraphCompiler::EmitSuperEqualityCallPrologue(Register result, |
| 246 Label* skip_call) { |
| 247 UNIMPLEMENTED(); |
| 248 } |
| 249 |
| 250 |
| 251 void FlowGraphCompiler::SaveLiveRegisters(LocationSummary* locs) { |
| 252 UNIMPLEMENTED(); |
| 253 } |
| 254 |
| 255 |
| 256 void FlowGraphCompiler::RestoreLiveRegisters(LocationSummary* locs) { |
| 257 UNIMPLEMENTED(); |
| 258 } |
| 259 |
| 260 |
| 261 void FlowGraphCompiler::EmitTestAndCall(const ICData& ic_data, |
| 262 Register class_id_reg, |
| 263 intptr_t arg_count, |
| 264 const Array& arg_names, |
| 265 Label* deopt, |
| 266 intptr_t deopt_id, |
| 267 intptr_t token_index, |
| 268 LocationSummary* locs) { |
| 269 UNIMPLEMENTED(); |
| 270 } |
| 271 |
| 272 |
| 273 void FlowGraphCompiler::EmitDoubleCompareBranch(Condition true_condition, |
| 274 FpuRegister left, |
| 275 FpuRegister right, |
| 276 BranchInstr* branch) { |
| 277 UNIMPLEMENTED(); |
| 278 } |
| 279 |
| 280 |
| 281 void FlowGraphCompiler::EmitDoubleCompareBool(Condition true_condition, |
| 282 FpuRegister left, |
| 283 FpuRegister right, |
| 284 Register result) { |
| 285 UNIMPLEMENTED(); |
| 286 } |
| 287 |
| 288 |
| 289 Condition FlowGraphCompiler::FlipCondition(Condition condition) { |
| 290 UNIMPLEMENTED(); |
| 291 return condition; |
| 292 } |
| 293 |
| 294 |
| 295 bool FlowGraphCompiler::EvaluateCondition(Condition condition, |
| 296 intptr_t left, |
| 297 intptr_t right) { |
| 298 UNIMPLEMENTED(); |
| 299 return false; |
| 300 } |
| 301 |
| 302 |
| 303 FieldAddress FlowGraphCompiler::ElementAddressForIntIndex(intptr_t cid, |
| 304 Register array, |
| 305 intptr_t index) { |
| 306 UNIMPLEMENTED(); |
| 307 return FieldAddress(array, index); |
| 308 } |
| 309 |
| 310 |
| 311 FieldAddress FlowGraphCompiler::ElementAddressForRegIndex(intptr_t cid, |
| 312 Register array, |
| 313 Register index) { |
| 314 UNIMPLEMENTED(); |
| 315 return FieldAddress(array, index); |
| 316 } |
| 317 |
| 318 |
| 319 Address FlowGraphCompiler::ExternalElementAddressForIntIndex(intptr_t cid, |
| 320 Register array, |
| 321 intptr_t index) { |
| 322 UNIMPLEMENTED(); |
| 323 return FieldAddress(array, index); |
| 324 } |
| 325 |
| 326 |
| 327 Address FlowGraphCompiler::ExternalElementAddressForRegIndex(intptr_t cid, |
| 328 Register array, |
| 329 Register index) { |
| 330 UNIMPLEMENTED(); |
| 331 return FieldAddress(array, index); |
| 332 } |
| 333 |
| 334 |
| 335 void ParallelMoveResolver::EmitMove(int index) { |
| 336 UNIMPLEMENTED(); |
| 337 } |
| 338 |
| 339 |
| 340 void ParallelMoveResolver::EmitSwap(int index) { |
| 341 UNIMPLEMENTED(); |
| 342 } |
| 343 |
| 344 |
| 345 void ParallelMoveResolver::MoveMemoryToMemory(const Address& dst, |
| 346 const Address& src) { |
| 347 UNIMPLEMENTED(); |
| 348 } |
| 349 |
| 350 |
| 351 void ParallelMoveResolver::StoreObject(const Address& dst, const Object& obj) { |
| 352 UNIMPLEMENTED(); |
| 353 } |
| 354 |
| 355 |
| 356 void ParallelMoveResolver::Exchange(Register reg, const Address& mem) { |
| 357 UNIMPLEMENTED(); |
| 358 } |
| 359 |
| 360 |
| 361 void ParallelMoveResolver::Exchange(const Address& mem1, const Address& mem2) { |
| 362 UNIMPLEMENTED(); |
| 363 } |
| 364 |
42 | 365 |
43 } // namespace dart | 366 } // namespace dart |
44 | 367 |
45 #endif // defined TARGET_ARCH_ARM | 368 #endif // defined TARGET_ARCH_ARM |
OLD | NEW |