Rename LChunkBase to LChunk, LChunk to LPlatformChunk and remove some unneeded explicit constructor…

src/lithium.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 239 matching lines @@
     case FAST_HOLEY_ELEMENTS:
     case DICTIONARY_ELEMENTS:
     case NON_STRICT_ARGUMENTS_ELEMENTS:
       return kPointerSizeLog2;
   }
   UNREACHABLE();
   return 0;
 }
 
 
-LLabel* LChunkBase::GetLabel(int block_id) const {
+LLabel* LChunk::GetLabel(int block_id) const {
   HBasicBlock* block = graph_->blocks()->at(block_id);
   int first_instruction = block->first_instruction_index();
   return LLabel::cast(instructions_[first_instruction]);
 }
 
 
-int LChunkBase::LookupDestination(int block_id) const {
+int LChunk::LookupDestination(int block_id) const {
   LLabel* cur = GetLabel(block_id);
   while (cur->replacement() != NULL) {
     cur = cur->replacement();
   }
   return cur->block_id();
 }
 
-Label* LChunkBase::GetAssemblyLabel(int block_id) const {
+Label* LChunk::GetAssemblyLabel(int block_id) const {
   LLabel* label = GetLabel(block_id);
   ASSERT(!label->HasReplacement());
   return label->label();
 }
 
-void LChunkBase::MarkEmptyBlocks() {
+void LChunk::MarkEmptyBlocks() {
   HPhase phase("L_Mark empty blocks", this);
   for (int i = 0; i < graph()->blocks()->length(); ++i) {
     HBasicBlock* block = graph()->blocks()->at(i);
     int first = block->first_instruction_index();
     int last = block->last_instruction_index();
     LInstruction* first_instr = instructions()->at(first);
     LInstruction* last_instr = instructions()->at(last);
 
     LLabel* label = LLabel::cast(first_instr);
     if (last_instr->IsGoto()) {
@@ skipping 15 matching lines @@
 
         if (can_eliminate) {
           label->set_replacement(GetLabel(goto_instr->block_id()));
         }
       }
     }
   }
 }
 
 
-void LChunkBase::AddInstruction(LInstruction* instr, HBasicBlock* block) {
+void LChunk::AddInstruction(LInstruction* instr, HBasicBlock* block) {
   LInstructionGap* gap = new(graph_->zone()) LInstructionGap(block);
   int index = -1;
   if (instr->IsControl()) {
     instructions_.Add(gap, zone());
     index = instructions_.length();
     instructions_.Add(instr, zone());
   } else {
     index = instructions_.length();
     instructions_.Add(instr, zone());
     instructions_.Add(gap, zone());
   }
   if (instr->HasPointerMap()) {
     pointer_maps_.Add(instr->pointer_map(), zone());
     instr->pointer_map()->set_lithium_position(index);
   }
 }
 
 
-LConstantOperand* LChunkBase::DefineConstantOperand(HConstant* constant) {
+LConstantOperand* LChunk::DefineConstantOperand(HConstant* constant) {
   return LConstantOperand::Create(constant->id(), zone());
 }
 
 
-int LChunkBase::GetParameterStackSlot(int index) const {
+int LChunk::GetParameterStackSlot(int index) const {
   // The receiver is at index 0, the first parameter at index 1, so we
   // shift all parameter indexes down by the number of parameters, and
   // make sure they end up negative so they are distinguishable from
   // spill slots.
   int result = index - info()->scope()->num_parameters() - 1;
   ASSERT(result < 0);
   return result;
 }
 
 
 // A parameter relative to ebp in the arguments stub.
-int LChunkBase::ParameterAt(int index) {
+int LChunk::ParameterAt(int index) {
   ASSERT(-1 <= index);  // -1 is the receiver.
   return (1 + info()->scope()->num_parameters() - index) *
       kPointerSize;
 }
 
 
-LGap* LChunkBase::GetGapAt(int index) const {
+LGap* LChunk::GetGapAt(int index) const {
   return LGap::cast(instructions_[index]);
 }
 
 
-bool LChunkBase::IsGapAt(int index) const {
+bool LChunk::IsGapAt(int index) const {
   return instructions_[index]->IsGap();
 }
 
 
-int LChunkBase::NearestGapPos(int index) const {
+int LChunk::NearestGapPos(int index) const {
   while (!IsGapAt(index)) index--;
   return index;
 }
 
 
-void LChunkBase::AddGapMove(int index, LOperand* from, LOperand* to) {
+void LChunk::AddGapMove(int index, LOperand* from, LOperand* to) {
   GetGapAt(index)->GetOrCreateParallelMove(
       LGap::START, zone())->AddMove(from, to, zone());
 }
 
 
-HConstant* LChunkBase::LookupConstant(LConstantOperand* operand) const {
+HConstant* LChunk::LookupConstant(LConstantOperand* operand) const {
   return HConstant::cast(graph_->LookupValue(operand->index()));
 }
 
 
-Representation LChunkBase::LookupLiteralRepresentation(
+Representation LChunk::LookupLiteralRepresentation(
     LConstantOperand* operand) const {
   return graph_->LookupValue(operand->index())->representation();
 }
 
 
-LChunkBase* LChunkBase::NewChunk(HGraph* graph) {
+LChunk* LChunk::NewChunk(HGraph* graph) {
   int values = graph->GetMaximumValueID();
   if (values > LUnallocated::kMaxVirtualRegisters) {
     if (FLAG_trace_bailout) {
       PrintF("Not enough virtual registers for (values).\n");
     }
     return NULL;
   }
   LAllocator allocator(values, graph);
   LChunkBuilder builder(graph->info(), graph, &allocator);
-  LChunkBase* chunk = builder.Build();
+  LChunk* chunk = builder.Build();
   if (chunk == NULL) return NULL;
 
   if (!allocator.Allocate(chunk)) {
     if (FLAG_trace_bailout) {
       PrintF("Not enough virtual registers (regalloc).\n");
     }
     return NULL;
   }
 
   return chunk;
 }
 
 
-Handle<Code> LChunkBase::Codegen() {
+Handle<Code> LChunk::Codegen() {
   MacroAssembler assembler(info()->isolate(), NULL, 0);
   LCodeGen generator(this, &assembler, info());
 
   MarkEmptyBlocks();
 
   if (generator.GenerateCode()) {
     if (FLAG_trace_codegen) {
       PrintF("Crankshaft Compiler - ");
     }
     CodeGenerator::MakeCodePrologue(info());
     Code::Flags flags = Code::ComputeFlags(Code::OPTIMIZED_FUNCTION);
     Handle<Code> code =
         CodeGenerator::MakeCodeEpilogue(&assembler, flags, info());
     generator.FinishCode(code);
     CodeGenerator::PrintCode(code, info());
     return code;
   }
   return Handle<Code>::null();
 }
 
 
 } }  // namespace v8::internal