Replace MIPS TraceSimMsg calls with Comment calls.

runtime/vm/intermediate_language_mips.cc

 // Copyright (c) 2013, 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/globals.h"  // Needed here to get TARGET_ARCH_MIPS.
 #if defined(TARGET_ARCH_MIPS)
 
 #include "vm/intermediate_language.h"
 
 #include "vm/dart_entry.h"
@@ skipping 36 matching lines @@
   LocationSummary* locs = new(zone) LocationSummary(
       zone, kNumInputs, kNumTemps, LocationSummary::kNoCall);
   locs->set_in(0, Location::AnyOrConstant(value()));
   return locs;
 }
 
 
 void PushArgumentInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   // In SSA mode, we need an explicit push. Nothing to do in non-SSA mode
   // where PushArgument is handled by BindInstr::EmitNativeCode.
-  __ TraceSimMsg("PushArgumentInstr");
+  __ Comment("PushArgumentInstr");
   if (compiler->is_optimizing()) {
     Location value = locs()->in(0);
     if (value.IsRegister()) {
       __ Push(value.reg());
     } else if (value.IsConstant()) {
       __ PushObject(value.constant());
     } else {
       ASSERT(value.IsStackSlot());
       const intptr_t value_offset = value.ToStackSlotOffset();
       __ LoadFromOffset(TMP, FP, value_offset);
@@ skipping 11 matching lines @@
       zone, kNumInputs, kNumTemps, LocationSummary::kNoCall);
   locs->set_in(0, Location::RegisterLocation(V0));
   return locs;
 }
 
 
 // Attempt optimized compilation at return instruction instead of at the entry.
 // The entry needs to be patchable, no inlined objects are allowed in the area
 // that will be overwritten by the patch instructions: a branch macro sequence.
 void ReturnInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
-  __ TraceSimMsg("ReturnInstr");
+  __ Comment("ReturnInstr");
   Register result = locs()->in(0).reg();
   ASSERT(result == V0);
 
   if (compiler->intrinsic_mode()) {
     // Intrinsics don't have a frame.
     __ Ret();
     return;
   }
 
 #if defined(DEBUG)
   Label stack_ok;
   __ Comment("Stack Check");
-  __ TraceSimMsg("Stack Check");
   const intptr_t fp_sp_dist =
       (kFirstLocalSlotFromFp + 1 - compiler->StackSize()) * kWordSize;
   ASSERT(fp_sp_dist <= 0);
   __ subu(CMPRES1, SP, FP);
 
   __ BranchEqual(CMPRES1, Immediate(fp_sp_dist), &stack_ok);
   __ break_(0);
 
   __ Bind(&stack_ok);
 #endif
@@ skipping 189 matching lines @@
 LocationSummary* LoadLocalInstr::MakeLocationSummary(Zone* zone,
                                                      bool opt) const {
   return LocationSummary::Make(zone,
                                0,
                                Location::RequiresRegister(),
                                LocationSummary::kNoCall);
 }
 
 
 void LoadLocalInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
-  __ TraceSimMsg("LoadLocalInstr");
+  __ Comment("LoadLocalInstr");
   Register result = locs()->out(0).reg();
   __ LoadFromOffset(result, FP, local().index() * kWordSize);
 }
 
 
 LocationSummary* StoreLocalInstr::MakeLocationSummary(Zone* zone,
                                                       bool opt) const {
   return LocationSummary::Make(zone,
                                1,
                                Location::SameAsFirstInput(),
                                LocationSummary::kNoCall);
 }
 
 
 void StoreLocalInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
-  __ TraceSimMsg("StoreLocalInstr");
+  __ Comment("StoreLocalInstr");
   Register value = locs()->in(0).reg();
   Register result = locs()->out(0).reg();
   ASSERT(result == value);  // Assert that register assignment is correct.
   __ StoreToOffset(value, FP, local().index() * kWordSize);
 }
 
 
 LocationSummary* ConstantInstr::MakeLocationSummary(Zone* zone,
                                                     bool opt) const {
   return LocationSummary::Make(zone,
                                0,
                                Location::RequiresRegister(),
                                LocationSummary::kNoCall);
 }
 
 
 void ConstantInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   // The register allocator drops constant definitions that have no uses.
   if (!locs()->out(0).IsInvalid()) {
-    __ TraceSimMsg("ConstantInstr");
+    __ Comment("ConstantInstr");
     Register result = locs()->out(0).reg();
     __ LoadObject(result, value());
   }
 }
 
 
 LocationSummary* UnboxedConstantInstr::MakeLocationSummary(Zone* zone,
                                                            bool opt) const {
   const intptr_t kNumInputs = 0;
   const intptr_t kNumTemps = (representation_ == kUnboxedInt32) ? 0 : 1;
@@ skipping 91 matching lines @@
   // We should never return here.
   __ break_(0);
   __ Bind(&done);
 }
 
 
 void AssertBooleanInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   Register obj = locs()->in(0).reg();
   Register result = locs()->out(0).reg();
 
-  __ TraceSimMsg("AssertBooleanInstr");
+  __ Comment("AssertBooleanInstr");
   EmitAssertBoolean(obj, token_pos(), deopt_id(), locs(), compiler);
   ASSERT(obj == result);
 }
 
 
 LocationSummary* EqualityCompareInstr::MakeLocationSummary(Zone* zone,
                                                            bool opt) const {
   const intptr_t kNumInputs = 2;
   if (operation_cid() == kMintCid) {
     const intptr_t kNumTemps = 0;
@@ skipping 30 matching lines @@
   }
   UNREACHABLE();
   return NULL;
 }
 
 
 static void LoadValueCid(FlowGraphCompiler* compiler,
                          Register value_cid_reg,
                          Register value_reg,
                          Label* value_is_smi = NULL) {
-  __ TraceSimMsg("LoadValueCid");
+  __ Comment("LoadValueCid");
   Label done;
   if (value_is_smi == NULL) {
     __ LoadImmediate(value_cid_reg, kSmiCid);
   }
   __ andi(CMPRES1, value_reg, Immediate(kSmiTagMask));
   if (value_is_smi == NULL) {
     __ beq(CMPRES1, ZR, &done);
   } else {
     __ beq(CMPRES1, ZR, value_is_smi);
   }
@@ skipping 29 matching lines @@
       UNREACHABLE();
       return NV;
   }
 }
 
 
 // The comparison code to emit is specified by true_condition.
 static void EmitBranchOnCondition(FlowGraphCompiler* compiler,
                                   Condition true_condition,
                                   BranchLabels labels) {
-  __ TraceSimMsg("ControlInstruction::EmitBranchOnCondition");
+  __ Comment("ControlInstruction::EmitBranchOnCondition");
   if (labels.fall_through == labels.false_label) {
     // If the next block is the false successor, fall through to it.
     __ BranchOnCondition(true_condition, labels.true_label);
   } else {
     // If the next block is not the false successor, branch to it.
     Condition false_condition = NegateCondition(true_condition);
     __ BranchOnCondition(false_condition, labels.false_label);
     // Fall through or jump to the true successor.
     if (labels.fall_through != labels.true_label) {
       __ b(labels.true_label);
     }
   }
 }
 
 
 static Condition EmitSmiComparisonOp(FlowGraphCompiler* compiler,
                                      const LocationSummary& locs,
                                      Token::Kind kind) {
-  __ TraceSimMsg("EmitSmiComparisonOp");
   __ Comment("EmitSmiComparisonOp");
   const Location left = locs.in(0);
   const Location right = locs.in(1);
   ASSERT(!left.IsConstant() || !right.IsConstant());
   ASSERT(left.IsRegister() || left.IsConstant());
   ASSERT(right.IsRegister() || right.IsConstant());
 
   int16_t imm = 0;
   const Register left_reg = left.IsRegister() ?
       left.reg() : __ LoadConditionOperand(CMPRES1, left.constant(), &imm);
   const Register right_reg = right.IsRegister() ?
       right.reg() : __ LoadConditionOperand(CMPRES2, right.constant(), &imm);
   return Condition(left_reg, right_reg, TokenKindToIntRelOp(kind), imm);
 }
 
 
 static Condition EmitUnboxedMintEqualityOp(FlowGraphCompiler* compiler,
                                            const LocationSummary& locs,
                                            Token::Kind kind,
                                            BranchLabels labels) {
-  __ TraceSimMsg("EmitUnboxedMintEqualityOp");
   __ Comment("EmitUnboxedMintEqualityOp");
   ASSERT(Token::IsEqualityOperator(kind));
   PairLocation* left_pair = locs.in(0).AsPairLocation();
   Register left_lo = left_pair->At(0).reg();
   Register left_hi = left_pair->At(1).reg();
   PairLocation* right_pair = locs.in(1).AsPairLocation();
   Register right_lo = right_pair->At(0).reg();
   Register right_hi = right_pair->At(1).reg();
 
   if (labels.false_label == NULL) {
@@ skipping 11 matching lines @@
     }
     return Condition(left_lo, right_lo, TokenKindToUintRelOp(kind));
   }
 }
 
 
 static Condition EmitUnboxedMintComparisonOp(FlowGraphCompiler* compiler,
                                              const LocationSummary& locs,
                                              Token::Kind kind,
                                              BranchLabels labels) {
-  __ TraceSimMsg("EmitUnboxedMintComparisonOp");
   __ Comment("EmitUnboxedMintComparisonOp");
   PairLocation* left_pair = locs.in(0).AsPairLocation();
   Register left_lo = left_pair->At(0).reg();
   Register left_hi = left_pair->At(1).reg();
   PairLocation* right_pair = locs.in(1).AsPairLocation();
   Register right_lo = right_pair->At(0).reg();
   Register right_hi = right_pair->At(1).reg();
 
   if (labels.false_label == NULL) {
     // Generate branch-free code (except for skipping the lower words compare).
@@ skipping 122 matching lines @@
   __ LoadObject(result, Bool::False());
   __ b(&done);
   __ Bind(&is_true);
   __ LoadObject(result, Bool::True());
   __ Bind(&done);
 }
 
 
 void EqualityCompareInstr::EmitBranchCode(FlowGraphCompiler* compiler,
                                           BranchInstr* branch) {
-  __ TraceSimMsg("EqualityCompareInstr");
-  __ Comment("EqualityCompareInstr:BranchCode");
+  __ Comment("EqualityCompareInstr::EmitBranchCode");
   ASSERT((kind() == Token::kNE) || (kind() == Token::kEQ));
 
   BranchLabels labels = compiler->CreateBranchLabels(branch);
   Condition true_condition = EmitComparisonCode(compiler, labels);
   EmitBranchOnCondition(compiler, true_condition, labels);
 }
 
 
 LocationSummary* TestSmiInstr::MakeLocationSummary(Zone* zone,
                                                    bool opt) const {
@@ skipping 155 matching lines @@
   } else if (operation_cid() == kMintCid) {
     return EmitUnboxedMintComparisonOp(compiler, *locs(), kind(), labels);
   } else {
     ASSERT(operation_cid() == kDoubleCid);
     return EmitDoubleComparisonOp(compiler, *locs(), kind(), labels);
   }
 }
 
 
 void RelationalOpInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
-  __ TraceSimMsg("RelationalOpInstr");
+  __ Comment("RelationalOpInstr");
 
   Label is_true, is_false;
   BranchLabels labels = { &is_true, &is_false, &is_false };
   Condition true_condition = EmitComparisonCode(compiler, labels);
   EmitBranchOnCondition(compiler, true_condition, labels);
 
   Register result = locs()->out(0).reg();
   Label done;
   __ Bind(&is_false);
   __ LoadObject(result, Bool::False());
   __ b(&done);
   __ Bind(&is_true);
   __ LoadObject(result, Bool::True());
   __ Bind(&done);
 }
 
 
 void RelationalOpInstr::EmitBranchCode(FlowGraphCompiler* compiler,
                                        BranchInstr* branch) {
-  __ TraceSimMsg("RelationalOpInstr");
+  __ Comment("RelationalOpInstr");
 
   BranchLabels labels = compiler->CreateBranchLabels(branch);
   Condition true_condition = EmitComparisonCode(compiler, labels);
   EmitBranchOnCondition(compiler, true_condition, labels);
 }
 
 
 LocationSummary* NativeCallInstr::MakeLocationSummary(Zone* zone,
                                                       bool opt) const {
   return MakeCallSummary(zone);
 }
 
 
 void NativeCallInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
-  __ TraceSimMsg("NativeCallInstr");
+  __ Comment("NativeCallInstr");
   Register result = locs()->out(0).reg();
 
   // Push the result place holder initialized to NULL.
   __ PushObject(Object::null_object());
   // Pass a pointer to the first argument in A2.
   if (!function().HasOptionalParameters()) {
     __ AddImmediate(A2, FP, (kParamEndSlotFromFp +
                              function().NumParameters()) * kWordSize);
   } else {
     __ AddImmediate(A2, FP, kFirstLocalSlotFromFp * kWordSize);
@@ skipping 43 matching lines @@
                                kNumInputs,
                                Location::RequiresRegister(),
                                LocationSummary::kNoCall);
 }
 
 
 void StringFromCharCodeInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   Register char_code = locs()->in(0).reg();
   Register result = locs()->out(0).reg();
 
-  __ TraceSimMsg("StringFromCharCodeInstr");
+  __ Comment("StringFromCharCodeInstr");
 
   __ LoadImmediate(result,
                    reinterpret_cast<uword>(Symbols::PredefinedAddress()));
   __ AddImmediate(result, Symbols::kNullCharCodeSymbolOffset * kWordSize);
   __ sll(TMP, char_code, 1);  // Char code is a smi.
   __ addu(TMP, TMP, result);
   __ lw(result, Address(TMP));
 }
 
 
 LocationSummary* StringToCharCodeInstr::MakeLocationSummary(Zone* zone,
                                                             bool opt) const {
   const intptr_t kNumInputs = 1;
   return LocationSummary::Make(zone,
                                kNumInputs,
                                Location::RequiresRegister(),
                                LocationSummary::kNoCall);
 }
 
 
 void StringToCharCodeInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
-  __ TraceSimMsg("StringToCharCodeInstr");
+  __ Comment("StringToCharCodeInstr");
 
   ASSERT(cid_ == kOneByteStringCid);
   Register str = locs()->in(0).reg();
   Register result = locs()->out(0).reg();
   ASSERT(str != result);
   Label done;
   __ lw(result, FieldAddress(str, String::length_offset()));
   __ BranchNotEqual(result, Immediate(Smi::RawValue(1)), &done);
   __ delay_slot()->addiu(result, ZR, Immediate(Smi::RawValue(-1)));
   __ lbu(result, FieldAddress(str, OneByteString::data_offset()));
@@ skipping 170 matching lines @@
       (representation() == kUnboxedInt32x4)) {
     locs->set_out(0, Location::RequiresFpuRegister());
   } else {
     locs->set_out(0, Location::RequiresRegister());
   }
   return locs;
 }
 
 
 void LoadIndexedInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
-  __ TraceSimMsg("LoadIndexedInstr");
+  __ Comment("LoadIndexedInstr");
   // The array register points to the backing store for external arrays.
   const Register array = locs()->in(0).reg();
   const Location index = locs()->in(1);
 
   Address element_address = index.IsRegister()
       ? __ ElementAddressForRegIndex(true,  // Load.
                                      IsExternal(), class_id(), index_scale(),
                                      array, index.reg())
       : __ ElementAddressForIntIndex(
             IsExternal(), class_id(), index_scale(),
@@ skipping 202 matching lines @@
       break;
     default:
       UNREACHABLE();
       return NULL;
   }
   return locs;
 }
 
 
 void StoreIndexedInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
-  __ TraceSimMsg("StoreIndexedInstr");
+  __ Comment("StoreIndexedInstr");
   // The array register points to the backing store for external arrays.
   const Register array = locs()->in(0).reg();
   const Location index = locs()->in(1);
 
   Address element_address = index.IsRegister()
       ? __ ElementAddressForRegIndex(false,  // Store.
                                      IsExternal(), class_id(), index_scale(),
                                      array, index.reg())
       : __ ElementAddressForIntIndex(
             IsExternal(), class_id(), index_scale(),
@@ skipping 111 matching lines @@
 
   for (intptr_t i = 0; i < num_temps; i++) {
     summary->set_temp(i, Location::RequiresRegister());
   }
 
   return summary;
 }
 
 
 void GuardFieldClassInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
-  __ TraceSimMsg("GuardFieldClassInstr");
+  __ Comment("GuardFieldClassInstr");
 
   const intptr_t value_cid = value()->Type()->ToCid();
   const intptr_t field_cid = field().guarded_cid();
   const intptr_t nullability = field().is_nullable() ? kNullCid : kIllegalCid;
 
   if (field_cid == kDynamicCid) {
     ASSERT(!compiler->is_optimizing());
     return;  // Nothing to emit.
   }
 
@@ skipping 452 matching lines @@
   return summary;
 }
 
 
 // When the parser is building an implicit static getter for optimization,
 // it can generate a function body where deoptimization ids do not line up
 // with the unoptimized code.
 //
 // This is safe only so long as LoadStaticFieldInstr cannot deoptimize.
 void LoadStaticFieldInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
-  __ TraceSimMsg("LoadStaticFieldInstr");
+  __ Comment("LoadStaticFieldInstr");
   Register field = locs()->in(0).reg();
   Register result = locs()->out(0).reg();
   __ LoadFromOffset(result, field, Field::value_offset() - kHeapObjectTag);
 }
 
 
 LocationSummary* StoreStaticFieldInstr::MakeLocationSummary(Zone* zone,
                                                             bool opt) const {
   LocationSummary* locs = new(zone) LocationSummary(
       zone, 1, 1, LocationSummary::kNoCall);
   locs->set_in(0, value()->NeedsStoreBuffer() ? Location::WritableRegister()
                                               : Location::RequiresRegister());
   locs->set_temp(0, Location::RequiresRegister());
   return locs;
 }
 
 
 void StoreStaticFieldInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
-  __ TraceSimMsg("StoreStaticFieldInstr");
+  __ Comment("StoreStaticFieldInstr");
   Register value = locs()->in(0).reg();
   Register temp = locs()->temp(0).reg();
 
   __ LoadObject(temp, field());
   if (this->value()->NeedsStoreBuffer()) {
     __ StoreIntoObject(temp,
         FieldAddress(temp, Field::value_offset()), value, CanValueBeSmi());
   } else {
     __ StoreIntoObjectNoBarrier(
         temp, FieldAddress(temp, Field::value_offset()), value);
@@ skipping 93 matching lines @@
       __ sw(T7, Address(T2, 0));
       __ addiu(T2, T2, Immediate(kWordSize));
       __ BranchUnsignedLess(T2, T1, &init_loop);
     }
   }
   __ b(done);
 }
 
 
 void CreateArrayInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
-  __ TraceSimMsg("CreateArrayInstr");
+  __ Comment("CreateArrayInstr");
   const Register kLengthReg = A1;
   const Register kElemTypeReg = A0;
   const Register kResultReg = V0;
   ASSERT(locs()->in(0).reg() == kElemTypeReg);
   ASSERT(locs()->in(1).reg() == kLengthReg);
 
   Label slow_path, done;
   if (num_elements()->BindsToConstant() &&
       num_elements()->BoundConstant().IsSmi()) {
     const intptr_t length = Smi::Cast(num_elements()->BoundConstant()).Value();
@@ skipping 128 matching lines @@
   const intptr_t kNumTemps = 0;
   LocationSummary* locs = new(zone) LocationSummary(
       zone, kNumInputs, kNumTemps, LocationSummary::kCall);
   locs->set_in(0, Location::RegisterLocation(T0));
   locs->set_out(0, Location::RegisterLocation(T0));
   return locs;
 }
 
 
 void InstantiateTypeInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
-  __ TraceSimMsg("InstantiateTypeInstr");
+  __ Comment("InstantiateTypeInstr");
   Register instantiator_reg = locs()->in(0).reg();
   Register result_reg = locs()->out(0).reg();
 
   // 'instantiator_reg' is the instantiator TypeArguments object (or null).
   // A runtime call to instantiate the type is required.
   __ addiu(SP, SP, Immediate(-3 * kWordSize));
   __ LoadObject(TMP, Object::null_object());
   __ sw(TMP, Address(SP, 2 * kWordSize));  // Make room for the result.
   __ LoadObject(TMP, type());
   __ sw(TMP, Address(SP, 1 * kWordSize));
@@ skipping 20 matching lines @@
   LocationSummary* locs = new(zone) LocationSummary(
       zone, kNumInputs, kNumTemps, LocationSummary::kCall);
   locs->set_in(0, Location::RegisterLocation(T0));
   locs->set_out(0, Location::RegisterLocation(T0));
   return locs;
 }
 
 
 void InstantiateTypeArgumentsInstr::EmitNativeCode(
     FlowGraphCompiler* compiler) {
-  __ TraceSimMsg("InstantiateTypeArgumentsInstr");
+  __ Comment("InstantiateTypeArgumentsInstr");
   Register instantiator_reg = locs()->in(0).reg();
   Register result_reg = locs()->out(0).reg();
   ASSERT(instantiator_reg == T0);
   ASSERT(instantiator_reg == result_reg);
 
   // 'instantiator_reg' is the instantiator TypeArguments object (or null).
   ASSERT(!type_arguments().IsUninstantiatedIdentity() &&
          !type_arguments().CanShareInstantiatorTypeArguments(
              instantiator_class()));
   // If the instantiator is null and if the type argument vector
@@ skipping 129 matching lines @@
   locs->set_temp(0, Location::RegisterLocation(T1));
   locs->set_out(0, Location::RegisterLocation(V0));
   return locs;
 }
 
 
 void AllocateContextInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   ASSERT(locs()->temp(0).reg() == T1);
   ASSERT(locs()->out(0).reg() == V0);
 
-  __ TraceSimMsg("AllocateContextInstr");
+  __ Comment("AllocateContextInstr");
   __ LoadImmediate(T1, num_context_variables());
   StubCode* stub_code = compiler->isolate()->stub_code();
   const ExternalLabel label(stub_code->AllocateContextEntryPoint());
   compiler->GenerateCall(token_pos(),
                          &label,
                          RawPcDescriptors::kOther,
                          locs());
 }
 
 
 LocationSummary* InitStaticFieldInstr::MakeLocationSummary(Zone* zone,
                                                            bool opt) const {
   const intptr_t kNumInputs = 1;
   const intptr_t kNumTemps = 1;
   LocationSummary* locs = new(zone) LocationSummary(
       zone, kNumInputs, kNumTemps, LocationSummary::kCall);
   locs->set_in(0, Location::RegisterLocation(T0));
   locs->set_temp(0, Location::RegisterLocation(T1));
   return locs;
 }
 
 
 void InitStaticFieldInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   Register field = locs()->in(0).reg();
   Register temp = locs()->temp(0).reg();
 
   Label call_runtime, no_call;
-  __ TraceSimMsg("InitStaticFieldInstr");
+  __ Comment("InitStaticFieldInstr");
 
   __ lw(temp, FieldAddress(field, Field::value_offset()));
   __ BranchEqual(temp, Object::sentinel(), &call_runtime);
   __ BranchNotEqual(temp, Object::transition_sentinel(), &no_call);
 
   __ Bind(&call_runtime);
   __ addiu(SP, SP, Immediate(-2 * kWordSize));
   __ LoadObject(TMP, Object::null_object());
   __ sw(TMP, Address(SP, 1 * kWordSize));   // Make room for (unused) result.
   __ sw(field, Address(SP, 0 * kWordSize));
@@ skipping 19 matching lines @@
   locs->set_in(0, Location::RegisterLocation(T0));
   locs->set_out(0, Location::RegisterLocation(T0));
   return locs;
 }
 
 
 void CloneContextInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   Register context_value = locs()->in(0).reg();
   Register result = locs()->out(0).reg();
 
-  __ TraceSimMsg("CloneContextInstr");
+  __ Comment("CloneContextInstr");
 
   __ addiu(SP, SP, Immediate(-2 * kWordSize));
   __ LoadObject(TMP, Object::null_object());  // Make room for the result.
   __ sw(TMP, Address(SP, 1 * kWordSize));
   __ sw(context_value, Address(SP, 0 * kWordSize));
 
   compiler->GenerateRuntimeCall(token_pos(),
                                 deopt_id(),
                                 kCloneContextRuntimeEntry,
                                 1,
@@ skipping 59 matching lines @@
 
 class CheckStackOverflowSlowPath : public SlowPathCode {
  public:
   explicit CheckStackOverflowSlowPath(CheckStackOverflowInstr* instruction)
       : instruction_(instruction) { }
 
   virtual void EmitNativeCode(FlowGraphCompiler* compiler) {
     if (FLAG_use_osr) {
       uword flags_address = Isolate::Current()->stack_overflow_flags_address();
       Register value = instruction_->locs()->temp(0).reg();
-      __ TraceSimMsg("CheckStackOverflowSlowPathOsr");
       __ Comment("CheckStackOverflowSlowPathOsr");
       __ Bind(osr_entry_label());
       __ LoadImmediate(TMP, flags_address);
       __ LoadImmediate(value, Isolate::kOsrRequest);
       __ sw(value, Address(TMP));
     }
-    __ TraceSimMsg("CheckStackOverflowSlowPath");
     __ Comment("CheckStackOverflowSlowPath");
     __ Bind(entry_label());
     compiler->SaveLiveRegisters(instruction_->locs());
     // pending_deoptimization_env_ is needed to generate a runtime call that
     // may throw an exception.
     ASSERT(compiler->pending_deoptimization_env_ == NULL);
     Environment* env = compiler->SlowPathEnvironmentFor(instruction_);
     compiler->pending_deoptimization_env_ = env;
     compiler->GenerateRuntimeCall(instruction_->token_pos(),
                                   instruction_->deopt_id(),
@@ skipping 17 matching lines @@
     return &osr_entry_label_;
   }
 
  private:
   CheckStackOverflowInstr* instruction_;
   Label osr_entry_label_;
 };
 
 
 void CheckStackOverflowInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
-  __ TraceSimMsg("CheckStackOverflowInstr");
+  __ Comment("CheckStackOverflowInstr");
   CheckStackOverflowSlowPath* slow_path = new CheckStackOverflowSlowPath(this);
   compiler->AddSlowPathCode(slow_path);
 
   __ LoadImmediate(TMP, Isolate::Current()->stack_limit_address());
   __ lw(CMPRES1, Address(TMP));
   __ BranchUnsignedLessEqual(SP, CMPRES1, slow_path->entry_label());
   if (compiler->CanOSRFunction() && in_loop()) {
     Register temp = locs()->temp(0).reg();
     // In unoptimized code check the usage counter to trigger OSR at loop
     // stack checks.  Use progressively higher thresholds for more deeply
@@ skipping 14 matching lines @@
 
 static void EmitSmiShiftLeft(FlowGraphCompiler* compiler,
                              BinarySmiOpInstr* shift_left) {
   const LocationSummary& locs = *shift_left->locs();
   Register left = locs.in(0).reg();
   Register result = locs.out(0).reg();
   Label* deopt = shift_left->CanDeoptimize() ?
       compiler->AddDeoptStub(shift_left->deopt_id(), ICData::kDeoptBinarySmiOp)
       : NULL;
 
-  __ TraceSimMsg("EmitSmiShiftLeft");
+  __ Comment("EmitSmiShiftLeft");
 
   if (locs.in(1).IsConstant()) {
     const Object& constant = locs.in(1).constant();
     ASSERT(constant.IsSmi());
     // Immediate shift operation takes 5 bits for the count.
     const intptr_t kCountLimit = 0x1F;
     const intptr_t value = Smi::Cast(constant).Value();
     ASSERT((0 < value) && (value < kCountLimit));
     if (shift_left->can_overflow()) {
       // Check for overflow (preserve left).
@@ skipping 118 matching lines @@
     summary->set_temp(0, Location::RequiresRegister());
   }
   // We make use of 3-operand instructions by not requiring result register
   // to be identical to first input register as on Intel.
   summary->set_out(0, Location::RequiresRegister());
   return summary;
 }
 
 
 void BinarySmiOpInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
-  __ TraceSimMsg("BinarySmiOpInstr");
+  __ Comment("BinarySmiOpInstr");
   if (op_kind() == Token::kSHL) {
     EmitSmiShiftLeft(compiler, this);
     return;
   }
 
   Register left = locs()->in(0).reg();
   Register result = locs()->out(0).reg();
   Label* deopt = NULL;
   if (CanDeoptimize()) {
     deopt = compiler->AddDeoptStub(deopt_id(), ICData::kDeoptBinarySmiOp);
   }
 
   if (locs()->in(1).IsConstant()) {
     const Object& constant = locs()->in(1).constant();
     ASSERT(constant.IsSmi());
     const int32_t imm = reinterpret_cast<int32_t>(constant.raw());
     switch (op_kind()) {
       case Token::kADD: {
         if (deopt == NULL) {
           __ AddImmediate(result, left, imm);
         } else {
           Register temp = locs()->temp(0).reg();
           __ AddImmediateDetectOverflow(result, left, imm, CMPRES1, temp);
           __ bltz(CMPRES1, deopt);
         }
         break;
       }
       case Token::kSUB: {
-        __ TraceSimMsg("kSUB imm");
+        __ Comment("kSUB imm");
         if (deopt == NULL) {
           __ AddImmediate(result, left, -imm);
         } else {
           __ SubImmediateDetectOverflow(result, left, imm, CMPRES1);
           __ bltz(CMPRES1, deopt);
         }
         break;
       }
       case Token::kMUL: {
         // Keep left value tagged and untag right value.
@@ skipping 39 matching lines @@
       }
       case Token::kBIT_XOR: {
         // No overflow check.
         __ XorImmediate(result, left, imm);
         break;
       }
       case Token::kSHR: {
         // sarl operation masks the count to 5 bits.
         const intptr_t kCountLimit = 0x1F;
         const intptr_t value = Smi::Cast(constant).Value();
-        __ TraceSimMsg("kSHR");
+        __ Comment("kSHR");
         __ sra(result, left, Utils::Minimum(value + kSmiTagSize, kCountLimit));
         __ SmiTag(result);
         break;
       }
 
       default:
         UNREACHABLE();
         break;
     }
     return;
   }
 
   Register right = locs()->in(1).reg();
   Range* right_range = this->right()->definition()->range();
   switch (op_kind()) {
     case Token::kADD: {
       if (deopt == NULL) {
         __ addu(result, left, right);
       } else {
         Register temp = locs()->temp(0).reg();
         __ AdduDetectOverflow(result, left, right, CMPRES1, temp);
         __ bltz(CMPRES1, deopt);
       }
       break;
     }
     case Token::kSUB: {
-      __ TraceSimMsg("kSUB");
+      __ Comment("kSUB");
       if (deopt == NULL) {
         __ subu(result, left, right);
       } else {
         __ SubuDetectOverflow(result, left, right, CMPRES1);
         __ bltz(CMPRES1, deopt);
       }
       break;
     }
     case Token::kMUL: {
-      __ TraceSimMsg("kMUL");
+      __ Comment("kMUL");
       __ sra(TMP, left, kSmiTagSize);
       __ mult(TMP, right);
       __ mflo(result);
       if (deopt != NULL) {
         __ mfhi(CMPRES2);
         __ sra(CMPRES1, result, 31);
         __ bne(CMPRES1, CMPRES2, deopt);
       }
       break;
     }
@@ skipping 1518 matching lines @@
 }
 
 
 LocationSummary* PolymorphicInstanceCallInstr::MakeLocationSummary(
     Zone* zone, bool opt) const {
   return MakeCallSummary(zone);
 }
 
 
 void PolymorphicInstanceCallInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
-  __ TraceSimMsg("PolymorphicInstanceCallInstr");
+  __ Comment("PolymorphicInstanceCallInstr");
   ASSERT(ic_data().NumArgsTested() == 1);
   if (!with_checks()) {
     ASSERT(ic_data().HasOneTarget());
     const Function& target = Function::ZoneHandle(ic_data().GetTargetAt(0));
     compiler->GenerateStaticCall(deopt_id(),
                                  instance_call()->token_pos(),
                                  target,
                                  instance_call()->ArgumentCount(),
                                  instance_call()->argument_names(),
                                  locs(),
@@ skipping 23 matching lines @@
 LocationSummary* BranchInstr::MakeLocationSummary(Zone* zone,
                                                   bool opt) const {
   comparison()->InitializeLocationSummary(zone, opt);
   // Branches don't produce a result.
   comparison()->locs()->set_out(0, Location::NoLocation());
   return comparison()->locs();
 }
 
 
 void BranchInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
-  __ TraceSimMsg("BranchInstr");
+  __ Comment("BranchInstr");
   comparison()->EmitBranchCode(compiler, this);
 }
 
 
 LocationSummary* CheckClassInstr::MakeLocationSummary(Zone* zone,
                                                       bool opt) const {
   const intptr_t kNumInputs = 1;
   const bool need_mask_temp = IsDenseSwitch() && !IsDenseMask(ComputeCidMask());
   const intptr_t kNumTemps = !IsNullCheck() ? (need_mask_temp ? 2 : 1) : 0;
   LocationSummary* summary = new(zone) LocationSummary(
@@ skipping 81 matching lines @@
   const intptr_t kNumInputs = 1;
   const intptr_t kNumTemps = 0;
   LocationSummary* summary = new(zone) LocationSummary(
       zone, kNumInputs, kNumTemps, LocationSummary::kNoCall);
   summary->set_in(0, Location::RequiresRegister());
   return summary;
 }
 
 
 void CheckSmiInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
-  __ TraceSimMsg("CheckSmiInstr");
+  __ Comment("CheckSmiInstr");
   Register value = locs()->in(0).reg();
   Label* deopt = compiler->AddDeoptStub(deopt_id(),
                                         ICData::kDeoptCheckSmi,
                                         licm_hoisted_ ? ICData::kHoisted : 0);
   __ andi(CMPRES1, value, Immediate(kSmiTagMask));
   __ bne(CMPRES1, ZR, deopt);
 }
 
 
 LocationSummary* CheckClassIdInstr::MakeLocationSummary(Zone* zone,
@@ skipping 633 matching lines @@
 }
 
 
 LocationSummary* GotoInstr::MakeLocationSummary(Zone* zone,
                                                 bool opt) const {
   return new(zone) LocationSummary(zone, 0, 0, LocationSummary::kNoCall);
 }
 
 
 void GotoInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
-  __ TraceSimMsg("GotoInstr");
+  __ Comment("GotoInstr");
   if (!compiler->is_optimizing()) {
     if (FLAG_emit_edge_counters) {
       compiler->EmitEdgeCounter();
     }
     // Add a deoptimization descriptor for deoptimizing instructions that
     // may be inserted before this instruction.  On MIPS this descriptor
     // points after the edge counter code so that we can reuse the same
     // pattern matching code as at call sites, which matches backwards from
     // the end of the pattern.
     compiler->AddCurrentDescriptor(RawPcDescriptors::kDeopt,
@@ skipping 94 matching lines @@
   }
   if (kind() != Token::kEQ_STRICT) {
     ASSERT(kind() == Token::kNE_STRICT);
     true_condition = NegateCondition(true_condition);
   }
   return true_condition;
 }
 
 
 void StrictCompareInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
-  __ TraceSimMsg("StrictCompareInstr");
   __ Comment("StrictCompareInstr");
   ASSERT(kind() == Token::kEQ_STRICT || kind() == Token::kNE_STRICT);
 
   Label is_true, is_false;
   BranchLabels labels = { &is_true, &is_false, &is_false };
   Condition true_condition = EmitComparisonCode(compiler, labels);
   EmitBranchOnCondition(compiler, true_condition, labels);
 
   Register result = locs()->out(0).reg();
   Label done;
   __ Bind(&is_false);
   __ LoadObject(result, Bool::False());
   __ b(&done);
   __ Bind(&is_true);
   __ LoadObject(result, Bool::True());
   __ Bind(&done);
 }
 
 
 void StrictCompareInstr::EmitBranchCode(FlowGraphCompiler* compiler,
                                         BranchInstr* branch) {
-  __ TraceSimMsg("StrictCompareInstr::EmitBranchCode");
+  __ Comment("StrictCompareInstr::EmitBranchCode");
   ASSERT(kind() == Token::kEQ_STRICT || kind() == Token::kNE_STRICT);
 
   BranchLabels labels = compiler->CreateBranchLabels(branch);
   Condition true_condition = EmitComparisonCode(compiler, labels);
   EmitBranchOnCondition(compiler, true_condition, labels);
 }
 
 
 LocationSummary* BooleanNegateInstr::MakeLocationSummary(Zone* zone,
                                                          bool opt) const {
@@ skipping 15 matching lines @@
 }
 
 
 LocationSummary* AllocateObjectInstr::MakeLocationSummary(Zone* zone,
                                                           bool opt) const {
   return MakeCallSummary(zone);
 }
 
 
 void AllocateObjectInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
-  __ TraceSimMsg("AllocateObjectInstr");
   __ Comment("AllocateObjectInstr");
   Isolate* isolate = compiler->isolate();
   StubCode* stub_code = isolate->stub_code();
   const Code& stub = Code::Handle(isolate,
                                   stub_code->GetAllocationStubForClass(cls()));
   const ExternalLabel label(stub.EntryPoint());
   compiler->GenerateCall(token_pos(),
                          &label,
                          RawPcDescriptors::kOther,
                          locs());
@@ skipping 22 matching lines @@
       zone, kNumInputs, kNumTemps, LocationSummary::kCall);
   locs->set_in(0, Location::RegisterLocation(T0));
   locs->set_out(0, Location::RegisterLocation(T0));
   return locs;
 }
 
 
 void GrowRegExpStackInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   const Register typed_data = locs()->in(0).reg();
   const Register result = locs()->out(0).reg();
-  __ TraceSimMsg("GrowRegExpStackInstr");
+  __ Comment("GrowRegExpStackInstr");
   __ addiu(SP, SP, Immediate(-2 * kWordSize));
   __ LoadObject(TMP, Object::null_object());
   __ sw(TMP, Address(SP, 1 * kWordSize));
   __ sw(typed_data, Address(SP, 0 * kWordSize));
   compiler->GenerateRuntimeCall(Scanner::kNoSourcePos,  // No token position.
                                 deopt_id(),
                                 kGrowRegExpStackRuntimeEntry,
                                 1,
                                 locs());
   __ lw(result, Address(SP, 1 * kWordSize));
   __ addiu(SP, SP, Immediate(2 * kWordSize));
 }
 
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_MIPS