Initial revision of ARM simulator and (empty) MIPS simulator.

runtime/vm/os_linux.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/os.h"
 
 #include <errno.h>
 #include <limits.h>
 #include <malloc.h>
 #include <time.h>
@@ skipping 292 matching lines @@
   return sysconf(_SC_NPROCESSORS_ONLN);
 }
 
 
 void OS::Sleep(int64_t millis) {
   // TODO(5411554):  For now just use usleep we may have to revisit this.
   usleep(millis * 1000);
 }
 
 
+void OS::DebugBreak() {
+#if defined(HOST_ARCH_X64) || defined(HOST_ARCH_IA32)
+  asm("int $3");
+#elif defined(HOST_ARCH_ARM)
+  asm("svc #0x9f0001");  // __ARM_NR_breakpoint
+#elif defined(HOST_ARCH_MIPS)
+  UNIMPLEMENTED();
+#else
+#error Unsupported architecture.
+#endif

[siva, 2013/01/24 02:03:09]

As discussed offline we have moved away from using asm statements in our code
because Mads found that they are not supported on win64.

I think this facility of generating a debug break is useful for generated code,
not sure why it needed for C++ code.

[Kevin Millikin (Google), 2013/01/24 08:26:36]

It's pretty minor, but it's nice to have because gdb's support for conditional
breakpoints is weak/broken.  For complicated conditions it's much easier to
recompile the project with a conditional OS::DebugBreak().  You can get the same
effect with a conditional ASSERT(true) and set a gdb breakpoint on the ASSERT. 
This just saves having to find the line and add the breakpoint, since you're
recompiling anyway.

I've just been using asm("int $3") directly since we originally removed this
handy function, but it's annoying to have to remember how to spell it on all
architectures if you work on more than one.  As for Win64, I have not yet
encountered a Win64-specific bug, but I suppose not having OS::DebugBreak
available there is the same as the current situation.

[Ivan Posva, 2013/01/24 18:25:57]

Since this is in a OS specific file we can add the correct way to trigger the
debugger on Windows without having to resort to inline assembly.

[regis, 2013/01/24 21:47:48]

As Kevin, I think that DebugBreak() is nice to have. I replaced the
UNIMPLEMENTED() on Windows by something that should do it in most cases:
void OS::DebugBreak() {
#if defined(_MSC_VER)
  // Microsoft Visual C/C++ or drop-in replacement.
  __debugbreak();
#elif defined(__GCC__)
  // MinGW?
  asm("int $3");
#else
  // Microsoft style assembly.
   __asm {
      int 3
   }
#endif
}

+}
+
+
 void OS::Print(const char* format, ...) {
   va_list args;
   va_start(args, format);
   VFPrint(stdout, format, args);
   va_end(args);
 }
 
 
 void OS::VFPrint(FILE* stream, const char* format, va_list args) {
   vfprintf(stream, format, args);
@@ skipping 55 matching lines @@
 
 
 void OS::PrintErr(const char* format, ...) {
   va_list args;
   va_start(args, format);
   VFPrint(stderr, format, args);
   va_end(args);
 }
 
 
+// Cache the null page size.
+uword OS::null_page_size_ = 0;
+
+
 void OS::InitOnce() {
   // TODO(5411554): For now we check that initonce is called only once,
   // Once there is more formal mechanism to call InitOnce we can move
   // this check there.
   static bool init_once_called = false;
   ASSERT(init_once_called == false);
   init_once_called = true;
+
+  // Initialize the null page size.
+  null_page_size_ = static_cast<uword>(getpagesize());
 }
 
 
 void OS::Shutdown() {
 }
 
 
 void OS::Abort() {
   abort();
 }
 
 
 void OS::Exit(int code) {
   exit(code);
 }
 
 }  // namespace dart