Implemented missing instructions in ia32, more sharing, removed bailouts, enable optimiziations on …

runtime/vm/intermediate_language.cc

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "vm/intermediate_language.h"
 
 #include "vm/bit_vector.h"
 #include "vm/flow_graph_builder.h"
 #include "vm/flow_graph_compiler.h"
 #include "vm/locations.h"
@@ skipping 608 matching lines @@
 // Truee iff. the v2 is above v1 on stack, or one of them is constant.
 static bool VerifyValues(Value* v1, Value* v2) {
   ASSERT(v1->IsUse() && v2->IsUse());
   return (v1->AsUse()->definition()->temp_index() + 1) ==
      v2->AsUse()->definition()->temp_index();
 }
 
 
 #define __ compiler->assembler()->
 
-void GraphEntryInstr::PrepareEntry(FlowGraphCompiler* compiler) {
+void GraphEntryInstr::PrepareEntry(FlowGraphCompilerShared* compiler) {
   // Nothing to do.
 }
 
 
-void JoinEntryInstr::PrepareEntry(FlowGraphCompiler* compiler) {
+void JoinEntryInstr::PrepareEntry(FlowGraphCompilerShared* compiler) {
   __ Bind(compiler->GetBlockLabel(this));
 }
 
 
-void TargetEntryInstr::PrepareEntry(FlowGraphCompiler* compiler) {
+void TargetEntryInstr::PrepareEntry(FlowGraphCompilerShared* compiler) {
   __ Bind(compiler->GetBlockLabel(this));
   if (HasTryIndex()) {
     compiler->AddExceptionHandler(try_index(),
                                   compiler->assembler()->CodeSize());
   }
 }
 
 
 LocationSummary* ThrowInstr::MakeLocationSummary() const {
   const int kNumInputs = 0;
   const int kNumTemps = 0;
   return new LocationSummary(kNumInputs, kNumTemps);
 }
 
 
 
-void ThrowInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
+void ThrowInstr::EmitNativeCode(FlowGraphCompilerShared* compiler) {
   ASSERT(exception()->IsUse());
   compiler->GenerateCallRuntime(cid(),
                                 token_index(),
                                 try_index(),
                                 kThrowRuntimeEntry);
   __ int3();
 }
 
 
 LocationSummary* ReThrowInstr::MakeLocationSummary() const {
   const int kNumInputs = 0;
   const int kNumTemps = 0;
   return new LocationSummary(kNumInputs, kNumTemps);
 }
 
 
-void ReThrowInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
+void ReThrowInstr::EmitNativeCode(FlowGraphCompilerShared* compiler) {
   ASSERT(exception()->IsUse());
   ASSERT(stack_trace()->IsUse());
   compiler->GenerateCallRuntime(cid(),
                                 token_index(),
                                 try_index(),
                                 kReThrowRuntimeEntry);
   __ int3();
 }
 
 
 LocationSummary* BranchInstr::MakeLocationSummary() const {
   const int kNumInputs = 1;
   const int kNumTemps = 0;
   LocationSummary* locs = new LocationSummary(kNumInputs, kNumTemps);
   locs->set_in(0, Location::RequiresRegister());
   return locs;
 }
 
 
-void BranchInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
+void BranchInstr::EmitNativeCode(FlowGraphCompilerShared* compiler) {
   Register value = locs()->in(0).reg();
   __ CompareObject(value,  Bool::ZoneHandle(Bool::True()));
   if (compiler->IsNextBlock(false_successor())) {
     // If the next block is the false successor we will fall through to it if
     // comparison with true fails.
     __ j(EQUAL, compiler->GetBlockLabel(true_successor()));
   } else {
     ASSERT(compiler->IsNextBlock(true_successor()));
     // If the next block is the true successor we negate comparison and fall
     // through to it.
     __ j(NOT_EQUAL, compiler->GetBlockLabel(false_successor()));
   }
 }
 
 
 LocationSummary* CurrentContextComp::MakeLocationSummary() const {
   return LocationSummary::Make(0, Location::RequiresRegister());
 }
 
 
-void CurrentContextComp::EmitNativeCode(FlowGraphCompiler* compiler) {
+void CurrentContextComp::EmitNativeCode(FlowGraphCompilerShared* compiler) {
   __ MoveRegister(locs()->out().reg(), CTX);
 }
 
 
 LocationSummary* StoreContextComp::MakeLocationSummary() const {
   const intptr_t kNumInputs = 1;
   const intptr_t kNumTemps = 0;
   LocationSummary* summary = new LocationSummary(kNumInputs, kNumTemps);
   summary->set_in(0, Location::RegisterLocation(CTX));
   return summary;
 }
 
 
-void StoreContextComp::EmitNativeCode(FlowGraphCompiler* compiler) {
+void StoreContextComp::EmitNativeCode(FlowGraphCompilerShared* compiler) {
   // Nothing to do.  Context register were loaded by register allocator.
   ASSERT(locs()->in(0).reg() == CTX);
 }
 
 
 LocationSummary* StrictCompareComp::MakeLocationSummary() const {
   return LocationSummary::Make(2, Location::SameAsFirstInput());
 }
 
 
-void StrictCompareComp::EmitNativeCode(FlowGraphCompiler* compiler) {
+void StrictCompareComp::EmitNativeCode(FlowGraphCompilerShared* compiler) {
   const Bool& bool_true = Bool::ZoneHandle(Bool::True());
   const Bool& bool_false = Bool::ZoneHandle(Bool::False());
 
   Register left = locs()->in(0).reg();
   Register right = locs()->in(1).reg();
   Register result = locs()->out().reg();
 
   __ CompareRegisters(left, right);
   Label load_true, done;
   if (kind() == Token::kEQ_STRICT) {
     __ j(EQUAL, &load_true, Assembler::kNearJump);
   } else {
     ASSERT(kind() == Token::kNE_STRICT);
     __ j(NOT_EQUAL, &load_true, Assembler::kNearJump);
   }
   __ LoadObject(result, bool_false);
   __ jmp(&done, Assembler::kNearJump);
   __ Bind(&load_true);
   __ LoadObject(result, bool_true);
   __ Bind(&done);
 }
 
 
-void ClosureCallComp::EmitNativeCode(FlowGraphCompiler* compiler) {
+void ClosureCallComp::EmitNativeCode(FlowGraphCompilerShared* compiler) {
   ASSERT(VerifyCallComputation(this));
   // The arguments to the stub include the closure.  The arguments
   // descriptor describes the closure's arguments (and so does not include
   // the closure).
   Register temp_reg = locs()->temp(0).reg();
   int argument_count = ArgumentCount();
   const Array& arguments_descriptor =
       CodeGenerator::ArgumentsDescriptor(argument_count - 1,
                                          argument_names());
   __ LoadObject(temp_reg, arguments_descriptor);
 
   compiler->GenerateCall(token_index(),
                          try_index(),
                          &StubCode::CallClosureFunctionLabel(),
                          PcDescriptors::kOther);
   __ Drop(argument_count);
 }
 
 
 LocationSummary* InstanceCallComp::MakeLocationSummary() const {
   return MakeCallSummary();
 }
 
 
-void InstanceCallComp::EmitNativeCode(FlowGraphCompiler* compiler) {
+void InstanceCallComp::EmitNativeCode(FlowGraphCompilerShared* compiler) {
   ASSERT(VerifyCallComputation(this));
   compiler->AddCurrentDescriptor(PcDescriptors::kDeopt,
                                  cid(),
                                  token_index(),
                                  try_index());
   compiler->GenerateInstanceCall(cid(),
                                  token_index(),
                                  try_index(),
                                  function_name(),
                                  ArgumentCount(),
                                  argument_names(),
                                  checked_argument_count());
 }
 
 
 LocationSummary* StaticCallComp::MakeLocationSummary() const {
   return MakeCallSummary();
 }
 
 
-void StaticCallComp::EmitNativeCode(FlowGraphCompiler* compiler) {
+void StaticCallComp::EmitNativeCode(FlowGraphCompilerShared* compiler) {
   ASSERT(VerifyCallComputation(this));
   compiler->GenerateStaticCall(cid(),
                                token_index(),
                                try_index(),
                                function(),
                                ArgumentCount(),
                                argument_names());
 }
 
 
 LocationSummary* UseVal::MakeLocationSummary() const {
   return NULL;
 }
 
 
-void UseVal::EmitNativeCode(FlowGraphCompiler* compiler) {
+void UseVal::EmitNativeCode(FlowGraphCompilerShared* compiler) {
   UNIMPLEMENTED();
 }
 
 
-void AssertAssignableComp::EmitNativeCode(FlowGraphCompiler* compiler) {
+void AssertAssignableComp::EmitNativeCode(FlowGraphCompilerShared* compiler) {
   compiler->GenerateAssertAssignable(cid(),
                                      token_index(),
                                      try_index(),
                                      dst_type(),
                                      dst_name());
   ASSERT(locs()->in(0).reg() == locs()->out().reg());
 }
 
 
 LocationSummary* AssertBooleanComp::MakeLocationSummary() const {
   return LocationSummary::Make(1, Location::SameAsFirstInput());
 }
 
 
 LocationSummary* StoreInstanceFieldComp::MakeLocationSummary() const {
   return LocationSummary::Make(2, Location::RequiresRegister());
 }
 
 
-void StoreInstanceFieldComp::EmitNativeCode(FlowGraphCompiler* compiler) {
+void StoreInstanceFieldComp::EmitNativeCode(FlowGraphCompilerShared* compiler) {
   ASSERT(VerifyValues(instance(), value()));
   Register instance = locs()->in(0).reg();
   Register value = locs()->in(1).reg();
   Register result = locs()->out().reg();
 
   __ StoreIntoObject(instance, FieldAddress(instance, field().Offset()),
                      value);
   // TODO(fschneider): Consider eliminating this move by specifying a
   // SameAsSecondInput for the result.
   __ MoveRegister(result, value);
 }
 
 
 LocationSummary* StoreStaticFieldComp::MakeLocationSummary() const {
   LocationSummary* locs = new LocationSummary(1, 1);
   locs->set_in(0, Location::RequiresRegister());
   locs->set_temp(0, Location::RequiresRegister());
   locs->set_out(Location::SameAsFirstInput());
   return locs;
 }
 
 
-void StoreStaticFieldComp::EmitNativeCode(FlowGraphCompiler* compiler) {
+void StoreStaticFieldComp::EmitNativeCode(FlowGraphCompilerShared* compiler) {
   Register value = locs()->in(0).reg();
   Register temp = locs()->temp(0).reg();
   ASSERT(locs()->out().reg() == value);
 
   __ LoadObject(temp, field());
   __ StoreIntoObject(temp, FieldAddress(temp, Field::value_offset()), value);
 }
 
 
 LocationSummary* BooleanNegateComp::MakeLocationSummary() const {
   return LocationSummary::Make(1, Location::RequiresRegister());
 }
 
 
-void BooleanNegateComp::EmitNativeCode(FlowGraphCompiler* compiler) {
+void BooleanNegateComp::EmitNativeCode(FlowGraphCompilerShared* compiler) {
   Register value = locs()->in(0).reg();
   Register result = locs()->out().reg();
 
   const Bool& bool_true = Bool::ZoneHandle(Bool::True());
   const Bool& bool_false = Bool::ZoneHandle(Bool::False());
   Label done;
   __ LoadObject(result, bool_true);
   __ CompareRegisters(result, value);
   __ j(NOT_EQUAL, &done, Assembler::kNearJump);
   __ LoadObject(result, bool_false);
   __ Bind(&done);
 }
 
 
 LocationSummary* ChainContextComp::MakeLocationSummary() const {
   return LocationSummary::Make(1, Location::NoLocation());
 }
 
 
-void ChainContextComp::EmitNativeCode(FlowGraphCompiler* compiler) {
+void ChainContextComp::EmitNativeCode(FlowGraphCompilerShared* compiler) {
   Register context_value = locs()->in(0).reg();
 
   // Chain the new context in context_value to its parent in CTX.
   __ StoreIntoObject(context_value,
                      FieldAddress(context_value, Context::parent_offset()),
                      CTX);
   // Set new context as current context.
   __ MoveRegister(CTX, context_value);
 }
 
 
 LocationSummary* StoreVMFieldComp::MakeLocationSummary() const {
   return LocationSummary::Make(2, Location::SameAsFirstInput());
 }
 
 
-void StoreVMFieldComp::EmitNativeCode(FlowGraphCompiler* compiler) {
+void StoreVMFieldComp::EmitNativeCode(FlowGraphCompilerShared* compiler) {
   Register value_reg = locs()->in(0).reg();
   Register dest_reg = locs()->in(1).reg();
   ASSERT(value_reg == locs()->out().reg());
 
   __ StoreIntoObject(dest_reg, FieldAddress(dest_reg, offset_in_bytes()),
                      value_reg);
 }
 
 
 LocationSummary* AllocateObjectComp::MakeLocationSummary() const {
   return MakeCallSummary();
 }
 
 
-void AllocateObjectComp::EmitNativeCode(FlowGraphCompiler* compiler) {
+void AllocateObjectComp::EmitNativeCode(FlowGraphCompilerShared* compiler) {
   const Class& cls = Class::ZoneHandle(constructor().owner());
   const Code& stub = Code::Handle(StubCode::GetAllocationStubForClass(cls));
   const ExternalLabel label(cls.ToCString(), stub.EntryPoint());
   compiler->GenerateCall(token_index(),
                          try_index(),
                          &label,
                          PcDescriptors::kOther);
   __ Drop(arguments().length());  // Discard arguments.
 }
 
 
 LocationSummary* CreateClosureComp::MakeLocationSummary() const {
   return MakeCallSummary();
 }
 
 
-void CreateClosureComp::EmitNativeCode(FlowGraphCompiler* compiler) {
+void CreateClosureComp::EmitNativeCode(FlowGraphCompilerShared* compiler) {
   const Function& closure_function = function();
   const Code& stub = Code::Handle(
       StubCode::GetAllocationStubForClosure(closure_function));
   const ExternalLabel label(closure_function.ToCString(), stub.EntryPoint());
   compiler->GenerateCall(token_index(), try_index(), &label,
                          PcDescriptors::kOther);
   __ Drop(2);  // Discard type arguments and receiver.
 }
 
 #undef __
 
 }  // namespace dart