Mac: Enable Mach exception handler by default

tools/command_tester.py

 #!/usr/bin/python
 # Copyright (c) 2012 The Native Client Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 
 """Simple testing harness for running commands and checking expected output.
 
 This harness is used instead of shell scripts to ensure windows compatibility
 
@@ skipping 190 matching lines @@
     MungeWindowsErrorExit(STATUS_INTEGER_DIVIDE_BY_ZERO),
     ]
 
 # We patch Windows' KiUserExceptionDispatcher on x86-64 to terminate
 # the process safely when untrusted code crashes.  We get the exit
 # code associated with the HLT instruction.
 win64_exit_via_ntdll_patch = [
     MungeWindowsErrorExit(STATUS_PRIVILEGED_INSTRUCTION)]
 
 
+EXC_BAD_ACCESS = 1
+EXC_BAD_INSTRUCTION = 2
+
+
 # 32-bit processes on Mac OS X return SIGBUS in most of the cases where Linux
 # returns SIGSEGV, except for actual x86 segmentation violations. 64-bit
 # processes on Mac OS X behave differently.
 status_map = {
     'sigtrap' : {
         'linux2': [-5], # SIGTRAP
         'darwin': [-5], # SIGTRAP
         },
     'trusted_sigabrt' : {
         'linux2': [-6], # SIGABRT
@@ skipping 15 matching lines @@
         # This is not used on Windows because Windows does not have an
         # equivalent of SIGPIPE.
         'linux2': [-13], # SIGPIPE
         'mac32': [-13], # SIGPIPE
         'mac64': [-13], # SIGPIPE
         },
     'untrusted_sigsegv': {
         'linux2': [-11], # SIGSEGV
         'mac32': [-11], # SIGSEGV
         'mac64': [-11], # SIGSEGV
+        'mach_exception': EXC_BAD_ACCESS,
         'win32':  win32_untrusted_crash_exit,
         'win64':  win64_exit_via_ntdll_patch,
         },
     'untrusted_sigill' : {
         'linux2': [-4], # SIGILL
         'mac32': [-4], # SIGILL
         'mac64': [-4], # SIGILL
         'win32':  win32_untrusted_crash_exit,
         'win64':  win64_exit_via_ntdll_patch,
         },
     'untrusted_sigfpe' : {
         'linux2': [-8], # SIGFPE
         'mac32': [-8], # SIGFPE
         'mac64': [-8], # SIGFPE
         'win32':  win32_sigfpe,
         'win64':  win64_exit_via_ntdll_patch,
         },
     'untrusted_segfault': {
         'linux2': [-11], # SIGSEGV
         'mac32': [-10], # SIGBUS
         'mac64': [-10], # SIGBUS
+        'mach_exception': EXC_BAD_ACCESS,
         'win32':  win32_untrusted_crash_exit,
         'win64':  win64_exit_via_ntdll_patch,
         },
     'untrusted_sigsegv_or_equivalent': {
         'linux2': [-11], # SIGSEGV
         'mac32': [-11], # SIGSEGV
         'mac64': [-10], # SIGBUS
+        'mach_exception': EXC_BAD_ACCESS,
         'win32':  win32_untrusted_crash_exit,
         'win64':  win64_exit_via_ntdll_patch,
         },
     'trusted_segfault': {
         'linux2': [-11], # SIGSEGV
         'mac32': [-10], # SIGBUS
         'mac64': [-11], # SIGSEGV
+        'mach_exception': EXC_BAD_ACCESS,
         'win32':  [MungeWindowsErrorExit(STATUS_ACCESS_VIOLATION)],
         'win64':  [MungeWindowsErrorExit(STATUS_ACCESS_VIOLATION)],
         },
     'trusted_sigsegv_or_equivalent': {
         'linux2': [-11], # SIGSEGV
         'mac32': [-11], # SIGSEGV
         'mac64': [-11], # SIGSEGV
+        'mach_exception': EXC_BAD_ACCESS,
         'win32':  [],
         'win64':  [],
         },
     # This is like 'untrusted_segfault', but without the 'untrusted_'
     # prefix which marks the status type as expecting a
     # gracefully-printed exit message from nacl_signal_common.c.  This
     # is a special case because we use different methods for writing
     # the exception stack frame on different platforms.  On Mac and
     # Windows, NaCl uses a system call which will detect unwritable
     # pages, so the exit status appears as an unhandled fault from
     # untrusted code.  On Linux, NaCl's signal handler writes the
     # frame directly, so the exit status comes from getting a SIGSEGV
     # inside the SIGSEGV handler.
     'unwritable_exception_stack': {
         'linux2': [-11], # SIGSEGV
         'mac32': [-10], # SIGBUS
         'mac64': [-10], # SIGBUS
+        'mach_exception': 123,
         'win32':  win32_untrusted_crash_exit,
         'win64':  win64_exit_via_ntdll_patch,
         },
     }
 
 
 def ProcessOptions(argv):
   global GlobalPlatform
 
   """Process command line options and return the unprocessed left overs."""
@@ skipping 28 matching lines @@
 
 
 # Parse output for signal type and number
 #
 # The '** Signal' output is from the nacl signal handler code.
 #
 # Since it is possible for there to be an output race with another
 # thread, or additional output due to atexit functions, we scan the
 # output in reverse order for the signal signature.
 def GetNaClSignalInfoFromStderr(stderr):
-  sigNum = None
-  sigType = 'normal'
-
   lines = stderr.splitlines()
-
   # Scan for signal msg in reverse order
   for curline in reversed(lines):
-    words = curline.split()
-    if len(words) > 4 and words[0] == '**' and words[1] == 'Signal':
-      sigNum = int(words[2])
-      sigType = words[4]
-      break
-  return sigNum, sigType
+    match = re.match('\*\* (Signal|Mach exception) (\d+) from '
+                     '(trusted|untrusted) code', curline)
+    if match is not None:
+      return match.group(0)
+  return None
+
 
 def GetQemuSignalFromStderr(stderr, default):
   for line in reversed(stderr.splitlines()):
     # Look for 'qemu: uncaught target signal XXX'.
     words = line.split()
     if (len(words) > 4 and
         words[0] == 'qemu:' and words[1] == 'uncaught' and
         words[2] == 'target' and words[3] == 'signal'):
       return -int(words[4])
   return default
@@ skipping 29 matching lines @@
             % FormatExitStatus(exit_status))
       return False
     elif len(intended_statuses) != 1:
       Print('\nERROR: Command returned exit status %s but produced '
             'multiple intended_exit_status lines (%s)'
             % (FormatExitStatus(exit_status), ', '.join(intended_statuses)))
       return False
     else:
       req_status = intended_statuses[0]
 
+  if req_status == 'unwritable_exception_stack' and sys.platform != 'linux2':
+    req_status = 'untrusted_segfault'
+
+  expected_printed_status = None
   expected_sigtype = 'normal'
   if req_status in status_map:
     expected_statuses = status_map[req_status][GlobalPlatform]
     if using_nacl_signal_handler:
       if req_status.startswith('trusted_'):
         expected_sigtype = 'trusted'
       elif req_status.startswith('untrusted_'):
         expected_sigtype = 'untrusted'
+
   else:
     expected_statuses = [int(req_status)]
 
-  # On 32-bit Windows, we cannot catch a signal that occurs in x86-32
-  # untrusted code, so it always appears as a 'normal' exit, which
-  # means that the signal handler does not print a message.
-  if GlobalPlatform == 'win32' and expected_sigtype == 'untrusted':
-    expected_sigtype = 'normal'
-
-  if expected_sigtype == 'normal':
-    expected_printed_signum = None
-  else:
-    assert sys.platform != 'win32'
-    assert len(expected_statuses) == 1
-    assert expected_statuses[0] < 0
-    expected_printed_signum = -expected_statuses[0]
-    expected_statuses = [IndirectSignal(expected_printed_signum)]
+  if expected_sigtype != 'normal':
+    if sys.platform == 'darwin':
+      # Mac OS X
+      expected_printed_status = '** Mach exception %d from %s code' % (
+          status_map[req_status]['mach_exception'],
+          expected_sigtype)
+    else:
+      # Linux
+      assert sys.platform != 'win32'
+      assert len(expected_statuses) == 1
+      assert expected_statuses[0] < 0
+      expected_printed_signum = -expected_statuses[0]
+      expected_printed_status = '** Signal %d from %s code' % (
+          expected_printed_signum,
+          expected_sigtype)
+      expected_statuses = [IndirectSignal(expected_printed_signum)]
 
   # If an uncaught signal occurs under QEMU (on ARM), the exit status
   # contains the signal number, mangled as per IndirectSignal().  We
   # extract the unadulterated signal number from QEMU's log message in
   # stderr instead.  If we are not using QEMU, or no signal is raised
   # under QEMU, this is a no-op.
   if stderr is not None:
     exit_status = GetQemuSignalFromStderr(stderr, exit_status)
 
   msg = '\nERROR: Command returned exit status %s but we expected %s' % (
       FormatExitStatus(exit_status),
       ' or '.join(FormatExitStatus(value) for value in expected_statuses))
   if exit_status not in expected_statuses:
     Print(msg)
     failed = True
   if using_nacl_signal_handler and stderr is not None:
-    expected_printed = (expected_printed_signum, expected_sigtype)
-    actual_printed = GetNaClSignalInfoFromStderr(stderr)
-    msg = ('\nERROR: Command printed the signal info %s to stderr '
-           'but we expected %s' %
-           (actual_printed, expected_printed))
-    if actual_printed != expected_printed:
+    actual_printed_status = GetNaClSignalInfoFromStderr(stderr)
+    msg = ('\nERROR: Command printed the signal info %r to stderr '
+           'but we expected %r' %
+           (actual_printed_status, expected_printed_status))
+    if actual_printed_status != expected_printed_status:
       Print(msg)
       failed = True
 
   return not failed
 
 def CheckTimeBounds(total_time):
   if GlobalSettings['time_error']:
     if total_time > GlobalSettings['time_error']:
       Print('ERROR: should have taken less than %f secs' %
             (GlobalSettings['time_error']))
@@ skipping 206 matching lines @@
     # Bogus time, since only ProcessLogOutputCombined failed.
     Print(FailureMessage(0.0) + ' ProcessLogOutputCombined failed!')
     return 1
   return 0
 
 if __name__ == '__main__':
   retval = Main(sys.argv[1:])
   # Add some whitepsace to make the logs easier to read.
   sys.stdout.write('\n\n')
   sys.exit(retval)