Lines Matching defs:code
2 // Use of this source code is governed by a BSD-style license that can be
272 // and does not count available bytes already in the old space or code
343 PrintPID("Code space, used: %6" V8_PTR_PREFIX
470 void Heap::ClearAllICsByKind(Code::Kind kind) {
474 Code* code = Code::cast(object);
475 Code::Kind current_kind = code->kind();
476 if (current_kind == Code::FUNCTION ||
477 current_kind == Code::OPTIMIZED_FUNCTION) {
478 code->ClearInlineCaches(kind);
744 // Note: as weak callbacks can execute arbitrary code, we cannot
1249 // Visitor class to verify pointers in code or data space do not point into
1505 // Copy objects reachable from the code flushing candidates list.
1689 // dependent code registered in the allocation sites to re-evaluate
1694 "Deopt all allocation sites dependent code due to low survival "
2074 // We should explicitly record code entry slot for compaction because
2079 Code* code = Code::cast(Code::GetObjectFromEntryAddress(code_entry_slot));
2081 code_entry_slot, code);
2245 // Scavenging code relies on the fact that new space object
2545 ALLOCATE_VARSIZE_MAP(CODE_TYPE, code)
2721 // MacroAssembler::Abort calls (usually enabled with --debug-code) depend on
2725 // gcc-4.4 has problem generating correct code of following snippet:
2805 // in JSObjects. The hash code has a special value so that it will not match
2808 // hash code in place. The hash code for the hidden_string is zero to ensure
2849 // Allocate cache for external strings pointing to native source code.
3436 // Code objects which should stay at a fixed address are allocated either
3437 // in the first page of code space (objects on the first page of each space
3441 // Discard the first code allocation, which was on a page where it could
3451 Code* code = Code::cast(result);
3453 isolate_->code_range()->contains(code->address()));
3454 code->set_gc_metadata(Smi::FromInt(0));
3455 code->set_ic_age(global_ic_age_);
3456 return code;
3460 AllocationResult Heap::CopyCode(Code* code) {
3464 code->constant_pool() != empty_constant_pool_array()) {
3465 // Copy the constant pool, since edits to the copied code may modify
3467 allocation = CopyConstantPoolArray(code->constant_pool());
3474 // Allocate an object the same size as the code object.
3475 int obj_size = code->Size();
3479 // Copy code object.
3480 Address old_addr = code->address();
3483 Code* new_code = Code::cast(result);
3490 isolate_->code_range()->contains(code->address()));
3496 AllocationResult Heap::CopyCode(Code* code, Vector<byte> reloc_info) {
3497 // Allocate ByteArray and ConstantPoolArray before the Code object, so that we
3498 // do not risk leaving uninitialized Code object (and breaking the heap).
3507 code->constant_pool() != empty_constant_pool_array()) {
3508 // Copy the constant pool, since edits to the copied code may modify
3510 AllocationResult allocation = CopyConstantPoolArray(code->constant_pool());
3516 int new_body_size = RoundUp(code->instruction_size(), kObjectAlignment);
3518 int new_obj_size = Code::SizeFor(new_body_size);
3520 Address old_addr = code->address();
3523 static_cast<size_t>(code->instruction_end() - old_addr);
3530 // Copy code object.
3536 Code* new_code = Code::cast(result);
3548 isolate_->code_range()->contains(code->address()));
3552 if (FLAG_verify_heap) code->ObjectVerify();
3604 // verification code
4396 PrintF(">>>>>> Code Stats (%s) >>>>>>\n", title);
4398 // We do not look for code in new space, map space, or old space. If code
4429 PrintF("Code space : ");
4705 // We only have code, sequential strings, or fixed arrays in large
4773 // Iterate over the builtin code objects and code stubs in the
4774 // heap. Note that it is not necessary to iterate over code objects
4808 // Iterate over the pointers the Serialization/Deserialization code is
4860 // of memory for each semispace because code in the snapshot has
4861 // write-barrier code that relies on the size and alignment of new
5104 // Initialize the code space, set its maximum capacity to the old
5127 // The large object code space may contain code or data. We set the memory
5129 // explicitly when allocating large code objects.
6117 index = FIRST_CODE_KIND_SUB_TYPE + Code::name; \
6142 FIRST_CODE_AGE_SUB_TYPE + Code::k##name##CodeAge - Code::kFirstCodeAge; \
