| // Copyright 2017 the V8 project authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include "src/assembler-inl.h" |
| #include "src/base/utils/random-number-generator.h" |
| #include "src/codegen.h" |
| #include "src/compilation-info.h" |
| #include "src/compiler/code-generator.h" |
| #include "src/compiler/instruction.h" |
| #include "src/compiler/linkage.h" |
| #include "src/isolate.h" |
| #include "src/objects-inl.h" |
| |
| #include "test/cctest/cctest.h" |
| #include "test/cctest/compiler/function-tester.h" |
| |
| namespace v8 { |
| namespace internal { |
| namespace compiler { |
| |
| namespace { |
| |
| int GetSlotSizeInBytes(MachineRepresentation rep) { |
| switch (rep) { |
| case MachineRepresentation::kTagged: |
| case MachineRepresentation::kFloat32: |
| return kPointerSize; |
| case MachineRepresentation::kFloat64: |
| return kDoubleSize; |
| case MachineRepresentation::kSimd128: |
| return kSimd128Size; |
| default: |
| break; |
| } |
| UNREACHABLE(); |
| } |
| |
| } // namespace |
| |
| // Wrapper around the CodeGenerator with the ability to randomly generate moves |
| // and swaps which can then be executed. The `slots` map represents how many |
| // slots should be allocated per representation. Parallel moves will then be |
| // generated by randomly picking slots. Constants can be provided so that |
| // parallel moves may use them. |
| // |
| // At the moment, only the following representations are tested: |
| // - kTagged |
| // - kFloat32 |
| // - kFloat64 |
| // - kSimd128 |
| // There is no need to test using Word32 or Word64 as they are the same as |
| // Tagged as far as the code generator is concerned. |
| class CodeGeneratorTester : public HandleAndZoneScope { |
| public: |
| CodeGeneratorTester(std::map<MachineRepresentation, int> slots = |
| std::map<MachineRepresentation, int>{}, |
| std::initializer_list<Constant> constants = {}) |
| : info_(ArrayVector("test"), main_isolate(), main_zone(), Code::STUB), |
| descriptor_(Linkage::GetStubCallDescriptor( |
| main_isolate(), main_zone(), VoidDescriptor(main_isolate()), 0, |
| CallDescriptor::kNoFlags, Operator::kNoProperties, |
| MachineType::AnyTagged(), 0)), |
| linkage_(descriptor_), |
| blocks_(main_zone()), |
| sequence_(main_isolate(), main_zone(), &blocks_), |
| rng_(CcTest::random_number_generator()), |
| frame_(descriptor_->CalculateFixedFrameSize()), |
| generator_(main_zone(), &frame_, &linkage_, &sequence_, &info_, |
| base::Optional<OsrHelper>(), kNoSourcePosition, nullptr) { |
| // Keep track of all supported representations depending on what kind of |
| // stack slots are supported. |
| for (const auto& slot : slots) { |
| supported_reps_.push_back(slot.first); |
| } |
| // Allocate new slots until we run out of them. |
| while (std::any_of(slots.cbegin(), slots.cend(), |
| [](const std::pair<MachineRepresentation, int>& entry) { |
| // True if there are slots left to allocate for this |
| // representation. |
| return entry.second > 0; |
| })) { |
| // Pick a random MachineRepresentation from supported_reps_. |
| MachineRepresentation rep = CreateRandomMachineRepresentation(); |
| auto entry = slots.find(rep); |
| DCHECK(entry != slots.end()); |
| // We may have picked a representation for which all slots have already |
| // been allocated. |
| if (entry->second > 0) { |
| // Keep a map of (MachineRepresentation . std::vector<int>) with |
| // allocated slots to pick from for each representation. |
| RegisterSlot(rep, frame_.AllocateSpillSlot(GetSlotSizeInBytes(rep))); |
| entry->second--; |
| } |
| } |
| for (auto constant : constants) { |
| int virtual_register = AllocateConstant(constant); |
| // Associate constants with their compatible representations. |
| // TODO(all): Test all types of constants. |
| switch (constant.type()) { |
| // Integer constants are always moved to a tagged location, whatever |
| // their sizes. |
| case Constant::kInt32: |
| case Constant::kInt64: |
| RegisterConstant(MachineRepresentation::kTagged, virtual_register); |
| break; |
| // FP constants may be moved to a tagged location using a heap number, |
| // or directly to a location of the same size. |
| case Constant::kFloat32: |
| RegisterConstant(MachineRepresentation::kTagged, virtual_register); |
| RegisterConstant(MachineRepresentation::kFloat32, virtual_register); |
| break; |
| case Constant::kFloat64: |
| RegisterConstant(MachineRepresentation::kTagged, virtual_register); |
| RegisterConstant(MachineRepresentation::kFloat64, virtual_register); |
| break; |
| default: |
| break; |
| } |
| } |
| // Force a frame to be created. |
| generator_.frame_access_state()->MarkHasFrame(true); |
| generator_.AssembleConstructFrame(); |
| // TODO(all): Generate a stack check here so that we fail gracefully if the |
| // frame is too big. |
| } |
| |
| int AllocateConstant(Constant constant) { |
| int virtual_register = sequence_.NextVirtualRegister(); |
| sequence_.AddConstant(virtual_register, constant); |
| return virtual_register; |
| } |
| |
| // Register a constant referenced by `virtual_register` as compatible with |
| // `rep`. |
| void RegisterConstant(MachineRepresentation rep, int virtual_register) { |
| auto entry = constants_.find(rep); |
| if (entry == constants_.end()) { |
| std::vector<int> vregs = {virtual_register}; |
| constants_.emplace(rep, vregs); |
| } else { |
| entry->second.push_back(virtual_register); |
| } |
| } |
| |
| void RegisterSlot(MachineRepresentation rep, int slot) { |
| auto entry = allocated_slots_.find(rep); |
| if (entry == allocated_slots_.end()) { |
| std::vector<int> slots = {slot}; |
| allocated_slots_.emplace(rep, slots); |
| } else { |
| entry->second.push_back(slot); |
| } |
| } |
| |
| enum PushTypeFlag { |
| kRegisterPush = CodeGenerator::kRegisterPush, |
| kStackSlotPush = CodeGenerator::kStackSlotPush, |
| kScalarPush = CodeGenerator::kScalarPush |
| }; |
| |
| enum OperandConstraint { |
| kNone, |
| // Restrict operands to non-constants. This is useful when generating a |
| // destination. |
| kCannotBeConstant |
| }; |
| |
| // Generate parallel moves at random. Note that they may not be compatible |
| // between each other as this doesn't matter to the code generator. |
| ParallelMove* GenerateRandomMoves(int size) { |
| ParallelMove* parallel_move = new (main_zone()) ParallelMove(main_zone()); |
| |
| for (int i = 0; i < size;) { |
| MachineRepresentation rep = CreateRandomMachineRepresentation(); |
| MoveOperands mo(CreateRandomOperand(kNone, rep), |
| CreateRandomOperand(kCannotBeConstant, rep)); |
| // It isn't valid to call `AssembleMove` and `AssembleSwap` with redundant |
| // moves. |
| if (mo.IsRedundant()) continue; |
| parallel_move->AddMove(mo.source(), mo.destination()); |
| // Iterate only when a move was created. |
| i++; |
| } |
| |
| return parallel_move; |
| } |
| |
| ParallelMove* GenerateRandomSwaps(int size) { |
| ParallelMove* parallel_move = new (main_zone()) ParallelMove(main_zone()); |
| |
| for (int i = 0; i < size;) { |
| MachineRepresentation rep = CreateRandomMachineRepresentation(); |
| InstructionOperand lhs = CreateRandomOperand(kCannotBeConstant, rep); |
| InstructionOperand rhs = CreateRandomOperand(kCannotBeConstant, rep); |
| MoveOperands mo(lhs, rhs); |
| // It isn't valid to call `AssembleMove` and `AssembleSwap` with redundant |
| // moves. |
| if (mo.IsRedundant()) continue; |
| // Canonicalize the swap: the register operand has to be the left hand |
| // side. |
| if (lhs.IsStackSlot() || lhs.IsFPStackSlot()) { |
| std::swap(lhs, rhs); |
| } |
| parallel_move->AddMove(lhs, rhs); |
| // Iterate only when a swap was created. |
| i++; |
| } |
| |
| return parallel_move; |
| } |
| |
| MachineRepresentation CreateRandomMachineRepresentation() { |
| int index = rng_->NextInt(static_cast<int>(supported_reps_.size())); |
| return supported_reps_[index]; |
| } |
| |
| InstructionOperand CreateRandomOperand(OperandConstraint constraint, |
| MachineRepresentation rep) { |
| // Only generate a Constant if the operand is a source and we have a |
| // constant with a compatible representation in stock. |
| bool generate_constant = (constraint != kCannotBeConstant) && |
| (constants_.find(rep) != constants_.end()); |
| switch (rng_->NextInt(generate_constant ? 3 : 2)) { |
| case 0: |
| return CreateRandomStackSlotOperand(rep); |
| case 1: |
| return CreateRandomRegisterOperand(rep); |
| case 2: |
| return CreateRandomConstant(rep); |
| } |
| UNREACHABLE(); |
| } |
| |
| InstructionOperand CreateRandomRegisterOperand(MachineRepresentation rep) { |
| int code; |
| const RegisterConfiguration* conf = RegisterConfiguration::Default(); |
| switch (rep) { |
| case MachineRepresentation::kFloat32: { |
| int index = rng_->NextInt(conf->num_allocatable_float_registers()); |
| code = conf->RegisterConfiguration::GetAllocatableFloatCode(index); |
| break; |
| } |
| case MachineRepresentation::kFloat64: { |
| int index = rng_->NextInt(conf->num_allocatable_double_registers()); |
| code = conf->RegisterConfiguration::GetAllocatableDoubleCode(index); |
| break; |
| } |
| case MachineRepresentation::kSimd128: { |
| int index = rng_->NextInt(conf->num_allocatable_simd128_registers()); |
| code = conf->RegisterConfiguration::GetAllocatableSimd128Code(index); |
| break; |
| } |
| case MachineRepresentation::kTagged: { |
| // Pick an allocatable register that is not the return register. |
| do { |
| int index = rng_->NextInt(conf->num_allocatable_general_registers()); |
| code = conf->RegisterConfiguration::GetAllocatableGeneralCode(index); |
| } while (code == kReturnRegister0.code()); |
| break; |
| } |
| default: |
| UNREACHABLE(); |
| break; |
| } |
| return AllocatedOperand(LocationOperand::REGISTER, rep, code); |
| } |
| |
| InstructionOperand CreateRandomStackSlotOperand(MachineRepresentation rep) { |
| int index = rng_->NextInt(static_cast<int>(allocated_slots_[rep].size())); |
| return AllocatedOperand(LocationOperand::STACK_SLOT, rep, |
| allocated_slots_[rep][index]); |
| } |
| |
| InstructionOperand CreateRandomConstant(MachineRepresentation rep) { |
| int index = rng_->NextInt(static_cast<int>(constants_[rep].size())); |
| return ConstantOperand(constants_[rep][index]); |
| } |
| |
| void CheckAssembleTailCallGaps(Instruction* instr, |
| int first_unused_stack_slot, |
| CodeGeneratorTester::PushTypeFlag push_type) { |
| generator_.AssembleTailCallBeforeGap(instr, first_unused_stack_slot); |
| #if defined(V8_TARGET_ARCH_ARM) || defined(V8_TARGET_ARCH_S390) || \ |
| defined(V8_TARGET_ARCH_PPC) |
| // Only folding register pushes is supported on ARM. |
| bool supported = ((push_type & CodeGenerator::kRegisterPush) == push_type); |
| #elif defined(V8_TARGET_ARCH_X64) || defined(V8_TARGET_ARCH_IA32) || \ |
| defined(V8_TARGET_ARCH_X87) |
| bool supported = ((push_type & CodeGenerator::kScalarPush) == push_type); |
| #else |
| bool supported = false; |
| #endif |
| if (supported) { |
| // Architectures supporting folding adjacent pushes should now have |
| // resolved all moves. |
| for (const auto& move : |
| *instr->parallel_moves()[Instruction::FIRST_GAP_POSITION]) { |
| CHECK(move->IsEliminated()); |
| } |
| } |
| generator_.AssembleGaps(instr); |
| generator_.AssembleTailCallAfterGap(instr, first_unused_stack_slot); |
| } |
| |
| void CheckAssembleMove(InstructionOperand* source, |
| InstructionOperand* destination) { |
| int start = generator_.tasm()->pc_offset(); |
| generator_.AssembleMove(source, destination); |
| CHECK(generator_.tasm()->pc_offset() > start); |
| } |
| |
| void CheckAssembleSwap(InstructionOperand* source, |
| InstructionOperand* destination) { |
| int start = generator_.tasm()->pc_offset(); |
| generator_.AssembleSwap(source, destination); |
| CHECK(generator_.tasm()->pc_offset() > start); |
| } |
| |
| Handle<Code> Finalize() { |
| InstructionOperand zero = ImmediateOperand(ImmediateOperand::INLINE, 0); |
| generator_.AssembleReturn(&zero); |
| |
| generator_.FinishCode(); |
| generator_.safepoints()->Emit(generator_.tasm(), |
| frame_.GetTotalFrameSlotCount()); |
| return generator_.FinalizeCode(); |
| } |
| |
| void Disassemble() { |
| HandleScope scope(main_isolate()); |
| Handle<Code> code = Finalize(); |
| if (FLAG_print_code) { |
| code->Print(); |
| } |
| } |
| |
| void Run() { |
| HandleScope scope(main_isolate()); |
| Handle<Code> code = Finalize(); |
| if (FLAG_print_code) { |
| code->Print(); |
| } |
| FunctionTester ft(code); |
| ft.Call(); |
| } |
| |
| v8::base::RandomNumberGenerator* rng() const { return rng_; } |
| |
| private: |
| CompilationInfo info_; |
| CallDescriptor* descriptor_; |
| Linkage linkage_; |
| ZoneVector<InstructionBlock*> blocks_; |
| InstructionSequence sequence_; |
| std::vector<MachineRepresentation> supported_reps_; |
| std::map<MachineRepresentation, std::vector<int>> allocated_slots_; |
| std::map<MachineRepresentation, std::vector<int>> constants_; |
| v8::base::RandomNumberGenerator* rng_; |
| Frame frame_; |
| CodeGenerator generator_; |
| }; |
| |
| // The following fuzz tests will assemble a lot of moves, wrap them in |
| // executable native code and run them. At this time, we only check that |
| // something is actually generated, and that it runs on hardware or the |
| // simulator. |
| |
| // TODO(all): It would be great to record the data on the stack after all moves |
| // are executed so that we could test the functionality in an architecture |
| // independent way. We would also have to make sure we generate moves compatible |
| // with each other as the gap-resolver tests do. |
| |
| TEST(FuzzAssembleMove) { |
| // Test small and potentially large ranges separately. Note that the number of |
| // slots affects how much stack is allocated when running the generated code. |
| // This means we have to be careful not to exceed the stack limit, which is |
| // lower on Windows. |
| for (auto n : {64, 500}) { |
| std::map<MachineRepresentation, int> slots = { |
| {MachineRepresentation::kTagged, n}, |
| {MachineRepresentation::kFloat32, n}, |
| {MachineRepresentation::kFloat64, n}}; |
| if (CpuFeatures::SupportsWasmSimd128()) { |
| // Generate fewer 128-bit slots. |
| slots.emplace(MachineRepresentation::kSimd128, n / 4); |
| } |
| CodeGeneratorTester c( |
| slots, |
| {Constant(0), Constant(1), Constant(2), Constant(3), Constant(4), |
| Constant(5), Constant(6), Constant(7), |
| Constant(static_cast<float>(0.1)), Constant(static_cast<float>(0.2)), |
| Constant(static_cast<float>(0.3)), Constant(static_cast<float>(0.4)), |
| Constant(static_cast<double>(0.5)), Constant(static_cast<double>(0.6)), |
| Constant(static_cast<double>(0.7)), |
| Constant(static_cast<double>(0.8))}); |
| ParallelMove* moves = c.GenerateRandomMoves(1000); |
| for (const auto m : *moves) { |
| c.CheckAssembleMove(&m->source(), &m->destination()); |
| } |
| c.Run(); |
| } |
| } |
| |
| TEST(FuzzAssembleSwap) { |
| // Test small and potentially large ranges separately. Note that the number of |
| // slots affects how much stack is allocated when running the generated code. |
| // This means we have to be careful not to exceed the stack limit, which is |
| // lower on Windows. |
| for (auto n : {64, 500}) { |
| std::map<MachineRepresentation, int> slots = { |
| {MachineRepresentation::kTagged, n}, |
| {MachineRepresentation::kFloat32, n}, |
| {MachineRepresentation::kFloat64, n}}; |
| if (CpuFeatures::SupportsWasmSimd128()) { |
| // Generate fewer 128-bit slots. |
| slots.emplace(MachineRepresentation::kSimd128, n / 4); |
| } |
| CodeGeneratorTester c(slots); |
| ParallelMove* moves = c.GenerateRandomSwaps(1000); |
| for (const auto m : *moves) { |
| c.CheckAssembleSwap(&m->source(), &m->destination()); |
| } |
| c.Run(); |
| } |
| } |
| |
| TEST(FuzzAssembleMoveAndSwap) { |
| // Test small and potentially large ranges separately. Note that the number of |
| // slots affects how much stack is allocated when running the generated code. |
| // This means we have to be careful not to exceed the stack limit, which is |
| // lower on Windows. |
| for (auto n : {64, 500}) { |
| std::map<MachineRepresentation, int> slots = { |
| {MachineRepresentation::kTagged, n}, |
| {MachineRepresentation::kFloat32, n}, |
| {MachineRepresentation::kFloat64, n}}; |
| if (CpuFeatures::SupportsWasmSimd128()) { |
| // Generate fewer 128-bit slots. |
| slots.emplace(MachineRepresentation::kSimd128, n / 4); |
| } |
| CodeGeneratorTester c( |
| slots, |
| {Constant(0), Constant(1), Constant(2), Constant(3), Constant(4), |
| Constant(5), Constant(6), Constant(7), |
| Constant(static_cast<float>(0.1)), Constant(static_cast<float>(0.2)), |
| Constant(static_cast<float>(0.3)), Constant(static_cast<float>(0.4)), |
| Constant(static_cast<double>(0.5)), Constant(static_cast<double>(0.6)), |
| Constant(static_cast<double>(0.7)), |
| Constant(static_cast<double>(0.8))}); |
| for (int i = 0; i < 1000; i++) { |
| // Randomly alternate between swaps and moves. |
| if (c.rng()->NextInt(2) == 0) { |
| MoveOperands* move = c.GenerateRandomMoves(1)->at(0); |
| c.CheckAssembleMove(&move->source(), &move->destination()); |
| } else { |
| MoveOperands* move = c.GenerateRandomSwaps(1)->at(0); |
| c.CheckAssembleSwap(&move->source(), &move->destination()); |
| } |
| } |
| c.Run(); |
| } |
| } |
| |
| TEST(AssembleTailCallGap) { |
| const RegisterConfiguration* conf = RegisterConfiguration::Default(); |
| |
| // This test assumes at least 4 registers are allocatable. |
| CHECK_LE(4, conf->num_allocatable_general_registers()); |
| |
| auto r0 = AllocatedOperand(LocationOperand::REGISTER, |
| MachineRepresentation::kTagged, |
| conf->GetAllocatableGeneralCode(0)); |
| auto r1 = AllocatedOperand(LocationOperand::REGISTER, |
| MachineRepresentation::kTagged, |
| conf->GetAllocatableGeneralCode(1)); |
| auto r2 = AllocatedOperand(LocationOperand::REGISTER, |
| MachineRepresentation::kTagged, |
| conf->GetAllocatableGeneralCode(2)); |
| auto r3 = AllocatedOperand(LocationOperand::REGISTER, |
| MachineRepresentation::kTagged, |
| conf->GetAllocatableGeneralCode(3)); |
| |
| auto slot_minus_4 = AllocatedOperand(LocationOperand::STACK_SLOT, |
| MachineRepresentation::kTagged, -4); |
| auto slot_minus_3 = AllocatedOperand(LocationOperand::STACK_SLOT, |
| MachineRepresentation::kTagged, -3); |
| auto slot_minus_2 = AllocatedOperand(LocationOperand::STACK_SLOT, |
| MachineRepresentation::kTagged, -2); |
| auto slot_minus_1 = AllocatedOperand(LocationOperand::STACK_SLOT, |
| MachineRepresentation::kTagged, -1); |
| |
| // Avoid slot 0 for architectures which use it store the return address. |
| int first_slot = V8_TARGET_ARCH_STORES_RETURN_ADDRESS_ON_STACK ? 1 : 0; |
| auto slot_0 = AllocatedOperand(LocationOperand::STACK_SLOT, |
| MachineRepresentation::kTagged, first_slot); |
| auto slot_1 = |
| AllocatedOperand(LocationOperand::STACK_SLOT, |
| MachineRepresentation::kTagged, first_slot + 1); |
| auto slot_2 = |
| AllocatedOperand(LocationOperand::STACK_SLOT, |
| MachineRepresentation::kTagged, first_slot + 2); |
| auto slot_3 = |
| AllocatedOperand(LocationOperand::STACK_SLOT, |
| MachineRepresentation::kTagged, first_slot + 3); |
| |
| // These tests all generate series of moves that the code generator should |
| // detect as adjacent pushes. Depending on the architecture, we make sure |
| // these moves get eliminated. |
| // Also, disassembling with `--print-code` is useful when debugging. |
| |
| { |
| // Generate a series of register pushes only. |
| CodeGeneratorTester c; |
| Instruction* instr = Instruction::New(c.main_zone(), kArchNop); |
| instr |
| ->GetOrCreateParallelMove(Instruction::FIRST_GAP_POSITION, |
| c.main_zone()) |
| ->AddMove(r3, slot_0); |
| instr |
| ->GetOrCreateParallelMove(Instruction::FIRST_GAP_POSITION, |
| c.main_zone()) |
| ->AddMove(r2, slot_1); |
| instr |
| ->GetOrCreateParallelMove(Instruction::FIRST_GAP_POSITION, |
| c.main_zone()) |
| ->AddMove(r1, slot_2); |
| instr |
| ->GetOrCreateParallelMove(Instruction::FIRST_GAP_POSITION, |
| c.main_zone()) |
| ->AddMove(r0, slot_3); |
| |
| c.CheckAssembleTailCallGaps(instr, first_slot + 4, |
| CodeGeneratorTester::kRegisterPush); |
| c.Disassemble(); |
| } |
| |
| { |
| // Generate a series of stack pushes only. |
| CodeGeneratorTester c; |
| Instruction* instr = Instruction::New(c.main_zone(), kArchNop); |
| instr |
| ->GetOrCreateParallelMove(Instruction::FIRST_GAP_POSITION, |
| c.main_zone()) |
| ->AddMove(slot_minus_4, slot_0); |
| instr |
| ->GetOrCreateParallelMove(Instruction::FIRST_GAP_POSITION, |
| c.main_zone()) |
| ->AddMove(slot_minus_3, slot_1); |
| instr |
| ->GetOrCreateParallelMove(Instruction::FIRST_GAP_POSITION, |
| c.main_zone()) |
| ->AddMove(slot_minus_2, slot_2); |
| instr |
| ->GetOrCreateParallelMove(Instruction::FIRST_GAP_POSITION, |
| c.main_zone()) |
| ->AddMove(slot_minus_1, slot_3); |
| |
| c.CheckAssembleTailCallGaps(instr, first_slot + 4, |
| CodeGeneratorTester::kStackSlotPush); |
| c.Disassemble(); |
| } |
| |
| { |
| // Generate a mix of stack and register pushes. |
| CodeGeneratorTester c; |
| Instruction* instr = Instruction::New(c.main_zone(), kArchNop); |
| instr |
| ->GetOrCreateParallelMove(Instruction::FIRST_GAP_POSITION, |
| c.main_zone()) |
| ->AddMove(slot_minus_2, slot_0); |
| instr |
| ->GetOrCreateParallelMove(Instruction::FIRST_GAP_POSITION, |
| c.main_zone()) |
| ->AddMove(r1, slot_1); |
| instr |
| ->GetOrCreateParallelMove(Instruction::FIRST_GAP_POSITION, |
| c.main_zone()) |
| ->AddMove(slot_minus_1, slot_2); |
| instr |
| ->GetOrCreateParallelMove(Instruction::FIRST_GAP_POSITION, |
| c.main_zone()) |
| ->AddMove(r0, slot_3); |
| |
| c.CheckAssembleTailCallGaps(instr, first_slot + 4, |
| CodeGeneratorTester::kScalarPush); |
| c.Disassemble(); |
| } |
| } |
| |
| } // namespace compiler |
| } // namespace internal |
| } // namespace v8 |
