Consistenly use stderr for printing simulator and debug messages

src/a64/simulator-a64.cc

 // Copyright 2013 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 927 matching lines @@
           clr_normal,
           clr_memory_address,
           address,
           clr_normal);
 }
 
 
 // Visitors---------------------------------------------------------------------
 
 void Simulator::VisitUnimplemented(Instruction* instr) {
-  printf("Unimplemented instruction at 0x%p: 0x%08" PRIx32 "\n",
-         reinterpret_cast<void*>(instr), instr->InstructionBits());
+  fprintf(stream_, "Unimplemented instruction at 0x%p: 0x%08" PRIx32 "\n",
+          reinterpret_cast<void*>(instr), instr->InstructionBits());
   UNIMPLEMENTED();
 }
 
 
 void Simulator::VisitUnallocated(Instruction* instr) {
-  printf("Unallocated instruction at 0x%p: 0x%08" PRIx32 "\n",
-         reinterpret_cast<void*>(instr), instr->InstructionBits());
+  fprintf(stream_, "Unallocated instruction at 0x%p: 0x%08" PRIx32 "\n",
+          reinterpret_cast<void*>(instr), instr->InstructionBits());
   UNIMPLEMENTED();
 }
 
 
 void Simulator::VisitPCRelAddressing(Instruction* instr) {
   switch (instr->Mask(PCRelAddressingMask)) {
     case ADR:
       set_reg(instr->Rd(), instr->ImmPCOffsetTarget());
       break;
     case ADRP:  // Not implemented in the assembler.
@@ skipping 264 matching lines @@
   unsigned srcdst = instr->Rt();
   uint8_t* address = AddressModeHelper(instr->Rn(), offset, addrmode);
   int num_bytes = 1 << instr->SizeLS();
 
   // Accesses below the stack pointer (but above the platform stack limit) are
   // not allowed in the ABI.
   uint64_t access_address = reinterpret_cast<uint64_t>(address);
   uint64_t stack_limit = reinterpret_cast<uint64_t>(stack_limit_);
   uint64_t stack_address = sp();
   if ((access_address >= stack_limit) && (access_address < stack_address)) {
-    printf("ACCESS BELOW STACK POINTER:\n");
-    printf("  sp is here:          0x%016" PRIx64 "\n", stack_address);
-    printf("  access was here:     0x%016" PRIx64 "\n", access_address);
-    printf("  stack limit is here: 0x%016" PRIx64 "\n", stack_limit);
-    printf("\n");
+    fprintf(stream_, "ACCESS BELOW STACK POINTER:\n");
+    fprintf(stream_, "  sp is here:          0x%016" PRIx64 "\n",
+            stack_address);
+    fprintf(stream_, "  access was here:     0x%016" PRIx64 "\n",
+            access_address);
+    fprintf(stream_, "  stack limit is here: 0x%016" PRIx64 "\n", stack_limit);
+    fprintf(stream_, "\n");
     ABORT();
   }
 
   LoadStoreOp op = static_cast<LoadStoreOp>(instr->Mask(LoadStoreOpMask));
   switch (op) {
     case LDRB_w:
     case LDRH_w:
     case LDR_w:
     case LDR_x: set_xreg(srcdst, MemoryRead(address, num_bytes)); break;
     case STRB_w:
@@ skipping 2115 matching lines @@
         // Read the argument encoded inline in the instruction stream.
         uint32_t type;
         ASSERT(sizeof(*pc_) == 1);
         memcpy(&type, pc_ + kPrintfTypeOffset, sizeof(type));
 
         const char* format = reg<const char*>(0);
 
         // Pass all of the relevant PCS registers onto printf. It doesn't
         // matter if we pass too many as the extra ones won't be read.
         int result;
-        fputs(clr_printf, stdout);
+        fputs(clr_printf, stream_);
         if (type == CPURegister::kRegister) {
-          result = printf(format,
-                          xreg(1), xreg(2), xreg(3), xreg(4),
-                          xreg(5), xreg(6), xreg(7));
+          result = fprintf(stream_, format,
+                           xreg(1), xreg(2), xreg(3), xreg(4),
+                           xreg(5), xreg(6), xreg(7));
         } else if (type == CPURegister::kFPRegister) {
-          result = printf(format,
-                          dreg(0), dreg(1), dreg(2), dreg(3),
-                          dreg(4), dreg(5), dreg(6), dreg(7));
+          result = fprintf(stream_, format,
+                           dreg(0), dreg(1), dreg(2), dreg(3),
+                           dreg(4), dreg(5), dreg(6), dreg(7));
         } else {
           ASSERT(type == CPURegister::kNoRegister);
-          result = printf("%s", format);
+          result = fprintf(stream_, "%s", format);
         }
-        fputs(clr_normal, stdout);
+        fputs(clr_normal, stream_);
         set_xreg(0, result);
 
         // TODO(jbramley): Consider clobbering all caller-saved registers here.
 
         // The printf parameters are inlined in the code, so skip them.
         set_pc(pc_->InstructionAtOffset(kPrintfLength));
 
         // Set LR as if we'd just called a native printf function.
         set_lr(pc());
 
@@ skipping 11 matching lines @@
     default:
       UNIMPLEMENTED();
   }
 }
 
 #endif  // USE_SIMULATOR
 
 } }  // namespace v8::internal
 
 #endif  // V8_TARGET_ARCH_A64