Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(272)

Side by Side Diff: src/x64/assembler-x64.cc

Issue 115567: X64: Move some methods in x64/ to their file and make codegen do int3. (Closed)
Patch Set: Created 11 years, 7 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
« no previous file with comments | « no previous file | src/x64/builtins-x64.cc » ('j') | src/x64/ic-x64.cc » ('J')
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
OLDNEW
1 // Copyright 2009 the V8 project authors. All rights reserved. 1 // Copyright 2009 the V8 project authors. All rights reserved.
2 // Redistribution and use in source and binary forms, with or without 2 // Redistribution and use in source and binary forms, with or without
3 // modification, are permitted provided that the following conditions are 3 // modification, are permitted provided that the following conditions are
4 // met: 4 // met:
5 // 5 //
6 // * Redistributions of source code must retain the above copyright 6 // * Redistributions of source code must retain the above copyright
7 // notice, this list of conditions and the following disclaimer. 7 // notice, this list of conditions and the following disclaimer.
8 // * Redistributions in binary form must reproduce the above 8 // * Redistributions in binary form must reproduce the above
9 // copyright notice, this list of conditions and the following 9 // copyright notice, this list of conditions and the following
10 // disclaimer in the documentation and/or other materials provided 10 // disclaimer in the documentation and/or other materials provided
(...skipping 16 matching lines...) Expand all
27 27
28 #include "v8.h" 28 #include "v8.h"
29 29
30 #include "macro-assembler.h" 30 #include "macro-assembler.h"
31 31
32 namespace v8 { namespace internal { 32 namespace v8 { namespace internal {
33 33
34 Register no_reg = { -1 }; 34 Register no_reg = { -1 };
35 35
36 36
37 } } // namespace v8::internal 37 // Safe default is no features.
38 uint64_t CpuFeatures::supported_ = 0;
39 uint64_t CpuFeatures::enabled_ = 0;
38 40
39 41 void CpuFeatures::Probe() {
40 // TODO(x64): Implement and move these to their correct cc-files: 42 // TODO(X64): UNIMPLEMENTED
41 #include "assembler.h"
42 #include "ast.h"
43 #include "bootstrapper.h"
44 #include "codegen-inl.h"
45 #include "cpu.h"
46 #include "debug.h"
47 #include "disasm.h"
48 #include "disassembler.h"
49 #include "frames-inl.h"
50 #include "x64/macro-assembler-x64.h"
51 #include "x64/regexp-macro-assembler-x64.h"
52 #include "ic-inl.h"
53 #include "log.h"
54 #include "macro-assembler.h"
55 #include "parser.h"
56 #include "regexp-macro-assembler.h"
57 #include "regexp-stack.h"
58 #include "register-allocator-inl.h"
59 #include "register-allocator.h"
60 #include "runtime.h"
61 #include "scopes.h"
62 #include "serialize.h"
63 #include "stub-cache.h"
64 #include "unicode.h"
65
66 namespace v8 { namespace internal {
67
68 void ArgumentsAccessStub::GenerateNewObject(MacroAssembler* a) {
69 UNIMPLEMENTED();
70 }
71
72 void ArgumentsAccessStub::GenerateReadElement(MacroAssembler* a) {
73 UNIMPLEMENTED();
74 }
75
76 void ArgumentsAccessStub::GenerateReadLength(MacroAssembler* a) {
77 UNIMPLEMENTED();
78 } 43 }
79 44
80 // ----------------------------------------------------------------------------- 45 // -----------------------------------------------------------------------------
81 // Implementation of Assembler 46 // Implementation of Assembler
47
48 // Emit a single byte. Must always be inlined.
49 #define EMIT(x) \
50 *pc_++ = (x)
Dean McNamee 2009/05/20 13:09:42 really needs to be 2 lines?
51
52 #ifdef GENERATED_CODE_COVERAGE
53 static void InitCoverageLog();
54 #endif
55
56 // -----------------------------------------------------------------------------
57 // Implementation of Assembler
82 58
83 byte* Assembler::spare_buffer_ = NULL; 59 byte* Assembler::spare_buffer_ = NULL;
84 60
85 Assembler::Assembler(void* buffer, int buffer_size) { 61 Assembler::Assembler(void* buffer, int buffer_size) {
86 if (buffer == NULL) { 62 if (buffer == NULL) {
87 // do our own buffer management 63 // do our own buffer management
88 if (buffer_size <= kMinimalBufferSize) { 64 if (buffer_size <= kMinimalBufferSize) {
89 buffer_size = kMinimalBufferSize; 65 buffer_size = kMinimalBufferSize;
90 66
91 if (spare_buffer_ != NULL) { 67 if (spare_buffer_ != NULL) {
(...skipping 68 matching lines...) Expand 10 before | Expand all | Expand 10 after
160 } 136 }
161 137
162 138
163 void Assembler::Align(int m) { 139 void Assembler::Align(int m) {
164 ASSERT(IsPowerOf2(m)); 140 ASSERT(IsPowerOf2(m));
165 while ((pc_offset() & (m - 1)) != 0) { 141 while ((pc_offset() & (m - 1)) != 0) {
166 nop(); 142 nop();
167 } 143 }
168 } 144 }
169 145
170
171 void Assembler::RecordComment(char const* a) { 146 void Assembler::RecordComment(char const* a) {
172 UNIMPLEMENTED(); 147 UNIMPLEMENTED();
173 } 148 }
174 149
175 void Assembler::RecordPosition(int a) { 150 void Assembler::RecordPosition(int a) {
176 UNIMPLEMENTED(); 151 UNIMPLEMENTED();
177 } 152 }
178 153
179 void Assembler::RecordStatementPosition(int a) { 154 void Assembler::RecordStatementPosition(int a) {
180 UNIMPLEMENTED(); 155 UNIMPLEMENTED();
181 } 156 }
182 157
183 void Assembler::bind(Label* a) { 158 void Assembler::bind(Label* a) {
184 UNIMPLEMENTED(); 159 UNIMPLEMENTED();
185 } 160 }
186 161
162 void Assembler::nop() {
163 UNIMPLEMENTED();
164 }
187 165
188 void Assembler::nop() { 166 void Assembler::GrowBuffer() {
167 ASSERT(overflow()); // should not call this otherwise
168 if (!own_buffer_) FATAL("external code buffer is too small");
169
170 // compute new buffer size
171 CodeDesc desc; // the new buffer
172 if (buffer_size_ < 4*KB) {
173 desc.buffer_size = 4*KB;
174 } else {
175 desc.buffer_size = 2*buffer_size_;
176 }
177 // Some internal data structures overflow for very large buffers,
178 // they must ensure that kMaximalBufferSize is not too large.
179 if ((desc.buffer_size > kMaximalBufferSize) ||
180 (desc.buffer_size > Heap::OldGenerationSize())) {
181 V8::FatalProcessOutOfMemory("Assembler::GrowBuffer");
182 }
183
184 // setup new buffer
185 desc.buffer = NewArray<byte>(desc.buffer_size);
186 desc.instr_size = pc_offset();
187 desc.reloc_size = (buffer_ + buffer_size_) - (reloc_info_writer.pos());
188
189 // Clear the buffer in debug mode. Use 'int3' instructions to make
190 // sure to get into problems if we ever run uninitialized code.
191 #ifdef DEBUG
192 memset(desc.buffer, 0xCC, desc.buffer_size);
193 #endif
194
195 // copy the data
196 int pc_delta = desc.buffer - buffer_;
197 int rc_delta = (desc.buffer + desc.buffer_size) - (buffer_ + buffer_size_);
198 memmove(desc.buffer, buffer_, desc.instr_size);
199 memmove(rc_delta + reloc_info_writer.pos(),
200 reloc_info_writer.pos(), desc.reloc_size);
201
202 // switch buffers
203 if (spare_buffer_ == NULL && buffer_size_ == kMinimalBufferSize) {
204 spare_buffer_ = buffer_;
205 } else {
206 DeleteArray(buffer_);
207 }
208 buffer_ = desc.buffer;
209 buffer_size_ = desc.buffer_size;
210 pc_ += pc_delta;
211 if (last_pc_ != NULL) {
212 last_pc_ += pc_delta;
213 }
214 reloc_info_writer.Reposition(reloc_info_writer.pos() + rc_delta,
215 reloc_info_writer.last_pc() + pc_delta);
216
217 // relocate runtime entries
218 for (RelocIterator it(desc); !it.done(); it.next()) {
219 RelocInfo::Mode rmode = it.rinfo()->rmode();
220 if (rmode == RelocInfo::RUNTIME_ENTRY) {
221 int32_t* p = reinterpret_cast<int32_t*>(it.rinfo()->pc());
William Hesse 2009/05/20 13:13:48 pc() is a byte*. If you want to manipulate it as
Lasse Reichstein 2009/05/20 14:25:42 Actually, it's not the pointer that is treated as
222 *p -= pc_delta; // relocate entry
223 } else if (rmode == RelocInfo::INTERNAL_REFERENCE) {
224 int32_t* p = reinterpret_cast<int32_t*>(it.rinfo()->pc());
225 if (*p != 0) { // 0 means uninitialized.
226 *p += pc_delta;
227 }
228 }
229 }
230
231 ASSERT(!overflow());
232 }
233
234
235 void Assembler::int3() {
236 EnsureSpace ensure_space(this);
237 last_pc_ = pc_;
238 EMIT(0xCC);
239 }
240
241 } } // namespace v8::internal
242
243
244 // TODO(x64): Implement and move these to their correct cc-files:
245 #include "ast.h"
246 #include "bootstrapper.h"
247 #include "codegen-inl.h"
248 #include "cpu.h"
249 #include "debug.h"
250 #include "disasm.h"
251 #include "disassembler.h"
252 #include "frames-inl.h"
253 #include "x64/macro-assembler-x64.h"
254 #include "x64/regexp-macro-assembler-x64.h"
255 #include "ic-inl.h"
256 #include "log.h"
257 #include "macro-assembler.h"
258 #include "parser.h"
259 #include "regexp-macro-assembler.h"
260 #include "regexp-stack.h"
261 #include "register-allocator-inl.h"
262 #include "register-allocator.h"
263 #include "runtime.h"
264 #include "scopes.h"
265 #include "serialize.h"
266 #include "stub-cache.h"
267 #include "unicode.h"
268
269 namespace v8 { namespace internal {
270
271 void ArgumentsAccessStub::GenerateNewObject(MacroAssembler* a) {
272 UNIMPLEMENTED();
273 }
274
275 void ArgumentsAccessStub::GenerateReadElement(MacroAssembler* a) {
276 UNIMPLEMENTED();
277 }
278
279 void ArgumentsAccessStub::GenerateReadLength(MacroAssembler* a) {
189 UNIMPLEMENTED(); 280 UNIMPLEMENTED();
190 } 281 }
191 282
192 283
193 void BreakLocationIterator::ClearDebugBreakAtReturn() { 284 void BreakLocationIterator::ClearDebugBreakAtReturn() {
194 UNIMPLEMENTED(); 285 UNIMPLEMENTED();
195 } 286 }
196 287
197 bool BreakLocationIterator::IsDebugBreakAtReturn() { 288 bool BreakLocationIterator::IsDebugBreakAtReturn() {
198 UNIMPLEMENTED(); 289 UNIMPLEMENTED();
199 return false; 290 return false;
200 } 291 }
201 292
202 void BreakLocationIterator::SetDebugBreakAtReturn() { 293 void BreakLocationIterator::SetDebugBreakAtReturn() {
203 UNIMPLEMENTED(); 294 UNIMPLEMENTED();
204 } 295 }
205 296
206 void CEntryStub::GenerateBody(MacroAssembler* a, bool b) {
207 UNIMPLEMENTED();
208 }
209
210 void CallIC::Generate(MacroAssembler* a, int b, ExternalReference const& c) { 297 void CallIC::Generate(MacroAssembler* a, int b, ExternalReference const& c) {
211 UNIMPLEMENTED(); 298 UNIMPLEMENTED();
212 } 299 }
213 300
214 void CallIC::GenerateMegamorphic(MacroAssembler* a, int b) { 301 void CallIC::GenerateMegamorphic(MacroAssembler* a, int b) {
215 UNIMPLEMENTED(); 302 UNIMPLEMENTED();
216 } 303 }
217 304
218 void CallIC::GenerateNormal(MacroAssembler* a, int b) { 305 void CallIC::GenerateNormal(MacroAssembler* a, int b) {
219 UNIMPLEMENTED(); 306 UNIMPLEMENTED();
(...skipping 15 matching lines...) Expand all
235 return NULL; 322 return NULL;
236 } 323 }
237 324
238 Object* CallStubCompiler::CompileCallInterceptor(Object* a, 325 Object* CallStubCompiler::CompileCallInterceptor(Object* a,
239 JSObject* b, 326 JSObject* b,
240 String* c) { 327 String* c) {
241 UNIMPLEMENTED(); 328 UNIMPLEMENTED();
242 return NULL; 329 return NULL;
243 } 330 }
244 331
245 CodeGenerator::CodeGenerator(int buffer_size,
246 Handle<Script> script,
247 bool is_eval)
248 : is_eval_(is_eval),
249 script_(script),
250 deferred_(8),
251 masm_(new MacroAssembler(NULL, buffer_size)),
252 scope_(NULL),
253 frame_(NULL),
254 allocator_(NULL),
255 state_(NULL),
256 loop_nesting_(0),
257 function_return_is_shadowed_(false),
258 in_spilled_code_(false) {
259 UNIMPLEMENTED();
260 }
261
262 void CodeGenerator::DeclareGlobals(Handle<FixedArray> a) {
263 UNIMPLEMENTED();
264 }
265
266 void CodeGenerator::GenCode(FunctionLiteral* a) {
267 UNIMPLEMENTED();
268 }
269
270 void CodeGenerator::GenerateFastCaseSwitchJumpTable(SwitchStatement* a,
271 int b,
272 int c,
273 Label* d,
274 Vector<Label*> e,
275 Vector<Label> f) {
276 UNIMPLEMENTED();
277 }
278
279 void CodeGenerator::VisitStatements(ZoneList<Statement*>* a) {
280 UNIMPLEMENTED();
281 }
282
283 void CodeGenerator::VisitBlock(Block* a) {
284 UNIMPLEMENTED();
285 }
286
287 void CodeGenerator::VisitDeclaration(Declaration* a) {
288 UNIMPLEMENTED();
289 }
290
291 void CodeGenerator::VisitExpressionStatement(ExpressionStatement* a) {
292 UNIMPLEMENTED();
293 }
294
295 void CodeGenerator::VisitEmptyStatement(EmptyStatement* a) {
296 UNIMPLEMENTED();
297 }
298
299 void CodeGenerator::VisitIfStatement(IfStatement* a) {
300 UNIMPLEMENTED();
301 }
302
303 void CodeGenerator::VisitContinueStatement(ContinueStatement* a) {
304 UNIMPLEMENTED();
305 }
306
307 void CodeGenerator::VisitBreakStatement(BreakStatement* a) {
308 UNIMPLEMENTED();
309 }
310
311 void CodeGenerator::VisitReturnStatement(ReturnStatement* a) {
312 UNIMPLEMENTED();
313 }
314
315 void CodeGenerator::VisitWithEnterStatement(WithEnterStatement* a) {
316 UNIMPLEMENTED();
317 }
318
319 void CodeGenerator::VisitWithExitStatement(WithExitStatement* a) {
320 UNIMPLEMENTED();
321 }
322
323 void CodeGenerator::VisitSwitchStatement(SwitchStatement* a) {
324 UNIMPLEMENTED();
325 }
326
327 void CodeGenerator::VisitLoopStatement(LoopStatement* a) {
328 UNIMPLEMENTED();
329 }
330
331 void CodeGenerator::VisitForInStatement(ForInStatement* a) {
332 UNIMPLEMENTED();
333 }
334
335 void CodeGenerator::VisitTryCatch(TryCatch* a) {
336 UNIMPLEMENTED();
337 }
338
339 void CodeGenerator::VisitTryFinally(TryFinally* a) {
340 UNIMPLEMENTED();
341 }
342
343 void CodeGenerator::VisitDebuggerStatement(DebuggerStatement* a) {
344 UNIMPLEMENTED();
345 }
346
347 void CodeGenerator::VisitFunctionLiteral(FunctionLiteral* a) {
348 UNIMPLEMENTED();
349 }
350
351 void CodeGenerator::VisitFunctionBoilerplateLiteral(
352 FunctionBoilerplateLiteral* a) {
353 UNIMPLEMENTED();
354 }
355
356 void CodeGenerator::VisitConditional(Conditional* a) {
357 UNIMPLEMENTED();
358 }
359
360 void CodeGenerator::VisitSlot(Slot* a) {
361 UNIMPLEMENTED();
362 }
363
364 void CodeGenerator::VisitVariableProxy(VariableProxy* a) {
365 UNIMPLEMENTED();
366 }
367
368 void CodeGenerator::VisitLiteral(Literal* a) {
369 UNIMPLEMENTED();
370 }
371
372 void CodeGenerator::VisitRegExpLiteral(RegExpLiteral* a) {
373 UNIMPLEMENTED();
374 }
375
376 void CodeGenerator::VisitObjectLiteral(ObjectLiteral* a) {
377 UNIMPLEMENTED();
378 }
379
380 void CodeGenerator::VisitArrayLiteral(ArrayLiteral* a) {
381 UNIMPLEMENTED();
382 }
383
384 void CodeGenerator::VisitCatchExtensionObject(CatchExtensionObject* a) {
385 UNIMPLEMENTED();
386 }
387
388 void CodeGenerator::VisitAssignment(Assignment* a) {
389 UNIMPLEMENTED();
390 }
391
392 void CodeGenerator::VisitThrow(Throw* a) {
393 UNIMPLEMENTED();
394 }
395
396 void CodeGenerator::VisitProperty(Property* a) {
397 UNIMPLEMENTED();
398 }
399
400 void CodeGenerator::VisitCall(Call* a) {
401 UNIMPLEMENTED();
402 }
403
404 void CodeGenerator::VisitCallEval(CallEval* a) {
405 UNIMPLEMENTED();
406 }
407
408 void CodeGenerator::VisitCallNew(CallNew* a) {
409 UNIMPLEMENTED();
410 }
411
412 void CodeGenerator::VisitCallRuntime(CallRuntime* a) {
413 UNIMPLEMENTED();
414 }
415
416 void CodeGenerator::VisitUnaryOperation(UnaryOperation* a) {
417 UNIMPLEMENTED();
418 }
419
420 void CodeGenerator::VisitCountOperation(CountOperation* a) {
421 UNIMPLEMENTED();
422 }
423
424 void CodeGenerator::VisitBinaryOperation(BinaryOperation* a) {
425 UNIMPLEMENTED();
426 }
427
428 void CodeGenerator::VisitCompareOperation(CompareOperation* a) {
429 UNIMPLEMENTED();
430 }
431
432 void CodeGenerator::VisitThisFunction(ThisFunction* a) {
433 UNIMPLEMENTED();
434 }
435
436 void CpuFeatures::Probe() {
437 UNIMPLEMENTED();
438 }
439
440
441 bool Debug::IsDebugBreakAtReturn(v8::internal::RelocInfo*) {
442 UNIMPLEMENTED();
443 return false;
444 }
445
446 void Debug::GenerateCallICDebugBreak(MacroAssembler* a) {
447 UNIMPLEMENTED();
448 }
449
450 void Debug::GenerateConstructCallDebugBreak(MacroAssembler* a) {
451 UNIMPLEMENTED();
452 }
453
454 void Debug::GenerateKeyedLoadICDebugBreak(MacroAssembler* a) {
455 UNIMPLEMENTED();
456 }
457
458 void Debug::GenerateKeyedStoreICDebugBreak(MacroAssembler* a) {
459 UNIMPLEMENTED();
460 }
461
462 void Debug::GenerateLoadICDebugBreak(MacroAssembler* a) {
463 UNIMPLEMENTED();
464 }
465
466 void Debug::GenerateReturnDebugBreak(MacroAssembler* a) {
467 UNIMPLEMENTED();
468 }
469
470 void Debug::GenerateReturnDebugBreakEntry(MacroAssembler* a) {
471 UNIMPLEMENTED();
472 }
473
474 void Debug::GenerateStoreICDebugBreak(MacroAssembler* a) {
475 UNIMPLEMENTED();
476 }
477
478 void Debug::GenerateStubNoRegistersDebugBreak(MacroAssembler* a) {
479 UNIMPLEMENTED();
480 }
481 332
482 StackFrame::Type ExitFrame::GetStateForFramePointer(unsigned char* a, 333 StackFrame::Type ExitFrame::GetStateForFramePointer(unsigned char* a,
483 StackFrame::State* b) { 334 StackFrame::State* b) {
484 UNIMPLEMENTED(); 335 // TODO(X64): UNIMPLEMENTED
485 return NONE; 336 return NONE;
486 } 337 }
487 338
488 void JSEntryStub::GenerateBody(MacroAssembler* a, bool b) {
489 UNIMPLEMENTED();
490 }
491
492 int JavaScriptFrame::GetProvidedParametersCount() const { 339 int JavaScriptFrame::GetProvidedParametersCount() const {
493 UNIMPLEMENTED(); 340 UNIMPLEMENTED();
494 return 0; 341 return 0;
495 } 342 }
496 343
497 void JumpTarget::DoBind(int a) { 344 void JumpTarget::DoBind(int a) {
498 UNIMPLEMENTED(); 345 UNIMPLEMENTED();
499 } 346 }
500 347
501 void JumpTarget::DoBranch(Condition a, Hint b) { 348 void JumpTarget::DoBranch(Condition a, Hint b) {
502 UNIMPLEMENTED(); 349 UNIMPLEMENTED();
503 } 350 }
504 351
505 void JumpTarget::DoJump() { 352 void JumpTarget::DoJump() {
506 UNIMPLEMENTED(); 353 UNIMPLEMENTED();
507 } 354 }
508 355
509 void KeyedLoadIC::ClearInlinedVersion(unsigned char* a) {
510 UNIMPLEMENTED();
511 }
512
513 void KeyedLoadIC::Generate(MacroAssembler* a, ExternalReference const& b) {
514 UNIMPLEMENTED();
515 }
516
517 void KeyedLoadIC::GenerateGeneric(MacroAssembler* a) {
518 UNIMPLEMENTED();
519 }
520
521 void KeyedLoadIC::GenerateMiss(MacroAssembler* a) {
522 UNIMPLEMENTED();
523 }
524
525 bool KeyedLoadIC::PatchInlinedLoad(unsigned char* a, Object* b) {
526 UNIMPLEMENTED();
527 return false;
528 }
529
530 Object* KeyedLoadStubCompiler::CompileLoadArrayLength(String* a) {
531 UNIMPLEMENTED();
532 return NULL;
533 }
534
535 Object* KeyedLoadStubCompiler::CompileLoadCallback(String* a,
536 JSObject* b,
537 JSObject* c,
538 AccessorInfo* d) {
539 UNIMPLEMENTED();
540 return NULL;
541 }
542
543 Object* KeyedLoadStubCompiler::CompileLoadConstant(String* a,
544 JSObject* b,
545 JSObject* c,
546 Object* d) {
547 UNIMPLEMENTED();
548 return NULL;
549 }
550
551 Object* KeyedLoadStubCompiler::CompileLoadField(String* a,
552 JSObject* b,
553 JSObject* c,
554 int d) {
555 UNIMPLEMENTED();
556 return NULL;
557 }
558
559 Object* KeyedLoadStubCompiler::CompileLoadFunctionPrototype(String* a) {
560 UNIMPLEMENTED();
561 return NULL;
562 }
563
564 Object* KeyedLoadStubCompiler::CompileLoadInterceptor(JSObject* a,
565 JSObject* b,
566 String* c) {
567 UNIMPLEMENTED();
568 return NULL;
569 }
570
571 Object* KeyedLoadStubCompiler::CompileLoadStringLength(String* a) {
572 UNIMPLEMENTED();
573 return NULL;
574 }
575
576 void KeyedStoreIC::Generate(MacroAssembler* a, ExternalReference const& b) {
577 UNIMPLEMENTED();
578 }
579
580 void KeyedStoreIC::GenerateExtendStorage(MacroAssembler* a) {
581 UNIMPLEMENTED();
582 }
583
584 void KeyedStoreIC::GenerateGeneric(MacroAssembler*a) {
585 UNIMPLEMENTED();
586 }
587
588 Object* KeyedStoreStubCompiler::CompileStoreField(JSObject* a,
589 int b,
590 Map* c,
591 String* d) {
592 UNIMPLEMENTED();
593 return NULL;
594 }
595
596 void LoadIC::ClearInlinedVersion(unsigned char* a) {
597 UNIMPLEMENTED();
598 }
599
600 void LoadIC::Generate(MacroAssembler* a, ExternalReference const& b) {
601 UNIMPLEMENTED();
602 }
603
604 void LoadIC::GenerateArrayLength(MacroAssembler* a) {
605 UNIMPLEMENTED();
606 }
607
608 void LoadIC::GenerateFunctionPrototype(MacroAssembler* a) {
609 UNIMPLEMENTED();
610 }
611
612 void LoadIC::GenerateMegamorphic(MacroAssembler* a) {
613 UNIMPLEMENTED();
614 }
615
616 void LoadIC::GenerateMiss(MacroAssembler* a) {
617 UNIMPLEMENTED();
618 }
619
620 void LoadIC::GenerateNormal(MacroAssembler* a) {
621 UNIMPLEMENTED();
622 }
623
624 void LoadIC::GenerateStringLength(MacroAssembler* a) {
625 UNIMPLEMENTED();
626 }
627
628 bool LoadIC::PatchInlinedLoad(unsigned char* a, Object* b, int c) {
629 UNIMPLEMENTED();
630 return false;
631 }
632 356
633 Object* LoadStubCompiler::CompileLoadCallback(JSObject* a, 357 Object* LoadStubCompiler::CompileLoadCallback(JSObject* a,
634 JSObject* b, 358 JSObject* b,
635 AccessorInfo* c, 359 AccessorInfo* c,
636 String* d) { 360 String* d) {
637 UNIMPLEMENTED(); 361 UNIMPLEMENTED();
638 return NULL; 362 return NULL;
639 } 363 }
640 364
641 Object* LoadStubCompiler::CompileLoadConstant(JSObject* a, 365 Object* LoadStubCompiler::CompileLoadConstant(JSObject* a,
(...skipping 12 matching lines...) Expand all
654 return NULL; 378 return NULL;
655 } 379 }
656 380
657 Object* LoadStubCompiler::CompileLoadInterceptor(JSObject* a, 381 Object* LoadStubCompiler::CompileLoadInterceptor(JSObject* a,
658 JSObject* b, 382 JSObject* b,
659 String* c) { 383 String* c) {
660 UNIMPLEMENTED(); 384 UNIMPLEMENTED();
661 return NULL; 385 return NULL;
662 } 386 }
663 387
664 MacroAssembler::MacroAssembler(void* buffer, int size)
665 : Assembler(buffer, size),
666 unresolved_(0),
667 generating_stub_(false),
668 allow_stub_calls_(true),
669 code_object_(Heap::undefined_value()) {
670 UNIMPLEMENTED();
671 }
672
673 void MacroAssembler::TailCallRuntime(ExternalReference const& a, int b) {
674 UNIMPLEMENTED();
675 }
676
677 bool RegisterAllocator::IsReserved(int a) { 388 bool RegisterAllocator::IsReserved(int a) {
678 UNIMPLEMENTED(); 389 UNIMPLEMENTED();
679 return false; 390 return false;
680 } 391 }
681 392
682 RegisterFile RegisterAllocator::Reserved() { 393 RegisterFile RegisterAllocator::Reserved() {
683 UNIMPLEMENTED(); 394 UNIMPLEMENTED();
684 return RegisterFile(); 395 return RegisterFile();
685 } 396 }
686 397
687 const int RelocInfo::kApplyMask = -1; 398 const int RelocInfo::kApplyMask = -1;
688 399
689 StackFrame::Type StackFrame::ComputeType(StackFrame::State* a) { 400 StackFrame::Type StackFrame::ComputeType(StackFrame::State* a) {
690 UNIMPLEMENTED(); 401 UNIMPLEMENTED();
691 return NONE; 402 return NONE;
692 } 403 }
693 404
694 void StoreIC::Generate(MacroAssembler* a, ExternalReference const& b) {
695 UNIMPLEMENTED();
696 }
697
698 void StoreIC::GenerateExtendStorage(MacroAssembler* a) {
699 UNIMPLEMENTED();
700 }
701
702 void StoreIC::GenerateMegamorphic(MacroAssembler* a) {
703 UNIMPLEMENTED();
704 }
705
706 Object* StoreStubCompiler::CompileStoreCallback(JSObject* a, 405 Object* StoreStubCompiler::CompileStoreCallback(JSObject* a,
707 AccessorInfo* b, 406 AccessorInfo* b,
708 String* c) { 407 String* c) {
709 UNIMPLEMENTED(); 408 UNIMPLEMENTED();
710 return NULL; 409 return NULL;
711 } 410 }
712 411
713 Object* StoreStubCompiler::CompileStoreField(JSObject* a, 412 Object* StoreStubCompiler::CompileStoreField(JSObject* a,
714 int b, 413 int b,
715 Map* c, 414 Map* c,
(...skipping 49 matching lines...) Expand 10 before | Expand all | Expand 10 after
765 464
766 VirtualFrame::VirtualFrame() : elements_(0) { 465 VirtualFrame::VirtualFrame() : elements_(0) {
767 UNIMPLEMENTED(); 466 UNIMPLEMENTED();
768 } 467 }
769 468
770 byte* ArgumentsAdaptorFrame::GetCallerStackPointer() const { 469 byte* ArgumentsAdaptorFrame::GetCallerStackPointer() const {
771 UNIMPLEMENTED(); 470 UNIMPLEMENTED();
772 return NULL; 471 return NULL;
773 } 472 }
774 473
775 void Builtins::Generate_Adaptor(MacroAssembler* a, Builtins::CFunctionId b) {
776 UNIMPLEMENTED();
777 }
778
779 void Builtins::Generate_ArgumentsAdaptorTrampoline(MacroAssembler* a) {
780 UNIMPLEMENTED();
781 }
782
783 void Builtins::Generate_FunctionApply(MacroAssembler* a) {
784 UNIMPLEMENTED();
785 }
786
787 void Builtins::Generate_FunctionCall(MacroAssembler* a) {
788 UNIMPLEMENTED();
789 }
790
791 void Builtins::Generate_JSConstructCall(MacroAssembler* a) {
792 UNIMPLEMENTED();
793 }
794
795 void Builtins::Generate_JSConstructEntryTrampoline(MacroAssembler* a) {
796 UNIMPLEMENTED();
797 }
798
799 void Builtins::Generate_JSEntryTrampoline(MacroAssembler* a) {
800 UNIMPLEMENTED();
801 }
802
803 void CodeGenerator::GenerateArgumentsAccess(ZoneList<Expression*>* a) { 474 void CodeGenerator::GenerateArgumentsAccess(ZoneList<Expression*>* a) {
804 UNIMPLEMENTED(); 475 UNIMPLEMENTED();
805 } 476 }
806 477
807 void CodeGenerator::GenerateArgumentsLength(ZoneList<Expression*>* a) { 478 void CodeGenerator::GenerateArgumentsLength(ZoneList<Expression*>* a) {
808 UNIMPLEMENTED(); 479 UNIMPLEMENTED();
809 } 480 }
810 481
811 void CodeGenerator::GenerateFastCharCodeAt(ZoneList<Expression*>* a) { 482 void CodeGenerator::GenerateFastCharCodeAt(ZoneList<Expression*>* a) {
812 UNIMPLEMENTED(); 483 UNIMPLEMENTED();
(...skipping 35 matching lines...) Expand 10 before | Expand all | Expand 10 after
848 UNIMPLEMENTED(); 519 UNIMPLEMENTED();
849 return NULL; 520 return NULL;
850 } 521 }
851 522
852 byte* JavaScriptFrame::GetCallerStackPointer() const { 523 byte* JavaScriptFrame::GetCallerStackPointer() const {
853 UNIMPLEMENTED(); 524 UNIMPLEMENTED();
854 return NULL; 525 return NULL;
855 } 526 }
856 527
857 } } // namespace v8::internal 528 } } // namespace v8::internal
OLDNEW
« no previous file with comments | « no previous file | src/x64/builtins-x64.cc » ('j') | src/x64/ic-x64.cc » ('J')

Powered by Google App Engine
This is Rietveld 408576698