Replace MIPS TraceSimMsg calls with Comment calls.

runtime/vm/stub_code_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"
 #if defined(TARGET_ARCH_MIPS)
 
 #include "vm/assembler.h"
 #include "vm/code_generator.h"
 #include "vm/compiler.h"
@@ skipping 23 matching lines @@
 //   S5 : address of the runtime function to call.
 //   S4 : number of arguments to the call.
 void StubCode::GenerateCallToRuntimeStub(Assembler* assembler) {
   const intptr_t isolate_offset = NativeArguments::isolate_offset();
   const intptr_t argc_tag_offset = NativeArguments::argc_tag_offset();
   const intptr_t argv_offset = NativeArguments::argv_offset();
   const intptr_t retval_offset = NativeArguments::retval_offset();
   const intptr_t exitframe_last_param_slot_from_fp = 2;
 
   __ SetPrologueOffset();
-  __ TraceSimMsg("CallToRuntimeStub");
+  __ Comment("CallToRuntimeStub");
   __ addiu(SP, SP, Immediate(-3 * kWordSize));
   __ sw(ZR, Address(SP, 2 * kWordSize));  // Push 0 for the PC marker
   __ sw(RA, Address(SP, 1 * kWordSize));
   __ sw(FP, Address(SP, 0 * kWordSize));
   __ mov(FP, SP);
 
   COMPILE_ASSERT((kAbiPreservedCpuRegs & (1 << S6)) != 0);
   __ LoadIsolate(S6);
 
   // Save exit frame information to enable stack walking as we are about
@@ skipping 39 matching lines @@
 
   // Call runtime or redirection via simulator.
   // We defensively always jalr through T9 because it is sometimes required by
   // the MIPS ABI.
   __ mov(T9, S5);
   __ jalr(T9);
 
     ASSERT(retval_offset == 3 * kWordSize);
   // Retval is next to 1st argument.
   __ delay_slot()->addiu(A3, A2, Immediate(kWordSize));
-  __ TraceSimMsg("CallToRuntimeStub return");
+  __ Comment("CallToRuntimeStub return");
 
   // Mark that the isolate is executing Dart code.
   __ LoadImmediate(A2, VMTag::kDartTagId);
   __ sw(A2, Address(S6, Isolate::vm_tag_offset()));
 
   // Reset exit frame information in Isolate structure.
   __ sw(ZR, Address(S6, Isolate::top_exit_frame_info_offset()));
 
   __ mov(SP, FP);
   __ lw(RA, Address(SP, 1 * kWordSize));
@@ skipping 28 matching lines @@
 //   T5 : address of the native function to call.
 //   A2 : address of first argument in argument array.
 //   A1 : argc_tag including number of arguments and function kind.
 void StubCode::GenerateCallNativeCFunctionStub(Assembler* assembler) {
   const intptr_t isolate_offset = NativeArguments::isolate_offset();
   const intptr_t argc_tag_offset = NativeArguments::argc_tag_offset();
   const intptr_t argv_offset = NativeArguments::argv_offset();
   const intptr_t retval_offset = NativeArguments::retval_offset();
 
   __ SetPrologueOffset();
-  __ TraceSimMsg("CallNativeCFunctionStub");
+  __ Comment("CallNativeCFunctionStub");
   __ addiu(SP, SP, Immediate(-3 * kWordSize));
   __ sw(ZR, Address(SP, 2 * kWordSize));  // Push 0 for the PC marker
   __ sw(RA, Address(SP, 1 * kWordSize));
   __ sw(FP, Address(SP, 0 * kWordSize));
   __ mov(FP, SP);
 
   COMPILE_ASSERT((kAbiPreservedCpuRegs & (1 << S6)) != 0);
   __ LoadIsolate(S6);
 
   // Save exit frame information to enable stack walking as we are about
@@ skipping 47 matching lines @@
   // Call native wrapper function or redirection via simulator.
 #if defined(USING_SIMULATOR)
   uword entry = reinterpret_cast<uword>(NativeEntry::NativeCallWrapper);
   entry = Simulator::RedirectExternalReference(
       entry, Simulator::kNativeCall, NativeEntry::kNumCallWrapperArguments);
   __ LoadImmediate(T9, entry);
   __ jalr(T9);
 #else
   __ BranchLink(&NativeEntry::NativeCallWrapperLabel());
 #endif
-  __ TraceSimMsg("CallNativeCFunctionStub return");
+  __ Comment("CallNativeCFunctionStub return");
 
   // Mark that the isolate is executing Dart code.
   __ LoadImmediate(A2, VMTag::kDartTagId);
   __ sw(A2, Address(S6, Isolate::vm_tag_offset()));
 
   // Reset exit frame information in Isolate structure.
   __ sw(ZR, Address(S6, Isolate::top_exit_frame_info_offset()));
 
   __ mov(SP, FP);
   __ lw(RA, Address(SP, 1 * kWordSize));
   __ lw(FP, Address(SP, 0 * kWordSize));
   __ Ret();
   __ delay_slot()->addiu(SP, SP, Immediate(3 * kWordSize));
 }
 
 
 // Input parameters:
 //   RA : return address.
 //   SP : address of return value.
 //   T5 : address of the native function to call.
 //   A2 : address of first argument in argument array.
 //   A1 : argc_tag including number of arguments and function kind.
 void StubCode::GenerateCallBootstrapCFunctionStub(Assembler* assembler) {
   const intptr_t isolate_offset = NativeArguments::isolate_offset();
   const intptr_t argc_tag_offset = NativeArguments::argc_tag_offset();
   const intptr_t argv_offset = NativeArguments::argv_offset();
   const intptr_t retval_offset = NativeArguments::retval_offset();
 
   __ SetPrologueOffset();
-  __ TraceSimMsg("CallNativeCFunctionStub");
+  __ Comment("CallNativeCFunctionStub");
   __ addiu(SP, SP, Immediate(-3 * kWordSize));
   __ sw(ZR, Address(SP, 2 * kWordSize));  // Push 0 for the PC marker
   __ sw(RA, Address(SP, 1 * kWordSize));
   __ sw(FP, Address(SP, 0 * kWordSize));
   __ mov(FP, SP);
 
   COMPILE_ASSERT((kAbiPreservedCpuRegs & (1 << S6)) != 0);
   __ LoadIsolate(S6);
 
   // Save exit frame information to enable stack walking as we are about
@@ skipping 42 matching lines @@
   __ mov(A0, SP);  // Pass the pointer to the NativeArguments.
 
   __ ReserveAlignedFrameSpace(kWordSize);  // Just passing A0.
 
   // Call native function or redirection via simulator.
 
   // We defensively always jalr through T9 because it is sometimes required by
   // the MIPS ABI.
   __ mov(T9, T5);
   __ jalr(T9);
-  __ TraceSimMsg("CallNativeCFunctionStub return");
+  __ Comment("CallNativeCFunctionStub return");
 
   // Mark that the isolate is executing Dart code.
   __ LoadImmediate(A2, VMTag::kDartTagId);
   __ sw(A2, Address(S6, Isolate::vm_tag_offset()));
 
   // Reset exit frame information in Isolate structure.
   __ sw(ZR, Address(S6, Isolate::top_exit_frame_info_offset()));
 
   __ mov(SP, FP);
   __ lw(RA, Address(SP, 1 * kWordSize));
   __ lw(FP, Address(SP, 0 * kWordSize));
   __ Ret();
   __ delay_slot()->addiu(SP, SP, Immediate(3 * kWordSize));
 }
 
 
 // Input parameters:
 //   S4: arguments descriptor array.
 void StubCode::GenerateCallStaticFunctionStub(Assembler* assembler) {
-  __ TraceSimMsg("CallStaticFunctionStub");
+  __ Comment("CallStaticFunctionStub");
   __ EnterStubFrame();
   // Setup space on stack for return value and preserve arguments descriptor.
 
   __ addiu(SP, SP, Immediate(-2 * kWordSize));
   __ sw(S4, Address(SP, 1 * kWordSize));
   __ LoadImmediate(TMP, reinterpret_cast<intptr_t>(Object::null()));
   __ sw(TMP, Address(SP, 0 * kWordSize));
 
   __ CallRuntime(kPatchStaticCallRuntimeEntry, 0);
-  __ TraceSimMsg("CallStaticFunctionStub return");
+  __ Comment("CallStaticFunctionStub return");
 
   // Get Code object result and restore arguments descriptor array.
   __ lw(T0, Address(SP, 0 * kWordSize));
   __ lw(S4, Address(SP, 1 * kWordSize));
   __ addiu(SP, SP, Immediate(2 * kWordSize));
 
   __ lw(T0, FieldAddress(T0, Code::instructions_offset()));
   __ AddImmediate(T0, Instructions::HeaderSize() - kHeapObjectTag);
 
   // Remove the stub frame as we are about to jump to the dart function.
   __ LeaveStubFrameAndReturn(T0);
 }
 
 
 // Called from a static call only when an invalid code has been entered
 // (invalid because its function was optimized or deoptimized).
 // S4: arguments descriptor array.
 void StubCode::GenerateFixCallersTargetStub(Assembler* assembler) {
   // Create a stub frame as we are pushing some objects on the stack before
   // calling into the runtime.
-  __ TraceSimMsg("FixCallersTarget");
+  __ Comment("FixCallersTarget");
   __ EnterStubFrame();
   // Setup space on stack for return value and preserve arguments descriptor.
   __ addiu(SP, SP, Immediate(-2 * kWordSize));
   __ sw(S4, Address(SP, 1 * kWordSize));
   __ LoadImmediate(TMP, reinterpret_cast<intptr_t>(Object::null()));
   __ sw(TMP, Address(SP, 0 * kWordSize));
   __ CallRuntime(kFixCallersTargetRuntimeEntry, 0);
   // Get Code object result and restore arguments descriptor array.
   __ lw(T0, Address(SP, 0 * kWordSize));
   __ lw(S4, Address(SP, 1 * kWordSize));
   __ addiu(SP, SP, Immediate(2 * kWordSize));
 
   // Jump to the dart function.
   __ lw(T0, FieldAddress(T0, Code::instructions_offset()));
   __ AddImmediate(T0, T0, Instructions::HeaderSize() - kHeapObjectTag);
 
   // Remove the stub frame.
   __ LeaveStubFrameAndReturn(T0);
 }
 
 
 // Called from object allocate instruction when the allocation stub has been
 // disabled.
 void StubCode::GenerateFixAllocationStubTargetStub(Assembler* assembler) {
-  __ TraceSimMsg("FixAllocationStubTarget");
+  __ Comment("FixAllocationStubTarget");
   __ EnterStubFrame();
   // Setup space on stack for return value.
   __ addiu(SP, SP, Immediate(-1 * kWordSize));
   __ LoadImmediate(TMP, reinterpret_cast<intptr_t>(Object::null()));
   __ sw(TMP, Address(SP, 0 * kWordSize));
   __ CallRuntime(kFixAllocationStubTargetRuntimeEntry, 0);
   // Get Code object result.
   __ lw(T0, Address(SP, 0 * kWordSize));
   __ addiu(SP, SP, Immediate(1 * kWordSize));
 
   // Jump to the dart function.
   __ lw(T0, FieldAddress(T0, Code::instructions_offset()));
   __ AddImmediate(T0, T0, Instructions::HeaderSize() - kHeapObjectTag);
 
   // Remove the stub frame.
   __ LeaveStubFrameAndReturn(T0);
 }
 
 
 // Called from array allocate instruction when the allocation stub has been
 // disabled.
 // A0: element type (preserved).
 // A1: length (preserved).
 void StubCode::GenerateFixAllocateArrayStubTargetStub(Assembler* assembler) {
-  __ TraceSimMsg("FixAllocationStubTarget");
+  __ Comment("FixAllocationStubTarget");
   __ EnterStubFrame();
   // Setup space on stack for return value.
   __ addiu(SP, SP, Immediate(-3 * kWordSize));
   __ sw(A0, Address(SP, 2 * kWordSize));
   __ sw(A1, Address(SP, 1 * kWordSize));
   __ LoadImmediate(TMP, reinterpret_cast<intptr_t>(Object::null()));
   __ sw(TMP, Address(SP, 0 * kWordSize));
   __ CallRuntime(kFixAllocationStubTargetRuntimeEntry, 0);
   // Get Code object result.
   __ lw(T0, Address(SP, 0 * kWordSize));
   __ lw(A1, Address(SP, 1 * kWordSize));
   __ lw(A0, Address(SP, 2 * kWordSize));
   __ addiu(SP, SP, Immediate(3 * kWordSize));
 
   // Jump to the dart function.
   __ lw(T0, FieldAddress(T0, Code::instructions_offset()));
   __ AddImmediate(T0, T0, Instructions::HeaderSize() - kHeapObjectTag);
 
   // Remove the stub frame.
   __ LeaveStubFrameAndReturn(T0);
 }
 
 
 // Input parameters:
 //   A1: Smi-tagged argument count, may be zero.
 //   FP[kParamEndSlotFromFp + 1]: Last argument.
 static void PushArgumentsArray(Assembler* assembler) {
   StubCode* stub_code = Isolate::Current()->stub_code();
-  __ TraceSimMsg("PushArgumentsArray");
+  __ Comment("PushArgumentsArray");
   // Allocate array to store arguments of caller.
   __ LoadImmediate(A0, reinterpret_cast<intptr_t>(Object::null()));
   // A0: Null element type for raw Array.
   // A1: Smi-tagged argument count, may be zero.
   const Code& array_stub = Code::Handle(stub_code->GetAllocateArrayStub());
   const ExternalLabel array_label(array_stub.EntryPoint());
   __ BranchLink(&array_label);
-  __ TraceSimMsg("PushArgumentsArray return");
+  __ Comment("PushArgumentsArray return");
   // V0: newly allocated array.
   // A1: Smi-tagged argument count, may be zero (was preserved by the stub).
   __ Push(V0);  // Array is in V0 and on top of stack.
   __ sll(T1, A1, 1);
   __ addu(T1, FP, T1);
   __ AddImmediate(T1, kParamEndSlotFromFp * kWordSize);
   // T1: address of first argument on stack.
   // T2: address of first argument in array.
 
   Label loop, loop_exit;
@@ skipping 43 matching lines @@
 //
 // Parts of the code cannot GC, part of the code can GC.
 static void GenerateDeoptimizationSequence(Assembler* assembler,
                                            bool preserve_result) {
   const intptr_t kPushedRegistersSize =
       kNumberOfCpuRegisters * kWordSize +
       4 * kWordSize +  // PP, FP, RA, PC marker.
       kNumberOfFRegisters * kWordSize;
 
   __ SetPrologueOffset();
-  __ TraceSimMsg("GenerateDeoptimizationSequence");
+  __ Comment("GenerateDeoptimizationSequence");
   // DeoptimizeCopyFrame expects a Dart frame, i.e. EnterDartFrame(0), but there
   // is no need to set the correct PC marker or load PP, since they get patched.
   __ addiu(SP, SP, Immediate(-kPushedRegistersSize * kWordSize));
   __ sw(ZR, Address(SP, kPushedRegistersSize - 1 * kWordSize));
   __ sw(RA, Address(SP, kPushedRegistersSize - 2 * kWordSize));
   __ sw(FP, Address(SP, kPushedRegistersSize - 3 * kWordSize));
   __ sw(PP, Address(SP, kPushedRegistersSize - 4 * kWordSize));
   __ addiu(FP, SP, Immediate(kPushedRegistersSize - 3 * kWordSize));
 
   // The code in this frame may not cause GC. kDeoptimizeCopyFrameRuntimeEntry
@@ skipping 136 matching lines @@
 
 // Called for inline allocation of arrays.
 // Input parameters:
 //   RA: return address.
 //   A1: Array length as Smi (must be preserved).
 //   A0: array element type (either NULL or an instantiated type).
 // NOTE: A1 cannot be clobbered here as the caller relies on it being saved.
 // The newly allocated object is returned in V0.
 void StubCode::GeneratePatchableAllocateArrayStub(Assembler* assembler,
     uword* entry_patch_offset, uword* patch_code_pc_offset) {
-  __ TraceSimMsg("AllocateArrayStub");
+  __ Comment("AllocateArrayStub");
   *entry_patch_offset = assembler->CodeSize();
   Label slow_case;
 
   // Compute the size to be allocated, it is based on the array length
   // and is computed as:
   // RoundedAllocationSize((array_length * kwordSize) + sizeof(RawArray)).
   __ mov(T3, A1);  // Array length.
 
   // Check that length is a positive Smi.
   __ andi(CMPRES1, T3, Immediate(kSmiTagMask));
@@ skipping 102 matching lines @@
   // calling into the runtime.
   __ EnterStubFrame();
   // Setup space on stack for return value.
   // Push array length as Smi and element type.
   __ addiu(SP, SP, Immediate(-3 * kWordSize));
   __ LoadImmediate(TMP, reinterpret_cast<intptr_t>(Object::null()));
   __ sw(TMP, Address(SP, 2 * kWordSize));
   __ sw(A1, Address(SP, 1 * kWordSize));
   __ sw(A0, Address(SP, 0 * kWordSize));
   __ CallRuntime(kAllocateArrayRuntimeEntry, 2);
-  __ TraceSimMsg("AllocateArrayStub return");
+  __ Comment("AllocateArrayStub return");
   // Pop arguments; result is popped in IP.
   __ lw(V0, Address(SP, 2 * kWordSize));
   __ lw(A1, Address(SP, 1 * kWordSize));
   __ lw(A0, Address(SP, 0 * kWordSize));
   __ addiu(SP, SP, Immediate(3 * kWordSize));
 
   __ LeaveStubFrameAndReturn();
   *patch_code_pc_offset = assembler->CodeSize();
   StubCode* stub_code = Isolate::Current()->stub_code();
   __ BranchPatchable(&stub_code->FixAllocateArrayStubTargetLabel());
 }
 
 
 // Called when invoking Dart code from C++ (VM code).
 // Input parameters:
 //   RA : points to return address.
 //   A0 : entrypoint of the Dart function to call.
 //   A1 : arguments descriptor array.
 //   A2 : arguments array.
 void StubCode::GenerateInvokeDartCodeStub(Assembler* assembler) {
   // Save frame pointer coming in.
-  __ TraceSimMsg("InvokeDartCodeStub");
+  __ Comment("InvokeDartCodeStub");
   __ EnterFrame();
 
   // Save new context and C++ ABI callee-saved registers.
 
   // The saved vm tag, top resource, and top exit frame info.
   const intptr_t kPreservedSlots = 3;
   const intptr_t kPreservedRegSpace =
       kWordSize * (kAbiPreservedCpuRegCount + kAbiPreservedFpuRegCount +
                    kPreservedSlots);
 
@@ skipping 65 matching lines @@
   __ addiu(A1, A1, Immediate(1));
   __ BranchSignedLess(A1, T1, &push_arguments);
   __ delay_slot()->addiu(A2, A2, Immediate(kWordSize));
 
   __ Bind(&done_push_arguments);
 
   // Call the Dart code entrypoint.
   // We are calling into Dart code, here, so there is no need to call through
   // T9 to match the ABI.
   __ jalr(A0);  // S4 is the arguments descriptor array.
-  __ TraceSimMsg("InvokeDartCodeStub return");
+  __ Comment("InvokeDartCodeStub return");
 
   // Get rid of arguments pushed on the stack.
   __ AddImmediate(SP, FP, kExitLinkSlotFromEntryFp * kWordSize);
 
   __ LoadIsolate(S6);
 
   // Restore the current VMTag from the stack.
   __ lw(T1, Address(SP, 2 * kWordSize));
   __ sw(T1, Address(S6, Isolate::vm_tag_offset()));
 
@@ skipping 26 matching lines @@
   __ LeaveFrameAndReturn();
 }
 
 
 // Called for inline allocation of contexts.
 // Input:
 //   T1: number of context variables.
 // Output:
 //   V0: new allocated RawContext object.
 void StubCode::GenerateAllocateContextStub(Assembler* assembler) {
-  __ TraceSimMsg("AllocateContext");
+  __ Comment("AllocateContext");
   if (FLAG_inline_alloc) {
     Label slow_case;
     Heap* heap = Isolate::Current()->heap();
     // First compute the rounded instance size.
     // T1: number of context variables.
     intptr_t fixed_size = sizeof(RawContext) + kObjectAlignment - 1;
     __ LoadImmediate(T2, fixed_size);
     __ sll(T0, T1, 2);
     __ addu(T2, T2, T0);
     ASSERT(kSmiTagShift == 1);
@@ skipping 98 matching lines @@
 
 
 DECLARE_LEAF_RUNTIME_ENTRY(void, StoreBufferBlockProcess, Isolate* isolate);
 
 
 // Helper stub to implement Assembler::StoreIntoObject.
 // Input parameters:
 //   T0: Address (i.e. object) being stored into.
 void StubCode::GenerateUpdateStoreBufferStub(Assembler* assembler) {
   // Save values being destroyed.
-  __ TraceSimMsg("UpdateStoreBufferStub");
+  __ Comment("UpdateStoreBufferStub");
   __ addiu(SP, SP, Immediate(-3 * kWordSize));
   __ sw(T3, Address(SP, 2 * kWordSize));
   __ sw(T2, Address(SP, 1 * kWordSize));
   __ sw(T1, Address(SP, 0 * kWordSize));
 
   Label add_to_buffer;
   // Check whether this object has already been remembered. Skip adding to the
   // store buffer if the object is in the store buffer already.
   // Spilled: T1, T2, T3.
   // T0: Address being stored.
@@ skipping 39 matching lines @@
   __ delay_slot()->addiu(SP, SP, Immediate(3 * kWordSize));
   __ Ret();
 
   // Handle overflow: Call the runtime leaf function.
   __ Bind(&L);
   // Setup frame, push callee-saved registers.
 
   __ EnterCallRuntimeFrame(1 * kWordSize);
   __ LoadIsolate(A0);
   __ CallRuntime(kStoreBufferBlockProcessRuntimeEntry, 1);
-  __ TraceSimMsg("UpdateStoreBufferStub return");
+  __ Comment("UpdateStoreBufferStub return");
   // Restore callee-saved registers, tear down frame.
   __ LeaveCallRuntimeFrame();
   __ Ret();
 }
 
 
 // Called for inline allocation of objects.
 // Input parameters:
 //   RA : return address.
 //   SP + 0 : type arguments object (only if class is parameterized).
 // Returns patch_code_pc offset where patching code for disabling the stub
 // has been generated (similar to regularly generated Dart code).
 void StubCode::GenerateAllocationStubForClass(
     Assembler* assembler, const Class& cls,
     uword* entry_patch_offset, uword* patch_code_pc_offset) {
-  __ TraceSimMsg("AllocationStubForClass");
+  __ Comment("AllocationStubForClass");
   *entry_patch_offset = assembler->CodeSize();
   // The generated code is different if the class is parameterized.
   const bool is_cls_parameterized = cls.NumTypeArguments() > 0;
   ASSERT(!is_cls_parameterized ||
          (cls.type_arguments_field_offset() != Class::kNoTypeArguments));
   // kInlineInstanceSize is a constant used as a threshold for determining
   // when the object initialization should be done as a loop or as
   // straight line code.
   const int kInlineInstanceSize = 12;
   const intptr_t instance_size = cls.instance_size();
@@ skipping 95 matching lines @@
   __ sw(TMP, Address(SP, 1 * kWordSize));  // Class of object to be allocated.
 
   if (is_cls_parameterized) {
     // Push type arguments of object to be allocated and of instantiator.
     __ sw(T1, Address(SP, 0 * kWordSize));
   } else {
     // Push null type arguments.
     __ sw(T7, Address(SP, 0 * kWordSize));
   }
   __ CallRuntime(kAllocateObjectRuntimeEntry, 2);  // Allocate object.
-  __ TraceSimMsg("AllocationStubForClass return");
+  __ Comment("AllocationStubForClass return");
   // Pop result (newly allocated object).
   __ lw(V0, Address(SP, 2 * kWordSize));
   __ addiu(SP, SP, Immediate(3 * kWordSize));  // Pop arguments.
   // V0: new object
   // Restore the frame pointer and return.
   __ LeaveStubFrameAndReturn(RA);
   *patch_code_pc_offset = assembler->CodeSize();
   StubCode* stub_code = Isolate::Current()->stub_code();
   __ BranchPatchable(&stub_code->FixAllocationStubTargetLabel());
 }
@@ skipping 32 matching lines @@
   // noSuchMethod on closures always throws an error, so it will never return.
   __ break_(0);
 }
 
 
 //  T0: function object.
 //  S5: inline cache data object.
 // Cannot use function object from ICData as it may be the inlined
 // function and not the top-scope function.
 void StubCode::GenerateOptimizedUsageCounterIncrement(Assembler* assembler) {
-  __ TraceSimMsg("OptimizedUsageCounterIncrement");
+  __ Comment("OptimizedUsageCounterIncrement");
   Register ic_reg = S5;
   Register func_reg = T0;
   if (FLAG_trace_optimized_ic_calls) {
     __ EnterStubFrame();
     __ addiu(SP, SP, Immediate(-4 * kWordSize));
     __ sw(T0, Address(SP, 3 * kWordSize));
     __ sw(S5, Address(SP, 2 * kWordSize));
     __ sw(ic_reg, Address(SP, 1 * kWordSize));  // Argument.
     __ sw(func_reg, Address(SP, 0 * kWordSize));  // Argument.
     __ CallRuntime(kTraceICCallRuntimeEntry, 2);
     __ lw(S5, Address(SP, 2 * kWordSize));
     __ lw(T0, Address(SP, 3 * kWordSize));
     __ addiu(SP, SP, Immediate(4 * kWordSize));  // Discard argument;
     __ LeaveStubFrame();
   }
   __ lw(T7, FieldAddress(func_reg, Function::usage_counter_offset()));
   __ addiu(T7, T7, Immediate(1));
   __ sw(T7, FieldAddress(func_reg, Function::usage_counter_offset()));
 }
 
 
 // Loads function into 'temp_reg'.
 void StubCode::GenerateUsageCounterIncrement(Assembler* assembler,
                                              Register temp_reg) {
-  __ TraceSimMsg("UsageCounterIncrement");
+  __ Comment("UsageCounterIncrement");
   Register ic_reg = S5;
   Register func_reg = temp_reg;
   ASSERT(temp_reg == T0);
   __ Comment("Increment function counter");
   __ lw(func_reg, FieldAddress(ic_reg, ICData::owner_offset()));
   __ lw(T1, FieldAddress(func_reg, Function::usage_counter_offset()));
   __ addiu(T1, T1, Immediate(1));
   __ sw(T1, FieldAddress(func_reg, Function::usage_counter_offset()));
 }
 
@@ skipping 75 matching lines @@
 // - If receiver is not-Smi -> load receiver's class.
 // - Check if 'num_args' (including receiver) match any IC data group.
 // - Match found -> jump to target.
 // - Match not found -> jump to IC miss.
 void StubCode::GenerateNArgsCheckInlineCacheStub(
     Assembler* assembler,
     intptr_t num_args,
     const RuntimeEntry& handle_ic_miss,
     Token::Kind kind,
     RangeCollectionMode range_collection_mode) {
-  __ TraceSimMsg("NArgsCheckInlineCacheStub");
+  __ Comment("NArgsCheckInlineCacheStub");
   ASSERT(num_args > 0);
 #if defined(DEBUG)
   { Label ok;
     // Check that the IC data array has NumArgsTested() == num_args.
     // 'NumArgsTested' is stored in the least significant bits of 'state_bits'.
     __ lw(T0, FieldAddress(S5, ICData::state_bits_offset()));
     ASSERT(ICData::NumArgsTestedShift() == 0);  // No shift needed.
     __ andi(T0, T0, Immediate(ICData::NumArgsTestedMask()));
     __ BranchEqual(T0, Immediate(num_args), &ok);
     __ Stop("Incorrect stub for IC data");
@@ skipping 118 matching lines @@
   __ LoadImmediate(TMP, reinterpret_cast<intptr_t>(Object::null()));
   __ sw(TMP, Address(SP, (num_slots - 3) * kWordSize));
   // Push call arguments.
   for (intptr_t i = 0; i < num_args; i++) {
     __ lw(TMP, Address(T1, -i * kWordSize));
     __ sw(TMP, Address(SP, (num_slots - i - 4) * kWordSize));
   }
   // Pass IC data object.
   __ sw(S5, Address(SP, (num_slots - num_args - 4) * kWordSize));
   __ CallRuntime(handle_ic_miss, num_args + 1);
-  __ TraceSimMsg("NArgsCheckInlineCacheStub return");
+  __ Comment("NArgsCheckInlineCacheStub return");
   // Pop returned function object into T3.
   // Restore arguments descriptor array and IC data array.
   __ lw(T3, Address(SP, (num_slots - 3) * kWordSize));
   __ lw(S4, Address(SP, (num_slots - 2) * kWordSize));
   __ lw(S5, Address(SP, (num_slots - 1) * kWordSize));
   // Remove the call arguments pushed earlier, including the IC data object
   // and the arguments descriptor array.
   __ addiu(SP, SP, Immediate(num_slots * kWordSize));
   __ LeaveStubFrame();
 
@@ skipping 167 matching lines @@
       kInlineCacheMissHandlerThreeArgsRuntimeEntry, Token::kILLEGAL,
       kIgnoreRanges);
 }
 
 
 // Intermediary stub between a static call and its target. ICData contains
 // the target function and the call count.
 // S5: ICData
 void StubCode::GenerateZeroArgsUnoptimizedStaticCallStub(Assembler* assembler) {
   GenerateUsageCounterIncrement(assembler, T0);
-  __ TraceSimMsg("UnoptimizedStaticCallStub");
+  __ Comment("UnoptimizedStaticCallStub");
 #if defined(DEBUG)
   { Label ok;
     // Check that the IC data array has NumArgsTested() == 0.
     // 'NumArgsTested' is stored in the least significant bits of 'state_bits'.
     __ lw(T0, FieldAddress(S5, ICData::state_bits_offset()));
     ASSERT(ICData::NumArgsTestedShift() == 0);  // No shift needed.
     __ andi(T0, T0, Immediate(ICData::NumArgsTestedMask()));
     __ beq(T0, ZR, &ok);
     __ Stop("Incorrect IC data for unoptimized static call");
     __ Bind(&ok);
@@ skipping 171 matching lines @@
 }
 
 
 // Used to check class and type arguments. Arguments passed in registers:
 // RA: return address.
 // A0: instance (must be preserved).
 // A1: instantiator type arguments or NULL.
 // A2: cache array.
 // Result in V0: null -> not found, otherwise result (true or false).
 static void GenerateSubtypeNTestCacheStub(Assembler* assembler, int n) {
-  __ TraceSimMsg("SubtypeNTestCacheStub");
+  __ Comment("SubtypeNTestCacheStub");
   ASSERT((1 <= n) && (n <= 3));
   if (n > 1) {
     // Get instance type arguments.
     __ LoadClass(T0, A0);
     // Compute instance type arguments into T1.
     Label has_no_type_arguments;
     __ LoadImmediate(T1, reinterpret_cast<intptr_t>(Object::null()));
     __ lw(T2, FieldAddress(T0,
         Class::type_arguments_field_offset_in_words_offset()));
     __ BranchEqual(
@@ skipping 122 matching lines @@
 
   __ jr(A0);  // Jump to the exception handler code.
   __ delay_slot()->mov(SP, A1);  // Stack pointer.
 }
 
 
 // Calls to the runtime to optimize the given function.
 // T0: function to be reoptimized.
 // S4: argument descriptor (preserved).
 void StubCode::GenerateOptimizeFunctionStub(Assembler* assembler) {
-  __ TraceSimMsg("OptimizeFunctionStub");
+  __ Comment("OptimizeFunctionStub");
   __ EnterStubFrame();
   __ addiu(SP, SP, Immediate(-3 * kWordSize));
   __ sw(S4, Address(SP, 2 * kWordSize));
   // Setup space on stack for return value.
   __ LoadImmediate(TMP, reinterpret_cast<intptr_t>(Object::null()));
   __ sw(TMP, Address(SP, 1 * kWordSize));
   __ sw(T0, Address(SP, 0 * kWordSize));
   __ CallRuntime(kOptimizeInvokedFunctionRuntimeEntry, 1);
-  __ TraceSimMsg("OptimizeFunctionStub return");
+  __ Comment("OptimizeFunctionStub return");
   __ lw(T0, Address(SP, 1 * kWordSize));  // Get Code object
   __ lw(S4, Address(SP, 2 * kWordSize));  // Restore argument descriptor.
   __ addiu(SP, SP, Immediate(3 * kWordSize));  // Discard argument.
 
   __ lw(T0, FieldAddress(T0, Code::instructions_offset()));
   __ AddImmediate(T0, Instructions::HeaderSize() - kHeapObjectTag);
   __ LeaveStubFrameAndReturn(T0);
   __ break_(0);
 }
 
 
 DECLARE_LEAF_RUNTIME_ENTRY(intptr_t,
                            BigintCompare,
                            RawBigint* left,
                            RawBigint* right);
 
 
 // Does identical check (object references are equal or not equal) with special
 // checks for boxed numbers.
 // Returns: CMPRES1 is zero if equal, non-zero otherwise.
 // Note: A Mint cannot contain a value that would fit in Smi, a Bigint
 // cannot contain a value that fits in Mint or Smi.
 void StubCode::GenerateIdenticalWithNumberCheckStub(Assembler* assembler,
                                                     const Register left,
                                                     const Register right,
                                                     const Register temp1,
                                                     const Register temp2) {
-  __ TraceSimMsg("IdenticalWithNumberCheckStub");
   __ Comment("IdenticalWithNumberCheckStub");
   Label reference_compare, done, check_mint, check_bigint;
   // If any of the arguments is Smi do reference compare.
   __ andi(temp1, left, Immediate(kSmiTagMask));
   __ beq(temp1, ZR, &reference_compare);
   __ andi(temp1, right, Immediate(kSmiTagMask));
   __ beq(temp1, ZR, &reference_compare);
 
   // Value compare for two doubles.
   __ LoadImmediate(temp1, kDoubleCid);
@@ skipping 38 matching lines @@
   __ subu(CMPRES1, temp1, temp2);
   __ bne(CMPRES1, ZR, &done);
 
   __ EnterStubFrame();
   __ ReserveAlignedFrameSpace(2 * kWordSize);
   __ sw(left, Address(SP, 1 * kWordSize));
   __ sw(right, Address(SP, 0 * kWordSize));
   __ mov(A0, left);
   __ mov(A1, right);
   __ CallRuntime(kBigintCompareRuntimeEntry, 2);
-  __ TraceSimMsg("IdenticalWithNumberCheckStub return");
+  __ Comment("IdenticalWithNumberCheckStub return");
   // Result in V0, 0 means equal.
   __ LeaveStubFrame();
   __ b(&done);
   __ delay_slot()->mov(CMPRES1, V0);
 
   __ Bind(&reference_compare);
   __ subu(CMPRES1, left, right);
   __ Bind(&done);
   // A branch or test after this comparison will check CMPRES1 == ZR.
 }
@@ skipping 47 matching lines @@
   const Register right = T0;
   __ lw(left, Address(SP, 1 * kWordSize));
   __ lw(right, Address(SP, 0 * kWordSize));
   GenerateIdenticalWithNumberCheckStub(assembler, left, right, temp1, temp2);
   __ Ret();
 }
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_MIPS