Last cleanup int -> intptr_t. Also removed a hack.

runtime/vm/simulator_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 <math.h>  // for isnan.
 #include <setjmp.h>
 #include <stdlib.h>
 
 #include "vm/globals.h"
 #if defined(TARGET_ARCH_MIPS)
@@ skipping 483 matching lines @@
 #undef ARG_SIZE
 
 #undef STR
 #undef XSTR
 }
 
 
 char* SimulatorDebugger::ReadLine(const char* prompt) {
   char* result = NULL;
   char line_buf[256];
-  int offset = 0;
+  intptr_t offset = 0;
   bool keep_going = true;
   OS::Print("%s", prompt);
   while (keep_going) {
     if (fgets(line_buf, sizeof(line_buf), stdin) == NULL) {
       // fgets got an error. Just give up.
       if (result != NULL) {
         delete[] result;
       }
       return NULL;
     }
-    int len = strlen(line_buf);
+    intptr_t len = strlen(line_buf);
     if (len > 1 &&
         line_buf[len - 2] == '\\' &&
         line_buf[len - 1] == '\n') {
       // When we read a line that ends with a "\" we remove the escape and
       // append the remainder.
       line_buf[len - 2] = '\n';
       line_buf[len - 1] = 0;
       len -= 1;
     } else if ((len > 0) && (line_buf[len - 1] == '\n')) {
       // Since we read a new line we are done reading the line. This
       // will exit the loop after copying this buffer into the result.
       keep_going = false;
     }
     if (result == NULL) {
       // Allocate the initial result and make room for the terminating '\0'
       result = new char[len + 1];
       if (result == NULL) {
         // OOM, so cannot readline anymore.
         return NULL;
       }
     } else {
       // Allocate a new result with enough room for the new addition.
-      int new_len = offset + len + 1;
+      intptr_t new_len = offset + len + 1;
       char* new_result = new char[new_len];
       if (new_result == NULL) {
         // OOM, free the buffer allocated so far and return NULL.
         delete[] result;
         return NULL;
       } else {
         // Copy the existing input into the new array and set the new
         // array as the result.
         memmove(new_result, result, offset);
         delete[] result;
@@ skipping 332 matching lines @@
 uint16_t Simulator::ReadHU(uword addr, Instr* instr) {
   if ((addr & 1) == 0) {
     uint16_t* ptr = reinterpret_cast<uint16_t*>(addr);
     return *ptr;
   }
   UnalignedAccess("unsigned halfword read", addr, instr);
   return 0;
 }
 
 
-int Simulator::ReadW(uword addr, Instr* instr) {
+intptr_t Simulator::ReadW(uword addr, Instr* instr) {
   if ((addr & 3) == 0) {
     intptr_t* ptr = reinterpret_cast<intptr_t*>(addr);
     return *ptr;
   }
   UnalignedAccess("read", addr, instr);
   return 0;
 }
 
 
 void Simulator::WriteB(uword addr, uint8_t value) {
   uint8_t* ptr = reinterpret_cast<uint8_t*>(addr);
   *ptr = value;
 }
 
 
 void Simulator::WriteH(uword addr, uint16_t value, Instr* instr) {
   if ((addr & 1) == 0) {
     uint16_t* ptr = reinterpret_cast<uint16_t*>(addr);
     *ptr = value;
     return;
   }
   UnalignedAccess("halfword write", addr, instr);
 }
 
 
-void Simulator::WriteW(uword addr, int value, Instr* instr) {
+void Simulator::WriteW(uword addr, intptr_t value, Instr* instr) {
   if ((addr & 3) == 0) {
     intptr_t* ptr = reinterpret_cast<intptr_t*>(addr);
     *ptr = value;
     return;
   }
   UnalignedAccess("write", addr, instr);
 }
 
 
 double Simulator::ReadD(uword addr, Instr* instr) {
@@ skipping 1317 matching lines @@
   set_register(kExceptionObjectReg, bit_cast<int32_t>(raw_exception));
   set_register(kStackTraceObjectReg, bit_cast<int32_t>(raw_stacktrace));
   buf->Longjmp();
 }
 
 }  // namespace dart
 
 #endif  // !defined(HOST_ARCH_MIPS)
 
 #endif  // defined TARGET_ARCH_MIPS