Clean up some A64 specific code in common code that was introduced by A64 merge

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 1433 matching lines @@
 
 uint8_t* Simulator::LoadStoreAddress(unsigned addr_reg,
                                      int64_t offset,
                                      AddrMode addrmode) {
   const unsigned kSPRegCode = kSPRegInternalCode & kRegCodeMask;
   int64_t address = xreg(addr_reg, Reg31IsStackPointer);
   if ((addr_reg == kSPRegCode) && ((address % 16) != 0)) {
     // When the base register is SP the stack pointer is required to be
     // quadword aligned prior to the address calculation and write-backs.
     // Misalignment will cause a stack alignment fault.
-    ALIGNMENT_EXCEPTION();
+    FATAL("ALIGNMENT EXCEPTION");
   }
 
   if ((addrmode == Offset) || (addrmode == PreIndex)) {
     address += offset;
   }
 
   return reinterpret_cast<uint8_t*>(address);
 }
 
 
 void Simulator::LoadStoreWriteBack(unsigned addr_reg,
                                    int64_t offset,
                                    AddrMode addrmode) {
   if ((addrmode == PreIndex) || (addrmode == PostIndex)) {
     ASSERT(offset != 0);
     uint64_t address = xreg(addr_reg, Reg31IsStackPointer);
     set_reg(addr_reg, address + offset, Reg31IsStackPointer);
   }
 }
 
 
 void Simulator::CheckMemoryAccess(uint8_t* address, uint8_t* stack) {
   if ((address >= stack_limit_) && (address < stack)) {
     fprintf(stream_, "ACCESS BELOW STACK POINTER:\n");
     fprintf(stream_, "  sp is here:          0x%16p\n", stack);
     fprintf(stream_, "  access was here:     0x%16p\n", address);
     fprintf(stream_, "  stack limit is here: 0x%16p\n", stack_limit_);
     fprintf(stream_, "\n");
-    ABORT();
+    FATAL("ACCESS BELOW STACK POINTER");
   }
 }
 
 
 uint64_t Simulator::MemoryRead(uint8_t* address, unsigned num_bytes) {
   ASSERT(address != NULL);
   ASSERT((num_bytes > 0) && (num_bytes <= sizeof(uint64_t)));
   uint64_t read = 0;
   memcpy(&read, address, num_bytes);
   return read;
@@ skipping 1708 matching lines @@
         int64_t external =
             reinterpret_cast<int64_t>(redirection->external_function());
 
         TraceSim("Call to host function at %p\n",
                  reinterpret_cast<void*>(redirection->external_function()));
 
         // SP must be 16 bytes aligned at the call interface.
         bool stack_alignment_exception = ((sp() & 0xf) != 0);
         if (stack_alignment_exception) {
           TraceSim("  with unaligned stack 0x%016" PRIx64 ".\n", sp());
-          ALIGNMENT_EXCEPTION();
+          FATAL("ALIGNMENT EXCEPTION");
         }
 
         switch (redirection->type()) {
           default:
             TraceSim("Type: Unknown.\n");
             UNREACHABLE();
             break;
 
           case ExternalReference::BUILTIN_CALL: {
             // MaybeObject* f(v8::internal::Arguments).
@@ skipping 197 matching lines @@
     default:
       UNIMPLEMENTED();
   }
 }
 
 #endif  // USE_SIMULATOR
 
 } }  // namespace v8::internal
 
 #endif  // V8_TARGET_ARCH_A64